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

Re: [libvirt] PATCH 2/5:centralize exit paths in remote driver



This patch merges all exit paths in the remote driver APIs so we more or
less always have a single exit path in every method. NB we don't quite
follow the HACKING guideline of naming cleanup paths 'cleanup', since
we will need two possible cleanup points in some methods. So I've got a
slightly different pattern

  cleanup:
     ....release data we allocated, typically free'ing the XDR object
  done:
     return ret;
  }

In the next patch, the 'done' label will also unlock the driver.

diff --git a/src/remote_internal.c b/src/remote_internal.c
--- a/src/remote_internal.c
+++ b/src/remote_internal.c
@@ -1253,12 +1253,16 @@ static int
 static int
 remoteSupportsFeature (virConnectPtr conn, int feature)
 {
+    int rv = -1;
     remote_supports_feature_args args;
     remote_supports_feature_ret ret;
     struct private_data *priv = conn->privateData;
 
     /* VIR_DRV_FEATURE_REMOTE* features are handled directly. */
-    if (feature == VIR_DRV_FEATURE_REMOTE) return 1;
+    if (feature == VIR_DRV_FEATURE_REMOTE) {
+        rv = 1;
+        goto done;
+    }
 
     args.feature = feature;
 
@@ -1266,9 +1270,12 @@ remoteSupportsFeature (virConnectPtr con
     if (call (conn, priv, 0, REMOTE_PROC_SUPPORTS_FEATURE,
               (xdrproc_t) xdr_remote_supports_feature_args, (char *) &args,
               (xdrproc_t) xdr_remote_supports_feature_ret, (char *) &ret) == -1)
-        return -1;
-
-    return ret.supported;
+        goto done;
+
+    rv = ret.supported;
+
+done:
+    return rv;
 }
 
 /* Unfortunately this function is defined to return a static string.
@@ -1282,25 +1289,33 @@ static const char *
 static const char *
 remoteType (virConnectPtr conn)
 {
+    char *rv = NULL;
     remote_get_type_ret ret;
     struct private_data *priv = conn->privateData;
 
     /* Cached? */
-    if (priv->type) return priv->type;
+    if (priv->type) {
+        rv = priv->type;
+        goto done;
+    }
 
     memset (&ret, 0, sizeof ret);
     if (call (conn, priv, 0, REMOTE_PROC_GET_TYPE,
               (xdrproc_t) xdr_void, (char *) NULL,
               (xdrproc_t) xdr_remote_get_type_ret, (char *) &ret) == -1)
-        return NULL;
+        goto done;
 
     /* Stash. */
-    return priv->type = ret.type;
+    rv = priv->type = ret.type;
+
+done:
+    return rv;
 }
 
 static int
 remoteGetVersion (virConnectPtr conn, unsigned long *hvVer)
 {
+    int rv = -1;
     remote_get_version_ret ret;
     struct private_data *priv = conn->privateData;
 
@@ -1308,15 +1323,19 @@ remoteGetVersion (virConnectPtr conn, un
     if (call (conn, priv, 0, REMOTE_PROC_GET_VERSION,
               (xdrproc_t) xdr_void, (char *) NULL,
               (xdrproc_t) xdr_remote_get_version_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     if (hvVer) *hvVer = ret.hv_ver;
-    return 0;
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static char *
 remoteGetHostname (virConnectPtr conn)
 {
+    char *rv = NULL;
     remote_get_hostname_ret ret;
     struct private_data *priv = conn->privateData;
 
@@ -1324,15 +1343,19 @@ remoteGetHostname (virConnectPtr conn)
     if (call (conn, priv, 0, REMOTE_PROC_GET_HOSTNAME,
               (xdrproc_t) xdr_void, (char *) NULL,
               (xdrproc_t) xdr_remote_get_hostname_ret, (char *) &ret) == -1)
-        return NULL;
+        goto done;
 
     /* Caller frees this. */
-    return ret.hostname;
+    rv = ret.hostname;
+
+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;
@@ -1342,14 +1365,18 @@ remoteGetMaxVcpus (virConnectPtr conn, c
     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)
-        return -1;
-
-    return ret.max_vcpus;
+        goto done;
+
+    rv = ret.max_vcpus;
+
+done:
+    return rv;
 }
 
 static int
 remoteNodeGetInfo (virConnectPtr conn, virNodeInfoPtr info)
 {
+    int rv = -1;
     remote_node_get_info_ret ret;
     struct private_data *priv = conn->privateData;
 
@@ -1357,7 +1384,7 @@ remoteNodeGetInfo (virConnectPtr conn, v
     if (call (conn, priv, 0, REMOTE_PROC_NODE_GET_INFO,
               (xdrproc_t) xdr_void, (char *) NULL,
               (xdrproc_t) xdr_remote_node_get_info_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     strncpy (info->model, ret.model, 32);
     info->model[31] = '\0';
@@ -1368,12 +1395,16 @@ remoteNodeGetInfo (virConnectPtr conn, v
     info->sockets = ret.sockets;
     info->cores = ret.cores;
     info->threads = ret.threads;
-    return 0;
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static char *
 remoteGetCapabilities (virConnectPtr conn)
 {
+    char *rv = NULL;
     remote_get_capabilities_ret ret;
     struct private_data *priv = conn->privateData;
 
@@ -1381,10 +1412,13 @@ remoteGetCapabilities (virConnectPtr con
     if (call (conn, priv, 0, REMOTE_PROC_GET_CAPABILITIES,
               (xdrproc_t) xdr_void, (char *) NULL,
               (xdrproc_t) xdr_remote_get_capabilities_ret, (char *)&ret) == -1)
-        return NULL;
+        goto done;
 
     /* Caller frees this. */
-    return ret.capabilities;
+    rv = ret.capabilities;
+
+done:
+    return rv;
 }
 
 static int
@@ -1393,6 +1427,7 @@ remoteNodeGetCellsFreeMemory(virConnectP
                             int startCell,
                             int maxCells)
 {
+    int rv = -1;
     remote_node_get_cells_free_memory_args args;
     remote_node_get_cells_free_memory_ret ret;
     int i;
@@ -1403,7 +1438,7 @@ remoteNodeGetCellsFreeMemory(virConnectP
                 _("too many NUMA cells: %d > %d"),
                 maxCells,
                 REMOTE_NODE_MAX_CELLS);
-        return -1;
+        goto done;
     }
 
     args.startCell = startCell;
@@ -1413,19 +1448,23 @@ remoteNodeGetCellsFreeMemory(virConnectP
     if (call (conn, priv, 0, REMOTE_PROC_NODE_GET_CELLS_FREE_MEMORY,
               (xdrproc_t) xdr_remote_node_get_cells_free_memory_args, (char *)&args,
               (xdrproc_t) xdr_remote_node_get_cells_free_memory_ret, (char *)&ret) == -1)
-        return -1;
+        goto done;
 
     for (i = 0 ; i < ret.freeMems.freeMems_len ; i++)
         freeMems[i] = ret.freeMems.freeMems_val[i];
 
     xdr_free((xdrproc_t) xdr_remote_node_get_cells_free_memory_ret, (char *) &ret);
 
-    return ret.freeMems.freeMems_len;
+    rv = ret.freeMems.freeMems_len;
+
+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;
 
@@ -1433,15 +1472,19 @@ remoteNodeGetFreeMemory (virConnectPtr c
     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)
-        return 0;
-
-    return ret.freeMem;
+        goto done;
+
+    rv = ret.freeMem;
+
+done:
+    return rv;
 }
 
 
 static int
 remoteListDomains (virConnectPtr conn, int *ids, int maxids)
 {
+    int rv = -1;
     int i;
     remote_list_domains_args args;
     remote_list_domains_ret ret;
@@ -1451,7 +1494,7 @@ remoteListDomains (virConnectPtr conn, i
         errorf (conn, VIR_ERR_RPC,
                 _("too many remote domain IDs: %d > %d"),
                 maxids, REMOTE_DOMAIN_ID_LIST_MAX);
-        return -1;
+        goto done;
     }
     args.maxids = maxids;
 
@@ -1459,27 +1502,31 @@ remoteListDomains (virConnectPtr conn, i
     if (call (conn, priv, 0, REMOTE_PROC_LIST_DOMAINS,
               (xdrproc_t) xdr_remote_list_domains_args, (char *) &args,
               (xdrproc_t) xdr_remote_list_domains_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     if (ret.ids.ids_len > maxids) {
         errorf (conn, VIR_ERR_RPC,
                 _("too many remote domain IDs: %d > %d"),
                 ret.ids.ids_len, maxids);
-        xdr_free ((xdrproc_t) xdr_remote_list_domains_ret, (char *) &ret);
-        return -1;
+        goto cleanup;
     }
 
     for (i = 0; i < ret.ids.ids_len; ++i)
         ids[i] = ret.ids.ids_val[i];
 
+    rv = ret.ids.ids_len;
+
+cleanup:
     xdr_free ((xdrproc_t) xdr_remote_list_domains_ret, (char *) &ret);
 
-    return ret.ids.ids_len;
+done:
+    return rv;
 }
 
 static int
 remoteNumOfDomains (virConnectPtr conn)
 {
+    int rv = -1;
     remote_num_of_domains_ret ret;
     struct private_data *priv = conn->privateData;
 
@@ -1487,9 +1534,12 @@ remoteNumOfDomains (virConnectPtr conn)
     if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DOMAINS,
               (xdrproc_t) xdr_void, (char *) NULL,
               (xdrproc_t) xdr_remote_num_of_domains_ret, (char *) &ret) == -1)
-        return -1;
-
-    return ret.num;
+        goto done;
+
+    rv = ret.num;
+
+done:
+    return rv;
 }
 
 static virDomainPtr
@@ -1497,7 +1547,7 @@ remoteDomainCreateXML (virConnectPtr con
                          const char *xmlDesc,
                          unsigned int flags)
 {
-    virDomainPtr dom;
+    virDomainPtr dom = NULL;
     remote_domain_create_xml_args args;
     remote_domain_create_xml_ret ret;
     struct private_data *priv = conn->privateData;
@@ -1509,18 +1559,19 @@ remoteDomainCreateXML (virConnectPtr con
     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)
-        return NULL;
+        goto done;
 
     dom = get_nonnull_domain (conn, ret.dom);
     xdr_free ((xdrproc_t) &xdr_remote_domain_create_xml_ret, (char *) &ret);
 
+done:
     return dom;
 }
 
 static virDomainPtr
 remoteDomainLookupByID (virConnectPtr conn, int id)
 {
-    virDomainPtr dom;
+    virDomainPtr dom = NULL;
     remote_domain_lookup_by_id_args args;
     remote_domain_lookup_by_id_ret ret;
     struct private_data *priv = conn->privateData;
@@ -1531,18 +1582,19 @@ remoteDomainLookupByID (virConnectPtr co
     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)
-        return NULL;
+        goto done;
 
     dom = get_nonnull_domain (conn, ret.dom);
     xdr_free ((xdrproc_t) &xdr_remote_domain_lookup_by_id_ret, (char *) &ret);
 
+done:
     return dom;
 }
 
 static virDomainPtr
 remoteDomainLookupByUUID (virConnectPtr conn, const unsigned char *uuid)
 {
-    virDomainPtr dom;
+    virDomainPtr dom = NULL;
     remote_domain_lookup_by_uuid_args args;
     remote_domain_lookup_by_uuid_ret ret;
     struct private_data *priv = conn->privateData;
@@ -1553,17 +1605,19 @@ remoteDomainLookupByUUID (virConnectPtr 
     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)
-        return NULL;
+        goto done;
 
     dom = get_nonnull_domain (conn, ret.dom);
     xdr_free ((xdrproc_t) &xdr_remote_domain_lookup_by_uuid_ret, (char *) &ret);
+
+done:
     return dom;
 }
 
 static virDomainPtr
 remoteDomainLookupByName (virConnectPtr conn, const char *name)
 {
-    virDomainPtr dom;
+    virDomainPtr dom = NULL;
     remote_domain_lookup_by_name_args args;
     remote_domain_lookup_by_name_ret ret;
     struct private_data *priv = conn->privateData;
@@ -1574,17 +1628,19 @@ remoteDomainLookupByName (virConnectPtr 
     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)
-        return NULL;
+        goto done;
 
     dom = get_nonnull_domain (conn, ret.dom);
     xdr_free ((xdrproc_t) &xdr_remote_domain_lookup_by_name_ret, (char *) &ret);
 
+done:
     return dom;
 }
 
 static int
 remoteDomainSuspend (virDomainPtr domain)
 {
+    int rv = -1;
     remote_domain_suspend_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -1593,14 +1649,18 @@ remoteDomainSuspend (virDomainPtr domain
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SUSPEND,
               (xdrproc_t) xdr_remote_domain_suspend_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainResume (virDomainPtr domain)
 {
+    int rv = -1;
     remote_domain_resume_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -1609,14 +1669,18 @@ remoteDomainResume (virDomainPtr domain)
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_RESUME,
               (xdrproc_t) xdr_remote_domain_resume_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainShutdown (virDomainPtr domain)
 {
+    int rv = -1;
     remote_domain_shutdown_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -1625,14 +1689,18 @@ remoteDomainShutdown (virDomainPtr domai
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SHUTDOWN,
               (xdrproc_t) xdr_remote_domain_shutdown_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainReboot (virDomainPtr domain, unsigned int flags)
 {
+    int rv = -1;
     remote_domain_reboot_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -1642,14 +1710,18 @@ remoteDomainReboot (virDomainPtr domain,
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_REBOOT,
               (xdrproc_t) xdr_remote_domain_reboot_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainDestroy (virDomainPtr domain)
 {
+    int rv = -1;
     remote_domain_destroy_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -1658,14 +1730,18 @@ remoteDomainDestroy (virDomainPtr domain
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_DESTROY,
               (xdrproc_t) xdr_remote_domain_destroy_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static char *
 remoteDomainGetOSType (virDomainPtr domain)
 {
+    char *rv = NULL;
     remote_domain_get_os_type_args args;
     remote_domain_get_os_type_ret ret;
     struct private_data *priv = domain->conn->privateData;
@@ -1676,15 +1752,19 @@ remoteDomainGetOSType (virDomainPtr doma
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_OS_TYPE,
               (xdrproc_t) xdr_remote_domain_get_os_type_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_get_os_type_ret, (char *) &ret) == -1)
-        return NULL;
-
-    /* Caller frees. */
-    return ret.type;
+        goto done;
+
+    /* Caller frees. */
+    rv = ret.type;
+
+done:
+    return rv;
 }
 
 static unsigned long
 remoteDomainGetMaxMemory (virDomainPtr domain)
 {
+    unsigned long rv = 0;
     remote_domain_get_max_memory_args args;
     remote_domain_get_max_memory_ret ret;
     struct private_data *priv = domain->conn->privateData;
@@ -1695,14 +1775,18 @@ remoteDomainGetMaxMemory (virDomainPtr d
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_MAX_MEMORY,
               (xdrproc_t) xdr_remote_domain_get_max_memory_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_get_max_memory_ret, (char *) &ret) == -1)
-        return 0;
-
-    return ret.memory;
+        goto done;
+
+    rv = ret.memory;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainSetMaxMemory (virDomainPtr domain, unsigned long memory)
 {
+    int rv = -1;
     remote_domain_set_max_memory_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -1712,14 +1796,18 @@ remoteDomainSetMaxMemory (virDomainPtr d
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MAX_MEMORY,
               (xdrproc_t) xdr_remote_domain_set_max_memory_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainSetMemory (virDomainPtr domain, unsigned long memory)
 {
+    int rv = -1;
     remote_domain_set_memory_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -1729,14 +1817,18 @@ remoteDomainSetMemory (virDomainPtr doma
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MEMORY,
               (xdrproc_t) xdr_remote_domain_set_memory_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainGetInfo (virDomainPtr domain, virDomainInfoPtr info)
 {
+    int rv = -1;
     remote_domain_get_info_args args;
     remote_domain_get_info_ret ret;
     struct private_data *priv = domain->conn->privateData;
@@ -1747,7 +1839,7 @@ remoteDomainGetInfo (virDomainPtr domain
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_INFO,
               (xdrproc_t) xdr_remote_domain_get_info_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_get_info_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     info->state = ret.state;
     info->maxMem = ret.max_mem;
@@ -1755,12 +1847,16 @@ remoteDomainGetInfo (virDomainPtr domain
     info->nrVirtCpu = ret.nr_virt_cpu;
     info->cpuTime = ret.cpu_time;
 
-    return 0;
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainSave (virDomainPtr domain, const char *to)
 {
+    int rv = -1;
     remote_domain_save_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -1770,14 +1866,18 @@ remoteDomainSave (virDomainPtr domain, c
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SAVE,
               (xdrproc_t) xdr_remote_domain_save_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainRestore (virConnectPtr conn, const char *from)
 {
+    int rv = -1;
     remote_domain_restore_args args;
     struct private_data *priv = conn->privateData;
 
@@ -1786,14 +1886,18 @@ remoteDomainRestore (virConnectPtr conn,
     if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_RESTORE,
               (xdrproc_t) xdr_remote_domain_restore_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainCoreDump (virDomainPtr domain, const char *to, int flags)
 {
+    int rv = -1;
     remote_domain_core_dump_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -1804,14 +1908,18 @@ remoteDomainCoreDump (virDomainPtr domai
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_CORE_DUMP,
               (xdrproc_t) xdr_remote_domain_core_dump_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainSetVcpus (virDomainPtr domain, unsigned int nvcpus)
 {
+    int rv = -1;
     remote_domain_set_vcpus_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -1821,9 +1929,12 @@ remoteDomainSetVcpus (virDomainPtr domai
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_VCPUS,
               (xdrproc_t) xdr_remote_domain_set_vcpus_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
@@ -1832,6 +1943,7 @@ remoteDomainPinVcpu (virDomainPtr domain
                      unsigned char *cpumap,
                      int maplen)
 {
+    int rv = -1;
     remote_domain_pin_vcpu_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -1839,7 +1951,7 @@ remoteDomainPinVcpu (virDomainPtr domain
         errorf (domain->conn, VIR_ERR_RPC,
                 _("map length greater than maximum: %d > %d"),
                 maplen, REMOTE_CPUMAP_MAX);
-        return -1;
+        goto done;
     }
 
     make_nonnull_domain (&args.dom, domain);
@@ -1850,9 +1962,12 @@ remoteDomainPinVcpu (virDomainPtr domain
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_PIN_VCPU,
               (xdrproc_t) xdr_remote_domain_pin_vcpu_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
@@ -1862,6 +1977,7 @@ remoteDomainGetVcpus (virDomainPtr domai
                       unsigned char *cpumaps,
                       int maplen)
 {
+    int rv = -1;
     int i;
     remote_domain_get_vcpus_args args;
     remote_domain_get_vcpus_ret ret;
@@ -1871,13 +1987,13 @@ remoteDomainGetVcpus (virDomainPtr domai
         errorf (domain->conn, VIR_ERR_RPC,
                 _("vCPU count exceeds maximum: %d > %d"),
                 maxinfo, REMOTE_VCPUINFO_MAX);
-        return -1;
+        goto done;
     }
     if (maxinfo * maplen > REMOTE_CPUMAPS_MAX) {
         errorf (domain->conn, VIR_ERR_RPC,
                 _("vCPU map buffer length exceeds maximum: %d > %d"),
                 maxinfo * maplen, REMOTE_CPUMAPS_MAX);
-        return -1;
+        goto done;
     }
 
     make_nonnull_domain (&args.dom, domain);
@@ -1888,21 +2004,19 @@ remoteDomainGetVcpus (virDomainPtr domai
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_VCPUS,
               (xdrproc_t) xdr_remote_domain_get_vcpus_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_get_vcpus_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     if (ret.info.info_len > maxinfo) {
         errorf (domain->conn, VIR_ERR_RPC,
                 _("host reports too many vCPUs: %d > %d"),
                 ret.info.info_len, maxinfo);
-        xdr_free ((xdrproc_t) xdr_remote_domain_get_vcpus_ret, (char *) &ret);
-        return -1;
+        goto cleanup;
     }
     if (ret.cpumaps.cpumaps_len > maxinfo * maplen) {
         errorf (domain->conn, VIR_ERR_RPC,
                 _("host reports map buffer length exceeds maximum: %d > %d"),
                 ret.cpumaps.cpumaps_len, maxinfo * maplen);
-        xdr_free ((xdrproc_t) xdr_remote_domain_get_vcpus_ret, (char *) &ret);
-        return -1;
+        goto cleanup;
     }
 
     memset (info, 0, sizeof (virVcpuInfo) * maxinfo);
@@ -1918,13 +2032,19 @@ remoteDomainGetVcpus (virDomainPtr domai
     for (i = 0; i < ret.cpumaps.cpumaps_len; ++i)
         cpumaps[i] = ret.cpumaps.cpumaps_val[i];
 
+    rv = ret.info.info_len;
+
+cleanup:
     xdr_free ((xdrproc_t) xdr_remote_domain_get_vcpus_ret, (char *) &ret);
-    return ret.info.info_len;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainGetMaxVcpus (virDomainPtr domain)
 {
+    int rv = -1;
     remote_domain_get_max_vcpus_args args;
     remote_domain_get_max_vcpus_ret ret;
     struct private_data *priv = domain->conn->privateData;
@@ -1935,14 +2055,18 @@ remoteDomainGetMaxVcpus (virDomainPtr do
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_MAX_VCPUS,
               (xdrproc_t) xdr_remote_domain_get_max_vcpus_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_get_max_vcpus_ret, (char *) &ret) == -1)
-        return -1;
-
-    return ret.num;
+        goto done;
+
+    rv = ret.num;
+
+done:
+    return rv;
 }
 
 static char *
 remoteDomainDumpXML (virDomainPtr domain, int flags)
 {
+    char *rv = NULL;
     remote_domain_dump_xml_args args;
     remote_domain_dump_xml_ret ret;
     struct private_data *priv = domain->conn->privateData;
@@ -1954,10 +2078,13 @@ remoteDomainDumpXML (virDomainPtr domain
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_DUMP_XML,
               (xdrproc_t) xdr_remote_domain_dump_xml_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_dump_xml_ret, (char *) &ret) == -1)
-        return NULL;
-
-    /* Caller frees. */
-    return ret.xml;
+        goto done;
+
+    /* Caller frees. */
+    rv = ret.xml;
+
+done:
+    return rv;
 }
 
 static int
@@ -1967,6 +2094,7 @@ remoteDomainMigratePrepare (virConnectPt
                             unsigned long flags, const char *dname,
                             unsigned long resource)
 {
+    int rv = -1;
     remote_domain_migrate_prepare_args args;
     remote_domain_migrate_prepare_ret ret;
     struct private_data *priv = dconn->privateData;
@@ -1980,7 +2108,7 @@ remoteDomainMigratePrepare (virConnectPt
     if (call (dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_PREPARE,
               (xdrproc_t) xdr_remote_domain_migrate_prepare_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_migrate_prepare_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     if (ret.cookie.cookie_len > 0) {
         *cookie = ret.cookie.cookie_val; /* Caller frees. */
@@ -1989,7 +2117,10 @@ remoteDomainMigratePrepare (virConnectPt
     if (ret.uri_out)
         *uri_out = *ret.uri_out; /* Caller frees. */
 
-    return 0;
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
@@ -2001,6 +2132,7 @@ remoteDomainMigratePerform (virDomainPtr
                             const char *dname,
                             unsigned long resource)
 {
+    int rv = -1;
     remote_domain_migrate_perform_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -2015,9 +2147,12 @@ remoteDomainMigratePerform (virDomainPtr
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_PERFORM,
               (xdrproc_t) xdr_remote_domain_migrate_perform_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static virDomainPtr
@@ -2028,7 +2163,7 @@ remoteDomainMigrateFinish (virConnectPtr
                            const char *uri,
                            unsigned long flags)
 {
-    virDomainPtr ddom;
+    virDomainPtr ddom = NULL;
     remote_domain_migrate_finish_args args;
     remote_domain_migrate_finish_ret ret;
     struct private_data *priv = dconn->privateData;
@@ -2043,11 +2178,12 @@ remoteDomainMigrateFinish (virConnectPtr
     if (call (dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_FINISH,
               (xdrproc_t) xdr_remote_domain_migrate_finish_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_migrate_finish_ret, (char *) &ret) == -1)
-        return NULL;
+        goto done;
 
     ddom = get_nonnull_domain (dconn, ret.ddom);
     xdr_free ((xdrproc_t) &xdr_remote_domain_migrate_finish_ret, (char *) &ret);
 
+done:
     return ddom;
 }
 
@@ -2059,6 +2195,7 @@ remoteDomainMigratePrepare2 (virConnectP
                              unsigned long resource,
                              const char *dom_xml)
 {
+    int rv = -1;
     remote_domain_migrate_prepare2_args args;
     remote_domain_migrate_prepare2_ret ret;
     struct private_data *priv = dconn->privateData;
@@ -2073,7 +2210,7 @@ remoteDomainMigratePrepare2 (virConnectP
     if (call (dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_PREPARE2,
               (xdrproc_t) xdr_remote_domain_migrate_prepare2_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_migrate_prepare2_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     if (ret.cookie.cookie_len > 0) {
         *cookie = ret.cookie.cookie_val; /* Caller frees. */
@@ -2082,7 +2219,10 @@ remoteDomainMigratePrepare2 (virConnectP
     if (ret.uri_out)
         *uri_out = *ret.uri_out; /* Caller frees. */
 
-    return 0;
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static virDomainPtr
@@ -2094,7 +2234,7 @@ remoteDomainMigrateFinish2 (virConnectPt
                             unsigned long flags,
                             int retcode)
 {
-    virDomainPtr ddom;
+    virDomainPtr ddom = NULL;
     remote_domain_migrate_finish2_args args;
     remote_domain_migrate_finish2_ret ret;
     struct private_data *priv = dconn->privateData;
@@ -2110,17 +2250,19 @@ remoteDomainMigrateFinish2 (virConnectPt
     if (call (dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_FINISH2,
               (xdrproc_t) xdr_remote_domain_migrate_finish2_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_migrate_finish2_ret, (char *) &ret) == -1)
-        return NULL;
+        goto done;
 
     ddom = get_nonnull_domain (dconn, ret.ddom);
     xdr_free ((xdrproc_t) &xdr_remote_domain_migrate_finish2_ret, (char *) &ret);
 
+done:
     return ddom;
 }
 
 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;
@@ -2130,7 +2272,7 @@ remoteListDefinedDomains (virConnectPtr 
         errorf (conn, VIR_ERR_RPC,
                 _("too many remote domain names: %d > %d"),
                 maxnames, REMOTE_DOMAIN_NAME_LIST_MAX);
-        return -1;
+        goto done;
     }
     args.maxnames = maxnames;
 
@@ -2138,32 +2280,36 @@ remoteListDefinedDomains (virConnectPtr 
     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)
-        return -1;
+        goto done;
 
     if (ret.names.names_len > maxnames) {
         errorf (conn, VIR_ERR_RPC,
                 _("too many remote domain names: %d > %d"),
                 ret.names.names_len, maxnames);
-        xdr_free ((xdrproc_t) xdr_remote_list_defined_domains_ret, (char *) &ret);
-        return -1;
-    }
-
-    /* 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]);
-
+        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]);
+
+    rv = ret.names.names_len;
+
+cleanup:
     xdr_free ((xdrproc_t) xdr_remote_list_defined_domains_ret, (char *) &ret);
 
-    return ret.names.names_len;
+done:
+    return rv;
 }
 
 static int
 remoteNumOfDefinedDomains (virConnectPtr conn)
 {
+    int rv = -1;
     remote_num_of_defined_domains_ret ret;
     struct private_data *priv = conn->privateData;
 
@@ -2171,14 +2317,18 @@ remoteNumOfDefinedDomains (virConnectPtr
     if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_DOMAINS,
               (xdrproc_t) xdr_void, (char *) NULL,
               (xdrproc_t) xdr_remote_num_of_defined_domains_ret, (char *) &ret) == -1)
-        return -1;
-
-    return ret.num;
+        goto done;
+
+    rv = ret.num;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainCreate (virDomainPtr domain)
 {
+    int rv = -1;
     remote_domain_create_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -2187,15 +2337,18 @@ remoteDomainCreate (virDomainPtr domain)
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_CREATE,
               (xdrproc_t) xdr_remote_domain_create_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static virDomainPtr
 remoteDomainDefineXML (virConnectPtr conn, const char *xml)
 {
-    virDomainPtr dom;
+    virDomainPtr dom = NULL;
     remote_domain_define_xml_args args;
     remote_domain_define_xml_ret ret;
     struct private_data *priv = conn->privateData;
@@ -2206,17 +2359,19 @@ remoteDomainDefineXML (virConnectPtr con
     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)
-        return NULL;
+        goto done;
 
     dom = get_nonnull_domain (conn, ret.dom);
     xdr_free ((xdrproc_t) xdr_remote_domain_define_xml_ret, (char *) &ret);
 
+done:
     return dom;
 }
 
 static int
 remoteDomainUndefine (virDomainPtr domain)
 {
+    int rv = -1;
     remote_domain_undefine_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -2225,14 +2380,18 @@ remoteDomainUndefine (virDomainPtr domai
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_UNDEFINE,
               (xdrproc_t) xdr_remote_domain_undefine_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainAttachDevice (virDomainPtr domain, const char *xml)
 {
+    int rv = -1;
     remote_domain_attach_device_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -2242,14 +2401,18 @@ remoteDomainAttachDevice (virDomainPtr d
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_ATTACH_DEVICE,
               (xdrproc_t) xdr_remote_domain_attach_device_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainDetachDevice (virDomainPtr domain, const char *xml)
 {
+    int rv = -1;
     remote_domain_detach_device_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -2259,14 +2422,18 @@ remoteDomainDetachDevice (virDomainPtr d
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_DETACH_DEVICE,
               (xdrproc_t) xdr_remote_domain_detach_device_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainGetAutostart (virDomainPtr domain, int *autostart)
 {
+    int rv = -1;
     remote_domain_get_autostart_args args;
     remote_domain_get_autostart_ret ret;
     struct private_data *priv = domain->conn->privateData;
@@ -2277,15 +2444,19 @@ remoteDomainGetAutostart (virDomainPtr d
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_AUTOSTART,
               (xdrproc_t) xdr_remote_domain_get_autostart_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_get_autostart_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     if (autostart) *autostart = ret.autostart;
-    return 0;
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainSetAutostart (virDomainPtr domain, int autostart)
 {
+    int rv = -1;
     remote_domain_set_autostart_args args;
     struct private_data *priv = domain->conn->privateData;
 
@@ -2295,14 +2466,18 @@ remoteDomainSetAutostart (virDomainPtr d
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_AUTOSTART,
               (xdrproc_t) xdr_remote_domain_set_autostart_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static char *
 remoteDomainGetSchedulerType (virDomainPtr domain, int *nparams)
 {
+    char *rv = NULL;
     remote_domain_get_scheduler_type_args args;
     remote_domain_get_scheduler_type_ret ret;
     struct private_data *priv = domain->conn->privateData;
@@ -2313,21 +2488,25 @@ remoteDomainGetSchedulerType (virDomainP
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_SCHEDULER_TYPE,
               (xdrproc_t) xdr_remote_domain_get_scheduler_type_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_get_scheduler_type_ret, (char *) &ret) == -1)
-        return NULL;
+        goto done;
 
     if (nparams) *nparams = ret.nparams;
 
     /* Caller frees this. */
-    return ret.type;
+    rv = ret.type;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainGetSchedulerParameters (virDomainPtr domain,
                                     virSchedParameterPtr params, int *nparams)
 {
+    int rv = -1;
     remote_domain_get_scheduler_parameters_args args;
     remote_domain_get_scheduler_parameters_ret ret;
-    int i;
+    int i = -1;
     struct private_data *priv = domain->conn->privateData;
 
     make_nonnull_domain (&args.dom, domain);
@@ -2337,16 +2516,15 @@ remoteDomainGetSchedulerParameters (virD
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS,
               (xdrproc_t) xdr_remote_domain_get_scheduler_parameters_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_get_scheduler_parameters_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     /* Check the length of the returned list carefully. */
     if (ret.params.params_len > REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX ||
         ret.params.params_len > *nparams) {
-        xdr_free ((xdrproc_t) xdr_remote_domain_get_scheduler_parameters_ret, (char *) &ret);
         error (domain->conn, VIR_ERR_RPC,
                _("remoteDomainGetSchedulerParameters: "
                  "returned number of parameters exceeds limit"));
-        return -1;
+        goto cleanup;
     }
     *nparams = ret.params.params_len;
 
@@ -2370,22 +2548,31 @@ remoteDomainGetSchedulerParameters (virD
         case VIR_DOMAIN_SCHED_FIELD_BOOLEAN:
             params[i].value.b = ret.params.params_val[i].value.remote_sched_param_value_u.b; break;
         default:
-            xdr_free ((xdrproc_t) xdr_remote_domain_get_scheduler_parameters_ret, (char *) &ret);
             error (domain->conn, VIR_ERR_RPC,
                    _("remoteDomainGetSchedulerParameters: "
                      "unknown parameter type"));
-            return -1;
-        }
-    }
-
+            goto cleanup;
+        }
+    }
+
+    rv = 0;
+
+cleanup:
     xdr_free ((xdrproc_t) xdr_remote_domain_get_scheduler_parameters_ret, (char *) &ret);
-    return 0;
+    if (rv != 0) {
+        for ( ; i >= 0 ; i--)
+            VIR_FREE(params[i].field);
+    }
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainSetSchedulerParameters (virDomainPtr domain,
                                     virSchedParameterPtr params, int nparams)
 {
+    int rv = -1;
     remote_domain_set_scheduler_parameters_args args;
     int i, do_error;
     struct private_data *priv = domain->conn->privateData;
@@ -2396,7 +2583,7 @@ remoteDomainSetSchedulerParameters (virD
     args.params.params_len = nparams;
     if (VIR_ALLOC_N(args.params.params_val, nparams) < 0) {
         error (domain->conn, VIR_ERR_RPC, _("out of memory allocating array"));
-        return -1;
+        goto done;
     }
 
     do_error = 0;
@@ -2429,21 +2616,25 @@ remoteDomainSetSchedulerParameters (virD
 
     if (do_error) {
         xdr_free ((xdrproc_t) xdr_remote_domain_set_scheduler_parameters_args, (char *) &args);
-        return -1;
+        goto done;
     }
 
     if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS,
               (xdrproc_t) xdr_remote_domain_set_scheduler_parameters_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainBlockStats (virDomainPtr domain, const char *path,
                         struct _virDomainBlockStats *stats)
 {
+    int rv = -1;
     remote_domain_block_stats_args args;
     remote_domain_block_stats_ret ret;
     struct private_data *priv = domain->conn->privateData;
@@ -2456,7 +2647,7 @@ remoteDomainBlockStats (virDomainPtr dom
               (xdrproc_t) xdr_remote_domain_block_stats_args, (char *) &args,
               (xdrproc_t) xdr_remote_domain_block_stats_ret, (char *) &ret)
         == -1)
-        return -1;
+        goto done;
 
     stats->rd_req = ret.rd_req;
     stats->rd_bytes = ret.rd_bytes;
@@ -2464,13 +2655,17 @@ remoteDomainBlockStats (virDomainPtr dom
     stats->wr_bytes = ret.wr_bytes;
     stats->errs = ret.errs;
 
-    return 0;
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteDomainInterfaceStats (virDomainPtr domain, const char *path,
                             struct _virDomainInterfaceStats *stats)
 {
+    int rv = -1;
     remote_domain_interface_stats_args args;
     remote_domain_interface_stats_ret ret;
     struct private_data *priv = domain->conn->privateData;
@@ -2484,7 +2679,7 @@ remoteDomainInterfaceStats (virDomainPtr
                 (char *) &args,
               (xdrproc_t) xdr_remote_domain_interface_stats_ret,
                 (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     stats->rx_bytes = ret.rx_bytes;
     stats->rx_packets = ret.rx_packets;
@@ -2495,7 +2690,10 @@ remoteDomainInterfaceStats (virDomainPtr
     stats->tx_errs = ret.tx_errs;
     stats->tx_drop = ret.tx_drop;
 
-    return 0;
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
@@ -2506,6 +2704,7 @@ remoteDomainBlockPeek (virDomainPtr doma
                        void *buffer,
                        unsigned int flags)
 {
+    int rv = -1;
     remote_domain_block_peek_args args;
     remote_domain_block_peek_ret ret;
     struct private_data *priv = domain->conn->privateData;
@@ -2514,7 +2713,7 @@ remoteDomainBlockPeek (virDomainPtr doma
         errorf (domain->conn, VIR_ERR_RPC,
                 _("block peek request too large for remote protocol, %zi > %d"),
                 size, REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX);
-        return -1;
+        goto done;
     }
 
     make_nonnull_domain (&args.dom, domain);
@@ -2529,19 +2728,22 @@ remoteDomainBlockPeek (virDomainPtr doma
                 (char *) &args,
               (xdrproc_t) xdr_remote_domain_block_peek_ret,
                 (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     if (ret.buffer.buffer_len != size) {
-            errorf (domain->conn, VIR_ERR_RPC,
-                    "%s", _("returned buffer is not same size as requested"));
-            free (ret.buffer.buffer_val);
-            return -1;
+        errorf (domain->conn, VIR_ERR_RPC,
+                "%s", _("returned buffer is not same size as requested"));
+        goto cleanup;
     }
 
     memcpy (buffer, ret.buffer.buffer_val, size);
+    rv = 0;
+
+cleanup:
     free (ret.buffer.buffer_val);
 
-    return 0;
+done:
+    return rv;
 }
 
 static int
@@ -2551,6 +2753,7 @@ remoteDomainMemoryPeek (virDomainPtr dom
                         void *buffer,
                         unsigned int flags)
 {
+    int rv = -1;
     remote_domain_memory_peek_args args;
     remote_domain_memory_peek_ret ret;
     struct private_data *priv = domain->conn->privateData;
@@ -2559,7 +2762,7 @@ remoteDomainMemoryPeek (virDomainPtr dom
         errorf (domain->conn, VIR_ERR_RPC,
                 _("memory peek request too large for remote protocol, %zi > %d"),
                 size, REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX);
-        return -1;
+        goto done;
     }
 
     make_nonnull_domain (&args.dom, domain);
@@ -2573,19 +2776,22 @@ remoteDomainMemoryPeek (virDomainPtr dom
                 (char *) &args,
               (xdrproc_t) xdr_remote_domain_memory_peek_ret,
                 (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     if (ret.buffer.buffer_len != size) {
-            errorf (domain->conn, VIR_ERR_RPC,
-                    "%s", _("returned buffer is not same size as requested"));
-            free (ret.buffer.buffer_val);
-            return -1;
+        errorf (domain->conn, VIR_ERR_RPC,
+                "%s", _("returned buffer is not same size as requested"));
+        goto cleanup;
     }
 
     memcpy (buffer, ret.buffer.buffer_val, size);
+    rv = 0;
+
+cleanup:
     free (ret.buffer.buffer_val);
 
-    return 0;
+done:
+    return rv;
 }
 
 /*----------------------------------------------------------------------*/
@@ -2639,23 +2845,24 @@ static int
 static int
 remoteNetworkClose (virConnectPtr conn)
 {
-    int ret = 0;
+    int rv = 0;
     struct private_data *priv = conn->networkPrivateData;
 
     if (priv->localUses) {
         priv->localUses--;
         if (!priv->localUses) {
-            ret = doRemoteClose(conn, priv);
+            rv = doRemoteClose(conn, priv);
             VIR_FREE(priv);
             conn->networkPrivateData = NULL;
         }
     }
-    return ret;
+    return rv;
 }
 
 static int
 remoteNumOfNetworks (virConnectPtr conn)
 {
+    int rv = -1;
     remote_num_of_networks_ret ret;
     struct private_data *priv = conn->networkPrivateData;
 
@@ -2663,14 +2870,18 @@ remoteNumOfNetworks (virConnectPtr conn)
     if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_NETWORKS,
               (xdrproc_t) xdr_void, (char *) NULL,
               (xdrproc_t) xdr_remote_num_of_networks_ret, (char *) &ret) == -1)
-        return -1;
-
-    return ret.num;
+        goto done;
+
+    rv = ret.num;
+
+done:
+    return rv;
 }
 
 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;
@@ -2680,7 +2891,7 @@ remoteListNetworks (virConnectPtr conn, 
         errorf (conn, VIR_ERR_RPC,
                 _("too many remote networks: %d > %d"),
                 maxnames, REMOTE_NETWORK_NAME_LIST_MAX);
-        return -1;
+        goto done;
     }
     args.maxnames = maxnames;
 
@@ -2688,32 +2899,36 @@ remoteListNetworks (virConnectPtr conn, 
     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)
-        return -1;
+        goto done;
 
     if (ret.names.names_len > maxnames) {
         errorf (conn, VIR_ERR_RPC,
                 _("too many remote networks: %d > %d"),
                 ret.names.names_len, maxnames);
-        xdr_free ((xdrproc_t) xdr_remote_list_networks_ret, (char *) &ret);
-        return -1;
-    }
-
-    /* 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]);
-
+        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]);
+
+    rv = ret.names.names_len;
+
+cleanup:
     xdr_free ((xdrproc_t) xdr_remote_list_networks_ret, (char *) &ret);
 
-    return ret.names.names_len;
+done:
+    return rv;
 }
 
 static int
 remoteNumOfDefinedNetworks (virConnectPtr conn)
 {
+    int rv = -1;
     remote_num_of_defined_networks_ret ret;
     struct private_data *priv = conn->networkPrivateData;
 
@@ -2721,15 +2936,19 @@ remoteNumOfDefinedNetworks (virConnectPt
     if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_NETWORKS,
               (xdrproc_t) xdr_void, (char *) NULL,
               (xdrproc_t) xdr_remote_num_of_defined_networks_ret, (char *) &ret) == -1)
-        return -1;
-
-    return ret.num;
+        goto done;
+
+    rv = ret.num;
+
+done:
+    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;
@@ -2739,7 +2958,7 @@ remoteListDefinedNetworks (virConnectPtr
         errorf (conn, VIR_ERR_RPC,
                 _("too many remote networks: %d > %d"),
                 maxnames, REMOTE_NETWORK_NAME_LIST_MAX);
-        return -1;
+        goto done;
     }
     args.maxnames = maxnames;
 
@@ -2747,34 +2966,37 @@ remoteListDefinedNetworks (virConnectPtr
     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)
-        return -1;
+        goto done;
 
     if (ret.names.names_len > maxnames) {
         errorf (conn, VIR_ERR_RPC,
                 _("too many remote networks: %d > %d"),
                 ret.names.names_len, maxnames);
-        xdr_free ((xdrproc_t) xdr_remote_list_defined_networks_ret, (char *) &ret);
-        return -1;
-    }
-
-    /* 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]);
-
+        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]);
+
+    rv = ret.names.names_len;
+
+cleanup:
     xdr_free ((xdrproc_t) xdr_remote_list_defined_networks_ret, (char *) &ret);
 
-    return ret.names.names_len;
+done:
+    return rv;
 }
 
 static virNetworkPtr
 remoteNetworkLookupByUUID (virConnectPtr conn,
                            const unsigned char *uuid)
 {
-    virNetworkPtr net;
+    virNetworkPtr net = NULL;
     remote_network_lookup_by_uuid_args args;
     remote_network_lookup_by_uuid_ret ret;
     struct private_data *priv = conn->networkPrivateData;
@@ -2785,11 +3007,12 @@ remoteNetworkLookupByUUID (virConnectPtr
     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)
-        return NULL;
+        goto done;
 
     net = get_nonnull_network (conn, ret.net);
     xdr_free ((xdrproc_t) &xdr_remote_network_lookup_by_uuid_ret, (char *) &ret);
 
+done:
     return net;
 }
 
@@ -2797,7 +3020,7 @@ remoteNetworkLookupByName (virConnectPtr
 remoteNetworkLookupByName (virConnectPtr conn,
                            const char *name)
 {
-    virNetworkPtr net;
+    virNetworkPtr net = NULL;
     remote_network_lookup_by_name_args args;
     remote_network_lookup_by_name_ret ret;
     struct private_data *priv = conn->networkPrivateData;
@@ -2808,18 +3031,19 @@ remoteNetworkLookupByName (virConnectPtr
     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)
-        return NULL;
+        goto done;
 
     net = get_nonnull_network (conn, ret.net);
     xdr_free ((xdrproc_t) &xdr_remote_network_lookup_by_name_ret, (char *) &ret);
 
+done:
     return net;
 }
 
 static virNetworkPtr
 remoteNetworkCreateXML (virConnectPtr conn, const char *xmlDesc)
 {
-    virNetworkPtr net;
+    virNetworkPtr net = NULL;
     remote_network_create_xml_args args;
     remote_network_create_xml_ret ret;
     struct private_data *priv = conn->networkPrivateData;
@@ -2830,18 +3054,19 @@ remoteNetworkCreateXML (virConnectPtr co
     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)
-        return NULL;
+        goto done;
 
     net = get_nonnull_network (conn, ret.net);
     xdr_free ((xdrproc_t) &xdr_remote_network_create_xml_ret, (char *) &ret);
 
+done:
     return net;
 }
 
 static virNetworkPtr
 remoteNetworkDefineXML (virConnectPtr conn, const char *xml)
 {
-    virNetworkPtr net;
+    virNetworkPtr net = NULL;
     remote_network_define_xml_args args;
     remote_network_define_xml_ret ret;
     struct private_data *priv = conn->networkPrivateData;
@@ -2852,17 +3077,19 @@ remoteNetworkDefineXML (virConnectPtr co
     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)
-        return NULL;
+        goto done;
 
     net = get_nonnull_network (conn, ret.net);
     xdr_free ((xdrproc_t) &xdr_remote_network_define_xml_ret, (char *) &ret);
 
+done:
     return net;
 }
 
 static int
 remoteNetworkUndefine (virNetworkPtr network)
 {
+    int rv = -1;
     remote_network_undefine_args args;
     struct private_data *priv = network->conn->networkPrivateData;
 
@@ -2871,14 +3098,18 @@ remoteNetworkUndefine (virNetworkPtr net
     if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_UNDEFINE,
               (xdrproc_t) xdr_remote_network_undefine_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteNetworkCreate (virNetworkPtr network)
 {
+    int rv = -1;
     remote_network_create_args args;
     struct private_data *priv = network->conn->networkPrivateData;
 
@@ -2887,14 +3118,18 @@ remoteNetworkCreate (virNetworkPtr netwo
     if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_CREATE,
               (xdrproc_t) xdr_remote_network_create_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteNetworkDestroy (virNetworkPtr network)
 {
+    int rv = -1;
     remote_network_destroy_args args;
     struct private_data *priv = network->conn->networkPrivateData;
 
@@ -2903,14 +3138,18 @@ remoteNetworkDestroy (virNetworkPtr netw
     if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_DESTROY,
               (xdrproc_t) xdr_remote_network_destroy_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static char *
 remoteNetworkDumpXML (virNetworkPtr network, int flags)
 {
+    char *rv = NULL;
     remote_network_dump_xml_args args;
     remote_network_dump_xml_ret ret;
     struct private_data *priv = network->conn->networkPrivateData;
@@ -2922,15 +3161,19 @@ remoteNetworkDumpXML (virNetworkPtr netw
     if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_DUMP_XML,
               (xdrproc_t) xdr_remote_network_dump_xml_args, (char *) &args,
               (xdrproc_t) xdr_remote_network_dump_xml_ret, (char *) &ret) == -1)
-        return NULL;
-
-    /* Caller frees. */
-    return ret.xml;
+        goto done;
+
+    /* Caller frees. */
+    rv = ret.xml;
+
+done:
+    return rv;
 }
 
 static char *
 remoteNetworkGetBridgeName (virNetworkPtr network)
 {
+    char *rv = NULL;
     remote_network_get_bridge_name_args args;
     remote_network_get_bridge_name_ret ret;
     struct private_data *priv = network->conn->networkPrivateData;
@@ -2941,15 +3184,19 @@ remoteNetworkGetBridgeName (virNetworkPt
     if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_GET_BRIDGE_NAME,
               (xdrproc_t) xdr_remote_network_get_bridge_name_args, (char *) &args,
               (xdrproc_t) xdr_remote_network_get_bridge_name_ret, (char *) &ret) == -1)
-        return NULL;
-
-    /* Caller frees. */
-    return ret.name;
+        goto done;
+
+    /* Caller frees. */
+    rv = ret.name;
+
+done:
+    return rv;
 }
 
 static int
 remoteNetworkGetAutostart (virNetworkPtr network, int *autostart)
 {
+    int rv = -1;
     remote_network_get_autostart_args args;
     remote_network_get_autostart_ret ret;
     struct private_data *priv = network->conn->networkPrivateData;
@@ -2960,16 +3207,20 @@ remoteNetworkGetAutostart (virNetworkPtr
     if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_GET_AUTOSTART,
               (xdrproc_t) xdr_remote_network_get_autostart_args, (char *) &args,
               (xdrproc_t) xdr_remote_network_get_autostart_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     if (autostart) *autostart = ret.autostart;
 
-    return 0;
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteNetworkSetAutostart (virNetworkPtr network, int autostart)
 {
+    int rv = -1;
     remote_network_set_autostart_args args;
     struct private_data *priv = network->conn->networkPrivateData;
 
@@ -2979,9 +3230,12 @@ remoteNetworkSetAutostart (virNetworkPtr
     if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_SET_AUTOSTART,
               (xdrproc_t) xdr_remote_network_set_autostart_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 
@@ -3054,12 +3308,14 @@ remoteStorageClose (virConnectPtr conn)
             conn->storagePrivateData = NULL;
         }
     }
+
     return ret;
 }
 
 static int
 remoteNumOfStoragePools (virConnectPtr conn)
 {
+    int rv = -1;
     remote_num_of_storage_pools_ret ret;
     struct private_data *priv = conn->storagePrivateData;
 
@@ -3067,14 +3323,18 @@ remoteNumOfStoragePools (virConnectPtr c
     if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_STORAGE_POOLS,
               (xdrproc_t) xdr_void, (char *) NULL,
               (xdrproc_t) xdr_remote_num_of_storage_pools_ret, (char *) &ret) == -1)
-        return -1;
-
-    return ret.num;
+        goto done;
+
+    rv = ret.num;
+
+done:
+    return rv;
 }
 
 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;
@@ -3082,7 +3342,7 @@ remoteListStoragePools (virConnectPtr co
 
     if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
         error (conn, VIR_ERR_RPC, _("too many storage pools requested"));
-        return -1;
+        goto done;
     }
     args.maxnames = maxnames;
 
@@ -3090,30 +3350,34 @@ remoteListStoragePools (virConnectPtr co
     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)
-        return -1;
+        goto done;
 
     if (ret.names.names_len > maxnames) {
         error (conn, VIR_ERR_RPC, _("too many storage pools received"));
-        xdr_free ((xdrproc_t) xdr_remote_list_storage_pools_ret, (char *) &ret);
-        return -1;
-    }
-
-    /* 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]);
-
+        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]);
+
+    rv = ret.names.names_len;
+
+cleanup:
     xdr_free ((xdrproc_t) xdr_remote_list_storage_pools_ret, (char *) &ret);
 
-    return ret.names.names_len;
+done:
+    return rv;
 }
 
 static int
 remoteNumOfDefinedStoragePools (virConnectPtr conn)
 {
+    int rv = -1;
     remote_num_of_defined_storage_pools_ret ret;
     struct private_data *priv = conn->storagePrivateData;
 
@@ -3121,15 +3385,19 @@ remoteNumOfDefinedStoragePools (virConne
     if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS,
               (xdrproc_t) xdr_void, (char *) NULL,
               (xdrproc_t) xdr_remote_num_of_defined_storage_pools_ret, (char *) &ret) == -1)
-        return -1;
-
-    return ret.num;
+        goto done;
+
+    rv = ret.num;
+
+done:
+    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;
@@ -3137,7 +3405,7 @@ remoteListDefinedStoragePools (virConnec
 
     if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
         error (conn, VIR_ERR_RPC, _("too many storage pools requested"));
-        return -1;
+        goto done;
     }
     args.maxnames = maxnames;
 
@@ -3145,25 +3413,28 @@ remoteListDefinedStoragePools (virConnec
     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)
-        return -1;
+        goto done;
 
     if (ret.names.names_len > maxnames) {
         error (conn, VIR_ERR_RPC, _("too many storage pools received"));
-        xdr_free ((xdrproc_t) xdr_remote_list_defined_storage_pools_ret, (char *) &ret);
-        return -1;
-    }
-
-    /* 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]);
-
+        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]);
+
+    rv = ret.names.names_len;
+
+cleanup:
     xdr_free ((xdrproc_t) xdr_remote_list_defined_storage_pools_ret, (char *) &ret);
 
-    return ret.names.names_len;
+done:
+    return rv;
 }
 
 static char *
@@ -3172,11 +3443,11 @@ remoteFindStoragePoolSources (virConnect
                               const char *srcSpec,
                               unsigned int flags)
 {
+    char *rv = NULL;
     remote_find_storage_pool_sources_args args;
     remote_find_storage_pool_sources_ret ret;
     struct private_data *priv = conn->storagePrivateData;
     const char *emptyString = "";
-    char *retval;
 
     args.type = (char*)type;
     /*
@@ -3197,21 +3468,22 @@ remoteFindStoragePoolSources (virConnect
     if (call (conn, priv, 0, REMOTE_PROC_FIND_STORAGE_POOL_SOURCES,
               (xdrproc_t) xdr_remote_find_storage_pool_sources_args, (char *) &args,
               (xdrproc_t) xdr_remote_find_storage_pool_sources_ret, (char *) &ret) == -1)
-        return NULL;
-
-    retval = ret.xml;
+        goto done;
+
+    rv = ret.xml;
     ret.xml = NULL; /* To stop xdr_free free'ing it */
 
     xdr_free ((xdrproc_t) xdr_remote_find_storage_pool_sources_ret, (char *) &ret);
 
-    return retval;
+done:
+    return rv;
 }
 
 static virStoragePoolPtr
 remoteStoragePoolLookupByUUID (virConnectPtr conn,
                                const unsigned char *uuid)
 {
-    virStoragePoolPtr pool;
+    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;
@@ -3222,11 +3494,12 @@ remoteStoragePoolLookupByUUID (virConnec
     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)
-        return NULL;
+        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:
     return pool;
 }
 
@@ -3234,7 +3507,7 @@ remoteStoragePoolLookupByName (virConnec
 remoteStoragePoolLookupByName (virConnectPtr conn,
                                const char *name)
 {
-    virStoragePoolPtr pool;
+    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;
@@ -3245,18 +3518,19 @@ remoteStoragePoolLookupByName (virConnec
     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)
-        return NULL;
+        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:
     return pool;
 }
 
 static virStoragePoolPtr
 remoteStoragePoolLookupByVolume (virStorageVolPtr vol)
 {
-    virStoragePoolPtr pool;
+    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;
@@ -3267,11 +3541,12 @@ remoteStoragePoolLookupByVolume (virStor
     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)
-        return NULL;
+        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:
     return pool;
 }
 
@@ -3279,7 +3554,7 @@ static virStoragePoolPtr
 static virStoragePoolPtr
 remoteStoragePoolCreateXML (virConnectPtr conn, const char *xmlDesc, unsigned int flags)
 {
-    virStoragePoolPtr pool;
+    virStoragePoolPtr pool = NULL;
     remote_storage_pool_create_xml_args args;
     remote_storage_pool_create_xml_ret ret;
     struct private_data *priv = conn->storagePrivateData;
@@ -3291,18 +3566,19 @@ remoteStoragePoolCreateXML (virConnectPt
     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)
-        return NULL;
+        goto done;
 
     pool = get_nonnull_storage_pool (conn, ret.pool);
     xdr_free ((xdrproc_t) &xdr_remote_storage_pool_create_xml_ret, (char *) &ret);
 
+done:
     return pool;
 }
 
 static virStoragePoolPtr
 remoteStoragePoolDefineXML (virConnectPtr conn, const char *xml, unsigned int flags)
 {
-    virStoragePoolPtr pool;
+    virStoragePoolPtr pool = NULL;
     remote_storage_pool_define_xml_args args;
     remote_storage_pool_define_xml_ret ret;
     struct private_data *priv = conn->storagePrivateData;
@@ -3314,17 +3590,19 @@ remoteStoragePoolDefineXML (virConnectPt
     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)
-        return NULL;
+        goto done;
 
     pool = get_nonnull_storage_pool (conn, ret.pool);
     xdr_free ((xdrproc_t) &xdr_remote_storage_pool_define_xml_ret, (char *) &ret);
 
+done:
     return pool;
 }
 
 static int
 remoteStoragePoolUndefine (virStoragePoolPtr pool)
 {
+    int rv = -1;
     remote_storage_pool_undefine_args args;
     struct private_data *priv = pool->conn->storagePrivateData;
 
@@ -3333,14 +3611,18 @@ remoteStoragePoolUndefine (virStoragePoo
     if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_UNDEFINE,
               (xdrproc_t) xdr_remote_storage_pool_undefine_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteStoragePoolCreate (virStoragePoolPtr pool, unsigned int flags)
 {
+    int rv = -1;
     remote_storage_pool_create_args args;
     struct private_data *priv = pool->conn->storagePrivateData;
 
@@ -3350,15 +3632,19 @@ remoteStoragePoolCreate (virStoragePoolP
     if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_CREATE,
               (xdrproc_t) xdr_remote_storage_pool_create_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteStoragePoolBuild (virStoragePoolPtr pool,
                         unsigned int flags)
 {
+    int rv = -1;
     remote_storage_pool_build_args args;
     struct private_data *priv = pool->conn->storagePrivateData;
 
@@ -3368,14 +3654,18 @@ remoteStoragePoolBuild (virStoragePoolPt
     if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_BUILD,
               (xdrproc_t) xdr_remote_storage_pool_build_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteStoragePoolDestroy (virStoragePoolPtr pool)
 {
+    int rv = -1;
     remote_storage_pool_destroy_args args;
     struct private_data *priv = pool->conn->storagePrivateData;
 
@@ -3384,15 +3674,19 @@ remoteStoragePoolDestroy (virStoragePool
     if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DESTROY,
               (xdrproc_t) xdr_remote_storage_pool_destroy_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteStoragePoolDelete (virStoragePoolPtr pool,
                          unsigned int flags)
 {
+    int rv = -1;
     remote_storage_pool_delete_args args;
     struct private_data *priv = pool->conn->storagePrivateData;
 
@@ -3402,15 +3696,19 @@ remoteStoragePoolDelete (virStoragePoolP
     if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DELETE,
               (xdrproc_t) xdr_remote_storage_pool_delete_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteStoragePoolRefresh (virStoragePoolPtr pool,
                           unsigned int flags)
 {
+    int rv = -1;
     remote_storage_pool_refresh_args args;
     struct private_data *priv = pool->conn->storagePrivateData;
 
@@ -3420,14 +3718,18 @@ remoteStoragePoolRefresh (virStoragePool
     if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_REFRESH,
               (xdrproc_t) xdr_remote_storage_pool_refresh_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteStoragePoolGetInfo (virStoragePoolPtr pool, virStoragePoolInfoPtr info)
 {
+    int rv = -1;
     remote_storage_pool_get_info_args args;
     remote_storage_pool_get_info_ret ret;
     struct private_data *priv = pool->conn->storagePrivateData;
@@ -3438,20 +3740,24 @@ remoteStoragePoolGetInfo (virStoragePool
     if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_GET_INFO,
               (xdrproc_t) xdr_remote_storage_pool_get_info_args, (char *) &args,
               (xdrproc_t) xdr_remote_storage_pool_get_info_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     info->state = ret.state;
     info->capacity = ret.capacity;
     info->allocation = ret.allocation;
     info->available = ret.available;
 
-    return 0;
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static char *
 remoteStoragePoolDumpXML (virStoragePoolPtr pool,
                           unsigned int flags)
 {
+    char *rv = NULL;
     remote_storage_pool_dump_xml_args args;
     remote_storage_pool_dump_xml_ret ret;
     struct private_data *priv = pool->conn->storagePrivateData;
@@ -3463,15 +3769,19 @@ remoteStoragePoolDumpXML (virStoragePool
     if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DUMP_XML,
               (xdrproc_t) xdr_remote_storage_pool_dump_xml_args, (char *) &args,
               (xdrproc_t) xdr_remote_storage_pool_dump_xml_ret, (char *) &ret) == -1)
-        return NULL;
-
-    /* Caller frees. */
-    return ret.xml;
+        goto done;
+
+    /* Caller frees. */
+    rv = ret.xml;
+
+done:
+    return rv;
 }
 
 static int
 remoteStoragePoolGetAutostart (virStoragePoolPtr pool, int *autostart)
 {
+    int rv = -1;
     remote_storage_pool_get_autostart_args args;
     remote_storage_pool_get_autostart_ret ret;
     struct private_data *priv = pool->conn->storagePrivateData;
@@ -3482,16 +3792,20 @@ remoteStoragePoolGetAutostart (virStorag
     if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART,
               (xdrproc_t) xdr_remote_storage_pool_get_autostart_args, (char *) &args,
               (xdrproc_t) xdr_remote_storage_pool_get_autostart_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     if (autostart) *autostart = ret.autostart;
 
-    return 0;
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteStoragePoolSetAutostart (virStoragePoolPtr pool, int autostart)
 {
+    int rv = -1;
     remote_storage_pool_set_autostart_args args;
     struct private_data *priv = pool->conn->storagePrivateData;
 
@@ -3501,15 +3815,19 @@ remoteStoragePoolSetAutostart (virStorag
     if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART,
               (xdrproc_t) xdr_remote_storage_pool_set_autostart_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 
 static int
 remoteStoragePoolNumOfVolumes (virStoragePoolPtr pool)
 {
+    int rv = -1;
     remote_storage_pool_num_of_volumes_args args;
     remote_storage_pool_num_of_volumes_ret ret;
     struct private_data *priv = pool->conn->storagePrivateData;
@@ -3520,14 +3838,18 @@ remoteStoragePoolNumOfVolumes (virStorag
     if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES,
               (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_args, (char *) &args,
               (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_ret, (char *) &ret) == -1)
-        return -1;
-
-    return ret.num;
+        goto done;
+
+    rv = ret.num;
+
+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;
@@ -3535,7 +3857,7 @@ remoteStoragePoolListVolumes (virStorage
 
     if (maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX) {
         error (pool->conn, VIR_ERR_RPC, _("too many storage volumes requested"));
-        return -1;
+        goto done;
     }
     args.maxnames = maxnames;
     make_nonnull_storage_pool(&args.pool, pool);
@@ -3544,25 +3866,28 @@ remoteStoragePoolListVolumes (virStorage
     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)
-        return -1;
+        goto done;
 
     if (ret.names.names_len > maxnames) {
         error (pool->conn, VIR_ERR_RPC, _("too many storage volumes received"));
-        xdr_free ((xdrproc_t) xdr_remote_storage_pool_list_volumes_ret, (char *) &ret);
-        return -1;
-    }
-
-    /* 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]);
-
+        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]);
+
+    rv = ret.names.names_len;
+
+cleanup:
     xdr_free ((xdrproc_t) xdr_remote_storage_pool_list_volumes_ret, (char *) &ret);
 
-    return ret.names.names_len;
+done:
+    return rv;
 }
 
 
@@ -3571,7 +3896,7 @@ remoteStorageVolLookupByName (virStorage
 remoteStorageVolLookupByName (virStoragePoolPtr pool,
                               const char *name)
 {
-    virStorageVolPtr vol;
+    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;
@@ -3583,11 +3908,12 @@ remoteStorageVolLookupByName (virStorage
     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)
-        return NULL;
+        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:
     return vol;
 }
 
@@ -3595,7 +3921,7 @@ remoteStorageVolLookupByKey (virConnectP
 remoteStorageVolLookupByKey (virConnectPtr conn,
                              const char *key)
 {
-    virStorageVolPtr vol;
+    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;
@@ -3606,11 +3932,12 @@ remoteStorageVolLookupByKey (virConnectP
     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)
-        return NULL;
+        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:
     return vol;
 }
 
@@ -3618,7 +3945,7 @@ remoteStorageVolLookupByPath (virConnect
 remoteStorageVolLookupByPath (virConnectPtr conn,
                               const char *path)
 {
-    virStorageVolPtr vol;
+    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;
@@ -3629,11 +3956,12 @@ remoteStorageVolLookupByPath (virConnect
     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)
-        return NULL;
+        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:
     return vol;
 }
 
@@ -3641,7 +3969,7 @@ remoteStorageVolCreateXML (virStoragePoo
 remoteStorageVolCreateXML (virStoragePoolPtr pool, const char *xmlDesc,
                            unsigned int flags)
 {
-    virStorageVolPtr vol;
+    virStorageVolPtr vol = NULL;
     remote_storage_vol_create_xml_args args;
     remote_storage_vol_create_xml_ret ret;
     struct private_data *priv = pool->conn->storagePrivateData;
@@ -3654,11 +3982,12 @@ remoteStorageVolCreateXML (virStoragePoo
     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)
-        return NULL;
+        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:
     return vol;
 }
 
@@ -3666,6 +3995,7 @@ remoteStorageVolDelete (virStorageVolPtr
 remoteStorageVolDelete (virStorageVolPtr vol,
                         unsigned int flags)
 {
+    int rv = -1;
     remote_storage_vol_delete_args args;
     struct private_data *priv = vol->conn->storagePrivateData;
 
@@ -3675,14 +4005,18 @@ remoteStorageVolDelete (virStorageVolPtr
     if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_DELETE,
               (xdrproc_t) xdr_remote_storage_vol_delete_args, (char *) &args,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
-        return -1;
-
-    return 0;
+        goto done;
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int
 remoteStorageVolGetInfo (virStorageVolPtr vol, virStorageVolInfoPtr info)
 {
+    int rv = -1;
     remote_storage_vol_get_info_args args;
     remote_storage_vol_get_info_ret ret;
     struct private_data *priv = vol->conn->storagePrivateData;
@@ -3693,19 +4027,23 @@ remoteStorageVolGetInfo (virStorageVolPt
     if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_GET_INFO,
               (xdrproc_t) xdr_remote_storage_vol_get_info_args, (char *) &args,
               (xdrproc_t) xdr_remote_storage_vol_get_info_ret, (char *) &ret) == -1)
-        return -1;
+        goto done;
 
     info->type = ret.type;
     info->capacity = ret.capacity;
     info->allocation = ret.allocation;
 
-    return 0;
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static char *
 remoteStorageVolDumpXML (virStorageVolPtr vol,
                          unsigned int flags)
 {
+    char *rv = NULL;
     remote_storage_vol_dump_xml_args args;
     remote_storage_vol_dump_xml_ret ret;
     struct private_data *priv = vol->conn->storagePrivateData;
@@ -3717,15 +4055,19 @@ remoteStorageVolDumpXML (virStorageVolPt
     if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_DUMP_XML,
               (xdrproc_t) xdr_remote_storage_vol_dump_xml_args, (char *) &args,
               (xdrproc_t) xdr_remote_storage_vol_dump_xml_ret, (char *) &ret) == -1)
-        return NULL;
-
-    /* Caller frees. */
-    return ret.xml;
+        goto done;
+
+    /* Caller frees. */
+    rv = ret.xml;
+
+done:
+    return rv;
 }
 
 static char *
 remoteStorageVolGetPath (virStorageVolPtr vol)
 {
+    char *rv = NULL;
     remote_storage_vol_get_path_args args;
     remote_storage_vol_get_path_ret ret;
     struct private_data *priv = vol->conn->storagePrivateData;
@@ -3736,10 +4078,13 @@ remoteStorageVolGetPath (virStorageVolPt
     if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_GET_PATH,
               (xdrproc_t) xdr_remote_storage_vol_get_path_args, (char *) &args,
               (xdrproc_t) xdr_remote_storage_vol_get_path_ret, (char *) &ret) == -1)
-        return NULL;
-
-    /* Caller frees. */
-    return ret.name;
+        goto done;
+
+    /* Caller frees. */
+    rv = ret.name;
+
+done:
+    return rv;
 }
 
 
@@ -3785,6 +4130,7 @@ static int remoteNodeNumOfDevices(virCon
                                   const char *cap,
                                   unsigned int flags)
 {
+    int rv = -1;
     remote_node_num_of_devices_args args;
     remote_node_num_of_devices_ret ret;
     struct private_data *priv = conn->devMonPrivateData;
@@ -3796,9 +4142,12 @@ static int remoteNodeNumOfDevices(virCon
     if (call (conn, priv, 0, REMOTE_PROC_NODE_NUM_OF_DEVICES,
               (xdrproc_t) xdr_remote_node_num_of_devices_args, (char *) &args,
               (xdrproc_t) xdr_remote_node_num_of_devices_ret, (char *) &ret) == -1)
-        return -1;
-
-    return ret.num;
+        goto done;
+
+    rv = ret.num;
+
+done:
+    return rv;
 }
 
 
@@ -3808,6 +4157,7 @@ static int remoteNodeListDevices(virConn
                                  int maxnames,
                                  unsigned int flags)
 {
+    int rv = -1;
     int i;
     remote_node_list_devices_args args;
     remote_node_list_devices_ret ret;
@@ -3815,7 +4165,7 @@ static int remoteNodeListDevices(virConn
 
     if (maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX) {
         error (conn, VIR_ERR_RPC, _("too many device names requested"));
-        return -1;
+        goto done;
     }
     args.cap = cap ? (char **)&cap : NULL;
     args.maxnames = maxnames;
@@ -3825,25 +4175,28 @@ static int remoteNodeListDevices(virConn
     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)
-        return -1;
+        goto done;
 
     if (ret.names.names_len > maxnames) {
         error (conn, VIR_ERR_RPC, _("too many device names received"));
-        xdr_free ((xdrproc_t) xdr_remote_node_list_devices_ret, (char *) &ret);
-        return -1;
-    }
-
-    /* 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]);
-
+        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]);
+
+    rv = ret.names.names_len;
+
+cleanup:
     xdr_free ((xdrproc_t) xdr_remote_node_list_devices_ret, (char *) &ret);
 
-    return ret.names.names_len;
+done:
+    return rv;
 }
 
 
@@ -3852,7 +4205,7 @@ static virNodeDevicePtr remoteNodeDevice
 {
     remote_node_device_lookup_by_name_args args;
     remote_node_device_lookup_by_name_ret ret;
-    virNodeDevicePtr dev;
+    virNodeDevicePtr dev = NULL;
     struct private_data *priv = conn->devMonPrivateData;
 
     args.name = (char *)name;
@@ -3861,18 +4214,20 @@ static virNodeDevicePtr remoteNodeDevice
     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)
-        return NULL;
+        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:
     return dev;
 }
 
 static char *remoteNodeDeviceDumpXML(virNodeDevicePtr dev,
                                      unsigned int flags)
 {
+    char *rv = NULL;
     remote_node_device_dump_xml_args args;
     remote_node_device_dump_xml_ret ret;
     struct private_data *priv = dev->conn->devMonPrivateData;
@@ -3884,14 +4239,18 @@ static char *remoteNodeDeviceDumpXML(vir
     if (call (dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_DUMP_XML,
               (xdrproc_t) xdr_remote_node_device_dump_xml_args, (char *) &args,
               (xdrproc_t) xdr_remote_node_device_dump_xml_ret, (char *) &ret) == -1)
-        return NULL;
-
-    /* Caller frees. */
-    return ret.xml;
+        goto done;
+
+    /* Caller frees. */
+    rv = ret.xml;
+
+done:
+    return rv;
 }
 
 static char *remoteNodeDeviceGetParent(virNodeDevicePtr dev)
 {
+    char *rv = NULL;
     remote_node_device_get_parent_args args;
     remote_node_device_get_parent_ret ret;
     struct private_data *priv = dev->conn->devMonPrivateData;
@@ -3902,14 +4261,18 @@ static char *remoteNodeDeviceGetParent(v
     if (call (dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_GET_PARENT,
               (xdrproc_t) xdr_remote_node_device_get_parent_args, (char *) &args,
               (xdrproc_t) xdr_remote_node_device_get_parent_ret, (char *) &ret) == -1)
-        return NULL;
-
-    /* Caller frees. */
-    return ret.parent ? *ret.parent : NULL;
+        goto done;
+
+    /* Caller frees. */
+    rv = ret.parent ? *ret.parent : NULL;
+
+done:
+    return rv;
 }
 
 static int remoteNodeDeviceNumOfCaps(virNodeDevicePtr dev)
 {
+    int rv = -1;
     remote_node_device_num_of_caps_args args;
     remote_node_device_num_of_caps_ret ret;
     struct private_data *priv = dev->conn->devMonPrivateData;
@@ -3920,15 +4283,19 @@ static int remoteNodeDeviceNumOfCaps(vir
     if (call (dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_NUM_OF_CAPS,
               (xdrproc_t) xdr_remote_node_device_num_of_caps_args, (char *) &args,
               (xdrproc_t) xdr_remote_node_device_num_of_caps_ret, (char *) &ret) == -1)
-        return -1;
-
-    return ret.num;
+        goto done;
+
+    rv = ret.num;
+
+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;
@@ -3936,7 +4303,7 @@ static int remoteNodeDeviceListCaps(virN
 
     if (maxnames > REMOTE_NODE_DEVICE_CAPS_LIST_MAX) {
         error (dev->conn, VIR_ERR_RPC, _("too many capability names requested"));
-        return -1;
+        goto done;
     }
     args.maxnames = maxnames;
     args.name = dev->name;
@@ -3945,25 +4312,28 @@ static int remoteNodeDeviceListCaps(virN
     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)
-        return -1;
+        goto done;
 
     if (ret.names.names_len > maxnames) {
         error (dev->conn, VIR_ERR_RPC, _("too many capability names received"));
-        xdr_free ((xdrproc_t) xdr_remote_node_device_list_caps_ret, (char *) &ret);
-        return -1;
-    }
-
-    /* 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]);
-
+        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]);
+
+    rv = ret.names.names_len;
+
+cleanup:
     xdr_free ((xdrproc_t) xdr_remote_node_device_list_caps_ret, (char *) &ret);
 
-    return ret.names.names_len;
+done:
+    return rv;
 }
 
 
@@ -4620,6 +4990,7 @@ remoteAuthSASL (virConnectPtr conn, stru
     remoteAuthFreeCredentials(cred, ncred);
     if (ret != 0 && saslconn)
         sasl_dispose(&saslconn);
+
     return ret;
 }
 #endif /* HAVE_SASL */
@@ -4684,16 +5055,17 @@ static int remoteDomainEventRegister (vi
                                       void *opaque ATTRIBUTE_UNUSED,
                                       virFreeCallback freecb)
 {
+    int rv = -1;
     struct private_data *priv = conn->privateData;
 
     if (priv->eventFlushTimer < 0) {
          error (conn, VIR_ERR_NO_SUPPORT, _("no event support"));
-         return -1;
+         goto done;
     }
     if (virDomainEventCallbackListAdd(conn, priv->callbackList,
                                       callback, opaque, freecb) < 0) {
          error (conn, VIR_ERR_RPC, _("adding cb to list"));
-         return -1;
+         goto done;
     }
 
     if ( priv->callbackList->count == 1 ) {
@@ -4701,21 +5073,25 @@ static int remoteDomainEventRegister (vi
         if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_EVENTS_REGISTER,
                 (xdrproc_t) xdr_void, (char *) NULL,
                 (xdrproc_t) xdr_void, (char *) NULL) == -1)
-            return -1;
-    }
-
-    return 0;
+            goto done;
+    }
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 static int remoteDomainEventDeregister (virConnectPtr conn,
-                                 void *callback ATTRIBUTE_UNUSED)
-{
+                                        void *callback ATTRIBUTE_UNUSED)
+{
+    int rv = -1;
     struct private_data *priv = conn->privateData;
 
     if (virDomainEventCallbackListRemove(conn, priv->callbackList,
-                                  callback) < 0) {
+                                         callback) < 0) {
          error (conn, VIR_ERR_RPC, _("removing cb fron list"));
-         return -1;
+         goto done;
     }
 
     if ( priv->callbackList->count == 0 ) {
@@ -4723,10 +5099,13 @@ static int remoteDomainEventDeregister (
         if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_EVENTS_DEREGISTER,
                 (xdrproc_t) xdr_void, (char *) NULL,
                 (xdrproc_t) xdr_void, (char *) NULL) == -1)
-            return -1;
-    }
-
-    return 0;
+            goto done;
+    }
+
+    rv = 0;
+
+done:
+    return rv;
 }
 
 /*----------------------------------------------------------------------*/
@@ -5524,22 +5903,22 @@ remoteDomainEventFired(int watch,
          DEBUG("%s : VIR_EVENT_HANDLE_HANGUP or "
                "VIR_EVENT_HANDLE_ERROR encountered", __FUNCTION__);
          virEventRemoveHandle(watch);
-         return;
+         goto done;
     }
 
     if (fd != priv->sock) {
         virEventRemoveHandle(watch);
-        return;
+        goto done;
     }
 
     /* Read and deserialise length word. */
     if (really_read (conn, priv, 0, buffer2, sizeof buffer2) == -1)
-        return;
+        goto done;
 
     xdrmem_create (&xdr, buffer2, sizeof buffer2, XDR_DECODE);
     if (!xdr_int (&xdr, &len)) {
         error (conn, VIR_ERR_RPC, _("xdr_int (length word, reply)"));
-        return;
+        goto done;
     }
     xdr_destroy (&xdr);
 
@@ -5548,20 +5927,20 @@ remoteDomainEventFired(int watch,
 
     if (len < 0 || len > REMOTE_MESSAGE_MAX) {
         error (conn, VIR_ERR_RPC, _("packet received from server too large"));
-        return;
+        goto done;
     }
 
     /* Read reply header and what follows (either a ret or an error). */
     if (really_read (conn, priv, 0, buffer, len) == -1) {
         error (conn, VIR_ERR_RPC, _("error reading buffer from memory"));
-        return;
+        goto done;
     }
 
     /* Deserialise reply header. */
     xdrmem_create (&xdr, buffer, len, XDR_DECODE);
     if (!xdr_remote_message_header (&xdr, &hdr)) {
         error (conn, VIR_ERR_RPC, _("invalid header in event firing"));
-        return;
+        goto done;
     }
 
     if (hdr.proc == REMOTE_PROC_DOMAIN_EVENT &&
@@ -5572,6 +5951,9 @@ remoteDomainEventFired(int watch,
         DEBUG0("invalid proc in event firing");
         error (conn, VIR_ERR_RPC, _("invalid proc in event firing"));
     }
+
+done:
+    return;
 }
 
 void


Daniel
-- 
|: Red Hat, Engineering, London   -o-   http://people.redhat.com/berrange/ :|
|: http://libvirt.org  -o-  http://virt-manager.org  -o-  http://ovirt.org :|
|: http://autobuild.org       -o-         http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505  -o-  F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|


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