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