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