daemon/guestfsd.c

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