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