src/guestfs.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 #ifdef HAVE_GETTEXT
  74 #include "gettext.h"
  75 #define _(str) dgettext(PACKAGE, (str))
  76 //#define N_(str) dgettext(PACKAGE, (str))
  77 #else
  78 #define _(str) str
  79 //#define N_(str) str
  80 #endif
  81
  82 #define error guestfs_error
  83 #define perrorf guestfs_perrorf
  84 #define safe_malloc guestfs_safe_malloc
  85 #define safe_realloc guestfs_safe_realloc
  86 #define safe_strdup guestfs_safe_strdup
  87 //#define safe_memdup guestfs_safe_memdup
  88
  89 #ifdef __linux__
  90 #define CAN_CHECK_PEER_EUID 1
  91 #else
  92 #define CAN_CHECK_PEER_EUID 0
  93 #endif
  94
  95 static void default_error_cb (guestfs_h *g, void *data, const char *msg);
  96 static int send_to_daemon (guestfs_h *g, const void *v_buf, size_t n);
  97 static int recv_from_daemon (guestfs_h *g, uint32_t *size_rtn, void **buf_rtn);
  98 static int accept_from_daemon (guestfs_h *g);
  99 static int check_peer_euid (guestfs_h *g, int sock, uid_t *rtn);
 100 static void close_handles (void);
 101 static int qemu_supports (guestfs_h *g, const char *option);
 102
 103 #define UNIX_PATH_MAX 108
 104
 105 #ifndef MAX
 106 #define MAX(a,b) ((a)>(b)?(a):(b))
 107 #endif
 108
 109 #ifdef __APPLE__
 110 #define xdr_uint32_t xdr_u_int32_t
 111 #endif
 112
 113 /* Network configuration of the appliance.  Note these addresses are
 114  * only meaningful within the context of the running appliance.  QEMU
 115  * translates network connections to these magic addresses into
 116  * userspace calls on the host (eg. connect(2)).  qemu-doc has a nice
 117  * diagram which is also useful to refer to.
 118  *
 119  * NETWORK: The network.
 120  *
 121  * ROUTER: The address of the "host", ie. this library.
 122  *
 123  * [Note: If you change NETWORK and ROUTER then you also have to
 124  * change the network configuration in appliance/init].
 125  *
 126  * GUESTFWD_ADDR, GUESTFWD_PORT: The guestfwd feature of qemu
 127  * magically connects this pseudo-address to the guestfwd channel.  In
 128  * typical Linux configurations of libguestfs, guestfwd is not
 129  * actually used any more.
 130  */
 131 #define NETWORK "169.254.0.0/16"
 132 #define ROUTER "169.254.2.2"
 133 #define GUESTFWD_ADDR "169.254.2.4"
 134 #define GUESTFWD_PORT "6666"
 135
 136 /* GuestFS handle and connection. */
 137 enum state { CONFIG, LAUNCHING, READY, BUSY, NO_HANDLE };
 138
 139 struct guestfs_h
 140 {
 141   struct guestfs_h *next;       /* Linked list of open handles. */
 142
 143   /* State: see the state machine diagram in the man page guestfs(3). */
 144   enum state state;
 145
 146   int fd[2];                    /* Stdin/stdout of qemu. */
 147   int sock;                     /* Daemon communications socket. */
 148   pid_t pid;                    /* Qemu PID. */
 149   pid_t recoverypid;            /* Recovery process PID. */
 150
 151   struct timeval launch_t;      /* The time that we called guestfs_launch. */
 152
 153   char *tmpdir;                 /* Temporary directory containing socket. */
 154
 155   char *qemu_help, *qemu_version; /* Output of qemu -help, qemu -version. */
 156
 157   char **cmdline;               /* Qemu command line. */
 158   int cmdline_size;
 159
 160   int verbose;
 161   int trace;
 162   int autosync;
 163   int direct;
 164   int recovery_proc;
 165
 166   char *path;                   /* Path to kernel, initrd. */
 167   char *qemu;                   /* Qemu binary. */
 168   char *append;                 /* Append to kernel command line. */
 169
 170   int memsize;                  /* Size of RAM (megabytes). */
 171
 172   int selinux;                  /* selinux enabled? */
 173
 174   char *last_error;
 175
 176   /* Callbacks. */
 177   guestfs_abort_cb           abort_cb;
 178   guestfs_error_handler_cb   error_cb;
 179   void *                     error_cb_data;
 180   guestfs_log_message_cb     log_message_cb;
 181   void *                     log_message_cb_data;
 182   guestfs_subprocess_quit_cb subprocess_quit_cb;
 183   void *                     subprocess_quit_cb_data;
 184   guestfs_launch_done_cb     launch_done_cb;
 185   void *                     launch_done_cb_data;
 186   guestfs_close_cb           close_cb;
 187   void *                     close_cb_data;
 188
 189   int msg_next_serial;
 190 };
 191
 192 gl_lock_define_initialized (static, handles_lock);
 193 static guestfs_h *handles = NULL;
 194 static int atexit_handler_set = 0;
 195
 196 guestfs_h *
 197 guestfs_create (void)
 198 {
 199   guestfs_h *g;
 200   const char *str;
 201
 202   g = malloc (sizeof (*g));
 203   if (!g) return NULL;
 204
 205   memset (g, 0, sizeof (*g));
 206
 207   g->state = CONFIG;
 208
 209   g->fd[0] = -1;
 210   g->fd[1] = -1;
 211   g->sock = -1;
 212
 213   g->abort_cb = abort;
 214   g->error_cb = default_error_cb;
 215   g->error_cb_data = NULL;
 216
 217   g->recovery_proc = 1;
 218
 219   str = getenv ("LIBGUESTFS_DEBUG");
 220   g->verbose = str != NULL && STREQ (str, "1");
 221
 222   str = getenv ("LIBGUESTFS_TRACE");
 223   g->trace = str != NULL && STREQ (str, "1");
 224
 225   str = getenv ("LIBGUESTFS_PATH");
 226   g->path = str != NULL ? strdup (str) : strdup (GUESTFS_DEFAULT_PATH);
 227   if (!g->path) goto error;
 228
 229   str = getenv ("LIBGUESTFS_QEMU");
 230   g->qemu = str != NULL ? strdup (str) : strdup (QEMU);
 231   if (!g->qemu) goto error;
 232
 233   str = getenv ("LIBGUESTFS_APPEND");
 234   if (str) {
 235     g->append = strdup (str);
 236     if (!g->append) goto error;
 237   }
 238
 239   /* Choose a suitable memory size.  Previously we tried to choose
 240    * a minimal memory size, but this isn't really necessary since
 241    * recent QEMU and KVM don't do anything nasty like locking
 242    * memory into core any more.  Thus we can safely choose a
 243    * large, generous amount of memory, and it'll just get swapped
 244    * on smaller systems.
 245    */
 246   str = getenv ("LIBGUESTFS_MEMSIZE");
 247   if (str) {
 248     if (sscanf (str, "%d", &g->memsize) != 1 || g->memsize <= 256) {
 249       fprintf (stderr, "libguestfs: non-numeric or too small value for LIBGUESTFS_MEMSIZE\n");
 250       goto error;
 251     }
 252   } else
 253     g->memsize = 500;
 254
 255   /* Start with large serial numbers so they are easy to spot
 256    * inside the protocol.
 257    */
 258   g->msg_next_serial = 0x00123400;
 259
 260   /* Link the handles onto a global list. */
 261   gl_lock_lock (handles_lock);
 262   g->next = handles;
 263   handles = g;
 264   if (!atexit_handler_set) {
 265     atexit (close_handles);
 266     atexit_handler_set = 1;
 267   }
 268   gl_lock_unlock (handles_lock);
 269
 270   if (g->verbose)
 271     fprintf (stderr, "new guestfs handle %p\n", g);
 272
 273   return g;
 274
 275  error:
 276   free (g->path);
 277   free (g->qemu);
 278   free (g->append);
 279   free (g);
 280   return NULL;
 281 }
 282
 283 void
 284 guestfs_close (guestfs_h *g)
 285 {
 286   int i;
 287   char filename[256];
 288   guestfs_h *gg;
 289
 290   if (g->state == NO_HANDLE) {
 291     /* Not safe to call 'error' here, so ... */
 292     fprintf (stderr, _("guestfs_close: called twice on the same handle\n"));
 293     return;
 294   }
 295
 296   if (g->verbose)
 297     fprintf (stderr, "closing guestfs handle %p (state %d)\n", g, g->state);
 298
 299   /* Run user close callback before anything else. */
 300   if (g->close_cb)
 301     g->close_cb (g, g->close_cb_data);
 302
 303   /* Try to sync if autosync flag is set. */
 304   if (g->autosync && g->state == READY) {
 305     guestfs_umount_all (g);
 306     guestfs_sync (g);
 307   }
 308
 309   /* Remove any handlers that might be called back before we kill the
 310    * subprocess.
 311    */
 312   g->log_message_cb = NULL;
 313
 314   if (g->state != CONFIG)
 315     guestfs_kill_subprocess (g);
 316
 317   /* Close sockets. */
 318   if (g->fd[0] >= 0)
 319     close (g->fd[0]);
 320   if (g->fd[1] >= 0)
 321     close (g->fd[1]);
 322   if (g->sock >= 0)
 323     close (g->sock);
 324   g->fd[0] = -1;
 325   g->fd[1] = -1;
 326   g->sock = -1;
 327
 328   /* Wait for subprocess(es) to exit. */
 329   waitpid (g->pid, NULL, 0);
 330   if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0);
 331
 332   /* Remove tmpfiles. */
 333   if (g->tmpdir) {
 334     snprintf (filename, sizeof filename, "%s/sock", g->tmpdir);
 335     unlink (filename);
 336
 337     snprintf (filename, sizeof filename, "%s/initrd", g->tmpdir);
 338     unlink (filename);
 339
 340     snprintf (filename, sizeof filename, "%s/kernel", g->tmpdir);
 341     unlink (filename);
 342
 343     rmdir (g->tmpdir);
 344
 345     free (g->tmpdir);
 346   }
 347
 348   if (g->cmdline) {
 349     for (i = 0; i < g->cmdline_size; ++i)
 350       free (g->cmdline[i]);
 351     free (g->cmdline);
 352   }
 353
 354   /* Mark the handle as dead before freeing it. */
 355   g->state = NO_HANDLE;
 356
 357   gl_lock_lock (handles_lock);
 358   if (handles == g)
 359     handles = g->next;
 360   else {
 361     for (gg = handles; gg->next != g; gg = gg->next)
 362       ;
 363     gg->next = g->next;
 364   }
 365   gl_lock_unlock (handles_lock);
 366
 367   free (g->last_error);
 368   free (g->path);
 369   free (g->qemu);
 370   free (g->append);
 371   free (g->qemu_help);
 372   free (g->qemu_version);
 373   free (g);
 374 }
 375
 376 /* Close all open handles (called from atexit(3)). */
 377 static void
 378 close_handles (void)
 379 {
 380   while (handles) guestfs_close (handles);
 381 }
 382
 383 const char *
 384 guestfs_last_error (guestfs_h *g)
 385 {
 386   return g->last_error;
 387 }
 388
 389 static void
 390 set_last_error (guestfs_h *g, const char *msg)
 391 {
 392   free (g->last_error);
 393   g->last_error = strdup (msg);
 394 }
 395
 396 static void
 397 default_error_cb (guestfs_h *g, void *data, const char *msg)
 398 {
 399   fprintf (stderr, _("libguestfs: error: %s\n"), msg);
 400 }
 401
 402 void
 403 guestfs_error (guestfs_h *g, const char *fs, ...)
 404 {
 405   va_list args;
 406   char *msg;
 407
 408   va_start (args, fs);
 409   int err = vasprintf (&msg, fs, args);
 410   va_end (args);
 411
 412   if (err < 0) return;
 413
 414   if (g->error_cb) g->error_cb (g, g->error_cb_data, msg);
 415   set_last_error (g, msg);
 416
 417   free (msg);
 418 }
 419
 420 void
 421 guestfs_perrorf (guestfs_h *g, const char *fs, ...)
 422 {
 423   va_list args;
 424   char *msg;
 425   int errnum = errno;
 426
 427   va_start (args, fs);
 428   int err = vasprintf (&msg, fs, args);
 429   va_end (args);
 430
 431   if (err < 0) return;
 432
 433 #if !defined(_GNU_SOURCE) || defined(__APPLE__)
 434   char buf[256];
 435   strerror_r (errnum, buf, sizeof buf);
 436 #else
 437   char _buf[256];
 438   char *buf;
 439   buf = strerror_r (errnum, _buf, sizeof _buf);
 440 #endif
 441
 442   msg = safe_realloc (g, msg, strlen (msg) + 2 + strlen (buf) + 1);
 443   strcat (msg, ": ");
 444   strcat (msg, buf);
 445
 446   if (g->error_cb) g->error_cb (g, g->error_cb_data, msg);
 447   set_last_error (g, msg);
 448
 449   free (msg);
 450 }
 451
 452 void *
 453 guestfs_safe_malloc (guestfs_h *g, size_t nbytes)
 454 {
 455   void *ptr = malloc (nbytes);
 456   if (nbytes > 0 && !ptr) g->abort_cb ();
 457   return ptr;
 458 }
 459
 460 /* Return 1 if an array of N objects, each of size S, cannot exist due
 461    to size arithmetic overflow.  S must be positive and N must be
 462    nonnegative.  This is a macro, not an inline function, so that it
 463    works correctly even when SIZE_MAX < N.
 464
 465    By gnulib convention, SIZE_MAX represents overflow in size
 466    calculations, so the conservative dividend to use here is
 467    SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value.
 468    However, malloc (SIZE_MAX) fails on all known hosts where
 469    sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for
 470    exactly-SIZE_MAX allocations on such hosts; this avoids a test and
 471    branch when S is known to be 1.  */
 472 # define xalloc_oversized(n, s) \
 473     ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n))
 474
 475 /* Technically we should add an autoconf test for this, testing for the desired
 476    functionality, like what's done in gnulib, but for now, this is fine.  */
 477 #if defined(__GLIBC__)
 478 #define HAVE_GNU_CALLOC (__GLIBC__ >= 2)
 479 #else
 480 #define HAVE_GNU_CALLOC 0
 481 #endif
 482
 483 /* Allocate zeroed memory for N elements of S bytes, with error
 484    checking.  S must be nonzero.  */
 485 void *
 486 guestfs_safe_calloc (guestfs_h *g, size_t n, size_t s)
 487 {
 488   /* From gnulib's calloc function in xmalloc.c.  */
 489   void *p;
 490   /* Test for overflow, since some calloc implementations don't have
 491      proper overflow checks.  But omit overflow and size-zero tests if
 492      HAVE_GNU_CALLOC, since GNU calloc catches overflow and never
 493      returns NULL if successful.  */
 494   if ((! HAVE_GNU_CALLOC && xalloc_oversized (n, s))
 495       || (! (p = calloc (n, s)) && (HAVE_GNU_CALLOC || n != 0)))
 496     g->abort_cb ();
 497   return p;
 498 }
 499
 500 void *
 501 guestfs_safe_realloc (guestfs_h *g, void *ptr, int nbytes)
 502 {
 503   void *p = realloc (ptr, nbytes);
 504   if (nbytes > 0 && !p) g->abort_cb ();
 505   return p;
 506 }
 507
 508 char *
 509 guestfs_safe_strdup (guestfs_h *g, const char *str)
 510 {
 511   char *s = strdup (str);
 512   if (!s) g->abort_cb ();
 513   return s;
 514 }
 515
 516 void *
 517 guestfs_safe_memdup (guestfs_h *g, void *ptr, size_t size)
 518 {
 519   void *p = malloc (size);
 520   if (!p) g->abort_cb ();
 521   memcpy (p, ptr, size);
 522   return p;
 523 }
 524
 525 static int
 526 xwrite (int fd, const void *v_buf, size_t len)
 527 {
 528   const char *buf = v_buf;
 529   int r;
 530
 531   while (len > 0) {
 532     r = write (fd, buf, len);
 533     if (r == -1)
 534       return -1;
 535
 536     buf += r;
 537     len -= r;
 538   }
 539
 540   return 0;
 541 }
 542
 543 void
 544 guestfs_set_out_of_memory_handler (guestfs_h *g, guestfs_abort_cb cb)
 545 {
 546   g->abort_cb = cb;
 547 }
 548
 549 guestfs_abort_cb
 550 guestfs_get_out_of_memory_handler (guestfs_h *g)
 551 {
 552   return g->abort_cb;
 553 }
 554
 555 void
 556 guestfs_set_error_handler (guestfs_h *g, guestfs_error_handler_cb cb, void *data)
 557 {
 558   g->error_cb = cb;
 559   g->error_cb_data = data;
 560 }
 561
 562 guestfs_error_handler_cb
 563 guestfs_get_error_handler (guestfs_h *g, void **data_rtn)
 564 {
 565   if (data_rtn) *data_rtn = g->error_cb_data;
 566   return g->error_cb;
 567 }
 568
 569 int
 570 guestfs__set_verbose (guestfs_h *g, int v)
 571 {
 572   g->verbose = !!v;
 573   return 0;
 574 }
 575
 576 int
 577 guestfs__get_verbose (guestfs_h *g)
 578 {
 579   return g->verbose;
 580 }
 581
 582 int
 583 guestfs__set_autosync (guestfs_h *g, int a)
 584 {
 585   g->autosync = !!a;
 586   return 0;
 587 }
 588
 589 int
 590 guestfs__get_autosync (guestfs_h *g)
 591 {
 592   return g->autosync;
 593 }
 594
 595 int
 596 guestfs__set_path (guestfs_h *g, const char *path)
 597 {
 598   free (g->path);
 599   g->path = NULL;
 600
 601   g->path =
 602     path == NULL ?
 603     safe_strdup (g, GUESTFS_DEFAULT_PATH) : safe_strdup (g, path);
 604   return 0;
 605 }
 606
 607 const char *
 608 guestfs__get_path (guestfs_h *g)
 609 {
 610   return g->path;
 611 }
 612
 613 int
 614 guestfs__set_qemu (guestfs_h *g, const char *qemu)
 615 {
 616   free (g->qemu);
 617   g->qemu = NULL;
 618
 619   g->qemu = qemu == NULL ? safe_strdup (g, QEMU) : safe_strdup (g, qemu);
 620   return 0;
 621 }
 622
 623 const char *
 624 guestfs__get_qemu (guestfs_h *g)
 625 {
 626   return g->qemu;
 627 }
 628
 629 int
 630 guestfs__set_append (guestfs_h *g, const char *append)
 631 {
 632   free (g->append);
 633   g->append = NULL;
 634
 635   g->append = append ? safe_strdup (g, append) : NULL;
 636   return 0;
 637 }
 638
 639 const char *
 640 guestfs__get_append (guestfs_h *g)
 641 {
 642   return g->append;
 643 }
 644
 645 int
 646 guestfs__set_memsize (guestfs_h *g, int memsize)
 647 {
 648   g->memsize = memsize;
 649   return 0;
 650 }
 651
 652 int
 653 guestfs__get_memsize (guestfs_h *g)
 654 {
 655   return g->memsize;
 656 }
 657
 658 int
 659 guestfs__set_selinux (guestfs_h *g, int selinux)
 660 {
 661   g->selinux = selinux;
 662   return 0;
 663 }
 664
 665 int
 666 guestfs__get_selinux (guestfs_h *g)
 667 {
 668   return g->selinux;
 669 }
 670
 671 int
 672 guestfs__get_pid (guestfs_h *g)
 673 {
 674   if (g->pid > 0)
 675     return g->pid;
 676   else {
 677     error (g, "get_pid: no qemu subprocess");
 678     return -1;
 679   }
 680 }
 681
 682 struct guestfs_version *
 683 guestfs__version (guestfs_h *g)
 684 {
 685   struct guestfs_version *r;
 686
 687   r = safe_malloc (g, sizeof *r);
 688   r->major = PACKAGE_VERSION_MAJOR;
 689   r->minor = PACKAGE_VERSION_MINOR;
 690   r->release = PACKAGE_VERSION_RELEASE;
 691   r->extra = safe_strdup (g, PACKAGE_VERSION_EXTRA);
 692   return r;
 693 }
 694
 695 int
 696 guestfs__set_trace (guestfs_h *g, int t)
 697 {
 698   g->trace = !!t;
 699   return 0;
 700 }
 701
 702 int
 703 guestfs__get_trace (guestfs_h *g)
 704 {
 705   return g->trace;
 706 }
 707
 708 int
 709 guestfs__set_direct (guestfs_h *g, int d)
 710 {
 711   g->direct = !!d;
 712   return 0;
 713 }
 714
 715 int
 716 guestfs__get_direct (guestfs_h *g)
 717 {
 718   return g->direct;
 719 }
 720
 721 int
 722 guestfs__set_recovery_proc (guestfs_h *g, int f)
 723 {
 724   g->recovery_proc = !!f;
 725   return 0;
 726 }
 727
 728 int
 729 guestfs__get_recovery_proc (guestfs_h *g)
 730 {
 731   return g->recovery_proc;
 732 }
 733
 734 /* Add a string to the current command line. */
 735 static void
 736 incr_cmdline_size (guestfs_h *g)
 737 {
 738   if (g->cmdline == NULL) {
 739     /* g->cmdline[0] is reserved for argv[0], set in guestfs_launch. */
 740     g->cmdline_size = 1;
 741     g->cmdline = safe_malloc (g, sizeof (char *));
 742     g->cmdline[0] = NULL;
 743   }
 744
 745   g->cmdline_size++;
 746   g->cmdline = safe_realloc (g, g->cmdline, sizeof (char *) * g->cmdline_size);
 747 }
 748
 749 static int
 750 add_cmdline (guestfs_h *g, const char *str)
 751 {
 752   if (g->state != CONFIG) {
 753     error (g,
 754         _("command line cannot be altered after qemu subprocess launched"));
 755     return -1;
 756   }
 757
 758   incr_cmdline_size (g);
 759   g->cmdline[g->cmdline_size-1] = safe_strdup (g, str);
 760   return 0;
 761 }
 762
 763 int
 764 guestfs__config (guestfs_h *g,
 765                  const char *qemu_param, const char *qemu_value)
 766 {
 767   if (qemu_param[0] != '-') {
 768     error (g, _("guestfs_config: parameter must begin with '-' character"));
 769     return -1;
 770   }
 771
 772   /* A bit fascist, but the user will probably break the extra
 773    * parameters that we add if they try to set any of these.
 774    */
 775   if (STREQ (qemu_param, "-kernel") ||
 776       STREQ (qemu_param, "-initrd") ||
 777       STREQ (qemu_param, "-nographic") ||
 778       STREQ (qemu_param, "-serial") ||
 779       STREQ (qemu_param, "-full-screen") ||
 780       STREQ (qemu_param, "-std-vga") ||
 781       STREQ (qemu_param, "-vnc")) {
 782     error (g, _("guestfs_config: parameter '%s' isn't allowed"), qemu_param);
 783     return -1;
 784   }
 785
 786   if (add_cmdline (g, qemu_param) != 0) return -1;
 787
 788   if (qemu_value != NULL) {
 789     if (add_cmdline (g, qemu_value) != 0) return -1;
 790   }
 791
 792   return 0;
 793 }
 794
 795 int
 796 guestfs__add_drive_with_if (guestfs_h *g, const char *filename,
 797                             const char *drive_if)
 798 {
 799   size_t len = strlen (filename) + 64;
 800   char buf[len];
 801
 802   if (strchr (filename, ',') != NULL) {
 803     error (g, _("filename cannot contain ',' (comma) character"));
 804     return -1;
 805   }
 806
 807   /* cache=off improves reliability in the event of a host crash.
 808    *
 809    * However this option causes qemu to try to open the file with
 810    * O_DIRECT.  This fails on some filesystem types (notably tmpfs).
 811    * So we check if we can open the file with or without O_DIRECT,
 812    * and use cache=off (or not) accordingly.
 813    *
 814    * This test also checks for the presence of the file, which
 815    * is a documented semantic of this interface.
 816    */
 817   int fd = open (filename, O_RDONLY|O_DIRECT);
 818   if (fd >= 0) {
 819     close (fd);
 820     snprintf (buf, len, "file=%s,cache=off,if=%s", filename, drive_if);
 821   } else {
 822     fd = open (filename, O_RDONLY);
 823     if (fd >= 0) {
 824       close (fd);
 825       snprintf (buf, len, "file=%s,if=%s", filename, drive_if);
 826     } else {
 827       perrorf (g, "%s", filename);
 828       return -1;
 829     }
 830   }
 831
 832   return guestfs__config (g, "-drive", buf);
 833 }
 834
 835 int
 836 guestfs__add_drive_ro_with_if (guestfs_h *g, const char *filename,
 837                                const char *drive_if)
 838 {
 839   if (strchr (filename, ',') != NULL) {
 840     error (g, _("filename cannot contain ',' (comma) character"));
 841     return -1;
 842   }
 843
 844   if (access (filename, F_OK) == -1) {
 845     perrorf (g, "%s", filename);
 846     return -1;
 847   }
 848
 849   size_t len = strlen (filename) + 64;
 850   char buf[len];
 851
 852   snprintf (buf, len, "file=%s,snapshot=on,if=%s", filename, drive_if);
 853
 854   return guestfs__config (g, "-drive", buf);
 855 }
 856
 857 int
 858 guestfs__add_drive (guestfs_h *g, const char *filename)
 859 {
 860   return guestfs__add_drive_with_if (g, filename, DRIVE_IF);
 861 }
 862
 863 int
 864 guestfs__add_drive_ro (guestfs_h *g, const char *filename)
 865 {
 866   return guestfs__add_drive_ro_with_if (g, filename, DRIVE_IF);
 867 }
 868
 869 int
 870 guestfs__add_cdrom (guestfs_h *g, const char *filename)
 871 {
 872   if (strchr (filename, ',') != NULL) {
 873     error (g, _("filename cannot contain ',' (comma) character"));
 874     return -1;
 875   }
 876
 877   if (access (filename, F_OK) == -1) {
 878     perrorf (g, "%s", filename);
 879     return -1;
 880   }
 881
 882   return guestfs__config (g, "-cdrom", filename);
 883 }
 884
 885 /* Returns true iff file is contained in dir. */
 886 static int
 887 dir_contains_file (const char *dir, const char *file)
 888 {
 889   int dirlen = strlen (dir);
 890   int filelen = strlen (file);
 891   int len = dirlen+filelen+2;
 892   char path[len];
 893
 894   snprintf (path, len, "%s/%s", dir, file);
 895   return access (path, F_OK) == 0;
 896 }
 897
 898 /* Returns true iff every listed file is contained in 'dir'. */
 899 static int
 900 dir_contains_files (const char *dir, ...)
 901 {
 902   va_list args;
 903   const char *file;
 904
 905   va_start (args, dir);
 906   while ((file = va_arg (args, const char *)) != NULL) {
 907     if (!dir_contains_file (dir, file)) {
 908       va_end (args);
 909       return 0;
 910     }
 911   }
 912   va_end (args);
 913   return 1;
 914 }
 915
 916 static void print_timestamped_message (guestfs_h *g, const char *fs, ...);
 917 static int build_supermin_appliance (guestfs_h *g, const char *path, char **kernel, char **initrd);
 918 static int is_openable (guestfs_h *g, const char *path, int flags);
 919 static void print_cmdline (guestfs_h *g);
 920
 921 static const char *kernel_name = "vmlinuz." REPO "." host_cpu;
 922 static const char *initrd_name = "initramfs." REPO "." host_cpu ".img";
 923
 924 int
 925 guestfs__launch (guestfs_h *g)
 926 {
 927   const char *tmpdir;
 928   char dir_template[PATH_MAX];
 929   int r, pmore;
 930   size_t len;
 931   int wfd[2], rfd[2];
 932   int tries;
 933   char *path, *pelem, *pend;
 934   char *kernel = NULL, *initrd = NULL;
 935   int null_vmchannel_sock;
 936   char unixsock[256];
 937   struct sockaddr_un addr;
 938
 939   /* Configured? */
 940   if (!g->cmdline) {
 941     error (g, _("you must call guestfs_add_drive before guestfs_launch"));
 942     return -1;
 943   }
 944
 945   if (g->state != CONFIG) {
 946     error (g, _("the libguestfs handle has already been launched"));
 947     return -1;
 948   }
 949
 950   /* Start the clock ... */
 951   gettimeofday (&g->launch_t, NULL);
 952
 953   /* Make the temporary directory. */
 954 #ifdef P_tmpdir
 955   tmpdir = P_tmpdir;
 956 #else
 957   tmpdir = "/tmp";
 958 #endif
 959
 960   tmpdir = getenv ("TMPDIR") ? : tmpdir;
 961   snprintf (dir_template, sizeof dir_template, "%s/libguestfsXXXXXX", tmpdir);
 962
 963   if (!g->tmpdir) {
 964     g->tmpdir = safe_strdup (g, dir_template);
 965     if (mkdtemp (g->tmpdir) == NULL) {
 966       perrorf (g, _("%s: cannot create temporary directory"), dir_template);
 967       goto cleanup0;
 968     }
 969   }
 970
 971   /* First search g->path for the supermin appliance, and try to
 972    * synthesize a kernel and initrd from that.  If it fails, we
 973    * try the path search again looking for a backup ordinary
 974    * appliance.
 975    */
 976   pelem = path = safe_strdup (g, g->path);
 977   do {
 978     pend = strchrnul (pelem, ':');
 979     pmore = *pend == ':';
 980     *pend = '\0';
 981     len = pend - pelem;
 982
 983     /* Empty element of "." means cwd. */
 984     if (len == 0 || (len == 1 && *pelem == '.')) {
 985       if (g->verbose)
 986         fprintf (stderr,
 987                  "looking for supermin appliance in current directory\n");
 988       if (dir_contains_files (".",
 989                               "supermin.d", "kmod.whitelist", NULL)) {
 990         if (build_supermin_appliance (g, ".", &kernel, &initrd) == -1)
 991           return -1;
 992         break;
 993       }
 994     }
 995     /* Look at <path>/supermin* etc. */
 996     else {
 997       if (g->verbose)
 998         fprintf (stderr, "looking for supermin appliance in %s\n", pelem);
 999
1000       if (dir_contains_files (pelem,
1001                               "supermin.d", "kmod.whitelist", NULL)) {
1002         if (build_supermin_appliance (g, pelem, &kernel, &initrd) == -1)
1003           return -1;
1004         break;
1005       }
1006     }
1007
1008     pelem = pend + 1;
1009   } while (pmore);
1010
1011   free (path);
1012
1013   if (kernel == NULL || initrd == NULL) {
1014     /* Search g->path for the kernel and initrd. */
1015     pelem = path = safe_strdup (g, g->path);
1016     do {
1017       pend = strchrnul (pelem, ':');
1018       pmore = *pend == ':';
1019       *pend = '\0';
1020       len = pend - pelem;
1021
1022       /* Empty element or "." means cwd. */
1023       if (len == 0 || (len == 1 && *pelem == '.')) {
1024         if (g->verbose)
1025           fprintf (stderr,
1026                    "looking for appliance in current directory\n");
1027         if (dir_contains_files (".", kernel_name, initrd_name, NULL)) {
1028           kernel = safe_strdup (g, kernel_name);
1029           initrd = safe_strdup (g, initrd_name);
1030           break;
1031         }
1032       }
1033       /* Look at <path>/kernel etc. */
1034       else {
1035         if (g->verbose)
1036           fprintf (stderr, "looking for appliance in %s\n", pelem);
1037
1038         if (dir_contains_files (pelem, kernel_name, initrd_name, NULL)) {
1039           kernel = safe_malloc (g, len + strlen (kernel_name) + 2);
1040           initrd = safe_malloc (g, len + strlen (initrd_name) + 2);
1041           sprintf (kernel, "%s/%s", pelem, kernel_name);
1042           sprintf (initrd, "%s/%s", pelem, initrd_name);
1043           break;
1044         }
1045       }
1046
1047       pelem = pend + 1;
1048     } while (pmore);
1049
1050     free (path);
1051   }
1052
1053   if (kernel == NULL || initrd == NULL) {
1054     error (g, _("cannot find %s or %s on LIBGUESTFS_PATH (current path = %s)"),
1055            kernel_name, initrd_name, g->path);
1056     goto cleanup0;
1057   }
1058
1059   if (g->verbose)
1060     print_timestamped_message (g, "begin testing qemu features");
1061
1062   /* Get qemu help text and version. */
1063   if (qemu_supports (g, NULL) == -1)
1064     goto cleanup0;
1065
1066   /* Choose which vmchannel implementation to use. */
1067   if (CAN_CHECK_PEER_EUID && qemu_supports (g, "-net user")) {
1068     /* The "null vmchannel" implementation.  Requires SLIRP (user mode
1069      * networking in qemu) but no other vmchannel support.  The daemon
1070      * will connect back to a random port number on localhost.
1071      */
1072     struct sockaddr_in addr;
1073     socklen_t addrlen = sizeof addr;
1074
1075     g->sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
1076     if (g->sock == -1) {
1077       perrorf (g, "socket");
1078       goto cleanup0;
1079     }
1080     addr.sin_family = AF_INET;
1081     addr.sin_port = htons (0);
1082     addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
1083     if (bind (g->sock, (struct sockaddr *) &addr, addrlen) == -1) {
1084       perrorf (g, "bind");
1085       goto cleanup0;
1086     }
1087
1088     if (listen (g->sock, 256) == -1) {
1089       perrorf (g, "listen");
1090       goto cleanup0;
1091     }
1092
1093     if (getsockname (g->sock, (struct sockaddr *) &addr, &addrlen) == -1) {
1094       perrorf (g, "getsockname");
1095       goto cleanup0;
1096     }
1097
1098     if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) {
1099       perrorf (g, "fcntl");
1100       goto cleanup0;
1101     }
1102
1103     null_vmchannel_sock = ntohs (addr.sin_port);
1104     if (g->verbose)
1105       fprintf (stderr, "null_vmchannel_sock = %d\n", null_vmchannel_sock);
1106   } else {
1107     /* Using some vmchannel impl.  We need to create a local Unix
1108      * domain socket for qemu to use.
1109      */
1110     snprintf (unixsock, sizeof unixsock, "%s/sock", g->tmpdir);
1111     unlink (unixsock);
1112     null_vmchannel_sock = 0;
1113   }
1114
1115   if (!g->direct) {
1116     if (pipe (wfd) == -1 || pipe (rfd) == -1) {
1117       perrorf (g, "pipe");
1118       goto cleanup0;
1119     }
1120   }
1121
1122   if (g->verbose)
1123     print_timestamped_message (g, "finished testing qemu features");
1124
1125   r = fork ();
1126   if (r == -1) {
1127     perrorf (g, "fork");
1128     if (!g->direct) {
1129       close (wfd[0]);
1130       close (wfd[1]);
1131       close (rfd[0]);
1132       close (rfd[1]);
1133     }
1134     goto cleanup0;
1135   }
1136
1137   if (r == 0) {                 /* Child (qemu). */
1138     char buf[256];
1139     const char *vmchannel = NULL;
1140
1141     /* Set up the full command line.  Do this in the subprocess so we
1142      * don't need to worry about cleaning up.
1143      */
1144     g->cmdline[0] = g->qemu;
1145
1146     /* qemu sometimes needs this option to enable hardware
1147      * virtualization, but some versions of 'qemu-kvm' will use KVM
1148      * regardless (even where this option appears in the help text).
1149      * It is rumoured that there are versions of qemu where supplying
1150      * this option when hardware virtualization is not available will
1151      * cause qemu to fail, so we we have to check at least that
1152      * /dev/kvm is openable.  That's not reliable, since /dev/kvm
1153      * might be openable by qemu but not by us (think: SELinux) in
1154      * which case the user would not get hardware virtualization,
1155      * although at least shouldn't fail.  A giant clusterfuck with the
1156      * qemu command line, again.
1157      */
1158     if (qemu_supports (g, "-enable-kvm") &&
1159         is_openable (g, "/dev/kvm", O_RDWR))
1160       add_cmdline (g, "-enable-kvm");
1161
1162     /* Newer versions of qemu (from around 2009/12) changed the
1163      * behaviour of monitors so that an implicit '-monitor stdio' is
1164      * assumed if we are in -nographic mode and there is no other
1165      * -monitor option.  Only a single stdio device is allowed, so
1166      * this broke the '-serial stdio' option.  There is a new flag
1167      * called -nodefaults which gets rid of all this default crud, so
1168      * let's use that to avoid this and any future surprises.
1169      */
1170     if (qemu_supports (g, "-nodefaults"))
1171       add_cmdline (g, "-nodefaults");
1172
1173     add_cmdline (g, "-nographic");
1174     add_cmdline (g, "-serial");
1175     add_cmdline (g, "stdio");
1176
1177     snprintf (buf, sizeof buf, "%d", g->memsize);
1178     add_cmdline (g, "-m");
1179     add_cmdline (g, buf);
1180
1181     /* Force exit instead of reboot on panic */
1182     add_cmdline (g, "-no-reboot");
1183
1184     /* These options recommended by KVM developers to improve reliability. */
1185     if (qemu_supports (g, "-no-hpet"))
1186       add_cmdline (g, "-no-hpet");
1187
1188     if (qemu_supports (g, "-rtc-td-hack"))
1189       add_cmdline (g, "-rtc-td-hack");
1190
1191     /* If qemu has SLIRP (user mode network) enabled then we can get
1192      * away with "no vmchannel", where we just connect back to a random
1193      * host port.
1194      */
1195     if (null_vmchannel_sock) {
1196       add_cmdline (g, "-net");
1197       add_cmdline (g, "user,vlan=0,net=" NETWORK);
1198
1199       snprintf (buf, sizeof buf,
1200                 "guestfs_vmchannel=tcp:" ROUTER ":%d",
1201                 null_vmchannel_sock);
1202       vmchannel = strdup (buf);
1203     }
1204
1205     /* New-style -net user,guestfwd=... syntax for guestfwd.  See:
1206      *
1207      * http://git.savannah.gnu.org/cgit/qemu.git/commit/?id=c92ef6a22d3c71538fcc48fb61ad353f7ba03b62
1208      *
1209      * The original suggested format doesn't work, see:
1210      *
1211      * http://lists.gnu.org/archive/html/qemu-devel/2009-07/msg01654.html
1212      *
1213      * However Gerd Hoffman privately suggested to me using -chardev
1214      * instead, which does work.
1215      */
1216     else if (qemu_supports (g, "-chardev") && qemu_supports (g, "guestfwd")) {
1217       snprintf (buf, sizeof buf,
1218                 "socket,id=guestfsvmc,path=%s,server,nowait", unixsock);
1219
1220       add_cmdline (g, "-chardev");
1221       add_cmdline (g, buf);
1222
1223       snprintf (buf, sizeof buf,
1224                 "user,vlan=0,net=" NETWORK ","
1225                 "guestfwd=tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT
1226                 "-chardev:guestfsvmc");
1227
1228       add_cmdline (g, "-net");
1229       add_cmdline (g, buf);
1230
1231       vmchannel = "guestfs_vmchannel=tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT;
1232     }
1233
1234     /* Not guestfwd.  HOPEFULLY this qemu uses the older -net channel
1235      * syntax, or if not then we'll get a quick failure.
1236      */
1237     else {
1238       snprintf (buf, sizeof buf,
1239                 "channel," GUESTFWD_PORT ":unix:%s,server,nowait", unixsock);
1240
1241       add_cmdline (g, "-net");
1242       add_cmdline (g, buf);
1243       add_cmdline (g, "-net");
1244       add_cmdline (g, "user,vlan=0,net=" NETWORK);
1245
1246       vmchannel = "guestfs_vmchannel=tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT;
1247     }
1248     add_cmdline (g, "-net");
1249     add_cmdline (g, "nic,model=" NET_IF ",vlan=0");
1250
1251 #define LINUX_CMDLINE                                                   \
1252     "panic=1 "         /* force kernel to panic if daemon exits */      \
1253     "console=ttyS0 "   /* serial console */                             \
1254     "udevtimeout=300 " /* good for very slow systems (RHBZ#480319) */   \
1255     "noapic "          /* workaround for RHBZ#502058 - ok if not SMP */ \
1256     "acpi=off "        /* we don't need ACPI, turn it off */            \
1257     "printk.time=1 "   /* display timestamp before kernel messages */   \
1258     "cgroup_disable=memory " /* saves us about 5 MB of RAM */
1259
1260     /* Linux kernel command line. */
1261     snprintf (buf, sizeof buf,
1262               LINUX_CMDLINE
1263               "%s "             /* (selinux) */
1264               "%s "             /* (vmchannel) */
1265               "%s "             /* (verbose) */
1266               "TERM=%s "        /* (TERM environment variable) */
1267               "%s",             /* (append) */
1268               g->selinux ? "selinux=1 enforcing=0" : "selinux=0",
1269               vmchannel ? vmchannel : "",
1270               g->verbose ? "guestfs_verbose=1" : "",
1271               getenv ("TERM") ? : "linux",
1272               g->append ? g->append : "");
1273
1274     add_cmdline (g, "-kernel");
1275     add_cmdline (g, (char *) kernel);
1276     add_cmdline (g, "-initrd");
1277     add_cmdline (g, (char *) initrd);
1278     add_cmdline (g, "-append");
1279     add_cmdline (g, buf);
1280
1281     /* Finish off the command line. */
1282     incr_cmdline_size (g);
1283     g->cmdline[g->cmdline_size-1] = NULL;
1284
1285     if (g->verbose)
1286       print_cmdline (g);
1287
1288     if (!g->direct) {
1289       /* Set up stdin, stdout. */
1290       close (0);
1291       close (1);
1292       close (wfd[1]);
1293       close (rfd[0]);
1294
1295       if (dup (wfd[0]) == -1) {
1296       dup_failed:
1297         perror ("dup failed");
1298         _exit (EXIT_FAILURE);
1299       }
1300       if (dup (rfd[1]) == -1)
1301         goto dup_failed;
1302
1303       close (wfd[0]);
1304       close (rfd[1]);
1305     }
1306
1307 #if 0
1308     /* Set up a new process group, so we can signal this process
1309      * and all subprocesses (eg. if qemu is really a shell script).
1310      */
1311     setpgid (0, 0);
1312 #endif
1313
1314     setenv ("LC_ALL", "C", 1);
1315
1316     execv (g->qemu, g->cmdline); /* Run qemu. */
1317     perror (g->qemu);
1318     _exit (EXIT_FAILURE);
1319   }
1320
1321   /* Parent (library). */
1322   g->pid = r;
1323
1324   free (kernel);
1325   kernel = NULL;
1326   free (initrd);
1327   initrd = NULL;
1328
1329   /* Fork the recovery process off which will kill qemu if the parent
1330    * process fails to do so (eg. if the parent segfaults).
1331    */
1332   g->recoverypid = -1;
1333   if (g->recovery_proc) {
1334     r = fork ();
1335     if (r == 0) {
1336       pid_t qemu_pid = g->pid;
1337       pid_t parent_pid = getppid ();
1338
1339       /* Writing to argv is hideously complicated and error prone.  See:
1340        * http://anoncvs.postgresql.org/cvsweb.cgi/pgsql/src/backend/utils/misc/ps_status.c?rev=1.33.2.1;content-type=text%2Fplain
1341        */
1342
1343       /* Loop around waiting for one or both of the other processes to
1344        * disappear.  It's fair to say this is very hairy.  The PIDs that
1345        * we are looking at might be reused by another process.  We are
1346        * effectively polling.  Is the cure worse than the disease?
1347        */
1348       for (;;) {
1349         if (kill (qemu_pid, 0) == -1) /* qemu's gone away, we aren't needed */
1350           _exit (EXIT_SUCCESS);
1351         if (kill (parent_pid, 0) == -1) {
1352           /* Parent's gone away, qemu still around, so kill qemu. */
1353           kill (qemu_pid, 9);
1354           _exit (EXIT_SUCCESS);
1355         }
1356         sleep (2);
1357       }
1358     }
1359
1360     /* Don't worry, if the fork failed, this will be -1.  The recovery
1361      * process isn't essential.
1362      */
1363     g->recoverypid = r;
1364   }
1365
1366   if (!g->direct) {
1367     /* Close the other ends of the pipe. */
1368     close (wfd[0]);
1369     close (rfd[1]);
1370
1371     if (fcntl (wfd[1], F_SETFL, O_NONBLOCK) == -1 ||
1372         fcntl (rfd[0], F_SETFL, O_NONBLOCK) == -1) {
1373       perrorf (g, "fcntl");
1374       goto cleanup1;
1375     }
1376
1377     g->fd[0] = wfd[1];          /* stdin of child */
1378     g->fd[1] = rfd[0];          /* stdout of child */
1379   } else {
1380     g->fd[0] = open ("/dev/null", O_RDWR);
1381     if (g->fd[0] == -1) {
1382       perrorf (g, "open /dev/null");
1383       goto cleanup1;
1384     }
1385     g->fd[1] = dup (g->fd[0]);
1386     if (g->fd[1] == -1) {
1387       perrorf (g, "dup");
1388       close (g->fd[0]);
1389       goto cleanup1;
1390     }
1391   }
1392
1393   if (null_vmchannel_sock) {
1394     int sock = -1;
1395     uid_t uid;
1396
1397     /* Null vmchannel implementation: We listen on g->sock for a
1398      * connection.  The connection could come from any local process
1399      * so we must check it comes from the appliance (or at least
1400      * from our UID) for security reasons.
1401      */
1402     while (sock == -1) {
1403       sock = accept_from_daemon (g);
1404       if (sock == -1)
1405         goto cleanup1;
1406
1407       if (check_peer_euid (g, sock, &uid) == -1)
1408         goto cleanup1;
1409       if (uid != geteuid ()) {
1410         fprintf (stderr,
1411                  "libguestfs: warning: unexpected connection from UID %d to port %d\n",
1412                  uid, null_vmchannel_sock);
1413         close (sock);
1414         sock = -1;
1415         continue;
1416       }
1417     }
1418
1419     if (fcntl (sock, F_SETFL, O_NONBLOCK) == -1) {
1420       perrorf (g, "fcntl");
1421       goto cleanup1;
1422     }
1423
1424     close (g->sock);
1425     g->sock = sock;
1426   } else {
1427     /* Other vmchannel.  Open the Unix socket.
1428      *
1429      * The vmchannel implementation that got merged with qemu sucks in
1430      * a number of ways.  Both ends do connect(2), which means that no
1431      * one knows what, if anything, is connected to the other end, or
1432      * if it becomes disconnected.  Even worse, we have to wait some
1433      * indeterminate time for qemu to create the socket and connect to
1434      * it (which happens very early in qemu's start-up), so any code
1435      * that uses vmchannel is inherently racy.  Hence this silly loop.
1436      */
1437     g->sock = socket (AF_UNIX, SOCK_STREAM, 0);
1438     if (g->sock == -1) {
1439       perrorf (g, "socket");
1440       goto cleanup1;
1441     }
1442
1443     if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) {
1444       perrorf (g, "fcntl");
1445       goto cleanup1;
1446     }
1447
1448     addr.sun_family = AF_UNIX;
1449     strncpy (addr.sun_path, unixsock, UNIX_PATH_MAX);
1450     addr.sun_path[UNIX_PATH_MAX-1] = '\0';
1451
1452     tries = 100;
1453     /* Always sleep at least once to give qemu a small chance to start up. */
1454     usleep (10000);
1455     while (tries > 0) {
1456       r = connect (g->sock, (struct sockaddr *) &addr, sizeof addr);
1457       if ((r == -1 && errno == EINPROGRESS) || r == 0)
1458         goto connected;
1459
1460       if (errno != ENOENT)
1461         perrorf (g, "connect");
1462       tries--;
1463       usleep (100000);
1464     }
1465
1466     error (g, _("failed to connect to vmchannel socket"));
1467     goto cleanup1;
1468
1469   connected: ;
1470   }
1471
1472   g->state = LAUNCHING;
1473
1474   /* Wait for qemu to start and to connect back to us via vmchannel and
1475    * send the GUESTFS_LAUNCH_FLAG message.
1476    */
1477   uint32_t size;
1478   void *buf = NULL;
1479   r = recv_from_daemon (g, &size, &buf);
1480   free (buf);
1481
1482   if (r == -1) return -1;
1483
1484   if (size != GUESTFS_LAUNCH_FLAG) {
1485     error (g, _("guestfs_launch failed, see earlier error messages"));
1486     goto cleanup1;
1487   }
1488
1489   if (g->verbose)
1490     print_timestamped_message (g, "appliance is up");
1491
1492   /* This is possible in some really strange situations, such as
1493    * guestfsd starts up OK but then qemu immediately exits.  Check for
1494    * it because the caller is probably expecting to be able to send
1495    * commands after this function returns.
1496    */
1497   if (g->state != READY) {
1498     error (g, _("qemu launched and contacted daemon, but state != READY"));
1499     goto cleanup1;
1500   }
1501
1502   return 0;
1503
1504  cleanup1:
1505   if (!g->direct) {
1506     close (wfd[1]);
1507     close (rfd[0]);
1508   }
1509   if (g->pid > 0) kill (g->pid, 9);
1510   if (g->recoverypid > 0) kill (g->recoverypid, 9);
1511   waitpid (g->pid, NULL, 0);
1512   if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0);
1513   g->fd[0] = -1;
1514   g->fd[1] = -1;
1515   g->pid = 0;
1516   g->recoverypid = 0;
1517   memset (&g->launch_t, 0, sizeof g->launch_t);
1518
1519  cleanup0:
1520   if (g->sock >= 0) {
1521     close (g->sock);
1522     g->sock = -1;
1523   }
1524   g->state = CONFIG;
1525   free (kernel);
1526   free (initrd);
1527   return -1;
1528 }
1529
1530 /* This function is used to print the qemu command line before it gets
1531  * executed, when in verbose mode.
1532  */
1533 static void
1534 print_cmdline (guestfs_h *g)
1535 {
1536   int i = 0;
1537   int needs_quote;
1538
1539   while (g->cmdline[i]) {
1540     if (g->cmdline[i][0] == '-') /* -option starts a new line */
1541       fprintf (stderr, " \\\n   ");
1542
1543     if (i > 0) fputc (' ', stderr);
1544
1545     /* Does it need shell quoting?  This only deals with simple cases. */
1546     needs_quote = strcspn (g->cmdline[i], " ") != strlen (g->cmdline[i]);
1547
1548     if (needs_quote) fputc ('\'', stderr);
1549     fprintf (stderr, "%s", g->cmdline[i]);
1550     if (needs_quote) fputc ('\'', stderr);
1551     i++;
1552   }
1553
1554   fputc ('\n', stderr);
1555 }
1556
1557 /* This function does the hard work of building the supermin appliance
1558  * on the fly.  'path' is the directory containing the control files.
1559  * 'kernel' and 'initrd' are where we will return the names of the
1560  * kernel and initrd (only initrd is built).  The work is done by
1561  * an external script.  We just tell it where to put the result.
1562  */
1563 static int
1564 build_supermin_appliance (guestfs_h *g, const char *path,
1565                           char **kernel, char **initrd)
1566 {
1567   char cmd[4096];
1568   int r, len;
1569
1570   if (g->verbose)
1571     print_timestamped_message (g, "begin building supermin appliance");
1572
1573   len = strlen (g->tmpdir);
1574   *kernel = safe_malloc (g, len + 8);
1575   snprintf (*kernel, len+8, "%s/kernel", g->tmpdir);
1576   *initrd = safe_malloc (g, len + 8);
1577   snprintf (*initrd, len+8, "%s/initrd", g->tmpdir);
1578
1579   snprintf (cmd, sizeof cmd,
1580             "febootstrap-supermin-helper%s "
1581             "-k '%s/kmod.whitelist' "
1582             "'%s/supermin.d' "
1583             host_cpu " "
1584             "%s %s",
1585             g->verbose ? " --verbose" : "",
1586             path,
1587             path,
1588             *kernel, *initrd);
1589   if (g->verbose)
1590     print_timestamped_message (g, "%s", cmd);
1591
1592   r = system (cmd);
1593   if (r == -1 || WEXITSTATUS(r) != 0) {
1594     error (g, _("external command failed: %s"), cmd);
1595     free (*kernel);
1596     free (*initrd);
1597     *kernel = *initrd = NULL;
1598     return -1;
1599   }
1600
1601   if (g->verbose)
1602     print_timestamped_message (g, "finished building supermin appliance");
1603
1604   return 0;
1605 }
1606
1607 /* Compute Y - X and return the result in milliseconds.
1608  * Approximately the same as this code:
1609  * http://www.mpp.mpg.de/~huber/util/timevaldiff.c
1610  */
1611 static int64_t
1612 timeval_diff (const struct timeval *x, const struct timeval *y)
1613 {
1614   int64_t msec;
1615
1616   msec = (y->tv_sec - x->tv_sec) * 1000;
1617   msec += (y->tv_usec - x->tv_usec) / 1000;
1618   return msec;
1619 }
1620
1621 static void
1622 print_timestamped_message (guestfs_h *g, const char *fs, ...)
1623 {
1624   va_list args;
1625   char *msg;
1626   int err;
1627   struct timeval tv;
1628
1629   va_start (args, fs);
1630   err = vasprintf (&msg, fs, args);
1631   va_end (args);
1632
1633   if (err < 0) return;
1634
1635   gettimeofday (&tv, NULL);
1636
1637   fprintf (stderr, "[%05" PRIi64 "ms] %s\n",
1638            timeval_diff (&g->launch_t, &tv), msg);
1639
1640   free (msg);
1641 }
1642
1643 static int read_all (guestfs_h *g, FILE *fp, char **ret);
1644
1645 /* Test qemu binary (or wrapper) runs, and do 'qemu -help' and
1646  * 'qemu -version' so we know what options this qemu supports and
1647  * the version.
1648  */
1649 static int
1650 test_qemu (guestfs_h *g)
1651 {
1652   char cmd[1024];
1653   FILE *fp;
1654
1655   snprintf (cmd, sizeof cmd, "LC_ALL=C '%s' -nographic -help", g->qemu);
1656
1657   fp = popen (cmd, "r");
1658   /* qemu -help should always work (qemu -version OTOH wasn't
1659    * supported by qemu 0.9).  If this command doesn't work then it
1660    * probably indicates that the qemu binary is missing.
1661    */
1662   if (!fp) {
1663     /* XXX This error is never printed, even if the qemu binary
1664      * doesn't exist.  Why?
1665      */
1666   error:
1667     perrorf (g, _("%s: command failed: If qemu is located on a non-standard path, try setting the LIBGUESTFS_QEMU environment variable."), cmd);
1668     return -1;
1669   }
1670
1671   if (read_all (g, fp, &g->qemu_help) == -1)
1672     goto error;
1673
1674   if (pclose (fp) == -1)
1675     goto error;
1676
1677   snprintf (cmd, sizeof cmd, "LC_ALL=C '%s' -nographic -version 2>/dev/null",
1678             g->qemu);
1679
1680   fp = popen (cmd, "r");
1681   if (fp) {
1682     /* Intentionally ignore errors. */
1683     read_all (g, fp, &g->qemu_version);
1684     pclose (fp);
1685   }
1686
1687   return 0;
1688 }
1689
1690 static int
1691 read_all (guestfs_h *g, FILE *fp, char **ret)
1692 {
1693   int r, n = 0;
1694   char *p;
1695
1696  again:
1697   if (feof (fp)) {
1698     *ret = safe_realloc (g, *ret, n + 1);
1699     (*ret)[n] = '\0';
1700     return n;
1701   }
1702
1703   *ret = safe_realloc (g, *ret, n + BUFSIZ);
1704   p = &(*ret)[n];
1705   r = fread (p, 1, BUFSIZ, fp);
1706   if (ferror (fp)) {
1707     perrorf (g, "read");
1708     return -1;
1709   }
1710   n += r;
1711   goto again;
1712 }
1713
1714 /* Test if option is supported by qemu command line (just by grepping
1715  * the help text).
1716  *
1717  * The first time this is used, it has to run the external qemu
1718  * binary.  If that fails, it returns -1.
1719  *
1720  * To just do the first-time run of the qemu binary, call this with
1721  * option == NULL, in which case it will return -1 if there was an
1722  * error doing that.
1723  */
1724 static int
1725 qemu_supports (guestfs_h *g, const char *option)
1726 {
1727   if (!g->qemu_help) {
1728     if (test_qemu (g) == -1)
1729       return -1;
1730   }
1731
1732   if (option == NULL)
1733     return 1;
1734
1735   return strstr (g->qemu_help, option) != NULL;
1736 }
1737
1738 /* Check if a file can be opened. */
1739 static int
1740 is_openable (guestfs_h *g, const char *path, int flags)
1741 {
1742   int fd = open (path, flags);
1743   if (fd == -1) {
1744     if (g->verbose)
1745       perror (path);
1746     return 0;
1747   }
1748   close (fd);
1749   return 1;
1750 }
1751
1752 /* Check the peer effective UID for a TCP socket.  Ideally we'd like
1753  * SO_PEERCRED for a loopback TCP socket.  This isn't possible on
1754  * Linux (but it is on Solaris!) so we read /proc/net/tcp instead.
1755  */
1756 static int
1757 check_peer_euid (guestfs_h *g, int sock, uid_t *rtn)
1758 {
1759 #if CAN_CHECK_PEER_EUID
1760   struct sockaddr_in peer;
1761   socklen_t addrlen = sizeof peer;
1762
1763   if (getpeername (sock, (struct sockaddr *) &peer, &addrlen) == -1) {
1764     perrorf (g, "getpeername");
1765     return -1;
1766   }
1767
1768   if (peer.sin_family != AF_INET ||
1769       ntohl (peer.sin_addr.s_addr) != INADDR_LOOPBACK) {
1770     error (g, "check_peer_euid: unexpected connection from non-IPv4, non-loopback peer (family = %d, addr = %s)",
1771            peer.sin_family, inet_ntoa (peer.sin_addr));
1772     return -1;
1773   }
1774
1775   struct sockaddr_in our;
1776   addrlen = sizeof our;
1777   if (getsockname (sock, (struct sockaddr *) &our, &addrlen) == -1) {
1778     perrorf (g, "getsockname");
1779     return -1;
1780   }
1781
1782   FILE *fp = fopen ("/proc/net/tcp", "r");
1783   if (fp == NULL) {
1784     perrorf (g, "/proc/net/tcp");
1785     return -1;
1786   }
1787
1788   char line[256];
1789   if (fgets (line, sizeof line, fp) == NULL) { /* Drop first line. */
1790     error (g, "unexpected end of file in /proc/net/tcp");
1791     fclose (fp);
1792     return -1;
1793   }
1794
1795   while (fgets (line, sizeof line, fp) != NULL) {
1796     unsigned line_our_addr, line_our_port, line_peer_addr, line_peer_port;
1797     int dummy0, dummy1, dummy2, dummy3, dummy4, dummy5, dummy6;
1798     int line_uid;
1799
1800     if (sscanf (line, "%d:%08X:%04X %08X:%04X %02X %08X:%08X %02X:%08X %08X %d",
1801                 &dummy0,
1802                 &line_our_addr, &line_our_port,
1803                 &line_peer_addr, &line_peer_port,
1804                 &dummy1, &dummy2, &dummy3, &dummy4, &dummy5, &dummy6,
1805                 &line_uid) == 12) {
1806       /* Note about /proc/net/tcp: local_address and rem_address are
1807        * always in network byte order.  However the port part is
1808        * always in host byte order.
1809        *
1810        * The sockname and peername that we got above are in network
1811        * byte order.  So we have to byte swap the port but not the
1812        * address part.
1813        */
1814       if (line_our_addr == our.sin_addr.s_addr &&
1815           line_our_port == ntohs (our.sin_port) &&
1816           line_peer_addr == peer.sin_addr.s_addr &&
1817           line_peer_port == ntohs (peer.sin_port)) {
1818         *rtn = line_uid;
1819         fclose (fp);
1820         return 0;
1821       }
1822     }
1823   }
1824
1825   error (g, "check_peer_euid: no matching TCP connection found in /proc/net/tcp");
1826   fclose (fp);
1827   return -1;
1828 #else /* !CAN_CHECK_PEER_EUID */
1829   /* This function exists but should never be called in this
1830    * configuration.
1831    */
1832   abort ();
1833 #endif /* !CAN_CHECK_PEER_EUID */
1834 }
1835
1836 /* You had to call this function after launch in versions <= 1.0.70,
1837  * but it is now a no-op.
1838  */
1839 int
1840 guestfs__wait_ready (guestfs_h *g)
1841 {
1842   if (g->state != READY)  {
1843     error (g, _("qemu has not been launched yet"));
1844     return -1;
1845   }
1846
1847   return 0;
1848 }
1849
1850 int
1851 guestfs__kill_subprocess (guestfs_h *g)
1852 {
1853   if (g->state == CONFIG) {
1854     error (g, _("no subprocess to kill"));
1855     return -1;
1856   }
1857
1858   if (g->verbose)
1859     fprintf (stderr, "sending SIGTERM to process %d\n", g->pid);
1860
1861   if (g->pid > 0) kill (g->pid, SIGTERM);
1862   if (g->recoverypid > 0) kill (g->recoverypid, 9);
1863
1864   return 0;
1865 }
1866
1867 /* Access current state. */
1868 int
1869 guestfs__is_config (guestfs_h *g)
1870 {
1871   return g->state == CONFIG;
1872 }
1873
1874 int
1875 guestfs__is_launching (guestfs_h *g)
1876 {
1877   return g->state == LAUNCHING;
1878 }
1879
1880 int
1881 guestfs__is_ready (guestfs_h *g)
1882 {
1883   return g->state == READY;
1884 }
1885
1886 int
1887 guestfs__is_busy (guestfs_h *g)
1888 {
1889   return g->state == BUSY;
1890 }
1891
1892 int
1893 guestfs__get_state (guestfs_h *g)
1894 {
1895   return g->state;
1896 }
1897
1898 void
1899 guestfs_set_log_message_callback (guestfs_h *g,
1900                                   guestfs_log_message_cb cb, void *opaque)
1901 {
1902   g->log_message_cb = cb;
1903   g->log_message_cb_data = opaque;
1904 }
1905
1906 void
1907 guestfs_set_subprocess_quit_callback (guestfs_h *g,
1908                                       guestfs_subprocess_quit_cb cb, void *opaque)
1909 {
1910   g->subprocess_quit_cb = cb;
1911   g->subprocess_quit_cb_data = opaque;
1912 }
1913
1914 void
1915 guestfs_set_launch_done_callback (guestfs_h *g,
1916                                   guestfs_launch_done_cb cb, void *opaque)
1917 {
1918   g->launch_done_cb = cb;
1919   g->launch_done_cb_data = opaque;
1920 }
1921
1922 void
1923 guestfs_set_close_callback (guestfs_h *g,
1924                             guestfs_close_cb cb, void *opaque)
1925 {
1926   g->close_cb = cb;
1927   g->close_cb_data = opaque;
1928 }
1929
1930 /*----------------------------------------------------------------------*/
1931
1932 /* This is the code used to send and receive RPC messages and (for
1933  * certain types of message) to perform file transfers.  This code is
1934  * driven from the generated actions (src/guestfs-actions.c).  There
1935  * are five different cases to consider:
1936  *
1937  * (1) A non-daemon function.  There is no RPC involved at all, it's
1938  * all handled inside the library.
1939  *
1940  * (2) A simple RPC (eg. "mount").  We write the request, then read
1941  * the reply.  The sequence of calls is:
1942  *
1943  *   guestfs___set_busy
1944  *   guestfs___send
1945  *   guestfs___recv
1946  *   guestfs___end_busy
1947  *
1948  * (3) An RPC with FileOut parameters (eg. "upload").  We write the
1949  * request, then write the file(s), then read the reply.  The sequence
1950  * of calls is:
1951  *
1952  *   guestfs___set_busy
1953  *   guestfs___send
1954  *   guestfs___send_file  (possibly multiple times)
1955  *   guestfs___recv
1956  *   guestfs___end_busy
1957  *
1958  * (4) An RPC with FileIn parameters (eg. "download").  We write the
1959  * request, then read the reply, then read the file(s).  The sequence
1960  * of calls is:
1961  *
1962  *   guestfs___set_busy
1963  *   guestfs___send
1964  *   guestfs___recv
1965  *   guestfs___recv_file  (possibly multiple times)
1966  *   guestfs___end_busy
1967  *
1968  * (5) Both FileOut and FileIn parameters.  There are no calls like
1969  * this in the current API, but they would be implemented as a
1970  * combination of cases (3) and (4).
1971  *
1972  * During all writes and reads, we also select(2) on qemu stdout
1973  * looking for messages (guestfsd stderr and guest kernel dmesg), and
1974  * anything received is passed up through the log_message_cb.  This is
1975  * also the reason why all the sockets are non-blocking.  We also have
1976  * to check for EOF (qemu died).  All of this is handled by the
1977  * functions send_to_daemon and recv_from_daemon.
1978  */
1979
1980 int
1981 guestfs___set_busy (guestfs_h *g)
1982 {
1983   if (g->state != READY) {
1984     error (g, _("guestfs_set_busy: called when in state %d != READY"),
1985            g->state);
1986     return -1;
1987   }
1988   g->state = BUSY;
1989   return 0;
1990 }
1991
1992 int
1993 guestfs___end_busy (guestfs_h *g)
1994 {
1995   switch (g->state)
1996     {
1997     case BUSY:
1998       g->state = READY;
1999       break;
2000     case CONFIG:
2001     case READY:
2002       break;
2003
2004     case LAUNCHING:
2005     case NO_HANDLE:
2006     default:
2007       error (g, _("guestfs_end_busy: called when in state %d"), g->state);
2008       return -1;
2009     }
2010   return 0;
2011 }
2012
2013 /* This is called if we detect EOF, ie. qemu died. */
2014 static void
2015 child_cleanup (guestfs_h *g)
2016 {
2017   if (g->verbose)
2018     fprintf (stderr, "child_cleanup: %p: child process died\n", g);
2019
2020   /*if (g->pid > 0) kill (g->pid, SIGTERM);*/
2021   if (g->recoverypid > 0) kill (g->recoverypid, 9);
2022   waitpid (g->pid, NULL, 0);
2023   if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0);
2024   close (g->fd[0]);
2025   close (g->fd[1]);
2026   close (g->sock);
2027   g->fd[0] = -1;
2028   g->fd[1] = -1;
2029   g->sock = -1;
2030   g->pid = 0;
2031   g->recoverypid = 0;
2032   memset (&g->launch_t, 0, sizeof g->launch_t);
2033   g->state = CONFIG;
2034   if (g->subprocess_quit_cb)
2035     g->subprocess_quit_cb (g, g->subprocess_quit_cb_data);
2036 }
2037
2038 static int
2039 read_log_message_or_eof (guestfs_h *g, int fd, int error_if_eof)
2040 {
2041   char buf[BUFSIZ];
2042   int n;
2043
2044 #if 0
2045   if (g->verbose)
2046     fprintf (stderr,
2047              "read_log_message_or_eof: %p g->state = %d, fd = %d\n",
2048              g, g->state, fd);
2049 #endif
2050
2051   /* QEMU's console emulates a 16550A serial port.  The real 16550A
2052    * device has a small FIFO buffer (16 bytes) which means here we see
2053    * lots of small reads of 1-16 bytes in length, usually single
2054    * bytes.
2055    */
2056   n = read (fd, buf, sizeof buf);
2057   if (n == 0) {
2058     /* Hopefully this indicates the qemu child process has died. */
2059     child_cleanup (g);
2060
2061     if (error_if_eof) {
2062       /* We weren't expecting eof here (called from launch) so place
2063        * something in the error buffer.  RHBZ#588851.
2064        */
2065       error (g, "child process died unexpectedly");
2066     }
2067     return -1;
2068   }
2069
2070   if (n == -1) {
2071     if (errno == EINTR || errno == EAGAIN)
2072       return 0;
2073
2074     perrorf (g, "read");
2075     return -1;
2076   }
2077
2078   /* In verbose mode, copy all log messages to stderr. */
2079   if (g->verbose)
2080     ignore_value (write (STDERR_FILENO, buf, n));
2081
2082   /* It's an actual log message, send it upwards if anyone is listening. */
2083   if (g->log_message_cb)
2084     g->log_message_cb (g, g->log_message_cb_data, buf, n);
2085
2086   return 0;
2087 }
2088
2089 static int
2090 check_for_daemon_cancellation_or_eof (guestfs_h *g, int fd)
2091 {
2092   char buf[4];
2093   int n;
2094   uint32_t flag;
2095   XDR xdr;
2096
2097   if (g->verbose)
2098     fprintf (stderr,
2099              "check_for_daemon_cancellation_or_eof: %p g->state = %d, fd = %d\n",
2100              g, g->state, fd);
2101
2102   n = read (fd, buf, 4);
2103   if (n == 0) {
2104     /* Hopefully this indicates the qemu child process has died. */
2105     child_cleanup (g);
2106     return -1;
2107   }
2108
2109   if (n == -1) {
2110     if (errno == EINTR || errno == EAGAIN)
2111       return 0;
2112
2113     perrorf (g, "read");
2114     return -1;
2115   }
2116
2117   xdrmem_create (&xdr, buf, 4, XDR_DECODE);
2118   xdr_uint32_t (&xdr, &flag);
2119   xdr_destroy (&xdr);
2120
2121   if (flag != GUESTFS_CANCEL_FLAG) {
2122     error (g, _("check_for_daemon_cancellation_or_eof: read 0x%x from daemon, expected 0x%x\n"),
2123            flag, GUESTFS_CANCEL_FLAG);
2124     return -1;
2125   }
2126
2127   return -2;
2128 }
2129
2130 /* This writes the whole N bytes of BUF to the daemon socket.
2131  *
2132  * If the whole write is successful, it returns 0.
2133  * If there was an error, it returns -1.
2134  * If the daemon sent a cancellation message, it returns -2.
2135  *
2136  * It also checks qemu stdout for log messages and passes those up
2137  * through log_message_cb.
2138  *
2139  * It also checks for EOF (qemu died) and passes that up through the
2140  * child_cleanup function above.
2141  */
2142 static int
2143 send_to_daemon (guestfs_h *g, const void *v_buf, size_t n)
2144 {
2145   const char *buf = v_buf;
2146   fd_set rset, rset2;
2147   fd_set wset, wset2;
2148
2149   if (g->verbose)
2150     fprintf (stderr,
2151              "send_to_daemon: %p g->state = %d, n = %zu\n", g, g->state, n);
2152
2153   FD_ZERO (&rset);
2154   FD_ZERO (&wset);
2155
2156   FD_SET (g->fd[1], &rset);     /* Read qemu stdout for log messages & EOF. */
2157   FD_SET (g->sock, &rset);      /* Read socket for cancellation & EOF. */
2158   FD_SET (g->sock, &wset);      /* Write to socket to send the data. */
2159
2160   int max_fd = MAX (g->sock, g->fd[1]);
2161
2162   while (n > 0) {
2163     rset2 = rset;
2164     wset2 = wset;
2165     int r = select (max_fd+1, &rset2, &wset2, NULL, NULL);
2166     if (r == -1) {
2167       if (errno == EINTR || errno == EAGAIN)
2168         continue;
2169       perrorf (g, "select");
2170       return -1;
2171     }
2172
2173     if (FD_ISSET (g->fd[1], &rset2)) {
2174       if (read_log_message_or_eof (g, g->fd[1], 0) == -1)
2175         return -1;
2176     }
2177     if (FD_ISSET (g->sock, &rset2)) {
2178       r = check_for_daemon_cancellation_or_eof (g, g->sock);
2179       if (r < 0)
2180         return r;
2181     }
2182     if (FD_ISSET (g->sock, &wset2)) {
2183       r = write (g->sock, buf, n);
2184       if (r == -1) {
2185         if (errno == EINTR || errno == EAGAIN)
2186           continue;
2187         perrorf (g, "write");
2188         if (errno == EPIPE) /* Disconnected from guest (RHBZ#508713). */
2189           child_cleanup (g);
2190         return -1;
2191       }
2192       buf += r;
2193       n -= r;
2194     }
2195   }
2196
2197   return 0;
2198 }
2199
2200 /* This reads a single message, file chunk, launch flag or
2201  * cancellation flag from the daemon.  If something was read, it
2202  * returns 0, otherwise -1.
2203  *
2204  * Both size_rtn and buf_rtn must be passed by the caller as non-NULL.
2205  *
2206  * *size_rtn returns the size of the returned message or it may be
2207  * GUESTFS_LAUNCH_FLAG or GUESTFS_CANCEL_FLAG.
2208  *
2209  * *buf_rtn is returned containing the message (if any) or will be set
2210  * to NULL.  *buf_rtn must be freed by the caller.
2211  *
2212  * It also checks qemu stdout for log messages and passes those up
2213  * through log_message_cb.
2214  *
2215  * It also checks for EOF (qemu died) and passes that up through the
2216  * child_cleanup function above.
2217  */
2218 static int
2219 recv_from_daemon (guestfs_h *g, uint32_t *size_rtn, void **buf_rtn)
2220 {
2221   fd_set rset, rset2;
2222
2223   if (g->verbose)
2224     fprintf (stderr,
2225              "recv_from_daemon: %p g->state = %d, size_rtn = %p, buf_rtn = %p\n",
2226              g, g->state, size_rtn, buf_rtn);
2227
2228   FD_ZERO (&rset);
2229
2230   FD_SET (g->fd[1], &rset);     /* Read qemu stdout for log messages & EOF. */
2231   FD_SET (g->sock, &rset);      /* Read socket for data & EOF. */
2232
2233   int max_fd = MAX (g->sock, g->fd[1]);
2234
2235   *size_rtn = 0;
2236   *buf_rtn = NULL;
2237
2238   char lenbuf[4];
2239   /* nr is the size of the message, but we prime it as -4 because we
2240    * have to read the message length word first.
2241    */
2242   ssize_t nr = -4;
2243
2244   while (nr < (ssize_t) *size_rtn) {
2245     rset2 = rset;
2246     int r = select (max_fd+1, &rset2, NULL, NULL, NULL);
2247     if (r == -1) {
2248       if (errno == EINTR || errno == EAGAIN)
2249         continue;
2250       perrorf (g, "select");
2251       free (*buf_rtn);
2252       *buf_rtn = NULL;
2253       return -1;
2254     }
2255
2256     if (FD_ISSET (g->fd[1], &rset2)) {
2257       if (read_log_message_or_eof (g, g->fd[1], 0) == -1) {
2258         free (*buf_rtn);
2259         *buf_rtn = NULL;
2260         return -1;
2261       }
2262     }
2263     if (FD_ISSET (g->sock, &rset2)) {
2264       if (nr < 0) {    /* Have we read the message length word yet? */
2265         r = read (g->sock, lenbuf+nr+4, -nr);
2266         if (r == -1) {
2267           if (errno == EINTR || errno == EAGAIN)
2268             continue;
2269           int err = errno;
2270           perrorf (g, "read");
2271           /* Under some circumstances we see "Connection reset by peer"
2272            * here when the child dies suddenly.  Catch this and call
2273            * the cleanup function, same as for EOF.
2274            */
2275           if (err == ECONNRESET)
2276             child_cleanup (g);
2277           return -1;
2278         }
2279         if (r == 0) {
2280           error (g, _("unexpected end of file when reading from daemon"));
2281           child_cleanup (g);
2282           return -1;
2283         }
2284         nr += r;
2285
2286         if (nr < 0)         /* Still not got the whole length word. */
2287           continue;
2288
2289         XDR xdr;
2290         xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
2291         xdr_uint32_t (&xdr, size_rtn);
2292         xdr_destroy (&xdr);
2293
2294         if (*size_rtn == GUESTFS_LAUNCH_FLAG) {
2295           if (g->state != LAUNCHING)
2296             error (g, _("received magic signature from guestfsd, but in state %d"),
2297                    g->state);
2298           else {
2299             g->state = READY;
2300             if (g->launch_done_cb)
2301               g->launch_done_cb (g, g->launch_done_cb_data);
2302           }
2303           return 0;
2304         }
2305         else if (*size_rtn == GUESTFS_CANCEL_FLAG)
2306           return 0;
2307         /* If this happens, it's pretty bad and we've probably lost
2308          * synchronization.
2309          */
2310         else if (*size_rtn > GUESTFS_MESSAGE_MAX) {
2311           error (g, _("message length (%u) > maximum possible size (%d)"),
2312                  (unsigned) *size_rtn, GUESTFS_MESSAGE_MAX);
2313           return -1;
2314         }
2315
2316         /* Allocate the complete buffer, size now known. */
2317         *buf_rtn = safe_malloc (g, *size_rtn);
2318         /*FALLTHROUGH*/
2319       }
2320
2321       size_t sizetoread = *size_rtn - nr;
2322       if (sizetoread > BUFSIZ) sizetoread = BUFSIZ;
2323
2324       r = read (g->sock, (char *) (*buf_rtn) + nr, sizetoread);
2325       if (r == -1) {
2326         if (errno == EINTR || errno == EAGAIN)
2327           continue;
2328         perrorf (g, "read");
2329         free (*buf_rtn);
2330         *buf_rtn = NULL;
2331         return -1;
2332       }
2333       if (r == 0) {
2334         error (g, _("unexpected end of file when reading from daemon"));
2335         child_cleanup (g);
2336         free (*buf_rtn);
2337         *buf_rtn = NULL;
2338         return -1;
2339       }
2340       nr += r;
2341     }
2342   }
2343
2344   /* Got the full message, caller can start processing it. */
2345 #ifdef ENABLE_PACKET_DUMP
2346   if (g->verbose) {
2347     ssize_t i, j;
2348
2349     for (i = 0; i < nr; i += 16) {
2350       printf ("%04zx: ", i);
2351       for (j = i; j < MIN (i+16, nr); ++j)
2352         printf ("%02x ", (*(unsigned char **)buf_rtn)[j]);
2353       for (; j < i+16; ++j)
2354         printf ("   ");
2355       printf ("|");
2356       for (j = i; j < MIN (i+16, nr); ++j)
2357         if (c_isprint ((*(char **)buf_rtn)[j]))
2358           printf ("%c", (*(char **)buf_rtn)[j]);
2359         else
2360           printf (".");
2361       for (; j < i+16; ++j)
2362         printf (" ");
2363       printf ("|\n");
2364     }
2365   }
2366 #endif
2367
2368   return 0;
2369 }
2370
2371 /* This is very much like recv_from_daemon above, but g->sock is
2372  * a listening socket and we are accepting a new connection on
2373  * that socket instead of reading anything.  Returns the newly
2374  * accepted socket.
2375  */
2376 static int
2377 accept_from_daemon (guestfs_h *g)
2378 {
2379   fd_set rset, rset2;
2380
2381   if (g->verbose)
2382     fprintf (stderr,
2383              "accept_from_daemon: %p g->state = %d\n", g, g->state);
2384
2385   FD_ZERO (&rset);
2386
2387   FD_SET (g->fd[1], &rset);     /* Read qemu stdout for log messages & EOF. */
2388   FD_SET (g->sock, &rset);      /* Read socket for accept. */
2389
2390   int max_fd = MAX (g->sock, g->fd[1]);
2391   int sock = -1;
2392
2393   while (sock == -1) {
2394     /* If the qemu process has died, clean up the zombie (RHBZ#579155).
2395      * By partially polling in the select below we ensure that this
2396      * function will be called eventually.
2397      */
2398     waitpid (g->pid, NULL, WNOHANG);
2399
2400     rset2 = rset;
2401
2402     struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
2403     int r = select (max_fd+1, &rset2, NULL, NULL, &tv);
2404     if (r == -1) {
2405       if (errno == EINTR || errno == EAGAIN)
2406         continue;
2407       perrorf (g, "select");
2408       return -1;
2409     }
2410
2411     if (FD_ISSET (g->fd[1], &rset2)) {
2412       if (read_log_message_or_eof (g, g->fd[1], 1) == -1)
2413         return -1;
2414     }
2415     if (FD_ISSET (g->sock, &rset2)) {
2416       sock = accept (g->sock, NULL, NULL);
2417       if (sock == -1) {
2418         if (errno == EINTR || errno == EAGAIN)
2419           continue;
2420         perrorf (g, "accept");
2421         return -1;
2422       }
2423     }
2424   }
2425
2426   return sock;
2427 }
2428
2429 int
2430 guestfs___send (guestfs_h *g, int proc_nr, xdrproc_t xdrp, char *args)
2431 {
2432   struct guestfs_message_header hdr;
2433   XDR xdr;
2434   u_int32_t len;
2435   int serial = g->msg_next_serial++;
2436   int r;
2437   char *msg_out;
2438   size_t msg_out_size;
2439
2440   if (g->state != BUSY) {
2441     error (g, _("guestfs___send: state %d != BUSY"), g->state);
2442     return -1;
2443   }
2444
2445   /* We have to allocate this message buffer on the heap because
2446    * it is quite large (although will be mostly unused).  We
2447    * can't allocate it on the stack because in some environments
2448    * we have quite limited stack space available, notably when
2449    * running in the JVM.
2450    */
2451   msg_out = safe_malloc (g, GUESTFS_MESSAGE_MAX + 4);
2452   xdrmem_create (&xdr, msg_out + 4, GUESTFS_MESSAGE_MAX, XDR_ENCODE);
2453
2454   /* Serialize the header. */
2455   hdr.prog = GUESTFS_PROGRAM;
2456   hdr.vers = GUESTFS_PROTOCOL_VERSION;
2457   hdr.proc = proc_nr;
2458   hdr.direction = GUESTFS_DIRECTION_CALL;
2459   hdr.serial = serial;
2460   hdr.status = GUESTFS_STATUS_OK;
2461
2462   if (!xdr_guestfs_message_header (&xdr, &hdr)) {
2463     error (g, _("xdr_guestfs_message_header failed"));
2464     goto cleanup1;
2465   }
2466
2467   /* Serialize the args.  If any, because some message types
2468    * have no parameters.
2469    */
2470   if (xdrp) {
2471     if (!(*xdrp) (&xdr, args)) {
2472       error (g, _("dispatch failed to marshal args"));
2473       goto cleanup1;
2474     }
2475   }
2476
2477   /* Get the actual length of the message, resize the buffer to match
2478    * the actual length, and write the length word at the beginning.
2479    */
2480   len = xdr_getpos (&xdr);
2481   xdr_destroy (&xdr);
2482
2483   msg_out = safe_realloc (g, msg_out, len + 4);
2484   msg_out_size = len + 4;
2485
2486   xdrmem_create (&xdr, msg_out, 4, XDR_ENCODE);
2487   xdr_uint32_t (&xdr, &len);
2488
2489  again:
2490   r = send_to_daemon (g, msg_out, msg_out_size);
2491   if (r == -2)                  /* Ignore stray daemon cancellations. */
2492     goto again;
2493   if (r == -1)
2494     goto cleanup1;
2495   free (msg_out);
2496
2497   return serial;
2498
2499  cleanup1:
2500   free (msg_out);
2501   return -1;
2502 }
2503
2504 static int cancel = 0; /* XXX Implement file cancellation. */
2505 static int send_file_chunk (guestfs_h *g, int cancel, const char *buf, size_t len);
2506 static int send_file_data (guestfs_h *g, const char *buf, size_t len);
2507 static int send_file_cancellation (guestfs_h *g);
2508 static int send_file_complete (guestfs_h *g);
2509
2510 /* Send a file.
2511  * Returns:
2512  *   0 OK
2513  *   -1 error
2514  *   -2 daemon cancelled (we must read the error message)
2515  */
2516 int
2517 guestfs___send_file (guestfs_h *g, const char *filename)
2518 {
2519   char buf[GUESTFS_MAX_CHUNK_SIZE];
2520   int fd, r, err;
2521
2522   fd = open (filename, O_RDONLY);
2523   if (fd == -1) {
2524     perrorf (g, "open: %s", filename);
2525     send_file_cancellation (g);
2526     /* Daemon sees cancellation and won't reply, so caller can
2527      * just return here.
2528      */
2529     return -1;
2530   }
2531
2532   /* Send file in chunked encoding. */
2533   while (!cancel) {
2534     r = read (fd, buf, sizeof buf);
2535     if (r == -1 && (errno == EINTR || errno == EAGAIN))
2536       continue;
2537     if (r <= 0) break;
2538     err = send_file_data (g, buf, r);
2539     if (err < 0) {
2540       if (err == -2)            /* daemon sent cancellation */
2541         send_file_cancellation (g);
2542       return err;
2543     }
2544   }
2545
2546   if (cancel) {                 /* cancel from either end */
2547     send_file_cancellation (g);
2548     return -1;
2549   }
2550
2551   if (r == -1) {
2552     perrorf (g, "read: %s", filename);
2553     send_file_cancellation (g);
2554     return -1;
2555   }
2556
2557   /* End of file, but before we send that, we need to close
2558    * the file and check for errors.
2559    */
2560   if (close (fd) == -1) {
2561     perrorf (g, "close: %s", filename);
2562     send_file_cancellation (g);
2563     return -1;
2564   }
2565
2566   return send_file_complete (g);
2567 }
2568
2569 /* Send a chunk of file data. */
2570 static int
2571 send_file_data (guestfs_h *g, const char *buf, size_t len)
2572 {
2573   return send_file_chunk (g, 0, buf, len);
2574 }
2575
2576 /* Send a cancellation message. */
2577 static int
2578 send_file_cancellation (guestfs_h *g)
2579 {
2580   return send_file_chunk (g, 1, NULL, 0);
2581 }
2582
2583 /* Send a file complete chunk. */
2584 static int
2585 send_file_complete (guestfs_h *g)
2586 {
2587   char buf[1];
2588   return send_file_chunk (g, 0, buf, 0);
2589 }
2590
2591 static int
2592 send_file_chunk (guestfs_h *g, int cancel, const char *buf, size_t buflen)
2593 {
2594   u_int32_t len;
2595   int r;
2596   guestfs_chunk chunk;
2597   XDR xdr;
2598   char *msg_out;
2599   size_t msg_out_size;
2600
2601   if (g->state != BUSY) {
2602     error (g, _("send_file_chunk: state %d != READY"), g->state);
2603     return -1;
2604   }
2605
2606   /* Allocate the chunk buffer.  Don't use the stack to avoid
2607    * excessive stack usage and unnecessary copies.
2608    */
2609   msg_out = safe_malloc (g, GUESTFS_MAX_CHUNK_SIZE + 4 + 48);
2610   xdrmem_create (&xdr, msg_out + 4, GUESTFS_MAX_CHUNK_SIZE + 48, XDR_ENCODE);
2611
2612   /* Serialize the chunk. */
2613   chunk.cancel = cancel;
2614   chunk.data.data_len = buflen;
2615   chunk.data.data_val = (char *) buf;
2616
2617   if (!xdr_guestfs_chunk (&xdr, &chunk)) {
2618     error (g, _("xdr_guestfs_chunk failed (buf = %p, buflen = %zu)"),
2619            buf, buflen);
2620     xdr_destroy (&xdr);
2621     goto cleanup1;
2622   }
2623
2624   len = xdr_getpos (&xdr);
2625   xdr_destroy (&xdr);
2626
2627   /* Reduce the size of the outgoing message buffer to the real length. */
2628   msg_out = safe_realloc (g, msg_out, len + 4);
2629   msg_out_size = len + 4;
2630
2631   xdrmem_create (&xdr, msg_out, 4, XDR_ENCODE);
2632   xdr_uint32_t (&xdr, &len);
2633
2634   r = send_to_daemon (g, msg_out, msg_out_size);
2635
2636   /* Did the daemon send a cancellation message? */
2637   if (r == -2) {
2638     if (g->verbose)
2639       fprintf (stderr, "got daemon cancellation\n");
2640     return -2;
2641   }
2642
2643   if (r == -1)
2644     goto cleanup1;
2645
2646   free (msg_out);
2647
2648   return 0;
2649
2650  cleanup1:
2651   free (msg_out);
2652   return -1;
2653 }
2654
2655 /* Receive a reply. */
2656 int
2657 guestfs___recv (guestfs_h *g, const char *fn,
2658                 guestfs_message_header *hdr,
2659                 guestfs_message_error *err,
2660                 xdrproc_t xdrp, char *ret)
2661 {
2662   XDR xdr;
2663   void *buf;
2664   uint32_t size;
2665   int r;
2666
2667  again:
2668   r = recv_from_daemon (g, &size, &buf);
2669   if (r == -1)
2670     return -1;
2671
2672   /* This can happen if a cancellation happens right at the end
2673    * of us sending a FileIn parameter to the daemon.  Discard.  The
2674    * daemon should send us an error message next.
2675    */
2676   if (size == GUESTFS_CANCEL_FLAG)
2677     goto again;
2678
2679   if (size == GUESTFS_LAUNCH_FLAG) {
2680     error (g, "%s: received unexpected launch flag from daemon when expecting reply", fn);
2681     return -1;
2682   }
2683
2684   xdrmem_create (&xdr, buf, size, XDR_DECODE);
2685
2686   if (!xdr_guestfs_message_header (&xdr, hdr)) {
2687     error (g, "%s: failed to parse reply header", fn);
2688     xdr_destroy (&xdr);
2689     free (buf);
2690     return -1;
2691   }
2692   if (hdr->status == GUESTFS_STATUS_ERROR) {
2693     if (!xdr_guestfs_message_error (&xdr, err)) {
2694       error (g, "%s: failed to parse reply error", fn);
2695       xdr_destroy (&xdr);
2696       free (buf);
2697       return -1;
2698     }
2699   } else {
2700     if (xdrp && ret && !xdrp (&xdr, ret)) {
2701       error (g, "%s: failed to parse reply", fn);
2702       xdr_destroy (&xdr);
2703       free (buf);
2704       return -1;
2705     }
2706   }
2707   xdr_destroy (&xdr);
2708   free (buf);
2709
2710   return 0;
2711 }
2712
2713 /* Receive a file. */
2714
2715 /* Returns -1 = error, 0 = EOF, > 0 = more data */
2716 static ssize_t receive_file_data (guestfs_h *g, void **buf);
2717
2718 int
2719 guestfs___recv_file (guestfs_h *g, const char *filename)
2720 {
2721   void *buf;
2722   int fd, r;
2723
2724   fd = open (filename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY, 0666);
2725   if (fd == -1) {
2726     perrorf (g, "open: %s", filename);
2727     goto cancel;
2728   }
2729
2730   /* Receive the file in chunked encoding. */
2731   while ((r = receive_file_data (g, &buf)) > 0) {
2732     if (xwrite (fd, buf, r) == -1) {
2733       perrorf (g, "%s: write", filename);
2734       free (buf);
2735       goto cancel;
2736     }
2737     free (buf);
2738   }
2739
2740   if (r == -1) {
2741     error (g, _("%s: error in chunked encoding"), filename);
2742     return -1;
2743   }
2744
2745   if (close (fd) == -1) {
2746     perrorf (g, "close: %s", filename);
2747     return -1;
2748   }
2749
2750   return 0;
2751
2752  cancel: ;
2753   /* Send cancellation message to daemon, then wait until it
2754    * cancels (just throwing away data).
2755    */
2756   XDR xdr;
2757   char fbuf[4];
2758   uint32_t flag = GUESTFS_CANCEL_FLAG;
2759
2760   if (g->verbose)
2761     fprintf (stderr, "%s: waiting for daemon to acknowledge cancellation\n",
2762              __func__);
2763
2764   xdrmem_create (&xdr, fbuf, sizeof fbuf, XDR_ENCODE);
2765   xdr_uint32_t (&xdr, &flag);
2766   xdr_destroy (&xdr);
2767
2768   if (xwrite (g->sock, fbuf, sizeof fbuf) == -1) {
2769     perrorf (g, _("write to daemon socket"));
2770     return -1;
2771   }
2772
2773   while (receive_file_data (g, NULL) > 0)
2774     ;                           /* just discard it */
2775
2776   return -1;
2777 }
2778
2779 /* Receive a chunk of file data. */
2780 /* Returns -1 = error, 0 = EOF, > 0 = more data */
2781 static ssize_t
2782 receive_file_data (guestfs_h *g, void **buf_r)
2783 {
2784   int r;
2785   void *buf;
2786   uint32_t len;
2787   XDR xdr;
2788   guestfs_chunk chunk;
2789
2790   r = recv_from_daemon (g, &len, &buf);
2791   if (r == -1) {
2792     error (g, _("receive_file_data: parse error in reply callback"));
2793     return -1;
2794   }
2795
2796   if (len == GUESTFS_LAUNCH_FLAG || len == GUESTFS_CANCEL_FLAG) {
2797     error (g, _("receive_file_data: unexpected flag received when reading file chunks"));
2798     return -1;
2799   }
2800
2801   memset (&chunk, 0, sizeof chunk);
2802
2803   xdrmem_create (&xdr, buf, len, XDR_DECODE);
2804   if (!xdr_guestfs_chunk (&xdr, &chunk)) {
2805     error (g, _("failed to parse file chunk"));
2806     free (buf);
2807     return -1;
2808   }
2809   xdr_destroy (&xdr);
2810   /* After decoding, the original buffer is no longer used. */
2811   free (buf);
2812
2813   if (chunk.cancel) {
2814     error (g, _("file receive cancelled by daemon"));
2815     free (chunk.data.data_val);
2816     return -1;
2817   }
2818
2819   if (chunk.data.data_len == 0) { /* end of transfer */
2820     free (chunk.data.data_val);
2821     return 0;
2822   }
2823
2824   if (buf_r) *buf_r = chunk.data.data_val;
2825   else free (chunk.data.data_val); /* else caller frees */
2826
2827   return chunk.data.data_len;
2828 }