src/proto.c

   1 /* libguestfs
   2  * Copyright (C) 2009-2010 Red Hat Inc.
   3  *
   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.
   8  *
   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.
  13  *
  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
  17  */
  18
  19 #include <config.h>
  20
  21 #define _BSD_SOURCE /* for mkdtemp, usleep */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <stdarg.h>
  26 #include <stddef.h>
  27 #include <stdint.h>
  28 #include <inttypes.h>
  29 #include <unistd.h>
  30 #include <string.h>
  31 #include <fcntl.h>
  32 #include <time.h>
  33 #include <sys/stat.h>
  34 #include <sys/select.h>
  35 #include <dirent.h>
  36 #include <signal.h>
  37
  38 #include <rpc/types.h>
  39 #include <rpc/xdr.h>
  40
  41 #ifdef HAVE_ERRNO_H
  42 #include <errno.h>
  43 #endif
  44
  45 #ifdef HAVE_SYS_TYPES_H
  46 #include <sys/types.h>
  47 #endif
  48
  49 #ifdef HAVE_SYS_WAIT_H
  50 #include <sys/wait.h>
  51 #endif
  52
  53 #ifdef HAVE_SYS_SOCKET_H
  54 #include <sys/socket.h>
  55 #endif
  56
  57 #ifdef HAVE_SYS_UN_H
  58 #include <sys/un.h>
  59 #endif
  60
  61 #include <arpa/inet.h>
  62 #include <netinet/in.h>
  63
  64 #include "c-ctype.h"
  65 #include "glthread/lock.h"
  66 #include "ignore-value.h"
  67
  68 #include "guestfs.h"
  69 #include "guestfs-internal.h"
  70 #include "guestfs-internal-actions.h"
  71 #include "guestfs_protocol.h"
  72
  73 /* Size of guestfs_progress message on the wire. */
  74 #define PROGRESS_MESSAGE_SIZE 24
  75
  76 /* This is the code used to send and receive RPC messages and (for
  77  * certain types of message) to perform file transfers.  This code is
  78  * driven from the generated actions (src/actions.c).  There
  79  * are five different cases to consider:
  80  *
  81  * (1) A non-daemon function.  There is no RPC involved at all, it's
  82  * all handled inside the library.
  83  *
  84  * (2) A simple RPC (eg. "mount").  We write the request, then read
  85  * the reply.  The sequence of calls is:
  86  *
  87  *   guestfs___set_busy
  88  *   guestfs___send
  89  *   guestfs___recv
  90  *   guestfs___end_busy
  91  *
  92  * (3) An RPC with FileOut parameters (eg. "upload").  We write the
  93  * request, then write the file(s), then read the reply.  The sequence
  94  * of calls is:
  95  *
  96  *   guestfs___set_busy
  97  *   guestfs___send
  98  *   guestfs___send_file  (possibly multiple times)
  99  *   guestfs___recv
 100  *   guestfs___end_busy
 101  *
 102  * (4) An RPC with FileIn parameters (eg. "download").  We write the
 103  * request, then read the reply, then read the file(s).  The sequence
 104  * of calls is:
 105  *
 106  *   guestfs___set_busy
 107  *   guestfs___send
 108  *   guestfs___recv
 109  *   guestfs___recv_file  (possibly multiple times)
 110  *   guestfs___end_busy
 111  *
 112  * (5) Both FileOut and FileIn parameters.  There are no calls like
 113  * this in the current API, but they would be implemented as a
 114  * combination of cases (3) and (4).
 115  *
 116  * During all writes and reads, we also select(2) on qemu stdout
 117  * looking for messages (guestfsd stderr and guest kernel dmesg), and
 118  * anything received is passed up through the log_message_cb.  This is
 119  * also the reason why all the sockets are non-blocking.  We also have
 120  * to check for EOF (qemu died).  All of this is handled by the
 121  * functions send_to_daemon and recv_from_daemon.
 122  */
 123
 124 static int
 125 xwrite (int fd, const void *v_buf, size_t len)
 126 {
 127   const char *buf = v_buf;
 128   int r;
 129
 130   while (len > 0) {
 131     r = write (fd, buf, len);
 132     if (r == -1)
 133       return -1;
 134
 135     buf += r;
 136     len -= r;
 137   }
 138
 139   return 0;
 140 }
 141
 142 int
 143 guestfs___set_busy (guestfs_h *g)
 144 {
 145   if (g->state != READY) {
 146     error (g, _("guestfs_set_busy: called when in state %d != READY"),
 147            g->state);
 148     return -1;
 149   }
 150   g->state = BUSY;
 151   return 0;
 152 }
 153
 154 int
 155 guestfs___end_busy (guestfs_h *g)
 156 {
 157   switch (g->state)
 158     {
 159     case BUSY:
 160       g->state = READY;
 161       break;
 162     case CONFIG:
 163     case READY:
 164       break;
 165
 166     case LAUNCHING:
 167     case NO_HANDLE:
 168     default:
 169       error (g, _("guestfs_end_busy: called when in state %d"), g->state);
 170       return -1;
 171     }
 172   return 0;
 173 }
 174
 175 /* This is called if we detect EOF, ie. qemu died. */
 176 static void
 177 child_cleanup (guestfs_h *g)
 178 {
 179   if (g->verbose)
 180     fprintf (stderr, "child_cleanup: %p: child process died\n", g);
 181
 182   /*if (g->pid > 0) kill (g->pid, SIGTERM);*/
 183   if (g->recoverypid > 0) kill (g->recoverypid, 9);
 184   waitpid (g->pid, NULL, 0);
 185   if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0);
 186   close (g->fd[0]);
 187   close (g->fd[1]);
 188   close (g->sock);
 189   g->fd[0] = -1;
 190   g->fd[1] = -1;
 191   g->sock = -1;
 192   g->pid = 0;
 193   g->recoverypid = 0;
 194   memset (&g->launch_t, 0, sizeof g->launch_t);
 195   g->state = CONFIG;
 196   if (g->subprocess_quit_cb)
 197     g->subprocess_quit_cb (g, g->subprocess_quit_cb_data);
 198 }
 199
 200 static int
 201 read_log_message_or_eof (guestfs_h *g, int fd, int error_if_eof)
 202 {
 203   char buf[BUFSIZ];
 204   int n;
 205
 206 #if 0
 207   if (g->verbose)
 208     fprintf (stderr,
 209              "read_log_message_or_eof: %p g->state = %d, fd = %d\n",
 210              g, g->state, fd);
 211 #endif
 212
 213   /* QEMU's console emulates a 16550A serial port.  The real 16550A
 214    * device has a small FIFO buffer (16 bytes) which means here we see
 215    * lots of small reads of 1-16 bytes in length, usually single
 216    * bytes.
 217    */
 218   n = read (fd, buf, sizeof buf);
 219   if (n == 0) {
 220     /* Hopefully this indicates the qemu child process has died. */
 221     child_cleanup (g);
 222
 223     if (error_if_eof) {
 224       /* We weren't expecting eof here (called from launch) so place
 225        * something in the error buffer.  RHBZ#588851.
 226        */
 227       error (g, "child process died unexpectedly");
 228     }
 229     return -1;
 230   }
 231
 232   if (n == -1) {
 233     if (errno == EINTR || errno == EAGAIN)
 234       return 0;
 235
 236     perrorf (g, "read");
 237     return -1;
 238   }
 239
 240   /* In verbose mode, copy all log messages to stderr. */
 241   if (g->verbose)
 242     ignore_value (write (STDERR_FILENO, buf, n));
 243
 244   /* It's an actual log message, send it upwards if anyone is listening. */
 245   if (g->log_message_cb)
 246     g->log_message_cb (g, g->log_message_cb_data, buf, n);
 247
 248   return 0;
 249 }
 250
 251 /* Read 'n' bytes, setting the socket to blocking temporarily so
 252  * that we really read the number of bytes requested.
 253  * Returns:  0 == EOF while reading
 254  *          -1 == error, error() function has been called
 255  *           n == read 'n' bytes in full
 256  */
 257 static ssize_t
 258 really_read_from_socket (guestfs_h *g, int sock, char *buf, size_t n)
 259 {
 260   long flags;
 261   ssize_t r;
 262   size_t got;
 263
 264   /* Set socket to blocking. */
 265   flags = fcntl (sock, F_GETFL);
 266   if (flags == -1) {
 267     perrorf (g, "fcntl");
 268     return -1;
 269   }
 270   if (fcntl (sock, F_SETFL, flags & ~O_NONBLOCK) == -1) {
 271     perrorf (g, "fcntl");
 272     return -1;
 273   }
 274
 275   got = 0;
 276   while (got < n) {
 277     r = read (sock, &buf[got], n-got);
 278     if (r == -1) {
 279       perrorf (g, "read");
 280       return -1;
 281     }
 282     if (r == 0)
 283       return 0; /* EOF */
 284     got += r;
 285   }
 286
 287   /* Restore original socket flags. */
 288   if (fcntl (sock, F_SETFL, flags) == -1) {
 289     perrorf (g, "fcntl");
 290     return -1;
 291   }
 292
 293   return (ssize_t) got;
 294 }
 295
 296 static int
 297 check_for_daemon_cancellation_or_eof (guestfs_h *g, int fd)
 298 {
 299   char buf[4];
 300   ssize_t n;
 301   uint32_t flag;
 302   XDR xdr;
 303
 304   if (g->verbose)
 305     fprintf (stderr,
 306              "check_for_daemon_cancellation_or_eof: %p g->state = %d, fd = %d\n",
 307              g, g->state, fd);
 308
 309   n = really_read_from_socket (g, fd, buf, 4);
 310   if (n == -1)
 311     return -1;
 312   if (n == 0) {
 313     /* Hopefully this indicates the qemu child process has died. */
 314     child_cleanup (g);
 315     return -1;
 316   }
 317
 318   xdrmem_create (&xdr, buf, 4, XDR_DECODE);
 319   xdr_uint32_t (&xdr, &flag);
 320   xdr_destroy (&xdr);
 321
 322   /* Read and process progress messages that happen during FileIn. */
 323   if (flag == GUESTFS_PROGRESS_FLAG) {
 324     char buf[PROGRESS_MESSAGE_SIZE];
 325
 326     n = really_read_from_socket (g, fd, buf, PROGRESS_MESSAGE_SIZE);
 327     if (n == -1)
 328       return -1;
 329     if (n == 0) {
 330       child_cleanup (g);
 331       return -1;
 332     }
 333
 334     if (g->state == BUSY && g->progress_cb) {
 335       guestfs_progress message;
 336
 337       xdrmem_create (&xdr, buf, PROGRESS_MESSAGE_SIZE, XDR_DECODE);
 338       xdr_guestfs_progress (&xdr, &message);
 339       xdr_destroy (&xdr);
 340
 341       g->progress_cb (g, g->progress_cb_data,
 342                       message.proc, message.serial,
 343                       message.position, message.total);
 344     }
 345
 346     return 0;
 347   }
 348
 349   if (flag != GUESTFS_CANCEL_FLAG) {
 350     error (g, _("check_for_daemon_cancellation_or_eof: read 0x%x from daemon, expected 0x%x\n"),
 351            flag, GUESTFS_CANCEL_FLAG);
 352     return -1;
 353   }
 354
 355   return -2;
 356 }
 357
 358 /* This writes the whole N bytes of BUF to the daemon socket.
 359  *
 360  * If the whole write is successful, it returns 0.
 361  * If there was an error, it returns -1.
 362  * If the daemon sent a cancellation message, it returns -2.
 363  *
 364  * It also checks qemu stdout for log messages and passes those up
 365  * through log_message_cb.
 366  *
 367  * It also checks for EOF (qemu died) and passes that up through the
 368  * child_cleanup function above.
 369  */
 370 int
 371 guestfs___send_to_daemon (guestfs_h *g, const void *v_buf, size_t n)
 372 {
 373   const char *buf = v_buf;
 374   fd_set rset, rset2;
 375   fd_set wset, wset2;
 376
 377   if (g->verbose)
 378     fprintf (stderr,
 379              "send_to_daemon: %p g->state = %d, n = %zu\n", g, g->state, n);
 380
 381   FD_ZERO (&rset);
 382   FD_ZERO (&wset);
 383
 384   FD_SET (g->fd[1], &rset);     /* Read qemu stdout for log messages & EOF. */
 385   FD_SET (g->sock, &rset);      /* Read socket for cancellation & EOF. */
 386   FD_SET (g->sock, &wset);      /* Write to socket to send the data. */
 387
 388   int max_fd = MAX (g->sock, g->fd[1]);
 389
 390   while (n > 0) {
 391     rset2 = rset;
 392     wset2 = wset;
 393     int r = select (max_fd+1, &rset2, &wset2, NULL, NULL);
 394     if (r == -1) {
 395       if (errno == EINTR || errno == EAGAIN)
 396         continue;
 397       perrorf (g, "select");
 398       return -1;
 399     }
 400
 401     if (FD_ISSET (g->fd[1], &rset2)) {
 402       if (read_log_message_or_eof (g, g->fd[1], 0) == -1)
 403         return -1;
 404     }
 405     if (FD_ISSET (g->sock, &rset2)) {
 406       r = check_for_daemon_cancellation_or_eof (g, g->sock);
 407       if (r == -1)
 408         return r;
 409       if (r == -2) {
 410         /* Daemon sent cancel message.  But to maintain
 411          * synchronization we must write out the remainder of the
 412          * write buffer before we return (RHBZ#576879).
 413          */
 414         if (xwrite (g->sock, buf, n) == -1) {
 415           perrorf (g, "write");
 416           return -1;
 417         }
 418         return -2; /* cancelled */
 419       }
 420     }
 421     if (FD_ISSET (g->sock, &wset2)) {
 422       r = write (g->sock, buf, n);
 423       if (r == -1) {
 424         if (errno == EINTR || errno == EAGAIN)
 425           continue;
 426         perrorf (g, "write");
 427         if (errno == EPIPE) /* Disconnected from guest (RHBZ#508713). */
 428           child_cleanup (g);
 429         return -1;
 430       }
 431       buf += r;
 432       n -= r;
 433     }
 434   }
 435
 436   return 0;
 437 }
 438
 439 /* This reads a single message, file chunk, launch flag or
 440  * cancellation flag from the daemon.  If something was read, it
 441  * returns 0, otherwise -1.
 442  *
 443  * Both size_rtn and buf_rtn must be passed by the caller as non-NULL.
 444  *
 445  * *size_rtn returns the size of the returned message or it may be
 446  * GUESTFS_LAUNCH_FLAG or GUESTFS_CANCEL_FLAG.
 447  *
 448  * *buf_rtn is returned containing the message (if any) or will be set
 449  * to NULL.  *buf_rtn must be freed by the caller.
 450  *
 451  * It also checks qemu stdout for log messages and passes those up
 452  * through log_message_cb.
 453  *
 454  * It also checks for EOF (qemu died) and passes that up through the
 455  * child_cleanup function above.
 456  *
 457  * Progress notifications are handled transparently by this function.
 458  * If the callback exists, it is called.  The caller of this function
 459  * will not see GUESTFS_PROGRESS_FLAG.
 460  */
 461
 462 static inline void
 463 unexpected_end_of_file_from_daemon_error (guestfs_h *g)
 464 {
 465 #define UNEXPEOF_ERROR "unexpected end of file when reading from daemon.\n"
 466 #define UNEXPEOF_TEST_TOOL \
 467   "Or you can run 'libguestfs-test-tool' and post the complete output into\n" \
 468   "a bug report or message to the libguestfs mailing list."
 469   if (!g->verbose)
 470     error (g, _(UNEXPEOF_ERROR
 471 "This usually means the libguestfs appliance failed to start up.  Please\n"
 472 "enable debugging (LIBGUESTFS_DEBUG=1) and rerun the command, then look at\n"
 473 "the debug messages output prior to this error.\n"
 474 UNEXPEOF_TEST_TOOL));
 475   else
 476     error (g, _(UNEXPEOF_ERROR
 477 "See earlier debug messages.\n"
 478 UNEXPEOF_TEST_TOOL));
 479 }
 480
 481 int
 482 guestfs___recv_from_daemon (guestfs_h *g, uint32_t *size_rtn, void **buf_rtn)
 483 {
 484   fd_set rset, rset2;
 485
 486   if (g->verbose)
 487     fprintf (stderr,
 488              "recv_from_daemon: %p g->state = %d, size_rtn = %p, buf_rtn = %p\n",
 489              g, g->state, size_rtn, buf_rtn);
 490
 491   FD_ZERO (&rset);
 492
 493   FD_SET (g->fd[1], &rset);     /* Read qemu stdout for log messages & EOF. */
 494   FD_SET (g->sock, &rset);      /* Read socket for data & EOF. */
 495
 496   int max_fd = MAX (g->sock, g->fd[1]);
 497
 498   *size_rtn = 0;
 499   *buf_rtn = NULL;
 500
 501   char lenbuf[4];
 502   /* nr is the size of the message, but we prime it as -4 because we
 503    * have to read the message length word first.
 504    */
 505   ssize_t nr = -4;
 506
 507   for (;;) {
 508     ssize_t message_size =
 509       *size_rtn != GUESTFS_PROGRESS_FLAG ?
 510       *size_rtn : PROGRESS_MESSAGE_SIZE;
 511     if (nr >= message_size)
 512       break;
 513
 514     rset2 = rset;
 515     int r = select (max_fd+1, &rset2, NULL, NULL, NULL);
 516     if (r == -1) {
 517       if (errno == EINTR || errno == EAGAIN)
 518         continue;
 519       perrorf (g, "select");
 520       free (*buf_rtn);
 521       *buf_rtn = NULL;
 522       return -1;
 523     }
 524
 525     if (FD_ISSET (g->fd[1], &rset2)) {
 526       if (read_log_message_or_eof (g, g->fd[1], 0) == -1) {
 527         free (*buf_rtn);
 528         *buf_rtn = NULL;
 529         return -1;
 530       }
 531     }
 532     if (FD_ISSET (g->sock, &rset2)) {
 533       if (nr < 0) {    /* Have we read the message length word yet? */
 534         r = read (g->sock, lenbuf+nr+4, -nr);
 535         if (r == -1) {
 536           if (errno == EINTR || errno == EAGAIN)
 537             continue;
 538           int err = errno;
 539           perrorf (g, "read");
 540           /* Under some circumstances we see "Connection reset by peer"
 541            * here when the child dies suddenly.  Catch this and call
 542            * the cleanup function, same as for EOF.
 543            */
 544           if (err == ECONNRESET)
 545             child_cleanup (g);
 546           return -1;
 547         }
 548         if (r == 0) {
 549           unexpected_end_of_file_from_daemon_error (g);
 550           child_cleanup (g);
 551           return -1;
 552         }
 553         nr += r;
 554
 555         if (nr < 0)         /* Still not got the whole length word. */
 556           continue;
 557
 558         XDR xdr;
 559         xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
 560         xdr_uint32_t (&xdr, size_rtn);
 561         xdr_destroy (&xdr);
 562
 563         /* *size_rtn changed, recalculate message_size */
 564         message_size =
 565           *size_rtn != GUESTFS_PROGRESS_FLAG ?
 566           *size_rtn : PROGRESS_MESSAGE_SIZE;
 567
 568         if (*size_rtn == GUESTFS_LAUNCH_FLAG) {
 569           if (g->state != LAUNCHING)
 570             error (g, _("received magic signature from guestfsd, but in state %d"),
 571                    g->state);
 572           else {
 573             g->state = READY;
 574             if (g->launch_done_cb)
 575               g->launch_done_cb (g, g->launch_done_cb_data);
 576           }
 577           return 0;
 578         }
 579         else if (*size_rtn == GUESTFS_CANCEL_FLAG)
 580           return 0;
 581         else if (*size_rtn == GUESTFS_PROGRESS_FLAG)
 582           /*FALLTHROUGH*/;
 583         /* If this happens, it's pretty bad and we've probably lost
 584          * synchronization.
 585          */
 586         else if (*size_rtn > GUESTFS_MESSAGE_MAX) {
 587           error (g, _("message length (%u) > maximum possible size (%d)"),
 588                  (unsigned) *size_rtn, GUESTFS_MESSAGE_MAX);
 589           return -1;
 590         }
 591
 592         /* Allocate the complete buffer, size now known. */
 593         *buf_rtn = safe_malloc (g, message_size);
 594         /*FALLTHROUGH*/
 595       }
 596
 597       size_t sizetoread = message_size - nr;
 598       if (sizetoread > BUFSIZ) sizetoread = BUFSIZ;
 599
 600       r = read (g->sock, (char *) (*buf_rtn) + nr, sizetoread);
 601       if (r == -1) {
 602         if (errno == EINTR || errno == EAGAIN)
 603           continue;
 604         perrorf (g, "read");
 605         free (*buf_rtn);
 606         *buf_rtn = NULL;
 607         return -1;
 608       }
 609       if (r == 0) {
 610         unexpected_end_of_file_from_daemon_error (g);
 611         child_cleanup (g);
 612         free (*buf_rtn);
 613         *buf_rtn = NULL;
 614         return -1;
 615       }
 616       nr += r;
 617     }
 618   }
 619
 620   /* Got the full message, caller can start processing it. */
 621 #ifdef ENABLE_PACKET_DUMP
 622   if (g->verbose) {
 623     ssize_t i, j;
 624
 625     for (i = 0; i < nr; i += 16) {
 626       printf ("%04zx: ", i);
 627       for (j = i; j < MIN (i+16, nr); ++j)
 628         printf ("%02x ", (*(unsigned char **)buf_rtn)[j]);
 629       for (; j < i+16; ++j)
 630         printf ("   ");
 631       printf ("|");
 632       for (j = i; j < MIN (i+16, nr); ++j)
 633         if (c_isprint ((*(char **)buf_rtn)[j]))
 634           printf ("%c", (*(char **)buf_rtn)[j]);
 635         else
 636           printf (".");
 637       for (; j < i+16; ++j)
 638         printf (" ");
 639       printf ("|\n");
 640     }
 641   }
 642 #endif
 643
 644   if (*size_rtn == GUESTFS_PROGRESS_FLAG) {
 645     if (g->state == BUSY && g->progress_cb) {
 646       guestfs_progress message;
 647       XDR xdr;
 648       xdrmem_create (&xdr, *buf_rtn, PROGRESS_MESSAGE_SIZE, XDR_DECODE);
 649       xdr_guestfs_progress (&xdr, &message);
 650       xdr_destroy (&xdr);
 651
 652       g->progress_cb (g, g->progress_cb_data,
 653                       message.proc, message.serial,
 654                       message.position, message.total);
 655     }
 656
 657     free (*buf_rtn);
 658     *buf_rtn = NULL;
 659
 660     /* Process next message. */
 661     return guestfs___recv_from_daemon (g, size_rtn, buf_rtn);
 662   }
 663
 664   return 0;
 665 }
 666
 667 /* This is very much like recv_from_daemon above, but g->sock is
 668  * a listening socket and we are accepting a new connection on
 669  * that socket instead of reading anything.  Returns the newly
 670  * accepted socket.
 671  */
 672 int
 673 guestfs___accept_from_daemon (guestfs_h *g)
 674 {
 675   fd_set rset, rset2;
 676
 677   if (g->verbose)
 678     fprintf (stderr,
 679              "accept_from_daemon: %p g->state = %d\n", g, g->state);
 680
 681   FD_ZERO (&rset);
 682
 683   FD_SET (g->fd[1], &rset);     /* Read qemu stdout for log messages & EOF. */
 684   FD_SET (g->sock, &rset);      /* Read socket for accept. */
 685
 686   int max_fd = MAX (g->sock, g->fd[1]);
 687   int sock = -1;
 688
 689   while (sock == -1) {
 690     /* If the qemu process has died, clean up the zombie (RHBZ#579155).
 691      * By partially polling in the select below we ensure that this
 692      * function will be called eventually.
 693      */
 694     waitpid (g->pid, NULL, WNOHANG);
 695
 696     rset2 = rset;
 697
 698     struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
 699     int r = select (max_fd+1, &rset2, NULL, NULL, &tv);
 700     if (r == -1) {
 701       if (errno == EINTR || errno == EAGAIN)
 702         continue;
 703       perrorf (g, "select");
 704       return -1;
 705     }
 706
 707     if (FD_ISSET (g->fd[1], &rset2)) {
 708       if (read_log_message_or_eof (g, g->fd[1], 1) == -1)
 709         return -1;
 710     }
 711     if (FD_ISSET (g->sock, &rset2)) {
 712       sock = accept (g->sock, NULL, NULL);
 713       if (sock == -1) {
 714         if (errno == EINTR || errno == EAGAIN)
 715           continue;
 716         perrorf (g, "accept");
 717         return -1;
 718       }
 719     }
 720   }
 721
 722   return sock;
 723 }
 724
 725 int
 726 guestfs___send (guestfs_h *g, int proc_nr,
 727                 uint64_t progress_hint, uint64_t optargs_bitmask,
 728                 xdrproc_t xdrp, char *args)
 729 {
 730   struct guestfs_message_header hdr;
 731   XDR xdr;
 732   u_int32_t len;
 733   int serial = g->msg_next_serial++;
 734   int r;
 735   char *msg_out;
 736   size_t msg_out_size;
 737
 738   if (g->state != BUSY) {
 739     error (g, _("guestfs___send: state %d != BUSY"), g->state);
 740     return -1;
 741   }
 742
 743   /* We have to allocate this message buffer on the heap because
 744    * it is quite large (although will be mostly unused).  We
 745    * can't allocate it on the stack because in some environments
 746    * we have quite limited stack space available, notably when
 747    * running in the JVM.
 748    */
 749   msg_out = safe_malloc (g, GUESTFS_MESSAGE_MAX + 4);
 750   xdrmem_create (&xdr, msg_out + 4, GUESTFS_MESSAGE_MAX, XDR_ENCODE);
 751
 752   /* Serialize the header. */
 753   hdr.prog = GUESTFS_PROGRAM;
 754   hdr.vers = GUESTFS_PROTOCOL_VERSION;
 755   hdr.proc = proc_nr;
 756   hdr.direction = GUESTFS_DIRECTION_CALL;
 757   hdr.serial = serial;
 758   hdr.status = GUESTFS_STATUS_OK;
 759   hdr.progress_hint = progress_hint;
 760   hdr.optargs_bitmask = optargs_bitmask;
 761
 762   if (!xdr_guestfs_message_header (&xdr, &hdr)) {
 763     error (g, _("xdr_guestfs_message_header failed"));
 764     goto cleanup1;
 765   }
 766
 767   /* Serialize the args.  If any, because some message types
 768    * have no parameters.
 769    */
 770   if (xdrp) {
 771     if (!(*xdrp) (&xdr, args)) {
 772       error (g, _("dispatch failed to marshal args"));
 773       goto cleanup1;
 774     }
 775   }
 776
 777   /* Get the actual length of the message, resize the buffer to match
 778    * the actual length, and write the length word at the beginning.
 779    */
 780   len = xdr_getpos (&xdr);
 781   xdr_destroy (&xdr);
 782
 783   msg_out = safe_realloc (g, msg_out, len + 4);
 784   msg_out_size = len + 4;
 785
 786   xdrmem_create (&xdr, msg_out, 4, XDR_ENCODE);
 787   xdr_uint32_t (&xdr, &len);
 788
 789  again:
 790   r = guestfs___send_to_daemon (g, msg_out, msg_out_size);
 791   if (r == -2)                  /* Ignore stray daemon cancellations. */
 792     goto again;
 793   if (r == -1)
 794     goto cleanup1;
 795   free (msg_out);
 796
 797   return serial;
 798
 799  cleanup1:
 800   free (msg_out);
 801   return -1;
 802 }
 803
 804 static int cancel = 0; /* XXX Implement file cancellation. */
 805 static int send_file_chunk (guestfs_h *g, int cancel, const char *buf, size_t len);
 806 static int send_file_data (guestfs_h *g, const char *buf, size_t len);
 807 static int send_file_cancellation (guestfs_h *g);
 808 static int send_file_complete (guestfs_h *g);
 809
 810 /* Send a file.
 811  * Returns:
 812  *   0 OK
 813  *   -1 error
 814  *   -2 daemon cancelled (we must read the error message)
 815  */
 816 int
 817 guestfs___send_file (guestfs_h *g, const char *filename)
 818 {
 819   char buf[GUESTFS_MAX_CHUNK_SIZE];
 820   int fd, r, err;
 821
 822   fd = open (filename, O_RDONLY);
 823   if (fd == -1) {
 824     perrorf (g, "open: %s", filename);
 825     send_file_cancellation (g);
 826     return -1;
 827   }
 828
 829   /* Send file in chunked encoding. */
 830   while (!cancel) {
 831     r = read (fd, buf, sizeof buf);
 832     if (r == -1 && (errno == EINTR || errno == EAGAIN))
 833       continue;
 834     if (r <= 0) break;
 835     err = send_file_data (g, buf, r);
 836     if (err < 0) {
 837       if (err == -2)            /* daemon sent cancellation */
 838         send_file_cancellation (g);
 839       return err;
 840     }
 841   }
 842
 843   if (cancel) {                 /* cancel from either end */
 844     send_file_cancellation (g);
 845     return -1;
 846   }
 847
 848   if (r == -1) {
 849     perrorf (g, "read: %s", filename);
 850     send_file_cancellation (g);
 851     return -1;
 852   }
 853
 854   /* End of file, but before we send that, we need to close
 855    * the file and check for errors.
 856    */
 857   if (close (fd) == -1) {
 858     perrorf (g, "close: %s", filename);
 859     send_file_cancellation (g);
 860     return -1;
 861   }
 862
 863   return send_file_complete (g);
 864 }
 865
 866 /* Send a chunk of file data. */
 867 static int
 868 send_file_data (guestfs_h *g, const char *buf, size_t len)
 869 {
 870   return send_file_chunk (g, 0, buf, len);
 871 }
 872
 873 /* Send a cancellation message. */
 874 static int
 875 send_file_cancellation (guestfs_h *g)
 876 {
 877   return send_file_chunk (g, 1, NULL, 0);
 878 }
 879
 880 /* Send a file complete chunk. */
 881 static int
 882 send_file_complete (guestfs_h *g)
 883 {
 884   char buf[1];
 885   return send_file_chunk (g, 0, buf, 0);
 886 }
 887
 888 static int
 889 send_file_chunk (guestfs_h *g, int cancel, const char *buf, size_t buflen)
 890 {
 891   u_int32_t len;
 892   int r;
 893   guestfs_chunk chunk;
 894   XDR xdr;
 895   char *msg_out;
 896   size_t msg_out_size;
 897
 898   if (g->state != BUSY) {
 899     error (g, _("send_file_chunk: state %d != READY"), g->state);
 900     return -1;
 901   }
 902
 903   /* Allocate the chunk buffer.  Don't use the stack to avoid
 904    * excessive stack usage and unnecessary copies.
 905    */
 906   msg_out = safe_malloc (g, GUESTFS_MAX_CHUNK_SIZE + 4 + 48);
 907   xdrmem_create (&xdr, msg_out + 4, GUESTFS_MAX_CHUNK_SIZE + 48, XDR_ENCODE);
 908
 909   /* Serialize the chunk. */
 910   chunk.cancel = cancel;
 911   chunk.data.data_len = buflen;
 912   chunk.data.data_val = (char *) buf;
 913
 914   if (!xdr_guestfs_chunk (&xdr, &chunk)) {
 915     error (g, _("xdr_guestfs_chunk failed (buf = %p, buflen = %zu)"),
 916            buf, buflen);
 917     xdr_destroy (&xdr);
 918     goto cleanup1;
 919   }
 920
 921   len = xdr_getpos (&xdr);
 922   xdr_destroy (&xdr);
 923
 924   /* Reduce the size of the outgoing message buffer to the real length. */
 925   msg_out = safe_realloc (g, msg_out, len + 4);
 926   msg_out_size = len + 4;
 927
 928   xdrmem_create (&xdr, msg_out, 4, XDR_ENCODE);
 929   xdr_uint32_t (&xdr, &len);
 930
 931   r = guestfs___send_to_daemon (g, msg_out, msg_out_size);
 932
 933   /* Did the daemon send a cancellation message? */
 934   if (r == -2) {
 935     if (g->verbose)
 936       fprintf (stderr, "got daemon cancellation\n");
 937     return -2;
 938   }
 939
 940   if (r == -1)
 941     goto cleanup1;
 942
 943   free (msg_out);
 944
 945   return 0;
 946
 947  cleanup1:
 948   free (msg_out);
 949   return -1;
 950 }
 951
 952 /* Receive a reply. */
 953 int
 954 guestfs___recv (guestfs_h *g, const char *fn,
 955                 guestfs_message_header *hdr,
 956                 guestfs_message_error *err,
 957                 xdrproc_t xdrp, char *ret)
 958 {
 959   XDR xdr;
 960   void *buf;
 961   uint32_t size;
 962   int r;
 963
 964  again:
 965   r = guestfs___recv_from_daemon (g, &size, &buf);
 966   if (r == -1)
 967     return -1;
 968
 969   /* This can happen if a cancellation happens right at the end
 970    * of us sending a FileIn parameter to the daemon.  Discard.  The
 971    * daemon should send us an error message next.
 972    */
 973   if (size == GUESTFS_CANCEL_FLAG)
 974     goto again;
 975
 976   if (size == GUESTFS_LAUNCH_FLAG) {
 977     error (g, "%s: received unexpected launch flag from daemon when expecting reply", fn);
 978     return -1;
 979   }
 980
 981   xdrmem_create (&xdr, buf, size, XDR_DECODE);
 982
 983   if (!xdr_guestfs_message_header (&xdr, hdr)) {
 984     error (g, "%s: failed to parse reply header", fn);
 985     xdr_destroy (&xdr);
 986     free (buf);
 987     return -1;
 988   }
 989   if (hdr->status == GUESTFS_STATUS_ERROR) {
 990     if (!xdr_guestfs_message_error (&xdr, err)) {
 991       error (g, "%s: failed to parse reply error", fn);
 992       xdr_destroy (&xdr);
 993       free (buf);
 994       return -1;
 995     }
 996   } else {
 997     if (xdrp && ret && !xdrp (&xdr, ret)) {
 998       error (g, "%s: failed to parse reply", fn);
 999       xdr_destroy (&xdr);
1000       free (buf);
1001       return -1;
1002     }
1003   }
1004   xdr_destroy (&xdr);
1005   free (buf);
1006
1007   return 0;
1008 }
1009
1010 /* Same as guestfs___recv, but it discards the reply message. */
1011 int
1012 guestfs___recv_discard (guestfs_h *g, const char *fn)
1013 {
1014   void *buf;
1015   uint32_t size;
1016   int r;
1017
1018  again:
1019   r = guestfs___recv_from_daemon (g, &size, &buf);
1020   if (r == -1)
1021     return -1;
1022
1023   /* This can happen if a cancellation happens right at the end
1024    * of us sending a FileIn parameter to the daemon.  Discard.  The
1025    * daemon should send us an error message next.
1026    */
1027   if (size == GUESTFS_CANCEL_FLAG)
1028     goto again;
1029
1030   if (size == GUESTFS_LAUNCH_FLAG) {
1031     error (g, "%s: received unexpected launch flag from daemon when expecting reply", fn);
1032     return -1;
1033   }
1034
1035   return 0;
1036 }
1037
1038 /* Receive a file. */
1039
1040 /* Returns -1 = error, 0 = EOF, > 0 = more data */
1041 static ssize_t receive_file_data (guestfs_h *g, void **buf);
1042
1043 int
1044 guestfs___recv_file (guestfs_h *g, const char *filename)
1045 {
1046   void *buf;
1047   int fd, r;
1048
1049   fd = open (filename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY, 0666);
1050   if (fd == -1) {
1051     perrorf (g, "open: %s", filename);
1052     goto cancel;
1053   }
1054
1055   /* Receive the file in chunked encoding. */
1056   while ((r = receive_file_data (g, &buf)) > 0) {
1057     if (xwrite (fd, buf, r) == -1) {
1058       perrorf (g, "%s: write", filename);
1059       free (buf);
1060       goto cancel;
1061     }
1062     free (buf);
1063   }
1064
1065   if (r == -1) {
1066     error (g, _("%s: error in chunked encoding"), filename);
1067     return -1;
1068   }
1069
1070   if (close (fd) == -1) {
1071     perrorf (g, "close: %s", filename);
1072     return -1;
1073   }
1074
1075   return 0;
1076
1077  cancel: ;
1078   /* Send cancellation message to daemon, then wait until it
1079    * cancels (just throwing away data).
1080    */
1081   XDR xdr;
1082   char fbuf[4];
1083   uint32_t flag = GUESTFS_CANCEL_FLAG;
1084
1085   if (g->verbose)
1086     fprintf (stderr, "%s: waiting for daemon to acknowledge cancellation\n",
1087              __func__);
1088
1089   xdrmem_create (&xdr, fbuf, sizeof fbuf, XDR_ENCODE);
1090   xdr_uint32_t (&xdr, &flag);
1091   xdr_destroy (&xdr);
1092
1093   if (xwrite (g->sock, fbuf, sizeof fbuf) == -1) {
1094     perrorf (g, _("write to daemon socket"));
1095     return -1;
1096   }
1097
1098   while (receive_file_data (g, NULL) > 0)
1099     ;                           /* just discard it */
1100
1101   return -1;
1102 }
1103
1104 /* Receive a chunk of file data. */
1105 /* Returns -1 = error, 0 = EOF, > 0 = more data */
1106 static ssize_t
1107 receive_file_data (guestfs_h *g, void **buf_r)
1108 {
1109   int r;
1110   void *buf;
1111   uint32_t len;
1112   XDR xdr;
1113   guestfs_chunk chunk;
1114
1115   r = guestfs___recv_from_daemon (g, &len, &buf);
1116   if (r == -1) {
1117     error (g, _("receive_file_data: parse error in reply callback"));
1118     return -1;
1119   }
1120
1121   if (len == GUESTFS_LAUNCH_FLAG || len == GUESTFS_CANCEL_FLAG) {
1122     error (g, _("receive_file_data: unexpected flag received when reading file chunks"));
1123     return -1;
1124   }
1125
1126   memset (&chunk, 0, sizeof chunk);
1127
1128   xdrmem_create (&xdr, buf, len, XDR_DECODE);
1129   if (!xdr_guestfs_chunk (&xdr, &chunk)) {
1130     error (g, _("failed to parse file chunk"));
1131     free (buf);
1132     return -1;
1133   }
1134   xdr_destroy (&xdr);
1135   /* After decoding, the original buffer is no longer used. */
1136   free (buf);
1137
1138   if (chunk.cancel) {
1139     error (g, _("file receive cancelled by daemon"));
1140     free (chunk.data.data_val);
1141     return -1;
1142   }
1143
1144   if (chunk.data.data_len == 0) { /* end of transfer */
1145     free (chunk.data.data_val);
1146     return 0;
1147   }
1148
1149   if (buf_r) *buf_r = chunk.data.data_val;
1150   else free (chunk.data.data_val); /* else caller frees */
1151
1152   return chunk.data.data_len;
1153 }