3 * Copyright (C) 2009 Red Hat Inc.
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.
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.
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
20 (* This script generates a large amount of code and documentation for
21 * all the daemon actions.
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.
27 * After editing this file, run it (./src/generator.ml) to regenerate
28 * all the output files.
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]
40 type style = ret * args
42 (* "RErr" as a return value means an int used as a simple error
43 * indication, ie. 0 or -1.
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).
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).
56 (* "RBool" is a bool return value which can be true/false or
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.
65 | RConstString of string
66 (* "RString" and "RStringList" are caller-frees. *)
68 | RStringList of string
69 (* Some limited tuples are possible: *)
70 | RIntBool of string * string
71 (* LVM PVs, VGs and LVs. *)
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.
85 | RHashtable of string
87 and args = argt list (* Function parameters, guestfs handle is implicit. *)
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.
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.
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 *)
120 let protocol_limit_warning =
121 "Because of the message protocol, there is a transfer limit
122 of somewhere between 2MB and 4MB. To transfer large files you should use
125 let danger_will_robinson =
126 "B<This command is dangerous. Without careful use you
127 can easily destroy all your data>."
129 (* You can supply zero or as many tests as you want per API call.
131 * Note that the test environment has 3 block devices, of size 500MB,
132 * 50MB and 10MB (respectively /dev/sda, /dev/sdb, /dev/sdc).
133 * Note for partitioning purposes, the 500MB device has 63 cylinders.
135 * To be able to run the tests in a reasonable amount of time,
136 * the virtual machine and block devices are reused between tests.
137 * So don't try testing kill_subprocess :-x
139 * Between each test we umount-all and lvm-remove-all (except InitNone).
141 * Don't assume anything about the previous contents of the block
142 * devices. Use 'Init*' to create some initial scenarios.
144 type tests = (test_init * test) list
146 (* Run the command sequence and just expect nothing to fail. *)
148 (* Run the command sequence and expect the output of the final
149 * command to be the string.
151 | TestOutput of seq * string
152 (* Run the command sequence and expect the output of the final
153 * command to be the list of strings.
155 | TestOutputList of seq * string list
156 (* Run the command sequence and expect the output of the final
157 * command to be the integer.
159 | TestOutputInt of seq * int
160 (* Run the command sequence and expect the output of the final
161 * command to be a true value (!= 0 or != NULL).
163 | TestOutputTrue of seq
164 (* Run the command sequence and expect the output of the final
165 * command to be a false value (== 0 or == NULL, but not an error).
167 | TestOutputFalse of seq
168 (* Run the command sequence and expect the output of the final
169 * command to be a list of the given length (but don't care about
172 | TestOutputLength of seq * int
173 (* Run the command sequence and expect the output of the final
174 * command to be a structure.
176 | TestOutputStruct of seq * test_field_compare list
177 (* Run the command sequence and expect the final command (only)
180 | TestLastFail of seq
182 and test_field_compare =
183 | CompareWithInt of string * int
184 | CompareWithString of string * string
185 | CompareFieldsIntEq of string * string
186 | CompareFieldsStrEq of string * string
188 (* Some initial scenarios for testing. *)
190 (* Do nothing, block devices could contain random stuff including
191 * LVM PVs, and some filesystems might be mounted. This is usually
195 (* Block devices are empty and no filesystems are mounted. *)
197 (* /dev/sda contains a single partition /dev/sda1, which is formatted
198 * as ext2, empty [except for lost+found] and mounted on /.
199 * /dev/sdb and /dev/sdc may have random content.
204 * /dev/sda1 (is a PV):
205 * /dev/VG/LV (size 8MB):
206 * formatted as ext2, empty [except for lost+found], mounted on /
207 * /dev/sdb and /dev/sdc may have random content.
211 (* Sequence of commands for testing. *)
213 and cmd = string list
215 (* Note about long descriptions: When referring to another
216 * action, use the format C<guestfs_other> (ie. the full name of
217 * the C function). This will be replaced as appropriate in other
220 * Apart from that, long descriptions are just perldoc paragraphs.
223 let non_daemon_functions = [
224 ("launch", (RErr, []), -1, [FishAlias "run"; FishAction "launch"],
226 "launch the qemu subprocess",
228 Internally libguestfs is implemented by running a virtual machine
231 You should call this after configuring the handle
232 (eg. adding drives) but before performing any actions.");
234 ("wait_ready", (RErr, []), -1, [NotInFish],
236 "wait until the qemu subprocess launches",
238 Internally libguestfs is implemented by running a virtual machine
241 You should call this after C<guestfs_launch> to wait for the launch
244 ("kill_subprocess", (RErr, []), -1, [],
246 "kill the qemu subprocess",
248 This kills the qemu subprocess. You should never need to call this.");
250 ("add_drive", (RErr, [String "filename"]), -1, [FishAlias "add"],
252 "add an image to examine or modify",
254 This function adds a virtual machine disk image C<filename> to the
255 guest. The first time you call this function, the disk appears as IDE
256 disk 0 (C</dev/sda>) in the guest, the second time as C</dev/sdb>, and
259 You don't necessarily need to be root when using libguestfs. However
260 you obviously do need sufficient permissions to access the filename
261 for whatever operations you want to perform (ie. read access if you
262 just want to read the image or write access if you want to modify the
265 This is equivalent to the qemu parameter C<-drive file=filename>.");
267 ("add_cdrom", (RErr, [String "filename"]), -1, [FishAlias "cdrom"],
269 "add a CD-ROM disk image to examine",
271 This function adds a virtual CD-ROM disk image to the guest.
273 This is equivalent to the qemu parameter C<-cdrom filename>.");
275 ("config", (RErr, [String "qemuparam"; OptString "qemuvalue"]), -1, [],
277 "add qemu parameters",
279 This can be used to add arbitrary qemu command line parameters
280 of the form C<-param value>. Actually it's not quite arbitrary - we
281 prevent you from setting some parameters which would interfere with
282 parameters that we use.
284 The first character of C<param> string must be a C<-> (dash).
286 C<value> can be NULL.");
288 ("set_qemu", (RErr, [String "qemu"]), -1, [FishAlias "qemu"],
290 "set the qemu binary",
292 Set the qemu binary that we will use.
294 The default is chosen when the library was compiled by the
297 You can also override this by setting the C<LIBGUESTFS_QEMU>
298 environment variable.
300 The string C<qemu> is stashed in the libguestfs handle, so the caller
301 must make sure it remains valid for the lifetime of the handle.
303 Setting C<qemu> to C<NULL> restores the default qemu binary.");
305 ("get_qemu", (RConstString "qemu", []), -1, [],
307 "get the qemu binary",
309 Return the current qemu binary.
311 This is always non-NULL. If it wasn't set already, then this will
312 return the default qemu binary name.");
314 ("set_path", (RErr, [String "path"]), -1, [FishAlias "path"],
316 "set the search path",
318 Set the path that libguestfs searches for kernel and initrd.img.
320 The default is C<$libdir/guestfs> unless overridden by setting
321 C<LIBGUESTFS_PATH> environment variable.
323 The string C<path> is stashed in the libguestfs handle, so the caller
324 must make sure it remains valid for the lifetime of the handle.
326 Setting C<path> to C<NULL> restores the default path.");
328 ("get_path", (RConstString "path", []), -1, [],
330 "get the search path",
332 Return the current search path.
334 This is always non-NULL. If it wasn't set already, then this will
335 return the default path.");
337 ("set_autosync", (RErr, [Bool "autosync"]), -1, [FishAlias "autosync"],
341 If C<autosync> is true, this enables autosync. Libguestfs will make a
342 best effort attempt to run C<guestfs_umount_all> followed by
343 C<guestfs_sync> when the handle is closed
344 (also if the program exits without closing handles).
346 This is disabled by default (except in guestfish where it is
347 enabled by default).");
349 ("get_autosync", (RBool "autosync", []), -1, [],
353 Get the autosync flag.");
355 ("set_verbose", (RErr, [Bool "verbose"]), -1, [FishAlias "verbose"],
359 If C<verbose> is true, this turns on verbose messages (to C<stderr>).
361 Verbose messages are disabled unless the environment variable
362 C<LIBGUESTFS_DEBUG> is defined and set to C<1>.");
364 ("get_verbose", (RBool "verbose", []), -1, [],
368 This returns the verbose messages flag.");
370 ("is_ready", (RBool "ready", []), -1, [],
372 "is ready to accept commands",
374 This returns true iff this handle is ready to accept commands
375 (in the C<READY> state).
377 For more information on states, see L<guestfs(3)>.");
379 ("is_config", (RBool "config", []), -1, [],
381 "is in configuration state",
383 This returns true iff this handle is being configured
384 (in the C<CONFIG> state).
386 For more information on states, see L<guestfs(3)>.");
388 ("is_launching", (RBool "launching", []), -1, [],
390 "is launching subprocess",
392 This returns true iff this handle is launching the subprocess
393 (in the C<LAUNCHING> state).
395 For more information on states, see L<guestfs(3)>.");
397 ("is_busy", (RBool "busy", []), -1, [],
399 "is busy processing a command",
401 This returns true iff this handle is busy processing a command
402 (in the C<BUSY> state).
404 For more information on states, see L<guestfs(3)>.");
406 ("get_state", (RInt "state", []), -1, [],
408 "get the current state",
410 This returns the current state as an opaque integer. This is
411 only useful for printing debug and internal error messages.
413 For more information on states, see L<guestfs(3)>.");
415 ("set_busy", (RErr, []), -1, [NotInFish],
419 This sets the state to C<BUSY>. This is only used when implementing
420 actions using the low-level API.
422 For more information on states, see L<guestfs(3)>.");
424 ("set_ready", (RErr, []), -1, [NotInFish],
426 "set state to ready",
428 This sets the state to C<READY>. This is only used when implementing
429 actions using the low-level API.
431 For more information on states, see L<guestfs(3)>.");
435 let daemon_functions = [
436 ("mount", (RErr, [String "device"; String "mountpoint"]), 1, [],
437 [InitEmpty, TestOutput (
438 [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
439 ["mkfs"; "ext2"; "/dev/sda1"];
440 ["mount"; "/dev/sda1"; "/"];
441 ["write_file"; "/new"; "new file contents"; "0"];
442 ["cat"; "/new"]], "new file contents")],
443 "mount a guest disk at a position in the filesystem",
445 Mount a guest disk at a position in the filesystem. Block devices
446 are named C</dev/sda>, C</dev/sdb> and so on, as they were added to
447 the guest. If those block devices contain partitions, they will have
448 the usual names (eg. C</dev/sda1>). Also LVM C</dev/VG/LV>-style
451 The rules are the same as for L<mount(2)>: A filesystem must
452 first be mounted on C</> before others can be mounted. Other
453 filesystems can only be mounted on directories which already
456 The mounted filesystem is writable, if we have sufficient permissions
457 on the underlying device.
459 The filesystem options C<sync> and C<noatime> are set with this
460 call, in order to improve reliability.");
462 ("sync", (RErr, []), 2, [],
463 [ InitEmpty, TestRun [["sync"]]],
464 "sync disks, writes are flushed through to the disk image",
466 This syncs the disk, so that any writes are flushed through to the
467 underlying disk image.
469 You should always call this if you have modified a disk image, before
470 closing the handle.");
472 ("touch", (RErr, [String "path"]), 3, [],
473 [InitBasicFS, TestOutputTrue (
475 ["exists"; "/new"]])],
476 "update file timestamps or create a new file",
478 Touch acts like the L<touch(1)> command. It can be used to
479 update the timestamps on a file, or, if the file does not exist,
480 to create a new zero-length file.");
482 ("cat", (RString "content", [String "path"]), 4, [ProtocolLimitWarning],
483 [InitBasicFS, TestOutput (
484 [["write_file"; "/new"; "new file contents"; "0"];
485 ["cat"; "/new"]], "new file contents")],
486 "list the contents of a file",
488 Return the contents of the file named C<path>.
490 Note that this function cannot correctly handle binary files
491 (specifically, files containing C<\\0> character which is treated
492 as end of string). For those you need to use the C<guestfs_download>
493 function which has a more complex interface.");
495 ("ll", (RString "listing", [String "directory"]), 5, [],
496 [], (* XXX Tricky to test because it depends on the exact format
497 * of the 'ls -l' command, which changes between F10 and F11.
499 "list the files in a directory (long format)",
501 List the files in C<directory> (relative to the root directory,
502 there is no cwd) in the format of 'ls -la'.
504 This command is mostly useful for interactive sessions. It
505 is I<not> intended that you try to parse the output string.");
507 ("ls", (RStringList "listing", [String "directory"]), 6, [],
508 [InitBasicFS, TestOutputList (
511 ["touch"; "/newest"];
512 ["ls"; "/"]], ["lost+found"; "new"; "newer"; "newest"])],
513 "list the files in a directory",
515 List the files in C<directory> (relative to the root directory,
516 there is no cwd). The '.' and '..' entries are not returned, but
517 hidden files are shown.
519 This command is mostly useful for interactive sessions. Programs
520 should probably use C<guestfs_readdir> instead.");
522 ("list_devices", (RStringList "devices", []), 7, [],
523 [InitEmpty, TestOutputList (
524 [["list_devices"]], ["/dev/sda"; "/dev/sdb"; "/dev/sdc"])],
525 "list the block devices",
527 List all the block devices.
529 The full block device names are returned, eg. C</dev/sda>");
531 ("list_partitions", (RStringList "partitions", []), 8, [],
532 [InitBasicFS, TestOutputList (
533 [["list_partitions"]], ["/dev/sda1"]);
534 InitEmpty, TestOutputList (
535 [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
536 ["list_partitions"]], ["/dev/sda1"; "/dev/sda2"; "/dev/sda3"])],
537 "list the partitions",
539 List all the partitions detected on all block devices.
541 The full partition device names are returned, eg. C</dev/sda1>
543 This does not return logical volumes. For that you will need to
544 call C<guestfs_lvs>.");
546 ("pvs", (RStringList "physvols", []), 9, [],
547 [InitBasicFSonLVM, TestOutputList (
548 [["pvs"]], ["/dev/sda1"]);
549 InitEmpty, TestOutputList (
550 [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
551 ["pvcreate"; "/dev/sda1"];
552 ["pvcreate"; "/dev/sda2"];
553 ["pvcreate"; "/dev/sda3"];
554 ["pvs"]], ["/dev/sda1"; "/dev/sda2"; "/dev/sda3"])],
555 "list the LVM physical volumes (PVs)",
557 List all the physical volumes detected. This is the equivalent
558 of the L<pvs(8)> command.
560 This returns a list of just the device names that contain
561 PVs (eg. C</dev/sda2>).
563 See also C<guestfs_pvs_full>.");
565 ("vgs", (RStringList "volgroups", []), 10, [],
566 [InitBasicFSonLVM, TestOutputList (
568 InitEmpty, TestOutputList (
569 [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
570 ["pvcreate"; "/dev/sda1"];
571 ["pvcreate"; "/dev/sda2"];
572 ["pvcreate"; "/dev/sda3"];
573 ["vgcreate"; "VG1"; "/dev/sda1 /dev/sda2"];
574 ["vgcreate"; "VG2"; "/dev/sda3"];
575 ["vgs"]], ["VG1"; "VG2"])],
576 "list the LVM volume groups (VGs)",
578 List all the volumes groups detected. This is the equivalent
579 of the L<vgs(8)> command.
581 This returns a list of just the volume group names that were
582 detected (eg. C<VolGroup00>).
584 See also C<guestfs_vgs_full>.");
586 ("lvs", (RStringList "logvols", []), 11, [],
587 [InitBasicFSonLVM, TestOutputList (
588 [["lvs"]], ["/dev/VG/LV"]);
589 InitEmpty, TestOutputList (
590 [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
591 ["pvcreate"; "/dev/sda1"];
592 ["pvcreate"; "/dev/sda2"];
593 ["pvcreate"; "/dev/sda3"];
594 ["vgcreate"; "VG1"; "/dev/sda1 /dev/sda2"];
595 ["vgcreate"; "VG2"; "/dev/sda3"];
596 ["lvcreate"; "LV1"; "VG1"; "50"];
597 ["lvcreate"; "LV2"; "VG1"; "50"];
598 ["lvcreate"; "LV3"; "VG2"; "50"];
599 ["lvs"]], ["/dev/VG1/LV1"; "/dev/VG1/LV2"; "/dev/VG2/LV3"])],
600 "list the LVM logical volumes (LVs)",
602 List all the logical volumes detected. This is the equivalent
603 of the L<lvs(8)> command.
605 This returns a list of the logical volume device names
606 (eg. C</dev/VolGroup00/LogVol00>).
608 See also C<guestfs_lvs_full>.");
610 ("pvs_full", (RPVList "physvols", []), 12, [],
611 [], (* XXX how to test? *)
612 "list the LVM physical volumes (PVs)",
614 List all the physical volumes detected. This is the equivalent
615 of the L<pvs(8)> command. The \"full\" version includes all fields.");
617 ("vgs_full", (RVGList "volgroups", []), 13, [],
618 [], (* XXX how to test? *)
619 "list the LVM volume groups (VGs)",
621 List all the volumes groups detected. This is the equivalent
622 of the L<vgs(8)> command. The \"full\" version includes all fields.");
624 ("lvs_full", (RLVList "logvols", []), 14, [],
625 [], (* XXX how to test? *)
626 "list the LVM logical volumes (LVs)",
628 List all the logical volumes detected. This is the equivalent
629 of the L<lvs(8)> command. The \"full\" version includes all fields.");
631 ("read_lines", (RStringList "lines", [String "path"]), 15, [],
632 [InitBasicFS, TestOutputList (
633 [["write_file"; "/new"; "line1\r\nline2\nline3"; "0"];
634 ["read_lines"; "/new"]], ["line1"; "line2"; "line3"]);
635 InitBasicFS, TestOutputList (
636 [["write_file"; "/new"; ""; "0"];
637 ["read_lines"; "/new"]], [])],
638 "read file as lines",
640 Return the contents of the file named C<path>.
642 The file contents are returned as a list of lines. Trailing
643 C<LF> and C<CRLF> character sequences are I<not> returned.
645 Note that this function cannot correctly handle binary files
646 (specifically, files containing C<\\0> character which is treated
647 as end of line). For those you need to use the C<guestfs_read_file>
648 function which has a more complex interface.");
650 ("aug_init", (RErr, [String "root"; Int "flags"]), 16, [],
651 [], (* XXX Augeas code needs tests. *)
652 "create a new Augeas handle",
654 Create a new Augeas handle for editing configuration files.
655 If there was any previous Augeas handle associated with this
656 guestfs session, then it is closed.
658 You must call this before using any other C<guestfs_aug_*>
661 C<root> is the filesystem root. C<root> must not be NULL,
664 The flags are the same as the flags defined in
665 E<lt>augeas.hE<gt>, the logical I<or> of the following
670 =item C<AUG_SAVE_BACKUP> = 1
672 Keep the original file with a C<.augsave> extension.
674 =item C<AUG_SAVE_NEWFILE> = 2
676 Save changes into a file with extension C<.augnew>, and
677 do not overwrite original. Overrides C<AUG_SAVE_BACKUP>.
679 =item C<AUG_TYPE_CHECK> = 4
681 Typecheck lenses (can be expensive).
683 =item C<AUG_NO_STDINC> = 8
685 Do not use standard load path for modules.
687 =item C<AUG_SAVE_NOOP> = 16
689 Make save a no-op, just record what would have been changed.
691 =item C<AUG_NO_LOAD> = 32
693 Do not load the tree in C<guestfs_aug_init>.
697 To close the handle, you can call C<guestfs_aug_close>.
699 To find out more about Augeas, see L<http://augeas.net/>.");
701 ("aug_close", (RErr, []), 26, [],
702 [], (* XXX Augeas code needs tests. *)
703 "close the current Augeas handle",
705 Close the current Augeas handle and free up any resources
706 used by it. After calling this, you have to call
707 C<guestfs_aug_init> again before you can use any other
710 ("aug_defvar", (RInt "nrnodes", [String "name"; OptString "expr"]), 17, [],
711 [], (* XXX Augeas code needs tests. *)
712 "define an Augeas variable",
714 Defines an Augeas variable C<name> whose value is the result
715 of evaluating C<expr>. If C<expr> is NULL, then C<name> is
718 On success this returns the number of nodes in C<expr>, or
719 C<0> if C<expr> evaluates to something which is not a nodeset.");
721 ("aug_defnode", (RIntBool ("nrnodes", "created"), [String "name"; String "expr"; String "val"]), 18, [],
722 [], (* XXX Augeas code needs tests. *)
723 "define an Augeas node",
725 Defines a variable C<name> whose value is the result of
728 If C<expr> evaluates to an empty nodeset, a node is created,
729 equivalent to calling C<guestfs_aug_set> C<expr>, C<value>.
730 C<name> will be the nodeset containing that single node.
732 On success this returns a pair containing the
733 number of nodes in the nodeset, and a boolean flag
734 if a node was created.");
736 ("aug_get", (RString "val", [String "path"]), 19, [],
737 [], (* XXX Augeas code needs tests. *)
738 "look up the value of an Augeas path",
740 Look up the value associated with C<path>. If C<path>
741 matches exactly one node, the C<value> is returned.");
743 ("aug_set", (RErr, [String "path"; String "val"]), 20, [],
744 [], (* XXX Augeas code needs tests. *)
745 "set Augeas path to value",
747 Set the value associated with C<path> to C<value>.");
749 ("aug_insert", (RErr, [String "path"; String "label"; Bool "before"]), 21, [],
750 [], (* XXX Augeas code needs tests. *)
751 "insert a sibling Augeas node",
753 Create a new sibling C<label> for C<path>, inserting it into
754 the tree before or after C<path> (depending on the boolean
757 C<path> must match exactly one existing node in the tree, and
758 C<label> must be a label, ie. not contain C</>, C<*> or end
759 with a bracketed index C<[N]>.");
761 ("aug_rm", (RInt "nrnodes", [String "path"]), 22, [],
762 [], (* XXX Augeas code needs tests. *)
763 "remove an Augeas path",
765 Remove C<path> and all of its children.
767 On success this returns the number of entries which were removed.");
769 ("aug_mv", (RErr, [String "src"; String "dest"]), 23, [],
770 [], (* XXX Augeas code needs tests. *)
773 Move the node C<src> to C<dest>. C<src> must match exactly
774 one node. C<dest> is overwritten if it exists.");
776 ("aug_match", (RStringList "matches", [String "path"]), 24, [],
777 [], (* XXX Augeas code needs tests. *)
778 "return Augeas nodes which match path",
780 Returns a list of paths which match the path expression C<path>.
781 The returned paths are sufficiently qualified so that they match
782 exactly one node in the current tree.");
784 ("aug_save", (RErr, []), 25, [],
785 [], (* XXX Augeas code needs tests. *)
786 "write all pending Augeas changes to disk",
788 This writes all pending changes to disk.
790 The flags which were passed to C<guestfs_aug_init> affect exactly
791 how files are saved.");
793 ("aug_load", (RErr, []), 27, [],
794 [], (* XXX Augeas code needs tests. *)
795 "load files into the tree",
797 Load files into the tree.
799 See C<aug_load> in the Augeas documentation for the full gory
802 ("aug_ls", (RStringList "matches", [String "path"]), 28, [],
803 [], (* XXX Augeas code needs tests. *)
804 "list Augeas nodes under a path",
806 This is just a shortcut for listing C<guestfs_aug_match>
807 C<path/*> and sorting the resulting nodes into alphabetical order.");
809 ("rm", (RErr, [String "path"]), 29, [],
810 [InitBasicFS, TestRun
813 InitBasicFS, TestLastFail
815 InitBasicFS, TestLastFail
820 Remove the single file C<path>.");
822 ("rmdir", (RErr, [String "path"]), 30, [],
823 [InitBasicFS, TestRun
826 InitBasicFS, TestLastFail
828 InitBasicFS, TestLastFail
831 "remove a directory",
833 Remove the single directory C<path>.");
835 ("rm_rf", (RErr, [String "path"]), 31, [],
836 [InitBasicFS, TestOutputFalse
838 ["mkdir"; "/new/foo"];
839 ["touch"; "/new/foo/bar"];
841 ["exists"; "/new"]]],
842 "remove a file or directory recursively",
844 Remove the file or directory C<path>, recursively removing the
845 contents if its a directory. This is like the C<rm -rf> shell
848 ("mkdir", (RErr, [String "path"]), 32, [],
849 [InitBasicFS, TestOutputTrue
852 InitBasicFS, TestLastFail
853 [["mkdir"; "/new/foo/bar"]]],
854 "create a directory",
856 Create a directory named C<path>.");
858 ("mkdir_p", (RErr, [String "path"]), 33, [],
859 [InitBasicFS, TestOutputTrue
860 [["mkdir_p"; "/new/foo/bar"];
861 ["is_dir"; "/new/foo/bar"]];
862 InitBasicFS, TestOutputTrue
863 [["mkdir_p"; "/new/foo/bar"];
864 ["is_dir"; "/new/foo"]];
865 InitBasicFS, TestOutputTrue
866 [["mkdir_p"; "/new/foo/bar"];
867 ["is_dir"; "/new"]]],
868 "create a directory and parents",
870 Create a directory named C<path>, creating any parent directories
871 as necessary. This is like the C<mkdir -p> shell command.");
873 ("chmod", (RErr, [Int "mode"; String "path"]), 34, [],
874 [], (* XXX Need stat command to test *)
877 Change the mode (permissions) of C<path> to C<mode>. Only
878 numeric modes are supported.");
880 ("chown", (RErr, [Int "owner"; Int "group"; String "path"]), 35, [],
881 [], (* XXX Need stat command to test *)
882 "change file owner and group",
884 Change the file owner to C<owner> and group to C<group>.
886 Only numeric uid and gid are supported. If you want to use
887 names, you will need to locate and parse the password file
888 yourself (Augeas support makes this relatively easy).");
890 ("exists", (RBool "existsflag", [String "path"]), 36, [],
891 [InitBasicFS, TestOutputTrue (
893 ["exists"; "/new"]]);
894 InitBasicFS, TestOutputTrue (
896 ["exists"; "/new"]])],
897 "test if file or directory exists",
899 This returns C<true> if and only if there is a file, directory
900 (or anything) with the given C<path> name.
902 See also C<guestfs_is_file>, C<guestfs_is_dir>, C<guestfs_stat>.");
904 ("is_file", (RBool "fileflag", [String "path"]), 37, [],
905 [InitBasicFS, TestOutputTrue (
907 ["is_file"; "/new"]]);
908 InitBasicFS, TestOutputFalse (
910 ["is_file"; "/new"]])],
911 "test if file exists",
913 This returns C<true> if and only if there is a file
914 with the given C<path> name. Note that it returns false for
915 other objects like directories.
917 See also C<guestfs_stat>.");
919 ("is_dir", (RBool "dirflag", [String "path"]), 38, [],
920 [InitBasicFS, TestOutputFalse (
922 ["is_dir"; "/new"]]);
923 InitBasicFS, TestOutputTrue (
925 ["is_dir"; "/new"]])],
926 "test if file exists",
928 This returns C<true> if and only if there is a directory
929 with the given C<path> name. Note that it returns false for
930 other objects like files.
932 See also C<guestfs_stat>.");
934 ("pvcreate", (RErr, [String "device"]), 39, [],
935 [InitEmpty, TestOutputList (
936 [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
937 ["pvcreate"; "/dev/sda1"];
938 ["pvcreate"; "/dev/sda2"];
939 ["pvcreate"; "/dev/sda3"];
940 ["pvs"]], ["/dev/sda1"; "/dev/sda2"; "/dev/sda3"])],
941 "create an LVM physical volume",
943 This creates an LVM physical volume on the named C<device>,
944 where C<device> should usually be a partition name such
947 ("vgcreate", (RErr, [String "volgroup"; StringList "physvols"]), 40, [],
948 [InitEmpty, TestOutputList (
949 [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
950 ["pvcreate"; "/dev/sda1"];
951 ["pvcreate"; "/dev/sda2"];
952 ["pvcreate"; "/dev/sda3"];
953 ["vgcreate"; "VG1"; "/dev/sda1 /dev/sda2"];
954 ["vgcreate"; "VG2"; "/dev/sda3"];
955 ["vgs"]], ["VG1"; "VG2"])],
956 "create an LVM volume group",
958 This creates an LVM volume group called C<volgroup>
959 from the non-empty list of physical volumes C<physvols>.");
961 ("lvcreate", (RErr, [String "logvol"; String "volgroup"; Int "mbytes"]), 41, [],
962 [InitEmpty, TestOutputList (
963 [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
964 ["pvcreate"; "/dev/sda1"];
965 ["pvcreate"; "/dev/sda2"];
966 ["pvcreate"; "/dev/sda3"];
967 ["vgcreate"; "VG1"; "/dev/sda1 /dev/sda2"];
968 ["vgcreate"; "VG2"; "/dev/sda3"];
969 ["lvcreate"; "LV1"; "VG1"; "50"];
970 ["lvcreate"; "LV2"; "VG1"; "50"];
971 ["lvcreate"; "LV3"; "VG2"; "50"];
972 ["lvcreate"; "LV4"; "VG2"; "50"];
973 ["lvcreate"; "LV5"; "VG2"; "50"];
975 ["/dev/VG1/LV1"; "/dev/VG1/LV2";
976 "/dev/VG2/LV3"; "/dev/VG2/LV4"; "/dev/VG2/LV5"])],
977 "create an LVM volume group",
979 This creates an LVM volume group called C<logvol>
980 on the volume group C<volgroup>, with C<size> megabytes.");
982 ("mkfs", (RErr, [String "fstype"; String "device"]), 42, [],
983 [InitEmpty, TestOutput (
984 [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
985 ["mkfs"; "ext2"; "/dev/sda1"];
986 ["mount"; "/dev/sda1"; "/"];
987 ["write_file"; "/new"; "new file contents"; "0"];
988 ["cat"; "/new"]], "new file contents")],
991 This creates a filesystem on C<device> (usually a partition
992 of LVM logical volume). The filesystem type is C<fstype>, for
995 ("sfdisk", (RErr, [String "device";
996 Int "cyls"; Int "heads"; Int "sectors";
997 StringList "lines"]), 43, [DangerWillRobinson],
999 "create partitions on a block device",
1001 This is a direct interface to the L<sfdisk(8)> program for creating
1002 partitions on block devices.
1004 C<device> should be a block device, for example C</dev/sda>.
1006 C<cyls>, C<heads> and C<sectors> are the number of cylinders, heads
1007 and sectors on the device, which are passed directly to sfdisk as
1008 the I<-C>, I<-H> and I<-S> parameters. If you pass C<0> for any
1009 of these, then the corresponding parameter is omitted. Usually for
1010 'large' disks, you can just pass C<0> for these, but for small
1011 (floppy-sized) disks, sfdisk (or rather, the kernel) cannot work
1012 out the right geometry and you will need to tell it.
1014 C<lines> is a list of lines that we feed to C<sfdisk>. For more
1015 information refer to the L<sfdisk(8)> manpage.
1017 To create a single partition occupying the whole disk, you would
1018 pass C<lines> as a single element list, when the single element being
1019 the string C<,> (comma).");
1021 ("write_file", (RErr, [String "path"; String "content"; Int "size"]), 44, [ProtocolLimitWarning],
1022 [InitBasicFS, TestOutput (
1023 [["write_file"; "/new"; "new file contents"; "0"];
1024 ["cat"; "/new"]], "new file contents");
1025 InitBasicFS, TestOutput (
1026 [["write_file"; "/new"; "\nnew file contents\n"; "0"];
1027 ["cat"; "/new"]], "\nnew file contents\n");
1028 InitBasicFS, TestOutput (
1029 [["write_file"; "/new"; "\n\n"; "0"];
1030 ["cat"; "/new"]], "\n\n");
1031 InitBasicFS, TestOutput (
1032 [["write_file"; "/new"; ""; "0"];
1033 ["cat"; "/new"]], "");
1034 InitBasicFS, TestOutput (
1035 [["write_file"; "/new"; "\n\n\n"; "0"];
1036 ["cat"; "/new"]], "\n\n\n");
1037 InitBasicFS, TestOutput (
1038 [["write_file"; "/new"; "\n"; "0"];
1039 ["cat"; "/new"]], "\n")],
1042 This call creates a file called C<path>. The contents of the
1043 file is the string C<content> (which can contain any 8 bit data),
1044 with length C<size>.
1046 As a special case, if C<size> is C<0>
1047 then the length is calculated using C<strlen> (so in this case
1048 the content cannot contain embedded ASCII NULs).");
1050 ("umount", (RErr, [String "pathordevice"]), 45, [FishAlias "unmount"],
1051 [InitEmpty, TestOutputList (
1052 [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1053 ["mkfs"; "ext2"; "/dev/sda1"];
1054 ["mount"; "/dev/sda1"; "/"];
1055 ["mounts"]], ["/dev/sda1"]);
1056 InitEmpty, TestOutputList (
1057 [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
1058 ["mkfs"; "ext2"; "/dev/sda1"];
1059 ["mount"; "/dev/sda1"; "/"];
1062 "unmount a filesystem",
1064 This unmounts the given filesystem. The filesystem may be
1065 specified either by its mountpoint (path) or the device which
1066 contains the filesystem.");
1068 ("mounts", (RStringList "devices", []), 46, [],
1069 [InitBasicFS, TestOutputList (
1070 [["mounts"]], ["/dev/sda1"])],
1071 "show mounted filesystems",
1073 This returns the list of currently mounted filesystems. It returns
1074 the list of devices (eg. C</dev/sda1>, C</dev/VG/LV>).
1076 Some internal mounts are not shown.");
1078 ("umount_all", (RErr, []), 47, [FishAlias "unmount-all"],
1079 [InitBasicFS, TestOutputList (
1082 (* check that umount_all can unmount nested mounts correctly: *)
1083 InitEmpty, TestOutputList (
1084 [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
1085 ["mkfs"; "ext2"; "/dev/sda1"];
1086 ["mkfs"; "ext2"; "/dev/sda2"];
1087 ["mkfs"; "ext2"; "/dev/sda3"];
1088 ["mount"; "/dev/sda1"; "/"];
1090 ["mount"; "/dev/sda2"; "/mp1"];
1091 ["mkdir"; "/mp1/mp2"];
1092 ["mount"; "/dev/sda3"; "/mp1/mp2"];
1093 ["mkdir"; "/mp1/mp2/mp3"];
1096 "unmount all filesystems",
1098 This unmounts all mounted filesystems.
1100 Some internal mounts are not unmounted by this call.");
1102 ("lvm_remove_all", (RErr, []), 48, [DangerWillRobinson],
1104 "remove all LVM LVs, VGs and PVs",
1106 This command removes all LVM logical volumes, volume groups
1107 and physical volumes.");
1109 ("file", (RString "description", [String "path"]), 49, [],
1110 [InitBasicFS, TestOutput (
1112 ["file"; "/new"]], "empty");
1113 InitBasicFS, TestOutput (
1114 [["write_file"; "/new"; "some content\n"; "0"];
1115 ["file"; "/new"]], "ASCII text");
1116 InitBasicFS, TestLastFail (
1117 [["file"; "/nofile"]])],
1118 "determine file type",
1120 This call uses the standard L<file(1)> command to determine
1121 the type or contents of the file. This also works on devices,
1122 for example to find out whether a partition contains a filesystem.
1124 The exact command which runs is C<file -bsL path>. Note in
1125 particular that the filename is not prepended to the output
1126 (the C<-b> option).");
1128 ("command", (RString "output", [StringList "arguments"]), 50, [],
1129 [], (* XXX how to test? *)
1130 "run a command from the guest filesystem",
1132 This call runs a command from the guest filesystem. The
1133 filesystem must be mounted, and must contain a compatible
1134 operating system (ie. something Linux, with the same
1135 or compatible processor architecture).
1137 The single parameter is an argv-style list of arguments.
1138 The first element is the name of the program to run.
1139 Subsequent elements are parameters. The list must be
1140 non-empty (ie. must contain a program name).
1142 The C<$PATH> environment variable will contain at least
1143 C</usr/bin> and C</bin>. If you require a program from
1144 another location, you should provide the full path in the
1147 Shared libraries and data files required by the program
1148 must be available on filesystems which are mounted in the
1149 correct places. It is the caller's responsibility to ensure
1150 all filesystems that are needed are mounted at the right
1153 ("command_lines", (RStringList "lines", [StringList "arguments"]), 51, [],
1154 [], (* XXX how to test? *)
1155 "run a command, returning lines",
1157 This is the same as C<guestfs_command>, but splits the
1158 result into a list of lines.");
1160 ("stat", (RStat "statbuf", [String "path"]), 52, [],
1161 [InitBasicFS, TestOutputStruct (
1163 ["stat"; "/new"]], [CompareWithInt ("size", 0)])],
1164 "get file information",
1166 Returns file information for the given C<path>.
1168 This is the same as the C<stat(2)> system call.");
1170 ("lstat", (RStat "statbuf", [String "path"]), 53, [],
1171 [InitBasicFS, TestOutputStruct (
1173 ["lstat"; "/new"]], [CompareWithInt ("size", 0)])],
1174 "get file information for a symbolic link",
1176 Returns file information for the given C<path>.
1178 This is the same as C<guestfs_stat> except that if C<path>
1179 is a symbolic link, then the link is stat-ed, not the file it
1182 This is the same as the C<lstat(2)> system call.");
1184 ("statvfs", (RStatVFS "statbuf", [String "path"]), 54, [],
1185 [InitBasicFS, TestOutputStruct (
1186 [["statvfs"; "/"]], [CompareWithInt ("bfree", 487702);
1187 CompareWithInt ("blocks", 490020);
1188 CompareWithInt ("bsize", 1024)])],
1189 "get file system statistics",
1191 Returns file system statistics for any mounted file system.
1192 C<path> should be a file or directory in the mounted file system
1193 (typically it is the mount point itself, but it doesn't need to be).
1195 This is the same as the C<statvfs(2)> system call.");
1197 ("tune2fs_l", (RHashtable "superblock", [String "device"]), 55, [],
1199 "get ext2/ext3/ext4 superblock details",
1201 This returns the contents of the ext2, ext3 or ext4 filesystem
1202 superblock on C<device>.
1204 It is the same as running C<tune2fs -l device>. See L<tune2fs(8)>
1205 manpage for more details. The list of fields returned isn't
1206 clearly defined, and depends on both the version of C<tune2fs>
1207 that libguestfs was built against, and the filesystem itself.");
1209 ("blockdev_setro", (RErr, [String "device"]), 56, [],
1210 [InitEmpty, TestOutputTrue (
1211 [["blockdev_setro"; "/dev/sda"];
1212 ["blockdev_getro"; "/dev/sda"]])],
1213 "set block device to read-only",
1215 Sets the block device named C<device> to read-only.
1217 This uses the L<blockdev(8)> command.");
1219 ("blockdev_setrw", (RErr, [String "device"]), 57, [],
1220 [InitEmpty, TestOutputFalse (
1221 [["blockdev_setrw"; "/dev/sda"];
1222 ["blockdev_getro"; "/dev/sda"]])],
1223 "set block device to read-write",
1225 Sets the block device named C<device> to read-write.
1227 This uses the L<blockdev(8)> command.");
1229 ("blockdev_getro", (RBool "ro", [String "device"]), 58, [],
1230 [InitEmpty, TestOutputTrue (
1231 [["blockdev_setro"; "/dev/sda"];
1232 ["blockdev_getro"; "/dev/sda"]])],
1233 "is block device set to read-only",
1235 Returns a boolean indicating if the block device is read-only
1236 (true if read-only, false if not).
1238 This uses the L<blockdev(8)> command.");
1240 ("blockdev_getss", (RInt "sectorsize", [String "device"]), 59, [],
1241 [InitEmpty, TestOutputInt (
1242 [["blockdev_getss"; "/dev/sda"]], 512)],
1243 "get sectorsize of block device",
1245 This returns the size of sectors on a block device.
1246 Usually 512, but can be larger for modern devices.
1248 (Note, this is not the size in sectors, use C<guestfs_blockdev_getsz>
1251 This uses the L<blockdev(8)> command.");
1253 ("blockdev_getbsz", (RInt "blocksize", [String "device"]), 60, [],
1254 [InitEmpty, TestOutputInt (
1255 [["blockdev_getbsz"; "/dev/sda"]], 4096)],
1256 "get blocksize of block device",
1258 This returns the block size of a device.
1260 (Note this is different from both I<size in blocks> and
1261 I<filesystem block size>).
1263 This uses the L<blockdev(8)> command.");
1265 ("blockdev_setbsz", (RErr, [String "device"; Int "blocksize"]), 61, [],
1267 "set blocksize of block device",
1269 This sets the block size of a device.
1271 (Note this is different from both I<size in blocks> and
1272 I<filesystem block size>).
1274 This uses the L<blockdev(8)> command.");
1276 ("blockdev_getsz", (RInt64 "sizeinsectors", [String "device"]), 62, [],
1277 [InitEmpty, TestOutputInt (
1278 [["blockdev_getsz"; "/dev/sda"]], 1024000)],
1279 "get total size of device in 512-byte sectors",
1281 This returns the size of the device in units of 512-byte sectors
1282 (even if the sectorsize isn't 512 bytes ... weird).
1284 See also C<guestfs_blockdev_getss> for the real sector size of
1285 the device, and C<guestfs_blockdev_getsize64> for the more
1286 useful I<size in bytes>.
1288 This uses the L<blockdev(8)> command.");
1290 ("blockdev_getsize64", (RInt64 "sizeinbytes", [String "device"]), 63, [],
1291 [InitEmpty, TestOutputInt (
1292 [["blockdev_getsize64"; "/dev/sda"]], 524288000)],
1293 "get total size of device in bytes",
1295 This returns the size of the device in bytes.
1297 See also C<guestfs_blockdev_getsz>.
1299 This uses the L<blockdev(8)> command.");
1301 ("blockdev_flushbufs", (RErr, [String "device"]), 64, [],
1303 [["blockdev_flushbufs"; "/dev/sda"]]],
1304 "flush device buffers",
1306 This tells the kernel to flush internal buffers associated
1309 This uses the L<blockdev(8)> command.");
1311 ("blockdev_rereadpt", (RErr, [String "device"]), 65, [],
1313 [["blockdev_rereadpt"; "/dev/sda"]]],
1314 "reread partition table",
1316 Reread the partition table on C<device>.
1318 This uses the L<blockdev(8)> command.");
1320 ("upload", (RErr, [FileIn "filename"; String "remotefilename"]), 66, [],
1321 [InitBasicFS, TestOutput (
1322 (* Pick a file from cwd which isn't likely to change. *)
1323 [["upload"; "COPYING.LIB"; "/COPYING.LIB"];
1324 ["checksum"; "md5"; "/COPYING.LIB"]], "e3eda01d9815f8d24aae2dbd89b68b06")],
1325 "upload a file from the local machine",
1327 Upload local file C<filename> to C<remotefilename> on the
1330 C<filename> can also be a named pipe.
1332 See also C<guestfs_download>.");
1334 ("download", (RErr, [String "remotefilename"; FileOut "filename"]), 67, [],
1335 [InitBasicFS, TestOutput (
1336 (* Pick a file from cwd which isn't likely to change. *)
1337 [["upload"; "COPYING.LIB"; "/COPYING.LIB"];
1338 ["download"; "/COPYING.LIB"; "testdownload.tmp"];
1339 ["upload"; "testdownload.tmp"; "/upload"];
1340 ["checksum"; "md5"; "/upload"]], "e3eda01d9815f8d24aae2dbd89b68b06")],
1341 "download a file to the local machine",
1343 Download file C<remotefilename> and save it as C<filename>
1344 on the local machine.
1346 C<filename> can also be a named pipe.
1348 See also C<guestfs_upload>, C<guestfs_cat>.");
1350 ("checksum", (RString "checksum", [String "csumtype"; String "path"]), 68, [],
1351 [InitBasicFS, TestOutput (
1352 [["write_file"; "/new"; "test\n"; "0"];
1353 ["checksum"; "crc"; "/new"]], "935282863");
1354 InitBasicFS, TestLastFail (
1355 [["checksum"; "crc"; "/new"]]);
1356 InitBasicFS, TestOutput (
1357 [["write_file"; "/new"; "test\n"; "0"];
1358 ["checksum"; "md5"; "/new"]], "d8e8fca2dc0f896fd7cb4cb0031ba249");
1359 InitBasicFS, TestOutput (
1360 [["write_file"; "/new"; "test\n"; "0"];
1361 ["checksum"; "sha1"; "/new"]], "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83");
1362 InitBasicFS, TestOutput (
1363 [["write_file"; "/new"; "test\n"; "0"];
1364 ["checksum"; "sha224"; "/new"]], "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec");
1365 InitBasicFS, TestOutput (
1366 [["write_file"; "/new"; "test\n"; "0"];
1367 ["checksum"; "sha256"; "/new"]], "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2");
1368 InitBasicFS, TestOutput (
1369 [["write_file"; "/new"; "test\n"; "0"];
1370 ["checksum"; "sha384"; "/new"]], "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d");
1371 InitBasicFS, TestOutput (
1372 [["write_file"; "/new"; "test\n"; "0"];
1373 ["checksum"; "sha512"; "/new"]], "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123")],
1374 "compute MD5, SHAx or CRC checksum of file",
1376 This call computes the MD5, SHAx or CRC checksum of the
1379 The type of checksum to compute is given by the C<csumtype>
1380 parameter which must have one of the following values:
1386 Compute the cyclic redundancy check (CRC) specified by POSIX
1387 for the C<cksum> command.
1391 Compute the MD5 hash (using the C<md5sum> program).
1395 Compute the SHA1 hash (using the C<sha1sum> program).
1399 Compute the SHA224 hash (using the C<sha224sum> program).
1403 Compute the SHA256 hash (using the C<sha256sum> program).
1407 Compute the SHA384 hash (using the C<sha384sum> program).
1411 Compute the SHA512 hash (using the C<sha512sum> program).
1415 The checksum is returned as a printable string.");
1417 ("tar_in", (RErr, [FileIn "tarfile"; String "directory"]), 69, [],
1418 [InitBasicFS, TestOutput (
1419 [["tar_in"; "images/helloworld.tar"; "/"];
1420 ["cat"; "/hello"]], "hello\n")],
1421 "unpack tarfile to directory",
1423 This command uploads and unpacks local file C<tarfile> (an
1424 I<uncompressed> tar file) into C<directory>.
1426 To upload a compressed tarball, use C<guestfs_tgz_in>.");
1428 ("tar_out", (RErr, [String "directory"; FileOut "tarfile"]), 70, [],
1430 "pack directory into tarfile",
1432 This command packs the contents of C<directory> and downloads
1433 it to local file C<tarfile>.
1435 To download a compressed tarball, use C<guestfs_tgz_out>.");
1437 ("tgz_in", (RErr, [FileIn "tarball"; String "directory"]), 71, [],
1438 [InitBasicFS, TestOutput (
1439 [["tgz_in"; "images/helloworld.tar.gz"; "/"];
1440 ["cat"; "/hello"]], "hello\n")],
1441 "unpack compressed tarball to directory",
1443 This command uploads and unpacks local file C<tarball> (a
1444 I<gzip compressed> tar file) into C<directory>.
1446 To upload an uncompressed tarball, use C<guestfs_tar_in>.");
1448 ("tgz_out", (RErr, [String "directory"; FileOut "tarball"]), 72, [],
1450 "pack directory into compressed tarball",
1452 This command packs the contents of C<directory> and downloads
1453 it to local file C<tarball>.
1455 To download an uncompressed tarball, use C<guestfs_tar_out>.");
1457 ("mount_ro", (RErr, [String "device"; String "mountpoint"]), 73, [],
1458 [InitBasicFS, TestLastFail (
1460 ["mount_ro"; "/dev/sda1"; "/"];
1461 ["touch"; "/new"]]);
1462 InitBasicFS, TestOutput (
1463 [["write_file"; "/new"; "data"; "0"];
1465 ["mount_ro"; "/dev/sda1"; "/"];
1466 ["cat"; "/new"]], "data")],
1467 "mount a guest disk, read-only",
1469 This is the same as the C<guestfs_mount> command, but it
1470 mounts the filesystem with the read-only (I<-o ro>) flag.");
1472 ("mount_options", (RErr, [String "options"; String "device"; String "mountpoint"]), 74, [],
1474 "mount a guest disk with mount options",
1476 This is the same as the C<guestfs_mount> command, but it
1477 allows you to set the mount options as for the
1478 L<mount(8)> I<-o> flag.");
1480 ("mount_vfs", (RErr, [String "options"; String "vfstype"; String "device"; String "mountpoint"]), 75, [],
1482 "mount a guest disk with mount options and vfstype",
1484 This is the same as the C<guestfs_mount> command, but it
1485 allows you to set both the mount options and the vfstype
1486 as for the L<mount(8)> I<-o> and I<-t> flags.");
1488 ("debug", (RString "result", [String "subcmd"; StringList "extraargs"]), 76, [],
1490 "debugging and internals",
1492 The C<guestfs_debug> command exposes some internals of
1493 C<guestfsd> (the guestfs daemon) that runs inside the
1496 There is no comprehensive help for this command. You have
1497 to look at the file C<daemon/debug.c> in the libguestfs source
1498 to find out what you can do.");
1500 ("lvremove", (RErr, [String "device"]), 77, [],
1501 [InitEmpty, TestOutputList (
1502 [["pvcreate"; "/dev/sda"];
1503 ["vgcreate"; "VG"; "/dev/sda"];
1504 ["lvcreate"; "LV1"; "VG"; "50"];
1505 ["lvcreate"; "LV2"; "VG"; "50"];
1506 ["lvremove"; "/dev/VG/LV1"];
1507 ["lvs"]], ["/dev/VG/LV2"]);
1508 InitEmpty, TestOutputList (
1509 [["pvcreate"; "/dev/sda"];
1510 ["vgcreate"; "VG"; "/dev/sda"];
1511 ["lvcreate"; "LV1"; "VG"; "50"];
1512 ["lvcreate"; "LV2"; "VG"; "50"];
1513 ["lvremove"; "/dev/VG"];
1515 InitEmpty, TestOutputList (
1516 [["pvcreate"; "/dev/sda"];
1517 ["vgcreate"; "VG"; "/dev/sda"];
1518 ["lvcreate"; "LV1"; "VG"; "50"];
1519 ["lvcreate"; "LV2"; "VG"; "50"];
1520 ["lvremove"; "/dev/VG"];
1522 "remove an LVM logical volume",
1524 Remove an LVM logical volume C<device>, where C<device> is
1525 the path to the LV, such as C</dev/VG/LV>.
1527 You can also remove all LVs in a volume group by specifying
1528 the VG name, C</dev/VG>.");
1530 ("vgremove", (RErr, [String "vgname"]), 78, [],
1531 [InitEmpty, TestOutputList (
1532 [["pvcreate"; "/dev/sda"];
1533 ["vgcreate"; "VG"; "/dev/sda"];
1534 ["lvcreate"; "LV1"; "VG"; "50"];
1535 ["lvcreate"; "LV2"; "VG"; "50"];
1538 InitEmpty, TestOutputList (
1539 [["pvcreate"; "/dev/sda"];
1540 ["vgcreate"; "VG"; "/dev/sda"];
1541 ["lvcreate"; "LV1"; "VG"; "50"];
1542 ["lvcreate"; "LV2"; "VG"; "50"];
1545 "remove an LVM volume group",
1547 Remove an LVM volume group C<vgname>, (for example C<VG>).
1549 This also forcibly removes all logical volumes in the volume
1552 ("pvremove", (RErr, [String "device"]), 79, [],
1553 [InitEmpty, TestOutputList (
1554 [["pvcreate"; "/dev/sda"];
1555 ["vgcreate"; "VG"; "/dev/sda"];
1556 ["lvcreate"; "LV1"; "VG"; "50"];
1557 ["lvcreate"; "LV2"; "VG"; "50"];
1559 ["pvremove"; "/dev/sda"];
1561 InitEmpty, TestOutputList (
1562 [["pvcreate"; "/dev/sda"];
1563 ["vgcreate"; "VG"; "/dev/sda"];
1564 ["lvcreate"; "LV1"; "VG"; "50"];
1565 ["lvcreate"; "LV2"; "VG"; "50"];
1567 ["pvremove"; "/dev/sda"];
1569 InitEmpty, TestOutputList (
1570 [["pvcreate"; "/dev/sda"];
1571 ["vgcreate"; "VG"; "/dev/sda"];
1572 ["lvcreate"; "LV1"; "VG"; "50"];
1573 ["lvcreate"; "LV2"; "VG"; "50"];
1575 ["pvremove"; "/dev/sda"];
1577 "remove an LVM physical volume",
1579 This wipes a physical volume C<device> so that LVM will no longer
1582 The implementation uses the C<pvremove> command which refuses to
1583 wipe physical volumes that contain any volume groups, so you have
1584 to remove those first.");
1586 ("set_e2label", (RErr, [String "device"; String "label"]), 80, [],
1587 [InitBasicFS, TestOutput (
1588 [["set_e2label"; "/dev/sda1"; "testlabel"];
1589 ["get_e2label"; "/dev/sda1"]], "testlabel")],
1590 "set the ext2/3/4 filesystem label",
1592 This sets the ext2/3/4 filesystem label of the filesystem on
1593 C<device> to C<label>. Filesystem labels are limited to
1596 You can use either C<guestfs_tune2fs_l> or C<guestfs_get_e2label>
1597 to return the existing label on a filesystem.");
1599 ("get_e2label", (RString "label", [String "device"]), 81, [],
1601 "get the ext2/3/4 filesystem label",
1603 This returns the ext2/3/4 filesystem label of the filesystem on
1606 ("set_e2uuid", (RErr, [String "device"; String "uuid"]), 82, [],
1607 [InitBasicFS, TestOutput (
1608 [["set_e2uuid"; "/dev/sda1"; "a3a61220-882b-4f61-89f4-cf24dcc7297d"];
1609 ["get_e2uuid"; "/dev/sda1"]], "a3a61220-882b-4f61-89f4-cf24dcc7297d");
1610 InitBasicFS, TestOutput (
1611 [["set_e2uuid"; "/dev/sda1"; "clear"];
1612 ["get_e2uuid"; "/dev/sda1"]], "");
1613 (* We can't predict what UUIDs will be, so just check the commands run. *)
1614 InitBasicFS, TestRun (
1615 [["set_e2uuid"; "/dev/sda1"; "random"]]);
1616 InitBasicFS, TestRun (
1617 [["set_e2uuid"; "/dev/sda1"; "time"]])],
1618 "set the ext2/3/4 filesystem UUID",
1620 This sets the ext2/3/4 filesystem UUID of the filesystem on
1621 C<device> to C<uuid>. The format of the UUID and alternatives
1622 such as C<clear>, C<random> and C<time> are described in the
1623 L<tune2fs(8)> manpage.
1625 You can use either C<guestfs_tune2fs_l> or C<guestfs_get_e2uuid>
1626 to return the existing UUID of a filesystem.");
1628 ("get_e2uuid", (RString "uuid", [String "device"]), 83, [],
1630 "get the ext2/3/4 filesystem UUID",
1632 This returns the ext2/3/4 filesystem UUID of the filesystem on
1635 ("fsck", (RInt "status", [String "fstype"; String "device"]), 84, [],
1636 [InitBasicFS, TestOutputInt (
1637 [["umount"; "/dev/sda1"];
1638 ["fsck"; "ext2"; "/dev/sda1"]], 0);
1639 InitBasicFS, TestOutputInt (
1640 [["umount"; "/dev/sda1"];
1641 ["zero"; "/dev/sda1"];
1642 ["fsck"; "ext2"; "/dev/sda1"]], 8)],
1643 "run the filesystem checker",
1645 This runs the filesystem checker (fsck) on C<device> which
1646 should have filesystem type C<fstype>.
1648 The returned integer is the status. See L<fsck(8)> for the
1649 list of status codes from C<fsck>.
1657 Multiple status codes can be summed together.
1661 A non-zero return code can mean \"success\", for example if
1662 errors have been corrected on the filesystem.
1666 Checking or repairing NTFS volumes is not supported
1671 This command is entirely equivalent to running C<fsck -a -t fstype device>.");
1673 ("zero", (RErr, [String "device"]), 85, [],
1674 [InitBasicFS, TestOutput (
1675 [["umount"; "/dev/sda1"];
1676 ["zero"; "/dev/sda1"];
1677 ["file"; "/dev/sda1"]], "data")],
1678 "write zeroes to the device",
1680 This command writes zeroes over the first few blocks of C<device>.
1682 How many blocks are zeroed isn't specified (but it's I<not> enough
1683 to securely wipe the device). It should be sufficient to remove
1684 any partition tables, filesystem superblocks and so on.");
1689 let all_functions = non_daemon_functions @ daemon_functions
1691 (* In some places we want the functions to be displayed sorted
1692 * alphabetically, so this is useful:
1694 let all_functions_sorted =
1695 List.sort (fun (n1,_,_,_,_,_,_) (n2,_,_,_,_,_,_) ->
1696 compare n1 n2) all_functions
1698 (* Column names and types from LVM PVs/VGs/LVs. *)
1707 "pv_attr", `String (* XXX *);
1708 "pv_pe_count", `Int;
1709 "pv_pe_alloc_count", `Int;
1712 "pv_mda_count", `Int;
1713 "pv_mda_free", `Bytes;
1714 (* Not in Fedora 10:
1715 "pv_mda_size", `Bytes;
1722 "vg_attr", `String (* XXX *);
1725 "vg_sysid", `String;
1726 "vg_extent_size", `Bytes;
1727 "vg_extent_count", `Int;
1728 "vg_free_count", `Int;
1736 "vg_mda_count", `Int;
1737 "vg_mda_free", `Bytes;
1738 (* Not in Fedora 10:
1739 "vg_mda_size", `Bytes;
1745 "lv_attr", `String (* XXX *);
1748 "lv_kernel_major", `Int;
1749 "lv_kernel_minor", `Int;
1753 "snap_percent", `OptPercent;
1754 "copy_percent", `OptPercent;
1757 "mirror_log", `String;
1761 (* Column names and types from stat structures.
1762 * NB. Can't use things like 'st_atime' because glibc header files
1763 * define some of these as macros. Ugh.
1780 let statvfs_cols = [
1794 (* Useful functions.
1795 * Note we don't want to use any external OCaml libraries which
1796 * makes this a bit harder than it should be.
1798 let failwithf fs = ksprintf failwith fs
1800 let replace_char s c1 c2 =
1801 let s2 = String.copy s in
1802 let r = ref false in
1803 for i = 0 to String.length s2 - 1 do
1804 if String.unsafe_get s2 i = c1 then (
1805 String.unsafe_set s2 i c2;
1809 if not !r then s else s2
1813 (* || c = '\f' *) || c = '\n' || c = '\r' || c = '\t' (* || c = '\v' *)
1815 let triml ?(test = isspace) str =
1817 let n = ref (String.length str) in
1818 while !n > 0 && test str.[!i]; do
1823 else String.sub str !i !n
1825 let trimr ?(test = isspace) str =
1826 let n = ref (String.length str) in
1827 while !n > 0 && test str.[!n-1]; do
1830 if !n = String.length str then str
1831 else String.sub str 0 !n
1833 let trim ?(test = isspace) str =
1834 trimr ~test (triml ~test str)
1836 let rec find s sub =
1837 let len = String.length s in
1838 let sublen = String.length sub in
1840 if i <= len-sublen then (
1842 if j < sublen then (
1843 if s.[i+j] = sub.[j] then loop2 (j+1)
1849 if r = -1 then loop (i+1) else r
1855 let rec replace_str s s1 s2 =
1856 let len = String.length s in
1857 let sublen = String.length s1 in
1858 let i = find s s1 in
1861 let s' = String.sub s 0 i in
1862 let s'' = String.sub s (i+sublen) (len-i-sublen) in
1863 s' ^ s2 ^ replace_str s'' s1 s2
1866 let rec string_split sep str =
1867 let len = String.length str in
1868 let seplen = String.length sep in
1869 let i = find str sep in
1870 if i = -1 then [str]
1872 let s' = String.sub str 0 i in
1873 let s'' = String.sub str (i+seplen) (len-i-seplen) in
1874 s' :: string_split sep s''
1877 let files_equal n1 n2 =
1878 let cmd = sprintf "cmp -s %s %s" (Filename.quote n1) (Filename.quote n2) in
1879 match Sys.command cmd with
1882 | i -> failwithf "%s: failed with error code %d" cmd i
1884 let rec find_map f = function
1885 | [] -> raise Not_found
1889 | None -> find_map f xs
1892 let rec loop i = function
1894 | x :: xs -> f i x; loop (i+1) xs
1899 let rec loop i = function
1901 | x :: xs -> let r = f i x in r :: loop (i+1) xs
1905 let name_of_argt = function
1906 | String n | OptString n | StringList n | Bool n | Int n
1907 | FileIn n | FileOut n -> n
1909 let seq_of_test = function
1910 | TestRun s | TestOutput (s, _) | TestOutputList (s, _)
1911 | TestOutputInt (s, _) | TestOutputTrue s | TestOutputFalse s
1912 | TestOutputLength (s, _) | TestOutputStruct (s, _)
1913 | TestLastFail s -> s
1915 (* Check function names etc. for consistency. *)
1916 let check_functions () =
1917 let contains_uppercase str =
1918 let len = String.length str in
1920 if i >= len then false
1923 if c >= 'A' && c <= 'Z' then true
1930 (* Check function names. *)
1932 fun (name, _, _, _, _, _, _) ->
1933 if String.length name >= 7 && String.sub name 0 7 = "guestfs" then
1934 failwithf "function name %s does not need 'guestfs' prefix" name;
1935 if contains_uppercase name then
1936 failwithf "function name %s should not contain uppercase chars" name;
1937 if String.contains name '-' then
1938 failwithf "function name %s should not contain '-', use '_' instead."
1942 (* Check function parameter/return names. *)
1944 fun (name, style, _, _, _, _, _) ->
1945 let check_arg_ret_name n =
1946 if contains_uppercase n then
1947 failwithf "%s param/ret %s should not contain uppercase chars"
1949 if String.contains n '-' || String.contains n '_' then
1950 failwithf "%s param/ret %s should not contain '-' or '_'"
1953 failwithf "%s has a param/ret called 'value', which causes conflicts in the OCaml bindings, use something like 'val' or a more descriptive name" n;
1954 if n = "argv" || n = "args" then
1955 failwithf "%s has a param/ret called 'argv' or 'args', which will cause some conflicts in the generated code" n
1958 (match fst style with
1960 | RInt n | RInt64 n | RBool n | RConstString n | RString n
1961 | RStringList n | RPVList n | RVGList n | RLVList n
1962 | RStat n | RStatVFS n
1964 check_arg_ret_name n
1966 check_arg_ret_name n;
1967 check_arg_ret_name m
1969 List.iter (fun arg -> check_arg_ret_name (name_of_argt arg)) (snd style)
1972 (* Check short descriptions. *)
1974 fun (name, _, _, _, _, shortdesc, _) ->
1975 if shortdesc.[0] <> Char.lowercase shortdesc.[0] then
1976 failwithf "short description of %s should begin with lowercase." name;
1977 let c = shortdesc.[String.length shortdesc-1] in
1978 if c = '\n' || c = '.' then
1979 failwithf "short description of %s should not end with . or \\n." name
1982 (* Check long dscriptions. *)
1984 fun (name, _, _, _, _, _, longdesc) ->
1985 if longdesc.[String.length longdesc-1] = '\n' then
1986 failwithf "long description of %s should not end with \\n." name
1989 (* Check proc_nrs. *)
1991 fun (name, _, proc_nr, _, _, _, _) ->
1992 if proc_nr <= 0 then
1993 failwithf "daemon function %s should have proc_nr > 0" name
1997 fun (name, _, proc_nr, _, _, _, _) ->
1998 if proc_nr <> -1 then
1999 failwithf "non-daemon function %s should have proc_nr -1" name
2000 ) non_daemon_functions;
2003 List.map (fun (name, _, proc_nr, _, _, _, _) -> name, proc_nr)
2006 List.sort (fun (_,nr1) (_,nr2) -> compare nr1 nr2) proc_nrs in
2007 let rec loop = function
2010 | (name1,nr1) :: ((name2,nr2) :: _ as rest) when nr1 < nr2 ->
2012 | (name1,nr1) :: (name2,nr2) :: _ ->
2013 failwithf "%s and %s have conflicting procedure numbers (%d, %d)"
2021 (* Ignore functions that have no tests. We generate a
2022 * warning when the user does 'make check' instead.
2024 | name, _, _, _, [], _, _ -> ()
2025 | name, _, _, _, tests, _, _ ->
2029 match seq_of_test test with
2031 failwithf "%s has a test containing an empty sequence" name
2032 | cmds -> List.map List.hd cmds
2034 let funcs = List.flatten funcs in
2036 let tested = List.mem name funcs in
2039 failwithf "function %s has tests but does not test itself" name
2042 (* 'pr' prints to the current output file. *)
2043 let chan = ref stdout
2044 let pr fs = ksprintf (output_string !chan) fs
2046 (* Generate a header block in a number of standard styles. *)
2047 type comment_style = CStyle | HashStyle | OCamlStyle
2048 type license = GPLv2 | LGPLv2
2050 let generate_header comment license =
2051 let c = match comment with
2052 | CStyle -> pr "/* "; " *"
2053 | HashStyle -> pr "# "; "#"
2054 | OCamlStyle -> pr "(* "; " *" in
2055 pr "libguestfs generated file\n";
2056 pr "%s WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.\n" c;
2057 pr "%s ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.\n" c;
2059 pr "%s Copyright (C) 2009 Red Hat Inc.\n" c;
2063 pr "%s This program is free software; you can redistribute it and/or modify\n" c;
2064 pr "%s it under the terms of the GNU General Public License as published by\n" c;
2065 pr "%s the Free Software Foundation; either version 2 of the License, or\n" c;
2066 pr "%s (at your option) any later version.\n" c;
2068 pr "%s This program is distributed in the hope that it will be useful,\n" c;
2069 pr "%s but WITHOUT ANY WARRANTY; without even the implied warranty of\n" c;
2070 pr "%s MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" c;
2071 pr "%s GNU General Public License for more details.\n" c;
2073 pr "%s You should have received a copy of the GNU General Public License along\n" c;
2074 pr "%s with this program; if not, write to the Free Software Foundation, Inc.,\n" c;
2075 pr "%s 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\n" c;
2078 pr "%s This library is free software; you can redistribute it and/or\n" c;
2079 pr "%s modify it under the terms of the GNU Lesser General Public\n" c;
2080 pr "%s License as published by the Free Software Foundation; either\n" c;
2081 pr "%s version 2 of the License, or (at your option) any later version.\n" c;
2083 pr "%s This library is distributed in the hope that it will be useful,\n" c;
2084 pr "%s but WITHOUT ANY WARRANTY; without even the implied warranty of\n" c;
2085 pr "%s MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n" c;
2086 pr "%s Lesser General Public License for more details.\n" c;
2088 pr "%s You should have received a copy of the GNU Lesser General Public\n" c;
2089 pr "%s License along with this library; if not, write to the Free Software\n" c;
2090 pr "%s Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n" c;
2093 | CStyle -> pr " */\n"
2095 | OCamlStyle -> pr " *)\n"
2099 (* Start of main code generation functions below this line. *)
2101 (* Generate the pod documentation for the C API. *)
2102 let rec generate_actions_pod () =
2104 fun (shortname, style, _, flags, _, _, longdesc) ->
2105 let name = "guestfs_" ^ shortname in
2106 pr "=head2 %s\n\n" name;
2108 generate_prototype ~extern:false ~handle:"handle" name style;
2110 pr "%s\n\n" longdesc;
2111 (match fst style with
2113 pr "This function returns 0 on success or -1 on error.\n\n"
2115 pr "On error this function returns -1.\n\n"
2117 pr "On error this function returns -1.\n\n"
2119 pr "This function returns a C truth value on success or -1 on error.\n\n"
2121 pr "This function returns a string, or NULL on error.
2122 The string is owned by the guest handle and must I<not> be freed.\n\n"
2124 pr "This function returns a string, or NULL on error.
2125 I<The caller must free the returned string after use>.\n\n"
2127 pr "This function returns a NULL-terminated array of strings
2128 (like L<environ(3)>), or NULL if there was an error.
2129 I<The caller must free the strings and the array after use>.\n\n"
2131 pr "This function returns a C<struct guestfs_int_bool *>,
2132 or NULL if there was an error.
2133 I<The caller must call C<guestfs_free_int_bool> after use>.\n\n"
2135 pr "This function returns a C<struct guestfs_lvm_pv_list *>
2136 (see E<lt>guestfs-structs.hE<gt>),
2137 or NULL if there was an error.
2138 I<The caller must call C<guestfs_free_lvm_pv_list> after use>.\n\n"
2140 pr "This function returns a C<struct guestfs_lvm_vg_list *>
2141 (see E<lt>guestfs-structs.hE<gt>),
2142 or NULL if there was an error.
2143 I<The caller must call C<guestfs_free_lvm_vg_list> after use>.\n\n"
2145 pr "This function returns a C<struct guestfs_lvm_lv_list *>
2146 (see E<lt>guestfs-structs.hE<gt>),
2147 or NULL if there was an error.
2148 I<The caller must call C<guestfs_free_lvm_lv_list> after use>.\n\n"
2150 pr "This function returns a C<struct guestfs_stat *>
2151 (see L<stat(2)> and E<lt>guestfs-structs.hE<gt>),
2152 or NULL if there was an error.
2153 I<The caller must call C<free> after use>.\n\n"
2155 pr "This function returns a C<struct guestfs_statvfs *>
2156 (see L<statvfs(2)> and E<lt>guestfs-structs.hE<gt>),
2157 or NULL if there was an error.
2158 I<The caller must call C<free> after use>.\n\n"
2160 pr "This function returns a NULL-terminated array of
2161 strings, or NULL if there was an error.
2162 The array of strings will always have length C<2n+1>, where
2163 C<n> keys and values alternate, followed by the trailing NULL entry.
2164 I<The caller must free the strings and the array after use>.\n\n"
2166 if List.mem ProtocolLimitWarning flags then
2167 pr "%s\n\n" protocol_limit_warning;
2168 if List.mem DangerWillRobinson flags then
2169 pr "%s\n\n" danger_will_robinson;
2170 ) all_functions_sorted
2172 and generate_structs_pod () =
2173 (* LVM structs documentation. *)
2176 pr "=head2 guestfs_lvm_%s\n" typ;
2178 pr " struct guestfs_lvm_%s {\n" typ;
2181 | name, `String -> pr " char *%s;\n" name
2183 pr " /* The next field is NOT nul-terminated, be careful when printing it: */\n";
2184 pr " char %s[32];\n" name
2185 | name, `Bytes -> pr " uint64_t %s;\n" name
2186 | name, `Int -> pr " int64_t %s;\n" name
2187 | name, `OptPercent ->
2188 pr " /* The next field is [0..100] or -1 meaning 'not present': */\n";
2189 pr " float %s;\n" name
2192 pr " struct guestfs_lvm_%s_list {\n" typ;
2193 pr " uint32_t len; /* Number of elements in list. */\n";
2194 pr " struct guestfs_lvm_%s *val; /* Elements. */\n" typ;
2197 pr " void guestfs_free_lvm_%s_list (struct guestfs_free_lvm_%s_list *);\n"
2200 ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols]
2202 (* Generate the protocol (XDR) file, 'guestfs_protocol.x' and
2203 * indirectly 'guestfs_protocol.h' and 'guestfs_protocol.c'.
2205 * We have to use an underscore instead of a dash because otherwise
2206 * rpcgen generates incorrect code.
2208 * This header is NOT exported to clients, but see also generate_structs_h.
2210 and generate_xdr () =
2211 generate_header CStyle LGPLv2;
2213 (* This has to be defined to get around a limitation in Sun's rpcgen. *)
2214 pr "typedef string str<>;\n";
2217 (* LVM internal structures. *)
2221 pr "struct guestfs_lvm_int_%s {\n" typ;
2223 | name, `String -> pr " string %s<>;\n" name
2224 | name, `UUID -> pr " opaque %s[32];\n" name
2225 | name, `Bytes -> pr " hyper %s;\n" name
2226 | name, `Int -> pr " hyper %s;\n" name
2227 | name, `OptPercent -> pr " float %s;\n" name
2231 pr "typedef struct guestfs_lvm_int_%s guestfs_lvm_int_%s_list<>;\n" typ typ;
2233 ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
2235 (* Stat internal structures. *)
2239 pr "struct guestfs_int_%s {\n" typ;
2241 | name, `Int -> pr " hyper %s;\n" name
2245 ) ["stat", stat_cols; "statvfs", statvfs_cols];
2248 fun (shortname, style, _, _, _, _, _) ->
2249 let name = "guestfs_" ^ shortname in
2251 (match snd style with
2254 pr "struct %s_args {\n" name;
2257 | String n -> pr " string %s<>;\n" n
2258 | OptString n -> pr " str *%s;\n" n
2259 | StringList n -> pr " str %s<>;\n" n
2260 | Bool n -> pr " bool %s;\n" n
2261 | Int n -> pr " int %s;\n" n
2262 | FileIn _ | FileOut _ -> ()
2266 (match fst style with
2269 pr "struct %s_ret {\n" name;
2273 pr "struct %s_ret {\n" name;
2274 pr " hyper %s;\n" n;
2277 pr "struct %s_ret {\n" name;
2281 failwithf "RConstString cannot be returned from a daemon function"
2283 pr "struct %s_ret {\n" name;
2284 pr " string %s<>;\n" n;
2287 pr "struct %s_ret {\n" name;
2288 pr " str %s<>;\n" n;
2291 pr "struct %s_ret {\n" name;
2296 pr "struct %s_ret {\n" name;
2297 pr " guestfs_lvm_int_pv_list %s;\n" n;
2300 pr "struct %s_ret {\n" name;
2301 pr " guestfs_lvm_int_vg_list %s;\n" n;
2304 pr "struct %s_ret {\n" name;
2305 pr " guestfs_lvm_int_lv_list %s;\n" n;
2308 pr "struct %s_ret {\n" name;
2309 pr " guestfs_int_stat %s;\n" n;
2312 pr "struct %s_ret {\n" name;
2313 pr " guestfs_int_statvfs %s;\n" n;
2316 pr "struct %s_ret {\n" name;
2317 pr " str %s<>;\n" n;
2322 (* Table of procedure numbers. *)
2323 pr "enum guestfs_procedure {\n";
2325 fun (shortname, _, proc_nr, _, _, _, _) ->
2326 pr " GUESTFS_PROC_%s = %d,\n" (String.uppercase shortname) proc_nr
2328 pr " GUESTFS_PROC_NR_PROCS\n";
2332 (* Having to choose a maximum message size is annoying for several
2333 * reasons (it limits what we can do in the API), but it (a) makes
2334 * the protocol a lot simpler, and (b) provides a bound on the size
2335 * of the daemon which operates in limited memory space. For large
2336 * file transfers you should use FTP.
2338 pr "const GUESTFS_MESSAGE_MAX = %d;\n" (4 * 1024 * 1024);
2341 (* Message header, etc. *)
2343 /* The communication protocol is now documented in the guestfs(3)
2347 const GUESTFS_PROGRAM = 0x2000F5F5;
2348 const GUESTFS_PROTOCOL_VERSION = 1;
2350 /* These constants must be larger than any possible message length. */
2351 const GUESTFS_LAUNCH_FLAG = 0xf5f55ff5;
2352 const GUESTFS_CANCEL_FLAG = 0xffffeeee;
2354 enum guestfs_message_direction {
2355 GUESTFS_DIRECTION_CALL = 0, /* client -> daemon */
2356 GUESTFS_DIRECTION_REPLY = 1 /* daemon -> client */
2359 enum guestfs_message_status {
2360 GUESTFS_STATUS_OK = 0,
2361 GUESTFS_STATUS_ERROR = 1
2364 const GUESTFS_ERROR_LEN = 256;
2366 struct guestfs_message_error {
2367 string error_message<GUESTFS_ERROR_LEN>;
2370 struct guestfs_message_header {
2371 unsigned prog; /* GUESTFS_PROGRAM */
2372 unsigned vers; /* GUESTFS_PROTOCOL_VERSION */
2373 guestfs_procedure proc; /* GUESTFS_PROC_x */
2374 guestfs_message_direction direction;
2375 unsigned serial; /* message serial number */
2376 guestfs_message_status status;
2379 const GUESTFS_MAX_CHUNK_SIZE = 8192;
2381 struct guestfs_chunk {
2382 int cancel; /* if non-zero, transfer is cancelled */
2383 /* data size is 0 bytes if the transfer has finished successfully */
2384 opaque data<GUESTFS_MAX_CHUNK_SIZE>;
2388 (* Generate the guestfs-structs.h file. *)
2389 and generate_structs_h () =
2390 generate_header CStyle LGPLv2;
2392 (* This is a public exported header file containing various
2393 * structures. The structures are carefully written to have
2394 * exactly the same in-memory format as the XDR structures that
2395 * we use on the wire to the daemon. The reason for creating
2396 * copies of these structures here is just so we don't have to
2397 * export the whole of guestfs_protocol.h (which includes much
2398 * unrelated and XDR-dependent stuff that we don't want to be
2399 * public, or required by clients).
2401 * To reiterate, we will pass these structures to and from the
2402 * client with a simple assignment or memcpy, so the format
2403 * must be identical to what rpcgen / the RFC defines.
2406 (* guestfs_int_bool structure. *)
2407 pr "struct guestfs_int_bool {\n";
2413 (* LVM public structures. *)
2417 pr "struct guestfs_lvm_%s {\n" typ;
2420 | name, `String -> pr " char *%s;\n" name
2421 | name, `UUID -> pr " char %s[32]; /* this is NOT nul-terminated, be careful when printing */\n" name
2422 | name, `Bytes -> pr " uint64_t %s;\n" name
2423 | name, `Int -> pr " int64_t %s;\n" name
2424 | name, `OptPercent -> pr " float %s; /* [0..100] or -1 */\n" name
2428 pr "struct guestfs_lvm_%s_list {\n" typ;
2429 pr " uint32_t len;\n";
2430 pr " struct guestfs_lvm_%s *val;\n" typ;
2433 ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
2435 (* Stat structures. *)
2439 pr "struct guestfs_%s {\n" typ;
2442 | name, `Int -> pr " int64_t %s;\n" name
2446 ) ["stat", stat_cols; "statvfs", statvfs_cols]
2448 (* Generate the guestfs-actions.h file. *)
2449 and generate_actions_h () =
2450 generate_header CStyle LGPLv2;
2452 fun (shortname, style, _, _, _, _, _) ->
2453 let name = "guestfs_" ^ shortname in
2454 generate_prototype ~single_line:true ~newline:true ~handle:"handle"
2458 (* Generate the client-side dispatch stubs. *)
2459 and generate_client_actions () =
2460 generate_header CStyle LGPLv2;
2466 #include \"guestfs.h\"
2467 #include \"guestfs_protocol.h\"
2469 #define error guestfs_error
2470 #define perrorf guestfs_perrorf
2471 #define safe_malloc guestfs_safe_malloc
2472 #define safe_realloc guestfs_safe_realloc
2473 #define safe_strdup guestfs_safe_strdup
2474 #define safe_memdup guestfs_safe_memdup
2476 /* Check the return message from a call for validity. */
2478 check_reply_header (guestfs_h *g,
2479 const struct guestfs_message_header *hdr,
2480 int proc_nr, int serial)
2482 if (hdr->prog != GUESTFS_PROGRAM) {
2483 error (g, \"wrong program (%%d/%%d)\", hdr->prog, GUESTFS_PROGRAM);
2486 if (hdr->vers != GUESTFS_PROTOCOL_VERSION) {
2487 error (g, \"wrong protocol version (%%d/%%d)\",
2488 hdr->vers, GUESTFS_PROTOCOL_VERSION);
2491 if (hdr->direction != GUESTFS_DIRECTION_REPLY) {
2492 error (g, \"unexpected message direction (%%d/%%d)\",
2493 hdr->direction, GUESTFS_DIRECTION_REPLY);
2496 if (hdr->proc != proc_nr) {
2497 error (g, \"unexpected procedure number (%%d/%%d)\", hdr->proc, proc_nr);
2500 if (hdr->serial != serial) {
2501 error (g, \"unexpected serial (%%d/%%d)\", hdr->serial, serial);
2508 /* Check we are in the right state to run a high-level action. */
2510 check_state (guestfs_h *g, const char *caller)
2512 if (!guestfs_is_ready (g)) {
2513 if (guestfs_is_config (g))
2514 error (g, \"%%s: call launch() before using this function\",
2516 else if (guestfs_is_launching (g))
2517 error (g, \"%%s: call wait_ready() before using this function\",
2520 error (g, \"%%s called from the wrong state, %%d != READY\",
2521 caller, guestfs_get_state (g));
2529 (* Client-side stubs for each function. *)
2531 fun (shortname, style, _, _, _, _, _) ->
2532 let name = "guestfs_" ^ shortname in
2534 (* Generate the context struct which stores the high-level
2535 * state between callback functions.
2537 pr "struct %s_ctx {\n" shortname;
2538 pr " /* This flag is set by the callbacks, so we know we've done\n";
2539 pr " * the callbacks as expected, and in the right sequence.\n";
2540 pr " * 0 = not called, 1 = reply_cb called.\n";
2542 pr " int cb_sequence;\n";
2543 pr " struct guestfs_message_header hdr;\n";
2544 pr " struct guestfs_message_error err;\n";
2545 (match fst style with
2548 failwithf "RConstString cannot be returned from a daemon function"
2550 | RBool _ | RString _ | RStringList _
2552 | RPVList _ | RVGList _ | RLVList _
2553 | RStat _ | RStatVFS _
2555 pr " struct %s_ret ret;\n" name
2560 (* Generate the reply callback function. *)
2561 pr "static void %s_reply_cb (guestfs_h *g, void *data, XDR *xdr)\n" shortname;
2563 pr " guestfs_main_loop *ml = guestfs_get_main_loop (g);\n";
2564 pr " struct %s_ctx *ctx = (struct %s_ctx *) data;\n" shortname shortname;
2566 pr " /* This should definitely not happen. */\n";
2567 pr " if (ctx->cb_sequence != 0) {\n";
2568 pr " ctx->cb_sequence = 9999;\n";
2569 pr " error (g, \"%%s: internal error: reply callback called twice\", \"%s\");\n" name;
2573 pr " ml->main_loop_quit (ml, g);\n";
2575 pr " if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {\n";
2576 pr " error (g, \"%%s: failed to parse reply header\", \"%s\");\n" name;
2579 pr " if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {\n";
2580 pr " if (!xdr_guestfs_message_error (xdr, &ctx->err)) {\n";
2581 pr " error (g, \"%%s: failed to parse reply error\", \"%s\");\n"
2588 (match fst style with
2591 failwithf "RConstString cannot be returned from a daemon function"
2593 | RBool _ | RString _ | RStringList _
2595 | RPVList _ | RVGList _ | RLVList _
2596 | RStat _ | RStatVFS _
2598 pr " if (!xdr_%s_ret (xdr, &ctx->ret)) {\n" name;
2599 pr " error (g, \"%%s: failed to parse reply\", \"%s\");\n" name;
2605 pr " ctx->cb_sequence = 1;\n";
2608 (* Generate the action stub. *)
2609 generate_prototype ~extern:false ~semicolon:false ~newline:true
2610 ~handle:"g" name style;
2613 match fst style with
2614 | RErr | RInt _ | RInt64 _ | RBool _ -> "-1"
2616 failwithf "RConstString cannot be returned from a daemon function"
2617 | RString _ | RStringList _ | RIntBool _
2618 | RPVList _ | RVGList _ | RLVList _
2619 | RStat _ | RStatVFS _
2625 (match snd style with
2627 | _ -> pr " struct %s_args args;\n" name
2630 pr " struct %s_ctx ctx;\n" shortname;
2631 pr " guestfs_main_loop *ml = guestfs_get_main_loop (g);\n";
2632 pr " int serial;\n";
2634 pr " if (check_state (g, \"%s\") == -1) return %s;\n" name error_code;
2635 pr " guestfs_set_busy (g);\n";
2637 pr " memset (&ctx, 0, sizeof ctx);\n";
2640 (* Send the main header and arguments. *)
2641 (match snd style with
2643 pr " serial = guestfs__send_sync (g, GUESTFS_PROC_%s, NULL, NULL);\n"
2644 (String.uppercase shortname)
2649 pr " args.%s = (char *) %s;\n" n n
2651 pr " args.%s = %s ? (char **) &%s : NULL;\n" n n n
2653 pr " args.%s.%s_val = (char **) %s;\n" n n n;
2654 pr " for (args.%s.%s_len = 0; %s[args.%s.%s_len]; args.%s.%s_len++) ;\n" n n n n n n n;
2656 pr " args.%s = %s;\n" n n
2658 pr " args.%s = %s;\n" n n
2659 | FileIn _ | FileOut _ -> ()
2661 pr " serial = guestfs__send_sync (g, GUESTFS_PROC_%s,\n"
2662 (String.uppercase shortname);
2663 pr " (xdrproc_t) xdr_%s_args, (char *) &args);\n"
2666 pr " if (serial == -1) {\n";
2667 pr " guestfs_set_ready (g);\n";
2668 pr " return %s;\n" error_code;
2672 (* Send any additional files (FileIn) requested. *)
2673 let need_read_reply_label = ref false in
2680 pr " r = guestfs__send_file_sync (g, %s);\n" n;
2681 pr " if (r == -1) {\n";
2682 pr " guestfs_set_ready (g);\n";
2683 pr " return %s;\n" error_code;
2685 pr " if (r == -2) /* daemon cancelled */\n";
2686 pr " goto read_reply;\n";
2687 need_read_reply_label := true;
2693 (* Wait for the reply from the remote end. *)
2694 if !need_read_reply_label then pr " read_reply:\n";
2695 pr " guestfs__switch_to_receiving (g);\n";
2696 pr " ctx.cb_sequence = 0;\n";
2697 pr " guestfs_set_reply_callback (g, %s_reply_cb, &ctx);\n" shortname;
2698 pr " (void) ml->main_loop_run (ml, g);\n";
2699 pr " guestfs_set_reply_callback (g, NULL, NULL);\n";
2700 pr " if (ctx.cb_sequence != 1) {\n";
2701 pr " error (g, \"%%s reply failed, see earlier error messages\", \"%s\");\n" name;
2702 pr " guestfs_set_ready (g);\n";
2703 pr " return %s;\n" error_code;
2707 pr " if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_%s, serial) == -1) {\n"
2708 (String.uppercase shortname);
2709 pr " guestfs_set_ready (g);\n";
2710 pr " return %s;\n" error_code;
2714 pr " if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {\n";
2715 pr " error (g, \"%%s\", ctx.err.error_message);\n";
2716 pr " guestfs_set_ready (g);\n";
2717 pr " return %s;\n" error_code;
2721 (* Expecting to receive further files (FileOut)? *)
2725 pr " if (guestfs__receive_file_sync (g, %s) == -1) {\n" n;
2726 pr " guestfs_set_ready (g);\n";
2727 pr " return %s;\n" error_code;
2733 pr " guestfs_set_ready (g);\n";
2735 (match fst style with
2736 | RErr -> pr " return 0;\n"
2737 | RInt n | RInt64 n | RBool n ->
2738 pr " return ctx.ret.%s;\n" n
2740 failwithf "RConstString cannot be returned from a daemon function"
2742 pr " return ctx.ret.%s; /* caller will free */\n" n
2743 | RStringList n | RHashtable n ->
2744 pr " /* caller will free this, but we need to add a NULL entry */\n";
2745 pr " ctx.ret.%s.%s_val =\n" n n;
2746 pr " safe_realloc (g, ctx.ret.%s.%s_val,\n" n n;
2747 pr " sizeof (char *) * (ctx.ret.%s.%s_len + 1));\n"
2749 pr " ctx.ret.%s.%s_val[ctx.ret.%s.%s_len] = NULL;\n" n n n n;
2750 pr " return ctx.ret.%s.%s_val;\n" n n
2752 pr " /* caller with free this */\n";
2753 pr " return safe_memdup (g, &ctx.ret, sizeof (ctx.ret));\n"
2754 | RPVList n | RVGList n | RLVList n
2755 | RStat n | RStatVFS n ->
2756 pr " /* caller will free this */\n";
2757 pr " return safe_memdup (g, &ctx.ret.%s, sizeof (ctx.ret.%s));\n" n n
2763 (* Generate daemon/actions.h. *)
2764 and generate_daemon_actions_h () =
2765 generate_header CStyle GPLv2;
2767 pr "#include \"../src/guestfs_protocol.h\"\n";
2771 fun (name, style, _, _, _, _, _) ->
2773 ~single_line:true ~newline:true ~in_daemon:true ~prefix:"do_"
2777 (* Generate the server-side stubs. *)
2778 and generate_daemon_actions () =
2779 generate_header CStyle GPLv2;
2781 pr "#include <config.h>\n";
2783 pr "#include <stdio.h>\n";
2784 pr "#include <stdlib.h>\n";
2785 pr "#include <string.h>\n";
2786 pr "#include <inttypes.h>\n";
2787 pr "#include <ctype.h>\n";
2788 pr "#include <rpc/types.h>\n";
2789 pr "#include <rpc/xdr.h>\n";
2791 pr "#include \"daemon.h\"\n";
2792 pr "#include \"../src/guestfs_protocol.h\"\n";
2793 pr "#include \"actions.h\"\n";
2797 fun (name, style, _, _, _, _, _) ->
2798 (* Generate server-side stubs. *)
2799 pr "static void %s_stub (XDR *xdr_in)\n" name;
2802 match fst style with
2803 | RErr | RInt _ -> pr " int r;\n"; "-1"
2804 | RInt64 _ -> pr " int64_t r;\n"; "-1"
2805 | RBool _ -> pr " int r;\n"; "-1"
2807 failwithf "RConstString cannot be returned from a daemon function"
2808 | RString _ -> pr " char *r;\n"; "NULL"
2809 | RStringList _ | RHashtable _ -> pr " char **r;\n"; "NULL"
2810 | RIntBool _ -> pr " guestfs_%s_ret *r;\n" name; "NULL"
2811 | RPVList _ -> pr " guestfs_lvm_int_pv_list *r;\n"; "NULL"
2812 | RVGList _ -> pr " guestfs_lvm_int_vg_list *r;\n"; "NULL"
2813 | RLVList _ -> pr " guestfs_lvm_int_lv_list *r;\n"; "NULL"
2814 | RStat _ -> pr " guestfs_int_stat *r;\n"; "NULL"
2815 | RStatVFS _ -> pr " guestfs_int_statvfs *r;\n"; "NULL" in
2817 (match snd style with
2820 pr " struct guestfs_%s_args args;\n" name;
2824 | OptString n -> pr " const char *%s;\n" n
2825 | StringList n -> pr " char **%s;\n" n
2826 | Bool n -> pr " int %s;\n" n
2827 | Int n -> pr " int %s;\n" n
2828 | FileIn _ | FileOut _ -> ()
2833 (match snd style with
2836 pr " memset (&args, 0, sizeof args);\n";
2838 pr " if (!xdr_guestfs_%s_args (xdr_in, &args)) {\n" name;
2839 pr " reply_with_error (\"%%s: daemon failed to decode procedure arguments\", \"%s\");\n" name;
2844 | String n -> pr " %s = args.%s;\n" n n
2845 | OptString n -> pr " %s = args.%s ? *args.%s : NULL;\n" n n n
2847 pr " %s = realloc (args.%s.%s_val,\n" n n n;
2848 pr " sizeof (char *) * (args.%s.%s_len+1));\n" n n;
2849 pr " if (%s == NULL) {\n" n;
2850 pr " reply_with_perror (\"realloc\");\n";
2853 pr " %s[args.%s.%s_len] = NULL;\n" n n n;
2854 pr " args.%s.%s_val = %s;\n" n n n;
2855 | Bool n -> pr " %s = args.%s;\n" n n
2856 | Int n -> pr " %s = args.%s;\n" n n
2857 | FileIn _ | FileOut _ -> ()
2862 (* Don't want to call the impl with any FileIn or FileOut
2863 * parameters, since these go "outside" the RPC protocol.
2866 List.filter (function FileIn _ | FileOut _ -> false | _ -> true)
2868 pr " r = do_%s " name;
2869 generate_call_args argsnofile;
2872 pr " if (r == %s)\n" error_code;
2873 pr " /* do_%s has already called reply_with_error */\n" name;
2877 (* If there are any FileOut parameters, then the impl must
2878 * send its own reply.
2881 List.exists (function FileOut _ -> true | _ -> false) (snd style) in
2883 pr " /* do_%s has already sent a reply */\n" name
2885 match fst style with
2886 | RErr -> pr " reply (NULL, NULL);\n"
2887 | RInt n | RInt64 n | RBool n ->
2888 pr " struct guestfs_%s_ret ret;\n" name;
2889 pr " ret.%s = r;\n" n;
2890 pr " reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
2893 failwithf "RConstString cannot be returned from a daemon function"
2895 pr " struct guestfs_%s_ret ret;\n" name;
2896 pr " ret.%s = r;\n" n;
2897 pr " reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
2900 | RStringList n | RHashtable n ->
2901 pr " struct guestfs_%s_ret ret;\n" name;
2902 pr " ret.%s.%s_len = count_strings (r);\n" n n;
2903 pr " ret.%s.%s_val = r;\n" n n;
2904 pr " reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
2906 pr " free_strings (r);\n"
2908 pr " reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) r);\n"
2910 pr " xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) r);\n" name
2911 | RPVList n | RVGList n | RLVList n
2912 | RStat n | RStatVFS n ->
2913 pr " struct guestfs_%s_ret ret;\n" name;
2914 pr " ret.%s = *r;\n" n;
2915 pr " reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n"
2917 pr " xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n"
2921 (* Free the args. *)
2922 (match snd style with
2927 pr " xdr_free ((xdrproc_t) xdr_guestfs_%s_args, (char *) &args);\n"
2934 (* Dispatch function. *)
2935 pr "void dispatch_incoming_message (XDR *xdr_in)\n";
2937 pr " switch (proc_nr) {\n";
2940 fun (name, style, _, _, _, _, _) ->
2941 pr " case GUESTFS_PROC_%s:\n" (String.uppercase name);
2942 pr " %s_stub (xdr_in);\n" name;
2947 pr " reply_with_error (\"dispatch_incoming_message: unknown procedure number %%d\", proc_nr);\n";
2952 (* LVM columns and tokenization functions. *)
2953 (* XXX This generates crap code. We should rethink how we
2959 pr "static const char *lvm_%s_cols = \"%s\";\n"
2960 typ (String.concat "," (List.map fst cols));
2963 pr "static int lvm_tokenize_%s (char *str, struct guestfs_lvm_int_%s *r)\n" typ typ;
2965 pr " char *tok, *p, *next;\n";
2969 pr " fprintf (stderr, \"%%s: <<%%s>>\\n\", __func__, str);\n";
2972 pr " if (!str) {\n";
2973 pr " fprintf (stderr, \"%%s: failed: passed a NULL string\\n\", __func__);\n";
2976 pr " if (!*str || isspace (*str)) {\n";
2977 pr " fprintf (stderr, \"%%s: failed: passed a empty string or one beginning with whitespace\\n\", __func__);\n";
2982 fun (name, coltype) ->
2983 pr " if (!tok) {\n";
2984 pr " fprintf (stderr, \"%%s: failed: string finished early, around token %%s\\n\", __func__, \"%s\");\n" name;
2987 pr " p = strchrnul (tok, ',');\n";
2988 pr " if (*p) next = p+1; else next = NULL;\n";
2989 pr " *p = '\\0';\n";
2992 pr " r->%s = strdup (tok);\n" name;
2993 pr " if (r->%s == NULL) {\n" name;
2994 pr " perror (\"strdup\");\n";
2998 pr " for (i = j = 0; i < 32; ++j) {\n";
2999 pr " if (tok[j] == '\\0') {\n";
3000 pr " fprintf (stderr, \"%%s: failed to parse UUID from '%%s'\\n\", __func__, tok);\n";
3002 pr " } else if (tok[j] != '-')\n";
3003 pr " r->%s[i++] = tok[j];\n" name;
3006 pr " if (sscanf (tok, \"%%\"SCNu64, &r->%s) != 1) {\n" name;
3007 pr " fprintf (stderr, \"%%s: failed to parse size '%%s' from token %%s\\n\", __func__, tok, \"%s\");\n" name;
3011 pr " if (sscanf (tok, \"%%\"SCNi64, &r->%s) != 1) {\n" name;
3012 pr " fprintf (stderr, \"%%s: failed to parse int '%%s' from token %%s\\n\", __func__, tok, \"%s\");\n" name;
3016 pr " if (tok[0] == '\\0')\n";
3017 pr " r->%s = -1;\n" name;
3018 pr " else if (sscanf (tok, \"%%f\", &r->%s) != 1) {\n" name;
3019 pr " fprintf (stderr, \"%%s: failed to parse float '%%s' from token %%s\\n\", __func__, tok, \"%s\");\n" name;
3023 pr " tok = next;\n";
3026 pr " if (tok != NULL) {\n";
3027 pr " fprintf (stderr, \"%%s: failed: extra tokens at end of string\\n\", __func__);\n";
3034 pr "guestfs_lvm_int_%s_list *\n" typ;
3035 pr "parse_command_line_%ss (void)\n" typ;
3037 pr " char *out, *err;\n";
3038 pr " char *p, *pend;\n";
3040 pr " guestfs_lvm_int_%s_list *ret;\n" typ;
3041 pr " void *newp;\n";
3043 pr " ret = malloc (sizeof *ret);\n";
3044 pr " if (!ret) {\n";
3045 pr " reply_with_perror (\"malloc\");\n";
3046 pr " return NULL;\n";
3049 pr " ret->guestfs_lvm_int_%s_list_len = 0;\n" typ;
3050 pr " ret->guestfs_lvm_int_%s_list_val = NULL;\n" typ;
3052 pr " r = command (&out, &err,\n";
3053 pr " \"/sbin/lvm\", \"%ss\",\n" typ;
3054 pr " \"-o\", lvm_%s_cols, \"--unbuffered\", \"--noheadings\",\n" typ;
3055 pr " \"--nosuffix\", \"--separator\", \",\", \"--units\", \"b\", NULL);\n";
3056 pr " if (r == -1) {\n";
3057 pr " reply_with_error (\"%%s\", err);\n";
3058 pr " free (out);\n";
3059 pr " free (err);\n";
3060 pr " free (ret);\n";
3061 pr " return NULL;\n";
3064 pr " free (err);\n";
3066 pr " /* Tokenize each line of the output. */\n";
3069 pr " while (p) {\n";
3070 pr " pend = strchr (p, '\\n'); /* Get the next line of output. */\n";
3071 pr " if (pend) {\n";
3072 pr " *pend = '\\0';\n";
3076 pr " while (*p && isspace (*p)) /* Skip any leading whitespace. */\n";
3079 pr " if (!*p) { /* Empty line? Skip it. */\n";
3084 pr " /* Allocate some space to store this next entry. */\n";
3085 pr " newp = realloc (ret->guestfs_lvm_int_%s_list_val,\n" typ;
3086 pr " sizeof (guestfs_lvm_int_%s) * (i+1));\n" typ;
3087 pr " if (newp == NULL) {\n";
3088 pr " reply_with_perror (\"realloc\");\n";
3089 pr " free (ret->guestfs_lvm_int_%s_list_val);\n" typ;
3090 pr " free (ret);\n";
3091 pr " free (out);\n";
3092 pr " return NULL;\n";
3094 pr " ret->guestfs_lvm_int_%s_list_val = newp;\n" typ;
3096 pr " /* Tokenize the next entry. */\n";
3097 pr " r = lvm_tokenize_%s (p, &ret->guestfs_lvm_int_%s_list_val[i]);\n" typ typ;
3098 pr " if (r == -1) {\n";
3099 pr " reply_with_error (\"failed to parse output of '%ss' command\");\n" typ;
3100 pr " free (ret->guestfs_lvm_int_%s_list_val);\n" typ;
3101 pr " free (ret);\n";
3102 pr " free (out);\n";
3103 pr " return NULL;\n";
3110 pr " ret->guestfs_lvm_int_%s_list_len = i;\n" typ;
3112 pr " free (out);\n";
3113 pr " return ret;\n";
3116 ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols]
3118 (* Generate the tests. *)
3119 and generate_tests () =
3120 generate_header CStyle GPLv2;
3127 #include <sys/types.h>
3130 #include \"guestfs.h\"
3132 static guestfs_h *g;
3133 static int suppress_error = 0;
3135 static void print_error (guestfs_h *g, void *data, const char *msg)
3137 if (!suppress_error)
3138 fprintf (stderr, \"%%s\\n\", msg);
3141 static void print_strings (char * const * const argv)
3145 for (argc = 0; argv[argc] != NULL; ++argc)
3146 printf (\"\\t%%s\\n\", argv[argc]);
3150 static void print_table (char * const * const argv)
3154 for (i = 0; argv[i] != NULL; i += 2)
3155 printf (\"%%s: %%s\\n\", argv[i], argv[i+1]);
3159 static void no_test_warnings (void)
3165 | name, _, _, _, [], _, _ ->
3166 pr " fprintf (stderr, \"warning: \\\"guestfs_%s\\\" has no tests\\n\");\n" name
3167 | name, _, _, _, tests, _, _ -> ()
3173 (* Generate the actual tests. Note that we generate the tests
3174 * in reverse order, deliberately, so that (in general) the
3175 * newest tests run first. This makes it quicker and easier to
3180 fun (name, _, _, _, tests, _, _) ->
3181 mapi (generate_one_test name) tests
3182 ) (List.rev all_functions) in
3183 let test_names = List.concat test_names in
3184 let nr_tests = List.length test_names in
3187 int main (int argc, char *argv[])
3192 const char *filename;
3194 int nr_tests, test_num = 0;
3196 no_test_warnings ();
3198 g = guestfs_create ();
3200 printf (\"guestfs_create FAILED\\n\");
3204 guestfs_set_error_handler (g, print_error, NULL);
3206 srcdir = getenv (\"srcdir\");
3207 if (!srcdir) srcdir = \".\";
3209 guestfs_set_path (g, \".\");
3211 filename = \"test1.img\";
3212 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
3217 if (lseek (fd, %d, SEEK_SET) == -1) {
3223 if (write (fd, &c, 1) == -1) {
3229 if (close (fd) == -1) {
3234 if (guestfs_add_drive (g, filename) == -1) {
3235 printf (\"guestfs_add_drive %%s FAILED\\n\", filename);
3239 filename = \"test2.img\";
3240 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
3245 if (lseek (fd, %d, SEEK_SET) == -1) {
3251 if (write (fd, &c, 1) == -1) {
3257 if (close (fd) == -1) {
3262 if (guestfs_add_drive (g, filename) == -1) {
3263 printf (\"guestfs_add_drive %%s FAILED\\n\", filename);
3267 filename = \"test3.img\";
3268 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
3273 if (lseek (fd, %d, SEEK_SET) == -1) {
3279 if (write (fd, &c, 1) == -1) {
3285 if (close (fd) == -1) {
3290 if (guestfs_add_drive (g, filename) == -1) {
3291 printf (\"guestfs_add_drive %%s FAILED\\n\", filename);
3295 if (guestfs_launch (g) == -1) {
3296 printf (\"guestfs_launch FAILED\\n\");
3299 if (guestfs_wait_ready (g) == -1) {
3300 printf (\"guestfs_wait_ready FAILED\\n\");
3306 " (500 * 1024 * 1024) (50 * 1024 * 1024) (10 * 1024 * 1024) nr_tests;
3310 pr " test_num++;\n";
3311 pr " printf (\"%%3d/%%3d %s\\n\", test_num, nr_tests);\n" test_name;
3312 pr " if (%s () == -1) {\n" test_name;
3313 pr " printf (\"%s FAILED\\n\");\n" test_name;
3319 pr " guestfs_close (g);\n";
3320 pr " unlink (\"test1.img\");\n";
3321 pr " unlink (\"test2.img\");\n";
3322 pr " unlink (\"test3.img\");\n";
3325 pr " if (failed > 0) {\n";
3326 pr " printf (\"***** %%d / %%d tests FAILED *****\\n\", failed, nr_tests);\n";
3334 and generate_one_test name i (init, test) =
3335 let test_name = sprintf "test_%s_%d" name i in
3337 pr "static int %s (void)\n" test_name;
3343 pr " /* InitEmpty for %s (%d) */\n" name i;
3344 List.iter (generate_test_command_call test_name)
3348 pr " /* InitBasicFS for %s (%d): create ext2 on /dev/sda1 */\n" name i;
3349 List.iter (generate_test_command_call test_name)
3352 ["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
3353 ["mkfs"; "ext2"; "/dev/sda1"];
3354 ["mount"; "/dev/sda1"; "/"]]
3355 | InitBasicFSonLVM ->
3356 pr " /* InitBasicFSonLVM for %s (%d): create ext2 on /dev/VG/LV */\n"
3358 List.iter (generate_test_command_call test_name)
3361 ["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
3362 ["pvcreate"; "/dev/sda1"];
3363 ["vgcreate"; "VG"; "/dev/sda1"];
3364 ["lvcreate"; "LV"; "VG"; "8"];
3365 ["mkfs"; "ext2"; "/dev/VG/LV"];
3366 ["mount"; "/dev/VG/LV"; "/"]]
3369 let get_seq_last = function
3371 failwithf "%s: you cannot use [] (empty list) when expecting a command"
3374 let seq = List.rev seq in
3375 List.rev (List.tl seq), List.hd seq
3380 pr " /* TestRun for %s (%d) */\n" name i;
3381 List.iter (generate_test_command_call test_name) seq
3382 | TestOutput (seq, expected) ->
3383 pr " /* TestOutput for %s (%d) */\n" name i;
3384 let seq, last = get_seq_last seq in
3386 pr " if (strcmp (r, \"%s\") != 0) {\n" (c_quote expected);
3387 pr " fprintf (stderr, \"%s: expected \\\"%s\\\" but got \\\"%%s\\\"\\n\", r);\n" test_name (c_quote expected);
3391 List.iter (generate_test_command_call test_name) seq;
3392 generate_test_command_call ~test test_name last
3393 | TestOutputList (seq, expected) ->
3394 pr " /* TestOutputList for %s (%d) */\n" name i;
3395 let seq, last = get_seq_last seq in
3399 pr " if (!r[%d]) {\n" i;
3400 pr " fprintf (stderr, \"%s: short list returned from command\\n\");\n" test_name;
3401 pr " print_strings (r);\n";
3404 pr " if (strcmp (r[%d], \"%s\") != 0) {\n" i (c_quote str);
3405 pr " fprintf (stderr, \"%s: expected \\\"%s\\\" but got \\\"%%s\\\"\\n\", r[%d]);\n" test_name (c_quote str) i;
3409 pr " if (r[%d] != NULL) {\n" (List.length expected);
3410 pr " fprintf (stderr, \"%s: extra elements returned from command\\n\");\n"
3412 pr " print_strings (r);\n";
3416 List.iter (generate_test_command_call test_name) seq;
3417 generate_test_command_call ~test test_name last
3418 | TestOutputInt (seq, expected) ->
3419 pr " /* TestOutputInt for %s (%d) */\n" name i;
3420 let seq, last = get_seq_last seq in
3422 pr " if (r != %d) {\n" expected;
3423 pr " fprintf (stderr, \"%s: expected %d but got %%d\\n\","
3429 List.iter (generate_test_command_call test_name) seq;
3430 generate_test_command_call ~test test_name last
3431 | TestOutputTrue seq ->
3432 pr " /* TestOutputTrue for %s (%d) */\n" name i;
3433 let seq, last = get_seq_last seq in
3436 pr " fprintf (stderr, \"%s: expected true, got false\\n\");\n"
3441 List.iter (generate_test_command_call test_name) seq;
3442 generate_test_command_call ~test test_name last
3443 | TestOutputFalse seq ->
3444 pr " /* TestOutputFalse for %s (%d) */\n" name i;
3445 let seq, last = get_seq_last seq in
3448 pr " fprintf (stderr, \"%s: expected false, got true\\n\");\n"
3453 List.iter (generate_test_command_call test_name) seq;
3454 generate_test_command_call ~test test_name last
3455 | TestOutputLength (seq, expected) ->
3456 pr " /* TestOutputLength for %s (%d) */\n" name i;
3457 let seq, last = get_seq_last seq in
3460 pr " for (j = 0; j < %d; ++j)\n" expected;
3461 pr " if (r[j] == NULL) {\n";
3462 pr " fprintf (stderr, \"%s: short list returned\\n\");\n"
3464 pr " print_strings (r);\n";
3467 pr " if (r[j] != NULL) {\n";
3468 pr " fprintf (stderr, \"%s: long list returned\\n\");\n"
3470 pr " print_strings (r);\n";
3474 List.iter (generate_test_command_call test_name) seq;
3475 generate_test_command_call ~test test_name last
3476 | TestOutputStruct (seq, checks) ->
3477 pr " /* TestOutputStruct for %s (%d) */\n" name i;
3478 let seq, last = get_seq_last seq in
3482 | CompareWithInt (field, expected) ->
3483 pr " if (r->%s != %d) {\n" field expected;
3484 pr " fprintf (stderr, \"%s: %s was %%d, expected %d\\n\",\n"
3485 test_name field expected;
3486 pr " (int) r->%s);\n" field;
3489 | CompareWithString (field, expected) ->
3490 pr " if (strcmp (r->%s, \"%s\") != 0) {\n" field expected;
3491 pr " fprintf (stderr, \"%s: %s was \"%%s\", expected \"%s\"\\n\",\n"
3492 test_name field expected;
3493 pr " r->%s);\n" field;
3496 | CompareFieldsIntEq (field1, field2) ->
3497 pr " if (r->%s != r->%s) {\n" field1 field2;
3498 pr " fprintf (stderr, \"%s: %s (%%d) <> %s (%%d)\\n\",\n"
3499 test_name field1 field2;
3500 pr " (int) r->%s, (int) r->%s);\n" field1 field2;
3503 | CompareFieldsStrEq (field1, field2) ->
3504 pr " if (strcmp (r->%s, r->%s) != 0) {\n" field1 field2;
3505 pr " fprintf (stderr, \"%s: %s (\"%%s\") <> %s (\"%%s\")\\n\",\n"
3506 test_name field1 field2;
3507 pr " r->%s, r->%s);\n" field1 field2;
3512 List.iter (generate_test_command_call test_name) seq;
3513 generate_test_command_call ~test test_name last
3514 | TestLastFail seq ->
3515 pr " /* TestLastFail for %s (%d) */\n" name i;
3516 let seq, last = get_seq_last seq in
3517 List.iter (generate_test_command_call test_name) seq;
3518 generate_test_command_call test_name ~expect_error:true last
3526 (* Generate the code to run a command, leaving the result in 'r'.
3527 * If you expect to get an error then you should set expect_error:true.
3529 and generate_test_command_call ?(expect_error = false) ?test test_name cmd =
3531 | [] -> assert false
3533 (* Look up the command to find out what args/ret it has. *)
3536 let _, style, _, _, _, _, _ =
3537 List.find (fun (n, _, _, _, _, _, _) -> n = name) all_functions in
3540 failwithf "%s: in test, command %s was not found" test_name name in
3542 if List.length (snd style) <> List.length args then
3543 failwithf "%s: in test, wrong number of args given to %s"
3554 | FileIn _, _ | FileOut _, _ -> ()
3555 | StringList n, arg ->
3556 pr " char *%s[] = {\n" n;
3557 let strs = string_split " " arg in
3559 fun str -> pr " \"%s\",\n" (c_quote str)
3563 ) (List.combine (snd style) args);
3566 match fst style with
3567 | RErr | RInt _ | RBool _ -> pr " int r;\n"; "-1"
3568 | RInt64 _ -> pr " int64_t r;\n"; "-1"
3569 | RConstString _ -> pr " const char *r;\n"; "NULL"
3570 | RString _ -> pr " char *r;\n"; "NULL"
3571 | RStringList _ | RHashtable _ ->
3576 pr " struct guestfs_int_bool *r;\n"; "NULL"
3578 pr " struct guestfs_lvm_pv_list *r;\n"; "NULL"
3580 pr " struct guestfs_lvm_vg_list *r;\n"; "NULL"
3582 pr " struct guestfs_lvm_lv_list *r;\n"; "NULL"
3584 pr " struct guestfs_stat *r;\n"; "NULL"
3586 pr " struct guestfs_statvfs *r;\n"; "NULL" in
3588 pr " suppress_error = %d;\n" (if expect_error then 1 else 0);
3589 pr " r = guestfs_%s (g" name;
3591 (* Generate the parameters. *)
3595 | FileIn _, arg | FileOut _, arg ->
3596 pr ", \"%s\"" (c_quote arg)
3597 | OptString _, arg ->
3598 if arg = "NULL" then pr ", NULL" else pr ", \"%s\"" (c_quote arg)
3599 | StringList n, _ ->
3603 try int_of_string arg
3604 with Failure "int_of_string" ->
3605 failwithf "%s: expecting an int, but got '%s'" test_name arg in
3608 let b = bool_of_string arg in pr ", %d" (if b then 1 else 0)
3609 ) (List.combine (snd style) args);
3612 if not expect_error then
3613 pr " if (r == %s)\n" error_code
3615 pr " if (r != %s)\n" error_code;
3618 (* Insert the test code. *)
3624 (match fst style with
3625 | RErr | RInt _ | RInt64 _ | RBool _ | RConstString _ -> ()
3626 | RString _ -> pr " free (r);\n"
3627 | RStringList _ | RHashtable _ ->
3628 pr " for (i = 0; r[i] != NULL; ++i)\n";
3629 pr " free (r[i]);\n";
3632 pr " guestfs_free_int_bool (r);\n"
3634 pr " guestfs_free_lvm_pv_list (r);\n"
3636 pr " guestfs_free_lvm_vg_list (r);\n"
3638 pr " guestfs_free_lvm_lv_list (r);\n"
3639 | RStat _ | RStatVFS _ ->
3646 let str = replace_str str "\r" "\\r" in
3647 let str = replace_str str "\n" "\\n" in
3648 let str = replace_str str "\t" "\\t" in
3651 (* Generate a lot of different functions for guestfish. *)
3652 and generate_fish_cmds () =
3653 generate_header CStyle GPLv2;
3657 fun (_, _, _, flags, _, _, _) -> not (List.mem NotInFish flags)
3659 let all_functions_sorted =
3661 fun (_, _, _, flags, _, _, _) -> not (List.mem NotInFish flags)
3662 ) all_functions_sorted in
3664 pr "#include <stdio.h>\n";
3665 pr "#include <stdlib.h>\n";
3666 pr "#include <string.h>\n";
3667 pr "#include <inttypes.h>\n";
3669 pr "#include <guestfs.h>\n";
3670 pr "#include \"fish.h\"\n";
3673 (* list_commands function, which implements guestfish -h *)
3674 pr "void list_commands (void)\n";
3676 pr " printf (\" %%-16s %%s\\n\", \"Command\", \"Description\");\n";
3677 pr " list_builtin_commands ();\n";
3679 fun (name, _, _, flags, _, shortdesc, _) ->
3680 let name = replace_char name '_' '-' in
3681 pr " printf (\"%%-20s %%s\\n\", \"%s\", \"%s\");\n"
3683 ) all_functions_sorted;
3684 pr " printf (\" Use -h <cmd> / help <cmd> to show detailed help for a command.\\n\");\n";
3688 (* display_command function, which implements guestfish -h cmd *)
3689 pr "void display_command (const char *cmd)\n";
3692 fun (name, style, _, flags, _, shortdesc, longdesc) ->
3693 let name2 = replace_char name '_' '-' in
3695 try find_map (function FishAlias n -> Some n | _ -> None) flags
3696 with Not_found -> name in
3697 let longdesc = replace_str longdesc "C<guestfs_" "C<" in
3699 match snd style with
3703 name2 (String.concat "> <" (List.map name_of_argt args)) in
3706 if List.mem ProtocolLimitWarning flags then
3707 ("\n\n" ^ protocol_limit_warning)
3710 (* For DangerWillRobinson commands, we should probably have
3711 * guestfish prompt before allowing you to use them (especially
3712 * in interactive mode). XXX
3716 if List.mem DangerWillRobinson flags then
3717 ("\n\n" ^ danger_will_robinson)
3720 let describe_alias =
3721 if name <> alias then
3722 sprintf "\n\nYou can use '%s' as an alias for this command." alias
3726 pr "strcasecmp (cmd, \"%s\") == 0" name;
3727 if name <> name2 then
3728 pr " || strcasecmp (cmd, \"%s\") == 0" name2;
3729 if name <> alias then
3730 pr " || strcasecmp (cmd, \"%s\") == 0" alias;
3732 pr " pod2text (\"%s - %s\", %S);\n"
3734 (" " ^ synopsis ^ "\n\n" ^ longdesc ^ warnings ^ describe_alias);
3737 pr " display_builtin_command (cmd);\n";
3741 (* print_{pv,vg,lv}_list functions *)
3745 pr "static void print_%s (struct guestfs_lvm_%s *%s)\n" typ typ typ;
3752 pr " printf (\"%s: %%s\\n\", %s->%s);\n" name typ name
3754 pr " printf (\"%s: \");\n" name;
3755 pr " for (i = 0; i < 32; ++i)\n";
3756 pr " printf (\"%%c\", %s->%s[i]);\n" typ name;
3757 pr " printf (\"\\n\");\n"
3759 pr " printf (\"%s: %%\" PRIu64 \"\\n\", %s->%s);\n" name typ name
3761 pr " printf (\"%s: %%\" PRIi64 \"\\n\", %s->%s);\n" name typ name
3762 | name, `OptPercent ->
3763 pr " if (%s->%s >= 0) printf (\"%s: %%g %%%%\\n\", %s->%s);\n"
3764 typ name name typ name;
3765 pr " else printf (\"%s: \\n\");\n" name
3769 pr "static void print_%s_list (struct guestfs_lvm_%s_list *%ss)\n"
3774 pr " for (i = 0; i < %ss->len; ++i)\n" typ;
3775 pr " print_%s (&%ss->val[i]);\n" typ typ;
3778 ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
3780 (* print_{stat,statvfs} functions *)
3784 pr "static void print_%s (struct guestfs_%s *%s)\n" typ typ typ;
3789 pr " printf (\"%s: %%\" PRIi64 \"\\n\", %s->%s);\n" name typ name
3793 ) ["stat", stat_cols; "statvfs", statvfs_cols];
3795 (* run_<action> actions *)
3797 fun (name, style, _, flags, _, _, _) ->
3798 pr "static int run_%s (const char *cmd, int argc, char *argv[])\n" name;
3800 (match fst style with
3803 | RBool _ -> pr " int r;\n"
3804 | RInt64 _ -> pr " int64_t r;\n"
3805 | RConstString _ -> pr " const char *r;\n"
3806 | RString _ -> pr " char *r;\n"
3807 | RStringList _ | RHashtable _ -> pr " char **r;\n"
3808 | RIntBool _ -> pr " struct guestfs_int_bool *r;\n"
3809 | RPVList _ -> pr " struct guestfs_lvm_pv_list *r;\n"
3810 | RVGList _ -> pr " struct guestfs_lvm_vg_list *r;\n"
3811 | RLVList _ -> pr " struct guestfs_lvm_lv_list *r;\n"
3812 | RStat _ -> pr " struct guestfs_stat *r;\n"
3813 | RStatVFS _ -> pr " struct guestfs_statvfs *r;\n"
3820 | FileOut n -> pr " const char *%s;\n" n
3821 | StringList n -> pr " char **%s;\n" n
3822 | Bool n -> pr " int %s;\n" n
3823 | Int n -> pr " int %s;\n" n
3826 (* Check and convert parameters. *)
3827 let argc_expected = List.length (snd style) in
3828 pr " if (argc != %d) {\n" argc_expected;
3829 pr " fprintf (stderr, \"%%s should have %d parameter(s)\\n\", cmd);\n"
3831 pr " fprintf (stderr, \"type 'help %%s' for help on %%s\\n\", cmd, cmd);\n";
3837 | String name -> pr " %s = argv[%d];\n" name i
3839 pr " %s = strcmp (argv[%d], \"\") != 0 ? argv[%d] : NULL;\n"
3842 pr " %s = strcmp (argv[%d], \"-\") != 0 ? argv[%d] : \"/dev/stdin\";\n"
3845 pr " %s = strcmp (argv[%d], \"-\") != 0 ? argv[%d] : \"/dev/stdout\";\n"
3847 | StringList name ->
3848 pr " %s = parse_string_list (argv[%d]);\n" name i
3850 pr " %s = is_true (argv[%d]) ? 1 : 0;\n" name i
3852 pr " %s = atoi (argv[%d]);\n" name i
3855 (* Call C API function. *)
3857 try find_map (function FishAction n -> Some n | _ -> None) flags
3858 with Not_found -> sprintf "guestfs_%s" name in
3860 generate_call_args ~handle:"g" (snd style);
3863 (* Check return value for errors and display command results. *)
3864 (match fst style with
3865 | RErr -> pr " return r;\n"
3867 pr " if (r == -1) return -1;\n";
3868 pr " printf (\"%%d\\n\", r);\n";
3871 pr " if (r == -1) return -1;\n";
3872 pr " printf (\"%%\" PRIi64 \"\\n\", r);\n";
3875 pr " if (r == -1) return -1;\n";
3876 pr " if (r) printf (\"true\\n\"); else printf (\"false\\n\");\n";
3879 pr " if (r == NULL) return -1;\n";
3880 pr " printf (\"%%s\\n\", r);\n";
3883 pr " if (r == NULL) return -1;\n";
3884 pr " printf (\"%%s\\n\", r);\n";
3888 pr " if (r == NULL) return -1;\n";
3889 pr " print_strings (r);\n";
3890 pr " free_strings (r);\n";
3893 pr " if (r == NULL) return -1;\n";
3894 pr " printf (\"%%d, %%s\\n\", r->i,\n";
3895 pr " r->b ? \"true\" : \"false\");\n";
3896 pr " guestfs_free_int_bool (r);\n";
3899 pr " if (r == NULL) return -1;\n";
3900 pr " print_pv_list (r);\n";
3901 pr " guestfs_free_lvm_pv_list (r);\n";
3904 pr " if (r == NULL) return -1;\n";
3905 pr " print_vg_list (r);\n";
3906 pr " guestfs_free_lvm_vg_list (r);\n";
3909 pr " if (r == NULL) return -1;\n";
3910 pr " print_lv_list (r);\n";
3911 pr " guestfs_free_lvm_lv_list (r);\n";
3914 pr " if (r == NULL) return -1;\n";
3915 pr " print_stat (r);\n";
3919 pr " if (r == NULL) return -1;\n";
3920 pr " print_statvfs (r);\n";
3924 pr " if (r == NULL) return -1;\n";
3925 pr " print_table (r);\n";
3926 pr " free_strings (r);\n";
3933 (* run_action function *)
3934 pr "int run_action (const char *cmd, int argc, char *argv[])\n";
3937 fun (name, _, _, flags, _, _, _) ->
3938 let name2 = replace_char name '_' '-' in
3940 try find_map (function FishAlias n -> Some n | _ -> None) flags
3941 with Not_found -> name in
3943 pr "strcasecmp (cmd, \"%s\") == 0" name;
3944 if name <> name2 then
3945 pr " || strcasecmp (cmd, \"%s\") == 0" name2;
3946 if name <> alias then
3947 pr " || strcasecmp (cmd, \"%s\") == 0" alias;
3949 pr " return run_%s (cmd, argc, argv);\n" name;
3953 pr " fprintf (stderr, \"%%s: unknown command\\n\", cmd);\n";
3960 (* Readline completion for guestfish. *)
3961 and generate_fish_completion () =
3962 generate_header CStyle GPLv2;
3966 fun (_, _, _, flags, _, _, _) -> not (List.mem NotInFish flags)
3976 #ifdef HAVE_LIBREADLINE
3977 #include <readline/readline.h>
3982 #ifdef HAVE_LIBREADLINE
3984 static const char *const commands[] = {
3987 (* Get the commands and sort them, including the aliases. *)
3990 fun (name, _, _, flags, _, _, _) ->
3991 let name2 = replace_char name '_' '-' in
3993 try find_map (function FishAlias n -> Some n | _ -> None) flags
3994 with Not_found -> name in
3996 if name <> alias then [name2; alias] else [name2]
3998 let commands = List.flatten commands in
3999 let commands = List.sort compare commands in
4001 List.iter (pr " \"%s\",\n") commands;
4007 generator (const char *text, int state)
4009 static int index, len;
4014 len = strlen (text);
4017 while ((name = commands[index]) != NULL) {
4019 if (strncasecmp (name, text, len) == 0)
4020 return strdup (name);
4026 #endif /* HAVE_LIBREADLINE */
4028 char **do_completion (const char *text, int start, int end)
4030 char **matches = NULL;
4032 #ifdef HAVE_LIBREADLINE
4034 matches = rl_completion_matches (text, generator);
4041 (* Generate the POD documentation for guestfish. *)
4042 and generate_fish_actions_pod () =
4043 let all_functions_sorted =
4045 fun (_, _, _, flags, _, _, _) -> not (List.mem NotInFish flags)
4046 ) all_functions_sorted in
4048 let rex = Str.regexp "C<guestfs_\\([^>]+\\)>" in
4051 fun (name, style, _, flags, _, _, longdesc) ->
4053 Str.global_substitute rex (
4056 try Str.matched_group 1 s
4058 failwithf "error substituting C<guestfs_...> in longdesc of function %s" name in
4059 "C<" ^ replace_char sub '_' '-' ^ ">"
4061 let name = replace_char name '_' '-' in
4063 try find_map (function FishAlias n -> Some n | _ -> None) flags
4064 with Not_found -> name in
4066 pr "=head2 %s" name;
4067 if name <> alias then
4074 | String n -> pr " %s" n
4075 | OptString n -> pr " %s" n
4076 | StringList n -> pr " '%s ...'" n
4077 | Bool _ -> pr " true|false"
4078 | Int n -> pr " %s" n
4079 | FileIn n | FileOut n -> pr " (%s|-)" n
4083 pr "%s\n\n" longdesc;
4085 if List.exists (function FileIn _ | FileOut _ -> true
4086 | _ -> false) (snd style) then
4087 pr "Use C<-> instead of a filename to read/write from stdin/stdout.\n\n";
4089 if List.mem ProtocolLimitWarning flags then
4090 pr "%s\n\n" protocol_limit_warning;
4092 if List.mem DangerWillRobinson flags then
4093 pr "%s\n\n" danger_will_robinson
4094 ) all_functions_sorted
4096 (* Generate a C function prototype. *)
4097 and generate_prototype ?(extern = true) ?(static = false) ?(semicolon = true)
4098 ?(single_line = false) ?(newline = false) ?(in_daemon = false)
4100 ?handle name style =
4101 if extern then pr "extern ";
4102 if static then pr "static ";
4103 (match fst style with
4105 | RInt _ -> pr "int "
4106 | RInt64 _ -> pr "int64_t "
4107 | RBool _ -> pr "int "
4108 | RConstString _ -> pr "const char *"
4109 | RString _ -> pr "char *"
4110 | RStringList _ | RHashtable _ -> pr "char **"
4112 if not in_daemon then pr "struct guestfs_int_bool *"
4113 else pr "guestfs_%s_ret *" name
4115 if not in_daemon then pr "struct guestfs_lvm_pv_list *"
4116 else pr "guestfs_lvm_int_pv_list *"
4118 if not in_daemon then pr "struct guestfs_lvm_vg_list *"
4119 else pr "guestfs_lvm_int_vg_list *"
4121 if not in_daemon then pr "struct guestfs_lvm_lv_list *"
4122 else pr "guestfs_lvm_int_lv_list *"
4124 if not in_daemon then pr "struct guestfs_stat *"
4125 else pr "guestfs_int_stat *"
4127 if not in_daemon then pr "struct guestfs_statvfs *"
4128 else pr "guestfs_int_statvfs *"
4130 pr "%s%s (" prefix name;
4131 if handle = None && List.length (snd style) = 0 then
4134 let comma = ref false in
4137 | Some handle -> pr "guestfs_h *%s" handle; comma := true
4141 if single_line then pr ", " else pr ",\n\t\t"
4148 | OptString n -> next (); pr "const char *%s" n
4149 | StringList n -> next (); pr "char * const* const %s" n
4150 | Bool n -> next (); pr "int %s" n
4151 | Int n -> next (); pr "int %s" n
4154 if not in_daemon then (next (); pr "const char *%s" n)
4158 if semicolon then pr ";";
4159 if newline then pr "\n"
4161 (* Generate C call arguments, eg "(handle, foo, bar)" *)
4162 and generate_call_args ?handle args =
4164 let comma = ref false in
4167 | Some handle -> pr "%s" handle; comma := true
4171 if !comma then pr ", ";
4173 pr "%s" (name_of_argt arg)
4177 (* Generate the OCaml bindings interface. *)
4178 and generate_ocaml_mli () =
4179 generate_header OCamlStyle LGPLv2;
4182 (** For API documentation you should refer to the C API
4183 in the guestfs(3) manual page. The OCaml API uses almost
4184 exactly the same calls. *)
4187 (** A [guestfs_h] handle. *)
4189 exception Error of string
4190 (** This exception is raised when there is an error. *)
4192 val create : unit -> t
4194 val close : t -> unit
4195 (** Handles are closed by the garbage collector when they become
4196 unreferenced, but callers can also call this in order to
4197 provide predictable cleanup. *)
4200 generate_ocaml_lvm_structure_decls ();
4202 generate_ocaml_stat_structure_decls ();
4206 fun (name, style, _, _, _, shortdesc, _) ->
4207 generate_ocaml_prototype name style;
4208 pr "(** %s *)\n" shortdesc;
4212 (* Generate the OCaml bindings implementation. *)
4213 and generate_ocaml_ml () =
4214 generate_header OCamlStyle LGPLv2;
4218 exception Error of string
4219 external create : unit -> t = \"ocaml_guestfs_create\"
4220 external close : t -> unit = \"ocaml_guestfs_close\"
4223 Callback.register_exception \"ocaml_guestfs_error\" (Error \"\")
4227 generate_ocaml_lvm_structure_decls ();
4229 generate_ocaml_stat_structure_decls ();
4233 fun (name, style, _, _, _, shortdesc, _) ->
4234 generate_ocaml_prototype ~is_external:true name style;
4237 (* Generate the OCaml bindings C implementation. *)
4238 and generate_ocaml_c () =
4239 generate_header CStyle LGPLv2;
4246 #include <caml/config.h>
4247 #include <caml/alloc.h>
4248 #include <caml/callback.h>
4249 #include <caml/fail.h>
4250 #include <caml/memory.h>
4251 #include <caml/mlvalues.h>
4252 #include <caml/signals.h>
4254 #include <guestfs.h>
4256 #include \"guestfs_c.h\"
4258 /* Copy a hashtable of string pairs into an assoc-list. We return
4259 * the list in reverse order, but hashtables aren't supposed to be
4262 static CAMLprim value
4263 copy_table (char * const * argv)
4266 CAMLlocal5 (rv, pairv, kv, vv, cons);
4270 for (i = 0; argv[i] != NULL; i += 2) {
4271 kv = caml_copy_string (argv[i]);
4272 vv = caml_copy_string (argv[i+1]);
4273 pairv = caml_alloc (2, 0);
4274 Store_field (pairv, 0, kv);
4275 Store_field (pairv, 1, vv);
4276 cons = caml_alloc (2, 0);
4277 Store_field (cons, 1, rv);
4279 Store_field (cons, 0, pairv);
4287 (* LVM struct copy functions. *)
4290 let has_optpercent_col =
4291 List.exists (function (_, `OptPercent) -> true | _ -> false) cols in
4293 pr "static CAMLprim value\n";
4294 pr "copy_lvm_%s (const struct guestfs_lvm_%s *%s)\n" typ typ typ;
4296 pr " CAMLparam0 ();\n";
4297 if has_optpercent_col then
4298 pr " CAMLlocal3 (rv, v, v2);\n"
4300 pr " CAMLlocal2 (rv, v);\n";
4302 pr " rv = caml_alloc (%d, 0);\n" (List.length cols);
4307 pr " v = caml_copy_string (%s->%s);\n" typ name
4309 pr " v = caml_alloc_string (32);\n";
4310 pr " memcpy (String_val (v), %s->%s, 32);\n" typ name
4313 pr " v = caml_copy_int64 (%s->%s);\n" typ name
4314 | name, `OptPercent ->
4315 pr " if (%s->%s >= 0) { /* Some %s */\n" typ name name;
4316 pr " v2 = caml_copy_double (%s->%s);\n" typ name;
4317 pr " v = caml_alloc (1, 0);\n";
4318 pr " Store_field (v, 0, v2);\n";
4319 pr " } else /* None */\n";
4320 pr " v = Val_int (0);\n";
4322 pr " Store_field (rv, %d, v);\n" i
4324 pr " CAMLreturn (rv);\n";
4328 pr "static CAMLprim value\n";
4329 pr "copy_lvm_%s_list (const struct guestfs_lvm_%s_list *%ss)\n"
4332 pr " CAMLparam0 ();\n";
4333 pr " CAMLlocal2 (rv, v);\n";
4336 pr " if (%ss->len == 0)\n" typ;
4337 pr " CAMLreturn (Atom (0));\n";
4339 pr " rv = caml_alloc (%ss->len, 0);\n" typ;
4340 pr " for (i = 0; i < %ss->len; ++i) {\n" typ;
4341 pr " v = copy_lvm_%s (&%ss->val[i]);\n" typ typ;
4342 pr " caml_modify (&Field (rv, i), v);\n";
4344 pr " CAMLreturn (rv);\n";
4348 ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
4350 (* Stat copy functions. *)
4353 pr "static CAMLprim value\n";
4354 pr "copy_%s (const struct guestfs_%s *%s)\n" typ typ typ;
4356 pr " CAMLparam0 ();\n";
4357 pr " CAMLlocal2 (rv, v);\n";
4359 pr " rv = caml_alloc (%d, 0);\n" (List.length cols);
4364 pr " v = caml_copy_int64 (%s->%s);\n" typ name
4366 pr " Store_field (rv, %d, v);\n" i
4368 pr " CAMLreturn (rv);\n";
4371 ) ["stat", stat_cols; "statvfs", statvfs_cols];
4375 fun (name, style, _, _, _, _, _) ->
4377 "gv" :: List.map (fun arg -> name_of_argt arg ^ "v") (snd style) in
4379 pr "CAMLprim value\n";
4380 pr "ocaml_guestfs_%s (value %s" name (List.hd params);
4381 List.iter (pr ", value %s") (List.tl params);
4386 | [p1; p2; p3; p4; p5] ->
4387 pr " CAMLparam5 (%s);\n" (String.concat ", " params)
4388 | p1 :: p2 :: p3 :: p4 :: p5 :: rest ->
4389 pr " CAMLparam5 (%s);\n" (String.concat ", " [p1; p2; p3; p4; p5]);
4390 pr " CAMLxparam%d (%s);\n"
4391 (List.length rest) (String.concat ", " rest)
4393 pr " CAMLparam%d (%s);\n" (List.length ps) (String.concat ", " ps)
4395 pr " CAMLlocal1 (rv);\n";
4398 pr " guestfs_h *g = Guestfs_val (gv);\n";
4399 pr " if (g == NULL)\n";
4400 pr " caml_failwith (\"%s: used handle after closing it\");\n" name;
4408 pr " const char *%s = String_val (%sv);\n" n n
4410 pr " const char *%s =\n" n;
4411 pr " %sv != Val_int (0) ? String_val (Field (%sv, 0)) : NULL;\n"
4414 pr " char **%s = ocaml_guestfs_strings_val (g, %sv);\n" n n
4416 pr " int %s = Bool_val (%sv);\n" n n
4418 pr " int %s = Int_val (%sv);\n" n n
4421 match fst style with
4422 | RErr -> pr " int r;\n"; "-1"
4423 | RInt _ -> pr " int r;\n"; "-1"
4424 | RInt64 _ -> pr " int64_t r;\n"; "-1"
4425 | RBool _ -> pr " int r;\n"; "-1"
4426 | RConstString _ -> pr " const char *r;\n"; "NULL"
4427 | RString _ -> pr " char *r;\n"; "NULL"
4433 pr " struct guestfs_int_bool *r;\n"; "NULL"
4435 pr " struct guestfs_lvm_pv_list *r;\n"; "NULL"
4437 pr " struct guestfs_lvm_vg_list *r;\n"; "NULL"
4439 pr " struct guestfs_lvm_lv_list *r;\n"; "NULL"
4441 pr " struct guestfs_stat *r;\n"; "NULL"
4443 pr " struct guestfs_statvfs *r;\n"; "NULL"
4450 pr " caml_enter_blocking_section ();\n";
4451 pr " r = guestfs_%s " name;
4452 generate_call_args ~handle:"g" (snd style);
4454 pr " caml_leave_blocking_section ();\n";
4459 pr " ocaml_guestfs_free_strings (%s);\n" n;
4460 | String _ | OptString _ | Bool _ | Int _ | FileIn _ | FileOut _ -> ()
4463 pr " if (r == %s)\n" error_code;
4464 pr " ocaml_guestfs_raise_error (g, \"%s\");\n" name;
4467 (match fst style with
4468 | RErr -> pr " rv = Val_unit;\n"
4469 | RInt _ -> pr " rv = Val_int (r);\n"
4471 pr " rv = caml_copy_int64 (r);\n"
4472 | RBool _ -> pr " rv = Val_bool (r);\n"
4473 | RConstString _ -> pr " rv = caml_copy_string (r);\n"
4475 pr " rv = caml_copy_string (r);\n";
4478 pr " rv = caml_copy_string_array ((const char **) r);\n";
4479 pr " for (i = 0; r[i] != NULL; ++i) free (r[i]);\n";
4482 pr " rv = caml_alloc (2, 0);\n";
4483 pr " Store_field (rv, 0, Val_int (r->i));\n";
4484 pr " Store_field (rv, 1, Val_bool (r->b));\n";
4485 pr " guestfs_free_int_bool (r);\n";
4487 pr " rv = copy_lvm_pv_list (r);\n";
4488 pr " guestfs_free_lvm_pv_list (r);\n";
4490 pr " rv = copy_lvm_vg_list (r);\n";
4491 pr " guestfs_free_lvm_vg_list (r);\n";
4493 pr " rv = copy_lvm_lv_list (r);\n";
4494 pr " guestfs_free_lvm_lv_list (r);\n";
4496 pr " rv = copy_stat (r);\n";
4499 pr " rv = copy_statvfs (r);\n";
4502 pr " rv = copy_table (r);\n";
4503 pr " for (i = 0; r[i] != NULL; ++i) free (r[i]);\n";
4507 pr " CAMLreturn (rv);\n";
4511 if List.length params > 5 then (
4512 pr "CAMLprim value\n";
4513 pr "ocaml_guestfs_%s_byte (value *argv, int argn)\n" name;
4515 pr " return ocaml_guestfs_%s (argv[0]" name;
4516 iteri (fun i _ -> pr ", argv[%d]" i) (List.tl params);
4523 and generate_ocaml_lvm_structure_decls () =
4526 pr "type lvm_%s = {\n" typ;
4529 | name, `String -> pr " %s : string;\n" name
4530 | name, `UUID -> pr " %s : string;\n" name
4531 | name, `Bytes -> pr " %s : int64;\n" name
4532 | name, `Int -> pr " %s : int64;\n" name
4533 | name, `OptPercent -> pr " %s : float option;\n" name
4537 ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols]
4539 and generate_ocaml_stat_structure_decls () =
4542 pr "type %s = {\n" typ;
4545 | name, `Int -> pr " %s : int64;\n" name
4549 ) ["stat", stat_cols; "statvfs", statvfs_cols]
4551 and generate_ocaml_prototype ?(is_external = false) name style =
4552 if is_external then pr "external " else pr "val ";
4553 pr "%s : t -> " name;
4556 | String _ | FileIn _ | FileOut _ -> pr "string -> "
4557 | OptString _ -> pr "string option -> "
4558 | StringList _ -> pr "string array -> "
4559 | Bool _ -> pr "bool -> "
4560 | Int _ -> pr "int -> "
4562 (match fst style with
4563 | RErr -> pr "unit" (* all errors are turned into exceptions *)
4564 | RInt _ -> pr "int"
4565 | RInt64 _ -> pr "int64"
4566 | RBool _ -> pr "bool"
4567 | RConstString _ -> pr "string"
4568 | RString _ -> pr "string"
4569 | RStringList _ -> pr "string array"
4570 | RIntBool _ -> pr "int * bool"
4571 | RPVList _ -> pr "lvm_pv array"
4572 | RVGList _ -> pr "lvm_vg array"
4573 | RLVList _ -> pr "lvm_lv array"
4574 | RStat _ -> pr "stat"
4575 | RStatVFS _ -> pr "statvfs"
4576 | RHashtable _ -> pr "(string * string) list"
4578 if is_external then (
4580 if List.length (snd style) + 1 > 5 then
4581 pr "\"ocaml_guestfs_%s_byte\" " name;
4582 pr "\"ocaml_guestfs_%s\"" name
4586 (* Generate Perl xs code, a sort of crazy variation of C with macros. *)
4587 and generate_perl_xs () =
4588 generate_header CStyle LGPLv2;
4591 #include \"EXTERN.h\"
4595 #include <guestfs.h>
4598 #define PRId64 \"lld\"
4602 my_newSVll(long long val) {
4603 #ifdef USE_64_BIT_ALL
4604 return newSViv(val);
4608 len = snprintf(buf, 100, \"%%\" PRId64, val);
4609 return newSVpv(buf, len);
4614 #define PRIu64 \"llu\"
4618 my_newSVull(unsigned long long val) {
4619 #ifdef USE_64_BIT_ALL
4620 return newSVuv(val);
4624 len = snprintf(buf, 100, \"%%\" PRIu64, val);
4625 return newSVpv(buf, len);
4629 /* http://www.perlmonks.org/?node_id=680842 */
4631 XS_unpack_charPtrPtr (SV *arg) {
4636 if (!arg || !SvOK (arg) || !SvROK (arg) || SvTYPE (SvRV (arg)) != SVt_PVAV)
4637 croak (\"array reference expected\");
4639 av = (AV *)SvRV (arg);
4640 ret = malloc (av_len (av) + 1 + 1);
4642 croak (\"malloc failed\");
4644 for (i = 0; i <= av_len (av); i++) {
4645 SV **elem = av_fetch (av, i, 0);
4647 if (!elem || !*elem)
4648 croak (\"missing element in list\");
4650 ret[i] = SvPV_nolen (*elem);
4658 MODULE = Sys::Guestfs PACKAGE = Sys::Guestfs
4663 RETVAL = guestfs_create ();
4665 croak (\"could not create guestfs handle\");
4666 guestfs_set_error_handler (RETVAL, NULL, NULL);
4679 fun (name, style, _, _, _, _, _) ->
4680 (match fst style with
4681 | RErr -> pr "void\n"
4682 | RInt _ -> pr "SV *\n"
4683 | RInt64 _ -> pr "SV *\n"
4684 | RBool _ -> pr "SV *\n"
4685 | RConstString _ -> pr "SV *\n"
4686 | RString _ -> pr "SV *\n"
4689 | RPVList _ | RVGList _ | RLVList _
4690 | RStat _ | RStatVFS _
4692 pr "void\n" (* all lists returned implictly on the stack *)
4694 (* Call and arguments. *)
4696 generate_call_args ~handle:"g" (snd style);
4698 pr " guestfs_h *g;\n";
4701 | String n | FileIn n | FileOut n -> pr " char *%s;\n" n
4702 | OptString n -> pr " char *%s;\n" n
4703 | StringList n -> pr " char **%s;\n" n
4704 | Bool n -> pr " int %s;\n" n
4705 | Int n -> pr " int %s;\n" n
4708 let do_cleanups () =
4711 | String _ | OptString _ | Bool _ | Int _
4712 | FileIn _ | FileOut _ -> ()
4713 | StringList n -> pr " free (%s);\n" n
4718 (match fst style with
4723 pr " r = guestfs_%s " name;
4724 generate_call_args ~handle:"g" (snd style);
4727 pr " if (r == -1)\n";
4728 pr " croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
4734 pr " %s = guestfs_%s " n name;
4735 generate_call_args ~handle:"g" (snd style);
4738 pr " if (%s == -1)\n" n;
4739 pr " croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
4740 pr " RETVAL = newSViv (%s);\n" n;
4745 pr " int64_t %s;\n" n;
4747 pr " %s = guestfs_%s " n name;
4748 generate_call_args ~handle:"g" (snd style);
4751 pr " if (%s == -1)\n" n;
4752 pr " croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
4753 pr " RETVAL = my_newSVll (%s);\n" n;
4758 pr " const char *%s;\n" n;
4760 pr " %s = guestfs_%s " n name;
4761 generate_call_args ~handle:"g" (snd style);
4764 pr " if (%s == NULL)\n" n;
4765 pr " croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
4766 pr " RETVAL = newSVpv (%s, 0);\n" n;
4771 pr " char *%s;\n" n;
4773 pr " %s = guestfs_%s " n name;
4774 generate_call_args ~handle:"g" (snd style);
4777 pr " if (%s == NULL)\n" n;
4778 pr " croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
4779 pr " RETVAL = newSVpv (%s, 0);\n" n;
4780 pr " free (%s);\n" n;
4783 | RStringList n | RHashtable n ->
4785 pr " char **%s;\n" n;
4788 pr " %s = guestfs_%s " n name;
4789 generate_call_args ~handle:"g" (snd style);
4792 pr " if (%s == NULL)\n" n;
4793 pr " croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
4794 pr " for (n = 0; %s[n] != NULL; ++n) /**/;\n" n;
4795 pr " EXTEND (SP, n);\n";
4796 pr " for (i = 0; i < n; ++i) {\n";
4797 pr " PUSHs (sv_2mortal (newSVpv (%s[i], 0)));\n" n;
4798 pr " free (%s[i]);\n" n;
4800 pr " free (%s);\n" n;
4803 pr " struct guestfs_int_bool *r;\n";
4805 pr " r = guestfs_%s " name;
4806 generate_call_args ~handle:"g" (snd style);
4809 pr " if (r == NULL)\n";
4810 pr " croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
4811 pr " EXTEND (SP, 2);\n";
4812 pr " PUSHs (sv_2mortal (newSViv (r->i)));\n";
4813 pr " PUSHs (sv_2mortal (newSViv (r->b)));\n";
4814 pr " guestfs_free_int_bool (r);\n";
4816 generate_perl_lvm_code "pv" pv_cols name style n do_cleanups
4818 generate_perl_lvm_code "vg" vg_cols name style n do_cleanups
4820 generate_perl_lvm_code "lv" lv_cols name style n do_cleanups
4822 generate_perl_stat_code "stat" stat_cols name style n do_cleanups
4824 generate_perl_stat_code
4825 "statvfs" statvfs_cols name style n do_cleanups
4831 and generate_perl_lvm_code typ cols name style n do_cleanups =
4833 pr " struct guestfs_lvm_%s_list *%s;\n" typ n;
4837 pr " %s = guestfs_%s " n name;
4838 generate_call_args ~handle:"g" (snd style);
4841 pr " if (%s == NULL)\n" n;
4842 pr " croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
4843 pr " EXTEND (SP, %s->len);\n" n;
4844 pr " for (i = 0; i < %s->len; ++i) {\n" n;
4845 pr " hv = newHV ();\n";
4849 pr " (void) hv_store (hv, \"%s\", %d, newSVpv (%s->val[i].%s, 0), 0);\n"
4850 name (String.length name) n name
4852 pr " (void) hv_store (hv, \"%s\", %d, newSVpv (%s->val[i].%s, 32), 0);\n"
4853 name (String.length name) n name
4855 pr " (void) hv_store (hv, \"%s\", %d, my_newSVull (%s->val[i].%s), 0);\n"
4856 name (String.length name) n name
4858 pr " (void) hv_store (hv, \"%s\", %d, my_newSVll (%s->val[i].%s), 0);\n"
4859 name (String.length name) n name
4860 | name, `OptPercent ->
4861 pr " (void) hv_store (hv, \"%s\", %d, newSVnv (%s->val[i].%s), 0);\n"
4862 name (String.length name) n name
4864 pr " PUSHs (sv_2mortal ((SV *) hv));\n";
4866 pr " guestfs_free_lvm_%s_list (%s);\n" typ n
4868 and generate_perl_stat_code typ cols name style n do_cleanups =
4870 pr " struct guestfs_%s *%s;\n" typ n;
4872 pr " %s = guestfs_%s " n name;
4873 generate_call_args ~handle:"g" (snd style);
4876 pr " if (%s == NULL)\n" n;
4877 pr " croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
4878 pr " EXTEND (SP, %d);\n" (List.length cols);
4882 pr " PUSHs (sv_2mortal (my_newSVll (%s->%s)));\n" n name
4884 pr " free (%s);\n" n
4886 (* Generate Sys/Guestfs.pm. *)
4887 and generate_perl_pm () =
4888 generate_header HashStyle LGPLv2;
4895 Sys::Guestfs - Perl bindings for libguestfs
4901 my $h = Sys::Guestfs->new ();
4902 $h->add_drive ('guest.img');
4905 $h->mount ('/dev/sda1', '/');
4906 $h->touch ('/hello');
4911 The C<Sys::Guestfs> module provides a Perl XS binding to the
4912 libguestfs API for examining and modifying virtual machine
4915 Amongst the things this is good for: making batch configuration
4916 changes to guests, getting disk used/free statistics (see also:
4917 virt-df), migrating between virtualization systems (see also:
4918 virt-p2v), performing partial backups, performing partial guest
4919 clones, cloning guests and changing registry/UUID/hostname info, and
4922 Libguestfs uses Linux kernel and qemu code, and can access any type of
4923 guest filesystem that Linux and qemu can, including but not limited
4924 to: ext2/3/4, btrfs, FAT and NTFS, LVM, many different disk partition
4925 schemes, qcow, qcow2, vmdk.
4927 Libguestfs provides ways to enumerate guest storage (eg. partitions,
4928 LVs, what filesystem is in each LV, etc.). It can also run commands
4929 in the context of the guest. Also you can access filesystems over FTP.
4933 All errors turn into calls to C<croak> (see L<Carp(3)>).
4941 package Sys::Guestfs;
4947 XSLoader::load ('Sys::Guestfs');
4949 =item $h = Sys::Guestfs->new ();
4951 Create a new guestfs handle.
4957 my $class = ref ($proto) || $proto;
4959 my $self = Sys::Guestfs::_create ();
4960 bless $self, $class;
4966 (* Actions. We only need to print documentation for these as
4967 * they are pulled in from the XS code automatically.
4970 fun (name, style, _, flags, _, _, longdesc) ->
4971 let longdesc = replace_str longdesc "C<guestfs_" "C<$h-E<gt>" in
4973 generate_perl_prototype name style;
4975 pr "%s\n\n" longdesc;
4976 if List.mem ProtocolLimitWarning flags then
4977 pr "%s\n\n" protocol_limit_warning;
4978 if List.mem DangerWillRobinson flags then
4979 pr "%s\n\n" danger_will_robinson
4980 ) all_functions_sorted;
4992 Copyright (C) 2009 Red Hat Inc.
4996 Please see the file COPYING.LIB for the full license.
5000 L<guestfs(3)>, L<guestfish(1)>.
5005 and generate_perl_prototype name style =
5006 (match fst style with
5012 | RString n -> pr "$%s = " n
5013 | RIntBool (n, m) -> pr "($%s, $%s) = " n m
5017 | RLVList n -> pr "@%s = " n
5020 | RHashtable n -> pr "%%%s = " n
5023 let comma = ref false in
5026 if !comma then pr ", ";
5029 | String n | OptString n | Bool n | Int n | FileIn n | FileOut n ->
5036 (* Generate Python C module. *)
5037 and generate_python_c () =
5038 generate_header CStyle LGPLv2;
5047 #include \"guestfs.h\"
5055 get_handle (PyObject *obj)
5058 assert (obj != Py_None);
5059 return ((Pyguestfs_Object *) obj)->g;
5063 put_handle (guestfs_h *g)
5067 PyCObject_FromVoidPtrAndDesc ((void *) g, (char *) \"guestfs_h\", NULL);
5070 /* This list should be freed (but not the strings) after use. */
5071 static const char **
5072 get_string_list (PyObject *obj)
5079 if (!PyList_Check (obj)) {
5080 PyErr_SetString (PyExc_RuntimeError, \"expecting a list parameter\");
5084 len = PyList_Size (obj);
5085 r = malloc (sizeof (char *) * (len+1));
5087 PyErr_SetString (PyExc_RuntimeError, \"get_string_list: out of memory\");
5091 for (i = 0; i < len; ++i)
5092 r[i] = PyString_AsString (PyList_GetItem (obj, i));
5099 put_string_list (char * const * const argv)
5104 for (argc = 0; argv[argc] != NULL; ++argc)
5107 list = PyList_New (argc);
5108 for (i = 0; i < argc; ++i)
5109 PyList_SetItem (list, i, PyString_FromString (argv[i]));
5115 put_table (char * const * const argv)
5117 PyObject *list, *item;
5120 for (argc = 0; argv[argc] != NULL; ++argc)
5123 list = PyList_New (argc >> 1);
5124 for (i = 0; i < argc; i += 2) {
5125 item = PyTuple_New (2);
5126 PyTuple_SetItem (item, 0, PyString_FromString (argv[i]));
5127 PyTuple_SetItem (item, 1, PyString_FromString (argv[i+1]));
5128 PyList_SetItem (list, i >> 1, item);
5135 free_strings (char **argv)
5139 for (argc = 0; argv[argc] != NULL; ++argc)
5145 py_guestfs_create (PyObject *self, PyObject *args)
5149 g = guestfs_create ();
5151 PyErr_SetString (PyExc_RuntimeError,
5152 \"guestfs.create: failed to allocate handle\");
5155 guestfs_set_error_handler (g, NULL, NULL);
5156 return put_handle (g);
5160 py_guestfs_close (PyObject *self, PyObject *args)
5165 if (!PyArg_ParseTuple (args, (char *) \"O:guestfs_close\", &py_g))
5167 g = get_handle (py_g);
5171 Py_INCREF (Py_None);
5177 (* LVM structures, turned into Python dictionaries. *)
5180 pr "static PyObject *\n";
5181 pr "put_lvm_%s (struct guestfs_lvm_%s *%s)\n" typ typ typ;
5183 pr " PyObject *dict;\n";
5185 pr " dict = PyDict_New ();\n";
5189 pr " PyDict_SetItemString (dict, \"%s\",\n" name;
5190 pr " PyString_FromString (%s->%s));\n"
5193 pr " PyDict_SetItemString (dict, \"%s\",\n" name;
5194 pr " PyString_FromStringAndSize (%s->%s, 32));\n"
5197 pr " PyDict_SetItemString (dict, \"%s\",\n" name;
5198 pr " PyLong_FromUnsignedLongLong (%s->%s));\n"
5201 pr " PyDict_SetItemString (dict, \"%s\",\n" name;
5202 pr " PyLong_FromLongLong (%s->%s));\n"
5204 | name, `OptPercent ->
5205 pr " if (%s->%s >= 0)\n" typ name;
5206 pr " PyDict_SetItemString (dict, \"%s\",\n" name;
5207 pr " PyFloat_FromDouble ((double) %s->%s));\n"
5210 pr " Py_INCREF (Py_None);\n";
5211 pr " PyDict_SetItemString (dict, \"%s\", Py_None);" name;
5214 pr " return dict;\n";
5218 pr "static PyObject *\n";
5219 pr "put_lvm_%s_list (struct guestfs_lvm_%s_list *%ss)\n" typ typ typ;
5221 pr " PyObject *list;\n";
5224 pr " list = PyList_New (%ss->len);\n" typ;
5225 pr " for (i = 0; i < %ss->len; ++i)\n" typ;
5226 pr " PyList_SetItem (list, i, put_lvm_%s (&%ss->val[i]));\n" typ typ;
5227 pr " return list;\n";
5230 ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
5232 (* Stat structures, turned into Python dictionaries. *)
5235 pr "static PyObject *\n";
5236 pr "put_%s (struct guestfs_%s *%s)\n" typ typ typ;
5238 pr " PyObject *dict;\n";
5240 pr " dict = PyDict_New ();\n";
5244 pr " PyDict_SetItemString (dict, \"%s\",\n" name;
5245 pr " PyLong_FromLongLong (%s->%s));\n"
5248 pr " return dict;\n";
5251 ) ["stat", stat_cols; "statvfs", statvfs_cols];
5253 (* Python wrapper functions. *)
5255 fun (name, style, _, _, _, _, _) ->
5256 pr "static PyObject *\n";
5257 pr "py_guestfs_%s (PyObject *self, PyObject *args)\n" name;
5260 pr " PyObject *py_g;\n";
5261 pr " guestfs_h *g;\n";
5262 pr " PyObject *py_r;\n";
5265 match fst style with
5266 | RErr | RInt _ | RBool _ -> pr " int r;\n"; "-1"
5267 | RInt64 _ -> pr " int64_t r;\n"; "-1"
5268 | RConstString _ -> pr " const char *r;\n"; "NULL"
5269 | RString _ -> pr " char *r;\n"; "NULL"
5270 | RStringList _ | RHashtable _ -> pr " char **r;\n"; "NULL"
5271 | RIntBool _ -> pr " struct guestfs_int_bool *r;\n"; "NULL"
5272 | RPVList n -> pr " struct guestfs_lvm_pv_list *r;\n"; "NULL"
5273 | RVGList n -> pr " struct guestfs_lvm_vg_list *r;\n"; "NULL"
5274 | RLVList n -> pr " struct guestfs_lvm_lv_list *r;\n"; "NULL"
5275 | RStat n -> pr " struct guestfs_stat *r;\n"; "NULL"
5276 | RStatVFS n -> pr " struct guestfs_statvfs *r;\n"; "NULL" in
5280 | String n | FileIn n | FileOut n -> pr " const char *%s;\n" n
5281 | OptString n -> pr " const char *%s;\n" n
5283 pr " PyObject *py_%s;\n" n;
5284 pr " const char **%s;\n" n
5285 | Bool n -> pr " int %s;\n" n
5286 | Int n -> pr " int %s;\n" n
5291 (* Convert the parameters. *)
5292 pr " if (!PyArg_ParseTuple (args, (char *) \"O";
5295 | String _ | FileIn _ | FileOut _ -> pr "s"
5296 | OptString _ -> pr "z"
5297 | StringList _ -> pr "O"
5298 | Bool _ -> pr "i" (* XXX Python has booleans? *)
5301 pr ":guestfs_%s\",\n" name;
5305 | String n | FileIn n | FileOut n -> pr ", &%s" n
5306 | OptString n -> pr ", &%s" n
5307 | StringList n -> pr ", &py_%s" n
5308 | Bool n -> pr ", &%s" n
5309 | Int n -> pr ", &%s" n
5313 pr " return NULL;\n";
5315 pr " g = get_handle (py_g);\n";
5318 | String _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
5320 pr " %s = get_string_list (py_%s);\n" n n;
5321 pr " if (!%s) return NULL;\n" n
5326 pr " r = guestfs_%s " name;
5327 generate_call_args ~handle:"g" (snd style);
5332 | String _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
5334 pr " free (%s);\n" n
5337 pr " if (r == %s) {\n" error_code;
5338 pr " PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));\n";
5339 pr " return NULL;\n";
5343 (match fst style with
5345 pr " Py_INCREF (Py_None);\n";
5346 pr " py_r = Py_None;\n"
5348 | RBool _ -> pr " py_r = PyInt_FromLong ((long) r);\n"
5349 | RInt64 _ -> pr " py_r = PyLong_FromLongLong (r);\n"
5350 | RConstString _ -> pr " py_r = PyString_FromString (r);\n"
5352 pr " py_r = PyString_FromString (r);\n";
5355 pr " py_r = put_string_list (r);\n";
5356 pr " free_strings (r);\n"
5358 pr " py_r = PyTuple_New (2);\n";
5359 pr " PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));\n";
5360 pr " PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));\n";
5361 pr " guestfs_free_int_bool (r);\n"
5363 pr " py_r = put_lvm_pv_list (r);\n";
5364 pr " guestfs_free_lvm_pv_list (r);\n"
5366 pr " py_r = put_lvm_vg_list (r);\n";
5367 pr " guestfs_free_lvm_vg_list (r);\n"
5369 pr " py_r = put_lvm_lv_list (r);\n";
5370 pr " guestfs_free_lvm_lv_list (r);\n"
5372 pr " py_r = put_stat (r);\n";
5375 pr " py_r = put_statvfs (r);\n";
5378 pr " py_r = put_table (r);\n";
5379 pr " free_strings (r);\n"
5382 pr " return py_r;\n";
5387 (* Table of functions. *)
5388 pr "static PyMethodDef methods[] = {\n";
5389 pr " { (char *) \"create\", py_guestfs_create, METH_VARARGS, NULL },\n";
5390 pr " { (char *) \"close\", py_guestfs_close, METH_VARARGS, NULL },\n";
5392 fun (name, _, _, _, _, _, _) ->
5393 pr " { (char *) \"%s\", py_guestfs_%s, METH_VARARGS, NULL },\n"
5396 pr " { NULL, NULL, 0, NULL }\n";
5400 (* Init function. *)
5403 initlibguestfsmod (void)
5405 static int initialized = 0;
5407 if (initialized) return;
5408 Py_InitModule ((char *) \"libguestfsmod\", methods);
5413 (* Generate Python module. *)
5414 and generate_python_py () =
5415 generate_header HashStyle LGPLv2;
5418 u\"\"\"Python bindings for libguestfs
5421 g = guestfs.GuestFS ()
5422 g.add_drive (\"guest.img\")
5425 parts = g.list_partitions ()
5427 The guestfs module provides a Python binding to the libguestfs API
5428 for examining and modifying virtual machine disk images.
5430 Amongst the things this is good for: making batch configuration
5431 changes to guests, getting disk used/free statistics (see also:
5432 virt-df), migrating between virtualization systems (see also:
5433 virt-p2v), performing partial backups, performing partial guest
5434 clones, cloning guests and changing registry/UUID/hostname info, and
5437 Libguestfs uses Linux kernel and qemu code, and can access any type of
5438 guest filesystem that Linux and qemu can, including but not limited
5439 to: ext2/3/4, btrfs, FAT and NTFS, LVM, many different disk partition
5440 schemes, qcow, qcow2, vmdk.
5442 Libguestfs provides ways to enumerate guest storage (eg. partitions,
5443 LVs, what filesystem is in each LV, etc.). It can also run commands
5444 in the context of the guest. Also you can access filesystems over FTP.
5446 Errors which happen while using the API are turned into Python
5447 RuntimeError exceptions.
5449 To create a guestfs handle you usually have to perform the following
5452 # Create the handle, call add_drive at least once, and possibly
5453 # several times if the guest has multiple block devices:
5454 g = guestfs.GuestFS ()
5455 g.add_drive (\"guest.img\")
5457 # Launch the qemu subprocess and wait for it to become ready:
5461 # Now you can issue commands, for example:
5466 import libguestfsmod
5469 \"\"\"Instances of this class are libguestfs API handles.\"\"\"
5471 def __init__ (self):
5472 \"\"\"Create a new libguestfs handle.\"\"\"
5473 self._o = libguestfsmod.create ()
5476 libguestfsmod.close (self._o)
5481 fun (name, style, _, flags, _, _, longdesc) ->
5482 let doc = replace_str longdesc "C<guestfs_" "C<g." in
5484 match fst style with
5485 | RErr | RInt _ | RInt64 _ | RBool _ | RConstString _
5488 doc ^ "\n\nThis function returns a list of strings."
5490 doc ^ "\n\nThis function returns a tuple (int, bool).\n"
5492 doc ^ "\n\nThis function returns a list of PVs. Each PV is represented as a dictionary."
5494 doc ^ "\n\nThis function returns a list of VGs. Each VG is represented as a dictionary."
5496 doc ^ "\n\nThis function returns a list of LVs. Each LV is represented as a dictionary."
5498 doc ^ "\n\nThis function returns a dictionary, with keys matching the various fields in the stat structure."
5500 doc ^ "\n\nThis function returns a dictionary, with keys matching the various fields in the statvfs structure."
5502 doc ^ "\n\nThis function returns a dictionary." in
5504 if List.mem ProtocolLimitWarning flags then
5505 doc ^ "\n\n" ^ protocol_limit_warning
5508 if List.mem DangerWillRobinson flags then
5509 doc ^ "\n\n" ^ danger_will_robinson
5511 let doc = pod2text ~width:60 name doc in
5512 let doc = List.map (fun line -> replace_str line "\\" "\\\\") doc in
5513 let doc = String.concat "\n " doc in
5516 generate_call_args ~handle:"self" (snd style);
5518 pr " u\"\"\"%s\"\"\"\n" doc;
5519 pr " return libguestfsmod.%s " name;
5520 generate_call_args ~handle:"self._o" (snd style);
5525 (* Useful if you need the longdesc POD text as plain text. Returns a
5528 * This is the slowest thing about autogeneration.
5530 and pod2text ~width name longdesc =
5531 let filename, chan = Filename.open_temp_file "gen" ".tmp" in
5532 fprintf chan "=head1 %s\n\n%s\n" name longdesc;
5534 let cmd = sprintf "pod2text -w %d %s" width (Filename.quote filename) in
5535 let chan = Unix.open_process_in cmd in
5536 let lines = ref [] in
5538 let line = input_line chan in
5539 if i = 1 then (* discard the first line of output *)
5542 let line = triml line in
5543 lines := line :: !lines;
5546 let lines = try loop 1 with End_of_file -> List.rev !lines in
5547 Unix.unlink filename;
5548 match Unix.close_process_in chan with
5549 | Unix.WEXITED 0 -> lines
5551 failwithf "pod2text: process exited with non-zero status (%d)" i
5552 | Unix.WSIGNALED i | Unix.WSTOPPED i ->
5553 failwithf "pod2text: process signalled or stopped by signal %d" i
5555 (* Generate ruby bindings. *)
5556 and generate_ruby_c () =
5557 generate_header CStyle LGPLv2;
5565 #include \"guestfs.h\"
5567 #include \"extconf.h\"
5569 static VALUE m_guestfs; /* guestfs module */
5570 static VALUE c_guestfs; /* guestfs_h handle */
5571 static VALUE e_Error; /* used for all errors */
5573 static void ruby_guestfs_free (void *p)
5576 guestfs_close ((guestfs_h *) p);
5579 static VALUE ruby_guestfs_create (VALUE m)
5583 g = guestfs_create ();
5585 rb_raise (e_Error, \"failed to create guestfs handle\");
5587 /* Don't print error messages to stderr by default. */
5588 guestfs_set_error_handler (g, NULL, NULL);
5590 /* Wrap it, and make sure the close function is called when the
5593 return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
5596 static VALUE ruby_guestfs_close (VALUE gv)
5599 Data_Get_Struct (gv, guestfs_h, g);
5601 ruby_guestfs_free (g);
5602 DATA_PTR (gv) = NULL;
5610 fun (name, style, _, _, _, _, _) ->
5611 pr "static VALUE ruby_guestfs_%s (VALUE gv" name;
5612 List.iter (fun arg -> pr ", VALUE %sv" (name_of_argt arg)) (snd style);
5615 pr " guestfs_h *g;\n";
5616 pr " Data_Get_Struct (gv, guestfs_h, g);\n";
5618 pr " rb_raise (rb_eArgError, \"%%s: used handle after closing it\", \"%s\");\n"
5624 | String n | FileIn n | FileOut n ->
5625 pr " const char *%s = StringValueCStr (%sv);\n" n n;
5627 pr " rb_raise (rb_eTypeError, \"expected string for parameter %%s of %%s\",\n";
5628 pr " \"%s\", \"%s\");\n" n name
5630 pr " const char *%s = StringValueCStr (%sv);\n" n n
5634 pr " int i, len;\n";
5635 pr " len = RARRAY_LEN (%sv);\n" n;
5636 pr " %s = guestfs_safe_malloc (g, sizeof (char *) * (len+1));\n"
5638 pr " for (i = 0; i < len; ++i) {\n";
5639 pr " VALUE v = rb_ary_entry (%sv, i);\n" n;
5640 pr " %s[i] = StringValueCStr (v);\n" n;
5642 pr " %s[len] = NULL;\n" n;
5646 pr " int %s = NUM2INT (%sv);\n" n n
5651 match fst style with
5652 | RErr | RInt _ | RBool _ -> pr " int r;\n"; "-1"
5653 | RInt64 _ -> pr " int64_t r;\n"; "-1"
5654 | RConstString _ -> pr " const char *r;\n"; "NULL"
5655 | RString _ -> pr " char *r;\n"; "NULL"
5656 | RStringList _ | RHashtable _ -> pr " char **r;\n"; "NULL"
5657 | RIntBool _ -> pr " struct guestfs_int_bool *r;\n"; "NULL"
5658 | RPVList n -> pr " struct guestfs_lvm_pv_list *r;\n"; "NULL"
5659 | RVGList n -> pr " struct guestfs_lvm_vg_list *r;\n"; "NULL"
5660 | RLVList n -> pr " struct guestfs_lvm_lv_list *r;\n"; "NULL"
5661 | RStat n -> pr " struct guestfs_stat *r;\n"; "NULL"
5662 | RStatVFS n -> pr " struct guestfs_statvfs *r;\n"; "NULL" in
5665 pr " r = guestfs_%s " name;
5666 generate_call_args ~handle:"g" (snd style);
5671 | String _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
5673 pr " free (%s);\n" n
5676 pr " if (r == %s)\n" error_code;
5677 pr " rb_raise (e_Error, \"%%s\", guestfs_last_error (g));\n";
5680 (match fst style with
5682 pr " return Qnil;\n"
5683 | RInt _ | RBool _ ->
5684 pr " return INT2NUM (r);\n"
5686 pr " return ULL2NUM (r);\n"
5688 pr " return rb_str_new2 (r);\n";
5690 pr " VALUE rv = rb_str_new2 (r);\n";
5694 pr " int i, len = 0;\n";
5695 pr " for (i = 0; r[i] != NULL; ++i) len++;\n";
5696 pr " VALUE rv = rb_ary_new2 (len);\n";
5697 pr " for (i = 0; r[i] != NULL; ++i) {\n";
5698 pr " rb_ary_push (rv, rb_str_new2 (r[i]));\n";
5699 pr " free (r[i]);\n";
5704 pr " VALUE rv = rb_ary_new2 (2);\n";
5705 pr " rb_ary_push (rv, INT2NUM (r->i));\n";
5706 pr " rb_ary_push (rv, INT2NUM (r->b));\n";
5707 pr " guestfs_free_int_bool (r);\n";
5710 generate_ruby_lvm_code "pv" pv_cols
5712 generate_ruby_lvm_code "vg" vg_cols
5714 generate_ruby_lvm_code "lv" lv_cols
5716 pr " VALUE rv = rb_hash_new ();\n";
5720 pr " rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->%s));\n" name name
5725 pr " VALUE rv = rb_hash_new ();\n";
5729 pr " rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->%s));\n" name name
5734 pr " VALUE rv = rb_hash_new ();\n";
5736 pr " for (i = 0; r[i] != NULL; i+=2) {\n";
5737 pr " rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));\n";
5738 pr " free (r[i]);\n";
5739 pr " free (r[i+1]);\n";
5750 /* Initialize the module. */
5751 void Init__guestfs ()
5753 m_guestfs = rb_define_module (\"Guestfs\");
5754 c_guestfs = rb_define_class_under (m_guestfs, \"Guestfs\", rb_cObject);
5755 e_Error = rb_define_class_under (m_guestfs, \"Error\", rb_eStandardError);
5757 rb_define_module_function (m_guestfs, \"create\", ruby_guestfs_create, 0);
5758 rb_define_method (c_guestfs, \"close\", ruby_guestfs_close, 0);
5761 (* Define the rest of the methods. *)
5763 fun (name, style, _, _, _, _, _) ->
5764 pr " rb_define_method (c_guestfs, \"%s\",\n" name;
5765 pr " ruby_guestfs_%s, %d);\n" name (List.length (snd style))
5770 (* Ruby code to return an LVM struct list. *)
5771 and generate_ruby_lvm_code typ cols =
5772 pr " VALUE rv = rb_ary_new2 (r->len);\n";
5774 pr " for (i = 0; i < r->len; ++i) {\n";
5775 pr " VALUE hv = rb_hash_new ();\n";
5779 pr " rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_str_new2 (r->val[i].%s));\n" name name
5781 pr " rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_str_new (r->val[i].%s, 32));\n" name name
5784 pr " rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->val[i].%s));\n" name name
5785 | name, `OptPercent ->
5786 pr " rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_dbl2big (r->val[i].%s));\n" name name
5788 pr " rb_ary_push (rv, hv);\n";
5790 pr " guestfs_free_lvm_%s_list (r);\n" typ;
5793 (* Generate Java bindings GuestFS.java file. *)
5794 and generate_java_java () =
5795 generate_header CStyle LGPLv2;
5798 package com.redhat.et.libguestfs;
5800 import java.util.HashMap;
5801 import com.redhat.et.libguestfs.LibGuestFSException;
5802 import com.redhat.et.libguestfs.PV;
5803 import com.redhat.et.libguestfs.VG;
5804 import com.redhat.et.libguestfs.LV;
5805 import com.redhat.et.libguestfs.Stat;
5806 import com.redhat.et.libguestfs.StatVFS;
5807 import com.redhat.et.libguestfs.IntBool;
5810 * The GuestFS object is a libguestfs handle.
5814 public class GuestFS {
5815 // Load the native code.
5817 System.loadLibrary (\"guestfs_jni\");
5821 * The native guestfs_h pointer.
5826 * Create a libguestfs handle.
5828 * @throws LibGuestFSException
5830 public GuestFS () throws LibGuestFSException
5834 private native long _create () throws LibGuestFSException;
5837 * Close a libguestfs handle.
5839 * You can also leave handles to be collected by the garbage
5840 * collector, but this method ensures that the resources used
5841 * by the handle are freed up immediately. If you call any
5842 * other methods after closing the handle, you will get an
5845 * @throws LibGuestFSException
5847 public void close () throws LibGuestFSException
5853 private native void _close (long g) throws LibGuestFSException;
5855 public void finalize () throws LibGuestFSException
5863 fun (name, style, _, flags, _, shortdesc, longdesc) ->
5864 let doc = replace_str longdesc "C<guestfs_" "C<g." in
5866 if List.mem ProtocolLimitWarning flags then
5867 doc ^ "\n\n" ^ protocol_limit_warning
5870 if List.mem DangerWillRobinson flags then
5871 doc ^ "\n\n" ^ danger_will_robinson
5873 let doc = pod2text ~width:60 name doc in
5874 let doc = String.concat "\n * " doc in
5877 pr " * %s\n" shortdesc;
5880 pr " * @throws LibGuestFSException\n";
5883 generate_java_prototype ~public:true ~semicolon:false name style;
5886 pr " if (g == 0)\n";
5887 pr " throw new LibGuestFSException (\"%s: handle is closed\");\n"
5890 if fst style <> RErr then pr "return ";
5892 generate_call_args ~handle:"g" (snd style);
5896 generate_java_prototype ~privat:true ~native:true name style;
5903 and generate_java_prototype ?(public=false) ?(privat=false) ?(native=false)
5904 ?(semicolon=true) name style =
5905 if privat then pr "private ";
5906 if public then pr "public ";
5907 if native then pr "native ";
5910 (match fst style with
5911 | RErr -> pr "void ";
5912 | RInt _ -> pr "int ";
5913 | RInt64 _ -> pr "long ";
5914 | RBool _ -> pr "boolean ";
5915 | RConstString _ | RString _ -> pr "String ";
5916 | RStringList _ -> pr "String[] ";
5917 | RIntBool _ -> pr "IntBool ";
5918 | RPVList _ -> pr "PV[] ";
5919 | RVGList _ -> pr "VG[] ";
5920 | RLVList _ -> pr "LV[] ";
5921 | RStat _ -> pr "Stat ";
5922 | RStatVFS _ -> pr "StatVFS ";
5923 | RHashtable _ -> pr "HashMap<String,String> ";
5926 if native then pr "_%s " name else pr "%s " name;
5928 let needs_comma = ref false in
5937 if !needs_comma then pr ", ";
5938 needs_comma := true;
5955 pr " throws LibGuestFSException";
5956 if semicolon then pr ";"
5958 and generate_java_struct typ cols =
5959 generate_header CStyle LGPLv2;
5962 package com.redhat.et.libguestfs;
5965 * Libguestfs %s structure.
5976 | name, `UUID -> pr " public String %s;\n" name
5978 | name, `Int -> pr " public long %s;\n" name
5979 | name, `OptPercent ->
5980 pr " /* The next field is [0..100] or -1 meaning 'not present': */\n";
5981 pr " public float %s;\n" name
5986 and generate_java_c () =
5987 generate_header CStyle LGPLv2;
5994 #include \"com_redhat_et_libguestfs_GuestFS.h\"
5995 #include \"guestfs.h\"
5997 /* Note that this function returns. The exception is not thrown
5998 * until after the wrapper function returns.
6001 throw_exception (JNIEnv *env, const char *msg)
6004 cl = (*env)->FindClass (env,
6005 \"com/redhat/et/libguestfs/LibGuestFSException\");
6006 (*env)->ThrowNew (env, cl, msg);
6009 JNIEXPORT jlong JNICALL
6010 Java_com_redhat_et_libguestfs_GuestFS__1create
6011 (JNIEnv *env, jobject obj)
6015 g = guestfs_create ();
6017 throw_exception (env, \"GuestFS.create: failed to allocate handle\");
6020 guestfs_set_error_handler (g, NULL, NULL);
6021 return (jlong) (long) g;
6024 JNIEXPORT void JNICALL
6025 Java_com_redhat_et_libguestfs_GuestFS__1close
6026 (JNIEnv *env, jobject obj, jlong jg)
6028 guestfs_h *g = (guestfs_h *) (long) jg;
6035 fun (name, style, _, _, _, _, _) ->
6037 (match fst style with
6038 | RErr -> pr "void ";
6039 | RInt _ -> pr "jint ";
6040 | RInt64 _ -> pr "jlong ";
6041 | RBool _ -> pr "jboolean ";
6042 | RConstString _ | RString _ -> pr "jstring ";
6043 | RIntBool _ | RStat _ | RStatVFS _ | RHashtable _ ->
6045 | RStringList _ | RPVList _ | RVGList _ | RLVList _ ->
6049 pr "Java_com_redhat_et_libguestfs_GuestFS_";
6050 pr "%s" (replace_str ("_" ^ name) "_" "_1");
6052 pr " (JNIEnv *env, jobject obj, jlong jg";
6059 pr ", jstring j%s" n
6061 pr ", jobjectArray j%s" n
6063 pr ", jboolean j%s" n
6069 pr " guestfs_h *g = (guestfs_h *) (long) jg;\n";
6070 let error_code, no_ret =
6071 match fst style with
6072 | RErr -> pr " int r;\n"; "-1", ""
6074 | RInt _ -> pr " int r;\n"; "-1", "0"
6075 | RInt64 _ -> pr " int64_t r;\n"; "-1", "0"
6076 | RConstString _ -> pr " const char *r;\n"; "NULL", "NULL"
6078 pr " jstring jr;\n";
6079 pr " char *r;\n"; "NULL", "NULL"
6081 pr " jobjectArray jr;\n";
6084 pr " jstring jstr;\n";
6085 pr " char **r;\n"; "NULL", "NULL"
6087 pr " jobject jr;\n";
6089 pr " jfieldID fl;\n";
6090 pr " struct guestfs_int_bool *r;\n"; "NULL", "NULL"
6092 pr " jobject jr;\n";
6094 pr " jfieldID fl;\n";
6095 pr " struct guestfs_stat *r;\n"; "NULL", "NULL"
6097 pr " jobject jr;\n";
6099 pr " jfieldID fl;\n";
6100 pr " struct guestfs_statvfs *r;\n"; "NULL", "NULL"
6102 pr " jobjectArray jr;\n";
6104 pr " jfieldID fl;\n";
6105 pr " jobject jfl;\n";
6106 pr " struct guestfs_lvm_pv_list *r;\n"; "NULL", "NULL"
6108 pr " jobjectArray jr;\n";
6110 pr " jfieldID fl;\n";
6111 pr " jobject jfl;\n";
6112 pr " struct guestfs_lvm_vg_list *r;\n"; "NULL", "NULL"
6114 pr " jobjectArray jr;\n";
6116 pr " jfieldID fl;\n";
6117 pr " jobject jfl;\n";
6118 pr " struct guestfs_lvm_lv_list *r;\n"; "NULL", "NULL"
6119 | RHashtable _ -> pr " char **r;\n"; "NULL", "NULL" in
6126 pr " const char *%s;\n" n
6128 pr " int %s_len;\n" n;
6129 pr " const char **%s;\n" n
6136 (match fst style with
6137 | RStringList _ | RPVList _ | RVGList _ | RLVList _ -> true
6138 | RErr _ | RBool _ | RInt _ | RInt64 _ | RConstString _
6139 | RString _ | RIntBool _ | RStat _ | RStatVFS _
6140 | RHashtable _ -> false) ||
6141 List.exists (function StringList _ -> true | _ -> false) (snd style) in
6147 (* Get the parameters. *)
6154 pr " %s = (*env)->GetStringUTFChars (env, j%s, NULL);\n" n n
6156 pr " %s_len = (*env)->GetArrayLength (env, j%s);\n" n n;
6157 pr " %s = guestfs_safe_malloc (g, sizeof (char *) * (%s_len+1));\n" n n;
6158 pr " for (i = 0; i < %s_len; ++i) {\n" n;
6159 pr " jobject o = (*env)->GetObjectArrayElement (env, j%s, i);\n"
6161 pr " %s[i] = (*env)->GetStringUTFChars (env, o, NULL);\n" n;
6163 pr " %s[%s_len] = NULL;\n" n n;
6166 pr " %s = j%s;\n" n n
6169 (* Make the call. *)
6170 pr " r = guestfs_%s " name;
6171 generate_call_args ~handle:"g" (snd style);
6174 (* Release the parameters. *)
6181 pr " (*env)->ReleaseStringUTFChars (env, j%s, %s);\n" n n
6183 pr " for (i = 0; i < %s_len; ++i) {\n" n;
6184 pr " jobject o = (*env)->GetObjectArrayElement (env, j%s, i);\n"
6186 pr " (*env)->ReleaseStringUTFChars (env, o, %s[i]);\n" n;
6188 pr " free (%s);\n" n
6193 (* Check for errors. *)
6194 pr " if (r == %s) {\n" error_code;
6195 pr " throw_exception (env, guestfs_last_error (g));\n";
6196 pr " return %s;\n" no_ret;
6200 (match fst style with
6202 | RInt _ -> pr " return (jint) r;\n"
6203 | RBool _ -> pr " return (jboolean) r;\n"
6204 | RInt64 _ -> pr " return (jlong) r;\n"
6205 | RConstString _ -> pr " return (*env)->NewStringUTF (env, r);\n"
6207 pr " jr = (*env)->NewStringUTF (env, r);\n";
6211 pr " for (r_len = 0; r[r_len] != NULL; ++r_len) ;\n";
6212 pr " cl = (*env)->FindClass (env, \"java/lang/String\");\n";
6213 pr " jstr = (*env)->NewStringUTF (env, \"\");\n";
6214 pr " jr = (*env)->NewObjectArray (env, r_len, cl, jstr);\n";
6215 pr " for (i = 0; i < r_len; ++i) {\n";
6216 pr " jstr = (*env)->NewStringUTF (env, r[i]);\n";
6217 pr " (*env)->SetObjectArrayElement (env, jr, i, jstr);\n";
6218 pr " free (r[i]);\n";
6223 pr " cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/IntBool\");\n";
6224 pr " jr = (*env)->AllocObject (env, cl);\n";
6225 pr " fl = (*env)->GetFieldID (env, cl, \"i\", \"I\");\n";
6226 pr " (*env)->SetIntField (env, jr, fl, r->i);\n";
6227 pr " fl = (*env)->GetFieldID (env, cl, \"i\", \"Z\");\n";
6228 pr " (*env)->SetBooleanField (env, jr, fl, r->b);\n";
6229 pr " guestfs_free_int_bool (r);\n";
6232 pr " cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/Stat\");\n";
6233 pr " jr = (*env)->AllocObject (env, cl);\n";
6237 pr " fl = (*env)->GetFieldID (env, cl, \"%s\", \"J\");\n"
6239 pr " (*env)->SetLongField (env, jr, fl, r->%s);\n" name;
6244 pr " cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/StatVFS\");\n";
6245 pr " jr = (*env)->AllocObject (env, cl);\n";
6249 pr " fl = (*env)->GetFieldID (env, cl, \"%s\", \"J\");\n"
6251 pr " (*env)->SetLongField (env, jr, fl, r->%s);\n" name;
6256 generate_java_lvm_return "pv" "PV" pv_cols
6258 generate_java_lvm_return "vg" "VG" vg_cols
6260 generate_java_lvm_return "lv" "LV" lv_cols
6263 pr " throw_exception (env, \"%s: internal error: please let us know how to make a Java HashMap from JNI bindings!\");\n" name;
6264 pr " return NULL;\n"
6271 and generate_java_lvm_return typ jtyp cols =
6272 pr " cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/%s\");\n" jtyp;
6273 pr " jr = (*env)->NewObjectArray (env, r->len, cl, NULL);\n";
6274 pr " for (i = 0; i < r->len; ++i) {\n";
6275 pr " jfl = (*env)->AllocObject (env, cl);\n";
6279 pr " fl = (*env)->GetFieldID (env, cl, \"%s\", \"Ljava/lang/String;\");\n" name;
6280 pr " (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].%s));\n" name;
6283 pr " char s[33];\n";
6284 pr " memcpy (s, r->val[i].%s, 32);\n" name;
6286 pr " fl = (*env)->GetFieldID (env, cl, \"%s\", \"Ljava/lang/String;\");\n" name;
6287 pr " (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));\n";
6289 | name, (`Bytes|`Int) ->
6290 pr " fl = (*env)->GetFieldID (env, cl, \"%s\", \"J\");\n" name;
6291 pr " (*env)->SetLongField (env, jfl, fl, r->val[i].%s);\n" name;
6292 | name, `OptPercent ->
6293 pr " fl = (*env)->GetFieldID (env, cl, \"%s\", \"F\");\n" name;
6294 pr " (*env)->SetFloatField (env, jfl, fl, r->val[i].%s);\n" name;
6296 pr " (*env)->SetObjectArrayElement (env, jfl, i, jfl);\n";
6298 pr " guestfs_free_lvm_%s_list (r);\n" typ;
6301 let output_to filename =
6302 let filename_new = filename ^ ".new" in
6303 chan := open_out filename_new;
6308 (* Is the new file different from the current file? *)
6309 if Sys.file_exists filename && files_equal filename filename_new then
6310 Unix.unlink filename_new (* same, so skip it *)
6312 (* different, overwrite old one *)
6313 (try Unix.chmod filename 0o644 with Unix.Unix_error _ -> ());
6314 Unix.rename filename_new filename;
6315 Unix.chmod filename 0o444;
6316 printf "written %s\n%!" filename;
6325 if not (Sys.file_exists "configure.ac") then (
6327 You are probably running this from the wrong directory.
6328 Run it from the top source directory using the command
6334 let close = output_to "src/guestfs_protocol.x" in
6338 let close = output_to "src/guestfs-structs.h" in
6339 generate_structs_h ();
6342 let close = output_to "src/guestfs-actions.h" in
6343 generate_actions_h ();
6346 let close = output_to "src/guestfs-actions.c" in
6347 generate_client_actions ();
6350 let close = output_to "daemon/actions.h" in
6351 generate_daemon_actions_h ();
6354 let close = output_to "daemon/stubs.c" in
6355 generate_daemon_actions ();
6358 let close = output_to "tests.c" in
6362 let close = output_to "fish/cmds.c" in
6363 generate_fish_cmds ();
6366 let close = output_to "fish/completion.c" in
6367 generate_fish_completion ();
6370 let close = output_to "guestfs-structs.pod" in
6371 generate_structs_pod ();
6374 let close = output_to "guestfs-actions.pod" in
6375 generate_actions_pod ();
6378 let close = output_to "guestfish-actions.pod" in
6379 generate_fish_actions_pod ();
6382 let close = output_to "ocaml/guestfs.mli" in
6383 generate_ocaml_mli ();
6386 let close = output_to "ocaml/guestfs.ml" in
6387 generate_ocaml_ml ();
6390 let close = output_to "ocaml/guestfs_c_actions.c" in
6391 generate_ocaml_c ();
6394 let close = output_to "perl/Guestfs.xs" in
6395 generate_perl_xs ();
6398 let close = output_to "perl/lib/Sys/Guestfs.pm" in
6399 generate_perl_pm ();
6402 let close = output_to "python/guestfs-py.c" in
6403 generate_python_c ();
6406 let close = output_to "python/guestfs.py" in
6407 generate_python_py ();
6410 let close = output_to "ruby/ext/guestfs/_guestfs.c" in
6414 let close = output_to "java/com/redhat/et/libguestfs/GuestFS.java" in
6415 generate_java_java ();
6418 let close = output_to "java/com/redhat/et/libguestfs/PV.java" in
6419 generate_java_struct "PV" pv_cols;
6422 let close = output_to "java/com/redhat/et/libguestfs/VG.java" in
6423 generate_java_struct "VG" vg_cols;
6426 let close = output_to "java/com/redhat/et/libguestfs/LV.java" in
6427 generate_java_struct "LV" lv_cols;
6430 let close = output_to "java/com/redhat/et/libguestfs/Stat.java" in
6431 generate_java_struct "Stat" stat_cols;
6434 let close = output_to "java/com/redhat/et/libguestfs/StatVFS.java" in
6435 generate_java_struct "StatVFS" statvfs_cols;
6438 let close = output_to "java/com_redhat_et_libguestfs_GuestFS.c" in