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);
}
}
