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