daemon/guestfsd.c

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