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