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