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