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