From: Richard Jones Date: Fri, 10 Apr 2009 11:53:28 +0000 (+0100) Subject: Generated files for previous commands. X-Git-Tag: 0.8~5 X-Git-Url: http://git.annexia.org/?a=commitdiff_plain;h=286841877f4223d67ec00b83e5a2aabfbb9e19ed;p=libguestfs.git Generated files for previous commands. --- diff --git a/daemon/actions.h b/daemon/actions.h index a2edc76..1b35cad 100644 --- a/daemon/actions.h +++ b/daemon/actions.h @@ -49,3 +49,10 @@ extern char **do_aug_match (const char *path); extern int do_aug_save (void); extern int do_aug_load (void); extern char **do_aug_ls (const char *path); +extern int do_rm (const char *path); +extern int do_rmdir (const char *path); +extern int do_rm_rf (const char *path); +extern int do_mkdir (const char *path); +extern int do_mkdir_p (const char *path); +extern int do_chmod (int mode, const char *path); +extern int do_chown (int owner, int group, const char *path); diff --git a/daemon/stubs.c b/daemon/stubs.c index eb39828..1227fa8 100644 --- a/daemon/stubs.c +++ b/daemon/stubs.c @@ -606,6 +606,166 @@ static void aug_ls_stub (XDR *xdr_in) free_strings (r); } +static void rm_stub (XDR *xdr_in) +{ + int r; + struct guestfs_rm_args args; + const char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_rm_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "rm"); + return; + } + path = args.path; + + r = do_rm (path); + if (r == -1) + /* do_rm has already called reply_with_error, so just return */ + return; + + reply (NULL, NULL); +} + +static void rmdir_stub (XDR *xdr_in) +{ + int r; + struct guestfs_rmdir_args args; + const char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_rmdir_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "rmdir"); + return; + } + path = args.path; + + r = do_rmdir (path); + if (r == -1) + /* do_rmdir has already called reply_with_error, so just return */ + return; + + reply (NULL, NULL); +} + +static void rm_rf_stub (XDR *xdr_in) +{ + int r; + struct guestfs_rm_rf_args args; + const char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_rm_rf_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "rm_rf"); + return; + } + path = args.path; + + r = do_rm_rf (path); + if (r == -1) + /* do_rm_rf has already called reply_with_error, so just return */ + return; + + reply (NULL, NULL); +} + +static void mkdir_stub (XDR *xdr_in) +{ + int r; + struct guestfs_mkdir_args args; + const char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_mkdir_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "mkdir"); + return; + } + path = args.path; + + r = do_mkdir (path); + if (r == -1) + /* do_mkdir has already called reply_with_error, so just return */ + return; + + reply (NULL, NULL); +} + +static void mkdir_p_stub (XDR *xdr_in) +{ + int r; + struct guestfs_mkdir_p_args args; + const char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_mkdir_p_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "mkdir_p"); + return; + } + path = args.path; + + r = do_mkdir_p (path); + if (r == -1) + /* do_mkdir_p has already called reply_with_error, so just return */ + return; + + reply (NULL, NULL); +} + +static void chmod_stub (XDR *xdr_in) +{ + int r; + struct guestfs_chmod_args args; + int mode; + const char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_chmod_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "chmod"); + return; + } + mode = args.mode; + path = args.path; + + r = do_chmod (mode, path); + if (r == -1) + /* do_chmod has already called reply_with_error, so just return */ + return; + + reply (NULL, NULL); +} + +static void chown_stub (XDR *xdr_in) +{ + int r; + struct guestfs_chown_args args; + int owner; + int group; + const char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_chown_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "chown"); + return; + } + owner = args.owner; + group = args.group; + path = args.path; + + r = do_chown (owner, group, path); + if (r == -1) + /* do_chown has already called reply_with_error, so just return */ + return; + + reply (NULL, NULL); +} + void dispatch_incoming_message (XDR *xdr_in) { switch (proc_nr) { @@ -693,6 +853,27 @@ void dispatch_incoming_message (XDR *xdr_in) case GUESTFS_PROC_AUG_LS: aug_ls_stub (xdr_in); break; + case GUESTFS_PROC_RM: + rm_stub (xdr_in); + break; + case GUESTFS_PROC_RMDIR: + rmdir_stub (xdr_in); + break; + case GUESTFS_PROC_RM_RF: + rm_rf_stub (xdr_in); + break; + case GUESTFS_PROC_MKDIR: + mkdir_stub (xdr_in); + break; + case GUESTFS_PROC_MKDIR_P: + mkdir_p_stub (xdr_in); + break; + case GUESTFS_PROC_CHMOD: + chmod_stub (xdr_in); + break; + case GUESTFS_PROC_CHOWN: + chown_stub (xdr_in); + break; default: reply_with_error ("dispatch_incoming_message: unknown procedure number %d", proc_nr); } diff --git a/fish/cmds.c b/fish/cmds.c index f0c0458..cef38cc 100644 --- a/fish/cmds.c +++ b/fish/cmds.c @@ -47,6 +47,8 @@ void list_commands (void) printf ("%-20s %s\n", "aug-save", "write all pending Augeas changes to disk"); printf ("%-20s %s\n", "aug-set", "set Augeas path to value"); printf ("%-20s %s\n", "cat", "list the contents of a file"); + printf ("%-20s %s\n", "chmod", "change file mode"); + printf ("%-20s %s\n", "chown", "change file owner and group"); printf ("%-20s %s\n", "config", "add qemu parameters"); printf ("%-20s %s\n", "get-autosync", "get autosync mode"); printf ("%-20s %s\n", "get-path", "get the search path"); @@ -59,10 +61,15 @@ void list_commands (void) printf ("%-20s %s\n", "ls", "list the files in a directory"); printf ("%-20s %s\n", "lvs", "list the LVM logical volumes (LVs)"); printf ("%-20s %s\n", "lvs-full", "list the LVM logical volumes (LVs)"); + printf ("%-20s %s\n", "mkdir", "create a directory"); + printf ("%-20s %s\n", "mkdir-p", "create a directory and parents"); printf ("%-20s %s\n", "mount", "mount a guest disk at a position in the filesystem"); printf ("%-20s %s\n", "pvs", "list the LVM physical volumes (PVs)"); printf ("%-20s %s\n", "pvs-full", "list the LVM physical volumes (PVs)"); printf ("%-20s %s\n", "read-lines", "read file as lines"); + printf ("%-20s %s\n", "rm", "remove a file"); + printf ("%-20s %s\n", "rm-rf", "remove a file or directory recursively"); + printf ("%-20s %s\n", "rmdir", "remove a directory"); printf ("%-20s %s\n", "set-autosync", "set autosync mode"); printf ("%-20s %s\n", "set-path", "set the search path"); printf ("%-20s %s\n", "set-verbose", "set verbose mode"); @@ -192,6 +199,27 @@ void display_command (const char *cmd) if (strcasecmp (cmd, "aug_ls") == 0 || strcasecmp (cmd, "aug-ls") == 0) pod2text ("aug-ls - list Augeas nodes under a path", " aug-ls \n\nThis is just a shortcut for listing C\nC and sorting the resulting nodes into alphabetical order."); else + if (strcasecmp (cmd, "rm") == 0) + pod2text ("rm - remove a file", " rm \n\nRemove the single file C."); + else + if (strcasecmp (cmd, "rmdir") == 0) + pod2text ("rmdir - remove a directory", " rmdir \n\nRemove the single directory C."); + else + if (strcasecmp (cmd, "rm_rf") == 0 || strcasecmp (cmd, "rm-rf") == 0) + pod2text ("rm-rf - remove a file or directory recursively", " rm-rf \n\nRemove the file or directory C, recursively removing the\ncontents if its a directory. This is like the C shell\ncommand."); + else + if (strcasecmp (cmd, "mkdir") == 0) + pod2text ("mkdir - create a directory", " mkdir \n\nCreate a directory named C."); + else + if (strcasecmp (cmd, "mkdir_p") == 0 || strcasecmp (cmd, "mkdir-p") == 0) + pod2text ("mkdir-p - create a directory and parents", " mkdir-p \n\nCreate a directory named C, creating any parent directories\nas necessary. This is like the C shell command."); + else + if (strcasecmp (cmd, "chmod") == 0) + pod2text ("chmod - change file mode", " chmod \n\nChange the mode (permissions) of C to C. Only\nnumeric modes are supported."); + else + if (strcasecmp (cmd, "chown") == 0) + pod2text ("chown - change file owner and group", " chown \n\nChange the file owner to C and group to C.\n\nOnly numeric uid and gid are supported. If you want to use\nnames, you will need to locate and parse the password file\nyourself (Augeas support makes this relatively easy)."); + else display_builtin_command (cmd); } @@ -888,6 +916,110 @@ static int run_aug_ls (const char *cmd, int argc, char *argv[]) return 0; } +static int run_rm (const char *cmd, int argc, char *argv[]) +{ + int r; + const char *path; + if (argc != 1) { + fprintf (stderr, "%s should have 1 parameter(s)\n", cmd); + fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd); + return -1; + } + path = argv[0]; + r = guestfs_rm (g, path); + return r; +} + +static int run_rmdir (const char *cmd, int argc, char *argv[]) +{ + int r; + const char *path; + if (argc != 1) { + fprintf (stderr, "%s should have 1 parameter(s)\n", cmd); + fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd); + return -1; + } + path = argv[0]; + r = guestfs_rmdir (g, path); + return r; +} + +static int run_rm_rf (const char *cmd, int argc, char *argv[]) +{ + int r; + const char *path; + if (argc != 1) { + fprintf (stderr, "%s should have 1 parameter(s)\n", cmd); + fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd); + return -1; + } + path = argv[0]; + r = guestfs_rm_rf (g, path); + return r; +} + +static int run_mkdir (const char *cmd, int argc, char *argv[]) +{ + int r; + const char *path; + if (argc != 1) { + fprintf (stderr, "%s should have 1 parameter(s)\n", cmd); + fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd); + return -1; + } + path = argv[0]; + r = guestfs_mkdir (g, path); + return r; +} + +static int run_mkdir_p (const char *cmd, int argc, char *argv[]) +{ + int r; + const char *path; + if (argc != 1) { + fprintf (stderr, "%s should have 1 parameter(s)\n", cmd); + fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd); + return -1; + } + path = argv[0]; + r = guestfs_mkdir_p (g, path); + return r; +} + +static int run_chmod (const char *cmd, int argc, char *argv[]) +{ + int r; + int mode; + const char *path; + if (argc != 2) { + fprintf (stderr, "%s should have 2 parameter(s)\n", cmd); + fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd); + return -1; + } + mode = atoi (argv[0]); + path = argv[1]; + r = guestfs_chmod (g, mode, path); + return r; +} + +static int run_chown (const char *cmd, int argc, char *argv[]) +{ + int r; + int owner; + int group; + const char *path; + if (argc != 3) { + fprintf (stderr, "%s should have 3 parameter(s)\n", cmd); + fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd); + return -1; + } + owner = atoi (argv[0]); + group = atoi (argv[1]); + path = argv[2]; + r = guestfs_chown (g, owner, group, path); + return r; +} + int run_action (const char *cmd, int argc, char *argv[]) { if (strcasecmp (cmd, "launch") == 0 || strcasecmp (cmd, "run") == 0) @@ -1007,6 +1139,27 @@ int run_action (const char *cmd, int argc, char *argv[]) if (strcasecmp (cmd, "aug_ls") == 0 || strcasecmp (cmd, "aug-ls") == 0) return run_aug_ls (cmd, argc, argv); else + if (strcasecmp (cmd, "rm") == 0) + return run_rm (cmd, argc, argv); + else + if (strcasecmp (cmd, "rmdir") == 0) + return run_rmdir (cmd, argc, argv); + else + if (strcasecmp (cmd, "rm_rf") == 0 || strcasecmp (cmd, "rm-rf") == 0) + return run_rm_rf (cmd, argc, argv); + else + if (strcasecmp (cmd, "mkdir") == 0) + return run_mkdir (cmd, argc, argv); + else + if (strcasecmp (cmd, "mkdir_p") == 0 || strcasecmp (cmd, "mkdir-p") == 0) + return run_mkdir_p (cmd, argc, argv); + else + if (strcasecmp (cmd, "chmod") == 0) + return run_chmod (cmd, argc, argv); + else + if (strcasecmp (cmd, "chown") == 0) + return run_chown (cmd, argc, argv); + else { fprintf (stderr, "%s: unknown command\n", cmd); return -1; diff --git a/guestfish-actions.pod b/guestfish-actions.pod index 6312288..d47e9bf 100644 --- a/guestfish-actions.pod +++ b/guestfish-actions.pod @@ -193,6 +193,23 @@ Note that this function cannot correctly handle binary files as end of string). For those you need to use the C function which has a more complex interface. +=head2 chmod + + chmod mode path + +Change the mode (permissions) of C to C. Only +numeric modes are supported. + +=head2 chown + + chown owner group path + +Change the file owner to C and group to C. + +Only numeric uid and gid are supported. If you want to use +names, you will need to locate and parse the password file +yourself (Augeas support makes this relatively easy). + =head2 config config qemuparam qemuvalue @@ -302,6 +319,19 @@ See also C. List all the logical volumes detected. This is the equivalent of the L command. The "full" version includes all fields. +=head2 mkdir + + mkdir path + +Create a directory named C. + +=head2 mkdir-p + + mkdir-p path + +Create a directory named C, creating any parent directories +as necessary. This is like the C shell command. + =head2 mount mount device mountpoint @@ -356,6 +386,26 @@ Note that this function cannot correctly handle binary files as end of line). For those you need to use the C function which has a more complex interface. +=head2 rm + + rm path + +Remove the single file C. + +=head2 rm-rf + + rm-rf path + +Remove the file or directory C, recursively removing the +contents if its a directory. This is like the C shell +command. + +=head2 rmdir + + rmdir path + +Remove the single directory C. + =head2 set-autosync | autosync set-autosync true|false diff --git a/guestfs-actions.pod b/guestfs-actions.pod index 4b1ad4b..069ea8f 100644 --- a/guestfs-actions.pod +++ b/guestfs-actions.pod @@ -257,6 +257,32 @@ Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP. +=head2 guestfs_chmod + + int guestfs_chmod (guestfs_h *handle, + int mode, + const char *path); + +Change the mode (permissions) of C to C. Only +numeric modes are supported. + +This function returns 0 on success or -1 on error. + +=head2 guestfs_chown + + int guestfs_chown (guestfs_h *handle, + int owner, + int group, + const char *path); + +Change the file owner to C and group to C. + +Only numeric uid and gid are supported. If you want to use +names, you will need to locate and parse the password file +yourself (Augeas support makes this relatively easy). + +This function returns 0 on success or -1 on error. + =head2 guestfs_config int guestfs_config (guestfs_h *handle, @@ -405,6 +431,25 @@ of the L command. The "full" version includes all fields. This function returns a C. I after use>. +=head2 guestfs_mkdir + + int guestfs_mkdir (guestfs_h *handle, + const char *path); + +Create a directory named C. + +This function returns 0 on success or -1 on error. + +=head2 guestfs_mkdir_p + + int guestfs_mkdir_p (guestfs_h *handle, + const char *path); + +Create a directory named C, creating any parent directories +as necessary. This is like the C shell command. + +This function returns 0 on success or -1 on error. + =head2 guestfs_mount int guestfs_mount (guestfs_h *handle, @@ -475,6 +520,35 @@ This function returns a NULL-terminated array of strings (like L), or NULL if there was an error. I. +=head2 guestfs_rm + + int guestfs_rm (guestfs_h *handle, + const char *path); + +Remove the single file C. + +This function returns 0 on success or -1 on error. + +=head2 guestfs_rm_rf + + int guestfs_rm_rf (guestfs_h *handle, + const char *path); + +Remove the file or directory C, recursively removing the +contents if its a directory. This is like the C shell +command. + +This function returns 0 on success or -1 on error. + +=head2 guestfs_rmdir + + int guestfs_rmdir (guestfs_h *handle, + const char *path); + +Remove the single directory C. + +This function returns 0 on success or -1 on error. + =head2 guestfs_set_autosync int guestfs_set_autosync (guestfs_h *handle, diff --git a/ocaml/guestfs.ml b/ocaml/guestfs.ml index fba005f..32a6b82 100644 --- a/ocaml/guestfs.ml +++ b/ocaml/guestfs.ml @@ -125,3 +125,10 @@ external aug_match : t -> string -> string array = "ocaml_guestfs_aug_match" external aug_save : t -> unit = "ocaml_guestfs_aug_save" external aug_load : t -> unit = "ocaml_guestfs_aug_load" external aug_ls : t -> string -> string array = "ocaml_guestfs_aug_ls" +external rm : t -> string -> unit = "ocaml_guestfs_rm" +external rmdir : t -> string -> unit = "ocaml_guestfs_rmdir" +external rm_rf : t -> string -> unit = "ocaml_guestfs_rm_rf" +external mkdir : t -> string -> unit = "ocaml_guestfs_mkdir" +external mkdir_p : t -> string -> unit = "ocaml_guestfs_mkdir_p" +external chmod : t -> int -> string -> unit = "ocaml_guestfs_chmod" +external chown : t -> int -> int -> string -> unit = "ocaml_guestfs_chown" diff --git a/ocaml/guestfs.mli b/ocaml/guestfs.mli index 4981eb1..ecf86f1 100644 --- a/ocaml/guestfs.mli +++ b/ocaml/guestfs.mli @@ -214,3 +214,24 @@ val aug_load : t -> unit val aug_ls : t -> string -> string array (** list Augeas nodes under a path *) +val rm : t -> string -> unit +(** remove a file *) + +val rmdir : t -> string -> unit +(** remove a directory *) + +val rm_rf : t -> string -> unit +(** remove a file or directory recursively *) + +val mkdir : t -> string -> unit +(** create a directory *) + +val mkdir_p : t -> string -> unit +(** create a directory and parents *) + +val chmod : t -> int -> string -> unit +(** change file mode *) + +val chown : t -> int -> int -> string -> unit +(** change file owner and group *) + diff --git a/ocaml/guestfs_c_actions.c b/ocaml/guestfs_c_actions.c index f26226c..6675cf8 100644 --- a/ocaml/guestfs_c_actions.c +++ b/ocaml/guestfs_c_actions.c @@ -1183,3 +1183,167 @@ ocaml_guestfs_aug_ls (value gv, value pathv) CAMLreturn (rv); } +CAMLprim value +ocaml_guestfs_rm (value gv, value pathv) +{ + CAMLparam2 (gv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("rm: used handle after closing it"); + + const char *path = String_val (pathv); + int r; + + caml_enter_blocking_section (); + r = guestfs_rm (g, path); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "rm"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_rmdir (value gv, value pathv) +{ + CAMLparam2 (gv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("rmdir: used handle after closing it"); + + const char *path = String_val (pathv); + int r; + + caml_enter_blocking_section (); + r = guestfs_rmdir (g, path); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "rmdir"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_rm_rf (value gv, value pathv) +{ + CAMLparam2 (gv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("rm_rf: used handle after closing it"); + + const char *path = String_val (pathv); + int r; + + caml_enter_blocking_section (); + r = guestfs_rm_rf (g, path); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "rm_rf"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_mkdir (value gv, value pathv) +{ + CAMLparam2 (gv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("mkdir: used handle after closing it"); + + const char *path = String_val (pathv); + int r; + + caml_enter_blocking_section (); + r = guestfs_mkdir (g, path); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "mkdir"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_mkdir_p (value gv, value pathv) +{ + CAMLparam2 (gv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("mkdir_p: used handle after closing it"); + + const char *path = String_val (pathv); + int r; + + caml_enter_blocking_section (); + r = guestfs_mkdir_p (g, path); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "mkdir_p"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_chmod (value gv, value modev, value pathv) +{ + CAMLparam3 (gv, modev, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("chmod: used handle after closing it"); + + int mode = Int_val (modev); + const char *path = String_val (pathv); + int r; + + caml_enter_blocking_section (); + r = guestfs_chmod (g, mode, path); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "chmod"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_chown (value gv, value ownerv, value groupv, value pathv) +{ + CAMLparam4 (gv, ownerv, groupv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("chown: used handle after closing it"); + + int owner = Int_val (ownerv); + int group = Int_val (groupv); + const char *path = String_val (pathv); + int r; + + caml_enter_blocking_section (); + r = guestfs_chown (g, owner, group, path); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "chown"); + + rv = Val_unit; + CAMLreturn (rv); +} + diff --git a/perl/Guestfs.xs b/perl/Guestfs.xs index 954d7e2..d5f1da6 100644 --- a/perl/Guestfs.xs +++ b/perl/Guestfs.xs @@ -642,3 +642,62 @@ PREINIT: } free (matches); +void +rm (g, path) + guestfs_h *g; + char *path; + PPCODE: + if (guestfs_rm (g, path) == -1) + croak ("rm: %s", last_error); + +void +rmdir (g, path) + guestfs_h *g; + char *path; + PPCODE: + if (guestfs_rmdir (g, path) == -1) + croak ("rmdir: %s", last_error); + +void +rm_rf (g, path) + guestfs_h *g; + char *path; + PPCODE: + if (guestfs_rm_rf (g, path) == -1) + croak ("rm_rf: %s", last_error); + +void +mkdir (g, path) + guestfs_h *g; + char *path; + PPCODE: + if (guestfs_mkdir (g, path) == -1) + croak ("mkdir: %s", last_error); + +void +mkdir_p (g, path) + guestfs_h *g; + char *path; + PPCODE: + if (guestfs_mkdir_p (g, path) == -1) + croak ("mkdir_p: %s", last_error); + +void +chmod (g, mode, path) + guestfs_h *g; + int mode; + char *path; + PPCODE: + if (guestfs_chmod (g, mode, path) == -1) + croak ("chmod: %s", last_error); + +void +chown (g, owner, group, path) + guestfs_h *g; + int owner; + int group; + char *path; + PPCODE: + if (guestfs_chown (g, owner, group, path) == -1) + croak ("chown: %s", last_error); + diff --git a/perl/lib/Sys/Guestfs.pm b/perl/lib/Sys/Guestfs.pm index d3027f3..50f5d75 100644 --- a/perl/lib/Sys/Guestfs.pm +++ b/perl/lib/Sys/Guestfs.pm @@ -258,6 +258,19 @@ Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP. +=item $h->chmod (mode, path); + +Change the mode (permissions) of C to C. Only +numeric modes are supported. + +=item $h->chown (owner, group, path); + +Change the file owner to C and group to C. + +Only numeric uid and gid are supported. If you want to use +names, you will need to locate and parse the password file +yourself (Augeas support makes this relatively easy). + =item $h->config (qemuparam, qemuvalue); This can be used to add arbitrary qemu command line parameters @@ -343,6 +356,15 @@ See also C<$h-Elvs_full>. List all the logical volumes detected. This is the equivalent of the L command. The "full" version includes all fields. +=item $h->mkdir (path); + +Create a directory named C. + +=item $h->mkdir_p (path); + +Create a directory named C, creating any parent directories +as necessary. This is like the C shell command. + =item $h->mount (device, mountpoint); Mount a guest disk at a position in the filesystem. Block devices @@ -389,6 +411,20 @@ Note that this function cannot correctly handle binary files as end of line). For those you need to use the C<$h-Eread_file> function which has a more complex interface. +=item $h->rm (path); + +Remove the single file C. + +=item $h->rm_rf (path); + +Remove the file or directory C, recursively removing the +contents if its a directory. This is like the C shell +command. + +=item $h->rmdir (path); + +Remove the single directory C. + =item $h->set_autosync (autosync); If C is true, this enables autosync. Libguestfs will make a diff --git a/src/guestfs-actions.c b/src/guestfs-actions.c index 9b9749a..25892cd 100644 --- a/src/guestfs-actions.c +++ b/src/guestfs-actions.c @@ -2051,3 +2051,492 @@ char **guestfs_aug_ls (guestfs_h *g, return rv.ret.matches.matches_val; } +struct rm_rv { + int cb_done; /* flag to indicate callback was called */ + struct guestfs_message_header hdr; + struct guestfs_message_error err; +}; + +static void rm_cb (guestfs_h *g, void *data, XDR *xdr) +{ + struct rm_rv *rv = (struct rm_rv *) data; + + if (!xdr_guestfs_message_header (xdr, &rv->hdr)) { + error (g, "guestfs_rm: failed to parse reply header"); + return; + } + if (rv->hdr.status == GUESTFS_STATUS_ERROR) { + if (!xdr_guestfs_message_error (xdr, &rv->err)) { + error (g, "guestfs_rm: failed to parse reply error"); + return; + } + goto done; + } + done: + rv->cb_done = 1; + main_loop.main_loop_quit (g); +} + +int guestfs_rm (guestfs_h *g, + const char *path) +{ + struct guestfs_rm_args args; + struct rm_rv rv; + int serial; + + if (g->state != READY) { + error (g, "guestfs_rm called from the wrong state, %d != READY", + g->state); + return -1; + } + + memset (&rv, 0, sizeof rv); + + args.path = (char *) path; + serial = dispatch (g, GUESTFS_PROC_RM, + (xdrproc_t) xdr_guestfs_rm_args, (char *) &args); + if (serial == -1) + return -1; + + rv.cb_done = 0; + g->reply_cb_internal = rm_cb; + g->reply_cb_internal_data = &rv; + main_loop.main_loop_run (g); + g->reply_cb_internal = NULL; + g->reply_cb_internal_data = NULL; + if (!rv.cb_done) { + error (g, "guestfs_rm failed, see earlier error messages"); + return -1; + } + + if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_RM, serial) == -1) + return -1; + + if (rv.hdr.status == GUESTFS_STATUS_ERROR) { + error (g, "%s", rv.err.error); + return -1; + } + + return 0; +} + +struct rmdir_rv { + int cb_done; /* flag to indicate callback was called */ + struct guestfs_message_header hdr; + struct guestfs_message_error err; +}; + +static void rmdir_cb (guestfs_h *g, void *data, XDR *xdr) +{ + struct rmdir_rv *rv = (struct rmdir_rv *) data; + + if (!xdr_guestfs_message_header (xdr, &rv->hdr)) { + error (g, "guestfs_rmdir: failed to parse reply header"); + return; + } + if (rv->hdr.status == GUESTFS_STATUS_ERROR) { + if (!xdr_guestfs_message_error (xdr, &rv->err)) { + error (g, "guestfs_rmdir: failed to parse reply error"); + return; + } + goto done; + } + done: + rv->cb_done = 1; + main_loop.main_loop_quit (g); +} + +int guestfs_rmdir (guestfs_h *g, + const char *path) +{ + struct guestfs_rmdir_args args; + struct rmdir_rv rv; + int serial; + + if (g->state != READY) { + error (g, "guestfs_rmdir called from the wrong state, %d != READY", + g->state); + return -1; + } + + memset (&rv, 0, sizeof rv); + + args.path = (char *) path; + serial = dispatch (g, GUESTFS_PROC_RMDIR, + (xdrproc_t) xdr_guestfs_rmdir_args, (char *) &args); + if (serial == -1) + return -1; + + rv.cb_done = 0; + g->reply_cb_internal = rmdir_cb; + g->reply_cb_internal_data = &rv; + main_loop.main_loop_run (g); + g->reply_cb_internal = NULL; + g->reply_cb_internal_data = NULL; + if (!rv.cb_done) { + error (g, "guestfs_rmdir failed, see earlier error messages"); + return -1; + } + + if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_RMDIR, serial) == -1) + return -1; + + if (rv.hdr.status == GUESTFS_STATUS_ERROR) { + error (g, "%s", rv.err.error); + return -1; + } + + return 0; +} + +struct rm_rf_rv { + int cb_done; /* flag to indicate callback was called */ + struct guestfs_message_header hdr; + struct guestfs_message_error err; +}; + +static void rm_rf_cb (guestfs_h *g, void *data, XDR *xdr) +{ + struct rm_rf_rv *rv = (struct rm_rf_rv *) data; + + if (!xdr_guestfs_message_header (xdr, &rv->hdr)) { + error (g, "guestfs_rm_rf: failed to parse reply header"); + return; + } + if (rv->hdr.status == GUESTFS_STATUS_ERROR) { + if (!xdr_guestfs_message_error (xdr, &rv->err)) { + error (g, "guestfs_rm_rf: failed to parse reply error"); + return; + } + goto done; + } + done: + rv->cb_done = 1; + main_loop.main_loop_quit (g); +} + +int guestfs_rm_rf (guestfs_h *g, + const char *path) +{ + struct guestfs_rm_rf_args args; + struct rm_rf_rv rv; + int serial; + + if (g->state != READY) { + error (g, "guestfs_rm_rf called from the wrong state, %d != READY", + g->state); + return -1; + } + + memset (&rv, 0, sizeof rv); + + args.path = (char *) path; + serial = dispatch (g, GUESTFS_PROC_RM_RF, + (xdrproc_t) xdr_guestfs_rm_rf_args, (char *) &args); + if (serial == -1) + return -1; + + rv.cb_done = 0; + g->reply_cb_internal = rm_rf_cb; + g->reply_cb_internal_data = &rv; + main_loop.main_loop_run (g); + g->reply_cb_internal = NULL; + g->reply_cb_internal_data = NULL; + if (!rv.cb_done) { + error (g, "guestfs_rm_rf failed, see earlier error messages"); + return -1; + } + + if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_RM_RF, serial) == -1) + return -1; + + if (rv.hdr.status == GUESTFS_STATUS_ERROR) { + error (g, "%s", rv.err.error); + return -1; + } + + return 0; +} + +struct mkdir_rv { + int cb_done; /* flag to indicate callback was called */ + struct guestfs_message_header hdr; + struct guestfs_message_error err; +}; + +static void mkdir_cb (guestfs_h *g, void *data, XDR *xdr) +{ + struct mkdir_rv *rv = (struct mkdir_rv *) data; + + if (!xdr_guestfs_message_header (xdr, &rv->hdr)) { + error (g, "guestfs_mkdir: failed to parse reply header"); + return; + } + if (rv->hdr.status == GUESTFS_STATUS_ERROR) { + if (!xdr_guestfs_message_error (xdr, &rv->err)) { + error (g, "guestfs_mkdir: failed to parse reply error"); + return; + } + goto done; + } + done: + rv->cb_done = 1; + main_loop.main_loop_quit (g); +} + +int guestfs_mkdir (guestfs_h *g, + const char *path) +{ + struct guestfs_mkdir_args args; + struct mkdir_rv rv; + int serial; + + if (g->state != READY) { + error (g, "guestfs_mkdir called from the wrong state, %d != READY", + g->state); + return -1; + } + + memset (&rv, 0, sizeof rv); + + args.path = (char *) path; + serial = dispatch (g, GUESTFS_PROC_MKDIR, + (xdrproc_t) xdr_guestfs_mkdir_args, (char *) &args); + if (serial == -1) + return -1; + + rv.cb_done = 0; + g->reply_cb_internal = mkdir_cb; + g->reply_cb_internal_data = &rv; + main_loop.main_loop_run (g); + g->reply_cb_internal = NULL; + g->reply_cb_internal_data = NULL; + if (!rv.cb_done) { + error (g, "guestfs_mkdir failed, see earlier error messages"); + return -1; + } + + if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_MKDIR, serial) == -1) + return -1; + + if (rv.hdr.status == GUESTFS_STATUS_ERROR) { + error (g, "%s", rv.err.error); + return -1; + } + + return 0; +} + +struct mkdir_p_rv { + int cb_done; /* flag to indicate callback was called */ + struct guestfs_message_header hdr; + struct guestfs_message_error err; +}; + +static void mkdir_p_cb (guestfs_h *g, void *data, XDR *xdr) +{ + struct mkdir_p_rv *rv = (struct mkdir_p_rv *) data; + + if (!xdr_guestfs_message_header (xdr, &rv->hdr)) { + error (g, "guestfs_mkdir_p: failed to parse reply header"); + return; + } + if (rv->hdr.status == GUESTFS_STATUS_ERROR) { + if (!xdr_guestfs_message_error (xdr, &rv->err)) { + error (g, "guestfs_mkdir_p: failed to parse reply error"); + return; + } + goto done; + } + done: + rv->cb_done = 1; + main_loop.main_loop_quit (g); +} + +int guestfs_mkdir_p (guestfs_h *g, + const char *path) +{ + struct guestfs_mkdir_p_args args; + struct mkdir_p_rv rv; + int serial; + + if (g->state != READY) { + error (g, "guestfs_mkdir_p called from the wrong state, %d != READY", + g->state); + return -1; + } + + memset (&rv, 0, sizeof rv); + + args.path = (char *) path; + serial = dispatch (g, GUESTFS_PROC_MKDIR_P, + (xdrproc_t) xdr_guestfs_mkdir_p_args, (char *) &args); + if (serial == -1) + return -1; + + rv.cb_done = 0; + g->reply_cb_internal = mkdir_p_cb; + g->reply_cb_internal_data = &rv; + main_loop.main_loop_run (g); + g->reply_cb_internal = NULL; + g->reply_cb_internal_data = NULL; + if (!rv.cb_done) { + error (g, "guestfs_mkdir_p failed, see earlier error messages"); + return -1; + } + + if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_MKDIR_P, serial) == -1) + return -1; + + if (rv.hdr.status == GUESTFS_STATUS_ERROR) { + error (g, "%s", rv.err.error); + return -1; + } + + return 0; +} + +struct chmod_rv { + int cb_done; /* flag to indicate callback was called */ + struct guestfs_message_header hdr; + struct guestfs_message_error err; +}; + +static void chmod_cb (guestfs_h *g, void *data, XDR *xdr) +{ + struct chmod_rv *rv = (struct chmod_rv *) data; + + if (!xdr_guestfs_message_header (xdr, &rv->hdr)) { + error (g, "guestfs_chmod: failed to parse reply header"); + return; + } + if (rv->hdr.status == GUESTFS_STATUS_ERROR) { + if (!xdr_guestfs_message_error (xdr, &rv->err)) { + error (g, "guestfs_chmod: failed to parse reply error"); + return; + } + goto done; + } + done: + rv->cb_done = 1; + main_loop.main_loop_quit (g); +} + +int guestfs_chmod (guestfs_h *g, + int mode, + const char *path) +{ + struct guestfs_chmod_args args; + struct chmod_rv rv; + int serial; + + if (g->state != READY) { + error (g, "guestfs_chmod called from the wrong state, %d != READY", + g->state); + return -1; + } + + memset (&rv, 0, sizeof rv); + + args.mode = mode; + args.path = (char *) path; + serial = dispatch (g, GUESTFS_PROC_CHMOD, + (xdrproc_t) xdr_guestfs_chmod_args, (char *) &args); + if (serial == -1) + return -1; + + rv.cb_done = 0; + g->reply_cb_internal = chmod_cb; + g->reply_cb_internal_data = &rv; + main_loop.main_loop_run (g); + g->reply_cb_internal = NULL; + g->reply_cb_internal_data = NULL; + if (!rv.cb_done) { + error (g, "guestfs_chmod failed, see earlier error messages"); + return -1; + } + + if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_CHMOD, serial) == -1) + return -1; + + if (rv.hdr.status == GUESTFS_STATUS_ERROR) { + error (g, "%s", rv.err.error); + return -1; + } + + return 0; +} + +struct chown_rv { + int cb_done; /* flag to indicate callback was called */ + struct guestfs_message_header hdr; + struct guestfs_message_error err; +}; + +static void chown_cb (guestfs_h *g, void *data, XDR *xdr) +{ + struct chown_rv *rv = (struct chown_rv *) data; + + if (!xdr_guestfs_message_header (xdr, &rv->hdr)) { + error (g, "guestfs_chown: failed to parse reply header"); + return; + } + if (rv->hdr.status == GUESTFS_STATUS_ERROR) { + if (!xdr_guestfs_message_error (xdr, &rv->err)) { + error (g, "guestfs_chown: failed to parse reply error"); + return; + } + goto done; + } + done: + rv->cb_done = 1; + main_loop.main_loop_quit (g); +} + +int guestfs_chown (guestfs_h *g, + int owner, + int group, + const char *path) +{ + struct guestfs_chown_args args; + struct chown_rv rv; + int serial; + + if (g->state != READY) { + error (g, "guestfs_chown called from the wrong state, %d != READY", + g->state); + return -1; + } + + memset (&rv, 0, sizeof rv); + + args.owner = owner; + args.group = group; + args.path = (char *) path; + serial = dispatch (g, GUESTFS_PROC_CHOWN, + (xdrproc_t) xdr_guestfs_chown_args, (char *) &args); + if (serial == -1) + return -1; + + rv.cb_done = 0; + g->reply_cb_internal = chown_cb; + g->reply_cb_internal_data = &rv; + main_loop.main_loop_run (g); + g->reply_cb_internal = NULL; + g->reply_cb_internal_data = NULL; + if (!rv.cb_done) { + error (g, "guestfs_chown failed, see earlier error messages"); + return -1; + } + + if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_CHOWN, serial) == -1) + return -1; + + if (rv.hdr.status == GUESTFS_STATUS_ERROR) { + error (g, "%s", rv.err.error); + return -1; + } + + return 0; +} + diff --git a/src/guestfs-actions.h b/src/guestfs-actions.h index 497e36b..06f1485 100644 --- a/src/guestfs-actions.h +++ b/src/guestfs-actions.h @@ -59,3 +59,10 @@ extern char **guestfs_aug_match (guestfs_h *handle, const char *path); extern int guestfs_aug_save (guestfs_h *handle); extern int guestfs_aug_load (guestfs_h *handle); extern char **guestfs_aug_ls (guestfs_h *handle, const char *path); +extern int guestfs_rm (guestfs_h *handle, const char *path); +extern int guestfs_rmdir (guestfs_h *handle, const char *path); +extern int guestfs_rm_rf (guestfs_h *handle, const char *path); +extern int guestfs_mkdir (guestfs_h *handle, const char *path); +extern int guestfs_mkdir_p (guestfs_h *handle, const char *path); +extern int guestfs_chmod (guestfs_h *handle, int mode, const char *path); +extern int guestfs_chown (guestfs_h *handle, int owner, int group, const char *path); diff --git a/src/guestfs_protocol.c b/src/guestfs_protocol.c index ed38a8d..781c2da 100644 --- a/src/guestfs_protocol.c +++ b/src/guestfs_protocol.c @@ -543,6 +543,82 @@ xdr_guestfs_aug_ls_ret (XDR *xdrs, guestfs_aug_ls_ret *objp) } bool_t +xdr_guestfs_rm_args (XDR *xdrs, guestfs_rm_args *objp) +{ + register int32_t *buf; + + if (!xdr_string (xdrs, &objp->path, ~0)) + return FALSE; + return TRUE; +} + +bool_t +xdr_guestfs_rmdir_args (XDR *xdrs, guestfs_rmdir_args *objp) +{ + register int32_t *buf; + + if (!xdr_string (xdrs, &objp->path, ~0)) + return FALSE; + return TRUE; +} + +bool_t +xdr_guestfs_rm_rf_args (XDR *xdrs, guestfs_rm_rf_args *objp) +{ + register int32_t *buf; + + if (!xdr_string (xdrs, &objp->path, ~0)) + return FALSE; + return TRUE; +} + +bool_t +xdr_guestfs_mkdir_args (XDR *xdrs, guestfs_mkdir_args *objp) +{ + register int32_t *buf; + + if (!xdr_string (xdrs, &objp->path, ~0)) + return FALSE; + return TRUE; +} + +bool_t +xdr_guestfs_mkdir_p_args (XDR *xdrs, guestfs_mkdir_p_args *objp) +{ + register int32_t *buf; + + if (!xdr_string (xdrs, &objp->path, ~0)) + return FALSE; + return TRUE; +} + +bool_t +xdr_guestfs_chmod_args (XDR *xdrs, guestfs_chmod_args *objp) +{ + register int32_t *buf; + + if (!xdr_int (xdrs, &objp->mode)) + return FALSE; + if (!xdr_string (xdrs, &objp->path, ~0)) + return FALSE; + return TRUE; +} + +bool_t +xdr_guestfs_chown_args (XDR *xdrs, guestfs_chown_args *objp) +{ + register int32_t *buf; + + if (!xdr_int (xdrs, &objp->owner)) + return FALSE; + if (!xdr_int (xdrs, &objp->group)) + return FALSE; + if (!xdr_string (xdrs, &objp->path, ~0)) + return FALSE; + return TRUE; +} + +bool_t xdr_guestfs_procedure (XDR *xdrs, guestfs_procedure *objp) { register int32_t *buf; diff --git a/src/guestfs_protocol.h b/src/guestfs_protocol.h index a094355..508bc4e 100644 --- a/src/guestfs_protocol.h +++ b/src/guestfs_protocol.h @@ -299,6 +299,44 @@ struct guestfs_aug_ls_ret { }; typedef struct guestfs_aug_ls_ret guestfs_aug_ls_ret; +struct guestfs_rm_args { + char *path; +}; +typedef struct guestfs_rm_args guestfs_rm_args; + +struct guestfs_rmdir_args { + char *path; +}; +typedef struct guestfs_rmdir_args guestfs_rmdir_args; + +struct guestfs_rm_rf_args { + char *path; +}; +typedef struct guestfs_rm_rf_args guestfs_rm_rf_args; + +struct guestfs_mkdir_args { + char *path; +}; +typedef struct guestfs_mkdir_args guestfs_mkdir_args; + +struct guestfs_mkdir_p_args { + char *path; +}; +typedef struct guestfs_mkdir_p_args guestfs_mkdir_p_args; + +struct guestfs_chmod_args { + int mode; + char *path; +}; +typedef struct guestfs_chmod_args guestfs_chmod_args; + +struct guestfs_chown_args { + int owner; + int group; + char *path; +}; +typedef struct guestfs_chown_args guestfs_chown_args; + enum guestfs_procedure { GUESTFS_PROC_MOUNT = 1, GUESTFS_PROC_SYNC = 2, @@ -328,7 +366,14 @@ enum guestfs_procedure { GUESTFS_PROC_AUG_SAVE = 25, GUESTFS_PROC_AUG_LOAD = 27, GUESTFS_PROC_AUG_LS = 28, - GUESTFS_PROC_dummy = 28 + 1, + GUESTFS_PROC_RM = 29, + GUESTFS_PROC_RMDIR = 30, + GUESTFS_PROC_RM_RF = 31, + GUESTFS_PROC_MKDIR = 32, + GUESTFS_PROC_MKDIR_P = 33, + GUESTFS_PROC_CHMOD = 34, + GUESTFS_PROC_CHOWN = 35, + GUESTFS_PROC_dummy = 35 + 1, }; typedef enum guestfs_procedure guestfs_procedure; #define GUESTFS_MESSAGE_MAX 4194304 @@ -407,6 +452,13 @@ extern bool_t xdr_guestfs_aug_match_args (XDR *, guestfs_aug_match_args*); extern bool_t xdr_guestfs_aug_match_ret (XDR *, guestfs_aug_match_ret*); extern bool_t xdr_guestfs_aug_ls_args (XDR *, guestfs_aug_ls_args*); extern bool_t xdr_guestfs_aug_ls_ret (XDR *, guestfs_aug_ls_ret*); +extern bool_t xdr_guestfs_rm_args (XDR *, guestfs_rm_args*); +extern bool_t xdr_guestfs_rmdir_args (XDR *, guestfs_rmdir_args*); +extern bool_t xdr_guestfs_rm_rf_args (XDR *, guestfs_rm_rf_args*); +extern bool_t xdr_guestfs_mkdir_args (XDR *, guestfs_mkdir_args*); +extern bool_t xdr_guestfs_mkdir_p_args (XDR *, guestfs_mkdir_p_args*); +extern bool_t xdr_guestfs_chmod_args (XDR *, guestfs_chmod_args*); +extern bool_t xdr_guestfs_chown_args (XDR *, guestfs_chown_args*); extern bool_t xdr_guestfs_procedure (XDR *, guestfs_procedure*); extern bool_t xdr_guestfs_message_direction (XDR *, guestfs_message_direction*); extern bool_t xdr_guestfs_message_status (XDR *, guestfs_message_status*); @@ -455,6 +507,13 @@ extern bool_t xdr_guestfs_aug_match_args (); extern bool_t xdr_guestfs_aug_match_ret (); extern bool_t xdr_guestfs_aug_ls_args (); extern bool_t xdr_guestfs_aug_ls_ret (); +extern bool_t xdr_guestfs_rm_args (); +extern bool_t xdr_guestfs_rmdir_args (); +extern bool_t xdr_guestfs_rm_rf_args (); +extern bool_t xdr_guestfs_mkdir_args (); +extern bool_t xdr_guestfs_mkdir_p_args (); +extern bool_t xdr_guestfs_chmod_args (); +extern bool_t xdr_guestfs_chown_args (); extern bool_t xdr_guestfs_procedure (); extern bool_t xdr_guestfs_message_direction (); extern bool_t xdr_guestfs_message_status (); diff --git a/src/guestfs_protocol.x b/src/guestfs_protocol.x index 8e3d2a9..41116b5 100644 --- a/src/guestfs_protocol.x +++ b/src/guestfs_protocol.x @@ -231,6 +231,37 @@ struct guestfs_aug_ls_ret { str matches<>; }; +struct guestfs_rm_args { + string path<>; +}; + +struct guestfs_rmdir_args { + string path<>; +}; + +struct guestfs_rm_rf_args { + string path<>; +}; + +struct guestfs_mkdir_args { + string path<>; +}; + +struct guestfs_mkdir_p_args { + string path<>; +}; + +struct guestfs_chmod_args { + int mode; + string path<>; +}; + +struct guestfs_chown_args { + int owner; + int group; + string path<>; +}; + enum guestfs_procedure { GUESTFS_PROC_MOUNT = 1, GUESTFS_PROC_SYNC = 2, @@ -260,6 +291,13 @@ enum guestfs_procedure { GUESTFS_PROC_AUG_SAVE = 25, GUESTFS_PROC_AUG_LOAD = 27, GUESTFS_PROC_AUG_LS = 28, + GUESTFS_PROC_RM = 29, + GUESTFS_PROC_RMDIR = 30, + GUESTFS_PROC_RM_RF = 31, + GUESTFS_PROC_MKDIR = 32, + GUESTFS_PROC_MKDIR_P = 33, + GUESTFS_PROC_CHMOD = 34, + GUESTFS_PROC_CHOWN = 35, GUESTFS_PROC_dummy };