fish/cmds.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <inttypes.h>
  26
  27 #include <guestfs.h>
  28 #include "fish.h"
  29
  30 void list_commands (void)
  31 {
  32   printf ("    %-16s     %s\n", "Command", "Description");
  33   list_builtin_commands ();
  34   printf ("%-20s %s\n", "add-cdrom", "add a CD-ROM disk image to examine");
  35   printf ("%-20s %s\n", "add-drive", "add an image to examine or modify");
  36   printf ("%-20s %s\n", "aug-close", "close the current Augeas handle");
  37   printf ("%-20s %s\n", "aug-defnode", "define an Augeas node");
  38   printf ("%-20s %s\n", "aug-defvar", "define an Augeas variable");
  39   printf ("%-20s %s\n", "aug-get", "look up the value of an Augeas path");
  40   printf ("%-20s %s\n", "aug-init", "create a new Augeas handle");
  41   printf ("%-20s %s\n", "aug-insert", "insert a sibling Augeas node");
  42   printf ("%-20s %s\n", "aug-load", "load files into the tree");
  43   printf ("%-20s %s\n", "aug-ls", "list Augeas nodes under a path");
  44   printf ("%-20s %s\n", "aug-match", "return Augeas nodes which match path");
  45   printf ("%-20s %s\n", "aug-mv", "move Augeas node");
  46   printf ("%-20s %s\n", "aug-rm", "remove an Augeas path");
  47   printf ("%-20s %s\n", "aug-save", "write all pending Augeas changes to disk");
  48   printf ("%-20s %s\n", "aug-set", "set Augeas path to value");
  49   printf ("%-20s %s\n", "cat", "list the contents of a file");
  50   printf ("%-20s %s\n", "chmod", "change file mode");
  51   printf ("%-20s %s\n", "chown", "change file owner and group");
  52   printf ("%-20s %s\n", "command", "run a command from the guest filesystem");
  53   printf ("%-20s %s\n", "command-lines", "run a command, returning lines");
  54   printf ("%-20s %s\n", "config", "add qemu parameters");
  55   printf ("%-20s %s\n", "exists", "test if file or directory exists");
  56   printf ("%-20s %s\n", "file", "determine file type");
  57   printf ("%-20s %s\n", "get-autosync", "get autosync mode");
  58   printf ("%-20s %s\n", "get-path", "get the search path");
  59   printf ("%-20s %s\n", "get-verbose", "get verbose mode");
  60   printf ("%-20s %s\n", "is-dir", "test if file exists");
  61   printf ("%-20s %s\n", "is-file", "test if file exists");
  62   printf ("%-20s %s\n", "kill-subprocess", "kill the qemu subprocess");
  63   printf ("%-20s %s\n", "launch", "launch the qemu subprocess");
  64   printf ("%-20s %s\n", "list-devices", "list the block devices");
  65   printf ("%-20s %s\n", "list-partitions", "list the partitions");
  66   printf ("%-20s %s\n", "ll", "list the files in a directory (long format)");
  67   printf ("%-20s %s\n", "ls", "list the files in a directory");
  68   printf ("%-20s %s\n", "lstat", "get file information for a symbolic link");
  69   printf ("%-20s %s\n", "lvcreate", "create an LVM volume group");
  70   printf ("%-20s %s\n", "lvm-remove-all", "remove all LVM LVs, VGs and PVs");
  71   printf ("%-20s %s\n", "lvs", "list the LVM logical volumes (LVs)");
  72   printf ("%-20s %s\n", "lvs-full", "list the LVM logical volumes (LVs)");
  73   printf ("%-20s %s\n", "mkdir", "create a directory");
  74   printf ("%-20s %s\n", "mkdir-p", "create a directory and parents");
  75   printf ("%-20s %s\n", "mkfs", "make a filesystem");
  76   printf ("%-20s %s\n", "mount", "mount a guest disk at a position in the filesystem");
  77   printf ("%-20s %s\n", "mounts", "show mounted filesystems");
  78   printf ("%-20s %s\n", "pvcreate", "create an LVM physical volume");
  79   printf ("%-20s %s\n", "pvs", "list the LVM physical volumes (PVs)");
  80   printf ("%-20s %s\n", "pvs-full", "list the LVM physical volumes (PVs)");
  81   printf ("%-20s %s\n", "read-lines", "read file as lines");
  82   printf ("%-20s %s\n", "rm", "remove a file");
  83   printf ("%-20s %s\n", "rm-rf", "remove a file or directory recursively");
  84   printf ("%-20s %s\n", "rmdir", "remove a directory");
  85   printf ("%-20s %s\n", "set-autosync", "set autosync mode");
  86   printf ("%-20s %s\n", "set-path", "set the search path");
  87   printf ("%-20s %s\n", "set-verbose", "set verbose mode");
  88   printf ("%-20s %s\n", "sfdisk", "create partitions on a block device");
  89   printf ("%-20s %s\n", "stat", "get file information");
  90   printf ("%-20s %s\n", "statvfs", "get file system statistics");
  91   printf ("%-20s %s\n", "sync", "sync disks, writes are flushed through to the disk image");
  92   printf ("%-20s %s\n", "touch", "update file timestamps or create a new file");
  93   printf ("%-20s %s\n", "umount", "unmount a filesystem");
  94   printf ("%-20s %s\n", "umount-all", "unmount all filesystems");
  95   printf ("%-20s %s\n", "vgcreate", "create an LVM volume group");
  96   printf ("%-20s %s\n", "vgs", "list the LVM volume groups (VGs)");
  97   printf ("%-20s %s\n", "vgs-full", "list the LVM volume groups (VGs)");
  98   printf ("%-20s %s\n", "write-file", "create a file");
  99   printf ("    Use -h <cmd> / help <cmd> to show detailed help for a command.\n");
 100 }
 101
 102 void display_command (const char *cmd)
 103 {
 104   if (strcasecmp (cmd, "launch") == 0 || strcasecmp (cmd, "run") == 0)
 105     pod2text ("launch - launch the qemu subprocess", " launch\n\nInternally libguestfs is implemented by running a virtual machine\nusing L<qemu(1)>.\n\nYou should call this after configuring the handle\n(eg. adding drives) but before performing any actions.\n\nYou can use 'run' as an alias for this command.");
 106   else
 107   if (strcasecmp (cmd, "kill_subprocess") == 0 || strcasecmp (cmd, "kill-subprocess") == 0)
 108     pod2text ("kill-subprocess - kill the qemu subprocess", " kill-subprocess\n\nThis kills the qemu subprocess.  You should never need to call this.");
 109   else
 110   if (strcasecmp (cmd, "add_drive") == 0 || strcasecmp (cmd, "add-drive") == 0 || strcasecmp (cmd, "add") == 0)
 111     pod2text ("add-drive - add an image to examine or modify", " add-drive <filename>\n\nThis function adds a virtual machine disk image C<filename> to the\nguest.  The first time you call this function, the disk appears as IDE\ndisk 0 (C</dev/sda>) in the guest, the second time as C</dev/sdb>, and\nso on.\n\nYou don't necessarily need to be root when using libguestfs.  However\nyou obviously do need sufficient permissions to access the filename\nfor whatever operations you want to perform (ie. read access if you\njust want to read the image or write access if you want to modify the\nimage).\n\nThis is equivalent to the qemu parameter C<-drive file=filename>.\n\nYou can use 'add' as an alias for this command.");
 112   else
 113   if (strcasecmp (cmd, "add_cdrom") == 0 || strcasecmp (cmd, "add-cdrom") == 0 || strcasecmp (cmd, "cdrom") == 0)
 114     pod2text ("add-cdrom - add a CD-ROM disk image to examine", " add-cdrom <filename>\n\nThis function adds a virtual CD-ROM disk image to the guest.\n\nThis is equivalent to the qemu parameter C<-cdrom filename>.\n\nYou can use 'cdrom' as an alias for this command.");
 115   else
 116   if (strcasecmp (cmd, "config") == 0)
 117     pod2text ("config - add qemu parameters", " config <qemuparam> <qemuvalue>\n\nThis can be used to add arbitrary qemu command line parameters\nof the form C<-param value>.  Actually it's not quite arbitrary - we\nprevent you from setting some parameters which would interfere with\nparameters that we use.\n\nThe first character of C<param> string must be a C<-> (dash).\n\nC<value> can be NULL.");
 118   else
 119   if (strcasecmp (cmd, "set_path") == 0 || strcasecmp (cmd, "set-path") == 0 || strcasecmp (cmd, "path") == 0)
 120     pod2text ("set-path - set the search path", " set-path <path>\n\nSet the path that libguestfs searches for kernel and initrd.img.\n\nThe default is C<$libdir/guestfs> unless overridden by setting\nC<LIBGUESTFS_PATH> environment variable.\n\nThe string C<path> is stashed in the libguestfs handle, so the caller\nmust make sure it remains valid for the lifetime of the handle.\n\nSetting C<path> to C<NULL> restores the default path.\n\nYou can use 'path' as an alias for this command.");
 121   else
 122   if (strcasecmp (cmd, "get_path") == 0 || strcasecmp (cmd, "get-path") == 0)
 123     pod2text ("get-path - get the search path", " get-path\n\nReturn the current search path.\n\nThis is always non-NULL.  If it wasn't set already, then this will\nreturn the default path.");
 124   else
 125   if (strcasecmp (cmd, "set_autosync") == 0 || strcasecmp (cmd, "set-autosync") == 0 || strcasecmp (cmd, "autosync") == 0)
 126     pod2text ("set-autosync - set autosync mode", " set-autosync <autosync>\n\nIf C<autosync> is true, this enables autosync.  Libguestfs will make a\nbest effort attempt to run C<sync> when the handle is closed\n(also if the program exits without closing handles).\n\nYou can use 'autosync' as an alias for this command.");
 127   else
 128   if (strcasecmp (cmd, "get_autosync") == 0 || strcasecmp (cmd, "get-autosync") == 0)
 129     pod2text ("get-autosync - get autosync mode", " get-autosync\n\nGet the autosync flag.");
 130   else
 131   if (strcasecmp (cmd, "set_verbose") == 0 || strcasecmp (cmd, "set-verbose") == 0 || strcasecmp (cmd, "verbose") == 0)
 132     pod2text ("set-verbose - set verbose mode", " set-verbose <verbose>\n\nIf C<verbose> is true, this turns on verbose messages (to C<stderr>).\n\nVerbose messages are disabled unless the environment variable\nC<LIBGUESTFS_DEBUG> is defined and set to C<1>.\n\nYou can use 'verbose' as an alias for this command.");
 133   else
 134   if (strcasecmp (cmd, "get_verbose") == 0 || strcasecmp (cmd, "get-verbose") == 0)
 135     pod2text ("get-verbose - get verbose mode", " get-verbose\n\nThis returns the verbose messages flag.");
 136   else
 137   if (strcasecmp (cmd, "mount") == 0)
 138     pod2text ("mount - mount a guest disk at a position in the filesystem", " mount <device> <mountpoint>\n\nMount a guest disk at a position in the filesystem.  Block devices\nare named C</dev/sda>, C</dev/sdb> and so on, as they were added to\nthe guest.  If those block devices contain partitions, they will have\nthe usual names (eg. C</dev/sda1>).  Also LVM C</dev/VG/LV>-style\nnames can be used.\n\nThe rules are the same as for L<mount(2)>:  A filesystem must\nfirst be mounted on C</> before others can be mounted.  Other\nfilesystems can only be mounted on directories which already\nexist.\n\nThe mounted filesystem is writable, if we have sufficient permissions\non the underlying device.\n\nThe filesystem options C<sync> and C<noatime> are set with this\ncall, in order to improve reliability.");
 139   else
 140   if (strcasecmp (cmd, "sync") == 0)
 141     pod2text ("sync - sync disks, writes are flushed through to the disk image", " sync\n\nThis syncs the disk, so that any writes are flushed through to the\nunderlying disk image.\n\nYou should always call this if you have modified a disk image, before\nclosing the handle.");
 142   else
 143   if (strcasecmp (cmd, "touch") == 0)
 144     pod2text ("touch - update file timestamps or create a new file", " touch <path>\n\nTouch acts like the L<touch(1)> command.  It can be used to\nupdate the timestamps on a file, or, if the file does not exist,\nto create a new zero-length file.");
 145   else
 146   if (strcasecmp (cmd, "cat") == 0)
 147     pod2text ("cat - list the contents of a file", " cat <path>\n\nReturn the contents of the file named C<path>.\n\nNote that this function cannot correctly handle binary files\n(specifically, files containing C<\\0> character which is treated\nas end of string).  For those you need to use the C<read_file>\nfunction which has a more complex interface.\n\nBecause of the message protocol, there is a transfer limit \nof somewhere between 2MB and 4MB.  To transfer large files you should use\nFTP.");
 148   else
 149   if (strcasecmp (cmd, "ll") == 0)
 150     pod2text ("ll - list the files in a directory (long format)", " ll <directory>\n\nList the files in C<directory> (relative to the root directory,\nthere is no cwd) in the format of 'ls -la'.\n\nThis command is mostly useful for interactive sessions.  It\nis I<not> intended that you try to parse the output string.");
 151   else
 152   if (strcasecmp (cmd, "ls") == 0)
 153     pod2text ("ls - list the files in a directory", " ls <directory>\n\nList the files in C<directory> (relative to the root directory,\nthere is no cwd).  The '.' and '..' entries are not returned, but\nhidden files are shown.\n\nThis command is mostly useful for interactive sessions.  Programs\nshould probably use C<readdir> instead.");
 154   else
 155   if (strcasecmp (cmd, "list_devices") == 0 || strcasecmp (cmd, "list-devices") == 0)
 156     pod2text ("list-devices - list the block devices", " list-devices\n\nList all the block devices.\n\nThe full block device names are returned, eg. C</dev/sda>");
 157   else
 158   if (strcasecmp (cmd, "list_partitions") == 0 || strcasecmp (cmd, "list-partitions") == 0)
 159     pod2text ("list-partitions - list the partitions", " list-partitions\n\nList all the partitions detected on all block devices.\n\nThe full partition device names are returned, eg. C</dev/sda1>\n\nThis does not return logical volumes.  For that you will need to\ncall C<lvs>.");
 160   else
 161   if (strcasecmp (cmd, "pvs") == 0)
 162     pod2text ("pvs - list the LVM physical volumes (PVs)", " pvs\n\nList all the physical volumes detected.  This is the equivalent\nof the L<pvs(8)> command.\n\nThis returns a list of just the device names that contain\nPVs (eg. C</dev/sda2>).\n\nSee also C<pvs_full>.");
 163   else
 164   if (strcasecmp (cmd, "vgs") == 0)
 165     pod2text ("vgs - list the LVM volume groups (VGs)", " vgs\n\nList all the volumes groups detected.  This is the equivalent\nof the L<vgs(8)> command.\n\nThis returns a list of just the volume group names that were\ndetected (eg. C<VolGroup00>).\n\nSee also C<vgs_full>.");
 166   else
 167   if (strcasecmp (cmd, "lvs") == 0)
 168     pod2text ("lvs - list the LVM logical volumes (LVs)", " lvs\n\nList all the logical volumes detected.  This is the equivalent\nof the L<lvs(8)> command.\n\nThis returns a list of the logical volume device names\n(eg. C</dev/VolGroup00/LogVol00>).\n\nSee also C<lvs_full>.");
 169   else
 170   if (strcasecmp (cmd, "pvs_full") == 0 || strcasecmp (cmd, "pvs-full") == 0)
 171     pod2text ("pvs-full - list the LVM physical volumes (PVs)", " pvs-full\n\nList all the physical volumes detected.  This is the equivalent\nof the L<pvs(8)> command.  The \"full\" version includes all fields.");
 172   else
 173   if (strcasecmp (cmd, "vgs_full") == 0 || strcasecmp (cmd, "vgs-full") == 0)
 174     pod2text ("vgs-full - list the LVM volume groups (VGs)", " vgs-full\n\nList all the volumes groups detected.  This is the equivalent\nof the L<vgs(8)> command.  The \"full\" version includes all fields.");
 175   else
 176   if (strcasecmp (cmd, "lvs_full") == 0 || strcasecmp (cmd, "lvs-full") == 0)
 177     pod2text ("lvs-full - list the LVM logical volumes (LVs)", " lvs-full\n\nList all the logical volumes detected.  This is the equivalent\nof the L<lvs(8)> command.  The \"full\" version includes all fields.");
 178   else
 179   if (strcasecmp (cmd, "read_lines") == 0 || strcasecmp (cmd, "read-lines") == 0)
 180     pod2text ("read-lines - read file as lines", " read-lines <path>\n\nReturn the contents of the file named C<path>.\n\nThe file contents are returned as a list of lines.  Trailing\nC<LF> and C<CRLF> character sequences are I<not> returned.\n\nNote that this function cannot correctly handle binary files\n(specifically, files containing C<\\0> character which is treated\nas end of line).  For those you need to use the C<read_file>\nfunction which has a more complex interface.");
 181   else
 182   if (strcasecmp (cmd, "aug_init") == 0 || strcasecmp (cmd, "aug-init") == 0)
 183     pod2text ("aug-init - create a new Augeas handle", " aug-init <root> <flags>\n\nCreate a new Augeas handle for editing configuration files.\nIf there was any previous Augeas handle associated with this\nguestfs session, then it is closed.\n\nYou must call this before using any other C<aug_*>\ncommands.\n\nC<root> is the filesystem root.  C<root> must not be NULL,\nuse C</> instead.\n\nThe flags are the same as the flags defined in\nE<lt>augeas.hE<gt>, the logical I<or> of the following\nintegers:\n\n=over 4\n\n=item C<AUG_SAVE_BACKUP> = 1\n\nKeep the original file with a C<.augsave> extension.\n\n=item C<AUG_SAVE_NEWFILE> = 2\n\nSave changes into a file with extension C<.augnew>, and\ndo not overwrite original.  Overrides C<AUG_SAVE_BACKUP>.\n\n=item C<AUG_TYPE_CHECK> = 4\n\nTypecheck lenses (can be expensive).\n\n=item C<AUG_NO_STDINC> = 8\n\nDo not use standard load path for modules.\n\n=item C<AUG_SAVE_NOOP> = 16\n\nMake save a no-op, just record what would have been changed.\n\n=item C<AUG_NO_LOAD> = 32\n\nDo not load the tree in C<aug_init>.\n\n=back\n\nTo close the handle, you can call C<aug_close>.\n\nTo find out more about Augeas, see L<http://augeas.net/>.");
 184   else
 185   if (strcasecmp (cmd, "aug_close") == 0 || strcasecmp (cmd, "aug-close") == 0)
 186     pod2text ("aug-close - close the current Augeas handle", " aug-close\n\nClose the current Augeas handle and free up any resources\nused by it.  After calling this, you have to call\nC<aug_init> again before you can use any other\nAugeas functions.");
 187   else
 188   if (strcasecmp (cmd, "aug_defvar") == 0 || strcasecmp (cmd, "aug-defvar") == 0)
 189     pod2text ("aug-defvar - define an Augeas variable", " aug-defvar <name> <expr>\n\nDefines an Augeas variable C<name> whose value is the result\nof evaluating C<expr>.  If C<expr> is NULL, then C<name> is\nundefined.\n\nOn success this returns the number of nodes in C<expr>, or\nC<0> if C<expr> evaluates to something which is not a nodeset.");
 190   else
 191   if (strcasecmp (cmd, "aug_defnode") == 0 || strcasecmp (cmd, "aug-defnode") == 0)
 192     pod2text ("aug-defnode - define an Augeas node", " aug-defnode <name> <expr> <val>\n\nDefines a variable C<name> whose value is the result of\nevaluating C<expr>.\n\nIf C<expr> evaluates to an empty nodeset, a node is created,\nequivalent to calling C<aug_set> C<expr>, C<value>.\nC<name> will be the nodeset containing that single node.\n\nOn success this returns a pair containing the\nnumber of nodes in the nodeset, and a boolean flag\nif a node was created.");
 193   else
 194   if (strcasecmp (cmd, "aug_get") == 0 || strcasecmp (cmd, "aug-get") == 0)
 195     pod2text ("aug-get - look up the value of an Augeas path", " aug-get <path>\n\nLook up the value associated with C<path>.  If C<path>\nmatches exactly one node, the C<value> is returned.");
 196   else
 197   if (strcasecmp (cmd, "aug_set") == 0 || strcasecmp (cmd, "aug-set") == 0)
 198     pod2text ("aug-set - set Augeas path to value", " aug-set <path> <val>\n\nSet the value associated with C<path> to C<value>.");
 199   else
 200   if (strcasecmp (cmd, "aug_insert") == 0 || strcasecmp (cmd, "aug-insert") == 0)
 201     pod2text ("aug-insert - insert a sibling Augeas node", " aug-insert <path> <label> <before>\n\nCreate a new sibling C<label> for C<path>, inserting it into\nthe tree before or after C<path> (depending on the boolean\nflag C<before>).\n\nC<path> must match exactly one existing node in the tree, and\nC<label> must be a label, ie. not contain C</>, C<*> or end\nwith a bracketed index C<[N]>.");
 202   else
 203   if (strcasecmp (cmd, "aug_rm") == 0 || strcasecmp (cmd, "aug-rm") == 0)
 204     pod2text ("aug-rm - remove an Augeas path", " aug-rm <path>\n\nRemove C<path> and all of its children.\n\nOn success this returns the number of entries which were removed.");
 205   else
 206   if (strcasecmp (cmd, "aug_mv") == 0 || strcasecmp (cmd, "aug-mv") == 0)
 207     pod2text ("aug-mv - move Augeas node", " aug-mv <src> <dest>\n\nMove the node C<src> to C<dest>.  C<src> must match exactly\none node.  C<dest> is overwritten if it exists.");
 208   else
 209   if (strcasecmp (cmd, "aug_match") == 0 || strcasecmp (cmd, "aug-match") == 0)
 210     pod2text ("aug-match - return Augeas nodes which match path", " aug-match <path>\n\nReturns a list of paths which match the path expression C<path>.\nThe returned paths are sufficiently qualified so that they match\nexactly one node in the current tree.");
 211   else
 212   if (strcasecmp (cmd, "aug_save") == 0 || strcasecmp (cmd, "aug-save") == 0)
 213     pod2text ("aug-save - write all pending Augeas changes to disk", " aug-save\n\nThis writes all pending changes to disk.\n\nThe flags which were passed to C<aug_init> affect exactly\nhow files are saved.");
 214   else
 215   if (strcasecmp (cmd, "aug_load") == 0 || strcasecmp (cmd, "aug-load") == 0)
 216     pod2text ("aug-load - load files into the tree", " aug-load\n\nLoad files into the tree.\n\nSee C<aug_load> in the Augeas documentation for the full gory\ndetails.");
 217   else
 218   if (strcasecmp (cmd, "aug_ls") == 0 || strcasecmp (cmd, "aug-ls") == 0)
 219     pod2text ("aug-ls - list Augeas nodes under a path", " aug-ls <path>\n\nThis is just a shortcut for listing C<aug_match>\nC<path/*> and sorting the resulting nodes into alphabetical order.");
 220   else
 221   if (strcasecmp (cmd, "rm") == 0)
 222     pod2text ("rm - remove a file", " rm <path>\n\nRemove the single file C<path>.");
 223   else
 224   if (strcasecmp (cmd, "rmdir") == 0)
 225     pod2text ("rmdir - remove a directory", " rmdir <path>\n\nRemove the single directory C<path>.");
 226   else
 227   if (strcasecmp (cmd, "rm_rf") == 0 || strcasecmp (cmd, "rm-rf") == 0)
 228     pod2text ("rm-rf - remove a file or directory recursively", " rm-rf <path>\n\nRemove the file or directory C<path>, recursively removing the\ncontents if its a directory.  This is like the C<rm -rf> shell\ncommand.");
 229   else
 230   if (strcasecmp (cmd, "mkdir") == 0)
 231     pod2text ("mkdir - create a directory", " mkdir <path>\n\nCreate a directory named C<path>.");
 232   else
 233   if (strcasecmp (cmd, "mkdir_p") == 0 || strcasecmp (cmd, "mkdir-p") == 0)
 234     pod2text ("mkdir-p - create a directory and parents", " mkdir-p <path>\n\nCreate a directory named C<path>, creating any parent directories\nas necessary.  This is like the C<mkdir -p> shell command.");
 235   else
 236   if (strcasecmp (cmd, "chmod") == 0)
 237     pod2text ("chmod - change file mode", " chmod <mode> <path>\n\nChange the mode (permissions) of C<path> to C<mode>.  Only\nnumeric modes are supported.");
 238   else
 239   if (strcasecmp (cmd, "chown") == 0)
 240     pod2text ("chown - change file owner and group", " chown <owner> <group> <path>\n\nChange the file owner to C<owner> and group to C<group>.\n\nOnly numeric uid and gid are supported.  If you want to use\nnames, you will need to locate and parse the password file\nyourself (Augeas support makes this relatively easy).");
 241   else
 242   if (strcasecmp (cmd, "exists") == 0)
 243     pod2text ("exists - test if file or directory exists", " exists <path>\n\nThis returns C<true> if and only if there is a file, directory\n(or anything) with the given C<path> name.\n\nSee also C<is_file>, C<is_dir>, C<stat>.");
 244   else
 245   if (strcasecmp (cmd, "is_file") == 0 || strcasecmp (cmd, "is-file") == 0)
 246     pod2text ("is-file - test if file exists", " is-file <path>\n\nThis returns C<true> if and only if there is a file\nwith the given C<path> name.  Note that it returns false for\nother objects like directories.\n\nSee also C<stat>.");
 247   else
 248   if (strcasecmp (cmd, "is_dir") == 0 || strcasecmp (cmd, "is-dir") == 0)
 249     pod2text ("is-dir - test if file exists", " is-dir <path>\n\nThis returns C<true> if and only if there is a directory\nwith the given C<path> name.  Note that it returns false for\nother objects like files.\n\nSee also C<stat>.");
 250   else
 251   if (strcasecmp (cmd, "pvcreate") == 0)
 252     pod2text ("pvcreate - create an LVM physical volume", " pvcreate <device>\n\nThis creates an LVM physical volume on the named C<device>,\nwhere C<device> should usually be a partition name such\nas C</dev/sda1>.");
 253   else
 254   if (strcasecmp (cmd, "vgcreate") == 0)
 255     pod2text ("vgcreate - create an LVM volume group", " vgcreate <volgroup> <physvols>\n\nThis creates an LVM volume group called C<volgroup>\nfrom the non-empty list of physical volumes C<physvols>.");
 256   else
 257   if (strcasecmp (cmd, "lvcreate") == 0)
 258     pod2text ("lvcreate - create an LVM volume group", " lvcreate <logvol> <volgroup> <mbytes>\n\nThis creates an LVM volume group called C<logvol>\non the volume group C<volgroup>, with C<size> megabytes.");
 259   else
 260   if (strcasecmp (cmd, "mkfs") == 0)
 261     pod2text ("mkfs - make a filesystem", " mkfs <fstype> <device>\n\nThis creates a filesystem on C<device> (usually a partition\nof LVM logical volume).  The filesystem type is C<fstype>, for\nexample C<ext3>.");
 262   else
 263   if (strcasecmp (cmd, "sfdisk") == 0)
 264     pod2text ("sfdisk - create partitions on a block device", " sfdisk <device> <cyls> <heads> <sectors> <lines>\n\nThis is a direct interface to the L<sfdisk(8)> program for creating\npartitions on block devices.\n\nC<device> should be a block device, for example C</dev/sda>.\n\nC<cyls>, C<heads> and C<sectors> are the number of cylinders, heads\nand sectors on the device, which are passed directly to sfdisk as\nthe I<-C>, I<-H> and I<-S> parameters.  If you pass C<0> for any\nof these, then the corresponding parameter is omitted.  Usually for\n'large' disks, you can just pass C<0> for these, but for small\n(floppy-sized) disks, sfdisk (or rather, the kernel) cannot work\nout the right geometry and you will need to tell it.\n\nC<lines> is a list of lines that we feed to C<sfdisk>.  For more\ninformation refer to the L<sfdisk(8)> manpage.\n\nTo create a single partition occupying the whole disk, you would\npass C<lines> as a single element list, when the single element being\nthe string C<,> (comma).\n\nB<This command is dangerous.  Without careful use you\ncan easily destroy all your data>.");
 265   else
 266   if (strcasecmp (cmd, "write_file") == 0 || strcasecmp (cmd, "write-file") == 0)
 267     pod2text ("write-file - create a file", " write-file <path> <content> <size>\n\nThis call creates a file called C<path>.  The contents of the\nfile is the string C<content> (which can contain any 8 bit data),\nwith length C<size>.\n\nAs a special case, if C<size> is C<0>\nthen the length is calculated using C<strlen> (so in this case\nthe content cannot contain embedded ASCII NULs).\n\nBecause of the message protocol, there is a transfer limit \nof somewhere between 2MB and 4MB.  To transfer large files you should use\nFTP.");
 268   else
 269   if (strcasecmp (cmd, "umount") == 0 || strcasecmp (cmd, "unmount") == 0)
 270     pod2text ("umount - unmount a filesystem", " umount <pathordevice>\n\nThis unmounts the given filesystem.  The filesystem may be\nspecified either by its mountpoint (path) or the device which\ncontains the filesystem.\n\nYou can use 'unmount' as an alias for this command.");
 271   else
 272   if (strcasecmp (cmd, "mounts") == 0)
 273     pod2text ("mounts - show mounted filesystems", " mounts\n\nThis returns the list of currently mounted filesystems.  It returns\nthe list of devices (eg. C</dev/sda1>, C</dev/VG/LV>).\n\nSome internal mounts are not shown.");
 274   else
 275   if (strcasecmp (cmd, "umount_all") == 0 || strcasecmp (cmd, "umount-all") == 0 || strcasecmp (cmd, "unmount-all") == 0)
 276     pod2text ("umount-all - unmount all filesystems", " umount-all\n\nThis unmounts all mounted filesystems.\n\nSome internal mounts are not unmounted by this call.\n\nYou can use 'unmount-all' as an alias for this command.");
 277   else
 278   if (strcasecmp (cmd, "lvm_remove_all") == 0 || strcasecmp (cmd, "lvm-remove-all") == 0)
 279     pod2text ("lvm-remove-all - remove all LVM LVs, VGs and PVs", " lvm-remove-all\n\nThis command removes all LVM logical volumes, volume groups\nand physical volumes.\n\nB<This command is dangerous.  Without careful use you\ncan easily destroy all your data>.");
 280   else
 281   if (strcasecmp (cmd, "file") == 0)
 282     pod2text ("file - determine file type", " file <path>\n\nThis call uses the standard L<file(1)> command to determine\nthe type or contents of the file.  This also works on devices,\nfor example to find out whether a partition contains a filesystem.\n\nThe exact command which runs is C<file -bsL path>.  Note in\nparticular that the filename is not prepended to the output\n(the C<-b> option).");
 283   else
 284   if (strcasecmp (cmd, "command") == 0)
 285     pod2text ("command - run a command from the guest filesystem", " command <arguments>\n\nThis call runs a command from the guest filesystem.  The\nfilesystem must be mounted, and must contain a compatible\noperating system (ie. something Linux, with the same\nor compatible processor architecture).\n\nThe single parameter is an argv-style list of arguments.\nThe first element is the name of the program to run.\nSubsequent elements are parameters.  The list must be\nnon-empty (ie. must contain a program name).\n\nThe C<$PATH> environment variable will contain at least\nC</usr/bin> and C</bin>.  If you require a program from\nanother location, you should provide the full path in the\nfirst parameter.\n\nShared libraries and data files required by the program\nmust be available on filesystems which are mounted in the\ncorrect places.  It is the caller's responsibility to ensure\nall filesystems that are needed are mounted at the right\nlocations.");
 286   else
 287   if (strcasecmp (cmd, "command_lines") == 0 || strcasecmp (cmd, "command-lines") == 0)
 288     pod2text ("command-lines - run a command, returning lines", " command-lines <arguments>\n\nThis is the same as C<command>, but splits the\nresult into a list of lines.");
 289   else
 290   if (strcasecmp (cmd, "stat") == 0)
 291     pod2text ("stat - get file information", " stat <path>\n\nReturns file information for the given C<path>.\n\nThis is the same as the C<stat(2)> system call.");
 292   else
 293   if (strcasecmp (cmd, "lstat") == 0)
 294     pod2text ("lstat - get file information for a symbolic link", " lstat <path>\n\nReturns file information for the given C<path>.\n\nThis is the same as C<stat> except that if C<path>\nis a symbolic link, then the link is stat-ed, not the file it\nrefers to.\n\nThis is the same as the C<lstat(2)> system call.");
 295   else
 296   if (strcasecmp (cmd, "statvfs") == 0)
 297     pod2text ("statvfs - get file system statistics", " statvfs <path>\n\nReturns file system statistics for any mounted file system.\nC<path> should be a file or directory in the mounted file system\n(typically it is the mount point itself, but it doesn't need to be).\n\nThis is the same as the C<statvfs(2)> system call.");
 298   else
 299     display_builtin_command (cmd);
 300 }
 301
 302 static void print_pv (struct guestfs_lvm_pv *pv)
 303 {
 304   int i;
 305
 306   printf ("pv_name: %s\n", pv->pv_name);
 307   printf ("pv_uuid: ");
 308   for (i = 0; i < 32; ++i)
 309     printf ("%c", pv->pv_uuid[i]);
 310   printf ("\n");
 311   printf ("pv_fmt: %s\n", pv->pv_fmt);
 312   printf ("pv_size: %" PRIu64 "\n", pv->pv_size);
 313   printf ("dev_size: %" PRIu64 "\n", pv->dev_size);
 314   printf ("pv_free: %" PRIu64 "\n", pv->pv_free);
 315   printf ("pv_used: %" PRIu64 "\n", pv->pv_used);
 316   printf ("pv_attr: %s\n", pv->pv_attr);
 317   printf ("pv_pe_count: %" PRIi64 "\n", pv->pv_pe_count);
 318   printf ("pv_pe_alloc_count: %" PRIi64 "\n", pv->pv_pe_alloc_count);
 319   printf ("pv_tags: %s\n", pv->pv_tags);
 320   printf ("pe_start: %" PRIu64 "\n", pv->pe_start);
 321   printf ("pv_mda_count: %" PRIi64 "\n", pv->pv_mda_count);
 322   printf ("pv_mda_free: %" PRIu64 "\n", pv->pv_mda_free);
 323 }
 324
 325 static void print_pv_list (struct guestfs_lvm_pv_list *pvs)
 326 {
 327   int i;
 328
 329   for (i = 0; i < pvs->len; ++i)
 330     print_pv (&pvs->val[i]);
 331 }
 332
 333 static void print_vg (struct guestfs_lvm_vg *vg)
 334 {
 335   int i;
 336
 337   printf ("vg_name: %s\n", vg->vg_name);
 338   printf ("vg_uuid: ");
 339   for (i = 0; i < 32; ++i)
 340     printf ("%c", vg->vg_uuid[i]);
 341   printf ("\n");
 342   printf ("vg_fmt: %s\n", vg->vg_fmt);
 343   printf ("vg_attr: %s\n", vg->vg_attr);
 344   printf ("vg_size: %" PRIu64 "\n", vg->vg_size);
 345   printf ("vg_free: %" PRIu64 "\n", vg->vg_free);
 346   printf ("vg_sysid: %s\n", vg->vg_sysid);
 347   printf ("vg_extent_size: %" PRIu64 "\n", vg->vg_extent_size);
 348   printf ("vg_extent_count: %" PRIi64 "\n", vg->vg_extent_count);
 349   printf ("vg_free_count: %" PRIi64 "\n", vg->vg_free_count);
 350   printf ("max_lv: %" PRIi64 "\n", vg->max_lv);
 351   printf ("max_pv: %" PRIi64 "\n", vg->max_pv);
 352   printf ("pv_count: %" PRIi64 "\n", vg->pv_count);
 353   printf ("lv_count: %" PRIi64 "\n", vg->lv_count);
 354   printf ("snap_count: %" PRIi64 "\n", vg->snap_count);
 355   printf ("vg_seqno: %" PRIi64 "\n", vg->vg_seqno);
 356   printf ("vg_tags: %s\n", vg->vg_tags);
 357   printf ("vg_mda_count: %" PRIi64 "\n", vg->vg_mda_count);
 358   printf ("vg_mda_free: %" PRIu64 "\n", vg->vg_mda_free);
 359 }
 360
 361 static void print_vg_list (struct guestfs_lvm_vg_list *vgs)
 362 {
 363   int i;
 364
 365   for (i = 0; i < vgs->len; ++i)
 366     print_vg (&vgs->val[i]);
 367 }
 368
 369 static void print_lv (struct guestfs_lvm_lv *lv)
 370 {
 371   int i;
 372
 373   printf ("lv_name: %s\n", lv->lv_name);
 374   printf ("lv_uuid: ");
 375   for (i = 0; i < 32; ++i)
 376     printf ("%c", lv->lv_uuid[i]);
 377   printf ("\n");
 378   printf ("lv_attr: %s\n", lv->lv_attr);
 379   printf ("lv_major: %" PRIi64 "\n", lv->lv_major);
 380   printf ("lv_minor: %" PRIi64 "\n", lv->lv_minor);
 381   printf ("lv_kernel_major: %" PRIi64 "\n", lv->lv_kernel_major);
 382   printf ("lv_kernel_minor: %" PRIi64 "\n", lv->lv_kernel_minor);
 383   printf ("lv_size: %" PRIu64 "\n", lv->lv_size);
 384   printf ("seg_count: %" PRIi64 "\n", lv->seg_count);
 385   printf ("origin: %s\n", lv->origin);
 386   if (lv->snap_percent >= 0) printf ("snap_percent: %g %%\n", lv->snap_percent);
 387   else printf ("snap_percent: \n");
 388   if (lv->copy_percent >= 0) printf ("copy_percent: %g %%\n", lv->copy_percent);
 389   else printf ("copy_percent: \n");
 390   printf ("move_pv: %s\n", lv->move_pv);
 391   printf ("lv_tags: %s\n", lv->lv_tags);
 392   printf ("mirror_log: %s\n", lv->mirror_log);
 393   printf ("modules: %s\n", lv->modules);
 394 }
 395
 396 static void print_lv_list (struct guestfs_lvm_lv_list *lvs)
 397 {
 398   int i;
 399
 400   for (i = 0; i < lvs->len; ++i)
 401     print_lv (&lvs->val[i]);
 402 }
 403
 404 static void print_stat (struct guestfs_stat *stat)
 405 {
 406   printf ("dev: %" PRIi64 "\n", stat->dev);
 407   printf ("ino: %" PRIi64 "\n", stat->ino);
 408   printf ("mode: %" PRIi64 "\n", stat->mode);
 409   printf ("nlink: %" PRIi64 "\n", stat->nlink);
 410   printf ("uid: %" PRIi64 "\n", stat->uid);
 411   printf ("gid: %" PRIi64 "\n", stat->gid);
 412   printf ("rdev: %" PRIi64 "\n", stat->rdev);
 413   printf ("size: %" PRIi64 "\n", stat->size);
 414   printf ("blksize: %" PRIi64 "\n", stat->blksize);
 415   printf ("blocks: %" PRIi64 "\n", stat->blocks);
 416   printf ("atime: %" PRIi64 "\n", stat->atime);
 417   printf ("mtime: %" PRIi64 "\n", stat->mtime);
 418   printf ("ctime: %" PRIi64 "\n", stat->ctime);
 419 }
 420
 421 static void print_statvfs (struct guestfs_statvfs *statvfs)
 422 {
 423   printf ("bsize: %" PRIi64 "\n", statvfs->bsize);
 424   printf ("frsize: %" PRIi64 "\n", statvfs->frsize);
 425   printf ("blocks: %" PRIi64 "\n", statvfs->blocks);
 426   printf ("bfree: %" PRIi64 "\n", statvfs->bfree);
 427   printf ("bavail: %" PRIi64 "\n", statvfs->bavail);
 428   printf ("files: %" PRIi64 "\n", statvfs->files);
 429   printf ("ffree: %" PRIi64 "\n", statvfs->ffree);
 430   printf ("favail: %" PRIi64 "\n", statvfs->favail);
 431   printf ("fsid: %" PRIi64 "\n", statvfs->fsid);
 432   printf ("flag: %" PRIi64 "\n", statvfs->flag);
 433   printf ("namemax: %" PRIi64 "\n", statvfs->namemax);
 434 }
 435
 436 static int run_launch (const char *cmd, int argc, char *argv[])
 437 {
 438   int r;
 439   if (argc != 0) {
 440     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 441     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 442     return -1;
 443   }
 444   r = launch (g);
 445   return r;
 446 }
 447
 448 static int run_kill_subprocess (const char *cmd, int argc, char *argv[])
 449 {
 450   int r;
 451   if (argc != 0) {
 452     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 453     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 454     return -1;
 455   }
 456   r = guestfs_kill_subprocess (g);
 457   return r;
 458 }
 459
 460 static int run_add_drive (const char *cmd, int argc, char *argv[])
 461 {
 462   int r;
 463   const char *filename;
 464   if (argc != 1) {
 465     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 466     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 467     return -1;
 468   }
 469   filename = argv[0];
 470   r = guestfs_add_drive (g, filename);
 471   return r;
 472 }
 473
 474 static int run_add_cdrom (const char *cmd, int argc, char *argv[])
 475 {
 476   int r;
 477   const char *filename;
 478   if (argc != 1) {
 479     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 480     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 481     return -1;
 482   }
 483   filename = argv[0];
 484   r = guestfs_add_cdrom (g, filename);
 485   return r;
 486 }
 487
 488 static int run_config (const char *cmd, int argc, char *argv[])
 489 {
 490   int r;
 491   const char *qemuparam;
 492   const char *qemuvalue;
 493   if (argc != 2) {
 494     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 495     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 496     return -1;
 497   }
 498   qemuparam = argv[0];
 499   qemuvalue = strcmp (argv[1], "") != 0 ? argv[1] : NULL;
 500   r = guestfs_config (g, qemuparam, qemuvalue);
 501   return r;
 502 }
 503
 504 static int run_set_path (const char *cmd, int argc, char *argv[])
 505 {
 506   int r;
 507   const char *path;
 508   if (argc != 1) {
 509     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 510     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 511     return -1;
 512   }
 513   path = argv[0];
 514   r = guestfs_set_path (g, path);
 515   return r;
 516 }
 517
 518 static int run_get_path (const char *cmd, int argc, char *argv[])
 519 {
 520   const char *r;
 521   if (argc != 0) {
 522     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 523     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 524     return -1;
 525   }
 526   r = guestfs_get_path (g);
 527   if (r == NULL) return -1;
 528   printf ("%s\n", r);
 529   return 0;
 530 }
 531
 532 static int run_set_autosync (const char *cmd, int argc, char *argv[])
 533 {
 534   int r;
 535   int autosync;
 536   if (argc != 1) {
 537     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 538     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 539     return -1;
 540   }
 541   autosync = is_true (argv[0]) ? 1 : 0;
 542   r = guestfs_set_autosync (g, autosync);
 543   return r;
 544 }
 545
 546 static int run_get_autosync (const char *cmd, int argc, char *argv[])
 547 {
 548   int r;
 549   if (argc != 0) {
 550     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 551     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 552     return -1;
 553   }
 554   r = guestfs_get_autosync (g);
 555   if (r == -1) return -1;
 556   if (r) printf ("true\n"); else printf ("false\n");
 557   return 0;
 558 }
 559
 560 static int run_set_verbose (const char *cmd, int argc, char *argv[])
 561 {
 562   int r;
 563   int verbose;
 564   if (argc != 1) {
 565     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 566     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 567     return -1;
 568   }
 569   verbose = is_true (argv[0]) ? 1 : 0;
 570   r = guestfs_set_verbose (g, verbose);
 571   return r;
 572 }
 573
 574 static int run_get_verbose (const char *cmd, int argc, char *argv[])
 575 {
 576   int r;
 577   if (argc != 0) {
 578     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 579     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 580     return -1;
 581   }
 582   r = guestfs_get_verbose (g);
 583   if (r == -1) return -1;
 584   if (r) printf ("true\n"); else printf ("false\n");
 585   return 0;
 586 }
 587
 588 static int run_mount (const char *cmd, int argc, char *argv[])
 589 {
 590   int r;
 591   const char *device;
 592   const char *mountpoint;
 593   if (argc != 2) {
 594     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 595     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 596     return -1;
 597   }
 598   device = argv[0];
 599   mountpoint = argv[1];
 600   r = guestfs_mount (g, device, mountpoint);
 601   return r;
 602 }
 603
 604 static int run_sync (const char *cmd, int argc, char *argv[])
 605 {
 606   int r;
 607   if (argc != 0) {
 608     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 609     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 610     return -1;
 611   }
 612   r = guestfs_sync (g);
 613   return r;
 614 }
 615
 616 static int run_touch (const char *cmd, int argc, char *argv[])
 617 {
 618   int r;
 619   const char *path;
 620   if (argc != 1) {
 621     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 622     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 623     return -1;
 624   }
 625   path = argv[0];
 626   r = guestfs_touch (g, path);
 627   return r;
 628 }
 629
 630 static int run_cat (const char *cmd, int argc, char *argv[])
 631 {
 632   char *r;
 633   const char *path;
 634   if (argc != 1) {
 635     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 636     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 637     return -1;
 638   }
 639   path = argv[0];
 640   r = guestfs_cat (g, path);
 641   if (r == NULL) return -1;
 642   printf ("%s\n", r);
 643   free (r);
 644   return 0;
 645 }
 646
 647 static int run_ll (const char *cmd, int argc, char *argv[])
 648 {
 649   char *r;
 650   const char *directory;
 651   if (argc != 1) {
 652     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 653     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 654     return -1;
 655   }
 656   directory = argv[0];
 657   r = guestfs_ll (g, directory);
 658   if (r == NULL) return -1;
 659   printf ("%s\n", r);
 660   free (r);
 661   return 0;
 662 }
 663
 664 static int run_ls (const char *cmd, int argc, char *argv[])
 665 {
 666   char **r;
 667   const char *directory;
 668   if (argc != 1) {
 669     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 670     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 671     return -1;
 672   }
 673   directory = argv[0];
 674   r = guestfs_ls (g, directory);
 675   if (r == NULL) return -1;
 676   print_strings (r);
 677   free_strings (r);
 678   return 0;
 679 }
 680
 681 static int run_list_devices (const char *cmd, int argc, char *argv[])
 682 {
 683   char **r;
 684   if (argc != 0) {
 685     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 686     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 687     return -1;
 688   }
 689   r = guestfs_list_devices (g);
 690   if (r == NULL) return -1;
 691   print_strings (r);
 692   free_strings (r);
 693   return 0;
 694 }
 695
 696 static int run_list_partitions (const char *cmd, int argc, char *argv[])
 697 {
 698   char **r;
 699   if (argc != 0) {
 700     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 701     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 702     return -1;
 703   }
 704   r = guestfs_list_partitions (g);
 705   if (r == NULL) return -1;
 706   print_strings (r);
 707   free_strings (r);
 708   return 0;
 709 }
 710
 711 static int run_pvs (const char *cmd, int argc, char *argv[])
 712 {
 713   char **r;
 714   if (argc != 0) {
 715     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 716     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 717     return -1;
 718   }
 719   r = guestfs_pvs (g);
 720   if (r == NULL) return -1;
 721   print_strings (r);
 722   free_strings (r);
 723   return 0;
 724 }
 725
 726 static int run_vgs (const char *cmd, int argc, char *argv[])
 727 {
 728   char **r;
 729   if (argc != 0) {
 730     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 731     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 732     return -1;
 733   }
 734   r = guestfs_vgs (g);
 735   if (r == NULL) return -1;
 736   print_strings (r);
 737   free_strings (r);
 738   return 0;
 739 }
 740
 741 static int run_lvs (const char *cmd, int argc, char *argv[])
 742 {
 743   char **r;
 744   if (argc != 0) {
 745     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 746     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 747     return -1;
 748   }
 749   r = guestfs_lvs (g);
 750   if (r == NULL) return -1;
 751   print_strings (r);
 752   free_strings (r);
 753   return 0;
 754 }
 755
 756 static int run_pvs_full (const char *cmd, int argc, char *argv[])
 757 {
 758   struct guestfs_lvm_pv_list *r;
 759   if (argc != 0) {
 760     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 761     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 762     return -1;
 763   }
 764   r = guestfs_pvs_full (g);
 765   if (r == NULL) return -1;
 766   print_pv_list (r);
 767   guestfs_free_lvm_pv_list (r);
 768   return 0;
 769 }
 770
 771 static int run_vgs_full (const char *cmd, int argc, char *argv[])
 772 {
 773   struct guestfs_lvm_vg_list *r;
 774   if (argc != 0) {
 775     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 776     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 777     return -1;
 778   }
 779   r = guestfs_vgs_full (g);
 780   if (r == NULL) return -1;
 781   print_vg_list (r);
 782   guestfs_free_lvm_vg_list (r);
 783   return 0;
 784 }
 785
 786 static int run_lvs_full (const char *cmd, int argc, char *argv[])
 787 {
 788   struct guestfs_lvm_lv_list *r;
 789   if (argc != 0) {
 790     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 791     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 792     return -1;
 793   }
 794   r = guestfs_lvs_full (g);
 795   if (r == NULL) return -1;
 796   print_lv_list (r);
 797   guestfs_free_lvm_lv_list (r);
 798   return 0;
 799 }
 800
 801 static int run_read_lines (const char *cmd, int argc, char *argv[])
 802 {
 803   char **r;
 804   const char *path;
 805   if (argc != 1) {
 806     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 807     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 808     return -1;
 809   }
 810   path = argv[0];
 811   r = guestfs_read_lines (g, path);
 812   if (r == NULL) return -1;
 813   print_strings (r);
 814   free_strings (r);
 815   return 0;
 816 }
 817
 818 static int run_aug_init (const char *cmd, int argc, char *argv[])
 819 {
 820   int r;
 821   const char *root;
 822   int flags;
 823   if (argc != 2) {
 824     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 825     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 826     return -1;
 827   }
 828   root = argv[0];
 829   flags = atoi (argv[1]);
 830   r = guestfs_aug_init (g, root, flags);
 831   return r;
 832 }
 833
 834 static int run_aug_close (const char *cmd, int argc, char *argv[])
 835 {
 836   int r;
 837   if (argc != 0) {
 838     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 839     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 840     return -1;
 841   }
 842   r = guestfs_aug_close (g);
 843   return r;
 844 }
 845
 846 static int run_aug_defvar (const char *cmd, int argc, char *argv[])
 847 {
 848   int r;
 849   const char *name;
 850   const char *expr;
 851   if (argc != 2) {
 852     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 853     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 854     return -1;
 855   }
 856   name = argv[0];
 857   expr = strcmp (argv[1], "") != 0 ? argv[1] : NULL;
 858   r = guestfs_aug_defvar (g, name, expr);
 859   if (r == -1) return -1;
 860   if (r) printf ("%d\n", r);
 861   return 0;
 862 }
 863
 864 static int run_aug_defnode (const char *cmd, int argc, char *argv[])
 865 {
 866   struct guestfs_int_bool *r;
 867   const char *name;
 868   const char *expr;
 869   const char *val;
 870   if (argc != 3) {
 871     fprintf (stderr, "%s should have 3 parameter(s)\n", cmd);
 872     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 873     return -1;
 874   }
 875   name = argv[0];
 876   expr = argv[1];
 877   val = argv[2];
 878   r = guestfs_aug_defnode (g, name, expr, val);
 879   if (r == NULL) return -1;
 880   printf ("%d, %s\n", r->i,
 881     r->b ? "true" : "false");
 882   guestfs_free_int_bool (r);
 883   return 0;
 884 }
 885
 886 static int run_aug_get (const char *cmd, int argc, char *argv[])
 887 {
 888   char *r;
 889   const char *path;
 890   if (argc != 1) {
 891     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 892     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 893     return -1;
 894   }
 895   path = argv[0];
 896   r = guestfs_aug_get (g, path);
 897   if (r == NULL) return -1;
 898   printf ("%s\n", r);
 899   free (r);
 900   return 0;
 901 }
 902
 903 static int run_aug_set (const char *cmd, int argc, char *argv[])
 904 {
 905   int r;
 906   const char *path;
 907   const char *val;
 908   if (argc != 2) {
 909     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 910     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 911     return -1;
 912   }
 913   path = argv[0];
 914   val = argv[1];
 915   r = guestfs_aug_set (g, path, val);
 916   return r;
 917 }
 918
 919 static int run_aug_insert (const char *cmd, int argc, char *argv[])
 920 {
 921   int r;
 922   const char *path;
 923   const char *label;
 924   int before;
 925   if (argc != 3) {
 926     fprintf (stderr, "%s should have 3 parameter(s)\n", cmd);
 927     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 928     return -1;
 929   }
 930   path = argv[0];
 931   label = argv[1];
 932   before = is_true (argv[2]) ? 1 : 0;
 933   r = guestfs_aug_insert (g, path, label, before);
 934   return r;
 935 }
 936
 937 static int run_aug_rm (const char *cmd, int argc, char *argv[])
 938 {
 939   int r;
 940   const char *path;
 941   if (argc != 1) {
 942     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 943     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 944     return -1;
 945   }
 946   path = argv[0];
 947   r = guestfs_aug_rm (g, path);
 948   if (r == -1) return -1;
 949   if (r) printf ("%d\n", r);
 950   return 0;
 951 }
 952
 953 static int run_aug_mv (const char *cmd, int argc, char *argv[])
 954 {
 955   int r;
 956   const char *src;
 957   const char *dest;
 958   if (argc != 2) {
 959     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 960     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 961     return -1;
 962   }
 963   src = argv[0];
 964   dest = argv[1];
 965   r = guestfs_aug_mv (g, src, dest);
 966   return r;
 967 }
 968
 969 static int run_aug_match (const char *cmd, int argc, char *argv[])
 970 {
 971   char **r;
 972   const char *path;
 973   if (argc != 1) {
 974     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 975     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 976     return -1;
 977   }
 978   path = argv[0];
 979   r = guestfs_aug_match (g, path);
 980   if (r == NULL) return -1;
 981   print_strings (r);
 982   free_strings (r);
 983   return 0;
 984 }
 985
 986 static int run_aug_save (const char *cmd, int argc, char *argv[])
 987 {
 988   int r;
 989   if (argc != 0) {
 990     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 991     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 992     return -1;
 993   }
 994   r = guestfs_aug_save (g);
 995   return r;
 996 }
 997
 998 static int run_aug_load (const char *cmd, int argc, char *argv[])
 999 {
1000   int r;
1001   if (argc != 0) {
1002     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
1003     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1004     return -1;
1005   }
1006   r = guestfs_aug_load (g);
1007   return r;
1008 }
1009
1010 static int run_aug_ls (const char *cmd, int argc, char *argv[])
1011 {
1012   char **r;
1013   const char *path;
1014   if (argc != 1) {
1015     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1016     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1017     return -1;
1018   }
1019   path = argv[0];
1020   r = guestfs_aug_ls (g, path);
1021   if (r == NULL) return -1;
1022   print_strings (r);
1023   free_strings (r);
1024   return 0;
1025 }
1026
1027 static int run_rm (const char *cmd, int argc, char *argv[])
1028 {
1029   int r;
1030   const char *path;
1031   if (argc != 1) {
1032     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1033     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1034     return -1;
1035   }
1036   path = argv[0];
1037   r = guestfs_rm (g, path);
1038   return r;
1039 }
1040
1041 static int run_rmdir (const char *cmd, int argc, char *argv[])
1042 {
1043   int r;
1044   const char *path;
1045   if (argc != 1) {
1046     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1047     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1048     return -1;
1049   }
1050   path = argv[0];
1051   r = guestfs_rmdir (g, path);
1052   return r;
1053 }
1054
1055 static int run_rm_rf (const char *cmd, int argc, char *argv[])
1056 {
1057   int r;
1058   const char *path;
1059   if (argc != 1) {
1060     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1061     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1062     return -1;
1063   }
1064   path = argv[0];
1065   r = guestfs_rm_rf (g, path);
1066   return r;
1067 }
1068
1069 static int run_mkdir (const char *cmd, int argc, char *argv[])
1070 {
1071   int r;
1072   const char *path;
1073   if (argc != 1) {
1074     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1075     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1076     return -1;
1077   }
1078   path = argv[0];
1079   r = guestfs_mkdir (g, path);
1080   return r;
1081 }
1082
1083 static int run_mkdir_p (const char *cmd, int argc, char *argv[])
1084 {
1085   int r;
1086   const char *path;
1087   if (argc != 1) {
1088     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1089     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1090     return -1;
1091   }
1092   path = argv[0];
1093   r = guestfs_mkdir_p (g, path);
1094   return r;
1095 }
1096
1097 static int run_chmod (const char *cmd, int argc, char *argv[])
1098 {
1099   int r;
1100   int mode;
1101   const char *path;
1102   if (argc != 2) {
1103     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
1104     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1105     return -1;
1106   }
1107   mode = atoi (argv[0]);
1108   path = argv[1];
1109   r = guestfs_chmod (g, mode, path);
1110   return r;
1111 }
1112
1113 static int run_chown (const char *cmd, int argc, char *argv[])
1114 {
1115   int r;
1116   int owner;
1117   int group;
1118   const char *path;
1119   if (argc != 3) {
1120     fprintf (stderr, "%s should have 3 parameter(s)\n", cmd);
1121     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1122     return -1;
1123   }
1124   owner = atoi (argv[0]);
1125   group = atoi (argv[1]);
1126   path = argv[2];
1127   r = guestfs_chown (g, owner, group, path);
1128   return r;
1129 }
1130
1131 static int run_exists (const char *cmd, int argc, char *argv[])
1132 {
1133   int r;
1134   const char *path;
1135   if (argc != 1) {
1136     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1137     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1138     return -1;
1139   }
1140   path = argv[0];
1141   r = guestfs_exists (g, path);
1142   if (r == -1) return -1;
1143   if (r) printf ("true\n"); else printf ("false\n");
1144   return 0;
1145 }
1146
1147 static int run_is_file (const char *cmd, int argc, char *argv[])
1148 {
1149   int r;
1150   const char *path;
1151   if (argc != 1) {
1152     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1153     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1154     return -1;
1155   }
1156   path = argv[0];
1157   r = guestfs_is_file (g, path);
1158   if (r == -1) return -1;
1159   if (r) printf ("true\n"); else printf ("false\n");
1160   return 0;
1161 }
1162
1163 static int run_is_dir (const char *cmd, int argc, char *argv[])
1164 {
1165   int r;
1166   const char *path;
1167   if (argc != 1) {
1168     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1169     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1170     return -1;
1171   }
1172   path = argv[0];
1173   r = guestfs_is_dir (g, path);
1174   if (r == -1) return -1;
1175   if (r) printf ("true\n"); else printf ("false\n");
1176   return 0;
1177 }
1178
1179 static int run_pvcreate (const char *cmd, int argc, char *argv[])
1180 {
1181   int r;
1182   const char *device;
1183   if (argc != 1) {
1184     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1185     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1186     return -1;
1187   }
1188   device = argv[0];
1189   r = guestfs_pvcreate (g, device);
1190   return r;
1191 }
1192
1193 static int run_vgcreate (const char *cmd, int argc, char *argv[])
1194 {
1195   int r;
1196   const char *volgroup;
1197   char **physvols;
1198   if (argc != 2) {
1199     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
1200     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1201     return -1;
1202   }
1203   volgroup = argv[0];
1204   physvols = parse_string_list (argv[1]);
1205   r = guestfs_vgcreate (g, volgroup, physvols);
1206   return r;
1207 }
1208
1209 static int run_lvcreate (const char *cmd, int argc, char *argv[])
1210 {
1211   int r;
1212   const char *logvol;
1213   const char *volgroup;
1214   int mbytes;
1215   if (argc != 3) {
1216     fprintf (stderr, "%s should have 3 parameter(s)\n", cmd);
1217     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1218     return -1;
1219   }
1220   logvol = argv[0];
1221   volgroup = argv[1];
1222   mbytes = atoi (argv[2]);
1223   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1224   return r;
1225 }
1226
1227 static int run_mkfs (const char *cmd, int argc, char *argv[])
1228 {
1229   int r;
1230   const char *fstype;
1231   const char *device;
1232   if (argc != 2) {
1233     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
1234     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1235     return -1;
1236   }
1237   fstype = argv[0];
1238   device = argv[1];
1239   r = guestfs_mkfs (g, fstype, device);
1240   return r;
1241 }
1242
1243 static int run_sfdisk (const char *cmd, int argc, char *argv[])
1244 {
1245   int r;
1246   const char *device;
1247   int cyls;
1248   int heads;
1249   int sectors;
1250   char **lines;
1251   if (argc != 5) {
1252     fprintf (stderr, "%s should have 5 parameter(s)\n", cmd);
1253     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1254     return -1;
1255   }
1256   device = argv[0];
1257   cyls = atoi (argv[1]);
1258   heads = atoi (argv[2]);
1259   sectors = atoi (argv[3]);
1260   lines = parse_string_list (argv[4]);
1261   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1262   return r;
1263 }
1264
1265 static int run_write_file (const char *cmd, int argc, char *argv[])
1266 {
1267   int r;
1268   const char *path;
1269   const char *content;
1270   int size;
1271   if (argc != 3) {
1272     fprintf (stderr, "%s should have 3 parameter(s)\n", cmd);
1273     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1274     return -1;
1275   }
1276   path = argv[0];
1277   content = argv[1];
1278   size = atoi (argv[2]);
1279   r = guestfs_write_file (g, path, content, size);
1280   return r;
1281 }
1282
1283 static int run_umount (const char *cmd, int argc, char *argv[])
1284 {
1285   int r;
1286   const char *pathordevice;
1287   if (argc != 1) {
1288     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1289     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1290     return -1;
1291   }
1292   pathordevice = argv[0];
1293   r = guestfs_umount (g, pathordevice);
1294   return r;
1295 }
1296
1297 static int run_mounts (const char *cmd, int argc, char *argv[])
1298 {
1299   char **r;
1300   if (argc != 0) {
1301     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
1302     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1303     return -1;
1304   }
1305   r = guestfs_mounts (g);
1306   if (r == NULL) return -1;
1307   print_strings (r);
1308   free_strings (r);
1309   return 0;
1310 }
1311
1312 static int run_umount_all (const char *cmd, int argc, char *argv[])
1313 {
1314   int r;
1315   if (argc != 0) {
1316     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
1317     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1318     return -1;
1319   }
1320   r = guestfs_umount_all (g);
1321   return r;
1322 }
1323
1324 static int run_lvm_remove_all (const char *cmd, int argc, char *argv[])
1325 {
1326   int r;
1327   if (argc != 0) {
1328     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
1329     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1330     return -1;
1331   }
1332   r = guestfs_lvm_remove_all (g);
1333   return r;
1334 }
1335
1336 static int run_file (const char *cmd, int argc, char *argv[])
1337 {
1338   char *r;
1339   const char *path;
1340   if (argc != 1) {
1341     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1342     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1343     return -1;
1344   }
1345   path = argv[0];
1346   r = guestfs_file (g, path);
1347   if (r == NULL) return -1;
1348   printf ("%s\n", r);
1349   free (r);
1350   return 0;
1351 }
1352
1353 static int run_command (const char *cmd, int argc, char *argv[])
1354 {
1355   char *r;
1356   char **arguments;
1357   if (argc != 1) {
1358     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1359     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1360     return -1;
1361   }
1362   arguments = parse_string_list (argv[0]);
1363   r = guestfs_command (g, arguments);
1364   if (r == NULL) return -1;
1365   printf ("%s\n", r);
1366   free (r);
1367   return 0;
1368 }
1369
1370 static int run_command_lines (const char *cmd, int argc, char *argv[])
1371 {
1372   char **r;
1373   char **arguments;
1374   if (argc != 1) {
1375     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1376     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1377     return -1;
1378   }
1379   arguments = parse_string_list (argv[0]);
1380   r = guestfs_command_lines (g, arguments);
1381   if (r == NULL) return -1;
1382   print_strings (r);
1383   free_strings (r);
1384   return 0;
1385 }
1386
1387 static int run_stat (const char *cmd, int argc, char *argv[])
1388 {
1389   struct guestfs_stat *r;
1390   const char *path;
1391   if (argc != 1) {
1392     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1393     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1394     return -1;
1395   }
1396   path = argv[0];
1397   r = guestfs_stat (g, path);
1398   if (r == NULL) return -1;
1399   print_stat (r);
1400   free (r);
1401   return 0;
1402 }
1403
1404 static int run_lstat (const char *cmd, int argc, char *argv[])
1405 {
1406   struct guestfs_stat *r;
1407   const char *path;
1408   if (argc != 1) {
1409     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1410     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1411     return -1;
1412   }
1413   path = argv[0];
1414   r = guestfs_lstat (g, path);
1415   if (r == NULL) return -1;
1416   print_stat (r);
1417   free (r);
1418   return 0;
1419 }
1420
1421 static int run_statvfs (const char *cmd, int argc, char *argv[])
1422 {
1423   struct guestfs_statvfs *r;
1424   const char *path;
1425   if (argc != 1) {
1426     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1427     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1428     return -1;
1429   }
1430   path = argv[0];
1431   r = guestfs_statvfs (g, path);
1432   if (r == NULL) return -1;
1433   print_statvfs (r);
1434   free (r);
1435   return 0;
1436 }
1437
1438 int run_action (const char *cmd, int argc, char *argv[])
1439 {
1440   if (strcasecmp (cmd, "launch") == 0 || strcasecmp (cmd, "run") == 0)
1441     return run_launch (cmd, argc, argv);
1442   else
1443   if (strcasecmp (cmd, "kill_subprocess") == 0 || strcasecmp (cmd, "kill-subprocess") == 0)
1444     return run_kill_subprocess (cmd, argc, argv);
1445   else
1446   if (strcasecmp (cmd, "add_drive") == 0 || strcasecmp (cmd, "add-drive") == 0 || strcasecmp (cmd, "add") == 0)
1447     return run_add_drive (cmd, argc, argv);
1448   else
1449   if (strcasecmp (cmd, "add_cdrom") == 0 || strcasecmp (cmd, "add-cdrom") == 0 || strcasecmp (cmd, "cdrom") == 0)
1450     return run_add_cdrom (cmd, argc, argv);
1451   else
1452   if (strcasecmp (cmd, "config") == 0)
1453     return run_config (cmd, argc, argv);
1454   else
1455   if (strcasecmp (cmd, "set_path") == 0 || strcasecmp (cmd, "set-path") == 0 || strcasecmp (cmd, "path") == 0)
1456     return run_set_path (cmd, argc, argv);
1457   else
1458   if (strcasecmp (cmd, "get_path") == 0 || strcasecmp (cmd, "get-path") == 0)
1459     return run_get_path (cmd, argc, argv);
1460   else
1461   if (strcasecmp (cmd, "set_autosync") == 0 || strcasecmp (cmd, "set-autosync") == 0 || strcasecmp (cmd, "autosync") == 0)
1462     return run_set_autosync (cmd, argc, argv);
1463   else
1464   if (strcasecmp (cmd, "get_autosync") == 0 || strcasecmp (cmd, "get-autosync") == 0)
1465     return run_get_autosync (cmd, argc, argv);
1466   else
1467   if (strcasecmp (cmd, "set_verbose") == 0 || strcasecmp (cmd, "set-verbose") == 0 || strcasecmp (cmd, "verbose") == 0)
1468     return run_set_verbose (cmd, argc, argv);
1469   else
1470   if (strcasecmp (cmd, "get_verbose") == 0 || strcasecmp (cmd, "get-verbose") == 0)
1471     return run_get_verbose (cmd, argc, argv);
1472   else
1473   if (strcasecmp (cmd, "mount") == 0)
1474     return run_mount (cmd, argc, argv);
1475   else
1476   if (strcasecmp (cmd, "sync") == 0)
1477     return run_sync (cmd, argc, argv);
1478   else
1479   if (strcasecmp (cmd, "touch") == 0)
1480     return run_touch (cmd, argc, argv);
1481   else
1482   if (strcasecmp (cmd, "cat") == 0)
1483     return run_cat (cmd, argc, argv);
1484   else
1485   if (strcasecmp (cmd, "ll") == 0)
1486     return run_ll (cmd, argc, argv);
1487   else
1488   if (strcasecmp (cmd, "ls") == 0)
1489     return run_ls (cmd, argc, argv);
1490   else
1491   if (strcasecmp (cmd, "list_devices") == 0 || strcasecmp (cmd, "list-devices") == 0)
1492     return run_list_devices (cmd, argc, argv);
1493   else
1494   if (strcasecmp (cmd, "list_partitions") == 0 || strcasecmp (cmd, "list-partitions") == 0)
1495     return run_list_partitions (cmd, argc, argv);
1496   else
1497   if (strcasecmp (cmd, "pvs") == 0)
1498     return run_pvs (cmd, argc, argv);
1499   else
1500   if (strcasecmp (cmd, "vgs") == 0)
1501     return run_vgs (cmd, argc, argv);
1502   else
1503   if (strcasecmp (cmd, "lvs") == 0)
1504     return run_lvs (cmd, argc, argv);
1505   else
1506   if (strcasecmp (cmd, "pvs_full") == 0 || strcasecmp (cmd, "pvs-full") == 0)
1507     return run_pvs_full (cmd, argc, argv);
1508   else
1509   if (strcasecmp (cmd, "vgs_full") == 0 || strcasecmp (cmd, "vgs-full") == 0)
1510     return run_vgs_full (cmd, argc, argv);
1511   else
1512   if (strcasecmp (cmd, "lvs_full") == 0 || strcasecmp (cmd, "lvs-full") == 0)
1513     return run_lvs_full (cmd, argc, argv);
1514   else
1515   if (strcasecmp (cmd, "read_lines") == 0 || strcasecmp (cmd, "read-lines") == 0)
1516     return run_read_lines (cmd, argc, argv);
1517   else
1518   if (strcasecmp (cmd, "aug_init") == 0 || strcasecmp (cmd, "aug-init") == 0)
1519     return run_aug_init (cmd, argc, argv);
1520   else
1521   if (strcasecmp (cmd, "aug_close") == 0 || strcasecmp (cmd, "aug-close") == 0)
1522     return run_aug_close (cmd, argc, argv);
1523   else
1524   if (strcasecmp (cmd, "aug_defvar") == 0 || strcasecmp (cmd, "aug-defvar") == 0)
1525     return run_aug_defvar (cmd, argc, argv);
1526   else
1527   if (strcasecmp (cmd, "aug_defnode") == 0 || strcasecmp (cmd, "aug-defnode") == 0)
1528     return run_aug_defnode (cmd, argc, argv);
1529   else
1530   if (strcasecmp (cmd, "aug_get") == 0 || strcasecmp (cmd, "aug-get") == 0)
1531     return run_aug_get (cmd, argc, argv);
1532   else
1533   if (strcasecmp (cmd, "aug_set") == 0 || strcasecmp (cmd, "aug-set") == 0)
1534     return run_aug_set (cmd, argc, argv);
1535   else
1536   if (strcasecmp (cmd, "aug_insert") == 0 || strcasecmp (cmd, "aug-insert") == 0)
1537     return run_aug_insert (cmd, argc, argv);
1538   else
1539   if (strcasecmp (cmd, "aug_rm") == 0 || strcasecmp (cmd, "aug-rm") == 0)
1540     return run_aug_rm (cmd, argc, argv);
1541   else
1542   if (strcasecmp (cmd, "aug_mv") == 0 || strcasecmp (cmd, "aug-mv") == 0)
1543     return run_aug_mv (cmd, argc, argv);
1544   else
1545   if (strcasecmp (cmd, "aug_match") == 0 || strcasecmp (cmd, "aug-match") == 0)
1546     return run_aug_match (cmd, argc, argv);
1547   else
1548   if (strcasecmp (cmd, "aug_save") == 0 || strcasecmp (cmd, "aug-save") == 0)
1549     return run_aug_save (cmd, argc, argv);
1550   else
1551   if (strcasecmp (cmd, "aug_load") == 0 || strcasecmp (cmd, "aug-load") == 0)
1552     return run_aug_load (cmd, argc, argv);
1553   else
1554   if (strcasecmp (cmd, "aug_ls") == 0 || strcasecmp (cmd, "aug-ls") == 0)
1555     return run_aug_ls (cmd, argc, argv);
1556   else
1557   if (strcasecmp (cmd, "rm") == 0)
1558     return run_rm (cmd, argc, argv);
1559   else
1560   if (strcasecmp (cmd, "rmdir") == 0)
1561     return run_rmdir (cmd, argc, argv);
1562   else
1563   if (strcasecmp (cmd, "rm_rf") == 0 || strcasecmp (cmd, "rm-rf") == 0)
1564     return run_rm_rf (cmd, argc, argv);
1565   else
1566   if (strcasecmp (cmd, "mkdir") == 0)
1567     return run_mkdir (cmd, argc, argv);
1568   else
1569   if (strcasecmp (cmd, "mkdir_p") == 0 || strcasecmp (cmd, "mkdir-p") == 0)
1570     return run_mkdir_p (cmd, argc, argv);
1571   else
1572   if (strcasecmp (cmd, "chmod") == 0)
1573     return run_chmod (cmd, argc, argv);
1574   else
1575   if (strcasecmp (cmd, "chown") == 0)
1576     return run_chown (cmd, argc, argv);
1577   else
1578   if (strcasecmp (cmd, "exists") == 0)
1579     return run_exists (cmd, argc, argv);
1580   else
1581   if (strcasecmp (cmd, "is_file") == 0 || strcasecmp (cmd, "is-file") == 0)
1582     return run_is_file (cmd, argc, argv);
1583   else
1584   if (strcasecmp (cmd, "is_dir") == 0 || strcasecmp (cmd, "is-dir") == 0)
1585     return run_is_dir (cmd, argc, argv);
1586   else
1587   if (strcasecmp (cmd, "pvcreate") == 0)
1588     return run_pvcreate (cmd, argc, argv);
1589   else
1590   if (strcasecmp (cmd, "vgcreate") == 0)
1591     return run_vgcreate (cmd, argc, argv);
1592   else
1593   if (strcasecmp (cmd, "lvcreate") == 0)
1594     return run_lvcreate (cmd, argc, argv);
1595   else
1596   if (strcasecmp (cmd, "mkfs") == 0)
1597     return run_mkfs (cmd, argc, argv);
1598   else
1599   if (strcasecmp (cmd, "sfdisk") == 0)
1600     return run_sfdisk (cmd, argc, argv);
1601   else
1602   if (strcasecmp (cmd, "write_file") == 0 || strcasecmp (cmd, "write-file") == 0)
1603     return run_write_file (cmd, argc, argv);
1604   else
1605   if (strcasecmp (cmd, "umount") == 0 || strcasecmp (cmd, "unmount") == 0)
1606     return run_umount (cmd, argc, argv);
1607   else
1608   if (strcasecmp (cmd, "mounts") == 0)
1609     return run_mounts (cmd, argc, argv);
1610   else
1611   if (strcasecmp (cmd, "umount_all") == 0 || strcasecmp (cmd, "umount-all") == 0 || strcasecmp (cmd, "unmount-all") == 0)
1612     return run_umount_all (cmd, argc, argv);
1613   else
1614   if (strcasecmp (cmd, "lvm_remove_all") == 0 || strcasecmp (cmd, "lvm-remove-all") == 0)
1615     return run_lvm_remove_all (cmd, argc, argv);
1616   else
1617   if (strcasecmp (cmd, "file") == 0)
1618     return run_file (cmd, argc, argv);
1619   else
1620   if (strcasecmp (cmd, "command") == 0)
1621     return run_command (cmd, argc, argv);
1622   else
1623   if (strcasecmp (cmd, "command_lines") == 0 || strcasecmp (cmd, "command-lines") == 0)
1624     return run_command_lines (cmd, argc, argv);
1625   else
1626   if (strcasecmp (cmd, "stat") == 0)
1627     return run_stat (cmd, argc, argv);
1628   else
1629   if (strcasecmp (cmd, "lstat") == 0)
1630     return run_lstat (cmd, argc, argv);
1631   else
1632   if (strcasecmp (cmd, "statvfs") == 0)
1633     return run_statvfs (cmd, argc, argv);
1634   else
1635     {
1636       fprintf (stderr, "%s: unknown command\n", cmd);
1637       return -1;
1638     }
1639   return 0;
1640 }
1641