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