+ /* Send file in chunked encoding. */
+ while (!cancel && (r = read (fd, buf, sizeof buf)) > 0) {
+ err = send_file_data_sync (g, buf, r);
+ if (err < 0) {
+ if (err == -2) /* daemon sent cancellation */
+ send_file_cancellation_sync (g);
+ return err;
+ }
+ }
+
+ if (cancel) { /* cancel from either end */
+ send_file_cancellation_sync (g);
+ return -1;
+ }
+
+ if (r == -1) {
+ perrorf (g, "read: %s", filename);
+ send_file_cancellation_sync (g);
+ return -1;
+ }
+
+ /* End of file, but before we send that, we need to close
+ * the file and check for errors.
+ */
+ if (close (fd) == -1) {
+ perrorf (g, "close: %s", filename);
+ send_file_cancellation_sync (g);
+ return -1;
+ }
+
+ return send_file_complete_sync (g);
+}
+
+/* Send a chunk of file data. */
+static int
+send_file_data_sync (guestfs_h *g, const char *buf, size_t len)
+{
+ return send_file_chunk_sync (g, 0, buf, len);
+}
+
+/* Send a cancellation message. */
+static int
+send_file_cancellation_sync (guestfs_h *g)
+{
+ return send_file_chunk_sync (g, 1, NULL, 0);
+}
+
+/* Send a file complete chunk. */
+static int
+send_file_complete_sync (guestfs_h *g)
+{
+ char buf[1];
+ return send_file_chunk_sync (g, 0, buf, 0);
+}
+
+/* Send a chunk, cancellation or end of file, synchronously (ie. wait
+ * for it to go).
+ */
+static int check_for_daemon_cancellation (guestfs_h *g);
+
+static int
+send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t buflen)
+{
+ unsigned len;
+ int sent;
+ guestfs_chunk chunk;
+ XDR xdr;
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+
+ if (g->state != BUSY) {
+ error (g, "send_file_chunk_sync: state %d != READY", g->state);
+ return -1;
+ }
+
+ /* This is probably an internal error. Or perhaps we should just
+ * free the buffer anyway?
+ */
+ if (g->msg_out != NULL) {
+ error (g, "guestfs__send_sync: msg_out should be NULL");
+ return -1;
+ }
+
+ /* Did the daemon send a cancellation message? */
+ if (check_for_daemon_cancellation (g)) {
+ if (g->verbose)
+ fprintf (stderr, "got daemon cancellation\n");
+ return -2;
+ }
+
+ /* Allocate the chunk buffer. Don't use the stack to avoid
+ * excessive stack usage and unnecessary copies.
+ */
+ g->msg_out = safe_malloc (g, GUESTFS_MAX_CHUNK_SIZE + 4 + 48);
+ xdrmem_create (&xdr, g->msg_out + 4, GUESTFS_MAX_CHUNK_SIZE + 48, XDR_ENCODE);
+
+ /* Serialize the chunk. */
+ chunk.cancel = cancel;
+ chunk.data.data_len = buflen;
+ chunk.data.data_val = (char *) buf;
+
+ if (!xdr_guestfs_chunk (&xdr, &chunk)) {
+ error (g, "xdr_guestfs_chunk failed (buf = %p, buflen = %zu)",
+ buf, buflen);
+ xdr_destroy (&xdr);