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