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