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