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", "tune2fs-l", "get ext2/ext3 superblock details");
  94   printf ("%-20s %s\n", "umount", "unmount a filesystem");
  95   printf ("%-20s %s\n", "umount-all", "unmount all filesystems");
  96   printf ("%-20s %s\n", "vgcreate", "create an LVM volume group");
  97   printf ("%-20s %s\n", "vgs", "list the LVM volume groups (VGs)");
  98   printf ("%-20s %s\n", "vgs-full", "list the LVM volume groups (VGs)");
  99   printf ("%-20s %s\n", "write-file", "create a file");
 100   printf ("    Use -h <cmd> / help <cmd> to show detailed help for a command.\n");
 101 }
 102
 103 void display_command (const char *cmd)
 104 {
 105   if (strcasecmp (cmd, "launch") == 0 || strcasecmp (cmd, "run") == 0)
 106     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.");
 107   else
 108   if (strcasecmp (cmd, "kill_subprocess") == 0 || strcasecmp (cmd, "kill-subprocess") == 0)
 109     pod2text ("kill-subprocess - kill the qemu subprocess", " kill-subprocess\n\nThis kills the qemu subprocess.  You should never need to call this.");
 110   else
 111   if (strcasecmp (cmd, "add_drive") == 0 || strcasecmp (cmd, "add-drive") == 0 || strcasecmp (cmd, "add") == 0)
 112     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.");
 113   else
 114   if (strcasecmp (cmd, "add_cdrom") == 0 || strcasecmp (cmd, "add-cdrom") == 0 || strcasecmp (cmd, "cdrom") == 0)
 115     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.");
 116   else
 117   if (strcasecmp (cmd, "config") == 0)
 118     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.");
 119   else
 120   if (strcasecmp (cmd, "set_path") == 0 || strcasecmp (cmd, "set-path") == 0 || strcasecmp (cmd, "path") == 0)
 121     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.");
 122   else
 123   if (strcasecmp (cmd, "get_path") == 0 || strcasecmp (cmd, "get-path") == 0)
 124     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.");
 125   else
 126   if (strcasecmp (cmd, "set_autosync") == 0 || strcasecmp (cmd, "set-autosync") == 0 || strcasecmp (cmd, "autosync") == 0)
 127     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.");
 128   else
 129   if (strcasecmp (cmd, "get_autosync") == 0 || strcasecmp (cmd, "get-autosync") == 0)
 130     pod2text ("get-autosync - get autosync mode", " get-autosync\n\nGet the autosync flag.");
 131   else
 132   if (strcasecmp (cmd, "set_verbose") == 0 || strcasecmp (cmd, "set-verbose") == 0 || strcasecmp (cmd, "verbose") == 0)
 133     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.");
 134   else
 135   if (strcasecmp (cmd, "get_verbose") == 0 || strcasecmp (cmd, "get-verbose") == 0)
 136     pod2text ("get-verbose - get verbose mode", " get-verbose\n\nThis returns the verbose messages flag.");
 137   else
 138   if (strcasecmp (cmd, "mount") == 0)
 139     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.");
 140   else
 141   if (strcasecmp (cmd, "sync") == 0)
 142     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.");
 143   else
 144   if (strcasecmp (cmd, "touch") == 0)
 145     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.");
 146   else
 147   if (strcasecmp (cmd, "cat") == 0)
 148     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.");
 149   else
 150   if (strcasecmp (cmd, "ll") == 0)
 151     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.");
 152   else
 153   if (strcasecmp (cmd, "ls") == 0)
 154     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.");
 155   else
 156   if (strcasecmp (cmd, "list_devices") == 0 || strcasecmp (cmd, "list-devices") == 0)
 157     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>");
 158   else
 159   if (strcasecmp (cmd, "list_partitions") == 0 || strcasecmp (cmd, "list-partitions") == 0)
 160     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>.");
 161   else
 162   if (strcasecmp (cmd, "pvs") == 0)
 163     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>.");
 164   else
 165   if (strcasecmp (cmd, "vgs") == 0)
 166     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>.");
 167   else
 168   if (strcasecmp (cmd, "lvs") == 0)
 169     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>.");
 170   else
 171   if (strcasecmp (cmd, "pvs_full") == 0 || strcasecmp (cmd, "pvs-full") == 0)
 172     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.");
 173   else
 174   if (strcasecmp (cmd, "vgs_full") == 0 || strcasecmp (cmd, "vgs-full") == 0)
 175     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.");
 176   else
 177   if (strcasecmp (cmd, "lvs_full") == 0 || strcasecmp (cmd, "lvs-full") == 0)
 178     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.");
 179   else
 180   if (strcasecmp (cmd, "read_lines") == 0 || strcasecmp (cmd, "read-lines") == 0)
 181     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.");
 182   else
 183   if (strcasecmp (cmd, "aug_init") == 0 || strcasecmp (cmd, "aug-init") == 0)
 184     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/>.");
 185   else
 186   if (strcasecmp (cmd, "aug_close") == 0 || strcasecmp (cmd, "aug-close") == 0)
 187     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.");
 188   else
 189   if (strcasecmp (cmd, "aug_defvar") == 0 || strcasecmp (cmd, "aug-defvar") == 0)
 190     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.");
 191   else
 192   if (strcasecmp (cmd, "aug_defnode") == 0 || strcasecmp (cmd, "aug-defnode") == 0)
 193     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.");
 194   else
 195   if (strcasecmp (cmd, "aug_get") == 0 || strcasecmp (cmd, "aug-get") == 0)
 196     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.");
 197   else
 198   if (strcasecmp (cmd, "aug_set") == 0 || strcasecmp (cmd, "aug-set") == 0)
 199     pod2text ("aug-set - set Augeas path to value", " aug-set <path> <val>\n\nSet the value associated with C<path> to C<value>.");
 200   else
 201   if (strcasecmp (cmd, "aug_insert") == 0 || strcasecmp (cmd, "aug-insert") == 0)
 202     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]>.");
 203   else
 204   if (strcasecmp (cmd, "aug_rm") == 0 || strcasecmp (cmd, "aug-rm") == 0)
 205     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.");
 206   else
 207   if (strcasecmp (cmd, "aug_mv") == 0 || strcasecmp (cmd, "aug-mv") == 0)
 208     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.");
 209   else
 210   if (strcasecmp (cmd, "aug_match") == 0 || strcasecmp (cmd, "aug-match") == 0)
 211     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.");
 212   else
 213   if (strcasecmp (cmd, "aug_save") == 0 || strcasecmp (cmd, "aug-save") == 0)
 214     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.");
 215   else
 216   if (strcasecmp (cmd, "aug_load") == 0 || strcasecmp (cmd, "aug-load") == 0)
 217     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.");
 218   else
 219   if (strcasecmp (cmd, "aug_ls") == 0 || strcasecmp (cmd, "aug-ls") == 0)
 220     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.");
 221   else
 222   if (strcasecmp (cmd, "rm") == 0)
 223     pod2text ("rm - remove a file", " rm <path>\n\nRemove the single file C<path>.");
 224   else
 225   if (strcasecmp (cmd, "rmdir") == 0)
 226     pod2text ("rmdir - remove a directory", " rmdir <path>\n\nRemove the single directory C<path>.");
 227   else
 228   if (strcasecmp (cmd, "rm_rf") == 0 || strcasecmp (cmd, "rm-rf") == 0)
 229     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.");
 230   else
 231   if (strcasecmp (cmd, "mkdir") == 0)
 232     pod2text ("mkdir - create a directory", " mkdir <path>\n\nCreate a directory named C<path>.");
 233   else
 234   if (strcasecmp (cmd, "mkdir_p") == 0 || strcasecmp (cmd, "mkdir-p") == 0)
 235     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.");
 236   else
 237   if (strcasecmp (cmd, "chmod") == 0)
 238     pod2text ("chmod - change file mode", " chmod <mode> <path>\n\nChange the mode (permissions) of C<path> to C<mode>.  Only\nnumeric modes are supported.");
 239   else
 240   if (strcasecmp (cmd, "chown") == 0)
 241     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).");
 242   else
 243   if (strcasecmp (cmd, "exists") == 0)
 244     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>.");
 245   else
 246   if (strcasecmp (cmd, "is_file") == 0 || strcasecmp (cmd, "is-file") == 0)
 247     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>.");
 248   else
 249   if (strcasecmp (cmd, "is_dir") == 0 || strcasecmp (cmd, "is-dir") == 0)
 250     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>.");
 251   else
 252   if (strcasecmp (cmd, "pvcreate") == 0)
 253     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>.");
 254   else
 255   if (strcasecmp (cmd, "vgcreate") == 0)
 256     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>.");
 257   else
 258   if (strcasecmp (cmd, "lvcreate") == 0)
 259     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.");
 260   else
 261   if (strcasecmp (cmd, "mkfs") == 0)
 262     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>.");
 263   else
 264   if (strcasecmp (cmd, "sfdisk") == 0)
 265     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>.");
 266   else
 267   if (strcasecmp (cmd, "write_file") == 0 || strcasecmp (cmd, "write-file") == 0)
 268     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.");
 269   else
 270   if (strcasecmp (cmd, "umount") == 0 || strcasecmp (cmd, "unmount") == 0)
 271     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.");
 272   else
 273   if (strcasecmp (cmd, "mounts") == 0)
 274     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.");
 275   else
 276   if (strcasecmp (cmd, "umount_all") == 0 || strcasecmp (cmd, "umount-all") == 0 || strcasecmp (cmd, "unmount-all") == 0)
 277     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.");
 278   else
 279   if (strcasecmp (cmd, "lvm_remove_all") == 0 || strcasecmp (cmd, "lvm-remove-all") == 0)
 280     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>.");
 281   else
 282   if (strcasecmp (cmd, "file") == 0)
 283     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).");
 284   else
 285   if (strcasecmp (cmd, "command") == 0)
 286     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.");
 287   else
 288   if (strcasecmp (cmd, "command_lines") == 0 || strcasecmp (cmd, "command-lines") == 0)
 289     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.");
 290   else
 291   if (strcasecmp (cmd, "stat") == 0)
 292     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.");
 293   else
 294   if (strcasecmp (cmd, "lstat") == 0)
 295     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.");
 296   else
 297   if (strcasecmp (cmd, "statvfs") == 0)
 298     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.");
 299   else
 300   if (strcasecmp (cmd, "tune2fs_l") == 0 || strcasecmp (cmd, "tune2fs-l") == 0)
 301     pod2text ("tune2fs-l - get ext2/ext3 superblock details", " tune2fs-l <device>\n\nThis returns the contents of the ext2 or ext3 filesystem superblock\non C<device>.\n\nIt is the same as running C<tune2fs -l device>.  See L<tune2fs(8)>\nmanpage for more details.  The list of fields returned isn't\nclearly defined, and depends on both the version of C<tune2fs>\nthat libguestfs was built against, and the filesystem itself.");
 302   else
 303     display_builtin_command (cmd);
 304 }
 305
 306 static void print_pv (struct guestfs_lvm_pv *pv)
 307 {
 308   int i;
 309
 310   printf ("pv_name: %s\n", pv->pv_name);
 311   printf ("pv_uuid: ");
 312   for (i = 0; i < 32; ++i)
 313     printf ("%c", pv->pv_uuid[i]);
 314   printf ("\n");
 315   printf ("pv_fmt: %s\n", pv->pv_fmt);
 316   printf ("pv_size: %" PRIu64 "\n", pv->pv_size);
 317   printf ("dev_size: %" PRIu64 "\n", pv->dev_size);
 318   printf ("pv_free: %" PRIu64 "\n", pv->pv_free);
 319   printf ("pv_used: %" PRIu64 "\n", pv->pv_used);
 320   printf ("pv_attr: %s\n", pv->pv_attr);
 321   printf ("pv_pe_count: %" PRIi64 "\n", pv->pv_pe_count);
 322   printf ("pv_pe_alloc_count: %" PRIi64 "\n", pv->pv_pe_alloc_count);
 323   printf ("pv_tags: %s\n", pv->pv_tags);
 324   printf ("pe_start: %" PRIu64 "\n", pv->pe_start);
 325   printf ("pv_mda_count: %" PRIi64 "\n", pv->pv_mda_count);
 326   printf ("pv_mda_free: %" PRIu64 "\n", pv->pv_mda_free);
 327 }
 328
 329 static void print_pv_list (struct guestfs_lvm_pv_list *pvs)
 330 {
 331   int i;
 332
 333   for (i = 0; i < pvs->len; ++i)
 334     print_pv (&pvs->val[i]);
 335 }
 336
 337 static void print_vg (struct guestfs_lvm_vg *vg)
 338 {
 339   int i;
 340
 341   printf ("vg_name: %s\n", vg->vg_name);
 342   printf ("vg_uuid: ");
 343   for (i = 0; i < 32; ++i)
 344     printf ("%c", vg->vg_uuid[i]);
 345   printf ("\n");
 346   printf ("vg_fmt: %s\n", vg->vg_fmt);
 347   printf ("vg_attr: %s\n", vg->vg_attr);
 348   printf ("vg_size: %" PRIu64 "\n", vg->vg_size);
 349   printf ("vg_free: %" PRIu64 "\n", vg->vg_free);
 350   printf ("vg_sysid: %s\n", vg->vg_sysid);
 351   printf ("vg_extent_size: %" PRIu64 "\n", vg->vg_extent_size);
 352   printf ("vg_extent_count: %" PRIi64 "\n", vg->vg_extent_count);
 353   printf ("vg_free_count: %" PRIi64 "\n", vg->vg_free_count);
 354   printf ("max_lv: %" PRIi64 "\n", vg->max_lv);
 355   printf ("max_pv: %" PRIi64 "\n", vg->max_pv);
 356   printf ("pv_count: %" PRIi64 "\n", vg->pv_count);
 357   printf ("lv_count: %" PRIi64 "\n", vg->lv_count);
 358   printf ("snap_count: %" PRIi64 "\n", vg->snap_count);
 359   printf ("vg_seqno: %" PRIi64 "\n", vg->vg_seqno);
 360   printf ("vg_tags: %s\n", vg->vg_tags);
 361   printf ("vg_mda_count: %" PRIi64 "\n", vg->vg_mda_count);
 362   printf ("vg_mda_free: %" PRIu64 "\n", vg->vg_mda_free);
 363 }
 364
 365 static void print_vg_list (struct guestfs_lvm_vg_list *vgs)
 366 {
 367   int i;
 368
 369   for (i = 0; i < vgs->len; ++i)
 370     print_vg (&vgs->val[i]);
 371 }
 372
 373 static void print_lv (struct guestfs_lvm_lv *lv)
 374 {
 375   int i;
 376
 377   printf ("lv_name: %s\n", lv->lv_name);
 378   printf ("lv_uuid: ");
 379   for (i = 0; i < 32; ++i)
 380     printf ("%c", lv->lv_uuid[i]);
 381   printf ("\n");
 382   printf ("lv_attr: %s\n", lv->lv_attr);
 383   printf ("lv_major: %" PRIi64 "\n", lv->lv_major);
 384   printf ("lv_minor: %" PRIi64 "\n", lv->lv_minor);
 385   printf ("lv_kernel_major: %" PRIi64 "\n", lv->lv_kernel_major);
 386   printf ("lv_kernel_minor: %" PRIi64 "\n", lv->lv_kernel_minor);
 387   printf ("lv_size: %" PRIu64 "\n", lv->lv_size);
 388   printf ("seg_count: %" PRIi64 "\n", lv->seg_count);
 389   printf ("origin: %s\n", lv->origin);
 390   if (lv->snap_percent >= 0) printf ("snap_percent: %g %%\n", lv->snap_percent);
 391   else printf ("snap_percent: \n");
 392   if (lv->copy_percent >= 0) printf ("copy_percent: %g %%\n", lv->copy_percent);
 393   else printf ("copy_percent: \n");
 394   printf ("move_pv: %s\n", lv->move_pv);
 395   printf ("lv_tags: %s\n", lv->lv_tags);
 396   printf ("mirror_log: %s\n", lv->mirror_log);
 397   printf ("modules: %s\n", lv->modules);
 398 }
 399
 400 static void print_lv_list (struct guestfs_lvm_lv_list *lvs)
 401 {
 402   int i;
 403
 404   for (i = 0; i < lvs->len; ++i)
 405     print_lv (&lvs->val[i]);
 406 }
 407
 408 static void print_stat (struct guestfs_stat *stat)
 409 {
 410   printf ("dev: %" PRIi64 "\n", stat->dev);
 411   printf ("ino: %" PRIi64 "\n", stat->ino);
 412   printf ("mode: %" PRIi64 "\n", stat->mode);
 413   printf ("nlink: %" PRIi64 "\n", stat->nlink);
 414   printf ("uid: %" PRIi64 "\n", stat->uid);
 415   printf ("gid: %" PRIi64 "\n", stat->gid);
 416   printf ("rdev: %" PRIi64 "\n", stat->rdev);
 417   printf ("size: %" PRIi64 "\n", stat->size);
 418   printf ("blksize: %" PRIi64 "\n", stat->blksize);
 419   printf ("blocks: %" PRIi64 "\n", stat->blocks);
 420   printf ("atime: %" PRIi64 "\n", stat->atime);
 421   printf ("mtime: %" PRIi64 "\n", stat->mtime);
 422   printf ("ctime: %" PRIi64 "\n", stat->ctime);
 423 }
 424
 425 static void print_statvfs (struct guestfs_statvfs *statvfs)
 426 {
 427   printf ("bsize: %" PRIi64 "\n", statvfs->bsize);
 428   printf ("frsize: %" PRIi64 "\n", statvfs->frsize);
 429   printf ("blocks: %" PRIi64 "\n", statvfs->blocks);
 430   printf ("bfree: %" PRIi64 "\n", statvfs->bfree);
 431   printf ("bavail: %" PRIi64 "\n", statvfs->bavail);
 432   printf ("files: %" PRIi64 "\n", statvfs->files);
 433   printf ("ffree: %" PRIi64 "\n", statvfs->ffree);
 434   printf ("favail: %" PRIi64 "\n", statvfs->favail);
 435   printf ("fsid: %" PRIi64 "\n", statvfs->fsid);
 436   printf ("flag: %" PRIi64 "\n", statvfs->flag);
 437   printf ("namemax: %" PRIi64 "\n", statvfs->namemax);
 438 }
 439
 440 static int run_launch (const char *cmd, int argc, char *argv[])
 441 {
 442   int r;
 443   if (argc != 0) {
 444     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 445     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 446     return -1;
 447   }
 448   r = launch (g);
 449   return r;
 450 }
 451
 452 static int run_kill_subprocess (const char *cmd, int argc, char *argv[])
 453 {
 454   int r;
 455   if (argc != 0) {
 456     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 457     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 458     return -1;
 459   }
 460   r = guestfs_kill_subprocess (g);
 461   return r;
 462 }
 463
 464 static int run_add_drive (const char *cmd, int argc, char *argv[])
 465 {
 466   int r;
 467   const char *filename;
 468   if (argc != 1) {
 469     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 470     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 471     return -1;
 472   }
 473   filename = argv[0];
 474   r = guestfs_add_drive (g, filename);
 475   return r;
 476 }
 477
 478 static int run_add_cdrom (const char *cmd, int argc, char *argv[])
 479 {
 480   int r;
 481   const char *filename;
 482   if (argc != 1) {
 483     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 484     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 485     return -1;
 486   }
 487   filename = argv[0];
 488   r = guestfs_add_cdrom (g, filename);
 489   return r;
 490 }
 491
 492 static int run_config (const char *cmd, int argc, char *argv[])
 493 {
 494   int r;
 495   const char *qemuparam;
 496   const char *qemuvalue;
 497   if (argc != 2) {
 498     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 499     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 500     return -1;
 501   }
 502   qemuparam = argv[0];
 503   qemuvalue = strcmp (argv[1], "") != 0 ? argv[1] : NULL;
 504   r = guestfs_config (g, qemuparam, qemuvalue);
 505   return r;
 506 }
 507
 508 static int run_set_path (const char *cmd, int argc, char *argv[])
 509 {
 510   int r;
 511   const char *path;
 512   if (argc != 1) {
 513     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 514     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 515     return -1;
 516   }
 517   path = argv[0];
 518   r = guestfs_set_path (g, path);
 519   return r;
 520 }
 521
 522 static int run_get_path (const char *cmd, int argc, char *argv[])
 523 {
 524   const char *r;
 525   if (argc != 0) {
 526     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 527     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 528     return -1;
 529   }
 530   r = guestfs_get_path (g);
 531   if (r == NULL) return -1;
 532   printf ("%s\n", r);
 533   return 0;
 534 }
 535
 536 static int run_set_autosync (const char *cmd, int argc, char *argv[])
 537 {
 538   int r;
 539   int autosync;
 540   if (argc != 1) {
 541     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 542     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 543     return -1;
 544   }
 545   autosync = is_true (argv[0]) ? 1 : 0;
 546   r = guestfs_set_autosync (g, autosync);
 547   return r;
 548 }
 549
 550 static int run_get_autosync (const char *cmd, int argc, char *argv[])
 551 {
 552   int r;
 553   if (argc != 0) {
 554     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 555     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 556     return -1;
 557   }
 558   r = guestfs_get_autosync (g);
 559   if (r == -1) return -1;
 560   if (r) printf ("true\n"); else printf ("false\n");
 561   return 0;
 562 }
 563
 564 static int run_set_verbose (const char *cmd, int argc, char *argv[])
 565 {
 566   int r;
 567   int verbose;
 568   if (argc != 1) {
 569     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 570     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 571     return -1;
 572   }
 573   verbose = is_true (argv[0]) ? 1 : 0;
 574   r = guestfs_set_verbose (g, verbose);
 575   return r;
 576 }
 577
 578 static int run_get_verbose (const char *cmd, int argc, char *argv[])
 579 {
 580   int r;
 581   if (argc != 0) {
 582     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 583     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 584     return -1;
 585   }
 586   r = guestfs_get_verbose (g);
 587   if (r == -1) return -1;
 588   if (r) printf ("true\n"); else printf ("false\n");
 589   return 0;
 590 }
 591
 592 static int run_mount (const char *cmd, int argc, char *argv[])
 593 {
 594   int r;
 595   const char *device;
 596   const char *mountpoint;
 597   if (argc != 2) {
 598     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 599     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 600     return -1;
 601   }
 602   device = argv[0];
 603   mountpoint = argv[1];
 604   r = guestfs_mount (g, device, mountpoint);
 605   return r;
 606 }
 607
 608 static int run_sync (const char *cmd, int argc, char *argv[])
 609 {
 610   int r;
 611   if (argc != 0) {
 612     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 613     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 614     return -1;
 615   }
 616   r = guestfs_sync (g);
 617   return r;
 618 }
 619
 620 static int run_touch (const char *cmd, int argc, char *argv[])
 621 {
 622   int r;
 623   const char *path;
 624   if (argc != 1) {
 625     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 626     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 627     return -1;
 628   }
 629   path = argv[0];
 630   r = guestfs_touch (g, path);
 631   return r;
 632 }
 633
 634 static int run_cat (const char *cmd, int argc, char *argv[])
 635 {
 636   char *r;
 637   const char *path;
 638   if (argc != 1) {
 639     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 640     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 641     return -1;
 642   }
 643   path = argv[0];
 644   r = guestfs_cat (g, path);
 645   if (r == NULL) return -1;
 646   printf ("%s\n", r);
 647   free (r);
 648   return 0;
 649 }
 650
 651 static int run_ll (const char *cmd, int argc, char *argv[])
 652 {
 653   char *r;
 654   const char *directory;
 655   if (argc != 1) {
 656     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 657     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 658     return -1;
 659   }
 660   directory = argv[0];
 661   r = guestfs_ll (g, directory);
 662   if (r == NULL) return -1;
 663   printf ("%s\n", r);
 664   free (r);
 665   return 0;
 666 }
 667
 668 static int run_ls (const char *cmd, int argc, char *argv[])
 669 {
 670   char **r;
 671   const char *directory;
 672   if (argc != 1) {
 673     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 674     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 675     return -1;
 676   }
 677   directory = argv[0];
 678   r = guestfs_ls (g, directory);
 679   if (r == NULL) return -1;
 680   print_strings (r);
 681   free_strings (r);
 682   return 0;
 683 }
 684
 685 static int run_list_devices (const char *cmd, int argc, char *argv[])
 686 {
 687   char **r;
 688   if (argc != 0) {
 689     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 690     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 691     return -1;
 692   }
 693   r = guestfs_list_devices (g);
 694   if (r == NULL) return -1;
 695   print_strings (r);
 696   free_strings (r);
 697   return 0;
 698 }
 699
 700 static int run_list_partitions (const char *cmd, int argc, char *argv[])
 701 {
 702   char **r;
 703   if (argc != 0) {
 704     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 705     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 706     return -1;
 707   }
 708   r = guestfs_list_partitions (g);
 709   if (r == NULL) return -1;
 710   print_strings (r);
 711   free_strings (r);
 712   return 0;
 713 }
 714
 715 static int run_pvs (const char *cmd, int argc, char *argv[])
 716 {
 717   char **r;
 718   if (argc != 0) {
 719     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 720     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 721     return -1;
 722   }
 723   r = guestfs_pvs (g);
 724   if (r == NULL) return -1;
 725   print_strings (r);
 726   free_strings (r);
 727   return 0;
 728 }
 729
 730 static int run_vgs (const char *cmd, int argc, char *argv[])
 731 {
 732   char **r;
 733   if (argc != 0) {
 734     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 735     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 736     return -1;
 737   }
 738   r = guestfs_vgs (g);
 739   if (r == NULL) return -1;
 740   print_strings (r);
 741   free_strings (r);
 742   return 0;
 743 }
 744
 745 static int run_lvs (const char *cmd, int argc, char *argv[])
 746 {
 747   char **r;
 748   if (argc != 0) {
 749     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 750     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 751     return -1;
 752   }
 753   r = guestfs_lvs (g);
 754   if (r == NULL) return -1;
 755   print_strings (r);
 756   free_strings (r);
 757   return 0;
 758 }
 759
 760 static int run_pvs_full (const char *cmd, int argc, char *argv[])
 761 {
 762   struct guestfs_lvm_pv_list *r;
 763   if (argc != 0) {
 764     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 765     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 766     return -1;
 767   }
 768   r = guestfs_pvs_full (g);
 769   if (r == NULL) return -1;
 770   print_pv_list (r);
 771   guestfs_free_lvm_pv_list (r);
 772   return 0;
 773 }
 774
 775 static int run_vgs_full (const char *cmd, int argc, char *argv[])
 776 {
 777   struct guestfs_lvm_vg_list *r;
 778   if (argc != 0) {
 779     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 780     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 781     return -1;
 782   }
 783   r = guestfs_vgs_full (g);
 784   if (r == NULL) return -1;
 785   print_vg_list (r);
 786   guestfs_free_lvm_vg_list (r);
 787   return 0;
 788 }
 789
 790 static int run_lvs_full (const char *cmd, int argc, char *argv[])
 791 {
 792   struct guestfs_lvm_lv_list *r;
 793   if (argc != 0) {
 794     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 795     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 796     return -1;
 797   }
 798   r = guestfs_lvs_full (g);
 799   if (r == NULL) return -1;
 800   print_lv_list (r);
 801   guestfs_free_lvm_lv_list (r);
 802   return 0;
 803 }
 804
 805 static int run_read_lines (const char *cmd, int argc, char *argv[])
 806 {
 807   char **r;
 808   const char *path;
 809   if (argc != 1) {
 810     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 811     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 812     return -1;
 813   }
 814   path = argv[0];
 815   r = guestfs_read_lines (g, path);
 816   if (r == NULL) return -1;
 817   print_strings (r);
 818   free_strings (r);
 819   return 0;
 820 }
 821
 822 static int run_aug_init (const char *cmd, int argc, char *argv[])
 823 {
 824   int r;
 825   const char *root;
 826   int flags;
 827   if (argc != 2) {
 828     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 829     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 830     return -1;
 831   }
 832   root = argv[0];
 833   flags = atoi (argv[1]);
 834   r = guestfs_aug_init (g, root, flags);
 835   return r;
 836 }
 837
 838 static int run_aug_close (const char *cmd, int argc, char *argv[])
 839 {
 840   int r;
 841   if (argc != 0) {
 842     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 843     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 844     return -1;
 845   }
 846   r = guestfs_aug_close (g);
 847   return r;
 848 }
 849
 850 static int run_aug_defvar (const char *cmd, int argc, char *argv[])
 851 {
 852   int r;
 853   const char *name;
 854   const char *expr;
 855   if (argc != 2) {
 856     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 857     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 858     return -1;
 859   }
 860   name = argv[0];
 861   expr = strcmp (argv[1], "") != 0 ? argv[1] : NULL;
 862   r = guestfs_aug_defvar (g, name, expr);
 863   if (r == -1) return -1;
 864   if (r) printf ("%d\n", r);
 865   return 0;
 866 }
 867
 868 static int run_aug_defnode (const char *cmd, int argc, char *argv[])
 869 {
 870   struct guestfs_int_bool *r;
 871   const char *name;
 872   const char *expr;
 873   const char *val;
 874   if (argc != 3) {
 875     fprintf (stderr, "%s should have 3 parameter(s)\n", cmd);
 876     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 877     return -1;
 878   }
 879   name = argv[0];
 880   expr = argv[1];
 881   val = argv[2];
 882   r = guestfs_aug_defnode (g, name, expr, val);
 883   if (r == NULL) return -1;
 884   printf ("%d, %s\n", r->i,
 885     r->b ? "true" : "false");
 886   guestfs_free_int_bool (r);
 887   return 0;
 888 }
 889
 890 static int run_aug_get (const char *cmd, int argc, char *argv[])
 891 {
 892   char *r;
 893   const char *path;
 894   if (argc != 1) {
 895     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 896     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 897     return -1;
 898   }
 899   path = argv[0];
 900   r = guestfs_aug_get (g, path);
 901   if (r == NULL) return -1;
 902   printf ("%s\n", r);
 903   free (r);
 904   return 0;
 905 }
 906
 907 static int run_aug_set (const char *cmd, int argc, char *argv[])
 908 {
 909   int r;
 910   const char *path;
 911   const char *val;
 912   if (argc != 2) {
 913     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 914     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 915     return -1;
 916   }
 917   path = argv[0];
 918   val = argv[1];
 919   r = guestfs_aug_set (g, path, val);
 920   return r;
 921 }
 922
 923 static int run_aug_insert (const char *cmd, int argc, char *argv[])
 924 {
 925   int r;
 926   const char *path;
 927   const char *label;
 928   int before;
 929   if (argc != 3) {
 930     fprintf (stderr, "%s should have 3 parameter(s)\n", cmd);
 931     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 932     return -1;
 933   }
 934   path = argv[0];
 935   label = argv[1];
 936   before = is_true (argv[2]) ? 1 : 0;
 937   r = guestfs_aug_insert (g, path, label, before);
 938   return r;
 939 }
 940
 941 static int run_aug_rm (const char *cmd, int argc, char *argv[])
 942 {
 943   int r;
 944   const char *path;
 945   if (argc != 1) {
 946     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 947     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 948     return -1;
 949   }
 950   path = argv[0];
 951   r = guestfs_aug_rm (g, path);
 952   if (r == -1) return -1;
 953   if (r) printf ("%d\n", r);
 954   return 0;
 955 }
 956
 957 static int run_aug_mv (const char *cmd, int argc, char *argv[])
 958 {
 959   int r;
 960   const char *src;
 961   const char *dest;
 962   if (argc != 2) {
 963     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 964     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 965     return -1;
 966   }
 967   src = argv[0];
 968   dest = argv[1];
 969   r = guestfs_aug_mv (g, src, dest);
 970   return r;
 971 }
 972
 973 static int run_aug_match (const char *cmd, int argc, char *argv[])
 974 {
 975   char **r;
 976   const char *path;
 977   if (argc != 1) {
 978     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 979     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 980     return -1;
 981   }
 982   path = argv[0];
 983   r = guestfs_aug_match (g, path);
 984   if (r == NULL) return -1;
 985   print_strings (r);
 986   free_strings (r);
 987   return 0;
 988 }
 989
 990 static int run_aug_save (const char *cmd, int argc, char *argv[])
 991 {
 992   int r;
 993   if (argc != 0) {
 994     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 995     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 996     return -1;
 997   }
 998   r = guestfs_aug_save (g);
 999   return r;
1000 }
1001
1002 static int run_aug_load (const char *cmd, int argc, char *argv[])
1003 {
1004   int r;
1005   if (argc != 0) {
1006     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
1007     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1008     return -1;
1009   }
1010   r = guestfs_aug_load (g);
1011   return r;
1012 }
1013
1014 static int run_aug_ls (const char *cmd, int argc, char *argv[])
1015 {
1016   char **r;
1017   const char *path;
1018   if (argc != 1) {
1019     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1020     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1021     return -1;
1022   }
1023   path = argv[0];
1024   r = guestfs_aug_ls (g, path);
1025   if (r == NULL) return -1;
1026   print_strings (r);
1027   free_strings (r);
1028   return 0;
1029 }
1030
1031 static int run_rm (const char *cmd, int argc, char *argv[])
1032 {
1033   int r;
1034   const char *path;
1035   if (argc != 1) {
1036     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1037     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1038     return -1;
1039   }
1040   path = argv[0];
1041   r = guestfs_rm (g, path);
1042   return r;
1043 }
1044
1045 static int run_rmdir (const char *cmd, int argc, char *argv[])
1046 {
1047   int r;
1048   const char *path;
1049   if (argc != 1) {
1050     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1051     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1052     return -1;
1053   }
1054   path = argv[0];
1055   r = guestfs_rmdir (g, path);
1056   return r;
1057 }
1058
1059 static int run_rm_rf (const char *cmd, int argc, char *argv[])
1060 {
1061   int r;
1062   const char *path;
1063   if (argc != 1) {
1064     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1065     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1066     return -1;
1067   }
1068   path = argv[0];
1069   r = guestfs_rm_rf (g, path);
1070   return r;
1071 }
1072
1073 static int run_mkdir (const char *cmd, int argc, char *argv[])
1074 {
1075   int r;
1076   const char *path;
1077   if (argc != 1) {
1078     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1079     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1080     return -1;
1081   }
1082   path = argv[0];
1083   r = guestfs_mkdir (g, path);
1084   return r;
1085 }
1086
1087 static int run_mkdir_p (const char *cmd, int argc, char *argv[])
1088 {
1089   int r;
1090   const char *path;
1091   if (argc != 1) {
1092     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1093     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1094     return -1;
1095   }
1096   path = argv[0];
1097   r = guestfs_mkdir_p (g, path);
1098   return r;
1099 }
1100
1101 static int run_chmod (const char *cmd, int argc, char *argv[])
1102 {
1103   int r;
1104   int mode;
1105   const char *path;
1106   if (argc != 2) {
1107     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
1108     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1109     return -1;
1110   }
1111   mode = atoi (argv[0]);
1112   path = argv[1];
1113   r = guestfs_chmod (g, mode, path);
1114   return r;
1115 }
1116
1117 static int run_chown (const char *cmd, int argc, char *argv[])
1118 {
1119   int r;
1120   int owner;
1121   int group;
1122   const char *path;
1123   if (argc != 3) {
1124     fprintf (stderr, "%s should have 3 parameter(s)\n", cmd);
1125     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1126     return -1;
1127   }
1128   owner = atoi (argv[0]);
1129   group = atoi (argv[1]);
1130   path = argv[2];
1131   r = guestfs_chown (g, owner, group, path);
1132   return r;
1133 }
1134
1135 static int run_exists (const char *cmd, int argc, char *argv[])
1136 {
1137   int r;
1138   const char *path;
1139   if (argc != 1) {
1140     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1141     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1142     return -1;
1143   }
1144   path = argv[0];
1145   r = guestfs_exists (g, path);
1146   if (r == -1) return -1;
1147   if (r) printf ("true\n"); else printf ("false\n");
1148   return 0;
1149 }
1150
1151 static int run_is_file (const char *cmd, int argc, char *argv[])
1152 {
1153   int r;
1154   const char *path;
1155   if (argc != 1) {
1156     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1157     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1158     return -1;
1159   }
1160   path = argv[0];
1161   r = guestfs_is_file (g, path);
1162   if (r == -1) return -1;
1163   if (r) printf ("true\n"); else printf ("false\n");
1164   return 0;
1165 }
1166
1167 static int run_is_dir (const char *cmd, int argc, char *argv[])
1168 {
1169   int r;
1170   const char *path;
1171   if (argc != 1) {
1172     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1173     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1174     return -1;
1175   }
1176   path = argv[0];
1177   r = guestfs_is_dir (g, path);
1178   if (r == -1) return -1;
1179   if (r) printf ("true\n"); else printf ("false\n");
1180   return 0;
1181 }
1182
1183 static int run_pvcreate (const char *cmd, int argc, char *argv[])
1184 {
1185   int r;
1186   const char *device;
1187   if (argc != 1) {
1188     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1189     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1190     return -1;
1191   }
1192   device = argv[0];
1193   r = guestfs_pvcreate (g, device);
1194   return r;
1195 }
1196
1197 static int run_vgcreate (const char *cmd, int argc, char *argv[])
1198 {
1199   int r;
1200   const char *volgroup;
1201   char **physvols;
1202   if (argc != 2) {
1203     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
1204     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1205     return -1;
1206   }
1207   volgroup = argv[0];
1208   physvols = parse_string_list (argv[1]);
1209   r = guestfs_vgcreate (g, volgroup, physvols);
1210   return r;
1211 }
1212
1213 static int run_lvcreate (const char *cmd, int argc, char *argv[])
1214 {
1215   int r;
1216   const char *logvol;
1217   const char *volgroup;
1218   int mbytes;
1219   if (argc != 3) {
1220     fprintf (stderr, "%s should have 3 parameter(s)\n", cmd);
1221     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1222     return -1;
1223   }
1224   logvol = argv[0];
1225   volgroup = argv[1];
1226   mbytes = atoi (argv[2]);
1227   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1228   return r;
1229 }
1230
1231 static int run_mkfs (const char *cmd, int argc, char *argv[])
1232 {
1233   int r;
1234   const char *fstype;
1235   const char *device;
1236   if (argc != 2) {
1237     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
1238     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1239     return -1;
1240   }
1241   fstype = argv[0];
1242   device = argv[1];
1243   r = guestfs_mkfs (g, fstype, device);
1244   return r;
1245 }
1246
1247 static int run_sfdisk (const char *cmd, int argc, char *argv[])
1248 {
1249   int r;
1250   const char *device;
1251   int cyls;
1252   int heads;
1253   int sectors;
1254   char **lines;
1255   if (argc != 5) {
1256     fprintf (stderr, "%s should have 5 parameter(s)\n", cmd);
1257     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1258     return -1;
1259   }
1260   device = argv[0];
1261   cyls = atoi (argv[1]);
1262   heads = atoi (argv[2]);
1263   sectors = atoi (argv[3]);
1264   lines = parse_string_list (argv[4]);
1265   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1266   return r;
1267 }
1268
1269 static int run_write_file (const char *cmd, int argc, char *argv[])
1270 {
1271   int r;
1272   const char *path;
1273   const char *content;
1274   int size;
1275   if (argc != 3) {
1276     fprintf (stderr, "%s should have 3 parameter(s)\n", cmd);
1277     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1278     return -1;
1279   }
1280   path = argv[0];
1281   content = argv[1];
1282   size = atoi (argv[2]);
1283   r = guestfs_write_file (g, path, content, size);
1284   return r;
1285 }
1286
1287 static int run_umount (const char *cmd, int argc, char *argv[])
1288 {
1289   int r;
1290   const char *pathordevice;
1291   if (argc != 1) {
1292     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1293     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1294     return -1;
1295   }
1296   pathordevice = argv[0];
1297   r = guestfs_umount (g, pathordevice);
1298   return r;
1299 }
1300
1301 static int run_mounts (const char *cmd, int argc, char *argv[])
1302 {
1303   char **r;
1304   if (argc != 0) {
1305     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
1306     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1307     return -1;
1308   }
1309   r = guestfs_mounts (g);
1310   if (r == NULL) return -1;
1311   print_strings (r);
1312   free_strings (r);
1313   return 0;
1314 }
1315
1316 static int run_umount_all (const char *cmd, int argc, char *argv[])
1317 {
1318   int r;
1319   if (argc != 0) {
1320     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
1321     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1322     return -1;
1323   }
1324   r = guestfs_umount_all (g);
1325   return r;
1326 }
1327
1328 static int run_lvm_remove_all (const char *cmd, int argc, char *argv[])
1329 {
1330   int r;
1331   if (argc != 0) {
1332     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
1333     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1334     return -1;
1335   }
1336   r = guestfs_lvm_remove_all (g);
1337   return r;
1338 }
1339
1340 static int run_file (const char *cmd, int argc, char *argv[])
1341 {
1342   char *r;
1343   const char *path;
1344   if (argc != 1) {
1345     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1346     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1347     return -1;
1348   }
1349   path = argv[0];
1350   r = guestfs_file (g, path);
1351   if (r == NULL) return -1;
1352   printf ("%s\n", r);
1353   free (r);
1354   return 0;
1355 }
1356
1357 static int run_command (const char *cmd, int argc, char *argv[])
1358 {
1359   char *r;
1360   char **arguments;
1361   if (argc != 1) {
1362     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1363     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1364     return -1;
1365   }
1366   arguments = parse_string_list (argv[0]);
1367   r = guestfs_command (g, arguments);
1368   if (r == NULL) return -1;
1369   printf ("%s\n", r);
1370   free (r);
1371   return 0;
1372 }
1373
1374 static int run_command_lines (const char *cmd, int argc, char *argv[])
1375 {
1376   char **r;
1377   char **arguments;
1378   if (argc != 1) {
1379     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1380     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1381     return -1;
1382   }
1383   arguments = parse_string_list (argv[0]);
1384   r = guestfs_command_lines (g, arguments);
1385   if (r == NULL) return -1;
1386   print_strings (r);
1387   free_strings (r);
1388   return 0;
1389 }
1390
1391 static int run_stat (const char *cmd, int argc, char *argv[])
1392 {
1393   struct guestfs_stat *r;
1394   const char *path;
1395   if (argc != 1) {
1396     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1397     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1398     return -1;
1399   }
1400   path = argv[0];
1401   r = guestfs_stat (g, path);
1402   if (r == NULL) return -1;
1403   print_stat (r);
1404   free (r);
1405   return 0;
1406 }
1407
1408 static int run_lstat (const char *cmd, int argc, char *argv[])
1409 {
1410   struct guestfs_stat *r;
1411   const char *path;
1412   if (argc != 1) {
1413     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1414     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1415     return -1;
1416   }
1417   path = argv[0];
1418   r = guestfs_lstat (g, path);
1419   if (r == NULL) return -1;
1420   print_stat (r);
1421   free (r);
1422   return 0;
1423 }
1424
1425 static int run_statvfs (const char *cmd, int argc, char *argv[])
1426 {
1427   struct guestfs_statvfs *r;
1428   const char *path;
1429   if (argc != 1) {
1430     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1431     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1432     return -1;
1433   }
1434   path = argv[0];
1435   r = guestfs_statvfs (g, path);
1436   if (r == NULL) return -1;
1437   print_statvfs (r);
1438   free (r);
1439   return 0;
1440 }
1441
1442 static int run_tune2fs_l (const char *cmd, int argc, char *argv[])
1443 {
1444   char **r;
1445   const char *device;
1446   if (argc != 1) {
1447     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
1448     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
1449     return -1;
1450   }
1451   device = argv[0];
1452   r = guestfs_tune2fs_l (g, device);
1453   if (r == NULL) return -1;
1454   print_table (r);
1455   free_strings (r);
1456   return 0;
1457 }
1458
1459 int run_action (const char *cmd, int argc, char *argv[])
1460 {
1461   if (strcasecmp (cmd, "launch") == 0 || strcasecmp (cmd, "run") == 0)
1462     return run_launch (cmd, argc, argv);
1463   else
1464   if (strcasecmp (cmd, "kill_subprocess") == 0 || strcasecmp (cmd, "kill-subprocess") == 0)
1465     return run_kill_subprocess (cmd, argc, argv);
1466   else
1467   if (strcasecmp (cmd, "add_drive") == 0 || strcasecmp (cmd, "add-drive") == 0 || strcasecmp (cmd, "add") == 0)
1468     return run_add_drive (cmd, argc, argv);
1469   else
1470   if (strcasecmp (cmd, "add_cdrom") == 0 || strcasecmp (cmd, "add-cdrom") == 0 || strcasecmp (cmd, "cdrom") == 0)
1471     return run_add_cdrom (cmd, argc, argv);
1472   else
1473   if (strcasecmp (cmd, "config") == 0)
1474     return run_config (cmd, argc, argv);
1475   else
1476   if (strcasecmp (cmd, "set_path") == 0 || strcasecmp (cmd, "set-path") == 0 || strcasecmp (cmd, "path") == 0)
1477     return run_set_path (cmd, argc, argv);
1478   else
1479   if (strcasecmp (cmd, "get_path") == 0 || strcasecmp (cmd, "get-path") == 0)
1480     return run_get_path (cmd, argc, argv);
1481   else
1482   if (strcasecmp (cmd, "set_autosync") == 0 || strcasecmp (cmd, "set-autosync") == 0 || strcasecmp (cmd, "autosync") == 0)
1483     return run_set_autosync (cmd, argc, argv);
1484   else
1485   if (strcasecmp (cmd, "get_autosync") == 0 || strcasecmp (cmd, "get-autosync") == 0)
1486     return run_get_autosync (cmd, argc, argv);
1487   else
1488   if (strcasecmp (cmd, "set_verbose") == 0 || strcasecmp (cmd, "set-verbose") == 0 || strcasecmp (cmd, "verbose") == 0)
1489     return run_set_verbose (cmd, argc, argv);
1490   else
1491   if (strcasecmp (cmd, "get_verbose") == 0 || strcasecmp (cmd, "get-verbose") == 0)
1492     return run_get_verbose (cmd, argc, argv);
1493   else
1494   if (strcasecmp (cmd, "mount") == 0)
1495     return run_mount (cmd, argc, argv);
1496   else
1497   if (strcasecmp (cmd, "sync") == 0)
1498     return run_sync (cmd, argc, argv);
1499   else
1500   if (strcasecmp (cmd, "touch") == 0)
1501     return run_touch (cmd, argc, argv);
1502   else
1503   if (strcasecmp (cmd, "cat") == 0)
1504     return run_cat (cmd, argc, argv);
1505   else
1506   if (strcasecmp (cmd, "ll") == 0)
1507     return run_ll (cmd, argc, argv);
1508   else
1509   if (strcasecmp (cmd, "ls") == 0)
1510     return run_ls (cmd, argc, argv);
1511   else
1512   if (strcasecmp (cmd, "list_devices") == 0 || strcasecmp (cmd, "list-devices") == 0)
1513     return run_list_devices (cmd, argc, argv);
1514   else
1515   if (strcasecmp (cmd, "list_partitions") == 0 || strcasecmp (cmd, "list-partitions") == 0)
1516     return run_list_partitions (cmd, argc, argv);
1517   else
1518   if (strcasecmp (cmd, "pvs") == 0)
1519     return run_pvs (cmd, argc, argv);
1520   else
1521   if (strcasecmp (cmd, "vgs") == 0)
1522     return run_vgs (cmd, argc, argv);
1523   else
1524   if (strcasecmp (cmd, "lvs") == 0)
1525     return run_lvs (cmd, argc, argv);
1526   else
1527   if (strcasecmp (cmd, "pvs_full") == 0 || strcasecmp (cmd, "pvs-full") == 0)
1528     return run_pvs_full (cmd, argc, argv);
1529   else
1530   if (strcasecmp (cmd, "vgs_full") == 0 || strcasecmp (cmd, "vgs-full") == 0)
1531     return run_vgs_full (cmd, argc, argv);
1532   else
1533   if (strcasecmp (cmd, "lvs_full") == 0 || strcasecmp (cmd, "lvs-full") == 0)
1534     return run_lvs_full (cmd, argc, argv);
1535   else
1536   if (strcasecmp (cmd, "read_lines") == 0 || strcasecmp (cmd, "read-lines") == 0)
1537     return run_read_lines (cmd, argc, argv);
1538   else
1539   if (strcasecmp (cmd, "aug_init") == 0 || strcasecmp (cmd, "aug-init") == 0)
1540     return run_aug_init (cmd, argc, argv);
1541   else
1542   if (strcasecmp (cmd, "aug_close") == 0 || strcasecmp (cmd, "aug-close") == 0)
1543     return run_aug_close (cmd, argc, argv);
1544   else
1545   if (strcasecmp (cmd, "aug_defvar") == 0 || strcasecmp (cmd, "aug-defvar") == 0)
1546     return run_aug_defvar (cmd, argc, argv);
1547   else
1548   if (strcasecmp (cmd, "aug_defnode") == 0 || strcasecmp (cmd, "aug-defnode") == 0)
1549     return run_aug_defnode (cmd, argc, argv);
1550   else
1551   if (strcasecmp (cmd, "aug_get") == 0 || strcasecmp (cmd, "aug-get") == 0)
1552     return run_aug_get (cmd, argc, argv);
1553   else
1554   if (strcasecmp (cmd, "aug_set") == 0 || strcasecmp (cmd, "aug-set") == 0)
1555     return run_aug_set (cmd, argc, argv);
1556   else
1557   if (strcasecmp (cmd, "aug_insert") == 0 || strcasecmp (cmd, "aug-insert") == 0)
1558     return run_aug_insert (cmd, argc, argv);
1559   else
1560   if (strcasecmp (cmd, "aug_rm") == 0 || strcasecmp (cmd, "aug-rm") == 0)
1561     return run_aug_rm (cmd, argc, argv);
1562   else
1563   if (strcasecmp (cmd, "aug_mv") == 0 || strcasecmp (cmd, "aug-mv") == 0)
1564     return run_aug_mv (cmd, argc, argv);
1565   else
1566   if (strcasecmp (cmd, "aug_match") == 0 || strcasecmp (cmd, "aug-match") == 0)
1567     return run_aug_match (cmd, argc, argv);
1568   else
1569   if (strcasecmp (cmd, "aug_save") == 0 || strcasecmp (cmd, "aug-save") == 0)
1570     return run_aug_save (cmd, argc, argv);
1571   else
1572   if (strcasecmp (cmd, "aug_load") == 0 || strcasecmp (cmd, "aug-load") == 0)
1573     return run_aug_load (cmd, argc, argv);
1574   else
1575   if (strcasecmp (cmd, "aug_ls") == 0 || strcasecmp (cmd, "aug-ls") == 0)
1576     return run_aug_ls (cmd, argc, argv);
1577   else
1578   if (strcasecmp (cmd, "rm") == 0)
1579     return run_rm (cmd, argc, argv);
1580   else
1581   if (strcasecmp (cmd, "rmdir") == 0)
1582     return run_rmdir (cmd, argc, argv);
1583   else
1584   if (strcasecmp (cmd, "rm_rf") == 0 || strcasecmp (cmd, "rm-rf") == 0)
1585     return run_rm_rf (cmd, argc, argv);
1586   else
1587   if (strcasecmp (cmd, "mkdir") == 0)
1588     return run_mkdir (cmd, argc, argv);
1589   else
1590   if (strcasecmp (cmd, "mkdir_p") == 0 || strcasecmp (cmd, "mkdir-p") == 0)
1591     return run_mkdir_p (cmd, argc, argv);
1592   else
1593   if (strcasecmp (cmd, "chmod") == 0)
1594     return run_chmod (cmd, argc, argv);
1595   else
1596   if (strcasecmp (cmd, "chown") == 0)
1597     return run_chown (cmd, argc, argv);
1598   else
1599   if (strcasecmp (cmd, "exists") == 0)
1600     return run_exists (cmd, argc, argv);
1601   else
1602   if (strcasecmp (cmd, "is_file") == 0 || strcasecmp (cmd, "is-file") == 0)
1603     return run_is_file (cmd, argc, argv);
1604   else
1605   if (strcasecmp (cmd, "is_dir") == 0 || strcasecmp (cmd, "is-dir") == 0)
1606     return run_is_dir (cmd, argc, argv);
1607   else
1608   if (strcasecmp (cmd, "pvcreate") == 0)
1609     return run_pvcreate (cmd, argc, argv);
1610   else
1611   if (strcasecmp (cmd, "vgcreate") == 0)
1612     return run_vgcreate (cmd, argc, argv);
1613   else
1614   if (strcasecmp (cmd, "lvcreate") == 0)
1615     return run_lvcreate (cmd, argc, argv);
1616   else
1617   if (strcasecmp (cmd, "mkfs") == 0)
1618     return run_mkfs (cmd, argc, argv);
1619   else
1620   if (strcasecmp (cmd, "sfdisk") == 0)
1621     return run_sfdisk (cmd, argc, argv);
1622   else
1623   if (strcasecmp (cmd, "write_file") == 0 || strcasecmp (cmd, "write-file") == 0)
1624     return run_write_file (cmd, argc, argv);
1625   else
1626   if (strcasecmp (cmd, "umount") == 0 || strcasecmp (cmd, "unmount") == 0)
1627     return run_umount (cmd, argc, argv);
1628   else
1629   if (strcasecmp (cmd, "mounts") == 0)
1630     return run_mounts (cmd, argc, argv);
1631   else
1632   if (strcasecmp (cmd, "umount_all") == 0 || strcasecmp (cmd, "umount-all") == 0 || strcasecmp (cmd, "unmount-all") == 0)
1633     return run_umount_all (cmd, argc, argv);
1634   else
1635   if (strcasecmp (cmd, "lvm_remove_all") == 0 || strcasecmp (cmd, "lvm-remove-all") == 0)
1636     return run_lvm_remove_all (cmd, argc, argv);
1637   else
1638   if (strcasecmp (cmd, "file") == 0)
1639     return run_file (cmd, argc, argv);
1640   else
1641   if (strcasecmp (cmd, "command") == 0)
1642     return run_command (cmd, argc, argv);
1643   else
1644   if (strcasecmp (cmd, "command_lines") == 0 || strcasecmp (cmd, "command-lines") == 0)
1645     return run_command_lines (cmd, argc, argv);
1646   else
1647   if (strcasecmp (cmd, "stat") == 0)
1648     return run_stat (cmd, argc, argv);
1649   else
1650   if (strcasecmp (cmd, "lstat") == 0)
1651     return run_lstat (cmd, argc, argv);
1652   else
1653   if (strcasecmp (cmd, "statvfs") == 0)
1654     return run_statvfs (cmd, argc, argv);
1655   else
1656   if (strcasecmp (cmd, "tune2fs_l") == 0 || strcasecmp (cmd, "tune2fs-l") == 0)
1657     return run_tune2fs_l (cmd, argc, argv);
1658   else
1659     {
1660       fprintf (stderr, "%s: unknown command\n", cmd);
1661       return -1;
1662     }
1663   return 0;
1664 }
1665