fish/fish.c

   1 /* guestfish - the filesystem interactive shell
   2  * Copyright (C) 2009-2010 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 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26 #include <getopt.h>
  27 #include <signal.h>
  28 #include <assert.h>
  29 #include <sys/types.h>
  30 #include <sys/wait.h>
  31 #include <locale.h>
  32
  33 #ifdef HAVE_LIBREADLINE
  34 #include <readline/readline.h>
  35 #include <readline/history.h>
  36 #endif
  37
  38 #include <guestfs.h>
  39
  40 #include "fish.h"
  41 #include "c-ctype.h"
  42 #include "closeout.h"
  43 #include "progname.h"
  44
  45 struct drv {
  46   struct drv *next;
  47   char *filename;               /* disk filename (for -a or -N options) */
  48   prep_data *data;              /* prepared type (for -N option only) */
  49   char *device;                 /* device inside the appliance */
  50 };
  51
  52 struct mp {
  53   struct mp *next;
  54   char *device;
  55   char *mountpoint;
  56 };
  57
  58 static void add_drives (struct drv *drv);
  59 static void prepare_drives (struct drv *drv);
  60 static void mount_mps (struct mp *mp);
  61 static int launch (void);
  62 static void interactive (void);
  63 static void shell_script (void);
  64 static void script (int prompt);
  65 static void cmdline (char *argv[], int optind, int argc);
  66 static void initialize_readline (void);
  67 static void cleanup_readline (void);
  68 #ifdef HAVE_LIBREADLINE
  69 static void add_history_line (const char *);
  70 #endif
  71 static void print_shell_quote (FILE *stream, const char *str);
  72
  73 /* Currently open libguestfs handle. */
  74 guestfs_h *g;
  75
  76 int read_only = 0;
  77 int quit = 0;
  78 int verbose = 0;
  79 int remote_control_listen = 0;
  80 int remote_control = 0;
  81 int exit_on_error = 1;
  82 int command_num = 0;
  83
  84 static void __attribute__((noreturn))
  85 usage (int status)
  86 {
  87   if (status != EXIT_SUCCESS)
  88     fprintf (stderr, _("Try `%s --help' for more information.\n"),
  89              program_name);
  90   else {
  91     fprintf (stdout,
  92            _("%s: guest filesystem shell\n"
  93              "%s lets you edit virtual machine filesystems\n"
  94              "Copyright (C) 2009 Red Hat Inc.\n"
  95              "Usage:\n"
  96              "  %s [--options] cmd [: cmd : cmd ...]\n"
  97              "  %s -i libvirt-domain\n"
  98              "  %s -i disk-image(s)\n"
  99              "or for interactive use:\n"
 100              "  %s\n"
 101              "or from a shell script:\n"
 102              "  %s <<EOF\n"
 103              "  cmd\n"
 104              "  ...\n"
 105              "  EOF\n"
 106              "Options:\n"
 107              "  -h|--cmd-help        List available commands\n"
 108              "  -h|--cmd-help cmd    Display detailed help on 'cmd'\n"
 109              "  -a|--add image       Add image\n"
 110              "  -D|--no-dest-paths   Don't tab-complete paths from guest fs\n"
 111              "  -f|--file file       Read commands from file\n"
 112              "  -i|--inspector       Run virt-inspector to get disk mountpoints\n"
 113              "  --listen             Listen for remote commands\n"
 114              "  -m|--mount dev[:mnt] Mount dev on mnt (if omitted, /)\n"
 115              "  -n|--no-sync         Don't autosync\n"
 116              "  -N|--new type        Create prepared disk (test1.img, ...)\n"
 117              "  --remote[=pid]       Send commands to remote %s\n"
 118              "  -r|--ro              Mount read-only\n"
 119              "  --selinux            Enable SELinux support\n"
 120              "  -v|--verbose         Verbose messages\n"
 121              "  -x                   Echo each command before executing it\n"
 122              "  -V|--version         Display version and exit\n"
 123              "For more information,  see the manpage %s(1).\n"),
 124              program_name, program_name, program_name,
 125              program_name, program_name, program_name,
 126              program_name, program_name, program_name);
 127   }
 128   exit (status);
 129 }
 130
 131 int
 132 main (int argc, char *argv[])
 133 {
 134   /* Set global program name that is not polluted with libtool artifacts.  */
 135   set_program_name (argv[0]);
 136
 137   atexit (close_stdout);
 138
 139   setlocale (LC_ALL, "");
 140   bindtextdomain (PACKAGE, LOCALEBASEDIR);
 141   textdomain (PACKAGE);
 142
 143   enum { HELP_OPTION = CHAR_MAX + 1 };
 144
 145   static const char *options = "a:Df:h::im:nN:rv?Vx";
 146   static const struct option long_options[] = {
 147     { "add", 1, 0, 'a' },
 148     { "cmd-help", 2, 0, 'h' },
 149     { "file", 1, 0, 'f' },
 150     { "help", 0, 0, HELP_OPTION },
 151     { "inspector", 0, 0, 'i' },
 152     { "listen", 0, 0, 0 },
 153     { "mount", 1, 0, 'm' },
 154     { "new", 1, 0, 'N' },
 155     { "no-dest-paths", 0, 0, 'D' },
 156     { "no-sync", 0, 0, 'n' },
 157     { "remote", 2, 0, 0 },
 158     { "ro", 0, 0, 'r' },
 159     { "selinux", 0, 0, 0 },
 160     { "verbose", 0, 0, 'v' },
 161     { "version", 0, 0, 'V' },
 162     { 0, 0, 0, 0 }
 163   };
 164   struct drv *drvs = NULL;
 165   struct drv *drv;
 166   struct mp *mps = NULL;
 167   struct mp *mp;
 168   char *p, *file = NULL;
 169   int c;
 170   int inspector = 0;
 171   int option_index;
 172   struct sigaction sa;
 173   char next_drive = 'a';
 174   int next_prepared_drive = 1;
 175
 176   initialize_readline ();
 177
 178   memset (&sa, 0, sizeof sa);
 179   sa.sa_handler = SIG_IGN;
 180   sa.sa_flags = SA_RESTART;
 181   sigaction (SIGPIPE, &sa, NULL);
 182
 183   /* guestfs_create is meant to be a lightweight operation, so
 184    * it's OK to do it early here.
 185    */
 186   g = guestfs_create ();
 187   if (g == NULL) {
 188     fprintf (stderr, _("guestfs_create: failed to create handle\n"));
 189     exit (EXIT_FAILURE);
 190   }
 191
 192   guestfs_set_autosync (g, 1);
 193
 194   /* If developing, add ./appliance to the path.  Note that libtools
 195    * interferes with this because uninstalled guestfish is a shell
 196    * script that runs the real program with an absolute path.  Detect
 197    * that too.
 198    *
 199    * BUT if LIBGUESTFS_PATH environment variable is already set by
 200    * the user, then don't override it.
 201    */
 202   if (getenv ("LIBGUESTFS_PATH") == NULL &&
 203       argv[0] &&
 204       (argv[0][0] != '/' || strstr (argv[0], "/.libs/lt-") != NULL))
 205     guestfs_set_path (g, "appliance:" GUESTFS_DEFAULT_PATH);
 206
 207   /* CAUTION: we are careful to modify argv[0] here, only after
 208    * using it just above.
 209    *
 210    * getopt_long uses argv[0], so give it the sanitized name.  Save a copy
 211    * of the original, in case it's needed in virt-inspector mode, below.
 212    */
 213   char *real_argv0 = argv[0];
 214   argv[0] = bad_cast (program_name);
 215
 216   for (;;) {
 217     c = getopt_long (argc, argv, options, long_options, &option_index);
 218     if (c == -1) break;
 219
 220     switch (c) {
 221     case 0:                     /* options which are long only */
 222       if (STREQ (long_options[option_index].name, "listen"))
 223         remote_control_listen = 1;
 224       else if (STREQ (long_options[option_index].name, "remote")) {
 225         if (optarg) {
 226           if (sscanf (optarg, "%d", &remote_control) != 1) {
 227             fprintf (stderr, _("%s: --listen=PID: PID was not a number: %s\n"),
 228                      program_name, optarg);
 229             exit (EXIT_FAILURE);
 230           }
 231         } else {
 232           p = getenv ("GUESTFISH_PID");
 233           if (!p || sscanf (p, "%d", &remote_control) != 1) {
 234             fprintf (stderr, _("%s: remote: $GUESTFISH_PID must be set"
 235                                " to the PID of the remote process\n"),
 236                      program_name);
 237             exit (EXIT_FAILURE);
 238           }
 239         }
 240       } else if (STREQ (long_options[option_index].name, "selinux")) {
 241         guestfs_set_selinux (g, 1);
 242       } else {
 243         fprintf (stderr, _("%s: unknown long option: %s (%d)\n"),
 244                  program_name, long_options[option_index].name, option_index);
 245         exit (EXIT_FAILURE);
 246       }
 247       break;
 248
 249     case 'a':
 250       if (access (optarg, R_OK) != 0) {
 251         perror (optarg);
 252         exit (EXIT_FAILURE);
 253       }
 254       drv = malloc (sizeof (struct drv));
 255       if (!drv) {
 256         perror ("malloc");
 257         exit (EXIT_FAILURE);
 258       }
 259       drv->filename = optarg;
 260       drv->data = NULL;
 261       /* We could fill the device field in, but in fact we
 262        * only use it for the -N option at present.
 263        */
 264       drv->device = NULL;
 265       drv->next = drvs;
 266       drvs = drv;
 267       next_drive++;
 268       break;
 269
 270     case 'N':
 271       if (STRCASEEQ (optarg, "list")) {
 272         list_prepared_drives ();
 273         exit (EXIT_SUCCESS);
 274       }
 275       drv = malloc (sizeof (struct drv));
 276       if (!drv) {
 277         perror ("malloc");
 278         exit (EXIT_FAILURE);
 279       }
 280       if (asprintf (&drv->filename, "test%d.img",
 281                     next_prepared_drive++) == -1) {
 282         perror ("asprintf");
 283         exit (EXIT_FAILURE);
 284       }
 285       drv->data = create_prepared_file (optarg, drv->filename);
 286       if (asprintf (&drv->device, "/dev/sd%c", next_drive++) == -1) {
 287         perror ("asprintf");
 288         exit (EXIT_FAILURE);
 289       }
 290       drv->next = drvs;
 291       drvs = drv;
 292       break;
 293
 294     case 'D':
 295       complete_dest_paths = 0;
 296       break;
 297
 298     case 'f':
 299       if (file) {
 300         fprintf (stderr, _("%s: only one -f parameter can be given\n"),
 301                  program_name);
 302         exit (EXIT_FAILURE);
 303       }
 304       file = optarg;
 305       break;
 306
 307     case 'h': {
 308       int r = 0;
 309
 310       if (optarg)
 311         r = display_command (optarg);
 312       else if (argv[optind] && argv[optind][0] != '-')
 313         r = display_command (argv[optind++]);
 314       else
 315         list_commands ();
 316
 317       exit (r == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 318     }
 319
 320     case 'i':
 321       inspector = 1;
 322       break;
 323
 324     case 'm':
 325       mp = malloc (sizeof (struct mp));
 326       if (!mp) {
 327         perror ("malloc");
 328         exit (EXIT_FAILURE);
 329       }
 330       p = strchr (optarg, ':');
 331       if (p) {
 332         *p = '\0';
 333         mp->mountpoint = p+1;
 334       } else
 335         mp->mountpoint = bad_cast ("/");
 336       mp->device = optarg;
 337       mp->next = mps;
 338       mps = mp;
 339       break;
 340
 341     case 'n':
 342       guestfs_set_autosync (g, 0);
 343       break;
 344
 345     case 'r':
 346       read_only = 1;
 347       break;
 348
 349     case 'v':
 350       verbose++;
 351       guestfs_set_verbose (g, verbose);
 352       break;
 353
 354     case 'V':
 355       printf ("%s %s\n", program_name, PACKAGE_VERSION);
 356       exit (EXIT_SUCCESS);
 357
 358     case 'x':
 359       guestfs_set_trace (g, 1);
 360       break;
 361
 362     case HELP_OPTION:
 363       usage (EXIT_SUCCESS);
 364
 365     default:
 366       usage (EXIT_FAILURE);
 367     }
 368   }
 369
 370   /* Inspector mode invalidates most of the other arguments. */
 371   if (inspector) {
 372     if (drvs || mps || remote_control_listen || remote_control ||
 373         guestfs_get_selinux (g)) {
 374       fprintf (stderr, _("%s: cannot use -i option with -a, -m, -N, "
 375                          "--listen, --remote or --selinux\n"),
 376                program_name);
 377       exit (EXIT_FAILURE);
 378     }
 379     if (optind >= argc) {
 380       fprintf (stderr,
 381            _("%s: -i requires a libvirt domain or path(s) to disk image(s)\n"),
 382                program_name);
 383       exit (EXIT_FAILURE);
 384     }
 385
 386     char *cmd;
 387     size_t cmdlen;
 388     FILE *fp = open_memstream (&cmd, &cmdlen);
 389     if (fp == NULL) {
 390       perror ("open_memstream");
 391       exit (EXIT_FAILURE);
 392     }
 393
 394     fprintf (fp, "virt-inspector");
 395     while (optind < argc) {
 396       fputc (' ', fp);
 397       print_shell_quote (fp, argv[optind]);
 398       optind++;
 399     }
 400
 401     if (read_only)
 402       fprintf (fp, " --ro-fish");
 403     else
 404       fprintf (fp, " --fish");
 405
 406     if (fclose (fp) == -1) {
 407       perror ("fclose");
 408       exit (EXIT_FAILURE);
 409     }
 410
 411     if (verbose)
 412       fprintf (stderr,
 413                "%s -i: running: %s\n", program_name, cmd);
 414
 415     FILE *pp = popen (cmd, "r");
 416     if (pp == NULL) {
 417       perror (cmd);
 418       exit (EXIT_FAILURE);
 419     }
 420
 421     char *cmd2;
 422     fp = open_memstream (&cmd2, &cmdlen);
 423     if (fp == NULL) {
 424       perror ("open_memstream");
 425       exit (EXIT_FAILURE);
 426     }
 427
 428     fprintf (fp, "%s", real_argv0);
 429
 430     if (guestfs_get_verbose (g))
 431       fprintf (fp, " -v");
 432     if (!guestfs_get_autosync (g))
 433       fprintf (fp, " -n");
 434     if (guestfs_get_trace (g))
 435       fprintf (fp, " -x");
 436
 437     char *insp = NULL;
 438     size_t insplen;
 439     if (getline (&insp, &insplen, pp) == -1) {
 440       perror (cmd);
 441       exit (EXIT_FAILURE);
 442     }
 443     fprintf (fp, " %s", insp);
 444
 445     if (pclose (pp) == -1) {
 446       perror (cmd);
 447       exit (EXIT_FAILURE);
 448     }
 449
 450     if (fclose (fp) == -1) {
 451       perror ("fclose");
 452       exit (EXIT_FAILURE);
 453     }
 454
 455     if (verbose)
 456       fprintf (stderr,
 457                "%s -i: running: %s\n", program_name, cmd2);
 458
 459     int r = system (cmd2);
 460     if (r == -1) {
 461       perror (cmd2);
 462       exit (EXIT_FAILURE);
 463     }
 464
 465     free (cmd);
 466     free (cmd2);
 467     free (insp);
 468
 469     exit (WEXITSTATUS (r));
 470   }
 471
 472   /* If we've got drives to add, add them now. */
 473   add_drives (drvs);
 474
 475   /* If we've got mountpoints or prepared drives, we must launch the
 476    * guest and mount them.
 477    */
 478   if (next_prepared_drive > 1 || mps != NULL) {
 479     if (launch () == -1) exit (EXIT_FAILURE);
 480     prepare_drives (drvs);
 481     mount_mps (mps);
 482   }
 483
 484   /* Remote control? */
 485   if (remote_control_listen && remote_control) {
 486     fprintf (stderr,
 487              _("%s: cannot use --listen and --remote options at the same time\n"),
 488              program_name);
 489     exit (EXIT_FAILURE);
 490   }
 491
 492   if (remote_control_listen) {
 493     if (optind < argc) {
 494       fprintf (stderr,
 495                _("%s: extra parameters on the command line with --listen flag\n"),
 496                program_name);
 497       exit (EXIT_FAILURE);
 498     }
 499     if (file) {
 500       fprintf (stderr,
 501                _("%s: cannot use --listen and --file options at the same time\n"),
 502                program_name);
 503       exit (EXIT_FAILURE);
 504     }
 505     rc_listen ();
 506   }
 507
 508   /* -f (file) parameter? */
 509   if (file) {
 510     close (0);
 511     if (open (file, O_RDONLY) == -1) {
 512       perror (file);
 513       exit (EXIT_FAILURE);
 514     }
 515   }
 516
 517   /* Interactive, shell script, or command(s) on the command line? */
 518   if (optind >= argc) {
 519     if (isatty (0))
 520       interactive ();
 521     else
 522       shell_script ();
 523   }
 524   else
 525     cmdline (argv, optind, argc);
 526
 527   cleanup_readline ();
 528
 529   exit (EXIT_SUCCESS);
 530 }
 531
 532 void
 533 pod2text (const char *name, const char *shortdesc, const char *str)
 534 {
 535   FILE *fp;
 536
 537   fp = popen ("pod2text", "w");
 538   if (fp == NULL) {
 539     /* pod2text failed, maybe not found, so let's just print the
 540      * source instead, since that's better than doing nothing.
 541      */
 542     printf ("%s - %s\n\n%s\n", name, shortdesc, str);
 543     return;
 544   }
 545   fprintf (fp, "=head1 NAME\n\n%s - %s\n\n", name, shortdesc);
 546   fputs (str, fp);
 547   pclose (fp);
 548 }
 549
 550 /* List is built in reverse order, so mount them in reverse order. */
 551 static void
 552 mount_mps (struct mp *mp)
 553 {
 554   int r;
 555
 556   if (mp) {
 557     mount_mps (mp->next);
 558
 559     /* Don't use guestfs_mount here because that will default to mount
 560      * options -o sync,noatime.  For more information, see guestfs(3)
 561      * section "LIBGUESTFS GOTCHAS".
 562      */
 563     const char *options = read_only ? "ro" : "";
 564     r = guestfs_mount_options (g, options, mp->device, mp->mountpoint);
 565     if (r == -1)
 566       exit (EXIT_FAILURE);
 567   }
 568 }
 569
 570 static void
 571 add_drives (struct drv *drv)
 572 {
 573   int r;
 574
 575   if (drv) {
 576     add_drives (drv->next);
 577
 578     if (drv->data /* -N option is not affected by --ro */ || !read_only)
 579       r = guestfs_add_drive (g, drv->filename);
 580     else
 581       r = guestfs_add_drive_ro (g, drv->filename);
 582     if (r == -1)
 583       exit (EXIT_FAILURE);
 584   }
 585 }
 586
 587 static void
 588 prepare_drives (struct drv *drv)
 589 {
 590   if (drv) {
 591     prepare_drives (drv->next);
 592     if (drv->data)
 593       prepare_drive (drv->filename, drv->data, drv->device);
 594   }
 595 }
 596
 597 static int
 598 launch (void)
 599 {
 600   if (guestfs_is_config (g)) {
 601     if (guestfs_launch (g) == -1)
 602       return -1;
 603   }
 604   return 0;
 605 }
 606
 607 static void
 608 interactive (void)
 609 {
 610   script (1);
 611 }
 612
 613 static void
 614 shell_script (void)
 615 {
 616   script (0);
 617 }
 618
 619 #define FISH "><fs> "
 620
 621 static char *line_read = NULL;
 622
 623 static char *
 624 rl_gets (int prompt)
 625 {
 626 #ifdef HAVE_LIBREADLINE
 627
 628   if (prompt) {
 629     if (line_read) {
 630       free (line_read);
 631       line_read = NULL;
 632     }
 633
 634     line_read = readline (prompt ? FISH : "");
 635
 636     if (line_read && *line_read)
 637       add_history_line (line_read);
 638
 639     return line_read;
 640   }
 641
 642 #endif /* HAVE_LIBREADLINE */
 643
 644   static char buf[8192];
 645   int len;
 646
 647   if (prompt) printf (FISH);
 648   line_read = fgets (buf, sizeof buf, stdin);
 649
 650   if (line_read) {
 651     len = strlen (line_read);
 652     if (len > 0 && buf[len-1] == '\n') buf[len-1] = '\0';
 653   }
 654
 655   return line_read;
 656 }
 657
 658 static void
 659 script (int prompt)
 660 {
 661   char *buf;
 662   char *cmd;
 663   char *p, *pend;
 664   char *argv[64];
 665   int len;
 666   int global_exit_on_error = !prompt;
 667   int tilde_candidate;
 668
 669   if (prompt)
 670     printf (_("\n"
 671               "Welcome to guestfish, the libguestfs filesystem interactive shell for\n"
 672               "editing virtual machine filesystems.\n"
 673               "\n"
 674               "Type: 'help' for a list of commands\n"
 675               "      'man' to read the manual\n"
 676               "      'quit' to quit the shell\n"
 677               "\n"));
 678
 679   while (!quit) {
 680     char *pipe = NULL;
 681
 682     exit_on_error = global_exit_on_error;
 683
 684     buf = rl_gets (prompt);
 685     if (!buf) {
 686       quit = 1;
 687       break;
 688     }
 689
 690     /* Skip any initial whitespace before the command. */
 691   again:
 692     while (*buf && c_isspace (*buf))
 693       buf++;
 694
 695     if (!*buf) continue;
 696
 697     /* If the next character is '#' then this is a comment. */
 698     if (*buf == '#') continue;
 699
 700     /* If the next character is '!' then pass the whole lot to system(3). */
 701     if (*buf == '!') {
 702       int r;
 703
 704       r = system (buf+1);
 705       if (exit_on_error) {
 706         if (r == -1 ||
 707             (WIFSIGNALED (r) &&
 708              (WTERMSIG (r) == SIGINT || WTERMSIG (r) == SIGQUIT)) ||
 709             WEXITSTATUS (r) != 0)
 710           exit (EXIT_FAILURE);
 711       }
 712       continue;
 713     }
 714
 715     /* If the next character is '-' allow the command to fail without
 716      * exiting on error (just for this one command though).
 717      */
 718     if (*buf == '-') {
 719       exit_on_error = 0;
 720       buf++;
 721       goto again;
 722     }
 723
 724     /* Get the command (cannot be quoted). */
 725     len = strcspn (buf, " \t");
 726
 727     if (len == 0) continue;
 728
 729     cmd = buf;
 730     unsigned int i = 0;
 731     if (buf[len] == '\0') {
 732       argv[0] = NULL;
 733       goto got_command;
 734     }
 735
 736     buf[len] = '\0';
 737     p = &buf[len+1];
 738     p += strspn (p, " \t");
 739
 740     /* Get the parameters. */
 741     while (*p && i < sizeof argv / sizeof argv[0]) {
 742       tilde_candidate = 0;
 743
 744       /* Parameters which start with quotes or pipes are treated
 745        * specially.  Bare parameters are delimited by whitespace.
 746        */
 747       if (*p == '"') {
 748         p++;
 749         len = strcspn (p, "\"");
 750         if (p[len] == '\0') {
 751           fprintf (stderr, _("%s: unterminated double quote\n"), program_name);
 752           if (exit_on_error) exit (EXIT_FAILURE);
 753           goto next_command;
 754         }
 755         if (p[len+1] && (p[len+1] != ' ' && p[len+1] != '\t')) {
 756           fprintf (stderr,
 757                    _("%s: command arguments not separated by whitespace\n"),
 758                    program_name);
 759           if (exit_on_error) exit (EXIT_FAILURE);
 760           goto next_command;
 761         }
 762         p[len] = '\0';
 763         pend = p[len+1] ? &p[len+2] : &p[len+1];
 764       } else if (*p == '\'') {
 765         p++;
 766         len = strcspn (p, "'");
 767         if (p[len] == '\0') {
 768           fprintf (stderr, _("%s: unterminated single quote\n"), program_name);
 769           if (exit_on_error) exit (EXIT_FAILURE);
 770           goto next_command;
 771         }
 772         if (p[len+1] && (p[len+1] != ' ' && p[len+1] != '\t')) {
 773           fprintf (stderr,
 774                    _("%s: command arguments not separated by whitespace\n"),
 775                    program_name);
 776           if (exit_on_error) exit (EXIT_FAILURE);
 777           goto next_command;
 778         }
 779         p[len] = '\0';
 780         pend = p[len+1] ? &p[len+2] : &p[len+1];
 781       } else if (*p == '|') {
 782         *p = '\0';
 783         pipe = p+1;
 784         continue;
 785         /*
 786       } else if (*p == '[') {
 787         int c = 1;
 788         p++;
 789         pend = p;
 790         while (*pend && c != 0) {
 791           if (*pend == '[') c++;
 792           else if (*pend == ']') c--;
 793           pend++;
 794         }
 795         if (c != 0) {
 796           fprintf (stderr,
 797                    _("%s: unterminated \"[...]\" sequence\n"), program_name);
 798           if (exit_on_error) exit (EXIT_FAILURE);
 799           goto next_command;
 800         }
 801         if (*pend && (*pend != ' ' && *pend != '\t')) {
 802           fprintf (stderr,
 803                    _("%s: command arguments not separated by whitespace\n"),
 804                    program_name);
 805           if (exit_on_error) exit (EXIT_FAILURE);
 806           goto next_command;
 807         }
 808         *(pend-1) = '\0';
 809         */
 810       } else if (*p != ' ' && *p != '\t') {
 811         /* If the first character is a ~ then note that this parameter
 812          * is a candidate for ~username expansion.  NB this does not
 813          * apply to quoted parameters.
 814          */
 815         tilde_candidate = *p == '~';
 816         len = strcspn (p, " \t");
 817         if (p[len]) {
 818           p[len] = '\0';
 819           pend = &p[len+1];
 820         } else
 821           pend = &p[len];
 822       } else {
 823         fprintf (stderr, _("%s: internal error parsing string at '%s'\n"),
 824                  program_name, p);
 825         abort ();
 826       }
 827
 828       if (!tilde_candidate)
 829         argv[i] = p;
 830       else
 831         argv[i] = try_tilde_expansion (p);
 832       i++;
 833       p = pend;
 834
 835       if (*p)
 836         p += strspn (p, " \t");
 837     }
 838
 839     if (i == sizeof argv / sizeof argv[0]) {
 840       fprintf (stderr, _("%s: too many arguments\n"), program_name);
 841       if (exit_on_error) exit (EXIT_FAILURE);
 842       goto next_command;
 843     }
 844
 845     argv[i] = NULL;
 846
 847   got_command:
 848     if (issue_command (cmd, argv, pipe) == -1) {
 849       if (exit_on_error) exit (EXIT_FAILURE);
 850     }
 851
 852   next_command:;
 853   }
 854   if (prompt) printf ("\n");
 855 }
 856
 857 static void
 858 cmdline (char *argv[], int optind, int argc)
 859 {
 860   const char *cmd;
 861   char **params;
 862
 863   exit_on_error = 1;
 864
 865   if (optind >= argc) return;
 866
 867   cmd = argv[optind++];
 868   if (STREQ (cmd, ":")) {
 869     fprintf (stderr, _("%s: empty command on command line\n"), program_name);
 870     exit (EXIT_FAILURE);
 871   }
 872
 873   /* Allow -cmd on the command line to mean (temporarily) override
 874    * the normal exit on error (RHBZ#578407).
 875    */
 876   if (cmd[0] == '-') {
 877     exit_on_error = 0;
 878     cmd++;
 879   }
 880
 881   params = &argv[optind];
 882
 883   /* Search for end of command list or ":" ... */
 884   while (optind < argc && STRNEQ (argv[optind], ":"))
 885     optind++;
 886
 887   if (optind == argc) {
 888     if (issue_command (cmd, params, NULL) == -1 && exit_on_error)
 889         exit (EXIT_FAILURE);
 890   } else {
 891     argv[optind] = NULL;
 892     if (issue_command (cmd, params, NULL) == -1 && exit_on_error)
 893       exit (EXIT_FAILURE);
 894     cmdline (argv, optind+1, argc);
 895   }
 896 }
 897
 898 int
 899 issue_command (const char *cmd, char *argv[], const char *pipecmd)
 900 {
 901   int argc;
 902   int stdout_saved_fd = -1;
 903   int pid = 0;
 904   int i, r;
 905
 906   /* This counts the commands issued, starting at 1. */
 907   command_num++;
 908
 909   /* For | ... commands.  Annoyingly we can't use popen(3) here. */
 910   if (pipecmd) {
 911     int fd[2];
 912
 913     if (fflush (stdout) == EOF) {
 914       perror ("failed to flush standard output");
 915       return -1;
 916     }
 917     if (pipe (fd) < 0) {
 918       perror ("pipe failed");
 919       return -1;
 920     }
 921     pid = fork ();
 922     if (pid == -1) {
 923       perror ("fork");
 924       return -1;
 925     }
 926
 927     if (pid == 0) {             /* Child process. */
 928       close (fd[1]);
 929       if (dup2 (fd[0], 0) < 0) {
 930         perror ("dup2 of stdin failed");
 931         _exit (1);
 932       }
 933
 934       r = system (pipecmd);
 935       if (r == -1) {
 936         perror (pipecmd);
 937         _exit (1);
 938       }
 939       _exit (WEXITSTATUS (r));
 940     }
 941
 942     if ((stdout_saved_fd = dup (1)) < 0) {
 943       perror ("failed to dup stdout");
 944       return -1;
 945     }
 946     close (fd[0]);
 947     if (dup2 (fd[1], 1) < 0) {
 948       perror ("failed to dup stdout");
 949       close (stdout_saved_fd);
 950       return -1;
 951     }
 952     close (fd[1]);
 953   }
 954
 955   for (argc = 0; argv[argc] != NULL; ++argc)
 956     ;
 957
 958   /* If --remote was set, then send this command to a remote process. */
 959   if (remote_control)
 960     r = rc_remote (remote_control, cmd, argc, argv, exit_on_error);
 961
 962   /* Otherwise execute it locally. */
 963   else if (STRCASEEQ (cmd, "help")) {
 964     if (argc == 0) {
 965       list_commands ();
 966       r = 0;
 967     } else
 968       r = display_command (argv[0]);
 969   }
 970   else if (STRCASEEQ (cmd, "quit") ||
 971            STRCASEEQ (cmd, "exit") ||
 972            STRCASEEQ (cmd, "q")) {
 973     quit = 1;
 974     r = 0;
 975   }
 976   else if (STRCASEEQ (cmd, "alloc") ||
 977            STRCASEEQ (cmd, "allocate"))
 978     r = do_alloc (cmd, argc, argv);
 979   else if (STRCASEEQ (cmd, "echo"))
 980     r = do_echo (cmd, argc, argv);
 981   else if (STRCASEEQ (cmd, "edit") ||
 982            STRCASEEQ (cmd, "vi") ||
 983            STRCASEEQ (cmd, "emacs"))
 984     r = do_edit (cmd, argc, argv);
 985   else if (STRCASEEQ (cmd, "lcd"))
 986     r = do_lcd (cmd, argc, argv);
 987   else if (STRCASEEQ (cmd, "glob"))
 988     r = do_glob (cmd, argc, argv);
 989   else if (STRCASEEQ (cmd, "man") ||
 990            STRCASEEQ (cmd, "manual"))
 991     r = do_man (cmd, argc, argv);
 992   else if (STRCASEEQ (cmd, "more") ||
 993            STRCASEEQ (cmd, "less"))
 994     r = do_more (cmd, argc, argv);
 995   else if (STRCASEEQ (cmd, "reopen"))
 996     r = do_reopen (cmd, argc, argv);
 997   else if (STRCASEEQ (cmd, "sparse"))
 998     r = do_sparse (cmd, argc, argv);
 999   else if (STRCASEEQ (cmd, "supported"))
1000     r = do_supported (cmd, argc, argv);
1001   else if (STRCASEEQ (cmd, "time"))
1002     r = do_time (cmd, argc, argv);
1003   else
1004     r = run_action (cmd, argc, argv);
1005
1006   /* Always flush stdout after every command, so that messages, results
1007    * etc appear immediately.
1008    */
1009   if (fflush (stdout) == EOF) {
1010     perror ("failed to flush standard output");
1011     return -1;
1012   }
1013
1014   if (pipecmd) {
1015     close (1);
1016     if (dup2 (stdout_saved_fd, 1) < 0) {
1017       perror ("failed to dup2 standard output");
1018       r = -1;
1019     }
1020     close (stdout_saved_fd);
1021     if (waitpid (pid, NULL, 0) < 0) {
1022       perror ("waiting for command to complete");
1023       r = -1;
1024     }
1025   }
1026
1027   return r;
1028 }
1029
1030 void
1031 list_builtin_commands (void)
1032 {
1033   /* help, man and quit should appear at the top */
1034   printf ("%-20s %s\n",
1035           "help", _("display a list of commands or help on a command"));
1036   printf ("%-20s %s\n",
1037           "man", _("read the manual"));
1038   printf ("%-20s %s\n",
1039           "quit", _("quit guestfish"));
1040
1041   printf ("%-20s %s\n",
1042           "alloc", _("allocate an image"));
1043   printf ("%-20s %s\n",
1044           "echo", _("display a line of text"));
1045   printf ("%-20s %s\n",
1046           "edit", _("edit a file in the image"));
1047   printf ("%-20s %s\n",
1048           "lcd", _("local change directory"));
1049   printf ("%-20s %s\n",
1050           "glob", _("expand wildcards in command"));
1051   printf ("%-20s %s\n",
1052           "more", _("view a file in the pager"));
1053   printf ("%-20s %s\n",
1054           "reopen", _("close and reopen libguestfs handle"));
1055   printf ("%-20s %s\n",
1056           "sparse", _("allocate a sparse image file"));
1057   printf ("%-20s %s\n",
1058           "supported", _("list supported groups of commands"));
1059   printf ("%-20s %s\n",
1060           "time", _("measure time taken to run command"));
1061
1062   /* actions are printed after this (see list_commands) */
1063 }
1064
1065 int
1066 display_builtin_command (const char *cmd)
1067 {
1068   /* help for actions is auto-generated, see display_command */
1069
1070   if (STRCASEEQ (cmd, "alloc") ||
1071       STRCASEEQ (cmd, "allocate")) {
1072     printf (_("alloc - allocate an image\n"
1073               "     alloc <filename> <size>\n"
1074               "\n"
1075               "    This creates an empty (zeroed) file of the given size,\n"
1076               "    and then adds so it can be further examined.\n"
1077               "\n"
1078               "    For more advanced image creation, see qemu-img utility.\n"
1079               "\n"
1080               "    Size can be specified using standard suffixes, eg. '1M'.\n"
1081               ));
1082     return 0;
1083   }
1084   else if (STRCASEEQ (cmd, "echo")) {
1085     printf (_("echo - display a line of text\n"
1086               "     echo [<params> ...]\n"
1087               "\n"
1088               "    This echos the parameters to the terminal.\n"));
1089     return 0;
1090   }
1091   else if (STRCASEEQ (cmd, "edit") ||
1092            STRCASEEQ (cmd, "vi") ||
1093            STRCASEEQ (cmd, "emacs")) {
1094     printf (_("edit - edit a file in the image\n"
1095               "     edit <filename>\n"
1096               "\n"
1097               "    This is used to edit a file.\n"
1098               "\n"
1099               "    It is the equivalent of (and is implemented by)\n"
1100               "    running \"cat\", editing locally, and then \"write\".\n"
1101               "\n"
1102               "    Normally it uses $EDITOR, but if you use the aliases\n"
1103               "    \"vi\" or \"emacs\" you will get those editors.\n"
1104               "\n"
1105               "    NOTE: This will not work reliably for large files\n"
1106               "    (> 2 MB) or binary files containing \\0 bytes.\n"));
1107     return 0;
1108   }
1109   else if (STRCASEEQ (cmd, "lcd")) {
1110     printf (_("lcd - local change directory\n"
1111               "    lcd <directory>\n"
1112               "\n"
1113               "    Change guestfish's current directory. This command is\n"
1114               "    useful if you want to download files to a particular\n"
1115               "    place.\n"));
1116     return 0;
1117   }
1118   else if (STRCASEEQ (cmd, "glob")) {
1119     printf (_("glob - expand wildcards in command\n"
1120               "    glob <command> [<args> ...]\n"
1121               "\n"
1122               "    Glob runs <command> with wildcards expanded in any\n"
1123               "    command args.  Note that the command is run repeatedly\n"
1124               "    once for each expanded argument.\n"));
1125     return 0;
1126   }
1127   else if (STRCASEEQ (cmd, "man") ||
1128            STRCASEEQ (cmd, "manual")) {
1129     printf (_("man - read the manual\n"
1130               "    man\n"
1131               "\n"
1132               "    Opens the manual page for guestfish.\n"));
1133     return 0;
1134   }
1135   else if (STRCASEEQ (cmd, "help")) {
1136     printf (_("help - display a list of commands or help on a command\n"
1137               "     help cmd\n"
1138               "     help\n"));
1139     return 0;
1140   }
1141   else if (STRCASEEQ (cmd, "more") ||
1142            STRCASEEQ (cmd, "less")) {
1143     printf (_("more - view a file in the pager\n"
1144               "     more <filename>\n"
1145               "\n"
1146               "    This is used to view a file in the pager.\n"
1147               "\n"
1148               "    It is the equivalent of (and is implemented by)\n"
1149               "    running \"cat\" and using the pager.\n"
1150               "\n"
1151               "    Normally it uses $PAGER, but if you use the alias\n"
1152               "    \"less\" then it always uses \"less\".\n"
1153               "\n"
1154               "    NOTE: This will not work reliably for large files\n"
1155               "    (> 2 MB) or binary files containing \\0 bytes.\n"));
1156     return 0;
1157   }
1158   else if (STRCASEEQ (cmd, "quit") ||
1159            STRCASEEQ (cmd, "exit") ||
1160            STRCASEEQ (cmd, "q")) {
1161     printf (_("quit - quit guestfish\n"
1162               "     quit\n"));
1163     return 0;
1164   }
1165   else if (STRCASEEQ (cmd, "reopen")) {
1166     printf (_("reopen - close and reopen the libguestfs handle\n"
1167               "     reopen\n"
1168               "\n"
1169               "Close and reopen the libguestfs handle.  It is not necessary to use\n"
1170               "this normally, because the handle is closed properly when guestfish\n"
1171               "exits.  However this is occasionally useful for testing.\n"));
1172     return 0;
1173   }
1174   else if (STRCASEEQ (cmd, "sparse")) {
1175     printf (_("sparse - allocate a sparse image file\n"
1176               "     sparse <filename> <size>\n"
1177               "\n"
1178               "    This creates an empty sparse file of the given size,\n"
1179               "    and then adds so it can be further examined.\n"
1180               "\n"
1181               "    In all respects it works the same as the 'alloc'\n"
1182               "    command, except that the image file is allocated\n"
1183               "    sparsely, which means that disk blocks are not assigned\n"
1184               "    to the file until they are needed.  Sparse disk files\n"
1185               "    only use space when written to, but they are slower\n"
1186               "    and there is a danger you could run out of real disk\n"
1187               "    space during a write operation.\n"
1188               "\n"
1189               "    For more advanced image creation, see qemu-img utility.\n"
1190               "\n"
1191               "    Size can be specified using standard suffixes, eg. '1M'.\n"
1192               ));
1193     return 0;
1194   }
1195   else if (STRCASEEQ (cmd, "supported")) {
1196     printf (_("supported - list supported groups of commands\n"
1197               "     supported\n"
1198               "\n"
1199               "    This command returns a list of the optional groups\n"
1200               "    known to the daemon, and indicates which ones are\n"
1201               "    supported by this build of the libguestfs appliance.\n"
1202               "\n"
1203               "    See also guestfs(3) section AVAILABILITY.\n"
1204               ));
1205     return 0;
1206   }
1207   else if (STRCASEEQ (cmd, "time")) {
1208     printf (_("time - measure time taken to run command\n"
1209               "    time <command> [<args> ...]\n"
1210               "\n"
1211               "    This runs <command> as usual, and prints the elapsed\n"
1212               "    time afterwards.\n"));
1213     return 0;
1214   }
1215   else {
1216     fprintf (stderr, _("%s: command not known, use -h to list all commands\n"),
1217              cmd);
1218     return -1;
1219   }
1220 }
1221
1222 /* This is printed when the user types in an unknown command for the
1223  * first command issued.  A common case is the user doing:
1224  *   guestfish disk.img
1225  * expecting guestfish to open 'disk.img' (in fact, this tried to
1226  * run a command 'disk.img').
1227  */
1228 void
1229 extended_help_message (void)
1230 {
1231   fprintf (stderr,
1232            _("Did you mean to open a disk image?  guestfish -a disk.img\n"
1233              "For a list of commands:             guestfish -h\n"
1234              "For complete documentation:         man guestfish\n"));
1235 }
1236
1237 void
1238 free_strings (char **argv)
1239 {
1240   int argc;
1241
1242   for (argc = 0; argv[argc] != NULL; ++argc)
1243     free (argv[argc]);
1244   free (argv);
1245 }
1246
1247 int
1248 count_strings (char *const *argv)
1249 {
1250   int c;
1251
1252   for (c = 0; argv[c]; ++c)
1253     ;
1254   return c;
1255 }
1256
1257 void
1258 print_strings (char *const *argv)
1259 {
1260   int argc;
1261
1262   for (argc = 0; argv[argc] != NULL; ++argc)
1263     printf ("%s\n", argv[argc]);
1264 }
1265
1266 void
1267 print_table (char *const *argv)
1268 {
1269   int i;
1270
1271   for (i = 0; argv[i] != NULL; i += 2)
1272     printf ("%s: %s\n", argv[i], argv[i+1]);
1273 }
1274
1275 int
1276 is_true (const char *str)
1277 {
1278   return
1279     STRCASENEQ (str, "0") &&
1280     STRCASENEQ (str, "f") &&
1281     STRCASENEQ (str, "false") &&
1282     STRCASENEQ (str, "n") &&
1283     STRCASENEQ (str, "no");
1284 }
1285
1286 /* Free strings from a non-NULL terminated char** */
1287 static void
1288 free_n_strings (char **str, size_t len)
1289 {
1290   size_t i;
1291
1292   for (i = 0; i < len; i++) {
1293     free (str[i]);
1294   }
1295   free (str);
1296 }
1297
1298 char **
1299 parse_string_list (const char *str)
1300 {
1301   char **argv = NULL;
1302   size_t argv_len = 0;
1303
1304   /* Current position pointer */
1305   const char *p = str;
1306
1307   /* Token might be simple:
1308    *  Token
1309    * or be quoted:
1310    *  'This is a single token'
1311    * or contain embedded single-quoted sections:
1312    *  This' is a sing'l'e to'ken
1313    *
1314    * The latter may seem over-complicated, but it's what a normal shell does.
1315    * Not doing it risks surprising somebody.
1316    *
1317    * This outer loop is over complete tokens.
1318    */
1319   while (*p) {
1320     char *tok = NULL;
1321     size_t tok_len = 0;
1322
1323     /* Skip leading whitespace */
1324     p += strspn (p, " \t");
1325
1326     char in_quote = 0;
1327
1328     /* This loop is over token 'fragments'. A token can be in multiple bits if
1329      * it contains single quotes. We also treat both sides of an escaped quote
1330      * as separate fragments because we can't just copy it: we have to remove
1331      * the \.
1332      */
1333     while (*p && (!c_isblank (*p) || in_quote)) {
1334       const char *end = p;
1335
1336       /* Check if the fragment starts with a quote */
1337       if ('\'' == *p) {
1338         /* Toggle in_quote */
1339         in_quote = !in_quote;
1340
1341         /* Skip the quote */
1342         p++; end++;
1343       }
1344
1345       /* If we're in a quote, look for an end quote */
1346       if (in_quote) {
1347         end += strcspn (end, "'");
1348       }
1349
1350       /* Otherwise, look for whitespace or a quote */
1351       else {
1352         end += strcspn (end, " \t'");
1353       }
1354
1355       /* Grow the token to accommodate the fragment */
1356       size_t tok_end = tok_len;
1357       tok_len += end - p;
1358       char *tok_new = realloc (tok, tok_len + 1);
1359       if (NULL == tok_new) {
1360         perror ("realloc");
1361         free_n_strings (argv, argv_len);
1362         free (tok);
1363         exit (EXIT_FAILURE);
1364       }
1365       tok = tok_new;
1366
1367       /* Check if we stopped on an escaped quote */
1368       if ('\'' == *end && end != p && *(end-1) == '\\') {
1369         /* Add everything before \' to the token */
1370         memcpy (&tok[tok_end], p, end - p - 1);
1371
1372         /* Add the quote */
1373         tok[tok_len-1] = '\'';
1374
1375         /* Already processed the quote */
1376         p = end + 1;
1377       }
1378
1379       else {
1380         /* Add the whole fragment */
1381         memcpy (&tok[tok_end], p, end - p);
1382
1383         p = end;
1384       }
1385     }
1386
1387     /* We've reached the end of a token. We shouldn't still be in quotes. */
1388     if (in_quote) {
1389       fprintf (stderr, _("Runaway quote in string \"%s\"\n"), str);
1390
1391       free_n_strings (argv, argv_len);
1392
1393       return NULL;
1394     }
1395
1396     /* Add this token if there is one. There might not be if there was
1397      * whitespace at the end of the input string */
1398     if (tok) {
1399       /* Add the NULL terminator */
1400       tok[tok_len] = '\0';
1401
1402       /* Add the argument to the argument list */
1403       argv_len++;
1404       char **argv_new = realloc (argv, sizeof (*argv) * argv_len);
1405       if (NULL == argv_new) {
1406         perror ("realloc");
1407         free_n_strings (argv, argv_len-1);
1408         free (tok);
1409         exit (EXIT_FAILURE);
1410       }
1411       argv = argv_new;
1412
1413       argv[argv_len-1] = tok;
1414     }
1415   }
1416
1417   /* NULL terminate the argument list */
1418   argv_len++;
1419   char **argv_new = realloc (argv, sizeof (*argv) * argv_len);
1420   if (NULL == argv_new) {
1421     perror ("realloc");
1422     free_n_strings (argv, argv_len-1);
1423     exit (EXIT_FAILURE);
1424   }
1425   argv = argv_new;
1426
1427   argv[argv_len-1] = NULL;
1428
1429   return argv;
1430 }
1431
1432 #ifdef HAVE_LIBREADLINE
1433 static char histfile[1024];
1434 static int nr_history_lines = 0;
1435 #endif
1436
1437 static void
1438 initialize_readline (void)
1439 {
1440 #ifdef HAVE_LIBREADLINE
1441   const char *home;
1442
1443   home = getenv ("HOME");
1444   if (home) {
1445     snprintf (histfile, sizeof histfile, "%s/.guestfish", home);
1446     using_history ();
1447     (void) read_history (histfile);
1448   }
1449
1450   rl_readline_name = "guestfish";
1451   rl_attempted_completion_function = do_completion;
1452
1453   /* Note that .inputrc (or /etc/inputrc) is not read until the first
1454    * call the readline(), which happens later.  Therefore, these
1455    * provide default values which can be overridden by the user if
1456    * they wish.
1457    */
1458   (void) rl_variable_bind ("completion-ignore-case", "on");
1459 #endif
1460 }
1461
1462 static void
1463 cleanup_readline (void)
1464 {
1465 #ifdef HAVE_LIBREADLINE
1466   int fd;
1467
1468   if (histfile[0] != '\0') {
1469     fd = open (histfile, O_WRONLY|O_CREAT, 0644);
1470     if (fd == -1) {
1471       perror (histfile);
1472       return;
1473     }
1474     close (fd);
1475
1476 #ifdef HAVE_APPEND_HISTORY
1477     (void) append_history (nr_history_lines, histfile);
1478 #else
1479     (void) write_history (histfile);
1480 #endif
1481   }
1482 #endif
1483 }
1484
1485 #ifdef HAVE_LIBREADLINE
1486 static void
1487 add_history_line (const char *line)
1488 {
1489   add_history (line);
1490   nr_history_lines++;
1491 }
1492 #endif
1493
1494 int
1495 xwrite (int fd, const void *v_buf, size_t len)
1496 {
1497   int r;
1498   const char *buf = v_buf;
1499
1500   while (len > 0) {
1501     r = write (fd, buf, len);
1502     if (r == -1) {
1503       perror ("write");
1504       return -1;
1505     }
1506     buf += r;
1507     len -= r;
1508   }
1509
1510   return 0;
1511 }
1512
1513 /* Resolve the special "win:..." form for Windows-specific paths.
1514  * This always returns a newly allocated string which is freed by the
1515  * caller function in "cmds.c".
1516  */
1517 char *
1518 resolve_win_path (const char *path)
1519 {
1520   char *ret;
1521   size_t i;
1522
1523   if (STRCASENEQLEN (path, "win:", 4)) {
1524     ret = strdup (path);
1525     if (ret == NULL)
1526       perror ("strdup");
1527     return ret;
1528   }
1529
1530   path += 4;
1531
1532   /* Drop drive letter, if it's "C:". */
1533   if (STRCASEEQLEN (path, "c:", 2))
1534     path += 2;
1535
1536   if (!*path) {
1537     ret = strdup ("/");
1538     if (ret == NULL)
1539       perror ("strdup");
1540     return ret;
1541   }
1542
1543   ret = strdup (path);
1544   if (ret == NULL) {
1545     perror ("strdup");
1546     return NULL;
1547   }
1548
1549   /* Blindly convert any backslashes into forward slashes.  Is this good? */
1550   for (i = 0; i < strlen (ret); ++i)
1551     if (ret[i] == '\\')
1552       ret[i] = '/';
1553
1554   char *t = guestfs_case_sensitive_path (g, ret);
1555   free (ret);
1556   ret = t;
1557
1558   return ret;
1559 }
1560
1561 /* Resolve the special FileIn paths ("-" or "-<<END" or filename).
1562  * The caller (cmds.c) will call free_file_in after the command has
1563  * run which should clean up resources.
1564  */
1565 static char *file_in_heredoc (const char *endmarker);
1566 static char *file_in_tmpfile = NULL;
1567
1568 char *
1569 file_in (const char *arg)
1570 {
1571   char *ret;
1572
1573   if (STREQ (arg, "-")) {
1574     ret = strdup ("/dev/stdin");
1575     if (!ret) {
1576       perror ("strdup");
1577       return NULL;
1578     }
1579   }
1580   else if (STRPREFIX (arg, "-<<")) {
1581     const char *endmarker = &arg[3];
1582     if (*endmarker == '\0') {
1583       fprintf (stderr, "%s: missing end marker in -<< expression\n",
1584                program_name);
1585       return NULL;
1586     }
1587     ret = file_in_heredoc (endmarker);
1588     if (ret == NULL)
1589       return NULL;
1590   }
1591   else {
1592     ret = strdup (arg);
1593     if (!ret) {
1594       perror ("strdup");
1595       return NULL;
1596     }
1597   }
1598
1599   return ret;
1600 }
1601
1602 static char *
1603 file_in_heredoc (const char *endmarker)
1604 {
1605   static const char template[] = "/tmp/heredocXXXXXX";
1606   file_in_tmpfile = strdup (template);
1607   if (file_in_tmpfile == NULL) {
1608     perror ("strdup");
1609     return NULL;
1610   }
1611
1612   int fd = mkstemp (file_in_tmpfile);
1613   if (fd == -1) {
1614     perror ("mkstemp");
1615     goto error1;
1616   }
1617
1618   size_t markerlen = strlen (endmarker);
1619
1620   char buffer[BUFSIZ];
1621   int write_error = 0;
1622   while (fgets (buffer, sizeof buffer, stdin) != NULL) {
1623     /* Look for "END"<EOF> or "END\n" in input. */
1624     size_t blen = strlen (buffer);
1625     if (STREQLEN (buffer, endmarker, markerlen) &&
1626         (blen == markerlen ||
1627          (blen == markerlen+1 && buffer[markerlen] == '\n')))
1628       goto found_end;
1629
1630     if (xwrite (fd, buffer, blen) == -1) {
1631       if (!write_error) perror ("write");
1632       write_error = 1;
1633       /* continue reading up to the end marker */
1634     }
1635   }
1636
1637   /* Reached EOF of stdin without finding the end marker, which
1638    * is likely to be an error.
1639    */
1640   fprintf (stderr, "%s: end of input reached without finding '%s'\n",
1641            program_name, endmarker);
1642   goto error2;
1643
1644  found_end:
1645   if (write_error) {
1646     close (fd);
1647     goto error2;
1648   }
1649
1650   if (close (fd) == -1) {
1651     perror ("close");
1652     goto error2;
1653   }
1654
1655   return file_in_tmpfile;
1656
1657  error2:
1658   unlink (file_in_tmpfile);
1659
1660  error1:
1661   free (file_in_tmpfile);
1662   file_in_tmpfile = NULL;
1663   return NULL;
1664 }
1665
1666 void
1667 free_file_in (char *s)
1668 {
1669   if (file_in_tmpfile) {
1670     if (unlink (file_in_tmpfile) == -1)
1671       perror (file_in_tmpfile);
1672     file_in_tmpfile = NULL;
1673   }
1674
1675   /* Free the device or file name which was strdup'd in file_in().
1676    * Note it's not immediately clear, but for -<< heredocs,
1677    * s == file_in_tmpfile, so this frees up that buffer.
1678    */
1679   free (s);
1680 }
1681
1682 /* Resolve the special FileOut paths ("-" or filename).
1683  * The caller (cmds.c) will call free (str) after the command has run.
1684  */
1685 char *
1686 file_out (const char *arg)
1687 {
1688   char *ret;
1689
1690   if (STREQ (arg, "-"))
1691     ret = strdup ("/dev/stdout");
1692   else
1693     ret = strdup (arg);
1694
1695   if (!ret) {
1696     perror ("strdup");
1697     return NULL;
1698   }
1699   return ret;
1700 }
1701
1702 static void
1703 print_shell_quote (FILE *stream, const char *str)
1704 {
1705 #define SAFE(c) (c_isalnum((c)) ||                                      \
1706                  (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
1707   int i;
1708
1709   for (i = 0; str[i]; ++i) {
1710     if (!SAFE(str[i]))
1711       putc ('\\', stream);
1712     putc (str[i], stream);
1713   }
1714 }