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", "cat", "list the contents of a file");
  37   printf ("%-20s %s\n", "config", "add qemu parameters");
  38   printf ("%-20s %s\n", "get-autosync", "get autosync mode");
  39   printf ("%-20s %s\n", "get-path", "get the search path");
  40   printf ("%-20s %s\n", "get-verbose", "get verbose mode");
  41   printf ("%-20s %s\n", "kill-subprocess", "kill the qemu subprocess");
  42   printf ("%-20s %s\n", "launch", "launch the qemu subprocess");
  43   printf ("%-20s %s\n", "list-devices", "list the block devices");
  44   printf ("%-20s %s\n", "list-partitions", "list the partitions");
  45   printf ("%-20s %s\n", "ll", "list the files in a directory (long format)");
  46   printf ("%-20s %s\n", "ls", "list the files in a directory");
  47   printf ("%-20s %s\n", "lvs", "list the LVM logical volumes (LVs)");
  48   printf ("%-20s %s\n", "lvs-full", "list the LVM logical volumes (LVs)");
  49   printf ("%-20s %s\n", "mount", "mount a guest disk at a position in the filesystem");
  50   printf ("%-20s %s\n", "pvs", "list the LVM physical volumes (PVs)");
  51   printf ("%-20s %s\n", "pvs-full", "list the LVM physical volumes (PVs)");
  52   printf ("%-20s %s\n", "set-autosync", "set autosync mode");
  53   printf ("%-20s %s\n", "set-path", "set the search path");
  54   printf ("%-20s %s\n", "set-verbose", "set verbose mode");
  55   printf ("%-20s %s\n", "sync", "sync disks, writes are flushed through to the disk image");
  56   printf ("%-20s %s\n", "touch", "update file timestamps or create a new file");
  57   printf ("%-20s %s\n", "vgs", "list the LVM volume groups (VGs)");
  58   printf ("%-20s %s\n", "vgs-full", "list the LVM volume groups (VGs)");
  59   printf ("    Use -h <cmd> / help <cmd> to show detailed help for a command.\n");
  60 }
  61
  62 void display_command (const char *cmd)
  63 {
  64   if (strcasecmp (cmd, "launch") == 0 || strcasecmp (cmd, "run") == 0)
  65     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.");
  66   else
  67   if (strcasecmp (cmd, "kill_subprocess") == 0 || strcasecmp (cmd, "kill-subprocess") == 0)
  68     pod2text ("kill-subprocess - kill the qemu subprocess", " kill-subprocess\n\nThis kills the qemu subprocess.  You should never need to call this.");
  69   else
  70   if (strcasecmp (cmd, "add_drive") == 0 || strcasecmp (cmd, "add-drive") == 0 || strcasecmp (cmd, "add") == 0)
  71     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.");
  72   else
  73   if (strcasecmp (cmd, "add_cdrom") == 0 || strcasecmp (cmd, "add-cdrom") == 0 || strcasecmp (cmd, "cdrom") == 0)
  74     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.");
  75   else
  76   if (strcasecmp (cmd, "config") == 0)
  77     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.");
  78   else
  79   if (strcasecmp (cmd, "set_path") == 0 || strcasecmp (cmd, "set-path") == 0 || strcasecmp (cmd, "path") == 0)
  80     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.");
  81   else
  82   if (strcasecmp (cmd, "get_path") == 0 || strcasecmp (cmd, "get-path") == 0)
  83     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.");
  84   else
  85   if (strcasecmp (cmd, "set_autosync") == 0 || strcasecmp (cmd, "set-autosync") == 0 || strcasecmp (cmd, "autosync") == 0)
  86     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.");
  87   else
  88   if (strcasecmp (cmd, "get_autosync") == 0 || strcasecmp (cmd, "get-autosync") == 0)
  89     pod2text ("get-autosync - get autosync mode", " get-autosync\n\nGet the autosync flag.");
  90   else
  91   if (strcasecmp (cmd, "set_verbose") == 0 || strcasecmp (cmd, "set-verbose") == 0 || strcasecmp (cmd, "verbose") == 0)
  92     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.");
  93   else
  94   if (strcasecmp (cmd, "get_verbose") == 0 || strcasecmp (cmd, "get-verbose") == 0)
  95     pod2text ("get-verbose - get verbose mode", " get-verbose\n\nThis returns the verbose messages flag.");
  96   else
  97   if (strcasecmp (cmd, "mount") == 0)
  98     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.");
  99   else
 100   if (strcasecmp (cmd, "sync") == 0)
 101     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.");
 102   else
 103   if (strcasecmp (cmd, "touch") == 0)
 104     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.");
 105   else
 106   if (strcasecmp (cmd, "cat") == 0)
 107     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.");
 108   else
 109   if (strcasecmp (cmd, "ll") == 0)
 110     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.");
 111   else
 112   if (strcasecmp (cmd, "ls") == 0)
 113     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.");
 114   else
 115   if (strcasecmp (cmd, "list_devices") == 0 || strcasecmp (cmd, "list-devices") == 0)
 116     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>");
 117   else
 118   if (strcasecmp (cmd, "list_partitions") == 0 || strcasecmp (cmd, "list-partitions") == 0)
 119     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>.");
 120   else
 121   if (strcasecmp (cmd, "pvs") == 0)
 122     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>.");
 123   else
 124   if (strcasecmp (cmd, "vgs") == 0)
 125     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>.");
 126   else
 127   if (strcasecmp (cmd, "lvs") == 0)
 128     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>.");
 129   else
 130   if (strcasecmp (cmd, "pvs_full") == 0 || strcasecmp (cmd, "pvs-full") == 0)
 131     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.");
 132   else
 133   if (strcasecmp (cmd, "vgs_full") == 0 || strcasecmp (cmd, "vgs-full") == 0)
 134     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.");
 135   else
 136   if (strcasecmp (cmd, "lvs_full") == 0 || strcasecmp (cmd, "lvs-full") == 0)
 137     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.");
 138   else
 139     display_builtin_command (cmd);
 140 }
 141
 142 static void print_pv (struct guestfs_lvm_pv *pv)
 143 {
 144   int i;
 145
 146   printf ("pv_name: %s\n", pv->pv_name);
 147   printf ("pv_uuid: ");
 148   for (i = 0; i < 32; ++i)
 149     printf ("%c", pv->pv_uuid[i]);
 150   printf ("\n");
 151   printf ("pv_fmt: %s\n", pv->pv_fmt);
 152   printf ("pv_size: %" PRIu64 "\n", pv->pv_size);
 153   printf ("dev_size: %" PRIu64 "\n", pv->dev_size);
 154   printf ("pv_free: %" PRIu64 "\n", pv->pv_free);
 155   printf ("pv_used: %" PRIu64 "\n", pv->pv_used);
 156   printf ("pv_attr: %s\n", pv->pv_attr);
 157   printf ("pv_pe_count: %" PRIi64 "\n", pv->pv_pe_count);
 158   printf ("pv_pe_alloc_count: %" PRIi64 "\n", pv->pv_pe_alloc_count);
 159   printf ("pv_tags: %s\n", pv->pv_tags);
 160   printf ("pe_start: %" PRIu64 "\n", pv->pe_start);
 161   printf ("pv_mda_count: %" PRIi64 "\n", pv->pv_mda_count);
 162   printf ("pv_mda_free: %" PRIu64 "\n", pv->pv_mda_free);
 163 }
 164
 165 static void print_pv_list (struct guestfs_lvm_pv_list *pvs)
 166 {
 167   int i;
 168
 169   for (i = 0; i < pvs->len; ++i)
 170     print_pv (&pvs->val[i]);
 171 }
 172
 173 static void print_vg (struct guestfs_lvm_vg *vg)
 174 {
 175   int i;
 176
 177   printf ("vg_name: %s\n", vg->vg_name);
 178   printf ("vg_uuid: ");
 179   for (i = 0; i < 32; ++i)
 180     printf ("%c", vg->vg_uuid[i]);
 181   printf ("\n");
 182   printf ("vg_fmt: %s\n", vg->vg_fmt);
 183   printf ("vg_attr: %s\n", vg->vg_attr);
 184   printf ("vg_size: %" PRIu64 "\n", vg->vg_size);
 185   printf ("vg_free: %" PRIu64 "\n", vg->vg_free);
 186   printf ("vg_sysid: %s\n", vg->vg_sysid);
 187   printf ("vg_extent_size: %" PRIu64 "\n", vg->vg_extent_size);
 188   printf ("vg_extent_count: %" PRIi64 "\n", vg->vg_extent_count);
 189   printf ("vg_free_count: %" PRIi64 "\n", vg->vg_free_count);
 190   printf ("max_lv: %" PRIi64 "\n", vg->max_lv);
 191   printf ("max_pv: %" PRIi64 "\n", vg->max_pv);
 192   printf ("pv_count: %" PRIi64 "\n", vg->pv_count);
 193   printf ("lv_count: %" PRIi64 "\n", vg->lv_count);
 194   printf ("snap_count: %" PRIi64 "\n", vg->snap_count);
 195   printf ("vg_seqno: %" PRIi64 "\n", vg->vg_seqno);
 196   printf ("vg_tags: %s\n", vg->vg_tags);
 197   printf ("vg_mda_count: %" PRIi64 "\n", vg->vg_mda_count);
 198   printf ("vg_mda_free: %" PRIu64 "\n", vg->vg_mda_free);
 199 }
 200
 201 static void print_vg_list (struct guestfs_lvm_vg_list *vgs)
 202 {
 203   int i;
 204
 205   for (i = 0; i < vgs->len; ++i)
 206     print_vg (&vgs->val[i]);
 207 }
 208
 209 static void print_lv (struct guestfs_lvm_lv *lv)
 210 {
 211   int i;
 212
 213   printf ("lv_name: %s\n", lv->lv_name);
 214   printf ("lv_uuid: ");
 215   for (i = 0; i < 32; ++i)
 216     printf ("%c", lv->lv_uuid[i]);
 217   printf ("\n");
 218   printf ("lv_attr: %s\n", lv->lv_attr);
 219   printf ("lv_major: %" PRIi64 "\n", lv->lv_major);
 220   printf ("lv_minor: %" PRIi64 "\n", lv->lv_minor);
 221   printf ("lv_kernel_major: %" PRIi64 "\n", lv->lv_kernel_major);
 222   printf ("lv_kernel_minor: %" PRIi64 "\n", lv->lv_kernel_minor);
 223   printf ("lv_size: %" PRIu64 "\n", lv->lv_size);
 224   printf ("seg_count: %" PRIi64 "\n", lv->seg_count);
 225   printf ("origin: %s\n", lv->origin);
 226   if (lv->snap_percent >= 0) printf ("snap_percent: %g %%\n", lv->snap_percent);
 227   else printf ("snap_percent: \n");
 228   if (lv->copy_percent >= 0) printf ("copy_percent: %g %%\n", lv->copy_percent);
 229   else printf ("copy_percent: \n");
 230   printf ("move_pv: %s\n", lv->move_pv);
 231   printf ("lv_tags: %s\n", lv->lv_tags);
 232   printf ("mirror_log: %s\n", lv->mirror_log);
 233   printf ("modules: %s\n", lv->modules);
 234 }
 235
 236 static void print_lv_list (struct guestfs_lvm_lv_list *lvs)
 237 {
 238   int i;
 239
 240   for (i = 0; i < lvs->len; ++i)
 241     print_lv (&lvs->val[i]);
 242 }
 243
 244 static int run_launch (const char *cmd, int argc, char *argv[])
 245 {
 246   int r;
 247   if (argc != 0) {
 248     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 249     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 250     return -1;
 251   }
 252   r = launch (g);
 253   return r;
 254 }
 255
 256 static int run_kill_subprocess (const char *cmd, int argc, char *argv[])
 257 {
 258   int r;
 259   if (argc != 0) {
 260     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 261     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 262     return -1;
 263   }
 264   r = guestfs_kill_subprocess (g);
 265   return r;
 266 }
 267
 268 static int run_add_drive (const char *cmd, int argc, char *argv[])
 269 {
 270   int r;
 271   const char *filename;
 272   if (argc != 1) {
 273     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 274     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 275     return -1;
 276   }
 277   filename = argv[0];
 278   r = guestfs_add_drive (g, filename);
 279   return r;
 280 }
 281
 282 static int run_add_cdrom (const char *cmd, int argc, char *argv[])
 283 {
 284   int r;
 285   const char *filename;
 286   if (argc != 1) {
 287     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 288     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 289     return -1;
 290   }
 291   filename = argv[0];
 292   r = guestfs_add_cdrom (g, filename);
 293   return r;
 294 }
 295
 296 static int run_config (const char *cmd, int argc, char *argv[])
 297 {
 298   int r;
 299   const char *qemuparam;
 300   const char *qemuvalue;
 301   if (argc != 2) {
 302     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 303     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 304     return -1;
 305   }
 306   qemuparam = argv[0];
 307   qemuvalue = strcmp (argv[1], "") != 0 ? argv[1] : NULL;
 308   r = guestfs_config (g, qemuparam, qemuvalue);
 309   return r;
 310 }
 311
 312 static int run_set_path (const char *cmd, int argc, char *argv[])
 313 {
 314   int r;
 315   const char *path;
 316   if (argc != 1) {
 317     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 318     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 319     return -1;
 320   }
 321   path = argv[0];
 322   r = guestfs_set_path (g, path);
 323   return r;
 324 }
 325
 326 static int run_get_path (const char *cmd, int argc, char *argv[])
 327 {
 328   const char *r;
 329   if (argc != 0) {
 330     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 331     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 332     return -1;
 333   }
 334   r = guestfs_get_path (g);
 335   if (r == NULL) return -1;
 336   printf ("%s\n", r);
 337   return 0;
 338 }
 339
 340 static int run_set_autosync (const char *cmd, int argc, char *argv[])
 341 {
 342   int r;
 343   int autosync;
 344   if (argc != 1) {
 345     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 346     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 347     return -1;
 348   }
 349   autosync = is_true (argv[0]) ? 1 : 0;
 350   r = guestfs_set_autosync (g, autosync);
 351   return r;
 352 }
 353
 354 static int run_get_autosync (const char *cmd, int argc, char *argv[])
 355 {
 356   int r;
 357   if (argc != 0) {
 358     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 359     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 360     return -1;
 361   }
 362   r = guestfs_get_autosync (g);
 363   if (r == -1) return -1;
 364   if (r) printf ("true\n"); else printf ("false\n");
 365   return 0;
 366 }
 367
 368 static int run_set_verbose (const char *cmd, int argc, char *argv[])
 369 {
 370   int r;
 371   int verbose;
 372   if (argc != 1) {
 373     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 374     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 375     return -1;
 376   }
 377   verbose = is_true (argv[0]) ? 1 : 0;
 378   r = guestfs_set_verbose (g, verbose);
 379   return r;
 380 }
 381
 382 static int run_get_verbose (const char *cmd, int argc, char *argv[])
 383 {
 384   int r;
 385   if (argc != 0) {
 386     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 387     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 388     return -1;
 389   }
 390   r = guestfs_get_verbose (g);
 391   if (r == -1) return -1;
 392   if (r) printf ("true\n"); else printf ("false\n");
 393   return 0;
 394 }
 395
 396 static int run_mount (const char *cmd, int argc, char *argv[])
 397 {
 398   int r;
 399   const char *device;
 400   const char *mountpoint;
 401   if (argc != 2) {
 402     fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
 403     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 404     return -1;
 405   }
 406   device = argv[0];
 407   mountpoint = argv[1];
 408   r = guestfs_mount (g, device, mountpoint);
 409   return r;
 410 }
 411
 412 static int run_sync (const char *cmd, int argc, char *argv[])
 413 {
 414   int r;
 415   if (argc != 0) {
 416     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 417     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 418     return -1;
 419   }
 420   r = guestfs_sync (g);
 421   return r;
 422 }
 423
 424 static int run_touch (const char *cmd, int argc, char *argv[])
 425 {
 426   int r;
 427   const char *path;
 428   if (argc != 1) {
 429     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 430     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 431     return -1;
 432   }
 433   path = argv[0];
 434   r = guestfs_touch (g, path);
 435   return r;
 436 }
 437
 438 static int run_cat (const char *cmd, int argc, char *argv[])
 439 {
 440   char *r;
 441   const char *path;
 442   if (argc != 1) {
 443     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 444     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 445     return -1;
 446   }
 447   path = argv[0];
 448   r = guestfs_cat (g, path);
 449   if (r == NULL) return -1;
 450   printf ("%s\n", r);
 451   free (r);
 452   return 0;
 453 }
 454
 455 static int run_ll (const char *cmd, int argc, char *argv[])
 456 {
 457   char *r;
 458   const char *directory;
 459   if (argc != 1) {
 460     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 461     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 462     return -1;
 463   }
 464   directory = argv[0];
 465   r = guestfs_ll (g, directory);
 466   if (r == NULL) return -1;
 467   printf ("%s\n", r);
 468   free (r);
 469   return 0;
 470 }
 471
 472 static int run_ls (const char *cmd, int argc, char *argv[])
 473 {
 474   char **r;
 475   const char *directory;
 476   if (argc != 1) {
 477     fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
 478     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 479     return -1;
 480   }
 481   directory = argv[0];
 482   r = guestfs_ls (g, directory);
 483   if (r == NULL) return -1;
 484   print_strings (r);
 485   free_strings (r);
 486   return 0;
 487 }
 488
 489 static int run_list_devices (const char *cmd, int argc, char *argv[])
 490 {
 491   char **r;
 492   if (argc != 0) {
 493     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 494     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 495     return -1;
 496   }
 497   r = guestfs_list_devices (g);
 498   if (r == NULL) return -1;
 499   print_strings (r);
 500   free_strings (r);
 501   return 0;
 502 }
 503
 504 static int run_list_partitions (const char *cmd, int argc, char *argv[])
 505 {
 506   char **r;
 507   if (argc != 0) {
 508     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 509     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 510     return -1;
 511   }
 512   r = guestfs_list_partitions (g);
 513   if (r == NULL) return -1;
 514   print_strings (r);
 515   free_strings (r);
 516   return 0;
 517 }
 518
 519 static int run_pvs (const char *cmd, int argc, char *argv[])
 520 {
 521   char **r;
 522   if (argc != 0) {
 523     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 524     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 525     return -1;
 526   }
 527   r = guestfs_pvs (g);
 528   if (r == NULL) return -1;
 529   print_strings (r);
 530   free_strings (r);
 531   return 0;
 532 }
 533
 534 static int run_vgs (const char *cmd, int argc, char *argv[])
 535 {
 536   char **r;
 537   if (argc != 0) {
 538     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 539     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 540     return -1;
 541   }
 542   r = guestfs_vgs (g);
 543   if (r == NULL) return -1;
 544   print_strings (r);
 545   free_strings (r);
 546   return 0;
 547 }
 548
 549 static int run_lvs (const char *cmd, int argc, char *argv[])
 550 {
 551   char **r;
 552   if (argc != 0) {
 553     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 554     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 555     return -1;
 556   }
 557   r = guestfs_lvs (g);
 558   if (r == NULL) return -1;
 559   print_strings (r);
 560   free_strings (r);
 561   return 0;
 562 }
 563
 564 static int run_pvs_full (const char *cmd, int argc, char *argv[])
 565 {
 566   struct guestfs_lvm_pv_list *r;
 567   if (argc != 0) {
 568     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 569     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 570     return -1;
 571   }
 572   r = guestfs_pvs_full (g);
 573   if (r == NULL) return -1;
 574   print_pv_list (r);
 575   guestfs_free_lvm_pv_list (r);
 576   return 0;
 577 }
 578
 579 static int run_vgs_full (const char *cmd, int argc, char *argv[])
 580 {
 581   struct guestfs_lvm_vg_list *r;
 582   if (argc != 0) {
 583     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 584     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 585     return -1;
 586   }
 587   r = guestfs_vgs_full (g);
 588   if (r == NULL) return -1;
 589   print_vg_list (r);
 590   guestfs_free_lvm_vg_list (r);
 591   return 0;
 592 }
 593
 594 static int run_lvs_full (const char *cmd, int argc, char *argv[])
 595 {
 596   struct guestfs_lvm_lv_list *r;
 597   if (argc != 0) {
 598     fprintf (stderr, "%s should have 0 parameter(s)\n", cmd);
 599     fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
 600     return -1;
 601   }
 602   r = guestfs_lvs_full (g);
 603   if (r == NULL) return -1;
 604   print_lv_list (r);
 605   guestfs_free_lvm_lv_list (r);
 606   return 0;
 607 }
 608
 609 int run_action (const char *cmd, int argc, char *argv[])
 610 {
 611   if (strcasecmp (cmd, "launch") == 0 || strcasecmp (cmd, "run") == 0)
 612     return run_launch (cmd, argc, argv);
 613   else
 614   if (strcasecmp (cmd, "kill_subprocess") == 0 || strcasecmp (cmd, "kill-subprocess") == 0)
 615     return run_kill_subprocess (cmd, argc, argv);
 616   else
 617   if (strcasecmp (cmd, "add_drive") == 0 || strcasecmp (cmd, "add-drive") == 0 || strcasecmp (cmd, "add") == 0)
 618     return run_add_drive (cmd, argc, argv);
 619   else
 620   if (strcasecmp (cmd, "add_cdrom") == 0 || strcasecmp (cmd, "add-cdrom") == 0 || strcasecmp (cmd, "cdrom") == 0)
 621     return run_add_cdrom (cmd, argc, argv);
 622   else
 623   if (strcasecmp (cmd, "config") == 0)
 624     return run_config (cmd, argc, argv);
 625   else
 626   if (strcasecmp (cmd, "set_path") == 0 || strcasecmp (cmd, "set-path") == 0 || strcasecmp (cmd, "path") == 0)
 627     return run_set_path (cmd, argc, argv);
 628   else
 629   if (strcasecmp (cmd, "get_path") == 0 || strcasecmp (cmd, "get-path") == 0)
 630     return run_get_path (cmd, argc, argv);
 631   else
 632   if (strcasecmp (cmd, "set_autosync") == 0 || strcasecmp (cmd, "set-autosync") == 0 || strcasecmp (cmd, "autosync") == 0)
 633     return run_set_autosync (cmd, argc, argv);
 634   else
 635   if (strcasecmp (cmd, "get_autosync") == 0 || strcasecmp (cmd, "get-autosync") == 0)
 636     return run_get_autosync (cmd, argc, argv);
 637   else
 638   if (strcasecmp (cmd, "set_verbose") == 0 || strcasecmp (cmd, "set-verbose") == 0 || strcasecmp (cmd, "verbose") == 0)
 639     return run_set_verbose (cmd, argc, argv);
 640   else
 641   if (strcasecmp (cmd, "get_verbose") == 0 || strcasecmp (cmd, "get-verbose") == 0)
 642     return run_get_verbose (cmd, argc, argv);
 643   else
 644   if (strcasecmp (cmd, "mount") == 0)
 645     return run_mount (cmd, argc, argv);
 646   else
 647   if (strcasecmp (cmd, "sync") == 0)
 648     return run_sync (cmd, argc, argv);
 649   else
 650   if (strcasecmp (cmd, "touch") == 0)
 651     return run_touch (cmd, argc, argv);
 652   else
 653   if (strcasecmp (cmd, "cat") == 0)
 654     return run_cat (cmd, argc, argv);
 655   else
 656   if (strcasecmp (cmd, "ll") == 0)
 657     return run_ll (cmd, argc, argv);
 658   else
 659   if (strcasecmp (cmd, "ls") == 0)
 660     return run_ls (cmd, argc, argv);
 661   else
 662   if (strcasecmp (cmd, "list_devices") == 0 || strcasecmp (cmd, "list-devices") == 0)
 663     return run_list_devices (cmd, argc, argv);
 664   else
 665   if (strcasecmp (cmd, "list_partitions") == 0 || strcasecmp (cmd, "list-partitions") == 0)
 666     return run_list_partitions (cmd, argc, argv);
 667   else
 668   if (strcasecmp (cmd, "pvs") == 0)
 669     return run_pvs (cmd, argc, argv);
 670   else
 671   if (strcasecmp (cmd, "vgs") == 0)
 672     return run_vgs (cmd, argc, argv);
 673   else
 674   if (strcasecmp (cmd, "lvs") == 0)
 675     return run_lvs (cmd, argc, argv);
 676   else
 677   if (strcasecmp (cmd, "pvs_full") == 0 || strcasecmp (cmd, "pvs-full") == 0)
 678     return run_pvs_full (cmd, argc, argv);
 679   else
 680   if (strcasecmp (cmd, "vgs_full") == 0 || strcasecmp (cmd, "vgs-full") == 0)
 681     return run_vgs_full (cmd, argc, argv);
 682   else
 683   if (strcasecmp (cmd, "lvs_full") == 0 || strcasecmp (cmd, "lvs-full") == 0)
 684     return run_lvs_full (cmd, argc, argv);
 685   else
 686     {
 687       fprintf (stderr, "%s: unknown command\n", cmd);
 688       return -1;
 689     }
 690   return 0;
 691 }
 692