int guestfs_int_recv_from_daemon (guestfs_h *g, uint32_t *size_rtn, void **buf_rtn) { int r; again: r = recv_from_daemon (g, size_rtn, buf_rtn); if (r == -1) return -1; if (*size_rtn == GUESTFS_PROGRESS_FLAG) { guestfs_progress message; XDR xdr; xdrmem_create (&xdr, *buf_rtn, PROGRESS_MESSAGE_SIZE, XDR_DECODE); xdr_guestfs_progress (&xdr, &message); xdr_destroy (&xdr); guestfs_int_progress_message_callback (g, &message); free (*buf_rtn); *buf_rtn = NULL; /* Process next message. */ goto again; } if (*size_rtn == GUESTFS_LAUNCH_FLAG || *size_rtn == GUESTFS_CANCEL_FLAG) return 0; /* Got the full message, caller can start processing it. */ assert (*buf_rtn != NULL); return 0; }
static int check_for_daemon_cancellation_or_eof (guestfs_h *g, int fd) { char summary[MAX_MESSAGE_SUMMARY]; char buf[4]; ssize_t n; uint32_t flag; XDR xdr; n = really_read_from_socket (g, fd, buf, 4); if (n == -1) return -1; if (n == 0) { /* Hopefully this indicates the qemu child process has died. */ child_cleanup (g); return -1; } debug (g, "check_for_daemon_cancellation_or_eof: %s", message_summary (buf, 4, summary)); xdrmem_create (&xdr, buf, 4, XDR_DECODE); xdr_uint32_t (&xdr, &flag); xdr_destroy (&xdr); /* Read and process progress messages that happen during FileIn. */ if (flag == GUESTFS_PROGRESS_FLAG) { char buf[PROGRESS_MESSAGE_SIZE]; guestfs_progress message; n = really_read_from_socket (g, fd, buf, PROGRESS_MESSAGE_SIZE); if (n == -1) return -1; if (n == 0) { child_cleanup (g); return -1; } xdrmem_create (&xdr, buf, PROGRESS_MESSAGE_SIZE, XDR_DECODE); xdr_guestfs_progress (&xdr, &message); xdr_destroy (&xdr); guestfs___progress_message_callback (g, &message); return 0; } if (flag != GUESTFS_CANCEL_FLAG) { error (g, _("check_for_daemon_cancellation_or_eof: read 0x%x from daemon, expected 0x%x\n"), flag, GUESTFS_CANCEL_FLAG); return -1; } return -2; }
/** * Before writing to the daemon socket, check the read side of the * daemon socket for any of these conditions: * * =over 4 * * =item error * * return -1 * * =item daemon cancellation message * * return -2 * * =item progress message * * handle it here * * =item end of input or appliance exited unexpectedly * * return 0 * * =item anything else * * return 1 * * =back */ static ssize_t check_daemon_socket (guestfs_h *g) { char buf[4]; ssize_t n; uint32_t flag; XDR xdr; assert (g->conn); /* callers must check this */ again: if (! g->conn->ops->can_read_data (g, g->conn)) return 1; n = g->conn->ops->read_data (g, g->conn, buf, 4); if (n <= 0) /* 0 or -1 */ return n; xdrmem_create (&xdr, buf, 4, XDR_DECODE); xdr_uint32_t (&xdr, &flag); xdr_destroy (&xdr); /* Read and process progress messages that happen during FileIn. */ if (flag == GUESTFS_PROGRESS_FLAG) { char mbuf[PROGRESS_MESSAGE_SIZE]; guestfs_progress message; n = g->conn->ops->read_data (g, g->conn, mbuf, PROGRESS_MESSAGE_SIZE); if (n <= 0) /* 0 or -1 */ return n; xdrmem_create (&xdr, mbuf, PROGRESS_MESSAGE_SIZE, XDR_DECODE); xdr_guestfs_progress (&xdr, &message); xdr_destroy (&xdr); guestfs_int_progress_message_callback (g, &message); goto again; } if (flag != GUESTFS_CANCEL_FLAG) { error (g, _("check_daemon_socket: read 0x%x from daemon, expected 0x%x. Lost protocol synchronization (bad!)\n"), flag, GUESTFS_CANCEL_FLAG); return -1; } return -2; }
void notify_progress_no_ratelimit (uint64_t position, uint64_t total, const struct timeval *now_t) { XDR xdr; char buf[128]; uint32_t i; size_t len; guestfs_progress message; count_progress++; last_progress_t = *now_t; /* Send the header word. */ i = GUESTFS_PROGRESS_FLAG; 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); } message.proc = proc_nr; message.serial = serial; message.position = position; message.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); } }
int guestfs___recv_from_daemon (guestfs_h *g, uint32_t *size_rtn, void **buf_rtn) { char summary[MAX_MESSAGE_SUMMARY]; fd_set rset, rset2; FD_ZERO (&rset); if (g->fd[1] >= 0) /* Read qemu stdout for log messages & EOF. */ FD_SET (g->fd[1], &rset); FD_SET (g->sock, &rset); /* Read socket for data & EOF. */ int max_fd = MAX (g->sock, g->fd[1]); *size_rtn = 0; *buf_rtn = NULL; char lenbuf[4]; /* nr is the size of the message, but we prime it as -4 because we * have to read the message length word first. */ ssize_t nr = -4; for (;;) { ssize_t message_size = *size_rtn != GUESTFS_PROGRESS_FLAG ? *size_rtn : PROGRESS_MESSAGE_SIZE; if (nr >= message_size) break; rset2 = rset; int r = select (max_fd+1, &rset2, NULL, NULL, NULL); if (r == -1) { if (errno == EINTR || errno == EAGAIN) continue; perrorf (g, "select"); free (*buf_rtn); *buf_rtn = NULL; return -1; } if (g->fd[1] >= 0 && FD_ISSET (g->fd[1], &rset2)) { if (read_log_message_or_eof (g, g->fd[1], 0) == -1) { free (*buf_rtn); *buf_rtn = NULL; return -1; } } if (FD_ISSET (g->sock, &rset2)) { if (nr < 0) { /* Have we read the message length word yet? */ r = read (g->sock, lenbuf+nr+4, -nr); if (r == -1) { if (errno == EINTR || errno == EAGAIN) continue; int err = errno; perrorf (g, "read"); /* Under some circumstances we see "Connection reset by peer" * here when the child dies suddenly. Catch this and call * the cleanup function, same as for EOF. */ if (err == ECONNRESET) child_cleanup (g); return -1; } if (r == 0) { unexpected_end_of_file_from_daemon_error (g); child_cleanup (g); return -1; } nr += r; if (nr < 0) /* Still not got the whole length word. */ continue; XDR xdr; xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE); xdr_uint32_t (&xdr, size_rtn); xdr_destroy (&xdr); /* *size_rtn changed, recalculate message_size */ message_size = *size_rtn != GUESTFS_PROGRESS_FLAG ? *size_rtn : PROGRESS_MESSAGE_SIZE; if (*size_rtn == GUESTFS_LAUNCH_FLAG) { if (g->state != LAUNCHING) error (g, _("received magic signature from guestfsd, but in state %d"), g->state); else { g->state = READY; guestfs___call_callbacks_void (g, GUESTFS_EVENT_LAUNCH_DONE); } debug (g, "recv_from_daemon: received GUESTFS_LAUNCH_FLAG"); return 0; } else if (*size_rtn == GUESTFS_CANCEL_FLAG) { debug (g, "recv_from_daemon: received GUESTFS_CANCEL_FLAG"); return 0; } else if (*size_rtn == GUESTFS_PROGRESS_FLAG) /*FALLTHROUGH*/; /* If this happens, it's pretty bad and we've probably lost * synchronization. */ else if (*size_rtn > GUESTFS_MESSAGE_MAX) { error (g, _("message length (%u) > maximum possible size (%d)"), (unsigned) *size_rtn, GUESTFS_MESSAGE_MAX); return -1; } /* Allocate the complete buffer, size now known. */ *buf_rtn = safe_malloc (g, message_size); /*FALLTHROUGH*/ } size_t sizetoread = message_size - nr; if (sizetoread > BUFSIZ) sizetoread = BUFSIZ; r = read (g->sock, (char *) (*buf_rtn) + nr, sizetoread); if (r == -1) { if (errno == EINTR || errno == EAGAIN) continue; perrorf (g, "read"); free (*buf_rtn); *buf_rtn = NULL; return -1; } if (r == 0) { unexpected_end_of_file_from_daemon_error (g); child_cleanup (g); free (*buf_rtn); *buf_rtn = NULL; return -1; } nr += r; } } /* Got the full message, caller can start processing it. */ #ifdef ENABLE_PACKET_DUMP if (g->verbose) { ssize_t i, j; for (i = 0; i < nr; i += 16) { printf ("%04zx: ", i); for (j = i; j < MIN (i+16, nr); ++j) printf ("%02x ", (*(unsigned char **)buf_rtn)[j]); for (; j < i+16; ++j) printf (" "); printf ("|"); for (j = i; j < MIN (i+16, nr); ++j) if (c_isprint ((*(char **)buf_rtn)[j])) printf ("%c", (*(char **)buf_rtn)[j]); else printf ("."); for (; j < i+16; ++j) printf (" "); printf ("|\n"); } } #endif if (*size_rtn == GUESTFS_PROGRESS_FLAG) { guestfs_progress message; XDR xdr; xdrmem_create (&xdr, *buf_rtn, PROGRESS_MESSAGE_SIZE, XDR_DECODE); xdr_guestfs_progress (&xdr, &message); xdr_destroy (&xdr); guestfs___progress_message_callback (g, &message); free (*buf_rtn); *buf_rtn = NULL; /* Process next message. */ return guestfs___recv_from_daemon (g, size_rtn, buf_rtn); } debug (g, "recv_from_daemon: %" PRIu32 " bytes: %s", *size_rtn, message_summary (*buf_rtn, *size_rtn, summary)); return 0; }
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); } }