src/generator.ml

   1 #!/usr/bin/env ocaml
   2 (* libguestfs
   3  * Copyright (C) 2009 Red Hat Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  18  *)
  19
  20 (* This script generates a large amount of code and documentation for
  21  * all the daemon actions.
  22  *
  23  * To add a new action there are only two files you need to change,
  24  * this one to describe the interface (see the big table below), and
  25  * daemon/<somefile>.c to write the implementation.
  26  *
  27  * After editing this file, run it (./src/generator.ml) to regenerate
  28  * all the output files.
  29  *
  30  * IMPORTANT: This script should NOT print any warnings.  If it prints
  31  * warnings, you should treat them as errors.
  32  * [Need to add -warn-error to ocaml command line]
  33  *)
  34
  35 #load "unix.cma";;
  36 #load "str.cma";;
  37
  38 open Printf
  39
  40 type style = ret * args
  41 and ret =
  42     (* "RErr" as a return value means an int used as a simple error
  43      * indication, ie. 0 or -1.
  44      *)
  45   | RErr
  46     (* "RInt" as a return value means an int which is -1 for error
  47      * or any value >= 0 on success.  Only use this for smallish
  48      * positive ints (0 <= i < 2^30).
  49      *)
  50   | RInt of string
  51     (* "RInt64" is the same as RInt, but is guaranteed to be able
  52      * to return a full 64 bit value, _except_ that -1 means error
  53      * (so -1 cannot be a valid, non-error return value).
  54      *)
  55   | RInt64 of string
  56     (* "RBool" is a bool return value which can be true/false or
  57      * -1 for error.
  58      *)
  59   | RBool of string
  60     (* "RConstString" is a string that refers to a constant value.
  61      * Try to avoid using this.  In particular you cannot use this
  62      * for values returned from the daemon, because there is no
  63      * thread-safe way to return them in the C API.
  64      *)
  65   | RConstString of string
  66     (* "RString" and "RStringList" are caller-frees. *)
  67   | RString of string
  68   | RStringList of string
  69     (* Some limited tuples are possible: *)
  70   | RIntBool of string * string
  71     (* LVM PVs, VGs and LVs. *)
  72   | RPVList of string
  73   | RVGList of string
  74   | RLVList of string
  75     (* Stat buffers. *)
  76   | RStat of string
  77   | RStatVFS of string
  78     (* Key-value pairs of untyped strings.  Turns into a hashtable or
  79      * dictionary in languages which support it.  DON'T use this as a
  80      * general "bucket" for results.  Prefer a stronger typed return
  81      * value if one is available, or write a custom struct.  Don't use
  82      * this if the list could potentially be very long, since it is
  83      * inefficient.  Keys should be unique.  NULLs are not permitted.
  84      *)
  85   | RHashtable of string
  86
  87 and args = argt list    (* Function parameters, guestfs handle is implicit. *)
  88
  89     (* Note in future we should allow a "variable args" parameter as
  90      * the final parameter, to allow commands like
  91      *   chmod mode file [file(s)...]
  92      * This is not implemented yet, but many commands (such as chmod)
  93      * are currently defined with the argument order keeping this future
  94      * possibility in mind.
  95      *)
  96 and argt =
  97   | String of string    (* const char *name, cannot be NULL *)
  98   | OptString of string (* const char *name, may be NULL *)
  99   | StringList of string(* list of strings (each string cannot be NULL) *)
 100   | Bool of string      (* boolean *)
 101   | Int of string       (* int (smallish ints, signed, <= 31 bits) *)
 102     (* These are treated as filenames (simple string parameters) in
 103      * the C API and bindings.  But in the RPC protocol, we transfer
 104      * the actual file content up to or down from the daemon.
 105      * FileIn: local machine -> daemon (in request)
 106      * FileOut: daemon -> local machine (in reply)
 107      * In guestfish (only), the special name "-" means read from
 108      * stdin or write to stdout.
 109      *)
 110   | FileIn of string
 111   | FileOut of string
 112
 113 type flags =
 114   | ProtocolLimitWarning  (* display warning about protocol size limits *)
 115   | DangerWillRobinson    (* flags particularly dangerous commands *)
 116   | FishAlias of string   (* provide an alias for this cmd in guestfish *)
 117   | FishAction of string  (* call this function in guestfish *)
 118   | NotInFish             (* do not export via guestfish *)
 119   | NotInDocs             (* do not add this function to documentation *)
 120
 121 let protocol_limit_warning =
 122   "Because of the message protocol, there is a transfer limit
 123 of somewhere between 2MB and 4MB.  To transfer large files you should use
 124 FTP."
 125
 126 let danger_will_robinson =
 127   "B<This command is dangerous.  Without careful use you
 128 can easily destroy all your data>."
 129
 130 (* You can supply zero or as many tests as you want per API call.
 131  *
 132  * Note that the test environment has 3 block devices, of size 500MB,
 133  * 50MB and 10MB (respectively /dev/sda, /dev/sdb, /dev/sdc), and
 134  * a fourth squashfs block device with some known files on it (/dev/sdd).
 135  *
 136  * Note for partitioning purposes, the 500MB device has 63 cylinders.
 137  *
 138  * The squashfs block device (/dev/sdd) comes from images/test.sqsh.
 139  *
 140  * To be able to run the tests in a reasonable amount of time,
 141  * the virtual machine and block devices are reused between tests.
 142  * So don't try testing kill_subprocess :-x
 143  *
 144  * Between each test we blockdev-setrw, umount-all, lvm-remove-all.
 145  *
 146  * If the appliance is running an older Linux kernel (eg. RHEL 5) then
 147  * devices are named /dev/hda etc.  To cope with this, the test suite
 148  * adds some hairly logic to detect this case, and then automagically
 149  * replaces all strings which match "/dev/sd.*" with "/dev/hd.*".
 150  * When writing test cases you shouldn't have to worry about this
 151  * difference.
 152  *
 153  * Don't assume anything about the previous contents of the block
 154  * devices.  Use 'Init*' to create some initial scenarios.
 155  *
 156  * You can add a prerequisite clause to any individual test.  This
 157  * is a run-time check, which, if it fails, causes the test to be
 158  * skipped.  Useful if testing a command which might not work on
 159  * all variations of libguestfs builds.  A test that has prerequisite
 160  * of 'Always' is run unconditionally.
 161  *
 162  * In addition, packagers can skip individual tests by setting the
 163  * environment variables:     eg:
 164  *   SKIP_TEST_<CMD>_<NUM>=1  SKIP_TEST_COMMAND_3=1  (skips test #3 of command)
 165  *   SKIP_TEST_<CMD>=1        SKIP_TEST_ZEROFREE=1   (skips all zerofree tests)
 166  *)
 167 type tests = (test_init * test_prereq * test) list
 168 and test =
 169     (* Run the command sequence and just expect nothing to fail. *)
 170   | TestRun of seq
 171     (* Run the command sequence and expect the output of the final
 172      * command to be the string.
 173      *)
 174   | TestOutput of seq * string
 175     (* Run the command sequence and expect the output of the final
 176      * command to be the list of strings.
 177      *)
 178   | TestOutputList of seq * string list
 179     (* Run the command sequence and expect the output of the final
 180      * command to be the integer.
 181      *)
 182   | TestOutputInt of seq * int
 183     (* Run the command sequence and expect the output of the final
 184      * command to be a true value (!= 0 or != NULL).
 185      *)
 186   | TestOutputTrue of seq
 187     (* Run the command sequence and expect the output of the final
 188      * command to be a false value (== 0 or == NULL, but not an error).
 189      *)
 190   | TestOutputFalse of seq
 191     (* Run the command sequence and expect the output of the final
 192      * command to be a list of the given length (but don't care about
 193      * content).
 194      *)
 195   | TestOutputLength of seq * int
 196     (* Run the command sequence and expect the output of the final
 197      * command to be a structure.
 198      *)
 199   | TestOutputStruct of seq * test_field_compare list
 200     (* Run the command sequence and expect the final command (only)
 201      * to fail.
 202      *)
 203   | TestLastFail of seq
 204
 205 and test_field_compare =
 206   | CompareWithInt of string * int
 207   | CompareWithString of string * string
 208   | CompareFieldsIntEq of string * string
 209   | CompareFieldsStrEq of string * string
 210
 211 (* Test prerequisites. *)
 212 and test_prereq =
 213     (* Test always runs. *)
 214   | Always
 215     (* Test is currently disabled - eg. it fails, or it tests some
 216      * unimplemented feature.
 217      *)
 218   | Disabled
 219     (* 'string' is some C code (a function body) that should return
 220      * true or false.  The test will run if the code returns true.
 221      *)
 222   | If of string
 223     (* As for 'If' but the test runs _unless_ the code returns true. *)
 224   | Unless of string
 225
 226 (* Some initial scenarios for testing. *)
 227 and test_init =
 228     (* Do nothing, block devices could contain random stuff including
 229      * LVM PVs, and some filesystems might be mounted.  This is usually
 230      * a bad idea.
 231      *)
 232   | InitNone
 233     (* Block devices are empty and no filesystems are mounted. *)
 234   | InitEmpty
 235     (* /dev/sda contains a single partition /dev/sda1, which is formatted
 236      * as ext2, empty [except for lost+found] and mounted on /.
 237      * /dev/sdb and /dev/sdc may have random content.
 238      * No LVM.
 239      *)
 240   | InitBasicFS
 241     (* /dev/sda:
 242      *   /dev/sda1 (is a PV):
 243      *     /dev/VG/LV (size 8MB):
 244      *       formatted as ext2, empty [except for lost+found], mounted on /
 245      * /dev/sdb and /dev/sdc may have random content.
 246      *)
 247   | InitBasicFSonLVM
 248
 249 (* Sequence of commands for testing. *)
 250 and seq = cmd list
 251 and cmd = string list
 252
 253 (* Note about long descriptions: When referring to another
 254  * action, use the format C<guestfs_other> (ie. the full name of
 255  * the C function).  This will be replaced as appropriate in other
 256  * language bindings.
 257  *
 258  * Apart from that, long descriptions are just perldoc paragraphs.
 259  *)
 260
 261 (* These test functions are used in the language binding tests. *)
 262
 263 let test_all_args = [
 264   String "str";
 265   OptString "optstr";
 266   StringList "strlist";
 267   Bool "b";
 268   Int "integer";
 269   FileIn "filein";
 270   FileOut "fileout";
 271 ]
 272
 273 let test_all_rets = [
 274   (* except for RErr, which is tested thoroughly elsewhere *)
 275   "test0rint",         RInt "valout";
 276   "test0rint64",       RInt64 "valout";
 277   "test0rbool",        RBool "valout";
 278   "test0rconststring", RConstString "valout";
 279   "test0rstring",      RString "valout";
 280   "test0rstringlist",  RStringList "valout";
 281   "test0rintbool",     RIntBool ("valout", "valout");
 282   "test0rpvlist",      RPVList "valout";
 283   "test0rvglist",      RVGList "valout";
 284   "test0rlvlist",      RLVList "valout";
 285   "test0rstat",        RStat "valout";
 286   "test0rstatvfs",     RStatVFS "valout";
 287   "test0rhashtable",   RHashtable "valout";
 288 ]
 289
 290 let test_functions = [
 291   ("test0", (RErr, test_all_args), -1, [NotInFish; NotInDocs],
 292    [],
 293    "internal test function - do not use",
 294    "\
 295 This is an internal test function which is used to test whether
 296 the automatically generated bindings can handle every possible
 297 parameter type correctly.
 298
 299 It echos the contents of each parameter to stdout.
 300
 301 You probably don't want to call this function.");
 302 ] @ List.flatten (
 303   List.map (
 304     fun (name, ret) ->
 305       [(name, (ret, [String "val"]), -1, [NotInFish; NotInDocs],
 306         [],
 307         "internal test function - do not use",
 308         "\
 309 This is an internal test function which is used to test whether
 310 the automatically generated bindings can handle every possible
 311 return type correctly.
 312
 313 It converts string C<val> to the return type.
 314
 315 You probably don't want to call this function.");
 316        (name ^ "err", (ret, []), -1, [NotInFish; NotInDocs],
 317         [],
 318         "internal test function - do not use",
 319         "\
 320 This is an internal test function which is used to test whether
 321 the automatically generated bindings can handle every possible
 322 return type correctly.
 323
 324 This function always returns an error.
 325
 326 You probably don't want to call this function.")]
 327   ) test_all_rets
 328 )
 329
 330 (* non_daemon_functions are any functions which don't get processed
 331  * in the daemon, eg. functions for setting and getting local
 332  * configuration values.
 333  *)
 334
 335 let non_daemon_functions = test_functions @ [
 336   ("launch", (RErr, []), -1, [FishAlias "run"; FishAction "launch"],
 337    [],
 338    "launch the qemu subprocess",
 339    "\
 340 Internally libguestfs is implemented by running a virtual machine
 341 using L<qemu(1)>.
 342
 343 You should call this after configuring the handle
 344 (eg. adding drives) but before performing any actions.");
 345
 346   ("wait_ready", (RErr, []), -1, [NotInFish],
 347    [],
 348    "wait until the qemu subprocess launches",
 349    "\
 350 Internally libguestfs is implemented by running a virtual machine
 351 using L<qemu(1)>.
 352
 353 You should call this after C<guestfs_launch> to wait for the launch
 354 to complete.");
 355
 356   ("kill_subprocess", (RErr, []), -1, [],
 357    [],
 358    "kill the qemu subprocess",
 359    "\
 360 This kills the qemu subprocess.  You should never need to call this.");
 361
 362   ("add_drive", (RErr, [String "filename"]), -1, [FishAlias "add"],
 363    [],
 364    "add an image to examine or modify",
 365    "\
 366 This function adds a virtual machine disk image C<filename> to the
 367 guest.  The first time you call this function, the disk appears as IDE
 368 disk 0 (C</dev/sda>) in the guest, the second time as C</dev/sdb>, and
 369 so on.
 370
 371 You don't necessarily need to be root when using libguestfs.  However
 372 you obviously do need sufficient permissions to access the filename
 373 for whatever operations you want to perform (ie. read access if you
 374 just want to read the image or write access if you want to modify the
 375 image).
 376
 377 This is equivalent to the qemu parameter C<-drive file=filename>.");
 378
 379   ("add_cdrom", (RErr, [String "filename"]), -1, [FishAlias "cdrom"],
 380    [],
 381    "add a CD-ROM disk image to examine",
 382    "\
 383 This function adds a virtual CD-ROM disk image to the guest.
 384
 385 This is equivalent to the qemu parameter C<-cdrom filename>.");
 386
 387   ("config", (RErr, [String "qemuparam"; OptString "qemuvalue"]), -1, [],
 388    [],
 389    "add qemu parameters",
 390    "\
 391 This can be used to add arbitrary qemu command line parameters
 392 of the form C<-param value>.  Actually it's not quite arbitrary - we
 393 prevent you from setting some parameters which would interfere with
 394 parameters that we use.
 395
 396 The first character of C<param> string must be a C<-> (dash).
 397
 398 C<value> can be NULL.");
 399
 400   ("set_qemu", (RErr, [String "qemu"]), -1, [FishAlias "qemu"],
 401    [],
 402    "set the qemu binary",
 403    "\
 404 Set the qemu binary that we will use.
 405
 406 The default is chosen when the library was compiled by the
 407 configure script.
 408
 409 You can also override this by setting the C<LIBGUESTFS_QEMU>
 410 environment variable.
 411
 412 Setting C<qemu> to C<NULL> restores the default qemu binary.");
 413
 414   ("get_qemu", (RConstString "qemu", []), -1, [],
 415    [],
 416    "get the qemu binary",
 417    "\
 418 Return the current qemu binary.
 419
 420 This is always non-NULL.  If it wasn't set already, then this will
 421 return the default qemu binary name.");
 422
 423   ("set_path", (RErr, [String "path"]), -1, [FishAlias "path"],
 424    [],
 425    "set the search path",
 426    "\
 427 Set the path that libguestfs searches for kernel and initrd.img.
 428
 429 The default is C<$libdir/guestfs> unless overridden by setting
 430 C<LIBGUESTFS_PATH> environment variable.
 431
 432 Setting C<path> to C<NULL> restores the default path.");
 433
 434   ("get_path", (RConstString "path", []), -1, [],
 435    [],
 436    "get the search path",
 437    "\
 438 Return the current search path.
 439
 440 This is always non-NULL.  If it wasn't set already, then this will
 441 return the default path.");
 442
 443   ("set_append", (RErr, [String "append"]), -1, [FishAlias "append"],
 444    [],
 445    "add options to kernel command line",
 446    "\
 447 This function is used to add additional options to the
 448 guest kernel command line.
 449
 450 The default is C<NULL> unless overridden by setting
 451 C<LIBGUESTFS_APPEND> environment variable.
 452
 453 Setting C<append> to C<NULL> means I<no> additional options
 454 are passed (libguestfs always adds a few of its own).");
 455
 456   ("get_append", (RConstString "append", []), -1, [],
 457    [],
 458    "get the additional kernel options",
 459    "\
 460 Return the additional kernel options which are added to the
 461 guest kernel command line.
 462
 463 If C<NULL> then no options are added.");
 464
 465   ("set_autosync", (RErr, [Bool "autosync"]), -1, [FishAlias "autosync"],
 466    [],
 467    "set autosync mode",
 468    "\
 469 If C<autosync> is true, this enables autosync.  Libguestfs will make a
 470 best effort attempt to run C<guestfs_umount_all> followed by
 471 C<guestfs_sync> when the handle is closed
 472 (also if the program exits without closing handles).
 473
 474 This is disabled by default (except in guestfish where it is
 475 enabled by default).");
 476
 477   ("get_autosync", (RBool "autosync", []), -1, [],
 478    [],
 479    "get autosync mode",
 480    "\
 481 Get the autosync flag.");
 482
 483   ("set_verbose", (RErr, [Bool "verbose"]), -1, [FishAlias "verbose"],
 484    [],
 485    "set verbose mode",
 486    "\
 487 If C<verbose> is true, this turns on verbose messages (to C<stderr>).
 488
 489 Verbose messages are disabled unless the environment variable
 490 C<LIBGUESTFS_DEBUG> is defined and set to C<1>.");
 491
 492   ("get_verbose", (RBool "verbose", []), -1, [],
 493    [],
 494    "get verbose mode",
 495    "\
 496 This returns the verbose messages flag.");
 497
 498   ("is_ready", (RBool "ready", []), -1, [],
 499    [],
 500    "is ready to accept commands",
 501    "\
 502 This returns true iff this handle is ready to accept commands
 503 (in the C<READY> state).
 504
 505 For more information on states, see L<guestfs(3)>.");
 506
 507   ("is_config", (RBool "config", []), -1, [],
 508    [],
 509    "is in configuration state",
 510    "\
 511 This returns true iff this handle is being configured
 512 (in the C<CONFIG> state).
 513
 514 For more information on states, see L<guestfs(3)>.");
 515
 516   ("is_launching", (RBool "launching", []), -1, [],
 517    [],
 518    "is launching subprocess",
 519    "\
 520 This returns true iff this handle is launching the subprocess
 521 (in the C<LAUNCHING> state).
 522
 523 For more information on states, see L<guestfs(3)>.");
 524
 525   ("is_busy", (RBool "busy", []), -1, [],
 526    [],
 527    "is busy processing a command",
 528    "\
 529 This returns true iff this handle is busy processing a command
 530 (in the C<BUSY> state).
 531
 532 For more information on states, see L<guestfs(3)>.");
 533
 534   ("get_state", (RInt "state", []), -1, [],
 535    [],
 536    "get the current state",
 537    "\
 538 This returns the current state as an opaque integer.  This is
 539 only useful for printing debug and internal error messages.
 540
 541 For more information on states, see L<guestfs(3)>.");
 542
 543   ("set_busy", (RErr, []), -1, [NotInFish],
 544    [],
 545    "set state to busy",
 546    "\
 547 This sets the state to C<BUSY>.  This is only used when implementing
 548 actions using the low-level API.
 549
 550 For more information on states, see L<guestfs(3)>.");
 551
 552   ("set_ready", (RErr, []), -1, [NotInFish],
 553    [],
 554    "set state to ready",
 555    "\
 556 This sets the state to C<READY>.  This is only used when implementing
 557 actions using the low-level API.
 558
 559 For more information on states, see L<guestfs(3)>.");
 560
 561   ("end_busy", (RErr, []), -1, [NotInFish],
 562    [],
 563    "leave the busy state",
 564    "\
 565 This sets the state to C<READY>, or if in C<CONFIG> then it leaves the
 566 state as is.  This is only used when implementing
 567 actions using the low-level API.
 568
 569 For more information on states, see L<guestfs(3)>.");
 570
 571 ]
 572
 573 (* daemon_functions are any functions which cause some action
 574  * to take place in the daemon.
 575  *)
 576
 577 let daemon_functions = [
 578   ("mount", (RErr, [String "device"; String "mountpoint"]), 1, [],
 579    [InitEmpty, Always, TestOutput (
 580       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
 581        ["mkfs"; "ext2"; "/dev/sda1"];
 582        ["mount"; "/dev/sda1"; "/"];
 583        ["write_file"; "/new"; "new file contents"; "0"];
 584        ["cat"; "/new"]], "new file contents")],
 585    "mount a guest disk at a position in the filesystem",
 586    "\
 587 Mount a guest disk at a position in the filesystem.  Block devices
 588 are named C</dev/sda>, C</dev/sdb> and so on, as they were added to
 589 the guest.  If those block devices contain partitions, they will have
 590 the usual names (eg. C</dev/sda1>).  Also LVM C</dev/VG/LV>-style
 591 names can be used.
 592
 593 The rules are the same as for L<mount(2)>:  A filesystem must
 594 first be mounted on C</> before others can be mounted.  Other
 595 filesystems can only be mounted on directories which already
 596 exist.
 597
 598 The mounted filesystem is writable, if we have sufficient permissions
 599 on the underlying device.
 600
 601 The filesystem options C<sync> and C<noatime> are set with this
 602 call, in order to improve reliability.");
 603
 604   ("sync", (RErr, []), 2, [],
 605    [ InitEmpty, Always, TestRun [["sync"]]],
 606    "sync disks, writes are flushed through to the disk image",
 607    "\
 608 This syncs the disk, so that any writes are flushed through to the
 609 underlying disk image.
 610
 611 You should always call this if you have modified a disk image, before
 612 closing the handle.");
 613
 614   ("touch", (RErr, [String "path"]), 3, [],
 615    [InitBasicFS, Always, TestOutputTrue (
 616       [["touch"; "/new"];
 617        ["exists"; "/new"]])],
 618    "update file timestamps or create a new file",
 619    "\
 620 Touch acts like the L<touch(1)> command.  It can be used to
 621 update the timestamps on a file, or, if the file does not exist,
 622 to create a new zero-length file.");
 623
 624   ("cat", (RString "content", [String "path"]), 4, [ProtocolLimitWarning],
 625    [InitBasicFS, Always, TestOutput (
 626       [["write_file"; "/new"; "new file contents"; "0"];
 627        ["cat"; "/new"]], "new file contents")],
 628    "list the contents of a file",
 629    "\
 630 Return the contents of the file named C<path>.
 631
 632 Note that this function cannot correctly handle binary files
 633 (specifically, files containing C<\\0> character which is treated
 634 as end of string).  For those you need to use the C<guestfs_download>
 635 function which has a more complex interface.");
 636
 637   ("ll", (RString "listing", [String "directory"]), 5, [],
 638    [], (* XXX Tricky to test because it depends on the exact format
 639         * of the 'ls -l' command, which changes between F10 and F11.
 640         *)
 641    "list the files in a directory (long format)",
 642    "\
 643 List the files in C<directory> (relative to the root directory,
 644 there is no cwd) in the format of 'ls -la'.
 645
 646 This command is mostly useful for interactive sessions.  It
 647 is I<not> intended that you try to parse the output string.");
 648
 649   ("ls", (RStringList "listing", [String "directory"]), 6, [],
 650    [InitBasicFS, Always, TestOutputList (
 651       [["touch"; "/new"];
 652        ["touch"; "/newer"];
 653        ["touch"; "/newest"];
 654        ["ls"; "/"]], ["lost+found"; "new"; "newer"; "newest"])],
 655    "list the files in a directory",
 656    "\
 657 List the files in C<directory> (relative to the root directory,
 658 there is no cwd).  The '.' and '..' entries are not returned, but
 659 hidden files are shown.
 660
 661 This command is mostly useful for interactive sessions.  Programs
 662 should probably use C<guestfs_readdir> instead.");
 663
 664   ("list_devices", (RStringList "devices", []), 7, [],
 665    [InitEmpty, Always, TestOutputList (
 666       [["list_devices"]], ["/dev/sda"; "/dev/sdb"; "/dev/sdc"; "/dev/sdd"])],
 667    "list the block devices",
 668    "\
 669 List all the block devices.
 670
 671 The full block device names are returned, eg. C</dev/sda>");
 672
 673   ("list_partitions", (RStringList "partitions", []), 8, [],
 674    [InitBasicFS, Always, TestOutputList (
 675       [["list_partitions"]], ["/dev/sda1"]);
 676     InitEmpty, Always, TestOutputList (
 677       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
 678        ["list_partitions"]], ["/dev/sda1"; "/dev/sda2"; "/dev/sda3"])],
 679    "list the partitions",
 680    "\
 681 List all the partitions detected on all block devices.
 682
 683 The full partition device names are returned, eg. C</dev/sda1>
 684
 685 This does not return logical volumes.  For that you will need to
 686 call C<guestfs_lvs>.");
 687
 688   ("pvs", (RStringList "physvols", []), 9, [],
 689    [InitBasicFSonLVM, Always, TestOutputList (
 690       [["pvs"]], ["/dev/sda1"]);
 691     InitEmpty, Always, TestOutputList (
 692       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
 693        ["pvcreate"; "/dev/sda1"];
 694        ["pvcreate"; "/dev/sda2"];
 695        ["pvcreate"; "/dev/sda3"];
 696        ["pvs"]], ["/dev/sda1"; "/dev/sda2"; "/dev/sda3"])],
 697    "list the LVM physical volumes (PVs)",
 698    "\
 699 List all the physical volumes detected.  This is the equivalent
 700 of the L<pvs(8)> command.
 701
 702 This returns a list of just the device names that contain
 703 PVs (eg. C</dev/sda2>).
 704
 705 See also C<guestfs_pvs_full>.");
 706
 707   ("vgs", (RStringList "volgroups", []), 10, [],
 708    [InitBasicFSonLVM, Always, TestOutputList (
 709       [["vgs"]], ["VG"]);
 710     InitEmpty, Always, TestOutputList (
 711       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
 712        ["pvcreate"; "/dev/sda1"];
 713        ["pvcreate"; "/dev/sda2"];
 714        ["pvcreate"; "/dev/sda3"];
 715        ["vgcreate"; "VG1"; "/dev/sda1 /dev/sda2"];
 716        ["vgcreate"; "VG2"; "/dev/sda3"];
 717        ["vgs"]], ["VG1"; "VG2"])],
 718    "list the LVM volume groups (VGs)",
 719    "\
 720 List all the volumes groups detected.  This is the equivalent
 721 of the L<vgs(8)> command.
 722
 723 This returns a list of just the volume group names that were
 724 detected (eg. C<VolGroup00>).
 725
 726 See also C<guestfs_vgs_full>.");
 727
 728   ("lvs", (RStringList "logvols", []), 11, [],
 729    [InitBasicFSonLVM, Always, TestOutputList (
 730       [["lvs"]], ["/dev/VG/LV"]);
 731     InitEmpty, Always, TestOutputList (
 732       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
 733        ["pvcreate"; "/dev/sda1"];
 734        ["pvcreate"; "/dev/sda2"];
 735        ["pvcreate"; "/dev/sda3"];
 736        ["vgcreate"; "VG1"; "/dev/sda1 /dev/sda2"];
 737        ["vgcreate"; "VG2"; "/dev/sda3"];
 738        ["lvcreate"; "LV1"; "VG1"; "50"];
 739        ["lvcreate"; "LV2"; "VG1"; "50"];
 740        ["lvcreate"; "LV3"; "VG2"; "50"];
 741        ["lvs"]], ["/dev/VG1/LV1"; "/dev/VG1/LV2"; "/dev/VG2/LV3"])],
 742    "list the LVM logical volumes (LVs)",
 743    "\
 744 List all the logical volumes detected.  This is the equivalent
 745 of the L<lvs(8)> command.
 746
 747 This returns a list of the logical volume device names
 748 (eg. C</dev/VolGroup00/LogVol00>).
 749
 750 See also C<guestfs_lvs_full>.");
 751
 752   ("pvs_full", (RPVList "physvols", []), 12, [],
 753    [], (* XXX how to test? *)
 754    "list the LVM physical volumes (PVs)",
 755    "\
 756 List all the physical volumes detected.  This is the equivalent
 757 of the L<pvs(8)> command.  The \"full\" version includes all fields.");
 758
 759   ("vgs_full", (RVGList "volgroups", []), 13, [],
 760    [], (* XXX how to test? *)
 761    "list the LVM volume groups (VGs)",
 762    "\
 763 List all the volumes groups detected.  This is the equivalent
 764 of the L<vgs(8)> command.  The \"full\" version includes all fields.");
 765
 766   ("lvs_full", (RLVList "logvols", []), 14, [],
 767    [], (* XXX how to test? *)
 768    "list the LVM logical volumes (LVs)",
 769    "\
 770 List all the logical volumes detected.  This is the equivalent
 771 of the L<lvs(8)> command.  The \"full\" version includes all fields.");
 772
 773   ("read_lines", (RStringList "lines", [String "path"]), 15, [],
 774    [InitBasicFS, Always, TestOutputList (
 775       [["write_file"; "/new"; "line1\r\nline2\nline3"; "0"];
 776        ["read_lines"; "/new"]], ["line1"; "line2"; "line3"]);
 777     InitBasicFS, Always, TestOutputList (
 778       [["write_file"; "/new"; ""; "0"];
 779        ["read_lines"; "/new"]], [])],
 780    "read file as lines",
 781    "\
 782 Return the contents of the file named C<path>.
 783
 784 The file contents are returned as a list of lines.  Trailing
 785 C<LF> and C<CRLF> character sequences are I<not> returned.
 786
 787 Note that this function cannot correctly handle binary files
 788 (specifically, files containing C<\\0> character which is treated
 789 as end of line).  For those you need to use the C<guestfs_read_file>
 790 function which has a more complex interface.");
 791
 792   ("aug_init", (RErr, [String "root"; Int "flags"]), 16, [],
 793    [], (* XXX Augeas code needs tests. *)
 794    "create a new Augeas handle",
 795    "\
 796 Create a new Augeas handle for editing configuration files.
 797 If there was any previous Augeas handle associated with this
 798 guestfs session, then it is closed.
 799
 800 You must call this before using any other C<guestfs_aug_*>
 801 commands.
 802
 803 C<root> is the filesystem root.  C<root> must not be NULL,
 804 use C</> instead.
 805
 806 The flags are the same as the flags defined in
 807 E<lt>augeas.hE<gt>, the logical I<or> of the following
 808 integers:
 809
 810 =over 4
 811
 812 =item C<AUG_SAVE_BACKUP> = 1
 813
 814 Keep the original file with a C<.augsave> extension.
 815
 816 =item C<AUG_SAVE_NEWFILE> = 2
 817
 818 Save changes into a file with extension C<.augnew>, and
 819 do not overwrite original.  Overrides C<AUG_SAVE_BACKUP>.
 820
 821 =item C<AUG_TYPE_CHECK> = 4
 822
 823 Typecheck lenses (can be expensive).
 824
 825 =item C<AUG_NO_STDINC> = 8
 826
 827 Do not use standard load path for modules.
 828
 829 =item C<AUG_SAVE_NOOP> = 16
 830
 831 Make save a no-op, just record what would have been changed.
 832
 833 =item C<AUG_NO_LOAD> = 32
 834
 835 Do not load the tree in C<guestfs_aug_init>.
 836
 837 =back
 838
 839 To close the handle, you can call C<guestfs_aug_close>.
 840
 841 To find out more about Augeas, see L<http://augeas.net/>.");
 842
 843   ("aug_close", (RErr, []), 26, [],
 844    [], (* XXX Augeas code needs tests. *)
 845    "close the current Augeas handle",
 846    "\
 847 Close the current Augeas handle and free up any resources
 848 used by it.  After calling this, you have to call
 849 C<guestfs_aug_init> again before you can use any other
 850 Augeas functions.");
 851
 852   ("aug_defvar", (RInt "nrnodes", [String "name"; OptString "expr"]), 17, [],
 853    [], (* XXX Augeas code needs tests. *)
 854    "define an Augeas variable",
 855    "\
 856 Defines an Augeas variable C<name> whose value is the result
 857 of evaluating C<expr>.  If C<expr> is NULL, then C<name> is
 858 undefined.
 859
 860 On success this returns the number of nodes in C<expr>, or
 861 C<0> if C<expr> evaluates to something which is not a nodeset.");
 862
 863   ("aug_defnode", (RIntBool ("nrnodes", "created"), [String "name"; String "expr"; String "val"]), 18, [],
 864    [], (* XXX Augeas code needs tests. *)
 865    "define an Augeas node",
 866    "\
 867 Defines a variable C<name> whose value is the result of
 868 evaluating C<expr>.
 869
 870 If C<expr> evaluates to an empty nodeset, a node is created,
 871 equivalent to calling C<guestfs_aug_set> C<expr>, C<value>.
 872 C<name> will be the nodeset containing that single node.
 873
 874 On success this returns a pair containing the
 875 number of nodes in the nodeset, and a boolean flag
 876 if a node was created.");
 877
 878   ("aug_get", (RString "val", [String "path"]), 19, [],
 879    [], (* XXX Augeas code needs tests. *)
 880    "look up the value of an Augeas path",
 881    "\
 882 Look up the value associated with C<path>.  If C<path>
 883 matches exactly one node, the C<value> is returned.");
 884
 885   ("aug_set", (RErr, [String "path"; String "val"]), 20, [],
 886    [], (* XXX Augeas code needs tests. *)
 887    "set Augeas path to value",
 888    "\
 889 Set the value associated with C<path> to C<value>.");
 890
 891   ("aug_insert", (RErr, [String "path"; String "label"; Bool "before"]), 21, [],
 892    [], (* XXX Augeas code needs tests. *)
 893    "insert a sibling Augeas node",
 894    "\
 895 Create a new sibling C<label> for C<path>, inserting it into
 896 the tree before or after C<path> (depending on the boolean
 897 flag C<before>).
 898
 899 C<path> must match exactly one existing node in the tree, and
 900 C<label> must be a label, ie. not contain C</>, C<*> or end
 901 with a bracketed index C<[N]>.");
 902
 903   ("aug_rm", (RInt "nrnodes", [String "path"]), 22, [],
 904    [], (* XXX Augeas code needs tests. *)
 905    "remove an Augeas path",
 906    "\
 907 Remove C<path> and all of its children.
 908
 909 On success this returns the number of entries which were removed.");
 910
 911   ("aug_mv", (RErr, [String "src"; String "dest"]), 23, [],
 912    [], (* XXX Augeas code needs tests. *)
 913    "move Augeas node",
 914    "\
 915 Move the node C<src> to C<dest>.  C<src> must match exactly
 916 one node.  C<dest> is overwritten if it exists.");
 917
 918   ("aug_match", (RStringList "matches", [String "path"]), 24, [],
 919    [], (* XXX Augeas code needs tests. *)
 920    "return Augeas nodes which match path",
 921    "\
 922 Returns a list of paths which match the path expression C<path>.
 923 The returned paths are sufficiently qualified so that they match
 924 exactly one node in the current tree.");
 925
 926   ("aug_save", (RErr, []), 25, [],
 927    [], (* XXX Augeas code needs tests. *)
 928    "write all pending Augeas changes to disk",
 929    "\
 930 This writes all pending changes to disk.
 931
 932 The flags which were passed to C<guestfs_aug_init> affect exactly
 933 how files are saved.");
 934
 935   ("aug_load", (RErr, []), 27, [],
 936    [], (* XXX Augeas code needs tests. *)
 937    "load files into the tree",
 938    "\
 939 Load files into the tree.
 940
 941 See C<aug_load> in the Augeas documentation for the full gory
 942 details.");
 943
 944   ("aug_ls", (RStringList "matches", [String "path"]), 28, [],
 945    [], (* XXX Augeas code needs tests. *)
 946    "list Augeas nodes under a path",
 947    "\
 948 This is just a shortcut for listing C<guestfs_aug_match>
 949 C<path/*> and sorting the resulting nodes into alphabetical order.");
 950
 951   ("rm", (RErr, [String "path"]), 29, [],
 952    [InitBasicFS, Always, TestRun
 953       [["touch"; "/new"];
 954        ["rm"; "/new"]];
 955     InitBasicFS, Always, TestLastFail
 956       [["rm"; "/new"]];
 957     InitBasicFS, Always, TestLastFail
 958       [["mkdir"; "/new"];
 959        ["rm"; "/new"]]],
 960    "remove a file",
 961    "\
 962 Remove the single file C<path>.");
 963
 964   ("rmdir", (RErr, [String "path"]), 30, [],
 965    [InitBasicFS, Always, TestRun
 966       [["mkdir"; "/new"];
 967        ["rmdir"; "/new"]];
 968     InitBasicFS, Always, TestLastFail
 969       [["rmdir"; "/new"]];
 970     InitBasicFS, Always, TestLastFail
 971       [["touch"; "/new"];
 972        ["rmdir"; "/new"]]],
 973    "remove a directory",
 974    "\
 975 Remove the single directory C<path>.");
 976
 977   ("rm_rf", (RErr, [String "path"]), 31, [],
 978    [InitBasicFS, Always, TestOutputFalse
 979       [["mkdir"; "/new"];
 980        ["mkdir"; "/new/foo"];
 981        ["touch"; "/new/foo/bar"];
 982        ["rm_rf"; "/new"];
 983        ["exists"; "/new"]]],
 984    "remove a file or directory recursively",
 985    "\
 986 Remove the file or directory C<path>, recursively removing the
 987 contents if its a directory.  This is like the C<rm -rf> shell
 988 command.");
 989
 990   ("mkdir", (RErr, [String "path"]), 32, [],
 991    [InitBasicFS, Always, TestOutputTrue
 992       [["mkdir"; "/new"];
 993        ["is_dir"; "/new"]];
 994     InitBasicFS, Always, TestLastFail
 995       [["mkdir"; "/new/foo/bar"]]],
 996    "create a directory",
 997    "\
 998 Create a directory named C<path>.");
 999
1000   ("mkdir_p", (RErr, [String "path"]), 33, [],
1001    [InitBasicFS, Always, TestOutputTrue
1002       [["mkdir_p"; "/new/foo/bar"];
1003        ["is_dir"; "/new/foo/bar"]];
1004     InitBasicFS, Always, TestOutputTrue
1005       [["mkdir_p"; "/new/foo/bar"];
1006        ["is_dir"; "/new/foo"]];
1007     InitBasicFS, Always, TestOutputTrue
1008       [["mkdir_p"; "/new/foo/bar"];
1009        ["is_dir"; "/new"]];
1010     (* Regression tests for RHBZ#503133: *)
1011     InitBasicFS, Always, TestRun
1012       [["mkdir"; "/new"];
1013        ["mkdir_p"; "/new"]];
1014     InitBasicFS, Always, TestLastFail
1015       [["touch"; "/new"];
1016        ["mkdir_p"; "/new"]]],
1017    "create a directory and parents",
1018    "\
1019 Create a directory named C<path>, creating any parent directories
1020 as necessary.  This is like the C<mkdir -p> shell command.");
1021
1022   ("chmod", (RErr, [Int "mode"; String "path"]), 34, [],
1023    [], (* XXX Need stat command to test *)
1024    "change file mode",
1025    "\
1026 Change the mode (permissions) of C<path> to C<mode>.  Only
1027 numeric modes are supported.");
1028
1029   ("chown", (RErr, [Int "owner"; Int "group"; String "path"]), 35, [],
1030    [], (* XXX Need stat command to test *)
1031    "change file owner and group",
1032    "\
1033 Change the file owner to C<owner> and group to C<group>.
1034
1035 Only numeric uid and gid are supported.  If you want to use
1036 names, you will need to locate and parse the password file
1037 yourself (Augeas support makes this relatively easy).");
1038
1039   ("exists", (RBool "existsflag", [String "path"]), 36, [],
1040    [InitBasicFS, Always, TestOutputTrue (
1041       [["touch"; "/new"];
1042        ["exists"; "/new"]]);
1043     InitBasicFS, Always, TestOutputTrue (
1044       [["mkdir"; "/new"];
1045        ["exists"; "/new"]])],
1046    "test if file or directory exists",
1047    "\
1048 This returns C<true> if and only if there is a file, directory
1049 (or anything) with the given C<path> name.
1050
1051 See also C<guestfs_is_file>, C<guestfs_is_dir>, C<guestfs_stat>.");
1052
1053   ("is_file", (RBool "fileflag", [String "path"]), 37, [],
1054    [InitBasicFS, Always, TestOutputTrue (
1055       [["touch"; "/new"];
1056        ["is_file"; "/new"]]);
1057     InitBasicFS, Always, TestOutputFalse (
1058       [["mkdir"; "/new"];
1059        ["is_file"; "/new"]])],
1060    "test if file exists",
1061    "\
1062 This returns C<true> if and only if there is a file
1063 with the given C<path> name.  Note that it returns false for
1064 other objects like directories.
1065
1066 See also C<guestfs_stat>.");
1067
1068   ("is_dir", (RBool "dirflag", [String "path"]), 38, [],
1069    [InitBasicFS, Always, TestOutputFalse (
1070       [["touch"; "/new"];
1071        ["is_dir"; "/new"]]);
1072     InitBasicFS, Always, TestOutputTrue (
1073       [["mkdir"; "/new"];
1074        ["is_dir"; "/new"]])],
1075    "test if file exists",
1076    "\
1077 This returns C<true> if and only if there is a directory
1078 with the given C<path> name.  Note that it returns false for
1079 other objects like files.
1080
1081 See also C<guestfs_stat>.");
1082
1083   ("pvcreate", (RErr, [String "device"]), 39, [],
1084    [InitEmpty, Always, TestOutputList (
1085       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
1086        ["pvcreate"; "/dev/sda1"];
1087        ["pvcreate"; "/dev/sda2"];
1088        ["pvcreate"; "/dev/sda3"];
1089        ["pvs"]], ["/dev/sda1"; "/dev/sda2"; "/dev/sda3"])],
1090    "create an LVM physical volume",
1091    "\
1092 This creates an LVM physical volume on the named C<device>,
1093 where C<device> should usually be a partition name such
1094 as C</dev/sda1>.");
1095
1096   ("vgcreate", (RErr, [String "volgroup"; StringList "physvols"]), 40, [],
1097    [InitEmpty, Always, TestOutputList (
1098       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
1099        ["pvcreate"; "/dev/sda1"];
1100        ["pvcreate"; "/dev/sda2"];
1101        ["pvcreate"; "/dev/sda3"];
1102        ["vgcreate"; "VG1"; "/dev/sda1 /dev/sda2"];
1103        ["vgcreate"; "VG2"; "/dev/sda3"];
1104        ["vgs"]], ["VG1"; "VG2"])],
1105    "create an LVM volume group",
1106    "\
1107 This creates an LVM volume group called C<volgroup>
1108 from the non-empty list of physical volumes C<physvols>.");
1109
1110   ("lvcreate", (RErr, [String "logvol"; String "volgroup"; Int "mbytes"]), 41, [],
1111    [InitEmpty, Always, TestOutputList (
1112       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
1113        ["pvcreate"; "/dev/sda1"];
1114        ["pvcreate"; "/dev/sda2"];
1115        ["pvcreate"; "/dev/sda3"];
1116        ["vgcreate"; "VG1"; "/dev/sda1 /dev/sda2"];
1117        ["vgcreate"; "VG2"; "/dev/sda3"];
1118        ["lvcreate"; "LV1"; "VG1"; "50"];
1119        ["lvcreate"; "LV2"; "VG1"; "50"];
1120        ["lvcreate"; "LV3"; "VG2"; "50"];
1121        ["lvcreate"; "LV4"; "VG2"; "50"];
1122        ["lvcreate"; "LV5"; "VG2"; "50"];
1123        ["lvs"]],
1124       ["/dev/VG1/LV1"; "/dev/VG1/LV2";
1125        "/dev/VG2/LV3"; "/dev/VG2/LV4"; "/dev/VG2/LV5"])],
1126    "create an LVM volume group",
1127    "\
1128 This creates an LVM volume group called C<logvol>
1129 on the volume group C<volgroup>, with C<size> megabytes.");
1130
1131   ("mkfs", (RErr, [String "fstype"; String "device"]), 42, [],
1132    [InitEmpty, Always, TestOutput (
1133       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1134        ["mkfs"; "ext2"; "/dev/sda1"];
1135        ["mount"; "/dev/sda1"; "/"];
1136        ["write_file"; "/new"; "new file contents"; "0"];
1137        ["cat"; "/new"]], "new file contents")],
1138    "make a filesystem",
1139    "\
1140 This creates a filesystem on C<device> (usually a partition
1141 or LVM logical volume).  The filesystem type is C<fstype>, for
1142 example C<ext3>.");
1143
1144   ("sfdisk", (RErr, [String "device";
1145                      Int "cyls"; Int "heads"; Int "sectors";
1146                      StringList "lines"]), 43, [DangerWillRobinson],
1147    [],
1148    "create partitions on a block device",
1149    "\
1150 This is a direct interface to the L<sfdisk(8)> program for creating
1151 partitions on block devices.
1152
1153 C<device> should be a block device, for example C</dev/sda>.
1154
1155 C<cyls>, C<heads> and C<sectors> are the number of cylinders, heads
1156 and sectors on the device, which are passed directly to sfdisk as
1157 the I<-C>, I<-H> and I<-S> parameters.  If you pass C<0> for any
1158 of these, then the corresponding parameter is omitted.  Usually for
1159 'large' disks, you can just pass C<0> for these, but for small
1160 (floppy-sized) disks, sfdisk (or rather, the kernel) cannot work
1161 out the right geometry and you will need to tell it.
1162
1163 C<lines> is a list of lines that we feed to C<sfdisk>.  For more
1164 information refer to the L<sfdisk(8)> manpage.
1165
1166 To create a single partition occupying the whole disk, you would
1167 pass C<lines> as a single element list, when the single element being
1168 the string C<,> (comma).
1169
1170 See also: C<guestfs_sfdisk_l>, C<guestfs_sfdisk_N>");
1171
1172   ("write_file", (RErr, [String "path"; String "content"; Int "size"]), 44, [ProtocolLimitWarning],
1173    [InitBasicFS, Always, TestOutput (
1174       [["write_file"; "/new"; "new file contents"; "0"];
1175        ["cat"; "/new"]], "new file contents");
1176     InitBasicFS, Always, TestOutput (
1177       [["write_file"; "/new"; "\nnew file contents\n"; "0"];
1178        ["cat"; "/new"]], "\nnew file contents\n");
1179     InitBasicFS, Always, TestOutput (
1180       [["write_file"; "/new"; "\n\n"; "0"];
1181        ["cat"; "/new"]], "\n\n");
1182     InitBasicFS, Always, TestOutput (
1183       [["write_file"; "/new"; ""; "0"];
1184        ["cat"; "/new"]], "");
1185     InitBasicFS, Always, TestOutput (
1186       [["write_file"; "/new"; "\n\n\n"; "0"];
1187        ["cat"; "/new"]], "\n\n\n");
1188     InitBasicFS, Always, TestOutput (
1189       [["write_file"; "/new"; "\n"; "0"];
1190        ["cat"; "/new"]], "\n")],
1191    "create a file",
1192    "\
1193 This call creates a file called C<path>.  The contents of the
1194 file is the string C<content> (which can contain any 8 bit data),
1195 with length C<size>.
1196
1197 As a special case, if C<size> is C<0>
1198 then the length is calculated using C<strlen> (so in this case
1199 the content cannot contain embedded ASCII NULs).
1200
1201 I<NB.> Owing to a bug, writing content containing ASCII NUL
1202 characters does I<not> work, even if the length is specified.
1203 We hope to resolve this bug in a future version.  In the meantime
1204 use C<guestfs_upload>.");
1205
1206   ("umount", (RErr, [String "pathordevice"]), 45, [FishAlias "unmount"],
1207    [InitEmpty, Always, TestOutputList (
1208       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1209        ["mkfs"; "ext2"; "/dev/sda1"];
1210        ["mount"; "/dev/sda1"; "/"];
1211        ["mounts"]], ["/dev/sda1"]);
1212     InitEmpty, Always, TestOutputList (
1213       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1214        ["mkfs"; "ext2"; "/dev/sda1"];
1215        ["mount"; "/dev/sda1"; "/"];
1216        ["umount"; "/"];
1217        ["mounts"]], [])],
1218    "unmount a filesystem",
1219    "\
1220 This unmounts the given filesystem.  The filesystem may be
1221 specified either by its mountpoint (path) or the device which
1222 contains the filesystem.");
1223
1224   ("mounts", (RStringList "devices", []), 46, [],
1225    [InitBasicFS, Always, TestOutputList (
1226       [["mounts"]], ["/dev/sda1"])],
1227    "show mounted filesystems",
1228    "\
1229 This returns the list of currently mounted filesystems.  It returns
1230 the list of devices (eg. C</dev/sda1>, C</dev/VG/LV>).
1231
1232 Some internal mounts are not shown.");
1233
1234   ("umount_all", (RErr, []), 47, [FishAlias "unmount-all"],
1235    [InitBasicFS, Always, TestOutputList (
1236       [["umount_all"];
1237        ["mounts"]], []);
1238     (* check that umount_all can unmount nested mounts correctly: *)
1239     InitEmpty, Always, TestOutputList (
1240       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
1241        ["mkfs"; "ext2"; "/dev/sda1"];
1242        ["mkfs"; "ext2"; "/dev/sda2"];
1243        ["mkfs"; "ext2"; "/dev/sda3"];
1244        ["mount"; "/dev/sda1"; "/"];
1245        ["mkdir"; "/mp1"];
1246        ["mount"; "/dev/sda2"; "/mp1"];
1247        ["mkdir"; "/mp1/mp2"];
1248        ["mount"; "/dev/sda3"; "/mp1/mp2"];
1249        ["mkdir"; "/mp1/mp2/mp3"];
1250        ["umount_all"];
1251        ["mounts"]], [])],
1252    "unmount all filesystems",
1253    "\
1254 This unmounts all mounted filesystems.
1255
1256 Some internal mounts are not unmounted by this call.");
1257
1258   ("lvm_remove_all", (RErr, []), 48, [DangerWillRobinson],
1259    [],
1260    "remove all LVM LVs, VGs and PVs",
1261    "\
1262 This command removes all LVM logical volumes, volume groups
1263 and physical volumes.");
1264
1265   ("file", (RString "description", [String "path"]), 49, [],
1266    [InitBasicFS, Always, TestOutput (
1267       [["touch"; "/new"];
1268        ["file"; "/new"]], "empty");
1269     InitBasicFS, Always, TestOutput (
1270       [["write_file"; "/new"; "some content\n"; "0"];
1271        ["file"; "/new"]], "ASCII text");
1272     InitBasicFS, Always, TestLastFail (
1273       [["file"; "/nofile"]])],
1274    "determine file type",
1275    "\
1276 This call uses the standard L<file(1)> command to determine
1277 the type or contents of the file.  This also works on devices,
1278 for example to find out whether a partition contains a filesystem.
1279
1280 The exact command which runs is C<file -bsL path>.  Note in
1281 particular that the filename is not prepended to the output
1282 (the C<-b> option).");
1283
1284   ("command", (RString "output", [StringList "arguments"]), 50, [ProtocolLimitWarning],
1285    [InitBasicFS, Always, TestOutput (
1286       [["upload"; "test-command"; "/test-command"];
1287        ["chmod"; "493"; "/test-command"];
1288        ["command"; "/test-command 1"]], "Result1");
1289     InitBasicFS, Always, TestOutput (
1290       [["upload"; "test-command"; "/test-command"];
1291        ["chmod"; "493"; "/test-command"];
1292        ["command"; "/test-command 2"]], "Result2\n");
1293     InitBasicFS, Always, TestOutput (
1294       [["upload"; "test-command"; "/test-command"];
1295        ["chmod"; "493"; "/test-command"];
1296        ["command"; "/test-command 3"]], "\nResult3");
1297     InitBasicFS, Always, TestOutput (
1298       [["upload"; "test-command"; "/test-command"];
1299        ["chmod"; "493"; "/test-command"];
1300        ["command"; "/test-command 4"]], "\nResult4\n");
1301     InitBasicFS, Always, TestOutput (
1302       [["upload"; "test-command"; "/test-command"];
1303        ["chmod"; "493"; "/test-command"];
1304        ["command"; "/test-command 5"]], "\nResult5\n\n");
1305     InitBasicFS, Always, TestOutput (
1306       [["upload"; "test-command"; "/test-command"];
1307        ["chmod"; "493"; "/test-command"];
1308        ["command"; "/test-command 6"]], "\n\nResult6\n\n");
1309     InitBasicFS, Always, TestOutput (
1310       [["upload"; "test-command"; "/test-command"];
1311        ["chmod"; "493"; "/test-command"];
1312        ["command"; "/test-command 7"]], "");
1313     InitBasicFS, Always, TestOutput (
1314       [["upload"; "test-command"; "/test-command"];
1315        ["chmod"; "493"; "/test-command"];
1316        ["command"; "/test-command 8"]], "\n");
1317     InitBasicFS, Always, TestOutput (
1318       [["upload"; "test-command"; "/test-command"];
1319        ["chmod"; "493"; "/test-command"];
1320        ["command"; "/test-command 9"]], "\n\n");
1321     InitBasicFS, Always, TestOutput (
1322       [["upload"; "test-command"; "/test-command"];
1323        ["chmod"; "493"; "/test-command"];
1324        ["command"; "/test-command 10"]], "Result10-1\nResult10-2\n");
1325     InitBasicFS, Always, TestOutput (
1326       [["upload"; "test-command"; "/test-command"];
1327        ["chmod"; "493"; "/test-command"];
1328        ["command"; "/test-command 11"]], "Result11-1\nResult11-2");
1329     InitBasicFS, Always, TestLastFail (
1330       [["upload"; "test-command"; "/test-command"];
1331        ["chmod"; "493"; "/test-command"];
1332        ["command"; "/test-command"]])],
1333    "run a command from the guest filesystem",
1334    "\
1335 This call runs a command from the guest filesystem.  The
1336 filesystem must be mounted, and must contain a compatible
1337 operating system (ie. something Linux, with the same
1338 or compatible processor architecture).
1339
1340 The single parameter is an argv-style list of arguments.
1341 The first element is the name of the program to run.
1342 Subsequent elements are parameters.  The list must be
1343 non-empty (ie. must contain a program name).
1344
1345 The return value is anything printed to I<stdout> by
1346 the command.
1347
1348 If the command returns a non-zero exit status, then
1349 this function returns an error message.  The error message
1350 string is the content of I<stderr> from the command.
1351
1352 The C<$PATH> environment variable will contain at least
1353 C</usr/bin> and C</bin>.  If you require a program from
1354 another location, you should provide the full path in the
1355 first parameter.
1356
1357 Shared libraries and data files required by the program
1358 must be available on filesystems which are mounted in the
1359 correct places.  It is the caller's responsibility to ensure
1360 all filesystems that are needed are mounted at the right
1361 locations.");
1362
1363   ("command_lines", (RStringList "lines", [StringList "arguments"]), 51, [ProtocolLimitWarning],
1364    [InitBasicFS, Always, TestOutputList (
1365       [["upload"; "test-command"; "/test-command"];
1366        ["chmod"; "493"; "/test-command"];
1367        ["command_lines"; "/test-command 1"]], ["Result1"]);
1368     InitBasicFS, Always, TestOutputList (
1369       [["upload"; "test-command"; "/test-command"];
1370        ["chmod"; "493"; "/test-command"];
1371        ["command_lines"; "/test-command 2"]], ["Result2"]);
1372     InitBasicFS, Always, TestOutputList (
1373       [["upload"; "test-command"; "/test-command"];
1374        ["chmod"; "493"; "/test-command"];
1375        ["command_lines"; "/test-command 3"]], ["";"Result3"]);
1376     InitBasicFS, Always, TestOutputList (
1377       [["upload"; "test-command"; "/test-command"];
1378        ["chmod"; "493"; "/test-command"];
1379        ["command_lines"; "/test-command 4"]], ["";"Result4"]);
1380     InitBasicFS, Always, TestOutputList (
1381       [["upload"; "test-command"; "/test-command"];
1382        ["chmod"; "493"; "/test-command"];
1383        ["command_lines"; "/test-command 5"]], ["";"Result5";""]);
1384     InitBasicFS, Always, TestOutputList (
1385       [["upload"; "test-command"; "/test-command"];
1386        ["chmod"; "493"; "/test-command"];
1387        ["command_lines"; "/test-command 6"]], ["";"";"Result6";""]);
1388     InitBasicFS, Always, TestOutputList (
1389       [["upload"; "test-command"; "/test-command"];
1390        ["chmod"; "493"; "/test-command"];
1391        ["command_lines"; "/test-command 7"]], []);
1392     InitBasicFS, Always, TestOutputList (
1393       [["upload"; "test-command"; "/test-command"];
1394        ["chmod"; "493"; "/test-command"];
1395        ["command_lines"; "/test-command 8"]], [""]);
1396     InitBasicFS, Always, TestOutputList (
1397       [["upload"; "test-command"; "/test-command"];
1398        ["chmod"; "493"; "/test-command"];
1399        ["command_lines"; "/test-command 9"]], ["";""]);
1400     InitBasicFS, Always, TestOutputList (
1401       [["upload"; "test-command"; "/test-command"];
1402        ["chmod"; "493"; "/test-command"];
1403        ["command_lines"; "/test-command 10"]], ["Result10-1";"Result10-2"]);
1404     InitBasicFS, Always, TestOutputList (
1405       [["upload"; "test-command"; "/test-command"];
1406        ["chmod"; "493"; "/test-command"];
1407        ["command_lines"; "/test-command 11"]], ["Result11-1";"Result11-2"])],
1408    "run a command, returning lines",
1409    "\
1410 This is the same as C<guestfs_command>, but splits the
1411 result into a list of lines.");
1412
1413   ("stat", (RStat "statbuf", [String "path"]), 52, [],
1414    [InitBasicFS, Always, TestOutputStruct (
1415       [["touch"; "/new"];
1416        ["stat"; "/new"]], [CompareWithInt ("size", 0)])],
1417    "get file information",
1418    "\
1419 Returns file information for the given C<path>.
1420
1421 This is the same as the C<stat(2)> system call.");
1422
1423   ("lstat", (RStat "statbuf", [String "path"]), 53, [],
1424    [InitBasicFS, Always, TestOutputStruct (
1425       [["touch"; "/new"];
1426        ["lstat"; "/new"]], [CompareWithInt ("size", 0)])],
1427    "get file information for a symbolic link",
1428    "\
1429 Returns file information for the given C<path>.
1430
1431 This is the same as C<guestfs_stat> except that if C<path>
1432 is a symbolic link, then the link is stat-ed, not the file it
1433 refers to.
1434
1435 This is the same as the C<lstat(2)> system call.");
1436
1437   ("statvfs", (RStatVFS "statbuf", [String "path"]), 54, [],
1438    [InitBasicFS, Always, TestOutputStruct (
1439       [["statvfs"; "/"]], [CompareWithInt ("bfree", 487702);
1440                            CompareWithInt ("blocks", 490020);
1441                            CompareWithInt ("bsize", 1024)])],
1442    "get file system statistics",
1443    "\
1444 Returns file system statistics for any mounted file system.
1445 C<path> should be a file or directory in the mounted file system
1446 (typically it is the mount point itself, but it doesn't need to be).
1447
1448 This is the same as the C<statvfs(2)> system call.");
1449
1450   ("tune2fs_l", (RHashtable "superblock", [String "device"]), 55, [],
1451    [], (* XXX test *)
1452    "get ext2/ext3/ext4 superblock details",
1453    "\
1454 This returns the contents of the ext2, ext3 or ext4 filesystem
1455 superblock on C<device>.
1456
1457 It is the same as running C<tune2fs -l device>.  See L<tune2fs(8)>
1458 manpage for more details.  The list of fields returned isn't
1459 clearly defined, and depends on both the version of C<tune2fs>
1460 that libguestfs was built against, and the filesystem itself.");
1461
1462   ("blockdev_setro", (RErr, [String "device"]), 56, [],
1463    [InitEmpty, Always, TestOutputTrue (
1464       [["blockdev_setro"; "/dev/sda"];
1465        ["blockdev_getro"; "/dev/sda"]])],
1466    "set block device to read-only",
1467    "\
1468 Sets the block device named C<device> to read-only.
1469
1470 This uses the L<blockdev(8)> command.");
1471
1472   ("blockdev_setrw", (RErr, [String "device"]), 57, [],
1473    [InitEmpty, Always, TestOutputFalse (
1474       [["blockdev_setrw"; "/dev/sda"];
1475        ["blockdev_getro"; "/dev/sda"]])],
1476    "set block device to read-write",
1477    "\
1478 Sets the block device named C<device> to read-write.
1479
1480 This uses the L<blockdev(8)> command.");
1481
1482   ("blockdev_getro", (RBool "ro", [String "device"]), 58, [],
1483    [InitEmpty, Always, TestOutputTrue (
1484       [["blockdev_setro"; "/dev/sda"];
1485        ["blockdev_getro"; "/dev/sda"]])],
1486    "is block device set to read-only",
1487    "\
1488 Returns a boolean indicating if the block device is read-only
1489 (true if read-only, false if not).
1490
1491 This uses the L<blockdev(8)> command.");
1492
1493   ("blockdev_getss", (RInt "sectorsize", [String "device"]), 59, [],
1494    [InitEmpty, Always, TestOutputInt (
1495       [["blockdev_getss"; "/dev/sda"]], 512)],
1496    "get sectorsize of block device",
1497    "\
1498 This returns the size of sectors on a block device.
1499 Usually 512, but can be larger for modern devices.
1500
1501 (Note, this is not the size in sectors, use C<guestfs_blockdev_getsz>
1502 for that).
1503
1504 This uses the L<blockdev(8)> command.");
1505
1506   ("blockdev_getbsz", (RInt "blocksize", [String "device"]), 60, [],
1507    [InitEmpty, Always, TestOutputInt (
1508       [["blockdev_getbsz"; "/dev/sda"]], 4096)],
1509    "get blocksize of block device",
1510    "\
1511 This returns the block size of a device.
1512
1513 (Note this is different from both I<size in blocks> and
1514 I<filesystem block size>).
1515
1516 This uses the L<blockdev(8)> command.");
1517
1518   ("blockdev_setbsz", (RErr, [String "device"; Int "blocksize"]), 61, [],
1519    [], (* XXX test *)
1520    "set blocksize of block device",
1521    "\
1522 This sets the block size of a device.
1523
1524 (Note this is different from both I<size in blocks> and
1525 I<filesystem block size>).
1526
1527 This uses the L<blockdev(8)> command.");
1528
1529   ("blockdev_getsz", (RInt64 "sizeinsectors", [String "device"]), 62, [],
1530    [InitEmpty, Always, TestOutputInt (
1531       [["blockdev_getsz"; "/dev/sda"]], 1024000)],
1532    "get total size of device in 512-byte sectors",
1533    "\
1534 This returns the size of the device in units of 512-byte sectors
1535 (even if the sectorsize isn't 512 bytes ... weird).
1536
1537 See also C<guestfs_blockdev_getss> for the real sector size of
1538 the device, and C<guestfs_blockdev_getsize64> for the more
1539 useful I<size in bytes>.
1540
1541 This uses the L<blockdev(8)> command.");
1542
1543   ("blockdev_getsize64", (RInt64 "sizeinbytes", [String "device"]), 63, [],
1544    [InitEmpty, Always, TestOutputInt (
1545       [["blockdev_getsize64"; "/dev/sda"]], 524288000)],
1546    "get total size of device in bytes",
1547    "\
1548 This returns the size of the device in bytes.
1549
1550 See also C<guestfs_blockdev_getsz>.
1551
1552 This uses the L<blockdev(8)> command.");
1553
1554   ("blockdev_flushbufs", (RErr, [String "device"]), 64, [],
1555    [InitEmpty, Always, TestRun
1556       [["blockdev_flushbufs"; "/dev/sda"]]],
1557    "flush device buffers",
1558    "\
1559 This tells the kernel to flush internal buffers associated
1560 with C<device>.
1561
1562 This uses the L<blockdev(8)> command.");
1563
1564   ("blockdev_rereadpt", (RErr, [String "device"]), 65, [],
1565    [InitEmpty, Always, TestRun
1566       [["blockdev_rereadpt"; "/dev/sda"]]],
1567    "reread partition table",
1568    "\
1569 Reread the partition table on C<device>.
1570
1571 This uses the L<blockdev(8)> command.");
1572
1573   ("upload", (RErr, [FileIn "filename"; String "remotefilename"]), 66, [],
1574    [InitBasicFS, Always, TestOutput (
1575       (* Pick a file from cwd which isn't likely to change. *)
1576     [["upload"; "../COPYING.LIB"; "/COPYING.LIB"];
1577      ["checksum"; "md5"; "/COPYING.LIB"]], "e3eda01d9815f8d24aae2dbd89b68b06")],
1578    "upload a file from the local machine",
1579    "\
1580 Upload local file C<filename> to C<remotefilename> on the
1581 filesystem.
1582
1583 C<filename> can also be a named pipe.
1584
1585 See also C<guestfs_download>.");
1586
1587   ("download", (RErr, [String "remotefilename"; FileOut "filename"]), 67, [],
1588    [InitBasicFS, Always, TestOutput (
1589       (* Pick a file from cwd which isn't likely to change. *)
1590     [["upload"; "../COPYING.LIB"; "/COPYING.LIB"];
1591      ["download"; "/COPYING.LIB"; "testdownload.tmp"];
1592      ["upload"; "testdownload.tmp"; "/upload"];
1593      ["checksum"; "md5"; "/upload"]], "e3eda01d9815f8d24aae2dbd89b68b06")],
1594    "download a file to the local machine",
1595    "\
1596 Download file C<remotefilename> and save it as C<filename>
1597 on the local machine.
1598
1599 C<filename> can also be a named pipe.
1600
1601 See also C<guestfs_upload>, C<guestfs_cat>.");
1602
1603   ("checksum", (RString "checksum", [String "csumtype"; String "path"]), 68, [],
1604    [InitBasicFS, Always, TestOutput (
1605       [["write_file"; "/new"; "test\n"; "0"];
1606        ["checksum"; "crc"; "/new"]], "935282863");
1607     InitBasicFS, Always, TestLastFail (
1608       [["checksum"; "crc"; "/new"]]);
1609     InitBasicFS, Always, TestOutput (
1610       [["write_file"; "/new"; "test\n"; "0"];
1611        ["checksum"; "md5"; "/new"]], "d8e8fca2dc0f896fd7cb4cb0031ba249");
1612     InitBasicFS, Always, TestOutput (
1613       [["write_file"; "/new"; "test\n"; "0"];
1614        ["checksum"; "sha1"; "/new"]], "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83");
1615     InitBasicFS, Always, TestOutput (
1616       [["write_file"; "/new"; "test\n"; "0"];
1617        ["checksum"; "sha224"; "/new"]], "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec");
1618     InitBasicFS, Always, TestOutput (
1619       [["write_file"; "/new"; "test\n"; "0"];
1620        ["checksum"; "sha256"; "/new"]], "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2");
1621     InitBasicFS, Always, TestOutput (
1622       [["write_file"; "/new"; "test\n"; "0"];
1623        ["checksum"; "sha384"; "/new"]], "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d");
1624     InitBasicFS, Always, TestOutput (
1625       [["write_file"; "/new"; "test\n"; "0"];
1626        ["checksum"; "sha512"; "/new"]], "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123");
1627     InitBasicFS, Always, TestOutput (
1628       [["mount"; "/dev/sdd"; "/"];
1629        ["checksum"; "md5"; "/known-3"]], "46d6ca27ee07cdc6fa99c2e138cc522c")],
1630    "compute MD5, SHAx or CRC checksum of file",
1631    "\
1632 This call computes the MD5, SHAx or CRC checksum of the
1633 file named C<path>.
1634
1635 The type of checksum to compute is given by the C<csumtype>
1636 parameter which must have one of the following values:
1637
1638 =over 4
1639
1640 =item C<crc>
1641
1642 Compute the cyclic redundancy check (CRC) specified by POSIX
1643 for the C<cksum> command.
1644
1645 =item C<md5>
1646
1647 Compute the MD5 hash (using the C<md5sum> program).
1648
1649 =item C<sha1>
1650
1651 Compute the SHA1 hash (using the C<sha1sum> program).
1652
1653 =item C<sha224>
1654
1655 Compute the SHA224 hash (using the C<sha224sum> program).
1656
1657 =item C<sha256>
1658
1659 Compute the SHA256 hash (using the C<sha256sum> program).
1660
1661 =item C<sha384>
1662
1663 Compute the SHA384 hash (using the C<sha384sum> program).
1664
1665 =item C<sha512>
1666
1667 Compute the SHA512 hash (using the C<sha512sum> program).
1668
1669 =back
1670
1671 The checksum is returned as a printable string.");
1672
1673   ("tar_in", (RErr, [FileIn "tarfile"; String "directory"]), 69, [],
1674    [InitBasicFS, Always, TestOutput (
1675       [["tar_in"; "../images/helloworld.tar"; "/"];
1676        ["cat"; "/hello"]], "hello\n")],
1677    "unpack tarfile to directory",
1678    "\
1679 This command uploads and unpacks local file C<tarfile> (an
1680 I<uncompressed> tar file) into C<directory>.
1681
1682 To upload a compressed tarball, use C<guestfs_tgz_in>.");
1683
1684   ("tar_out", (RErr, [String "directory"; FileOut "tarfile"]), 70, [],
1685    [],
1686    "pack directory into tarfile",
1687    "\
1688 This command packs the contents of C<directory> and downloads
1689 it to local file C<tarfile>.
1690
1691 To download a compressed tarball, use C<guestfs_tgz_out>.");
1692
1693   ("tgz_in", (RErr, [FileIn "tarball"; String "directory"]), 71, [],
1694    [InitBasicFS, Always, TestOutput (
1695       [["tgz_in"; "../images/helloworld.tar.gz"; "/"];
1696        ["cat"; "/hello"]], "hello\n")],
1697    "unpack compressed tarball to directory",
1698    "\
1699 This command uploads and unpacks local file C<tarball> (a
1700 I<gzip compressed> tar file) into C<directory>.
1701
1702 To upload an uncompressed tarball, use C<guestfs_tar_in>.");
1703
1704   ("tgz_out", (RErr, [String "directory"; FileOut "tarball"]), 72, [],
1705    [],
1706    "pack directory into compressed tarball",
1707    "\
1708 This command packs the contents of C<directory> and downloads
1709 it to local file C<tarball>.
1710
1711 To download an uncompressed tarball, use C<guestfs_tar_out>.");
1712
1713   ("mount_ro", (RErr, [String "device"; String "mountpoint"]), 73, [],
1714    [InitBasicFS, Always, TestLastFail (
1715       [["umount"; "/"];
1716        ["mount_ro"; "/dev/sda1"; "/"];
1717        ["touch"; "/new"]]);
1718     InitBasicFS, Always, TestOutput (
1719       [["write_file"; "/new"; "data"; "0"];
1720        ["umount"; "/"];
1721        ["mount_ro"; "/dev/sda1"; "/"];
1722        ["cat"; "/new"]], "data")],
1723    "mount a guest disk, read-only",
1724    "\
1725 This is the same as the C<guestfs_mount> command, but it
1726 mounts the filesystem with the read-only (I<-o ro>) flag.");
1727
1728   ("mount_options", (RErr, [String "options"; String "device"; String "mountpoint"]), 74, [],
1729    [],
1730    "mount a guest disk with mount options",
1731    "\
1732 This is the same as the C<guestfs_mount> command, but it
1733 allows you to set the mount options as for the
1734 L<mount(8)> I<-o> flag.");
1735
1736   ("mount_vfs", (RErr, [String "options"; String "vfstype"; String "device"; String "mountpoint"]), 75, [],
1737    [],
1738    "mount a guest disk with mount options and vfstype",
1739    "\
1740 This is the same as the C<guestfs_mount> command, but it
1741 allows you to set both the mount options and the vfstype
1742 as for the L<mount(8)> I<-o> and I<-t> flags.");
1743
1744   ("debug", (RString "result", [String "subcmd"; StringList "extraargs"]), 76, [],
1745    [],
1746    "debugging and internals",
1747    "\
1748 The C<guestfs_debug> command exposes some internals of
1749 C<guestfsd> (the guestfs daemon) that runs inside the
1750 qemu subprocess.
1751
1752 There is no comprehensive help for this command.  You have
1753 to look at the file C<daemon/debug.c> in the libguestfs source
1754 to find out what you can do.");
1755
1756   ("lvremove", (RErr, [String "device"]), 77, [],
1757    [InitEmpty, Always, TestOutputList (
1758       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1759        ["pvcreate"; "/dev/sda1"];
1760        ["vgcreate"; "VG"; "/dev/sda1"];
1761        ["lvcreate"; "LV1"; "VG"; "50"];
1762        ["lvcreate"; "LV2"; "VG"; "50"];
1763        ["lvremove"; "/dev/VG/LV1"];
1764        ["lvs"]], ["/dev/VG/LV2"]);
1765     InitEmpty, Always, TestOutputList (
1766       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1767        ["pvcreate"; "/dev/sda1"];
1768        ["vgcreate"; "VG"; "/dev/sda1"];
1769        ["lvcreate"; "LV1"; "VG"; "50"];
1770        ["lvcreate"; "LV2"; "VG"; "50"];
1771        ["lvremove"; "/dev/VG"];
1772        ["lvs"]], []);
1773     InitEmpty, Always, TestOutputList (
1774       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1775        ["pvcreate"; "/dev/sda1"];
1776        ["vgcreate"; "VG"; "/dev/sda1"];
1777        ["lvcreate"; "LV1"; "VG"; "50"];
1778        ["lvcreate"; "LV2"; "VG"; "50"];
1779        ["lvremove"; "/dev/VG"];
1780        ["vgs"]], ["VG"])],
1781    "remove an LVM logical volume",
1782    "\
1783 Remove an LVM logical volume C<device>, where C<device> is
1784 the path to the LV, such as C</dev/VG/LV>.
1785
1786 You can also remove all LVs in a volume group by specifying
1787 the VG name, C</dev/VG>.");
1788
1789   ("vgremove", (RErr, [String "vgname"]), 78, [],
1790    [InitEmpty, Always, TestOutputList (
1791       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1792        ["pvcreate"; "/dev/sda1"];
1793        ["vgcreate"; "VG"; "/dev/sda1"];
1794        ["lvcreate"; "LV1"; "VG"; "50"];
1795        ["lvcreate"; "LV2"; "VG"; "50"];
1796        ["vgremove"; "VG"];
1797        ["lvs"]], []);
1798     InitEmpty, Always, TestOutputList (
1799       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1800        ["pvcreate"; "/dev/sda1"];
1801        ["vgcreate"; "VG"; "/dev/sda1"];
1802        ["lvcreate"; "LV1"; "VG"; "50"];
1803        ["lvcreate"; "LV2"; "VG"; "50"];
1804        ["vgremove"; "VG"];
1805        ["vgs"]], [])],
1806    "remove an LVM volume group",
1807    "\
1808 Remove an LVM volume group C<vgname>, (for example C<VG>).
1809
1810 This also forcibly removes all logical volumes in the volume
1811 group (if any).");
1812
1813   ("pvremove", (RErr, [String "device"]), 79, [],
1814    [InitEmpty, Always, TestOutputList (
1815       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1816        ["pvcreate"; "/dev/sda1"];
1817        ["vgcreate"; "VG"; "/dev/sda1"];
1818        ["lvcreate"; "LV1"; "VG"; "50"];
1819        ["lvcreate"; "LV2"; "VG"; "50"];
1820        ["vgremove"; "VG"];
1821        ["pvremove"; "/dev/sda1"];
1822        ["lvs"]], []);
1823     InitEmpty, Always, TestOutputList (
1824       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1825        ["pvcreate"; "/dev/sda1"];
1826        ["vgcreate"; "VG"; "/dev/sda1"];
1827        ["lvcreate"; "LV1"; "VG"; "50"];
1828        ["lvcreate"; "LV2"; "VG"; "50"];
1829        ["vgremove"; "VG"];
1830        ["pvremove"; "/dev/sda1"];
1831        ["vgs"]], []);
1832     InitEmpty, Always, TestOutputList (
1833       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1834        ["pvcreate"; "/dev/sda1"];
1835        ["vgcreate"; "VG"; "/dev/sda1"];
1836        ["lvcreate"; "LV1"; "VG"; "50"];
1837        ["lvcreate"; "LV2"; "VG"; "50"];
1838        ["vgremove"; "VG"];
1839        ["pvremove"; "/dev/sda1"];
1840        ["pvs"]], [])],
1841    "remove an LVM physical volume",
1842    "\
1843 This wipes a physical volume C<device> so that LVM will no longer
1844 recognise it.
1845
1846 The implementation uses the C<pvremove> command which refuses to
1847 wipe physical volumes that contain any volume groups, so you have
1848 to remove those first.");
1849
1850   ("set_e2label", (RErr, [String "device"; String "label"]), 80, [],
1851    [InitBasicFS, Always, TestOutput (
1852       [["set_e2label"; "/dev/sda1"; "testlabel"];
1853        ["get_e2label"; "/dev/sda1"]], "testlabel")],
1854    "set the ext2/3/4 filesystem label",
1855    "\
1856 This sets the ext2/3/4 filesystem label of the filesystem on
1857 C<device> to C<label>.  Filesystem labels are limited to
1858 16 characters.
1859
1860 You can use either C<guestfs_tune2fs_l> or C<guestfs_get_e2label>
1861 to return the existing label on a filesystem.");
1862
1863   ("get_e2label", (RString "label", [String "device"]), 81, [],
1864    [],
1865    "get the ext2/3/4 filesystem label",
1866    "\
1867 This returns the ext2/3/4 filesystem label of the filesystem on
1868 C<device>.");
1869
1870   ("set_e2uuid", (RErr, [String "device"; String "uuid"]), 82, [],
1871    [InitBasicFS, Always, TestOutput (
1872       [["set_e2uuid"; "/dev/sda1"; "a3a61220-882b-4f61-89f4-cf24dcc7297d"];
1873        ["get_e2uuid"; "/dev/sda1"]], "a3a61220-882b-4f61-89f4-cf24dcc7297d");
1874     InitBasicFS, Always, TestOutput (
1875       [["set_e2uuid"; "/dev/sda1"; "clear"];
1876        ["get_e2uuid"; "/dev/sda1"]], "");
1877     (* We can't predict what UUIDs will be, so just check the commands run. *)
1878     InitBasicFS, Always, TestRun (
1879       [["set_e2uuid"; "/dev/sda1"; "random"]]);
1880     InitBasicFS, Always, TestRun (
1881       [["set_e2uuid"; "/dev/sda1"; "time"]])],
1882    "set the ext2/3/4 filesystem UUID",
1883    "\
1884 This sets the ext2/3/4 filesystem UUID of the filesystem on
1885 C<device> to C<uuid>.  The format of the UUID and alternatives
1886 such as C<clear>, C<random> and C<time> are described in the
1887 L<tune2fs(8)> manpage.
1888
1889 You can use either C<guestfs_tune2fs_l> or C<guestfs_get_e2uuid>
1890 to return the existing UUID of a filesystem.");
1891
1892   ("get_e2uuid", (RString "uuid", [String "device"]), 83, [],
1893    [],
1894    "get the ext2/3/4 filesystem UUID",
1895    "\
1896 This returns the ext2/3/4 filesystem UUID of the filesystem on
1897 C<device>.");
1898
1899   ("fsck", (RInt "status", [String "fstype"; String "device"]), 84, [],
1900    [InitBasicFS, Always, TestOutputInt (
1901       [["umount"; "/dev/sda1"];
1902        ["fsck"; "ext2"; "/dev/sda1"]], 0);
1903     InitBasicFS, Always, TestOutputInt (
1904       [["umount"; "/dev/sda1"];
1905        ["zero"; "/dev/sda1"];
1906        ["fsck"; "ext2"; "/dev/sda1"]], 8)],
1907    "run the filesystem checker",
1908    "\
1909 This runs the filesystem checker (fsck) on C<device> which
1910 should have filesystem type C<fstype>.
1911
1912 The returned integer is the status.  See L<fsck(8)> for the
1913 list of status codes from C<fsck>.
1914
1915 Notes:
1916
1917 =over 4
1918
1919 =item *
1920
1921 Multiple status codes can be summed together.
1922
1923 =item *
1924
1925 A non-zero return code can mean \"success\", for example if
1926 errors have been corrected on the filesystem.
1927
1928 =item *
1929
1930 Checking or repairing NTFS volumes is not supported
1931 (by linux-ntfs).
1932
1933 =back
1934
1935 This command is entirely equivalent to running C<fsck -a -t fstype device>.");
1936
1937   ("zero", (RErr, [String "device"]), 85, [],
1938    [InitBasicFS, Always, TestOutput (
1939       [["umount"; "/dev/sda1"];
1940        ["zero"; "/dev/sda1"];
1941        ["file"; "/dev/sda1"]], "data")],
1942    "write zeroes to the device",
1943    "\
1944 This command writes zeroes over the first few blocks of C<device>.
1945
1946 How many blocks are zeroed isn't specified (but it's I<not> enough
1947 to securely wipe the device).  It should be sufficient to remove
1948 any partition tables, filesystem superblocks and so on.");
1949
1950   ("grub_install", (RErr, [String "root"; String "device"]), 86, [],
1951    [InitBasicFS, Always, TestOutputTrue (
1952       [["grub_install"; "/"; "/dev/sda1"];
1953        ["is_dir"; "/boot"]])],
1954    "install GRUB",
1955    "\
1956 This command installs GRUB (the Grand Unified Bootloader) on
1957 C<device>, with the root directory being C<root>.");
1958
1959   ("cp", (RErr, [String "src"; String "dest"]), 87, [],
1960    [InitBasicFS, Always, TestOutput (
1961       [["write_file"; "/old"; "file content"; "0"];
1962        ["cp"; "/old"; "/new"];
1963        ["cat"; "/new"]], "file content");
1964     InitBasicFS, Always, TestOutputTrue (
1965       [["write_file"; "/old"; "file content"; "0"];
1966        ["cp"; "/old"; "/new"];
1967        ["is_file"; "/old"]]);
1968     InitBasicFS, Always, TestOutput (
1969       [["write_file"; "/old"; "file content"; "0"];
1970        ["mkdir"; "/dir"];
1971        ["cp"; "/old"; "/dir/new"];
1972        ["cat"; "/dir/new"]], "file content")],
1973    "copy a file",
1974    "\
1975 This copies a file from C<src> to C<dest> where C<dest> is
1976 either a destination filename or destination directory.");
1977
1978   ("cp_a", (RErr, [String "src"; String "dest"]), 88, [],
1979    [InitBasicFS, Always, TestOutput (
1980       [["mkdir"; "/olddir"];
1981        ["mkdir"; "/newdir"];
1982        ["write_file"; "/olddir/file"; "file content"; "0"];
1983        ["cp_a"; "/olddir"; "/newdir"];
1984        ["cat"; "/newdir/olddir/file"]], "file content")],
1985    "copy a file or directory recursively",
1986    "\
1987 This copies a file or directory from C<src> to C<dest>
1988 recursively using the C<cp -a> command.");
1989
1990   ("mv", (RErr, [String "src"; String "dest"]), 89, [],
1991    [InitBasicFS, Always, TestOutput (
1992       [["write_file"; "/old"; "file content"; "0"];
1993        ["mv"; "/old"; "/new"];
1994        ["cat"; "/new"]], "file content");
1995     InitBasicFS, Always, TestOutputFalse (
1996       [["write_file"; "/old"; "file content"; "0"];
1997        ["mv"; "/old"; "/new"];
1998        ["is_file"; "/old"]])],
1999    "move a file",
2000    "\
2001 This moves a file from C<src> to C<dest> where C<dest> is
2002 either a destination filename or destination directory.");
2003
2004   ("drop_caches", (RErr, [Int "whattodrop"]), 90, [],
2005    [InitEmpty, Always, TestRun (
2006       [["drop_caches"; "3"]])],
2007    "drop kernel page cache, dentries and inodes",
2008    "\
2009 This instructs the guest kernel to drop its page cache,
2010 and/or dentries and inode caches.  The parameter C<whattodrop>
2011 tells the kernel what precisely to drop, see
2012 L<http://linux-mm.org/Drop_Caches>
2013
2014 Setting C<whattodrop> to 3 should drop everything.
2015
2016 This automatically calls L<sync(2)> before the operation,
2017 so that the maximum guest memory is freed.");
2018
2019   ("dmesg", (RString "kmsgs", []), 91, [],
2020    [InitEmpty, Always, TestRun (
2021       [["dmesg"]])],
2022    "return kernel messages",
2023    "\
2024 This returns the kernel messages (C<dmesg> output) from
2025 the guest kernel.  This is sometimes useful for extended
2026 debugging of problems.
2027
2028 Another way to get the same information is to enable
2029 verbose messages with C<guestfs_set_verbose> or by setting
2030 the environment variable C<LIBGUESTFS_DEBUG=1> before
2031 running the program.");
2032
2033   ("ping_daemon", (RErr, []), 92, [],
2034    [InitEmpty, Always, TestRun (
2035       [["ping_daemon"]])],
2036    "ping the guest daemon",
2037    "\
2038 This is a test probe into the guestfs daemon running inside
2039 the qemu subprocess.  Calling this function checks that the
2040 daemon responds to the ping message, without affecting the daemon
2041 or attached block device(s) in any other way.");
2042
2043   ("equal", (RBool "equality", [String "file1"; String "file2"]), 93, [],
2044    [InitBasicFS, Always, TestOutputTrue (
2045       [["write_file"; "/file1"; "contents of a file"; "0"];
2046        ["cp"; "/file1"; "/file2"];
2047        ["equal"; "/file1"; "/file2"]]);
2048     InitBasicFS, Always, TestOutputFalse (
2049       [["write_file"; "/file1"; "contents of a file"; "0"];
2050        ["write_file"; "/file2"; "contents of another file"; "0"];
2051        ["equal"; "/file1"; "/file2"]]);
2052     InitBasicFS, Always, TestLastFail (
2053       [["equal"; "/file1"; "/file2"]])],
2054    "test if two files have equal contents",
2055    "\
2056 This compares the two files C<file1> and C<file2> and returns
2057 true if their content is exactly equal, or false otherwise.
2058
2059 The external L<cmp(1)> program is used for the comparison.");
2060
2061   ("strings", (RStringList "stringsout", [String "path"]), 94, [ProtocolLimitWarning],
2062    [InitBasicFS, Always, TestOutputList (
2063       [["write_file"; "/new"; "hello\nworld\n"; "0"];
2064        ["strings"; "/new"]], ["hello"; "world"]);
2065     InitBasicFS, Always, TestOutputList (
2066       [["touch"; "/new"];
2067        ["strings"; "/new"]], [])],
2068    "print the printable strings in a file",
2069    "\
2070 This runs the L<strings(1)> command on a file and returns
2071 the list of printable strings found.");
2072
2073   ("strings_e", (RStringList "stringsout", [String "encoding"; String "path"]), 95, [ProtocolLimitWarning],
2074    [InitBasicFS, Always, TestOutputList (
2075       [["write_file"; "/new"; "hello\nworld\n"; "0"];
2076        ["strings_e"; "b"; "/new"]], []);
2077     InitBasicFS, Disabled, TestOutputList (
2078       [["write_file"; "/new"; "\000h\000e\000l\000l\000o\000\n\000w\000o\000r\000l\000d\000\n"; "24"];
2079        ["strings_e"; "b"; "/new"]], ["hello"; "world"])],
2080    "print the printable strings in a file",
2081    "\
2082 This is like the C<guestfs_strings> command, but allows you to
2083 specify the encoding.
2084
2085 See the L<strings(1)> manpage for the full list of encodings.
2086
2087 Commonly useful encodings are C<l> (lower case L) which will
2088 show strings inside Windows/x86 files.
2089
2090 The returned strings are transcoded to UTF-8.");
2091
2092   ("hexdump", (RString "dump", [String "path"]), 96, [ProtocolLimitWarning],
2093    [InitBasicFS, Always, TestOutput (
2094       [["write_file"; "/new"; "hello\nworld\n"; "12"];
2095        ["hexdump"; "/new"]], "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n")],
2096    "dump a file in hexadecimal",
2097    "\
2098 This runs C<hexdump -C> on the given C<path>.  The result is
2099 the human-readable, canonical hex dump of the file.");
2100
2101   ("zerofree", (RErr, [String "device"]), 97, [],
2102    [InitNone, Always, TestOutput (
2103       [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
2104        ["mkfs"; "ext3"; "/dev/sda1"];
2105        ["mount"; "/dev/sda1"; "/"];
2106        ["write_file"; "/new"; "test file"; "0"];
2107        ["umount"; "/dev/sda1"];
2108        ["zerofree"; "/dev/sda1"];
2109        ["mount"; "/dev/sda1"; "/"];
2110        ["cat"; "/new"]], "test file")],
2111    "zero unused inodes and disk blocks on ext2/3 filesystem",
2112    "\
2113 This runs the I<zerofree> program on C<device>.  This program
2114 claims to zero unused inodes and disk blocks on an ext2/3
2115 filesystem, thus making it possible to compress the filesystem
2116 more effectively.
2117
2118 You should B<not> run this program if the filesystem is
2119 mounted.
2120
2121 It is possible that using this program can damage the filesystem
2122 or data on the filesystem.");
2123
2124   ("pvresize", (RErr, [String "device"]), 98, [],
2125    [],
2126    "resize an LVM physical volume",
2127    "\
2128 This resizes (expands or shrinks) an existing LVM physical
2129 volume to match the new size of the underlying device.");
2130
2131   ("sfdisk_N", (RErr, [String "device"; Int "n";
2132                        Int "cyls"; Int "heads"; Int "sectors";
2133                        String "line"]), 99, [DangerWillRobinson],
2134    [],
2135    "modify a single partition on a block device",
2136    "\
2137 This runs L<sfdisk(8)> option to modify just the single
2138 partition C<n> (note: C<n> counts from 1).
2139
2140 For other parameters, see C<guestfs_sfdisk>.  You should usually
2141 pass C<0> for the cyls/heads/sectors parameters.");
2142
2143   ("sfdisk_l", (RString "partitions", [String "device"]), 100, [],
2144    [],
2145    "display the partition table",
2146    "\
2147 This displays the partition table on C<device>, in the
2148 human-readable output of the L<sfdisk(8)> command.  It is
2149 not intended to be parsed.");
2150
2151   ("sfdisk_kernel_geometry", (RString "partitions", [String "device"]), 101, [],
2152    [],
2153    "display the kernel geometry",
2154    "\
2155 This displays the kernel's idea of the geometry of C<device>.
2156
2157 The result is in human-readable format, and not designed to
2158 be parsed.");
2159
2160   ("sfdisk_disk_geometry", (RString "partitions", [String "device"]), 102, [],
2161    [],
2162    "display the disk geometry from the partition table",
2163    "\
2164 This displays the disk geometry of C<device> read from the
2165 partition table.  Especially in the case where the underlying
2166 block device has been resized, this can be different from the
2167 kernel's idea of the geometry (see C<guestfs_sfdisk_kernel_geometry>).
2168
2169 The result is in human-readable format, and not designed to
2170 be parsed.");
2171
2172   ("vg_activate_all", (RErr, [Bool "activate"]), 103, [],
2173    [],
2174    "activate or deactivate all volume groups",
2175    "\
2176 This command activates or (if C<activate> is false) deactivates
2177 all logical volumes in all volume groups.
2178 If activated, then they are made known to the
2179 kernel, ie. they appear as C</dev/mapper> devices.  If deactivated,
2180 then those devices disappear.
2181
2182 This command is the same as running C<vgchange -a y|n>");
2183
2184   ("vg_activate", (RErr, [Bool "activate"; StringList "volgroups"]), 104, [],
2185    [],
2186    "activate or deactivate some volume groups",
2187    "\
2188 This command activates or (if C<activate> is false) deactivates
2189 all logical volumes in the listed volume groups C<volgroups>.
2190 If activated, then they are made known to the
2191 kernel, ie. they appear as C</dev/mapper> devices.  If deactivated,
2192 then those devices disappear.
2193
2194 This command is the same as running C<vgchange -a y|n volgroups...>
2195
2196 Note that if C<volgroups> is an empty list then B<all> volume groups
2197 are activated or deactivated.");
2198
2199   ("lvresize", (RErr, [String "device"; Int "mbytes"]), 105, [],
2200    [InitNone, Always, TestOutput (
2201     [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
2202      ["pvcreate"; "/dev/sda1"];
2203      ["vgcreate"; "VG"; "/dev/sda1"];
2204      ["lvcreate"; "LV"; "VG"; "10"];
2205      ["mkfs"; "ext2"; "/dev/VG/LV"];
2206      ["mount"; "/dev/VG/LV"; "/"];
2207      ["write_file"; "/new"; "test content"; "0"];
2208      ["umount"; "/"];
2209      ["lvresize"; "/dev/VG/LV"; "20"];
2210      ["e2fsck_f"; "/dev/VG/LV"];
2211      ["resize2fs"; "/dev/VG/LV"];
2212      ["mount"; "/dev/VG/LV"; "/"];
2213      ["cat"; "/new"]], "test content")],
2214    "resize an LVM logical volume",
2215    "\
2216 This resizes (expands or shrinks) an existing LVM logical
2217 volume to C<mbytes>.  When reducing, data in the reduced part
2218 is lost.");
2219
2220   ("resize2fs", (RErr, [String "device"]), 106, [],
2221    [], (* lvresize tests this *)
2222    "resize an ext2/ext3 filesystem",
2223    "\
2224 This resizes an ext2 or ext3 filesystem to match the size of
2225 the underlying device.
2226
2227 I<Note:> It is sometimes required that you run C<guestfs_e2fsck_f>
2228 on the C<device> before calling this command.  For unknown reasons
2229 C<resize2fs> sometimes gives an error about this and sometimes not.
2230 In any case, it is always safe to call C<guestfs_e2fsck_f> before
2231 calling this function.");
2232
2233   ("find", (RStringList "names", [String "directory"]), 107, [],
2234    [InitBasicFS, Always, TestOutputList (
2235       [["find"; "/"]], ["lost+found"]);
2236     InitBasicFS, Always, TestOutputList (
2237       [["touch"; "/a"];
2238        ["mkdir"; "/b"];
2239        ["touch"; "/b/c"];
2240        ["find"; "/"]], ["a"; "b"; "b/c"; "lost+found"]);
2241     InitBasicFS, Always, TestOutputList (
2242       [["mkdir_p"; "/a/b/c"];
2243        ["touch"; "/a/b/c/d"];
2244        ["find"; "/a/b/"]], ["c"; "c/d"])],
2245    "find all files and directories",
2246    "\
2247 This command lists out all files and directories, recursively,
2248 starting at C<directory>.  It is essentially equivalent to
2249 running the shell command C<find directory -print> but some
2250 post-processing happens on the output, described below.
2251
2252 This returns a list of strings I<without any prefix>.  Thus
2253 if the directory structure was:
2254
2255  /tmp/a
2256  /tmp/b
2257  /tmp/c/d
2258
2259 then the returned list from C<guestfs_find> C</tmp> would be
2260 4 elements:
2261
2262  a
2263  b
2264  c
2265  c/d
2266
2267 If C<directory> is not a directory, then this command returns
2268 an error.
2269
2270 The returned list is sorted.");
2271
2272   ("e2fsck_f", (RErr, [String "device"]), 108, [],
2273    [], (* lvresize tests this *)
2274    "check an ext2/ext3 filesystem",
2275    "\
2276 This runs C<e2fsck -p -f device>, ie. runs the ext2/ext3
2277 filesystem checker on C<device>, noninteractively (C<-p>),
2278 even if the filesystem appears to be clean (C<-f>).
2279
2280 This command is only needed because of C<guestfs_resize2fs>
2281 (q.v.).  Normally you should use C<guestfs_fsck>.");
2282
2283 ]
2284
2285 let all_functions = non_daemon_functions @ daemon_functions
2286
2287 (* In some places we want the functions to be displayed sorted
2288  * alphabetically, so this is useful:
2289  *)
2290 let all_functions_sorted =
2291   List.sort (fun (n1,_,_,_,_,_,_) (n2,_,_,_,_,_,_) ->
2292                compare n1 n2) all_functions
2293
2294 (* Column names and types from LVM PVs/VGs/LVs. *)
2295 let pv_cols = [
2296   "pv_name", `String;
2297   "pv_uuid", `UUID;
2298   "pv_fmt", `String;
2299   "pv_size", `Bytes;
2300   "dev_size", `Bytes;
2301   "pv_free", `Bytes;
2302   "pv_used", `Bytes;
2303   "pv_attr", `String (* XXX *);
2304   "pv_pe_count", `Int;
2305   "pv_pe_alloc_count", `Int;
2306   "pv_tags", `String;
2307   "pe_start", `Bytes;
2308   "pv_mda_count", `Int;
2309   "pv_mda_free", `Bytes;
2310 (* Not in Fedora 10:
2311   "pv_mda_size", `Bytes;
2312 *)
2313 ]
2314 let vg_cols = [
2315   "vg_name", `String;
2316   "vg_uuid", `UUID;
2317   "vg_fmt", `String;
2318   "vg_attr", `String (* XXX *);
2319   "vg_size", `Bytes;
2320   "vg_free", `Bytes;
2321   "vg_sysid", `String;
2322   "vg_extent_size", `Bytes;
2323   "vg_extent_count", `Int;
2324   "vg_free_count", `Int;
2325   "max_lv", `Int;
2326   "max_pv", `Int;
2327   "pv_count", `Int;
2328   "lv_count", `Int;
2329   "snap_count", `Int;
2330   "vg_seqno", `Int;
2331   "vg_tags", `String;
2332   "vg_mda_count", `Int;
2333   "vg_mda_free", `Bytes;
2334 (* Not in Fedora 10:
2335   "vg_mda_size", `Bytes;
2336 *)
2337 ]
2338 let lv_cols = [
2339   "lv_name", `String;
2340   "lv_uuid", `UUID;
2341   "lv_attr", `String (* XXX *);
2342   "lv_major", `Int;
2343   "lv_minor", `Int;
2344   "lv_kernel_major", `Int;
2345   "lv_kernel_minor", `Int;
2346   "lv_size", `Bytes;
2347   "seg_count", `Int;
2348   "origin", `String;
2349   "snap_percent", `OptPercent;
2350   "copy_percent", `OptPercent;
2351   "move_pv", `String;
2352   "lv_tags", `String;
2353   "mirror_log", `String;
2354   "modules", `String;
2355 ]
2356
2357 (* Column names and types from stat structures.
2358  * NB. Can't use things like 'st_atime' because glibc header files
2359  * define some of these as macros.  Ugh.
2360  *)
2361 let stat_cols = [
2362   "dev", `Int;
2363   "ino", `Int;
2364   "mode", `Int;
2365   "nlink", `Int;
2366   "uid", `Int;
2367   "gid", `Int;
2368   "rdev", `Int;
2369   "size", `Int;
2370   "blksize", `Int;
2371   "blocks", `Int;
2372   "atime", `Int;
2373   "mtime", `Int;
2374   "ctime", `Int;
2375 ]
2376 let statvfs_cols = [
2377   "bsize", `Int;
2378   "frsize", `Int;
2379   "blocks", `Int;
2380   "bfree", `Int;
2381   "bavail", `Int;
2382   "files", `Int;
2383   "ffree", `Int;
2384   "favail", `Int;
2385   "fsid", `Int;
2386   "flag", `Int;
2387   "namemax", `Int;
2388 ]
2389
2390 (* Used for testing language bindings. *)
2391 type callt =
2392   | CallString of string
2393   | CallOptString of string option
2394   | CallStringList of string list
2395   | CallInt of int
2396   | CallBool of bool
2397
2398 (* Useful functions.
2399  * Note we don't want to use any external OCaml libraries which
2400  * makes this a bit harder than it should be.
2401  *)
2402 let failwithf fs = ksprintf failwith fs
2403
2404 let replace_char s c1 c2 =
2405   let s2 = String.copy s in
2406   let r = ref false in
2407   for i = 0 to String.length s2 - 1 do
2408     if String.unsafe_get s2 i = c1 then (
2409       String.unsafe_set s2 i c2;
2410       r := true
2411     )
2412   done;
2413   if not !r then s else s2
2414
2415 let isspace c =
2416   c = ' '
2417   (* || c = '\f' *) || c = '\n' || c = '\r' || c = '\t' (* || c = '\v' *)
2418
2419 let triml ?(test = isspace) str =
2420   let i = ref 0 in
2421   let n = ref (String.length str) in
2422   while !n > 0 && test str.[!i]; do
2423     decr n;
2424     incr i
2425   done;
2426   if !i = 0 then str
2427   else String.sub str !i !n
2428
2429 let trimr ?(test = isspace) str =
2430   let n = ref (String.length str) in
2431   while !n > 0 && test str.[!n-1]; do
2432     decr n
2433   done;
2434   if !n = String.length str then str
2435   else String.sub str 0 !n
2436
2437 let trim ?(test = isspace) str =
2438   trimr ~test (triml ~test str)
2439
2440 let rec find s sub =
2441   let len = String.length s in
2442   let sublen = String.length sub in
2443   let rec loop i =
2444     if i <= len-sublen then (
2445       let rec loop2 j =
2446         if j < sublen then (
2447           if s.[i+j] = sub.[j] then loop2 (j+1)
2448           else -1
2449         ) else
2450           i (* found *)
2451       in
2452       let r = loop2 0 in
2453       if r = -1 then loop (i+1) else r
2454     ) else
2455       -1 (* not found *)
2456   in
2457   loop 0
2458
2459 let rec replace_str s s1 s2 =
2460   let len = String.length s in
2461   let sublen = String.length s1 in
2462   let i = find s s1 in
2463   if i = -1 then s
2464   else (
2465     let s' = String.sub s 0 i in
2466     let s'' = String.sub s (i+sublen) (len-i-sublen) in
2467     s' ^ s2 ^ replace_str s'' s1 s2
2468   )
2469
2470 let rec string_split sep str =
2471   let len = String.length str in
2472   let seplen = String.length sep in
2473   let i = find str sep in
2474   if i = -1 then [str]
2475   else (
2476     let s' = String.sub str 0 i in
2477     let s'' = String.sub str (i+seplen) (len-i-seplen) in
2478     s' :: string_split sep s''
2479   )
2480
2481 let files_equal n1 n2 =
2482   let cmd = sprintf "cmp -s %s %s" (Filename.quote n1) (Filename.quote n2) in
2483   match Sys.command cmd with
2484   | 0 -> true
2485   | 1 -> false
2486   | i -> failwithf "%s: failed with error code %d" cmd i
2487
2488 let rec find_map f = function
2489   | [] -> raise Not_found
2490   | x :: xs ->
2491       match f x with
2492       | Some y -> y
2493       | None -> find_map f xs
2494
2495 let iteri f xs =
2496   let rec loop i = function
2497     | [] -> ()
2498     | x :: xs -> f i x; loop (i+1) xs
2499   in
2500   loop 0 xs
2501
2502 let mapi f xs =
2503   let rec loop i = function
2504     | [] -> []
2505     | x :: xs -> let r = f i x in r :: loop (i+1) xs
2506   in
2507   loop 0 xs
2508
2509 let name_of_argt = function
2510   | String n | OptString n | StringList n | Bool n | Int n
2511   | FileIn n | FileOut n -> n
2512
2513 let seq_of_test = function
2514   | TestRun s | TestOutput (s, _) | TestOutputList (s, _)
2515   | TestOutputInt (s, _) | TestOutputTrue s | TestOutputFalse s
2516   | TestOutputLength (s, _) | TestOutputStruct (s, _)
2517   | TestLastFail s -> s
2518
2519 (* Check function names etc. for consistency. *)
2520 let check_functions () =
2521   let contains_uppercase str =
2522     let len = String.length str in
2523     let rec loop i =
2524       if i >= len then false
2525       else (
2526         let c = str.[i] in
2527         if c >= 'A' && c <= 'Z' then true
2528         else loop (i+1)
2529       )
2530     in
2531     loop 0
2532   in
2533
2534   (* Check function names. *)
2535   List.iter (
2536     fun (name, _, _, _, _, _, _) ->
2537       if String.length name >= 7 && String.sub name 0 7 = "guestfs" then
2538         failwithf "function name %s does not need 'guestfs' prefix" name;
2539       if name = "" then
2540         failwithf "function name is empty";
2541       if name.[0] < 'a' || name.[0] > 'z' then
2542         failwithf "function name %s must start with lowercase a-z" name;
2543       if String.contains name '-' then
2544         failwithf "function name %s should not contain '-', use '_' instead."
2545           name
2546   ) all_functions;
2547
2548   (* Check function parameter/return names. *)
2549   List.iter (
2550     fun (name, style, _, _, _, _, _) ->
2551       let check_arg_ret_name n =
2552         if contains_uppercase n then
2553           failwithf "%s param/ret %s should not contain uppercase chars"
2554             name n;
2555         if String.contains n '-' || String.contains n '_' then
2556           failwithf "%s param/ret %s should not contain '-' or '_'"
2557             name n;
2558         if n = "value" then
2559           failwithf "%s has a param/ret called 'value', which causes conflicts in the OCaml bindings, use something like 'val' or a more descriptive name" name;
2560         if n = "int" || n = "char" || n = "short" || n = "long" then
2561           failwithf "%s has a param/ret which conflicts with a C type (eg. 'int', 'char' etc.)" name;
2562         if n = "i" then
2563           failwithf "%s has a param/ret called 'i', which will cause some conflicts in the generated code" name;
2564         if n = "argv" || n = "args" then
2565           failwithf "%s has a param/ret called 'argv' or 'args', which will cause some conflicts in the generated code" name
2566       in
2567
2568       (match fst style with
2569        | RErr -> ()
2570        | RInt n | RInt64 n | RBool n | RConstString n | RString n
2571        | RStringList n | RPVList n | RVGList n | RLVList n
2572        | RStat n | RStatVFS n
2573        | RHashtable n ->
2574            check_arg_ret_name n
2575        | RIntBool (n,m) ->
2576            check_arg_ret_name n;
2577            check_arg_ret_name m
2578       );
2579       List.iter (fun arg -> check_arg_ret_name (name_of_argt arg)) (snd style)
2580   ) all_functions;
2581
2582   (* Check short descriptions. *)
2583   List.iter (
2584     fun (name, _, _, _, _, shortdesc, _) ->
2585       if shortdesc.[0] <> Char.lowercase shortdesc.[0] then
2586         failwithf "short description of %s should begin with lowercase." name;
2587       let c = shortdesc.[String.length shortdesc-1] in
2588       if c = '\n' || c = '.' then
2589         failwithf "short description of %s should not end with . or \\n." name
2590   ) all_functions;
2591
2592   (* Check long dscriptions. *)
2593   List.iter (
2594     fun (name, _, _, _, _, _, longdesc) ->
2595       if longdesc.[String.length longdesc-1] = '\n' then
2596         failwithf "long description of %s should not end with \\n." name
2597   ) all_functions;
2598
2599   (* Check proc_nrs. *)
2600   List.iter (
2601     fun (name, _, proc_nr, _, _, _, _) ->
2602       if proc_nr <= 0 then
2603         failwithf "daemon function %s should have proc_nr > 0" name
2604   ) daemon_functions;
2605
2606   List.iter (
2607     fun (name, _, proc_nr, _, _, _, _) ->
2608       if proc_nr <> -1 then
2609         failwithf "non-daemon function %s should have proc_nr -1" name
2610   ) non_daemon_functions;
2611
2612   let proc_nrs =
2613     List.map (fun (name, _, proc_nr, _, _, _, _) -> name, proc_nr)
2614       daemon_functions in
2615   let proc_nrs =
2616     List.sort (fun (_,nr1) (_,nr2) -> compare nr1 nr2) proc_nrs in
2617   let rec loop = function
2618     | [] -> ()
2619     | [_] -> ()
2620     | (name1,nr1) :: ((name2,nr2) :: _ as rest) when nr1 < nr2 ->
2621         loop rest
2622     | (name1,nr1) :: (name2,nr2) :: _ ->
2623         failwithf "%s and %s have conflicting procedure numbers (%d, %d)"
2624           name1 name2 nr1 nr2
2625   in
2626   loop proc_nrs;
2627
2628   (* Check tests. *)
2629   List.iter (
2630     function
2631       (* Ignore functions that have no tests.  We generate a
2632        * warning when the user does 'make check' instead.
2633        *)
2634     | name, _, _, _, [], _, _ -> ()
2635     | name, _, _, _, tests, _, _ ->
2636         let funcs =
2637           List.map (
2638             fun (_, _, test) ->
2639               match seq_of_test test with
2640               | [] ->
2641                   failwithf "%s has a test containing an empty sequence" name
2642               | cmds -> List.map List.hd cmds
2643           ) tests in
2644         let funcs = List.flatten funcs in
2645
2646         let tested = List.mem name funcs in
2647
2648         if not tested then
2649           failwithf "function %s has tests but does not test itself" name
2650   ) all_functions
2651
2652 (* 'pr' prints to the current output file. *)
2653 let chan = ref stdout
2654 let pr fs = ksprintf (output_string !chan) fs
2655
2656 (* Generate a header block in a number of standard styles. *)
2657 type comment_style = CStyle | HashStyle | OCamlStyle | HaskellStyle
2658 type license = GPLv2 | LGPLv2
2659
2660 let generate_header comment license =
2661   let c = match comment with
2662     | CStyle ->     pr "/* "; " *"
2663     | HashStyle ->  pr "# ";  "#"
2664     | OCamlStyle -> pr "(* "; " *"
2665     | HaskellStyle -> pr "{- "; "  " in
2666   pr "libguestfs generated file\n";
2667   pr "%s WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.\n" c;
2668   pr "%s ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.\n" c;
2669   pr "%s\n" c;
2670   pr "%s Copyright (C) 2009 Red Hat Inc.\n" c;
2671   pr "%s\n" c;
2672   (match license with
2673    | GPLv2 ->
2674        pr "%s This program is free software; you can redistribute it and/or modify\n" c;
2675        pr "%s it under the terms of the GNU General Public License as published by\n" c;
2676        pr "%s the Free Software Foundation; either version 2 of the License, or\n" c;
2677        pr "%s (at your option) any later version.\n" c;
2678        pr "%s\n" c;
2679        pr "%s This program is distributed in the hope that it will be useful,\n" c;
2680        pr "%s but WITHOUT ANY WARRANTY; without even the implied warranty of\n" c;
2681        pr "%s MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n" c;
2682        pr "%s GNU General Public License for more details.\n" c;
2683        pr "%s\n" c;
2684        pr "%s You should have received a copy of the GNU General Public License along\n" c;
2685        pr "%s with this program; if not, write to the Free Software Foundation, Inc.,\n" c;
2686        pr "%s 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\n" c;
2687
2688    | LGPLv2 ->
2689        pr "%s This library is free software; you can redistribute it and/or\n" c;
2690        pr "%s modify it under the terms of the GNU Lesser General Public\n" c;
2691        pr "%s License as published by the Free Software Foundation; either\n" c;
2692        pr "%s version 2 of the License, or (at your option) any later version.\n" c;
2693        pr "%s\n" c;
2694        pr "%s This library is distributed in the hope that it will be useful,\n" c;
2695        pr "%s but WITHOUT ANY WARRANTY; without even the implied warranty of\n" c;
2696        pr "%s MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n" c;
2697        pr "%s Lesser General Public License for more details.\n" c;
2698        pr "%s\n" c;
2699        pr "%s You should have received a copy of the GNU Lesser General Public\n" c;
2700        pr "%s License along with this library; if not, write to the Free Software\n" c;
2701        pr "%s Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n" c;
2702   );
2703   (match comment with
2704    | CStyle -> pr " */\n"
2705    | HashStyle -> ()
2706    | OCamlStyle -> pr " *)\n"
2707    | HaskellStyle -> pr "-}\n"
2708   );
2709   pr "\n"
2710
2711 (* Start of main code generation functions below this line. *)
2712
2713 (* Generate the pod documentation for the C API. *)
2714 let rec generate_actions_pod () =
2715   List.iter (
2716     fun (shortname, style, _, flags, _, _, longdesc) ->
2717       if not (List.mem NotInDocs flags) then (
2718         let name = "guestfs_" ^ shortname in
2719         pr "=head2 %s\n\n" name;
2720         pr " ";
2721         generate_prototype ~extern:false ~handle:"handle" name style;
2722         pr "\n\n";
2723         pr "%s\n\n" longdesc;
2724         (match fst style with
2725          | RErr ->
2726              pr "This function returns 0 on success or -1 on error.\n\n"
2727          | RInt _ ->
2728              pr "On error this function returns -1.\n\n"
2729          | RInt64 _ ->
2730              pr "On error this function returns -1.\n\n"
2731          | RBool _ ->
2732              pr "This function returns a C truth value on success or -1 on error.\n\n"
2733          | RConstString _ ->
2734              pr "This function returns a string, or NULL on error.
2735 The string is owned by the guest handle and must I<not> be freed.\n\n"
2736          | RString _ ->
2737              pr "This function returns a string, or NULL on error.
2738 I<The caller must free the returned string after use>.\n\n"
2739          | RStringList _ ->
2740              pr "This function returns a NULL-terminated array of strings
2741 (like L<environ(3)>), or NULL if there was an error.
2742 I<The caller must free the strings and the array after use>.\n\n"
2743          | RIntBool _ ->
2744              pr "This function returns a C<struct guestfs_int_bool *>,
2745 or NULL if there was an error.
2746 I<The caller must call C<guestfs_free_int_bool> after use>.\n\n"
2747          | RPVList _ ->
2748              pr "This function returns a C<struct guestfs_lvm_pv_list *>
2749 (see E<lt>guestfs-structs.hE<gt>),
2750 or NULL if there was an error.
2751 I<The caller must call C<guestfs_free_lvm_pv_list> after use>.\n\n"
2752          | RVGList _ ->
2753              pr "This function returns a C<struct guestfs_lvm_vg_list *>
2754 (see E<lt>guestfs-structs.hE<gt>),
2755 or NULL if there was an error.
2756 I<The caller must call C<guestfs_free_lvm_vg_list> after use>.\n\n"
2757          | RLVList _ ->
2758              pr "This function returns a C<struct guestfs_lvm_lv_list *>
2759 (see E<lt>guestfs-structs.hE<gt>),
2760 or NULL if there was an error.
2761 I<The caller must call C<guestfs_free_lvm_lv_list> after use>.\n\n"
2762          | RStat _ ->
2763              pr "This function returns a C<struct guestfs_stat *>
2764 (see L<stat(2)> and E<lt>guestfs-structs.hE<gt>),
2765 or NULL if there was an error.
2766 I<The caller must call C<free> after use>.\n\n"
2767          | RStatVFS _ ->
2768              pr "This function returns a C<struct guestfs_statvfs *>
2769 (see L<statvfs(2)> and E<lt>guestfs-structs.hE<gt>),
2770 or NULL if there was an error.
2771 I<The caller must call C<free> after use>.\n\n"
2772          | RHashtable _ ->
2773              pr "This function returns a NULL-terminated array of
2774 strings, or NULL if there was an error.
2775 The array of strings will always have length C<2n+1>, where
2776 C<n> keys and values alternate, followed by the trailing NULL entry.
2777 I<The caller must free the strings and the array after use>.\n\n"
2778         );
2779         if List.mem ProtocolLimitWarning flags then
2780           pr "%s\n\n" protocol_limit_warning;
2781         if List.mem DangerWillRobinson flags then
2782           pr "%s\n\n" danger_will_robinson
2783       )
2784   ) all_functions_sorted
2785
2786 and generate_structs_pod () =
2787   (* LVM structs documentation. *)
2788   List.iter (
2789     fun (typ, cols) ->
2790       pr "=head2 guestfs_lvm_%s\n" typ;
2791       pr "\n";
2792       pr " struct guestfs_lvm_%s {\n" typ;
2793       List.iter (
2794         function
2795         | name, `String -> pr "  char *%s;\n" name
2796         | name, `UUID ->
2797             pr "  /* The next field is NOT nul-terminated, be careful when printing it: */\n";
2798             pr "  char %s[32];\n" name
2799         | name, `Bytes -> pr "  uint64_t %s;\n" name
2800         | name, `Int -> pr "  int64_t %s;\n" name
2801         | name, `OptPercent ->
2802             pr "  /* The next field is [0..100] or -1 meaning 'not present': */\n";
2803             pr "  float %s;\n" name
2804       ) cols;
2805       pr " \n";
2806       pr " struct guestfs_lvm_%s_list {\n" typ;
2807       pr "   uint32_t len; /* Number of elements in list. */\n";
2808       pr "   struct guestfs_lvm_%s *val; /* Elements. */\n" typ;
2809       pr " };\n";
2810       pr " \n";
2811       pr " void guestfs_free_lvm_%s_list (struct guestfs_free_lvm_%s_list *);\n"
2812         typ typ;
2813       pr "\n"
2814   ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols]
2815
2816 (* Generate the protocol (XDR) file, 'guestfs_protocol.x' and
2817  * indirectly 'guestfs_protocol.h' and 'guestfs_protocol.c'.
2818  *
2819  * We have to use an underscore instead of a dash because otherwise
2820  * rpcgen generates incorrect code.
2821  *
2822  * This header is NOT exported to clients, but see also generate_structs_h.
2823  *)
2824 and generate_xdr () =
2825   generate_header CStyle LGPLv2;
2826
2827   (* This has to be defined to get around a limitation in Sun's rpcgen. *)
2828   pr "typedef string str<>;\n";
2829   pr "\n";
2830
2831   (* LVM internal structures. *)
2832   List.iter (
2833     function
2834     | typ, cols ->
2835         pr "struct guestfs_lvm_int_%s {\n" typ;
2836         List.iter (function
2837                    | name, `String -> pr "  string %s<>;\n" name
2838                    | name, `UUID -> pr "  opaque %s[32];\n" name
2839                    | name, `Bytes -> pr "  hyper %s;\n" name
2840                    | name, `Int -> pr "  hyper %s;\n" name
2841                    | name, `OptPercent -> pr "  float %s;\n" name
2842                   ) cols;
2843         pr "};\n";
2844         pr "\n";
2845         pr "typedef struct guestfs_lvm_int_%s guestfs_lvm_int_%s_list<>;\n" typ typ;
2846         pr "\n";
2847   ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
2848
2849   (* Stat internal structures. *)
2850   List.iter (
2851     function
2852     | typ, cols ->
2853         pr "struct guestfs_int_%s {\n" typ;
2854         List.iter (function
2855                    | name, `Int -> pr "  hyper %s;\n" name
2856                   ) cols;
2857         pr "};\n";
2858         pr "\n";
2859   ) ["stat", stat_cols; "statvfs", statvfs_cols];
2860
2861   List.iter (
2862     fun (shortname, style, _, _, _, _, _) ->
2863       let name = "guestfs_" ^ shortname in
2864
2865       (match snd style with
2866        | [] -> ()
2867        | args ->
2868            pr "struct %s_args {\n" name;
2869            List.iter (
2870              function
2871              | String n -> pr "  string %s<>;\n" n
2872              | OptString n -> pr "  str *%s;\n" n
2873              | StringList n -> pr "  str %s<>;\n" n
2874              | Bool n -> pr "  bool %s;\n" n
2875              | Int n -> pr "  int %s;\n" n
2876              | FileIn _ | FileOut _ -> ()
2877            ) args;
2878            pr "};\n\n"
2879       );
2880       (match fst style with
2881        | RErr -> ()
2882        | RInt n ->
2883            pr "struct %s_ret {\n" name;
2884            pr "  int %s;\n" n;
2885            pr "};\n\n"
2886        | RInt64 n ->
2887            pr "struct %s_ret {\n" name;
2888            pr "  hyper %s;\n" n;
2889            pr "};\n\n"
2890        | RBool n ->
2891            pr "struct %s_ret {\n" name;
2892            pr "  bool %s;\n" n;
2893            pr "};\n\n"
2894        | RConstString _ ->
2895            failwithf "RConstString cannot be returned from a daemon function"
2896        | RString n ->
2897            pr "struct %s_ret {\n" name;
2898            pr "  string %s<>;\n" n;
2899            pr "};\n\n"
2900        | RStringList n ->
2901            pr "struct %s_ret {\n" name;
2902            pr "  str %s<>;\n" n;
2903            pr "};\n\n"
2904        | RIntBool (n,m) ->
2905            pr "struct %s_ret {\n" name;
2906            pr "  int %s;\n" n;
2907            pr "  bool %s;\n" m;
2908            pr "};\n\n"
2909        | RPVList n ->
2910            pr "struct %s_ret {\n" name;
2911            pr "  guestfs_lvm_int_pv_list %s;\n" n;
2912            pr "};\n\n"
2913        | RVGList n ->
2914            pr "struct %s_ret {\n" name;
2915            pr "  guestfs_lvm_int_vg_list %s;\n" n;
2916            pr "};\n\n"
2917        | RLVList n ->
2918            pr "struct %s_ret {\n" name;
2919            pr "  guestfs_lvm_int_lv_list %s;\n" n;
2920            pr "};\n\n"
2921        | RStat n ->
2922            pr "struct %s_ret {\n" name;
2923            pr "  guestfs_int_stat %s;\n" n;
2924            pr "};\n\n"
2925        | RStatVFS n ->
2926            pr "struct %s_ret {\n" name;
2927            pr "  guestfs_int_statvfs %s;\n" n;
2928            pr "};\n\n"
2929        | RHashtable n ->
2930            pr "struct %s_ret {\n" name;
2931            pr "  str %s<>;\n" n;
2932            pr "};\n\n"
2933       );
2934   ) daemon_functions;
2935
2936   (* Table of procedure numbers. *)
2937   pr "enum guestfs_procedure {\n";
2938   List.iter (
2939     fun (shortname, _, proc_nr, _, _, _, _) ->
2940       pr "  GUESTFS_PROC_%s = %d,\n" (String.uppercase shortname) proc_nr
2941   ) daemon_functions;
2942   pr "  GUESTFS_PROC_NR_PROCS\n";
2943   pr "};\n";
2944   pr "\n";
2945
2946   (* Having to choose a maximum message size is annoying for several
2947    * reasons (it limits what we can do in the API), but it (a) makes
2948    * the protocol a lot simpler, and (b) provides a bound on the size
2949    * of the daemon which operates in limited memory space.  For large
2950    * file transfers you should use FTP.
2951    *)
2952   pr "const GUESTFS_MESSAGE_MAX = %d;\n" (4 * 1024 * 1024);
2953   pr "\n";
2954
2955   (* Message header, etc. *)
2956   pr "\
2957 /* The communication protocol is now documented in the guestfs(3)
2958  * manpage.
2959  */
2960
2961 const GUESTFS_PROGRAM = 0x2000F5F5;
2962 const GUESTFS_PROTOCOL_VERSION = 1;
2963
2964 /* These constants must be larger than any possible message length. */
2965 const GUESTFS_LAUNCH_FLAG = 0xf5f55ff5;
2966 const GUESTFS_CANCEL_FLAG = 0xffffeeee;
2967
2968 enum guestfs_message_direction {
2969   GUESTFS_DIRECTION_CALL = 0,        /* client -> daemon */
2970   GUESTFS_DIRECTION_REPLY = 1        /* daemon -> client */
2971 };
2972
2973 enum guestfs_message_status {
2974   GUESTFS_STATUS_OK = 0,
2975   GUESTFS_STATUS_ERROR = 1
2976 };
2977
2978 const GUESTFS_ERROR_LEN = 256;
2979
2980 struct guestfs_message_error {
2981   string error_message<GUESTFS_ERROR_LEN>;
2982 };
2983
2984 struct guestfs_message_header {
2985   unsigned prog;                     /* GUESTFS_PROGRAM */
2986   unsigned vers;                     /* GUESTFS_PROTOCOL_VERSION */
2987   guestfs_procedure proc;            /* GUESTFS_PROC_x */
2988   guestfs_message_direction direction;
2989   unsigned serial;                   /* message serial number */
2990   guestfs_message_status status;
2991 };
2992
2993 const GUESTFS_MAX_CHUNK_SIZE = 8192;
2994
2995 struct guestfs_chunk {
2996   int cancel;                        /* if non-zero, transfer is cancelled */
2997   /* data size is 0 bytes if the transfer has finished successfully */
2998   opaque data<GUESTFS_MAX_CHUNK_SIZE>;
2999 };
3000 "
3001
3002 (* Generate the guestfs-structs.h file. *)
3003 and generate_structs_h () =
3004   generate_header CStyle LGPLv2;
3005
3006   (* This is a public exported header file containing various
3007    * structures.  The structures are carefully written to have
3008    * exactly the same in-memory format as the XDR structures that
3009    * we use on the wire to the daemon.  The reason for creating
3010    * copies of these structures here is just so we don't have to
3011    * export the whole of guestfs_protocol.h (which includes much
3012    * unrelated and XDR-dependent stuff that we don't want to be
3013    * public, or required by clients).
3014    *
3015    * To reiterate, we will pass these structures to and from the
3016    * client with a simple assignment or memcpy, so the format
3017    * must be identical to what rpcgen / the RFC defines.
3018    *)
3019
3020   (* guestfs_int_bool structure. *)
3021   pr "struct guestfs_int_bool {\n";
3022   pr "  int32_t i;\n";
3023   pr "  int32_t b;\n";
3024   pr "};\n";
3025   pr "\n";
3026
3027   (* LVM public structures. *)
3028   List.iter (
3029     function
3030     | typ, cols ->
3031         pr "struct guestfs_lvm_%s {\n" typ;
3032         List.iter (
3033           function
3034           | name, `String -> pr "  char *%s;\n" name
3035           | name, `UUID -> pr "  char %s[32]; /* this is NOT nul-terminated, be careful when printing */\n" name
3036           | name, `Bytes -> pr "  uint64_t %s;\n" name
3037           | name, `Int -> pr "  int64_t %s;\n" name
3038           | name, `OptPercent -> pr "  float %s; /* [0..100] or -1 */\n" name
3039         ) cols;
3040         pr "};\n";
3041         pr "\n";
3042         pr "struct guestfs_lvm_%s_list {\n" typ;
3043         pr "  uint32_t len;\n";
3044         pr "  struct guestfs_lvm_%s *val;\n" typ;
3045         pr "};\n";
3046         pr "\n"
3047   ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
3048
3049   (* Stat structures. *)
3050   List.iter (
3051     function
3052     | typ, cols ->
3053         pr "struct guestfs_%s {\n" typ;
3054         List.iter (
3055           function
3056           | name, `Int -> pr "  int64_t %s;\n" name
3057         ) cols;
3058         pr "};\n";
3059         pr "\n"
3060   ) ["stat", stat_cols; "statvfs", statvfs_cols]
3061
3062 (* Generate the guestfs-actions.h file. *)
3063 and generate_actions_h () =
3064   generate_header CStyle LGPLv2;
3065   List.iter (
3066     fun (shortname, style, _, _, _, _, _) ->
3067       let name = "guestfs_" ^ shortname in
3068       generate_prototype ~single_line:true ~newline:true ~handle:"handle"
3069         name style
3070   ) all_functions
3071
3072 (* Generate the client-side dispatch stubs. *)
3073 and generate_client_actions () =
3074   generate_header CStyle LGPLv2;
3075
3076   pr "\
3077 #include <stdio.h>
3078 #include <stdlib.h>
3079
3080 #include \"guestfs.h\"
3081 #include \"guestfs_protocol.h\"
3082
3083 #define error guestfs_error
3084 #define perrorf guestfs_perrorf
3085 #define safe_malloc guestfs_safe_malloc
3086 #define safe_realloc guestfs_safe_realloc
3087 #define safe_strdup guestfs_safe_strdup
3088 #define safe_memdup guestfs_safe_memdup
3089
3090 /* Check the return message from a call for validity. */
3091 static int
3092 check_reply_header (guestfs_h *g,
3093                     const struct guestfs_message_header *hdr,
3094                     int proc_nr, int serial)
3095 {
3096   if (hdr->prog != GUESTFS_PROGRAM) {
3097     error (g, \"wrong program (%%d/%%d)\", hdr->prog, GUESTFS_PROGRAM);
3098     return -1;
3099   }
3100   if (hdr->vers != GUESTFS_PROTOCOL_VERSION) {
3101     error (g, \"wrong protocol version (%%d/%%d)\",
3102            hdr->vers, GUESTFS_PROTOCOL_VERSION);
3103     return -1;
3104   }
3105   if (hdr->direction != GUESTFS_DIRECTION_REPLY) {
3106     error (g, \"unexpected message direction (%%d/%%d)\",
3107            hdr->direction, GUESTFS_DIRECTION_REPLY);
3108     return -1;
3109   }
3110   if (hdr->proc != proc_nr) {
3111     error (g, \"unexpected procedure number (%%d/%%d)\", hdr->proc, proc_nr);
3112     return -1;
3113   }
3114   if (hdr->serial != serial) {
3115     error (g, \"unexpected serial (%%d/%%d)\", hdr->serial, serial);
3116     return -1;
3117   }
3118
3119   return 0;
3120 }
3121
3122 /* Check we are in the right state to run a high-level action. */
3123 static int
3124 check_state (guestfs_h *g, const char *caller)
3125 {
3126   if (!guestfs_is_ready (g)) {
3127     if (guestfs_is_config (g))
3128       error (g, \"%%s: call launch() before using this function\",
3129         caller);
3130     else if (guestfs_is_launching (g))
3131       error (g, \"%%s: call wait_ready() before using this function\",
3132         caller);
3133     else
3134       error (g, \"%%s called from the wrong state, %%d != READY\",
3135         caller, guestfs_get_state (g));
3136     return -1;
3137   }
3138   return 0;
3139 }
3140
3141 ";
3142
3143   (* Client-side stubs for each function. *)
3144   List.iter (
3145     fun (shortname, style, _, _, _, _, _) ->
3146       let name = "guestfs_" ^ shortname in
3147
3148       (* Generate the context struct which stores the high-level
3149        * state between callback functions.
3150        *)
3151       pr "struct %s_ctx {\n" shortname;
3152       pr "  /* This flag is set by the callbacks, so we know we've done\n";
3153       pr "   * the callbacks as expected, and in the right sequence.\n";
3154       pr "   * 0 = not called, 1 = reply_cb called.\n";
3155       pr "   */\n";
3156       pr "  int cb_sequence;\n";
3157       pr "  struct guestfs_message_header hdr;\n";
3158       pr "  struct guestfs_message_error err;\n";
3159       (match fst style with
3160        | RErr -> ()
3161        | RConstString _ ->
3162            failwithf "RConstString cannot be returned from a daemon function"
3163        | RInt _ | RInt64 _
3164        | RBool _ | RString _ | RStringList _
3165        | RIntBool _
3166        | RPVList _ | RVGList _ | RLVList _
3167        | RStat _ | RStatVFS _
3168        | RHashtable _ ->
3169            pr "  struct %s_ret ret;\n" name
3170       );
3171       pr "};\n";
3172       pr "\n";
3173
3174       (* Generate the reply callback function. *)
3175       pr "static void %s_reply_cb (guestfs_h *g, void *data, XDR *xdr)\n" shortname;
3176       pr "{\n";
3177       pr "  guestfs_main_loop *ml = guestfs_get_main_loop (g);\n";
3178       pr "  struct %s_ctx *ctx = (struct %s_ctx *) data;\n" shortname shortname;
3179       pr "\n";
3180       pr "  /* This should definitely not happen. */\n";
3181       pr "  if (ctx->cb_sequence != 0) {\n";
3182       pr "    ctx->cb_sequence = 9999;\n";
3183       pr "    error (g, \"%%s: internal error: reply callback called twice\", \"%s\");\n" name;
3184       pr "    return;\n";
3185       pr "  }\n";
3186       pr "\n";
3187       pr "  ml->main_loop_quit (ml, g);\n";
3188       pr "\n";
3189       pr "  if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {\n";
3190       pr "    error (g, \"%%s: failed to parse reply header\", \"%s\");\n" name;
3191       pr "    return;\n";
3192       pr "  }\n";
3193       pr "  if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {\n";
3194       pr "    if (!xdr_guestfs_message_error (xdr, &ctx->err)) {\n";
3195       pr "      error (g, \"%%s: failed to parse reply error\", \"%s\");\n"
3196         name;
3197       pr "      return;\n";
3198       pr "    }\n";
3199       pr "    goto done;\n";
3200       pr "  }\n";
3201
3202       (match fst style with
3203        | RErr -> ()
3204        | RConstString _ ->
3205            failwithf "RConstString cannot be returned from a daemon function"
3206        | RInt _ | RInt64 _
3207        | RBool _ | RString _ | RStringList _
3208        | RIntBool _
3209        | RPVList _ | RVGList _ | RLVList _
3210        | RStat _ | RStatVFS _
3211        | RHashtable _ ->
3212             pr "  if (!xdr_%s_ret (xdr, &ctx->ret)) {\n" name;
3213             pr "    error (g, \"%%s: failed to parse reply\", \"%s\");\n" name;
3214             pr "    return;\n";
3215             pr "  }\n";
3216       );
3217
3218       pr " done:\n";
3219       pr "  ctx->cb_sequence = 1;\n";
3220       pr "}\n\n";
3221
3222       (* Generate the action stub. *)
3223       generate_prototype ~extern:false ~semicolon:false ~newline:true
3224         ~handle:"g" name style;
3225
3226       let error_code =
3227         match fst style with
3228         | RErr | RInt _ | RInt64 _ | RBool _ -> "-1"
3229         | RConstString _ ->
3230             failwithf "RConstString cannot be returned from a daemon function"
3231         | RString _ | RStringList _ | RIntBool _
3232         | RPVList _ | RVGList _ | RLVList _
3233         | RStat _ | RStatVFS _
3234         | RHashtable _ ->
3235             "NULL" in
3236
3237       pr "{\n";
3238
3239       (match snd style with
3240        | [] -> ()
3241        | _ -> pr "  struct %s_args args;\n" name
3242       );
3243
3244       pr "  struct %s_ctx ctx;\n" shortname;
3245       pr "  guestfs_main_loop *ml = guestfs_get_main_loop (g);\n";
3246       pr "  int serial;\n";
3247       pr "\n";
3248       pr "  if (check_state (g, \"%s\") == -1) return %s;\n" name error_code;
3249       pr "  guestfs_set_busy (g);\n";
3250       pr "\n";
3251       pr "  memset (&ctx, 0, sizeof ctx);\n";
3252       pr "\n";
3253
3254       (* Send the main header and arguments. *)
3255       (match snd style with
3256        | [] ->
3257            pr "  serial = guestfs__send_sync (g, GUESTFS_PROC_%s, NULL, NULL);\n"
3258              (String.uppercase shortname)
3259        | args ->
3260            List.iter (
3261              function
3262              | String n ->
3263                  pr "  args.%s = (char *) %s;\n" n n
3264              | OptString n ->
3265                  pr "  args.%s = %s ? (char **) &%s : NULL;\n" n n n
3266              | StringList n ->
3267                  pr "  args.%s.%s_val = (char **) %s;\n" n n n;
3268                  pr "  for (args.%s.%s_len = 0; %s[args.%s.%s_len]; args.%s.%s_len++) ;\n" n n n n n n n;
3269              | Bool n ->
3270                  pr "  args.%s = %s;\n" n n
3271              | Int n ->
3272                  pr "  args.%s = %s;\n" n n
3273              | FileIn _ | FileOut _ -> ()
3274            ) args;
3275            pr "  serial = guestfs__send_sync (g, GUESTFS_PROC_%s,\n"
3276              (String.uppercase shortname);
3277            pr "        (xdrproc_t) xdr_%s_args, (char *) &args);\n"
3278              name;
3279       );
3280       pr "  if (serial == -1) {\n";
3281       pr "    guestfs_end_busy (g);\n";
3282       pr "    return %s;\n" error_code;
3283       pr "  }\n";
3284       pr "\n";
3285
3286       (* Send any additional files (FileIn) requested. *)
3287       let need_read_reply_label = ref false in
3288       List.iter (
3289         function
3290         | FileIn n ->
3291             pr "  {\n";
3292             pr "    int r;\n";
3293             pr "\n";
3294             pr "    r = guestfs__send_file_sync (g, %s);\n" n;
3295             pr "    if (r == -1) {\n";
3296             pr "      guestfs_end_busy (g);\n";
3297             pr "      return %s;\n" error_code;
3298             pr "    }\n";
3299             pr "    if (r == -2) /* daemon cancelled */\n";
3300             pr "      goto read_reply;\n";
3301             need_read_reply_label := true;
3302             pr "  }\n";
3303             pr "\n";
3304         | _ -> ()
3305       ) (snd style);
3306
3307       (* Wait for the reply from the remote end. *)
3308       if !need_read_reply_label then pr " read_reply:\n";
3309       pr "  guestfs__switch_to_receiving (g);\n";
3310       pr "  ctx.cb_sequence = 0;\n";
3311       pr "  guestfs_set_reply_callback (g, %s_reply_cb, &ctx);\n" shortname;
3312       pr "  (void) ml->main_loop_run (ml, g);\n";
3313       pr "  guestfs_set_reply_callback (g, NULL, NULL);\n";
3314       pr "  if (ctx.cb_sequence != 1) {\n";
3315       pr "    error (g, \"%%s reply failed, see earlier error messages\", \"%s\");\n" name;
3316       pr "    guestfs_end_busy (g);\n";
3317       pr "    return %s;\n" error_code;
3318       pr "  }\n";
3319       pr "\n";
3320
3321       pr "  if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_%s, serial) == -1) {\n"
3322         (String.uppercase shortname);
3323       pr "    guestfs_end_busy (g);\n";
3324       pr "    return %s;\n" error_code;
3325       pr "  }\n";
3326       pr "\n";
3327
3328       pr "  if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {\n";
3329       pr "    error (g, \"%%s\", ctx.err.error_message);\n";
3330       pr "    free (ctx.err.error_message);\n";
3331       pr "    guestfs_end_busy (g);\n";
3332       pr "    return %s;\n" error_code;
3333       pr "  }\n";
3334       pr "\n";
3335
3336       (* Expecting to receive further files (FileOut)? *)
3337       List.iter (
3338         function
3339         | FileOut n ->
3340             pr "  if (guestfs__receive_file_sync (g, %s) == -1) {\n" n;
3341             pr "    guestfs_end_busy (g);\n";
3342             pr "    return %s;\n" error_code;
3343             pr "  }\n";
3344             pr "\n";
3345         | _ -> ()
3346       ) (snd style);
3347
3348       pr "  guestfs_end_busy (g);\n";
3349
3350       (match fst style with
3351        | RErr -> pr "  return 0;\n"
3352        | RInt n | RInt64 n | RBool n ->
3353            pr "  return ctx.ret.%s;\n" n
3354        | RConstString _ ->
3355            failwithf "RConstString cannot be returned from a daemon function"
3356        | RString n ->
3357            pr "  return ctx.ret.%s; /* caller will free */\n" n
3358        | RStringList n | RHashtable n ->
3359            pr "  /* caller will free this, but we need to add a NULL entry */\n";
3360            pr "  ctx.ret.%s.%s_val =\n" n n;
3361            pr "    safe_realloc (g, ctx.ret.%s.%s_val,\n" n n;
3362            pr "                  sizeof (char *) * (ctx.ret.%s.%s_len + 1));\n"
3363              n n;
3364            pr "  ctx.ret.%s.%s_val[ctx.ret.%s.%s_len] = NULL;\n" n n n n;
3365            pr "  return ctx.ret.%s.%s_val;\n" n n
3366        | RIntBool _ ->
3367            pr "  /* caller with free this */\n";
3368            pr "  return safe_memdup (g, &ctx.ret, sizeof (ctx.ret));\n"
3369        | RPVList n | RVGList n | RLVList n
3370        | RStat n | RStatVFS n ->
3371            pr "  /* caller will free this */\n";
3372            pr "  return safe_memdup (g, &ctx.ret.%s, sizeof (ctx.ret.%s));\n" n n
3373       );
3374
3375       pr "}\n\n"
3376   ) daemon_functions
3377
3378 (* Generate daemon/actions.h. *)
3379 and generate_daemon_actions_h () =
3380   generate_header CStyle GPLv2;
3381
3382   pr "#include \"../src/guestfs_protocol.h\"\n";
3383   pr "\n";
3384
3385   List.iter (
3386     fun (name, style, _, _, _, _, _) ->
3387         generate_prototype
3388           ~single_line:true ~newline:true ~in_daemon:true ~prefix:"do_"
3389           name style;
3390   ) daemon_functions
3391
3392 (* Generate the server-side stubs. *)
3393 and generate_daemon_actions () =
3394   generate_header CStyle GPLv2;
3395
3396   pr "#include <config.h>\n";
3397   pr "\n";
3398   pr "#include <stdio.h>\n";
3399   pr "#include <stdlib.h>\n";
3400   pr "#include <string.h>\n";
3401   pr "#include <inttypes.h>\n";
3402   pr "#include <ctype.h>\n";
3403   pr "#include <rpc/types.h>\n";
3404   pr "#include <rpc/xdr.h>\n";
3405   pr "\n";
3406   pr "#include \"daemon.h\"\n";
3407   pr "#include \"../src/guestfs_protocol.h\"\n";
3408   pr "#include \"actions.h\"\n";
3409   pr "\n";
3410
3411   List.iter (
3412     fun (name, style, _, _, _, _, _) ->
3413       (* Generate server-side stubs. *)
3414       pr "static void %s_stub (XDR *xdr_in)\n" name;
3415       pr "{\n";
3416       let error_code =
3417         match fst style with
3418         | RErr | RInt _ -> pr "  int r;\n"; "-1"
3419         | RInt64 _ -> pr "  int64_t r;\n"; "-1"
3420         | RBool _ -> pr "  int r;\n"; "-1"
3421         | RConstString _ ->
3422             failwithf "RConstString cannot be returned from a daemon function"
3423         | RString _ -> pr "  char *r;\n"; "NULL"
3424         | RStringList _ | RHashtable _ -> pr "  char **r;\n"; "NULL"
3425         | RIntBool _ -> pr "  guestfs_%s_ret *r;\n" name; "NULL"
3426         | RPVList _ -> pr "  guestfs_lvm_int_pv_list *r;\n"; "NULL"
3427         | RVGList _ -> pr "  guestfs_lvm_int_vg_list *r;\n"; "NULL"
3428         | RLVList _ -> pr "  guestfs_lvm_int_lv_list *r;\n"; "NULL"
3429         | RStat _ -> pr "  guestfs_int_stat *r;\n"; "NULL"
3430         | RStatVFS _ -> pr "  guestfs_int_statvfs *r;\n"; "NULL" in
3431
3432       (match snd style with
3433        | [] -> ()
3434        | args ->
3435            pr "  struct guestfs_%s_args args;\n" name;
3436            List.iter (
3437              function
3438              | String n
3439              | OptString n -> pr "  const char *%s;\n" n
3440              | StringList n -> pr "  char **%s;\n" n
3441              | Bool n -> pr "  int %s;\n" n
3442              | Int n -> pr "  int %s;\n" n
3443              | FileIn _ | FileOut _ -> ()
3444            ) args
3445       );
3446       pr "\n";
3447
3448       (match snd style with
3449        | [] -> ()
3450        | args ->
3451            pr "  memset (&args, 0, sizeof args);\n";
3452            pr "\n";
3453            pr "  if (!xdr_guestfs_%s_args (xdr_in, &args)) {\n" name;
3454            pr "    reply_with_error (\"%%s: daemon failed to decode procedure arguments\", \"%s\");\n" name;
3455            pr "    return;\n";
3456            pr "  }\n";
3457            List.iter (
3458              function
3459              | String n -> pr "  %s = args.%s;\n" n n
3460              | OptString n -> pr "  %s = args.%s ? *args.%s : NULL;\n" n n n
3461              | StringList n ->
3462                  pr "  %s = realloc (args.%s.%s_val,\n" n n n;
3463                  pr "                sizeof (char *) * (args.%s.%s_len+1));\n" n n;
3464                  pr "  if (%s == NULL) {\n" n;
3465                  pr "    reply_with_perror (\"realloc\");\n";
3466                  pr "    goto done;\n";
3467                  pr "  }\n";
3468                  pr "  %s[args.%s.%s_len] = NULL;\n" n n n;
3469                  pr "  args.%s.%s_val = %s;\n" n n n;
3470              | Bool n -> pr "  %s = args.%s;\n" n n
3471              | Int n -> pr "  %s = args.%s;\n" n n
3472              | FileIn _ | FileOut _ -> ()
3473            ) args;
3474            pr "\n"
3475       );
3476
3477       (* Don't want to call the impl with any FileIn or FileOut
3478        * parameters, since these go "outside" the RPC protocol.
3479        *)
3480       let argsnofile =
3481         List.filter (function FileIn _ | FileOut _ -> false | _ -> true)
3482           (snd style) in
3483       pr "  r = do_%s " name;
3484       generate_call_args argsnofile;
3485       pr ";\n";
3486
3487       pr "  if (r == %s)\n" error_code;
3488       pr "    /* do_%s has already called reply_with_error */\n" name;
3489       pr "    goto done;\n";
3490       pr "\n";
3491
3492       (* If there are any FileOut parameters, then the impl must
3493        * send its own reply.
3494        *)
3495       let no_reply =
3496         List.exists (function FileOut _ -> true | _ -> false) (snd style) in
3497       if no_reply then
3498         pr "  /* do_%s has already sent a reply */\n" name
3499       else (
3500         match fst style with
3501         | RErr -> pr "  reply (NULL, NULL);\n"
3502         | RInt n | RInt64 n | RBool n ->
3503             pr "  struct guestfs_%s_ret ret;\n" name;
3504             pr "  ret.%s = r;\n" n;
3505             pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
3506               name
3507         | RConstString _ ->
3508             failwithf "RConstString cannot be returned from a daemon function"
3509         | RString n ->
3510             pr "  struct guestfs_%s_ret ret;\n" name;
3511             pr "  ret.%s = r;\n" n;
3512             pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
3513               name;
3514             pr "  free (r);\n"
3515         | RStringList n | RHashtable n ->
3516             pr "  struct guestfs_%s_ret ret;\n" name;
3517             pr "  ret.%s.%s_len = count_strings (r);\n" n n;
3518             pr "  ret.%s.%s_val = r;\n" n n;
3519             pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
3520               name;
3521             pr "  free_strings (r);\n"
3522         | RIntBool _ ->
3523             pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) r);\n"
3524               name;
3525             pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) r);\n" name
3526         | RPVList n | RVGList n | RLVList n
3527         | RStat n | RStatVFS n ->
3528             pr "  struct guestfs_%s_ret ret;\n" name;
3529             pr "  ret.%s = *r;\n" n;
3530             pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n"
3531               name;
3532             pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n"
3533               name
3534       );
3535
3536       (* Free the args. *)
3537       (match snd style with
3538        | [] ->
3539            pr "done: ;\n";
3540        | _ ->
3541            pr "done:\n";
3542            pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_args, (char *) &args);\n"
3543              name
3544       );
3545
3546       pr "}\n\n";
3547   ) daemon_functions;
3548
3549   (* Dispatch function. *)
3550   pr "void dispatch_incoming_message (XDR *xdr_in)\n";
3551   pr "{\n";
3552   pr "  switch (proc_nr) {\n";
3553
3554   List.iter (
3555     fun (name, style, _, _, _, _, _) ->
3556         pr "    case GUESTFS_PROC_%s:\n" (String.uppercase name);
3557         pr "      %s_stub (xdr_in);\n" name;
3558         pr "      break;\n"
3559   ) daemon_functions;
3560
3561   pr "    default:\n";
3562   pr "      reply_with_error (\"dispatch_incoming_message: unknown procedure number %%d\", proc_nr);\n";
3563   pr "  }\n";
3564   pr "}\n";
3565   pr "\n";
3566
3567   (* LVM columns and tokenization functions. *)
3568   (* XXX This generates crap code.  We should rethink how we
3569    * do this parsing.
3570    *)
3571   List.iter (
3572     function
3573     | typ, cols ->
3574         pr "static const char *lvm_%s_cols = \"%s\";\n"
3575           typ (String.concat "," (List.map fst cols));
3576         pr "\n";
3577
3578         pr "static int lvm_tokenize_%s (char *str, struct guestfs_lvm_int_%s *r)\n" typ typ;
3579         pr "{\n";
3580         pr "  char *tok, *p, *next;\n";
3581         pr "  int i, j;\n";
3582         pr "\n";
3583         (*
3584         pr "  fprintf (stderr, \"%%s: <<%%s>>\\n\", __func__, str);\n";
3585         pr "\n";
3586         *)
3587         pr "  if (!str) {\n";
3588         pr "    fprintf (stderr, \"%%s: failed: passed a NULL string\\n\", __func__);\n";
3589         pr "    return -1;\n";
3590         pr "  }\n";
3591         pr "  if (!*str || isspace (*str)) {\n";
3592         pr "    fprintf (stderr, \"%%s: failed: passed a empty string or one beginning with whitespace\\n\", __func__);\n";
3593         pr "    return -1;\n";
3594         pr "  }\n";
3595         pr "  tok = str;\n";
3596         List.iter (
3597           fun (name, coltype) ->
3598             pr "  if (!tok) {\n";
3599             pr "    fprintf (stderr, \"%%s: failed: string finished early, around token %%s\\n\", __func__, \"%s\");\n" name;
3600             pr "    return -1;\n";
3601             pr "  }\n";
3602             pr "  p = strchrnul (tok, ',');\n";
3603             pr "  if (*p) next = p+1; else next = NULL;\n";
3604             pr "  *p = '\\0';\n";
3605             (match coltype with
3606              | `String ->
3607                  pr "  r->%s = strdup (tok);\n" name;
3608                  pr "  if (r->%s == NULL) {\n" name;
3609                  pr "    perror (\"strdup\");\n";
3610                  pr "    return -1;\n";
3611                  pr "  }\n"
3612              | `UUID ->
3613                  pr "  for (i = j = 0; i < 32; ++j) {\n";
3614                  pr "    if (tok[j] == '\\0') {\n";
3615                  pr "      fprintf (stderr, \"%%s: failed to parse UUID from '%%s'\\n\", __func__, tok);\n";
3616                  pr "      return -1;\n";
3617                  pr "    } else if (tok[j] != '-')\n";
3618                  pr "      r->%s[i++] = tok[j];\n" name;
3619                  pr "  }\n";
3620              | `Bytes ->
3621                  pr "  if (sscanf (tok, \"%%\"SCNu64, &r->%s) != 1) {\n" name;
3622                  pr "    fprintf (stderr, \"%%s: failed to parse size '%%s' from token %%s\\n\", __func__, tok, \"%s\");\n" name;
3623                  pr "    return -1;\n";
3624                  pr "  }\n";
3625              | `Int ->
3626                  pr "  if (sscanf (tok, \"%%\"SCNi64, &r->%s) != 1) {\n" name;
3627                  pr "    fprintf (stderr, \"%%s: failed to parse int '%%s' from token %%s\\n\", __func__, tok, \"%s\");\n" name;
3628                  pr "    return -1;\n";
3629                  pr "  }\n";
3630              | `OptPercent ->
3631                  pr "  if (tok[0] == '\\0')\n";
3632                  pr "    r->%s = -1;\n" name;
3633                  pr "  else if (sscanf (tok, \"%%f\", &r->%s) != 1) {\n" name;
3634                  pr "    fprintf (stderr, \"%%s: failed to parse float '%%s' from token %%s\\n\", __func__, tok, \"%s\");\n" name;
3635                  pr "    return -1;\n";
3636                  pr "  }\n";
3637             );
3638             pr "  tok = next;\n";
3639         ) cols;
3640
3641         pr "  if (tok != NULL) {\n";
3642         pr "    fprintf (stderr, \"%%s: failed: extra tokens at end of string\\n\", __func__);\n";
3643         pr "    return -1;\n";
3644         pr "  }\n";
3645         pr "  return 0;\n";
3646         pr "}\n";
3647         pr "\n";
3648
3649         pr "guestfs_lvm_int_%s_list *\n" typ;
3650         pr "parse_command_line_%ss (void)\n" typ;
3651         pr "{\n";
3652         pr "  char *out, *err;\n";
3653         pr "  char *p, *pend;\n";
3654         pr "  int r, i;\n";
3655         pr "  guestfs_lvm_int_%s_list *ret;\n" typ;
3656         pr "  void *newp;\n";
3657         pr "\n";
3658         pr "  ret = malloc (sizeof *ret);\n";
3659         pr "  if (!ret) {\n";
3660         pr "    reply_with_perror (\"malloc\");\n";
3661         pr "    return NULL;\n";
3662         pr "  }\n";
3663         pr "\n";
3664         pr "  ret->guestfs_lvm_int_%s_list_len = 0;\n" typ;
3665         pr "  ret->guestfs_lvm_int_%s_list_val = NULL;\n" typ;
3666         pr "\n";
3667         pr "  r = command (&out, &err,\n";
3668         pr "           \"/sbin/lvm\", \"%ss\",\n" typ;
3669         pr "           \"-o\", lvm_%s_cols, \"--unbuffered\", \"--noheadings\",\n" typ;
3670         pr "           \"--nosuffix\", \"--separator\", \",\", \"--units\", \"b\", NULL);\n";
3671         pr "  if (r == -1) {\n";
3672         pr "    reply_with_error (\"%%s\", err);\n";
3673         pr "    free (out);\n";
3674         pr "    free (err);\n";
3675         pr "    free (ret);\n";
3676         pr "    return NULL;\n";
3677         pr "  }\n";
3678         pr "\n";
3679         pr "  free (err);\n";
3680         pr "\n";
3681         pr "  /* Tokenize each line of the output. */\n";
3682         pr "  p = out;\n";
3683         pr "  i = 0;\n";
3684         pr "  while (p) {\n";
3685         pr "    pend = strchr (p, '\\n');       /* Get the next line of output. */\n";
3686         pr "    if (pend) {\n";
3687         pr "      *pend = '\\0';\n";
3688         pr "      pend++;\n";
3689         pr "    }\n";
3690         pr "\n";
3691         pr "    while (*p && isspace (*p))      /* Skip any leading whitespace. */\n";
3692         pr "      p++;\n";
3693         pr "\n";
3694         pr "    if (!*p) {                      /* Empty line?  Skip it. */\n";
3695         pr "      p = pend;\n";
3696         pr "      continue;\n";
3697         pr "    }\n";
3698         pr "\n";
3699         pr "    /* Allocate some space to store this next entry. */\n";
3700         pr "    newp = realloc (ret->guestfs_lvm_int_%s_list_val,\n" typ;
3701         pr "                sizeof (guestfs_lvm_int_%s) * (i+1));\n" typ;
3702         pr "    if (newp == NULL) {\n";
3703         pr "      reply_with_perror (\"realloc\");\n";
3704         pr "      free (ret->guestfs_lvm_int_%s_list_val);\n" typ;
3705         pr "      free (ret);\n";
3706         pr "      free (out);\n";
3707         pr "      return NULL;\n";
3708         pr "    }\n";
3709         pr "    ret->guestfs_lvm_int_%s_list_val = newp;\n" typ;
3710         pr "\n";
3711         pr "    /* Tokenize the next entry. */\n";
3712         pr "    r = lvm_tokenize_%s (p, &ret->guestfs_lvm_int_%s_list_val[i]);\n" typ typ;
3713         pr "    if (r == -1) {\n";
3714         pr "      reply_with_error (\"failed to parse output of '%ss' command\");\n" typ;
3715         pr "      free (ret->guestfs_lvm_int_%s_list_val);\n" typ;
3716         pr "      free (ret);\n";
3717         pr "      free (out);\n";
3718         pr "      return NULL;\n";
3719         pr "    }\n";
3720         pr "\n";
3721         pr "    ++i;\n";
3722         pr "    p = pend;\n";
3723         pr "  }\n";
3724         pr "\n";
3725         pr "  ret->guestfs_lvm_int_%s_list_len = i;\n" typ;
3726         pr "\n";
3727         pr "  free (out);\n";
3728         pr "  return ret;\n";
3729         pr "}\n"
3730
3731   ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols]
3732
3733 (* Generate the tests. *)
3734 and generate_tests () =
3735   generate_header CStyle GPLv2;
3736
3737   pr "\
3738 #include <stdio.h>
3739 #include <stdlib.h>
3740 #include <string.h>
3741 #include <unistd.h>
3742 #include <sys/types.h>
3743 #include <fcntl.h>
3744
3745 #include \"guestfs.h\"
3746
3747 static guestfs_h *g;
3748 static int suppress_error = 0;
3749
3750 /* This will be 's' or 'h' depending on whether the guest kernel
3751  * names IDE devices /dev/sd* or /dev/hd*.
3752  */
3753 static char devchar = 's';
3754
3755 static void print_error (guestfs_h *g, void *data, const char *msg)
3756 {
3757   if (!suppress_error)
3758     fprintf (stderr, \"%%s\\n\", msg);
3759 }
3760
3761 static void print_strings (char * const * const argv)
3762 {
3763   int argc;
3764
3765   for (argc = 0; argv[argc] != NULL; ++argc)
3766     printf (\"\\t%%s\\n\", argv[argc]);
3767 }
3768
3769 /*
3770 static void print_table (char * const * const argv)
3771 {
3772   int i;
3773
3774   for (i = 0; argv[i] != NULL; i += 2)
3775     printf (\"%%s: %%s\\n\", argv[i], argv[i+1]);
3776 }
3777 */
3778
3779 static void no_test_warnings (void)
3780 {
3781 ";
3782
3783   List.iter (
3784     function
3785     | name, _, _, _, [], _, _ ->
3786         pr "  fprintf (stderr, \"warning: \\\"guestfs_%s\\\" has no tests\\n\");\n" name
3787     | name, _, _, _, tests, _, _ -> ()
3788   ) all_functions;
3789
3790   pr "}\n";
3791   pr "\n";
3792
3793   (* Generate the actual tests.  Note that we generate the tests
3794    * in reverse order, deliberately, so that (in general) the
3795    * newest tests run first.  This makes it quicker and easier to
3796    * debug them.
3797    *)
3798   let test_names =
3799     List.map (
3800       fun (name, _, _, _, tests, _, _) ->
3801         mapi (generate_one_test name) tests
3802     ) (List.rev all_functions) in
3803   let test_names = List.concat test_names in
3804   let nr_tests = List.length test_names in
3805
3806   pr "\
3807 int main (int argc, char *argv[])
3808 {
3809   char c = 0;
3810   int failed = 0;
3811   const char *srcdir;
3812   const char *filename;
3813   int fd, i;
3814   int nr_tests, test_num = 0;
3815   char **devs;
3816
3817   no_test_warnings ();
3818
3819   g = guestfs_create ();
3820   if (g == NULL) {
3821     printf (\"guestfs_create FAILED\\n\");
3822     exit (1);
3823   }
3824
3825   guestfs_set_error_handler (g, print_error, NULL);
3826
3827   guestfs_set_path (g, \"../appliance\");
3828
3829   filename = \"test1.img\";
3830   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
3831   if (fd == -1) {
3832     perror (filename);
3833     exit (1);
3834   }
3835   if (lseek (fd, %d, SEEK_SET) == -1) {
3836     perror (\"lseek\");
3837     close (fd);
3838     unlink (filename);
3839     exit (1);
3840   }
3841   if (write (fd, &c, 1) == -1) {
3842     perror (\"write\");
3843     close (fd);
3844     unlink (filename);
3845     exit (1);
3846   }
3847   if (close (fd) == -1) {
3848     perror (filename);
3849     unlink (filename);
3850     exit (1);
3851   }
3852   if (guestfs_add_drive (g, filename) == -1) {
3853     printf (\"guestfs_add_drive %%s FAILED\\n\", filename);
3854     exit (1);
3855   }
3856
3857   filename = \"test2.img\";
3858   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
3859   if (fd == -1) {
3860     perror (filename);
3861     exit (1);
3862   }
3863   if (lseek (fd, %d, SEEK_SET) == -1) {
3864     perror (\"lseek\");
3865     close (fd);
3866     unlink (filename);
3867     exit (1);
3868   }
3869   if (write (fd, &c, 1) == -1) {
3870     perror (\"write\");
3871     close (fd);
3872     unlink (filename);
3873     exit (1);
3874   }
3875   if (close (fd) == -1) {
3876     perror (filename);
3877     unlink (filename);
3878     exit (1);
3879   }
3880   if (guestfs_add_drive (g, filename) == -1) {
3881     printf (\"guestfs_add_drive %%s FAILED\\n\", filename);
3882     exit (1);
3883   }
3884
3885   filename = \"test3.img\";
3886   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
3887   if (fd == -1) {
3888     perror (filename);
3889     exit (1);
3890   }
3891   if (lseek (fd, %d, SEEK_SET) == -1) {
3892     perror (\"lseek\");
3893     close (fd);
3894     unlink (filename);
3895     exit (1);
3896   }
3897   if (write (fd, &c, 1) == -1) {
3898     perror (\"write\");
3899     close (fd);
3900     unlink (filename);
3901     exit (1);
3902   }
3903   if (close (fd) == -1) {
3904     perror (filename);
3905     unlink (filename);
3906     exit (1);
3907   }
3908   if (guestfs_add_drive (g, filename) == -1) {
3909     printf (\"guestfs_add_drive %%s FAILED\\n\", filename);
3910     exit (1);
3911   }
3912
3913   if (guestfs_add_drive (g, \"../images/test.sqsh\") == -1) {
3914     printf (\"guestfs_add_drive %%s FAILED\\n\", filename);
3915     exit (1);
3916   }
3917
3918   if (guestfs_launch (g) == -1) {
3919     printf (\"guestfs_launch FAILED\\n\");
3920     exit (1);
3921   }
3922   if (guestfs_wait_ready (g) == -1) {
3923     printf (\"guestfs_wait_ready FAILED\\n\");
3924     exit (1);
3925   }
3926
3927   /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
3928    * names.  This changed between RHEL 5 and RHEL 6 so we have to
3929    * support both.
3930    */
3931   devs = guestfs_list_devices (g);
3932   if (devs == NULL || devs[0] == NULL) {
3933     printf (\"guestfs_list_devices FAILED\\n\");
3934     exit (1);
3935   }
3936   if (strncmp (devs[0], \"/dev/sd\", 7) == 0)
3937     devchar = 's';
3938   else if (strncmp (devs[0], \"/dev/hd\", 7) == 0)
3939     devchar = 'h';
3940   else {
3941     printf (\"guestfs_list_devices returned unexpected string '%%s'\\n\",
3942             devs[0]);
3943     exit (1);
3944   }
3945   for (i = 0; devs[i] != NULL; ++i)
3946     free (devs[i]);
3947   free (devs);
3948
3949   nr_tests = %d;
3950
3951 " (500 * 1024 * 1024) (50 * 1024 * 1024) (10 * 1024 * 1024) nr_tests;
3952
3953   iteri (
3954     fun i test_name ->
3955       pr "  test_num++;\n";
3956       pr "  printf (\"%%3d/%%3d %s\\n\", test_num, nr_tests);\n" test_name;
3957       pr "  if (%s () == -1) {\n" test_name;
3958       pr "    printf (\"%s FAILED\\n\");\n" test_name;
3959       pr "    failed++;\n";
3960       pr "  }\n";
3961   ) test_names;
3962   pr "\n";
3963
3964   pr "  guestfs_close (g);\n";
3965   pr "  unlink (\"test1.img\");\n";
3966   pr "  unlink (\"test2.img\");\n";
3967   pr "  unlink (\"test3.img\");\n";
3968   pr "\n";
3969
3970   pr "  if (failed > 0) {\n";
3971   pr "    printf (\"***** %%d / %%d tests FAILED *****\\n\", failed, nr_tests);\n";
3972   pr "    exit (1);\n";
3973   pr "  }\n";
3974   pr "\n";
3975
3976   pr "  exit (0);\n";
3977   pr "}\n"
3978
3979 and generate_one_test name i (init, prereq, test) =
3980   let test_name = sprintf "test_%s_%d" name i in
3981
3982   pr "\
3983 static int %s_skip (void)
3984 {
3985   const char *str;
3986
3987   str = getenv (\"SKIP_%s\");
3988   if (str && strcmp (str, \"1\") == 0) return 1;
3989   str = getenv (\"SKIP_TEST_%s\");
3990   if (str && strcmp (str, \"1\") == 0) return 1;
3991   return 0;
3992 }
3993
3994 " test_name (String.uppercase test_name) (String.uppercase name);
3995
3996   (match prereq with
3997    | Disabled | Always -> ()
3998    | If code | Unless code ->
3999        pr "static int %s_prereq (void)\n" test_name;
4000        pr "{\n";
4001        pr "  %s\n" code;
4002        pr "}\n";
4003        pr "\n";
4004   );
4005
4006   pr "\
4007 static int %s (void)
4008 {
4009   if (%s_skip ()) {
4010     printf (\"%%s skipped (reason: SKIP_TEST_* variable set)\\n\", \"%s\");
4011     return 0;
4012   }
4013
4014 " test_name test_name test_name;
4015
4016   (match prereq with
4017    | Disabled ->
4018        pr "  printf (\"%%s skipped (reason: test disabled in generator)\\n\", \"%s\");\n" test_name
4019    | If _ ->
4020        pr "  if (! %s_prereq ()) {\n" test_name;
4021        pr "    printf (\"%%s skipped (reason: test prerequisite)\\n\", \"%s\");\n" test_name;
4022        pr "    return 0;\n";
4023        pr "  }\n";
4024        pr "\n";
4025        generate_one_test_body name i test_name init test;
4026    | Unless _ ->
4027        pr "  if (%s_prereq ()) {\n" test_name;
4028        pr "    printf (\"%%s skipped (reason: test prerequisite)\\n\", \"%s\");\n" test_name;
4029        pr "    return 0;\n";
4030        pr "  }\n";
4031        pr "\n";
4032        generate_one_test_body name i test_name init test;
4033    | Always ->
4034        generate_one_test_body name i test_name init test
4035   );
4036
4037   pr "  return 0;\n";
4038   pr "}\n";
4039   pr "\n";
4040   test_name
4041
4042 and generate_one_test_body name i test_name init test =
4043   (match init with
4044    | InitNone
4045    | InitEmpty ->
4046        pr "  /* InitNone|InitEmpty for %s */\n" test_name;
4047        List.iter (generate_test_command_call test_name)
4048          [["blockdev_setrw"; "/dev/sda"];
4049           ["umount_all"];
4050           ["lvm_remove_all"]]
4051    | InitBasicFS ->
4052        pr "  /* InitBasicFS for %s: create ext2 on /dev/sda1 */\n" test_name;
4053        List.iter (generate_test_command_call test_name)
4054          [["blockdev_setrw"; "/dev/sda"];
4055           ["umount_all"];
4056           ["lvm_remove_all"];
4057           ["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
4058           ["mkfs"; "ext2"; "/dev/sda1"];
4059           ["mount"; "/dev/sda1"; "/"]]
4060    | InitBasicFSonLVM ->
4061        pr "  /* InitBasicFSonLVM for %s: create ext2 on /dev/VG/LV */\n"
4062          test_name;
4063        List.iter (generate_test_command_call test_name)
4064          [["blockdev_setrw"; "/dev/sda"];
4065           ["umount_all"];
4066           ["lvm_remove_all"];
4067           ["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
4068           ["pvcreate"; "/dev/sda1"];
4069           ["vgcreate"; "VG"; "/dev/sda1"];
4070           ["lvcreate"; "LV"; "VG"; "8"];
4071           ["mkfs"; "ext2"; "/dev/VG/LV"];
4072           ["mount"; "/dev/VG/LV"; "/"]]
4073   );
4074
4075   let get_seq_last = function
4076     | [] ->
4077         failwithf "%s: you cannot use [] (empty list) when expecting a command"
4078           test_name
4079     | seq ->
4080         let seq = List.rev seq in
4081         List.rev (List.tl seq), List.hd seq
4082   in
4083
4084   match test with
4085   | TestRun seq ->
4086       pr "  /* TestRun for %s (%d) */\n" name i;
4087       List.iter (generate_test_command_call test_name) seq
4088   | TestOutput (seq, expected) ->
4089       pr "  /* TestOutput for %s (%d) */\n" name i;
4090       pr "  char expected[] = \"%s\";\n" (c_quote expected);
4091       if String.length expected > 7 &&
4092         String.sub expected 0 7 = "/dev/sd" then
4093           pr "  expected[5] = devchar;\n";
4094       let seq, last = get_seq_last seq in
4095       let test () =
4096         pr "    if (strcmp (r, expected) != 0) {\n";
4097         pr "      fprintf (stderr, \"%s: expected \\\"%%s\\\" but got \\\"%%s\\\"\\n\", expected, r);\n" test_name;
4098         pr "      return -1;\n";
4099         pr "    }\n"
4100       in
4101       List.iter (generate_test_command_call test_name) seq;
4102       generate_test_command_call ~test test_name last
4103   | TestOutputList (seq, expected) ->
4104       pr "  /* TestOutputList for %s (%d) */\n" name i;
4105       let seq, last = get_seq_last seq in
4106       let test () =
4107         iteri (
4108           fun i str ->
4109             pr "    if (!r[%d]) {\n" i;
4110             pr "      fprintf (stderr, \"%s: short list returned from command\\n\");\n" test_name;
4111             pr "      print_strings (r);\n";
4112             pr "      return -1;\n";
4113             pr "    }\n";
4114             pr "    {\n";
4115             pr "      char expected[] = \"%s\";\n" (c_quote str);
4116             if String.length str > 7 && String.sub str 0 7 = "/dev/sd" then
4117               pr "      expected[5] = devchar;\n";
4118             pr "      if (strcmp (r[%d], expected) != 0) {\n" i;
4119             pr "        fprintf (stderr, \"%s: expected \\\"%%s\\\" but got \\\"%%s\\\"\\n\", expected, r[%d]);\n" test_name i;
4120             pr "        return -1;\n";
4121             pr "      }\n";
4122             pr "    }\n"
4123         ) expected;
4124         pr "    if (r[%d] != NULL) {\n" (List.length expected);
4125         pr "      fprintf (stderr, \"%s: extra elements returned from command\\n\");\n"
4126           test_name;
4127         pr "      print_strings (r);\n";
4128         pr "      return -1;\n";
4129         pr "    }\n"
4130       in
4131       List.iter (generate_test_command_call test_name) seq;
4132       generate_test_command_call ~test test_name last
4133   | TestOutputInt (seq, expected) ->
4134       pr "  /* TestOutputInt for %s (%d) */\n" name i;
4135       let seq, last = get_seq_last seq in
4136       let test () =
4137         pr "    if (r != %d) {\n" expected;
4138         pr "      fprintf (stderr, \"%s: expected %d but got %%d\\n\","
4139           test_name expected;
4140         pr "               (int) r);\n";
4141         pr "      return -1;\n";
4142         pr "    }\n"
4143       in
4144       List.iter (generate_test_command_call test_name) seq;
4145       generate_test_command_call ~test test_name last
4146   | TestOutputTrue seq ->
4147       pr "  /* TestOutputTrue for %s (%d) */\n" name i;
4148       let seq, last = get_seq_last seq in
4149       let test () =
4150         pr "    if (!r) {\n";
4151         pr "      fprintf (stderr, \"%s: expected true, got false\\n\");\n"
4152           test_name;
4153         pr "      return -1;\n";
4154         pr "    }\n"
4155       in
4156       List.iter (generate_test_command_call test_name) seq;
4157       generate_test_command_call ~test test_name last
4158   | TestOutputFalse seq ->
4159       pr "  /* TestOutputFalse for %s (%d) */\n" name i;
4160       let seq, last = get_seq_last seq in
4161       let test () =
4162         pr "    if (r) {\n";
4163         pr "      fprintf (stderr, \"%s: expected false, got true\\n\");\n"
4164           test_name;
4165         pr "      return -1;\n";
4166         pr "    }\n"
4167       in
4168       List.iter (generate_test_command_call test_name) seq;
4169       generate_test_command_call ~test test_name last
4170   | TestOutputLength (seq, expected) ->
4171       pr "  /* TestOutputLength for %s (%d) */\n" name i;
4172       let seq, last = get_seq_last seq in
4173       let test () =
4174         pr "    int j;\n";
4175         pr "    for (j = 0; j < %d; ++j)\n" expected;
4176         pr "      if (r[j] == NULL) {\n";
4177         pr "        fprintf (stderr, \"%s: short list returned\\n\");\n"
4178           test_name;
4179         pr "        print_strings (r);\n";
4180         pr "        return -1;\n";
4181         pr "      }\n";
4182         pr "    if (r[j] != NULL) {\n";
4183         pr "      fprintf (stderr, \"%s: long list returned\\n\");\n"
4184           test_name;
4185         pr "      print_strings (r);\n";
4186         pr "      return -1;\n";
4187         pr "    }\n"
4188       in
4189       List.iter (generate_test_command_call test_name) seq;
4190       generate_test_command_call ~test test_name last
4191   | TestOutputStruct (seq, checks) ->
4192       pr "  /* TestOutputStruct for %s (%d) */\n" name i;
4193       let seq, last = get_seq_last seq in
4194       let test () =
4195         List.iter (
4196           function
4197           | CompareWithInt (field, expected) ->
4198               pr "    if (r->%s != %d) {\n" field expected;
4199               pr "      fprintf (stderr, \"%s: %s was %%d, expected %d\\n\",\n"
4200                 test_name field expected;
4201               pr "               (int) r->%s);\n" field;
4202               pr "      return -1;\n";
4203               pr "    }\n"
4204           | CompareWithString (field, expected) ->
4205               pr "    if (strcmp (r->%s, \"%s\") != 0) {\n" field expected;
4206               pr "      fprintf (stderr, \"%s: %s was \"%%s\", expected \"%s\"\\n\",\n"
4207                 test_name field expected;
4208               pr "               r->%s);\n" field;
4209               pr "      return -1;\n";
4210               pr "    }\n"
4211           | CompareFieldsIntEq (field1, field2) ->
4212               pr "    if (r->%s != r->%s) {\n" field1 field2;
4213               pr "      fprintf (stderr, \"%s: %s (%%d) <> %s (%%d)\\n\",\n"
4214                 test_name field1 field2;
4215               pr "               (int) r->%s, (int) r->%s);\n" field1 field2;
4216               pr "      return -1;\n";
4217               pr "    }\n"
4218           | CompareFieldsStrEq (field1, field2) ->
4219               pr "    if (strcmp (r->%s, r->%s) != 0) {\n" field1 field2;
4220               pr "      fprintf (stderr, \"%s: %s (\"%%s\") <> %s (\"%%s\")\\n\",\n"
4221                 test_name field1 field2;
4222               pr "               r->%s, r->%s);\n" field1 field2;
4223               pr "      return -1;\n";
4224               pr "    }\n"
4225         ) checks
4226       in
4227       List.iter (generate_test_command_call test_name) seq;
4228       generate_test_command_call ~test test_name last
4229   | TestLastFail seq ->
4230       pr "  /* TestLastFail for %s (%d) */\n" name i;
4231       let seq, last = get_seq_last seq in
4232       List.iter (generate_test_command_call test_name) seq;
4233       generate_test_command_call test_name ~expect_error:true last
4234
4235 (* Generate the code to run a command, leaving the result in 'r'.
4236  * If you expect to get an error then you should set expect_error:true.
4237  *)
4238 and generate_test_command_call ?(expect_error = false) ?test test_name cmd =
4239   match cmd with
4240   | [] -> assert false
4241   | name :: args ->
4242       (* Look up the command to find out what args/ret it has. *)
4243       let style =
4244         try
4245           let _, style, _, _, _, _, _ =
4246             List.find (fun (n, _, _, _, _, _, _) -> n = name) all_functions in
4247           style
4248         with Not_found ->
4249           failwithf "%s: in test, command %s was not found" test_name name in
4250
4251       if List.length (snd style) <> List.length args then
4252         failwithf "%s: in test, wrong number of args given to %s"
4253           test_name name;
4254
4255       pr "  {\n";
4256
4257       List.iter (
4258         function
4259         | OptString n, "NULL" -> ()
4260         | String n, arg
4261         | OptString n, arg ->
4262             pr "    char %s[] = \"%s\";\n" n (c_quote arg);
4263             if String.length arg > 7 && String.sub arg 0 7 = "/dev/sd" then
4264               pr "    %s[5] = devchar;\n" n
4265         | Int _, _
4266         | Bool _, _
4267         | FileIn _, _ | FileOut _, _ -> ()
4268         | StringList n, arg ->
4269             let strs = string_split " " arg in
4270             iteri (
4271               fun i str ->
4272                 pr "    char %s_%d[] = \"%s\";\n" n i (c_quote str);
4273                 if String.length str > 7 && String.sub str 0 7 = "/dev/sd" then
4274                   pr "    %s_%d[5] = devchar;\n" n i
4275             ) strs;
4276             pr "    char *%s[] = {\n" n;
4277             iteri (
4278               fun i _ -> pr "      %s_%d,\n" n i
4279             ) strs;
4280             pr "      NULL\n";
4281             pr "    };\n";
4282       ) (List.combine (snd style) args);
4283
4284       let error_code =
4285         match fst style with
4286         | RErr | RInt _ | RBool _ -> pr "    int r;\n"; "-1"
4287         | RInt64 _ -> pr "    int64_t r;\n"; "-1"
4288         | RConstString _ -> pr "    const char *r;\n"; "NULL"
4289         | RString _ -> pr "    char *r;\n"; "NULL"
4290         | RStringList _ | RHashtable _ ->
4291             pr "    char **r;\n";
4292             pr "    int i;\n";
4293             "NULL"
4294         | RIntBool _ ->
4295             pr "    struct guestfs_int_bool *r;\n"; "NULL"
4296         | RPVList _ ->
4297             pr "    struct guestfs_lvm_pv_list *r;\n"; "NULL"
4298         | RVGList _ ->
4299             pr "    struct guestfs_lvm_vg_list *r;\n"; "NULL"
4300         | RLVList _ ->
4301             pr "    struct guestfs_lvm_lv_list *r;\n"; "NULL"
4302         | RStat _ ->
4303             pr "    struct guestfs_stat *r;\n"; "NULL"
4304         | RStatVFS _ ->
4305             pr "    struct guestfs_statvfs *r;\n"; "NULL" in
4306
4307       pr "    suppress_error = %d;\n" (if expect_error then 1 else 0);
4308       pr "    r = guestfs_%s (g" name;
4309
4310       (* Generate the parameters. *)
4311       List.iter (
4312         function
4313         | OptString _, "NULL" -> pr ", NULL"
4314         | String n, _
4315         | OptString n, _ ->
4316             pr ", %s" n
4317         | FileIn _, arg | FileOut _, arg ->
4318             pr ", \"%s\"" (c_quote arg)
4319         | StringList n, _ ->
4320             pr ", %s" n
4321         | Int _, arg ->
4322             let i =
4323               try int_of_string arg
4324               with Failure "int_of_string" ->
4325                 failwithf "%s: expecting an int, but got '%s'" test_name arg in
4326             pr ", %d" i
4327         | Bool _, arg ->
4328             let b = bool_of_string arg in pr ", %d" (if b then 1 else 0)
4329       ) (List.combine (snd style) args);
4330
4331       pr ");\n";
4332       if not expect_error then
4333         pr "    if (r == %s)\n" error_code
4334       else
4335         pr "    if (r != %s)\n" error_code;
4336       pr "      return -1;\n";
4337
4338       (* Insert the test code. *)
4339       (match test with
4340        | None -> ()
4341        | Some f -> f ()
4342       );
4343
4344       (match fst style with
4345        | RErr | RInt _ | RInt64 _ | RBool _ | RConstString _ -> ()
4346        | RString _ -> pr "    free (r);\n"
4347        | RStringList _ | RHashtable _ ->
4348            pr "    for (i = 0; r[i] != NULL; ++i)\n";
4349            pr "      free (r[i]);\n";
4350            pr "    free (r);\n"
4351        | RIntBool _ ->
4352            pr "    guestfs_free_int_bool (r);\n"
4353        | RPVList _ ->
4354            pr "    guestfs_free_lvm_pv_list (r);\n"
4355        | RVGList _ ->
4356            pr "    guestfs_free_lvm_vg_list (r);\n"
4357        | RLVList _ ->
4358            pr "    guestfs_free_lvm_lv_list (r);\n"
4359        | RStat _ | RStatVFS _ ->
4360            pr "    free (r);\n"
4361       );
4362
4363       pr "  }\n"
4364
4365 and c_quote str =
4366   let str = replace_str str "\r" "\\r" in
4367   let str = replace_str str "\n" "\\n" in
4368   let str = replace_str str "\t" "\\t" in
4369   let str = replace_str str "\000" "\\0" in
4370   str
4371
4372 (* Generate a lot of different functions for guestfish. *)
4373 and generate_fish_cmds () =
4374   generate_header CStyle GPLv2;
4375
4376   let all_functions =
4377     List.filter (
4378       fun (_, _, _, flags, _, _, _) -> not (List.mem NotInFish flags)
4379     ) all_functions in
4380   let all_functions_sorted =
4381     List.filter (
4382       fun (_, _, _, flags, _, _, _) -> not (List.mem NotInFish flags)
4383     ) all_functions_sorted in
4384
4385   pr "#include <stdio.h>\n";
4386   pr "#include <stdlib.h>\n";
4387   pr "#include <string.h>\n";
4388   pr "#include <inttypes.h>\n";
4389   pr "\n";
4390   pr "#include <guestfs.h>\n";
4391   pr "#include \"fish.h\"\n";
4392   pr "\n";
4393
4394   (* list_commands function, which implements guestfish -h *)
4395   pr "void list_commands (void)\n";
4396   pr "{\n";
4397   pr "  printf (\"    %%-16s     %%s\\n\", \"Command\", \"Description\");\n";
4398   pr "  list_builtin_commands ();\n";
4399   List.iter (
4400     fun (name, _, _, flags, _, shortdesc, _) ->
4401       let name = replace_char name '_' '-' in
4402       pr "  printf (\"%%-20s %%s\\n\", \"%s\", \"%s\");\n"
4403         name shortdesc
4404   ) all_functions_sorted;
4405   pr "  printf (\"    Use -h <cmd> / help <cmd> to show detailed help for a command.\\n\");\n";
4406   pr "}\n";
4407   pr "\n";
4408
4409   (* display_command function, which implements guestfish -h cmd *)
4410   pr "void display_command (const char *cmd)\n";
4411   pr "{\n";
4412   List.iter (
4413     fun (name, style, _, flags, _, shortdesc, longdesc) ->
4414       let name2 = replace_char name '_' '-' in
4415       let alias =
4416         try find_map (function FishAlias n -> Some n | _ -> None) flags
4417         with Not_found -> name in
4418       let longdesc = replace_str longdesc "C<guestfs_" "C<" in
4419       let synopsis =
4420         match snd style with
4421         | [] -> name2
4422         | args ->
4423             sprintf "%s <%s>"
4424               name2 (String.concat "> <" (List.map name_of_argt args)) in
4425
4426       let warnings =
4427         if List.mem ProtocolLimitWarning flags then
4428           ("\n\n" ^ protocol_limit_warning)
4429         else "" in
4430
4431       (* For DangerWillRobinson commands, we should probably have
4432        * guestfish prompt before allowing you to use them (especially
4433        * in interactive mode). XXX
4434        *)
4435       let warnings =
4436         warnings ^
4437           if List.mem DangerWillRobinson flags then
4438             ("\n\n" ^ danger_will_robinson)
4439           else "" in
4440
4441       let describe_alias =
4442         if name <> alias then
4443           sprintf "\n\nYou can use '%s' as an alias for this command." alias
4444         else "" in
4445
4446       pr "  if (";
4447       pr "strcasecmp (cmd, \"%s\") == 0" name;
4448       if name <> name2 then
4449         pr " || strcasecmp (cmd, \"%s\") == 0" name2;
4450       if name <> alias then
4451         pr " || strcasecmp (cmd, \"%s\") == 0" alias;
4452       pr ")\n";
4453       pr "    pod2text (\"%s - %s\", %S);\n"
4454         name2 shortdesc
4455         (" " ^ synopsis ^ "\n\n" ^ longdesc ^ warnings ^ describe_alias);
4456       pr "  else\n"
4457   ) all_functions;
4458   pr "    display_builtin_command (cmd);\n";
4459   pr "}\n";
4460   pr "\n";
4461
4462   (* print_{pv,vg,lv}_list functions *)
4463   List.iter (
4464     function
4465     | typ, cols ->
4466         pr "static void print_%s (struct guestfs_lvm_%s *%s)\n" typ typ typ;
4467         pr "{\n";
4468         pr "  int i;\n";
4469         pr "\n";
4470         List.iter (
4471           function
4472           | name, `String ->
4473               pr "  printf (\"%s: %%s\\n\", %s->%s);\n" name typ name
4474           | name, `UUID ->
4475               pr "  printf (\"%s: \");\n" name;
4476               pr "  for (i = 0; i < 32; ++i)\n";
4477               pr "    printf (\"%%c\", %s->%s[i]);\n" typ name;
4478               pr "  printf (\"\\n\");\n"
4479           | name, `Bytes ->
4480               pr "  printf (\"%s: %%\" PRIu64 \"\\n\", %s->%s);\n" name typ name
4481           | name, `Int ->
4482               pr "  printf (\"%s: %%\" PRIi64 \"\\n\", %s->%s);\n" name typ name
4483           | name, `OptPercent ->
4484               pr "  if (%s->%s >= 0) printf (\"%s: %%g %%%%\\n\", %s->%s);\n"
4485                 typ name name typ name;
4486               pr "  else printf (\"%s: \\n\");\n" name
4487         ) cols;
4488         pr "}\n";
4489         pr "\n";
4490         pr "static void print_%s_list (struct guestfs_lvm_%s_list *%ss)\n"
4491           typ typ typ;
4492         pr "{\n";
4493         pr "  int i;\n";
4494         pr "\n";
4495         pr "  for (i = 0; i < %ss->len; ++i)\n" typ;
4496         pr "    print_%s (&%ss->val[i]);\n" typ typ;
4497         pr "}\n";
4498         pr "\n";
4499   ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
4500
4501   (* print_{stat,statvfs} functions *)
4502   List.iter (
4503     function
4504     | typ, cols ->
4505         pr "static void print_%s (struct guestfs_%s *%s)\n" typ typ typ;
4506         pr "{\n";
4507         List.iter (
4508           function
4509           | name, `Int ->
4510               pr "  printf (\"%s: %%\" PRIi64 \"\\n\", %s->%s);\n" name typ name
4511         ) cols;
4512         pr "}\n";
4513         pr "\n";
4514   ) ["stat", stat_cols; "statvfs", statvfs_cols];
4515
4516   (* run_<action> actions *)
4517   List.iter (
4518     fun (name, style, _, flags, _, _, _) ->
4519       pr "static int run_%s (const char *cmd, int argc, char *argv[])\n" name;
4520       pr "{\n";
4521       (match fst style with
4522        | RErr
4523        | RInt _
4524        | RBool _ -> pr "  int r;\n"
4525        | RInt64 _ -> pr "  int64_t r;\n"
4526        | RConstString _ -> pr "  const char *r;\n"
4527        | RString _ -> pr "  char *r;\n"
4528        | RStringList _ | RHashtable _ -> pr "  char **r;\n"
4529        | RIntBool _ -> pr "  struct guestfs_int_bool *r;\n"
4530        | RPVList _ -> pr "  struct guestfs_lvm_pv_list *r;\n"
4531        | RVGList _ -> pr "  struct guestfs_lvm_vg_list *r;\n"
4532        | RLVList _ -> pr "  struct guestfs_lvm_lv_list *r;\n"
4533        | RStat _ -> pr "  struct guestfs_stat *r;\n"
4534        | RStatVFS _ -> pr "  struct guestfs_statvfs *r;\n"
4535       );
4536       List.iter (
4537         function
4538         | String n
4539         | OptString n
4540         | FileIn n
4541         | FileOut n -> pr "  const char *%s;\n" n
4542         | StringList n -> pr "  char **%s;\n" n
4543         | Bool n -> pr "  int %s;\n" n
4544         | Int n -> pr "  int %s;\n" n
4545       ) (snd style);
4546
4547       (* Check and convert parameters. *)
4548       let argc_expected = List.length (snd style) in
4549       pr "  if (argc != %d) {\n" argc_expected;
4550       pr "    fprintf (stderr, \"%%s should have %d parameter(s)\\n\", cmd);\n"
4551         argc_expected;
4552       pr "    fprintf (stderr, \"type 'help %%s' for help on %%s\\n\", cmd, cmd);\n";
4553       pr "    return -1;\n";
4554       pr "  }\n";
4555       iteri (
4556         fun i ->
4557           function
4558           | String name -> pr "  %s = argv[%d];\n" name i
4559           | OptString name ->
4560               pr "  %s = strcmp (argv[%d], \"\") != 0 ? argv[%d] : NULL;\n"
4561                 name i i
4562           | FileIn name ->
4563               pr "  %s = strcmp (argv[%d], \"-\") != 0 ? argv[%d] : \"/dev/stdin\";\n"
4564                 name i i
4565           | FileOut name ->
4566               pr "  %s = strcmp (argv[%d], \"-\") != 0 ? argv[%d] : \"/dev/stdout\";\n"
4567                 name i i
4568           | StringList name ->
4569               pr "  %s = parse_string_list (argv[%d]);\n" name i
4570           | Bool name ->
4571               pr "  %s = is_true (argv[%d]) ? 1 : 0;\n" name i
4572           | Int name ->
4573               pr "  %s = atoi (argv[%d]);\n" name i
4574       ) (snd style);
4575
4576       (* Call C API function. *)
4577       let fn =
4578         try find_map (function FishAction n -> Some n | _ -> None) flags
4579         with Not_found -> sprintf "guestfs_%s" name in
4580       pr "  r = %s " fn;
4581       generate_call_args ~handle:"g" (snd style);
4582       pr ";\n";
4583
4584       (* Check return value for errors and display command results. *)
4585       (match fst style with
4586        | RErr -> pr "  return r;\n"
4587        | RInt _ ->
4588            pr "  if (r == -1) return -1;\n";
4589            pr "  printf (\"%%d\\n\", r);\n";
4590            pr "  return 0;\n"
4591        | RInt64 _ ->
4592            pr "  if (r == -1) return -1;\n";
4593            pr "  printf (\"%%\" PRIi64 \"\\n\", r);\n";
4594            pr "  return 0;\n"
4595        | RBool _ ->
4596            pr "  if (r == -1) return -1;\n";
4597            pr "  if (r) printf (\"true\\n\"); else printf (\"false\\n\");\n";
4598            pr "  return 0;\n"
4599        | RConstString _ ->
4600            pr "  if (r == NULL) return -1;\n";
4601            pr "  printf (\"%%s\\n\", r);\n";
4602            pr "  return 0;\n"
4603        | RString _ ->
4604            pr "  if (r == NULL) return -1;\n";
4605            pr "  printf (\"%%s\\n\", r);\n";
4606            pr "  free (r);\n";
4607            pr "  return 0;\n"
4608        | RStringList _ ->
4609            pr "  if (r == NULL) return -1;\n";
4610            pr "  print_strings (r);\n";
4611            pr "  free_strings (r);\n";
4612            pr "  return 0;\n"
4613        | RIntBool _ ->
4614            pr "  if (r == NULL) return -1;\n";
4615            pr "  printf (\"%%d, %%s\\n\", r->i,\n";
4616            pr "    r->b ? \"true\" : \"false\");\n";
4617            pr "  guestfs_free_int_bool (r);\n";
4618            pr "  return 0;\n"
4619        | RPVList _ ->
4620            pr "  if (r == NULL) return -1;\n";
4621            pr "  print_pv_list (r);\n";
4622            pr "  guestfs_free_lvm_pv_list (r);\n";
4623            pr "  return 0;\n"
4624        | RVGList _ ->
4625            pr "  if (r == NULL) return -1;\n";
4626            pr "  print_vg_list (r);\n";
4627            pr "  guestfs_free_lvm_vg_list (r);\n";
4628            pr "  return 0;\n"
4629        | RLVList _ ->
4630            pr "  if (r == NULL) return -1;\n";
4631            pr "  print_lv_list (r);\n";
4632            pr "  guestfs_free_lvm_lv_list (r);\n";
4633            pr "  return 0;\n"
4634        | RStat _ ->
4635            pr "  if (r == NULL) return -1;\n";
4636            pr "  print_stat (r);\n";
4637            pr "  free (r);\n";
4638            pr "  return 0;\n"
4639        | RStatVFS _ ->
4640            pr "  if (r == NULL) return -1;\n";
4641            pr "  print_statvfs (r);\n";
4642            pr "  free (r);\n";
4643            pr "  return 0;\n"
4644        | RHashtable _ ->
4645            pr "  if (r == NULL) return -1;\n";
4646            pr "  print_table (r);\n";
4647            pr "  free_strings (r);\n";
4648            pr "  return 0;\n"
4649       );
4650       pr "}\n";
4651       pr "\n"
4652   ) all_functions;
4653
4654   (* run_action function *)
4655   pr "int run_action (const char *cmd, int argc, char *argv[])\n";
4656   pr "{\n";
4657   List.iter (
4658     fun (name, _, _, flags, _, _, _) ->
4659       let name2 = replace_char name '_' '-' in
4660       let alias =
4661         try find_map (function FishAlias n -> Some n | _ -> None) flags
4662         with Not_found -> name in
4663       pr "  if (";
4664       pr "strcasecmp (cmd, \"%s\") == 0" name;
4665       if name <> name2 then
4666         pr " || strcasecmp (cmd, \"%s\") == 0" name2;
4667       if name <> alias then
4668         pr " || strcasecmp (cmd, \"%s\") == 0" alias;
4669       pr ")\n";
4670       pr "    return run_%s (cmd, argc, argv);\n" name;
4671       pr "  else\n";
4672   ) all_functions;
4673   pr "    {\n";
4674   pr "      fprintf (stderr, \"%%s: unknown command\\n\", cmd);\n";
4675   pr "      return -1;\n";
4676   pr "    }\n";
4677   pr "  return 0;\n";
4678   pr "}\n";
4679   pr "\n"
4680
4681 (* Readline completion for guestfish. *)
4682 and generate_fish_completion () =
4683   generate_header CStyle GPLv2;
4684
4685   let all_functions =
4686     List.filter (
4687       fun (_, _, _, flags, _, _, _) -> not (List.mem NotInFish flags)
4688     ) all_functions in
4689
4690   pr "\
4691 #include <config.h>
4692
4693 #include <stdio.h>
4694 #include <stdlib.h>
4695 #include <string.h>
4696
4697 #ifdef HAVE_LIBREADLINE
4698 #include <readline/readline.h>
4699 #endif
4700
4701 #include \"fish.h\"
4702
4703 #ifdef HAVE_LIBREADLINE
4704
4705 static const char *const commands[] = {
4706   BUILTIN_COMMANDS_FOR_COMPLETION,
4707 ";
4708
4709   (* Get the commands, including the aliases.  They don't need to be
4710    * sorted - the generator() function just does a dumb linear search.
4711    *)
4712   let commands =
4713     List.map (
4714       fun (name, _, _, flags, _, _, _) ->
4715         let name2 = replace_char name '_' '-' in
4716         let alias =
4717           try find_map (function FishAlias n -> Some n | _ -> None) flags
4718           with Not_found -> name in
4719
4720         if name <> alias then [name2; alias] else [name2]
4721     ) all_functions in
4722   let commands = List.flatten commands in
4723
4724   List.iter (pr "  \"%s\",\n") commands;
4725
4726   pr "  NULL
4727 };
4728
4729 static char *
4730 generator (const char *text, int state)
4731 {
4732   static int index, len;
4733   const char *name;
4734
4735   if (!state) {
4736     index = 0;
4737     len = strlen (text);
4738   }
4739
4740   while ((name = commands[index]) != NULL) {
4741     index++;
4742     if (strncasecmp (name, text, len) == 0)
4743       return strdup (name);
4744   }
4745
4746   return NULL;
4747 }
4748
4749 #endif /* HAVE_LIBREADLINE */
4750
4751 char **do_completion (const char *text, int start, int end)
4752 {
4753   char **matches = NULL;
4754
4755 #ifdef HAVE_LIBREADLINE
4756   if (start == 0)
4757     matches = rl_completion_matches (text, generator);
4758 #endif
4759
4760   return matches;
4761 }
4762 ";
4763
4764 (* Generate the POD documentation for guestfish. *)
4765 and generate_fish_actions_pod () =
4766   let all_functions_sorted =
4767     List.filter (
4768       fun (_, _, _, flags, _, _, _) ->
4769         not (List.mem NotInFish flags || List.mem NotInDocs flags)
4770     ) all_functions_sorted in
4771
4772   let rex = Str.regexp "C<guestfs_\\([^>]+\\)>" in
4773
4774   List.iter (
4775     fun (name, style, _, flags, _, _, longdesc) ->
4776       let longdesc =
4777         Str.global_substitute rex (
4778           fun s ->
4779             let sub =
4780               try Str.matched_group 1 s
4781               with Not_found ->
4782                 failwithf "error substituting C<guestfs_...> in longdesc of function %s" name in
4783             "C<" ^ replace_char sub '_' '-' ^ ">"
4784         ) longdesc in
4785       let name = replace_char name '_' '-' in
4786       let alias =
4787         try find_map (function FishAlias n -> Some n | _ -> None) flags
4788         with Not_found -> name in
4789
4790       pr "=head2 %s" name;
4791       if name <> alias then
4792         pr " | %s" alias;
4793       pr "\n";
4794       pr "\n";
4795       pr " %s" name;
4796       List.iter (
4797         function
4798         | String n -> pr " %s" n
4799         | OptString n -> pr " %s" n
4800         | StringList n -> pr " '%s ...'" n
4801         | Bool _ -> pr " true|false"
4802         | Int n -> pr " %s" n
4803         | FileIn n | FileOut n -> pr " (%s|-)" n
4804       ) (snd style);
4805       pr "\n";
4806       pr "\n";
4807       pr "%s\n\n" longdesc;
4808
4809       if List.exists (function FileIn _ | FileOut _ -> true
4810                       | _ -> false) (snd style) then
4811         pr "Use C<-> instead of a filename to read/write from stdin/stdout.\n\n";
4812
4813       if List.mem ProtocolLimitWarning flags then
4814         pr "%s\n\n" protocol_limit_warning;
4815
4816       if List.mem DangerWillRobinson flags then
4817         pr "%s\n\n" danger_will_robinson
4818   ) all_functions_sorted
4819
4820 (* Generate a C function prototype. *)
4821 and generate_prototype ?(extern = true) ?(static = false) ?(semicolon = true)
4822     ?(single_line = false) ?(newline = false) ?(in_daemon = false)
4823     ?(prefix = "")
4824     ?handle name style =
4825   if extern then pr "extern ";
4826   if static then pr "static ";
4827   (match fst style with
4828    | RErr -> pr "int "
4829    | RInt _ -> pr "int "
4830    | RInt64 _ -> pr "int64_t "
4831    | RBool _ -> pr "int "
4832    | RConstString _ -> pr "const char *"
4833    | RString _ -> pr "char *"
4834    | RStringList _ | RHashtable _ -> pr "char **"
4835    | RIntBool _ ->
4836        if not in_daemon then pr "struct guestfs_int_bool *"
4837        else pr "guestfs_%s_ret *" name
4838    | RPVList _ ->
4839        if not in_daemon then pr "struct guestfs_lvm_pv_list *"
4840        else pr "guestfs_lvm_int_pv_list *"
4841    | RVGList _ ->
4842        if not in_daemon then pr "struct guestfs_lvm_vg_list *"
4843        else pr "guestfs_lvm_int_vg_list *"
4844    | RLVList _ ->
4845        if not in_daemon then pr "struct guestfs_lvm_lv_list *"
4846        else pr "guestfs_lvm_int_lv_list *"
4847    | RStat _ ->
4848        if not in_daemon then pr "struct guestfs_stat *"
4849        else pr "guestfs_int_stat *"
4850    | RStatVFS _ ->
4851        if not in_daemon then pr "struct guestfs_statvfs *"
4852        else pr "guestfs_int_statvfs *"
4853   );
4854   pr "%s%s (" prefix name;
4855   if handle = None && List.length (snd style) = 0 then
4856     pr "void"
4857   else (
4858     let comma = ref false in
4859     (match handle with
4860      | None -> ()
4861      | Some handle -> pr "guestfs_h *%s" handle; comma := true
4862     );
4863     let next () =
4864       if !comma then (
4865         if single_line then pr ", " else pr ",\n\t\t"
4866       );
4867       comma := true
4868     in
4869     List.iter (
4870       function
4871       | String n
4872       | OptString n -> next (); pr "const char *%s" n
4873       | StringList n -> next (); pr "char * const* const %s" n
4874       | Bool n -> next (); pr "int %s" n
4875       | Int n -> next (); pr "int %s" n
4876       | FileIn n
4877       | FileOut n ->
4878           if not in_daemon then (next (); pr "const char *%s" n)
4879     ) (snd style);
4880   );
4881   pr ")";
4882   if semicolon then pr ";";
4883   if newline then pr "\n"
4884
4885 (* Generate C call arguments, eg "(handle, foo, bar)" *)
4886 and generate_call_args ?handle args =
4887   pr "(";
4888   let comma = ref false in
4889   (match handle with
4890    | None -> ()
4891    | Some handle -> pr "%s" handle; comma := true
4892   );
4893   List.iter (
4894     fun arg ->
4895       if !comma then pr ", ";
4896       comma := true;
4897       pr "%s" (name_of_argt arg)
4898   ) args;
4899   pr ")"
4900
4901 (* Generate the OCaml bindings interface. *)
4902 and generate_ocaml_mli () =
4903   generate_header OCamlStyle LGPLv2;
4904
4905   pr "\
4906 (** For API documentation you should refer to the C API
4907     in the guestfs(3) manual page.  The OCaml API uses almost
4908     exactly the same calls. *)
4909
4910 type t
4911 (** A [guestfs_h] handle. *)
4912
4913 exception Error of string
4914 (** This exception is raised when there is an error. *)
4915
4916 val create : unit -> t
4917
4918 val close : t -> unit
4919 (** Handles are closed by the garbage collector when they become
4920     unreferenced, but callers can also call this in order to
4921     provide predictable cleanup. *)
4922
4923 ";
4924   generate_ocaml_lvm_structure_decls ();
4925
4926   generate_ocaml_stat_structure_decls ();
4927
4928   (* The actions. *)
4929   List.iter (
4930     fun (name, style, _, _, _, shortdesc, _) ->
4931       generate_ocaml_prototype name style;
4932       pr "(** %s *)\n" shortdesc;
4933       pr "\n"
4934   ) all_functions
4935
4936 (* Generate the OCaml bindings implementation. *)
4937 and generate_ocaml_ml () =
4938   generate_header OCamlStyle LGPLv2;
4939
4940   pr "\
4941 type t
4942 exception Error of string
4943 external create : unit -> t = \"ocaml_guestfs_create\"
4944 external close : t -> unit = \"ocaml_guestfs_close\"
4945
4946 let () =
4947   Callback.register_exception \"ocaml_guestfs_error\" (Error \"\")
4948
4949 ";
4950
4951   generate_ocaml_lvm_structure_decls ();
4952
4953   generate_ocaml_stat_structure_decls ();
4954
4955   (* The actions. *)
4956   List.iter (
4957     fun (name, style, _, _, _, shortdesc, _) ->
4958       generate_ocaml_prototype ~is_external:true name style;
4959   ) all_functions
4960
4961 (* Generate the OCaml bindings C implementation. *)
4962 and generate_ocaml_c () =
4963   generate_header CStyle LGPLv2;
4964
4965   pr "\
4966 #include <stdio.h>
4967 #include <stdlib.h>
4968 #include <string.h>
4969
4970 #include <caml/config.h>
4971 #include <caml/alloc.h>
4972 #include <caml/callback.h>
4973 #include <caml/fail.h>
4974 #include <caml/memory.h>
4975 #include <caml/mlvalues.h>
4976 #include <caml/signals.h>
4977
4978 #include <guestfs.h>
4979
4980 #include \"guestfs_c.h\"
4981
4982 /* Copy a hashtable of string pairs into an assoc-list.  We return
4983  * the list in reverse order, but hashtables aren't supposed to be
4984  * ordered anyway.
4985  */
4986 static CAMLprim value
4987 copy_table (char * const * argv)
4988 {
4989   CAMLparam0 ();
4990   CAMLlocal5 (rv, pairv, kv, vv, cons);
4991   int i;
4992
4993   rv = Val_int (0);
4994   for (i = 0; argv[i] != NULL; i += 2) {
4995     kv = caml_copy_string (argv[i]);
4996     vv = caml_copy_string (argv[i+1]);
4997     pairv = caml_alloc (2, 0);
4998     Store_field (pairv, 0, kv);
4999     Store_field (pairv, 1, vv);
5000     cons = caml_alloc (2, 0);
5001     Store_field (cons, 1, rv);
5002     rv = cons;
5003     Store_field (cons, 0, pairv);
5004   }
5005
5006   CAMLreturn (rv);
5007 }
5008
5009 ";
5010
5011   (* LVM struct copy functions. *)
5012   List.iter (
5013     fun (typ, cols) ->
5014       let has_optpercent_col =
5015         List.exists (function (_, `OptPercent) -> true | _ -> false) cols in
5016
5017       pr "static CAMLprim value\n";
5018       pr "copy_lvm_%s (const struct guestfs_lvm_%s *%s)\n" typ typ typ;
5019       pr "{\n";
5020       pr "  CAMLparam0 ();\n";
5021       if has_optpercent_col then
5022         pr "  CAMLlocal3 (rv, v, v2);\n"
5023       else
5024         pr "  CAMLlocal2 (rv, v);\n";
5025       pr "\n";
5026       pr "  rv = caml_alloc (%d, 0);\n" (List.length cols);
5027       iteri (
5028         fun i col ->
5029           (match col with
5030            | name, `String ->
5031                pr "  v = caml_copy_string (%s->%s);\n" typ name
5032            | name, `UUID ->
5033                pr "  v = caml_alloc_string (32);\n";
5034                pr "  memcpy (String_val (v), %s->%s, 32);\n" typ name
5035            | name, `Bytes
5036            | name, `Int ->
5037                pr "  v = caml_copy_int64 (%s->%s);\n" typ name
5038            | name, `OptPercent ->
5039                pr "  if (%s->%s >= 0) { /* Some %s */\n" typ name name;
5040                pr "    v2 = caml_copy_double (%s->%s);\n" typ name;
5041                pr "    v = caml_alloc (1, 0);\n";
5042                pr "    Store_field (v, 0, v2);\n";
5043                pr "  } else /* None */\n";
5044                pr "    v = Val_int (0);\n";
5045           );
5046           pr "  Store_field (rv, %d, v);\n" i
5047       ) cols;
5048       pr "  CAMLreturn (rv);\n";
5049       pr "}\n";
5050       pr "\n";
5051
5052       pr "static CAMLprim value\n";
5053       pr "copy_lvm_%s_list (const struct guestfs_lvm_%s_list *%ss)\n"
5054         typ typ typ;
5055       pr "{\n";
5056       pr "  CAMLparam0 ();\n";
5057       pr "  CAMLlocal2 (rv, v);\n";
5058       pr "  int i;\n";
5059       pr "\n";
5060       pr "  if (%ss->len == 0)\n" typ;
5061       pr "    CAMLreturn (Atom (0));\n";
5062       pr "  else {\n";
5063       pr "    rv = caml_alloc (%ss->len, 0);\n" typ;
5064       pr "    for (i = 0; i < %ss->len; ++i) {\n" typ;
5065       pr "      v = copy_lvm_%s (&%ss->val[i]);\n" typ typ;
5066       pr "      caml_modify (&Field (rv, i), v);\n";
5067       pr "    }\n";
5068       pr "    CAMLreturn (rv);\n";
5069       pr "  }\n";
5070       pr "}\n";
5071       pr "\n";
5072   ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
5073
5074   (* Stat copy functions. *)
5075   List.iter (
5076     fun (typ, cols) ->
5077       pr "static CAMLprim value\n";
5078       pr "copy_%s (const struct guestfs_%s *%s)\n" typ typ typ;
5079       pr "{\n";
5080       pr "  CAMLparam0 ();\n";
5081       pr "  CAMLlocal2 (rv, v);\n";
5082       pr "\n";
5083       pr "  rv = caml_alloc (%d, 0);\n" (List.length cols);
5084       iteri (
5085         fun i col ->
5086           (match col with
5087            | name, `Int ->
5088                pr "  v = caml_copy_int64 (%s->%s);\n" typ name
5089           );
5090           pr "  Store_field (rv, %d, v);\n" i
5091       ) cols;
5092       pr "  CAMLreturn (rv);\n";
5093       pr "}\n";
5094       pr "\n";
5095   ) ["stat", stat_cols; "statvfs", statvfs_cols];
5096
5097   (* The wrappers. *)
5098   List.iter (
5099     fun (name, style, _, _, _, _, _) ->
5100       let params =
5101         "gv" :: List.map (fun arg -> name_of_argt arg ^ "v") (snd style) in
5102
5103       pr "CAMLprim value\n";
5104       pr "ocaml_guestfs_%s (value %s" name (List.hd params);
5105       List.iter (pr ", value %s") (List.tl params);
5106       pr ")\n";
5107       pr "{\n";
5108
5109       (match params with
5110        | [p1; p2; p3; p4; p5] ->
5111            pr "  CAMLparam5 (%s);\n" (String.concat ", " params)
5112        | p1 :: p2 :: p3 :: p4 :: p5 :: rest ->
5113            pr "  CAMLparam5 (%s);\n" (String.concat ", " [p1; p2; p3; p4; p5]);
5114            pr "  CAMLxparam%d (%s);\n"
5115              (List.length rest) (String.concat ", " rest)
5116        | ps ->
5117            pr "  CAMLparam%d (%s);\n" (List.length ps) (String.concat ", " ps)
5118       );
5119       pr "  CAMLlocal1 (rv);\n";
5120       pr "\n";
5121
5122       pr "  guestfs_h *g = Guestfs_val (gv);\n";
5123       pr "  if (g == NULL)\n";
5124       pr "    caml_failwith (\"%s: used handle after closing it\");\n" name;
5125       pr "\n";
5126
5127       List.iter (
5128         function
5129         | String n
5130         | FileIn n
5131         | FileOut n ->
5132             pr "  const char *%s = String_val (%sv);\n" n n
5133         | OptString n ->
5134             pr "  const char *%s =\n" n;
5135             pr "    %sv != Val_int (0) ? String_val (Field (%sv, 0)) : NULL;\n"
5136               n n
5137         | StringList n ->
5138             pr "  char **%s = ocaml_guestfs_strings_val (g, %sv);\n" n n
5139         | Bool n ->
5140             pr "  int %s = Bool_val (%sv);\n" n n
5141         | Int n ->
5142             pr "  int %s = Int_val (%sv);\n" n n
5143       ) (snd style);
5144       let error_code =
5145         match fst style with
5146         | RErr -> pr "  int r;\n"; "-1"
5147         | RInt _ -> pr "  int r;\n"; "-1"
5148         | RInt64 _ -> pr "  int64_t r;\n"; "-1"
5149         | RBool _ -> pr "  int r;\n"; "-1"
5150         | RConstString _ -> pr "  const char *r;\n"; "NULL"
5151         | RString _ -> pr "  char *r;\n"; "NULL"
5152         | RStringList _ ->
5153             pr "  int i;\n";
5154             pr "  char **r;\n";
5155             "NULL"
5156         | RIntBool _ ->
5157             pr "  struct guestfs_int_bool *r;\n"; "NULL"
5158         | RPVList _ ->
5159             pr "  struct guestfs_lvm_pv_list *r;\n"; "NULL"
5160         | RVGList _ ->
5161             pr "  struct guestfs_lvm_vg_list *r;\n"; "NULL"
5162         | RLVList _ ->
5163             pr "  struct guestfs_lvm_lv_list *r;\n"; "NULL"
5164         | RStat _ ->
5165             pr "  struct guestfs_stat *r;\n"; "NULL"
5166         | RStatVFS _ ->
5167             pr "  struct guestfs_statvfs *r;\n"; "NULL"
5168         | RHashtable _ ->
5169             pr "  int i;\n";
5170             pr "  char **r;\n";
5171             "NULL" in
5172       pr "\n";
5173
5174       pr "  caml_enter_blocking_section ();\n";
5175       pr "  r = guestfs_%s " name;
5176       generate_call_args ~handle:"g" (snd style);
5177       pr ";\n";
5178       pr "  caml_leave_blocking_section ();\n";
5179
5180       List.iter (
5181         function
5182         | StringList n ->
5183             pr "  ocaml_guestfs_free_strings (%s);\n" n;
5184         | String _ | OptString _ | Bool _ | Int _ | FileIn _ | FileOut _ -> ()
5185       ) (snd style);
5186
5187       pr "  if (r == %s)\n" error_code;
5188       pr "    ocaml_guestfs_raise_error (g, \"%s\");\n" name;
5189       pr "\n";
5190
5191       (match fst style with
5192        | RErr -> pr "  rv = Val_unit;\n"
5193        | RInt _ -> pr "  rv = Val_int (r);\n"
5194        | RInt64 _ ->
5195            pr "  rv = caml_copy_int64 (r);\n"
5196        | RBool _ -> pr "  rv = Val_bool (r);\n"
5197        | RConstString _ -> pr "  rv = caml_copy_string (r);\n"
5198        | RString _ ->
5199            pr "  rv = caml_copy_string (r);\n";
5200            pr "  free (r);\n"
5201        | RStringList _ ->
5202            pr "  rv = caml_copy_string_array ((const char **) r);\n";
5203            pr "  for (i = 0; r[i] != NULL; ++i) free (r[i]);\n";
5204            pr "  free (r);\n"
5205        | RIntBool _ ->
5206            pr "  rv = caml_alloc (2, 0);\n";
5207            pr "  Store_field (rv, 0, Val_int (r->i));\n";
5208            pr "  Store_field (rv, 1, Val_bool (r->b));\n";
5209            pr "  guestfs_free_int_bool (r);\n";
5210        | RPVList _ ->
5211            pr "  rv = copy_lvm_pv_list (r);\n";
5212            pr "  guestfs_free_lvm_pv_list (r);\n";
5213        | RVGList _ ->
5214            pr "  rv = copy_lvm_vg_list (r);\n";
5215            pr "  guestfs_free_lvm_vg_list (r);\n";
5216        | RLVList _ ->
5217            pr "  rv = copy_lvm_lv_list (r);\n";
5218            pr "  guestfs_free_lvm_lv_list (r);\n";
5219        | RStat _ ->
5220            pr "  rv = copy_stat (r);\n";
5221            pr "  free (r);\n";
5222        | RStatVFS _ ->
5223            pr "  rv = copy_statvfs (r);\n";
5224            pr "  free (r);\n";
5225        | RHashtable _ ->
5226            pr "  rv = copy_table (r);\n";
5227            pr "  for (i = 0; r[i] != NULL; ++i) free (r[i]);\n";
5228            pr "  free (r);\n";
5229       );
5230
5231       pr "  CAMLreturn (rv);\n";
5232       pr "}\n";
5233       pr "\n";
5234
5235       if List.length params > 5 then (
5236         pr "CAMLprim value\n";
5237         pr "ocaml_guestfs_%s_byte (value *argv, int argn)\n" name;
5238         pr "{\n";
5239         pr "  return ocaml_guestfs_%s (argv[0]" name;
5240         iteri (fun i _ -> pr ", argv[%d]" i) (List.tl params);
5241         pr ");\n";
5242         pr "}\n";
5243         pr "\n"
5244       )
5245   ) all_functions
5246
5247 and generate_ocaml_lvm_structure_decls () =
5248   List.iter (
5249     fun (typ, cols) ->
5250       pr "type lvm_%s = {\n" typ;
5251       List.iter (
5252         function
5253         | name, `String -> pr "  %s : string;\n" name
5254         | name, `UUID -> pr "  %s : string;\n" name
5255         | name, `Bytes -> pr "  %s : int64;\n" name
5256         | name, `Int -> pr "  %s : int64;\n" name
5257         | name, `OptPercent -> pr "  %s : float option;\n" name
5258       ) cols;
5259       pr "}\n";
5260       pr "\n"
5261   ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols]
5262
5263 and generate_ocaml_stat_structure_decls () =
5264   List.iter (
5265     fun (typ, cols) ->
5266       pr "type %s = {\n" typ;
5267       List.iter (
5268         function
5269         | name, `Int -> pr "  %s : int64;\n" name
5270       ) cols;
5271       pr "}\n";
5272       pr "\n"
5273   ) ["stat", stat_cols; "statvfs", statvfs_cols]
5274
5275 and generate_ocaml_prototype ?(is_external = false) name style =
5276   if is_external then pr "external " else pr "val ";
5277   pr "%s : t -> " name;
5278   List.iter (
5279     function
5280     | String _ | FileIn _ | FileOut _ -> pr "string -> "
5281     | OptString _ -> pr "string option -> "
5282     | StringList _ -> pr "string array -> "
5283     | Bool _ -> pr "bool -> "
5284     | Int _ -> pr "int -> "
5285   ) (snd style);
5286   (match fst style with
5287    | RErr -> pr "unit" (* all errors are turned into exceptions *)
5288    | RInt _ -> pr "int"
5289    | RInt64 _ -> pr "int64"
5290    | RBool _ -> pr "bool"
5291    | RConstString _ -> pr "string"
5292    | RString _ -> pr "string"
5293    | RStringList _ -> pr "string array"
5294    | RIntBool _ -> pr "int * bool"
5295    | RPVList _ -> pr "lvm_pv array"
5296    | RVGList _ -> pr "lvm_vg array"
5297    | RLVList _ -> pr "lvm_lv array"
5298    | RStat _ -> pr "stat"
5299    | RStatVFS _ -> pr "statvfs"
5300    | RHashtable _ -> pr "(string * string) list"
5301   );
5302   if is_external then (
5303     pr " = ";
5304     if List.length (snd style) + 1 > 5 then
5305       pr "\"ocaml_guestfs_%s_byte\" " name;
5306     pr "\"ocaml_guestfs_%s\"" name
5307   );
5308   pr "\n"
5309
5310 (* Generate Perl xs code, a sort of crazy variation of C with macros. *)
5311 and generate_perl_xs () =
5312   generate_header CStyle LGPLv2;
5313
5314   pr "\
5315 #include \"EXTERN.h\"
5316 #include \"perl.h\"
5317 #include \"XSUB.h\"
5318
5319 #include <guestfs.h>
5320
5321 #ifndef PRId64
5322 #define PRId64 \"lld\"
5323 #endif
5324
5325 static SV *
5326 my_newSVll(long long val) {
5327 #ifdef USE_64_BIT_ALL
5328   return newSViv(val);
5329 #else
5330   char buf[100];
5331   int len;
5332   len = snprintf(buf, 100, \"%%\" PRId64, val);
5333   return newSVpv(buf, len);
5334 #endif
5335 }
5336
5337 #ifndef PRIu64
5338 #define PRIu64 \"llu\"
5339 #endif
5340
5341 static SV *
5342 my_newSVull(unsigned long long val) {
5343 #ifdef USE_64_BIT_ALL
5344   return newSVuv(val);
5345 #else
5346   char buf[100];
5347   int len;
5348   len = snprintf(buf, 100, \"%%\" PRIu64, val);
5349   return newSVpv(buf, len);
5350 #endif
5351 }
5352
5353 /* http://www.perlmonks.org/?node_id=680842 */
5354 static char **
5355 XS_unpack_charPtrPtr (SV *arg) {
5356   char **ret;
5357   AV *av;
5358   I32 i;
5359
5360   if (!arg || !SvOK (arg) || !SvROK (arg) || SvTYPE (SvRV (arg)) != SVt_PVAV)
5361     croak (\"array reference expected\");
5362
5363   av = (AV *)SvRV (arg);
5364   ret = malloc ((av_len (av) + 1 + 1) * sizeof (char *));
5365   if (!ret)
5366     croak (\"malloc failed\");
5367
5368   for (i = 0; i <= av_len (av); i++) {
5369     SV **elem = av_fetch (av, i, 0);
5370
5371     if (!elem || !*elem)
5372       croak (\"missing element in list\");
5373
5374     ret[i] = SvPV_nolen (*elem);
5375   }
5376
5377   ret[i] = NULL;
5378
5379   return ret;
5380 }
5381
5382 MODULE = Sys::Guestfs  PACKAGE = Sys::Guestfs
5383
5384 PROTOTYPES: ENABLE
5385
5386 guestfs_h *
5387 _create ()
5388    CODE:
5389       RETVAL = guestfs_create ();
5390       if (!RETVAL)
5391         croak (\"could not create guestfs handle\");
5392       guestfs_set_error_handler (RETVAL, NULL, NULL);
5393  OUTPUT:
5394       RETVAL
5395
5396 void
5397 DESTROY (g)
5398       guestfs_h *g;
5399  PPCODE:
5400       guestfs_close (g);
5401
5402 ";
5403
5404   List.iter (
5405     fun (name, style, _, _, _, _, _) ->
5406       (match fst style with
5407        | RErr -> pr "void\n"
5408        | RInt _ -> pr "SV *\n"
5409        | RInt64 _ -> pr "SV *\n"
5410        | RBool _ -> pr "SV *\n"
5411        | RConstString _ -> pr "SV *\n"
5412        | RString _ -> pr "SV *\n"
5413        | RStringList _
5414        | RIntBool _
5415        | RPVList _ | RVGList _ | RLVList _
5416        | RStat _ | RStatVFS _
5417        | RHashtable _ ->
5418            pr "void\n" (* all lists returned implictly on the stack *)
5419       );
5420       (* Call and arguments. *)
5421       pr "%s " name;
5422       generate_call_args ~handle:"g" (snd style);
5423       pr "\n";
5424       pr "      guestfs_h *g;\n";
5425       iteri (
5426         fun i ->
5427           function
5428           | String n | FileIn n | FileOut n -> pr "      char *%s;\n" n
5429           | OptString n ->
5430               (* http://www.perlmonks.org/?node_id=554277
5431                * Note that the implicit handle argument means we have
5432                * to add 1 to the ST(x) operator.
5433                *)
5434               pr "      char *%s = SvOK(ST(%d)) ? SvPV_nolen(ST(%d)) : NULL;\n" n (i+1) (i+1)
5435           | StringList n -> pr "      char **%s;\n" n
5436           | Bool n -> pr "      int %s;\n" n
5437           | Int n -> pr "      int %s;\n" n
5438       ) (snd style);
5439
5440       let do_cleanups () =
5441         List.iter (
5442           function
5443           | String _ | OptString _ | Bool _ | Int _
5444           | FileIn _ | FileOut _ -> ()
5445           | StringList n -> pr "      free (%s);\n" n
5446         ) (snd style)
5447       in
5448
5449       (* Code. *)
5450       (match fst style with
5451        | RErr ->
5452            pr "PREINIT:\n";
5453            pr "      int r;\n";
5454            pr " PPCODE:\n";
5455            pr "      r = guestfs_%s " name;
5456            generate_call_args ~handle:"g" (snd style);
5457            pr ";\n";
5458            do_cleanups ();
5459            pr "      if (r == -1)\n";
5460            pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
5461        | RInt n
5462        | RBool n ->
5463            pr "PREINIT:\n";
5464            pr "      int %s;\n" n;
5465            pr "   CODE:\n";
5466            pr "      %s = guestfs_%s " n name;
5467            generate_call_args ~handle:"g" (snd style);
5468            pr ";\n";
5469            do_cleanups ();
5470            pr "      if (%s == -1)\n" n;
5471            pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
5472            pr "      RETVAL = newSViv (%s);\n" n;
5473            pr " OUTPUT:\n";
5474            pr "      RETVAL\n"
5475        | RInt64 n ->
5476            pr "PREINIT:\n";
5477            pr "      int64_t %s;\n" n;
5478            pr "   CODE:\n";
5479            pr "      %s = guestfs_%s " n name;
5480            generate_call_args ~handle:"g" (snd style);
5481            pr ";\n";
5482            do_cleanups ();
5483            pr "      if (%s == -1)\n" n;
5484            pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
5485            pr "      RETVAL = my_newSVll (%s);\n" n;
5486            pr " OUTPUT:\n";
5487            pr "      RETVAL\n"
5488        | RConstString n ->
5489            pr "PREINIT:\n";
5490            pr "      const char *%s;\n" n;
5491            pr "   CODE:\n";
5492            pr "      %s = guestfs_%s " n name;
5493            generate_call_args ~handle:"g" (snd style);
5494            pr ";\n";
5495            do_cleanups ();
5496            pr "      if (%s == NULL)\n" n;
5497            pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
5498            pr "      RETVAL = newSVpv (%s, 0);\n" n;
5499            pr " OUTPUT:\n";
5500            pr "      RETVAL\n"
5501        | RString n ->
5502            pr "PREINIT:\n";
5503            pr "      char *%s;\n" n;
5504            pr "   CODE:\n";
5505            pr "      %s = guestfs_%s " n name;
5506            generate_call_args ~handle:"g" (snd style);
5507            pr ";\n";
5508            do_cleanups ();
5509            pr "      if (%s == NULL)\n" n;
5510            pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
5511            pr "      RETVAL = newSVpv (%s, 0);\n" n;
5512            pr "      free (%s);\n" n;
5513            pr " OUTPUT:\n";
5514            pr "      RETVAL\n"
5515        | RStringList n | RHashtable n ->
5516            pr "PREINIT:\n";
5517            pr "      char **%s;\n" n;
5518            pr "      int i, n;\n";
5519            pr " PPCODE:\n";
5520            pr "      %s = guestfs_%s " n name;
5521            generate_call_args ~handle:"g" (snd style);
5522            pr ";\n";
5523            do_cleanups ();
5524            pr "      if (%s == NULL)\n" n;
5525            pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
5526            pr "      for (n = 0; %s[n] != NULL; ++n) /**/;\n" n;
5527            pr "      EXTEND (SP, n);\n";
5528            pr "      for (i = 0; i < n; ++i) {\n";
5529            pr "        PUSHs (sv_2mortal (newSVpv (%s[i], 0)));\n" n;
5530            pr "        free (%s[i]);\n" n;
5531            pr "      }\n";
5532            pr "      free (%s);\n" n;
5533        | RIntBool _ ->
5534            pr "PREINIT:\n";
5535            pr "      struct guestfs_int_bool *r;\n";
5536            pr " PPCODE:\n";
5537            pr "      r = guestfs_%s " name;
5538            generate_call_args ~handle:"g" (snd style);
5539            pr ";\n";
5540            do_cleanups ();
5541            pr "      if (r == NULL)\n";
5542            pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
5543            pr "      EXTEND (SP, 2);\n";
5544            pr "      PUSHs (sv_2mortal (newSViv (r->i)));\n";
5545            pr "      PUSHs (sv_2mortal (newSViv (r->b)));\n";
5546            pr "      guestfs_free_int_bool (r);\n";
5547        | RPVList n ->
5548            generate_perl_lvm_code "pv" pv_cols name style n do_cleanups
5549        | RVGList n ->
5550            generate_perl_lvm_code "vg" vg_cols name style n do_cleanups
5551        | RLVList n ->
5552            generate_perl_lvm_code "lv" lv_cols name style n do_cleanups
5553        | RStat n ->
5554            generate_perl_stat_code "stat" stat_cols name style n do_cleanups
5555        | RStatVFS n ->
5556            generate_perl_stat_code
5557              "statvfs" statvfs_cols name style n do_cleanups
5558       );
5559
5560       pr "\n"
5561   ) all_functions
5562
5563 and generate_perl_lvm_code typ cols name style n do_cleanups =
5564   pr "PREINIT:\n";
5565   pr "      struct guestfs_lvm_%s_list *%s;\n" typ n;
5566   pr "      int i;\n";
5567   pr "      HV *hv;\n";
5568   pr " PPCODE:\n";
5569   pr "      %s = guestfs_%s " n name;
5570   generate_call_args ~handle:"g" (snd style);
5571   pr ";\n";
5572   do_cleanups ();
5573   pr "      if (%s == NULL)\n" n;
5574   pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
5575   pr "      EXTEND (SP, %s->len);\n" n;
5576   pr "      for (i = 0; i < %s->len; ++i) {\n" n;
5577   pr "        hv = newHV ();\n";
5578   List.iter (
5579     function
5580     | name, `String ->
5581         pr "        (void) hv_store (hv, \"%s\", %d, newSVpv (%s->val[i].%s, 0), 0);\n"
5582           name (String.length name) n name
5583     | name, `UUID ->
5584         pr "        (void) hv_store (hv, \"%s\", %d, newSVpv (%s->val[i].%s, 32), 0);\n"
5585           name (String.length name) n name
5586     | name, `Bytes ->
5587         pr "        (void) hv_store (hv, \"%s\", %d, my_newSVull (%s->val[i].%s), 0);\n"
5588           name (String.length name) n name
5589     | name, `Int ->
5590         pr "        (void) hv_store (hv, \"%s\", %d, my_newSVll (%s->val[i].%s), 0);\n"
5591           name (String.length name) n name
5592     | name, `OptPercent ->
5593         pr "        (void) hv_store (hv, \"%s\", %d, newSVnv (%s->val[i].%s), 0);\n"
5594           name (String.length name) n name
5595   ) cols;
5596   pr "        PUSHs (sv_2mortal ((SV *) hv));\n";
5597   pr "      }\n";
5598   pr "      guestfs_free_lvm_%s_list (%s);\n" typ n
5599
5600 and generate_perl_stat_code typ cols name style n do_cleanups =
5601   pr "PREINIT:\n";
5602   pr "      struct guestfs_%s *%s;\n" typ n;
5603   pr " PPCODE:\n";
5604   pr "      %s = guestfs_%s " n name;
5605   generate_call_args ~handle:"g" (snd style);
5606   pr ";\n";
5607   do_cleanups ();
5608   pr "      if (%s == NULL)\n" n;
5609   pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
5610   pr "      EXTEND (SP, %d);\n" (List.length cols);
5611   List.iter (
5612     function
5613     | name, `Int ->
5614         pr "      PUSHs (sv_2mortal (my_newSVll (%s->%s)));\n" n name
5615   ) cols;
5616   pr "      free (%s);\n" n
5617
5618 (* Generate Sys/Guestfs.pm. *)
5619 and generate_perl_pm () =
5620   generate_header HashStyle LGPLv2;
5621
5622   pr "\
5623 =pod
5624
5625 =head1 NAME
5626
5627 Sys::Guestfs - Perl bindings for libguestfs
5628
5629 =head1 SYNOPSIS
5630
5631  use Sys::Guestfs;
5632
5633  my $h = Sys::Guestfs->new ();
5634  $h->add_drive ('guest.img');
5635  $h->launch ();
5636  $h->wait_ready ();
5637  $h->mount ('/dev/sda1', '/');
5638  $h->touch ('/hello');
5639  $h->sync ();
5640
5641 =head1 DESCRIPTION
5642
5643 The C<Sys::Guestfs> module provides a Perl XS binding to the
5644 libguestfs API for examining and modifying virtual machine
5645 disk images.
5646
5647 Amongst the things this is good for: making batch configuration
5648 changes to guests, getting disk used/free statistics (see also:
5649 virt-df), migrating between virtualization systems (see also:
5650 virt-p2v), performing partial backups, performing partial guest
5651 clones, cloning guests and changing registry/UUID/hostname info, and
5652 much else besides.
5653
5654 Libguestfs uses Linux kernel and qemu code, and can access any type of
5655 guest filesystem that Linux and qemu can, including but not limited
5656 to: ext2/3/4, btrfs, FAT and NTFS, LVM, many different disk partition
5657 schemes, qcow, qcow2, vmdk.
5658
5659 Libguestfs provides ways to enumerate guest storage (eg. partitions,
5660 LVs, what filesystem is in each LV, etc.).  It can also run commands
5661 in the context of the guest.  Also you can access filesystems over FTP.
5662
5663 =head1 ERRORS
5664
5665 All errors turn into calls to C<croak> (see L<Carp(3)>).
5666
5667 =head1 METHODS
5668
5669 =over 4
5670
5671 =cut
5672
5673 package Sys::Guestfs;
5674
5675 use strict;
5676 use warnings;
5677
5678 require XSLoader;
5679 XSLoader::load ('Sys::Guestfs');
5680
5681 =item $h = Sys::Guestfs->new ();
5682
5683 Create a new guestfs handle.
5684
5685 =cut
5686
5687 sub new {
5688   my $proto = shift;
5689   my $class = ref ($proto) || $proto;
5690
5691   my $self = Sys::Guestfs::_create ();
5692   bless $self, $class;
5693   return $self;
5694 }
5695
5696 ";
5697
5698   (* Actions.  We only need to print documentation for these as
5699    * they are pulled in from the XS code automatically.
5700    *)
5701   List.iter (
5702     fun (name, style, _, flags, _, _, longdesc) ->
5703       if not (List.mem NotInDocs flags) then (
5704         let longdesc = replace_str longdesc "C<guestfs_" "C<$h-E<gt>" in
5705         pr "=item ";
5706         generate_perl_prototype name style;
5707         pr "\n\n";
5708         pr "%s\n\n" longdesc;
5709         if List.mem ProtocolLimitWarning flags then
5710           pr "%s\n\n" protocol_limit_warning;
5711         if List.mem DangerWillRobinson flags then
5712           pr "%s\n\n" danger_will_robinson
5713       )
5714   ) all_functions_sorted;
5715
5716   (* End of file. *)
5717   pr "\
5718 =cut
5719
5720 1;
5721
5722 =back
5723
5724 =head1 COPYRIGHT
5725
5726 Copyright (C) 2009 Red Hat Inc.
5727
5728 =head1 LICENSE
5729
5730 Please see the file COPYING.LIB for the full license.
5731
5732 =head1 SEE ALSO
5733
5734 L<guestfs(3)>, L<guestfish(1)>.
5735
5736 =cut
5737 "
5738
5739 and generate_perl_prototype name style =
5740   (match fst style with
5741    | RErr -> ()
5742    | RBool n
5743    | RInt n
5744    | RInt64 n
5745    | RConstString n
5746    | RString n -> pr "$%s = " n
5747    | RIntBool (n, m) -> pr "($%s, $%s) = " n m
5748    | RStringList n
5749    | RPVList n
5750    | RVGList n
5751    | RLVList n -> pr "@%s = " n
5752    | RStat n
5753    | RStatVFS n
5754    | RHashtable n -> pr "%%%s = " n
5755   );
5756   pr "$h->%s (" name;
5757   let comma = ref false in
5758   List.iter (
5759     fun arg ->
5760       if !comma then pr ", ";
5761       comma := true;
5762       match arg with
5763       | String n | OptString n | Bool n | Int n | FileIn n | FileOut n ->
5764           pr "$%s" n
5765       | StringList n ->
5766           pr "\\@%s" n
5767   ) (snd style);
5768   pr ");"
5769
5770 (* Generate Python C module. *)
5771 and generate_python_c () =
5772   generate_header CStyle LGPLv2;
5773
5774   pr "\
5775 #include <stdio.h>
5776 #include <stdlib.h>
5777 #include <assert.h>
5778
5779 #include <Python.h>
5780
5781 #include \"guestfs.h\"
5782
5783 typedef struct {
5784   PyObject_HEAD
5785   guestfs_h *g;
5786 } Pyguestfs_Object;
5787
5788 static guestfs_h *
5789 get_handle (PyObject *obj)
5790 {
5791   assert (obj);
5792   assert (obj != Py_None);
5793   return ((Pyguestfs_Object *) obj)->g;
5794 }
5795
5796 static PyObject *
5797 put_handle (guestfs_h *g)
5798 {
5799   assert (g);
5800   return
5801     PyCObject_FromVoidPtrAndDesc ((void *) g, (char *) \"guestfs_h\", NULL);
5802 }
5803
5804 /* This list should be freed (but not the strings) after use. */
5805 static const char **
5806 get_string_list (PyObject *obj)
5807 {
5808   int i, len;
5809   const char **r;
5810
5811   assert (obj);
5812
5813   if (!PyList_Check (obj)) {
5814     PyErr_SetString (PyExc_RuntimeError, \"expecting a list parameter\");
5815     return NULL;
5816   }
5817
5818   len = PyList_Size (obj);
5819   r = malloc (sizeof (char *) * (len+1));
5820   if (r == NULL) {
5821     PyErr_SetString (PyExc_RuntimeError, \"get_string_list: out of memory\");
5822     return NULL;
5823   }
5824
5825   for (i = 0; i < len; ++i)
5826     r[i] = PyString_AsString (PyList_GetItem (obj, i));
5827   r[len] = NULL;
5828
5829   return r;
5830 }
5831
5832 static PyObject *
5833 put_string_list (char * const * const argv)
5834 {
5835   PyObject *list;
5836   int argc, i;
5837
5838   for (argc = 0; argv[argc] != NULL; ++argc)
5839     ;
5840
5841   list = PyList_New (argc);
5842   for (i = 0; i < argc; ++i)
5843     PyList_SetItem (list, i, PyString_FromString (argv[i]));
5844
5845   return list;
5846 }
5847
5848 static PyObject *
5849 put_table (char * const * const argv)
5850 {
5851   PyObject *list, *item;
5852   int argc, i;
5853
5854   for (argc = 0; argv[argc] != NULL; ++argc)
5855     ;
5856
5857   list = PyList_New (argc >> 1);
5858   for (i = 0; i < argc; i += 2) {
5859     item = PyTuple_New (2);
5860     PyTuple_SetItem (item, 0, PyString_FromString (argv[i]));
5861     PyTuple_SetItem (item, 1, PyString_FromString (argv[i+1]));
5862     PyList_SetItem (list, i >> 1, item);
5863   }
5864
5865   return list;
5866 }
5867
5868 static void
5869 free_strings (char **argv)
5870 {
5871   int argc;
5872
5873   for (argc = 0; argv[argc] != NULL; ++argc)
5874     free (argv[argc]);
5875   free (argv);
5876 }
5877
5878 static PyObject *
5879 py_guestfs_create (PyObject *self, PyObject *args)
5880 {
5881   guestfs_h *g;
5882
5883   g = guestfs_create ();
5884   if (g == NULL) {
5885     PyErr_SetString (PyExc_RuntimeError,
5886                      \"guestfs.create: failed to allocate handle\");
5887     return NULL;
5888   }
5889   guestfs_set_error_handler (g, NULL, NULL);
5890   return put_handle (g);
5891 }
5892
5893 static PyObject *
5894 py_guestfs_close (PyObject *self, PyObject *args)
5895 {
5896   PyObject *py_g;
5897   guestfs_h *g;
5898
5899   if (!PyArg_ParseTuple (args, (char *) \"O:guestfs_close\", &py_g))
5900     return NULL;
5901   g = get_handle (py_g);
5902
5903   guestfs_close (g);
5904
5905   Py_INCREF (Py_None);
5906   return Py_None;
5907 }
5908
5909 ";
5910
5911   (* LVM structures, turned into Python dictionaries. *)
5912   List.iter (
5913     fun (typ, cols) ->
5914       pr "static PyObject *\n";
5915       pr "put_lvm_%s (struct guestfs_lvm_%s *%s)\n" typ typ typ;
5916       pr "{\n";
5917       pr "  PyObject *dict;\n";
5918       pr "\n";
5919       pr "  dict = PyDict_New ();\n";
5920       List.iter (
5921         function
5922         | name, `String ->
5923             pr "  PyDict_SetItemString (dict, \"%s\",\n" name;
5924             pr "                        PyString_FromString (%s->%s));\n"
5925               typ name
5926         | name, `UUID ->
5927             pr "  PyDict_SetItemString (dict, \"%s\",\n" name;
5928             pr "                        PyString_FromStringAndSize (%s->%s, 32));\n"
5929               typ name
5930         | name, `Bytes ->
5931             pr "  PyDict_SetItemString (dict, \"%s\",\n" name;
5932             pr "                        PyLong_FromUnsignedLongLong (%s->%s));\n"
5933               typ name
5934         | name, `Int ->
5935             pr "  PyDict_SetItemString (dict, \"%s\",\n" name;
5936             pr "                        PyLong_FromLongLong (%s->%s));\n"
5937               typ name
5938         | name, `OptPercent ->
5939             pr "  if (%s->%s >= 0)\n" typ name;
5940             pr "    PyDict_SetItemString (dict, \"%s\",\n" name;
5941             pr "                          PyFloat_FromDouble ((double) %s->%s));\n"
5942               typ name;
5943             pr "  else {\n";
5944             pr "    Py_INCREF (Py_None);\n";
5945             pr "    PyDict_SetItemString (dict, \"%s\", Py_None);" name;
5946             pr "  }\n"
5947       ) cols;
5948       pr "  return dict;\n";
5949       pr "};\n";
5950       pr "\n";
5951
5952       pr "static PyObject *\n";
5953       pr "put_lvm_%s_list (struct guestfs_lvm_%s_list *%ss)\n" typ typ typ;
5954       pr "{\n";
5955       pr "  PyObject *list;\n";
5956       pr "  int i;\n";
5957       pr "\n";
5958       pr "  list = PyList_New (%ss->len);\n" typ;
5959       pr "  for (i = 0; i < %ss->len; ++i)\n" typ;
5960       pr "    PyList_SetItem (list, i, put_lvm_%s (&%ss->val[i]));\n" typ typ;
5961       pr "  return list;\n";
5962       pr "};\n";
5963       pr "\n"
5964   ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
5965
5966   (* Stat structures, turned into Python dictionaries. *)
5967   List.iter (
5968     fun (typ, cols) ->
5969       pr "static PyObject *\n";
5970       pr "put_%s (struct guestfs_%s *%s)\n" typ typ typ;
5971       pr "{\n";
5972       pr "  PyObject *dict;\n";
5973       pr "\n";
5974       pr "  dict = PyDict_New ();\n";
5975       List.iter (
5976         function
5977         | name, `Int ->
5978             pr "  PyDict_SetItemString (dict, \"%s\",\n" name;
5979             pr "                        PyLong_FromLongLong (%s->%s));\n"
5980               typ name
5981       ) cols;
5982       pr "  return dict;\n";
5983       pr "};\n";
5984       pr "\n";
5985   ) ["stat", stat_cols; "statvfs", statvfs_cols];
5986
5987   (* Python wrapper functions. *)
5988   List.iter (
5989     fun (name, style, _, _, _, _, _) ->
5990       pr "static PyObject *\n";
5991       pr "py_guestfs_%s (PyObject *self, PyObject *args)\n" name;
5992       pr "{\n";
5993
5994       pr "  PyObject *py_g;\n";
5995       pr "  guestfs_h *g;\n";
5996       pr "  PyObject *py_r;\n";
5997
5998       let error_code =
5999         match fst style with
6000         | RErr | RInt _ | RBool _ -> pr "  int r;\n"; "-1"
6001         | RInt64 _ -> pr "  int64_t r;\n"; "-1"
6002         | RConstString _ -> pr "  const char *r;\n"; "NULL"
6003         | RString _ -> pr "  char *r;\n"; "NULL"
6004         | RStringList _ | RHashtable _ -> pr "  char **r;\n"; "NULL"
6005         | RIntBool _ -> pr "  struct guestfs_int_bool *r;\n"; "NULL"
6006         | RPVList n -> pr "  struct guestfs_lvm_pv_list *r;\n"; "NULL"
6007         | RVGList n -> pr "  struct guestfs_lvm_vg_list *r;\n"; "NULL"
6008         | RLVList n -> pr "  struct guestfs_lvm_lv_list *r;\n"; "NULL"
6009         | RStat n -> pr "  struct guestfs_stat *r;\n"; "NULL"
6010         | RStatVFS n -> pr "  struct guestfs_statvfs *r;\n"; "NULL" in
6011
6012       List.iter (
6013         function
6014         | String n | FileIn n | FileOut n -> pr "  const char *%s;\n" n
6015         | OptString n -> pr "  const char *%s;\n" n
6016         | StringList n ->
6017             pr "  PyObject *py_%s;\n" n;
6018             pr "  const char **%s;\n" n
6019         | Bool n -> pr "  int %s;\n" n
6020         | Int n -> pr "  int %s;\n" n
6021       ) (snd style);
6022
6023       pr "\n";
6024
6025       (* Convert the parameters. *)
6026       pr "  if (!PyArg_ParseTuple (args, (char *) \"O";
6027       List.iter (
6028         function
6029         | String _ | FileIn _ | FileOut _ -> pr "s"
6030         | OptString _ -> pr "z"
6031         | StringList _ -> pr "O"
6032         | Bool _ -> pr "i" (* XXX Python has booleans? *)
6033         | Int _ -> pr "i"
6034       ) (snd style);
6035       pr ":guestfs_%s\",\n" name;
6036       pr "                         &py_g";
6037       List.iter (
6038         function
6039         | String n | FileIn n | FileOut n -> pr ", &%s" n
6040         | OptString n -> pr ", &%s" n
6041         | StringList n -> pr ", &py_%s" n
6042         | Bool n -> pr ", &%s" n
6043         | Int n -> pr ", &%s" n
6044       ) (snd style);
6045
6046       pr "))\n";
6047       pr "    return NULL;\n";
6048
6049       pr "  g = get_handle (py_g);\n";
6050       List.iter (
6051         function
6052         | String _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
6053         | StringList n ->
6054             pr "  %s = get_string_list (py_%s);\n" n n;
6055             pr "  if (!%s) return NULL;\n" n
6056       ) (snd style);
6057
6058       pr "\n";
6059
6060       pr "  r = guestfs_%s " name;
6061       generate_call_args ~handle:"g" (snd style);
6062       pr ";\n";
6063
6064       List.iter (
6065         function
6066         | String _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
6067         | StringList n ->
6068             pr "  free (%s);\n" n
6069       ) (snd style);
6070
6071       pr "  if (r == %s) {\n" error_code;
6072       pr "    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));\n";
6073       pr "    return NULL;\n";
6074       pr "  }\n";
6075       pr "\n";
6076
6077       (match fst style with
6078        | RErr ->
6079            pr "  Py_INCREF (Py_None);\n";
6080            pr "  py_r = Py_None;\n"
6081        | RInt _
6082        | RBool _ -> pr "  py_r = PyInt_FromLong ((long) r);\n"
6083        | RInt64 _ -> pr "  py_r = PyLong_FromLongLong (r);\n"
6084        | RConstString _ -> pr "  py_r = PyString_FromString (r);\n"
6085        | RString _ ->
6086            pr "  py_r = PyString_FromString (r);\n";
6087            pr "  free (r);\n"
6088        | RStringList _ ->
6089            pr "  py_r = put_string_list (r);\n";
6090            pr "  free_strings (r);\n"
6091        | RIntBool _ ->
6092            pr "  py_r = PyTuple_New (2);\n";
6093            pr "  PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));\n";
6094            pr "  PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));\n";
6095            pr "  guestfs_free_int_bool (r);\n"
6096        | RPVList n ->
6097            pr "  py_r = put_lvm_pv_list (r);\n";
6098            pr "  guestfs_free_lvm_pv_list (r);\n"
6099        | RVGList n ->
6100            pr "  py_r = put_lvm_vg_list (r);\n";
6101            pr "  guestfs_free_lvm_vg_list (r);\n"
6102        | RLVList n ->
6103            pr "  py_r = put_lvm_lv_list (r);\n";
6104            pr "  guestfs_free_lvm_lv_list (r);\n"
6105        | RStat n ->
6106            pr "  py_r = put_stat (r);\n";
6107            pr "  free (r);\n"
6108        | RStatVFS n ->
6109            pr "  py_r = put_statvfs (r);\n";
6110            pr "  free (r);\n"
6111        | RHashtable n ->
6112            pr "  py_r = put_table (r);\n";
6113            pr "  free_strings (r);\n"
6114       );
6115
6116       pr "  return py_r;\n";
6117       pr "}\n";
6118       pr "\n"
6119   ) all_functions;
6120
6121   (* Table of functions. *)
6122   pr "static PyMethodDef methods[] = {\n";
6123   pr "  { (char *) \"create\", py_guestfs_create, METH_VARARGS, NULL },\n";
6124   pr "  { (char *) \"close\", py_guestfs_close, METH_VARARGS, NULL },\n";
6125   List.iter (
6126     fun (name, _, _, _, _, _, _) ->
6127       pr "  { (char *) \"%s\", py_guestfs_%s, METH_VARARGS, NULL },\n"
6128         name name
6129   ) all_functions;
6130   pr "  { NULL, NULL, 0, NULL }\n";
6131   pr "};\n";
6132   pr "\n";
6133
6134   (* Init function. *)
6135   pr "\
6136 void
6137 initlibguestfsmod (void)
6138 {
6139   static int initialized = 0;
6140
6141   if (initialized) return;
6142   Py_InitModule ((char *) \"libguestfsmod\", methods);
6143   initialized = 1;
6144 }
6145 "
6146
6147 (* Generate Python module. *)
6148 and generate_python_py () =
6149   generate_header HashStyle LGPLv2;
6150
6151   pr "\
6152 u\"\"\"Python bindings for libguestfs
6153
6154 import guestfs
6155 g = guestfs.GuestFS ()
6156 g.add_drive (\"guest.img\")
6157 g.launch ()
6158 g.wait_ready ()
6159 parts = g.list_partitions ()
6160
6161 The guestfs module provides a Python binding to the libguestfs API
6162 for examining and modifying virtual machine disk images.
6163
6164 Amongst the things this is good for: making batch configuration
6165 changes to guests, getting disk used/free statistics (see also:
6166 virt-df), migrating between virtualization systems (see also:
6167 virt-p2v), performing partial backups, performing partial guest
6168 clones, cloning guests and changing registry/UUID/hostname info, and
6169 much else besides.
6170
6171 Libguestfs uses Linux kernel and qemu code, and can access any type of
6172 guest filesystem that Linux and qemu can, including but not limited
6173 to: ext2/3/4, btrfs, FAT and NTFS, LVM, many different disk partition
6174 schemes, qcow, qcow2, vmdk.
6175
6176 Libguestfs provides ways to enumerate guest storage (eg. partitions,
6177 LVs, what filesystem is in each LV, etc.).  It can also run commands
6178 in the context of the guest.  Also you can access filesystems over FTP.
6179
6180 Errors which happen while using the API are turned into Python
6181 RuntimeError exceptions.
6182
6183 To create a guestfs handle you usually have to perform the following
6184 sequence of calls:
6185
6186 # Create the handle, call add_drive at least once, and possibly
6187 # several times if the guest has multiple block devices:
6188 g = guestfs.GuestFS ()
6189 g.add_drive (\"guest.img\")
6190
6191 # Launch the qemu subprocess and wait for it to become ready:
6192 g.launch ()
6193 g.wait_ready ()
6194
6195 # Now you can issue commands, for example:
6196 logvols = g.lvs ()
6197
6198 \"\"\"
6199
6200 import libguestfsmod
6201
6202 class GuestFS:
6203     \"\"\"Instances of this class are libguestfs API handles.\"\"\"
6204
6205     def __init__ (self):
6206         \"\"\"Create a new libguestfs handle.\"\"\"
6207         self._o = libguestfsmod.create ()
6208
6209     def __del__ (self):
6210         libguestfsmod.close (self._o)
6211
6212 ";
6213
6214   List.iter (
6215     fun (name, style, _, flags, _, _, longdesc) ->
6216       pr "    def %s " name;
6217       generate_call_args ~handle:"self" (snd style);
6218       pr ":\n";
6219
6220       if not (List.mem NotInDocs flags) then (
6221         let doc = replace_str longdesc "C<guestfs_" "C<g." in
6222         let doc =
6223           match fst style with
6224           | RErr | RInt _ | RInt64 _ | RBool _ | RConstString _
6225           | RString _ -> doc
6226           | RStringList _ ->
6227               doc ^ "\n\nThis function returns a list of strings."
6228           | RIntBool _ ->
6229               doc ^ "\n\nThis function returns a tuple (int, bool).\n"
6230           | RPVList _ ->
6231               doc ^ "\n\nThis function returns a list of PVs.  Each PV is represented as a dictionary."
6232           | RVGList _ ->
6233               doc ^ "\n\nThis function returns a list of VGs.  Each VG is represented as a dictionary."
6234           | RLVList _ ->
6235               doc ^ "\n\nThis function returns a list of LVs.  Each LV is represented as a dictionary."
6236           | RStat _ ->
6237               doc ^ "\n\nThis function returns a dictionary, with keys matching the various fields in the stat structure."
6238           | RStatVFS _ ->
6239               doc ^ "\n\nThis function returns a dictionary, with keys matching the various fields in the statvfs structure."
6240           | RHashtable _ ->
6241               doc ^ "\n\nThis function returns a dictionary." in
6242         let doc =
6243           if List.mem ProtocolLimitWarning flags then
6244             doc ^ "\n\n" ^ protocol_limit_warning
6245           else doc in
6246         let doc =
6247           if List.mem DangerWillRobinson flags then
6248             doc ^ "\n\n" ^ danger_will_robinson
6249           else doc in
6250         let doc = pod2text ~width:60 name doc in
6251         let doc = List.map (fun line -> replace_str line "\\" "\\\\") doc in
6252         let doc = String.concat "\n        " doc in
6253         pr "        u\"\"\"%s\"\"\"\n" doc;
6254       );
6255       pr "        return libguestfsmod.%s " name;
6256       generate_call_args ~handle:"self._o" (snd style);
6257       pr "\n";
6258       pr "\n";
6259   ) all_functions
6260
6261 (* Useful if you need the longdesc POD text as plain text.  Returns a
6262  * list of lines.
6263  *
6264  * This is the slowest thing about autogeneration.
6265  *)
6266 and pod2text ~width name longdesc =
6267   let filename, chan = Filename.open_temp_file "gen" ".tmp" in
6268   fprintf chan "=head1 %s\n\n%s\n" name longdesc;
6269   close_out chan;
6270   let cmd = sprintf "pod2text -w %d %s" width (Filename.quote filename) in
6271   let chan = Unix.open_process_in cmd in
6272   let lines = ref [] in
6273   let rec loop i =
6274     let line = input_line chan in
6275     if i = 1 then               (* discard the first line of output *)
6276       loop (i+1)
6277     else (
6278       let line = triml line in
6279       lines := line :: !lines;
6280       loop (i+1)
6281     ) in
6282   let lines = try loop 1 with End_of_file -> List.rev !lines in
6283   Unix.unlink filename;
6284   match Unix.close_process_in chan with
6285   | Unix.WEXITED 0 -> lines
6286   | Unix.WEXITED i ->
6287       failwithf "pod2text: process exited with non-zero status (%d)" i
6288   | Unix.WSIGNALED i | Unix.WSTOPPED i ->
6289       failwithf "pod2text: process signalled or stopped by signal %d" i
6290
6291 (* Generate ruby bindings. *)
6292 and generate_ruby_c () =
6293   generate_header CStyle LGPLv2;
6294
6295   pr "\
6296 #include <stdio.h>
6297 #include <stdlib.h>
6298
6299 #include <ruby.h>
6300
6301 #include \"guestfs.h\"
6302
6303 #include \"extconf.h\"
6304
6305 /* For Ruby < 1.9 */
6306 #ifndef RARRAY_LEN
6307 #define RARRAY_LEN(r) (RARRAY((r))->len)
6308 #endif
6309
6310 static VALUE m_guestfs;                 /* guestfs module */
6311 static VALUE c_guestfs;                 /* guestfs_h handle */
6312 static VALUE e_Error;                   /* used for all errors */
6313
6314 static void ruby_guestfs_free (void *p)
6315 {
6316   if (!p) return;
6317   guestfs_close ((guestfs_h *) p);
6318 }
6319
6320 static VALUE ruby_guestfs_create (VALUE m)
6321 {
6322   guestfs_h *g;
6323
6324   g = guestfs_create ();
6325   if (!g)
6326     rb_raise (e_Error, \"failed to create guestfs handle\");
6327
6328   /* Don't print error messages to stderr by default. */
6329   guestfs_set_error_handler (g, NULL, NULL);
6330
6331   /* Wrap it, and make sure the close function is called when the
6332    * handle goes away.
6333    */
6334   return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
6335 }
6336
6337 static VALUE ruby_guestfs_close (VALUE gv)
6338 {
6339   guestfs_h *g;
6340   Data_Get_Struct (gv, guestfs_h, g);
6341
6342   ruby_guestfs_free (g);
6343   DATA_PTR (gv) = NULL;
6344
6345   return Qnil;
6346 }
6347
6348 ";
6349
6350   List.iter (
6351     fun (name, style, _, _, _, _, _) ->
6352       pr "static VALUE ruby_guestfs_%s (VALUE gv" name;
6353       List.iter (fun arg -> pr ", VALUE %sv" (name_of_argt arg)) (snd style);
6354       pr ")\n";
6355       pr "{\n";
6356       pr "  guestfs_h *g;\n";
6357       pr "  Data_Get_Struct (gv, guestfs_h, g);\n";
6358       pr "  if (!g)\n";
6359       pr "    rb_raise (rb_eArgError, \"%%s: used handle after closing it\", \"%s\");\n"
6360         name;
6361       pr "\n";
6362
6363       List.iter (
6364         function
6365         | String n | FileIn n | FileOut n ->
6366             pr "  const char *%s = StringValueCStr (%sv);\n" n n;
6367             pr "  if (!%s)\n" n;
6368             pr "    rb_raise (rb_eTypeError, \"expected string for parameter %%s of %%s\",\n";
6369             pr "              \"%s\", \"%s\");\n" n name
6370         | OptString n ->
6371             pr "  const char *%s = !NIL_P (%sv) ? StringValueCStr (%sv) : NULL;\n" n n n
6372         | StringList n ->
6373             pr "  char **%s;" n;
6374             pr "  {\n";
6375             pr "    int i, len;\n";
6376             pr "    len = RARRAY_LEN (%sv);\n" n;
6377             pr "    %s = guestfs_safe_malloc (g, sizeof (char *) * (len+1));\n"
6378               n;
6379             pr "    for (i = 0; i < len; ++i) {\n";
6380             pr "      VALUE v = rb_ary_entry (%sv, i);\n" n;
6381             pr "      %s[i] = StringValueCStr (v);\n" n;
6382             pr "    }\n";
6383             pr "    %s[len] = NULL;\n" n;
6384             pr "  }\n";
6385         | Bool n ->
6386             pr "  int %s = RTEST (%sv);\n" n n
6387         | Int n ->
6388             pr "  int %s = NUM2INT (%sv);\n" n n
6389       ) (snd style);
6390       pr "\n";
6391
6392       let error_code =
6393         match fst style with
6394         | RErr | RInt _ | RBool _ -> pr "  int r;\n"; "-1"
6395         | RInt64 _ -> pr "  int64_t r;\n"; "-1"
6396         | RConstString _ -> pr "  const char *r;\n"; "NULL"
6397         | RString _ -> pr "  char *r;\n"; "NULL"
6398         | RStringList _ | RHashtable _ -> pr "  char **r;\n"; "NULL"
6399         | RIntBool _ -> pr "  struct guestfs_int_bool *r;\n"; "NULL"
6400         | RPVList n -> pr "  struct guestfs_lvm_pv_list *r;\n"; "NULL"
6401         | RVGList n -> pr "  struct guestfs_lvm_vg_list *r;\n"; "NULL"
6402         | RLVList n -> pr "  struct guestfs_lvm_lv_list *r;\n"; "NULL"
6403         | RStat n -> pr "  struct guestfs_stat *r;\n"; "NULL"
6404         | RStatVFS n -> pr "  struct guestfs_statvfs *r;\n"; "NULL" in
6405       pr "\n";
6406
6407       pr "  r = guestfs_%s " name;
6408       generate_call_args ~handle:"g" (snd style);
6409       pr ";\n";
6410
6411       List.iter (
6412         function
6413         | String _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
6414         | StringList n ->
6415             pr "  free (%s);\n" n
6416       ) (snd style);
6417
6418       pr "  if (r == %s)\n" error_code;
6419       pr "    rb_raise (e_Error, \"%%s\", guestfs_last_error (g));\n";
6420       pr "\n";
6421
6422       (match fst style with
6423        | RErr ->
6424            pr "  return Qnil;\n"
6425        | RInt _ | RBool _ ->
6426            pr "  return INT2NUM (r);\n"
6427        | RInt64 _ ->
6428            pr "  return ULL2NUM (r);\n"
6429        | RConstString _ ->
6430            pr "  return rb_str_new2 (r);\n";
6431        | RString _ ->
6432            pr "  VALUE rv = rb_str_new2 (r);\n";
6433            pr "  free (r);\n";
6434            pr "  return rv;\n";
6435        | RStringList _ ->
6436            pr "  int i, len = 0;\n";
6437            pr "  for (i = 0; r[i] != NULL; ++i) len++;\n";
6438            pr "  VALUE rv = rb_ary_new2 (len);\n";
6439            pr "  for (i = 0; r[i] != NULL; ++i) {\n";
6440            pr "    rb_ary_push (rv, rb_str_new2 (r[i]));\n";
6441            pr "    free (r[i]);\n";
6442            pr "  }\n";
6443            pr "  free (r);\n";
6444            pr "  return rv;\n"
6445        | RIntBool _ ->
6446            pr "  VALUE rv = rb_ary_new2 (2);\n";
6447            pr "  rb_ary_push (rv, INT2NUM (r->i));\n";
6448            pr "  rb_ary_push (rv, INT2NUM (r->b));\n";
6449            pr "  guestfs_free_int_bool (r);\n";
6450            pr "  return rv;\n"
6451        | RPVList n ->
6452            generate_ruby_lvm_code "pv" pv_cols
6453        | RVGList n ->
6454            generate_ruby_lvm_code "vg" vg_cols
6455        | RLVList n ->
6456            generate_ruby_lvm_code "lv" lv_cols
6457        | RStat n ->
6458            pr "  VALUE rv = rb_hash_new ();\n";
6459            List.iter (
6460              function
6461              | name, `Int ->
6462                  pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->%s));\n" name name
6463            ) stat_cols;
6464            pr "  free (r);\n";
6465            pr "  return rv;\n"
6466        | RStatVFS n ->
6467            pr "  VALUE rv = rb_hash_new ();\n";
6468            List.iter (
6469              function
6470              | name, `Int ->
6471                  pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->%s));\n" name name
6472            ) statvfs_cols;
6473            pr "  free (r);\n";
6474            pr "  return rv;\n"
6475        | RHashtable _ ->
6476            pr "  VALUE rv = rb_hash_new ();\n";
6477            pr "  int i;\n";
6478            pr "  for (i = 0; r[i] != NULL; i+=2) {\n";
6479            pr "    rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));\n";
6480            pr "    free (r[i]);\n";
6481            pr "    free (r[i+1]);\n";
6482            pr "  }\n";
6483            pr "  free (r);\n";
6484            pr "  return rv;\n"
6485       );
6486
6487       pr "}\n";
6488       pr "\n"
6489   ) all_functions;
6490
6491   pr "\
6492 /* Initialize the module. */
6493 void Init__guestfs ()
6494 {
6495   m_guestfs = rb_define_module (\"Guestfs\");
6496   c_guestfs = rb_define_class_under (m_guestfs, \"Guestfs\", rb_cObject);
6497   e_Error = rb_define_class_under (m_guestfs, \"Error\", rb_eStandardError);
6498
6499   rb_define_module_function (m_guestfs, \"create\", ruby_guestfs_create, 0);
6500   rb_define_method (c_guestfs, \"close\", ruby_guestfs_close, 0);
6501
6502 ";
6503   (* Define the rest of the methods. *)
6504   List.iter (
6505     fun (name, style, _, _, _, _, _) ->
6506       pr "  rb_define_method (c_guestfs, \"%s\",\n" name;
6507       pr "        ruby_guestfs_%s, %d);\n" name (List.length (snd style))
6508   ) all_functions;
6509
6510   pr "}\n"
6511
6512 (* Ruby code to return an LVM struct list. *)
6513 and generate_ruby_lvm_code typ cols =
6514   pr "  VALUE rv = rb_ary_new2 (r->len);\n";
6515   pr "  int i;\n";
6516   pr "  for (i = 0; i < r->len; ++i) {\n";
6517   pr "    VALUE hv = rb_hash_new ();\n";
6518   List.iter (
6519     function
6520     | name, `String ->
6521         pr "    rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_str_new2 (r->val[i].%s));\n" name name
6522     | name, `UUID ->
6523         pr "    rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_str_new (r->val[i].%s, 32));\n" name name
6524     | name, `Bytes
6525     | name, `Int ->
6526         pr "    rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->val[i].%s));\n" name name
6527     | name, `OptPercent ->
6528         pr "    rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_dbl2big (r->val[i].%s));\n" name name
6529   ) cols;
6530   pr "    rb_ary_push (rv, hv);\n";
6531   pr "  }\n";
6532   pr "  guestfs_free_lvm_%s_list (r);\n" typ;
6533   pr "  return rv;\n"
6534
6535 (* Generate Java bindings GuestFS.java file. *)
6536 and generate_java_java () =
6537   generate_header CStyle LGPLv2;
6538
6539   pr "\
6540 package com.redhat.et.libguestfs;
6541
6542 import java.util.HashMap;
6543 import com.redhat.et.libguestfs.LibGuestFSException;
6544 import com.redhat.et.libguestfs.PV;
6545 import com.redhat.et.libguestfs.VG;
6546 import com.redhat.et.libguestfs.LV;
6547 import com.redhat.et.libguestfs.Stat;
6548 import com.redhat.et.libguestfs.StatVFS;
6549 import com.redhat.et.libguestfs.IntBool;
6550
6551 /**
6552  * The GuestFS object is a libguestfs handle.
6553  *
6554  * @author rjones
6555  */
6556 public class GuestFS {
6557   // Load the native code.
6558   static {
6559     System.loadLibrary (\"guestfs_jni\");
6560   }
6561
6562   /**
6563    * The native guestfs_h pointer.
6564    */
6565   long g;
6566
6567   /**
6568    * Create a libguestfs handle.
6569    *
6570    * @throws LibGuestFSException
6571    */
6572   public GuestFS () throws LibGuestFSException
6573   {
6574     g = _create ();
6575   }
6576   private native long _create () throws LibGuestFSException;
6577
6578   /**
6579    * Close a libguestfs handle.
6580    *
6581    * You can also leave handles to be collected by the garbage
6582    * collector, but this method ensures that the resources used
6583    * by the handle are freed up immediately.  If you call any
6584    * other methods after closing the handle, you will get an
6585    * exception.
6586    *
6587    * @throws LibGuestFSException
6588    */
6589   public void close () throws LibGuestFSException
6590   {
6591     if (g != 0)
6592       _close (g);
6593     g = 0;
6594   }
6595   private native void _close (long g) throws LibGuestFSException;
6596
6597   public void finalize () throws LibGuestFSException
6598   {
6599     close ();
6600   }
6601
6602 ";
6603
6604   List.iter (
6605     fun (name, style, _, flags, _, shortdesc, longdesc) ->
6606       if not (List.mem NotInDocs flags); then (
6607         let doc = replace_str longdesc "C<guestfs_" "C<g." in
6608         let doc =
6609           if List.mem ProtocolLimitWarning flags then
6610             doc ^ "\n\n" ^ protocol_limit_warning
6611           else doc in
6612         let doc =
6613           if List.mem DangerWillRobinson flags then
6614             doc ^ "\n\n" ^ danger_will_robinson
6615           else doc in
6616         let doc = pod2text ~width:60 name doc in
6617         let doc = List.map (            (* RHBZ#501883 *)
6618           function
6619           | "" -> "<p>"
6620           | nonempty -> nonempty
6621         ) doc in
6622         let doc = String.concat "\n   * " doc in
6623
6624         pr "  /**\n";
6625         pr "   * %s\n" shortdesc;
6626         pr "   * <p>\n";
6627         pr "   * %s\n" doc;
6628         pr "   * @throws LibGuestFSException\n";
6629         pr "   */\n";
6630         pr "  ";
6631       );
6632       generate_java_prototype ~public:true ~semicolon:false name style;
6633       pr "\n";
6634       pr "  {\n";
6635       pr "    if (g == 0)\n";
6636       pr "      throw new LibGuestFSException (\"%s: handle is closed\");\n"
6637         name;
6638       pr "    ";
6639       if fst style <> RErr then pr "return ";
6640       pr "_%s " name;
6641       generate_call_args ~handle:"g" (snd style);
6642       pr ";\n";
6643       pr "  }\n";
6644       pr "  ";
6645       generate_java_prototype ~privat:true ~native:true name style;
6646       pr "\n";
6647       pr "\n";
6648   ) all_functions;
6649
6650   pr "}\n"
6651
6652 and generate_java_prototype ?(public=false) ?(privat=false) ?(native=false)
6653     ?(semicolon=true) name style =
6654   if privat then pr "private ";
6655   if public then pr "public ";
6656   if native then pr "native ";
6657
6658   (* return type *)
6659   (match fst style with
6660    | RErr -> pr "void ";
6661    | RInt _ -> pr "int ";
6662    | RInt64 _ -> pr "long ";
6663    | RBool _ -> pr "boolean ";
6664    | RConstString _ | RString _ -> pr "String ";
6665    | RStringList _ -> pr "String[] ";
6666    | RIntBool _ -> pr "IntBool ";
6667    | RPVList _ -> pr "PV[] ";
6668    | RVGList _ -> pr "VG[] ";
6669    | RLVList _ -> pr "LV[] ";
6670    | RStat _ -> pr "Stat ";
6671    | RStatVFS _ -> pr "StatVFS ";
6672    | RHashtable _ -> pr "HashMap<String,String> ";
6673   );
6674
6675   if native then pr "_%s " name else pr "%s " name;
6676   pr "(";
6677   let needs_comma = ref false in
6678   if native then (
6679     pr "long g";
6680     needs_comma := true
6681   );
6682
6683   (* args *)
6684   List.iter (
6685     fun arg ->
6686       if !needs_comma then pr ", ";
6687       needs_comma := true;
6688
6689       match arg with
6690       | String n
6691       | OptString n
6692       | FileIn n
6693       | FileOut n ->
6694           pr "String %s" n
6695       | StringList n ->
6696           pr "String[] %s" n
6697       | Bool n ->
6698           pr "boolean %s" n
6699       | Int n ->
6700           pr "int %s" n
6701   ) (snd style);
6702
6703   pr ")\n";
6704   pr "    throws LibGuestFSException";
6705   if semicolon then pr ";"
6706
6707 and generate_java_struct typ cols =
6708   generate_header CStyle LGPLv2;
6709
6710   pr "\
6711 package com.redhat.et.libguestfs;
6712
6713 /**
6714  * Libguestfs %s structure.
6715  *
6716  * @author rjones
6717  * @see GuestFS
6718  */
6719 public class %s {
6720 " typ typ;
6721
6722   List.iter (
6723     function
6724     | name, `String
6725     | name, `UUID -> pr "  public String %s;\n" name
6726     | name, `Bytes
6727     | name, `Int -> pr "  public long %s;\n" name
6728     | name, `OptPercent ->
6729         pr "  /* The next field is [0..100] or -1 meaning 'not present': */\n";
6730         pr "  public float %s;\n" name
6731   ) cols;
6732
6733   pr "}\n"
6734
6735 and generate_java_c () =
6736   generate_header CStyle LGPLv2;
6737
6738   pr "\
6739 #include <stdio.h>
6740 #include <stdlib.h>
6741 #include <string.h>
6742
6743 #include \"com_redhat_et_libguestfs_GuestFS.h\"
6744 #include \"guestfs.h\"
6745
6746 /* Note that this function returns.  The exception is not thrown
6747  * until after the wrapper function returns.
6748  */
6749 static void
6750 throw_exception (JNIEnv *env, const char *msg)
6751 {
6752   jclass cl;
6753   cl = (*env)->FindClass (env,
6754                           \"com/redhat/et/libguestfs/LibGuestFSException\");
6755   (*env)->ThrowNew (env, cl, msg);
6756 }
6757
6758 JNIEXPORT jlong JNICALL
6759 Java_com_redhat_et_libguestfs_GuestFS__1create
6760   (JNIEnv *env, jobject obj)
6761 {
6762   guestfs_h *g;
6763
6764   g = guestfs_create ();
6765   if (g == NULL) {
6766     throw_exception (env, \"GuestFS.create: failed to allocate handle\");
6767     return 0;
6768   }
6769   guestfs_set_error_handler (g, NULL, NULL);
6770   return (jlong) (long) g;
6771 }
6772
6773 JNIEXPORT void JNICALL
6774 Java_com_redhat_et_libguestfs_GuestFS__1close
6775   (JNIEnv *env, jobject obj, jlong jg)
6776 {
6777   guestfs_h *g = (guestfs_h *) (long) jg;
6778   guestfs_close (g);
6779 }
6780
6781 ";
6782
6783   List.iter (
6784     fun (name, style, _, _, _, _, _) ->
6785       pr "JNIEXPORT ";
6786       (match fst style with
6787        | RErr -> pr "void ";
6788        | RInt _ -> pr "jint ";
6789        | RInt64 _ -> pr "jlong ";
6790        | RBool _ -> pr "jboolean ";
6791        | RConstString _ | RString _ -> pr "jstring ";
6792        | RIntBool _ | RStat _ | RStatVFS _ | RHashtable _ ->
6793            pr "jobject ";
6794        | RStringList _ | RPVList _ | RVGList _ | RLVList _ ->
6795            pr "jobjectArray ";
6796       );
6797       pr "JNICALL\n";
6798       pr "Java_com_redhat_et_libguestfs_GuestFS_";
6799       pr "%s" (replace_str ("_" ^ name) "_" "_1");
6800       pr "\n";
6801       pr "  (JNIEnv *env, jobject obj, jlong jg";
6802       List.iter (
6803         function
6804         | String n
6805         | OptString n
6806         | FileIn n
6807         | FileOut n ->
6808             pr ", jstring j%s" n
6809         | StringList n ->
6810             pr ", jobjectArray j%s" n
6811         | Bool n ->
6812             pr ", jboolean j%s" n
6813         | Int n ->
6814             pr ", jint j%s" n
6815       ) (snd style);
6816       pr ")\n";
6817       pr "{\n";
6818       pr "  guestfs_h *g = (guestfs_h *) (long) jg;\n";
6819       let error_code, no_ret =
6820         match fst style with
6821         | RErr -> pr "  int r;\n"; "-1", ""
6822         | RBool _
6823         | RInt _ -> pr "  int r;\n"; "-1", "0"
6824         | RInt64 _ -> pr "  int64_t r;\n"; "-1", "0"
6825         | RConstString _ -> pr "  const char *r;\n"; "NULL", "NULL"
6826         | RString _ ->
6827             pr "  jstring jr;\n";
6828             pr "  char *r;\n"; "NULL", "NULL"
6829         | RStringList _ ->
6830             pr "  jobjectArray jr;\n";
6831             pr "  int r_len;\n";
6832             pr "  jclass cl;\n";
6833             pr "  jstring jstr;\n";
6834             pr "  char **r;\n"; "NULL", "NULL"
6835         | RIntBool _ ->
6836             pr "  jobject jr;\n";
6837             pr "  jclass cl;\n";
6838             pr "  jfieldID fl;\n";
6839             pr "  struct guestfs_int_bool *r;\n"; "NULL", "NULL"
6840         | RStat _ ->
6841             pr "  jobject jr;\n";
6842             pr "  jclass cl;\n";
6843             pr "  jfieldID fl;\n";
6844             pr "  struct guestfs_stat *r;\n"; "NULL", "NULL"
6845         | RStatVFS _ ->
6846             pr "  jobject jr;\n";
6847             pr "  jclass cl;\n";
6848             pr "  jfieldID fl;\n";
6849             pr "  struct guestfs_statvfs *r;\n"; "NULL", "NULL"
6850         | RPVList _ ->
6851             pr "  jobjectArray jr;\n";
6852             pr "  jclass cl;\n";
6853             pr "  jfieldID fl;\n";
6854             pr "  jobject jfl;\n";
6855             pr "  struct guestfs_lvm_pv_list *r;\n"; "NULL", "NULL"
6856         | RVGList _ ->
6857             pr "  jobjectArray jr;\n";
6858             pr "  jclass cl;\n";
6859             pr "  jfieldID fl;\n";
6860             pr "  jobject jfl;\n";
6861             pr "  struct guestfs_lvm_vg_list *r;\n"; "NULL", "NULL"
6862         | RLVList _ ->
6863             pr "  jobjectArray jr;\n";
6864             pr "  jclass cl;\n";
6865             pr "  jfieldID fl;\n";
6866             pr "  jobject jfl;\n";
6867             pr "  struct guestfs_lvm_lv_list *r;\n"; "NULL", "NULL"
6868         | RHashtable _ -> pr "  char **r;\n"; "NULL", "NULL" in
6869       List.iter (
6870         function
6871         | String n
6872         | OptString n
6873         | FileIn n
6874         | FileOut n ->
6875             pr "  const char *%s;\n" n
6876         | StringList n ->
6877             pr "  int %s_len;\n" n;
6878             pr "  const char **%s;\n" n
6879         | Bool n
6880         | Int n ->
6881             pr "  int %s;\n" n
6882       ) (snd style);
6883
6884       let needs_i =
6885         (match fst style with
6886          | RStringList _ | RPVList _ | RVGList _ | RLVList _ -> true
6887          | RErr | RBool _ | RInt _ | RInt64 _ | RConstString _
6888          | RString _ | RIntBool _ | RStat _ | RStatVFS _
6889          | RHashtable _ -> false) ||
6890         List.exists (function StringList _ -> true | _ -> false) (snd style) in
6891       if needs_i then
6892         pr "  int i;\n";
6893
6894       pr "\n";
6895
6896       (* Get the parameters. *)
6897       List.iter (
6898         function
6899         | String n
6900         | FileIn n
6901         | FileOut n ->
6902             pr "  %s = (*env)->GetStringUTFChars (env, j%s, NULL);\n" n n
6903         | OptString n ->
6904             (* This is completely undocumented, but Java null becomes
6905              * a NULL parameter.
6906              *)
6907             pr "  %s = j%s ? (*env)->GetStringUTFChars (env, j%s, NULL) : NULL;\n" n n n
6908         | StringList n ->
6909             pr "  %s_len = (*env)->GetArrayLength (env, j%s);\n" n n;
6910             pr "  %s = guestfs_safe_malloc (g, sizeof (char *) * (%s_len+1));\n" n n;
6911             pr "  for (i = 0; i < %s_len; ++i) {\n" n;
6912             pr "    jobject o = (*env)->GetObjectArrayElement (env, j%s, i);\n"
6913               n;
6914             pr "    %s[i] = (*env)->GetStringUTFChars (env, o, NULL);\n" n;
6915             pr "  }\n";
6916             pr "  %s[%s_len] = NULL;\n" n n;
6917         | Bool n
6918         | Int n ->
6919             pr "  %s = j%s;\n" n n
6920       ) (snd style);
6921
6922       (* Make the call. *)
6923       pr "  r = guestfs_%s " name;
6924       generate_call_args ~handle:"g" (snd style);
6925       pr ";\n";
6926
6927       (* Release the parameters. *)
6928       List.iter (
6929         function
6930         | String n
6931         | FileIn n
6932         | FileOut n ->
6933             pr "  (*env)->ReleaseStringUTFChars (env, j%s, %s);\n" n n
6934         | OptString n ->
6935             pr "  if (j%s)\n" n;
6936             pr "    (*env)->ReleaseStringUTFChars (env, j%s, %s);\n" n n
6937         | StringList n ->
6938             pr "  for (i = 0; i < %s_len; ++i) {\n" n;
6939             pr "    jobject o = (*env)->GetObjectArrayElement (env, j%s, i);\n"
6940               n;
6941             pr "    (*env)->ReleaseStringUTFChars (env, o, %s[i]);\n" n;
6942             pr "  }\n";
6943             pr "  free (%s);\n" n
6944         | Bool n
6945         | Int n -> ()
6946       ) (snd style);
6947
6948       (* Check for errors. *)
6949       pr "  if (r == %s) {\n" error_code;
6950       pr "    throw_exception (env, guestfs_last_error (g));\n";
6951       pr "    return %s;\n" no_ret;
6952       pr "  }\n";
6953
6954       (* Return value. *)
6955       (match fst style with
6956        | RErr -> ()
6957        | RInt _ -> pr "  return (jint) r;\n"
6958        | RBool _ -> pr "  return (jboolean) r;\n"
6959        | RInt64 _ -> pr "  return (jlong) r;\n"
6960        | RConstString _ -> pr "  return (*env)->NewStringUTF (env, r);\n"
6961        | RString _ ->
6962            pr "  jr = (*env)->NewStringUTF (env, r);\n";
6963            pr "  free (r);\n";
6964            pr "  return jr;\n"
6965        | RStringList _ ->
6966            pr "  for (r_len = 0; r[r_len] != NULL; ++r_len) ;\n";
6967            pr "  cl = (*env)->FindClass (env, \"java/lang/String\");\n";
6968            pr "  jstr = (*env)->NewStringUTF (env, \"\");\n";
6969            pr "  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);\n";
6970            pr "  for (i = 0; i < r_len; ++i) {\n";
6971            pr "    jstr = (*env)->NewStringUTF (env, r[i]);\n";
6972            pr "    (*env)->SetObjectArrayElement (env, jr, i, jstr);\n";
6973            pr "    free (r[i]);\n";
6974            pr "  }\n";
6975            pr "  free (r);\n";
6976            pr "  return jr;\n"
6977        | RIntBool _ ->
6978            pr "  cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/IntBool\");\n";
6979            pr "  jr = (*env)->AllocObject (env, cl);\n";
6980            pr "  fl = (*env)->GetFieldID (env, cl, \"i\", \"I\");\n";
6981            pr "  (*env)->SetIntField (env, jr, fl, r->i);\n";
6982            pr "  fl = (*env)->GetFieldID (env, cl, \"i\", \"Z\");\n";
6983            pr "  (*env)->SetBooleanField (env, jr, fl, r->b);\n";
6984            pr "  guestfs_free_int_bool (r);\n";
6985            pr "  return jr;\n"
6986        | RStat _ ->
6987            pr "  cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/Stat\");\n";
6988            pr "  jr = (*env)->AllocObject (env, cl);\n";
6989            List.iter (
6990              function
6991              | name, `Int ->
6992                  pr "  fl = (*env)->GetFieldID (env, cl, \"%s\", \"J\");\n"
6993                    name;
6994                  pr "  (*env)->SetLongField (env, jr, fl, r->%s);\n" name;
6995            ) stat_cols;
6996            pr "  free (r);\n";
6997            pr "  return jr;\n"
6998        | RStatVFS _ ->
6999            pr "  cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/StatVFS\");\n";
7000            pr "  jr = (*env)->AllocObject (env, cl);\n";
7001            List.iter (
7002              function
7003              | name, `Int ->
7004                  pr "  fl = (*env)->GetFieldID (env, cl, \"%s\", \"J\");\n"
7005                    name;
7006                  pr "  (*env)->SetLongField (env, jr, fl, r->%s);\n" name;
7007            ) statvfs_cols;
7008            pr "  free (r);\n";
7009            pr "  return jr;\n"
7010        | RPVList _ ->
7011            generate_java_lvm_return "pv" "PV" pv_cols
7012        | RVGList _ ->
7013            generate_java_lvm_return "vg" "VG" vg_cols
7014        | RLVList _ ->
7015            generate_java_lvm_return "lv" "LV" lv_cols
7016        | RHashtable _ ->
7017            (* XXX *)
7018            pr "  throw_exception (env, \"%s: internal error: please let us know how to make a Java HashMap from JNI bindings!\");\n" name;
7019            pr "  return NULL;\n"
7020       );
7021
7022       pr "}\n";
7023       pr "\n"
7024   ) all_functions
7025
7026 and generate_java_lvm_return typ jtyp cols =
7027   pr "  cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/%s\");\n" jtyp;
7028   pr "  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);\n";
7029   pr "  for (i = 0; i < r->len; ++i) {\n";
7030   pr "    jfl = (*env)->AllocObject (env, cl);\n";
7031   List.iter (
7032     function
7033     | name, `String ->
7034         pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"Ljava/lang/String;\");\n" name;
7035         pr "    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].%s));\n" name;
7036     | name, `UUID ->
7037         pr "    {\n";
7038         pr "      char s[33];\n";
7039         pr "      memcpy (s, r->val[i].%s, 32);\n" name;
7040         pr "      s[32] = 0;\n";
7041         pr "      fl = (*env)->GetFieldID (env, cl, \"%s\", \"Ljava/lang/String;\");\n" name;
7042         pr "      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));\n";
7043         pr "    }\n";
7044     | name, (`Bytes|`Int) ->
7045         pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"J\");\n" name;
7046         pr "    (*env)->SetLongField (env, jfl, fl, r->val[i].%s);\n" name;
7047     | name, `OptPercent ->
7048         pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"F\");\n" name;
7049         pr "    (*env)->SetFloatField (env, jfl, fl, r->val[i].%s);\n" name;
7050   ) cols;
7051   pr "    (*env)->SetObjectArrayElement (env, jfl, i, jfl);\n";
7052   pr "  }\n";
7053   pr "  guestfs_free_lvm_%s_list (r);\n" typ;
7054   pr "  return jr;\n"
7055
7056 and generate_haskell_hs () =
7057   generate_header HaskellStyle LGPLv2;
7058
7059   (* XXX We only know how to generate partial FFI for Haskell
7060    * at the moment.  Please help out!
7061    *)
7062   let can_generate style =
7063     let check_no_bad_args =
7064       List.for_all (function Bool _ | Int _ -> false | _ -> true)
7065     in
7066     match style with
7067     | RErr, args -> check_no_bad_args args
7068     | RBool _, _
7069     | RInt _, _
7070     | RInt64 _, _
7071     | RConstString _, _
7072     | RString _, _
7073     | RStringList _, _
7074     | RIntBool _, _
7075     | RPVList _, _
7076     | RVGList _, _
7077     | RLVList _, _
7078     | RStat _, _
7079     | RStatVFS _, _
7080     | RHashtable _, _ -> false in
7081
7082   pr "\
7083 {-# INCLUDE <guestfs.h> #-}
7084 {-# LANGUAGE ForeignFunctionInterface #-}
7085
7086 module Guestfs (
7087   create";
7088
7089   (* List out the names of the actions we want to export. *)
7090   List.iter (
7091     fun (name, style, _, _, _, _, _) ->
7092       if can_generate style then pr ",\n  %s" name
7093   ) all_functions;
7094
7095   pr "
7096   ) where
7097 import Foreign
7098 import Foreign.C
7099 import IO
7100 import Control.Exception
7101 import Data.Typeable
7102
7103 data GuestfsS = GuestfsS            -- represents the opaque C struct
7104 type GuestfsP = Ptr GuestfsS        -- guestfs_h *
7105 type GuestfsH = ForeignPtr GuestfsS -- guestfs_h * with attached finalizer
7106
7107 -- XXX define properly later XXX
7108 data PV = PV
7109 data VG = VG
7110 data LV = LV
7111 data IntBool = IntBool
7112 data Stat = Stat
7113 data StatVFS = StatVFS
7114 data Hashtable = Hashtable
7115
7116 foreign import ccall unsafe \"guestfs_create\" c_create
7117   :: IO GuestfsP
7118 foreign import ccall unsafe \"&guestfs_close\" c_close
7119   :: FunPtr (GuestfsP -> IO ())
7120 foreign import ccall unsafe \"guestfs_set_error_handler\" c_set_error_handler
7121   :: GuestfsP -> Ptr CInt -> Ptr CInt -> IO ()
7122
7123 create :: IO GuestfsH
7124 create = do
7125   p <- c_create
7126   c_set_error_handler p nullPtr nullPtr
7127   h <- newForeignPtr c_close p
7128   return h
7129
7130 foreign import ccall unsafe \"guestfs_last_error\" c_last_error
7131   :: GuestfsP -> IO CString
7132
7133 -- last_error :: GuestfsH -> IO (Maybe String)
7134 -- last_error h = do
7135 --   str <- withForeignPtr h (\\p -> c_last_error p)
7136 --   maybePeek peekCString str
7137
7138 last_error :: GuestfsH -> IO (String)
7139 last_error h = do
7140   str <- withForeignPtr h (\\p -> c_last_error p)
7141   if (str == nullPtr)
7142     then return \"no error\"
7143     else peekCString str
7144
7145 ";
7146
7147   (* Generate wrappers for each foreign function. *)
7148   List.iter (
7149     fun (name, style, _, _, _, _, _) ->
7150       if can_generate style then (
7151         pr "foreign import ccall unsafe \"guestfs_%s\" c_%s\n" name name;
7152         pr "  :: ";
7153         generate_haskell_prototype ~handle:"GuestfsP" style;
7154         pr "\n";
7155         pr "\n";
7156         pr "%s :: " name;
7157         generate_haskell_prototype ~handle:"GuestfsH" ~hs:true style;
7158         pr "\n";
7159         pr "%s %s = do\n" name
7160           (String.concat " " ("h" :: List.map name_of_argt (snd style)));
7161         pr "  r <- ";
7162         List.iter (
7163           function
7164           | FileIn n
7165           | FileOut n
7166           | String n -> pr "withCString %s $ \\%s -> " n n
7167           | OptString n -> pr "maybeWith withCString %s $ \\%s -> " n n
7168           | StringList n -> pr "withMany withCString %s $ \\%s -> withArray0 nullPtr %s $ \\%s -> " n n n n
7169           | Bool n ->
7170               (* XXX this doesn't work *)
7171               pr "      let\n";
7172               pr "        %s = case %s of\n" n n;
7173               pr "          False -> 0\n";
7174               pr "          True -> 1\n";
7175               pr "      in fromIntegral %s $ \\%s ->\n" n n
7176           | Int n -> pr "fromIntegral %s $ \\%s -> " n n
7177         ) (snd style);
7178         pr "withForeignPtr h (\\p -> c_%s %s)\n" name
7179           (String.concat " " ("p" :: List.map name_of_argt (snd style)));
7180         (match fst style with
7181          | RErr | RInt _ | RInt64 _ | RBool _ ->
7182              pr "  if (r == -1)\n";
7183              pr "    then do\n";
7184              pr "      err <- last_error h\n";
7185              pr "      fail err\n";
7186          | RConstString _ | RString _ | RStringList _ | RIntBool _
7187          | RPVList _ | RVGList _ | RLVList _ | RStat _ | RStatVFS _
7188          | RHashtable _ ->
7189              pr "  if (r == nullPtr)\n";
7190              pr "    then do\n";
7191              pr "      err <- last_error h\n";
7192              pr "      fail err\n";
7193         );
7194         (match fst style with
7195          | RErr ->
7196              pr "    else return ()\n"
7197          | RInt _ ->
7198              pr "    else return (fromIntegral r)\n"
7199          | RInt64 _ ->
7200              pr "    else return (fromIntegral r)\n"
7201          | RBool _ ->
7202              pr "    else return (toBool r)\n"
7203          | RConstString _
7204          | RString _
7205          | RStringList _
7206          | RIntBool _
7207          | RPVList _
7208          | RVGList _
7209          | RLVList _
7210          | RStat _
7211          | RStatVFS _
7212          | RHashtable _ ->
7213              pr "    else return ()\n" (* XXXXXXXXXXXXXXXXXXXX *)
7214         );
7215         pr "\n";
7216       )
7217   ) all_functions
7218
7219 and generate_haskell_prototype ~handle ?(hs = false) style =
7220   pr "%s -> " handle;
7221   let string = if hs then "String" else "CString" in
7222   let int = if hs then "Int" else "CInt" in
7223   let bool = if hs then "Bool" else "CInt" in
7224   let int64 = if hs then "Integer" else "Int64" in
7225   List.iter (
7226     fun arg ->
7227       (match arg with
7228        | String _ -> pr "%s" string
7229        | OptString _ -> if hs then pr "Maybe String" else pr "CString"
7230        | StringList _ -> if hs then pr "[String]" else pr "Ptr CString"
7231        | Bool _ -> pr "%s" bool
7232        | Int _ -> pr "%s" int
7233        | FileIn _ -> pr "%s" string
7234        | FileOut _ -> pr "%s" string
7235       );
7236       pr " -> ";
7237   ) (snd style);
7238   pr "IO (";
7239   (match fst style with
7240    | RErr -> if not hs then pr "CInt"
7241    | RInt _ -> pr "%s" int
7242    | RInt64 _ -> pr "%s" int64
7243    | RBool _ -> pr "%s" bool
7244    | RConstString _ -> pr "%s" string
7245    | RString _ -> pr "%s" string
7246    | RStringList _ -> pr "[%s]" string
7247    | RIntBool _ -> pr "IntBool"
7248    | RPVList _ -> pr "[PV]"
7249    | RVGList _ -> pr "[VG]"
7250    | RLVList _ -> pr "[LV]"
7251    | RStat _ -> pr "Stat"
7252    | RStatVFS _ -> pr "StatVFS"
7253    | RHashtable _ -> pr "Hashtable"
7254   );
7255   pr ")"
7256
7257 and generate_bindtests () =
7258   generate_header CStyle LGPLv2;
7259
7260   pr "\
7261 #include <stdio.h>
7262 #include <stdlib.h>
7263 #include <inttypes.h>
7264 #include <string.h>
7265
7266 #include \"guestfs.h\"
7267 #include \"guestfs_protocol.h\"
7268
7269 #define error guestfs_error
7270
7271 static void
7272 print_strings (char * const* const argv)
7273 {
7274   int argc;
7275
7276   printf (\"[\");
7277   for (argc = 0; argv[argc] != NULL; ++argc) {
7278     if (argc > 0) printf (\", \");
7279     printf (\"\\\"%%s\\\"\", argv[argc]);
7280   }
7281   printf (\"]\\n\");
7282 }
7283
7284 /* The test0 function prints its parameters to stdout. */
7285 ";
7286
7287   let test0, tests =
7288     match test_functions with
7289     | [] -> assert false
7290     | test0 :: tests -> test0, tests in
7291
7292   let () =
7293     let (name, style, _, _, _, _, _) = test0 in
7294     generate_prototype ~extern:false ~semicolon:false ~newline:true
7295       ~handle:"g" ~prefix:"guestfs_" name style;
7296     pr "{\n";
7297     List.iter (
7298       function
7299       | String n
7300       | FileIn n
7301       | FileOut n -> pr "  printf (\"%%s\\n\", %s);\n" n
7302       | OptString n -> pr "  printf (\"%%s\\n\", %s ? %s : \"null\");\n" n n
7303       | StringList n -> pr "  print_strings (%s);\n" n
7304       | Bool n -> pr "  printf (\"%%s\\n\", %s ? \"true\" : \"false\");\n" n
7305       | Int n -> pr "  printf (\"%%d\\n\", %s);\n" n
7306     ) (snd style);
7307     pr "  /* Java changes stdout line buffering so we need this: */\n";
7308     pr "  fflush (stdout);\n";
7309     pr "  return 0;\n";
7310     pr "}\n";
7311     pr "\n" in
7312
7313   List.iter (
7314     fun (name, style, _, _, _, _, _) ->
7315       if String.sub name (String.length name - 3) 3 <> "err" then (
7316         pr "/* Test normal return. */\n";
7317         generate_prototype ~extern:false ~semicolon:false ~newline:true
7318           ~handle:"g" ~prefix:"guestfs_" name style;
7319         pr "{\n";
7320         (match fst style with
7321          | RErr ->
7322              pr "  return 0;\n"
7323          | RInt _ ->
7324              pr "  int r;\n";
7325              pr "  sscanf (val, \"%%d\", &r);\n";
7326              pr "  return r;\n"
7327          | RInt64 _ ->
7328              pr "  int64_t r;\n";
7329              pr "  sscanf (val, \"%%\" SCNi64, &r);\n";
7330              pr "  return r;\n"
7331          | RBool _ ->
7332              pr "  return strcmp (val, \"true\") == 0;\n"
7333          | RConstString _ ->
7334              (* Can't return the input string here.  Return a static
7335               * string so we ensure we get a segfault if the caller
7336               * tries to free it.
7337               *)
7338              pr "  return \"static string\";\n"
7339          | RString _ ->
7340              pr "  return strdup (val);\n"
7341          | RStringList _ ->
7342              pr "  char **strs;\n";
7343              pr "  int n, i;\n";
7344              pr "  sscanf (val, \"%%d\", &n);\n";
7345              pr "  strs = malloc ((n+1) * sizeof (char *));\n";
7346              pr "  for (i = 0; i < n; ++i) {\n";
7347              pr "    strs[i] = malloc (16);\n";
7348              pr "    snprintf (strs[i], 16, \"%%d\", i);\n";
7349              pr "  }\n";
7350              pr "  strs[n] = NULL;\n";
7351              pr "  return strs;\n"
7352          | RIntBool _ ->
7353              pr "  struct guestfs_int_bool *r;\n";
7354              pr "  r = malloc (sizeof (struct guestfs_int_bool));\n";
7355              pr "  sscanf (val, \"%%\" SCNi32, &r->i);\n";
7356              pr "  r->b = 0;\n";
7357              pr "  return r;\n"
7358          | RPVList _ ->
7359              pr "  struct guestfs_lvm_pv_list *r;\n";
7360              pr "  int i;\n";
7361              pr "  r = malloc (sizeof (struct guestfs_lvm_pv_list));\n";
7362              pr "  sscanf (val, \"%%d\", &r->len);\n";
7363              pr "  r->val = calloc (r->len, sizeof (struct guestfs_lvm_pv));\n";
7364              pr "  for (i = 0; i < r->len; ++i) {\n";
7365              pr "    r->val[i].pv_name = malloc (16);\n";
7366              pr "    snprintf (r->val[i].pv_name, 16, \"%%d\", i);\n";
7367              pr "  }\n";
7368              pr "  return r;\n"
7369          | RVGList _ ->
7370              pr "  struct guestfs_lvm_vg_list *r;\n";
7371              pr "  int i;\n";
7372              pr "  r = malloc (sizeof (struct guestfs_lvm_vg_list));\n";
7373              pr "  sscanf (val, \"%%d\", &r->len);\n";
7374              pr "  r->val = calloc (r->len, sizeof (struct guestfs_lvm_vg));\n";
7375              pr "  for (i = 0; i < r->len; ++i) {\n";
7376              pr "    r->val[i].vg_name = malloc (16);\n";
7377              pr "    snprintf (r->val[i].vg_name, 16, \"%%d\", i);\n";
7378              pr "  }\n";
7379              pr "  return r;\n"
7380          | RLVList _ ->
7381              pr "  struct guestfs_lvm_lv_list *r;\n";
7382              pr "  int i;\n";
7383              pr "  r = malloc (sizeof (struct guestfs_lvm_lv_list));\n";
7384              pr "  sscanf (val, \"%%d\", &r->len);\n";
7385              pr "  r->val = calloc (r->len, sizeof (struct guestfs_lvm_lv));\n";
7386              pr "  for (i = 0; i < r->len; ++i) {\n";
7387              pr "    r->val[i].lv_name = malloc (16);\n";
7388              pr "    snprintf (r->val[i].lv_name, 16, \"%%d\", i);\n";
7389              pr "  }\n";
7390              pr "  return r;\n"
7391          | RStat _ ->
7392              pr "  struct guestfs_stat *r;\n";
7393              pr "  r = calloc (1, sizeof (*r));\n";
7394              pr "  sscanf (val, \"%%\" SCNi64, &r->dev);\n";
7395              pr "  return r;\n"
7396          | RStatVFS _ ->
7397              pr "  struct guestfs_statvfs *r;\n";
7398              pr "  r = calloc (1, sizeof (*r));\n";
7399              pr "  sscanf (val, \"%%\" SCNi64, &r->bsize);\n";
7400              pr "  return r;\n"
7401          | RHashtable _ ->
7402              pr "  char **strs;\n";
7403              pr "  int n, i;\n";
7404              pr "  sscanf (val, \"%%d\", &n);\n";
7405              pr "  strs = malloc ((n*2+1) * sizeof (char *));\n";
7406              pr "  for (i = 0; i < n; ++i) {\n";
7407              pr "    strs[i*2] = malloc (16);\n";
7408              pr "    strs[i*2+1] = malloc (16);\n";
7409              pr "    snprintf (strs[i*2], 16, \"%%d\", i);\n";
7410              pr "    snprintf (strs[i*2+1], 16, \"%%d\", i);\n";
7411              pr "  }\n";
7412              pr "  strs[n*2] = NULL;\n";
7413              pr "  return strs;\n"
7414         );
7415         pr "}\n";
7416         pr "\n"
7417       ) else (
7418         pr "/* Test error return. */\n";
7419         generate_prototype ~extern:false ~semicolon:false ~newline:true
7420           ~handle:"g" ~prefix:"guestfs_" name style;
7421         pr "{\n";
7422         pr "  error (g, \"error\");\n";
7423         (match fst style with
7424          | RErr | RInt _ | RInt64 _ | RBool _ ->
7425              pr "  return -1;\n"
7426          | RConstString _
7427          | RString _ | RStringList _ | RIntBool _
7428          | RPVList _ | RVGList _ | RLVList _ | RStat _ | RStatVFS _
7429          | RHashtable _ ->
7430              pr "  return NULL;\n"
7431         );
7432         pr "}\n";
7433         pr "\n"
7434       )
7435   ) tests
7436
7437 and generate_ocaml_bindtests () =
7438   generate_header OCamlStyle GPLv2;
7439
7440   pr "\
7441 let () =
7442   let g = Guestfs.create () in
7443 ";
7444
7445   let mkargs args =
7446     String.concat " " (
7447       List.map (
7448         function
7449         | CallString s -> "\"" ^ s ^ "\""
7450         | CallOptString None -> "None"
7451         | CallOptString (Some s) -> sprintf "(Some \"%s\")" s
7452         | CallStringList xs ->
7453             "[|" ^ String.concat ";" (List.map (sprintf "\"%s\"") xs) ^ "|]"
7454         | CallInt i when i >= 0 -> string_of_int i
7455         | CallInt i (* when i < 0 *) -> "(" ^ string_of_int i ^ ")"
7456         | CallBool b -> string_of_bool b
7457       ) args
7458     )
7459   in
7460
7461   generate_lang_bindtests (
7462     fun f args -> pr "  Guestfs.%s g %s;\n" f (mkargs args)
7463   );
7464
7465   pr "print_endline \"EOF\"\n"
7466
7467 and generate_perl_bindtests () =
7468   pr "#!/usr/bin/perl -w\n";
7469   generate_header HashStyle GPLv2;
7470
7471   pr "\
7472 use strict;
7473
7474 use Sys::Guestfs;
7475
7476 my $g = Sys::Guestfs->new ();
7477 ";
7478
7479   let mkargs args =
7480     String.concat ", " (
7481       List.map (
7482         function
7483         | CallString s -> "\"" ^ s ^ "\""
7484         | CallOptString None -> "undef"
7485         | CallOptString (Some s) -> sprintf "\"%s\"" s
7486         | CallStringList xs ->
7487             "[" ^ String.concat "," (List.map (sprintf "\"%s\"") xs) ^ "]"
7488         | CallInt i -> string_of_int i
7489         | CallBool b -> if b then "1" else "0"
7490       ) args
7491     )
7492   in
7493
7494   generate_lang_bindtests (
7495     fun f args -> pr "$g->%s (%s);\n" f (mkargs args)
7496   );
7497
7498   pr "print \"EOF\\n\"\n"
7499
7500 and generate_python_bindtests () =
7501   generate_header HashStyle GPLv2;
7502
7503   pr "\
7504 import guestfs
7505
7506 g = guestfs.GuestFS ()
7507 ";
7508
7509   let mkargs args =
7510     String.concat ", " (
7511       List.map (
7512         function
7513         | CallString s -> "\"" ^ s ^ "\""
7514         | CallOptString None -> "None"
7515         | CallOptString (Some s) -> sprintf "\"%s\"" s
7516         | CallStringList xs ->
7517             "[" ^ String.concat "," (List.map (sprintf "\"%s\"") xs) ^ "]"
7518         | CallInt i -> string_of_int i
7519         | CallBool b -> if b then "1" else "0"
7520       ) args
7521     )
7522   in
7523
7524   generate_lang_bindtests (
7525     fun f args -> pr "g.%s (%s)\n" f (mkargs args)
7526   );
7527
7528   pr "print \"EOF\"\n"
7529
7530 and generate_ruby_bindtests () =
7531   generate_header HashStyle GPLv2;
7532
7533   pr "\
7534 require 'guestfs'
7535
7536 g = Guestfs::create()
7537 ";
7538
7539   let mkargs args =
7540     String.concat ", " (
7541       List.map (
7542         function
7543         | CallString s -> "\"" ^ s ^ "\""
7544         | CallOptString None -> "nil"
7545         | CallOptString (Some s) -> sprintf "\"%s\"" s
7546         | CallStringList xs ->
7547             "[" ^ String.concat "," (List.map (sprintf "\"%s\"") xs) ^ "]"
7548         | CallInt i -> string_of_int i
7549         | CallBool b -> string_of_bool b
7550       ) args
7551     )
7552   in
7553
7554   generate_lang_bindtests (
7555     fun f args -> pr "g.%s(%s)\n" f (mkargs args)
7556   );
7557
7558   pr "print \"EOF\\n\"\n"
7559
7560 and generate_java_bindtests () =
7561   generate_header CStyle GPLv2;
7562
7563   pr "\
7564 import com.redhat.et.libguestfs.*;
7565
7566 public class Bindtests {
7567     public static void main (String[] argv)
7568     {
7569         try {
7570             GuestFS g = new GuestFS ();
7571 ";
7572
7573   let mkargs args =
7574     String.concat ", " (
7575       List.map (
7576         function
7577         | CallString s -> "\"" ^ s ^ "\""
7578         | CallOptString None -> "null"
7579         | CallOptString (Some s) -> sprintf "\"%s\"" s
7580         | CallStringList xs ->
7581             "new String[]{" ^
7582               String.concat "," (List.map (sprintf "\"%s\"") xs) ^ "}"
7583         | CallInt i -> string_of_int i
7584         | CallBool b -> string_of_bool b
7585       ) args
7586     )
7587   in
7588
7589   generate_lang_bindtests (
7590     fun f args -> pr "            g.%s (%s);\n" f (mkargs args)
7591   );
7592
7593   pr "
7594             System.out.println (\"EOF\");
7595         }
7596         catch (Exception exn) {
7597             System.err.println (exn);
7598             System.exit (1);
7599         }
7600     }
7601 }
7602 "
7603
7604 and generate_haskell_bindtests () =
7605   () (* XXX Haskell bindings need to be fleshed out. *)
7606
7607 (* Language-independent bindings tests - we do it this way to
7608  * ensure there is parity in testing bindings across all languages.
7609  *)
7610 and generate_lang_bindtests call =
7611   call "test0" [CallString "abc"; CallOptString (Some "def");
7612                 CallStringList []; CallBool false;
7613                 CallInt 0; CallString "123"; CallString "456"];
7614   call "test0" [CallString "abc"; CallOptString None;
7615                 CallStringList []; CallBool false;
7616                 CallInt 0; CallString "123"; CallString "456"];
7617   call "test0" [CallString ""; CallOptString (Some "def");
7618                 CallStringList []; CallBool false;
7619                 CallInt 0; CallString "123"; CallString "456"];
7620   call "test0" [CallString ""; CallOptString (Some "");
7621                 CallStringList []; CallBool false;
7622                 CallInt 0; CallString "123"; CallString "456"];
7623   call "test0" [CallString "abc"; CallOptString (Some "def");
7624                 CallStringList ["1"]; CallBool false;
7625                 CallInt 0; CallString "123"; CallString "456"];
7626   call "test0" [CallString "abc"; CallOptString (Some "def");
7627                 CallStringList ["1"; "2"]; CallBool false;
7628                 CallInt 0; CallString "123"; CallString "456"];
7629   call "test0" [CallString "abc"; CallOptString (Some "def");
7630                 CallStringList ["1"]; CallBool true;
7631                 CallInt 0; CallString "123"; CallString "456"];
7632   call "test0" [CallString "abc"; CallOptString (Some "def");
7633                 CallStringList ["1"]; CallBool false;
7634                 CallInt (-1); CallString "123"; CallString "456"];
7635   call "test0" [CallString "abc"; CallOptString (Some "def");
7636                 CallStringList ["1"]; CallBool false;
7637                 CallInt (-2); CallString "123"; CallString "456"];
7638   call "test0" [CallString "abc"; CallOptString (Some "def");
7639                 CallStringList ["1"]; CallBool false;
7640                 CallInt 1; CallString "123"; CallString "456"];
7641   call "test0" [CallString "abc"; CallOptString (Some "def");
7642                 CallStringList ["1"]; CallBool false;
7643                 CallInt 2; CallString "123"; CallString "456"];
7644   call "test0" [CallString "abc"; CallOptString (Some "def");
7645                 CallStringList ["1"]; CallBool false;
7646                 CallInt 4095; CallString "123"; CallString "456"];
7647   call "test0" [CallString "abc"; CallOptString (Some "def");
7648                 CallStringList ["1"]; CallBool false;
7649                 CallInt 0; CallString ""; CallString ""]
7650
7651   (* XXX Add here tests of the return and error functions. *)
7652
7653 let output_to filename =
7654   let filename_new = filename ^ ".new" in
7655   chan := open_out filename_new;
7656   let close () =
7657     close_out !chan;
7658     chan := stdout;
7659
7660     (* Is the new file different from the current file? *)
7661     if Sys.file_exists filename && files_equal filename filename_new then
7662       Unix.unlink filename_new          (* same, so skip it *)
7663     else (
7664       (* different, overwrite old one *)
7665       (try Unix.chmod filename 0o644 with Unix.Unix_error _ -> ());
7666       Unix.rename filename_new filename;
7667       Unix.chmod filename 0o444;
7668       printf "written %s\n%!" filename;
7669     )
7670   in
7671   close
7672
7673 (* Main program. *)
7674 let () =
7675   check_functions ();
7676
7677   if not (Sys.file_exists "configure.ac") then (
7678     eprintf "\
7679 You are probably running this from the wrong directory.
7680 Run it from the top source directory using the command
7681   src/generator.ml
7682 ";
7683     exit 1
7684   );
7685
7686   let close = output_to "src/guestfs_protocol.x" in
7687   generate_xdr ();
7688   close ();
7689
7690   let close = output_to "src/guestfs-structs.h" in
7691   generate_structs_h ();
7692   close ();
7693
7694   let close = output_to "src/guestfs-actions.h" in
7695   generate_actions_h ();
7696   close ();
7697
7698   let close = output_to "src/guestfs-actions.c" in
7699   generate_client_actions ();
7700   close ();
7701
7702   let close = output_to "daemon/actions.h" in
7703   generate_daemon_actions_h ();
7704   close ();
7705
7706   let close = output_to "daemon/stubs.c" in
7707   generate_daemon_actions ();
7708   close ();
7709
7710   let close = output_to "capitests/tests.c" in
7711   generate_tests ();
7712   close ();
7713
7714   let close = output_to "src/guestfs-bindtests.c" in
7715   generate_bindtests ();
7716   close ();
7717
7718   let close = output_to "fish/cmds.c" in
7719   generate_fish_cmds ();
7720   close ();
7721
7722   let close = output_to "fish/completion.c" in
7723   generate_fish_completion ();
7724   close ();
7725
7726   let close = output_to "guestfs-structs.pod" in
7727   generate_structs_pod ();
7728   close ();
7729
7730   let close = output_to "guestfs-actions.pod" in
7731   generate_actions_pod ();
7732   close ();
7733
7734   let close = output_to "guestfish-actions.pod" in
7735   generate_fish_actions_pod ();
7736   close ();
7737
7738   let close = output_to "ocaml/guestfs.mli" in
7739   generate_ocaml_mli ();
7740   close ();
7741
7742   let close = output_to "ocaml/guestfs.ml" in
7743   generate_ocaml_ml ();
7744   close ();
7745
7746   let close = output_to "ocaml/guestfs_c_actions.c" in
7747   generate_ocaml_c ();
7748   close ();
7749
7750   let close = output_to "ocaml/bindtests.ml" in
7751   generate_ocaml_bindtests ();
7752   close ();
7753
7754   let close = output_to "perl/Guestfs.xs" in
7755   generate_perl_xs ();
7756   close ();
7757
7758   let close = output_to "perl/lib/Sys/Guestfs.pm" in
7759   generate_perl_pm ();
7760   close ();
7761
7762   let close = output_to "perl/bindtests.pl" in
7763   generate_perl_bindtests ();
7764   close ();
7765
7766   let close = output_to "python/guestfs-py.c" in
7767   generate_python_c ();
7768   close ();
7769
7770   let close = output_to "python/guestfs.py" in
7771   generate_python_py ();
7772   close ();
7773
7774   let close = output_to "python/bindtests.py" in
7775   generate_python_bindtests ();
7776   close ();
7777
7778   let close = output_to "ruby/ext/guestfs/_guestfs.c" in
7779   generate_ruby_c ();
7780   close ();
7781
7782   let close = output_to "ruby/bindtests.rb" in
7783   generate_ruby_bindtests ();
7784   close ();
7785
7786   let close = output_to "java/com/redhat/et/libguestfs/GuestFS.java" in
7787   generate_java_java ();
7788   close ();
7789
7790   let close = output_to "java/com/redhat/et/libguestfs/PV.java" in
7791   generate_java_struct "PV" pv_cols;
7792   close ();
7793
7794   let close = output_to "java/com/redhat/et/libguestfs/VG.java" in
7795   generate_java_struct "VG" vg_cols;
7796   close ();
7797
7798   let close = output_to "java/com/redhat/et/libguestfs/LV.java" in
7799   generate_java_struct "LV" lv_cols;
7800   close ();
7801
7802   let close = output_to "java/com/redhat/et/libguestfs/Stat.java" in
7803   generate_java_struct "Stat" stat_cols;
7804   close ();
7805
7806   let close = output_to "java/com/redhat/et/libguestfs/StatVFS.java" in
7807   generate_java_struct "StatVFS" statvfs_cols;
7808   close ();
7809
7810   let close = output_to "java/com_redhat_et_libguestfs_GuestFS.c" in
7811   generate_java_c ();
7812   close ();
7813
7814   let close = output_to "java/Bindtests.java" in
7815   generate_java_bindtests ();
7816   close ();
7817
7818   let close = output_to "haskell/Guestfs.hs" in
7819   generate_haskell_hs ();
7820   close ();
7821
7822   let close = output_to "haskell/bindtests.hs" in
7823   generate_haskell_bindtests ();
7824   close ();