#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
+#include <inttypes.h>
#include <unistd.h>
#include <errno.h>
#include <sys/param.h> /* defines MIN */
#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;
+/* 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_<foo>_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;
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);
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
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",
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)) {
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);
}
}
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);
}
}
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)
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
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;
}
}
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;
}
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;
}
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;
}
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);
}
xdr_destroy (&xdr);
if (xwrite (sock, buf, 4) == -1) {
- fprintf (stderr, "xwrite failed\n");
+ fprintf (stderr, "guestfsd: xwrite failed\n");
exit (EXIT_FAILURE);
}
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;
}
xdr_destroy (&xdr);
if (xwrite (sock, buf, len) == -1) {
- fprintf (stderr, "xwrite failed\n");
+ fprintf (stderr, "guestfsd: xwrite failed\n");
exit (EXIT_FAILURE);
}
}