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