X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=daemon%2Fproto.c;h=63d1cc990003652924da66ad6ed3d4b8bd7b4953;hp=a0d3736a788f3a9765231ef3fcee228115728f6b;hb=4d900cdac8258daa2e99c6ceb2a4985154e94150;hpb=6a14f1c2502f58ff7bed8cb451f95a83f5ee920a diff --git a/daemon/proto.c b/daemon/proto.c index a0d3736..63d1cc9 100644 --- a/daemon/proto.c +++ b/daemon/proto.c @@ -25,19 +25,35 @@ #include #include #include /* defines MIN */ +#include +#include #include #include +#ifdef HAVE_WINDOWS_H +#include +#endif + #include "c-ctype.h" #include "ignore-value.h" #include "daemon.h" -#include "../src/guestfs_protocol.h" +#include "guestfs_protocol.h" +#include "errnostring.h" /* The message currently being processed. */ int proc_nr; int serial; +/* Time at which we received the current request. */ +static struct timeval start_t; + +/* Time at which the last progress notification was sent. */ +static struct timeval last_progress_t; + +/* Counts the number of progress notifications sent during this call. */ +static int count_progress; + /* The daemon communications socket. */ static int sock; @@ -49,8 +65,6 @@ main_loop (int _sock) char lenbuf[4]; uint32_t len; struct guestfs_message_header hdr; - struct timeval start_t, end_t; - int64_t start_us, end_us, elapsed_us; sock = _sock; @@ -63,16 +77,16 @@ main_loop (int _sock) /* Read the length word. */ if (xread (sock, lenbuf, 4) == -1) - exit (1); + exit (EXIT_FAILURE); xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE); - xdr_uint32_t (&xdr, &len); + xdr_u_int (&xdr, &len); xdr_destroy (&xdr); if (len > GUESTFS_MESSAGE_MAX) { fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n", len); - exit (1); + exit (EXIT_FAILURE); } buf = malloc (len); @@ -82,7 +96,7 @@ main_loop (int _sock) } if (xread (sock, buf, len) == -1) - exit (1); + exit (EXIT_FAILURE); #ifdef ENABLE_PACKET_DUMP if (verbose) { @@ -107,15 +121,15 @@ main_loop (int _sock) } #endif - /* In verbose mode, display the time taken to run each command. */ - if (verbose) - gettimeofday (&start_t, NULL); + gettimeofday (&start_t, NULL); + last_progress_t = start_t; + count_progress = 0; /* Decode the message header. */ xdrmem_create (&xdr, buf, len, XDR_DECODE); if (!xdr_guestfs_message_header (&xdr, &hdr)) { fprintf (stderr, "guestfsd: could not decode message header\n"); - exit (1); + exit (EXIT_FAILURE); } /* Check the version etc. */ @@ -136,19 +150,33 @@ main_loop (int _sock) goto cont; } - /* Now start to process this message. */ proc_nr = hdr.proc; serial = hdr.serial; + + /* Clear errors before we call the stub functions. This is just + * to ensure that we can accurately report errors in cases where + * error handling paths don't set errno correctly. + */ + errno = 0; +#ifdef WIN32 + SetLastError (0); + WSASetLastError (0); +#endif + + /* Now start to process this message. */ dispatch_incoming_message (&xdr); /* Note that dispatch_incoming_message will also send a reply. */ /* In verbose mode, display the time taken to run each command. */ if (verbose) { + struct timeval end_t; gettimeofday (&end_t, NULL); + int64_t start_us, end_us, elapsed_us; start_us = (int64_t) start_t.tv_sec * 1000000 + start_t.tv_usec; 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", proc_nr, proc_nr >= 0 && proc_nr < GUESTFS_PROC_NR_PROCS @@ -163,7 +191,7 @@ main_loop (int _sock) } } -static void send_error (const char *msg); +static void send_error (int errnum, const char *msg); void reply_with_error (const char *fs, ...) @@ -175,16 +203,15 @@ reply_with_error (const char *fs, ...) vsnprintf (err, sizeof err, fs, args); va_end (args); - send_error (err); + send_error (0, err); } void -reply_with_perror (const char *fs, ...) +reply_with_perror_errno (int err, const char *fs, ...) { char buf1[GUESTFS_ERROR_LEN]; char buf2[GUESTFS_ERROR_LEN]; va_list args; - int err = errno; va_start (args, fs); vsnprintf (buf1, sizeof buf1, fs, args); @@ -192,11 +219,11 @@ reply_with_perror (const char *fs, ...) snprintf (buf2, sizeof buf2, "%s: %s", buf1, strerror (err)); - send_error (buf2); + send_error (err, buf2); } static void -send_error (const char *msg) +send_error (int errnum, const char *msg) { XDR xdr; char buf[GUESTFS_ERROR_LEN + 200]; @@ -218,30 +245,35 @@ send_error (const char *msg) if (!xdr_guestfs_message_header (&xdr, &hdr)) { fprintf (stderr, "guestfsd: failed to encode error message header\n"); - exit (1); + exit (EXIT_FAILURE); } + /* 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)) { fprintf (stderr, "guestfsd: failed to encode error message body\n"); - exit (1); + exit (EXIT_FAILURE); } len = xdr_getpos (&xdr); xdr_destroy (&xdr); xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE); - xdr_uint32_t (&xdr, &len); + xdr_u_int (&xdr, &len); xdr_destroy (&xdr); if (xwrite (sock, lenbuf, 4) == -1) { fprintf (stderr, "xwrite failed\n"); - exit (1); + exit (EXIT_FAILURE); } if (xwrite (sock, buf, len) == -1) { fprintf (stderr, "xwrite failed\n"); - exit (1); + exit (EXIT_FAILURE); } } @@ -265,7 +297,7 @@ reply (xdrproc_t xdrp, char *ret) if (!xdr_guestfs_message_header (&xdr, &hdr)) { fprintf (stderr, "guestfsd: failed to encode reply header\n"); - exit (1); + exit (EXIT_FAILURE); } if (xdrp) { @@ -274,7 +306,7 @@ reply (xdrproc_t xdrp, char *ret) * we want to return an error message instead. (RHBZ#509597). */ if (!(*xdrp) (&xdr, ret)) { - reply_with_perror ("guestfsd: failed to encode reply body\n"); + reply_with_error ("guestfsd: failed to encode reply body\n(maybe the reply exceeds the maximum message size in the protocol?)"); xdr_destroy (&xdr); return; } @@ -284,16 +316,16 @@ reply (xdrproc_t xdrp, char *ret) xdr_destroy (&xdr); xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE); - xdr_uint32_t (&xdr, &len); + xdr_u_int (&xdr, &len); xdr_destroy (&xdr); if (xwrite (sock, lenbuf, 4) == -1) { fprintf (stderr, "xwrite failed\n"); - exit (1); + exit (EXIT_FAILURE); } if (xwrite (sock, buf, len) == -1) { fprintf (stderr, "xwrite failed\n"); - exit (1); + exit (EXIT_FAILURE); } } @@ -309,12 +341,15 @@ receive_file (receive_cb cb, void *opaque) uint32_t len; for (;;) { + if (verbose) + fprintf (stderr, "receive_file: reading length word\n"); + /* Read the length word. */ if (xread (sock, lenbuf, 4) == -1) - exit (1); + exit (EXIT_FAILURE); xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE); - xdr_uint32_t (&xdr, &len); + xdr_u_int (&xdr, &len); xdr_destroy (&xdr); if (len == GUESTFS_CANCEL_FLAG) @@ -323,7 +358,7 @@ receive_file (receive_cb cb, void *opaque) if (len > GUESTFS_MESSAGE_MAX) { fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n", len); - exit (1); + exit (EXIT_FAILURE); } buf = malloc (len); @@ -333,7 +368,7 @@ receive_file (receive_cb cb, void *opaque) } if (xread (sock, buf, len) == -1) - exit (1); + exit (EXIT_FAILURE); xdrmem_create (&xdr, buf, len, XDR_DECODE); memset (&chunk, 0, sizeof chunk); @@ -346,15 +381,18 @@ receive_file (receive_cb cb, void *opaque) free (buf); if (verbose) - printf ("receive_file: got chunk: cancel = %d, len = %d, buf = %p\n", - chunk.cancel, chunk.data.data_len, chunk.data.data_val); + fprintf (stderr, "receive_file: got chunk: cancel = %d, len = %d, buf = %p\n", + chunk.cancel, chunk.data.data_len, chunk.data.data_val); if (chunk.cancel) { - fprintf (stderr, "receive_file: received cancellation from library\n"); + if (verbose) + fprintf (stderr, "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"); xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk); return 0; /* end of file */ } @@ -365,13 +403,16 @@ receive_file (receive_cb cb, void *opaque) r = 0; xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk); - if (r == -1) /* write error */ + if (r == -1) { /* write error */ + if (verbose) + fprintf (stderr, "receive_file: write error\n"); return -1; + } } } /* Send a cancellation flag back to the library. */ -void +int cancel_receive (void) { XDR xdr; @@ -379,16 +420,16 @@ cancel_receive (void) uint32_t flag = GUESTFS_CANCEL_FLAG; xdrmem_create (&xdr, fbuf, sizeof fbuf, XDR_ENCODE); - xdr_uint32_t (&xdr, &flag); + xdr_u_int (&xdr, &flag); xdr_destroy (&xdr); if (xwrite (sock, fbuf, sizeof fbuf) == -1) { perror ("write to socket"); - return; + return -1; } /* Keep receiving chunks and discarding, until library sees cancel. */ - (void) receive_file (NULL, NULL); + return receive_file (NULL, NULL); } static int check_for_library_cancellation (void); @@ -454,7 +495,7 @@ check_for_library_cancellation (void) return 0; xdrmem_create (&xdr, buf, sizeof buf, XDR_DECODE); - xdr_uint32_t (&xdr, &flag); + xdr_u_int (&xdr, &flag); xdr_destroy (&xdr); if (flag != GUESTFS_CANCEL_FLAG) { @@ -496,15 +537,90 @@ send_chunk (const guestfs_chunk *chunk) xdr_destroy (&xdr); xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE); - xdr_uint32_t (&xdr, &len); + xdr_u_int (&xdr, &len); xdr_destroy (&xdr); int err = (xwrite (sock, lenbuf, 4) == 0 && xwrite (sock, buf, len) == 0 ? 0 : -1); if (err) { fprintf (stderr, "send_chunk: write failed\n"); - exit (1); + exit (EXIT_FAILURE); } return err; } + +/* Initial delay before sending notification messages, and + * the period at which we send them thereafter. These times + * are in microseconds. + */ +#define NOTIFICATION_INITIAL_DELAY 2000000 +#define NOTIFICATION_PERIOD 333333 + +void +notify_progress (uint64_t position, uint64_t total) +{ + struct timeval now_t; + gettimeofday (&now_t, NULL); + + /* Always send a notification at 100%. This simplifies callers by + * allowing them to 'finish' the progress bar at 100% without + * needing special code. + */ + if (count_progress > 0 && position == total) + goto send; + + /* Calculate time in microseconds since the last progress message + * was sent out (or since the start of the call). + */ + int64_t last_us, now_us, elapsed_us; + last_us = + (int64_t) last_progress_t.tv_sec * 1000000 + last_progress_t.tv_usec; + now_us = (int64_t) now_t.tv_sec * 1000000 + now_t.tv_usec; + elapsed_us = now_us - last_us; + + /* Rate limit. */ + if ((count_progress == 0 && elapsed_us < NOTIFICATION_INITIAL_DELAY) || + (count_progress > 0 && elapsed_us < NOTIFICATION_PERIOD)) + return; + + send: + /* We're going to send a message now ... */ + count_progress++; + last_progress_t = now_t; + + /* Send the header word. */ + XDR xdr; + char buf[128]; + uint32_t i = GUESTFS_PROGRESS_FLAG; + size_t len; + xdrmem_create (&xdr, buf, 4, XDR_ENCODE); + xdr_u_int (&xdr, &i); + xdr_destroy (&xdr); + + if (xwrite (sock, buf, 4) == -1) { + fprintf (stderr, "xwrite failed\n"); + exit (EXIT_FAILURE); + } + + guestfs_progress message = { + .proc = proc_nr, + .serial = serial, + .position = position, + .total = 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"); + xdr_destroy (&xdr); + return; + } + len = xdr_getpos (&xdr); + xdr_destroy (&xdr); + + if (xwrite (sock, buf, len) == -1) { + fprintf (stderr, "xwrite failed\n"); + exit (EXIT_FAILURE); + } +}