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