src/launch.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 static int check_peer_euid (guestfs_h *g, int sock, uid_t *rtn);
  74 static int qemu_supports (guestfs_h *g, const char *option);
  75
  76 /* Add a string to the current command line. */
  77 static void
  78 incr_cmdline_size (guestfs_h *g)
  79 {
  80   if (g->cmdline == NULL) {
  81     /* g->cmdline[0] is reserved for argv[0], set in guestfs_launch. */
  82     g->cmdline_size = 1;
  83     g->cmdline = safe_malloc (g, sizeof (char *));
  84     g->cmdline[0] = NULL;
  85   }
  86
  87   g->cmdline_size++;
  88   g->cmdline = safe_realloc (g, g->cmdline, sizeof (char *) * g->cmdline_size);
  89 }
  90
  91 static int
  92 add_cmdline (guestfs_h *g, const char *str)
  93 {
  94   if (g->state != CONFIG) {
  95     error (g,
  96         _("command line cannot be altered after qemu subprocess launched"));
  97     return -1;
  98   }
  99
 100   incr_cmdline_size (g);
 101   g->cmdline[g->cmdline_size-1] = safe_strdup (g, str);
 102   return 0;
 103 }
 104
 105 int
 106 guestfs__config (guestfs_h *g,
 107                  const char *qemu_param, const char *qemu_value)
 108 {
 109   if (qemu_param[0] != '-') {
 110     error (g, _("guestfs_config: parameter must begin with '-' character"));
 111     return -1;
 112   }
 113
 114   /* A bit fascist, but the user will probably break the extra
 115    * parameters that we add if they try to set any of these.
 116    */
 117   if (STREQ (qemu_param, "-kernel") ||
 118       STREQ (qemu_param, "-initrd") ||
 119       STREQ (qemu_param, "-nographic") ||
 120       STREQ (qemu_param, "-serial") ||
 121       STREQ (qemu_param, "-full-screen") ||
 122       STREQ (qemu_param, "-std-vga") ||
 123       STREQ (qemu_param, "-vnc")) {
 124     error (g, _("guestfs_config: parameter '%s' isn't allowed"), qemu_param);
 125     return -1;
 126   }
 127
 128   if (add_cmdline (g, qemu_param) != 0) return -1;
 129
 130   if (qemu_value != NULL) {
 131     if (add_cmdline (g, qemu_value) != 0) return -1;
 132   }
 133
 134   return 0;
 135 }
 136
 137 int
 138 guestfs__add_drive_with_if (guestfs_h *g, const char *filename,
 139                             const char *drive_if)
 140 {
 141   size_t len = strlen (filename) + 64;
 142   char buf[len];
 143
 144   if (strchr (filename, ',') != NULL) {
 145     error (g, _("filename cannot contain ',' (comma) character"));
 146     return -1;
 147   }
 148
 149   /* cache=off improves reliability in the event of a host crash.
 150    *
 151    * However this option causes qemu to try to open the file with
 152    * O_DIRECT.  This fails on some filesystem types (notably tmpfs).
 153    * So we check if we can open the file with or without O_DIRECT,
 154    * and use cache=off (or not) accordingly.
 155    *
 156    * This test also checks for the presence of the file, which
 157    * is a documented semantic of this interface.
 158    */
 159   int fd = open (filename, O_RDONLY|O_DIRECT);
 160   if (fd >= 0) {
 161     close (fd);
 162     snprintf (buf, len, "file=%s,cache=off,if=%s", filename, drive_if);
 163   } else {
 164     fd = open (filename, O_RDONLY);
 165     if (fd >= 0) {
 166       close (fd);
 167       snprintf (buf, len, "file=%s,if=%s", filename, drive_if);
 168     } else {
 169       perrorf (g, "%s", filename);
 170       return -1;
 171     }
 172   }
 173
 174   return guestfs__config (g, "-drive", buf);
 175 }
 176
 177 int
 178 guestfs__add_drive_ro_with_if (guestfs_h *g, const char *filename,
 179                                const char *drive_if)
 180 {
 181   if (strchr (filename, ',') != NULL) {
 182     error (g, _("filename cannot contain ',' (comma) character"));
 183     return -1;
 184   }
 185
 186   if (access (filename, F_OK) == -1) {
 187     perrorf (g, "%s", filename);
 188     return -1;
 189   }
 190
 191   size_t len = strlen (filename) + 64;
 192   char buf[len];
 193
 194   snprintf (buf, len, "file=%s,snapshot=on,if=%s", filename, drive_if);
 195
 196   return guestfs__config (g, "-drive", buf);
 197 }
 198
 199 int
 200 guestfs__add_drive (guestfs_h *g, const char *filename)
 201 {
 202   return guestfs__add_drive_with_if (g, filename, DRIVE_IF);
 203 }
 204
 205 int
 206 guestfs__add_drive_ro (guestfs_h *g, const char *filename)
 207 {
 208   return guestfs__add_drive_ro_with_if (g, filename, DRIVE_IF);
 209 }
 210
 211 int
 212 guestfs__add_cdrom (guestfs_h *g, const char *filename)
 213 {
 214   if (strchr (filename, ',') != NULL) {
 215     error (g, _("filename cannot contain ',' (comma) character"));
 216     return -1;
 217   }
 218
 219   if (access (filename, F_OK) == -1) {
 220     perrorf (g, "%s", filename);
 221     return -1;
 222   }
 223
 224   return guestfs__config (g, "-cdrom", filename);
 225 }
 226
 227 /* Returns true iff file is contained in dir. */
 228 static int
 229 dir_contains_file (const char *dir, const char *file)
 230 {
 231   int dirlen = strlen (dir);
 232   int filelen = strlen (file);
 233   int len = dirlen+filelen+2;
 234   char path[len];
 235
 236   snprintf (path, len, "%s/%s", dir, file);
 237   return access (path, F_OK) == 0;
 238 }
 239
 240 /* Returns true iff every listed file is contained in 'dir'. */
 241 static int
 242 dir_contains_files (const char *dir, ...)
 243 {
 244   va_list args;
 245   const char *file;
 246
 247   va_start (args, dir);
 248   while ((file = va_arg (args, const char *)) != NULL) {
 249     if (!dir_contains_file (dir, file)) {
 250       va_end (args);
 251       return 0;
 252     }
 253   }
 254   va_end (args);
 255   return 1;
 256 }
 257
 258 static int build_supermin_appliance (guestfs_h *g, const char *path, char **kernel, char **initrd);
 259 static int is_openable (guestfs_h *g, const char *path, int flags);
 260 static void print_cmdline (guestfs_h *g);
 261
 262 static const char *kernel_name = "vmlinuz." REPO "." host_cpu;
 263 static const char *initrd_name = "initramfs." REPO "." host_cpu ".img";
 264
 265 int
 266 guestfs__launch (guestfs_h *g)
 267 {
 268   int r, pmore;
 269   size_t len;
 270   int wfd[2], rfd[2];
 271   int tries;
 272   char *path, *pelem, *pend;
 273   char *kernel = NULL, *initrd = NULL;
 274   int null_vmchannel_sock;
 275   char unixsock[256];
 276   struct sockaddr_un addr;
 277
 278   /* Configured? */
 279   if (!g->cmdline) {
 280     error (g, _("you must call guestfs_add_drive before guestfs_launch"));
 281     return -1;
 282   }
 283
 284   if (g->state != CONFIG) {
 285     error (g, _("the libguestfs handle has already been launched"));
 286     return -1;
 287   }
 288
 289   /* Start the clock ... */
 290   gettimeofday (&g->launch_t, NULL);
 291
 292   /* Make the temporary directory. */
 293   if (!g->tmpdir) {
 294     const char *tmpdir = guestfs___tmpdir ();
 295     char dir_template[strlen (tmpdir) + 32];
 296     sprintf (dir_template, "%s/libguestfsXXXXXX", tmpdir);
 297
 298     g->tmpdir = safe_strdup (g, dir_template);
 299     if (mkdtemp (g->tmpdir) == NULL) {
 300       perrorf (g, _("%s: cannot create temporary directory"), dir_template);
 301       goto cleanup0;
 302     }
 303   }
 304
 305   /* Allow anyone to read the temporary directory.  There are no
 306    * secrets in the kernel or initrd files.  The socket in this
 307    * directory won't be readable but anyone can see it exists if they
 308    * want. (RHBZ#610880).
 309    */
 310   if (chmod (g->tmpdir, 0755) == -1)
 311     fprintf (stderr, "chmod: %s: %m (ignored)\n", g->tmpdir);
 312
 313   /* First search g->path for the supermin appliance, and try to
 314    * synthesize a kernel and initrd from that.  If it fails, we
 315    * try the path search again looking for a backup ordinary
 316    * appliance.
 317    */
 318   pelem = path = safe_strdup (g, g->path);
 319   do {
 320     pend = strchrnul (pelem, ':');
 321     pmore = *pend == ':';
 322     *pend = '\0';
 323     len = pend - pelem;
 324
 325     /* Empty element of "." means cwd. */
 326     if (len == 0 || (len == 1 && *pelem == '.')) {
 327       if (g->verbose)
 328         fprintf (stderr,
 329                  "looking for supermin appliance in current directory\n");
 330       if (dir_contains_files (".",
 331                               "supermin.d", "kmod.whitelist", NULL)) {
 332         if (build_supermin_appliance (g, ".", &kernel, &initrd) == -1)
 333           return -1;
 334         break;
 335       }
 336     }
 337     /* Look at <path>/supermin* etc. */
 338     else {
 339       if (g->verbose)
 340         fprintf (stderr, "looking for supermin appliance in %s\n", pelem);
 341
 342       if (dir_contains_files (pelem,
 343                               "supermin.d", "kmod.whitelist", NULL)) {
 344         if (build_supermin_appliance (g, pelem, &kernel, &initrd) == -1)
 345           return -1;
 346         break;
 347       }
 348     }
 349
 350     pelem = pend + 1;
 351   } while (pmore);
 352
 353   free (path);
 354
 355   if (kernel == NULL || initrd == NULL) {
 356     /* Search g->path for the kernel and initrd. */
 357     pelem = path = safe_strdup (g, g->path);
 358     do {
 359       pend = strchrnul (pelem, ':');
 360       pmore = *pend == ':';
 361       *pend = '\0';
 362       len = pend - pelem;
 363
 364       /* Empty element or "." means cwd. */
 365       if (len == 0 || (len == 1 && *pelem == '.')) {
 366         if (g->verbose)
 367           fprintf (stderr,
 368                    "looking for appliance in current directory\n");
 369         if (dir_contains_files (".", kernel_name, initrd_name, NULL)) {
 370           kernel = safe_strdup (g, kernel_name);
 371           initrd = safe_strdup (g, initrd_name);
 372           break;
 373         }
 374       }
 375       /* Look at <path>/kernel etc. */
 376       else {
 377         if (g->verbose)
 378           fprintf (stderr, "looking for appliance in %s\n", pelem);
 379
 380         if (dir_contains_files (pelem, kernel_name, initrd_name, NULL)) {
 381           kernel = safe_malloc (g, len + strlen (kernel_name) + 2);
 382           initrd = safe_malloc (g, len + strlen (initrd_name) + 2);
 383           sprintf (kernel, "%s/%s", pelem, kernel_name);
 384           sprintf (initrd, "%s/%s", pelem, initrd_name);
 385           break;
 386         }
 387       }
 388
 389       pelem = pend + 1;
 390     } while (pmore);
 391
 392     free (path);
 393   }
 394
 395   if (kernel == NULL || initrd == NULL) {
 396     error (g, _("cannot find %s or %s on LIBGUESTFS_PATH (current path = %s)"),
 397            kernel_name, initrd_name, g->path);
 398     goto cleanup0;
 399   }
 400
 401   if (g->verbose)
 402     guestfs___print_timestamped_message (g, "begin testing qemu features");
 403
 404   /* Get qemu help text and version. */
 405   if (qemu_supports (g, NULL) == -1)
 406     goto cleanup0;
 407
 408   /* Choose which vmchannel implementation to use. */
 409   if (CAN_CHECK_PEER_EUID && qemu_supports (g, "-net user")) {
 410     /* The "null vmchannel" implementation.  Requires SLIRP (user mode
 411      * networking in qemu) but no other vmchannel support.  The daemon
 412      * will connect back to a random port number on localhost.
 413      */
 414     struct sockaddr_in addr;
 415     socklen_t addrlen = sizeof addr;
 416
 417     g->sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
 418     if (g->sock == -1) {
 419       perrorf (g, "socket");
 420       goto cleanup0;
 421     }
 422     addr.sin_family = AF_INET;
 423     addr.sin_port = htons (0);
 424     addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
 425     if (bind (g->sock, (struct sockaddr *) &addr, addrlen) == -1) {
 426       perrorf (g, "bind");
 427       goto cleanup0;
 428     }
 429
 430     if (listen (g->sock, 256) == -1) {
 431       perrorf (g, "listen");
 432       goto cleanup0;
 433     }
 434
 435     if (getsockname (g->sock, (struct sockaddr *) &addr, &addrlen) == -1) {
 436       perrorf (g, "getsockname");
 437       goto cleanup0;
 438     }
 439
 440     if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) {
 441       perrorf (g, "fcntl");
 442       goto cleanup0;
 443     }
 444
 445     null_vmchannel_sock = ntohs (addr.sin_port);
 446     if (g->verbose)
 447       fprintf (stderr, "null_vmchannel_sock = %d\n", null_vmchannel_sock);
 448   } else {
 449     /* Using some vmchannel impl.  We need to create a local Unix
 450      * domain socket for qemu to use.
 451      */
 452     snprintf (unixsock, sizeof unixsock, "%s/sock", g->tmpdir);
 453     unlink (unixsock);
 454     null_vmchannel_sock = 0;
 455   }
 456
 457   if (!g->direct) {
 458     if (pipe (wfd) == -1 || pipe (rfd) == -1) {
 459       perrorf (g, "pipe");
 460       goto cleanup0;
 461     }
 462   }
 463
 464   if (g->verbose)
 465     guestfs___print_timestamped_message (g, "finished testing qemu features");
 466
 467   r = fork ();
 468   if (r == -1) {
 469     perrorf (g, "fork");
 470     if (!g->direct) {
 471       close (wfd[0]);
 472       close (wfd[1]);
 473       close (rfd[0]);
 474       close (rfd[1]);
 475     }
 476     goto cleanup0;
 477   }
 478
 479   if (r == 0) {                 /* Child (qemu). */
 480     char buf[256];
 481     const char *vmchannel = NULL;
 482
 483     /* Set up the full command line.  Do this in the subprocess so we
 484      * don't need to worry about cleaning up.
 485      */
 486     g->cmdline[0] = g->qemu;
 487
 488     if (qemu_supports (g, "-nodefconfig"))
 489       add_cmdline (g, "-nodefconfig");
 490
 491     /* qemu sometimes needs this option to enable hardware
 492      * virtualization, but some versions of 'qemu-kvm' will use KVM
 493      * regardless (even where this option appears in the help text).
 494      * It is rumoured that there are versions of qemu where supplying
 495      * this option when hardware virtualization is not available will
 496      * cause qemu to fail, so we we have to check at least that
 497      * /dev/kvm is openable.  That's not reliable, since /dev/kvm
 498      * might be openable by qemu but not by us (think: SELinux) in
 499      * which case the user would not get hardware virtualization,
 500      * although at least shouldn't fail.  A giant clusterfuck with the
 501      * qemu command line, again.
 502      */
 503     if (qemu_supports (g, "-enable-kvm") &&
 504         is_openable (g, "/dev/kvm", O_RDWR))
 505       add_cmdline (g, "-enable-kvm");
 506
 507     /* Newer versions of qemu (from around 2009/12) changed the
 508      * behaviour of monitors so that an implicit '-monitor stdio' is
 509      * assumed if we are in -nographic mode and there is no other
 510      * -monitor option.  Only a single stdio device is allowed, so
 511      * this broke the '-serial stdio' option.  There is a new flag
 512      * called -nodefaults which gets rid of all this default crud, so
 513      * let's use that to avoid this and any future surprises.
 514      */
 515     if (qemu_supports (g, "-nodefaults"))
 516       add_cmdline (g, "-nodefaults");
 517
 518     add_cmdline (g, "-nographic");
 519     add_cmdline (g, "-serial");
 520     add_cmdline (g, "stdio");
 521
 522     snprintf (buf, sizeof buf, "%d", g->memsize);
 523     add_cmdline (g, "-m");
 524     add_cmdline (g, buf);
 525
 526     /* Force exit instead of reboot on panic */
 527     add_cmdline (g, "-no-reboot");
 528
 529     /* These options recommended by KVM developers to improve reliability. */
 530     if (qemu_supports (g, "-no-hpet"))
 531       add_cmdline (g, "-no-hpet");
 532
 533     if (qemu_supports (g, "-rtc-td-hack"))
 534       add_cmdline (g, "-rtc-td-hack");
 535
 536     /* If qemu has SLIRP (user mode network) enabled then we can get
 537      * away with "no vmchannel", where we just connect back to a random
 538      * host port.
 539      */
 540     if (null_vmchannel_sock) {
 541       add_cmdline (g, "-net");
 542       add_cmdline (g, "user,vlan=0,net=" NETWORK);
 543
 544       snprintf (buf, sizeof buf,
 545                 "guestfs_vmchannel=tcp:" ROUTER ":%d",
 546                 null_vmchannel_sock);
 547       vmchannel = strdup (buf);
 548     }
 549
 550     /* New-style -net user,guestfwd=... syntax for guestfwd.  See:
 551      *
 552      * http://git.savannah.gnu.org/cgit/qemu.git/commit/?id=c92ef6a22d3c71538fcc48fb61ad353f7ba03b62
 553      *
 554      * The original suggested format doesn't work, see:
 555      *
 556      * http://lists.gnu.org/archive/html/qemu-devel/2009-07/msg01654.html
 557      *
 558      * However Gerd Hoffman privately suggested to me using -chardev
 559      * instead, which does work.
 560      */
 561     else if (qemu_supports (g, "-chardev") && qemu_supports (g, "guestfwd")) {
 562       snprintf (buf, sizeof buf,
 563                 "socket,id=guestfsvmc,path=%s,server,nowait", unixsock);
 564
 565       add_cmdline (g, "-chardev");
 566       add_cmdline (g, buf);
 567
 568       snprintf (buf, sizeof buf,
 569                 "user,vlan=0,net=" NETWORK ","
 570                 "guestfwd=tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT
 571                 "-chardev:guestfsvmc");
 572
 573       add_cmdline (g, "-net");
 574       add_cmdline (g, buf);
 575
 576       vmchannel = "guestfs_vmchannel=tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT;
 577     }
 578
 579     /* Not guestfwd.  HOPEFULLY this qemu uses the older -net channel
 580      * syntax, or if not then we'll get a quick failure.
 581      */
 582     else {
 583       snprintf (buf, sizeof buf,
 584                 "channel," GUESTFWD_PORT ":unix:%s,server,nowait", unixsock);
 585
 586       add_cmdline (g, "-net");
 587       add_cmdline (g, buf);
 588       add_cmdline (g, "-net");
 589       add_cmdline (g, "user,vlan=0,net=" NETWORK);
 590
 591       vmchannel = "guestfs_vmchannel=tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT;
 592     }
 593     add_cmdline (g, "-net");
 594     add_cmdline (g, "nic,model=" NET_IF ",vlan=0");
 595
 596 #define LINUX_CMDLINE                                                   \
 597     "panic=1 "         /* force kernel to panic if daemon exits */      \
 598     "console=ttyS0 "   /* serial console */                             \
 599     "udevtimeout=300 " /* good for very slow systems (RHBZ#480319) */   \
 600     "noapic "          /* workaround for RHBZ#502058 - ok if not SMP */ \
 601     "acpi=off "        /* we don't need ACPI, turn it off */            \
 602     "printk.time=1 "   /* display timestamp before kernel messages */   \
 603     "cgroup_disable=memory " /* saves us about 5 MB of RAM */
 604
 605     /* Linux kernel command line. */
 606     snprintf (buf, sizeof buf,
 607               LINUX_CMDLINE
 608               "%s "             /* (selinux) */
 609               "%s "             /* (vmchannel) */
 610               "%s "             /* (verbose) */
 611               "TERM=%s "        /* (TERM environment variable) */
 612               "%s",             /* (append) */
 613               g->selinux ? "selinux=1 enforcing=0" : "selinux=0",
 614               vmchannel ? vmchannel : "",
 615               g->verbose ? "guestfs_verbose=1" : "",
 616               getenv ("TERM") ? : "linux",
 617               g->append ? g->append : "");
 618
 619     add_cmdline (g, "-kernel");
 620     add_cmdline (g, (char *) kernel);
 621     add_cmdline (g, "-initrd");
 622     add_cmdline (g, (char *) initrd);
 623     add_cmdline (g, "-append");
 624     add_cmdline (g, buf);
 625
 626     /* Finish off the command line. */
 627     incr_cmdline_size (g);
 628     g->cmdline[g->cmdline_size-1] = NULL;
 629
 630     if (g->verbose)
 631       print_cmdline (g);
 632
 633     if (!g->direct) {
 634       /* Set up stdin, stdout. */
 635       close (0);
 636       close (1);
 637       close (wfd[1]);
 638       close (rfd[0]);
 639
 640       if (dup (wfd[0]) == -1) {
 641       dup_failed:
 642         perror ("dup failed");
 643         _exit (EXIT_FAILURE);
 644       }
 645       if (dup (rfd[1]) == -1)
 646         goto dup_failed;
 647
 648       close (wfd[0]);
 649       close (rfd[1]);
 650     }
 651
 652 #if 0
 653     /* Set up a new process group, so we can signal this process
 654      * and all subprocesses (eg. if qemu is really a shell script).
 655      */
 656     setpgid (0, 0);
 657 #endif
 658
 659     setenv ("LC_ALL", "C", 1);
 660
 661     execv (g->qemu, g->cmdline); /* Run qemu. */
 662     perror (g->qemu);
 663     _exit (EXIT_FAILURE);
 664   }
 665
 666   /* Parent (library). */
 667   g->pid = r;
 668
 669   free (kernel);
 670   kernel = NULL;
 671   free (initrd);
 672   initrd = NULL;
 673
 674   /* Fork the recovery process off which will kill qemu if the parent
 675    * process fails to do so (eg. if the parent segfaults).
 676    */
 677   g->recoverypid = -1;
 678   if (g->recovery_proc) {
 679     r = fork ();
 680     if (r == 0) {
 681       pid_t qemu_pid = g->pid;
 682       pid_t parent_pid = getppid ();
 683
 684       /* Writing to argv is hideously complicated and error prone.  See:
 685        * http://anoncvs.postgresql.org/cvsweb.cgi/pgsql/src/backend/utils/misc/ps_status.c?rev=1.33.2.1;content-type=text%2Fplain
 686        */
 687
 688       /* Loop around waiting for one or both of the other processes to
 689        * disappear.  It's fair to say this is very hairy.  The PIDs that
 690        * we are looking at might be reused by another process.  We are
 691        * effectively polling.  Is the cure worse than the disease?
 692        */
 693       for (;;) {
 694         if (kill (qemu_pid, 0) == -1) /* qemu's gone away, we aren't needed */
 695           _exit (EXIT_SUCCESS);
 696         if (kill (parent_pid, 0) == -1) {
 697           /* Parent's gone away, qemu still around, so kill qemu. */
 698           kill (qemu_pid, 9);
 699           _exit (EXIT_SUCCESS);
 700         }
 701         sleep (2);
 702       }
 703     }
 704
 705     /* Don't worry, if the fork failed, this will be -1.  The recovery
 706      * process isn't essential.
 707      */
 708     g->recoverypid = r;
 709   }
 710
 711   if (!g->direct) {
 712     /* Close the other ends of the pipe. */
 713     close (wfd[0]);
 714     close (rfd[1]);
 715
 716     if (fcntl (wfd[1], F_SETFL, O_NONBLOCK) == -1 ||
 717         fcntl (rfd[0], F_SETFL, O_NONBLOCK) == -1) {
 718       perrorf (g, "fcntl");
 719       goto cleanup1;
 720     }
 721
 722     g->fd[0] = wfd[1];          /* stdin of child */
 723     g->fd[1] = rfd[0];          /* stdout of child */
 724   } else {
 725     g->fd[0] = open ("/dev/null", O_RDWR);
 726     if (g->fd[0] == -1) {
 727       perrorf (g, "open /dev/null");
 728       goto cleanup1;
 729     }
 730     g->fd[1] = dup (g->fd[0]);
 731     if (g->fd[1] == -1) {
 732       perrorf (g, "dup");
 733       close (g->fd[0]);
 734       goto cleanup1;
 735     }
 736   }
 737
 738   if (null_vmchannel_sock) {
 739     int sock = -1;
 740     uid_t uid;
 741
 742     /* Null vmchannel implementation: We listen on g->sock for a
 743      * connection.  The connection could come from any local process
 744      * so we must check it comes from the appliance (or at least
 745      * from our UID) for security reasons.
 746      */
 747     while (sock == -1) {
 748       sock = guestfs___accept_from_daemon (g);
 749       if (sock == -1)
 750         goto cleanup1;
 751
 752       if (check_peer_euid (g, sock, &uid) == -1)
 753         goto cleanup1;
 754       if (uid != geteuid ()) {
 755         fprintf (stderr,
 756                  "libguestfs: warning: unexpected connection from UID %d to port %d\n",
 757                  uid, null_vmchannel_sock);
 758         close (sock);
 759         sock = -1;
 760         continue;
 761       }
 762     }
 763
 764     if (fcntl (sock, F_SETFL, O_NONBLOCK) == -1) {
 765       perrorf (g, "fcntl");
 766       goto cleanup1;
 767     }
 768
 769     close (g->sock);
 770     g->sock = sock;
 771   } else {
 772     /* Other vmchannel.  Open the Unix socket.
 773      *
 774      * The vmchannel implementation that got merged with qemu sucks in
 775      * a number of ways.  Both ends do connect(2), which means that no
 776      * one knows what, if anything, is connected to the other end, or
 777      * if it becomes disconnected.  Even worse, we have to wait some
 778      * indeterminate time for qemu to create the socket and connect to
 779      * it (which happens very early in qemu's start-up), so any code
 780      * that uses vmchannel is inherently racy.  Hence this silly loop.
 781      */
 782     g->sock = socket (AF_UNIX, SOCK_STREAM, 0);
 783     if (g->sock == -1) {
 784       perrorf (g, "socket");
 785       goto cleanup1;
 786     }
 787
 788     if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) {
 789       perrorf (g, "fcntl");
 790       goto cleanup1;
 791     }
 792
 793     addr.sun_family = AF_UNIX;
 794     strncpy (addr.sun_path, unixsock, UNIX_PATH_MAX);
 795     addr.sun_path[UNIX_PATH_MAX-1] = '\0';
 796
 797     tries = 100;
 798     /* Always sleep at least once to give qemu a small chance to start up. */
 799     usleep (10000);
 800     while (tries > 0) {
 801       r = connect (g->sock, (struct sockaddr *) &addr, sizeof addr);
 802       if ((r == -1 && errno == EINPROGRESS) || r == 0)
 803         goto connected;
 804
 805       if (errno != ENOENT)
 806         perrorf (g, "connect");
 807       tries--;
 808       usleep (100000);
 809     }
 810
 811     error (g, _("failed to connect to vmchannel socket"));
 812     goto cleanup1;
 813
 814   connected: ;
 815   }
 816
 817   g->state = LAUNCHING;
 818
 819   /* Wait for qemu to start and to connect back to us via vmchannel and
 820    * send the GUESTFS_LAUNCH_FLAG message.
 821    */
 822   uint32_t size;
 823   void *buf = NULL;
 824   r = guestfs___recv_from_daemon (g, &size, &buf);
 825   free (buf);
 826
 827   if (r == -1) return -1;
 828
 829   if (size != GUESTFS_LAUNCH_FLAG) {
 830     error (g, _("guestfs_launch failed, see earlier error messages"));
 831     goto cleanup1;
 832   }
 833
 834   if (g->verbose)
 835     guestfs___print_timestamped_message (g, "appliance is up");
 836
 837   /* This is possible in some really strange situations, such as
 838    * guestfsd starts up OK but then qemu immediately exits.  Check for
 839    * it because the caller is probably expecting to be able to send
 840    * commands after this function returns.
 841    */
 842   if (g->state != READY) {
 843     error (g, _("qemu launched and contacted daemon, but state != READY"));
 844     goto cleanup1;
 845   }
 846
 847   return 0;
 848
 849  cleanup1:
 850   if (!g->direct) {
 851     close (wfd[1]);
 852     close (rfd[0]);
 853   }
 854   if (g->pid > 0) kill (g->pid, 9);
 855   if (g->recoverypid > 0) kill (g->recoverypid, 9);
 856   waitpid (g->pid, NULL, 0);
 857   if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0);
 858   g->fd[0] = -1;
 859   g->fd[1] = -1;
 860   g->pid = 0;
 861   g->recoverypid = 0;
 862   memset (&g->launch_t, 0, sizeof g->launch_t);
 863
 864  cleanup0:
 865   if (g->sock >= 0) {
 866     close (g->sock);
 867     g->sock = -1;
 868   }
 869   g->state = CONFIG;
 870   free (kernel);
 871   free (initrd);
 872   return -1;
 873 }
 874
 875 const char *
 876 guestfs___tmpdir (void)
 877 {
 878   const char *tmpdir;
 879
 880 #ifdef P_tmpdir
 881   tmpdir = P_tmpdir;
 882 #else
 883   tmpdir = "/tmp";
 884 #endif
 885
 886   const char *t = getenv ("TMPDIR");
 887   if (t) tmpdir = t;
 888
 889   return tmpdir;
 890 }
 891
 892 /* This function is used to print the qemu command line before it gets
 893  * executed, when in verbose mode.
 894  */
 895 static void
 896 print_cmdline (guestfs_h *g)
 897 {
 898   int i = 0;
 899   int needs_quote;
 900
 901   while (g->cmdline[i]) {
 902     if (g->cmdline[i][0] == '-') /* -option starts a new line */
 903       fprintf (stderr, " \\\n   ");
 904
 905     if (i > 0) fputc (' ', stderr);
 906
 907     /* Does it need shell quoting?  This only deals with simple cases. */
 908     needs_quote = strcspn (g->cmdline[i], " ") != strlen (g->cmdline[i]);
 909
 910     if (needs_quote) fputc ('\'', stderr);
 911     fprintf (stderr, "%s", g->cmdline[i]);
 912     if (needs_quote) fputc ('\'', stderr);
 913     i++;
 914   }
 915
 916   fputc ('\n', stderr);
 917 }
 918
 919 /* This function does the hard work of building the supermin appliance
 920  * on the fly.  'path' is the directory containing the control files.
 921  * 'kernel' and 'initrd' are where we will return the names of the
 922  * kernel and initrd (only initrd is built).  The work is done by
 923  * an external script.  We just tell it where to put the result.
 924  */
 925 static int
 926 build_supermin_appliance (guestfs_h *g, const char *path,
 927                           char **kernel, char **initrd)
 928 {
 929   char cmd[4096];
 930   int r, len;
 931
 932   if (g->verbose)
 933     guestfs___print_timestamped_message (g, "begin building supermin appliance");
 934
 935   len = strlen (g->tmpdir);
 936   *kernel = safe_malloc (g, len + 8);
 937   snprintf (*kernel, len+8, "%s/kernel", g->tmpdir);
 938   *initrd = safe_malloc (g, len + 8);
 939   snprintf (*initrd, len+8, "%s/initrd", g->tmpdir);
 940
 941   /* Set a sensible umask in the subprocess, so kernel and initrd
 942    * output files are world-readable (RHBZ#610880).
 943    */
 944   snprintf (cmd, sizeof cmd,
 945             "umask 0002; "
 946             "febootstrap-supermin-helper%s "
 947             "-k '%s/kmod.whitelist' "
 948             "'%s/supermin.d' "
 949             host_cpu " "
 950             "%s %s",
 951             g->verbose ? " --verbose" : "",
 952             path,
 953             path,
 954             *kernel, *initrd);
 955   if (g->verbose)
 956     guestfs___print_timestamped_message (g, "%s", cmd);
 957
 958   r = system (cmd);
 959   if (r == -1 || WEXITSTATUS(r) != 0) {
 960     error (g, _("external command failed: %s"), cmd);
 961     free (*kernel);
 962     free (*initrd);
 963     *kernel = *initrd = NULL;
 964     return -1;
 965   }
 966
 967   if (g->verbose)
 968     guestfs___print_timestamped_message (g, "finished building supermin appliance");
 969
 970   return 0;
 971 }
 972
 973 /* Compute Y - X and return the result in milliseconds.
 974  * Approximately the same as this code:
 975  * http://www.mpp.mpg.de/~huber/util/timevaldiff.c
 976  */
 977 static int64_t
 978 timeval_diff (const struct timeval *x, const struct timeval *y)
 979 {
 980   int64_t msec;
 981
 982   msec = (y->tv_sec - x->tv_sec) * 1000;
 983   msec += (y->tv_usec - x->tv_usec) / 1000;
 984   return msec;
 985 }
 986
 987 void
 988 guestfs___print_timestamped_message (guestfs_h *g, const char *fs, ...)
 989 {
 990   va_list args;
 991   char *msg;
 992   int err;
 993   struct timeval tv;
 994
 995   va_start (args, fs);
 996   err = vasprintf (&msg, fs, args);
 997   va_end (args);
 998
 999   if (err < 0) return;
1000
1001   gettimeofday (&tv, NULL);
1002
1003   fprintf (stderr, "[%05" PRIi64 "ms] %s\n",
1004            timeval_diff (&g->launch_t, &tv), msg);
1005
1006   free (msg);
1007 }
1008
1009 static int read_all (guestfs_h *g, FILE *fp, char **ret);
1010
1011 /* Test qemu binary (or wrapper) runs, and do 'qemu -help' and
1012  * 'qemu -version' so we know what options this qemu supports and
1013  * the version.
1014  */
1015 static int
1016 test_qemu (guestfs_h *g)
1017 {
1018   char cmd[1024];
1019   FILE *fp;
1020
1021   snprintf (cmd, sizeof cmd, "LC_ALL=C '%s' -nographic -help", g->qemu);
1022
1023   fp = popen (cmd, "r");
1024   /* qemu -help should always work (qemu -version OTOH wasn't
1025    * supported by qemu 0.9).  If this command doesn't work then it
1026    * probably indicates that the qemu binary is missing.
1027    */
1028   if (!fp) {
1029     /* XXX This error is never printed, even if the qemu binary
1030      * doesn't exist.  Why?
1031      */
1032   error:
1033     perrorf (g, _("%s: command failed: If qemu is located on a non-standard path, try setting the LIBGUESTFS_QEMU environment variable."), cmd);
1034     return -1;
1035   }
1036
1037   if (read_all (g, fp, &g->qemu_help) == -1)
1038     goto error;
1039
1040   if (pclose (fp) == -1)
1041     goto error;
1042
1043   snprintf (cmd, sizeof cmd, "LC_ALL=C '%s' -nographic -version 2>/dev/null",
1044             g->qemu);
1045
1046   fp = popen (cmd, "r");
1047   if (fp) {
1048     /* Intentionally ignore errors. */
1049     read_all (g, fp, &g->qemu_version);
1050     pclose (fp);
1051   }
1052
1053   return 0;
1054 }
1055
1056 static int
1057 read_all (guestfs_h *g, FILE *fp, char **ret)
1058 {
1059   int r, n = 0;
1060   char *p;
1061
1062  again:
1063   if (feof (fp)) {
1064     *ret = safe_realloc (g, *ret, n + 1);
1065     (*ret)[n] = '\0';
1066     return n;
1067   }
1068
1069   *ret = safe_realloc (g, *ret, n + BUFSIZ);
1070   p = &(*ret)[n];
1071   r = fread (p, 1, BUFSIZ, fp);
1072   if (ferror (fp)) {
1073     perrorf (g, "read");
1074     return -1;
1075   }
1076   n += r;
1077   goto again;
1078 }
1079
1080 /* Test if option is supported by qemu command line (just by grepping
1081  * the help text).
1082  *
1083  * The first time this is used, it has to run the external qemu
1084  * binary.  If that fails, it returns -1.
1085  *
1086  * To just do the first-time run of the qemu binary, call this with
1087  * option == NULL, in which case it will return -1 if there was an
1088  * error doing that.
1089  */
1090 static int
1091 qemu_supports (guestfs_h *g, const char *option)
1092 {
1093   if (!g->qemu_help) {
1094     if (test_qemu (g) == -1)
1095       return -1;
1096   }
1097
1098   if (option == NULL)
1099     return 1;
1100
1101   return strstr (g->qemu_help, option) != NULL;
1102 }
1103
1104 /* Check if a file can be opened. */
1105 static int
1106 is_openable (guestfs_h *g, const char *path, int flags)
1107 {
1108   int fd = open (path, flags);
1109   if (fd == -1) {
1110     if (g->verbose)
1111       perror (path);
1112     return 0;
1113   }
1114   close (fd);
1115   return 1;
1116 }
1117
1118 /* Check the peer effective UID for a TCP socket.  Ideally we'd like
1119  * SO_PEERCRED for a loopback TCP socket.  This isn't possible on
1120  * Linux (but it is on Solaris!) so we read /proc/net/tcp instead.
1121  */
1122 static int
1123 check_peer_euid (guestfs_h *g, int sock, uid_t *rtn)
1124 {
1125 #if CAN_CHECK_PEER_EUID
1126   struct sockaddr_in peer;
1127   socklen_t addrlen = sizeof peer;
1128
1129   if (getpeername (sock, (struct sockaddr *) &peer, &addrlen) == -1) {
1130     perrorf (g, "getpeername");
1131     return -1;
1132   }
1133
1134   if (peer.sin_family != AF_INET ||
1135       ntohl (peer.sin_addr.s_addr) != INADDR_LOOPBACK) {
1136     error (g, "check_peer_euid: unexpected connection from non-IPv4, non-loopback peer (family = %d, addr = %s)",
1137            peer.sin_family, inet_ntoa (peer.sin_addr));
1138     return -1;
1139   }
1140
1141   struct sockaddr_in our;
1142   addrlen = sizeof our;
1143   if (getsockname (sock, (struct sockaddr *) &our, &addrlen) == -1) {
1144     perrorf (g, "getsockname");
1145     return -1;
1146   }
1147
1148   FILE *fp = fopen ("/proc/net/tcp", "r");
1149   if (fp == NULL) {
1150     perrorf (g, "/proc/net/tcp");
1151     return -1;
1152   }
1153
1154   char line[256];
1155   if (fgets (line, sizeof line, fp) == NULL) { /* Drop first line. */
1156     error (g, "unexpected end of file in /proc/net/tcp");
1157     fclose (fp);
1158     return -1;
1159   }
1160
1161   while (fgets (line, sizeof line, fp) != NULL) {
1162     unsigned line_our_addr, line_our_port, line_peer_addr, line_peer_port;
1163     int dummy0, dummy1, dummy2, dummy3, dummy4, dummy5, dummy6;
1164     int line_uid;
1165
1166     if (sscanf (line, "%d:%08X:%04X %08X:%04X %02X %08X:%08X %02X:%08X %08X %d",
1167                 &dummy0,
1168                 &line_our_addr, &line_our_port,
1169                 &line_peer_addr, &line_peer_port,
1170                 &dummy1, &dummy2, &dummy3, &dummy4, &dummy5, &dummy6,
1171                 &line_uid) == 12) {
1172       /* Note about /proc/net/tcp: local_address and rem_address are
1173        * always in network byte order.  However the port part is
1174        * always in host byte order.
1175        *
1176        * The sockname and peername that we got above are in network
1177        * byte order.  So we have to byte swap the port but not the
1178        * address part.
1179        */
1180       if (line_our_addr == our.sin_addr.s_addr &&
1181           line_our_port == ntohs (our.sin_port) &&
1182           line_peer_addr == peer.sin_addr.s_addr &&
1183           line_peer_port == ntohs (peer.sin_port)) {
1184         *rtn = line_uid;
1185         fclose (fp);
1186         return 0;
1187       }
1188     }
1189   }
1190
1191   error (g, "check_peer_euid: no matching TCP connection found in /proc/net/tcp");
1192   fclose (fp);
1193   return -1;
1194 #else /* !CAN_CHECK_PEER_EUID */
1195   /* This function exists but should never be called in this
1196    * configuration.
1197    */
1198   abort ();
1199 #endif /* !CAN_CHECK_PEER_EUID */
1200 }
1201
1202 /* You had to call this function after launch in versions <= 1.0.70,
1203  * but it is now a no-op.
1204  */
1205 int
1206 guestfs__wait_ready (guestfs_h *g)
1207 {
1208   if (g->state != READY)  {
1209     error (g, _("qemu has not been launched yet"));
1210     return -1;
1211   }
1212
1213   return 0;
1214 }
1215
1216 int
1217 guestfs__kill_subprocess (guestfs_h *g)
1218 {
1219   if (g->state == CONFIG) {
1220     error (g, _("no subprocess to kill"));
1221     return -1;
1222   }
1223
1224   if (g->verbose)
1225     fprintf (stderr, "sending SIGTERM to process %d\n", g->pid);
1226
1227   if (g->pid > 0) kill (g->pid, SIGTERM);
1228   if (g->recoverypid > 0) kill (g->recoverypid, 9);
1229
1230   return 0;
1231 }
1232
1233 /* Access current state. */
1234 int
1235 guestfs__is_config (guestfs_h *g)
1236 {
1237   return g->state == CONFIG;
1238 }
1239
1240 int
1241 guestfs__is_launching (guestfs_h *g)
1242 {
1243   return g->state == LAUNCHING;
1244 }
1245
1246 int
1247 guestfs__is_ready (guestfs_h *g)
1248 {
1249   return g->state == READY;
1250 }
1251
1252 int
1253 guestfs__is_busy (guestfs_h *g)
1254 {
1255   return g->state == BUSY;
1256 }
1257
1258 int
1259 guestfs__get_state (guestfs_h *g)
1260 {
1261   return g->state;
1262 }