int feature)
{
remote_connect_supports_feature_args args = { feature };
- remote_connect_supports_feature_ret ret = { 0 };
+ g_auto(remote_connect_supports_feature_ret) ret = { 0 };
int rc;
rc = call(conn, priv, 0, REMOTE_PROC_CONNECT_SUPPORTS_FEATURE,
static const char *
remoteConnectGetType(virConnectPtr conn)
{
- remote_connect_get_type_ret ret = {0};
+ g_auto(remote_connect_get_type_ret) ret = {0};
struct private_data *priv = conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
static int remoteConnectIsSecure(virConnectPtr conn)
{
struct private_data *priv = conn->privateData;
- remote_connect_is_secure_ret ret = {0};
+ g_auto(remote_connect_is_secure_ret) ret = {0};
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_IS_SECURE,
{
bool encrypted;
struct private_data *priv = conn->privateData;
- remote_connect_is_secure_ret ret = {0};
+ g_auto(remote_connect_is_secure_ret) ret = {0};
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_IS_SECURE,
virNodeCPUStatsPtr params, int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_node_get_cpu_stats_args args = {0};
- remote_node_get_cpu_stats_ret ret = {0};
+ g_auto(remote_node_get_cpu_stats_ret) ret = {0};
size_t i;
struct private_data *priv = conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
ret.params.params_len > *nparams) {
virReportError(VIR_ERR_RPC, "%s",
_("remoteNodeGetCPUStats: returned number of stats exceeds limit"));
- goto cleanup;
+ return -1;
}
/* Handle the case when the caller does not know the number of stats
* and is asking for the number of stats supported
*/
if (*nparams == 0) {
*nparams = ret.nparams;
- rv = 0;
- goto cleanup;
+ return 0;
}
*nparams = ret.params.params_len;
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Stats %1$s too big for destination"),
ret.params.params_val[i].field);
- goto cleanup;
+ return -1;
}
params[i].value = ret.params.params_val[i].value;
}
- rv = 0;
-
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_node_get_cpu_stats_ret, (char *) &ret);
- return rv;
+ return 0;
}
static int
int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_node_get_memory_stats_args args = {0};
- remote_node_get_memory_stats_ret ret = {0};
+ g_auto(remote_node_get_memory_stats_ret) ret = {0};
size_t i;
struct private_data *priv = conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
ret.params.params_len > *nparams) {
virReportError(VIR_ERR_RPC, "%s",
_("remoteNodeGetMemoryStats: returned number of stats exceeds limit"));
- goto cleanup;
+ return -1;
}
/* Handle the case when the caller does not know the number of stats
* and is asking for the number of stats supported
*/
if (*nparams == 0) {
*nparams = ret.nparams;
- rv = 0;
- goto cleanup;
+ return 0;
}
*nparams = ret.params.params_len;
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Stats %1$s too big for destination"),
ret.params.params_val[i].field);
- goto cleanup;
+ return -1;
}
params[i].value = ret.params.params_val[i].value;
}
- rv = 0;
-
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_node_get_memory_stats_ret, (char *) &ret);
- return rv;
+ return 0;
}
static int
int maxCells)
{
remote_node_get_cells_free_memory_args args = {0};
- remote_node_get_cells_free_memory_ret ret = {0};
+ g_auto(remote_node_get_cells_free_memory_ret) ret = {0};
size_t i;
struct private_data *priv = conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
for (i = 0; i < ret.cells.cells_len; i++)
freeMems[i] = ret.cells.cells_val[i];
- xdr_free((xdrproc_t) xdr_remote_node_get_cells_free_memory_ret, (char *) &ret);
-
return ret.cells.cells_len;
}
static int
remoteConnectListDomains(virConnectPtr conn, int *ids, int maxids)
{
- int rv = -1;
size_t i;
remote_connect_list_domains_args args = {0};
- remote_connect_list_domains_ret ret = {0};
+ g_auto(remote_connect_list_domains_ret) ret = {0};
struct private_data *priv = conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
virReportError(VIR_ERR_RPC,
_("Too many domains '%1$d' for limit '%2$d'"),
ret.ids.ids_len, maxids);
- goto cleanup;
+ return -1;
}
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_connect_list_domains_ret, (char *) &ret);
- return rv;
+ return ret.ids.ids_len;
}
static int
int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_domain_block_stats_flags_args args = {0};
- remote_domain_block_stats_flags_ret ret = {0};
+ g_auto(remote_domain_block_stats_flags_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
ret.params.params_len > *nparams) {
virReportError(VIR_ERR_RPC, "%s",
_("remoteDomainBlockStatsFlags: returned number of stats exceeds limit"));
- goto cleanup;
+ return -1;
}
/* Handle the case when the caller does not know the number of stats
*/
if (*nparams == 0) {
*nparams = ret.nparams;
- rv = 0;
- goto cleanup;
+ return 0;
}
*nparams = ret.params.params_len;
REMOTE_DOMAIN_BLOCK_STATS_PARAMETERS_MAX,
¶ms,
nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_block_stats_flags_ret,
- (char *) &ret);
- return rv;
+ return 0;
}
static int
virTypedParameterPtr params, int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_domain_get_memory_parameters_args args = {0};
- remote_domain_get_memory_parameters_ret ret = {0};
+ g_auto(remote_domain_get_memory_parameters_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
*/
if (*nparams == 0) {
*nparams = ret.nparams;
- rv = 0;
- goto cleanup;
+ return 0;
}
if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
REMOTE_DOMAIN_MEMORY_PARAMETERS_MAX,
¶ms,
nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_memory_parameters_ret,
- (char *) &ret);
- return rv;
+ return 0;
}
static int
virTypedParameterPtr params, int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_domain_get_numa_parameters_args args = {0};
- remote_domain_get_numa_parameters_ret ret = {0};
+ g_auto(remote_domain_get_numa_parameters_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
*/
if (*nparams == 0) {
*nparams = ret.nparams;
- rv = 0;
- goto cleanup;
+ return 0;
}
if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
REMOTE_DOMAIN_NUMA_PARAMETERS_MAX,
¶ms,
nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_numa_parameters_ret,
- (char *) &ret);
- return rv;
+ return 0;
}
static int
int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_domain_get_launch_security_info_args args = {0};
- remote_domain_get_launch_security_info_ret ret = {0};
+ g_auto(remote_domain_get_launch_security_info_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
REMOTE_DOMAIN_LAUNCH_SECURITY_INFO_PARAMS_MAX,
params,
nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_launch_security_info_ret,
- (char *) &ret);
- return rv;
+ return 0;
}
static int
int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_domain_get_perf_events_args args = {0};
- remote_domain_get_perf_events_ret ret = {0};
+ g_auto(remote_domain_get_perf_events_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
REMOTE_DOMAIN_PERF_EVENTS_MAX,
params,
nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_perf_events_ret,
- (char *) &ret);
- return rv;
+ return 0;
}
static int
virTypedParameterPtr params, int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_domain_get_blkio_parameters_args args = {0};
- remote_domain_get_blkio_parameters_ret ret = {0};
+ g_auto(remote_domain_get_blkio_parameters_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
*/
if (*nparams == 0) {
*nparams = ret.nparams;
- rv = 0;
- goto cleanup;
+ return 0;
}
if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
REMOTE_DOMAIN_BLKIO_PARAMETERS_MAX,
¶ms,
nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_blkio_parameters_ret,
- (char *) &ret);
- return rv;
+ return 0;
}
static int
int maplen,
unsigned int flags)
{
- int rv = -1;
size_t i;
remote_domain_get_vcpu_pin_info_args args = {0};
- remote_domain_get_vcpu_pin_info_ret ret = {0};
+ g_auto(remote_domain_get_vcpu_pin_info_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
virReportError(VIR_ERR_RPC,
_("host reports too many vCPUs: %1$d > %2$d"),
ret.num, ncpumaps);
- goto cleanup;
+ return -1;
}
if (ret.cpumaps.cpumaps_len > ncpumaps * maplen) {
virReportError(VIR_ERR_RPC,
_("host reports map buffer length exceeds maximum: %1$d > %2$d"),
ret.cpumaps.cpumaps_len, ncpumaps * maplen);
- goto cleanup;
+ return -1;
}
memset(cpumaps, 0, ncpumaps * maplen);
for (i = 0; i < ret.cpumaps.cpumaps_len; ++i)
cpumaps[i] = ret.cpumaps.cpumaps_val[i];
- rv = ret.num;
-
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_vcpu_pin_info_ret, (char *) &ret);
- return rv;
+ return ret.num;
}
static int
int maplen,
unsigned int flags)
{
- int rv = -1;
size_t i;
remote_domain_get_emulator_pin_info_args args = {0};
- remote_domain_get_emulator_pin_info_ret ret = {0};
+ g_auto(remote_domain_get_emulator_pin_info_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
virReportError(VIR_ERR_RPC,
_("host reports map buffer length exceeds maximum: %1$d > %2$d"),
ret.cpumaps.cpumaps_len, maplen);
- goto cleanup;
+ return -1;
}
memset(cpumaps, 0, maplen);
for (i = 0; i < ret.cpumaps.cpumaps_len; ++i)
cpumaps[i] = ret.cpumaps.cpumaps_val[i];
- rv = ret.ret;
-
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_emulator_pin_info_ret,
- (char *) &ret);
- return rv;
+ return ret.ret;
}
static int
unsigned char *cpumaps,
int maplen)
{
- int rv = -1;
size_t i;
remote_domain_get_vcpus_args args = {0};
- remote_domain_get_vcpus_ret ret = {0};
+ g_auto(remote_domain_get_vcpus_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
virReportError(VIR_ERR_RPC,
_("host reports too many vCPUs: %1$d > %2$d"),
ret.info.info_len, maxinfo);
- goto cleanup;
+ return -1;
}
if (ret.cpumaps.cpumaps_len > maxinfo * maplen) {
virReportError(VIR_ERR_RPC,
_("host reports map buffer length exceeds maximum: %1$d > %2$d"),
ret.cpumaps.cpumaps_len, maxinfo * maplen);
- goto cleanup;
+ return -1;
}
memset(info, 0, sizeof(*info) * maxinfo);
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 rv;
+ return ret.info.info_len;
}
static int
virDomainIOThreadInfoPtr **info,
unsigned int flags)
{
- int rv = -1;
size_t i;
struct private_data *priv = dom->conn->privateData;
remote_domain_get_iothread_info_args args = {0};
- remote_domain_get_iothread_info_ret ret = {0};
+ g_auto(remote_domain_get_iothread_info_ret) ret = {0};
remote_domain_iothread_info *src;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Too many IOThreads in info: %1$d for limit %2$d"),
ret.info.info_len, REMOTE_IOTHREAD_INFO_MAX);
- goto cleanup;
+ return -1;
}
if (info) {
if (!ret.info.info_len) {
*info = NULL;
- rv = ret.ret;
- goto cleanup;
+ return ret.ret;
}
info_ret = g_new0(virDomainIOThreadInfoPtr, ret.info.info_len);
*info = info_ret;
}
- rv = ret.ret;
-
- cleanup:
- xdr_free((xdrproc_t)xdr_remote_domain_get_iothread_info_ret,
- (char *) &ret);
- return rv;
+ return ret.ret;
}
static int
remoteDomainGetSecurityLabel(virDomainPtr domain, virSecurityLabelPtr seclabel)
{
remote_domain_get_security_label_args args = {0};
- remote_domain_get_security_label_ret ret = {0};
+ g_auto(remote_domain_get_security_label_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
- int rv = -1;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
if (virStrcpyStatic(seclabel->label, ret.label.label_val) < 0) {
virReportError(VIR_ERR_RPC, _("security label exceeds maximum: %1$zu"),
sizeof(seclabel->label) - 1);
- goto cleanup;
+ return -1;
}
seclabel->enforcing = ret.enforcing;
}
- rv = 0;
-
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_security_label_ret, (char *)&ret);
- return rv;
+ return 0;
}
static int
remoteDomainGetSecurityLabelList(virDomainPtr domain, virSecurityLabelPtr* seclabels)
{
remote_domain_get_security_label_list_args args = {0};
- remote_domain_get_security_label_list_ret ret = {0};
+ g_auto(remote_domain_get_security_label_list_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
size_t i;
- int rv = -1;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
virReportError(VIR_ERR_RPC, _("security label exceeds maximum: %1$zd"),
sizeof((*seclabels)->label) - 1);
VIR_FREE(*seclabels);
- goto cleanup;
+ return -1;
}
(*seclabels)[i].enforcing = cur->enforcing;
}
}
- rv = ret.ret;
-
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_security_label_list_ret, (char *)&ret);
- return rv;
+ return ret.ret;
}
static int
unsigned int flags)
{
remote_domain_get_state_args args = {0};
- remote_domain_get_state_ret ret = {0};
+ g_auto(remote_domain_get_state_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
static int
remoteNodeGetSecurityModel(virConnectPtr conn, virSecurityModelPtr secmodel)
{
- remote_node_get_security_model_ret ret = {0};
+ g_auto(remote_node_get_security_model_ret) ret = {0};
struct private_data *priv = conn->privateData;
- int rv = -1;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(secmodel, 0, sizeof(*secmodel));
if (virStrcpyStatic(secmodel->model, ret.model.model_val) < 0) {
virReportError(VIR_ERR_RPC, _("security model exceeds maximum: %1$zu"),
sizeof(secmodel->model) - 1);
- goto cleanup;
+ return -1;
}
}
if (virStrcpyStatic(secmodel->doi, ret.doi.doi_val) < 0) {
virReportError(VIR_ERR_RPC, _("security doi exceeds maximum: %1$zu"),
sizeof(secmodel->doi) - 1);
- goto cleanup;
+ return -1;
}
}
- rv = 0;
-
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_node_get_security_model_ret, (char *)&ret);
- return rv;
+ return 0;
}
static int
unsigned long resource)
{
remote_domain_migrate_prepare_args args = {0};
- remote_domain_migrate_prepare_ret ret = {0};
+ g_auto(remote_domain_migrate_prepare_ret) ret = {0};
struct private_data *priv = dconn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
return -1;
if (ret.cookie.cookie_len > 0) {
- *cookie = ret.cookie.cookie_val; /* Caller frees. */
+ *cookie = g_steal_pointer(&ret.cookie.cookie_val); /* Caller frees. */
*cookielen = ret.cookie.cookie_len;
+ ret.cookie.cookie_len = 0;
}
if (ret.uri_out)
- *uri_out = *ret.uri_out; /* Caller frees. */
+ *uri_out = g_steal_pointer(ret.uri_out); /* Caller frees. */
VIR_FREE(ret.uri_out);
return 0;
unsigned long resource,
const char *dom_xml)
{
- int rv = -1;
remote_domain_migrate_prepare2_args args = {0};
- remote_domain_migrate_prepare2_ret ret = {0};
+ g_auto(remote_domain_migrate_prepare2_ret) ret = {0};
struct private_data *priv = dconn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (!cookie || !cookielen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores cookie or cookielen"));
- goto error;
+ return -1;
}
- *cookie = ret.cookie.cookie_val; /* Caller frees. */
+ *cookie = g_steal_pointer(&ret.cookie.cookie_val); /* Caller frees. */
*cookielen = ret.cookie.cookie_len;
}
if (ret.uri_out) {
if (!uri_out) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores uri_out"));
- goto error;
+ return -1;
}
- *uri_out = *ret.uri_out; /* Caller frees. */
+ *uri_out = g_steal_pointer(ret.uri_out); /* Caller frees. */
}
- rv = 0;
-
- done:
- VIR_FREE(ret.uri_out);
- return rv;
- error:
- if (ret.cookie.cookie_len)
- VIR_FREE(ret.cookie.cookie_val);
- if (ret.uri_out)
- VIR_FREE(*ret.uri_out);
- goto done;
+ return 0;
}
static int
{
remote_domain_create_args args = {0};
remote_domain_lookup_by_uuid_args args2 = {0};
- remote_domain_lookup_by_uuid_ret ret2 = {0};
+ g_auto(remote_domain_lookup_by_uuid_ret) ret2 = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
return -1;
domain->id = ret2.dom.id;
- xdr_free((xdrproc_t) &xdr_remote_domain_lookup_by_uuid_ret, (char *) &ret2);
return 0;
}
remoteDomainGetSchedulerType(virDomainPtr domain, int *nparams)
{
remote_domain_get_scheduler_type_args args = {0};
- remote_domain_get_scheduler_type_ret ret = {0};
+ g_auto(remote_domain_get_scheduler_type_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (nparams) *nparams = ret.nparams;
/* Caller frees this. */
- return ret.type;
+ return g_steal_pointer(&ret.type);
}
static int
unsigned int nr_stats,
unsigned int flags)
{
- int rv = -1;
remote_domain_memory_stats_args args = {0};
- remote_domain_memory_stats_ret ret = {0};
+ g_auto(remote_domain_memory_stats_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
size_t i;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
stats[i].tag = ret.stats.stats_val[i].tag;
stats[i].val = ret.stats.stats_val[i].val;
}
- rv = ret.stats.stats_len;
- xdr_free((xdrproc_t) xdr_remote_domain_memory_stats_ret, (char *) &ret);
-
- return rv;
+ return ret.stats.stats_len;
}
static int
void *buffer,
unsigned int flags)
{
- int rv = -1;
remote_domain_block_peek_args args = {0};
- remote_domain_block_peek_ret ret = {0};
+ g_auto(remote_domain_block_peek_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (ret.buffer.buffer_len != size) {
virReportError(VIR_ERR_RPC, "%s",
_("returned buffer is not same size as requested"));
- goto cleanup;
+ return -1;
}
memcpy(buffer, ret.buffer.buffer_val, size);
- rv = 0;
-
- cleanup:
- VIR_FREE(ret.buffer.buffer_val);
- return rv;
+ return 0;
}
static int
void *buffer,
unsigned int flags)
{
- int rv = -1;
remote_domain_memory_peek_args args = {0};
- remote_domain_memory_peek_ret ret = {0};
+ g_auto(remote_domain_memory_peek_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (ret.buffer.buffer_len != size) {
virReportError(VIR_ERR_RPC, "%s",
_("returned buffer is not same size as requested"));
- goto cleanup;
+ return -1;
}
memcpy(buffer, ret.buffer.buffer_val, size);
- rv = 0;
-
- cleanup:
- VIR_FREE(ret.buffer.buffer_val);
-
- return rv;
+ return 0;
}
static int remoteDomainGetBlockJobInfo(virDomainPtr domain,
unsigned int flags)
{
remote_domain_get_block_job_info_args args = {0};
- remote_domain_get_block_job_info_ret ret = {0};
+ g_auto(remote_domain_get_block_job_info_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_domain_get_block_io_tune_args args = {0};
- remote_domain_get_block_io_tune_ret ret = {0};
+ g_auto(remote_domain_get_block_io_tune_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
*/
if (*nparams == 0) {
*nparams = ret.nparams;
- rv = 0;
- goto cleanup;
+ return -1;
}
if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
REMOTE_DOMAIN_BLOCK_IO_TUNE_PARAMETERS_MAX,
¶ms,
nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_block_io_tune_ret,
- (char *) &ret);
- return rv;
+ return 0;
}
static int remoteDomainGetCPUStats(virDomainPtr domain,
{
struct private_data *priv = domain->conn->privateData;
remote_domain_get_cpu_stats_args args = {0};
- remote_domain_get_cpu_stats_ret ret = {0};
- int rv = -1;
+ g_auto(remote_domain_get_cpu_stats_ret) ret = {0};
int cpu;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
virReportError(VIR_ERR_RPC, "%s",
_("remoteDomainGetCPUStats: returned number of stats exceeds limit"));
memset(params, 0, sizeof(*params) * nparams * ncpus);
- goto cleanup;
+ return -1;
}
/* Handle the case when the caller does not know the number of stats
* and is asking for the number of stats supported
*/
if (nparams == 0) {
- rv = ret.nparams;
- goto cleanup;
+ return ret.nparams;
}
/* The remote side did not send back any zero entries, so we have
if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) stride,
ret.nparams,
REMOTE_NODE_CPU_STATS_MAX,
- &cpu_params, &tmp) < 0)
- goto cleanup;
+ &cpu_params, &tmp) < 0) {
+ virTypedParamsClear(params, nparams * ncpus);
+ return -1;
+ }
}
- rv = ret.nparams;
- cleanup:
- if (rv < 0)
- virTypedParamsClear(params, nparams * ncpus);
-
- xdr_free((xdrproc_t) xdr_remote_domain_get_cpu_stats_ret,
- (char *) &ret);
- return rv;
+ return ret.nparams;
}
{
struct private_data *priv = conn->privateData;
remote_connect_network_event_register_any_args args = {0};
- remote_connect_network_event_register_any_ret ret = {0};
+ g_auto(remote_connect_network_event_register_any_ret) ret = {0};
int callbackID;
int count;
remote_nonnull_network network;
{
struct private_data *priv = conn->privateData;
remote_connect_storage_pool_event_register_any_args args = {0};
- remote_connect_storage_pool_event_register_any_ret ret = {0};
+ g_auto(remote_connect_storage_pool_event_register_any_ret) ret = {0};
int callbackID;
int count;
remote_nonnull_storage_pool storage_pool;
{
struct private_data *priv = conn->privateData;
remote_connect_node_device_event_register_any_args args = {0};
- remote_connect_node_device_event_register_any_ret ret = {0};
+ g_auto(remote_connect_node_device_event_register_any_ret) ret = {0};
int callbackID;
int count;
remote_nonnull_node_device node_device;
{
struct private_data *priv = conn->privateData;
remote_connect_secret_event_register_any_args args = {0};
- remote_connect_secret_event_register_any_ret ret = {0};
+ g_auto(remote_connect_secret_event_register_any_ret) ret = {0};
int callbackID;
int count;
remote_nonnull_secret sec;
{
struct private_data *priv = conn->privateData;
qemu_connect_domain_monitor_event_register_args args;
- qemu_connect_domain_monitor_event_register_ret ret = {0};
+ g_auto(qemu_connect_domain_monitor_event_register_ret) ret = {0};
int callbackID;
int count;
remote_nonnull_domain domain;
const char *srcSpec,
unsigned int flags)
{
- char *rv = NULL;
remote_connect_find_storage_pool_sources_args args = {0};
- remote_connect_find_storage_pool_sources_ret ret = {0};
+ g_auto(remote_connect_find_storage_pool_sources_ret) ret = {0};
struct private_data *priv = conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
(xdrproc_t) xdr_remote_connect_find_storage_pool_sources_ret, (char *) &ret) == -1)
return NULL;
- rv = g_steal_pointer(&ret.xml); /* To stop xdr_free free'ing it */
-
- xdr_free((xdrproc_t) xdr_remote_connect_find_storage_pool_sources_ret, (char *) &ret);
- return rv;
+ return g_steal_pointer(&ret.xml);
}
/*----------------------------------------------------------------------*/
virConnectAuthPtr auth G_GNUC_UNUSED,
const char *authtype)
{
- struct remote_auth_list_ret ret = {0};
+ g_auto(remote_auth_list_ret) ret = {0};
int err, type = REMOTE_AUTH_NONE;
err = call(conn, priv, 0,
remoteAuthPolkit(virConnectPtr conn, struct private_data *priv,
virConnectAuthPtr auth G_GNUC_UNUSED)
{
- remote_auth_polkit_ret ret = {0};
+ g_auto(remote_auth_polkit_ret) ret = {0};
VIR_DEBUG("Client initialize PolicyKit authentication");
if (call(conn, priv, 0, REMOTE_PROC_AUTH_POLKIT,
/* Tell the server when we are the first callback registering */
if (priv->serverEventFilter) {
remote_connect_domain_event_callback_register_any_args args = {0};
- remote_connect_domain_event_callback_register_any_ret ret = {0};
+ g_auto(remote_connect_domain_event_callback_register_any_ret) ret = {0};
args.eventID = VIR_DOMAIN_EVENT_ID_LIFECYCLE;
args.dom = NULL;
unsigned int flags)
{
remote_secret_get_value_args args = {0};
- remote_secret_get_value_ret ret = {0};
+ g_auto(remote_secret_get_value_ret) ret = {0};
struct private_data *priv = secret->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
return NULL;
*value_size = ret.value.value_len;
- return (unsigned char *) ret.value.value_val; /* Caller frees. */
+ return (unsigned char *) g_steal_pointer(&ret.value.value_val); /* Caller frees. */
}
if (count == 1) {
if (priv->serverEventFilter) {
remote_connect_domain_event_callback_register_any_args args = {0};
- remote_connect_domain_event_callback_register_any_ret ret = {0};
+ g_auto(remote_connect_domain_event_callback_register_any_ret) ret = {0};
args.eventID = eventID;
if (dom) {
remoteDomainQemuMonitorCommand(virDomainPtr domain, const char *cmd,
char **result, unsigned int flags)
{
- int rv = -1;
qemu_domain_monitor_command_args args;
- qemu_domain_monitor_command_ret ret = {0};
+ g_auto(qemu_domain_monitor_command_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
(xdrproc_t) xdr_qemu_domain_monitor_command_ret, (char *) &ret) == -1)
return -1;
- *result = g_strdup(ret.result);
-
- rv = 0;
-
- xdr_free((xdrproc_t) xdr_qemu_domain_monitor_command_ret, (char *) &ret);
+ *result = g_steal_pointer(&ret.result);
- return rv;
+ return 0;
}
unsigned int flags)
{
qemu_domain_monitor_command_with_files_args args;
- qemu_domain_monitor_command_with_files_ret ret = {0};
+ g_auto(qemu_domain_monitor_command_with_files_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
size_t rpc_noutfiles = 0;
g_autofree int *rpc_outfiles = NULL;
if (noutfiles)
*noutfiles = rpc_noutfiles;
- *result = g_strdup(ret.result);
-
- xdr_free((xdrproc_t) xdr_qemu_domain_monitor_command_with_files_ret, (char *) &ret);
+ *result = g_steal_pointer(&ret.result);
if (rpc_outfiles) {
for (i = 0; i < rpc_noutfiles; i++) {
const char *dname,
unsigned long resource)
{
- char *rv = NULL;
remote_domain_migrate_begin3_args args = {0};
- remote_domain_migrate_begin3_ret ret = {0};
+ g_auto(remote_domain_migrate_begin3_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (!cookieout || !cookieoutlen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores cookieout or cookieoutlen"));
- goto error;
+ return NULL;
}
- *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */
+ *cookieout = g_steal_pointer(&ret.cookie_out.cookie_out_val); /* Caller frees. */
*cookieoutlen = ret.cookie_out.cookie_out_len;
+ ret.cookie_out.cookie_out_len = 0;
}
- rv = ret.xml; /* caller frees */
-
- done:
- return rv;
-
- error:
- VIR_FREE(ret.cookie_out.cookie_out_val);
- goto done;
+ return g_steal_pointer(&ret.xml); /* caller frees */
}
unsigned long resource,
const char *dom_xml)
{
- int rv = -1;
remote_domain_migrate_prepare3_args args = {0};
- remote_domain_migrate_prepare3_ret ret = {0};
+ g_auto(remote_domain_migrate_prepare3_ret) ret = {0};
struct private_data *priv = dconn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (!cookieout || !cookieoutlen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores cookieout or cookieoutlen"));
- goto error;
+ return -1;
}
- *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */
+ *cookieout = g_steal_pointer(&ret.cookie_out.cookie_out_val); /* Caller frees. */
*cookieoutlen = ret.cookie_out.cookie_out_len;
+ ret.cookie_out.cookie_out_len = 0;
}
if (ret.uri_out) {
if (!uri_out) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores uri_out"));
- goto error;
+ return -1;
}
- *uri_out = *ret.uri_out; /* Caller frees. */
+ *uri_out = g_steal_pointer(ret.uri_out); /* Caller frees. */
}
- rv = 0;
-
- done:
- VIR_FREE(ret.uri_out);
- return rv;
- error:
- VIR_FREE(ret.cookie_out.cookie_out_val);
- if (ret.uri_out)
- VIR_FREE(*ret.uri_out);
- goto done;
+ return 0;
}
{
struct private_data *priv = dconn->privateData;
remote_domain_migrate_prepare_tunnel3_args args = {0};
- remote_domain_migrate_prepare_tunnel3_ret ret = {0};
+ g_auto(remote_domain_migrate_prepare_tunnel3_ret) ret = {0};
virNetClientStream *netst;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (!cookieout || !cookieoutlen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores cookieout or cookieoutlen"));
- goto error;
+ return -1;
}
- *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */
+ *cookieout = g_steal_pointer(&ret.cookie_out.cookie_out_val); /* Caller frees. */
*cookieoutlen = ret.cookie_out.cookie_out_len;
+ ret.cookie_out.cookie_out_len = 0;
}
return 0;
-
- error:
- VIR_FREE(ret.cookie_out.cookie_out_val);
- return -1;
}
unsigned long resource)
{
remote_domain_migrate_perform3_args args = {0};
- remote_domain_migrate_perform3_ret ret = {0};
+ g_auto(remote_domain_migrate_perform3_ret) ret = {0};
struct private_data *priv = dom->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (!cookieout || !cookieoutlen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores cookieout or cookieoutlen"));
- goto error;
+ return -1;
}
- *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */
+ *cookieout = g_steal_pointer(&ret.cookie_out.cookie_out_val); /* Caller frees. */
*cookieoutlen = ret.cookie_out.cookie_out_len;
+ ret.cookie_out.cookie_out_len = 0;
}
return 0;
-
- error:
- VIR_FREE(ret.cookie_out.cookie_out_val);
- return -1;
}
int cancelled)
{
remote_domain_migrate_finish3_args args = {0};
- remote_domain_migrate_finish3_ret ret = {0};
+ g_auto(remote_domain_migrate_finish3_ret) ret = {0};
struct private_data *priv = dconn->privateData;
- virDomainPtr rv = NULL;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.cookie_in.cookie_in_val = (char *)cookiein;
if (!cookieout || !cookieoutlen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores cookieout or cookieoutlen"));
- goto error;
+ return NULL;
}
*cookieout = g_steal_pointer(&ret.cookie_out.cookie_out_val); /* Caller frees. */
*cookieoutlen = ret.cookie_out.cookie_out_len;
ret.cookie_out.cookie_out_len = 0;
}
- rv = get_nonnull_domain(dconn, ret.dom);
-
- xdr_free((xdrproc_t) &xdr_remote_domain_migrate_finish3_ret, (char *) &ret);
-
- return rv;
-
- error:
- VIR_FREE(ret.cookie_out.cookie_out_val);
- return NULL;
+ return get_nonnull_domain(dconn, ret.dom);
}
char ***models,
unsigned int flags)
{
- int rv = -1;
size_t i;
g_auto(GStrv) retmodels = NULL;
remote_connect_get_cpu_model_names_args args = {0};
- remote_connect_get_cpu_model_names_ret ret = {0};
+ g_auto(remote_connect_get_cpu_model_names_ret) ret = {0};
struct private_data *priv = conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
_("Too many model names '%1$d' for limit '%2$d'"),
ret.models.models_len,
REMOTE_CONNECT_CPU_MODELS_MAX);
- goto cleanup;
+ return -1;
}
if (models) {
*models = g_steal_pointer(&retmodels);
}
- rv = ret.ret;
-
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_connect_get_cpu_model_names_ret, (char *) &ret);
-
- return rv;
+ return ret.ret;
}
unsigned int maxerrors,
unsigned int flags)
{
- int rv = -1;
struct private_data *priv = dom->conn->privateData;
remote_domain_get_disk_errors_args args = {0};
- remote_domain_get_disk_errors_ret ret = {0};
+ g_auto(remote_domain_get_disk_errors_ret) ret = {0};
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
REMOTE_DOMAIN_DISK_ERRORS_MAX,
errors,
maxerrors) < 0)
- goto cleanup;
-
- rv = ret.nerrors;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_disk_errors_ret, (char *) &ret);
- return rv;
+ return ret.nerrors;
}
#include "remote_client_bodies.h"
virTypedParameterPtr params, int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_domain_get_interface_parameters_args args = {0};
- remote_domain_get_interface_parameters_ret ret = {0};
+ g_auto(remote_domain_get_interface_parameters_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
*/
if (*nparams == 0) {
*nparams = ret.nparams;
- rv = 0;
- goto cleanup;
+ return 0;
}
if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
REMOTE_DOMAIN_INTERFACE_PARAMETERS_MAX,
¶ms,
nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_interface_parameters_ret,
- (char *) &ret);
- return rv;
+ return 0;
}
int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_node_get_memory_parameters_args args = {0};
- remote_node_get_memory_parameters_ret ret = {0};
+ g_auto(remote_node_get_memory_parameters_ret) ret = {0};
struct private_data *priv = conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
*/
if (*nparams == 0) {
*nparams = ret.nparams;
- rv = 0;
- goto cleanup;
+ return 0;
}
if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
REMOTE_NODE_MEMORY_PARAMETERS_MAX,
¶ms,
nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_node_get_memory_parameters_ret,
- (char *) &ret);
- return rv;
+ return 0;
}
int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_node_get_sev_info_args args = {0};
- remote_node_get_sev_info_ret ret = {0};
+ g_auto(remote_node_get_sev_info_ret) ret = {0};
struct private_data *priv = conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
REMOTE_NODE_SEV_INFO_MAX,
params,
nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_node_get_sev_info_ret, (char *) &ret);
- return rv;
+ return 0;
}
unsigned int *online,
unsigned int flags)
{
- int rv = -1;
remote_node_get_cpu_map_args args = {0};
- remote_node_get_cpu_map_ret ret = {0};
+ g_auto(remote_node_get_cpu_map_ret) ret = {0};
struct private_data *priv = conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
return -1;
if (ret.ret < 0)
- goto cleanup;
+ return -1;
if (cpumap) {
*cpumap = g_new0(unsigned char, ret.cpumap.cpumap_len);
if (online)
*online = ret.online;
- rv = ret.ret;
-
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_node_get_cpu_map_ret, (char *) &ret);
- return rv;
+ return ret.ret;
}
int *nparams,
unsigned int flags)
{
- int rv = -1;
remote_domain_get_job_stats_args args = {0};
- remote_domain_get_job_stats_ret ret = {0};
+ g_auto(remote_domain_get_job_stats_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
ret.params.params_len,
REMOTE_DOMAIN_JOB_STATS_MAX,
params, nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_domain_get_job_stats_ret,
- (char *) &ret);
- return rv;
+ return 0;
}
{
char *rv = NULL;
remote_domain_migrate_begin3_params_args args = {0};
- remote_domain_migrate_begin3_params_ret ret = {0};
+ g_auto(remote_domain_migrate_begin3_params_ret) ret = {0};
struct private_data *priv = domain->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX,
(struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
- VIR_TYPED_PARAM_STRING_OKAY) < 0) {
- goto cleanup;
- }
+ VIR_TYPED_PARAM_STRING_OKAY) < 0)
+ return NULL;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3_PARAMS,
(xdrproc_t) xdr_remote_domain_migrate_begin3_params_args,
if (!cookieout || !cookieoutlen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores cookieout or cookieoutlen"));
- goto error;
+ goto cleanup;
}
- *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */
+ *cookieout = g_steal_pointer(&ret.cookie_out.cookie_out_val); /* Caller frees. */
*cookieoutlen = ret.cookie_out.cookie_out_len;
+ ret.cookie_out.cookie_out_len = 0;
}
- rv = ret.xml; /* caller frees */
+ rv = g_steal_pointer(&ret.xml); /* caller frees */
cleanup:
virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
return rv;
-
- error:
- VIR_FREE(ret.cookie_out.cookie_out_val);
- goto cleanup;
}
{
int rv = -1;
remote_domain_migrate_prepare3_params_args args = {0};
- remote_domain_migrate_prepare3_params_ret ret = {0};
+ g_auto(remote_domain_migrate_prepare3_params_ret) ret = {0};
struct private_data *priv = dconn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX,
(struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
- VIR_TYPED_PARAM_STRING_OKAY) < 0) {
- goto cleanup;
- }
+ VIR_TYPED_PARAM_STRING_OKAY) < 0)
+ return -1;
args.cookie_in.cookie_in_val = (char *)cookiein;
args.cookie_in.cookie_in_len = cookieinlen;
if (!cookieout || !cookieoutlen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores cookieout or cookieoutlen"));
- goto error;
+ goto cleanup;
}
- *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */
+ *cookieout = g_steal_pointer(&ret.cookie_out.cookie_out_val); /* Caller frees. */
*cookieoutlen = ret.cookie_out.cookie_out_len;
+ ret.cookie_out.cookie_out_len = 0;
}
if (ret.uri_out) {
if (!uri_out) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores uri_out"));
- goto error;
+ goto cleanup;
}
- *uri_out = *ret.uri_out; /* Caller frees. */
+ *uri_out = g_steal_pointer(ret.uri_out); /* Caller frees. */
}
rv = 0;
cleanup:
virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
- VIR_FREE(ret.uri_out);
return rv;
-
- error:
- VIR_FREE(ret.cookie_out.cookie_out_val);
- if (ret.uri_out)
- VIR_FREE(*ret.uri_out);
- goto cleanup;
}
struct private_data *priv = dconn->privateData;
int rv = -1;
remote_domain_migrate_prepare_tunnel3_params_args args = {0};
- remote_domain_migrate_prepare_tunnel3_params_ret ret = {0};
+ g_auto(remote_domain_migrate_prepare_tunnel3_params_ret) ret = {0};
virNetClientStream *netst;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX,
(struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
- VIR_TYPED_PARAM_STRING_OKAY) < 0) {
- goto cleanup;
- }
+ VIR_TYPED_PARAM_STRING_OKAY) < 0)
+ return -1;
if (!(netst = virNetClientStreamNew(priv->remoteProgram,
REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3_PARAMS,
if (!cookieout || !cookieoutlen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores cookieout or cookieoutlen"));
- goto error;
+ goto cleanup;
}
- *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */
+ *cookieout = g_steal_pointer(&ret.cookie_out.cookie_out_val); /* Caller frees. */
*cookieoutlen = ret.cookie_out.cookie_out_len;
+ ret.cookie_out.cookie_out_len = 0;
}
rv = 0;
virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
return rv;
-
- error:
- VIR_FREE(ret.cookie_out.cookie_out_val);
- goto cleanup;
}
{
int rv = -1;
remote_domain_migrate_perform3_params_args args = {0};
- remote_domain_migrate_perform3_params_ret ret = {0};
+ g_auto(remote_domain_migrate_perform3_params_ret) ret = {0};
struct private_data *priv = dom->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX,
(struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
- VIR_TYPED_PARAM_STRING_OKAY) < 0) {
- goto cleanup;
- }
+ VIR_TYPED_PARAM_STRING_OKAY) < 0)
+ return -1;
if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3_PARAMS,
(xdrproc_t) xdr_remote_domain_migrate_perform3_params_args,
if (!cookieout || !cookieoutlen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores cookieout or cookieoutlen"));
- goto error;
+ goto cleanup;
}
- *cookieout = ret.cookie_out.cookie_out_val; /* Caller frees. */
+ *cookieout = g_steal_pointer(&ret.cookie_out.cookie_out_val); /* Caller frees. */
*cookieoutlen = ret.cookie_out.cookie_out_len;
+ ret.cookie_out.cookie_out_len = 0;
}
rv = 0;
virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
return rv;
-
- error:
- VIR_FREE(ret.cookie_out.cookie_out_val);
- goto cleanup;
}
int cancelled)
{
remote_domain_migrate_finish3_params_args args = {0};
- remote_domain_migrate_finish3_params_ret ret = {0};
+ g_auto(remote_domain_migrate_finish3_params_ret) ret = {0};
struct private_data *priv = dconn->privateData;
virDomainPtr rv = NULL;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX,
(struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
- VIR_TYPED_PARAM_STRING_OKAY) < 0) {
- goto cleanup;
- }
+ VIR_TYPED_PARAM_STRING_OKAY) < 0)
+ return NULL;
if (call(dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_FINISH3_PARAMS,
(xdrproc_t) xdr_remote_domain_migrate_finish3_params_args,
if (!cookieout || !cookieoutlen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("caller ignores cookieout or cookieoutlen"));
- goto error;
+ goto cleanup;
}
*cookieout = g_steal_pointer(&ret.cookie_out.cookie_out_val); /* Caller frees. */
*cookieoutlen = ret.cookie_out.cookie_out_len;
}
rv = get_nonnull_domain(dconn, ret.dom);
-
- xdr_free((xdrproc_t) &xdr_remote_domain_migrate_finish3_params_ret,
- (char *) &ret);
-
cleanup:
virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
return rv;
-
- error:
- VIR_FREE(ret.cookie_out.cookie_out_val);
- goto cleanup;
}
REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX,
(struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
- VIR_TYPED_PARAM_STRING_OKAY) < 0) {
- goto cleanup;
- }
+ VIR_TYPED_PARAM_STRING_OKAY) < 0)
+ return -1;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3_PARAMS,
(xdrproc_t) xdr_remote_domain_migrate_confirm3_params_args,
remoteDomainCreateXMLWithFiles(virConnectPtr conn, const char *xml_desc,
unsigned int nfiles, int *files, unsigned int flags)
{
- virDomainPtr rv = NULL;
struct private_data *priv = conn->privateData;
remote_domain_create_xml_with_files_args args = {0};
- remote_domain_create_xml_with_files_ret ret = {0};
+ g_auto(remote_domain_create_xml_with_files_ret) ret = {0};
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.xml_desc = (char *)xml_desc;
(xdrproc_t)xdr_remote_domain_create_xml_with_files_ret, (char *)&ret) == -1)
return NULL;
- rv = get_nonnull_domain(conn, ret.dom);
- xdr_free((xdrproc_t)xdr_remote_domain_create_xml_with_files_ret, (char *)&ret);
-
- return rv;
+ return get_nonnull_domain(conn, ret.dom);
}
{
struct private_data *priv = dom->conn->privateData;
remote_domain_create_with_files_args args = {0};
- remote_domain_create_with_files_ret ret = {0};
+ g_auto(remote_domain_create_with_files_ret) ret = {0};
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
return -1;
dom->id = ret.dom.id;
- xdr_free((xdrproc_t) &xdr_remote_domain_create_with_files_ret, (char *) &ret);
return 0;
}
{
struct private_data *priv = dom->conn->privateData;
remote_domain_get_time_args args = {0};
- remote_domain_get_time_ret ret = {0};
+ g_auto(remote_domain_get_time_ret) ret = {0};
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
*seconds = ret.seconds;
*nseconds = ret.nseconds;
- xdr_free((xdrproc_t) &xdr_remote_domain_get_time_ret, (char *) &ret);
return 0;
}
unsigned int flags)
{
remote_node_get_free_pages_args args = {0};
- remote_node_get_free_pages_ret ret = {0};
+ g_auto(remote_node_get_free_pages_ret) ret = {0};
struct private_data *priv = conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memcpy(counts, ret.counts.counts_val, ret.counts.counts_len * sizeof(*counts));
- xdr_free((xdrproc_t) xdr_remote_node_get_free_pages_ret, (char *) &ret);
-
return ret.counts.counts_len;
}
size_t i;
struct private_data *priv = net->conn->privateData;
remote_network_get_dhcp_leases_args args = {0};
- remote_network_get_dhcp_leases_ret ret = {0};
+ g_auto(remote_network_get_dhcp_leases_ret) ret = {0};
virNetworkDHCPLeasePtr *leases_ret = NULL;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Number of leases is %1$d, which exceeds max limit: %2$d"),
ret.leases.leases_len, REMOTE_NETWORK_DHCP_LEASES_MAX);
- goto cleanup;
+ return -1;
}
if (leases) {
virNetworkDHCPLeaseFree(leases_ret[i]);
VIR_FREE(leases_ret);
}
- xdr_free((xdrproc_t)xdr_remote_network_get_dhcp_leases_ret,
- (char *) &ret);
return rv;
}
int rv = -1;
size_t i;
remote_connect_get_all_domain_stats_args args = {0};
- remote_connect_get_all_domain_stats_ret ret = {0};
+ g_auto(remote_connect_get_all_domain_stats_ret) ret = {0};
virDomainStatsRecordPtr elem = NULL;
virDomainStatsRecordPtr *tmpret = NULL;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
}
virDomainStatsRecordListFree(tmpret);
VIR_FREE(args.doms.doms_val);
- xdr_free((xdrproc_t)xdr_remote_connect_get_all_domain_stats_ret,
- (char *) &ret);
return rv;
}
unsigned int flags)
{
remote_node_alloc_pages_args args = {0};
- remote_node_alloc_pages_ret ret = {0};
+ g_auto(remote_node_alloc_pages_ret) ret = {0};
struct private_data *priv = conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
virDomainFSInfoPtr **info,
unsigned int flags)
{
- int rv = -1;
size_t i, j, len;
struct private_data *priv = dom->conn->privateData;
remote_domain_get_fsinfo_args args = {0};
- remote_domain_get_fsinfo_ret ret = {0};
+ g_auto(remote_domain_get_fsinfo_ret) ret = {0};
remote_domain_fsinfo *src;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Too many mountpoints in fsinfo: %1$d for limit %2$d"),
ret.info.info_len, REMOTE_DOMAIN_FSINFO_MAX);
- goto cleanup;
+ return -1;
}
if (info) {
if (!ret.info.info_len) {
*info = NULL;
- rv = ret.ret;
- goto cleanup;
+ return ret.ret;
}
info_ret = g_new0(virDomainFSInfoPtr, ret.info.info_len);
*info = info_ret;
}
- rv = ret.ret;
-
- cleanup:
- xdr_free((xdrproc_t)xdr_remote_domain_get_fsinfo_ret,
- (char *) &ret);
- return rv;
+ return ret.ret;
}
virDomainInterfacePtr *ifaces_ret = NULL;
remote_domain_interface_addresses_args args = {0};
- remote_domain_interface_addresses_ret ret = {0};
+ g_auto(remote_domain_interface_addresses_ret) ret = {0};
struct private_data *priv = dom->conn->privateData;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Number of interfaces, %1$d exceeds the max limit: %2$d"),
ret.ifaces.ifaces_len, REMOTE_DOMAIN_INTERFACE_MAX);
- goto cleanup;
+ return -1;
}
if (ret.ifaces.ifaces_len)
virDomainInterfaceFree(ifaces_ret[i]);
VIR_FREE(ifaces_ret);
}
- xdr_free((xdrproc_t)xdr_remote_domain_interface_addresses_ret,
- (char *) &ret);
return rv;
}
int rv = -1;
struct private_data *priv = dom->conn->privateData;
remote_domain_rename_args args = {0};
- remote_domain_rename_ret ret = {0};
+ g_auto(remote_domain_rename_ret) ret = {0};
char *tmp = NULL;
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
{
struct private_data *priv = vol->conn->privateData;
remote_storage_vol_get_info_flags_args args = {0};
- remote_storage_vol_get_info_flags_ret ret = {0};
+ g_auto(remote_storage_vol_get_info_flags_ret) ret = {0};
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_storage_vol(&args.vol, vol);
int *nparams,
unsigned int flags)
{
- int rv = -1;
struct private_data *priv = port->net->conn->privateData;
remote_network_port_get_parameters_args args = {0};
- remote_network_port_get_parameters_ret ret = {0};
+ g_auto(remote_network_port_get_parameters_ret) ret = {0};
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_network_port(&args.port, port);
REMOTE_NETWORK_PORT_PARAMETERS_MAX,
params,
nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t) xdr_remote_network_port_get_parameters_ret, (char *) &ret);
- return rv;
+ return 0;
}
static int
int *nparams,
unsigned int flags)
{
- int rv = -1;
struct private_data *priv = dom->conn->privateData;
remote_domain_get_guest_info_args args = {0};
- remote_domain_get_guest_info_ret ret = {0};
+ g_auto(remote_domain_get_guest_info_ret) ret = {0};
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
REMOTE_DOMAIN_GUEST_INFO_PARAMS_MAX,
params,
nparams) < 0)
- goto cleanup;
-
- rv = 0;
+ return -1;
- cleanup:
- xdr_free((xdrproc_t)xdr_remote_domain_get_guest_info_ret,
- (char *) &ret);
- return rv;
+ return 0;
}
static int
char ***keys,
unsigned int flags)
{
- int rv = -1;
size_t i;
struct private_data *priv = domain->conn->privateData;
remote_domain_authorized_ssh_keys_get_args args = {0};
- remote_domain_authorized_ssh_keys_get_ret ret = {0};
+ g_auto(remote_domain_authorized_ssh_keys_get_ret) ret = {0};
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
if (ret.keys.keys_len > REMOTE_DOMAIN_AUTHORIZED_SSH_KEYS_MAX) {
virReportError(VIR_ERR_RPC, "%s",
_("remoteDomainAuthorizedSSHKeysGet: returned number of keys exceeds limit"));
- goto cleanup;
+ return -1;
}
*keys = g_new0(char *, ret.keys.keys_len + 1);
for (i = 0; i < ret.keys.keys_len; i++)
- (*keys)[i] = g_strdup(ret.keys.keys_val[i]);
-
- rv = ret.keys.keys_len;
+ (*keys)[i] = g_steal_pointer(&ret.keys.keys_val[i]);
- cleanup:
- xdr_free((xdrproc_t)xdr_remote_domain_authorized_ssh_keys_get_ret,
- (char *) &ret);
- return rv;
+ return ret.keys.keys_len;
}
static int
char ***msgs,
unsigned int flags)
{
- int rv = -1;
size_t i;
struct private_data *priv = domain->conn->privateData;
remote_domain_get_messages_args args = {0};
- remote_domain_get_messages_ret ret = {0};
+ g_auto(remote_domain_get_messages_ret) ret = {0};
VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_MESSAGES,
(xdrproc_t) xdr_remote_domain_get_messages_args, (char *)&args,
(xdrproc_t) xdr_remote_domain_get_messages_ret, (char *)&ret) == -1) {
- goto cleanup;
+ return -1;
}
if (ret.msgs.msgs_len > REMOTE_DOMAIN_MESSAGES_MAX) {
virReportError(VIR_ERR_RPC, "%s",
_("remoteDomainGetMessages: returned number of msgs exceeds limit"));
- goto cleanup;
+ return -1;
}
*msgs = g_new0(char *, ret.msgs.msgs_len + 1);
for (i = 0; i < ret.msgs.msgs_len; i++)
- (*msgs)[i] = g_strdup(ret.msgs.msgs_val[i]);
+ (*msgs)[i] = g_steal_pointer(&ret.msgs.msgs_val[i]);
- rv = ret.msgs.msgs_len;
-
- cleanup:
- xdr_free((xdrproc_t)xdr_remote_domain_get_messages_ret,
- (char *) &ret);
- return rv;
+ return ret.msgs.msgs_len;
}
projects / libvirt.git / commitdiff