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