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