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
 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   /* Get the vmchannel string.
 243    *
 244    * Sources:
 245    *   --channel/-c option on the command line
 246    *   guestfs_vmchannel=... from the kernel command line
 247    *   guestfs=... from the kernel command line
 248    *   built-in default
 249    *
 250    * At the moment we expect this to contain "tcp:ip:port" but in
 251    * future it might contain a device name, eg. "/dev/vcon4" for
 252    * virtio-console vmchannel.
 253    */
 254   if (vmchannel == NULL && cmdline) {
 255     char *p;
 256     size_t len;
 257
 258     p = strstr (cmdline, "guestfs_vmchannel=");
 259     if (p) {
 260       len = strcspn (p + 18, " \t\n");
 261       vmchannel = strndup (p + 18, len);
 262       if (!vmchannel) {
 263         perror ("strndup");
 264         exit (EXIT_FAILURE);
 265       }
 266     }
 267
 268     /* Old libraries passed guestfs=host:port.  Rewrite it as tcp:host:port. */
 269     if (vmchannel == NULL) {
 270       /* We will rewrite it part of the "guestfs=" string with
 271        *                       "tcp:"       hence p + 4 below.    */
 272       p = strstr (cmdline, "guestfs=");
 273       if (p) {
 274         len = strcspn (p + 4, " \t\n");
 275         vmchannel = strndup (p + 4, len);
 276         if (!vmchannel) {
 277           perror ("strndup");
 278           exit (EXIT_FAILURE);
 279         }
 280         memcpy (vmchannel, "tcp:", 4);
 281       }
 282     }
 283   }
 284
 285   /* Default vmchannel. */
 286   if (vmchannel == NULL) {
 287     vmchannel = strdup ("tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT);
 288     if (!vmchannel) {
 289       perror ("strdup");
 290       exit (EXIT_FAILURE);
 291     }
 292   }
 293
 294   if (verbose)
 295     printf ("vmchannel: %s\n", vmchannel);
 296
 297   /* Connect to vmchannel. */
 298   int sock = -1;
 299
 300   if (STREQLEN (vmchannel, "tcp:", 4)) {
 301     /* Resolve the hostname. */
 302     struct addrinfo *res, *rr;
 303     struct addrinfo hints;
 304     int r;
 305     char *host, *port;
 306
 307     host = vmchannel+4;
 308     port = strchr (host, ':');
 309     if (port) {
 310       port[0] = '\0';
 311       port++;
 312     } else {
 313       fprintf (stderr, "vmchannel: expecting \"tcp:<ip>:<port>\": %s\n",
 314                vmchannel);
 315       exit (EXIT_FAILURE);
 316     }
 317
 318     memset (&hints, 0, sizeof hints);
 319     hints.ai_socktype = SOCK_STREAM;
 320     hints.ai_flags = AI_ADDRCONFIG;
 321     r = getaddrinfo (host, port, &hints, &res);
 322     if (r != 0) {
 323       fprintf (stderr, "%s:%s: %s\n",
 324                host, port, gai_strerror (r));
 325       exit (EXIT_FAILURE);
 326     }
 327
 328     /* Connect to the given TCP socket. */
 329     for (rr = res; rr != NULL; rr = rr->ai_next) {
 330       sock = socket (rr->ai_family, rr->ai_socktype, rr->ai_protocol);
 331       if (sock != -1) {
 332         if (connect (sock, rr->ai_addr, rr->ai_addrlen) == 0)
 333           break;
 334         perror ("connect");
 335
 336         close (sock);
 337         sock = -1;
 338       }
 339     }
 340     freeaddrinfo (res);
 341   } else {
 342     fprintf (stderr,
 343              "unknown vmchannel connection type: %s\n"
 344              "expecting \"tcp:<ip>:<port>\"\n",
 345              vmchannel);
 346     exit (EXIT_FAILURE);
 347   }
 348
 349   if (sock == -1) {
 350     fprintf (stderr,
 351              "\n"
 352              "Failed to connect to any vmchannel implementation.\n"
 353              "vmchannel: %s\n"
 354              "\n"
 355              "This is a fatal error and the appliance will now exit.\n"
 356              "\n"
 357              "Usually this error is caused by either QEMU or the appliance\n"
 358              "kernel not supporting the vmchannel method that the\n"
 359              "libguestfs library chose to use.  Please run\n"
 360              "'libguestfs-test-tool' and provide the complete, unedited\n"
 361              "output to the libguestfs developers, either in a bug report\n"
 362              "or on the libguestfs redhat com mailing list.\n"
 363              "\n",
 364              vmchannel);
 365     exit (EXIT_FAILURE);
 366   }
 367
 368   /* Send the magic length message which indicates that
 369    * userspace is up inside the guest.
 370    */
 371   char lenbuf[4];
 372   XDR xdr;
 373   uint32_t len = GUESTFS_LAUNCH_FLAG;
 374   xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
 375   xdr_u_int (&xdr, &len);
 376
 377   if (xwrite (sock, lenbuf, sizeof lenbuf) == -1)
 378     exit (EXIT_FAILURE);
 379
 380   xdr_destroy (&xdr);
 381
 382   /* Fork into the background. */
 383   if (!dont_fork) {
 384     if (daemon (0, 1) == -1) {
 385       perror ("daemon");
 386       exit (EXIT_FAILURE);
 387     }
 388   }
 389
 390   /* Enter the main loop, reading and performing actions. */
 391   main_loop (sock);
 392
 393   exit (EXIT_SUCCESS);
 394 }
 395
 396 /* Read /proc/cmdline. */
 397 static char *
 398 read_cmdline (void)
 399 {
 400   int fd = open ("/proc/cmdline", O_RDONLY);
 401   if (fd == -1) {
 402     perror ("/proc/cmdline");
 403     return NULL;
 404   }
 405
 406   size_t len = 0;
 407   ssize_t n;
 408   char buf[256];
 409   char *r = NULL;
 410
 411   for (;;) {
 412     n = read (fd, buf, sizeof buf);
 413     if (n == -1) {
 414       perror ("read");
 415       free (r);
 416       close (fd);
 417       return NULL;
 418     }
 419     if (n == 0)
 420       break;
 421     char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
 422     if (newr == NULL) {
 423       perror ("realloc");
 424       free (r);
 425       close (fd);
 426       return NULL;
 427     }
 428     r = newr;
 429     memcpy (&r[len], buf, n);
 430     len += n;
 431   }
 432
 433   if (r)
 434     r[len] = '\0';
 435
 436   if (close (fd) == -1) {
 437     perror ("close");
 438     free (r);
 439     return NULL;
 440   }
 441
 442   return r;
 443 }
 444
 445 /* Turn "/path" into "/sysroot/path".
 446  *
 447  * Caller must check for NULL and call reply_with_perror ("malloc")
 448  * if it is.  Caller must also free the string.
 449  *
 450  * See also the custom %R printf formatter which does shell quoting too.
 451  */
 452 char *
 453 sysroot_path (const char *path)
 454 {
 455   char *r;
 456   int len = strlen (path) + sysroot_len + 1;
 457
 458   r = malloc (len);
 459   if (r == NULL)
 460     return NULL;
 461
 462   snprintf (r, len, "%s%s", sysroot, path);
 463   return r;
 464 }
 465
 466 int
 467 xwrite (int sock, const void *v_buf, size_t len)
 468 {
 469   int r;
 470   const char *buf = v_buf;
 471
 472   while (len > 0) {
 473     r = write (sock, buf, len);
 474     if (r == -1) {
 475       perror ("write");
 476       return -1;
 477     }
 478     buf += r;
 479     len -= r;
 480   }
 481
 482   return 0;
 483 }
 484
 485 int
 486 xread (int sock, void *v_buf, size_t len)
 487 {
 488   int r;
 489   char *buf = v_buf;
 490
 491   while (len > 0) {
 492     r = read (sock, buf, len);
 493     if (r == -1) {
 494       perror ("read");
 495       return -1;
 496     }
 497     if (r == 0) {
 498       fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
 499       return -1;
 500     }
 501     buf += r;
 502     len -= r;
 503   }
 504
 505   return 0;
 506 }
 507
 508 int
 509 add_string (char ***argv, int *size, int *alloc, const char *str)
 510 {
 511   char **new_argv;
 512   char *new_str;
 513
 514   if (*size >= *alloc) {
 515     *alloc += 64;
 516     new_argv = realloc (*argv, *alloc * sizeof (char *));
 517     if (new_argv == NULL) {
 518       reply_with_perror ("realloc");
 519       free_strings (*argv);
 520       return -1;
 521     }
 522     *argv = new_argv;
 523   }
 524
 525   if (str) {
 526     new_str = strdup (str);
 527     if (new_str == NULL) {
 528       reply_with_perror ("strdup");
 529       free_strings (*argv);
 530     }
 531   } else
 532     new_str = NULL;
 533
 534   (*argv)[*size] = new_str;
 535
 536   (*size)++;
 537   return 0;
 538 }
 539
 540 int
 541 count_strings (char *const *argv)
 542 {
 543   int argc;
 544
 545   for (argc = 0; argv[argc] != NULL; ++argc)
 546     ;
 547   return argc;
 548 }
 549
 550 static int
 551 compare (const void *vp1, const void *vp2)
 552 {
 553   char * const *p1 = (char * const *) vp1;
 554   char * const *p2 = (char * const *) vp2;
 555   return strcmp (*p1, *p2);
 556 }
 557
 558 void
 559 sort_strings (char **argv, int len)
 560 {
 561   qsort (argv, len, sizeof (char *), compare);
 562 }
 563
 564 void
 565 free_strings (char **argv)
 566 {
 567   int argc;
 568
 569   for (argc = 0; argv[argc] != NULL; ++argc)
 570     free (argv[argc]);
 571   free (argv);
 572 }
 573
 574 void
 575 free_stringslen (char **argv, int len)
 576 {
 577   int i;
 578
 579   for (i = 0; i < len; ++i)
 580     free (argv[i]);
 581   free (argv);
 582 }
 583
 584 /* Easy ways to run external commands.  For full documentation, see
 585  * 'commandrvf' below.
 586  */
 587 int
 588 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
 589 {
 590   va_list args;
 591   const char **argv;
 592   char *s;
 593   int i, r;
 594
 595   /* Collect the command line arguments into an array. */
 596   i = 2;
 597   argv = malloc (sizeof (char *) * i);
 598   if (argv == NULL) {
 599     perror ("malloc");
 600     return -1;
 601   }
 602   argv[0] = (char *) name;
 603   argv[1] = NULL;
 604
 605   va_start (args, name);
 606
 607   while ((s = va_arg (args, char *)) != NULL) {
 608     const char **p = realloc (argv, sizeof (char *) * (++i));
 609     if (p == NULL) {
 610       perror ("realloc");
 611       free (argv);
 612       va_end (args);
 613       return -1;
 614     }
 615     argv = p;
 616     argv[i-2] = s;
 617     argv[i-1] = NULL;
 618   }
 619
 620   va_end (args);
 621
 622   r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
 623
 624   /* NB: Mustn't free the strings which are on the stack. */
 625   free (argv);
 626
 627   return r;
 628 }
 629
 630 /* Same as 'command', but we allow the status code from the
 631  * subcommand to be non-zero, and return that status code.
 632  * We still return -1 if there was some other error.
 633  */
 634 int
 635 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
 636 {
 637   va_list args;
 638   const char **argv;
 639   char *s;
 640   int i, r;
 641
 642   /* Collect the command line arguments into an array. */
 643   i = 2;
 644   argv = malloc (sizeof (char *) * i);
 645   if (argv == NULL) {
 646     perror ("malloc");
 647     return -1;
 648   }
 649   argv[0] = (char *) name;
 650   argv[1] = NULL;
 651
 652   va_start (args, name);
 653
 654   while ((s = va_arg (args, char *)) != NULL) {
 655     const char **p = realloc (argv, sizeof (char *) * (++i));
 656     if (p == NULL) {
 657       perror ("realloc");
 658       free (argv);
 659       va_end (args);
 660       return -1;
 661     }
 662     argv = p;
 663     argv[i-2] = s;
 664     argv[i-1] = NULL;
 665   }
 666
 667   va_end (args);
 668
 669   r = commandrvf (stdoutput, stderror, flags, argv);
 670
 671   /* NB: Mustn't free the strings which are on the stack. */
 672   free (argv);
 673
 674   return r;
 675 }
 676
 677 /* Same as 'command', but passing an argv. */
 678 int
 679 commandvf (char **stdoutput, char **stderror, int flags,
 680            char const *const *argv)
 681 {
 682   int r;
 683
 684   r = commandrvf (stdoutput, stderror, flags, (void *) argv);
 685   if (r == 0)
 686     return 0;
 687   else
 688     return -1;
 689 }
 690
 691 /* This is a more sane version of 'system(3)' for running external
 692  * commands.  It uses fork/execvp, so we don't need to worry about
 693  * quoting of parameters, and it allows us to capture any error
 694  * messages in a buffer.
 695  *
 696  * If stdoutput is not NULL, then *stdoutput will return the stdout
 697  * of the command.
 698  *
 699  * If stderror is not NULL, then *stderror will return the stderr
 700  * of the command.  If there is a final \n character, it is removed
 701  * so you can use the error string directly in a call to
 702  * reply_with_error.
 703  *
 704  * Flags:
 705  *
 706  * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
 707  * that send error messages to stdout (hello, parted) but that don't
 708  * have any useful stdout information, use this flag to capture the
 709  * error messages in the *stderror buffer.  If using this flag,
 710  * you should pass stdoutput as NULL because nothing could ever be
 711  * captured in that buffer.
 712  */
 713 int
 714 commandrvf (char **stdoutput, char **stderror, int flags,
 715             char const* const *argv)
 716 {
 717   int so_size = 0, se_size = 0;
 718   int so_fd[2], se_fd[2];
 719   pid_t pid;
 720   int r, quit, i;
 721   fd_set rset, rset2;
 722   char buf[256];
 723   char *p;
 724
 725   if (stdoutput) *stdoutput = NULL;
 726   if (stderror) *stderror = NULL;
 727
 728   if (verbose) {
 729     printf ("%s", argv[0]);
 730     for (i = 1; argv[i] != NULL; ++i)
 731       printf (" %s", argv[i]);
 732     printf ("\n");
 733   }
 734
 735   if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
 736     perror ("pipe");
 737     return -1;
 738   }
 739
 740   pid = fork ();
 741   if (pid == -1) {
 742     perror ("fork");
 743     close (so_fd[0]);
 744     close (so_fd[1]);
 745     close (se_fd[0]);
 746     close (se_fd[1]);
 747     return -1;
 748   }
 749
 750   if (pid == 0) {               /* Child process. */
 751     close (0);
 752     open ("/dev/null", O_RDONLY); /* Set stdin to /dev/null (ignore failure) */
 753     close (so_fd[0]);
 754     close (se_fd[0]);
 755     if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
 756       dup2 (so_fd[1], 1);
 757     else
 758       dup2 (se_fd[1], 1);
 759     dup2 (se_fd[1], 2);
 760     close (so_fd[1]);
 761     close (se_fd[1]);
 762
 763     execvp (argv[0], (void *) argv);
 764     perror (argv[0]);
 765     _exit (1);
 766   }
 767
 768   /* Parent process. */
 769   close (so_fd[1]);
 770   close (se_fd[1]);
 771
 772   FD_ZERO (&rset);
 773   FD_SET (so_fd[0], &rset);
 774   FD_SET (se_fd[0], &rset);
 775
 776   quit = 0;
 777   while (quit < 2) {
 778     rset2 = rset;
 779     r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
 780     if (r == -1) {
 781       perror ("select");
 782     quit:
 783       if (stdoutput) free (*stdoutput);
 784       if (stderror) free (*stderror);
 785       close (so_fd[0]);
 786       close (se_fd[0]);
 787       waitpid (pid, NULL, 0);
 788       return -1;
 789     }
 790
 791     if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
 792       r = read (so_fd[0], buf, sizeof buf);
 793       if (r == -1) {
 794         perror ("read");
 795         goto quit;
 796       }
 797       if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
 798
 799       if (r > 0 && stdoutput) {
 800         so_size += r;
 801         p = realloc (*stdoutput, so_size);
 802         if (p == NULL) {
 803           perror ("realloc");
 804           goto quit;
 805         }
 806         *stdoutput = p;
 807         memcpy (*stdoutput + so_size - r, buf, r);
 808       }
 809     }
 810
 811     if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
 812       r = read (se_fd[0], buf, sizeof buf);
 813       if (r == -1) {
 814         perror ("read");
 815         goto quit;
 816       }
 817       if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
 818
 819       if (r > 0) {
 820         if (verbose)
 821           ignore_value (write (2, buf, r));
 822
 823         if (stderror) {
 824           se_size += r;
 825           p = realloc (*stderror, se_size);
 826           if (p == NULL) {
 827             perror ("realloc");
 828             goto quit;
 829           }
 830           *stderror = p;
 831           memcpy (*stderror + se_size - r, buf, r);
 832         }
 833       }
 834     }
 835   }
 836
 837   close (so_fd[0]);
 838   close (se_fd[0]);
 839
 840   /* Make sure the output buffers are \0-terminated.  Also remove any
 841    * trailing \n characters from the error buffer (not from stdout).
 842    */
 843   if (stdoutput) {
 844     void *q = realloc (*stdoutput, so_size+1);
 845     if (q == NULL) {
 846       perror ("realloc");
 847       free (*stdoutput);
 848     }
 849     *stdoutput = q;
 850     if (*stdoutput)
 851       (*stdoutput)[so_size] = '\0';
 852   }
 853   if (stderror) {
 854     void *q = realloc (*stderror, se_size+1);
 855     if (q == NULL) {
 856       perror ("realloc");
 857       free (*stderror);
 858     }
 859     *stderror = q;
 860     if (*stderror) {
 861       (*stderror)[se_size] = '\0';
 862       se_size--;
 863       while (se_size >= 0 && (*stderror)[se_size] == '\n')
 864         (*stderror)[se_size--] = '\0';
 865     }
 866   }
 867
 868   /* Get the exit status of the command. */
 869   if (waitpid (pid, &r, 0) != pid) {
 870     perror ("waitpid");
 871     return -1;
 872   }
 873
 874   if (WIFEXITED (r)) {
 875     return WEXITSTATUS (r);
 876   } else
 877     return -1;
 878 }
 879
 880 /* Split an output string into a NULL-terminated list of lines.
 881  * Typically this is used where we have run an external command
 882  * which has printed out a list of things, and we want to return
 883  * an actual list.
 884  *
 885  * The corner cases here are quite tricky.  Note in particular:
 886  *
 887  *   "" -> []
 888  *   "\n" -> [""]
 889  *   "a\nb" -> ["a"; "b"]
 890  *   "a\nb\n" -> ["a"; "b"]
 891  *   "a\nb\n\n" -> ["a"; "b"; ""]
 892  *
 893  * The original string is written over and destroyed by this
 894  * function (which is usually OK because it's the 'out' string
 895  * from command()).  You can free the original string, because
 896  * add_string() strdups the strings.
 897  */
 898 char **
 899 split_lines (char *str)
 900 {
 901   char **lines = NULL;
 902   int size = 0, alloc = 0;
 903   char *p, *pend;
 904
 905   if (STREQ (str, ""))
 906     goto empty_list;
 907
 908   p = str;
 909   while (p) {
 910     /* Empty last line? */
 911     if (p[0] == '\0')
 912       break;
 913
 914     pend = strchr (p, '\n');
 915     if (pend) {
 916       *pend = '\0';
 917       pend++;
 918     }
 919
 920     if (add_string (&lines, &size, &alloc, p) == -1) {
 921       return NULL;
 922     }
 923
 924     p = pend;
 925   }
 926
 927  empty_list:
 928   if (add_string (&lines, &size, &alloc, NULL) == -1)
 929     return NULL;
 930
 931   return lines;
 932 }
 933
 934 /* Skip leading and trailing whitespace, updating the original string
 935  * in-place.
 936  */
 937 void
 938 trim (char *str)
 939 {
 940   size_t len = strlen (str);
 941
 942   while (len > 0 && c_isspace (str[len-1])) {
 943     str[len-1] = '\0';
 944     len--;
 945   }
 946
 947   const char *p = str;
 948   while (*p && c_isspace (*p)) {
 949     p++;
 950     len--;
 951   }
 952
 953   memmove (str, p, len+1);
 954 }
 955
 956 /* printf helper function so we can use %Q ("quoted") and %R to print
 957  * shell-quoted strings.  See HACKING file for more details.
 958  */
 959 static int
 960 print_shell_quote (FILE *stream,
 961                    const struct printf_info *info ATTRIBUTE_UNUSED,
 962                    const void *const *args)
 963 {
 964 #define SAFE(c) (c_isalnum((c)) ||                                      \
 965                  (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
 966   int i, len;
 967   const char *str = *((const char **) (args[0]));
 968
 969   for (i = len = 0; str[i]; ++i) {
 970     if (!SAFE(str[i])) {
 971       putc ('\\', stream);
 972       len ++;
 973     }
 974     putc (str[i], stream);
 975     len ++;
 976   }
 977
 978   return len;
 979 }
 980
 981 static int
 982 print_sysroot_shell_quote (FILE *stream,
 983                            const struct printf_info *info,
 984                            const void *const *args)
 985 {
 986   fputs (sysroot, stream);
 987   return sysroot_len + print_shell_quote (stream, info, args);
 988 }
 989
 990 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
 991 static int
 992 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
 993                size_t n, int *argtypes, int *size)
 994 {
 995   if (n > 0) {
 996     argtypes[0] = PA_STRING;
 997     size[0] = sizeof (const char *);
 998   }
 999   return 1;
1000 }
1001 #else
1002 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
1003 static int
1004 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
1005 {
1006   if (n > 0)
1007     argtypes[0] = PA_STRING;
1008   return 1;
1009 }
1010 #else
1011 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
1012 #endif
1013 #endif
1014
1015 /* Perform device name translation.  Don't call this directly -
1016  * use the RESOLVE_DEVICE macro.
1017  *
1018  * See guestfs(3) for the algorithm.
1019  *
1020  * We have to open the device and test for ENXIO, because
1021  * the device nodes themselves will exist in the appliance.
1022  */
1023 int
1024 device_name_translation (char *device, const char *func)
1025 {
1026   int fd;
1027
1028   fd = open (device, O_RDONLY);
1029   if (fd >= 0) {
1030     close (fd);
1031     return 0;
1032   }
1033
1034   if (errno != ENXIO && errno != ENOENT) {
1035   error:
1036     reply_with_perror ("%s: %s", func, device);
1037     return -1;
1038   }
1039
1040   /* If the name begins with "/dev/sd" then try the alternatives. */
1041   if (STRNEQLEN (device, "/dev/sd", 7))
1042     goto error;
1043
1044   device[5] = 'h';              /* /dev/hd (old IDE driver) */
1045   fd = open (device, O_RDONLY);
1046   if (fd >= 0) {
1047     close (fd);
1048     return 0;
1049   }
1050
1051   device[5] = 'v';              /* /dev/vd (for virtio devices) */
1052   fd = open (device, O_RDONLY);
1053   if (fd >= 0) {
1054     close (fd);
1055     return 0;
1056   }
1057
1058   device[5] = 's';              /* Restore original device name. */
1059   goto error;
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 }