*)
and argt =
| String of string (* const char *name, cannot be NULL *)
+ | Device of string (* /dev device name, cannot be NULL *)
| OptString of string (* const char *name, may be NULL *)
| StringList of string(* list of strings (each string cannot be NULL) *)
| Bool of string (* boolean *)
This is equivalent to the qemu parameter
C<-drive file=filename,cache=off,if=...>.
+C<cache=off> is omitted in cases where it is not supported by
+the underlying filesystem.
Note that this call checks for the existence of C<filename>. This
stops you from specifying other types of drive which are supported
*)
let daemon_functions = [
- ("mount", (RErr, [String "device"; String "mountpoint"]), 1, [],
+ ("mount", (RErr, [Device "device"; String "mountpoint"]), 1, [],
[InitEmpty, Always, TestOutput (
[["sfdiskM"; "/dev/sda"; ","];
["mkfs"; "ext2"; "/dev/sda1"];
See also C<guestfs_stat>.");
- ("pvcreate", (RErr, [String "device"]), 39, [],
+ ("pvcreate", (RErr, [Device "device"]), 39, [],
[InitEmpty, Always, TestOutputListOfDevices (
[["sfdiskM"; "/dev/sda"; ",100 ,200 ,"];
["pvcreate"; "/dev/sda1"];
This creates an LVM volume group called C<logvol>
on the volume group C<volgroup>, with C<size> megabytes.");
- ("mkfs", (RErr, [String "fstype"; String "device"]), 42, [],
+ ("mkfs", (RErr, [String "fstype"; Device "device"]), 42, [],
[InitEmpty, Always, TestOutput (
[["sfdiskM"; "/dev/sda"; ","];
["mkfs"; "ext2"; "/dev/sda1"];
or LVM logical volume). The filesystem type is C<fstype>, for
example C<ext3>.");
- ("sfdisk", (RErr, [String "device";
+ ("sfdisk", (RErr, [Device "device";
Int "cyls"; Int "heads"; Int "sectors";
StringList "lines"]), 43, [DangerWillRobinson],
[],
This is the same as the C<statvfs(2)> system call.");
- ("tune2fs_l", (RHashtable "superblock", [String "device"]), 55, [],
+ ("tune2fs_l", (RHashtable "superblock", [Device "device"]), 55, [],
[], (* XXX test *)
"get ext2/ext3/ext4 superblock details",
"\
clearly defined, and depends on both the version of C<tune2fs>
that libguestfs was built against, and the filesystem itself.");
- ("blockdev_setro", (RErr, [String "device"]), 56, [],
+ ("blockdev_setro", (RErr, [Device "device"]), 56, [],
[InitEmpty, Always, TestOutputTrue (
[["blockdev_setro"; "/dev/sda"];
["blockdev_getro"; "/dev/sda"]])],
This uses the L<blockdev(8)> command.");
- ("blockdev_setrw", (RErr, [String "device"]), 57, [],
+ ("blockdev_setrw", (RErr, [Device "device"]), 57, [],
[InitEmpty, Always, TestOutputFalse (
[["blockdev_setrw"; "/dev/sda"];
["blockdev_getro"; "/dev/sda"]])],
This uses the L<blockdev(8)> command.");
- ("blockdev_getro", (RBool "ro", [String "device"]), 58, [],
+ ("blockdev_getro", (RBool "ro", [Device "device"]), 58, [],
[InitEmpty, Always, TestOutputTrue (
[["blockdev_setro"; "/dev/sda"];
["blockdev_getro"; "/dev/sda"]])],
This uses the L<blockdev(8)> command.");
- ("blockdev_getss", (RInt "sectorsize", [String "device"]), 59, [],
+ ("blockdev_getss", (RInt "sectorsize", [Device "device"]), 59, [],
[InitEmpty, Always, TestOutputInt (
[["blockdev_getss"; "/dev/sda"]], 512)],
"get sectorsize of block device",
This uses the L<blockdev(8)> command.");
- ("blockdev_getbsz", (RInt "blocksize", [String "device"]), 60, [],
+ ("blockdev_getbsz", (RInt "blocksize", [Device "device"]), 60, [],
[InitEmpty, Always, TestOutputInt (
[["blockdev_getbsz"; "/dev/sda"]], 4096)],
"get blocksize of block device",
This uses the L<blockdev(8)> command.");
- ("blockdev_setbsz", (RErr, [String "device"; Int "blocksize"]), 61, [],
+ ("blockdev_setbsz", (RErr, [Device "device"; Int "blocksize"]), 61, [],
[], (* XXX test *)
"set blocksize of block device",
"\
This uses the L<blockdev(8)> command.");
- ("blockdev_getsz", (RInt64 "sizeinsectors", [String "device"]), 62, [],
+ ("blockdev_getsz", (RInt64 "sizeinsectors", [Device "device"]), 62, [],
[InitEmpty, Always, TestOutputInt (
[["blockdev_getsz"; "/dev/sda"]], 1024000)],
"get total size of device in 512-byte sectors",
This uses the L<blockdev(8)> command.");
- ("blockdev_getsize64", (RInt64 "sizeinbytes", [String "device"]), 63, [],
+ ("blockdev_getsize64", (RInt64 "sizeinbytes", [Device "device"]), 63, [],
[InitEmpty, Always, TestOutputInt (
[["blockdev_getsize64"; "/dev/sda"]], 524288000)],
"get total size of device in bytes",
This uses the L<blockdev(8)> command.");
- ("blockdev_flushbufs", (RErr, [String "device"]), 64, [],
+ ("blockdev_flushbufs", (RErr, [Device "device"]), 64, [],
[InitEmpty, Always, TestRun
[["blockdev_flushbufs"; "/dev/sda"]]],
"flush device buffers",
This uses the L<blockdev(8)> command.");
- ("blockdev_rereadpt", (RErr, [String "device"]), 65, [],
+ ("blockdev_rereadpt", (RErr, [Device "device"]), 65, [],
[InitEmpty, Always, TestRun
[["blockdev_rereadpt"; "/dev/sda"]]],
"reread partition table",
To download an uncompressed tarball, use C<guestfs_tar_out>.");
- ("mount_ro", (RErr, [String "device"; String "mountpoint"]), 73, [],
+ ("mount_ro", (RErr, [Device "device"; String "mountpoint"]), 73, [],
[InitBasicFS, Always, TestLastFail (
[["umount"; "/"];
["mount_ro"; "/dev/sda1"; "/"];
This is the same as the C<guestfs_mount> command, but it
mounts the filesystem with the read-only (I<-o ro>) flag.");
- ("mount_options", (RErr, [String "options"; String "device"; String "mountpoint"]), 74, [],
+ ("mount_options", (RErr, [String "options"; Device "device"; String "mountpoint"]), 74, [],
[],
"mount a guest disk with mount options",
"\
allows you to set the mount options as for the
L<mount(8)> I<-o> flag.");
- ("mount_vfs", (RErr, [String "options"; String "vfstype"; String "device"; String "mountpoint"]), 75, [],
+ ("mount_vfs", (RErr, [String "options"; String "vfstype"; Device "device"; String "mountpoint"]), 75, [],
[],
"mount a guest disk with mount options and vfstype",
"\
to look at the file C<daemon/debug.c> in the libguestfs source
to find out what you can do.");
- ("lvremove", (RErr, [String "device"]), 77, [],
+ ("lvremove", (RErr, [Device "device"]), 77, [],
[InitEmpty, Always, TestOutputList (
[["sfdiskM"; "/dev/sda"; ","];
["pvcreate"; "/dev/sda1"];
This also forcibly removes all logical volumes in the volume
group (if any).");
- ("pvremove", (RErr, [String "device"]), 79, [],
+ ("pvremove", (RErr, [Device "device"]), 79, [],
[InitEmpty, Always, TestOutputListOfDevices (
[["sfdiskM"; "/dev/sda"; ","];
["pvcreate"; "/dev/sda1"];
wipe physical volumes that contain any volume groups, so you have
to remove those first.");
- ("set_e2label", (RErr, [String "device"; String "label"]), 80, [],
+ ("set_e2label", (RErr, [Device "device"; String "label"]), 80, [],
[InitBasicFS, Always, TestOutput (
[["set_e2label"; "/dev/sda1"; "testlabel"];
["get_e2label"; "/dev/sda1"]], "testlabel")],
You can use either C<guestfs_tune2fs_l> or C<guestfs_get_e2label>
to return the existing label on a filesystem.");
- ("get_e2label", (RString "label", [String "device"]), 81, [],
+ ("get_e2label", (RString "label", [Device "device"]), 81, [],
[],
"get the ext2/3/4 filesystem label",
"\
This returns the ext2/3/4 filesystem label of the filesystem on
C<device>.");
- ("set_e2uuid", (RErr, [String "device"; String "uuid"]), 82, [],
+ ("set_e2uuid", (RErr, [Device "device"; String "uuid"]), 82, [],
[InitBasicFS, Always, TestOutput (
[["set_e2uuid"; "/dev/sda1"; "a3a61220-882b-4f61-89f4-cf24dcc7297d"];
["get_e2uuid"; "/dev/sda1"]], "a3a61220-882b-4f61-89f4-cf24dcc7297d");
You can use either C<guestfs_tune2fs_l> or C<guestfs_get_e2uuid>
to return the existing UUID of a filesystem.");
- ("get_e2uuid", (RString "uuid", [String "device"]), 83, [],
+ ("get_e2uuid", (RString "uuid", [Device "device"]), 83, [],
[],
"get the ext2/3/4 filesystem UUID",
"\
This returns the ext2/3/4 filesystem UUID of the filesystem on
C<device>.");
- ("fsck", (RInt "status", [String "fstype"; String "device"]), 84, [],
+ ("fsck", (RInt "status", [String "fstype"; Device "device"]), 84, [],
[InitBasicFS, Always, TestOutputInt (
[["umount"; "/dev/sda1"];
["fsck"; "ext2"; "/dev/sda1"]], 0);
This command is entirely equivalent to running C<fsck -a -t fstype device>.");
- ("zero", (RErr, [String "device"]), 85, [],
+ ("zero", (RErr, [Device "device"]), 85, [],
[InitBasicFS, Always, TestOutput (
[["umount"; "/dev/sda1"];
["zero"; "/dev/sda1"];
See also: C<guestfs_scrub_device>.");
- ("grub_install", (RErr, [String "root"; String "device"]), 86, [],
+ ("grub_install", (RErr, [String "root"; Device "device"]), 86, [],
(* Test disabled because grub-install incompatible with virtio-blk driver.
* See also: https://bugzilla.redhat.com/show_bug.cgi?id=479760
*)
This runs C<hexdump -C> on the given C<path>. The result is
the human-readable, canonical hex dump of the file.");
- ("zerofree", (RErr, [String "device"]), 97, [],
+ ("zerofree", (RErr, [Device "device"]), 97, [],
[InitNone, Always, TestOutput (
[["sfdiskM"; "/dev/sda"; ","];
["mkfs"; "ext3"; "/dev/sda1"];
It is possible that using this program can damage the filesystem
or data on the filesystem.");
- ("pvresize", (RErr, [String "device"]), 98, [],
+ ("pvresize", (RErr, [Device "device"]), 98, [],
[],
"resize an LVM physical volume",
"\
This resizes (expands or shrinks) an existing LVM physical
volume to match the new size of the underlying device.");
- ("sfdisk_N", (RErr, [String "device"; Int "partnum";
+ ("sfdisk_N", (RErr, [Device "device"; Int "partnum";
Int "cyls"; Int "heads"; Int "sectors";
String "line"]), 99, [DangerWillRobinson],
[],
For other parameters, see C<guestfs_sfdisk>. You should usually
pass C<0> for the cyls/heads/sectors parameters.");
- ("sfdisk_l", (RString "partitions", [String "device"]), 100, [],
+ ("sfdisk_l", (RString "partitions", [Device "device"]), 100, [],
[],
"display the partition table",
"\
human-readable output of the L<sfdisk(8)> command. It is
not intended to be parsed.");
- ("sfdisk_kernel_geometry", (RString "partitions", [String "device"]), 101, [],
+ ("sfdisk_kernel_geometry", (RString "partitions", [Device "device"]), 101, [],
[],
"display the kernel geometry",
"\
The result is in human-readable format, and not designed to
be parsed.");
- ("sfdisk_disk_geometry", (RString "partitions", [String "device"]), 102, [],
+ ("sfdisk_disk_geometry", (RString "partitions", [Device "device"]), 102, [],
[],
"display the disk geometry from the partition table",
"\
Note that if C<volgroups> is an empty list then B<all> volume groups
are activated or deactivated.");
- ("lvresize", (RErr, [String "device"; Int "mbytes"]), 105, [],
+ ("lvresize", (RErr, [Device "device"; Int "mbytes"]), 105, [],
[InitNone, Always, TestOutput (
[["sfdiskM"; "/dev/sda"; ","];
["pvcreate"; "/dev/sda1"];
volume to C<mbytes>. When reducing, data in the reduced part
is lost.");
- ("resize2fs", (RErr, [String "device"]), 106, [],
+ ("resize2fs", (RErr, [Device "device"]), 106, [],
[], (* lvresize tests this *)
"resize an ext2/ext3 filesystem",
"\
The returned list is sorted.");
- ("e2fsck_f", (RErr, [String "device"]), 108, [],
+ ("e2fsck_f", (RErr, [Device "device"]), 108, [],
[], (* lvresize tests this *)
"check an ext2/ext3 filesystem",
"\
"\
Sleep for C<secs> seconds.");
- ("ntfs_3g_probe", (RInt "status", [Bool "rw"; String "device"]), 110, [],
+ ("ntfs_3g_probe", (RInt "status", [Bool "rw"; Device "device"]), 110, [],
[InitNone, Always, TestOutputInt (
[["sfdiskM"; "/dev/sda"; ","];
["mkfs"; "ntfs"; "/dev/sda1"];
with flags C<GLOB_MARK|GLOB_BRACE>.
See that manual page for more details.");
- ("scrub_device", (RErr, [String "device"]), 114, [DangerWillRobinson],
+ ("scrub_device", (RErr, [Device "device"]), 114, [DangerWillRobinson],
[InitNone, Always, TestRun ( (* use /dev/sdc because it's smaller *)
[["scrub_device"; "/dev/sdc"]])],
"scrub (securely wipe) a device",
in a file) on a mount point. It is entirely equivalent to
the command C<mount -o loop file mountpoint>.");
- ("mkswap", (RErr, [String "device"]), 130, [],
+ ("mkswap", (RErr, [Device "device"]), 130, [],
[InitEmpty, Always, TestRun (
[["sfdiskM"; "/dev/sda"; ","];
["mkswap"; "/dev/sda1"]])],
"\
Create a swap partition on C<device>.");
- ("mkswap_L", (RErr, [String "label"; String "device"]), 131, [],
+ ("mkswap_L", (RErr, [String "label"; Device "device"]), 131, [],
[InitEmpty, Always, TestRun (
[["sfdiskM"; "/dev/sda"; ","];
["mkswap_L"; "hello"; "/dev/sda1"]])],
(eg. C</dev/sda>), just to a partition. This appears to be
a limitation of the kernel or swap tools.");
- ("mkswap_U", (RErr, [String "uuid"; String "device"]), 132, [],
+ ("mkswap_U", (RErr, [String "uuid"; Device "device"]), 132, [],
[InitEmpty, Always, TestRun (
[["sfdiskM"; "/dev/sda"; ","];
["mkswap_U"; "a3a61220-882b-4f61-89f4-cf24dcc7297d"; "/dev/sda1"]])],
get a simple list of names, use C<guestfs_ls>. To get a printable
directory for human consumption, use C<guestfs_ll>.");
- ("sfdiskM", (RErr, [String "device"; StringList "lines"]), 139, [DangerWillRobinson],
+ ("sfdiskM", (RErr, [Device "device"; StringList "lines"]), 139, [DangerWillRobinson],
[],
"create partitions on a block device",
"\
C<alloc> command which allocates a file in the host and
attaches it as a device.");
- ("swapon_device", (RErr, [String "device"]), 170, [],
+ ("swapon_device", (RErr, [Device "device"]), 170, [],
[InitPartition, Always, TestRun (
[["mkswap"; "/dev/sda1"];
["swapon_device"; "/dev/sda1"];
information about the host to the guest this way. Instead,
attach a new host device to the guest and swap on that.");
- ("swapoff_device", (RErr, [String "device"]), 171, [],
+ ("swapoff_device", (RErr, [Device "device"]), 171, [],
[], (* XXX tested by swapon_device *)
"disable swap on device",
"\
opened by inotify_init. It removes all watches, throws
away any pending events, and deallocates all resources.");
+ ("setcon", (RErr, [String "context"]), 185, [],
+ [],
+ "set SELinux security context",
+ "\
+This sets the SELinux security context of the daemon
+to the string C<context>.
+
+See the documentation about SELINUX in L<guestfs(3)>.");
+
+ ("getcon", (RString "context", []), 186, [],
+ [],
+ "get SELinux security context",
+ "\
+This gets the SELinux security context of the daemon.
+
+See the documentation about SELINUX in L<guestfs(3)>,
+and C<guestfs_setcon>");
+
]
let all_functions = non_daemon_functions @ daemon_functions
loop 0 xs
let name_of_argt = function
- | String n | OptString n | StringList n | Bool n | Int n
+ | Device n | String n | OptString n | StringList n | Bool n | Int n
| FileIn n | FileOut n -> n
let java_name_of_struct typ =
pr "struct %s_args {\n" name;
List.iter (
function
- | String n -> pr " string %s<>;\n" n
+ | Device n | String n -> pr " string %s<>;\n" n
| OptString n -> pr " str *%s;\n" n
| StringList n -> pr " str %s<>;\n" n
| Bool n -> pr " bool %s;\n" n
| args ->
List.iter (
function
- | String n ->
+ | Device n | String n ->
pr " args.%s = (char *) %s;\n" n n
| OptString n ->
pr " args.%s = %s ? (char **) &%s : NULL;\n" n n n
* allow device name translation. This is safe because
* we can modify the string (passed from RPC).
*)
- | String n
+ | Device n | String n
| OptString n -> pr " char *%s;\n" n
| StringList n -> pr " char **%s;\n" n
| Bool n -> pr " int %s;\n" n
pr " }\n";
List.iter (
function
+ | Device n ->
+ pr " %s = args.%s;\n" n n;
+ pr " RESOLVE_DEVICE (%s, goto done);" n;
| String n -> pr " %s = args.%s;\n" n n
| OptString n -> pr " %s = args.%s ? *args.%s : NULL;\n" n n n
| StringList n ->
List.iter (
function
| OptString n, "NULL" -> ()
+ | Device n, arg
| String n, arg
| OptString n, arg ->
pr " const char *%s = \"%s\";\n" n (c_quote arg);
List.iter (
function
| OptString _, "NULL" -> pr ", NULL"
+ | Device n, _
| String n, _
| OptString n, _ ->
pr ", %s" n
);
List.iter (
function
+ | Device n
| String n
| OptString n
| FileIn n
iteri (
fun i ->
function
- | String name -> pr " %s = argv[%d];\n" name i
+ | Device name | String name -> pr " %s = argv[%d];\n" name i
| OptString name ->
pr " %s = strcmp (argv[%d], \"\") != 0 ? argv[%d] : NULL;\n"
name i i
pr " %s" name;
List.iter (
function
- | String n -> pr " %s" n
+ | Device n | String n -> pr " %s" n
| OptString n -> pr " %s" n
| StringList n -> pr " '%s ...'" n
| Bool _ -> pr " true|false"
in
List.iter (
function
+ | Device n
| String n
| OptString n ->
next ();
List.iter (
function
+ | Device n
| String n
| FileIn n
| FileOut n ->
function
| StringList n ->
pr " ocaml_guestfs_free_strings (%s);\n" n;
- | String _ | OptString _ | Bool _ | Int _ | FileIn _ | FileOut _ -> ()
+ | Device _ | String _ | OptString _ | Bool _ | Int _
+ | FileIn _ | FileOut _ -> ()
) (snd style);
pr " if (r == %s)\n" error_code;
pr "%s : t -> " name;
List.iter (
function
- | String _ | FileIn _ | FileOut _ -> pr "string -> "
+ | Device _ | String _ | FileIn _ | FileOut _ -> pr "string -> "
| OptString _ -> pr "string option -> "
| StringList _ -> pr "string array -> "
| Bool _ -> pr "bool -> "
iteri (
fun i ->
function
- | String n | FileIn n | FileOut n -> pr " char *%s;\n" n
+ | Device n | String n | FileIn n | FileOut n -> pr " char *%s;\n" n
| OptString n ->
(* http://www.perlmonks.org/?node_id=554277
* Note that the implicit handle argument means we have
let do_cleanups () =
List.iter (
function
- | String _ | OptString _ | Bool _ | Int _
+ | Device _ | String _ | OptString _ | Bool _ | Int _
| FileIn _ | FileOut _ -> ()
| StringList n -> pr " free (%s);\n" n
) (snd style)
if !comma then pr ", ";
comma := true;
match arg with
- | String n | OptString n | Bool n | Int n | FileIn n | FileOut n ->
+ | Device n | String n
+ | OptString n | Bool n | Int n | FileIn n | FileOut n ->
pr "$%s" n
| StringList n ->
pr "\\@%s" n
List.iter (
function
- | String n | FileIn n | FileOut n -> pr " const char *%s;\n" n
+ | Device n | String n | FileIn n | FileOut n -> pr " const char *%s;\n" n
| OptString n -> pr " const char *%s;\n" n
| StringList n ->
pr " PyObject *py_%s;\n" n;
pr " if (!PyArg_ParseTuple (args, (char *) \"O";
List.iter (
function
- | String _ | FileIn _ | FileOut _ -> pr "s"
+ | Device _ | String _ | FileIn _ | FileOut _ -> pr "s"
| OptString _ -> pr "z"
| StringList _ -> pr "O"
| Bool _ -> pr "i" (* XXX Python has booleans? *)
pr " &py_g";
List.iter (
function
- | String n | FileIn n | FileOut n -> pr ", &%s" n
+ | Device n | String n | FileIn n | FileOut n -> pr ", &%s" n
| OptString n -> pr ", &%s" n
| StringList n -> pr ", &py_%s" n
| Bool n -> pr ", &%s" n
pr " g = get_handle (py_g);\n";
List.iter (
function
- | String _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
+ | Device _ | String _
+ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
| StringList n ->
pr " %s = get_string_list (py_%s);\n" n n;
pr " if (!%s) return NULL;\n" n
List.iter (
function
- | String _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
+ | Device _ | String _
+ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
| StringList n ->
pr " free (%s);\n" n
) (snd style);
List.iter (
function
- | String n | FileIn n | FileOut n ->
+ | Device n | String n | FileIn n | FileOut n ->
pr " Check_Type (%sv, T_STRING);\n" n;
pr " const char *%s = StringValueCStr (%sv);\n" n n;
pr " if (!%s)\n" n;
List.iter (
function
- | String _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
+ | Device _ | String _
+ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
| StringList n ->
pr " free (%s);\n" n
) (snd style);
needs_comma := true;
match arg with
+ | Device n
| String n
| OptString n
| FileIn n
pr " (JNIEnv *env, jobject obj, jlong jg";
List.iter (
function
+ | Device n
| String n
| OptString n
| FileIn n
"NULL", "NULL" in
List.iter (
function
+ | Device n
| String n
| OptString n
| FileIn n
(* Get the parameters. *)
List.iter (
function
+ | Device n
| String n
| FileIn n
| FileOut n ->
(* Release the parameters. *)
List.iter (
function
+ | Device n
| String n
| FileIn n
| FileOut n ->
function
| FileIn n
| FileOut n
- | String n -> pr "withCString %s $ \\%s -> " n n
+ | Device n | String n -> pr "withCString %s $ \\%s -> " n n
| OptString n -> pr "maybeWith withCString %s $ \\%s -> " n n
| StringList n -> pr "withMany withCString %s $ \\%s -> withArray0 nullPtr %s $ \\%s -> " n n n n
| Bool _ | Int _ -> ()
function
| Bool n -> sprintf "(fromBool %s)" n
| Int n -> sprintf "(fromIntegral %s)" n
- | FileIn n | FileOut n | String n | OptString n | StringList n -> n
+ | FileIn n | FileOut n
+ | Device n | String n | OptString n | StringList n -> n
) (snd style) in
pr "withForeignPtr h (\\p -> c_%s %s)\n" name
(String.concat " " ("p" :: args));
List.iter (
fun arg ->
(match arg with
- | String _ -> pr "%s" string
+ | Device _ | String _ -> pr "%s" string
| OptString _ -> if hs then pr "Maybe String" else pr "CString"
| StringList _ -> if hs then pr "[String]" else pr "Ptr CString"
| Bool _ -> pr "%s" bool
pr "{\n";
List.iter (
function
+ | Device n
| String n
| FileIn n
| FileOut n -> pr " printf (\"%%s\\n\", %s);\n" n
git.annexia.org / libguestfs.git / blobdiff