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

[libvirt] [PATCH 17/22] remote generator, client: Handle functions with wrapped return values



---
 daemon/remote_generator.pl        |   88 ++--
 src/remote/remote_client_bodies.c |  987 +++++++++++++++++++++++++++++++++++--
 src/remote/remote_driver.c        |  996 -------------------------------------
 3 files changed, 993 insertions(+), 1078 deletions(-)

diff --git a/daemon/remote_generator.pl b/daemon/remote_generator.pl
index a973b21..5045b7f 100755
--- a/daemon/remote_generator.pl
+++ b/daemon/remote_generator.pl
@@ -753,82 +753,44 @@ elsif ($opt_k) {
                           "CPUBaseline",
                           "DomainBlockStats",
                           "DomainCreate",
-                          "DomainCreateXML",
-                          "DomainDefineXML",
                           "DomainDestroy",
                           "DomainGetAutostart",
                           "DomainGetBlockInfo",
                           "DomainGetInfo",
-                          "StoragePoolLookupByUUID",
-                          "NodeDeviceCreateXML",
                           "DomainGetJobInfo",
                           "DomainInterfaceStats",
-                          "DomainLookupByID",
-                          "DomainLookupByName",
-                          "DomainLookupByUIID",
                           "DomainMigrateFinish",
-                          "NWFilterDefineXML",
-                          "NWFilterLookupByName",
-                          "NWFilterLookupByUUID",
-                          "SecretLookupByUUID",
-                          "SecretLookupByUsage",
-                          "StoragePoolCreateXML",
-                          "DomainLookupByUUID",
+                          "NWFilterDefineXML", # public API and XDR protocol mismatch
                           "DomainMigratePerform",
                           "DomainMigrateFinish2",
-                          "DomainSnapshotCreateXML",
-                          "DomainSnapshotCurrent",
                           "DomainSnapshotListNames",
                           "GetLibVersion",
-                          "GetMaxVcpus",
-                          "DomainSnapshotLookupByName",
-                          "DomainXMLFromNative",
                           "FindStoragePoolSources",
                           "GetVersion",
-                          "GetLibVersion",
-                          "InterfaceDefineXML",
-                          "InterfaceLookupByName",
                           "IsSecure",
                           "ListDefinedDomains",
                           "ListDefinedInterfaces",
                           "ListNWFilters",
-                          "NetworkCreateXML",
                           "SupportsFeature",
-                          "StorageVolLookupByPath",
                           "StorageVolGetInfo",
-                          "StorageVolCreateXML",
-                          "StorageVolLookupByName",
-                          "StorageVolLookupByKey",
                           "StoragePoolGetInfo",
-                          "StorageVolCreateXMLFrom",
-                          "StoragePoolLookupByName",
                           "NodeListDevices",
                           "NodeGetCellsFreeMemory",
                           "ListDefinedNetworks",
-                          "DomainXMLToNative",
                           "StoragePoolListVolumes",
-                          "SecretDefineXML",
                           "ListDomains",
                           "ListStoragePools",
                           "NetworkGetAutostart",
-                          "StoragePoolLookupByVolume",
                           "StoragePoolGetAutostart",
                           "SecretSetValue",
-                          "StoragePoolDefineXML",
                           "NodeGetInfo",
                           "GetURI",
-                          "InterfaceLookupByMACString",
                           "ListInterfaces",
-                          "NetworkDefineXML",
-                          "NetworkLookupByName",
                           "ListDefinedStoragePools",
                           "NodeDeviceDettach",
-                          "NodeDeviceLookupByName",
-                          "NodeGetFreeMemory",
                           "ListNetworks",
                           "NodeDeviceListCaps",
                           "NodeDeviceReset",
-                          "NetworkLookupByUUID",
                           "NodeDeviceReAttach",
                           "ListSecrets",
 
@@ -889,7 +851,9 @@ elsif ($opt_k) {
             my $has_node_device = 0;
 
             # node device is special
-            if ($call->{args} =~ m/^remote_node_/) {
+            if ($call->{args} =~ m/^remote_node_/ and
+                !($call->{args} =~ m/^remote_node_device_lookup_by_name_/) and
+                !($call->{args} =~ m/^remote_node_device_create_xml_/)) {
                 $has_node_device = 1;
                 $priv_name = "devMonPrivateData";
             }
@@ -901,13 +865,14 @@ elsif ($opt_k) {
                     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 $arg_name = $2;
                     my $type_name = name_to_ProcName($name);
 
                     if ($is_first_arg) {
                         if ($name eq "domain_snapshot") {
-                            $priv_src = "$2->domain->conn";
+                            $priv_src = "$arg_name->domain->conn";
                         } else {
-                            $priv_src = "$2->conn";
+                            $priv_src = "$arg_name->conn";
                         }
 
                         if ($name =~ m/^storage_/) {
@@ -917,8 +882,11 @@ elsif ($opt_k) {
                         }
                     }
 
-                    push(@args_list, "vir${type_name}Ptr $2");
-                    push(@setters_list, "make_nonnull_$1(&args.$2, $2);");
+                    push(@args_list, "vir${type_name}Ptr $arg_name");
+                    push(@setters_list, "make_nonnull_$1(&args.$arg_name, $arg_name);");
+                } elsif ($args_member =~ m/^remote_uuid (\S+);/) {
+                    push(@args_list, "const unsigned char *$1");
+                    push(@setters_list, "memcpy(args.$1, $1, VIR_UUID_BUFLEN);");
                 } elsif ($args_member =~ m/^remote_string (\S+);/) {
                     push(@args_list, "const char *$1");
                     push(@setters_list, "args.$1 = $1 ? (char **)&$1 : NULL;");
@@ -988,14 +956,42 @@ elsif ($opt_k) {
                     push(@ret_list, "rv = ret.$1;");
                     $single_ret_var = "char *rv = NULL";
                     $single_ret_type = "char *";
+                } elsif ($ret_member =~ m/remote_nonnull_(domain|network|storage_pool|storage_vol|node_device|interface|secret|nwfilter|domain_snapshot) (\S+);/) {
+                    my $name = $1;
+                    my $arg_name = $2;
+                    my $type_name = name_to_ProcName($name);
+
+                    if ($name eq "node_device") {
+                        $priv_name = "devMonPrivateData";
+                    } elsif ($name =~ m/^storage_/) {
+                        $priv_name = "storagePrivateData";
+                    } elsif (!($name =~ m/^domain/)) {
+                        $priv_name = "${name}PrivateData";
+                    }
+
+                    if ($name eq "domain_snapshot") {
+                        push(@ret_list, "rv = get_nonnull_$name(dom, ret.$arg_name);");
+                    } else {
+                        push(@ret_list, "rv = get_nonnull_$name($priv_src, ret.$arg_name);");
+                    }
+
+                    push(@ret_list, "xdr_free((xdrproc_t)xdr_$call->{ret}, (char *)&ret);");
+                    $single_ret_var = "vir${type_name}Ptr rv = NULL";
+                    $single_ret_type = "vir${type_name}Ptr";
                 } elsif ($ret_member =~ m/^int (\S+);/) {
                     push(@ret_list, "rv = ret.$1;");
                     $single_ret_var = "int rv = -1";
                     $single_ret_type = "int";
                 } elsif ($ret_member =~ m/hyper (\S+);/) {
                     push(@ret_list, "rv = ret.$1;");
-                    $single_ret_var = "unsigned long rv = 0";
-                    $single_ret_type = "unsigned long";
+
+                    if ($call->{ProcName} eq "NodeGetFreeMemory") {
+                        $single_ret_var = "unsigned long long rv = 0";
+                        $single_ret_type = "unsigned long long";
+                    } else {
+                        $single_ret_var = "unsigned long rv = 0";
+                        $single_ret_type = "unsigned long";
+                    }
                 } else {
                     die "unhandled type for return value: $ret_member";
                 }
diff --git a/src/remote/remote_client_bodies.c b/src/remote/remote_client_bodies.c
index b878832..5471c1b 100644
--- a/src/remote/remote_client_bodies.c
+++ b/src/remote/remote_client_bodies.c
@@ -148,9 +148,60 @@ done:
 
 /* remoteDispatchDomainCreateWithFlags has to be implemented manually */
 
-/* remoteDispatchDomainCreateXML has to be implemented manually */
+static virDomainPtr
+remoteDomainCreateXML(virConnectPtr conn, const char *xml_desc, unsigned int flags)
+{
+    virDomainPtr rv = NULL;
+    struct private_data *priv = conn->privateData;
+    remote_domain_create_xml_args args;
+    remote_domain_create_xml_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.xml_desc = (char *)xml_desc;
+    args.flags = flags;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_CREATE_XML,
+             (xdrproc_t)xdr_remote_domain_create_xml_args, (char *)&args,
+             (xdrproc_t)xdr_remote_domain_create_xml_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_domain(conn, ret.dom);
+    xdr_free((xdrproc_t)xdr_remote_domain_create_xml_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virDomainPtr
+remoteDomainDefineXML(virConnectPtr conn, const char *xml)
+{
+    virDomainPtr rv = NULL;
+    struct private_data *priv = conn->privateData;
+    remote_domain_define_xml_args args;
+    remote_domain_define_xml_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.xml = (char *)xml;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_DEFINE_XML,
+             (xdrproc_t)xdr_remote_domain_define_xml_args, (char *)&args,
+             (xdrproc_t)xdr_remote_domain_define_xml_ret, (char *)&ret) == -1)
+        goto done;
 
-/* remoteDispatchDomainDefineXML has to be implemented manually */
+    rv = get_nonnull_domain(conn, ret.dom);
+    xdr_free((xdrproc_t)xdr_remote_domain_define_xml_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 /* remoteDispatchDomainDestroy has to be implemented manually */
 
@@ -497,11 +548,86 @@ done:
     return rv;
 }
 
-/* remoteDispatchDomainLookupByID has to be implemented manually */
+static virDomainPtr
+remoteDomainLookupByID(virConnectPtr conn, int id)
+{
+    virDomainPtr rv = NULL;
+    struct private_data *priv = conn->privateData;
+    remote_domain_lookup_by_id_args args;
+    remote_domain_lookup_by_id_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.id = id;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_ID,
+             (xdrproc_t)xdr_remote_domain_lookup_by_id_args, (char *)&args,
+             (xdrproc_t)xdr_remote_domain_lookup_by_id_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_domain(conn, ret.dom);
+    xdr_free((xdrproc_t)xdr_remote_domain_lookup_by_id_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virDomainPtr
+remoteDomainLookupByName(virConnectPtr conn, const char *name)
+{
+    virDomainPtr rv = NULL;
+    struct private_data *priv = conn->privateData;
+    remote_domain_lookup_by_name_args args;
+    remote_domain_lookup_by_name_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.name = (char *)name;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME,
+             (xdrproc_t)xdr_remote_domain_lookup_by_name_args, (char *)&args,
+             (xdrproc_t)xdr_remote_domain_lookup_by_name_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_domain(conn, ret.dom);
+    xdr_free((xdrproc_t)xdr_remote_domain_lookup_by_name_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virDomainPtr
+remoteDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+    virDomainPtr rv = NULL;
+    struct private_data *priv = conn->privateData;
+    remote_domain_lookup_by_uuid_args args;
+    remote_domain_lookup_by_uuid_ret ret;
+
+    remoteDriverLock(priv);
+
+    memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID,
+             (xdrproc_t)xdr_remote_domain_lookup_by_uuid_args, (char *)&args,
+             (xdrproc_t)xdr_remote_domain_lookup_by_uuid_ret, (char *)&ret) == -1)
+        goto done;
 
-/* remoteDispatchDomainLookupByName has to be implemented manually */
+    rv = get_nonnull_domain(conn, ret.dom);
+    xdr_free((xdrproc_t)xdr_remote_domain_lookup_by_uuid_ret, (char *)&ret);
 
-/* remoteDispatchDomainLookupByUUID has to be implemented manually */
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteDomainManagedSave(virDomainPtr dom, unsigned int flags)
@@ -914,9 +1040,62 @@ done:
     return rv;
 }
 
-/* remoteDispatchDomainSnapshotCreateXML has to be implemented manually */
+static virDomainSnapshotPtr
+remoteDomainSnapshotCreateXML(virDomainPtr dom, const char *xml_desc, unsigned int flags)
+{
+    virDomainSnapshotPtr rv = NULL;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_snapshot_create_xml_args args;
+    remote_domain_snapshot_create_xml_ret ret;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.xml_desc = (char *)xml_desc;
+    args.flags = flags;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_CREATE_XML,
+             (xdrproc_t)xdr_remote_domain_snapshot_create_xml_args, (char *)&args,
+             (xdrproc_t)xdr_remote_domain_snapshot_create_xml_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_domain_snapshot(dom, ret.snap);
+    xdr_free((xdrproc_t)xdr_remote_domain_snapshot_create_xml_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virDomainSnapshotPtr
+remoteDomainSnapshotCurrent(virDomainPtr dom, unsigned int flags)
+{
+    virDomainSnapshotPtr rv = NULL;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_snapshot_current_args args;
+    remote_domain_snapshot_current_ret ret;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.flags = flags;
+
+    memset(&ret, 0, sizeof ret);
 
-/* remoteDispatchDomainSnapshotCurrent has to be implemented manually */
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_CURRENT,
+             (xdrproc_t)xdr_remote_domain_snapshot_current_args, (char *)&args,
+             (xdrproc_t)xdr_remote_domain_snapshot_current_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_domain_snapshot(dom, ret.snap);
+    xdr_free((xdrproc_t)xdr_remote_domain_snapshot_current_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteDomainSnapshotDelete(virDomainSnapshotPtr snap, unsigned int flags)
@@ -971,7 +1150,34 @@ done:
 
 /* remoteDispatchDomainSnapshotListNames has to be implemented manually */
 
-/* remoteDispatchDomainSnapshotLookupByName has to be implemented manually */
+static virDomainSnapshotPtr
+remoteDomainSnapshotLookupByName(virDomainPtr dom, const char *name, unsigned int flags)
+{
+    virDomainSnapshotPtr rv = NULL;
+    struct private_data *priv = dom->conn->privateData;
+    remote_domain_snapshot_lookup_by_name_args args;
+    remote_domain_snapshot_lookup_by_name_ret ret;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain(&args.dom, dom);
+    args.name = (char *)name;
+    args.flags = flags;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LOOKUP_BY_NAME,
+             (xdrproc_t)xdr_remote_domain_snapshot_lookup_by_name_args, (char *)&args,
+             (xdrproc_t)xdr_remote_domain_snapshot_lookup_by_name_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_domain_snapshot(dom, ret.snap);
+    xdr_free((xdrproc_t)xdr_remote_domain_snapshot_lookup_by_name_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteDomainSnapshotNum(virDomainPtr dom, unsigned int flags)
@@ -1071,9 +1277,61 @@ done:
     return rv;
 }
 
-/* remoteDispatchDomainXMLFromNative has to be implemented manually */
+static char *
+remoteDomainXMLFromNative(virConnectPtr conn, const char *nativeFormat, const char *nativeConfig, unsigned int flags)
+{
+    char *rv = NULL;
+    struct private_data *priv = conn->privateData;
+    remote_domain_xml_from_native_args args;
+    remote_domain_xml_from_native_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.nativeFormat = (char *)nativeFormat;
+    args.nativeConfig = (char *)nativeConfig;
+    args.flags = flags;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_XML_FROM_NATIVE,
+             (xdrproc_t)xdr_remote_domain_xml_from_native_args, (char *)&args,
+             (xdrproc_t)xdr_remote_domain_xml_from_native_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = ret.domainXml;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static char *
+remoteDomainXMLToNative(virConnectPtr conn, const char *nativeFormat, const char *domainXml, unsigned int flags)
+{
+    char *rv = NULL;
+    struct private_data *priv = conn->privateData;
+    remote_domain_xml_to_native_args args;
+    remote_domain_xml_to_native_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.nativeFormat = (char *)nativeFormat;
+    args.domainXml = (char *)domainXml;
+    args.flags = flags;
 
-/* remoteDispatchDomainXMLToNative has to be implemented manually */
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_XML_TO_NATIVE,
+             (xdrproc_t)xdr_remote_domain_xml_to_native_args, (char *)&args,
+             (xdrproc_t)xdr_remote_domain_xml_to_native_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = ret.nativeConfig;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 /* remoteDispatchFindStoragePoolSources has to be implemented manually */
 
@@ -1125,7 +1383,31 @@ done:
 
 /* remoteDispatchGetLibVersion has to be implemented manually */
 
-/* remoteDispatchGetMaxVcpus has to be implemented manually */
+static int
+remoteGetMaxVcpus(virConnectPtr conn, const char *type)
+{
+    int rv = -1;
+    struct private_data *priv = conn->privateData;
+    remote_get_max_vcpus_args args;
+    remote_get_max_vcpus_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.type = type ? (char **)&type : NULL;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_GET_MAX_VCPUS,
+             (xdrproc_t)xdr_remote_get_max_vcpus_args, (char *)&args,
+             (xdrproc_t)xdr_remote_get_max_vcpus_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = ret.max_vcpus;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static char *
 remoteGetSysinfo(virConnectPtr conn, unsigned int flags)
@@ -1183,7 +1465,33 @@ done:
     return rv;
 }
 
-/* remoteDispatchInterfaceDefineXML has to be implemented manually */
+static virInterfacePtr
+remoteInterfaceDefineXML(virConnectPtr conn, const char *xml, unsigned int flags)
+{
+    virInterfacePtr rv = NULL;
+    struct private_data *priv = conn->interfacePrivateData;
+    remote_interface_define_xml_args args;
+    remote_interface_define_xml_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.xml = (char *)xml;
+    args.flags = flags;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_INTERFACE_DEFINE_XML,
+             (xdrproc_t)xdr_remote_interface_define_xml_args, (char *)&args,
+             (xdrproc_t)xdr_remote_interface_define_xml_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_interface(conn, ret.iface);
+    xdr_free((xdrproc_t)xdr_remote_interface_define_xml_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteInterfaceDestroy(virInterfacePtr iface, unsigned int flags)
@@ -1262,9 +1570,59 @@ done:
     return rv;
 }
 
-/* remoteDispatchInterfaceLookupByMACString has to be implemented manually */
+static virInterfacePtr
+remoteInterfaceLookupByMACString(virConnectPtr conn, const char *mac)
+{
+    virInterfacePtr rv = NULL;
+    struct private_data *priv = conn->interfacePrivateData;
+    remote_interface_lookup_by_mac_string_args args;
+    remote_interface_lookup_by_mac_string_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.mac = (char *)mac;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING,
+             (xdrproc_t)xdr_remote_interface_lookup_by_mac_string_args, (char *)&args,
+             (xdrproc_t)xdr_remote_interface_lookup_by_mac_string_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_interface(conn, ret.iface);
+    xdr_free((xdrproc_t)xdr_remote_interface_lookup_by_mac_string_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virInterfacePtr
+remoteInterfaceLookupByName(virConnectPtr conn, const char *name)
+{
+    virInterfacePtr rv = NULL;
+    struct private_data *priv = conn->interfacePrivateData;
+    remote_interface_lookup_by_name_args args;
+    remote_interface_lookup_by_name_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.name = (char *)name;
+
+    memset(&ret, 0, sizeof ret);
 
-/* remoteDispatchInterfaceLookupByName has to be implemented manually */
+    if (call(conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME,
+             (xdrproc_t)xdr_remote_interface_lookup_by_name_args, (char *)&args,
+             (xdrproc_t)xdr_remote_interface_lookup_by_name_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_interface(conn, ret.iface);
+    xdr_free((xdrproc_t)xdr_remote_interface_lookup_by_name_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteInterfaceUndefine(virInterfacePtr iface)
@@ -1334,9 +1692,59 @@ done:
     return rv;
 }
 
-/* remoteDispatchNetworkCreateXML has to be implemented manually */
+static virNetworkPtr
+remoteNetworkCreateXML(virConnectPtr conn, const char *xml)
+{
+    virNetworkPtr rv = NULL;
+    struct private_data *priv = conn->networkPrivateData;
+    remote_network_create_xml_args args;
+    remote_network_create_xml_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.xml = (char *)xml;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_NETWORK_CREATE_XML,
+             (xdrproc_t)xdr_remote_network_create_xml_args, (char *)&args,
+             (xdrproc_t)xdr_remote_network_create_xml_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_network(conn, ret.net);
+    xdr_free((xdrproc_t)xdr_remote_network_create_xml_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virNetworkPtr
+remoteNetworkDefineXML(virConnectPtr conn, const char *xml)
+{
+    virNetworkPtr rv = NULL;
+    struct private_data *priv = conn->networkPrivateData;
+    remote_network_define_xml_args args;
+    remote_network_define_xml_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.xml = (char *)xml;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_NETWORK_DEFINE_XML,
+             (xdrproc_t)xdr_remote_network_define_xml_args, (char *)&args,
+             (xdrproc_t)xdr_remote_network_define_xml_ret, (char *)&ret) == -1)
+        goto done;
 
-/* remoteDispatchNetworkDefineXML has to be implemented manually */
+    rv = get_nonnull_network(conn, ret.net);
+    xdr_free((xdrproc_t)xdr_remote_network_define_xml_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteNetworkDestroy(virNetworkPtr net)
@@ -1468,9 +1876,59 @@ done:
     return rv;
 }
 
-/* remoteDispatchNetworkLookupByName has to be implemented manually */
+static virNetworkPtr
+remoteNetworkLookupByName(virConnectPtr conn, const char *name)
+{
+    virNetworkPtr rv = NULL;
+    struct private_data *priv = conn->networkPrivateData;
+    remote_network_lookup_by_name_args args;
+    remote_network_lookup_by_name_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.name = (char *)name;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_NETWORK_LOOKUP_BY_NAME,
+             (xdrproc_t)xdr_remote_network_lookup_by_name_args, (char *)&args,
+             (xdrproc_t)xdr_remote_network_lookup_by_name_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_network(conn, ret.net);
+    xdr_free((xdrproc_t)xdr_remote_network_lookup_by_name_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virNetworkPtr
+remoteNetworkLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+    virNetworkPtr rv = NULL;
+    struct private_data *priv = conn->networkPrivateData;
+    remote_network_lookup_by_uuid_args args;
+    remote_network_lookup_by_uuid_ret ret;
+
+    remoteDriverLock(priv);
+
+    memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
 
-/* remoteDispatchNetworkLookupByUUID has to be implemented manually */
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_NETWORK_LOOKUP_BY_UUID,
+             (xdrproc_t)xdr_remote_network_lookup_by_uuid_args, (char *)&args,
+             (xdrproc_t)xdr_remote_network_lookup_by_uuid_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_network(conn, ret.net);
+    xdr_free((xdrproc_t)xdr_remote_network_lookup_by_uuid_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteNetworkSetAutostart(virNetworkPtr net, int autostart)
@@ -1519,7 +1977,33 @@ done:
     return rv;
 }
 
-/* remoteDispatchNodeDeviceCreateXML has to be implemented manually */
+static virNodeDevicePtr
+remoteNodeDeviceCreateXML(virConnectPtr conn, const char *xml_desc, unsigned int flags)
+{
+    virNodeDevicePtr rv = NULL;
+    struct private_data *priv = conn->devMonPrivateData;
+    remote_node_device_create_xml_args args;
+    remote_node_device_create_xml_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.xml_desc = (char *)xml_desc;
+    args.flags = flags;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_NODE_DEVICE_CREATE_XML,
+             (xdrproc_t)xdr_remote_node_device_create_xml_args, (char *)&args,
+             (xdrproc_t)xdr_remote_node_device_create_xml_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_node_device(conn, ret.dev);
+    xdr_free((xdrproc_t)xdr_remote_node_device_create_xml_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteNodeDeviceDestroy(virNodeDevicePtr dev)
@@ -1577,7 +2061,32 @@ done:
 
 /* remoteDispatchNodeDeviceListCaps has to be implemented manually */
 
-/* remoteDispatchNodeDeviceLookupByName has to be implemented manually */
+static virNodeDevicePtr
+remoteNodeDeviceLookupByName(virConnectPtr conn, const char *name)
+{
+    virNodeDevicePtr rv = NULL;
+    struct private_data *priv = conn->devMonPrivateData;
+    remote_node_device_lookup_by_name_args args;
+    remote_node_device_lookup_by_name_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.name = (char *)name;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME,
+             (xdrproc_t)xdr_remote_node_device_lookup_by_name_args, (char *)&args,
+             (xdrproc_t)xdr_remote_node_device_lookup_by_name_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_node_device(conn, ret.dev);
+    xdr_free((xdrproc_t)xdr_remote_node_device_lookup_by_name_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteNodeDeviceNumOfCaps(virNodeDevicePtr dev)
@@ -1611,7 +2120,28 @@ done:
 
 /* remoteDispatchNodeGetCellsFreeMemory has to be implemented manually */
 
-/* remoteDispatchNodeGetFreeMemory has to be implemented manually */
+static unsigned long long
+remoteNodeGetFreeMemory(virConnectPtr conn)
+{
+    unsigned long long rv = 0;
+    struct private_data *priv = conn->privateData;
+    remote_node_get_free_memory_ret ret;
+
+    remoteDriverLock(priv);
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_NODE_GET_FREE_MEMORY,
+             (xdrproc_t)xdr_void, (char *)NULL,
+             (xdrproc_t)xdr_remote_node_get_free_memory_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = ret.freeMem;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 /* remoteDispatchNodeGetInfo has to be implemented manually */
 
@@ -1905,9 +2435,59 @@ done:
     return rv;
 }
 
-/* remoteDispatchNWFilterLookupByName has to be implemented manually */
+static virNWFilterPtr
+remoteNWFilterLookupByName(virConnectPtr conn, const char *name)
+{
+    virNWFilterPtr rv = NULL;
+    struct private_data *priv = conn->nwfilterPrivateData;
+    remote_nwfilter_lookup_by_name_args args;
+    remote_nwfilter_lookup_by_name_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.name = (char *)name;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_NWFILTER_LOOKUP_BY_NAME,
+             (xdrproc_t)xdr_remote_nwfilter_lookup_by_name_args, (char *)&args,
+             (xdrproc_t)xdr_remote_nwfilter_lookup_by_name_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_nwfilter(conn, ret.nwfilter);
+    xdr_free((xdrproc_t)xdr_remote_nwfilter_lookup_by_name_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virNWFilterPtr
+remoteNWFilterLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+    virNWFilterPtr rv = NULL;
+    struct private_data *priv = conn->nwfilterPrivateData;
+    remote_nwfilter_lookup_by_uuid_args args;
+    remote_nwfilter_lookup_by_uuid_ret ret;
+
+    remoteDriverLock(priv);
+
+    memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_NWFILTER_LOOKUP_BY_UUID,
+             (xdrproc_t)xdr_remote_nwfilter_lookup_by_uuid_args, (char *)&args,
+             (xdrproc_t)xdr_remote_nwfilter_lookup_by_uuid_ret, (char *)&ret) == -1)
+        goto done;
 
-/* remoteDispatchNWFilterLookupByUUID has to be implemented manually */
+    rv = get_nonnull_nwfilter(conn, ret.nwfilter);
+    xdr_free((xdrproc_t)xdr_remote_nwfilter_lookup_by_uuid_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteNWFilterUndefine(virNWFilterPtr nwfilter)
@@ -1934,7 +2514,33 @@ done:
 
 /* remoteDispatchOpen has to be implemented manually */
 
-/* remoteDispatchSecretDefineXML has to be implemented manually */
+static virSecretPtr
+remoteSecretDefineXML(virConnectPtr conn, const char *xml, unsigned int flags)
+{
+    virSecretPtr rv = NULL;
+    struct private_data *priv = conn->secretPrivateData;
+    remote_secret_define_xml_args args;
+    remote_secret_define_xml_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.xml = (char *)xml;
+    args.flags = flags;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_SECRET_DEFINE_XML,
+             (xdrproc_t)xdr_remote_secret_define_xml_args, (char *)&args,
+             (xdrproc_t)xdr_remote_secret_define_xml_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_secret(conn, ret.secret);
+    xdr_free((xdrproc_t)xdr_remote_secret_define_xml_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 /* remoteDispatchSecretGetValue has to be implemented manually */
 
@@ -1965,9 +2571,60 @@ done:
     return rv;
 }
 
-/* remoteDispatchSecretLookupByUsage has to be implemented manually */
+static virSecretPtr
+remoteSecretLookupByUsage(virConnectPtr conn, int usageType, const char *usageID)
+{
+    virSecretPtr rv = NULL;
+    struct private_data *priv = conn->secretPrivateData;
+    remote_secret_lookup_by_usage_args args;
+    remote_secret_lookup_by_usage_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.usageType = usageType;
+    args.usageID = (char *)usageID;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_SECRET_LOOKUP_BY_USAGE,
+             (xdrproc_t)xdr_remote_secret_lookup_by_usage_args, (char *)&args,
+             (xdrproc_t)xdr_remote_secret_lookup_by_usage_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_secret(conn, ret.secret);
+    xdr_free((xdrproc_t)xdr_remote_secret_lookup_by_usage_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virSecretPtr
+remoteSecretLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+    virSecretPtr rv = NULL;
+    struct private_data *priv = conn->secretPrivateData;
+    remote_secret_lookup_by_uuid_args args;
+    remote_secret_lookup_by_uuid_ret ret;
+
+    remoteDriverLock(priv);
+
+    memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_SECRET_LOOKUP_BY_UUID,
+             (xdrproc_t)xdr_remote_secret_lookup_by_uuid_args, (char *)&args,
+             (xdrproc_t)xdr_remote_secret_lookup_by_uuid_ret, (char *)&ret) == -1)
+        goto done;
 
-/* remoteDispatchSecretLookupByUUID has to be implemented manually */
+    rv = get_nonnull_secret(conn, ret.secret);
+    xdr_free((xdrproc_t)xdr_remote_secret_lookup_by_uuid_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 /* remoteDispatchSecretSetValue has to be implemented manually */
 
@@ -2042,9 +2699,61 @@ done:
     return rv;
 }
 
-/* remoteDispatchStoragePoolCreateXML has to be implemented manually */
+static virStoragePoolPtr
+remoteStoragePoolCreateXML(virConnectPtr conn, const char *xml, unsigned int flags)
+{
+    virStoragePoolPtr rv = NULL;
+    struct private_data *priv = conn->storagePrivateData;
+    remote_storage_pool_create_xml_args args;
+    remote_storage_pool_create_xml_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.xml = (char *)xml;
+    args.flags = flags;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_STORAGE_POOL_CREATE_XML,
+             (xdrproc_t)xdr_remote_storage_pool_create_xml_args, (char *)&args,
+             (xdrproc_t)xdr_remote_storage_pool_create_xml_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_storage_pool(conn, ret.pool);
+    xdr_free((xdrproc_t)xdr_remote_storage_pool_create_xml_ret, (char *)&ret);
 
-/* remoteDispatchStoragePoolDefineXML has to be implemented manually */
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virStoragePoolPtr
+remoteStoragePoolDefineXML(virConnectPtr conn, const char *xml, unsigned int flags)
+{
+    virStoragePoolPtr rv = NULL;
+    struct private_data *priv = conn->storagePrivateData;
+    remote_storage_pool_define_xml_args args;
+    remote_storage_pool_define_xml_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.xml = (char *)xml;
+    args.flags = flags;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DEFINE_XML,
+             (xdrproc_t)xdr_remote_storage_pool_define_xml_args, (char *)&args,
+             (xdrproc_t)xdr_remote_storage_pool_define_xml_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_storage_pool(conn, ret.pool);
+    xdr_free((xdrproc_t)xdr_remote_storage_pool_define_xml_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteStoragePoolDelete(virStoragePoolPtr pool, unsigned int flags)
@@ -2178,11 +2887,86 @@ done:
 
 /* remoteDispatchStoragePoolListVolumes has to be implemented manually */
 
-/* remoteDispatchStoragePoolLookupByName has to be implemented manually */
+static virStoragePoolPtr
+remoteStoragePoolLookupByName(virConnectPtr conn, const char *name)
+{
+    virStoragePoolPtr rv = NULL;
+    struct private_data *priv = conn->storagePrivateData;
+    remote_storage_pool_lookup_by_name_args args;
+    remote_storage_pool_lookup_by_name_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.name = (char *)name;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME,
+             (xdrproc_t)xdr_remote_storage_pool_lookup_by_name_args, (char *)&args,
+             (xdrproc_t)xdr_remote_storage_pool_lookup_by_name_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_storage_pool(conn, ret.pool);
+    xdr_free((xdrproc_t)xdr_remote_storage_pool_lookup_by_name_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virStoragePoolPtr
+remoteStoragePoolLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+    virStoragePoolPtr rv = NULL;
+    struct private_data *priv = conn->storagePrivateData;
+    remote_storage_pool_lookup_by_uuid_args args;
+    remote_storage_pool_lookup_by_uuid_ret ret;
+
+    remoteDriverLock(priv);
+
+    memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
 
-/* remoteDispatchStoragePoolLookupByUUID has to be implemented manually */
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID,
+             (xdrproc_t)xdr_remote_storage_pool_lookup_by_uuid_args, (char *)&args,
+             (xdrproc_t)xdr_remote_storage_pool_lookup_by_uuid_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_storage_pool(conn, ret.pool);
+    xdr_free((xdrproc_t)xdr_remote_storage_pool_lookup_by_uuid_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virStoragePoolPtr
+remoteStoragePoolLookupByVolume(virStorageVolPtr vol)
+{
+    virStoragePoolPtr rv = NULL;
+    struct private_data *priv = vol->conn->storagePrivateData;
+    remote_storage_pool_lookup_by_volume_args args;
+    remote_storage_pool_lookup_by_volume_ret ret;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_vol(&args.vol, vol);
+
+    memset(&ret, 0, sizeof ret);
 
-/* remoteDispatchStoragePoolLookupByVolume has to be implemented manually */
+    if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME,
+             (xdrproc_t)xdr_remote_storage_pool_lookup_by_volume_args, (char *)&args,
+             (xdrproc_t)xdr_remote_storage_pool_lookup_by_volume_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_storage_pool(vol->conn, ret.pool);
+    xdr_free((xdrproc_t)xdr_remote_storage_pool_lookup_by_volume_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteStoragePoolNumOfVolumes(virStoragePoolPtr pool)
@@ -2281,9 +3065,64 @@ done:
     return rv;
 }
 
-/* remoteDispatchStorageVolCreateXML has to be implemented manually */
+static virStorageVolPtr
+remoteStorageVolCreateXML(virStoragePoolPtr pool, const char *xml, unsigned int flags)
+{
+    virStorageVolPtr rv = NULL;
+    struct private_data *priv = pool->conn->storagePrivateData;
+    remote_storage_vol_create_xml_args args;
+    remote_storage_vol_create_xml_ret ret;
+
+    remoteDriverLock(priv);
 
-/* remoteDispatchStorageVolCreateXMLFrom has to be implemented manually */
+    make_nonnull_storage_pool(&args.pool, pool);
+    args.xml = (char *)xml;
+    args.flags = flags;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_CREATE_XML,
+             (xdrproc_t)xdr_remote_storage_vol_create_xml_args, (char *)&args,
+             (xdrproc_t)xdr_remote_storage_vol_create_xml_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_storage_vol(pool->conn, ret.vol);
+    xdr_free((xdrproc_t)xdr_remote_storage_vol_create_xml_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virStorageVolPtr
+remoteStorageVolCreateXMLFrom(virStoragePoolPtr pool, const char *xml, virStorageVolPtr clonevol, unsigned int flags)
+{
+    virStorageVolPtr rv = NULL;
+    struct private_data *priv = pool->conn->storagePrivateData;
+    remote_storage_vol_create_xml_from_args args;
+    remote_storage_vol_create_xml_from_ret ret;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_pool(&args.pool, pool);
+    args.xml = (char *)xml;
+    make_nonnull_storage_vol(&args.clonevol, clonevol);
+    args.flags = flags;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM,
+             (xdrproc_t)xdr_remote_storage_vol_create_xml_from_args, (char *)&args,
+             (xdrproc_t)xdr_remote_storage_vol_create_xml_from_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_storage_vol(pool->conn, ret.vol);
+    xdr_free((xdrproc_t)xdr_remote_storage_vol_create_xml_from_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 static int
 remoteStorageVolDelete(virStorageVolPtr vol, unsigned int flags)
@@ -2366,11 +3205,87 @@ done:
     return rv;
 }
 
-/* remoteDispatchStorageVolLookupByKey has to be implemented manually */
+static virStorageVolPtr
+remoteStorageVolLookupByKey(virConnectPtr conn, const char *key)
+{
+    virStorageVolPtr rv = NULL;
+    struct private_data *priv = conn->storagePrivateData;
+    remote_storage_vol_lookup_by_key_args args;
+    remote_storage_vol_lookup_by_key_ret ret;
+
+    remoteDriverLock(priv);
 
-/* remoteDispatchStorageVolLookupByName has to be implemented manually */
+    args.key = (char *)key;
 
-/* remoteDispatchStorageVolLookupByPath has to be implemented manually */
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY,
+             (xdrproc_t)xdr_remote_storage_vol_lookup_by_key_args, (char *)&args,
+             (xdrproc_t)xdr_remote_storage_vol_lookup_by_key_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_storage_vol(conn, ret.vol);
+    xdr_free((xdrproc_t)xdr_remote_storage_vol_lookup_by_key_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virStorageVolPtr
+remoteStorageVolLookupByName(virStoragePoolPtr pool, const char *name)
+{
+    virStorageVolPtr rv = NULL;
+    struct private_data *priv = pool->conn->storagePrivateData;
+    remote_storage_vol_lookup_by_name_args args;
+    remote_storage_vol_lookup_by_name_ret ret;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_pool(&args.pool, pool);
+    args.name = (char *)name;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME,
+             (xdrproc_t)xdr_remote_storage_vol_lookup_by_name_args, (char *)&args,
+             (xdrproc_t)xdr_remote_storage_vol_lookup_by_name_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_storage_vol(pool->conn, ret.vol);
+    xdr_free((xdrproc_t)xdr_remote_storage_vol_lookup_by_name_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static virStorageVolPtr
+remoteStorageVolLookupByPath(virConnectPtr conn, const char *path)
+{
+    virStorageVolPtr rv = NULL;
+    struct private_data *priv = conn->storagePrivateData;
+    remote_storage_vol_lookup_by_path_args args;
+    remote_storage_vol_lookup_by_path_ret ret;
+
+    remoteDriverLock(priv);
+
+    args.path = (char *)path;
+
+    memset(&ret, 0, sizeof ret);
+
+    if (call(conn, priv, 0, REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH,
+             (xdrproc_t)xdr_remote_storage_vol_lookup_by_path_args, (char *)&args,
+             (xdrproc_t)xdr_remote_storage_vol_lookup_by_path_ret, (char *)&ret) == -1)
+        goto done;
+
+    rv = get_nonnull_storage_vol(conn, ret.vol);
+    xdr_free((xdrproc_t)xdr_remote_storage_vol_lookup_by_path_ret, (char *)&ret);
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
 
 /* remoteDispatchStorageVolUpload has to be implemented manually */
 
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index a67f9f6..79ebfb3 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -1810,31 +1810,6 @@ done:
     return rv;
 }
 
-
-static int
-remoteGetMaxVcpus (virConnectPtr conn, const char *type)
-{
-    int rv = -1;
-    remote_get_max_vcpus_args args;
-    remote_get_max_vcpus_ret ret;
-    struct private_data *priv = conn->privateData;
-
-    remoteDriverLock(priv);
-
-    memset (&ret, 0, sizeof ret);
-    args.type = type == NULL ? NULL : (char **) &type;
-    if (call (conn, priv, 0, REMOTE_PROC_GET_MAX_VCPUS,
-              (xdrproc_t) xdr_remote_get_max_vcpus_args, (char *) &args,
-              (xdrproc_t) xdr_remote_get_max_vcpus_ret, (char *) &ret) == -1)
-        goto done;
-
-    rv = ret.max_vcpus;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
 static int
 remoteNodeGetInfo (virConnectPtr conn, virNodeInfoPtr info)
 {
@@ -1908,29 +1883,6 @@ done:
     return rv;
 }
 
-static unsigned long long
-remoteNodeGetFreeMemory (virConnectPtr conn)
-{
-    unsigned long long rv = 0; /* 0 is error value this special function*/
-    remote_node_get_free_memory_ret ret;
-    struct private_data *priv = conn->privateData;
-
-    remoteDriverLock(priv);
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_NODE_GET_FREE_MEMORY,
-              (xdrproc_t) xdr_void, NULL,
-              (xdrproc_t) xdr_remote_node_get_free_memory_ret, (char *)&ret) == -1)
-        goto done;
-
-    rv = ret.freeMem;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-
 static int
 remoteListDomains (virConnectPtr conn, int *ids, int maxids)
 {
@@ -1976,113 +1928,6 @@ done:
     return rv;
 }
 
-static virDomainPtr
-remoteDomainCreateXML (virConnectPtr conn,
-                         const char *xmlDesc,
-                         unsigned int flags)
-{
-    virDomainPtr dom = NULL;
-    remote_domain_create_xml_args args;
-    remote_domain_create_xml_ret ret;
-    struct private_data *priv = conn->privateData;
-
-    remoteDriverLock(priv);
-
-    args.xml_desc = (char *) xmlDesc;
-    args.flags = flags;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_CREATE_XML,
-              (xdrproc_t) xdr_remote_domain_create_xml_args, (char *) &args,
-              (xdrproc_t) xdr_remote_domain_create_xml_ret, (char *) &ret) == -1)
-        goto done;
-
-    dom = get_nonnull_domain (conn, ret.dom);
-    xdr_free ((xdrproc_t) &xdr_remote_domain_create_xml_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return dom;
-}
-
-static virDomainPtr
-remoteDomainLookupByID (virConnectPtr conn, int id)
-{
-    virDomainPtr dom = NULL;
-    remote_domain_lookup_by_id_args args;
-    remote_domain_lookup_by_id_ret ret;
-    struct private_data *priv = conn->privateData;
-
-    remoteDriverLock(priv);
-
-    args.id = id;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_ID,
-              (xdrproc_t) xdr_remote_domain_lookup_by_id_args, (char *) &args,
-              (xdrproc_t) xdr_remote_domain_lookup_by_id_ret, (char *) &ret) == -1)
-        goto done;
-
-    dom = get_nonnull_domain (conn, ret.dom);
-    xdr_free ((xdrproc_t) &xdr_remote_domain_lookup_by_id_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return dom;
-}
-
-static virDomainPtr
-remoteDomainLookupByUUID (virConnectPtr conn, const unsigned char *uuid)
-{
-    virDomainPtr dom = NULL;
-    remote_domain_lookup_by_uuid_args args;
-    remote_domain_lookup_by_uuid_ret ret;
-    struct private_data *priv = conn->privateData;
-
-    remoteDriverLock(priv);
-
-    memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID,
-              (xdrproc_t) xdr_remote_domain_lookup_by_uuid_args, (char *) &args,
-              (xdrproc_t) xdr_remote_domain_lookup_by_uuid_ret, (char *) &ret) == -1)
-        goto done;
-
-    dom = get_nonnull_domain (conn, ret.dom);
-    xdr_free ((xdrproc_t) &xdr_remote_domain_lookup_by_uuid_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return dom;
-}
-
-static virDomainPtr
-remoteDomainLookupByName (virConnectPtr conn, const char *name)
-{
-    virDomainPtr dom = NULL;
-    remote_domain_lookup_by_name_args args;
-    remote_domain_lookup_by_name_ret ret;
-    struct private_data *priv = conn->privateData;
-
-    remoteDriverLock(priv);
-
-    args.name = (char *) name;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME,
-              (xdrproc_t) xdr_remote_domain_lookup_by_name_args, (char *) &args,
-              (xdrproc_t) xdr_remote_domain_lookup_by_name_ret, (char *) &ret) == -1)
-        goto done;
-
-    dom = get_nonnull_domain (conn, ret.dom);
-    xdr_free ((xdrproc_t) &xdr_remote_domain_lookup_by_name_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return dom;
-}
-
 static int
 remoteDomainDestroy (virDomainPtr domain)
 {
@@ -2666,68 +2511,6 @@ done:
     return rv;
 }
 
-static char *
-remoteDomainXMLFromNative (virConnectPtr conn,
-                           const char *format,
-                           const char *config,
-                           unsigned int flags)
-{
-    char *rv = NULL;
-    remote_domain_xml_from_native_args args;
-    remote_domain_xml_from_native_ret ret;
-    struct private_data *priv = conn->privateData;
-
-    remoteDriverLock(priv);
-
-    args.nativeFormat = (char *)format;
-    args.nativeConfig = (char *)config;
-    args.flags = flags;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_XML_FROM_NATIVE,
-              (xdrproc_t) xdr_remote_domain_xml_from_native_args, (char *) &args,
-              (xdrproc_t) xdr_remote_domain_xml_from_native_ret, (char *) &ret) == -1)
-        goto done;
-
-    /* Caller frees. */
-    rv = ret.domainXml;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
-static char *
-remoteDomainXMLToNative (virConnectPtr conn,
-                         const char *format,
-                         const char *xml,
-                         unsigned int flags)
-{
-    char *rv = NULL;
-    remote_domain_xml_to_native_args args;
-    remote_domain_xml_to_native_ret ret;
-    struct private_data *priv = conn->privateData;
-
-    remoteDriverLock(priv);
-
-    args.nativeFormat = (char *)format;
-    args.domainXml = (char *)xml;
-    args.flags = flags;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_XML_TO_NATIVE,
-              (xdrproc_t) xdr_remote_domain_xml_to_native_args, (char *) &args,
-              (xdrproc_t) xdr_remote_domain_xml_to_native_ret, (char *) &ret) == -1)
-        goto done;
-
-    /* Caller frees. */
-    rv = ret.nativeConfig;
-
-done:
-    remoteDriverUnlock(priv);
-    return rv;
-}
-
 static int
 remoteDomainMigratePrepare (virConnectPtr dconn,
                             char **cookie, int *cookielen,
@@ -3062,32 +2845,6 @@ done:
     return rv;
 }
 
-static virDomainPtr
-remoteDomainDefineXML (virConnectPtr conn, const char *xml)
-{
-    virDomainPtr dom = NULL;
-    remote_domain_define_xml_args args;
-    remote_domain_define_xml_ret ret;
-    struct private_data *priv = conn->privateData;
-
-    remoteDriverLock(priv);
-
-    args.xml = (char *) xml;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_DEFINE_XML,
-              (xdrproc_t) xdr_remote_domain_define_xml_args, (char *) &args,
-              (xdrproc_t) xdr_remote_domain_define_xml_ret, (char *) &ret) == -1)
-        goto done;
-
-    dom = get_nonnull_domain (conn, ret.dom);
-    xdr_free ((xdrproc_t) xdr_remote_domain_define_xml_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return dom;
-}
-
 static int
 remoteDomainGetAutostart (virDomainPtr domain, int *autostart)
 {
@@ -3711,112 +3468,6 @@ done:
     return rv;
 }
 
-static virNetworkPtr
-remoteNetworkLookupByUUID (virConnectPtr conn,
-                           const unsigned char *uuid)
-{
-    virNetworkPtr net = NULL;
-    remote_network_lookup_by_uuid_args args;
-    remote_network_lookup_by_uuid_ret ret;
-    struct private_data *priv = conn->networkPrivateData;
-
-    remoteDriverLock(priv);
-
-    memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_NETWORK_LOOKUP_BY_UUID,
-              (xdrproc_t) xdr_remote_network_lookup_by_uuid_args, (char *) &args,
-              (xdrproc_t) xdr_remote_network_lookup_by_uuid_ret, (char *) &ret) == -1)
-        goto done;
-
-    net = get_nonnull_network (conn, ret.net);
-    xdr_free ((xdrproc_t) &xdr_remote_network_lookup_by_uuid_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return net;
-}
-
-static virNetworkPtr
-remoteNetworkLookupByName (virConnectPtr conn,
-                           const char *name)
-{
-    virNetworkPtr net = NULL;
-    remote_network_lookup_by_name_args args;
-    remote_network_lookup_by_name_ret ret;
-    struct private_data *priv = conn->networkPrivateData;
-
-    remoteDriverLock(priv);
-
-    args.name = (char *) name;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_NETWORK_LOOKUP_BY_NAME,
-              (xdrproc_t) xdr_remote_network_lookup_by_name_args, (char *) &args,
-              (xdrproc_t) xdr_remote_network_lookup_by_name_ret, (char *) &ret) == -1)
-        goto done;
-
-    net = get_nonnull_network (conn, ret.net);
-    xdr_free ((xdrproc_t) &xdr_remote_network_lookup_by_name_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return net;
-}
-
-static virNetworkPtr
-remoteNetworkCreateXML (virConnectPtr conn, const char *xmlDesc)
-{
-    virNetworkPtr net = NULL;
-    remote_network_create_xml_args args;
-    remote_network_create_xml_ret ret;
-    struct private_data *priv = conn->networkPrivateData;
-
-    remoteDriverLock(priv);
-
-    args.xml = (char *) xmlDesc;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_NETWORK_CREATE_XML,
-              (xdrproc_t) xdr_remote_network_create_xml_args, (char *) &args,
-              (xdrproc_t) xdr_remote_network_create_xml_ret, (char *) &ret) == -1)
-        goto done;
-
-    net = get_nonnull_network (conn, ret.net);
-    xdr_free ((xdrproc_t) &xdr_remote_network_create_xml_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return net;
-}
-
-static virNetworkPtr
-remoteNetworkDefineXML (virConnectPtr conn, const char *xml)
-{
-    virNetworkPtr net = NULL;
-    remote_network_define_xml_args args;
-    remote_network_define_xml_ret ret;
-    struct private_data *priv = conn->networkPrivateData;
-
-    remoteDriverLock(priv);
-
-    args.xml = (char *) xml;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_NETWORK_DEFINE_XML,
-              (xdrproc_t) xdr_remote_network_define_xml_args, (char *) &args,
-              (xdrproc_t) xdr_remote_network_define_xml_ret, (char *) &ret) == -1)
-        goto done;
-
-    net = get_nonnull_network (conn, ret.net);
-    xdr_free ((xdrproc_t) &xdr_remote_network_define_xml_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return net;
-}
-
 static int
 remoteNetworkGetAutostart (virNetworkPtr network, int *autostart)
 {
@@ -4024,89 +3675,6 @@ done:
     return rv;
 }
 
-static virInterfacePtr
-remoteInterfaceLookupByName (virConnectPtr conn,
-                             const char *name)
-{
-    virInterfacePtr iface = NULL;
-    remote_interface_lookup_by_name_args args;
-    remote_interface_lookup_by_name_ret ret;
-    struct private_data *priv = conn->interfacePrivateData;
-
-    remoteDriverLock(priv);
-
-    args.name = (char *) name;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME,
-              (xdrproc_t) xdr_remote_interface_lookup_by_name_args, (char *) &args,
-              (xdrproc_t) xdr_remote_interface_lookup_by_name_ret, (char *) &ret) == -1)
-        goto done;
-
-    iface = get_nonnull_interface (conn, ret.iface);
-    xdr_free ((xdrproc_t) &xdr_remote_interface_lookup_by_name_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return iface;
-}
-
-static virInterfacePtr
-remoteInterfaceLookupByMACString (virConnectPtr conn,
-                                  const char *mac)
-{
-    virInterfacePtr iface = NULL;
-    remote_interface_lookup_by_mac_string_args args;
-    remote_interface_lookup_by_mac_string_ret ret;
-    struct private_data *priv = conn->interfacePrivateData;
-
-    remoteDriverLock(priv);
-
-    args.mac = (char *) mac;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING,
-              (xdrproc_t) xdr_remote_interface_lookup_by_mac_string_args, (char *) &args,
-              (xdrproc_t) xdr_remote_interface_lookup_by_mac_string_ret, (char *) &ret) == -1)
-        goto done;
-
-    iface = get_nonnull_interface (conn, ret.iface);
-    xdr_free ((xdrproc_t) &xdr_remote_interface_lookup_by_mac_string_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return iface;
-}
-
-static virInterfacePtr
-remoteInterfaceDefineXML (virConnectPtr conn,
-                          const char *xmlDesc,
-                          unsigned int flags)
-{
-    virInterfacePtr iface = NULL;
-    remote_interface_define_xml_args args;
-    remote_interface_define_xml_ret ret;
-    struct private_data *priv = conn->interfacePrivateData;
-
-    remoteDriverLock(priv);
-
-    args.xml = (char *) xmlDesc;
-    args.flags = flags;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_INTERFACE_DEFINE_XML,
-              (xdrproc_t) xdr_remote_interface_define_xml_args, (char *) &args,
-              (xdrproc_t) xdr_remote_interface_define_xml_ret, (char *) &ret) == -1)
-        goto done;
-
-    iface = get_nonnull_interface (conn, ret.iface);
-    xdr_free ((xdrproc_t) &xdr_remote_interface_define_xml_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return iface;
-}
-
 /*----------------------------------------------------------------------*/
 
 static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -4332,140 +3900,6 @@ done:
     return rv;
 }
 
-static virStoragePoolPtr
-remoteStoragePoolLookupByUUID (virConnectPtr conn,
-                               const unsigned char *uuid)
-{
-    virStoragePoolPtr pool = NULL;
-    remote_storage_pool_lookup_by_uuid_args args;
-    remote_storage_pool_lookup_by_uuid_ret ret;
-    struct private_data *priv = conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID,
-              (xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_args, (char *) &args,
-              (xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_ret, (char *) &ret) == -1)
-        goto done;
-
-    pool = get_nonnull_storage_pool (conn, ret.pool);
-    xdr_free ((xdrproc_t) &xdr_remote_storage_pool_lookup_by_uuid_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return pool;
-}
-
-static virStoragePoolPtr
-remoteStoragePoolLookupByName (virConnectPtr conn,
-                               const char *name)
-{
-    virStoragePoolPtr pool = NULL;
-    remote_storage_pool_lookup_by_name_args args;
-    remote_storage_pool_lookup_by_name_ret ret;
-    struct private_data *priv = conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    args.name = (char *) name;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME,
-              (xdrproc_t) xdr_remote_storage_pool_lookup_by_name_args, (char *) &args,
-              (xdrproc_t) xdr_remote_storage_pool_lookup_by_name_ret, (char *) &ret) == -1)
-        goto done;
-
-    pool = get_nonnull_storage_pool (conn, ret.pool);
-    xdr_free ((xdrproc_t) &xdr_remote_storage_pool_lookup_by_name_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return pool;
-}
-
-static virStoragePoolPtr
-remoteStoragePoolLookupByVolume (virStorageVolPtr vol)
-{
-    virStoragePoolPtr pool = NULL;
-    remote_storage_pool_lookup_by_volume_args args;
-    remote_storage_pool_lookup_by_volume_ret ret;
-    struct private_data *priv = vol->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_vol (&args.vol, vol);
-
-    memset (&ret, 0, sizeof ret);
-    if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME,
-              (xdrproc_t) xdr_remote_storage_pool_lookup_by_volume_args, (char *) &args,
-              (xdrproc_t) xdr_remote_storage_pool_lookup_by_volume_ret, (char *) &ret) == -1)
-        goto done;
-
-    pool = get_nonnull_storage_pool (vol->conn, ret.pool);
-    xdr_free ((xdrproc_t) &xdr_remote_storage_pool_lookup_by_volume_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return pool;
-}
-
-static virStoragePoolPtr
-remoteStoragePoolCreateXML (virConnectPtr conn, const char *xmlDesc, unsigned int flags)
-{
-    virStoragePoolPtr pool = NULL;
-    remote_storage_pool_create_xml_args args;
-    remote_storage_pool_create_xml_ret ret;
-    struct private_data *priv = conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    args.xml = (char *) xmlDesc;
-    args.flags = flags;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_STORAGE_POOL_CREATE_XML,
-              (xdrproc_t) xdr_remote_storage_pool_create_xml_args, (char *) &args,
-              (xdrproc_t) xdr_remote_storage_pool_create_xml_ret, (char *) &ret) == -1)
-        goto done;
-
-    pool = get_nonnull_storage_pool (conn, ret.pool);
-    xdr_free ((xdrproc_t) &xdr_remote_storage_pool_create_xml_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return pool;
-}
-
-static virStoragePoolPtr
-remoteStoragePoolDefineXML (virConnectPtr conn, const char *xml, unsigned int flags)
-{
-    virStoragePoolPtr pool = NULL;
-    remote_storage_pool_define_xml_args args;
-    remote_storage_pool_define_xml_ret ret;
-    struct private_data *priv = conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    args.xml = (char *) xml;
-    args.flags = flags;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DEFINE_XML,
-              (xdrproc_t) xdr_remote_storage_pool_define_xml_args, (char *) &args,
-              (xdrproc_t) xdr_remote_storage_pool_define_xml_ret, (char *) &ret) == -1)
-        goto done;
-
-    pool = get_nonnull_storage_pool (conn, ret.pool);
-    xdr_free ((xdrproc_t) &xdr_remote_storage_pool_define_xml_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return pool;
-}
-
 static int
 remoteStoragePoolGetInfo (virStoragePoolPtr pool, virStoragePoolInfoPtr info)
 {
@@ -4580,151 +4014,6 @@ done:
     return rv;
 }
 
-
-
-static virStorageVolPtr
-remoteStorageVolLookupByName (virStoragePoolPtr pool,
-                              const char *name)
-{
-    virStorageVolPtr vol = NULL;
-    remote_storage_vol_lookup_by_name_args args;
-    remote_storage_vol_lookup_by_name_ret ret;
-    struct private_data *priv = pool->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_pool(&args.pool, pool);
-    args.name = (char *) name;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME,
-              (xdrproc_t) xdr_remote_storage_vol_lookup_by_name_args, (char *) &args,
-              (xdrproc_t) xdr_remote_storage_vol_lookup_by_name_ret, (char *) &ret) == -1)
-        goto done;
-
-    vol = get_nonnull_storage_vol (pool->conn, ret.vol);
-    xdr_free ((xdrproc_t) &xdr_remote_storage_vol_lookup_by_name_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return vol;
-}
-
-static virStorageVolPtr
-remoteStorageVolLookupByKey (virConnectPtr conn,
-                             const char *key)
-{
-    virStorageVolPtr  vol = NULL;
-    remote_storage_vol_lookup_by_key_args args;
-    remote_storage_vol_lookup_by_key_ret ret;
-    struct private_data *priv = conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    args.key = (char *) key;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY,
-              (xdrproc_t) xdr_remote_storage_vol_lookup_by_key_args, (char *) &args,
-              (xdrproc_t) xdr_remote_storage_vol_lookup_by_key_ret, (char *) &ret) == -1)
-        goto done;
-
-    vol = get_nonnull_storage_vol (conn, ret.vol);
-    xdr_free ((xdrproc_t) &xdr_remote_storage_vol_lookup_by_key_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return vol;
-}
-
-static virStorageVolPtr
-remoteStorageVolLookupByPath (virConnectPtr conn,
-                              const char *path)
-{
-    virStorageVolPtr vol = NULL;
-    remote_storage_vol_lookup_by_path_args args;
-    remote_storage_vol_lookup_by_path_ret ret;
-    struct private_data *priv = conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    args.path = (char *) path;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH,
-              (xdrproc_t) xdr_remote_storage_vol_lookup_by_path_args, (char *) &args,
-              (xdrproc_t) xdr_remote_storage_vol_lookup_by_path_ret, (char *) &ret) == -1)
-        goto done;
-
-    vol = get_nonnull_storage_vol (conn, ret.vol);
-    xdr_free ((xdrproc_t) &xdr_remote_storage_vol_lookup_by_path_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return vol;
-}
-
-static virStorageVolPtr
-remoteStorageVolCreateXML (virStoragePoolPtr pool, const char *xmlDesc,
-                           unsigned int flags)
-{
-    virStorageVolPtr vol = NULL;
-    remote_storage_vol_create_xml_args args;
-    remote_storage_vol_create_xml_ret ret;
-    struct private_data *priv = pool->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_pool (&args.pool, pool);
-    args.xml = (char *) xmlDesc;
-    args.flags = flags;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_CREATE_XML,
-              (xdrproc_t) xdr_remote_storage_vol_create_xml_args, (char *) &args,
-              (xdrproc_t) xdr_remote_storage_vol_create_xml_ret, (char *) &ret) == -1)
-        goto done;
-
-    vol = get_nonnull_storage_vol (pool->conn, ret.vol);
-    xdr_free ((xdrproc_t) &xdr_remote_storage_vol_create_xml_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return vol;
-}
-
-static virStorageVolPtr
-remoteStorageVolCreateXMLFrom (virStoragePoolPtr pool,
-                               const char *xmlDesc,
-                               virStorageVolPtr clonevol,
-                               unsigned int flags)
-{
-    virStorageVolPtr newvol = NULL;
-    remote_storage_vol_create_xml_from_args args;
-    remote_storage_vol_create_xml_from_ret ret;
-    struct private_data *priv = pool->conn->storagePrivateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_storage_pool (&args.pool, pool);
-    make_nonnull_storage_vol (&args.clonevol, clonevol);
-    args.xml = (char *) xmlDesc;
-    args.flags = flags;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM,
-              (xdrproc_t) xdr_remote_storage_vol_create_xml_from_args, (char *) &args,
-              (xdrproc_t) xdr_remote_storage_vol_create_xml_from_ret, (char *) &ret) == -1)
-        goto done;
-
-    newvol = get_nonnull_storage_vol (pool->conn, ret.vol);
-    xdr_free ((xdrproc_t) &xdr_remote_storage_vol_create_xml_from_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return newvol;
-}
-
 static int
 remoteStorageVolGetInfo (virStorageVolPtr vol, virStorageVolInfoPtr info)
 {
@@ -4881,34 +4170,6 @@ done:
     return rv;
 }
 
-
-static virNodeDevicePtr remoteNodeDeviceLookupByName(virConnectPtr conn,
-                                                     const char *name)
-{
-    remote_node_device_lookup_by_name_args args;
-    remote_node_device_lookup_by_name_ret ret;
-    virNodeDevicePtr dev = NULL;
-    struct private_data *priv = conn->devMonPrivateData;
-
-    remoteDriverLock(priv);
-
-    args.name = (char *)name;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME,
-              (xdrproc_t) xdr_remote_node_device_lookup_by_name_args, (char *) &args,
-              (xdrproc_t) xdr_remote_node_device_lookup_by_name_ret, (char *) &ret) == -1)
-        goto done;
-
-    dev = get_nonnull_node_device(conn, ret.dev);
-
-    xdr_free ((xdrproc_t) xdr_remote_node_device_lookup_by_name_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return dev;
-}
-
 static char *remoteNodeDeviceGetParent(virNodeDevicePtr dev)
 {
     char *rv = NULL;
@@ -5067,36 +4328,6 @@ done:
     return rv;
 }
 
-
-static virNodeDevicePtr
-remoteNodeDeviceCreateXML(virConnectPtr conn,
-                          const char *xmlDesc,
-                          unsigned int flags)
-{
-    remote_node_device_create_xml_args args;
-    remote_node_device_create_xml_ret ret;
-    virNodeDevicePtr dev = NULL;
-    struct private_data *priv = conn->devMonPrivateData;
-
-    remoteDriverLock(priv);
-
-    memset(&ret, 0, sizeof ret);
-    args.xml_desc = (char *)xmlDesc;
-    args.flags = flags;
-
-    if (call(conn, priv, 0, REMOTE_PROC_NODE_DEVICE_CREATE_XML,
-             (xdrproc_t) xdr_remote_node_device_create_xml_args, (char *) &args,
-             (xdrproc_t) xdr_remote_node_device_create_xml_ret, (char *) &ret) == -1)
-        goto done;
-
-    dev = get_nonnull_node_device(conn, ret.dev);
-    xdr_free ((xdrproc_t) xdr_remote_node_device_create_xml_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return dev;
-}
-
 /* ------------------------------------------------------------- */
 
 static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -5245,62 +4476,6 @@ done:
     return rv;
 }
 
-
-
-static virNWFilterPtr
-remoteNWFilterLookupByUUID (virConnectPtr conn,
-                            const unsigned char *uuid)
-{
-    virNWFilterPtr net = NULL;
-    remote_nwfilter_lookup_by_uuid_args args;
-    remote_nwfilter_lookup_by_uuid_ret ret;
-    struct private_data *priv = conn->nwfilterPrivateData;
-
-    remoteDriverLock(priv);
-
-    memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_NWFILTER_LOOKUP_BY_UUID,
-              (xdrproc_t) xdr_remote_nwfilter_lookup_by_uuid_args, (char *) &args,
-              (xdrproc_t) xdr_remote_nwfilter_lookup_by_uuid_ret, (char *) &ret) == -1)
-        goto done;
-
-    net = get_nonnull_nwfilter (conn, ret.nwfilter);
-    xdr_free ((xdrproc_t) &xdr_remote_nwfilter_lookup_by_uuid_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return net;
-}
-
-static virNWFilterPtr
-remoteNWFilterLookupByName (virConnectPtr conn,
-                            const char *name)
-{
-    virNWFilterPtr net = NULL;
-    remote_nwfilter_lookup_by_name_args args;
-    remote_nwfilter_lookup_by_name_ret ret;
-    struct private_data *priv = conn->nwfilterPrivateData;
-
-    remoteDriverLock(priv);
-
-    args.name = (char *) name;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (conn, priv, 0, REMOTE_PROC_NWFILTER_LOOKUP_BY_NAME,
-              (xdrproc_t) xdr_remote_nwfilter_lookup_by_name_args, (char *) &args,
-              (xdrproc_t) xdr_remote_nwfilter_lookup_by_name_ret, (char *) &ret) == -1)
-        goto done;
-
-    net = get_nonnull_nwfilter (conn, ret.nwfilter);
-    xdr_free ((xdrproc_t) &xdr_remote_nwfilter_lookup_by_name_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return net;
-}
-
 /*----------------------------------------------------------------------*/
 
 static int
@@ -6418,89 +5593,6 @@ done:
     return rv;
 }
 
-static virSecretPtr
-remoteSecretLookupByUUID (virConnectPtr conn, const unsigned char *uuid)
-{
-    virSecretPtr rv = NULL;
-    remote_secret_lookup_by_uuid_args args;
-    remote_secret_lookup_by_uuid_ret ret;
-    struct private_data *priv = conn->secretPrivateData;
-
-    remoteDriverLock (priv);
-
-    memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
-
-    memset (&ret, 0, sizeof (ret));
-    if (call (conn, priv, 0, REMOTE_PROC_SECRET_LOOKUP_BY_UUID,
-              (xdrproc_t) xdr_remote_secret_lookup_by_uuid_args, (char *) &args,
-              (xdrproc_t) xdr_remote_secret_lookup_by_uuid_ret, (char *) &ret) == -1)
-        goto done;
-
-    rv = get_nonnull_secret (conn, ret.secret);
-    xdr_free ((xdrproc_t) xdr_remote_secret_lookup_by_uuid_ret,
-              (char *) &ret);
-
-done:
-    remoteDriverUnlock (priv);
-    return rv;
-}
-
-static virSecretPtr
-remoteSecretLookupByUsage (virConnectPtr conn, int usageType, const char *usageID)
-{
-    virSecretPtr rv = NULL;
-    remote_secret_lookup_by_usage_args args;
-    remote_secret_lookup_by_usage_ret ret;
-    struct private_data *priv = conn->secretPrivateData;
-
-    remoteDriverLock (priv);
-
-    args.usageType = usageType;
-    args.usageID = (char *)usageID;
-
-    memset (&ret, 0, sizeof (ret));
-    if (call (conn, priv, 0, REMOTE_PROC_SECRET_LOOKUP_BY_USAGE,
-              (xdrproc_t) xdr_remote_secret_lookup_by_usage_args, (char *) &args,
-              (xdrproc_t) xdr_remote_secret_lookup_by_usage_ret, (char *) &ret) == -1)
-        goto done;
-
-    rv = get_nonnull_secret (conn, ret.secret);
-    xdr_free ((xdrproc_t) xdr_remote_secret_lookup_by_usage_ret,
-              (char *) &ret);
-
-done:
-    remoteDriverUnlock (priv);
-    return rv;
-}
-
-static virSecretPtr
-remoteSecretDefineXML (virConnectPtr conn, const char *xml, unsigned int flags)
-{
-    virSecretPtr rv = NULL;
-    remote_secret_define_xml_args args;
-    remote_secret_define_xml_ret ret;
-    struct private_data *priv = conn->secretPrivateData;
-
-    remoteDriverLock (priv);
-
-    args.xml = (char *) xml;
-    args.flags = flags;
-
-    memset (&ret, 0, sizeof (ret));
-    if (call (conn, priv, 0, REMOTE_PROC_SECRET_DEFINE_XML,
-              (xdrproc_t) xdr_remote_secret_define_xml_args, (char *) &args,
-              (xdrproc_t) xdr_remote_secret_define_xml_ret, (char *) &ret) == -1)
-        goto done;
-
-    rv = get_nonnull_secret (conn, ret.secret);
-    xdr_free ((xdrproc_t) xdr_remote_secret_define_xml_ret,
-              (char *) &ret);
-
-done:
-    remoteDriverUnlock (priv);
-    return rv;
-}
-
 static int
 remoteSecretSetValue (virSecretPtr secret, const unsigned char *value,
                       size_t value_size, unsigned int flags)
@@ -7173,36 +6265,6 @@ done:
     return rv;
 }
 
-static virDomainSnapshotPtr
-remoteDomainSnapshotCreateXML(virDomainPtr domain,
-                              const char *xmlDesc,
-                              unsigned int flags)
-{
-    virDomainSnapshotPtr snapshot = NULL;
-    remote_domain_snapshot_create_xml_args args;
-    remote_domain_snapshot_create_xml_ret ret;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain (&args.dom, domain);
-    args.xml_desc = (char *) xmlDesc;
-    args.flags = flags;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_CREATE_XML,
-              (xdrproc_t) xdr_remote_domain_snapshot_create_xml_args, (char *) &args,
-              (xdrproc_t) xdr_remote_domain_snapshot_create_xml_ret, (char *) &ret) == -1)
-        goto done;
-
-    snapshot = get_nonnull_domain_snapshot(domain, ret.snap);
-    xdr_free ((xdrproc_t) &xdr_remote_domain_snapshot_create_xml_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return snapshot;
-}
-
 static int
 remoteDomainSnapshotListNames (virDomainPtr domain, char **const names,
                                int maxnames, unsigned int flags)
@@ -7266,64 +6328,6 @@ done:
     return rv;
 }
 
-
-static virDomainSnapshotPtr
-remoteDomainSnapshotLookupByName (virDomainPtr domain, const char *name,
-                                  unsigned int flags)
-{
-    virDomainSnapshotPtr snapshot = NULL;
-    remote_domain_snapshot_lookup_by_name_args args;
-    remote_domain_snapshot_lookup_by_name_ret ret;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain(&args.dom, domain);
-    args.name = (char *) name;
-    args.flags = flags;
-
-    memset (&ret, 0, sizeof ret);
-    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LOOKUP_BY_NAME,
-              (xdrproc_t) xdr_remote_domain_snapshot_lookup_by_name_args, (char *) &args,
-              (xdrproc_t) xdr_remote_domain_snapshot_lookup_by_name_ret, (char *) &ret) == -1)
-        goto done;
-
-    snapshot = get_nonnull_domain_snapshot (domain, ret.snap);
-    xdr_free ((xdrproc_t) &xdr_remote_domain_snapshot_lookup_by_name_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return snapshot;
-}
-
-static virDomainSnapshotPtr
-remoteDomainSnapshotCurrent(virDomainPtr domain,
-                            unsigned int flags)
-{
-    virDomainSnapshotPtr snapshot = NULL;
-    remote_domain_snapshot_current_args args;
-    remote_domain_snapshot_current_ret ret;
-    struct private_data *priv = domain->conn->privateData;
-
-    remoteDriverLock(priv);
-
-    make_nonnull_domain(&args.dom, domain);
-    args.flags = flags;
-
-    memset(&ret, 0, sizeof ret);
-    if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_CURRENT,
-             (xdrproc_t) xdr_remote_domain_snapshot_current_args, (char *) &args,
-             (xdrproc_t) xdr_remote_domain_snapshot_current_ret, (char *) &ret) == -1)
-        goto done;
-
-    snapshot = get_nonnull_domain_snapshot(domain, ret.snap);
-    xdr_free((xdrproc_t) &xdr_remote_domain_snapshot_current_ret, (char *) &ret);
-
-done:
-    remoteDriverUnlock(priv);
-    return snapshot;
-}
-
 static int remoteDomainEventRegisterAny(virConnectPtr conn,
                                         virDomainPtr dom,
                                         int eventID,
-- 
1.7.0.4


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