daemon/guestfsd.c

   1 /* libguestfs - the guestfsd daemon
   2  * Copyright (C) 2009-2010 Red Hat Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program 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
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 #include <config.h>
  20
  21 #define _BSD_SOURCE             /* for daemon(3) */
  22
  23 #ifdef HAVE_WINDOWS_H
  24 # include <windows.h>
  25 #endif
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31 #include <rpc/types.h>
  32 #include <rpc/xdr.h>
  33 #include <getopt.h>
  34 #include <sys/param.h>
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <fcntl.h>
  38 #include <signal.h>
  39 #include <netdb.h>
  40 #include <sys/select.h>
  41 #include <sys/wait.h>
  42 #include <arpa/inet.h>
  43 #include <netinet/in.h>
  44 #include <errno.h>
  45
  46 #ifdef HAVE_PRINTF_H
  47 # include <printf.h>
  48 #endif
  49
  50 #include "sockets.h"
  51 #include "c-ctype.h"
  52 #include "ignore-value.h"
  53 #include "error.h"
  54
  55 #include "daemon.h"
  56
  57 static char *read_cmdline (void);
  58
  59 /* This is the default address we connect to for very old libraries
  60  * which didn't specify the address and port number explicitly on the
  61  * kernel command line.  It's now recommended to always specify the
  62  * address and port number on the command line, so this will not be
  63  * used any more.
  64  */
  65 #define OLD_GUESTFWD_ADDR "10.0.2.4"
  66 #define OLD_GUESTFWD_PORT "6666"
  67
  68 /* This is only a hint.  If not defined, ignore it. */
  69 #ifndef AI_ADDRCONFIG
  70 # define AI_ADDRCONFIG 0
  71 #endif
  72
  73 #ifndef MAX
  74 # define MAX(a,b) ((a)>(b)?(a):(b))
  75 #endif
  76
  77 /* If root device is an ext2 filesystem, this is the major and minor.
  78  * This is so we can ignore this device from the point of view of the
  79  * user, eg. in guestfs_list_devices and many other places.
  80  */
  81 static dev_t root_device = 0;
  82
  83 int verbose = 0;
  84
  85 static int print_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
  86 static int print_sysroot_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
  87 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
  88 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes, int *size);
  89 #else
  90 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
  91 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes);
  92 #else
  93 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
  94 #endif
  95 #endif
  96
  97 #ifdef WIN32
  98 static int
  99 daemon (int nochdir, int noclose)
 100 {
 101   fprintf (stderr,
 102            "On Windows the daemon does not support forking into the "
 103            "background.\nYou *must* run the daemon with the -f option.\n");
 104   exit (EXIT_FAILURE);
 105 }
 106 #endif /* WIN32 */
 107
 108 #ifdef WIN32
 109 static int
 110 winsock_init (void)
 111 {
 112   int r;
 113
 114   /* http://msdn2.microsoft.com/en-us/library/ms742213.aspx */
 115   r = gl_sockets_startup (SOCKETS_2_2);
 116   return r == 0 ? 0 : -1;
 117 }
 118 #else /* !WIN32 */
 119 static int
 120 winsock_init (void)
 121 {
 122   return 0;
 123 }
 124 #endif /* !WIN32 */
 125
 126 /* Location to mount root device. */
 127 const char *sysroot = "/sysroot"; /* No trailing slash. */
 128 int sysroot_len = 8;
 129
 130 /* Not used explicitly, but required by the gnulib 'error' module. */
 131 const char *program_name = "guestfsd";
 132
 133 static void
 134 usage (void)
 135 {
 136   fprintf (stderr,
 137     "guestfsd [-f|--foreground] [-c|--channel vmchannel] [-v|--verbose]\n");
 138 }
 139
 140 int
 141 main (int argc, char *argv[])
 142 {
 143   static const char *options = "fc:v?";
 144   static const struct option long_options[] = {
 145     { "channel", required_argument, 0, 'c' },
 146     { "foreground", 0, 0, 'f' },
 147     { "help", 0, 0, '?' },
 148     { "verbose", 0, 0, 'v' },
 149     { 0, 0, 0, 0 }
 150   };
 151   int c;
 152   int dont_fork = 0;
 153   char *cmdline;
 154   char *vmchannel = NULL;
 155
 156   if (winsock_init () == -1)
 157     error (EXIT_FAILURE, 0, "winsock initialization failed");
 158
 159 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
 160   /* http://udrepper.livejournal.com/20948.html */
 161   register_printf_specifier ('Q', print_shell_quote, print_arginfo);
 162   register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
 163 #else
 164 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
 165   register_printf_function ('Q', print_shell_quote, print_arginfo);
 166   register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
 167 #else
 168 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
 169 #endif
 170 #endif
 171
 172   struct stat statbuf;
 173   if (stat ("/", &statbuf) == 0)
 174     root_device = statbuf.st_dev;
 175
 176   for (;;) {
 177     c = getopt_long (argc, argv, options, long_options, NULL);
 178     if (c == -1) break;
 179
 180     switch (c) {
 181     case 'c':
 182       vmchannel = optarg;
 183       break;
 184
 185     case 'f':
 186       dont_fork = 1;
 187       break;
 188
 189     case 'v':
 190       verbose = 1;
 191       break;
 192
 193     case '?':
 194       usage ();
 195       exit (EXIT_SUCCESS);
 196
 197     default:
 198       fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
 199       exit (EXIT_FAILURE);
 200     }
 201   }
 202
 203   if (optind < argc) {
 204     usage ();
 205     exit (EXIT_FAILURE);
 206   }
 207
 208   cmdline = read_cmdline ();
 209
 210   /* Set the verbose flag. */
 211   verbose = verbose ||
 212     (cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
 213   if (verbose)
 214     printf ("verbose daemon enabled\n");
 215
 216   if (verbose) {
 217     if (cmdline)
 218       printf ("linux commmand line: %s\n", cmdline);
 219     else
 220       printf ("could not read linux command line\n");
 221   }
 222
 223 #ifndef WIN32
 224   /* Make sure SIGPIPE doesn't kill us. */
 225   struct sigaction sa;
 226   memset (&sa, 0, sizeof sa);
 227   sa.sa_handler = SIG_IGN;
 228   sa.sa_flags = 0;
 229   if (sigaction (SIGPIPE, &sa, NULL) == -1)
 230     perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
 231 #endif
 232
 233 #ifdef WIN32
 234 # define setenv(n,v,f) _putenv(n "=" v)
 235 #endif
 236   /* Set up a basic environment.  After we are called by /init the
 237    * environment is essentially empty.
 238    * https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
 239    *
 240    * NOTE: if you change $PATH, you must also change 'prog_exists'
 241    * function below.
 242    */
 243   setenv ("PATH", "/sbin:/usr/sbin:/bin:/usr/bin", 1);
 244   setenv ("SHELL", "/bin/sh", 1);
 245   setenv ("LC_ALL", "C", 1);
 246   setenv ("TERM", "dumb", 1);
 247
 248 #ifndef WIN32
 249   /* We document that umask defaults to 022 (it should be this anyway). */
 250   umask (022);
 251 #else
 252   /* This is the default for Windows anyway.  It's not even clear if
 253    * Windows ever uses this -- the MSDN documentation for the function
 254    * contains obvious errors.
 255    */
 256   _umask (0);
 257 #endif
 258
 259   /* Get the vmchannel string.
 260    *
 261    * Sources:
 262    *   --channel/-c option on the command line
 263    *   guestfs_vmchannel=... from the kernel command line
 264    *   guestfs=... from the kernel command line
 265    *   built-in default
 266    *
 267    * At the moment we expect this to contain "tcp:ip:port" but in
 268    * future it might contain a device name, eg. "/dev/vcon4" for
 269    * virtio-console vmchannel.
 270    */
 271   if (vmchannel == NULL && cmdline) {
 272     char *p;
 273     size_t len;
 274
 275     p = strstr (cmdline, "guestfs_vmchannel=");
 276     if (p) {
 277       len = strcspn (p + 18, " \t\n");
 278       vmchannel = strndup (p + 18, len);
 279       if (!vmchannel) {
 280         perror ("strndup");
 281         exit (EXIT_FAILURE);
 282       }
 283     }
 284
 285     /* Old libraries passed guestfs=host:port.  Rewrite it as tcp:host:port. */
 286     if (vmchannel == NULL) {
 287       /* We will rewrite it part of the "guestfs=" string with
 288        *                       "tcp:"       hence p + 4 below.    */
 289       p = strstr (cmdline, "guestfs=");
 290       if (p) {
 291         len = strcspn (p + 4, " \t\n");
 292         vmchannel = strndup (p + 4, len);
 293         if (!vmchannel) {
 294           perror ("strndup");
 295           exit (EXIT_FAILURE);
 296         }
 297         memcpy (vmchannel, "tcp:", 4);
 298       }
 299     }
 300   }
 301
 302   /* Default vmchannel. */
 303   if (vmchannel == NULL) {
 304     vmchannel = strdup ("tcp:" OLD_GUESTFWD_ADDR ":" OLD_GUESTFWD_PORT);
 305     if (!vmchannel) {
 306       perror ("strdup");
 307       exit (EXIT_FAILURE);
 308     }
 309   }
 310
 311   if (verbose)
 312     printf ("vmchannel: %s\n", vmchannel);
 313
 314   /* Connect to vmchannel. */
 315   int sock = -1;
 316
 317   if (STREQLEN (vmchannel, "tcp:", 4)) {
 318     /* Resolve the hostname. */
 319     struct addrinfo *res, *rr;
 320     struct addrinfo hints;
 321     int r;
 322     char *host, *port;
 323
 324     host = vmchannel+4;
 325     port = strchr (host, ':');
 326     if (port) {
 327       port[0] = '\0';
 328       port++;
 329     } else {
 330       fprintf (stderr, "vmchannel: expecting \"tcp:<ip>:<port>\": %s\n",
 331                vmchannel);
 332       exit (EXIT_FAILURE);
 333     }
 334
 335     memset (&hints, 0, sizeof hints);
 336     hints.ai_socktype = SOCK_STREAM;
 337     hints.ai_flags = AI_ADDRCONFIG;
 338     r = getaddrinfo (host, port, &hints, &res);
 339     if (r != 0) {
 340       fprintf (stderr, "%s:%s: %s\n",
 341                host, port, gai_strerror (r));
 342       exit (EXIT_FAILURE);
 343     }
 344
 345     /* Connect to the given TCP socket. */
 346     for (rr = res; rr != NULL; rr = rr->ai_next) {
 347       sock = socket (rr->ai_family, rr->ai_socktype, rr->ai_protocol);
 348       if (sock != -1) {
 349         if (connect (sock, rr->ai_addr, rr->ai_addrlen) == 0)
 350           break;
 351         perror ("connect");
 352
 353         close (sock);
 354         sock = -1;
 355       }
 356     }
 357     freeaddrinfo (res);
 358   } else {
 359     fprintf (stderr,
 360              "unknown vmchannel connection type: %s\n"
 361              "expecting \"tcp:<ip>:<port>\"\n",
 362              vmchannel);
 363     exit (EXIT_FAILURE);
 364   }
 365
 366   if (sock == -1) {
 367     fprintf (stderr,
 368              "\n"
 369              "Failed to connect to any vmchannel implementation.\n"
 370              "vmchannel: %s\n"
 371              "\n"
 372              "This is a fatal error and the appliance will now exit.\n"
 373              "\n"
 374              "Usually this error is caused by either QEMU or the appliance\n"
 375              "kernel not supporting the vmchannel method that the\n"
 376              "libguestfs library chose to use.  Please run\n"
 377              "'libguestfs-test-tool' and provide the complete, unedited\n"
 378              "output to the libguestfs developers, either in a bug report\n"
 379              "or on the libguestfs redhat com mailing list.\n"
 380              "\n",
 381              vmchannel);
 382     exit (EXIT_FAILURE);
 383   }
 384
 385   /* Send the magic length message which indicates that
 386    * userspace is up inside the guest.
 387    */
 388   char lenbuf[4];
 389   XDR xdr;
 390   uint32_t len = GUESTFS_LAUNCH_FLAG;
 391   xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
 392   xdr_u_int (&xdr, &len);
 393
 394   if (xwrite (sock, lenbuf, sizeof lenbuf) == -1)
 395     exit (EXIT_FAILURE);
 396
 397   xdr_destroy (&xdr);
 398
 399   /* Fork into the background. */
 400   if (!dont_fork) {
 401     if (daemon (0, 1) == -1) {
 402       perror ("daemon");
 403       exit (EXIT_FAILURE);
 404     }
 405   }
 406
 407   /* Enter the main loop, reading and performing actions. */
 408   main_loop (sock);
 409
 410   exit (EXIT_SUCCESS);
 411 }
 412
 413 /* Read /proc/cmdline. */
 414 static char *
 415 read_cmdline (void)
 416 {
 417   int fd = open ("/proc/cmdline", O_RDONLY);
 418   if (fd == -1) {
 419     perror ("/proc/cmdline");
 420     return NULL;
 421   }
 422
 423   size_t len = 0;
 424   ssize_t n;
 425   char buf[256];
 426   char *r = NULL;
 427
 428   for (;;) {
 429     n = read (fd, buf, sizeof buf);
 430     if (n == -1) {
 431       perror ("read");
 432       free (r);
 433       close (fd);
 434       return NULL;
 435     }
 436     if (n == 0)
 437       break;
 438     char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
 439     if (newr == NULL) {
 440       perror ("realloc");
 441       free (r);
 442       close (fd);
 443       return NULL;
 444     }
 445     r = newr;
 446     memcpy (&r[len], buf, n);
 447     len += n;
 448   }
 449
 450   if (r)
 451     r[len] = '\0';
 452
 453   if (close (fd) == -1) {
 454     perror ("close");
 455     free (r);
 456     return NULL;
 457   }
 458
 459   return r;
 460 }
 461
 462 /* Return true iff device is the root device (and therefore should be
 463  * ignored from the point of view of user calls).
 464  */
 465 int
 466 is_root_device (const char *device)
 467 {
 468   struct stat statbuf;
 469   if (stat (device, &statbuf) == -1) {
 470     perror (device);
 471     return 0;
 472   }
 473   if (statbuf.st_rdev == root_device)
 474     return 1;
 475   return 0;
 476 }
 477
 478 /* Turn "/path" into "/sysroot/path".
 479  *
 480  * Caller must check for NULL and call reply_with_perror ("malloc")
 481  * if it is.  Caller must also free the string.
 482  *
 483  * See also the custom %R printf formatter which does shell quoting too.
 484  */
 485 char *
 486 sysroot_path (const char *path)
 487 {
 488   char *r;
 489   int len = strlen (path) + sysroot_len + 1;
 490
 491   r = malloc (len);
 492   if (r == NULL)
 493     return NULL;
 494
 495   snprintf (r, len, "%s%s", sysroot, path);
 496   return r;
 497 }
 498
 499 int
 500 xwrite (int sock, const void *v_buf, size_t len)
 501 {
 502   int r;
 503   const char *buf = v_buf;
 504
 505   while (len > 0) {
 506     r = write (sock, buf, len);
 507     if (r == -1) {
 508       perror ("write");
 509       return -1;
 510     }
 511     buf += r;
 512     len -= r;
 513   }
 514
 515   return 0;
 516 }
 517
 518 int
 519 xread (int sock, void *v_buf, size_t len)
 520 {
 521   int r;
 522   char *buf = v_buf;
 523
 524   while (len > 0) {
 525     r = read (sock, buf, len);
 526     if (r == -1) {
 527       perror ("read");
 528       return -1;
 529     }
 530     if (r == 0) {
 531       fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
 532       return -1;
 533     }
 534     buf += r;
 535     len -= r;
 536   }
 537
 538   return 0;
 539 }
 540
 541 int
 542 add_string (char ***argv, int *size, int *alloc, const char *str)
 543 {
 544   char **new_argv;
 545   char *new_str;
 546
 547   if (*size >= *alloc) {
 548     *alloc += 64;
 549     new_argv = realloc (*argv, *alloc * sizeof (char *));
 550     if (new_argv == NULL) {
 551       reply_with_perror ("realloc");
 552       free_strings (*argv);
 553       return -1;
 554     }
 555     *argv = new_argv;
 556   }
 557
 558   if (str) {
 559     new_str = strdup (str);
 560     if (new_str == NULL) {
 561       reply_with_perror ("strdup");
 562       free_strings (*argv);
 563     }
 564   } else
 565     new_str = NULL;
 566
 567   (*argv)[*size] = new_str;
 568
 569   (*size)++;
 570   return 0;
 571 }
 572
 573 size_t
 574 count_strings (char *const *argv)
 575 {
 576   size_t argc;
 577
 578   for (argc = 0; argv[argc] != NULL; ++argc)
 579     ;
 580   return argc;
 581 }
 582
 583 /* http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2 */
 584 int
 585 is_power_of_2 (unsigned long v)
 586 {
 587   return v && ((v & (v - 1)) == 0);
 588 }
 589
 590 static int
 591 compare (const void *vp1, const void *vp2)
 592 {
 593   char * const *p1 = (char * const *) vp1;
 594   char * const *p2 = (char * const *) vp2;
 595   return strcmp (*p1, *p2);
 596 }
 597
 598 void
 599 sort_strings (char **argv, int len)
 600 {
 601   qsort (argv, len, sizeof (char *), compare);
 602 }
 603
 604 void
 605 free_strings (char **argv)
 606 {
 607   int argc;
 608
 609   for (argc = 0; argv[argc] != NULL; ++argc)
 610     free (argv[argc]);
 611   free (argv);
 612 }
 613
 614 void
 615 free_stringslen (char **argv, int len)
 616 {
 617   int i;
 618
 619   for (i = 0; i < len; ++i)
 620     free (argv[i]);
 621   free (argv);
 622 }
 623
 624 /* Easy ways to run external commands.  For full documentation, see
 625  * 'commandrvf' below.
 626  */
 627 int
 628 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
 629 {
 630   va_list args;
 631   const char **argv;
 632   char *s;
 633   int i, r;
 634
 635   /* Collect the command line arguments into an array. */
 636   i = 2;
 637   argv = malloc (sizeof (char *) * i);
 638   if (argv == NULL) {
 639     perror ("malloc");
 640     return -1;
 641   }
 642   argv[0] = (char *) name;
 643   argv[1] = NULL;
 644
 645   va_start (args, name);
 646
 647   while ((s = va_arg (args, char *)) != NULL) {
 648     const char **p = realloc (argv, sizeof (char *) * (++i));
 649     if (p == NULL) {
 650       perror ("realloc");
 651       free (argv);
 652       va_end (args);
 653       return -1;
 654     }
 655     argv = p;
 656     argv[i-2] = s;
 657     argv[i-1] = NULL;
 658   }
 659
 660   va_end (args);
 661
 662   r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
 663
 664   /* NB: Mustn't free the strings which are on the stack. */
 665   free (argv);
 666
 667   return r;
 668 }
 669
 670 /* Same as 'command', but we allow the status code from the
 671  * subcommand to be non-zero, and return that status code.
 672  * We still return -1 if there was some other error.
 673  */
 674 int
 675 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
 676 {
 677   va_list args;
 678   const char **argv;
 679   char *s;
 680   int i, r;
 681
 682   /* Collect the command line arguments into an array. */
 683   i = 2;
 684   argv = malloc (sizeof (char *) * i);
 685   if (argv == NULL) {
 686     perror ("malloc");
 687     return -1;
 688   }
 689   argv[0] = (char *) name;
 690   argv[1] = NULL;
 691
 692   va_start (args, name);
 693
 694   while ((s = va_arg (args, char *)) != NULL) {
 695     const char **p = realloc (argv, sizeof (char *) * (++i));
 696     if (p == NULL) {
 697       perror ("realloc");
 698       free (argv);
 699       va_end (args);
 700       return -1;
 701     }
 702     argv = p;
 703     argv[i-2] = s;
 704     argv[i-1] = NULL;
 705   }
 706
 707   va_end (args);
 708
 709   r = commandrvf (stdoutput, stderror, flags, argv);
 710
 711   /* NB: Mustn't free the strings which are on the stack. */
 712   free (argv);
 713
 714   return r;
 715 }
 716
 717 /* Same as 'command', but passing an argv. */
 718 int
 719 commandvf (char **stdoutput, char **stderror, int flags,
 720            char const *const *argv)
 721 {
 722   int r;
 723
 724   r = commandrvf (stdoutput, stderror, flags, (void *) argv);
 725   if (r == 0)
 726     return 0;
 727   else
 728     return -1;
 729 }
 730
 731 /* This is a more sane version of 'system(3)' for running external
 732  * commands.  It uses fork/execvp, so we don't need to worry about
 733  * quoting of parameters, and it allows us to capture any error
 734  * messages in a buffer.
 735  *
 736  * If stdoutput is not NULL, then *stdoutput will return the stdout
 737  * of the command.
 738  *
 739  * If stderror is not NULL, then *stderror will return the stderr
 740  * of the command.  If there is a final \n character, it is removed
 741  * so you can use the error string directly in a call to
 742  * reply_with_error.
 743  *
 744  * Flags:
 745  *
 746  * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
 747  * that send error messages to stdout (hello, parted) but that don't
 748  * have any useful stdout information, use this flag to capture the
 749  * error messages in the *stderror buffer.  If using this flag,
 750  * you should pass stdoutput as NULL because nothing could ever be
 751  * captured in that buffer.
 752  *
 753  * COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN: For running external
 754  * commands on chrooted files correctly (see RHBZ#579608) specifying
 755  * this flag causes another process to be forked which chroots into
 756  * sysroot and just copies the input file to stdin of the specified
 757  * command.  The file descriptor is ORed with the flags, and that file
 758  * descriptor is always closed by this function.  See hexdump.c for an
 759  * example of usage.
 760  */
 761 int
 762 commandrvf (char **stdoutput, char **stderror, int flags,
 763             char const* const *argv)
 764 {
 765   int so_size = 0, se_size = 0;
 766   int so_fd[2], se_fd[2];
 767   int flag_copy_stdin = flags & COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN;
 768   int stdin_fd[2] = { -1, -1 };
 769   pid_t pid, stdin_pid = -1;
 770   int r, quit, i;
 771   fd_set rset, rset2;
 772   char buf[256];
 773   char *p;
 774
 775   if (stdoutput) *stdoutput = NULL;
 776   if (stderror) *stderror = NULL;
 777
 778   if (verbose) {
 779     printf ("%s", argv[0]);
 780     for (i = 1; argv[i] != NULL; ++i)
 781       printf (" %s", argv[i]);
 782     printf ("\n");
 783   }
 784
 785   /* Note: abort is used in a few places along the error paths early
 786    * in this function.  This is because (a) cleaning up correctly is
 787    * very complex at these places and (b) abort is used when a
 788    * resource problems is indicated which would be due to much more
 789    * serious issues - eg. memory or file descriptor leaks.  We
 790    * wouldn't expect fork(2) or pipe(2) to fail in normal
 791    * circumstances.
 792    */
 793
 794   if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
 795     error (0, errno, "pipe");
 796     abort ();
 797   }
 798
 799   if (flag_copy_stdin) {
 800     if (pipe (stdin_fd) == -1) {
 801       error (0, errno, "pipe");
 802       abort ();
 803     }
 804   }
 805
 806   pid = fork ();
 807   if (pid == -1) {
 808     error (0, errno, "fork");
 809     abort ();
 810   }
 811
 812   if (pid == 0) {               /* Child process running the command. */
 813     close (0);
 814     if (flag_copy_stdin) {
 815       dup2 (stdin_fd[0], 0);
 816       close (stdin_fd[0]);
 817       close (stdin_fd[1]);
 818     } else {
 819       /* Set stdin to /dev/null (ignore failure) */
 820       open ("/dev/null", O_RDONLY);
 821     }
 822     close (so_fd[0]);
 823     close (se_fd[0]);
 824     if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
 825       dup2 (so_fd[1], 1);
 826     else
 827       dup2 (se_fd[1], 1);
 828     dup2 (se_fd[1], 2);
 829     close (so_fd[1]);
 830     close (se_fd[1]);
 831
 832     execvp (argv[0], (void *) argv);
 833     perror (argv[0]);
 834     _exit (EXIT_FAILURE);
 835   }
 836
 837   if (flag_copy_stdin) {
 838     int fd = flags & COMMAND_FLAG_FD_MASK;
 839
 840     stdin_pid = fork ();
 841     if (stdin_pid == -1) {
 842       error (0, errno, "fork");
 843       abort ();
 844     }
 845
 846     if (stdin_pid == 0) {       /* Child process copying stdin. */
 847       close (so_fd[0]);
 848       close (so_fd[1]);
 849       close (se_fd[0]);
 850       close (se_fd[1]);
 851
 852       close (1);
 853       dup2 (stdin_fd[1], 1);
 854       close (stdin_fd[0]);
 855       close (stdin_fd[1]);
 856
 857       if (chroot (sysroot) == -1) {
 858         perror ("chroot");
 859         _exit (EXIT_FAILURE);
 860       }
 861
 862       ssize_t n;
 863       char buffer[BUFSIZ];
 864       while ((n = read (fd, buffer, sizeof buffer)) > 0) {
 865         if (xwrite (1, buffer, n) == -1)
 866           /* EPIPE error indicates the command process has exited
 867            * early.  If the command process fails that will be caught
 868            * by the daemon, and if not, then it's not an error.
 869            */
 870           _exit (errno == EPIPE ? EXIT_SUCCESS : EXIT_FAILURE);
 871       }
 872
 873       if (n == -1) {
 874         perror ("read");
 875         _exit (EXIT_FAILURE);
 876       }
 877
 878       if (close (fd) == -1) {
 879         perror ("close");
 880         _exit (EXIT_FAILURE);
 881       }
 882
 883       _exit (EXIT_SUCCESS);
 884     }
 885
 886     close (fd);
 887     close (stdin_fd[0]);
 888     close (stdin_fd[1]);
 889   }
 890
 891   /* Parent process. */
 892   close (so_fd[1]);
 893   close (se_fd[1]);
 894
 895   FD_ZERO (&rset);
 896   FD_SET (so_fd[0], &rset);
 897   FD_SET (se_fd[0], &rset);
 898
 899   quit = 0;
 900   while (quit < 2) {
 901     rset2 = rset;
 902     r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
 903     if (r == -1) {
 904       perror ("select");
 905     quit:
 906       if (stdoutput) free (*stdoutput);
 907       if (stderror) free (*stderror);
 908       close (so_fd[0]);
 909       close (se_fd[0]);
 910       waitpid (pid, NULL, 0);
 911       if (stdin_pid >= 0) waitpid (stdin_pid, NULL, 0);
 912       return -1;
 913     }
 914
 915     if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
 916       r = read (so_fd[0], buf, sizeof buf);
 917       if (r == -1) {
 918         perror ("read");
 919         goto quit;
 920       }
 921       if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
 922
 923       if (r > 0 && stdoutput) {
 924         so_size += r;
 925         p = realloc (*stdoutput, so_size);
 926         if (p == NULL) {
 927           perror ("realloc");
 928           goto quit;
 929         }
 930         *stdoutput = p;
 931         memcpy (*stdoutput + so_size - r, buf, r);
 932       }
 933     }
 934
 935     if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
 936       r = read (se_fd[0], buf, sizeof buf);
 937       if (r == -1) {
 938         perror ("read");
 939         goto quit;
 940       }
 941       if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
 942
 943       if (r > 0) {
 944         if (verbose)
 945           ignore_value (write (2, buf, r));
 946
 947         if (stderror) {
 948           se_size += r;
 949           p = realloc (*stderror, se_size);
 950           if (p == NULL) {
 951             perror ("realloc");
 952             goto quit;
 953           }
 954           *stderror = p;
 955           memcpy (*stderror + se_size - r, buf, r);
 956         }
 957       }
 958     }
 959   }
 960
 961   close (so_fd[0]);
 962   close (se_fd[0]);
 963
 964   /* Make sure the output buffers are \0-terminated.  Also remove any
 965    * trailing \n characters from the error buffer (not from stdout).
 966    */
 967   if (stdoutput) {
 968     void *q = realloc (*stdoutput, so_size+1);
 969     if (q == NULL) {
 970       perror ("realloc");
 971       free (*stdoutput);
 972     }
 973     *stdoutput = q;
 974     if (*stdoutput)
 975       (*stdoutput)[so_size] = '\0';
 976   }
 977   if (stderror) {
 978     void *q = realloc (*stderror, se_size+1);
 979     if (q == NULL) {
 980       perror ("realloc");
 981       free (*stderror);
 982     }
 983     *stderror = q;
 984     if (*stderror) {
 985       (*stderror)[se_size] = '\0';
 986       se_size--;
 987       while (se_size >= 0 && (*stderror)[se_size] == '\n')
 988         (*stderror)[se_size--] = '\0';
 989     }
 990   }
 991
 992   if (flag_copy_stdin) {
 993     /* Check copy process didn't fail. */
 994     if (waitpid (stdin_pid, &r, 0) != stdin_pid) {
 995       perror ("waitpid");
 996       kill (pid, 9);
 997       waitpid (pid, NULL, 0);
 998       return -1;
 999     }
1000
1001     if (!WIFEXITED (r) || WEXITSTATUS (r) != 0) {
1002       fprintf (stderr, "failed copying from input file, see earlier messages\n");
1003       kill (pid, 9);
1004       waitpid (pid, NULL, 0);
1005       return -1;
1006     }
1007   }
1008
1009   /* Get the exit status of the command. */
1010   if (waitpid (pid, &r, 0) != pid) {
1011     perror ("waitpid");
1012     return -1;
1013   }
1014
1015   if (WIFEXITED (r)) {
1016     return WEXITSTATUS (r);
1017   } else
1018     return -1;
1019 }
1020
1021 /* Split an output string into a NULL-terminated list of lines.
1022  * Typically this is used where we have run an external command
1023  * which has printed out a list of things, and we want to return
1024  * an actual list.
1025  *
1026  * The corner cases here are quite tricky.  Note in particular:
1027  *
1028  *   "" -> []
1029  *   "\n" -> [""]
1030  *   "a\nb" -> ["a"; "b"]
1031  *   "a\nb\n" -> ["a"; "b"]
1032  *   "a\nb\n\n" -> ["a"; "b"; ""]
1033  *
1034  * The original string is written over and destroyed by this
1035  * function (which is usually OK because it's the 'out' string
1036  * from command()).  You can free the original string, because
1037  * add_string() strdups the strings.
1038  */
1039 char **
1040 split_lines (char *str)
1041 {
1042   char **lines = NULL;
1043   int size = 0, alloc = 0;
1044   char *p, *pend;
1045
1046   if (STREQ (str, ""))
1047     goto empty_list;
1048
1049   p = str;
1050   while (p) {
1051     /* Empty last line? */
1052     if (p[0] == '\0')
1053       break;
1054
1055     pend = strchr (p, '\n');
1056     if (pend) {
1057       *pend = '\0';
1058       pend++;
1059     }
1060
1061     if (add_string (&lines, &size, &alloc, p) == -1) {
1062       return NULL;
1063     }
1064
1065     p = pend;
1066   }
1067
1068  empty_list:
1069   if (add_string (&lines, &size, &alloc, NULL) == -1)
1070     return NULL;
1071
1072   return lines;
1073 }
1074
1075 /* Skip leading and trailing whitespace, updating the original string
1076  * in-place.
1077  */
1078 void
1079 trim (char *str)
1080 {
1081   size_t len = strlen (str);
1082
1083   while (len > 0 && c_isspace (str[len-1])) {
1084     str[len-1] = '\0';
1085     len--;
1086   }
1087
1088   const char *p = str;
1089   while (*p && c_isspace (*p)) {
1090     p++;
1091     len--;
1092   }
1093
1094   memmove (str, p, len+1);
1095 }
1096
1097 /* printf helper function so we can use %Q ("quoted") and %R to print
1098  * shell-quoted strings.  See HACKING file for more details.
1099  */
1100 static int
1101 print_shell_quote (FILE *stream,
1102                    const struct printf_info *info ATTRIBUTE_UNUSED,
1103                    const void *const *args)
1104 {
1105 #define SAFE(c) (c_isalnum((c)) ||                                      \
1106                  (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
1107   int i, len;
1108   const char *str = *((const char **) (args[0]));
1109
1110   for (i = len = 0; str[i]; ++i) {
1111     if (!SAFE(str[i])) {
1112       putc ('\\', stream);
1113       len ++;
1114     }
1115     putc (str[i], stream);
1116     len ++;
1117   }
1118
1119   return len;
1120 }
1121
1122 static int
1123 print_sysroot_shell_quote (FILE *stream,
1124                            const struct printf_info *info,
1125                            const void *const *args)
1126 {
1127   fputs (sysroot, stream);
1128   return sysroot_len + print_shell_quote (stream, info, args);
1129 }
1130
1131 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
1132 static int
1133 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
1134                size_t n, int *argtypes, int *size)
1135 {
1136   if (n > 0) {
1137     argtypes[0] = PA_STRING;
1138     size[0] = sizeof (const char *);
1139   }
1140   return 1;
1141 }
1142 #else
1143 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
1144 static int
1145 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
1146 {
1147   if (n > 0)
1148     argtypes[0] = PA_STRING;
1149   return 1;
1150 }
1151 #else
1152 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
1153 #endif
1154 #endif
1155
1156 /* Perform device name translation.  Don't call this directly -
1157  * use the RESOLVE_DEVICE macro.
1158  *
1159  * See guestfs(3) for the algorithm.
1160  *
1161  * We have to open the device and test for ENXIO, because
1162  * the device nodes themselves will exist in the appliance.
1163  */
1164 int
1165 device_name_translation (char *device)
1166 {
1167   int fd;
1168
1169   fd = open (device, O_RDONLY);
1170   if (fd >= 0) {
1171   close_ok:
1172     close (fd);
1173     return 0;
1174   }
1175
1176   if (errno != ENXIO && errno != ENOENT)
1177     return -1;
1178
1179   /* If the name begins with "/dev/sd" then try the alternatives. */
1180   if (STRNEQLEN (device, "/dev/sd", 7))
1181     return -1;
1182
1183   device[5] = 'h';              /* /dev/hd (old IDE driver) */
1184   fd = open (device, O_RDONLY);
1185   if (fd >= 0)
1186     goto close_ok;
1187
1188   device[5] = 'v';              /* /dev/vd (for virtio devices) */
1189   fd = open (device, O_RDONLY);
1190   if (fd >= 0)
1191     goto close_ok;
1192
1193   device[5] = 's';              /* Restore original device name. */
1194   return -1;
1195 }
1196
1197 /* Check program exists and is executable on $PATH.  Actually, we
1198  * just assume PATH contains the default entries (see main() above).
1199  */
1200 int
1201 prog_exists (const char *prog)
1202 {
1203   static const char * const dirs[] =
1204     { "/sbin", "/usr/sbin", "/bin", "/usr/bin" };
1205   size_t i;
1206   char buf[1024];
1207
1208   for (i = 0; i < sizeof dirs / sizeof dirs[0]; ++i) {
1209     snprintf (buf, sizeof buf, "%s/%s", dirs[i], prog);
1210     if (access (buf, X_OK) == 0)
1211       return 1;
1212   }
1213   return 0;
1214 }
1215
1216 /* LVM and other commands aren't synchronous, especially when udev is
1217  * involved.  eg. You can create or remove some device, but the /dev
1218  * device node won't appear until some time later.  This means that
1219  * you get an error if you run one command followed by another.
1220  *
1221  * Use 'udevadm settle' after certain commands, but don't be too
1222  * fussed if it fails.
1223  *
1224  * 'udevsettle' was the old name for this command (RHEL 5).  This was
1225  * deprecated in favour of 'udevadm settle'.  The old 'udevsettle'
1226  * command was left as a symlink.  Then in Fedora 13 the old symlink
1227  * remained but it stopped working (RHBZ#548121), so we have to be
1228  * careful not to assume that we can use 'udevsettle' if it exists.
1229  */
1230 void
1231 udev_settle (void)
1232 {
1233   (void) command (NULL, NULL, "udevadm", "settle", NULL);
1234   (void) command (NULL, NULL, "udevsettle", NULL);
1235 }