daemon/guestfsd.c

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