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