protocol: Fix case where download can fail for small files.
[libguestfs.git] / daemon / proto.c
1 /* libguestfs - the guestfsd daemon
2  * Copyright (C) 2009-2011 Red Hat Inc.
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <config.h>
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <stdarg.h>
24 #include <string.h>
25 #include <signal.h>
26 #include <inttypes.h>
27 #include <unistd.h>
28 #include <errno.h>
29 #include <sys/param.h>          /* defines MIN */
30 #include <sys/select.h>
31 #include <sys/time.h>
32 #include <rpc/types.h>
33 #include <rpc/xdr.h>
34
35 #ifdef HAVE_WINDOWS_H
36 #include <windows.h>
37 #endif
38
39 #include "c-ctype.h"
40 #include "ignore-value.h"
41
42 #include "daemon.h"
43 #include "guestfs_protocol.h"
44 #include "errnostring.h"
45
46 /* The message currently being processed. */
47 int proc_nr;
48 int serial;
49
50 /* Hint for implementing progress messages for uploaded/incoming data.
51  * The caller sets this to a value > 0 if it knows or can estimate how
52  * much data will be sent (this is not always known, eg. for uploads
53  * coming from a pipe).  If this is known then we can emit progress
54  * messages as we write the data.
55  */
56 uint64_t progress_hint;
57
58 /* Optional arguments bitmask.  Caller sets this to indicate which
59  * optional arguments in the guestfs_<foo>_args structure are
60  * meaningful.  Optional arguments not covered by the bitmask are set
61  * to arbitrary values and the daemon should ignore them.  If the
62  * bitmask has bits set that the daemon doesn't understand, then the
63  * whole call is rejected early in processing.
64  */
65 uint64_t optargs_bitmask;
66
67 /* Time at which we received the current request. */
68 static struct timeval start_t;
69
70 /* Time at which the last progress notification was sent. */
71 static struct timeval last_progress_t;
72
73 /* Counts the number of progress notifications sent during this call. */
74 static int count_progress;
75
76 /* The daemon communications socket. */
77 static int sock;
78
79 void
80 main_loop (int _sock)
81 {
82   XDR xdr;
83   char *buf;
84   char lenbuf[4];
85   uint32_t len;
86   struct guestfs_message_header hdr;
87
88   sock = _sock;
89
90   for (;;) {
91     /* Read the length word. */
92     if (xread (sock, lenbuf, 4) == -1)
93       exit (EXIT_FAILURE);
94
95     xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
96     xdr_u_int (&xdr, &len);
97     xdr_destroy (&xdr);
98
99     if (verbose)
100       fprintf (stderr,
101                "guestfsd: main_loop: new request, len 0x%" PRIx32 "\n",
102                len);
103
104     /* Cancellation sent from the library and received after the
105      * previous request has finished processing.  Just ignore it.
106      */
107     if (len == GUESTFS_CANCEL_FLAG)
108       continue;
109
110     if (len > GUESTFS_MESSAGE_MAX) {
111       fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n",
112                len);
113       exit (EXIT_FAILURE);
114     }
115
116     buf = malloc (len);
117     if (!buf) {
118       reply_with_perror ("malloc");
119       continue;
120     }
121
122     if (xread (sock, buf, len) == -1)
123       exit (EXIT_FAILURE);
124
125 #ifdef ENABLE_PACKET_DUMP
126     if (verbose) {
127       size_t i, j;
128
129       for (i = 0; i < len; i += 16) {
130         printf ("%04zx: ", i);
131         for (j = i; j < MIN (i+16, len); ++j)
132           printf ("%02x ", (unsigned char) buf[j]);
133         for (; j < i+16; ++j)
134           printf ("   ");
135         printf ("|");
136         for (j = i; j < MIN (i+16, len); ++j)
137           if (c_isprint (buf[j]))
138             printf ("%c", buf[j]);
139           else
140             printf (".");
141         for (; j < i+16; ++j)
142           printf (" ");
143         printf ("|\n");
144       }
145     }
146 #endif
147
148     gettimeofday (&start_t, NULL);
149     last_progress_t = start_t;
150     count_progress = 0;
151
152     /* Decode the message header. */
153     xdrmem_create (&xdr, buf, len, XDR_DECODE);
154     if (!xdr_guestfs_message_header (&xdr, &hdr)) {
155       fprintf (stderr, "guestfsd: could not decode message header\n");
156       exit (EXIT_FAILURE);
157     }
158
159     /* Check the version etc. */
160     if (hdr.prog != GUESTFS_PROGRAM) {
161       reply_with_error ("wrong program (%d)", hdr.prog);
162       goto cont;
163     }
164     if (hdr.vers != GUESTFS_PROTOCOL_VERSION) {
165       reply_with_error ("wrong protocol version (%d)", hdr.vers);
166       goto cont;
167     }
168     if (hdr.direction != GUESTFS_DIRECTION_CALL) {
169       reply_with_error ("unexpected message direction (%d)", hdr.direction);
170       goto cont;
171     }
172     if (hdr.status != GUESTFS_STATUS_OK) {
173       reply_with_error ("unexpected message status (%d)", hdr.status);
174       goto cont;
175     }
176
177     proc_nr = hdr.proc;
178     serial = hdr.serial;
179     progress_hint = hdr.progress_hint;
180     optargs_bitmask = hdr.optargs_bitmask;
181
182     /* Clear errors before we call the stub functions.  This is just
183      * to ensure that we can accurately report errors in cases where
184      * error handling paths don't set errno correctly.
185      */
186     errno = 0;
187 #ifdef WIN32
188     SetLastError (0);
189     WSASetLastError (0);
190 #endif
191
192     /* Now start to process this message. */
193     dispatch_incoming_message (&xdr);
194     /* Note that dispatch_incoming_message will also send a reply. */
195
196     /* In verbose mode, display the time taken to run each command. */
197     if (verbose) {
198       struct timeval end_t;
199       gettimeofday (&end_t, NULL);
200
201       int64_t start_us, end_us, elapsed_us;
202       start_us = (int64_t) start_t.tv_sec * 1000000 + start_t.tv_usec;
203       end_us = (int64_t) end_t.tv_sec * 1000000 + end_t.tv_usec;
204       elapsed_us = end_us - start_us;
205
206       fprintf (stderr,
207                "guestfsd: main_loop: proc %d (%s) took %d.%02d seconds\n",
208                proc_nr,
209                proc_nr >= 0 && proc_nr < GUESTFS_PROC_NR_PROCS
210                ? function_names[proc_nr] : "UNKNOWN PROCEDURE",
211                (int) (elapsed_us / 1000000),
212                (int) ((elapsed_us / 10000) % 100));
213     }
214
215   cont:
216     xdr_destroy (&xdr);
217     free (buf);
218   }
219 }
220
221 static void send_error (int errnum, const char *msg);
222
223 void
224 reply_with_error (const char *fs, ...)
225 {
226   char err[GUESTFS_ERROR_LEN];
227   va_list args;
228
229   va_start (args, fs);
230   vsnprintf (err, sizeof err, fs, args);
231   va_end (args);
232
233   send_error (0, err);
234 }
235
236 void
237 reply_with_perror_errno (int err, const char *fs, ...)
238 {
239   char buf1[GUESTFS_ERROR_LEN];
240   char buf2[GUESTFS_ERROR_LEN];
241   va_list args;
242
243   va_start (args, fs);
244   vsnprintf (buf1, sizeof buf1, fs, args);
245   va_end (args);
246
247   snprintf (buf2, sizeof buf2, "%s: %s", buf1, strerror (err));
248
249   send_error (err, buf2);
250 }
251
252 static void
253 send_error (int errnum, const char *msg)
254 {
255   XDR xdr;
256   char buf[GUESTFS_ERROR_LEN + 200];
257   char lenbuf[4];
258   struct guestfs_message_header hdr;
259   struct guestfs_message_error err;
260   unsigned len;
261
262   fprintf (stderr, "guestfsd: error: %s\n", msg);
263
264   xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
265
266   hdr.prog = GUESTFS_PROGRAM;
267   hdr.vers = GUESTFS_PROTOCOL_VERSION;
268   hdr.direction = GUESTFS_DIRECTION_REPLY;
269   hdr.status = GUESTFS_STATUS_ERROR;
270   hdr.proc = proc_nr;
271   hdr.serial = serial;
272
273   if (!xdr_guestfs_message_header (&xdr, &hdr)) {
274     fprintf (stderr, "guestfsd: failed to encode error message header\n");
275     exit (EXIT_FAILURE);
276   }
277
278   /* These strings are not going to be freed.  We just cast them
279    * to (char *) because they are defined that way in the XDR structs.
280    */
281   err.errno_string =
282     (char *) (errnum > 0 ? guestfs___errno_to_string (errnum) : "");
283   err.error_message = (char *) msg;
284
285   if (!xdr_guestfs_message_error (&xdr, &err)) {
286     fprintf (stderr, "guestfsd: failed to encode error message body\n");
287     exit (EXIT_FAILURE);
288   }
289
290   len = xdr_getpos (&xdr);
291   xdr_destroy (&xdr);
292
293   xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
294   xdr_u_int (&xdr, &len);
295   xdr_destroy (&xdr);
296
297   if (xwrite (sock, lenbuf, 4) == -1) {
298     fprintf (stderr, "guestfsd: xwrite failed\n");
299     exit (EXIT_FAILURE);
300   }
301   if (xwrite (sock, buf, len) == -1) {
302     fprintf (stderr, "guestfsd: xwrite failed\n");
303     exit (EXIT_FAILURE);
304   }
305 }
306
307 void
308 reply (xdrproc_t xdrp, char *ret)
309 {
310   XDR xdr;
311   char buf[GUESTFS_MESSAGE_MAX];
312   char lenbuf[4];
313   struct guestfs_message_header hdr;
314   unsigned len;
315
316   xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
317
318   hdr.prog = GUESTFS_PROGRAM;
319   hdr.vers = GUESTFS_PROTOCOL_VERSION;
320   hdr.direction = GUESTFS_DIRECTION_REPLY;
321   hdr.status = GUESTFS_STATUS_OK;
322   hdr.proc = proc_nr;
323   hdr.serial = serial;
324
325   if (!xdr_guestfs_message_header (&xdr, &hdr)) {
326     fprintf (stderr, "guestfsd: failed to encode reply header\n");
327     exit (EXIT_FAILURE);
328   }
329
330   if (xdrp) {
331     /* This can fail if the reply body is too large, for example
332      * if it exceeds the maximum message size.  In that case
333      * we want to return an error message instead. (RHBZ#509597).
334      */
335     if (!(*xdrp) (&xdr, ret)) {
336       reply_with_error ("guestfsd: failed to encode reply body\n(maybe the reply exceeds the maximum message size in the protocol?)");
337       xdr_destroy (&xdr);
338       return;
339     }
340   }
341
342   len = xdr_getpos (&xdr);
343   xdr_destroy (&xdr);
344
345   xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
346   xdr_u_int (&xdr, &len);
347   xdr_destroy (&xdr);
348
349   if (xwrite (sock, lenbuf, 4) == -1) {
350     fprintf (stderr, "guestfsd: xwrite failed\n");
351     exit (EXIT_FAILURE);
352   }
353   if (xwrite (sock, buf, len) == -1) {
354     fprintf (stderr, "guestfsd: xwrite failed\n");
355     exit (EXIT_FAILURE);
356   }
357 }
358
359 /* Receive file chunks, repeatedly calling 'cb'. */
360 int
361 receive_file (receive_cb cb, void *opaque)
362 {
363   guestfs_chunk chunk;
364   char lenbuf[4];
365   char *buf;
366   XDR xdr;
367   int r;
368   uint32_t len;
369
370   for (;;) {
371     if (verbose)
372       fprintf (stderr, "guestfsd: receive_file: reading length word\n");
373
374     /* Read the length word. */
375     if (xread (sock, lenbuf, 4) == -1)
376       exit (EXIT_FAILURE);
377
378     xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
379     xdr_u_int (&xdr, &len);
380     xdr_destroy (&xdr);
381
382     if (len == GUESTFS_CANCEL_FLAG)
383       continue;                 /* Just ignore it. */
384
385     if (len > GUESTFS_MESSAGE_MAX) {
386       fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n",
387                len);
388       exit (EXIT_FAILURE);
389     }
390
391     buf = malloc (len);
392     if (!buf) {
393       perror ("malloc");
394       return -1;
395     }
396
397     if (xread (sock, buf, len) == -1)
398       exit (EXIT_FAILURE);
399
400     xdrmem_create (&xdr, buf, len, XDR_DECODE);
401     memset (&chunk, 0, sizeof chunk);
402     if (!xdr_guestfs_chunk (&xdr, &chunk)) {
403       xdr_destroy (&xdr);
404       free (buf);
405       return -1;
406     }
407     xdr_destroy (&xdr);
408     free (buf);
409
410     if (verbose)
411       fprintf (stderr,
412                "guestfsd: receive_file: got chunk: cancel = 0x%x, len = %d, buf = %p\n",
413                chunk.cancel, chunk.data.data_len, chunk.data.data_val);
414
415     if (chunk.cancel != 0 && chunk.cancel != 1) {
416       fprintf (stderr,
417                "guestfsd: receive_file: chunk.cancel != [0|1] ... "
418                "continuing even though we have probably lost synchronization with the library\n");
419       return -1;
420     }
421
422     if (chunk.cancel) {
423       if (verbose)
424         fprintf (stderr,
425           "guestfsd: receive_file: received cancellation from library\n");
426       xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
427       return -2;
428     }
429     if (chunk.data.data_len == 0) {
430       if (verbose)
431         fprintf (stderr,
432                  "guestfsd: receive_file: end of file, leaving function\n");
433       xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
434       return 0;                 /* end of file */
435     }
436
437     /* Note that the callback can generate progress messages. */
438     if (cb)
439       r = cb (opaque, chunk.data.data_val, chunk.data.data_len);
440     else
441       r = 0;
442
443     xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
444     if (r == -1) {              /* write error */
445       if (verbose)
446         fprintf (stderr, "guestfsd: receive_file: write error\n");
447       return -1;
448     }
449   }
450 }
451
452 /* Send a cancellation flag back to the library. */
453 int
454 cancel_receive (void)
455 {
456   XDR xdr;
457   char fbuf[4];
458   uint32_t flag = GUESTFS_CANCEL_FLAG;
459
460   xdrmem_create (&xdr, fbuf, sizeof fbuf, XDR_ENCODE);
461   xdr_u_int (&xdr, &flag);
462   xdr_destroy (&xdr);
463
464   if (xwrite (sock, fbuf, sizeof fbuf) == -1) {
465     perror ("write to socket");
466     return -1;
467   }
468
469   /* Keep receiving chunks and discarding, until library sees cancel. */
470   return receive_file (NULL, NULL);
471 }
472
473 static int check_for_library_cancellation (void);
474 static int send_chunk (const guestfs_chunk *);
475
476 /* Also check if the library sends us a cancellation message. */
477 int
478 send_file_write (const void *buf, int len)
479 {
480   guestfs_chunk chunk;
481   int cancel;
482
483   if (len > GUESTFS_MAX_CHUNK_SIZE) {
484     fprintf (stderr, "guestfsd: send_file_write: len (%d) > GUESTFS_MAX_CHUNK_SIZE (%d)\n",
485              len, GUESTFS_MAX_CHUNK_SIZE);
486     return -1;
487   }
488
489   cancel = check_for_library_cancellation ();
490
491   if (cancel) {
492     chunk.cancel = 1;
493     chunk.data.data_len = 0;
494     chunk.data.data_val = NULL;
495   } else {
496     chunk.cancel = 0;
497     chunk.data.data_len = len;
498     chunk.data.data_val = (char *) buf;
499   }
500
501   if (send_chunk (&chunk) == -1)
502     return -1;
503
504   if (cancel) return -2;
505   return 0;
506 }
507
508 static int
509 check_for_library_cancellation (void)
510 {
511   fd_set rset;
512   struct timeval tv;
513   int r;
514   char buf[4];
515   uint32_t flag;
516   XDR xdr;
517
518   FD_ZERO (&rset);
519   FD_SET (sock, &rset);
520   tv.tv_sec = 0;
521   tv.tv_usec = 0;
522   r = select (sock+1, &rset, NULL, NULL, &tv);
523   if (r == -1) {
524     perror ("select");
525     return 0;
526   }
527   if (r == 0)
528     return 0;
529
530   /* Read the message from the daemon. */
531   r = xread (sock, buf, sizeof buf);
532   if (r == -1)
533     return 0;
534
535   xdrmem_create (&xdr, buf, sizeof buf, XDR_DECODE);
536   xdr_u_int (&xdr, &flag);
537   xdr_destroy (&xdr);
538
539   if (flag != GUESTFS_CANCEL_FLAG) {
540     fprintf (stderr, "guestfsd: check_for_library_cancellation: read 0x%x from library, expected 0x%x\n",
541              flag, GUESTFS_CANCEL_FLAG);
542     return 0;
543   }
544
545   return 1;
546 }
547
548 int
549 send_file_end (int cancel)
550 {
551   guestfs_chunk chunk;
552
553   chunk.cancel = cancel;
554   chunk.data.data_len = 0;
555   chunk.data.data_val = NULL;
556   return send_chunk (&chunk);
557 }
558
559 static int
560 send_chunk (const guestfs_chunk *chunk)
561 {
562   char buf[GUESTFS_MAX_CHUNK_SIZE + 48];
563   char lenbuf[4];
564   XDR xdr;
565   uint32_t len;
566
567   xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
568   if (!xdr_guestfs_chunk (&xdr, (guestfs_chunk *) chunk)) {
569     fprintf (stderr, "guestfsd: send_chunk: failed to encode chunk\n");
570     xdr_destroy (&xdr);
571     return -1;
572   }
573
574   len = xdr_getpos (&xdr);
575   xdr_destroy (&xdr);
576
577   xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
578   xdr_u_int (&xdr, &len);
579   xdr_destroy (&xdr);
580
581   int err = (xwrite (sock, lenbuf, 4) == 0
582              && xwrite (sock, buf, len) == 0 ? 0 : -1);
583   if (err) {
584     fprintf (stderr, "guestfsd: send_chunk: write failed\n");
585     exit (EXIT_FAILURE);
586   }
587
588   return err;
589 }
590
591 /* Initial delay before sending notification messages, and
592  * the period at which we send them thereafter.  These times
593  * are in microseconds.
594  */
595 #define NOTIFICATION_INITIAL_DELAY 2000000
596 #define NOTIFICATION_PERIOD         333333
597
598 void
599 notify_progress (uint64_t position, uint64_t total)
600 {
601   struct timeval now_t;
602   gettimeofday (&now_t, NULL);
603
604   /* Always send a notification at 100%.  This simplifies callers by
605    * allowing them to 'finish' the progress bar at 100% without
606    * needing special code.
607    */
608   if (count_progress > 0 && position == total)
609     goto send;
610
611   /* Calculate time in microseconds since the last progress message
612    * was sent out (or since the start of the call).
613    */
614   int64_t last_us, now_us, elapsed_us;
615   last_us =
616     (int64_t) last_progress_t.tv_sec * 1000000 + last_progress_t.tv_usec;
617   now_us = (int64_t) now_t.tv_sec * 1000000 + now_t.tv_usec;
618   elapsed_us = now_us - last_us;
619
620   /* Rate limit. */
621   if ((count_progress == 0 && elapsed_us < NOTIFICATION_INITIAL_DELAY) ||
622       (count_progress > 0 && elapsed_us < NOTIFICATION_PERIOD))
623     return;
624
625  send:
626   /* We're going to send a message now ... */
627   count_progress++;
628   last_progress_t = now_t;
629
630   /* Send the header word. */
631   XDR xdr;
632   char buf[128];
633   uint32_t i = GUESTFS_PROGRESS_FLAG;
634   size_t len;
635   xdrmem_create (&xdr, buf, 4, XDR_ENCODE);
636   xdr_u_int (&xdr, &i);
637   xdr_destroy (&xdr);
638
639   if (xwrite (sock, buf, 4) == -1) {
640     fprintf (stderr, "guestfsd: xwrite failed\n");
641     exit (EXIT_FAILURE);
642   }
643
644   guestfs_progress message = {
645     .proc = proc_nr,
646     .serial = serial,
647     .position = position,
648     .total = total,
649   };
650
651   xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
652   if (!xdr_guestfs_progress (&xdr, &message)) {
653     fprintf (stderr, "guestfsd: xdr_guestfs_progress: failed to encode message\n");
654     xdr_destroy (&xdr);
655     return;
656   }
657   len = xdr_getpos (&xdr);
658   xdr_destroy (&xdr);
659
660   if (xwrite (sock, buf, len) == -1) {
661     fprintf (stderr, "guestfsd: xwrite failed\n");
662     exit (EXIT_FAILURE);
663   }
664 }
665
666 /* "Pulse mode" progress messages. */
667
668 #if defined(HAVE_SETITIMER) && defined(HAVE_SIGACTION)
669
670 static void async_safe_send_pulse (int sig);
671
672 void
673 pulse_mode_start (void)
674 {
675   struct sigaction act;
676   struct itimerval it;
677
678   memset (&act, 0, sizeof act);
679   act.sa_handler = async_safe_send_pulse;
680   act.sa_flags = SA_RESTART;
681
682   if (sigaction (SIGALRM, &act, NULL) == -1) {
683     perror ("pulse_mode_start: sigaction");
684     return;
685   }
686
687   it.it_value.tv_sec = NOTIFICATION_INITIAL_DELAY / 1000000;
688   it.it_value.tv_usec = NOTIFICATION_INITIAL_DELAY % 1000000;
689   it.it_interval.tv_sec = NOTIFICATION_PERIOD / 1000000;
690   it.it_interval.tv_usec = NOTIFICATION_PERIOD % 1000000;
691
692   if (setitimer (ITIMER_REAL, &it, NULL) == -1)
693     perror ("pulse_mode_start: setitimer");
694 }
695
696 void
697 pulse_mode_end (void)
698 {
699   pulse_mode_cancel ();         /* Cancel the itimer. */
700
701   notify_progress (1, 1);
702 }
703
704 void
705 pulse_mode_cancel (void)
706 {
707   int err = errno;              /* Function must preserve errno. */
708   struct itimerval it;
709   struct sigaction act;
710
711   /* Setting it_value to zero cancels the itimer. */
712   it.it_value.tv_sec = 0;
713   it.it_value.tv_usec = 0;
714   it.it_interval.tv_sec = 0;
715   it.it_interval.tv_usec = 0;
716
717   if (setitimer (ITIMER_REAL, &it, NULL) == -1)
718     perror ("pulse_mode_cancel: setitimer");
719
720   memset (&act, 0, sizeof act);
721   act.sa_handler = SIG_DFL;
722
723   if (sigaction (SIGALRM, &act, NULL) == -1)
724     perror ("pulse_mode_cancel: sigaction");
725
726   errno = err;
727 }
728
729 /* Send a position = 0, total = 1 (pulse mode) message.  The tricky
730  * part is we have to do it without invoking any non-async-safe
731  * functions (see signal(7) for a list).  Therefore, KISS.
732  */
733 static void
734 async_safe_send_pulse (int sig)
735 {
736   /* XDR is a RFC ... */
737   unsigned char msg[] = {
738     (GUESTFS_PROGRESS_FLAG & 0xff000000) >> 24,
739     (GUESTFS_PROGRESS_FLAG & 0x00ff0000) >> 16,
740     (GUESTFS_PROGRESS_FLAG & 0x0000ff00) >> 8,
741     GUESTFS_PROGRESS_FLAG & 0x000000ff,
742     (proc_nr & 0xff000000) >> 24,
743     (proc_nr & 0x00ff0000) >> 16,
744     (proc_nr & 0x0000ff00) >> 8,
745     proc_nr & 0x000000ff,
746     (serial & 0xff000000) >> 24,
747     (serial & 0x00ff0000) >> 16,
748     (serial & 0x0000ff00) >> 8,
749     serial & 0x000000ff,
750     /* 64 bit position = 0 */ 0, 0, 0, 0, 0, 0, 0, 0,
751     /* 64 bit total = 1 */    0, 0, 0, 0, 0, 0, 0, 1
752   };
753
754   if (xwrite (sock, msg, sizeof msg) == -1)
755     exit (EXIT_FAILURE);
756 }
757
758 #else /* !HAVE_SETITIMER || !HAVE_SIGACTION */
759
760 void
761 pulse_mode_start (void)
762 {
763   /* empty */
764 }
765
766 void
767 pulse_mode_end (void)
768 {
769   /* empty */
770 }
771
772 void
773 pulse_mode_cancel (void)
774 {
775   /* empty */
776 }
777
778 #endif /* !HAVE_SETITIMER || !HAVE_SIGACTION */