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