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