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