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 /* http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2 */
 558 int
 559 is_power_of_2 (unsigned long v)
 560 {
 561   return v && ((v & (v - 1)) == 0);
 562 }
 563
 564 static int
 565 compare (const void *vp1, const void *vp2)
 566 {
 567   char * const *p1 = (char * const *) vp1;
 568   char * const *p2 = (char * const *) vp2;
 569   return strcmp (*p1, *p2);
 570 }
 571
 572 void
 573 sort_strings (char **argv, int len)
 574 {
 575   qsort (argv, len, sizeof (char *), compare);
 576 }
 577
 578 void
 579 free_strings (char **argv)
 580 {
 581   int argc;
 582
 583   for (argc = 0; argv[argc] != NULL; ++argc)
 584     free (argv[argc]);
 585   free (argv);
 586 }
 587
 588 void
 589 free_stringslen (char **argv, int len)
 590 {
 591   int i;
 592
 593   for (i = 0; i < len; ++i)
 594     free (argv[i]);
 595   free (argv);
 596 }
 597
 598 /* Easy ways to run external commands.  For full documentation, see
 599  * 'commandrvf' below.
 600  */
 601 int
 602 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
 603 {
 604   va_list args;
 605   const char **argv;
 606   char *s;
 607   int i, r;
 608
 609   /* Collect the command line arguments into an array. */
 610   i = 2;
 611   argv = malloc (sizeof (char *) * i);
 612   if (argv == NULL) {
 613     perror ("malloc");
 614     return -1;
 615   }
 616   argv[0] = (char *) name;
 617   argv[1] = NULL;
 618
 619   va_start (args, name);
 620
 621   while ((s = va_arg (args, char *)) != NULL) {
 622     const char **p = realloc (argv, sizeof (char *) * (++i));
 623     if (p == NULL) {
 624       perror ("realloc");
 625       free (argv);
 626       va_end (args);
 627       return -1;
 628     }
 629     argv = p;
 630     argv[i-2] = s;
 631     argv[i-1] = NULL;
 632   }
 633
 634   va_end (args);
 635
 636   r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
 637
 638   /* NB: Mustn't free the strings which are on the stack. */
 639   free (argv);
 640
 641   return r;
 642 }
 643
 644 /* Same as 'command', but we allow the status code from the
 645  * subcommand to be non-zero, and return that status code.
 646  * We still return -1 if there was some other error.
 647  */
 648 int
 649 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
 650 {
 651   va_list args;
 652   const char **argv;
 653   char *s;
 654   int i, r;
 655
 656   /* Collect the command line arguments into an array. */
 657   i = 2;
 658   argv = malloc (sizeof (char *) * i);
 659   if (argv == NULL) {
 660     perror ("malloc");
 661     return -1;
 662   }
 663   argv[0] = (char *) name;
 664   argv[1] = NULL;
 665
 666   va_start (args, name);
 667
 668   while ((s = va_arg (args, char *)) != NULL) {
 669     const char **p = realloc (argv, sizeof (char *) * (++i));
 670     if (p == NULL) {
 671       perror ("realloc");
 672       free (argv);
 673       va_end (args);
 674       return -1;
 675     }
 676     argv = p;
 677     argv[i-2] = s;
 678     argv[i-1] = NULL;
 679   }
 680
 681   va_end (args);
 682
 683   r = commandrvf (stdoutput, stderror, flags, argv);
 684
 685   /* NB: Mustn't free the strings which are on the stack. */
 686   free (argv);
 687
 688   return r;
 689 }
 690
 691 /* Same as 'command', but passing an argv. */
 692 int
 693 commandvf (char **stdoutput, char **stderror, int flags,
 694            char const *const *argv)
 695 {
 696   int r;
 697
 698   r = commandrvf (stdoutput, stderror, flags, (void *) argv);
 699   if (r == 0)
 700     return 0;
 701   else
 702     return -1;
 703 }
 704
 705 /* This is a more sane version of 'system(3)' for running external
 706  * commands.  It uses fork/execvp, so we don't need to worry about
 707  * quoting of parameters, and it allows us to capture any error
 708  * messages in a buffer.
 709  *
 710  * If stdoutput is not NULL, then *stdoutput will return the stdout
 711  * of the command.
 712  *
 713  * If stderror is not NULL, then *stderror will return the stderr
 714  * of the command.  If there is a final \n character, it is removed
 715  * so you can use the error string directly in a call to
 716  * reply_with_error.
 717  *
 718  * Flags:
 719  *
 720  * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
 721  * that send error messages to stdout (hello, parted) but that don't
 722  * have any useful stdout information, use this flag to capture the
 723  * error messages in the *stderror buffer.  If using this flag,
 724  * you should pass stdoutput as NULL because nothing could ever be
 725  * captured in that buffer.
 726  *
 727  * COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN: For running external
 728  * commands on chrooted files correctly (see RHBZ#579608) specifying
 729  * this flag causes another process to be forked which chroots into
 730  * sysroot and just copies the input file to stdin of the specified
 731  * command.  The file descriptor is ORed with the flags, and that file
 732  * descriptor is always closed by this function.  See hexdump.c for an
 733  * example of usage.
 734  */
 735 int
 736 commandrvf (char **stdoutput, char **stderror, int flags,
 737             char const* const *argv)
 738 {
 739   int so_size = 0, se_size = 0;
 740   int so_fd[2], se_fd[2];
 741   int flag_copy_stdin = flags & COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN;
 742   int stdin_fd[2] = { -1, -1 };
 743   pid_t pid, stdin_pid = -1;
 744   int r, quit, i;
 745   fd_set rset, rset2;
 746   char buf[256];
 747   char *p;
 748
 749   if (stdoutput) *stdoutput = NULL;
 750   if (stderror) *stderror = NULL;
 751
 752   if (verbose) {
 753     printf ("%s", argv[0]);
 754     for (i = 1; argv[i] != NULL; ++i)
 755       printf (" %s", argv[i]);
 756     printf ("\n");
 757   }
 758
 759   /* Note: abort is used in a few places along the error paths early
 760    * in this function.  This is because (a) cleaning up correctly is
 761    * very complex at these places and (b) abort is used when a
 762    * resource problems is indicated which would be due to much more
 763    * serious issues - eg. memory or file descriptor leaks.  We
 764    * wouldn't expect fork(2) or pipe(2) to fail in normal
 765    * circumstances.
 766    */
 767
 768   if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
 769     error (0, errno, "pipe");
 770     abort ();
 771   }
 772
 773   if (flag_copy_stdin) {
 774     if (pipe (stdin_fd) == -1) {
 775       error (0, errno, "pipe");
 776       abort ();
 777     }
 778   }
 779
 780   pid = fork ();
 781   if (pid == -1) {
 782     error (0, errno, "fork");
 783     abort ();
 784   }
 785
 786   if (pid == 0) {               /* Child process running the command. */
 787     close (0);
 788     if (flag_copy_stdin) {
 789       dup2 (stdin_fd[0], 0);
 790       close (stdin_fd[0]);
 791       close (stdin_fd[1]);
 792     } else {
 793       /* Set stdin to /dev/null (ignore failure) */
 794       open ("/dev/null", O_RDONLY);
 795     }
 796     close (so_fd[0]);
 797     close (se_fd[0]);
 798     if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
 799       dup2 (so_fd[1], 1);
 800     else
 801       dup2 (se_fd[1], 1);
 802     dup2 (se_fd[1], 2);
 803     close (so_fd[1]);
 804     close (se_fd[1]);
 805
 806     execvp (argv[0], (void *) argv);
 807     perror (argv[0]);
 808     _exit (EXIT_FAILURE);
 809   }
 810
 811   if (flag_copy_stdin) {
 812     int fd = flags & COMMAND_FLAG_FD_MASK;
 813
 814     stdin_pid = fork ();
 815     if (stdin_pid == -1) {
 816       error (0, errno, "fork");
 817       abort ();
 818     }
 819
 820     if (stdin_pid == 0) {       /* Child process copying stdin. */
 821       close (so_fd[0]);
 822       close (so_fd[1]);
 823       close (se_fd[0]);
 824       close (se_fd[1]);
 825
 826       close (1);
 827       dup2 (stdin_fd[1], 1);
 828       close (stdin_fd[0]);
 829       close (stdin_fd[1]);
 830
 831       if (chroot (sysroot) == -1) {
 832         perror ("chroot");
 833         _exit (EXIT_FAILURE);
 834       }
 835
 836       ssize_t n;
 837       char buffer[BUFSIZ];
 838       while ((n = read (fd, buffer, sizeof buffer)) > 0) {
 839         if (xwrite (1, buffer, n) == -1)
 840           /* EPIPE error indicates the command process has exited
 841            * early.  If the command process fails that will be caught
 842            * by the daemon, and if not, then it's not an error.
 843            */
 844           _exit (errno == EPIPE ? EXIT_SUCCESS : EXIT_FAILURE);
 845       }
 846
 847       if (n == -1) {
 848         perror ("read");
 849         _exit (EXIT_FAILURE);
 850       }
 851
 852       if (close (fd) == -1) {
 853         perror ("close");
 854         _exit (EXIT_FAILURE);
 855       }
 856
 857       _exit (EXIT_SUCCESS);
 858     }
 859
 860     close (fd);
 861     close (stdin_fd[0]);
 862     close (stdin_fd[1]);
 863   }
 864
 865   /* Parent process. */
 866   close (so_fd[1]);
 867   close (se_fd[1]);
 868
 869   FD_ZERO (&rset);
 870   FD_SET (so_fd[0], &rset);
 871   FD_SET (se_fd[0], &rset);
 872
 873   quit = 0;
 874   while (quit < 2) {
 875     rset2 = rset;
 876     r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
 877     if (r == -1) {
 878       perror ("select");
 879     quit:
 880       if (stdoutput) free (*stdoutput);
 881       if (stderror) free (*stderror);
 882       close (so_fd[0]);
 883       close (se_fd[0]);
 884       waitpid (pid, NULL, 0);
 885       if (stdin_pid >= 0) waitpid (stdin_pid, NULL, 0);
 886       return -1;
 887     }
 888
 889     if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
 890       r = read (so_fd[0], buf, sizeof buf);
 891       if (r == -1) {
 892         perror ("read");
 893         goto quit;
 894       }
 895       if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
 896
 897       if (r > 0 && stdoutput) {
 898         so_size += r;
 899         p = realloc (*stdoutput, so_size);
 900         if (p == NULL) {
 901           perror ("realloc");
 902           goto quit;
 903         }
 904         *stdoutput = p;
 905         memcpy (*stdoutput + so_size - r, buf, r);
 906       }
 907     }
 908
 909     if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
 910       r = read (se_fd[0], buf, sizeof buf);
 911       if (r == -1) {
 912         perror ("read");
 913         goto quit;
 914       }
 915       if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
 916
 917       if (r > 0) {
 918         if (verbose)
 919           ignore_value (write (2, buf, r));
 920
 921         if (stderror) {
 922           se_size += r;
 923           p = realloc (*stderror, se_size);
 924           if (p == NULL) {
 925             perror ("realloc");
 926             goto quit;
 927           }
 928           *stderror = p;
 929           memcpy (*stderror + se_size - r, buf, r);
 930         }
 931       }
 932     }
 933   }
 934
 935   close (so_fd[0]);
 936   close (se_fd[0]);
 937
 938   /* Make sure the output buffers are \0-terminated.  Also remove any
 939    * trailing \n characters from the error buffer (not from stdout).
 940    */
 941   if (stdoutput) {
 942     void *q = realloc (*stdoutput, so_size+1);
 943     if (q == NULL) {
 944       perror ("realloc");
 945       free (*stdoutput);
 946     }
 947     *stdoutput = q;
 948     if (*stdoutput)
 949       (*stdoutput)[so_size] = '\0';
 950   }
 951   if (stderror) {
 952     void *q = realloc (*stderror, se_size+1);
 953     if (q == NULL) {
 954       perror ("realloc");
 955       free (*stderror);
 956     }
 957     *stderror = q;
 958     if (*stderror) {
 959       (*stderror)[se_size] = '\0';
 960       se_size--;
 961       while (se_size >= 0 && (*stderror)[se_size] == '\n')
 962         (*stderror)[se_size--] = '\0';
 963     }
 964   }
 965
 966   if (flag_copy_stdin) {
 967     /* Check copy process didn't fail. */
 968     if (waitpid (stdin_pid, &r, 0) != stdin_pid) {
 969       perror ("waitpid");
 970       kill (pid, 9);
 971       waitpid (pid, NULL, 0);
 972       return -1;
 973     }
 974
 975     if (!WIFEXITED (r) || WEXITSTATUS (r) != 0) {
 976       fprintf (stderr, "failed copying from input file, see earlier messages\n");
 977       kill (pid, 9);
 978       waitpid (pid, NULL, 0);
 979       return -1;
 980     }
 981   }
 982
 983   /* Get the exit status of the command. */
 984   if (waitpid (pid, &r, 0) != pid) {
 985     perror ("waitpid");
 986     return -1;
 987   }
 988
 989   if (WIFEXITED (r)) {
 990     return WEXITSTATUS (r);
 991   } else
 992     return -1;
 993 }
 994
 995 /* Split an output string into a NULL-terminated list of lines.
 996  * Typically this is used where we have run an external command
 997  * which has printed out a list of things, and we want to return
 998  * an actual list.
 999  *
1000  * The corner cases here are quite tricky.  Note in particular:
1001  *
1002  *   "" -> []
1003  *   "\n" -> [""]
1004  *   "a\nb" -> ["a"; "b"]
1005  *   "a\nb\n" -> ["a"; "b"]
1006  *   "a\nb\n\n" -> ["a"; "b"; ""]
1007  *
1008  * The original string is written over and destroyed by this
1009  * function (which is usually OK because it's the 'out' string
1010  * from command()).  You can free the original string, because
1011  * add_string() strdups the strings.
1012  */
1013 char **
1014 split_lines (char *str)
1015 {
1016   char **lines = NULL;
1017   int size = 0, alloc = 0;
1018   char *p, *pend;
1019
1020   if (STREQ (str, ""))
1021     goto empty_list;
1022
1023   p = str;
1024   while (p) {
1025     /* Empty last line? */
1026     if (p[0] == '\0')
1027       break;
1028
1029     pend = strchr (p, '\n');
1030     if (pend) {
1031       *pend = '\0';
1032       pend++;
1033     }
1034
1035     if (add_string (&lines, &size, &alloc, p) == -1) {
1036       return NULL;
1037     }
1038
1039     p = pend;
1040   }
1041
1042  empty_list:
1043   if (add_string (&lines, &size, &alloc, NULL) == -1)
1044     return NULL;
1045
1046   return lines;
1047 }
1048
1049 /* Skip leading and trailing whitespace, updating the original string
1050  * in-place.
1051  */
1052 void
1053 trim (char *str)
1054 {
1055   size_t len = strlen (str);
1056
1057   while (len > 0 && c_isspace (str[len-1])) {
1058     str[len-1] = '\0';
1059     len--;
1060   }
1061
1062   const char *p = str;
1063   while (*p && c_isspace (*p)) {
1064     p++;
1065     len--;
1066   }
1067
1068   memmove (str, p, len+1);
1069 }
1070
1071 /* printf helper function so we can use %Q ("quoted") and %R to print
1072  * shell-quoted strings.  See HACKING file for more details.
1073  */
1074 static int
1075 print_shell_quote (FILE *stream,
1076                    const struct printf_info *info ATTRIBUTE_UNUSED,
1077                    const void *const *args)
1078 {
1079 #define SAFE(c) (c_isalnum((c)) ||                                      \
1080                  (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
1081   int i, len;
1082   const char *str = *((const char **) (args[0]));
1083
1084   for (i = len = 0; str[i]; ++i) {
1085     if (!SAFE(str[i])) {
1086       putc ('\\', stream);
1087       len ++;
1088     }
1089     putc (str[i], stream);
1090     len ++;
1091   }
1092
1093   return len;
1094 }
1095
1096 static int
1097 print_sysroot_shell_quote (FILE *stream,
1098                            const struct printf_info *info,
1099                            const void *const *args)
1100 {
1101   fputs (sysroot, stream);
1102   return sysroot_len + print_shell_quote (stream, info, args);
1103 }
1104
1105 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
1106 static int
1107 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
1108                size_t n, int *argtypes, int *size)
1109 {
1110   if (n > 0) {
1111     argtypes[0] = PA_STRING;
1112     size[0] = sizeof (const char *);
1113   }
1114   return 1;
1115 }
1116 #else
1117 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
1118 static int
1119 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
1120 {
1121   if (n > 0)
1122     argtypes[0] = PA_STRING;
1123   return 1;
1124 }
1125 #else
1126 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
1127 #endif
1128 #endif
1129
1130 /* Perform device name translation.  Don't call this directly -
1131  * use the RESOLVE_DEVICE macro.
1132  *
1133  * See guestfs(3) for the algorithm.
1134  *
1135  * We have to open the device and test for ENXIO, because
1136  * the device nodes themselves will exist in the appliance.
1137  */
1138 int
1139 device_name_translation (char *device)
1140 {
1141   int fd;
1142
1143   fd = open (device, O_RDONLY);
1144   if (fd >= 0) {
1145   close_ok:
1146     close (fd);
1147     return 0;
1148   }
1149
1150   if (errno != ENXIO && errno != ENOENT)
1151     return -1;
1152
1153   /* If the name begins with "/dev/sd" then try the alternatives. */
1154   if (STRNEQLEN (device, "/dev/sd", 7))
1155     return -1;
1156
1157   device[5] = 'h';              /* /dev/hd (old IDE driver) */
1158   fd = open (device, O_RDONLY);
1159   if (fd >= 0)
1160     goto close_ok;
1161
1162   device[5] = 'v';              /* /dev/vd (for virtio devices) */
1163   fd = open (device, O_RDONLY);
1164   if (fd >= 0)
1165     goto close_ok;
1166
1167   device[5] = 's';              /* Restore original device name. */
1168   return -1;
1169 }
1170
1171 /* Check program exists and is executable on $PATH.  Actually, we
1172  * just assume PATH contains the default entries (see main() above).
1173  */
1174 int
1175 prog_exists (const char *prog)
1176 {
1177   static const char * const dirs[] =
1178     { "/sbin", "/usr/sbin", "/bin", "/usr/bin" };
1179   size_t i;
1180   char buf[1024];
1181
1182   for (i = 0; i < sizeof dirs / sizeof dirs[0]; ++i) {
1183     snprintf (buf, sizeof buf, "%s/%s", dirs[i], prog);
1184     if (access (buf, X_OK) == 0)
1185       return 1;
1186   }
1187   return 0;
1188 }
1189
1190 /* LVM and other commands aren't synchronous, especially when udev is
1191  * involved.  eg. You can create or remove some device, but the /dev
1192  * device node won't appear until some time later.  This means that
1193  * you get an error if you run one command followed by another.
1194  *
1195  * Use 'udevadm settle' after certain commands, but don't be too
1196  * fussed if it fails.
1197  *
1198  * 'udevsettle' was the old name for this command (RHEL 5).  This was
1199  * deprecated in favour of 'udevadm settle'.  The old 'udevsettle'
1200  * command was left as a symlink.  Then in Fedora 13 the old symlink
1201  * remained but it stopped working (RHBZ#548121), so we have to be
1202  * careful not to assume that we can use 'udevsettle' if it exists.
1203  */
1204 void
1205 udev_settle (void)
1206 {
1207   (void) command (NULL, NULL, "udevadm", "settle", NULL);
1208   (void) command (NULL, NULL, "udevsettle", NULL);
1209 }