Added Augeas support.

9 files changed, 1576 insertions, 110 deletions

diff --git a/src/generator.ml b/src/generator.ml
index af19fdad..3f42c391 100755
--- a/src/generator.ml
+++ b/src/generator.ml
@@ -32,17 +32,25 @@ and ret =
      * indication, ie. 0 or -1.
      *)
   | Err
+    (* "Int" as a return value means an int which is -1 for error
+     * or any value >= 0 on success.
+     *)
+  | RInt of string
     (* "RBool" is a bool return value which can be true/false or
      * -1 for error.
      *)
   | RBool of string
     (* "RConstString" is a string that refers to a constant value.
-     * Try to avoid using this.
+     * Try to avoid using this.  In particular you cannot use this
+     * for values returned from the daemon, because there is no
+     * thread-safe way to return them in the C API.
      *)
   | RConstString of string
     (* "RString" and "RStringList" are caller-frees. *)
   | RString of string
   | RStringList of string
+    (* Some limited tuples are possible: *)
+  | RIntBool of string * string
     (* LVM PVs, VGs and LVs. *)
   | RPVList of string
   | RVGList of string
@@ -52,10 +60,12 @@ and args =
   | P0
   | P1 of argt
   | P2 of argt * argt
+  | P3 of argt * argt * argt
 and argt =
   | String of string	(* const char *name, cannot be NULL *)
   | OptString of string	(* const char *name, may be NULL *)
   | Bool of string	(* boolean *)
+  | Int of string	(* int (smallish ints, signed, <= 31 bits) *)
 
 type flags =
   | ProtocolLimitWarning  (* display warning about protocol size limits *)
@@ -323,6 +333,146 @@ Note that this function cannot correctly handle binary files
 (specifically, files containing C<\\0> character which is treated
 as end of line).  For those you need to use the C<guestfs_read_file>
 function which has a more complex interface.");
+
+  ("aug_init", (Err, P2 (String "root", Int "flags")), 16, [],
+   "create a new Augeas handle",
+   "\
+Create a new Augeas handle for editing configuration files.
+If there was any previous Augeas handle associated with this
+guestfs session, then it is closed.
+
+You must call this before using any other C<guestfs_aug_*>
+commands.
+
+C<root> is the filesystem root.  C<root> must not be NULL,
+use C</> instead.
+
+The flags are the same as the flags defined in
+E<lt>augeas.hE<gt>, the logical I<or> of the following
+integers:
+
+=over 4
+
+=item 1 C<AUG_SAVE_BACKUP>
+
+Keep the original file with a C<.augsave> extension.
+
+=item 2 C<AUG_SAVE_NEWFILE>
+
+Save changes into a file with extension C<.augnew>, and
+do not overwrite original.  Overrides C<AUG_SAVE_BACKUP>.
+
+=item 4 C<AUG_TYPE_CHECK>
+
+Typecheck lenses (can be expensive).
+
+=item 8 C<AUG_NO_STDINC>
+
+Do not use standard load path for modules.
+
+=item 16 C<AUG_SAVE_NOOP>
+
+Make save a no-op, just record what would have been changed.
+
+=item 32 C<AUG_NO_LOAD>
+
+Do not load the tree in C<guestfs_aug_init>.
+
+=back
+
+To close the handle, you can call C<guestfs_aug_close>.
+
+To find out more about Augeas, see L<http://augeas.net/>.");
+
+  ("aug_close", (Err, P0), 26, [],
+   "close the current Augeas handle",
+   "\
+Close the current Augeas handle and free up any resources
+used by it.  After calling this, you have to call
+C<guestfs_aug_init> again before you can use any other
+Augeas functions.");
+
+  ("aug_defvar", (RInt "nrnodes", P2 (String "name", OptString "expr")), 17, [],
+   "define an Augeas variable",
+   "\
+Defines an Augeas variable C<name> whose value is the result
+of evaluating C<expr>.  If C<expr> is NULL, then C<name> is
+undefined.
+
+On success this returns the number of nodes in C<expr>, or
+C<0> if C<expr> evaluates to something which is not a nodeset.");
+
+  ("aug_defnode", (RIntBool ("nrnodes", "created"), P3 (String "name", String "expr", String "val")), 18, [],
+   "define an Augeas node",
+   "\
+Defines a variable C<name> whose value is the result of
+evaluating C<expr>.
+
+If C<expr> evaluates to an empty nodeset, a node is created,
+equivalent to calling C<guestfs_aug_set> C<expr>, C<value>.
+C<name> will be the nodeset containing that single node.
+
+On success this returns a pair containing the
+number of nodes in the nodeset, and a boolean flag
+if a node was created.");
+
+  ("aug_get", (RString "val", P1 (String "path")), 19, [],
+   "look up the value of an Augeas path",
+   "\
+Look up the value associated with C<path>.  If C<path>
+matches exactly one node, the C<value> is returned.");
+
+  ("aug_set", (Err, P2 (String "path", String "val")), 20, [],
+   "set Augeas path to value",
+   "\
+Set the value associated with C<path> to C<value>.");
+
+  ("aug_insert", (Err, P3 (String "path", String "label", Bool "before")), 21, [],
+   "insert a sibling Augeas node",
+   "\
+Create a new sibling C<label> for C<path>, inserting it into
+the tree before or after C<path> (depending on the boolean
+flag C<before>).
+
+C<path> must match exactly one existing node in the tree, and
+C<label> must be a label, ie. not contain C</>, C<*> or end
+with a bracketed index C<[N]>.");
+
+  ("aug_rm", (RInt "nrnodes", P1 (String "path")), 22, [],
+   "remove an Augeas path",
+   "\
+Remove C<path> and all of its children.
+
+On success this returns the number of entries which were removed.");
+
+  ("aug_mv", (Err, P2 (String "src", String "dest")), 23, [],
+   "move Augeas node",
+   "\
+Move the node C<src> to C<dest>.  C<src> must match exactly
+one node.  C<dest> is overwritten if it exists.");
+
+  ("aug_match", (RStringList "matches", P1 (String "path")), 24, [],
+   "return Augeas nodes which match path",
+   "\
+Returns a list of paths which match the path expression C<path>.
+The returned paths are sufficiently qualified so that they match
+exactly one node in the current tree.");
+
+  ("aug_save", (Err, P0), 25, [],
+   "write all pending Augeas changes to disk",
+   "\
+This writes all pending changes to disk.
+
+The flags which were passed to C<guestfs_aug_init> affect exactly
+how files are saved.");
+
+  ("aug_load", (Err, P0), 27, [],
+   "load files into the tree",
+   "\
+Load files into the tree.
+
+See C<aug_load> in the Augeas documentation for the full gory
+details.");
 ]
 
 let all_functions = non_daemon_functions @ daemon_functions
@@ -465,18 +615,25 @@ let iter_args f = function
   | P0 -> ()
   | P1 arg1 -> f arg1
   | P2 (arg1, arg2) -> f arg1; f arg2
+  | P3 (arg1, arg2, arg3) -> f arg1; f arg2; f arg3
 
 let iteri_args f = function
   | P0 -> ()
   | P1 arg1 -> f 0 arg1
   | P2 (arg1, arg2) -> f 0 arg1; f 1 arg2
+  | P3 (arg1, arg2, arg3) -> f 0 arg1; f 1 arg2; f 2 arg3
 
 let map_args f = function
   | P0 -> []
   | P1 arg1 -> [f arg1]
-  | P2 (arg1, arg2) -> [f arg1; f arg2]
+  | P2 (arg1, arg2) ->
+      let n1 = f arg1 in let n2 = f arg2 in [n1; n2]
+  | P3 (arg1, arg2, arg3) ->
+      let n1 = f arg1 in let n2 = f arg2 in let n3 = f arg3 in [n1; n2; n3]
+
+let nr_args = function | P0 -> 0 | P1 _ -> 1 | P2 _ -> 2 | P3 _ -> 3
 
-let nr_args = function | P0 -> 0 | P1 _ -> 1 | P2 _ -> 2
+let name_of_argt = function String n | OptString n | Bool n | Int n -> n
 
 (* Check function names etc. for consistency. *)
 let check_functions () =
@@ -583,6 +740,8 @@ and generate_actions_pod () =
       (match fst style with
        | Err ->
 	   pr "This function returns 0 on success or -1 on error.\n\n"
+       | RInt _ ->
+	   pr "On error this function returns -1.\n\n"
        | RBool _ ->
 	   pr "This function returns a C truth value on success or -1 on error.\n\n"
        | RConstString _ ->
@@ -595,14 +754,17 @@ I<The caller must free the returned string after use>.\n\n"
 	   pr "This function returns a NULL-terminated array of strings
 (like L<environ(3)>), or NULL if there was an error.
 I<The caller must free the strings and the array after use>.\n\n"
+       | RIntBool _ ->
+	   pr "This function returns a C<struct guestfs_int_bool *>.
+I<The caller must call C<guestfs_free_int_bool> after use.>.\n\n"
        | RPVList _ ->
-	   pr "This function returns a C<struct guestfs_lvm_pv_list>.
+	   pr "This function returns a C<struct guestfs_lvm_pv_list *>.
 I<The caller must call C<guestfs_free_lvm_pv_list> after use.>.\n\n"
        | RVGList _ ->
-	   pr "This function returns a C<struct guestfs_lvm_vg_list>.
+	   pr "This function returns a C<struct guestfs_lvm_vg_list *>.
 I<The caller must call C<guestfs_free_lvm_vg_list> after use.>.\n\n"
        | RLVList _ ->
-	   pr "This function returns a C<struct guestfs_lvm_lv_list>.
+	   pr "This function returns a C<struct guestfs_lvm_lv_list *>.
 I<The caller must call C<guestfs_free_lvm_lv_list> after use.>.\n\n"
       );
       if List.mem ProtocolLimitWarning flags then
@@ -676,21 +838,26 @@ and generate_xdr () =
   List.iter (
     fun(shortname, style, _, _, _, _) ->
       let name = "guestfs_" ^ shortname in
-      pr "/* %s */\n\n" name;
+
       (match snd style with
        | P0 -> ()
        | args ->
 	   pr "struct %s_args {\n" name;
 	   iter_args (
 	     function
-	     | String name -> pr "  string %s<>;\n" name
-	     | OptString name -> pr "  string *%s<>;\n" name
-	     | Bool name -> pr "  bool %s;\n" name
+	     | String n -> pr "  string %s<>;\n" n
+	     | OptString n -> pr "  str *%s;\n" n
+	     | Bool n -> pr "  bool %s;\n" n
+	     | Int n -> pr "  int %s;\n" n
 	   ) args;
 	   pr "};\n\n"
       );
       (match fst style with
        | Err -> ()
+       | RInt n ->
+	   pr "struct %s_ret {\n" name;
+	   pr "  int %s;\n" n;
+	   pr "};\n\n"
        | RBool n ->
 	   pr "struct %s_ret {\n" name;
 	   pr "  bool %s;\n" n;
@@ -705,6 +872,11 @@ and generate_xdr () =
 	   pr "struct %s_ret {\n" name;
 	   pr "  str %s<>;\n" n;
 	   pr "};\n\n"
+       | RIntBool (n,m) ->
+	   pr "struct %s_ret {\n" name;
+	   pr "  int %s;\n" n;
+	   pr "  bool %s;\n" m;
+	   pr "};\n\n"
        | RPVList n ->
 	   pr "struct %s_ret {\n" name;
 	   pr "  guestfs_lvm_int_pv_list %s;\n" n;
@@ -788,6 +960,13 @@ and generate_structs_h () =
    * must be identical to what rpcgen / the RFC defines.
    *)
 
+  (* guestfs_int_bool structure. *)
+  pr "struct guestfs_int_bool {\n";
+  pr "  int32_t i;\n";
+  pr "  int32_t b;\n";
+  pr "};\n";
+  pr "\n";
+
   (* LVM public structures. *)
   List.iter (
     function
@@ -838,7 +1017,9 @@ and generate_client_actions () =
        | Err -> ()
        | RConstString _ ->
 	   failwithf "RConstString cannot be returned from a daemon function"
+       | RInt _
        | RBool _ | RString _ | RStringList _
+       | RIntBool _
        | RPVList _ | RVGList _ | RLVList _ ->
 	   pr "  struct %s_ret ret;\n" name
       );
@@ -865,7 +1046,9 @@ and generate_client_actions () =
        | Err -> ()
        | RConstString _ ->
 	   failwithf "RConstString cannot be returned from a daemon function"
+       | RInt _
        | RBool _ | RString _ | RStringList _
+       | RIntBool _
        | RPVList _ | RVGList _ | RLVList _ ->
 	    pr "  if (!xdr_%s_ret (xdr, &rv->ret)) {\n" name;
 	    pr "    error (g, \"%s: failed to parse reply\");\n" name;
@@ -884,10 +1067,11 @@ and generate_client_actions () =
 
       let error_code =
 	match fst style with
-	| Err | RBool _ -> "-1"
+	| Err | RInt _ | RBool _ -> "-1"
 	| RConstString _ ->
 	    failwithf "RConstString cannot be returned from a daemon function"
-	| RString _ | RStringList _ | RPVList _ | RVGList _ | RLVList _ ->
+	| RString _ | RStringList _ | RIntBool _
+	| RPVList _ | RVGList _ | RLVList _ ->
 	    "NULL" in
 
       pr "{\n";
@@ -917,12 +1101,14 @@ and generate_client_actions () =
        | args ->
 	   iter_args (
 	     function
-	     | String name ->
-		 pr "  args.%s = (char *) %s;\n" name name
-	     | OptString name ->
-		 pr "  args.%s = %s ? *%s : NULL;\n" name name name
-	     | Bool name ->
-		 pr "  args.%s = %s;\n" name name
+	     | String n ->
+		 pr "  args.%s = (char *) %s;\n" n n
+	     | OptString n ->
+		 pr "  args.%s = %s ? (char **) &%s : NULL;\n" n n n
+	     | Bool n ->
+		 pr "  args.%s = %s;\n" n n
+	     | Int n ->
+		 pr "  args.%s = %s;\n" n n
 	   ) args;
 	   pr "  serial = dispatch (g, GUESTFS_PROC_%s,\n"
 	     (String.uppercase shortname);
@@ -958,6 +1144,7 @@ and generate_client_actions () =
 
       (match fst style with
        | Err -> pr "  return 0;\n"
+       | RInt n
        | RBool n -> pr "  return rv.ret.%s;\n" n
        | RConstString _ ->
 	   failwithf "RConstString cannot be returned from a daemon function"
@@ -971,6 +1158,9 @@ and generate_client_actions () =
 	     n n;
 	   pr "  rv.ret.%s.%s_val[rv.ret.%s.%s_len] = NULL;\n" n n n n;
 	   pr "  return rv.ret.%s.%s_val;\n" n n
+       | RIntBool _ ->
+	   pr "  /* caller with free this */\n";
+	   pr "  return safe_memdup (g, &rv.ret, sizeof (rv.ret));\n"
        | RPVList n ->
 	   pr "  /* caller will free this */\n";
 	   pr "  return safe_memdup (g, &rv.ret.%s, sizeof (rv.ret.%s));\n" n n
@@ -995,7 +1185,8 @@ and generate_daemon_actions_h () =
   List.iter (
     fun (name, style, _, _, _, _) ->
 	generate_prototype
-	  ~single_line:true ~newline:true ~in_daemon:true ("do_" ^ name) style;
+	  ~single_line:true ~newline:true ~in_daemon:true ~prefix:"do_"
+	  name style;
   ) daemon_functions
 
 (* Generate the server-side stubs. *)
@@ -1024,12 +1215,13 @@ and generate_daemon_actions () =
       pr "{\n";
       let error_code =
 	match fst style with
-	| Err -> pr "  int r;\n"; "-1"
+	| Err | RInt _ -> pr "  int r;\n"; "-1"
 	| RBool _ -> pr "  int r;\n"; "-1"
 	| RConstString _ ->
 	    failwithf "RConstString cannot be returned from a daemon function"
 	| RString _ -> pr "  char *r;\n"; "NULL"
 	| RStringList _ -> pr "  char **r;\n"; "NULL"
+	| RIntBool _ -> pr "  guestfs_%s_ret *r;\n" name; "NULL"
 	| RPVList _ -> pr "  guestfs_lvm_int_pv_list *r;\n"; "NULL"
 	| RVGList _ -> pr "  guestfs_lvm_int_vg_list *r;\n"; "NULL"
 	| RLVList _ -> pr "  guestfs_lvm_int_lv_list *r;\n"; "NULL" in
@@ -1040,9 +1232,10 @@ and generate_daemon_actions () =
 	   pr "  struct guestfs_%s_args args;\n" name;
 	   iter_args (
 	     function
-	     | String name
-	     | OptString name -> pr "  const char *%s;\n" name
-	     | Bool name -> pr "  int %s;\n" name
+	     | String n
+	     | OptString n -> pr "  const char *%s;\n" n
+	     | Bool n -> pr "  int %s;\n" n
+	     | Int n -> pr "  int %s;\n" n
 	   ) args
       );
       pr "\n";
@@ -1053,14 +1246,15 @@ and generate_daemon_actions () =
 	   pr "  memset (&args, 0, sizeof args);\n";
 	   pr "\n";
 	   pr "  if (!xdr_guestfs_%s_args (xdr_in, &args)) {\n" name;
-	   pr "    reply_with_error (\"%s: daemon failed to decode procedure arguments\");\n" name;
+	   pr "    reply_with_error (\"%%s: daemon failed to decode procedure arguments\", \"%s\");\n" name;
 	   pr "    return;\n";
 	   pr "  }\n";
 	   iter_args (
 	     function
-	     | String name -> pr "  %s = args.%s;\n" name name
-	     | OptString name -> pr "  %s = args.%s;\n" name name (* XXX? *)
-	     | Bool name -> pr "  %s = args.%s;\n" name name
+	     | String n -> pr "  %s = args.%s;\n" n n
+	     | OptString n -> pr "  %s = args.%s ? *args.%s : NULL;\n" n n n
+	     | Bool n -> pr "  %s = args.%s;\n" n n
+	     | Int n -> pr "  %s = args.%s;\n" n n
 	   ) args;
 	   pr "\n"
       );
@@ -1076,6 +1270,10 @@ and generate_daemon_actions () =
 
       (match fst style with
        | Err -> pr "  reply (NULL, NULL);\n"
+       | RInt n ->
+	   pr "  struct guestfs_%s_ret ret;\n" name;
+	   pr "  ret.%s = r;\n" n;
+	   pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n" name
        | RBool n ->
 	   pr "  struct guestfs_%s_ret ret;\n" name;
 	   pr "  ret.%s = r;\n" n;
@@ -1093,20 +1291,23 @@ and generate_daemon_actions () =
 	   pr "  ret.%s.%s_val = r;\n" n n;
 	   pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n" name;
 	   pr "  free_strings (r);\n"
+       | RIntBool _ ->
+	   pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) r);\n" name;
+	   pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) r);\n" name
        | RPVList n ->
 	   pr "  struct guestfs_%s_ret ret;\n" name;
 	   pr "  ret.%s = *r;\n" n;
-	   pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n" name;
+	   pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n" name;
 	   pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n" name
        | RVGList n ->
 	   pr "  struct guestfs_%s_ret ret;\n" name;
 	   pr "  ret.%s = *r;\n" n;
-	   pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n" name;
+	   pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n" name;
 	   pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n" name
        | RLVList n ->
 	   pr "  struct guestfs_%s_ret ret;\n" name;
 	   pr "  ret.%s = *r;\n" n;
-	   pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n" name;
+	   pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n" name;
 	   pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n" name
       );
 
@@ -1348,12 +1549,7 @@ and generate_fish_cmds () =
 	| P0 -> name2
 	| args ->
 	    sprintf "%s <%s>"
-	      name2 (
-		String.concat "> <" (
-		  map_args (function
-			    | String n | OptString n | Bool n -> n) args
-		)
-	      ) in
+	      name2 (String.concat "> <" (map_args name_of_argt args)) in
 
       let warnings =
 	if List.mem ProtocolLimitWarning flags then
@@ -1429,19 +1625,22 @@ FTP."
       pr "{\n";
       (match fst style with
        | Err
+       | RInt _
        | RBool _ -> pr "  int r;\n"
        | RConstString _ -> pr "  const char *r;\n"
        | RString _ -> pr "  char *r;\n"
        | RStringList _ -> pr "  char **r;\n"
+       | RIntBool _ -> pr "  struct guestfs_int_bool *r;\n"
        | RPVList _ -> pr "  struct guestfs_lvm_pv_list *r;\n"
        | RVGList _ -> pr "  struct guestfs_lvm_vg_list *r;\n"
        | RLVList _ -> pr "  struct guestfs_lvm_lv_list *r;\n"
       );
       iter_args (
 	function
-	| String name -> pr "  const char *%s;\n" name
-	| OptString name -> pr "  const char *%s;\n" name
-	| Bool name -> pr "  int %s;\n" name
+	| String n -> pr "  const char *%s;\n" n
+	| OptString n -> pr "  const char *%s;\n" n
+	| Bool n -> pr "  int %s;\n" n
+	| Int n -> pr "  int %s;\n" n
       ) (snd style);
 
       (* Check and convert parameters. *)
@@ -1461,6 +1660,8 @@ FTP."
 		name i i
 	  | Bool name ->
 	      pr "  %s = is_true (argv[%d]) ? 1 : 0;\n" name i
+	  | Int name ->
+	      pr "  %s = atoi (argv[%d]);\n" name i
       ) (snd style);
 
       (* Call C API function. *)
@@ -1474,6 +1675,10 @@ FTP."
       (* Check return value for errors and display command results. *)
       (match fst style with
        | Err -> pr "  return r;\n"
+       | RInt _ ->
+	   pr "  if (r == -1) return -1;\n";
+	   pr "  if (r) printf (\"%%d\\n\", r);\n";
+	   pr "  return 0;\n"
        | RBool _ ->
 	   pr "  if (r == -1) return -1;\n";
 	   pr "  if (r) printf (\"true\\n\"); else printf (\"false\\n\");\n";
@@ -1492,6 +1697,12 @@ FTP."
 	   pr "  print_strings (r);\n";
 	   pr "  free_strings (r);\n";
 	   pr "  return 0;\n"
+       | RIntBool _ ->
+	   pr "  if (r == NULL) return -1;\n";
+	   pr "  printf (\"%%d, %%s\\n\", r->i,\n";
+	   pr "    r->b ? \"true\" : \"false\");\n";
+	   pr "  guestfs_free_int_bool (r);\n";
+	   pr "  return 0;\n"
        | RPVList _ ->
 	   pr "  if (r == NULL) return -1;\n";
 	   pr "  print_pv_list (r);\n";
@@ -1565,6 +1776,7 @@ and generate_fish_actions_pod () =
 	| String n -> pr " %s" n
 	| OptString n -> pr " %s" n
 	| Bool _ -> pr " true|false"
+	| Int n -> pr " %s" n
       ) (snd style);
       pr "\n";
       pr "\n";
@@ -1574,15 +1786,20 @@ and generate_fish_actions_pod () =
 (* Generate a C function prototype. *)
 and generate_prototype ?(extern = true) ?(static = false) ?(semicolon = true)
     ?(single_line = false) ?(newline = false) ?(in_daemon = false)
+    ?(prefix = "")
     ?handle name style =
   if extern then pr "extern ";
   if static then pr "static ";
   (match fst style with
    | Err -> pr "int "
+   | RInt _ -> pr "int "
    | RBool _ -> pr "int "
    | RConstString _ -> pr "const char *"
    | RString _ -> pr "char *"
    | RStringList _ -> pr "char **"
+   | RIntBool _ ->
+       if not in_daemon then pr "struct guestfs_int_bool *"
+       else pr "guestfs_%s_ret *" name
    | RPVList _ ->
        if not in_daemon then pr "struct guestfs_lvm_pv_list *"
        else pr "guestfs_lvm_int_pv_list *"
@@ -1593,24 +1810,29 @@ and generate_prototype ?(extern = true) ?(static = false) ?(semicolon = true)
        if not in_daemon then pr "struct guestfs_lvm_lv_list *"
        else pr "guestfs_lvm_int_lv_list *"
   );
-  pr "%s (" name;
-  let comma = ref false in
-  (match handle with
-   | None -> ()
-   | Some handle -> pr "guestfs_h *%s" handle; comma := true
-  );
-  let next () =
-    if !comma then (
-      if single_line then pr ", " else pr ",\n\t\t"
+  pr "%s%s (" prefix name;
+  if handle = None && nr_args (snd style) = 0 then
+    pr "void"
+  else (
+    let comma = ref false in
+    (match handle with
+     | None -> ()
+     | Some handle -> pr "guestfs_h *%s" handle; comma := true
     );
-    comma := true
-  in
-  iter_args (
-    function
-    | String name -> next (); pr "const char *%s" name
-    | OptString name -> next (); pr "const char *%s" name
-    | Bool name -> next (); pr "int %s" name
-  ) (snd style);
+    let next () =
+      if !comma then (
+	if single_line then pr ", " else pr ",\n\t\t"
+      );
+      comma := true
+    in
+    iter_args (
+      function
+      | String n -> next (); pr "const char *%s" n
+      | OptString n -> next (); pr "const char *%s" n
+      | Bool n -> next (); pr "int %s" n
+      | Int n -> next (); pr "int %s" n
+    ) (snd style);
+  );
   pr ")";
   if semicolon then pr ";";
   if newline then pr "\n"
@@ -1628,9 +1850,10 @@ and generate_call_args ?handle style =
       if !comma then pr ", ";
       comma := true;
       match arg with
-      | String name -> pr "%s" name
-      | OptString name -> pr "%s" name
-      | Bool name -> pr "%s" name
+      | String n -> pr "%s" n
+      | OptString n -> pr "%s" n
+      | Bool n -> pr "%s" n
+      | Int n -> pr "%s" n
   ) (snd style);
   pr ")"
 
@@ -1779,15 +2002,13 @@ and generate_ocaml_c () =
       pr "CAMLprim value\n";
       pr "ocaml_guestfs_%s (value gv" name;
       iter_args (
-	function
-	| String n | OptString n | Bool n -> pr ", value %sv" n
+	fun arg -> pr ", value %sv" (name_of_argt arg)
       ) (snd style);
       pr ")\n";
       pr "{\n";
       pr "  CAMLparam%d (gv" (1 + (nr_args (snd style)));
       iter_args (
-	function
-	| String n | OptString n | Bool n -> pr ", %sv" n
+	fun arg -> pr ", %sv" (name_of_argt arg)
       ) (snd style);
       pr ");\n";
       pr "  CAMLlocal1 (rv);\n";
@@ -1808,10 +2029,13 @@ and generate_ocaml_c () =
 	      n n
 	| Bool n ->
 	    pr "  int %s = Bool_val (%sv);\n" n n
+	| Int n ->
+	    pr "  int %s = Int_val (%sv);\n" n n
       ) (snd style);
       let error_code =
 	match fst style with
 	| Err -> pr "  int r;\n"; "-1"
+	| RInt _ -> pr "  int r;\n"; "-1"
 	| RBool _ -> pr "  int r;\n"; "-1"
 	| RConstString _ -> pr "  const char *r;\n"; "NULL"
 	| RString _ -> pr "  char *r;\n"; "NULL"
@@ -1819,6 +2043,9 @@ and generate_ocaml_c () =
 	    pr "  int i;\n";
 	    pr "  char **r;\n";
 	    "NULL"
+	| RIntBool _ ->
+	    pr "  struct guestfs_int_bool *r;\n";
+	    "NULL"
 	| RPVList _ ->
 	    pr "  struct guestfs_lvm_pv_list *r;\n";
 	    "NULL"
@@ -1841,7 +2068,8 @@ and generate_ocaml_c () =
 
       (match fst style with
        | Err -> pr "  rv = Val_unit;\n"
-       | RBool _ -> pr "  rv = r ? Val_true : Val_false;\n"
+       | RInt _ -> pr "  rv = Val_int (r);\n"
+       | RBool _ -> pr "  rv = Val_bool (r);\n"
        | RConstString _ -> pr "  rv = caml_copy_string (r);\n"
        | RString _ ->
 	   pr "  rv = caml_copy_string (r);\n";
@@ -1850,6 +2078,11 @@ and generate_ocaml_c () =
 	   pr "  rv = caml_copy_string_array ((const char **) r);\n";
 	   pr "  for (i = 0; r[i] != NULL; ++i) free (r[i]);\n";
 	   pr "  free (r);\n"
+       | RIntBool _ ->
+	   pr "  rv = caml_alloc (2, 0);\n";
+	   pr "  Store_field (rv, 0, Val_int (r->i));\n";
+	   pr "  Store_field (rv, 1, Val_bool (r->b));\n";
+	   pr "  guestfs_free_int_bool (r);\n";
        | RPVList _ ->
 	   pr "  rv = copy_lvm_pv_list (r);\n";
 	   pr "  guestfs_free_lvm_pv_list (r);\n";
@@ -1890,13 +2123,16 @@ and generate_ocaml_prototype ?(is_external = false) name style =
     | String _ -> pr "string -> "
     | OptString _ -> pr "string option -> "
     | Bool _ -> pr "bool -> "
+    | Int _ -> pr "int -> "
   ) (snd style);
   (match fst style with
    | Err -> pr "unit" (* all errors are turned into exceptions *)
+   | RInt _ -> pr "int"
    | RBool _ -> pr "bool"
    | RConstString _ -> pr "string"
    | RString _ -> pr "string"
    | RStringList _ -> pr "string array"
+   | RIntBool _ -> pr "int * bool"
    | RPVList _ -> pr "lvm_pv array"
    | RVGList _ -> pr "lvm_vg array"
    | RLVList _ -> pr "lvm_lv array"
@@ -1987,10 +2223,12 @@ DESTROY (g)
     fun (name, style, _, _, _, _) ->
       (match fst style with
        | Err -> pr "void\n"
+       | RInt _ -> pr "SV *\n"
        | RBool _ -> pr "SV *\n"
        | RConstString _ -> pr "SV *\n"
        | RString _ -> pr "SV *\n"
        | RStringList _
+       | RIntBool _
        | RPVList _ | RVGList _ | RLVList _ ->
 	   pr "void\n" (* all lists returned implictly on the stack *)
       );
@@ -2004,6 +2242,7 @@ DESTROY (g)
 	| String n -> pr "      char *%s;\n" n
 	| OptString n -> pr "      char *%s;\n" n
 	| Bool n -> pr "      int %s;\n" n
+	| Int n -> pr "      int %s;\n" n
       ) (snd style);
       (* Code. *)
       (match fst style with
@@ -2013,21 +2252,22 @@ DESTROY (g)
 	   generate_call_args ~handle:"g" style;
 	   pr " == -1)\n";
 	   pr "        croak (\"%s: %%s\", last_error);\n" name
-       | RConstString n ->
+       | RInt n
+       | RBool n ->
 	   pr "PREINIT:\n";
-	   pr "      const char *%s;\n" n;
+	   pr "      int %s;\n" n;
 	   pr "   CODE:\n";
 	   pr "      %s = guestfs_%s " n name;
 	   generate_call_args ~handle:"g" style;
 	   pr ";\n";
-	   pr "      if (%s == NULL)\n" n;
+	   pr "      if (%s == -1)\n" n;
 	   pr "        croak (\"%s: %%s\", last_error);\n" name;
-	   pr "      RETVAL = newSVpv (%s, 0);\n" n;
+	   pr "      RETVAL = newSViv (%s);\n" n;
 	   pr " OUTPUT:\n";
 	   pr "      RETVAL\n"
-       | RString n ->
+       | RConstString n ->
 	   pr "PREINIT:\n";
-	   pr "      char *%s;\n" n;
+	   pr "      const char *%s;\n" n;
 	   pr "   CODE:\n";
 	   pr "      %s = guestfs_%s " n name;
 	   generate_call_args ~handle:"g" style;
@@ -2035,19 +2275,19 @@ DESTROY (g)
 	   pr "      if (%s == NULL)\n" n;
 	   pr "        croak (\"%s: %%s\", last_error);\n" name;
 	   pr "      RETVAL = newSVpv (%s, 0);\n" n;
-	   pr "      free (%s);\n" n;
 	   pr " OUTPUT:\n";
 	   pr "      RETVAL\n"
-       | RBool n ->
+       | RString n ->
 	   pr "PREINIT:\n";
-	   pr "      int %s;\n" n;
+	   pr "      char *%s;\n" n;
 	   pr "   CODE:\n";
 	   pr "      %s = guestfs_%s " n name;
 	   generate_call_args ~handle:"g" style;
 	   pr ";\n";
-	   pr "      if (%s == -1)\n" n;
+	   pr "      if (%s == NULL)\n" n;
 	   pr "        croak (\"%s: %%s\", last_error);\n" name;
-	   pr "      RETVAL = newSViv (%s);\n" n;
+	   pr "      RETVAL = newSVpv (%s, 0);\n" n;
+	   pr "      free (%s);\n" n;
 	   pr " OUTPUT:\n";
 	   pr "      RETVAL\n"
        | RStringList n ->
@@ -2067,6 +2307,19 @@ DESTROY (g)
 	   pr "        free (%s[i]);\n" n;
 	   pr "      }\n";
 	   pr "      free (%s);\n" n;
+       | RIntBool _ ->
+	   pr "PREINIT:\n";
+	   pr "      struct guestfs_int_bool *r;\n";
+	   pr " PPCODE:\n";
+	   pr "      r = guestfs_%s " name;
+	   generate_call_args ~handle:"g" style;
+	   pr ";\n";
+	   pr "      if (r == NULL)\n";
+	   pr "        croak (\"%s: %%s\", last_error);\n" name;
+	   pr "      EXTEND (SP, 2);\n";
+	   pr "      PUSHs (sv_2mortal (newSViv (r->i)));\n";
+	   pr "      PUSHs (sv_2mortal (newSViv (r->b)));\n";
+	   pr "      guestfs_free_int_bool (r);\n";
        | RPVList n ->
 	   generate_perl_lvm_code "pv" pv_cols name style n;
        | RVGList n ->
@@ -2236,8 +2489,10 @@ and generate_perl_prototype name style =
   (match fst style with
    | Err -> ()
    | RBool n
+   | RInt n
    | RConstString n
    | RString n -> pr "$%s = " n
+   | RIntBool (n, m) -> pr "($%s, $%s) = " n m
    | RStringList n
    | RPVList n
    | RVGList n
@@ -2249,10 +2504,7 @@ and generate_perl_prototype name style =
     fun arg ->
       if !comma then pr ", ";
       comma := true;
-      match arg with
-      | String n -> pr "%s" n
-      | OptString n -> pr "%s" n
-      | Bool n -> pr "%s" n
+      pr "%s" (name_of_argt arg)
   ) (snd style);
   pr ");"
 
diff --git a/src/guestfs-actions.c b/src/guestfs-actions.c
index ebde5fca..0bb868ca 100644
--- a/src/guestfs-actions.c
+++ b/src/guestfs-actions.c
@@ -1111,3 +1111,865 @@ char **guestfs_read_lines (guestfs_h *g,
   return rv.ret.lines.lines_val;
 }
 
+struct aug_init_rv {
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
+};
+
+static void aug_init_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  struct aug_init_rv *rv = (struct aug_init_rv *) data;
+
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_aug_init: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_aug_init: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+ done:
+  rv->cb_done = 1;
+  main_loop.main_loop_quit (g);
+}
+
+int guestfs_aug_init (guestfs_h *g,
+		const char *root,
+		int flags)
+{
+  struct guestfs_aug_init_args args;
+  struct aug_init_rv rv;
+  int serial;
+
+  if (g->state != READY) {
+    error (g, "guestfs_aug_init called from the wrong state, %d != READY",
+      g->state);
+    return -1;
+  }
+
+  memset (&rv, 0, sizeof rv);
+
+  args.root = (char *) root;
+  args.flags = flags;
+  serial = dispatch (g, GUESTFS_PROC_AUG_INIT,
+                     (xdrproc_t) xdr_guestfs_aug_init_args, (char *) &args);
+  if (serial == -1)
+    return -1;
+
+  rv.cb_done = 0;
+  g->reply_cb_internal = aug_init_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_aug_init failed, see earlier error messages");
+    return -1;
+  }
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_INIT, serial) == -1)
+    return -1;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
+    return -1;
+  }
+
+  return 0;
+}
+
+struct aug_close_rv {
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
+};
+
+static void aug_close_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  struct aug_close_rv *rv = (struct aug_close_rv *) data;
+
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_aug_close: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_aug_close: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+ done:
+  rv->cb_done = 1;
+  main_loop.main_loop_quit (g);
+}
+
+int guestfs_aug_close (guestfs_h *g)
+{
+  struct aug_close_rv rv;
+  int serial;
+
+  if (g->state != READY) {
+    error (g, "guestfs_aug_close called from the wrong state, %d != READY",
+      g->state);
+    return -1;
+  }
+
+  memset (&rv, 0, sizeof rv);
+
+  serial = dispatch (g, GUESTFS_PROC_AUG_CLOSE, NULL, NULL);
+  if (serial == -1)
+    return -1;
+
+  rv.cb_done = 0;
+  g->reply_cb_internal = aug_close_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_aug_close failed, see earlier error messages");
+    return -1;
+  }
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_CLOSE, serial) == -1)
+    return -1;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
+    return -1;
+  }
+
+  return 0;
+}
+
+struct aug_defvar_rv {
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
+  struct guestfs_aug_defvar_ret ret;
+};
+
+static void aug_defvar_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  struct aug_defvar_rv *rv = (struct aug_defvar_rv *) data;
+
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_aug_defvar: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_aug_defvar: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+  if (!xdr_guestfs_aug_defvar_ret (xdr, &rv->ret)) {
+    error (g, "guestfs_aug_defvar: failed to parse reply");
+    return;
+  }
+ done:
+  rv->cb_done = 1;
+  main_loop.main_loop_quit (g);
+}
+
+int guestfs_aug_defvar (guestfs_h *g,
+		const char *name,
+		const char *expr)
+{
+  struct guestfs_aug_defvar_args args;
+  struct aug_defvar_rv rv;
+  int serial;
+
+  if (g->state != READY) {
+    error (g, "guestfs_aug_defvar called from the wrong state, %d != READY",
+      g->state);
+    return -1;
+  }
+
+  memset (&rv, 0, sizeof rv);
+
+  args.name = (char *) name;
+  args.expr = expr ? (char **) &expr : NULL;
+  serial = dispatch (g, GUESTFS_PROC_AUG_DEFVAR,
+                     (xdrproc_t) xdr_guestfs_aug_defvar_args, (char *) &args);
+  if (serial == -1)
+    return -1;
+
+  rv.cb_done = 0;
+  g->reply_cb_internal = aug_defvar_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_aug_defvar failed, see earlier error messages");
+    return -1;
+  }
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_DEFVAR, serial) == -1)
+    return -1;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
+    return -1;
+  }
+
+  return rv.ret.nrnodes;
+}
+
+struct aug_defnode_rv {
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
+  struct guestfs_aug_defnode_ret ret;
+};
+
+static void aug_defnode_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  struct aug_defnode_rv *rv = (struct aug_defnode_rv *) data;
+
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_aug_defnode: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_aug_defnode: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+  if (!xdr_guestfs_aug_defnode_ret (xdr, &rv->ret)) {
+    error (g, "guestfs_aug_defnode: failed to parse reply");
+    return;
+  }
+ done:
+  rv->cb_done = 1;
+  main_loop.main_loop_quit (g);
+}
+
+struct guestfs_int_bool *guestfs_aug_defnode (guestfs_h *g,
+		const char *name,
+		const char *expr,
+		const char *val)
+{
+  struct guestfs_aug_defnode_args args;
+  struct aug_defnode_rv rv;
+  int serial;
+
+  if (g->state != READY) {
+    error (g, "guestfs_aug_defnode called from the wrong state, %d != READY",
+      g->state);
+    return NULL;
+  }
+
+  memset (&rv, 0, sizeof rv);
+
+  args.name = (char *) name;
+  args.expr = (char *) expr;
+  args.val = (char *) val;
+  serial = dispatch (g, GUESTFS_PROC_AUG_DEFNODE,
+                     (xdrproc_t) xdr_guestfs_aug_defnode_args, (char *) &args);
+  if (serial == -1)
+    return NULL;
+
+  rv.cb_done = 0;
+  g->reply_cb_internal = aug_defnode_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_aug_defnode failed, see earlier error messages");
+    return NULL;
+  }
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_DEFNODE, serial) == -1)
+    return NULL;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
+    return NULL;
+  }
+
+  /* caller with free this */
+  return safe_memdup (g, &rv.ret, sizeof (rv.ret));
+}
+
+struct aug_get_rv {
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
+  struct guestfs_aug_get_ret ret;
+};
+
+static void aug_get_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  struct aug_get_rv *rv = (struct aug_get_rv *) data;
+
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_aug_get: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_aug_get: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+  if (!xdr_guestfs_aug_get_ret (xdr, &rv->ret)) {
+    error (g, "guestfs_aug_get: failed to parse reply");
+    return;
+  }
+ done:
+  rv->cb_done = 1;
+  main_loop.main_loop_quit (g);
+}
+
+char *guestfs_aug_get (guestfs_h *g,
+		const char *path)
+{
+  struct guestfs_aug_get_args args;
+  struct aug_get_rv rv;
+  int serial;
+
+  if (g->state != READY) {
+    error (g, "guestfs_aug_get called from the wrong state, %d != READY",
+      g->state);
+    return NULL;
+  }
+
+  memset (&rv, 0, sizeof rv);
+
+  args.path = (char *) path;
+  serial = dispatch (g, GUESTFS_PROC_AUG_GET,
+                     (xdrproc_t) xdr_guestfs_aug_get_args, (char *) &args);
+  if (serial == -1)
+    return NULL;
+
+  rv.cb_done = 0;
+  g->reply_cb_internal = aug_get_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_aug_get failed, see earlier error messages");
+    return NULL;
+  }
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_GET, serial) == -1)
+    return NULL;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
+    return NULL;
+  }
+
+  return rv.ret.val; /* caller will free */
+}
+
+struct aug_set_rv {
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
+};
+
+static void aug_set_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  struct aug_set_rv *rv = (struct aug_set_rv *) data;
+
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_aug_set: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_aug_set: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+ done:
+  rv->cb_done = 1;
+  main_loop.main_loop_quit (g);
+}
+
+int guestfs_aug_set (guestfs_h *g,
+		const char *path,
+		const char *val)
+{
+  struct guestfs_aug_set_args args;
+  struct aug_set_rv rv;
+  int serial;
+
+  if (g->state != READY) {
+    error (g, "guestfs_aug_set called from the wrong state, %d != READY",
+      g->state);
+    return -1;
+  }
+
+  memset (&rv, 0, sizeof rv);
+
+  args.path = (char *) path;
+  args.val = (char *) val;
+  serial = dispatch (g, GUESTFS_PROC_AUG_SET,
+                     (xdrproc_t) xdr_guestfs_aug_set_args, (char *) &args);
+  if (serial == -1)
+    return -1;
+
+  rv.cb_done = 0;
+  g->reply_cb_internal = aug_set_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_aug_set failed, see earlier error messages");
+    return -1;
+  }
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_SET, serial) == -1)
+    return -1;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
+    return -1;
+  }
+
+  return 0;
+}
+
+struct aug_insert_rv {
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
+};
+
+static void aug_insert_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  struct aug_insert_rv *rv = (struct aug_insert_rv *) data;
+
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_aug_insert: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_aug_insert: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+ done:
+  rv->cb_done = 1;
+  main_loop.main_loop_quit (g);
+}
+
+int guestfs_aug_insert (guestfs_h *g,
+		const char *path,
+		const char *label,
+		int before)
+{
+  struct guestfs_aug_insert_args args;
+  struct aug_insert_rv rv;
+  int serial;
+
+  if (g->state != READY) {
+    error (g, "guestfs_aug_insert called from the wrong state, %d != READY",
+      g->state);
+    return -1;
+  }
+
+  memset (&rv, 0, sizeof rv);
+
+  args.path = (char *) path;
+  args.label = (char *) label;
+  args.before = before;
+  serial = dispatch (g, GUESTFS_PROC_AUG_INSERT,
+                     (xdrproc_t) xdr_guestfs_aug_insert_args, (char *) &args);
+  if (serial == -1)
+    return -1;
+
+  rv.cb_done = 0;
+  g->reply_cb_internal = aug_insert_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_aug_insert failed, see earlier error messages");
+    return -1;
+  }
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_INSERT, serial) == -1)
+    return -1;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
+    return -1;
+  }
+
+  return 0;
+}
+
+struct aug_rm_rv {
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
+  struct guestfs_aug_rm_ret ret;
+};
+
+static void aug_rm_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  struct aug_rm_rv *rv = (struct aug_rm_rv *) data;
+
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_aug_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_aug_rm: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+  if (!xdr_guestfs_aug_rm_ret (xdr, &rv->ret)) {
+    error (g, "guestfs_aug_rm: failed to parse reply");
+    return;
+  }
+ done:
+  rv->cb_done = 1;
+  main_loop.main_loop_quit (g);
+}
+
+int guestfs_aug_rm (guestfs_h *g,
+		const char *path)
+{
+  struct guestfs_aug_rm_args args;
+  struct aug_rm_rv rv;
+  int serial;
+
+  if (g->state != READY) {
+    error (g, "guestfs_aug_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_AUG_RM,
+                     (xdrproc_t) xdr_guestfs_aug_rm_args, (char *) &args);
+  if (serial == -1)
+    return -1;
+
+  rv.cb_done = 0;
+  g->reply_cb_internal = aug_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_aug_rm failed, see earlier error messages");
+    return -1;
+  }
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_RM, serial) == -1)
+    return -1;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
+    return -1;
+  }
+
+  return rv.ret.nrnodes;
+}
+
+struct aug_mv_rv {
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
+};
+
+static void aug_mv_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  struct aug_mv_rv *rv = (struct aug_mv_rv *) data;
+
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_aug_mv: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_aug_mv: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+ done:
+  rv->cb_done = 1;
+  main_loop.main_loop_quit (g);
+}
+
+int guestfs_aug_mv (guestfs_h *g,
+		const char *src,
+		const char *dest)
+{
+  struct guestfs_aug_mv_args args;
+  struct aug_mv_rv rv;
+  int serial;
+
+  if (g->state != READY) {
+    error (g, "guestfs_aug_mv called from the wrong state, %d != READY",
+      g->state);
+    return -1;
+  }
+
+  memset (&rv, 0, sizeof rv);
+
+  args.src = (char *) src;
+  args.dest = (char *) dest;
+  serial = dispatch (g, GUESTFS_PROC_AUG_MV,
+                     (xdrproc_t) xdr_guestfs_aug_mv_args, (char *) &args);
+  if (serial == -1)
+    return -1;
+
+  rv.cb_done = 0;
+  g->reply_cb_internal = aug_mv_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_aug_mv failed, see earlier error messages");
+    return -1;
+  }
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_MV, serial) == -1)
+    return -1;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
+    return -1;
+  }
+
+  return 0;
+}
+
+struct aug_match_rv {
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
+  struct guestfs_aug_match_ret ret;
+};
+
+static void aug_match_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  struct aug_match_rv *rv = (struct aug_match_rv *) data;
+
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_aug_match: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_aug_match: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+  if (!xdr_guestfs_aug_match_ret (xdr, &rv->ret)) {
+    error (g, "guestfs_aug_match: failed to parse reply");
+    return;
+  }
+ done:
+  rv->cb_done = 1;
+  main_loop.main_loop_quit (g);
+}
+
+char **guestfs_aug_match (guestfs_h *g,
+		const char *path)
+{
+  struct guestfs_aug_match_args args;
+  struct aug_match_rv rv;
+  int serial;
+
+  if (g->state != READY) {
+    error (g, "guestfs_aug_match called from the wrong state, %d != READY",
+      g->state);
+    return NULL;
+  }
+
+  memset (&rv, 0, sizeof rv);
+
+  args.path = (char *) path;
+  serial = dispatch (g, GUESTFS_PROC_AUG_MATCH,
+                     (xdrproc_t) xdr_guestfs_aug_match_args, (char *) &args);
+  if (serial == -1)
+    return NULL;
+
+  rv.cb_done = 0;
+  g->reply_cb_internal = aug_match_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_aug_match failed, see earlier error messages");
+    return NULL;
+  }
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_MATCH, serial) == -1)
+    return NULL;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
+    return NULL;
+  }
+
+  /* caller will free this, but we need to add a NULL entry */
+  rv.ret.matches.matches_val =    safe_realloc (g, rv.ret.matches.matches_val,
+                  sizeof (char *) * (rv.ret.matches.matches_len + 1));
+  rv.ret.matches.matches_val[rv.ret.matches.matches_len] = NULL;
+  return rv.ret.matches.matches_val;
+}
+
+struct aug_save_rv {
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
+};
+
+static void aug_save_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  struct aug_save_rv *rv = (struct aug_save_rv *) data;
+
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_aug_save: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_aug_save: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+ done:
+  rv->cb_done = 1;
+  main_loop.main_loop_quit (g);
+}
+
+int guestfs_aug_save (guestfs_h *g)
+{
+  struct aug_save_rv rv;
+  int serial;
+
+  if (g->state != READY) {
+    error (g, "guestfs_aug_save called from the wrong state, %d != READY",
+      g->state);
+    return -1;
+  }
+
+  memset (&rv, 0, sizeof rv);
+
+  serial = dispatch (g, GUESTFS_PROC_AUG_SAVE, NULL, NULL);
+  if (serial == -1)
+    return -1;
+
+  rv.cb_done = 0;
+  g->reply_cb_internal = aug_save_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_aug_save failed, see earlier error messages");
+    return -1;
+  }
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_SAVE, serial) == -1)
+    return -1;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
+    return -1;
+  }
+
+  return 0;
+}
+
+struct aug_load_rv {
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
+};
+
+static void aug_load_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  struct aug_load_rv *rv = (struct aug_load_rv *) data;
+
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_aug_load: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_aug_load: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+ done:
+  rv->cb_done = 1;
+  main_loop.main_loop_quit (g);
+}
+
+int guestfs_aug_load (guestfs_h *g)
+{
+  struct aug_load_rv rv;
+  int serial;
+
+  if (g->state != READY) {
+    error (g, "guestfs_aug_load called from the wrong state, %d != READY",
+      g->state);
+    return -1;
+  }
+
+  memset (&rv, 0, sizeof rv);
+
+  serial = dispatch (g, GUESTFS_PROC_AUG_LOAD, NULL, NULL);
+  if (serial == -1)
+    return -1;
+
+  rv.cb_done = 0;
+  g->reply_cb_internal = aug_load_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_aug_load failed, see earlier error messages");
+    return -1;
+  }
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_LOAD, 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 a84488d6..eeb69035 100644
--- a/src/guestfs-actions.h
+++ b/src/guestfs-actions.h
@@ -46,3 +46,15 @@ extern struct guestfs_lvm_pv_list *guestfs_pvs_full (guestfs_h *handle);
 extern struct guestfs_lvm_vg_list *guestfs_vgs_full (guestfs_h *handle);
 extern struct guestfs_lvm_lv_list *guestfs_lvs_full (guestfs_h *handle);
 extern char **guestfs_read_lines (guestfs_h *handle, const char *path);
+extern int guestfs_aug_init (guestfs_h *handle, const char *root, int flags);
+extern int guestfs_aug_close (guestfs_h *handle);
+extern int guestfs_aug_defvar (guestfs_h *handle, const char *name, const char *expr);
+extern struct guestfs_int_bool *guestfs_aug_defnode (guestfs_h *handle, const char *name, const char *expr, const char *val);
+extern char *guestfs_aug_get (guestfs_h *handle, const char *path);
+extern int guestfs_aug_set (guestfs_h *handle, const char *path, const char *val);
+extern int guestfs_aug_insert (guestfs_h *handle, const char *path, const char *label, int before);
+extern int guestfs_aug_rm (guestfs_h *handle, const char *path);
+extern int guestfs_aug_mv (guestfs_h *handle, const char *src, const char *dest);
+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);
diff --git a/src/guestfs-structs.h b/src/guestfs-structs.h
index 45ce1316..b3751cd5 100644
--- a/src/guestfs-structs.h
+++ b/src/guestfs-structs.h
@@ -19,6 +19,11 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+struct guestfs_int_bool {
+  int32_t i;
+  int32_t b;
+};
+
 struct guestfs_lvm_pv {
   char *pv_name;
   char pv_uuid[32]; /* this is NOT nul-terminated, be careful when printing */
diff --git a/src/guestfs.c b/src/guestfs.c
index 7f0f8214..cab264a4 100644
--- a/src/guestfs.c
+++ b/src/guestfs.c
@@ -1271,6 +1271,12 @@ check_reply_header (guestfs_h *g,
  * generator.ml.
  */
 void
+guestfs_free_int_bool (struct guestfs_int_bool *x)
+{
+  free (x);
+}
+
+void
 guestfs_free_lvm_pv_list (struct guestfs_lvm_pv_list *x)
 {
   xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_pv_list, (char *) x);
diff --git a/src/guestfs.h b/src/guestfs.h
index 1ed066e9..c677730a 100644
--- a/src/guestfs.h
+++ b/src/guestfs.h
@@ -45,6 +45,7 @@ extern guestfs_abort_cb guestfs_get_out_of_memory_handler (guestfs_h *g);
 #include <guestfs-structs.h>
 #include <guestfs-actions.h>
 
+extern void guestfs_free_int_bool (struct guestfs_int_bool *);
 extern void guestfs_free_lvm_pv_list (struct guestfs_lvm_pv_list *);
 extern void guestfs_free_lvm_vg_list (struct guestfs_lvm_vg_list *);
 extern void guestfs_free_lvm_lv_list (struct guestfs_lvm_lv_list *);
diff --git a/src/guestfs_protocol.c b/src/guestfs_protocol.c
index 31034e54..a5737288 100644
--- a/src/guestfs_protocol.c
+++ b/src/guestfs_protocol.c
@@ -363,6 +363,165 @@ xdr_guestfs_read_lines_ret (XDR *xdrs, guestfs_read_lines_ret *objp)
 }
 
 bool_t
+xdr_guestfs_aug_init_args (XDR *xdrs, guestfs_aug_init_args *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_string (xdrs, &objp->root, ~0))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->flags))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_defvar_args (XDR *xdrs, guestfs_aug_defvar_args *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_string (xdrs, &objp->name, ~0))
+		 return FALSE;
+	 if (!xdr_pointer (xdrs, (char **)&objp->expr, sizeof (str), (xdrproc_t) xdr_str))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_defvar_ret (XDR *xdrs, guestfs_aug_defvar_ret *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_int (xdrs, &objp->nrnodes))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_defnode_args (XDR *xdrs, guestfs_aug_defnode_args *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_string (xdrs, &objp->name, ~0))
+		 return FALSE;
+	 if (!xdr_string (xdrs, &objp->expr, ~0))
+		 return FALSE;
+	 if (!xdr_string (xdrs, &objp->val, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_defnode_ret (XDR *xdrs, guestfs_aug_defnode_ret *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_int (xdrs, &objp->nrnodes))
+		 return FALSE;
+	 if (!xdr_bool (xdrs, &objp->created))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_get_args (XDR *xdrs, guestfs_aug_get_args *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_string (xdrs, &objp->path, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_get_ret (XDR *xdrs, guestfs_aug_get_ret *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_string (xdrs, &objp->val, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_set_args (XDR *xdrs, guestfs_aug_set_args *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_string (xdrs, &objp->path, ~0))
+		 return FALSE;
+	 if (!xdr_string (xdrs, &objp->val, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_insert_args (XDR *xdrs, guestfs_aug_insert_args *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_string (xdrs, &objp->path, ~0))
+		 return FALSE;
+	 if (!xdr_string (xdrs, &objp->label, ~0))
+		 return FALSE;
+	 if (!xdr_bool (xdrs, &objp->before))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_rm_args (XDR *xdrs, guestfs_aug_rm_args *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_string (xdrs, &objp->path, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_rm_ret (XDR *xdrs, guestfs_aug_rm_ret *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_int (xdrs, &objp->nrnodes))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_mv_args (XDR *xdrs, guestfs_aug_mv_args *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_string (xdrs, &objp->src, ~0))
+		 return FALSE;
+	 if (!xdr_string (xdrs, &objp->dest, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_match_args (XDR *xdrs, guestfs_aug_match_args *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_string (xdrs, &objp->path, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_guestfs_aug_match_ret (XDR *xdrs, guestfs_aug_match_ret *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_array (xdrs, (char **)&objp->matches.matches_val, (u_int *) &objp->matches.matches_len, ~0,
+		sizeof (str), (xdrproc_t) xdr_str))
+		 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 a2bf0c13..94129864 100644
--- a/src/guestfs_protocol.h
+++ b/src/guestfs_protocol.h
@@ -204,6 +204,88 @@ struct guestfs_read_lines_ret {
 };
 typedef struct guestfs_read_lines_ret guestfs_read_lines_ret;
 
+struct guestfs_aug_init_args {
+	char *root;
+	int flags;
+};
+typedef struct guestfs_aug_init_args guestfs_aug_init_args;
+
+struct guestfs_aug_defvar_args {
+	char *name;
+	str *expr;
+};
+typedef struct guestfs_aug_defvar_args guestfs_aug_defvar_args;
+
+struct guestfs_aug_defvar_ret {
+	int nrnodes;
+};
+typedef struct guestfs_aug_defvar_ret guestfs_aug_defvar_ret;
+
+struct guestfs_aug_defnode_args {
+	char *name;
+	char *expr;
+	char *val;
+};
+typedef struct guestfs_aug_defnode_args guestfs_aug_defnode_args;
+
+struct guestfs_aug_defnode_ret {
+	int nrnodes;
+	bool_t created;
+};
+typedef struct guestfs_aug_defnode_ret guestfs_aug_defnode_ret;
+
+struct guestfs_aug_get_args {
+	char *path;
+};
+typedef struct guestfs_aug_get_args guestfs_aug_get_args;
+
+struct guestfs_aug_get_ret {
+	char *val;
+};
+typedef struct guestfs_aug_get_ret guestfs_aug_get_ret;
+
+struct guestfs_aug_set_args {
+	char *path;
+	char *val;
+};
+typedef struct guestfs_aug_set_args guestfs_aug_set_args;
+
+struct guestfs_aug_insert_args {
+	char *path;
+	char *label;
+	bool_t before;
+};
+typedef struct guestfs_aug_insert_args guestfs_aug_insert_args;
+
+struct guestfs_aug_rm_args {
+	char *path;
+};
+typedef struct guestfs_aug_rm_args guestfs_aug_rm_args;
+
+struct guestfs_aug_rm_ret {
+	int nrnodes;
+};
+typedef struct guestfs_aug_rm_ret guestfs_aug_rm_ret;
+
+struct guestfs_aug_mv_args {
+	char *src;
+	char *dest;
+};
+typedef struct guestfs_aug_mv_args guestfs_aug_mv_args;
+
+struct guestfs_aug_match_args {
+	char *path;
+};
+typedef struct guestfs_aug_match_args guestfs_aug_match_args;
+
+struct guestfs_aug_match_ret {
+	struct {
+		u_int matches_len;
+		str *matches_val;
+	} matches;
+};
+typedef struct guestfs_aug_match_ret guestfs_aug_match_ret;
+
 enum guestfs_procedure {
 	GUESTFS_PROC_MOUNT = 1,
 	GUESTFS_PROC_SYNC = 2,
@@ -220,7 +302,19 @@ enum guestfs_procedure {
 	GUESTFS_PROC_VGS_FULL = 13,
 	GUESTFS_PROC_LVS_FULL = 14,
 	GUESTFS_PROC_READ_LINES = 15,
-	GUESTFS_PROC_dummy = 15 + 1,
+	GUESTFS_PROC_AUG_INIT = 16,
+	GUESTFS_PROC_AUG_CLOSE = 26,
+	GUESTFS_PROC_AUG_DEFVAR = 17,
+	GUESTFS_PROC_AUG_DEFNODE = 18,
+	GUESTFS_PROC_AUG_GET = 19,
+	GUESTFS_PROC_AUG_SET = 20,
+	GUESTFS_PROC_AUG_INSERT = 21,
+	GUESTFS_PROC_AUG_RM = 22,
+	GUESTFS_PROC_AUG_MV = 23,
+	GUESTFS_PROC_AUG_MATCH = 24,
+	GUESTFS_PROC_AUG_SAVE = 25,
+	GUESTFS_PROC_AUG_LOAD = 27,
+	GUESTFS_PROC_dummy = 27 + 1,
 };
 typedef enum guestfs_procedure guestfs_procedure;
 #define GUESTFS_MESSAGE_MAX 4194304
@@ -283,6 +377,20 @@ extern  bool_t xdr_guestfs_vgs_full_ret (XDR *, guestfs_vgs_full_ret*);
 extern  bool_t xdr_guestfs_lvs_full_ret (XDR *, guestfs_lvs_full_ret*);
 extern  bool_t xdr_guestfs_read_lines_args (XDR *, guestfs_read_lines_args*);
 extern  bool_t xdr_guestfs_read_lines_ret (XDR *, guestfs_read_lines_ret*);
+extern  bool_t xdr_guestfs_aug_init_args (XDR *, guestfs_aug_init_args*);
+extern  bool_t xdr_guestfs_aug_defvar_args (XDR *, guestfs_aug_defvar_args*);
+extern  bool_t xdr_guestfs_aug_defvar_ret (XDR *, guestfs_aug_defvar_ret*);
+extern  bool_t xdr_guestfs_aug_defnode_args (XDR *, guestfs_aug_defnode_args*);
+extern  bool_t xdr_guestfs_aug_defnode_ret (XDR *, guestfs_aug_defnode_ret*);
+extern  bool_t xdr_guestfs_aug_get_args (XDR *, guestfs_aug_get_args*);
+extern  bool_t xdr_guestfs_aug_get_ret (XDR *, guestfs_aug_get_ret*);
+extern  bool_t xdr_guestfs_aug_set_args (XDR *, guestfs_aug_set_args*);
+extern  bool_t xdr_guestfs_aug_insert_args (XDR *, guestfs_aug_insert_args*);
+extern  bool_t xdr_guestfs_aug_rm_args (XDR *, guestfs_aug_rm_args*);
+extern  bool_t xdr_guestfs_aug_rm_ret (XDR *, guestfs_aug_rm_ret*);
+extern  bool_t xdr_guestfs_aug_mv_args (XDR *, guestfs_aug_mv_args*);
+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_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*);
@@ -315,6 +423,20 @@ extern bool_t xdr_guestfs_vgs_full_ret ();
 extern bool_t xdr_guestfs_lvs_full_ret ();
 extern bool_t xdr_guestfs_read_lines_args ();
 extern bool_t xdr_guestfs_read_lines_ret ();
+extern bool_t xdr_guestfs_aug_init_args ();
+extern bool_t xdr_guestfs_aug_defvar_args ();
+extern bool_t xdr_guestfs_aug_defvar_ret ();
+extern bool_t xdr_guestfs_aug_defnode_args ();
+extern bool_t xdr_guestfs_aug_defnode_ret ();
+extern bool_t xdr_guestfs_aug_get_args ();
+extern bool_t xdr_guestfs_aug_get_ret ();
+extern bool_t xdr_guestfs_aug_set_args ();
+extern bool_t xdr_guestfs_aug_insert_args ();
+extern bool_t xdr_guestfs_aug_rm_args ();
+extern bool_t xdr_guestfs_aug_rm_ret ();
+extern bool_t xdr_guestfs_aug_mv_args ();
+extern bool_t xdr_guestfs_aug_match_args ();
+extern bool_t xdr_guestfs_aug_match_ret ();
 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 c00c4c4d..eb3045e0 100644
--- a/src/guestfs_protocol.x
+++ b/src/guestfs_protocol.x
@@ -85,23 +85,15 @@ struct guestfs_lvm_int_lv {
 
 typedef struct guestfs_lvm_int_lv guestfs_lvm_int_lv_list<>;
 
-/* guestfs_mount */
-
 struct guestfs_mount_args {
   string device<>;
   string mountpoint<>;
 };
 
-/* guestfs_sync */
-
-/* guestfs_touch */
-
 struct guestfs_touch_args {
   string path<>;
 };
 
-/* guestfs_cat */
-
 struct guestfs_cat_args {
   string path<>;
 };
@@ -110,8 +102,6 @@ struct guestfs_cat_ret {
   string content<>;
 };
 
-/* guestfs_ll */
-
 struct guestfs_ll_args {
   string directory<>;
 };
@@ -120,8 +110,6 @@ struct guestfs_ll_ret {
   string listing<>;
 };
 
-/* guestfs_ls */
-
 struct guestfs_ls_args {
   string directory<>;
 };
@@ -130,56 +118,38 @@ struct guestfs_ls_ret {
   str listing<>;
 };
 
-/* guestfs_list_devices */
-
 struct guestfs_list_devices_ret {
   str devices<>;
 };
 
-/* guestfs_list_partitions */
-
 struct guestfs_list_partitions_ret {
   str partitions<>;
 };
 
-/* guestfs_pvs */
-
 struct guestfs_pvs_ret {
   str physvols<>;
 };
 
-/* guestfs_vgs */
-
 struct guestfs_vgs_ret {
   str volgroups<>;
 };
 
-/* guestfs_lvs */
-
 struct guestfs_lvs_ret {
   str logvols<>;
 };
 
-/* guestfs_pvs_full */
-
 struct guestfs_pvs_full_ret {
   guestfs_lvm_int_pv_list physvols;
 };
 
-/* guestfs_vgs_full */
-
 struct guestfs_vgs_full_ret {
   guestfs_lvm_int_vg_list volgroups;
 };
 
-/* guestfs_lvs_full */
-
 struct guestfs_lvs_full_ret {
   guestfs_lvm_int_lv_list logvols;
 };
 
-/* guestfs_read_lines */
-
 struct guestfs_read_lines_args {
   string path<>;
 };
@@ -188,6 +158,71 @@ struct guestfs_read_lines_ret {
   str lines<>;
 };
 
+struct guestfs_aug_init_args {
+  string root<>;
+  int flags;
+};
+
+struct guestfs_aug_defvar_args {
+  string name<>;
+  str *expr;
+};
+
+struct guestfs_aug_defvar_ret {
+  int nrnodes;
+};
+
+struct guestfs_aug_defnode_args {
+  string name<>;
+  string expr<>;
+  string val<>;
+};
+
+struct guestfs_aug_defnode_ret {
+  int nrnodes;
+  bool created;
+};
+
+struct guestfs_aug_get_args {
+  string path<>;
+};
+
+struct guestfs_aug_get_ret {
+  string val<>;
+};
+
+struct guestfs_aug_set_args {
+  string path<>;
+  string val<>;
+};
+
+struct guestfs_aug_insert_args {
+  string path<>;
+  string label<>;
+  bool before;
+};
+
+struct guestfs_aug_rm_args {
+  string path<>;
+};
+
+struct guestfs_aug_rm_ret {
+  int nrnodes;
+};
+
+struct guestfs_aug_mv_args {
+  string src<>;
+  string dest<>;
+};
+
+struct guestfs_aug_match_args {
+  string path<>;
+};
+
+struct guestfs_aug_match_ret {
+  str matches<>;
+};
+
 enum guestfs_procedure {
   GUESTFS_PROC_MOUNT = 1,
   GUESTFS_PROC_SYNC = 2,
@@ -204,6 +239,18 @@ enum guestfs_procedure {
   GUESTFS_PROC_VGS_FULL = 13,
   GUESTFS_PROC_LVS_FULL = 14,
   GUESTFS_PROC_READ_LINES = 15,
+  GUESTFS_PROC_AUG_INIT = 16,
+  GUESTFS_PROC_AUG_CLOSE = 26,
+  GUESTFS_PROC_AUG_DEFVAR = 17,
+  GUESTFS_PROC_AUG_DEFNODE = 18,
+  GUESTFS_PROC_AUG_GET = 19,
+  GUESTFS_PROC_AUG_SET = 20,
+  GUESTFS_PROC_AUG_INSERT = 21,
+  GUESTFS_PROC_AUG_RM = 22,
+  GUESTFS_PROC_AUG_MV = 23,
+  GUESTFS_PROC_AUG_MATCH = 24,
+  GUESTFS_PROC_AUG_SAVE = 25,
+  GUESTFS_PROC_AUG_LOAD = 27,
   GUESTFS_PROC_dummy
 };