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