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