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