f5d538d12c11b055b0dce630cc1342a61b9abc23
[libguestfs.git] / fish / fish.c
1 /* guestfish - the filesystem interactive shell
2  * Copyright (C) 2009 Red Hat Inc.
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <config.h>
20
21 #define _GNU_SOURCE // for strchrnul
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <fcntl.h>
28 #include <getopt.h>
29 #include <signal.h>
30 #include <assert.h>
31 #include <ctype.h>
32 #include <sys/types.h>
33 #include <sys/wait.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
44 struct mp {
45   struct mp *next;
46   char *device;
47   char *mountpoint;
48 };
49
50 struct drv {
51   struct drv *next;
52   char *filename;
53 };
54
55 static void add_drives (struct drv *drv);
56 static void mount_mps (struct mp *mp);
57 static void interactive (void);
58 static void shell_script (void);
59 static void script (int prompt);
60 static void cmdline (char *argv[], int optind, int argc);
61 static void initialize_readline (void);
62 static void cleanup_readline (void);
63 static void add_history_line (const char *);
64
65 /* Currently open libguestfs handle. */
66 guestfs_h *g;
67
68 int read_only = 0;
69 int quit = 0;
70 int verbose = 0;
71 int echo_commands = 0;
72 int remote_control_listen = 0;
73 int remote_control = 0;
74 int exit_on_error = 1;
75
76 int
77 launch (guestfs_h *_g)
78 {
79   assert (_g == g);
80
81   if (guestfs_is_config (g)) {
82     if (guestfs_launch (g) == -1)
83       return -1;
84     if (guestfs_wait_ready (g) == -1)
85       return -1;
86   }
87   return 0;
88 }
89
90 static void
91 usage (void)
92 {
93   fprintf (stderr,
94            _("guestfish: guest filesystem shell\n"
95              "guestfish lets you edit virtual machine filesystems\n"
96              "Copyright (C) 2009 Red Hat Inc.\n"
97              "Usage:\n"
98              "  guestfish [--options] cmd [: cmd : cmd ...]\n"
99              "  guestfish -i libvirt-domain\n"
100              "  guestfish -i disk-image(s)\n"
101              "or for interactive use:\n"
102              "  guestfish\n"
103              "or from a shell script:\n"
104              "  guestfish <<EOF\n"
105              "  cmd\n"
106              "  ...\n"
107              "  EOF\n"
108              "Options:\n"
109              "  -h|--cmd-help        List available commands\n"
110              "  -h|--cmd-help cmd    Display detailed help on 'cmd'\n"
111              "  -a|--add image       Add image\n"
112              "  -D|--no-dest-paths   Don't tab-complete paths from guest fs\n"
113              "  -f|--file file       Read commands from file\n"
114              "  -i|--inspector       Run virt-inspector to get disk mountpoints\n"
115              "  --listen             Listen for remote commands\n"
116              "  -m|--mount dev[:mnt] Mount dev on mnt (if omitted, /)\n"
117              "  -n|--no-sync         Don't autosync\n"
118              "  --remote[=pid]       Send commands to remote guestfish\n"
119              "  -r|--ro              Mount read-only\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 guestfish(1).\n"));
124 }
125
126 int
127 main (int argc, char *argv[])
128 {
129   static const char *options = "a:Df:h::im:nrv?Vx";
130   static struct option long_options[] = {
131     { "add", 1, 0, 'a' },
132     { "cmd-help", 2, 0, 'h' },
133     { "file", 1, 0, 'f' },
134     { "help", 0, 0, '?' },
135     { "inspector", 0, 0, 'i' },
136     { "listen", 0, 0, 0 },
137     { "mount", 1, 0, 'm' },
138     { "no-dest-paths", 0, 0, 'D' },
139     { "no-sync", 0, 0, 'n' },
140     { "remote", 2, 0, 0 },
141     { "ro", 0, 0, 'r' },
142     { "verbose", 0, 0, 'v' },
143     { "version", 0, 0, 'V' },
144     { 0, 0, 0, 0 }
145   };
146   struct drv *drvs = NULL;
147   struct drv *drv;
148   struct mp *mps = NULL;
149   struct mp *mp;
150   char *p, *file = NULL;
151   int c;
152   int inspector = 0;
153   int option_index;
154   struct sigaction sa;
155
156   initialize_readline ();
157
158   memset (&sa, 0, sizeof sa);
159   sa.sa_handler = SIG_IGN;
160   sa.sa_flags = SA_RESTART;
161   sigaction (SIGPIPE, &sa, NULL);
162
163   /* guestfs_create is meant to be a lightweight operation, so
164    * it's OK to do it early here.
165    */
166   g = guestfs_create ();
167   if (g == NULL) {
168     fprintf (stderr, _("guestfs_create: failed to create handle\n"));
169     exit (1);
170   }
171
172   guestfs_set_autosync (g, 1);
173
174   /* If developing, add ./appliance to the path.  Note that libtools
175    * interferes with this because uninstalled guestfish is a shell
176    * script that runs the real program with an absolute path.  Detect
177    * that too.
178    *
179    * BUT if LIBGUESTFS_PATH environment variable is already set by
180    * the user, then don't override it.
181    */
182   if (getenv ("LIBGUESTFS_PATH") == NULL &&
183       argv[0] &&
184       (argv[0][0] != '/' || strstr (argv[0], "/.libs/lt-") != NULL))
185     guestfs_set_path (g, "appliance:" GUESTFS_DEFAULT_PATH);
186
187   for (;;) {
188     c = getopt_long (argc, argv, options, long_options, &option_index);
189     if (c == -1) break;
190
191     switch (c) {
192     case 0:                     /* options which are long only */
193       if (strcmp (long_options[option_index].name, "listen") == 0)
194         remote_control_listen = 1;
195       else if (strcmp (long_options[option_index].name, "remote") == 0) {
196         if (optarg) {
197           if (sscanf (optarg, "%d", &remote_control) != 1) {
198             fprintf (stderr, _("guestfish: --listen=PID: PID was not a number: %s\n"), optarg);
199             exit (1);
200           }
201         } else {
202           p = getenv ("GUESTFISH_PID");
203           if (!p || sscanf (p, "%d", &remote_control) != 1) {
204             fprintf (stderr, _("guestfish: remote: $GUESTFISH_PID must be set to the PID of the remote process\n"));
205             exit (1);
206           }
207         }
208       } else {
209         fprintf (stderr, _("guestfish: unknown long option: %s (%d)\n"),
210                  long_options[option_index].name, option_index);
211         exit (1);
212       }
213       break;
214
215     case 'a':
216       if (access (optarg, R_OK) != 0) {
217         perror (optarg);
218         exit (1);
219       }
220       drv = malloc (sizeof (struct drv));
221       if (!drv) {
222         perror ("malloc");
223         exit (1);
224       }
225       drv->filename = optarg;
226       drv->next = drvs;
227       drvs = drv;
228       break;
229
230     case 'D':
231       complete_dest_paths = 0;
232       break;
233
234     case 'f':
235       if (file) {
236         fprintf (stderr, _("guestfish: only one -f parameter can be given\n"));
237         exit (1);
238       }
239       file = optarg;
240       break;
241
242     case 'h':
243       if (optarg)
244         display_command (optarg);
245       else if (argv[optind] && argv[optind][0] != '-')
246         display_command (argv[optind++]);
247       else
248         list_commands ();
249       exit (0);
250
251     case 'i':
252       inspector = 1;
253       break;
254
255     case 'm':
256       mp = malloc (sizeof (struct mp));
257       if (!mp) {
258         perror ("malloc");
259         exit (1);
260       }
261       p = strchr (optarg, ':');
262       if (p) {
263         *p = '\0';
264         mp->mountpoint = p+1;
265       } else
266         mp->mountpoint = "/";
267       mp->device = optarg;
268       mp->next = mps;
269       mps = mp;
270       break;
271
272     case 'n':
273       guestfs_set_autosync (g, 0);
274       break;
275
276     case 'r':
277       read_only = 1;
278       break;
279
280     case 'v':
281       verbose++;
282       guestfs_set_verbose (g, verbose);
283       break;
284
285     case 'V':
286       printf ("guestfish %s\n", PACKAGE_VERSION);
287       exit (0);
288
289     case 'x':
290       echo_commands = 1;
291       break;
292
293     case '?':
294       usage ();
295       exit (0);
296
297     default:
298       fprintf (stderr, _("guestfish: unexpected command line option 0x%x\n"),
299                c);
300       exit (1);
301     }
302   }
303
304   /* Inspector mode invalidates most of the other arguments. */
305   if (inspector) {
306     char cmd[1024];
307     int r;
308
309     if (drvs || mps || remote_control_listen || remote_control) {
310       fprintf (stderr, _("guestfish: cannot use -i option with -a, -m, --listen or --remote\n"));
311       exit (1);
312     }
313     if (optind >= argc) {
314       fprintf (stderr, _("guestfish -i requires a libvirt domain or path(s) to disk image(s)\n"));
315       exit (1);
316     }
317
318     strcpy (cmd, "a=`virt-inspector");
319     while (optind < argc) {
320       if (strlen (cmd) + strlen (argv[optind]) + strlen (argv[0]) + 60
321           >= sizeof cmd) {
322         fprintf (stderr, _("guestfish: virt-inspector command too long for fixed-size buffer\n"));
323         exit (1);
324       }
325       strcat (cmd, " '");
326       strcat (cmd, argv[optind]);
327       strcat (cmd, "'");
328       optind++;
329     }
330
331     if (read_only)
332       strcat (cmd, " --ro-fish");
333     else
334       strcat (cmd, " --fish");
335
336     sprintf (&cmd[strlen(cmd)], "` && %s $a", argv[0]);
337
338     if (guestfs_get_verbose (g))
339       strcat (cmd, " -v");
340     if (!guestfs_get_autosync (g))
341       strcat (cmd, " -n");
342
343     /*printf ("%s\n", cmd);*/
344
345     r = system (cmd);
346     if (r == -1) {
347       perror ("system");
348       exit (1);
349     }
350     exit (WEXITSTATUS (r));
351   }
352
353   /* If we've got drives to add, add them now. */
354   add_drives (drvs);
355
356   /* If we've got mountpoints, we must launch the guest and mount them. */
357   if (mps != NULL) {
358     if (launch (g) == -1) exit (1);
359     mount_mps (mps);
360   }
361
362   /* Remote control? */
363   if (remote_control_listen && remote_control) {
364     fprintf (stderr, _("guestfish: cannot use --listen and --remote options at the same time\n"));
365     exit (1);
366   }
367
368   if (remote_control_listen) {
369     if (optind < argc) {
370       fprintf (stderr, _("guestfish: extra parameters on the command line with --listen flag\n"));
371       exit (1);
372     }
373     if (file) {
374       fprintf (stderr, _("guestfish: cannot use --listen and --file options at the same time\n"));
375       exit (1);
376     }
377     rc_listen ();
378   }
379
380   /* -f (file) parameter? */
381   if (file) {
382     close (0);
383     if (open (file, O_RDONLY) == -1) {
384       perror (file);
385       exit (1);
386     }
387   }
388
389   /* Interactive, shell script, or command(s) on the command line? */
390   if (optind >= argc) {
391     if (isatty (0))
392       interactive ();
393     else
394       shell_script ();
395   }
396   else
397     cmdline (argv, optind, argc);
398
399   cleanup_readline ();
400
401   exit (0);
402 }
403
404 void
405 pod2text (const char *heading, const char *str)
406 {
407   FILE *fp;
408
409   fp = popen ("pod2text", "w");
410   if (fp == NULL) {
411     /* pod2text failed, maybe not found, so let's just print the
412      * source instead, since that's better than doing nothing.
413      */
414     printf ("%s\n\n%s\n", heading, str);
415     return;
416   }
417   fputs ("=head1 ", fp);
418   fputs (heading, fp);
419   fputs ("\n\n", fp);
420   fputs (str, fp);
421   pclose (fp);
422 }
423
424 /* List is built in reverse order, so mount them in reverse order. */
425 static void
426 mount_mps (struct mp *mp)
427 {
428   int r;
429
430   if (mp) {
431     mount_mps (mp->next);
432     if (!read_only)
433       r = guestfs_mount (g, mp->device, mp->mountpoint);
434     else
435       r = guestfs_mount_ro (g, mp->device, mp->mountpoint);
436     if (r == -1)
437       exit (1);
438   }
439 }
440
441 static void
442 add_drives (struct drv *drv)
443 {
444   int r;
445
446   if (drv) {
447     add_drives (drv->next);
448     if (!read_only)
449       r = guestfs_add_drive (g, drv->filename);
450     else
451       r = guestfs_add_drive_ro (g, drv->filename);
452     if (r == -1)
453       exit (1);
454   }
455 }
456
457 static void
458 interactive (void)
459 {
460   script (1);
461 }
462
463 static void
464 shell_script (void)
465 {
466   script (0);
467 }
468
469 #define FISH "><fs> "
470
471 static char *line_read = NULL;
472
473 static char *
474 rl_gets (int prompt)
475 {
476 #ifdef HAVE_LIBREADLINE
477
478   if (prompt) {
479     if (line_read) {
480       free (line_read);
481       line_read = NULL;
482     }
483
484     line_read = readline (prompt ? FISH : "");
485
486     if (line_read && *line_read)
487       add_history_line (line_read);
488
489     return line_read;
490   }
491
492 #endif /* HAVE_LIBREADLINE */
493
494   static char buf[8192];
495   int len;
496
497   if (prompt) printf (FISH);
498   line_read = fgets (buf, sizeof buf, stdin);
499
500   if (line_read) {
501     len = strlen (line_read);
502     if (len > 0 && buf[len-1] == '\n') buf[len-1] = '\0';
503   }
504
505   return line_read;
506 }
507
508 static void
509 script (int prompt)
510 {
511   char *buf;
512   char *cmd;
513   char *p, *pend;
514   char *argv[64];
515   int i, len;
516   int global_exit_on_error = !prompt;
517   int tilde_candidate;
518
519   if (prompt)
520     printf (_("\n"
521               "Welcome to guestfish, the libguestfs filesystem interactive shell for\n"
522               "editing virtual machine filesystems.\n"
523               "\n"
524               "Type: 'help' for help with commands\n"
525               "      'quit' to quit the shell\n"
526               "\n"));
527
528   while (!quit) {
529     char *pipe = NULL;
530
531     exit_on_error = global_exit_on_error;
532
533     buf = rl_gets (prompt);
534     if (!buf) {
535       quit = 1;
536       break;
537     }
538
539     /* Skip any initial whitespace before the command. */
540   again:
541     while (*buf && isspace (*buf))
542       buf++;
543
544     if (!*buf) continue;
545
546     /* If the next character is '#' then this is a comment. */
547     if (*buf == '#') continue;
548
549     /* If the next character is '!' then pass the whole lot to system(3). */
550     if (*buf == '!') {
551       int r;
552
553       r = system (buf+1);
554       if (exit_on_error) {
555         if (r == -1 ||
556             (WIFSIGNALED (r) &&
557              (WTERMSIG (r) == SIGINT || WTERMSIG (r) == SIGQUIT)) ||
558             WEXITSTATUS (r) != 0)
559           exit (1);
560       }
561       continue;
562     }
563
564     /* If the next character is '-' allow the command to fail without
565      * exiting on error (just for this one command though).
566      */
567     if (*buf == '-') {
568       exit_on_error = 0;
569       buf++;
570       goto again;
571     }
572
573     /* Get the command (cannot be quoted). */
574     len = strcspn (buf, " \t");
575
576     if (len == 0) continue;
577
578     cmd = buf;
579     i = 0;
580     if (buf[len] == '\0') {
581       argv[0] = NULL;
582       goto got_command;
583     }
584
585     buf[len] = '\0';
586     p = &buf[len+1];
587     p += strspn (p, " \t");
588
589     /* Get the parameters. */
590     while (*p && i < sizeof argv / sizeof argv[0]) {
591       tilde_candidate = 0;
592
593       /* Parameters which start with quotes or pipes are treated
594        * specially.  Bare parameters are delimited by whitespace.
595        */
596       if (*p == '"') {
597         p++;
598         len = strcspn (p, "\"");
599         if (p[len] == '\0') {
600           fprintf (stderr, _("guestfish: unterminated double quote\n"));
601           if (exit_on_error) exit (1);
602           goto next_command;
603         }
604         if (p[len+1] && (p[len+1] != ' ' && p[len+1] != '\t')) {
605           fprintf (stderr, _("guestfish: command arguments not separated by whitespace\n"));
606           if (exit_on_error) exit (1);
607           goto next_command;
608         }
609         p[len] = '\0';
610         pend = p[len+1] ? &p[len+2] : &p[len+1];
611       } else if (*p == '\'') {
612         p++;
613         len = strcspn (p, "'");
614         if (p[len] == '\0') {
615           fprintf (stderr, _("guestfish: unterminated single quote\n"));
616           if (exit_on_error) exit (1);
617           goto next_command;
618         }
619         if (p[len+1] && (p[len+1] != ' ' && p[len+1] != '\t')) {
620           fprintf (stderr, _("guestfish: command arguments not separated by whitespace\n"));
621           if (exit_on_error) exit (1);
622           goto next_command;
623         }
624         p[len] = '\0';
625         pend = p[len+1] ? &p[len+2] : &p[len+1];
626       } else if (*p == '|') {
627         *p = '\0';
628         pipe = p+1;
629         continue;
630         /*
631       } else if (*p == '[') {
632         int c = 1;
633         p++;
634         pend = p;
635         while (*pend && c != 0) {
636           if (*pend == '[') c++;
637           else if (*pend == ']') c--;
638           pend++;
639         }
640         if (c != 0) {
641           fprintf (stderr, _("guestfish: unterminated \"[...]\" sequence\n"));
642           if (exit_on_error) exit (1);
643           goto next_command;
644         }
645         if (*pend && (*pend != ' ' && *pend != '\t')) {
646           fprintf (stderr, _("guestfish: command arguments not separated by whitespace\n"));
647           if (exit_on_error) exit (1);
648           goto next_command;
649         }
650         *(pend-1) = '\0';
651         */
652       } else if (*p != ' ' && *p != '\t') {
653         /* If the first character is a ~ then note that this parameter
654          * is a candidate for ~username expansion.  NB this does not
655          * apply to quoted parameters.
656          */
657         tilde_candidate = *p == '~';
658         len = strcspn (p, " \t");
659         if (p[len]) {
660           p[len] = '\0';
661           pend = &p[len+1];
662         } else
663           pend = &p[len];
664       } else {
665         fprintf (stderr, _("guestfish: internal error parsing string at '%s'\n"),
666                  p);
667         abort ();
668       }
669
670       if (!tilde_candidate)
671         argv[i] = p;
672       else
673         argv[i] = try_tilde_expansion (p);
674       i++;
675       p = pend;
676
677       if (*p)
678         p += strspn (p, " \t");
679     }
680
681     if (i == sizeof argv / sizeof argv[0]) {
682       fprintf (stderr, _("guestfish: too many arguments\n"));
683       if (exit_on_error) exit (1);
684       goto next_command;
685     }
686
687     argv[i] = NULL;
688
689   got_command:
690     if (issue_command (cmd, argv, pipe) == -1) {
691       if (exit_on_error) exit (1);
692     }
693
694   next_command:;
695   }
696   if (prompt) printf ("\n");
697 }
698
699 static void
700 cmdline (char *argv[], int optind, int argc)
701 {
702   const char *cmd;
703   char **params;
704
705   exit_on_error = 1;
706
707   if (optind >= argc) return;
708
709   cmd = argv[optind++];
710   if (strcmp (cmd, ":") == 0) {
711     fprintf (stderr, _("guestfish: empty command on command line\n"));
712     exit (1);
713   }
714   params = &argv[optind];
715
716   /* Search for end of command list or ":" ... */
717   while (optind < argc && strcmp (argv[optind], ":") != 0)
718     optind++;
719
720   if (optind == argc) {
721     if (issue_command (cmd, params, NULL) == -1) exit (1);
722   } else {
723     argv[optind] = NULL;
724     if (issue_command (cmd, params, NULL) == -1) exit (1);
725     cmdline (argv, optind+1, argc);
726   }
727 }
728
729 int
730 issue_command (const char *cmd, char *argv[], const char *pipecmd)
731 {
732   int argc;
733   int stdout_saved_fd = -1;
734   int pid = 0;
735   int i, r;
736
737   if (echo_commands) {
738     printf ("%s", cmd);
739     for (i = 0; argv[i] != NULL; ++i)
740       printf (" %s", argv[i]);
741     printf ("\n");
742   }
743
744   /* For | ... commands.  Annoyingly we can't use popen(3) here. */
745   if (pipecmd) {
746     int fd[2];
747
748     fflush (stdout);
749     pipe (fd);
750     pid = fork ();
751     if (pid == -1) {
752       perror ("fork");
753       return -1;
754     }
755
756     if (pid == 0) {             /* Child process. */
757       close (fd[1]);
758       dup2 (fd[0], 0);
759
760       r = system (pipecmd);
761       if (r == -1) {
762         perror (pipecmd);
763         _exit (1);
764       }
765       _exit (WEXITSTATUS (r));
766     }
767
768     stdout_saved_fd = dup (1);
769     close (fd[0]);
770     dup2 (fd[1], 1);
771     close (fd[1]);
772   }
773
774   for (argc = 0; argv[argc] != NULL; ++argc)
775     ;
776
777   /* If --remote was set, then send this command to a remote process. */
778   if (remote_control)
779     r = rc_remote (remote_control, cmd, argc, argv, exit_on_error);
780
781   /* Otherwise execute it locally. */
782   else if (strcasecmp (cmd, "help") == 0) {
783     if (argc == 0)
784       list_commands ();
785     else
786       display_command (argv[0]);
787     r = 0;
788   }
789   else if (strcasecmp (cmd, "quit") == 0 ||
790            strcasecmp (cmd, "exit") == 0 ||
791            strcasecmp (cmd, "q") == 0) {
792     quit = 1;
793     r = 0;
794   }
795   else if (strcasecmp (cmd, "alloc") == 0 ||
796            strcasecmp (cmd, "allocate") == 0)
797     r = do_alloc (cmd, argc, argv);
798   else if (strcasecmp (cmd, "echo") == 0)
799     r = do_echo (cmd, argc, argv);
800   else if (strcasecmp (cmd, "edit") == 0 ||
801            strcasecmp (cmd, "vi") == 0 ||
802            strcasecmp (cmd, "emacs") == 0)
803     r = do_edit (cmd, argc, argv);
804   else if (strcasecmp (cmd, "lcd") == 0)
805     r = do_lcd (cmd, argc, argv);
806   else if (strcasecmp (cmd, "glob") == 0)
807     r = do_glob (cmd, argc, argv);
808   else if (strcasecmp (cmd, "more") == 0 ||
809            strcasecmp (cmd, "less") == 0)
810     r = do_more (cmd, argc, argv);
811   else if (strcasecmp (cmd, "reopen") == 0)
812     r = do_reopen (cmd, argc, argv);
813   else if (strcasecmp (cmd, "time") == 0)
814     r = do_time (cmd, argc, argv);
815   else
816     r = run_action (cmd, argc, argv);
817
818   /* Always flush stdout after every command, so that messages, results
819    * etc appear immediately.
820    */
821   fflush (stdout);
822
823   if (pipecmd) {
824     close (1);
825     dup2 (stdout_saved_fd, 1);
826     close (stdout_saved_fd);
827     waitpid (pid, NULL, 0);
828   }
829
830   return r;
831 }
832
833 void
834 list_builtin_commands (void)
835 {
836   /* help and quit should appear at the top */
837   printf ("%-20s %s\n",
838           "help", _("display a list of commands or help on a command"));
839   printf ("%-20s %s\n",
840           "quit", _("quit guestfish"));
841
842   printf ("%-20s %s\n",
843           "alloc", _("allocate an image"));
844   printf ("%-20s %s\n",
845           "echo", _("display a line of text"));
846   printf ("%-20s %s\n",
847           "edit", _("edit a file in the image"));
848   printf ("%-20s %s\n",
849           "lcd", _("local change directory"));
850   printf ("%-20s %s\n",
851           "glob", _("expand wildcards in command"));
852   printf ("%-20s %s\n",
853           "more", _("view a file in the pager"));
854   printf ("%-20s %s\n",
855           "reopen", _("close and reopen libguestfs handle"));
856   printf ("%-20s %s\n",
857           "time", _("measure time taken to run command"));
858
859   /* actions are printed after this (see list_commands) */
860 }
861
862 void
863 display_builtin_command (const char *cmd)
864 {
865   /* help for actions is auto-generated, see display_command */
866
867   if (strcasecmp (cmd, "alloc") == 0 ||
868       strcasecmp (cmd, "allocate") == 0)
869     printf (_("alloc - allocate an image\n"
870               "     alloc <filename> <size>\n"
871               "\n"
872               "    This creates an empty (zeroed) file of the given size,\n"
873               "    and then adds so it can be further examined.\n"
874               "\n"
875               "    For more advanced image creation, see qemu-img utility.\n"
876               "\n"
877               "    Size can be specified (where <nn> means a number):\n"
878               "    <nn>             number of kilobytes\n"
879               "      eg: 1440       standard 3.5\" floppy\n"
880               "    <nn>K or <nn>KB  number of kilobytes\n"
881               "    <nn>M or <nn>MB  number of megabytes\n"
882               "    <nn>G or <nn>GB  number of gigabytes\n"
883               "    <nn>sects        number of 512 byte sectors\n"));
884   else if (strcasecmp (cmd, "echo") == 0)
885     printf (_("echo - display a line of text\n"
886               "     echo [<params> ...]\n"
887               "\n"
888               "    This echos the parameters to the terminal.\n"));
889   else if (strcasecmp (cmd, "edit") == 0 ||
890            strcasecmp (cmd, "vi") == 0 ||
891            strcasecmp (cmd, "emacs") == 0)
892     printf (_("edit - edit a file in the image\n"
893               "     edit <filename>\n"
894               "\n"
895               "    This is used to edit a file.\n"
896               "\n"
897               "    It is the equivalent of (and is implemented by)\n"
898               "    running \"cat\", editing locally, and then \"write-file\".\n"
899               "\n"
900               "    Normally it uses $EDITOR, but if you use the aliases\n"
901               "    \"vi\" or \"emacs\" you will get those editors.\n"
902               "\n"
903               "    NOTE: This will not work reliably for large files\n"
904               "    (> 2 MB) or binary files containing \\0 bytes.\n"));
905   else if (strcasecmp (cmd, "lcd") == 0)
906     printf (_("lcd - local change directory\n"
907               "    lcd <directory>\n"
908               "\n"
909               "    Change guestfish's current directory. This command is\n"
910               "    useful if you want to download files to a particular\n"
911               "    place.\n"));
912   else if (strcasecmp (cmd, "glob") == 0)
913     printf (_("glob - expand wildcards in command\n"
914               "    glob <command> [<args> ...]\n"
915               "\n"
916               "    Glob runs <command> with wildcards expanded in any\n"
917               "    command args.  Note that the command is run repeatedly\n"
918               "    once for each expanded argument.\n"));
919   else if (strcasecmp (cmd, "help") == 0)
920     printf (_("help - display a list of commands or help on a command\n"
921               "     help cmd\n"
922               "     help\n"));
923   else if (strcasecmp (cmd, "more") == 0 ||
924            strcasecmp (cmd, "less") == 0)
925     printf (_("more - view a file in the pager\n"
926               "     more <filename>\n"
927               "\n"
928               "    This is used to view a file in the pager.\n"
929               "\n"
930               "    It is the equivalent of (and is implemented by)\n"
931               "    running \"cat\" and using the pager.\n"
932               "\n"
933               "    Normally it uses $PAGER, but if you use the alias\n"
934               "    \"less\" then it always uses \"less\".\n"
935               "\n"
936               "    NOTE: This will not work reliably for large files\n"
937               "    (> 2 MB) or binary files containing \\0 bytes.\n"));
938   else if (strcasecmp (cmd, "quit") == 0 ||
939            strcasecmp (cmd, "exit") == 0 ||
940            strcasecmp (cmd, "q") == 0)
941     printf (_("quit - quit guestfish\n"
942               "     quit\n"));
943   else if (strcasecmp (cmd, "reopen") == 0)
944     printf (_("reopen - close and reopen the libguestfs handle\n"
945               "     reopen\n"
946               "\n"
947               "Close and reopen the libguestfs handle.  It is not necessary to use\n"
948               "this normally, because the handle is closed properly when guestfish\n"
949               "exits.  However this is occasionally useful for testing.\n"));
950   else if (strcasecmp (cmd, "time") == 0)
951     printf (_("time - measure time taken to run command\n"
952               "    time <command> [<args> ...]\n"
953               "\n"
954               "    This runs <command> as usual, and prints the elapsed\n"
955               "    time afterwards.\n"));
956   else
957     fprintf (stderr, _("%s: command not known, use -h to list all commands\n"),
958              cmd);
959 }
960
961 void
962 free_strings (char **argv)
963 {
964   int argc;
965
966   for (argc = 0; argv[argc] != NULL; ++argc)
967     free (argv[argc]);
968   free (argv);
969 }
970
971 int
972 count_strings (char * const * const argv)
973 {
974   int c;
975
976   for (c = 0; argv[c]; ++c)
977     ;
978   return c;
979 }
980
981 void
982 print_strings (char * const * const argv)
983 {
984   int argc;
985
986   for (argc = 0; argv[argc] != NULL; ++argc)
987     printf ("%s\n", argv[argc]);
988 }
989
990 void
991 print_table (char * const * const argv)
992 {
993   int i;
994
995   for (i = 0; argv[i] != NULL; i += 2)
996     printf ("%s: %s\n", argv[i], argv[i+1]);
997 }
998
999 int
1000 is_true (const char *str)
1001 {
1002   return
1003     strcasecmp (str, "0") != 0 &&
1004     strcasecmp (str, "f") != 0 &&
1005     strcasecmp (str, "false") != 0 &&
1006     strcasecmp (str, "n") != 0 &&
1007     strcasecmp (str, "no") != 0;
1008 }
1009
1010 /* XXX We could improve list parsing. */
1011 char **
1012 parse_string_list (const char *str)
1013 {
1014   char **argv;
1015   const char *p, *pend;
1016   int argc, i;
1017
1018   argc = 1;
1019   for (i = 0; str[i]; ++i)
1020     if (str[i] == ' ') argc++;
1021
1022   argv = malloc (sizeof (char *) * (argc+1));
1023   if (argv == NULL) { perror ("malloc"); exit (1); }
1024
1025   p = str;
1026   i = 0;
1027   while (*p) {
1028     pend = strchrnul (p, ' ');
1029     argv[i] = strndup (p, pend-p);
1030     i++;
1031     p = *pend == ' ' ? pend+1 : pend;
1032   }
1033   argv[i] = NULL;
1034
1035   return argv;
1036 }
1037
1038 #ifdef HAVE_LIBREADLINE
1039 static char histfile[1024];
1040 static int nr_history_lines = 0;
1041 #endif
1042
1043 static void
1044 initialize_readline (void)
1045 {
1046 #ifdef HAVE_LIBREADLINE
1047   const char *home;
1048
1049   home = getenv ("HOME");
1050   if (home) {
1051     snprintf (histfile, sizeof histfile, "%s/.guestfish", home);
1052     using_history ();
1053     (void) read_history (histfile);
1054   }
1055
1056   rl_readline_name = "guestfish";
1057   rl_attempted_completion_function = do_completion;
1058 #endif
1059 }
1060
1061 static void
1062 cleanup_readline (void)
1063 {
1064 #ifdef HAVE_LIBREADLINE
1065   int fd;
1066
1067   if (histfile[0] != '\0') {
1068     fd = open (histfile, O_WRONLY|O_CREAT, 0644);
1069     if (fd == -1) {
1070       perror (histfile);
1071       return;
1072     }
1073     close (fd);
1074
1075     (void) append_history (nr_history_lines, histfile);
1076   }
1077 #endif
1078 }
1079
1080 static void
1081 add_history_line (const char *line)
1082 {
1083 #ifdef HAVE_LIBREADLINE
1084   add_history (line);
1085   nr_history_lines++;
1086 #endif
1087 }
1088
1089 int
1090 xwrite (int fd, const void *buf, size_t len)
1091 {
1092   int r;
1093
1094   while (len > 0) {
1095     r = write (fd, buf, len);
1096     if (r == -1) {
1097       perror ("write");
1098       return -1;
1099     }
1100     buf += r;
1101     len -= r;
1102   }
1103
1104   return 0;
1105 }