[libvirt] [PATCH 21/22] remote generator, client: Handle functions that return lists

--- daemon/remote_generator.pl | 93 ++++- src/remote/remote_client_bodies.c | 786 ++++++++++++++++++++++++++++++++++++- src/remote/remote_driver.c | 758 ----------------------------------- 3 files changed, 851 insertions(+), 786 deletions(-) diff --git a/daemon/remote_generator.pl b/daemon/remote_generator.pl index 774188b..f5be8d6 100755 --- a/daemon/remote_generator.pl +++ b/daemon/remote_generator.pl @@ -755,29 +755,16 @@ elsif ($opt_k) { "NWFilterDefineXML", # public API and XDR protocol mismatch "DomainMigratePerform", "DomainMigrateFinish2", - "DomainSnapshotListNames", "FindStoragePoolSources", "IsSecure", - "ListDefinedDomains", - "ListDefinedInterfaces", - "ListNWFilters", "SupportsFeature", - "NodeListDevices", "NodeGetCellsFreeMemory", - "ListDefinedNetworks", - "StoragePoolListVolumes", "ListDomains", - "ListStoragePools", "SecretSetValue", "GetURI", - "ListInterfaces", - "ListDefinedStoragePools", "NodeDeviceDettach", - "ListNetworks", - "NodeDeviceListCaps", "NodeDeviceReset", "NodeDeviceReAttach", - "ListSecrets", "DomainBlockPeek", "DomainCreateWithFlags", @@ -925,8 +912,9 @@ elsif ($opt_k) { # fix priv_name for the NumOf* functions if ($priv_name eq "privateData" and - !($call->{ProcName} =~ m/Domains/) and - $call->{ProcName} =~ m/NumOf(Defined|Domain)*(\S+)s/) { + !($call->{ProcName} =~ m/(Domains|DomainSnapshot)/) and + ($call->{ProcName} =~ m/NumOf(Defined|Domain)*(\S+)s/ or + $call->{ProcName} =~ m/List(Defined|Domain)*(\S+)s/)) { my $prefix = lc $2; $prefix =~ s/(pool|vol)$//; $priv_name = "${prefix}PrivateData"; @@ -937,6 +925,11 @@ elsif ($opt_k) { my $call_ret = "&ret"; my $single_ret_var = "int rv = -1"; my $single_ret_type = "int"; + my $single_ret_as_list = 0; + my $single_ret_list_error_msg_type = "undefined"; + my $single_ret_list_name = "undefined"; + my $single_ret_list_max_var = "undefined"; + my $single_ret_list_max_define = "undefined"; my $multi_ret = 0; if ($call->{ret} ne "void" and @@ -961,6 +954,30 @@ elsif ($opt_k) { } else { die "unhandled type for multi-return-value: $ret_member"; } + } elsif ($ret_member =~ m/remote_nonnull_string (\S+)<(\S+)>;/) { + $single_ret_as_list = 1; + $single_ret_list_name = $1; + $single_ret_list_max_var = "max$1"; + $single_ret_list_max_define = $2; + + my $first_arg = shift(@args_list); + my $second_arg; + + if ($call->{ProcName} eq "NodeListDevices") { + $second_arg = shift(@args_list); + } + + unshift(@args_list, "char **const $1"); + + if (defined $second_arg) { + unshift(@args_list, $second_arg); + } + + unshift(@args_list, $first_arg); + + push(@ret_list, "rv = ret.$1.$1_len;"); + $single_ret_var = "int rv = -1"; + $single_ret_type = "int"; } elsif ($ret_member =~ m/remote_nonnull_string (\S+);/) { push(@ret_list, "rv = ret.$1;"); $single_ret_var = "char *rv = NULL"; @@ -1058,9 +1075,23 @@ elsif ($opt_k) { print " $var;\n"; } + if ($single_ret_as_list) { + print " int i;\n"; + } + print "\n"; print " remoteDriverLock(priv);\n"; + if ($single_ret_as_list) { + print "\n"; + print " if ($single_ret_list_max_var > $single_ret_list_max_define) {\n"; + print " remoteError(VIR_ERR_RPC,\n"; + print " _(\"too many remote ${single_ret_list_error_msg_type}s: %d > %d\"),\n"; + print " $single_ret_list_max_var, $single_ret_list_max_define);\n"; + print " goto done;\n"; + print " }\n"; + } + if (@setters_list) { print "\n"; print " "; @@ -1084,6 +1115,32 @@ elsif ($opt_k) { print " goto done;\n"; print "\n"; + if ($single_ret_as_list) { + print " if (ret.$single_ret_list_name.${single_ret_list_name}_len > $single_ret_list_max_var) {\n"; + print " remoteError(VIR_ERR_RPC,\n"; + print " _(\"too many remote ${single_ret_list_error_msg_type}s: %d > %d\"),\n"; + print " ret.$single_ret_list_name.${single_ret_list_name}_len, $single_ret_list_max_var);\n"; + print " goto cleanup;\n"; + print " }\n"; + print "\n"; + print " /* This call is caller-frees (although that isn't clear from\n"; + print " * the documentation). However xdr_free will free up both the\n"; + print " * names and the list of pointers, so we have to strdup the\n"; + print " * names here. */\n"; + print " for (i = 0; i < ret.$single_ret_list_name.${single_ret_list_name}_len; ++i) {\n"; + print " ${single_ret_list_name}[i] = strdup(ret.$single_ret_list_name.${single_ret_list_name}_val[i]);\n"; + print "\n"; + print " if (${single_ret_list_name}[i] == NULL) {\n"; + print " for (--i; i >= 0; --i)\n"; + print " VIR_FREE(${single_ret_list_name}[i]);\n"; + print "\n"; + print " virReportOOMError();\n"; + print " goto cleanup;\n"; + print " }\n"; + print " }\n"; + print "\n"; + } + if (@ret_list) { print " "; print join("\n ", @ret_list); @@ -1094,6 +1151,12 @@ elsif ($opt_k) { print " rv = 0;\n"; } + if ($single_ret_as_list) { + print "\n"; + print "cleanup:\n"; + print " xdr_free((xdrproc_t)xdr_remote_$call->{name}_ret, (char *)&ret);\n"; + } + print "\n"; print "done:\n"; print " remoteDriverUnlock(priv);\n"; diff --git a/src/remote/remote_client_bodies.c b/src/remote/remote_client_bodies.c index e61055b..4970c23 100644 --- a/src/remote/remote_client_bodies.c +++ b/src/remote/remote_client_bodies.c @@ -1330,7 +1330,67 @@ done: return rv; } -/* remoteDispatchDomainSnapshotListNames has to be implemented manually */ +static int +remoteDomainSnapshotListNames(virDomainPtr dom, char **const names, int maxnames, unsigned int flags) +{ + int rv = -1; + struct private_data *priv = dom->conn->privateData; + remote_domain_snapshot_list_names_args args; + remote_domain_snapshot_list_names_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxnames > REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined names: %d > %d"), + maxnames, REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX); + goto done; + } + + make_nonnull_domain(&args.dom, dom); + args.maxnames = maxnames; + args.flags = flags; + + memset(&ret, 0, sizeof ret); + + if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_NAMES, + (xdrproc_t)xdr_remote_domain_snapshot_list_names_args, (char *)&args, + (xdrproc_t)xdr_remote_domain_snapshot_list_names_ret, (char *)&ret) == -1) + goto done; + + if (ret.names.names_len > maxnames) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.names.names_len, maxnames); + goto cleanup; + } + + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.names.names_len; ++i) { + names[i] = strdup(ret.names.names_val[i]); + + if (names[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(names[i]); + + virReportOOMError(); + goto cleanup; + } + } + + rv = ret.names.names_len; + +cleanup: + xdr_free((xdrproc_t)xdr_remote_domain_snapshot_list_names_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} static virDomainSnapshotPtr remoteDomainSnapshotLookupByName(virDomainPtr dom, const char *name, unsigned int flags) @@ -1875,25 +1935,547 @@ done: /* remoteDispatchIsSecure has to be implemented manually */ -/* remoteDispatchListDefinedDomains has to be implemented manually */ +static int +remoteListDefinedDomains(virConnectPtr conn, char **const names, int maxnames) +{ + int rv = -1; + struct private_data *priv = conn->privateData; + remote_list_defined_domains_args args; + remote_list_defined_domains_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxnames > REMOTE_DOMAIN_NAME_LIST_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined names: %d > %d"), + maxnames, REMOTE_DOMAIN_NAME_LIST_MAX); + goto done; + } + + args.maxnames = maxnames; + + memset(&ret, 0, sizeof ret); + + if (call(conn, priv, 0, REMOTE_PROC_LIST_DEFINED_DOMAINS, + (xdrproc_t)xdr_remote_list_defined_domains_args, (char *)&args, + (xdrproc_t)xdr_remote_list_defined_domains_ret, (char *)&ret) == -1) + goto done; + + if (ret.names.names_len > maxnames) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.names.names_len, maxnames); + goto cleanup; + } -/* remoteDispatchListDefinedInterfaces has to be implemented manually */ + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.names.names_len; ++i) { + names[i] = strdup(ret.names.names_val[i]); -/* remoteDispatchListDefinedNetworks has to be implemented manually */ + if (names[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(names[i]); -/* remoteDispatchListDefinedStoragePools has to be implemented manually */ + virReportOOMError(); + goto cleanup; + } + } + + rv = ret.names.names_len; + +cleanup: + xdr_free((xdrproc_t)xdr_remote_list_defined_domains_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} + +static int +remoteListDefinedInterfaces(virConnectPtr conn, char **const names, int maxnames) +{ + int rv = -1; + struct private_data *priv = conn->interfacePrivateData; + remote_list_defined_interfaces_args args; + remote_list_defined_interfaces_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxnames > REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined names: %d > %d"), + maxnames, REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX); + goto done; + } + + args.maxnames = maxnames; + + memset(&ret, 0, sizeof ret); + + if (call(conn, priv, 0, REMOTE_PROC_LIST_DEFINED_INTERFACES, + (xdrproc_t)xdr_remote_list_defined_interfaces_args, (char *)&args, + (xdrproc_t)xdr_remote_list_defined_interfaces_ret, (char *)&ret) == -1) + goto done; + + if (ret.names.names_len > maxnames) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.names.names_len, maxnames); + goto cleanup; + } + + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.names.names_len; ++i) { + names[i] = strdup(ret.names.names_val[i]); + + if (names[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(names[i]); + + virReportOOMError(); + goto cleanup; + } + } + + rv = ret.names.names_len; + +cleanup: + xdr_free((xdrproc_t)xdr_remote_list_defined_interfaces_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} + +static int +remoteListDefinedNetworks(virConnectPtr conn, char **const names, int maxnames) +{ + int rv = -1; + struct private_data *priv = conn->networkPrivateData; + remote_list_defined_networks_args args; + remote_list_defined_networks_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxnames > REMOTE_NETWORK_NAME_LIST_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined names: %d > %d"), + maxnames, REMOTE_NETWORK_NAME_LIST_MAX); + goto done; + } + + args.maxnames = maxnames; + + memset(&ret, 0, sizeof ret); + + if (call(conn, priv, 0, REMOTE_PROC_LIST_DEFINED_NETWORKS, + (xdrproc_t)xdr_remote_list_defined_networks_args, (char *)&args, + (xdrproc_t)xdr_remote_list_defined_networks_ret, (char *)&ret) == -1) + goto done; + + if (ret.names.names_len > maxnames) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.names.names_len, maxnames); + goto cleanup; + } + + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.names.names_len; ++i) { + names[i] = strdup(ret.names.names_val[i]); + + if (names[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(names[i]); + + virReportOOMError(); + goto cleanup; + } + } + + rv = ret.names.names_len; + +cleanup: + xdr_free((xdrproc_t)xdr_remote_list_defined_networks_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} + +static int +remoteListDefinedStoragePools(virConnectPtr conn, char **const names, int maxnames) +{ + int rv = -1; + struct private_data *priv = conn->storagePrivateData; + remote_list_defined_storage_pools_args args; + remote_list_defined_storage_pools_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined names: %d > %d"), + maxnames, REMOTE_STORAGE_POOL_NAME_LIST_MAX); + goto done; + } + + args.maxnames = maxnames; + + memset(&ret, 0, sizeof ret); + + if (call(conn, priv, 0, REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS, + (xdrproc_t)xdr_remote_list_defined_storage_pools_args, (char *)&args, + (xdrproc_t)xdr_remote_list_defined_storage_pools_ret, (char *)&ret) == -1) + goto done; + + if (ret.names.names_len > maxnames) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.names.names_len, maxnames); + goto cleanup; + } + + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.names.names_len; ++i) { + names[i] = strdup(ret.names.names_val[i]); + + if (names[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(names[i]); + + virReportOOMError(); + goto cleanup; + } + } + + rv = ret.names.names_len; + +cleanup: + xdr_free((xdrproc_t)xdr_remote_list_defined_storage_pools_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} /* remoteDispatchListDomains has to be implemented manually */ -/* remoteDispatchListInterfaces has to be implemented manually */ +static int +remoteListInterfaces(virConnectPtr conn, char **const names, int maxnames) +{ + int rv = -1; + struct private_data *priv = conn->interfacePrivateData; + remote_list_interfaces_args args; + remote_list_interfaces_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxnames > REMOTE_INTERFACE_NAME_LIST_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined names: %d > %d"), + maxnames, REMOTE_INTERFACE_NAME_LIST_MAX); + goto done; + } + + args.maxnames = maxnames; + + memset(&ret, 0, sizeof ret); + + if (call(conn, priv, 0, REMOTE_PROC_LIST_INTERFACES, + (xdrproc_t)xdr_remote_list_interfaces_args, (char *)&args, + (xdrproc_t)xdr_remote_list_interfaces_ret, (char *)&ret) == -1) + goto done; + + if (ret.names.names_len > maxnames) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.names.names_len, maxnames); + goto cleanup; + } + + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.names.names_len; ++i) { + names[i] = strdup(ret.names.names_val[i]); + + if (names[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(names[i]); + + virReportOOMError(); + goto cleanup; + } + } + + rv = ret.names.names_len; + +cleanup: + xdr_free((xdrproc_t)xdr_remote_list_interfaces_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} + +static int +remoteListNetworks(virConnectPtr conn, char **const names, int maxnames) +{ + int rv = -1; + struct private_data *priv = conn->networkPrivateData; + remote_list_networks_args args; + remote_list_networks_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxnames > REMOTE_NETWORK_NAME_LIST_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined names: %d > %d"), + maxnames, REMOTE_NETWORK_NAME_LIST_MAX); + goto done; + } + + args.maxnames = maxnames; + + memset(&ret, 0, sizeof ret); + + if (call(conn, priv, 0, REMOTE_PROC_LIST_NETWORKS, + (xdrproc_t)xdr_remote_list_networks_args, (char *)&args, + (xdrproc_t)xdr_remote_list_networks_ret, (char *)&ret) == -1) + goto done; + + if (ret.names.names_len > maxnames) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.names.names_len, maxnames); + goto cleanup; + } + + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.names.names_len; ++i) { + names[i] = strdup(ret.names.names_val[i]); + + if (names[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(names[i]); + + virReportOOMError(); + goto cleanup; + } + } + + rv = ret.names.names_len; + +cleanup: + xdr_free((xdrproc_t)xdr_remote_list_networks_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} + +static int +remoteListNWFilters(virConnectPtr conn, char **const names, int maxnames) +{ + int rv = -1; + struct private_data *priv = conn->nwfilterPrivateData; + remote_list_nwfilters_args args; + remote_list_nwfilters_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxnames > REMOTE_NWFILTER_NAME_LIST_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined names: %d > %d"), + maxnames, REMOTE_NWFILTER_NAME_LIST_MAX); + goto done; + } + + args.maxnames = maxnames; + + memset(&ret, 0, sizeof ret); + + if (call(conn, priv, 0, REMOTE_PROC_LIST_NWFILTERS, + (xdrproc_t)xdr_remote_list_nwfilters_args, (char *)&args, + (xdrproc_t)xdr_remote_list_nwfilters_ret, (char *)&ret) == -1) + goto done; + + if (ret.names.names_len > maxnames) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.names.names_len, maxnames); + goto cleanup; + } + + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.names.names_len; ++i) { + names[i] = strdup(ret.names.names_val[i]); + + if (names[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(names[i]); + + virReportOOMError(); + goto cleanup; + } + } + + rv = ret.names.names_len; + +cleanup: + xdr_free((xdrproc_t)xdr_remote_list_nwfilters_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} + +static int +remoteListSecrets(virConnectPtr conn, char **const uuids, int maxuuids) +{ + int rv = -1; + struct private_data *priv = conn->secretPrivateData; + remote_list_secrets_args args; + remote_list_secrets_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxuuids > REMOTE_SECRET_UUID_LIST_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined uuids: %d > %d"), + maxuuids, REMOTE_SECRET_UUID_LIST_MAX); + goto done; + } + + args.maxuuids = maxuuids; + + memset(&ret, 0, sizeof ret); + + if (call(conn, priv, 0, REMOTE_PROC_LIST_SECRETS, + (xdrproc_t)xdr_remote_list_secrets_args, (char *)&args, + (xdrproc_t)xdr_remote_list_secrets_ret, (char *)&ret) == -1) + goto done; + + if (ret.uuids.uuids_len > maxuuids) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.uuids.uuids_len, maxuuids); + goto cleanup; + } + + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.uuids.uuids_len; ++i) { + uuids[i] = strdup(ret.uuids.uuids_val[i]); -/* remoteDispatchListNetworks has to be implemented manually */ + if (uuids[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(uuids[i]); -/* remoteDispatchListNWFilters has to be implemented manually */ + virReportOOMError(); + goto cleanup; + } + } -/* remoteDispatchListSecrets has to be implemented manually */ + rv = ret.uuids.uuids_len; -/* remoteDispatchListStoragePools has to be implemented manually */ +cleanup: + xdr_free((xdrproc_t)xdr_remote_list_secrets_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} + +static int +remoteListStoragePools(virConnectPtr conn, char **const names, int maxnames) +{ + int rv = -1; + struct private_data *priv = conn->storagePrivateData; + remote_list_storage_pools_args args; + remote_list_storage_pools_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined names: %d > %d"), + maxnames, REMOTE_STORAGE_POOL_NAME_LIST_MAX); + goto done; + } + + args.maxnames = maxnames; + + memset(&ret, 0, sizeof ret); + + if (call(conn, priv, 0, REMOTE_PROC_LIST_STORAGE_POOLS, + (xdrproc_t)xdr_remote_list_storage_pools_args, (char *)&args, + (xdrproc_t)xdr_remote_list_storage_pools_ret, (char *)&ret) == -1) + goto done; + + if (ret.names.names_len > maxnames) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.names.names_len, maxnames); + goto cleanup; + } + + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.names.names_len; ++i) { + names[i] = strdup(ret.names.names_val[i]); + + if (names[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(names[i]); + + virReportOOMError(); + goto cleanup; + } + } + + rv = ret.names.names_len; + +cleanup: + xdr_free((xdrproc_t)xdr_remote_list_storage_pools_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} static int remoteNetworkCreate(virNetworkPtr net) @@ -2310,7 +2892,66 @@ done: /* remoteDispatchNodeDeviceGetParent has to be implemented manually */ -/* remoteDispatchNodeDeviceListCaps has to be implemented manually */ +static int +remoteNodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames) +{ + int rv = -1; + struct private_data *priv = dev->conn->devMonPrivateData; + remote_node_device_list_caps_args args; + remote_node_device_list_caps_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxnames > REMOTE_NODE_DEVICE_CAPS_LIST_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined names: %d > %d"), + maxnames, REMOTE_NODE_DEVICE_CAPS_LIST_MAX); + goto done; + } + + args.name = dev->name; + args.maxnames = maxnames; + + memset(&ret, 0, sizeof ret); + + if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_LIST_CAPS, + (xdrproc_t)xdr_remote_node_device_list_caps_args, (char *)&args, + (xdrproc_t)xdr_remote_node_device_list_caps_ret, (char *)&ret) == -1) + goto done; + + if (ret.names.names_len > maxnames) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.names.names_len, maxnames); + goto cleanup; + } + + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.names.names_len; ++i) { + names[i] = strdup(ret.names.names_val[i]); + + if (names[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(names[i]); + + virReportOOMError(); + goto cleanup; + } + } + + rv = ret.names.names_len; + +cleanup: + xdr_free((xdrproc_t)xdr_remote_node_device_list_caps_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} static virNodeDevicePtr remoteNodeDeviceLookupByName(virConnectPtr conn, const char *name) @@ -2427,7 +3068,67 @@ done: /* remoteDispatchNodeGetSecurityModel has to be implemented manually */ -/* remoteDispatchNodeListDevices has to be implemented manually */ +static int +remoteNodeListDevices(virConnectPtr conn, const char *cap, char **const names, int maxnames, unsigned int flags) +{ + int rv = -1; + struct private_data *priv = conn->devMonPrivateData; + remote_node_list_devices_args args; + remote_node_list_devices_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined names: %d > %d"), + maxnames, REMOTE_NODE_DEVICE_NAME_LIST_MAX); + goto done; + } + + args.cap = cap ? (char **)&cap : NULL; + args.maxnames = maxnames; + args.flags = flags; + + memset(&ret, 0, sizeof ret); + + if (call(conn, priv, 0, REMOTE_PROC_NODE_LIST_DEVICES, + (xdrproc_t)xdr_remote_node_list_devices_args, (char *)&args, + (xdrproc_t)xdr_remote_node_list_devices_ret, (char *)&ret) == -1) + goto done; + + if (ret.names.names_len > maxnames) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.names.names_len, maxnames); + goto cleanup; + } + + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.names.names_len; ++i) { + names[i] = strdup(ret.names.names_val[i]); + + if (names[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(names[i]); + + virReportOOMError(); + goto cleanup; + } + } + + rv = ret.names.names_len; + +cleanup: + xdr_free((xdrproc_t)xdr_remote_node_list_devices_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} static int remoteNodeNumOfDevices(virConnectPtr conn, const char *cap, unsigned int flags) @@ -3218,7 +3919,66 @@ done: return rv; } -/* remoteDispatchStoragePoolListVolumes has to be implemented manually */ +static int +remoteStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int maxnames) +{ + int rv = -1; + struct private_data *priv = pool->conn->storagePrivateData; + remote_storage_pool_list_volumes_args args; + remote_storage_pool_list_volumes_ret ret; + int i; + + remoteDriverLock(priv); + + if (maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX) { + remoteError(VIR_ERR_RPC, + _("too many remote undefined names: %d > %d"), + maxnames, REMOTE_STORAGE_VOL_NAME_LIST_MAX); + goto done; + } + + make_nonnull_storage_pool(&args.pool, pool); + args.maxnames = maxnames; + + memset(&ret, 0, sizeof ret); + + if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES, + (xdrproc_t)xdr_remote_storage_pool_list_volumes_args, (char *)&args, + (xdrproc_t)xdr_remote_storage_pool_list_volumes_ret, (char *)&ret) == -1) + goto done; + + if (ret.names.names_len > maxnames) { + remoteError(VIR_ERR_RPC, + _("too many remote undefineds: %d > %d"), + ret.names.names_len, maxnames); + goto cleanup; + } + + /* This call is caller-frees (although that isn't clear from + * the documentation). However xdr_free will free up both the + * names and the list of pointers, so we have to strdup the + * names here. */ + for (i = 0; i < ret.names.names_len; ++i) { + names[i] = strdup(ret.names.names_val[i]); + + if (names[i] == NULL) { + for (--i; i >= 0; --i) + VIR_FREE(names[i]); + + virReportOOMError(); + goto cleanup; + } + } + + rv = ret.names.names_len; + +cleanup: + xdr_free((xdrproc_t)xdr_remote_storage_pool_list_volumes_ret, (char *)&ret); + +done: + remoteDriverUnlock(priv); + return rv; +} static virStoragePoolPtr remoteStoragePoolLookupByName(virConnectPtr conn, const char *name) diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 777a7bf..8a0fc0e 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -2607,65 +2607,6 @@ done: } static int -remoteListDefinedDomains (virConnectPtr conn, char **const names, int maxnames) -{ - int rv = -1; - int i; - remote_list_defined_domains_args args; - remote_list_defined_domains_ret ret; - struct private_data *priv = conn->privateData; - - remoteDriverLock(priv); - - if (maxnames > REMOTE_DOMAIN_NAME_LIST_MAX) { - remoteError(VIR_ERR_RPC, - _("too many remote domain names: %d > %d"), - maxnames, REMOTE_DOMAIN_NAME_LIST_MAX); - goto done; - } - args.maxnames = maxnames; - - memset (&ret, 0, sizeof ret); - if (call (conn, priv, 0, REMOTE_PROC_LIST_DEFINED_DOMAINS, - (xdrproc_t) xdr_remote_list_defined_domains_args, (char *) &args, - (xdrproc_t) xdr_remote_list_defined_domains_ret, (char *) &ret) == -1) - goto done; - - if (ret.names.names_len > maxnames) { - remoteError(VIR_ERR_RPC, - _("too many remote domain names: %d > %d"), - ret.names.names_len, maxnames); - goto cleanup; - } - - /* This call is caller-frees (although that isn't clear from - * the documentation). However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.names.names_len; ++i) { - names[i] = strdup (ret.names.names_val[i]); - - if (names[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(names[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.names.names_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_list_defined_domains_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - -static int remoteDomainCreate (virDomainPtr domain) { int rv = -1; @@ -3122,125 +3063,6 @@ remoteNetworkClose(virConnectPtr conn) return remoteGenericClose(conn, &conn->networkPrivateData); } -static int -remoteListNetworks (virConnectPtr conn, char **const names, int maxnames) -{ - int rv = -1; - int i; - remote_list_networks_args args; - remote_list_networks_ret ret; - struct private_data *priv = conn->networkPrivateData; - - remoteDriverLock(priv); - - if (maxnames > REMOTE_NETWORK_NAME_LIST_MAX) { - remoteError(VIR_ERR_RPC, - _("too many remote networks: %d > %d"), - maxnames, REMOTE_NETWORK_NAME_LIST_MAX); - goto done; - } - args.maxnames = maxnames; - - memset (&ret, 0, sizeof ret); - if (call (conn, priv, 0, REMOTE_PROC_LIST_NETWORKS, - (xdrproc_t) xdr_remote_list_networks_args, (char *) &args, - (xdrproc_t) xdr_remote_list_networks_ret, (char *) &ret) == -1) - goto done; - - if (ret.names.names_len > maxnames) { - remoteError(VIR_ERR_RPC, - _("too many remote networks: %d > %d"), - ret.names.names_len, maxnames); - goto cleanup; - } - - /* This call is caller-frees (although that isn't clear from - * the documentation). However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.names.names_len; ++i) { - names[i] = strdup (ret.names.names_val[i]); - - if (names[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(names[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.names.names_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_list_networks_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - -static int -remoteListDefinedNetworks (virConnectPtr conn, - char **const names, int maxnames) -{ - int rv = -1; - int i; - remote_list_defined_networks_args args; - remote_list_defined_networks_ret ret; - struct private_data *priv = conn->networkPrivateData; - - remoteDriverLock(priv); - - if (maxnames > REMOTE_NETWORK_NAME_LIST_MAX) { - remoteError(VIR_ERR_RPC, - _("too many remote networks: %d > %d"), - maxnames, REMOTE_NETWORK_NAME_LIST_MAX); - goto done; - } - args.maxnames = maxnames; - - memset (&ret, 0, sizeof ret); - if (call (conn, priv, 0, REMOTE_PROC_LIST_DEFINED_NETWORKS, - (xdrproc_t) xdr_remote_list_defined_networks_args, (char *) &args, - (xdrproc_t) xdr_remote_list_defined_networks_ret, (char *) &ret) == -1) - goto done; - - if (ret.names.names_len > maxnames) { - remoteError(VIR_ERR_RPC, - _("too many remote networks: %d > %d"), - ret.names.names_len, maxnames); - goto cleanup; - } - - /* This call is caller-frees (although that isn't clear from - * the documentation). However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.names.names_len; ++i) { - names[i] = strdup (ret.names.names_val[i]); - - if (names[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(names[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.names.names_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_list_defined_networks_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - /*----------------------------------------------------------------------*/ static virDrvOpenStatus ATTRIBUTE_NONNULL (1) @@ -3255,124 +3077,6 @@ remoteInterfaceClose(virConnectPtr conn) return remoteGenericClose(conn, &conn->interfacePrivateData); } -static int -remoteListInterfaces (virConnectPtr conn, char **const names, int maxnames) -{ - int rv = -1; - int i; - remote_list_interfaces_args args; - remote_list_interfaces_ret ret; - struct private_data *priv = conn->interfacePrivateData; - - remoteDriverLock(priv); - - if (maxnames > REMOTE_INTERFACE_NAME_LIST_MAX) { - remoteError(VIR_ERR_RPC, - _("too many remote interfaces: %d > %d"), - maxnames, REMOTE_INTERFACE_NAME_LIST_MAX); - goto done; - } - args.maxnames = maxnames; - - memset (&ret, 0, sizeof ret); - if (call (conn, priv, 0, REMOTE_PROC_LIST_INTERFACES, - (xdrproc_t) xdr_remote_list_interfaces_args, (char *) &args, - (xdrproc_t) xdr_remote_list_interfaces_ret, (char *) &ret) == -1) - goto done; - - if (ret.names.names_len > maxnames) { - remoteError(VIR_ERR_RPC, - _("too many remote interfaces: %d > %d"), - ret.names.names_len, maxnames); - goto cleanup; - } - - /* This call is caller-frees (although that isn't clear from - * the documentation). However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.names.names_len; ++i) { - names[i] = strdup (ret.names.names_val[i]); - - if (names[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(names[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.names.names_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_list_interfaces_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - -static int -remoteListDefinedInterfaces (virConnectPtr conn, char **const names, int maxnames) -{ - int rv = -1; - int i; - remote_list_defined_interfaces_args args; - remote_list_defined_interfaces_ret ret; - struct private_data *priv = conn->interfacePrivateData; - - remoteDriverLock(priv); - - if (maxnames > REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX) { - remoteError(VIR_ERR_RPC, - _("too many remote interfaces: %d > %d"), - maxnames, REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX); - goto done; - } - args.maxnames = maxnames; - - memset (&ret, 0, sizeof ret); - if (call (conn, priv, 0, REMOTE_PROC_LIST_DEFINED_INTERFACES, - (xdrproc_t) xdr_remote_list_defined_interfaces_args, (char *) &args, - (xdrproc_t) xdr_remote_list_defined_interfaces_ret, (char *) &ret) == -1) - goto done; - - if (ret.names.names_len > maxnames) { - remoteError(VIR_ERR_RPC, - _("too many remote interfaces: %d > %d"), - ret.names.names_len, maxnames); - goto cleanup; - } - - /* This call is caller-frees (although that isn't clear from - * the documentation). However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.names.names_len; ++i) { - names[i] = strdup (ret.names.names_val[i]); - - if (names[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(names[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.names.names_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_list_defined_interfaces_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - /*----------------------------------------------------------------------*/ static virDrvOpenStatus ATTRIBUTE_NONNULL (1) @@ -3387,117 +3091,6 @@ remoteStorageClose(virConnectPtr conn) return remoteGenericClose(conn, &conn->storagePrivateData); } -static int -remoteListStoragePools (virConnectPtr conn, char **const names, int maxnames) -{ - int rv = -1; - int i; - remote_list_storage_pools_args args; - remote_list_storage_pools_ret ret; - struct private_data *priv = conn->storagePrivateData; - - remoteDriverLock(priv); - - if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) { - remoteError(VIR_ERR_RPC, "%s", _("too many storage pools requested")); - goto done; - } - args.maxnames = maxnames; - - memset (&ret, 0, sizeof ret); - if (call (conn, priv, 0, REMOTE_PROC_LIST_STORAGE_POOLS, - (xdrproc_t) xdr_remote_list_storage_pools_args, (char *) &args, - (xdrproc_t) xdr_remote_list_storage_pools_ret, (char *) &ret) == -1) - goto done; - - if (ret.names.names_len > maxnames) { - remoteError(VIR_ERR_RPC, "%s", _("too many storage pools received")); - goto cleanup; - } - - /* This call is caller-frees (although that isn't clear from - * the documentation). However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.names.names_len; ++i) { - names[i] = strdup (ret.names.names_val[i]); - - if (names[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(names[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.names.names_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_list_storage_pools_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - -static int -remoteListDefinedStoragePools (virConnectPtr conn, - char **const names, int maxnames) -{ - int rv = -1; - int i; - remote_list_defined_storage_pools_args args; - remote_list_defined_storage_pools_ret ret; - struct private_data *priv = conn->storagePrivateData; - - remoteDriverLock(priv); - - if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) { - remoteError(VIR_ERR_RPC, "%s", _("too many storage pools requested")); - goto done; - } - args.maxnames = maxnames; - - memset (&ret, 0, sizeof ret); - if (call (conn, priv, 0, REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS, - (xdrproc_t) xdr_remote_list_defined_storage_pools_args, (char *) &args, - (xdrproc_t) xdr_remote_list_defined_storage_pools_ret, (char *) &ret) == -1) - goto done; - - if (ret.names.names_len > maxnames) { - remoteError(VIR_ERR_RPC, "%s", _("too many storage pools received")); - goto cleanup; - } - - /* This call is caller-frees (although that isn't clear from - * the documentation). However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.names.names_len; ++i) { - names[i] = strdup (ret.names.names_val[i]); - - if (names[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(names[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.names.names_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_list_defined_storage_pools_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - static char * remoteFindStoragePoolSources (virConnectPtr conn, const char *type, @@ -3543,62 +3136,6 @@ done: return rv; } -static int -remoteStoragePoolListVolumes (virStoragePoolPtr pool, char **const names, int maxnames) -{ - int rv = -1; - int i; - remote_storage_pool_list_volumes_args args; - remote_storage_pool_list_volumes_ret ret; - struct private_data *priv = pool->conn->storagePrivateData; - - remoteDriverLock(priv); - - if (maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX) { - remoteError(VIR_ERR_RPC, "%s", _("too many storage volumes requested")); - goto done; - } - args.maxnames = maxnames; - make_nonnull_storage_pool(&args.pool, pool); - - memset (&ret, 0, sizeof ret); - if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES, - (xdrproc_t) xdr_remote_storage_pool_list_volumes_args, (char *) &args, - (xdrproc_t) xdr_remote_storage_pool_list_volumes_ret, (char *) &ret) == -1) - goto done; - - if (ret.names.names_len > maxnames) { - remoteError(VIR_ERR_RPC, "%s", _("too many storage volumes received")); - goto cleanup; - } - - /* This call is caller-frees (although that isn't clear from - * the documentation). However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.names.names_len; ++i) { - names[i] = strdup (ret.names.names_val[i]); - - if (names[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(names[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.names.names_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_storage_pool_list_volumes_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - /*----------------------------------------------------------------------*/ static virDrvOpenStatus ATTRIBUTE_NONNULL (1) @@ -3613,66 +3150,6 @@ remoteDevMonClose(virConnectPtr conn) return remoteGenericClose(conn, &conn->devMonPrivateData); } -static int remoteNodeListDevices(virConnectPtr conn, - const char *cap, - char **const names, - int maxnames, - unsigned int flags) -{ - int rv = -1; - int i; - remote_node_list_devices_args args; - remote_node_list_devices_ret ret; - struct private_data *priv = conn->devMonPrivateData; - - remoteDriverLock(priv); - - if (maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX) { - remoteError(VIR_ERR_RPC, "%s", _("too many device names requested")); - goto done; - } - args.cap = cap ? (char **)&cap : NULL; - args.maxnames = maxnames; - args.flags = flags; - - memset (&ret, 0, sizeof ret); - if (call (conn, priv, 0, REMOTE_PROC_NODE_LIST_DEVICES, - (xdrproc_t) xdr_remote_node_list_devices_args, (char *) &args, - (xdrproc_t) xdr_remote_node_list_devices_ret, (char *) &ret) == -1) - goto done; - - if (ret.names.names_len > maxnames) { - remoteError(VIR_ERR_RPC, "%s", _("too many device names received")); - goto cleanup; - } - - /* This call is caller-frees (although that isn't clear from - * the documentation). However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.names.names_len; ++i) { - names[i] = strdup (ret.names.names_val[i]); - - if (names[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(names[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.names.names_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_node_list_devices_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - static char *remoteNodeDeviceGetParent(virNodeDevicePtr dev) { char *rv = NULL; @@ -3699,63 +3176,6 @@ done: return rv; } -static int remoteNodeDeviceListCaps(virNodeDevicePtr dev, - char **const names, - int maxnames) -{ - int rv = -1; - int i; - remote_node_device_list_caps_args args; - remote_node_device_list_caps_ret ret; - struct private_data *priv = dev->conn->devMonPrivateData; - - remoteDriverLock(priv); - - if (maxnames > REMOTE_NODE_DEVICE_CAPS_LIST_MAX) { - remoteError(VIR_ERR_RPC, "%s", _("too many capability names requested")); - goto done; - } - args.maxnames = maxnames; - args.name = dev->name; - - memset (&ret, 0, sizeof ret); - if (call (dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_LIST_CAPS, - (xdrproc_t) xdr_remote_node_device_list_caps_args, (char *) &args, - (xdrproc_t) xdr_remote_node_device_list_caps_ret, (char *) &ret) == -1) - goto done; - - if (ret.names.names_len > maxnames) { - remoteError(VIR_ERR_RPC, "%s", _("too many capability names received")); - goto cleanup; - } - - /* This call is caller-frees (although that isn't clear from - * the documentation). However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.names.names_len; ++i) { - names[i] = strdup (ret.names.names_val[i]); - - if (names[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(names[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.names.names_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_node_device_list_caps_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - static int remoteNodeDeviceDettach (virNodeDevicePtr dev) { @@ -3872,65 +3292,6 @@ done: return net; } -static int -remoteListNWFilters (virConnectPtr conn, char **const names, int maxnames) -{ - int rv = -1; - int i; - remote_list_nwfilters_args args; - remote_list_nwfilters_ret ret; - struct private_data *priv = conn->nwfilterPrivateData; - - remoteDriverLock(priv); - - if (maxnames > REMOTE_NWFILTER_NAME_LIST_MAX) { - remoteError(VIR_ERR_RPC, - _("too many remote nwfilters: %d > %d"), - maxnames, REMOTE_NWFILTER_NAME_LIST_MAX); - goto done; - } - args.maxnames = maxnames; - - memset (&ret, 0, sizeof ret); - if (call (conn, priv, 0, REMOTE_PROC_LIST_NWFILTERS, - (xdrproc_t) xdr_remote_list_nwfilters_args, (char *) &args, - (xdrproc_t) xdr_remote_list_nwfilters_ret, (char *) &ret) == -1) - goto done; - - if (ret.names.names_len > maxnames) { - remoteError(VIR_ERR_RPC, - _("too many remote nwfilters: %d > %d"), - ret.names.names_len, maxnames); - goto cleanup; - } - - /* This call is caller-frees (although that isn't clear from - * the documentation). However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.names.names_len; ++i) { - names[i] = strdup (ret.names.names_val[i]); - - if (names[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(names[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.names.names_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_list_nwfilters_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - /*----------------------------------------------------------------------*/ static int @@ -4938,62 +4299,6 @@ remoteSecretClose (virConnectPtr conn) } static int -remoteListSecrets (virConnectPtr conn, char **uuids, int maxuuids) -{ - int rv = -1; - int i; - remote_list_secrets_args args; - remote_list_secrets_ret ret; - struct private_data *priv = conn->secretPrivateData; - - remoteDriverLock(priv); - - if (maxuuids > REMOTE_SECRET_UUID_LIST_MAX) { - remoteError(VIR_ERR_RPC, _("too many remote secret UUIDs: %d > %d"), - maxuuids, REMOTE_SECRET_UUID_LIST_MAX); - goto done; - } - args.maxuuids = maxuuids; - - memset (&ret, 0, sizeof ret); - if (call (conn, priv, 0, REMOTE_PROC_LIST_SECRETS, - (xdrproc_t) xdr_remote_list_secrets_args, (char *) &args, - (xdrproc_t) xdr_remote_list_secrets_ret, (char *) &ret) == -1) - goto done; - - if (ret.uuids.uuids_len > maxuuids) { - remoteError(VIR_ERR_RPC, _("too many remote secret UUIDs: %d > %d"), - ret.uuids.uuids_len, maxuuids); - goto cleanup; - } - - /* This call is caller-frees. However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.uuids.uuids_len; ++i) { - uuids[i] = strdup (ret.uuids.uuids_val[i]); - - if (uuids[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(uuids[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.uuids.uuids_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_list_secrets_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - -static int remoteSecretSetValue (virSecretPtr secret, const unsigned char *value, size_t value_size, unsigned int flags) { @@ -5626,69 +4931,6 @@ done: return cpu; } -static int -remoteDomainSnapshotListNames (virDomainPtr domain, char **const names, - int maxnames, unsigned int flags) -{ - int rv = -1; - int i; - remote_domain_snapshot_list_names_args args; - remote_domain_snapshot_list_names_ret ret; - struct private_data *priv = domain->conn->privateData; - - remoteDriverLock(priv); - - if (maxnames > REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX) { - remoteError(VIR_ERR_RPC, - _("too many remote domain snapshot names: %d > %d"), - maxnames, REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX); - goto done; - } - - make_nonnull_domain(&args.dom, domain); - args.maxnames = maxnames; - args.flags = flags; - - memset (&ret, 0, sizeof ret); - if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_NAMES, - (xdrproc_t) xdr_remote_domain_snapshot_list_names_args, (char *) &args, - (xdrproc_t) xdr_remote_domain_snapshot_list_names_ret, (char *) &ret) == -1) - goto done; - - if (ret.names.names_len > maxnames) { - remoteError(VIR_ERR_RPC, - _("too many remote domain snapshots: %d > %d"), - ret.names.names_len, maxnames); - goto cleanup; - } - - /* This call is caller-frees (although that isn't clear from - * the documentation). However xdr_free will free up both the - * names and the list of pointers, so we have to strdup the - * names here. - */ - for (i = 0; i < ret.names.names_len; ++i) { - names[i] = strdup (ret.names.names_val[i]); - - if (names[i] == NULL) { - for (--i; i >= 0; --i) - VIR_FREE(names[i]); - - virReportOOMError(); - goto cleanup; - } - } - - rv = ret.names.names_len; - -cleanup: - xdr_free ((xdrproc_t) xdr_remote_domain_snapshot_list_names_ret, (char *) &ret); - -done: - remoteDriverUnlock(priv); - return rv; -} - static int remoteDomainEventRegisterAny(virConnectPtr conn, virDomainPtr dom, int eventID, -- 1.7.0.4