[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[libvirt] [PATCH 15/22] remote generator, client: Handle simple remote driver functions



Rename remoteSecretListSecrets to remoteListSecrets to match the normal
naming pattern.
---
 cfg.mk                            |    8 +-
 daemon/remote_generator.pl        |  335 +++++++++-
 src/Makefile.am                   |   13 +-
 src/remote/qemu_client_bodies.c   |    4 +
 src/remote/remote_client_bodies.c | 1391 +++++++++++++++++++++++++++++++++++++
 src/remote/remote_driver.c        | 1116 +-----------------------------
 6 files changed, 1750 insertions(+), 1117 deletions(-)
 create mode 100644 src/remote/qemu_client_bodies.c
 create mode 100644 src/remote/remote_client_bodies.c

diff --git a/cfg.mk b/cfg.mk
index a38ea48..82759bf 100644
--- a/cfg.mk
+++ b/cfg.mk
@@ -611,7 +611,7 @@ exclude_file_name_regexp--sc_prohibit_close = \
 exclude_file_name_regexp--sc_prohibit_doubled_word = ^po/
 
 exclude_file_name_regexp--sc_prohibit_empty_lines_at_EOF = \
-  (^docs/api_extension/|^tests/qemuhelpdata/|\.(gif|ico|png)$$|daemon/.*_dispatch_bodies.c$$)
+  (^docs/api_extension/|^tests/qemuhelpdata/|\.(gif|ico|png)$$|^daemon/.*_dispatch_bodies.c$$|^src/remote/.*_client_bodies.c$$)
 
 _src2=src/(util/util|libvirt|lxc/lxc_controller)
 exclude_file_name_regexp--sc_prohibit_fork_wrappers = \
@@ -633,9 +633,11 @@ exclude_file_name_regexp--sc_prohibit_strncpy = \
 
 exclude_file_name_regexp--sc_prohibit_xmlGetProp = ^src/util/xml\.c$$
 
-exclude_file_name_regexp--sc_require_config_h = ^(examples/|daemon/.*_dispatch_bodies.c$$)
+exclude_file_name_regexp--sc_require_config_h = \
+  ^(examples/|daemon/.*_dispatch_bodies.c$$|src/remote/.*_client_bodies.c$$)
 
-exclude_file_name_regexp--sc_require_config_h_first = ^(examples/|daemon/.*_dispatch_bodies.c$$)
+exclude_file_name_regexp--sc_require_config_h_first = \
+  ^(examples/|daemon/.*_dispatch_bodies.c$$|src/remote/.*_client_bodies.c$$)
 
 exclude_file_name_regexp--sc_trailing_blank = (^docs/|\.(fig|gif|ico|png)$$)
 
diff --git a/daemon/remote_generator.pl b/daemon/remote_generator.pl
index 9fa3caa..73d1596 100755
--- a/daemon/remote_generator.pl
+++ b/daemon/remote_generator.pl
@@ -20,8 +20,8 @@ use strict;
 use Getopt::Std;
 
 # Command line options.
-our ($opt_p, $opt_t, $opt_a, $opt_r, $opt_d, $opt_c, $opt_b);
-getopts ('ptardcb');
+our ($opt_p, $opt_t, $opt_a, $opt_r, $opt_d, $opt_c, $opt_b, $opt_k);
+getopts ('ptardcbk');
 
 my $structprefix = $ARGV[0];
 my $procprefix = uc $structprefix;
@@ -724,3 +724,334 @@ elsif ($opt_b) {
         print "\n";
     }
 }
+
+# Bodies for client functions ("remote_client_bodies.c").
+elsif ($opt_k) {
+    # list of functions that currently are not generatable
+    my @ungeneratable;
+
+    if ($structprefix eq "remote") {
+        @ungeneratable = ("Close",
+                          "DomainEventsDeregisterAny",
+                          "DomainEventsRegisterAny",
+                          "DomainMigratePrepareTunnel",
+                          "DomainOpenConsole",
+                          "DomainPinVcpu",
+                          "DomainSetSchedulerParameters",
+                          "DomainSetMemoryParameters",
+                          "DomainSetBlkioParameters",
+                          "Open",
+                          "StorageVolUpload",
+                          "StorageVolDownload",
+
+                          "AuthList",
+                          "AuthSaslInit",
+                          "AuthSaslStart",
+                          "AuthSaslStep",
+                          "AuthPolkit",
+
+                          "CPUBaseline",
+                          "CPUCompare",
+                          "DomainBlockStats",
+                          "DomainCreate",
+                          "DomainCreateXML",
+                          "DomainDefineXML",
+                          "DomainDestroy",
+                          "DomainDumpXML",
+                          "DomainGetAutostart",
+                          "DomainGetBlockInfo",
+                          "DomainGetInfo",
+                          "StoragePoolLookupByUUID",
+                          "StoragePoolNumOfVolumes",
+                          "NodeDeviceCreateXML",
+                          "DomainGetJobInfo",
+                          "DomainGetMaxMemory",
+                          "DomainGetOSType",
+                          "DomainGetVcpusFlags",
+                          "HasCurrentSnapshot",
+                          "DomainInterfaceStats",
+                          "DomainIsActive",
+                          "DomainIsPersistent",
+                          "DomainIsUpdated",
+                          "DomainLookupByID",
+                          "DomainLookupByName",
+                          "DomainLookupByUIID",
+                          "DomainMigrateFinish",
+                          "DomainGetMaxVcpus",
+                          "DomainHasCurrentSnapshot",
+                          "NWFilterDefineXML",
+                          "NumOfStoragePools",
+                          "NWFilterLookupByName",
+                          "NWFilterLookupByUUID",
+                          "SecretLookupByUUID",
+                          "SecretLookupByUsage",
+                          "StoragePoolCreateXML",
+                          "StoragePoolIsActive",
+                          "DomainHasManagedSaveImage",
+                          "DomainLookupByUUID",
+                          "DomainMigratePerform",
+                          "DomainMigrateFinish2",
+                          "DomainSnapshotCreateXML",
+                          "DomainSnapshotDumpXML",
+                          "DomainSnapshotNum",
+                          "DomainSnapshotCurrent",
+                          "DomainSnapshotListNames",
+                          "GetCapabilities",
+                          "GetHostname",
+                          "GetLibVersion",
+                          "GetMaxVcpus",
+                          "DomainSnapshotLookupByName",
+                          "DomainXMLFromNative",
+                          "FindStoragePoolSources",
+                          "GetSysinfo",
+                          "GetVersion",
+                          "GetLibVersion",
+                          "InterfaceDefineXML",
+                          "InterfaceGetXMLDesc",
+                          "InterfaceLookupByName",
+                          "IsSecure",
+                          "ListDefinedDomains",
+                          "ListDefinedInterfaces",
+                          "ListNWFilters",
+                          "NetworkCreateXML",
+                          "SupportsFeature",
+                          "StorageVolLookupByPath",
+                          "StorageVolGetInfo",
+                          "StorageVolCreateXML",
+                          "StorageVolLookupByName",
+                          "StorageVolLookupByKey",
+                          "StoragePoolIsPersistent",
+                          "StoragePoolGetInfo",
+                          "StorageVolGetPath",
+                          "StorageVolCreateXMLFrom",
+                          "StoragePoolLookupByName",
+                          "SecretGetXMLDesc",
+                          "NWFilterGetXMLDesc",
+                          "NumOfNWFilters",
+                          "NumOfInterfaces",
+                          "NumOfDomains",
+                          "NumOfDefinedStoragePools",
+                          "NodeListDevices",
+                          "NodeGetCellsFreeMemory",
+                          "NodeDeviceDumpXML",
+                          "NetworkIsActive",
+                          "ListDefinedNetworks",
+                          "DomainXMLToNative",
+                          "StorageVolDumpXML",
+                          "StoragePoolListVolumes",
+                          "StoragePoolDumpXML",
+                          "SecretDefineXML",
+                          "NumOfDefinedNetworks",
+                          "InterfaceIsActive",
+                          "ListDomains",
+                          "ListStoragePools",
+                          "NetworkDumpXML",
+                          "NetworkGetAutostart",
+                          "NetworkGetBridgeName",
+                          "StoragePoolLookupByVolume",
+                          "StoragePoolGetAutostart",
+                          "SecretSetValue",
+                          "NumOfDefinedInterfaces",
+                          "StoragePoolDefineXML",
+                          "NodeNumOfDevices",
+                          "NodeGetInfo",
+                          "GetURI",
+                          "InterfaceLookupByMACString",
+                          "ListInterfaces",
+                          "NetworkDefineXML",
+                          "NetworkLookupByName",
+                          "ListDefinedStoragePools",
+                          "NetworkIsPersistent",
+                          "NodeDeviceDettach",
+                          "NodeDeviceLookupByName",
+                          "NodeGetFreeMemory",
+                          "NumOfDefinedDomains",
+                          "ListNetworks",
+                          "NodeDeviceListCaps",
+                          "NodeDeviceReset",
+                          "NumOfNetworks",
+                          "NetworkLookupByUUID",
+                          "NodeDeviceNumOfCaps",
+                          "NumOfSecrets",
+                          "NodeDeviceReAttach",
+                          "ListSecrets",
+
+                          "DomainBlockPeek",
+                          "DomainCreateWithFlags",
+                          "DomainEventsDeregister",
+                          "DomainEventsRegister",
+                          "DomainGetBlkioParameters",
+                          "DomainGetMemoryParameters",
+                          "DomainGetSchedulerParameters",
+                          "DomainGetSchedulerType",
+                          "DomainGetSecurityLabel",
+                          "DomainGetVcpus",
+                          "DomainMemoryPeek",
+                          "DomainMemoryStats",
+                          "DomainMigratePrepare",
+                          "DomainMigratePrepare2",
+                          "GetType",
+                          "NodeDeviceGetParent",
+                          "NodeGetSecurityModel",
+                          "SecretGetValue");
+    } elsif ($structprefix eq "qemu") {
+        @ungeneratable = ("MonitorCommand");
+    }
+
+    my %ug = map { $_ => 1 } @ungeneratable;
+    my @keys = sort (keys %calls);
+
+    foreach (@keys) {
+        my $call = $calls{$_};
+
+        # skip things which are REMOTE_MESSAGE
+        next if $call->{msg};
+
+        if (exists($ug{$call->{ProcName}})) {
+            print "/* ${structprefix}Dispatch$call->{ProcName} has to " .
+                  "be implemented manually */\n\n";
+            next;
+        }
+
+        my @args_list = ();
+        my @vars_list = ();
+        my @setters_list = ();
+        my $priv_src = "conn";
+        my $priv_name = "privateData";
+        my $args = "&args";
+        my $ret = "&ret";
+
+        if ($call->{args} eq "void") {
+            $args = "NULL";
+        } else {
+            push(@vars_list, "$call->{args} args");
+
+            my $is_first_arg = 1;
+            my $has_node_device = 0;
+
+            # node device is special
+            if ($call->{args} =~ m/^remote_node_device_/) {
+                $has_node_device = 1;
+            }
+
+            foreach my $args_member (@{$call->{args_members}}) {
+                if ($args_member =~ m/^remote_nonnull_string name;/ and $has_node_device) {
+                    $priv_src = "dev->conn";
+                    $priv_name = "devMonPrivateData";
+                    push(@args_list, "virNodeDevicePtr dev");
+                    push(@setters_list, "args.name = dev->name;");
+                } elsif ($args_member =~ m/^remote_nonnull_(domain|network|storage_pool|storage_vol|interface|secret|nwfilter|domain_snapshot) (\S+);/) {
+                    my $name = $1;
+                    my $type_name = name_to_ProcName($name);
+
+                    if ($is_first_arg) {
+                        if ($name eq "domain_snapshot") {
+                            $priv_src = "$2->domain->conn";
+                        } else {
+                            $priv_src = "$2->conn";
+                        }
+
+                        if ($name =~ m/^storage_/) {
+                            $priv_name = "storagePrivateData";
+                        } elsif (!($name =~ m/^domain/)) {
+                            $priv_name = "${name}PrivateData";
+                        }
+                    }
+
+                    push(@args_list, "vir${type_name}Ptr $2");
+                    push(@setters_list, "make_nonnull_$1(&args.$2, $2);");
+                } elsif ($args_member =~ m/^remote_nonnull_string (\S+);/) {
+                    push(@args_list, "const char *$1");
+                    push(@setters_list, "args.$1 = (char *)$1;");
+                } elsif ($args_member =~ m/(\S+)<\S+>;/) {
+                    # ignored for now
+                } elsif ($args_member =~ m/^(.*) (\S+);/) {
+                    my $type_name = $1;
+                    my $arg_name = $2;
+
+                    $type_name =~ s/hyper/long/;
+                    $type_name =~ s/^unsigned$/unsigned int/;
+                    $type_name =~ s/u_int/unsigned int/;
+
+                    if ($type_name eq "int") {
+                        # fix bad decisions in the xdr protocol
+                        if ($arg_name eq "flags" and
+                            $call->{ProcName} ne "DomainCoreDump") {
+                            $type_name = "unsigned int";
+                        } elsif ($arg_name eq "nvcpus" and
+                                 $call->{ProcName} eq "DomainSetVcpus") {
+                            $type_name = "unsigned int";
+                        }
+                    }
+
+                    if ($call->{ProcName} eq "DomainMigrateSetMaxDowntime" and
+                        $arg_name eq "downtime") {
+                        $type_name = "unsigned long long";
+                    }
+
+                    push(@args_list, "$type_name $arg_name");
+                    push(@setters_list, "args.$arg_name = $arg_name;");
+                } elsif ($args_member =~ m/^\/*/) {
+                    # ignore comments
+                } else {
+                    die "unhandled type for argument value: $args_member";
+                }
+
+                if ($is_first_arg and $priv_src eq "conn") {
+                    unshift(@args_list, "virConnectPtr conn");
+                }
+
+                $is_first_arg = 0;
+            }
+        }
+
+        if ($call->{ret} eq "void") {
+            $ret = "NULL";
+        } else {
+            push(@vars_list, "$call->{ret} ret");
+        }
+
+        # print function
+        print "static int\n";
+        print "remote$call->{ProcName}(";
+
+        print join(", ", @args_list);
+
+        print ")\n";
+        print "{\n";
+        print "    int rv = -1;\n";
+        print "    struct private_data *priv = $priv_src->$priv_name;\n";
+
+        foreach my $var (@vars_list) {
+            print "    $var;\n";
+        }
+
+        print "\n";
+        print "    remoteDriverLock(priv);\n";
+        print "\n";
+
+        if (@setters_list) {
+            print "    ";
+        }
+
+        print join("\n    ", @setters_list);
+
+        if (@setters_list) {
+            print "\n";
+        }
+
+        print "\n";
+        print "    if (call($priv_src, priv, 0, ${procprefix}_PROC_$call->{UC_NAME},\n";
+        print "             (xdrproc_t)xdr_$call->{args}, (char *)$args,\n";
+        print "             (xdrproc_t)xdr_$call->{ret}, (char *)$ret) == -1)\n";
+        print "        goto done;\n";
+        print "\n";
+        print "    rv = 0;\n";
+        print "\n";
+        print "done:\n";
+        print "    remoteDriverUnlock(priv);\n";
+        print "    return rv;\n";
+        print "}\n";
+        print "\n";
+    }
+}
diff --git a/src/Makefile.am b/src/Makefile.am
index 1eaa7d1..8ba176d 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -162,8 +162,19 @@ REMOTE_DRIVER_SOURCES =						\
 		remote/qemu_protocol.c				\
 		remote/qemu_protocol.h
 
+remote/remote_driver.c: remote/remote_client_bodies.c remote/qemu_client_bodies.c
+
+REMOTE_PROTOCOL = $(top_srcdir)/src/remote/remote_protocol.x
+QEMU_PROTOCOL = $(top_srcdir)/src/remote/qemu_protocol.x
+
+remote/remote_client_bodies.c: $(top_srcdir)/daemon/remote_generator.pl $(REMOTE_PROTOCOL)
+	$(AM_V_GEN)perl -w $(top_srcdir)/daemon/remote_generator.pl -c -k remote $(REMOTE_PROTOCOL) > $@
+
+remote/qemu_client_bodies.c: $(top_srcdir)/daemon/remote_generator.pl $(QEMU_PROTOCOL)
+	$(AM_V_GEN)perl -w $(top_srcdir)/daemon/remote_generator.pl -k remote $(QEMU_PROTOCOL) > $@
+
 EXTRA_DIST += remote/remote_protocol.x remote/qemu_protocol.x \
-		remote/rpcgen_fix.pl
+		remote/rpcgen_fix.pl remote/remote_client_bodies.c remote/qemu_client_bodies.c
 
 # Ensure that we don't change the struct or member names or member ordering
 # in remote_protocol.x  The embedded perl below needs a few comments, and
diff --git a/src/remote/qemu_client_bodies.c b/src/remote/qemu_client_bodies.c
new file mode 100644
index 0000000..dd66ba3
--- /dev/null
+++ b/src/remote/qemu_client_bodies.c
@@ -0,0 +1,4 @@
+/* Automatically generated by remote_generator.pl.
+ * Do not edit this file.  Any changes you make will be lost.
+ */
+
diff --git a/src/remote/remote_client_bodies.c b/src/remote/remote_client_bodies.c
new file mode 100644
index 0000000..07ddfbf
--- /dev/null
+++ b/src/remote/remote_client_bodies.c
@@ -0,0 +1,1391 @@
+/* Automatically generated by remote_generator.pl.
+ * Do not edit this file.  Any changes you make will be lost.
+ */
+
+/* remoteDispatchAuthList has to be implemented manually */
+
+/* remoteDispatchAuthPolkit has to be implemented manually */
+
+/* remoteDispatchAuthSaslInit has to be implemented manually */
+
+/* remoteDispatchAuthSaslStart has to be implemented manually */
+
+/* remoteDispatchAuthSaslStep has to be implemented manually */
+
+/* remoteDispatchClose has to be implemented manually */
+
+/* remoteDispatchCPUBaseline has to be implemented manually */
+
+/* remoteDispatchCPUCompare has to be implemented manually */
+
+static int
+remoteDomainAbortJob(virDomainPtr dom)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_abort_job_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_ABORT_JOB,
+             (xdrproc_t)xdr_remote_domain_abort_job_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainAttachDevice(virDomainPtr dom, const char *xml)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_attach_device_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.xml = (char *)xml;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_ATTACH_DEVICE,
+             (xdrproc_t)xdr_remote_domain_attach_device_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainAttachDeviceFlags(virDomainPtr dom, const char *xml, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_attach_device_flags_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.xml = (char *)xml;
+    args.flags = flags;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_ATTACH_DEVICE_FLAGS,
+             (xdrproc_t)xdr_remote_domain_attach_device_flags_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchDomainBlockPeek has to be implemented manually */
+
+/* remoteDispatchDomainBlockStats has to be implemented manually */
+
+static int
+remoteDomainCoreDump(virDomainPtr dom, const char *to, int flags)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_core_dump_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.to = (char *)to;
+    args.flags = flags;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_CORE_DUMP,
+             (xdrproc_t)xdr_remote_domain_core_dump_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchDomainCreate has to be implemented manually */
+
+/* remoteDispatchDomainCreateWithFlags has to be implemented manually */
+
+/* remoteDispatchDomainCreateXML has to be implemented manually */
+
+/* remoteDispatchDomainDefineXML has to be implemented manually */
+
+/* remoteDispatchDomainDestroy has to be implemented manually */
+
+static int
+remoteDomainDetachDevice(virDomainPtr dom, const char *xml)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_detach_device_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.xml = (char *)xml;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_DETACH_DEVICE,
+             (xdrproc_t)xdr_remote_domain_detach_device_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainDetachDeviceFlags(virDomainPtr dom, const char *xml, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_detach_device_flags_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.xml = (char *)xml;
+    args.flags = flags;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_DETACH_DEVICE_FLAGS,
+             (xdrproc_t)xdr_remote_domain_detach_device_flags_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchDomainDumpXML has to be implemented manually */
+
+/* remoteDispatchDomainEventsDeregister has to be implemented manually */
+
+/* remoteDispatchDomainEventsDeregisterAny has to be implemented manually */
+
+/* remoteDispatchDomainEventsRegister has to be implemented manually */
+
+/* remoteDispatchDomainEventsRegisterAny has to be implemented manually */
+
+/* remoteDispatchDomainGetAutostart has to be implemented manually */
+
+/* remoteDispatchDomainGetBlkioParameters has to be implemented manually */
+
+/* remoteDispatchDomainGetBlockInfo has to be implemented manually */
+
+/* remoteDispatchDomainGetInfo has to be implemented manually */
+
+/* remoteDispatchDomainGetJobInfo has to be implemented manually */
+
+/* remoteDispatchDomainGetMaxMemory has to be implemented manually */
+
+/* remoteDispatchDomainGetMaxVcpus has to be implemented manually */
+
+/* remoteDispatchDomainGetMemoryParameters has to be implemented manually */
+
+/* remoteDispatchDomainGetOSType has to be implemented manually */
+
+/* remoteDispatchDomainGetSchedulerParameters has to be implemented manually */
+
+/* remoteDispatchDomainGetSchedulerType has to be implemented manually */
+
+/* remoteDispatchDomainGetSecurityLabel has to be implemented manually */
+
+/* remoteDispatchDomainGetVcpus has to be implemented manually */
+
+/* remoteDispatchDomainGetVcpusFlags has to be implemented manually */
+
+/* remoteDispatchDomainHasCurrentSnapshot has to be implemented manually */
+
+/* remoteDispatchDomainHasManagedSaveImage has to be implemented manually */
+
+/* remoteDispatchDomainInterfaceStats has to be implemented manually */
+
+/* remoteDispatchDomainIsActive has to be implemented manually */
+
+/* remoteDispatchDomainIsPersistent has to be implemented manually */
+
+/* remoteDispatchDomainIsUpdated has to be implemented manually */
+
+/* remoteDispatchDomainLookupByID has to be implemented manually */
+
+/* remoteDispatchDomainLookupByName has to be implemented manually */
+
+/* remoteDispatchDomainLookupByUUID has to be implemented manually */
+
+static int
+remoteDomainManagedSave(virDomainPtr dom, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_managed_save_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.flags = flags;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_MANAGED_SAVE,
+             (xdrproc_t)xdr_remote_domain_managed_save_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainManagedSaveRemove(virDomainPtr dom, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_managed_save_remove_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.flags = flags;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_MANAGED_SAVE_REMOVE,
+             (xdrproc_t)xdr_remote_domain_managed_save_remove_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchDomainMemoryPeek has to be implemented manually */
+
+/* remoteDispatchDomainMemoryStats has to be implemented manually */
+
+/* remoteDispatchDomainMigrateFinish has to be implemented manually */
+
+/* remoteDispatchDomainMigrateFinish2 has to be implemented manually */
+
+/* remoteDispatchDomainMigratePerform has to be implemented manually */
+
+/* remoteDispatchDomainMigratePrepare has to be implemented manually */
+
+/* remoteDispatchDomainMigratePrepare2 has to be implemented manually */
+
+/* remoteDispatchDomainMigratePrepareTunnel has to be implemented manually */
+
+static int
+remoteDomainMigrateSetMaxDowntime(virDomainPtr dom, unsigned long long downtime, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_migrate_set_max_downtime_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.downtime = downtime;
+    args.flags = flags;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_DOWNTIME,
+             (xdrproc_t)xdr_remote_domain_migrate_set_max_downtime_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainMigrateSetMaxSpeed(virDomainPtr dom, unsigned long bandwidth, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_migrate_set_max_speed_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.bandwidth = bandwidth;
+    args.flags = flags;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_SPEED,
+             (xdrproc_t)xdr_remote_domain_migrate_set_max_speed_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchDomainOpenConsole has to be implemented manually */
+
+/* remoteDispatchDomainPinVcpu has to be implemented manually */
+
+static int
+remoteDomainReboot(virDomainPtr dom, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_reboot_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.flags = flags;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_REBOOT,
+             (xdrproc_t)xdr_remote_domain_reboot_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainRestore(virConnectPtr conn, const char *from)
+{
+    int rv = -1;
+    struct private_data *priv = conn->privateData;
+    remote_domain_restore_args args;
+
+    remoteDriverLock(priv);
+
+    args.from = (char *)from;
+
+    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_RESTORE,
+             (xdrproc_t)xdr_remote_domain_restore_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainResume(virDomainPtr dom)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_resume_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_RESUME,
+             (xdrproc_t)xdr_remote_domain_resume_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainRevertToSnapshot(virDomainSnapshotPtr snap, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = snap->domain->conn->privateData;
+    remote_domain_revert_to_snapshot_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain_snapshot(&args.snap, snap);
+    args.flags = flags;
+
+    if (call(snap->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_REVERT_TO_SNAPSHOT,
+             (xdrproc_t)xdr_remote_domain_revert_to_snapshot_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainSave(virDomainPtr dom, const char *to)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_save_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.to = (char *)to;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SAVE,
+             (xdrproc_t)xdr_remote_domain_save_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainSetAutostart(virDomainPtr dom, int autostart)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_set_autostart_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.autostart = autostart;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_AUTOSTART,
+             (xdrproc_t)xdr_remote_domain_set_autostart_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchDomainSetBlkioParameters has to be implemented manually */
+
+static int
+remoteDomainSetMaxMemory(virDomainPtr dom, unsigned long memory)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_set_max_memory_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.memory = memory;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MAX_MEMORY,
+             (xdrproc_t)xdr_remote_domain_set_max_memory_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainSetMemory(virDomainPtr dom, unsigned long memory)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_set_memory_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.memory = memory;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MEMORY,
+             (xdrproc_t)xdr_remote_domain_set_memory_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainSetMemoryFlags(virDomainPtr dom, unsigned long memory, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_set_memory_flags_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.memory = memory;
+    args.flags = flags;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MEMORY_FLAGS,
+             (xdrproc_t)xdr_remote_domain_set_memory_flags_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchDomainSetMemoryParameters has to be implemented manually */
+
+/* remoteDispatchDomainSetSchedulerParameters has to be implemented manually */
+
+static int
+remoteDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_set_vcpus_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.nvcpus = nvcpus;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_VCPUS,
+             (xdrproc_t)xdr_remote_domain_set_vcpus_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_set_vcpus_flags_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.nvcpus = nvcpus;
+    args.flags = flags;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_VCPUS_FLAGS,
+             (xdrproc_t)xdr_remote_domain_set_vcpus_flags_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainShutdown(virDomainPtr dom)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_shutdown_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SHUTDOWN,
+             (xdrproc_t)xdr_remote_domain_shutdown_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchDomainSnapshotCreateXML has to be implemented manually */
+
+/* remoteDispatchDomainSnapshotCurrent has to be implemented manually */
+
+static int
+remoteDomainSnapshotDelete(virDomainSnapshotPtr snap, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = snap->domain->conn->privateData;
+    remote_domain_snapshot_delete_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain_snapshot(&args.snap, snap);
+    args.flags = flags;
+
+    if (call(snap->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_DELETE,
+             (xdrproc_t)xdr_remote_domain_snapshot_delete_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchDomainSnapshotDumpXML has to be implemented manually */
+
+/* remoteDispatchDomainSnapshotListNames has to be implemented manually */
+
+/* remoteDispatchDomainSnapshotLookupByName has to be implemented manually */
+
+/* remoteDispatchDomainSnapshotNum has to be implemented manually */
+
+static int
+remoteDomainSuspend(virDomainPtr dom)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_suspend_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SUSPEND,
+             (xdrproc_t)xdr_remote_domain_suspend_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainUndefine(virDomainPtr dom)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_undefine_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_UNDEFINE,
+             (xdrproc_t)xdr_remote_domain_undefine_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainUpdateDeviceFlags(virDomainPtr dom, const char *xml, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_update_device_flags_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.xml = (char *)xml;
+    args.flags = flags;
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_UPDATE_DEVICE_FLAGS,
+             (xdrproc_t)xdr_remote_domain_update_device_flags_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchDomainXMLFromNative has to be implemented manually */
+
+/* remoteDispatchDomainXMLToNative has to be implemented manually */
+
+/* remoteDispatchFindStoragePoolSources has to be implemented manually */
+
+/* remoteDispatchGetCapabilities has to be implemented manually */
+
+/* remoteDispatchGetHostname has to be implemented manually */
+
+/* remoteDispatchGetLibVersion has to be implemented manually */
+
+/* remoteDispatchGetMaxVcpus has to be implemented manually */
+
+/* remoteDispatchGetSysinfo has to be implemented manually */
+
+/* remoteDispatchGetType has to be implemented manually */
+
+/* remoteDispatchGetURI has to be implemented manually */
+
+/* remoteDispatchGetVersion has to be implemented manually */
+
+static int
+remoteInterfaceCreate(virInterfacePtr iface, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = iface->conn->interfacePrivateData;
+    remote_interface_create_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_interface(&args.iface, iface);
+    args.flags = flags;
+
+    if (call(iface->conn, priv, 0, REMOTE_PROC_INTERFACE_CREATE,
+             (xdrproc_t)xdr_remote_interface_create_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchInterfaceDefineXML has to be implemented manually */
+
+static int
+remoteInterfaceDestroy(virInterfacePtr iface, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = iface->conn->interfacePrivateData;
+    remote_interface_destroy_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_interface(&args.iface, iface);
+    args.flags = flags;
+
+    if (call(iface->conn, priv, 0, REMOTE_PROC_INTERFACE_DESTROY,
+             (xdrproc_t)xdr_remote_interface_destroy_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchInterfaceGetXMLDesc has to be implemented manually */
+
+/* remoteDispatchInterfaceIsActive has to be implemented manually */
+
+/* remoteDispatchInterfaceLookupByMACString has to be implemented manually */
+
+/* remoteDispatchInterfaceLookupByName has to be implemented manually */
+
+static int
+remoteInterfaceUndefine(virInterfacePtr iface)
+{
+    int rv = -1;
+    struct private_data *priv = iface->conn->interfacePrivateData;
+    remote_interface_undefine_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_interface(&args.iface, iface);
+
+    if (call(iface->conn, priv, 0, REMOTE_PROC_INTERFACE_UNDEFINE,
+             (xdrproc_t)xdr_remote_interface_undefine_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchIsSecure has to be implemented manually */
+
+/* remoteDispatchListDefinedDomains has to be implemented manually */
+
+/* remoteDispatchListDefinedInterfaces has to be implemented manually */
+
+/* remoteDispatchListDefinedNetworks has to be implemented manually */
+
+/* remoteDispatchListDefinedStoragePools has to be implemented manually */
+
+/* remoteDispatchListDomains has to be implemented manually */
+
+/* remoteDispatchListInterfaces has to be implemented manually */
+
+/* remoteDispatchListNetworks has to be implemented manually */
+
+/* remoteDispatchListNWFilters has to be implemented manually */
+
+/* remoteDispatchListSecrets has to be implemented manually */
+
+/* remoteDispatchListStoragePools has to be implemented manually */
+
+static int
+remoteNetworkCreate(virNetworkPtr net)
+{
+    int rv = -1;
+    struct private_data *priv = net->conn->networkPrivateData;
+    remote_network_create_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_network(&args.net, net);
+
+    if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_CREATE,
+             (xdrproc_t)xdr_remote_network_create_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchNetworkCreateXML has to be implemented manually */
+
+/* remoteDispatchNetworkDefineXML has to be implemented manually */
+
+static int
+remoteNetworkDestroy(virNetworkPtr net)
+{
+    int rv = -1;
+    struct private_data *priv = net->conn->networkPrivateData;
+    remote_network_destroy_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_network(&args.net, net);
+
+    if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_DESTROY,
+             (xdrproc_t)xdr_remote_network_destroy_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchNetworkDumpXML has to be implemented manually */
+
+/* remoteDispatchNetworkGetAutostart has to be implemented manually */
+
+/* remoteDispatchNetworkGetBridgeName has to be implemented manually */
+
+/* remoteDispatchNetworkIsActive has to be implemented manually */
+
+/* remoteDispatchNetworkIsPersistent has to be implemented manually */
+
+/* remoteDispatchNetworkLookupByName has to be implemented manually */
+
+/* remoteDispatchNetworkLookupByUUID has to be implemented manually */
+
+static int
+remoteNetworkSetAutostart(virNetworkPtr net, int autostart)
+{
+    int rv = -1;
+    struct private_data *priv = net->conn->networkPrivateData;
+    remote_network_set_autostart_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_network(&args.net, net);
+    args.autostart = autostart;
+
+    if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_SET_AUTOSTART,
+             (xdrproc_t)xdr_remote_network_set_autostart_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteNetworkUndefine(virNetworkPtr net)
+{
+    int rv = -1;
+    struct private_data *priv = net->conn->networkPrivateData;
+    remote_network_undefine_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_network(&args.net, net);
+
+    if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_UNDEFINE,
+             (xdrproc_t)xdr_remote_network_undefine_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchNodeDeviceCreateXML has to be implemented manually */
+
+static int
+remoteNodeDeviceDestroy(virNodeDevicePtr dev)
+{
+    int rv = -1;
+    struct private_data *priv = dev->conn->devMonPrivateData;
+    remote_node_device_destroy_args args;
+
+    remoteDriverLock(priv);
+
+    args.name = dev->name;
+
+    if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_DESTROY,
+             (xdrproc_t)xdr_remote_node_device_destroy_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchNodeDeviceDettach has to be implemented manually */
+
+/* remoteDispatchNodeDeviceDumpXML has to be implemented manually */
+
+/* remoteDispatchNodeDeviceGetParent has to be implemented manually */
+
+/* remoteDispatchNodeDeviceListCaps has to be implemented manually */
+
+/* remoteDispatchNodeDeviceLookupByName has to be implemented manually */
+
+/* remoteDispatchNodeDeviceNumOfCaps has to be implemented manually */
+
+/* remoteDispatchNodeDeviceReAttach has to be implemented manually */
+
+/* remoteDispatchNodeDeviceReset has to be implemented manually */
+
+/* remoteDispatchNodeGetCellsFreeMemory has to be implemented manually */
+
+/* remoteDispatchNodeGetFreeMemory has to be implemented manually */
+
+/* remoteDispatchNodeGetInfo has to be implemented manually */
+
+/* remoteDispatchNodeGetSecurityModel has to be implemented manually */
+
+/* remoteDispatchNodeListDevices has to be implemented manually */
+
+/* remoteDispatchNodeNumOfDevices has to be implemented manually */
+
+/* remoteDispatchNumOfDefinedDomains has to be implemented manually */
+
+/* remoteDispatchNumOfDefinedInterfaces has to be implemented manually */
+
+/* remoteDispatchNumOfDefinedNetworks has to be implemented manually */
+
+/* remoteDispatchNumOfDefinedStoragePools has to be implemented manually */
+
+/* remoteDispatchNumOfDomains has to be implemented manually */
+
+/* remoteDispatchNumOfInterfaces has to be implemented manually */
+
+/* remoteDispatchNumOfNetworks has to be implemented manually */
+
+/* remoteDispatchNumOfNWFilters has to be implemented manually */
+
+/* remoteDispatchNumOfSecrets has to be implemented manually */
+
+/* remoteDispatchNumOfStoragePools has to be implemented manually */
+
+/* remoteDispatchNWFilterDefineXML has to be implemented manually */
+
+/* remoteDispatchNWFilterGetXMLDesc has to be implemented manually */
+
+/* remoteDispatchNWFilterLookupByName has to be implemented manually */
+
+/* remoteDispatchNWFilterLookupByUUID has to be implemented manually */
+
+static int
+remoteNWFilterUndefine(virNWFilterPtr nwfilter)
+{
+    int rv = -1;
+    struct private_data *priv = nwfilter->conn->nwfilterPrivateData;
+    remote_nwfilter_undefine_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_nwfilter(&args.nwfilter, nwfilter);
+
+    if (call(nwfilter->conn, priv, 0, REMOTE_PROC_NWFILTER_UNDEFINE,
+             (xdrproc_t)xdr_remote_nwfilter_undefine_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchOpen has to be implemented manually */
+
+/* remoteDispatchSecretDefineXML has to be implemented manually */
+
+/* remoteDispatchSecretGetValue has to be implemented manually */
+
+/* remoteDispatchSecretGetXMLDesc has to be implemented manually */
+
+/* remoteDispatchSecretLookupByUsage has to be implemented manually */
+
+/* remoteDispatchSecretLookupByUUID has to be implemented manually */
+
+/* remoteDispatchSecretSetValue has to be implemented manually */
+
+static int
+remoteSecretUndefine(virSecretPtr secret)
+{
+    int rv = -1;
+    struct private_data *priv = secret->conn->secretPrivateData;
+    remote_secret_undefine_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_secret(&args.secret, secret);
+
+    if (call(secret->conn, priv, 0, REMOTE_PROC_SECRET_UNDEFINE,
+             (xdrproc_t)xdr_remote_secret_undefine_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteStoragePoolBuild(virStoragePoolPtr pool, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = pool->conn->storagePrivateData;
+    remote_storage_pool_build_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_pool(&args.pool, pool);
+    args.flags = flags;
+
+    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_BUILD,
+             (xdrproc_t)xdr_remote_storage_pool_build_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteStoragePoolCreate(virStoragePoolPtr pool, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = pool->conn->storagePrivateData;
+    remote_storage_pool_create_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_pool(&args.pool, pool);
+    args.flags = flags;
+
+    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_CREATE,
+             (xdrproc_t)xdr_remote_storage_pool_create_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchStoragePoolCreateXML has to be implemented manually */
+
+/* remoteDispatchStoragePoolDefineXML has to be implemented manually */
+
+static int
+remoteStoragePoolDelete(virStoragePoolPtr pool, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = pool->conn->storagePrivateData;
+    remote_storage_pool_delete_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_pool(&args.pool, pool);
+    args.flags = flags;
+
+    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DELETE,
+             (xdrproc_t)xdr_remote_storage_pool_delete_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteStoragePoolDestroy(virStoragePoolPtr pool)
+{
+    int rv = -1;
+    struct private_data *priv = pool->conn->storagePrivateData;
+    remote_storage_pool_destroy_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_pool(&args.pool, pool);
+
+    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DESTROY,
+             (xdrproc_t)xdr_remote_storage_pool_destroy_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchStoragePoolDumpXML has to be implemented manually */
+
+/* remoteDispatchStoragePoolGetAutostart has to be implemented manually */
+
+/* remoteDispatchStoragePoolGetInfo has to be implemented manually */
+
+/* remoteDispatchStoragePoolIsActive has to be implemented manually */
+
+/* remoteDispatchStoragePoolIsPersistent has to be implemented manually */
+
+/* remoteDispatchStoragePoolListVolumes has to be implemented manually */
+
+/* remoteDispatchStoragePoolLookupByName has to be implemented manually */
+
+/* remoteDispatchStoragePoolLookupByUUID has to be implemented manually */
+
+/* remoteDispatchStoragePoolLookupByVolume has to be implemented manually */
+
+/* remoteDispatchStoragePoolNumOfVolumes has to be implemented manually */
+
+static int
+remoteStoragePoolRefresh(virStoragePoolPtr pool, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = pool->conn->storagePrivateData;
+    remote_storage_pool_refresh_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_pool(&args.pool, pool);
+    args.flags = flags;
+
+    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_REFRESH,
+             (xdrproc_t)xdr_remote_storage_pool_refresh_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteStoragePoolSetAutostart(virStoragePoolPtr pool, int autostart)
+{
+    int rv = -1;
+    struct private_data *priv = pool->conn->storagePrivateData;
+    remote_storage_pool_set_autostart_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_pool(&args.pool, pool);
+    args.autostart = autostart;
+
+    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART,
+             (xdrproc_t)xdr_remote_storage_pool_set_autostart_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteStoragePoolUndefine(virStoragePoolPtr pool)
+{
+    int rv = -1;
+    struct private_data *priv = pool->conn->storagePrivateData;
+    remote_storage_pool_undefine_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_pool(&args.pool, pool);
+
+    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_UNDEFINE,
+             (xdrproc_t)xdr_remote_storage_pool_undefine_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchStorageVolCreateXML has to be implemented manually */
+
+/* remoteDispatchStorageVolCreateXMLFrom has to be implemented manually */
+
+static int
+remoteStorageVolDelete(virStorageVolPtr vol, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = vol->conn->storagePrivateData;
+    remote_storage_vol_delete_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_vol(&args.vol, vol);
+    args.flags = flags;
+
+    if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_DELETE,
+             (xdrproc_t)xdr_remote_storage_vol_delete_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchStorageVolDownload has to be implemented manually */
+
+/* remoteDispatchStorageVolDumpXML has to be implemented manually */
+
+/* remoteDispatchStorageVolGetInfo has to be implemented manually */
+
+/* remoteDispatchStorageVolGetPath has to be implemented manually */
+
+/* remoteDispatchStorageVolLookupByKey has to be implemented manually */
+
+/* remoteDispatchStorageVolLookupByName has to be implemented manually */
+
+/* remoteDispatchStorageVolLookupByPath has to be implemented manually */
+
+/* remoteDispatchStorageVolUpload has to be implemented manually */
+
+static int
+remoteStorageVolWipe(virStorageVolPtr vol, unsigned int flags)
+{
+    int rv = -1;
+    struct private_data *priv = vol->conn->storagePrivateData;
+    remote_storage_vol_wipe_args args;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_vol(&args.vol, vol);
+    args.flags = flags;
+
+    if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_WIPE,
+             (xdrproc_t)xdr_remote_storage_vol_wipe_args, (char *)&args,
+             (xdrproc_t)xdr_void, (char *)NULL) == -1)
+        goto done;
+
+    rv = 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+/* remoteDispatchSupportsFeature has to be implemented manually */
+
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 934fdda..bf4d866 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -2249,99 +2249,6 @@ done:
 }
 
 static int
-remoteDomainSuspend (virDomainPtr domain)
-{
-    int rv = -1;
-    remote_domain_suspend_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SUSPEND,
-              (xdrproc_t) xdr_remote_domain_suspend_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainResume (virDomainPtr domain)
-{
-    int rv = -1;
-    remote_domain_resume_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_RESUME,
-              (xdrproc_t) xdr_remote_domain_resume_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainShutdown (virDomainPtr domain)
-{
-    int rv = -1;
-    remote_domain_shutdown_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SHUTDOWN,
-              (xdrproc_t) xdr_remote_domain_shutdown_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainReboot (virDomainPtr domain, unsigned int flags)
-{
-    int rv = -1;
-    remote_domain_reboot_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.flags = flags;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_REBOOT,
-              (xdrproc_t) xdr_remote_domain_reboot_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
 remoteDomainDestroy (virDomainPtr domain)
 {
     int rv = -1;
@@ -2417,81 +2324,6 @@ done:
 }
 
 static int
-remoteDomainSetMaxMemory (virDomainPtr domain, unsigned long memory)
-{
-    int rv = -1;
-    remote_domain_set_max_memory_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.memory = memory;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MAX_MEMORY,
-              (xdrproc_t) xdr_remote_domain_set_max_memory_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainSetMemory (virDomainPtr domain, unsigned long memory)
-{
-    int rv = -1;
-    remote_domain_set_memory_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.memory = memory;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MEMORY,
-              (xdrproc_t) xdr_remote_domain_set_memory_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainSetMemoryFlags (virDomainPtr domain, unsigned long memory, unsigned int flags)
-{
-    int rv = -1;
-    remote_domain_set_memory_flags_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.memory = memory;
-    args.flags = flags;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MEMORY_FLAGS,
-              (xdrproc_t) xdr_remote_domain_set_memory_flags_args,
-              (char *) &args,
-              (xdrproc_t) xdr_void,
-              (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
 remoteDomainSetMemoryParameters (virDomainPtr domain,
                                  virMemoryParameterPtr params,
                                  int nparams,
@@ -2861,129 +2693,6 @@ done:
 }
 
 static int
-remoteDomainSave (virDomainPtr domain, const char *to)
-{
-    int rv = -1;
-    remote_domain_save_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.to = (char *) to;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SAVE,
-              (xdrproc_t) xdr_remote_domain_save_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainRestore (virConnectPtr conn, const char *from)
-{
-    int rv = -1;
-    remote_domain_restore_args args;
-    struct private_data *priv = conn->privateData;
-
-    remoteDriverLock(priv);
-
-    args.from = (char *) from;
-
-    if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_RESTORE,
-              (xdrproc_t) xdr_remote_domain_restore_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainCoreDump (virDomainPtr domain, const char *to, int flags)
-{
-    int rv = -1;
-    remote_domain_core_dump_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.to = (char *) to;
-    args.flags = flags;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_CORE_DUMP,
-              (xdrproc_t) xdr_remote_domain_core_dump_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainSetVcpus (virDomainPtr domain, unsigned int nvcpus)
-{
-    int rv = -1;
-    remote_domain_set_vcpus_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.nvcpus = nvcpus;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_VCPUS,
-              (xdrproc_t) xdr_remote_domain_set_vcpus_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainSetVcpusFlags (virDomainPtr domain, unsigned int nvcpus,
-                           unsigned int flags)
-{
-    int rv = -1;
-    remote_domain_set_vcpus_flags_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.nvcpus = nvcpus;
-    args.flags = flags;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_VCPUS_FLAGS,
-              (xdrproc_t) xdr_remote_domain_set_vcpus_flags_args,
-              (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
 remoteDomainGetVcpusFlags (virDomainPtr domain, unsigned int flags)
 {
     int rv = -1;
@@ -3696,155 +3405,6 @@ done:
 }
 
 static int
-remoteDomainUndefine (virDomainPtr domain)
-{
-    int rv = -1;
-    remote_domain_undefine_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_UNDEFINE,
-              (xdrproc_t) xdr_remote_domain_undefine_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainAttachDevice (virDomainPtr domain, const char *xml)
-{
-    int rv = -1;
-    remote_domain_attach_device_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.xml = (char *) xml;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_ATTACH_DEVICE,
-              (xdrproc_t) xdr_remote_domain_attach_device_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainAttachDeviceFlags (virDomainPtr domain, const char *xml,
-                               unsigned int flags)
-{
-    int rv = -1;
-    remote_domain_attach_device_flags_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.xml = (char *) xml;
-    args.flags = flags;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_ATTACH_DEVICE_FLAGS,
-              (xdrproc_t) xdr_remote_domain_attach_device_flags_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainDetachDevice (virDomainPtr domain, const char *xml)
-{
-    int rv = -1;
-    remote_domain_detach_device_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.xml = (char *) xml;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_DETACH_DEVICE,
-              (xdrproc_t) xdr_remote_domain_detach_device_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainDetachDeviceFlags (virDomainPtr domain, const char *xml,
-                               unsigned int flags)
-{
-    int rv = -1;
-    remote_domain_detach_device_flags_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.xml = (char *) xml;
-    args.flags = flags;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_DETACH_DEVICE_FLAGS,
-              (xdrproc_t) xdr_remote_domain_detach_device_flags_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainUpdateDeviceFlags (virDomainPtr domain, const char *xml,
-                               unsigned int flags)
-{
-    int rv = -1;
-    remote_domain_update_device_flags_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.xml = (char *) xml;
-    args.flags = flags;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_UPDATE_DEVICE_FLAGS,
-              (xdrproc_t) xdr_remote_domain_update_device_flags_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
 remoteDomainGetAutostart (virDomainPtr domain, int *autostart)
 {
     int rv = -1;
@@ -3870,30 +3430,6 @@ done:
     return rv;
 }
 
-static int
-remoteDomainSetAutostart (virDomainPtr domain, int autostart)
-{
-    int rv = -1;
-    remote_domain_set_autostart_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.autostart = autostart;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_AUTOSTART,
-              (xdrproc_t) xdr_remote_domain_set_autostart_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
 static char *
 remoteDomainGetSchedulerType (virDomainPtr domain, int *nparams)
 {
@@ -4311,30 +3847,6 @@ done:
 }
 
 static int
-remoteDomainManagedSave (virDomainPtr domain, unsigned int flags)
-{
-    int rv = -1;
-    remote_domain_managed_save_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.flags = flags;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MANAGED_SAVE,
-              (xdrproc_t) xdr_remote_domain_managed_save_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
 remoteDomainHasManagedSaveImage (virDomainPtr domain, unsigned int flags)
 {
     int rv = -1;
@@ -4359,30 +3871,6 @@ done:
     return rv;
 }
 
-static int
-remoteDomainManagedSaveRemove (virDomainPtr domain, unsigned int flags)
-{
-    int rv = -1;
-    remote_domain_managed_save_remove_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.flags = flags;
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MANAGED_SAVE_REMOVE,
-              (xdrproc_t) xdr_remote_domain_managed_save_remove_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
 /*----------------------------------------------------------------------*/
 
 static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -4762,75 +4250,6 @@ done:
     return net;
 }
 
-static int
-remoteNetworkUndefine (virNetworkPtr network)
-{
-    int rv = -1;
-    remote_network_undefine_args args;
-    struct private_data *priv = network->conn->networkPrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_network (&args.net, network);
-
-    if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_UNDEFINE,
-              (xdrproc_t) xdr_remote_network_undefine_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteNetworkCreate (virNetworkPtr network)
-{
-    int rv = -1;
-    remote_network_create_args args;
-    struct private_data *priv = network->conn->networkPrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_network (&args.net, network);
-
-    if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_CREATE,
-              (xdrproc_t) xdr_remote_network_create_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteNetworkDestroy (virNetworkPtr network)
-{
-    int rv = -1;
-    remote_network_destroy_args args;
-    struct private_data *priv = network->conn->networkPrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_network (&args.net, network);
-
-    if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_DESTROY,
-              (xdrproc_t) xdr_remote_network_destroy_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
 static char *
 remoteNetworkDumpXML (virNetworkPtr network, int flags)
 {
@@ -4911,33 +4330,6 @@ done:
     return rv;
 }
 
-static int
-remoteNetworkSetAutostart (virNetworkPtr network, int autostart)
-{
-    int rv = -1;
-    remote_network_set_autostart_args args;
-    struct private_data *priv = network->conn->networkPrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_network (&args.net, network);
-    args.autostart = autostart;
-
-    if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_SET_AUTOSTART,
-              (xdrproc_t) xdr_remote_network_set_autostart_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-
-
-
 /*----------------------------------------------------------------------*/
 
 static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -5299,79 +4691,6 @@ done:
     return iface;
 }
 
-static int
-remoteInterfaceUndefine (virInterfacePtr iface)
-{
-    int rv = -1;
-    remote_interface_undefine_args args;
-    struct private_data *priv = iface->conn->interfacePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_interface (&args.iface, iface);
-
-    if (call (iface->conn, priv, 0, REMOTE_PROC_INTERFACE_UNDEFINE,
-              (xdrproc_t) xdr_remote_interface_undefine_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteInterfaceCreate (virInterfacePtr iface,
-                       unsigned int flags)
-{
-    int rv = -1;
-    remote_interface_create_args args;
-    struct private_data *priv = iface->conn->interfacePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_interface (&args.iface, iface);
-    args.flags = flags;
-
-    if (call (iface->conn, priv, 0, REMOTE_PROC_INTERFACE_CREATE,
-              (xdrproc_t) xdr_remote_interface_create_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteInterfaceDestroy (virInterfacePtr iface,
-                        unsigned int flags)
-{
-    int rv = -1;
-    remote_interface_destroy_args args;
-    struct private_data *priv = iface->conn->interfacePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_interface (&args.iface, iface);
-    args.flags = flags;
-
-    if (call (iface->conn, priv, 0, REMOTE_PROC_INTERFACE_DESTROY,
-              (xdrproc_t) xdr_remote_interface_destroy_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
 /*----------------------------------------------------------------------*/
 
 static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -5826,151 +5145,6 @@ done:
 }
 
 static int
-remoteStoragePoolUndefine (virStoragePoolPtr pool)
-{
-    int rv = -1;
-    remote_storage_pool_undefine_args args;
-    struct private_data *priv = pool->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_pool (&args.pool, pool);
-
-    if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_UNDEFINE,
-              (xdrproc_t) xdr_remote_storage_pool_undefine_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteStoragePoolCreate (virStoragePoolPtr pool, unsigned int flags)
-{
-    int rv = -1;
-    remote_storage_pool_create_args args;
-    struct private_data *priv = pool->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_pool (&args.pool, pool);
-    args.flags = flags;
-
-    if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_CREATE,
-              (xdrproc_t) xdr_remote_storage_pool_create_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteStoragePoolBuild (virStoragePoolPtr pool,
-                        unsigned int flags)
-{
-    int rv = -1;
-    remote_storage_pool_build_args args;
-    struct private_data *priv = pool->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_pool (&args.pool, pool);
-    args.flags = flags;
-
-    if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_BUILD,
-              (xdrproc_t) xdr_remote_storage_pool_build_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteStoragePoolDestroy (virStoragePoolPtr pool)
-{
-    int rv = -1;
-    remote_storage_pool_destroy_args args;
-    struct private_data *priv = pool->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_pool (&args.pool, pool);
-
-    if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DESTROY,
-              (xdrproc_t) xdr_remote_storage_pool_destroy_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteStoragePoolDelete (virStoragePoolPtr pool,
-                         unsigned int flags)
-{
-    int rv = -1;
-    remote_storage_pool_delete_args args;
-    struct private_data *priv = pool->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_pool (&args.pool, pool);
-    args.flags = flags;
-
-    if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DELETE,
-              (xdrproc_t) xdr_remote_storage_pool_delete_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteStoragePoolRefresh (virStoragePoolPtr pool,
-                          unsigned int flags)
-{
-    int rv = -1;
-    remote_storage_pool_refresh_args args;
-    struct private_data *priv = pool->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_pool (&args.pool, pool);
-    args.flags = flags;
-
-    if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_REFRESH,
-              (xdrproc_t) xdr_remote_storage_pool_refresh_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
 remoteStoragePoolGetInfo (virStoragePoolPtr pool, virStoragePoolInfoPtr info)
 {
     int rv = -1;
@@ -6056,31 +5230,6 @@ done:
 }
 
 static int
-remoteStoragePoolSetAutostart (virStoragePoolPtr pool, int autostart)
-{
-    int rv = -1;
-    remote_storage_pool_set_autostart_args args;
-    struct private_data *priv = pool->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_pool (&args.pool, pool);
-    args.autostart = autostart;
-
-    if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART,
-              (xdrproc_t) xdr_remote_storage_pool_set_autostart_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-
-static int
 remoteStoragePoolNumOfVolumes (virStoragePoolPtr pool)
 {
     int rv = -1;
@@ -6307,57 +5456,6 @@ done:
 }
 
 static int
-remoteStorageVolDelete (virStorageVolPtr vol,
-                        unsigned int flags)
-{
-    int rv = -1;
-    remote_storage_vol_delete_args args;
-    struct private_data *priv = vol->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_vol (&args.vol, vol);
-    args.flags = flags;
-
-    if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_DELETE,
-              (xdrproc_t) xdr_remote_storage_vol_delete_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteStorageVolWipe(virStorageVolPtr vol,
-                     unsigned int flags)
-{
-    int rv = -1;
-    remote_storage_vol_wipe_args args;
-    struct private_data *priv = vol->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_vol(&args.vol, vol);
-    args.flags = flags;
-
-    if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_WIPE,
-             (xdrproc_t) xdr_remote_storage_vol_wipe_args, (char *) &args,
-             (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-
-static int
 remoteStorageVolGetInfo (virStorageVolPtr vol, virStorageVolInfoPtr info)
 {
     int rv = -1;
@@ -6863,29 +5961,6 @@ done:
     return dev;
 }
 
-static int
-remoteNodeDeviceDestroy(virNodeDevicePtr dev)
-{
-    int rv = -1;
-    remote_node_device_destroy_args args;
-    struct private_data *priv = dev->conn->devMonPrivateData;
-
-    remoteDriverLock(priv);
-
-    args.name = dev->name;
-
-    if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_DESTROY,
-             (xdrproc_t) xdr_remote_node_device_destroy_args, (char *) &args,
-             (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
 /* ------------------------------------------------------------- */
 
 static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -6999,31 +6074,6 @@ done:
     return net;
 }
 
-
-static int
-remoteNWFilterUndefine (virNWFilterPtr nwfilter)
-{
-    int rv = -1;
-    remote_nwfilter_undefine_args args;
-    struct private_data *priv = nwfilter->conn->nwfilterPrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_nwfilter (&args.nwfilter, nwfilter);
-
-    if (call (nwfilter->conn, priv, 0, REMOTE_PROC_NWFILTER_UNDEFINE,
-              (xdrproc_t) xdr_remote_nwfilter_undefine_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-
 static int
 remoteListNWFilters (virConnectPtr conn, char **const names, int maxnames)
 {
@@ -8252,7 +7302,7 @@ done:
 }
 
 static int
-remoteSecretListSecrets (virConnectPtr conn, char **uuids, int maxuuids)
+remoteListSecrets (virConnectPtr conn, char **uuids, int maxuuids)
 {
     int rv = -1;
     int i;
@@ -8472,30 +7522,6 @@ done:
     return rv;
 }
 
-static int
-remoteSecretUndefine (virSecretPtr secret)
-{
-    int rv = -1;
-    remote_secret_undefine_args args;
-    struct private_data *priv = secret->conn->secretPrivateData;
-
-    remoteDriverLock (priv);
-
-    make_nonnull_secret (&args.secret, secret);
-
-    if (call (secret->conn, priv, 0, REMOTE_PROC_SECRET_UNDEFINE,
-              (xdrproc_t) xdr_remote_secret_undefine_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock (priv);
-    return rv;
-}
-
-
 static struct private_stream_data *
 remoteStreamOpen(virStreamPtr st,
                  unsigned int proc_nr,
@@ -9141,89 +8167,6 @@ done:
     return rv;
 }
 
-
-static int
-remoteDomainAbortJob (virDomainPtr domain)
-{
-    int rv = -1;
-    remote_domain_abort_job_args args;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_ABORT_JOB,
-              (xdrproc_t) xdr_remote_domain_abort_job_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-
-static int
-remoteDomainMigrateSetMaxDowntime(virDomainPtr domain,
-                                  unsigned long long downtime,
-                                  unsigned int flags)
-{
-    struct private_data *priv = domain->conn->privateData;
-    remote_domain_migrate_set_max_downtime_args args;
-    int rv = -1;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain(&args.dom, domain);
-    args.downtime = downtime;
-    args.flags = flags;
-
-    if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_DOWNTIME,
-             (xdrproc_t) xdr_remote_domain_migrate_set_max_downtime_args,
-             (char *) &args,
-             (xdrproc_t) xdr_void,
-             (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static int
-remoteDomainMigrateSetMaxSpeed(virDomainPtr domain,
-                               unsigned long bandwidth,
-                               unsigned int flags)
-{
-    struct private_data *priv = domain->conn->privateData;
-    remote_domain_migrate_set_max_speed_args args;
-    int rv = -1;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain(&args.dom, domain);
-    args.bandwidth = bandwidth;
-    args.flags = flags;
-
-    if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_SPEED,
-             (xdrproc_t) xdr_remote_domain_migrate_set_max_speed_args,
-             (char *) &args,
-             (xdrproc_t) xdr_void,
-             (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
 static virDomainSnapshotPtr
 remoteDomainSnapshotCreateXML(virDomainPtr domain,
                               const char *xmlDesc,
@@ -9458,58 +8401,6 @@ done:
     return snapshot;
 }
 
-
-static int
-remoteDomainRevertToSnapshot (virDomainSnapshotPtr snapshot,
-                              unsigned int flags)
-{
-    int rv = -1;
-    remote_domain_revert_to_snapshot_args args;
-    struct private_data *priv = snapshot->domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain_snapshot(&args.snap, snapshot);
-    args.flags = flags;
-
-    if (call (snapshot->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_REVERT_TO_SNAPSHOT,
-              (xdrproc_t) xdr_remote_domain_revert_to_snapshot_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-
-static int
-remoteDomainSnapshotDelete (virDomainSnapshotPtr snapshot,
-                            unsigned int flags)
-{
-    int rv = -1;
-    remote_domain_snapshot_delete_args args;
-    struct private_data *priv = snapshot->domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain_snapshot(&args.snap, snapshot);
-    args.flags = flags;
-
-    if (call (snapshot->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_DELETE,
-              (xdrproc_t) xdr_remote_domain_snapshot_delete_args, (char *) &args,
-              (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        goto done;
-
-    rv = 0;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
 static int remoteDomainEventRegisterAny(virConnectPtr conn,
                                         virDomainPtr dom,
                                         int eventID,
@@ -9770,6 +8661,9 @@ done:
     return rv;
 }
 
+#include "remote_client_bodies.c"
+#include "qemu_client_bodies.c"
+
 /*----------------------------------------------------------------------*/
 
 static struct remote_thread_call *
@@ -11389,7 +10283,7 @@ static virSecretDriver secret_driver = {
     .open = remoteSecretOpen,
     .close = remoteSecretClose,
     .numOfSecrets = remoteSecretNumOfSecrets,
-    .listSecrets = remoteSecretListSecrets,
+    .listSecrets = remoteListSecrets,
     .lookupByUUID = remoteSecretLookupByUUID,
     .lookupByUsage = remoteSecretLookupByUsage,
     .defineXML = remoteSecretDefineXML,
-- 
1.7.0.4


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]