X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=daemon%2Fproto.c;h=6b7a1877c3517089dc762c3bfd4cd2d198994376;hp=f3b1fc0e5e0681d61d21507e05a4827e10c40be8;hb=40f7323134e058c0920caa18c667ea99a4c8b3e8;hpb=9ff99418361cd1b56b00e4ffef52444021e60c72 diff --git a/daemon/proto.c b/daemon/proto.c index f3b1fc0..6b7a187 100644 --- a/daemon/proto.c +++ b/daemon/proto.c @@ -22,6 +22,8 @@ #include #include #include +#include +#include #include #include #include /* defines MIN */ @@ -39,11 +41,29 @@ #include "daemon.h" #include "guestfs_protocol.h" +#include "errnostring.h" /* The message currently being processed. */ int proc_nr; int serial; +/* Hint for implementing progress messages for uploaded/incoming data. + * The caller sets this to a value > 0 if it knows or can estimate how + * much data will be sent (this is not always known, eg. for uploads + * coming from a pipe). If this is known then we can emit progress + * messages as we write the data. + */ +uint64_t progress_hint; + +/* Optional arguments bitmask. Caller sets this to indicate which + * optional arguments in the guestfs__args structure are + * meaningful. Optional arguments not covered by the bitmask are set + * to arbitrary values and the daemon should ignore them. If the + * bitmask has bits set that the daemon doesn't understand, then the + * whole call is rejected early in processing. + */ +uint64_t optargs_bitmask; + /* Time at which we received the current request. */ static struct timeval start_t; @@ -82,6 +102,11 @@ main_loop (int _sock) xdr_u_int (&xdr, &len); xdr_destroy (&xdr); + if (verbose) + fprintf (stderr, + "guestfsd: main_loop: new request, len 0x%" PRIx32 "\n", + len); + if (len > GUESTFS_MESSAGE_MAX) { fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n", len); @@ -151,6 +176,8 @@ main_loop (int _sock) proc_nr = hdr.proc; serial = hdr.serial; + progress_hint = hdr.progress_hint; + optargs_bitmask = hdr.optargs_bitmask; /* Clear errors before we call the stub functions. This is just * to ensure that we can accurately report errors in cases where @@ -176,7 +203,8 @@ main_loop (int _sock) end_us = (int64_t) end_t.tv_sec * 1000000 + end_t.tv_usec; elapsed_us = end_us - start_us; - fprintf (stderr, "proc %d (%s) took %d.%02d seconds\n", + fprintf (stderr, + "guestfsd: main_loop: proc %d (%s) took %d.%02d seconds\n", proc_nr, proc_nr >= 0 && proc_nr < GUESTFS_PROC_NR_PROCS ? function_names[proc_nr] : "UNKNOWN PROCEDURE", @@ -247,7 +275,11 @@ send_error (int errnum, const char *msg) exit (EXIT_FAILURE); } - err.linux_errno = errnum; + /* These strings are not going to be freed. We just cast them + * to (char *) because they are defined that way in the XDR structs. + */ + err.errno_string = + (char *) (errnum > 0 ? guestfs___errno_to_string (errnum) : ""); err.error_message = (char *) msg; if (!xdr_guestfs_message_error (&xdr, &err)) { @@ -263,11 +295,11 @@ send_error (int errnum, const char *msg) xdr_destroy (&xdr); if (xwrite (sock, lenbuf, 4) == -1) { - fprintf (stderr, "xwrite failed\n"); + fprintf (stderr, "guestfsd: xwrite failed\n"); exit (EXIT_FAILURE); } if (xwrite (sock, buf, len) == -1) { - fprintf (stderr, "xwrite failed\n"); + fprintf (stderr, "guestfsd: xwrite failed\n"); exit (EXIT_FAILURE); } } @@ -315,11 +347,11 @@ reply (xdrproc_t xdrp, char *ret) xdr_destroy (&xdr); if (xwrite (sock, lenbuf, 4) == -1) { - fprintf (stderr, "xwrite failed\n"); + fprintf (stderr, "guestfsd: xwrite failed\n"); exit (EXIT_FAILURE); } if (xwrite (sock, buf, len) == -1) { - fprintf (stderr, "xwrite failed\n"); + fprintf (stderr, "guestfsd: xwrite failed\n"); exit (EXIT_FAILURE); } } @@ -337,7 +369,7 @@ receive_file (receive_cb cb, void *opaque) for (;;) { if (verbose) - fprintf (stderr, "receive_file: reading length word\n"); + fprintf (stderr, "guestfsd: receive_file: reading length word\n"); /* Read the length word. */ if (xread (sock, lenbuf, 4) == -1) @@ -376,22 +408,33 @@ receive_file (receive_cb cb, void *opaque) free (buf); if (verbose) - fprintf (stderr, "receive_file: got chunk: cancel = %d, len = %d, buf = %p\n", + fprintf (stderr, + "guestfsd: receive_file: got chunk: cancel = 0x%x, len = %d, buf = %p\n", chunk.cancel, chunk.data.data_len, chunk.data.data_val); + if (chunk.cancel != 0 && chunk.cancel != 1) { + fprintf (stderr, + "guestfsd: receive_file: chunk.cancel != [0|1] ... " + "continuing even though we have probably lost synchronization with the library\n"); + return -1; + } + if (chunk.cancel) { if (verbose) - fprintf (stderr, "receive_file: received cancellation from library\n"); + fprintf (stderr, + "guestfsd: receive_file: received cancellation from library\n"); xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk); return -2; } if (chunk.data.data_len == 0) { if (verbose) - fprintf (stderr, "receive_file: end of file, leaving function\n"); + fprintf (stderr, + "guestfsd: receive_file: end of file, leaving function\n"); xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk); return 0; /* end of file */ } + /* Note that the callback can generate progress messages. */ if (cb) r = cb (opaque, chunk.data.data_val, chunk.data.data_len); else @@ -400,7 +443,7 @@ receive_file (receive_cb cb, void *opaque) xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk); if (r == -1) { /* write error */ if (verbose) - fprintf (stderr, "receive_file: write error\n"); + fprintf (stderr, "guestfsd: receive_file: write error\n"); return -1; } } @@ -438,7 +481,7 @@ send_file_write (const void *buf, int len) int cancel; if (len > GUESTFS_MAX_CHUNK_SIZE) { - fprintf (stderr, "send_file_write: len (%d) > GUESTFS_MAX_CHUNK_SIZE (%d)\n", + fprintf (stderr, "guestfsd: send_file_write: len (%d) > GUESTFS_MAX_CHUNK_SIZE (%d)\n", len, GUESTFS_MAX_CHUNK_SIZE); return -1; } @@ -494,7 +537,7 @@ check_for_library_cancellation (void) xdr_destroy (&xdr); if (flag != GUESTFS_CANCEL_FLAG) { - fprintf (stderr, "check_for_library_cancellation: read 0x%x from library, expected 0x%x\n", + fprintf (stderr, "guestfsd: check_for_library_cancellation: read 0x%x from library, expected 0x%x\n", flag, GUESTFS_CANCEL_FLAG); return 0; } @@ -523,7 +566,7 @@ send_chunk (const guestfs_chunk *chunk) xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE); if (!xdr_guestfs_chunk (&xdr, (guestfs_chunk *) chunk)) { - fprintf (stderr, "send_chunk: failed to encode chunk\n"); + fprintf (stderr, "guestfsd: send_chunk: failed to encode chunk\n"); xdr_destroy (&xdr); return -1; } @@ -538,7 +581,7 @@ send_chunk (const guestfs_chunk *chunk) int err = (xwrite (sock, lenbuf, 4) == 0 && xwrite (sock, buf, len) == 0 ? 0 : -1); if (err) { - fprintf (stderr, "send_chunk: write failed\n"); + fprintf (stderr, "guestfsd: send_chunk: write failed\n"); exit (EXIT_FAILURE); } @@ -594,7 +637,7 @@ notify_progress (uint64_t position, uint64_t total) xdr_destroy (&xdr); if (xwrite (sock, buf, 4) == -1) { - fprintf (stderr, "xwrite failed\n"); + fprintf (stderr, "guestfsd: xwrite failed\n"); exit (EXIT_FAILURE); } @@ -607,7 +650,7 @@ notify_progress (uint64_t position, uint64_t total) xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE); if (!xdr_guestfs_progress (&xdr, &message)) { - fprintf (stderr, "xdr_guestfs_progress: failed to encode message\n"); + fprintf (stderr, "guestfsd: xdr_guestfs_progress: failed to encode message\n"); xdr_destroy (&xdr); return; } @@ -615,7 +658,121 @@ notify_progress (uint64_t position, uint64_t total) xdr_destroy (&xdr); if (xwrite (sock, buf, len) == -1) { - fprintf (stderr, "xwrite failed\n"); + fprintf (stderr, "guestfsd: xwrite failed\n"); exit (EXIT_FAILURE); } } + +/* "Pulse mode" progress messages. */ + +#if defined(HAVE_SETITIMER) && defined(HAVE_SIGACTION) + +static void async_safe_send_pulse (int sig); + +void +pulse_mode_start (void) +{ + struct sigaction act; + struct itimerval it; + + memset (&act, 0, sizeof act); + act.sa_handler = async_safe_send_pulse; + act.sa_flags = SA_RESTART; + + if (sigaction (SIGALRM, &act, NULL) == -1) { + perror ("pulse_mode_start: sigaction"); + return; + } + + it.it_value.tv_sec = NOTIFICATION_INITIAL_DELAY / 1000000; + it.it_value.tv_usec = NOTIFICATION_INITIAL_DELAY % 1000000; + it.it_interval.tv_sec = NOTIFICATION_PERIOD / 1000000; + it.it_interval.tv_usec = NOTIFICATION_PERIOD % 1000000; + + if (setitimer (ITIMER_REAL, &it, NULL) == -1) + perror ("pulse_mode_start: setitimer"); +} + +void +pulse_mode_end (void) +{ + pulse_mode_cancel (); /* Cancel the itimer. */ + + notify_progress (1, 1); +} + +void +pulse_mode_cancel (void) +{ + int err = errno; /* Function must preserve errno. */ + struct itimerval it; + struct sigaction act; + + /* Setting it_value to zero cancels the itimer. */ + it.it_value.tv_sec = 0; + it.it_value.tv_usec = 0; + it.it_interval.tv_sec = 0; + it.it_interval.tv_usec = 0; + + if (setitimer (ITIMER_REAL, &it, NULL) == -1) + perror ("pulse_mode_cancel: setitimer"); + + memset (&act, 0, sizeof act); + act.sa_handler = SIG_DFL; + + if (sigaction (SIGALRM, &act, NULL) == -1) + perror ("pulse_mode_cancel: sigaction"); + + errno = err; +} + +/* Send a position = 0, total = 1 (pulse mode) message. The tricky + * part is we have to do it without invoking any non-async-safe + * functions (see signal(7) for a list). Therefore, KISS. + */ +static void +async_safe_send_pulse (int sig) +{ + /* XDR is a RFC ... */ + unsigned char msg[] = { + (GUESTFS_PROGRESS_FLAG & 0xff000000) >> 24, + (GUESTFS_PROGRESS_FLAG & 0x00ff0000) >> 16, + (GUESTFS_PROGRESS_FLAG & 0x0000ff00) >> 8, + GUESTFS_PROGRESS_FLAG & 0x000000ff, + (proc_nr & 0xff000000) >> 24, + (proc_nr & 0x00ff0000) >> 16, + (proc_nr & 0x0000ff00) >> 8, + proc_nr & 0x000000ff, + (serial & 0xff000000) >> 24, + (serial & 0x00ff0000) >> 16, + (serial & 0x0000ff00) >> 8, + serial & 0x000000ff, + /* 64 bit position = 0 */ 0, 0, 0, 0, 0, 0, 0, 0, + /* 64 bit total = 1 */ 0, 0, 0, 0, 0, 0, 0, 1 + }; + + if (xwrite (sock, msg, sizeof msg) == -1) + exit (EXIT_FAILURE); +} + +#else /* !HAVE_SETITIMER || !HAVE_SIGACTION */ + +void +pulse_mode_start (void) +{ + /* empty */ +} + +void +pulse_mode_end (void) +{ + /* empty */ +} + +void +pulse_mode_cancel (void) +{ + /* empty */ +} + +#endif /* !HAVE_SETITIMER || !HAVE_SIGACTION */