+
+static int check_for_library_cancellation (void);
+static int send_chunk (const guestfs_chunk *);
+
+/* Also check if the library sends us a cancellation message. */
+int
+send_file_write (const void *buf, int len)
+{
+ guestfs_chunk chunk;
+ int cancel;
+
+ if (len > GUESTFS_MAX_CHUNK_SIZE) {
+ fprintf (stderr, "guestfsd: send_file_write: len (%d) > GUESTFS_MAX_CHUNK_SIZE (%d)\n",
+ len, GUESTFS_MAX_CHUNK_SIZE);
+ return -1;
+ }
+
+ cancel = check_for_library_cancellation ();
+
+ if (cancel) {
+ chunk.cancel = 1;
+ chunk.data.data_len = 0;
+ chunk.data.data_val = NULL;
+ } else {
+ chunk.cancel = 0;
+ chunk.data.data_len = len;
+ chunk.data.data_val = (char *) buf;
+ }
+
+ if (send_chunk (&chunk) == -1)
+ return -1;
+
+ if (cancel) return -2;
+ return 0;
+}
+
+static int
+check_for_library_cancellation (void)
+{
+ fd_set rset;
+ struct timeval tv;
+ int r;
+ char buf[4];
+ uint32_t flag;
+ XDR xdr;
+
+ FD_ZERO (&rset);
+ FD_SET (sock, &rset);
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ r = select (sock+1, &rset, NULL, NULL, &tv);
+ if (r == -1) {
+ perror ("select");
+ return 0;
+ }
+ if (r == 0)
+ return 0;
+
+ /* Read the message from the daemon. */
+ r = xread (sock, buf, sizeof buf);
+ if (r == -1)
+ return 0;
+
+ xdrmem_create (&xdr, buf, sizeof buf, XDR_DECODE);
+ xdr_u_int (&xdr, &flag);
+ xdr_destroy (&xdr);
+
+ if (flag != GUESTFS_CANCEL_FLAG) {
+ fprintf (stderr, "guestfsd: check_for_library_cancellation: read 0x%x from library, expected 0x%x\n",
+ flag, GUESTFS_CANCEL_FLAG);
+ return 0;
+ }
+
+ return 1;
+}
+
+int
+send_file_end (int cancel)
+{
+ guestfs_chunk chunk;
+
+ chunk.cancel = cancel;
+ chunk.data.data_len = 0;
+ chunk.data.data_val = NULL;
+ return send_chunk (&chunk);
+}
+
+static int
+send_chunk (const guestfs_chunk *chunk)
+{
+ char buf[GUESTFS_MAX_CHUNK_SIZE + 48];
+ char lenbuf[4];
+ XDR xdr;
+ uint32_t len;
+
+ xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
+ if (!xdr_guestfs_chunk (&xdr, (guestfs_chunk *) chunk)) {
+ fprintf (stderr, "guestfsd: send_chunk: failed to encode chunk\n");
+ xdr_destroy (&xdr);
+ return -1;
+ }
+
+ len = xdr_getpos (&xdr);
+ xdr_destroy (&xdr);
+
+ xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);
+ 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, "guestfsd: send_chunk: write failed\n");
+ 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, "guestfsd: 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, "guestfsd: 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, "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 */