2 * Copyright (C) 2009-2010 Red Hat Inc.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #define _BSD_SOURCE /* for mkdtemp, usleep */
34 #include <sys/select.h>
38 #include <rpc/types.h>
45 #ifdef HAVE_SYS_TYPES_H
46 #include <sys/types.h>
49 #ifdef HAVE_SYS_WAIT_H
53 #ifdef HAVE_SYS_SOCKET_H
54 #include <sys/socket.h>
61 #include <arpa/inet.h>
62 #include <netinet/in.h>
65 #include "glthread/lock.h"
66 #include "ignore-value.h"
69 #include "guestfs-internal.h"
70 #include "guestfs-internal-actions.h"
71 #include "guestfs_protocol.h"
73 /* This is the code used to send and receive RPC messages and (for
74 * certain types of message) to perform file transfers. This code is
75 * driven from the generated actions (src/actions.c). There
76 * are five different cases to consider:
78 * (1) A non-daemon function. There is no RPC involved at all, it's
79 * all handled inside the library.
81 * (2) A simple RPC (eg. "mount"). We write the request, then read
82 * the reply. The sequence of calls is:
89 * (3) An RPC with FileOut parameters (eg. "upload"). We write the
90 * request, then write the file(s), then read the reply. The sequence
95 * guestfs___send_file (possibly multiple times)
99 * (4) An RPC with FileIn parameters (eg. "download"). We write the
100 * request, then read the reply, then read the file(s). The sequence
106 * guestfs___recv_file (possibly multiple times)
109 * (5) Both FileOut and FileIn parameters. There are no calls like
110 * this in the current API, but they would be implemented as a
111 * combination of cases (3) and (4).
113 * During all writes and reads, we also select(2) on qemu stdout
114 * looking for messages (guestfsd stderr and guest kernel dmesg), and
115 * anything received is passed up through the log_message_cb. This is
116 * also the reason why all the sockets are non-blocking. We also have
117 * to check for EOF (qemu died). All of this is handled by the
118 * functions send_to_daemon and recv_from_daemon.
122 xwrite (int fd, const void *v_buf, size_t len)
124 const char *buf = v_buf;
128 r = write (fd, buf, len);
140 guestfs___set_busy (guestfs_h *g)
142 if (g->state != READY) {
143 error (g, _("guestfs_set_busy: called when in state %d != READY"),
152 guestfs___end_busy (guestfs_h *g)
166 error (g, _("guestfs_end_busy: called when in state %d"), g->state);
172 /* This is called if we detect EOF, ie. qemu died. */
174 child_cleanup (guestfs_h *g)
177 fprintf (stderr, "child_cleanup: %p: child process died\n", g);
179 /*if (g->pid > 0) kill (g->pid, SIGTERM);*/
180 if (g->recoverypid > 0) kill (g->recoverypid, 9);
181 waitpid (g->pid, NULL, 0);
182 if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0);
191 memset (&g->launch_t, 0, sizeof g->launch_t);
193 if (g->subprocess_quit_cb)
194 g->subprocess_quit_cb (g, g->subprocess_quit_cb_data);
198 read_log_message_or_eof (guestfs_h *g, int fd, int error_if_eof)
206 "read_log_message_or_eof: %p g->state = %d, fd = %d\n",
210 /* QEMU's console emulates a 16550A serial port. The real 16550A
211 * device has a small FIFO buffer (16 bytes) which means here we see
212 * lots of small reads of 1-16 bytes in length, usually single
215 n = read (fd, buf, sizeof buf);
217 /* Hopefully this indicates the qemu child process has died. */
221 /* We weren't expecting eof here (called from launch) so place
222 * something in the error buffer. RHBZ#588851.
224 error (g, "child process died unexpectedly");
230 if (errno == EINTR || errno == EAGAIN)
237 /* In verbose mode, copy all log messages to stderr. */
239 ignore_value (write (STDERR_FILENO, buf, n));
241 /* It's an actual log message, send it upwards if anyone is listening. */
242 if (g->log_message_cb)
243 g->log_message_cb (g, g->log_message_cb_data, buf, n);
249 check_for_daemon_cancellation_or_eof (guestfs_h *g, int fd)
258 "check_for_daemon_cancellation_or_eof: %p g->state = %d, fd = %d\n",
261 n = read (fd, buf, 4);
263 /* Hopefully this indicates the qemu child process has died. */
269 if (errno == EINTR || errno == EAGAIN)
276 xdrmem_create (&xdr, buf, 4, XDR_DECODE);
277 xdr_uint32_t (&xdr, &flag);
280 if (flag != GUESTFS_CANCEL_FLAG) {
281 error (g, _("check_for_daemon_cancellation_or_eof: read 0x%x from daemon, expected 0x%x\n"),
282 flag, GUESTFS_CANCEL_FLAG);
289 /* This writes the whole N bytes of BUF to the daemon socket.
291 * If the whole write is successful, it returns 0.
292 * If there was an error, it returns -1.
293 * If the daemon sent a cancellation message, it returns -2.
295 * It also checks qemu stdout for log messages and passes those up
296 * through log_message_cb.
298 * It also checks for EOF (qemu died) and passes that up through the
299 * child_cleanup function above.
302 guestfs___send_to_daemon (guestfs_h *g, const void *v_buf, size_t n)
304 const char *buf = v_buf;
310 "send_to_daemon: %p g->state = %d, n = %zu\n", g, g->state, n);
315 FD_SET (g->fd[1], &rset); /* Read qemu stdout for log messages & EOF. */
316 FD_SET (g->sock, &rset); /* Read socket for cancellation & EOF. */
317 FD_SET (g->sock, &wset); /* Write to socket to send the data. */
319 int max_fd = MAX (g->sock, g->fd[1]);
324 int r = select (max_fd+1, &rset2, &wset2, NULL, NULL);
326 if (errno == EINTR || errno == EAGAIN)
328 perrorf (g, "select");
332 if (FD_ISSET (g->fd[1], &rset2)) {
333 if (read_log_message_or_eof (g, g->fd[1], 0) == -1)
336 if (FD_ISSET (g->sock, &rset2)) {
337 r = check_for_daemon_cancellation_or_eof (g, g->sock);
341 if (FD_ISSET (g->sock, &wset2)) {
342 r = write (g->sock, buf, n);
344 if (errno == EINTR || errno == EAGAIN)
346 perrorf (g, "write");
347 if (errno == EPIPE) /* Disconnected from guest (RHBZ#508713). */
359 /* This reads a single message, file chunk, launch flag or
360 * cancellation flag from the daemon. If something was read, it
361 * returns 0, otherwise -1.
363 * Both size_rtn and buf_rtn must be passed by the caller as non-NULL.
365 * *size_rtn returns the size of the returned message or it may be
366 * GUESTFS_LAUNCH_FLAG or GUESTFS_CANCEL_FLAG.
368 * *buf_rtn is returned containing the message (if any) or will be set
369 * to NULL. *buf_rtn must be freed by the caller.
371 * It also checks qemu stdout for log messages and passes those up
372 * through log_message_cb.
374 * It also checks for EOF (qemu died) and passes that up through the
375 * child_cleanup function above.
378 guestfs___recv_from_daemon (guestfs_h *g, uint32_t *size_rtn, void **buf_rtn)
384 "recv_from_daemon: %p g->state = %d, size_rtn = %p, buf_rtn = %p\n",
385 g, g->state, size_rtn, buf_rtn);
389 FD_SET (g->fd[1], &rset); /* Read qemu stdout for log messages & EOF. */
390 FD_SET (g->sock, &rset); /* Read socket for data & EOF. */
392 int max_fd = MAX (g->sock, g->fd[1]);
398 /* nr is the size of the message, but we prime it as -4 because we
399 * have to read the message length word first.
403 while (nr < (ssize_t) *size_rtn) {
405 int r = select (max_fd+1, &rset2, NULL, NULL, NULL);
407 if (errno == EINTR || errno == EAGAIN)
409 perrorf (g, "select");
415 if (FD_ISSET (g->fd[1], &rset2)) {
416 if (read_log_message_or_eof (g, g->fd[1], 0) == -1) {
422 if (FD_ISSET (g->sock, &rset2)) {
423 if (nr < 0) { /* Have we read the message length word yet? */
424 r = read (g->sock, lenbuf+nr+4, -nr);
426 if (errno == EINTR || errno == EAGAIN)
430 /* Under some circumstances we see "Connection reset by peer"
431 * here when the child dies suddenly. Catch this and call
432 * the cleanup function, same as for EOF.
434 if (err == ECONNRESET)
439 error (g, _("unexpected end of file when reading from daemon"));
445 if (nr < 0) /* Still not got the whole length word. */
449 xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
450 xdr_uint32_t (&xdr, size_rtn);
453 if (*size_rtn == GUESTFS_LAUNCH_FLAG) {
454 if (g->state != LAUNCHING)
455 error (g, _("received magic signature from guestfsd, but in state %d"),
459 if (g->launch_done_cb)
460 g->launch_done_cb (g, g->launch_done_cb_data);
464 else if (*size_rtn == GUESTFS_CANCEL_FLAG)
466 /* If this happens, it's pretty bad and we've probably lost
469 else if (*size_rtn > GUESTFS_MESSAGE_MAX) {
470 error (g, _("message length (%u) > maximum possible size (%d)"),
471 (unsigned) *size_rtn, GUESTFS_MESSAGE_MAX);
475 /* Allocate the complete buffer, size now known. */
476 *buf_rtn = safe_malloc (g, *size_rtn);
480 size_t sizetoread = *size_rtn - nr;
481 if (sizetoread > BUFSIZ) sizetoread = BUFSIZ;
483 r = read (g->sock, (char *) (*buf_rtn) + nr, sizetoread);
485 if (errno == EINTR || errno == EAGAIN)
493 error (g, _("unexpected end of file when reading from daemon"));
503 /* Got the full message, caller can start processing it. */
504 #ifdef ENABLE_PACKET_DUMP
508 for (i = 0; i < nr; i += 16) {
509 printf ("%04zx: ", i);
510 for (j = i; j < MIN (i+16, nr); ++j)
511 printf ("%02x ", (*(unsigned char **)buf_rtn)[j]);
512 for (; j < i+16; ++j)
515 for (j = i; j < MIN (i+16, nr); ++j)
516 if (c_isprint ((*(char **)buf_rtn)[j]))
517 printf ("%c", (*(char **)buf_rtn)[j]);
520 for (; j < i+16; ++j)
530 /* This is very much like recv_from_daemon above, but g->sock is
531 * a listening socket and we are accepting a new connection on
532 * that socket instead of reading anything. Returns the newly
536 guestfs___accept_from_daemon (guestfs_h *g)
542 "accept_from_daemon: %p g->state = %d\n", g, g->state);
546 FD_SET (g->fd[1], &rset); /* Read qemu stdout for log messages & EOF. */
547 FD_SET (g->sock, &rset); /* Read socket for accept. */
549 int max_fd = MAX (g->sock, g->fd[1]);
553 /* If the qemu process has died, clean up the zombie (RHBZ#579155).
554 * By partially polling in the select below we ensure that this
555 * function will be called eventually.
557 waitpid (g->pid, NULL, WNOHANG);
561 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
562 int r = select (max_fd+1, &rset2, NULL, NULL, &tv);
564 if (errno == EINTR || errno == EAGAIN)
566 perrorf (g, "select");
570 if (FD_ISSET (g->fd[1], &rset2)) {
571 if (read_log_message_or_eof (g, g->fd[1], 1) == -1)
574 if (FD_ISSET (g->sock, &rset2)) {
575 sock = accept (g->sock, NULL, NULL);
577 if (errno == EINTR || errno == EAGAIN)
579 perrorf (g, "accept");
589 guestfs___send (guestfs_h *g, int proc_nr, xdrproc_t xdrp, char *args)
591 struct guestfs_message_header hdr;
594 int serial = g->msg_next_serial++;
599 if (g->state != BUSY) {
600 error (g, _("guestfs___send: state %d != BUSY"), g->state);
604 /* We have to allocate this message buffer on the heap because
605 * it is quite large (although will be mostly unused). We
606 * can't allocate it on the stack because in some environments
607 * we have quite limited stack space available, notably when
608 * running in the JVM.
610 msg_out = safe_malloc (g, GUESTFS_MESSAGE_MAX + 4);
611 xdrmem_create (&xdr, msg_out + 4, GUESTFS_MESSAGE_MAX, XDR_ENCODE);
613 /* Serialize the header. */
614 hdr.prog = GUESTFS_PROGRAM;
615 hdr.vers = GUESTFS_PROTOCOL_VERSION;
617 hdr.direction = GUESTFS_DIRECTION_CALL;
619 hdr.status = GUESTFS_STATUS_OK;
621 if (!xdr_guestfs_message_header (&xdr, &hdr)) {
622 error (g, _("xdr_guestfs_message_header failed"));
626 /* Serialize the args. If any, because some message types
627 * have no parameters.
630 if (!(*xdrp) (&xdr, args)) {
631 error (g, _("dispatch failed to marshal args"));
636 /* Get the actual length of the message, resize the buffer to match
637 * the actual length, and write the length word at the beginning.
639 len = xdr_getpos (&xdr);
642 msg_out = safe_realloc (g, msg_out, len + 4);
643 msg_out_size = len + 4;
645 xdrmem_create (&xdr, msg_out, 4, XDR_ENCODE);
646 xdr_uint32_t (&xdr, &len);
649 r = guestfs___send_to_daemon (g, msg_out, msg_out_size);
650 if (r == -2) /* Ignore stray daemon cancellations. */
663 static int cancel = 0; /* XXX Implement file cancellation. */
664 static int send_file_chunk (guestfs_h *g, int cancel, const char *buf, size_t len);
665 static int send_file_data (guestfs_h *g, const char *buf, size_t len);
666 static int send_file_cancellation (guestfs_h *g);
667 static int send_file_complete (guestfs_h *g);
673 * -2 daemon cancelled (we must read the error message)
676 guestfs___send_file (guestfs_h *g, const char *filename)
678 char buf[GUESTFS_MAX_CHUNK_SIZE];
681 fd = open (filename, O_RDONLY);
683 perrorf (g, "open: %s", filename);
684 send_file_cancellation (g);
685 /* Daemon sees cancellation and won't reply, so caller can
691 /* Send file in chunked encoding. */
693 r = read (fd, buf, sizeof buf);
694 if (r == -1 && (errno == EINTR || errno == EAGAIN))
697 err = send_file_data (g, buf, r);
699 if (err == -2) /* daemon sent cancellation */
700 send_file_cancellation (g);
705 if (cancel) { /* cancel from either end */
706 send_file_cancellation (g);
711 perrorf (g, "read: %s", filename);
712 send_file_cancellation (g);
716 /* End of file, but before we send that, we need to close
717 * the file and check for errors.
719 if (close (fd) == -1) {
720 perrorf (g, "close: %s", filename);
721 send_file_cancellation (g);
725 return send_file_complete (g);
728 /* Send a chunk of file data. */
730 send_file_data (guestfs_h *g, const char *buf, size_t len)
732 return send_file_chunk (g, 0, buf, len);
735 /* Send a cancellation message. */
737 send_file_cancellation (guestfs_h *g)
739 return send_file_chunk (g, 1, NULL, 0);
742 /* Send a file complete chunk. */
744 send_file_complete (guestfs_h *g)
747 return send_file_chunk (g, 0, buf, 0);
751 send_file_chunk (guestfs_h *g, int cancel, const char *buf, size_t buflen)
760 if (g->state != BUSY) {
761 error (g, _("send_file_chunk: state %d != READY"), g->state);
765 /* Allocate the chunk buffer. Don't use the stack to avoid
766 * excessive stack usage and unnecessary copies.
768 msg_out = safe_malloc (g, GUESTFS_MAX_CHUNK_SIZE + 4 + 48);
769 xdrmem_create (&xdr, msg_out + 4, GUESTFS_MAX_CHUNK_SIZE + 48, XDR_ENCODE);
771 /* Serialize the chunk. */
772 chunk.cancel = cancel;
773 chunk.data.data_len = buflen;
774 chunk.data.data_val = (char *) buf;
776 if (!xdr_guestfs_chunk (&xdr, &chunk)) {
777 error (g, _("xdr_guestfs_chunk failed (buf = %p, buflen = %zu)"),
783 len = xdr_getpos (&xdr);
786 /* Reduce the size of the outgoing message buffer to the real length. */
787 msg_out = safe_realloc (g, msg_out, len + 4);
788 msg_out_size = len + 4;
790 xdrmem_create (&xdr, msg_out, 4, XDR_ENCODE);
791 xdr_uint32_t (&xdr, &len);
793 r = guestfs___send_to_daemon (g, msg_out, msg_out_size);
795 /* Did the daemon send a cancellation message? */
798 fprintf (stderr, "got daemon cancellation\n");
814 /* Receive a reply. */
816 guestfs___recv (guestfs_h *g, const char *fn,
817 guestfs_message_header *hdr,
818 guestfs_message_error *err,
819 xdrproc_t xdrp, char *ret)
827 r = guestfs___recv_from_daemon (g, &size, &buf);
831 /* This can happen if a cancellation happens right at the end
832 * of us sending a FileIn parameter to the daemon. Discard. The
833 * daemon should send us an error message next.
835 if (size == GUESTFS_CANCEL_FLAG)
838 if (size == GUESTFS_LAUNCH_FLAG) {
839 error (g, "%s: received unexpected launch flag from daemon when expecting reply", fn);
843 xdrmem_create (&xdr, buf, size, XDR_DECODE);
845 if (!xdr_guestfs_message_header (&xdr, hdr)) {
846 error (g, "%s: failed to parse reply header", fn);
851 if (hdr->status == GUESTFS_STATUS_ERROR) {
852 if (!xdr_guestfs_message_error (&xdr, err)) {
853 error (g, "%s: failed to parse reply error", fn);
859 if (xdrp && ret && !xdrp (&xdr, ret)) {
860 error (g, "%s: failed to parse reply", fn);
872 /* Receive a file. */
874 /* Returns -1 = error, 0 = EOF, > 0 = more data */
875 static ssize_t receive_file_data (guestfs_h *g, void **buf);
878 guestfs___recv_file (guestfs_h *g, const char *filename)
883 fd = open (filename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY, 0666);
885 perrorf (g, "open: %s", filename);
889 /* Receive the file in chunked encoding. */
890 while ((r = receive_file_data (g, &buf)) > 0) {
891 if (xwrite (fd, buf, r) == -1) {
892 perrorf (g, "%s: write", filename);
900 error (g, _("%s: error in chunked encoding"), filename);
904 if (close (fd) == -1) {
905 perrorf (g, "close: %s", filename);
912 /* Send cancellation message to daemon, then wait until it
913 * cancels (just throwing away data).
917 uint32_t flag = GUESTFS_CANCEL_FLAG;
920 fprintf (stderr, "%s: waiting for daemon to acknowledge cancellation\n",
923 xdrmem_create (&xdr, fbuf, sizeof fbuf, XDR_ENCODE);
924 xdr_uint32_t (&xdr, &flag);
927 if (xwrite (g->sock, fbuf, sizeof fbuf) == -1) {
928 perrorf (g, _("write to daemon socket"));
932 while (receive_file_data (g, NULL) > 0)
933 ; /* just discard it */
938 /* Receive a chunk of file data. */
939 /* Returns -1 = error, 0 = EOF, > 0 = more data */
941 receive_file_data (guestfs_h *g, void **buf_r)
949 r = guestfs___recv_from_daemon (g, &len, &buf);
951 error (g, _("receive_file_data: parse error in reply callback"));
955 if (len == GUESTFS_LAUNCH_FLAG || len == GUESTFS_CANCEL_FLAG) {
956 error (g, _("receive_file_data: unexpected flag received when reading file chunks"));
960 memset (&chunk, 0, sizeof chunk);
962 xdrmem_create (&xdr, buf, len, XDR_DECODE);
963 if (!xdr_guestfs_chunk (&xdr, &chunk)) {
964 error (g, _("failed to parse file chunk"));
969 /* After decoding, the original buffer is no longer used. */
973 error (g, _("file receive cancelled by daemon"));
974 free (chunk.data.data_val);
978 if (chunk.data.data_len == 0) { /* end of transfer */
979 free (chunk.data.data_val);
983 if (buf_r) *buf_r = chunk.data.data_val;
984 else free (chunk.data.data_val); /* else caller frees */
986 return chunk.data.data_len;