static void
virAppendBootloaderArgs(virCommand *cmd, virDomainDef *def)
{
- char **blargs;
+ g_auto(GStrv) blargs = NULL;
/* XXX: Handle quoted? */
blargs = g_strsplit(def->os.bootloaderArgs, " ", 0);
virCommandAddArgSet(cmd, (const char * const *)blargs);
- g_strfreev(blargs);
}
static virCommand *
const char *start;
const char *next;
char *line;
- char **lines = NULL;
+ g_auto(GStrv) lines = NULL;
size_t i;
size_t line_count = 0;
size_t lines_alloc = 0;
for (i = 0; i < line_count; i++) {
size_t j;
- char **arglist = NULL;
+ g_auto(GStrv) arglist = NULL;
size_t args_count = 0;
size_t args_alloc = 0;
if (!bhyve_argc)
goto error;
for (j = 0; j < args_count; j++)
- _bhyve_argv[j] = arglist[j];
+ _bhyve_argv[j] = g_steal_pointer(&arglist[j]);
_bhyve_argv[j] = NULL;
*bhyve_argc = args_count-1;
- VIR_FREE(arglist);
} else if (!_loader_argv) {
VIR_REALLOC_N(_loader_argv, args_count + 1);
if (!loader_argc)
goto error;
for (j = 0; j < args_count; j++)
- _loader_argv[j] = arglist[j];
+ _loader_argv[j] = g_steal_pointer(&arglist[j]);
_loader_argv[j] = NULL;
*loader_argc = args_count-1;
- VIR_FREE(arglist);
- } else {
- /* To prevent a use-after-free here, only free the argument list
- * when it is definitely not going to be used */
- g_strfreev(arglist);
}
}
if (!(*bhyve_argv = _bhyve_argv))
goto error;
- g_strfreev(lines);
return 0;
error:
VIR_FREE(_loader_argv);
VIR_FREE(_bhyve_argv);
- g_strfreev(lines);
return -1;
}
{
virDomainDef *def = NULL;
int bhyve_argc = 0;
- char **bhyve_argv = NULL;
+ g_auto(GStrv) bhyve_argv = NULL;
int loader_argc = 0;
- char **loader_argv = NULL;
+ g_auto(GStrv) loader_argv = NULL;
if (!(def = virDomainDefNew(xmlopt)))
goto cleanup;
}
cleanup:
- g_strfreev(loader_argv);
- g_strfreev(bhyve_argv);
return def;
error:
virDomainDefFree(def);
libxlDriverGetDom0MaxmemConf(libxlDriverConfig *cfg,
unsigned long long *maxmem)
{
- char **cmd_tokens = NULL;
- char **mem_tokens = NULL;
+ g_auto(GStrv) cmd_tokens = NULL;
size_t i;
size_t j;
libxl_physinfo physinfo;
goto physmem;
for (i = 0; cmd_tokens[i] != NULL; i++) {
+ g_auto(GStrv) mem_tokens = NULL;
+
if (!STRPREFIX(cmd_tokens[i], "dom0_mem="))
continue;
goto cleanup;
}
}
- g_strfreev(mem_tokens);
- mem_tokens = NULL;
}
physmem:
ret = 0;
cleanup:
- g_strfreev(cmd_tokens);
- g_strfreev(mem_tokens);
return ret;
}
/* 'bridge' string contains a bridge name and one or more vlan trunks */
size_t i;
size_t nvlans = 0;
- char **vlanstr_list = g_strsplit(bridge, ":", 0);
+ g_auto(GStrv) vlanstr_list = g_strsplit(bridge, ":", 0);
if (!vlanstr_list)
return -1;
net->vlan.tag = g_new0(unsigned int, nvlans);
for (i = 1; i <= nvlans; i++) {
- if (virStrToLong_ui(vlanstr_list[i], NULL, 10, &tag) < 0) {
- g_strfreev(vlanstr_list);
+ if (virStrToLong_ui(vlanstr_list[i], NULL, 10, &tag) < 0)
return -1;
- }
+
net->vlan.tag[i - 1] = tag;
}
net->vlan.nTags = nvlans;
net->vlan.trunk = true;
- g_strfreev(vlanstr_list);
net->virtPortProfile = g_new0(virNetDevVPortProfile, 1);
net->virtPortProfile->virtPortType = VIR_NETDEV_VPORT_PROFILE_OPENVSWITCH;
goto cleanup;
}
if (ip) {
- char **ip_list = g_strsplit(ip, " ", 0);
+ g_auto(GStrv) ip_list = g_strsplit(ip, " ", 0);
size_t i;
if (!ip_list)
goto cleanup;
for (i = 0; ip_list[i]; i++) {
- if (virDomainNetAppendIPAddress(net, ip_list[i], 0, 0) < 0) {
- g_strfreev(ip_list);
+ if (virDomainNetAppendIPAddress(net, ip_list[i], 0, 0) < 0)
goto cleanup;
- }
}
- g_strfreev(ip_list);
}
if (script && script[0])
xenMakeIPList(virNetDevIPInfo *guestIP)
{
size_t i;
- char **address_array;
+ g_auto(GStrv) address_array = NULL;
char *ret = NULL;
address_array = g_new0(char *, guestIP->nips + 1);
ret = g_strjoinv(" ", address_array);
cleanup:
- g_strfreev(address_array);
return ret;
}
xenParseXLCPUID(virConf *conf, virDomainDef *def)
{
g_autofree char *cpuid_str = NULL;
- char **cpuid_pairs = NULL;
- char **name_and_value = NULL;
+ g_auto(GStrv) cpuid_pairs = NULL;
size_t i;
int ret = -1;
int policy;
}
for (i = 1; cpuid_pairs[i]; i++) {
- name_and_value = g_strsplit(cpuid_pairs[i], "=", 2);
+ g_auto(GStrv) name_and_value = g_strsplit(cpuid_pairs[i], "=", 2);
if (!name_and_value)
goto cleanup;
if (!name_and_value[0] || !name_and_value[1]) {
xenTranslateCPUFeature(name_and_value[0], true),
policy) < 0)
goto cleanup;
-
- g_strfreev(name_and_value);
- name_and_value = NULL;
}
ret = 0;
cleanup:
- g_strfreev(name_and_value);
- g_strfreev(cpuid_pairs);
return ret;
}
{
int ret = -1;
char *tmp = NULL;
- char **token = NULL;
size_t vcpus = 0;
size_t nr_nodes = 0;
size_t vnodeCnt = 0;
vcpus += virBitmapCountBits(cpumask);
} else if (STRPREFIX(str, "vdistances")) {
+ g_auto(GStrv) token = NULL;
size_t i, ndistances;
unsigned int value;
VIR_FREE(tmp);
tmp = g_strdup(vtoken);
- g_strfreev(token);
if (!(token = g_strsplit(tmp, ",", 0)))
goto cleanup;
cleanup:
if (ret)
VIR_FREE(cpu);
- g_strfreev(token);
VIR_FREE(tmp);
return ret;
static int
xenFormatXLCPUID(virConf *conf, virDomainDef *def)
{
- char **cpuid_pairs = NULL;
+ g_auto(GStrv) cpuid_pairs = NULL;
g_autofree char *cpuid_string = NULL;
size_t i, j;
int ret = -1;
ret = 0;
cleanup:
- g_strfreev(cpuid_pairs);
return ret;
}
static int lxcContainerUnmountSubtree(const char *prefix,
bool isOldRootFS)
{
- char **mounts = NULL;
+ g_auto(GStrv) mounts = NULL;
size_t nmounts = 0;
size_t i;
int saveErrno;
ret = 0;
cleanup:
- g_strfreev(mounts);
-
return ret;
}
g_autofree char *tmp = NULL;
size_t i;
size_t ntokens = 0;
- char **parts;
- char **result = NULL;
+ g_auto(GStrv) parts = NULL;
+ g_auto(GStrv) result = NULL;
tmp = g_strdup(string);
result[ntokens - 2] = g_strdup(parts[i]);
}
- g_strfreev(parts);
- return result;
+ return g_steal_pointer(&result);
error:
- g_strfreev(parts);
- g_strfreev(result);
return NULL;
}
lxcParseFstabLine(char *fstabLine)
{
lxcFstab *fstab = NULL;
- char **parts;
+ g_auto(GStrv) parts = NULL;
if (!fstabLine)
return NULL;
fstab->type = g_strdup(parts[2]);
fstab->options = g_strdup(parts[3]);
- g_strfreev(parts);
-
return fstab;
error:
lxcFstabFree(fstab);
- g_strfreev(parts);
return NULL;
}
{
const char *src = NULL;
g_autofree char *dst = NULL;
- char **options = g_strsplit(fstab->options, ",", 0);
+ g_auto(GStrv) options = g_strsplit(fstab->options, ",", 0);
bool readonly;
int type = VIR_DOMAIN_FS_TYPE_MOUNT;
unsigned long long usage = 0;
ret = 1;
cleanup:
- g_strfreev(options);
return ret;
}
static int
lxcBlkioDeviceWalkCallback(const char *name, virConfValue *value, void *data)
{
- char **parts = NULL;
+ g_auto(GStrv) parts = NULL;
virBlkioDevice *device = NULL;
virDomainDef *def = data;
size_t i = 0;
ret = 0;
cleanup:
- g_strfreev(parts);
return ret;
}
lxcSetCapDrop(virDomainDef *def, virConf *properties)
{
g_autofree char *value = NULL;
- char **toDrop = NULL;
+ g_auto(GStrv) toDrop = NULL;
const char *capString;
size_t i;
}
def->features[VIR_DOMAIN_FEATURE_CAPABILITIES] = VIR_DOMAIN_CAPABILITIES_POLICY_ALLOW;
-
- g_strfreev(toDrop);
}
virDomainDef *
{
g_autofree char *proc = NULL;
g_autofree char *data = NULL;
- char **lines = NULL;
+ g_auto(GStrv) lines = NULL;
size_t i;
int ret = -1;
double val;
ret = 0;
cleanup:
- g_strfreev(lines);
return ret;
}
bool migratable;
virCPUDef *cpu = NULL;
char *cpustr = NULL;
- char **features = NULL;
+ g_auto(GStrv) features = NULL;
virCheckFlags(VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES |
VIR_CONNECT_BASELINE_CPU_MIGRATABLE, NULL);
cleanup:
virCPUDefListFree(cpus);
virCPUDefFree(cpu);
- g_strfreev(features);
return cpustr;
}
remote_connect_get_cpu_model_names_ret *ret)
{
int len, rv = -1;
- char **models = NULL;
+ g_auto(GStrv) models = NULL;
virConnectPtr conn = remoteGetHypervisorConn(client);
if (!conn)
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
- g_strfreev(models);
return rv;
}
{
int rv = -1;
size_t i;
- char **retmodels = NULL;
+ g_auto(GStrv) retmodels = NULL;
remote_connect_get_cpu_model_names_args args;
remote_connect_get_cpu_model_names_ret ret;
rv = ret.ret;
cleanup:
- g_strfreev(retmodels);
-
xdr_free((xdrproc_t) xdr_remote_connect_get_cpu_model_names_ret, (char *) &ret);
done:
virStorageBackendRBDState *ptr = NULL;
struct rados_cluster_stat_t clusterstat;
struct rados_pool_stat_t poolstat;
- char **names = NULL;
+ g_auto(GStrv) names = NULL;
size_t i;
if (!(ptr = virStorageBackendRBDNewState(pool)))
ret = 0;
cleanup:
- g_strfreev(names);
virStorageBackendRBDFreeState(&ptr);
return ret;
}
static int
virCgroupSetPartitionSuffix(const char *path, char **res)
{
- char **tokens;
+ g_auto(GStrv) tokens = NULL;
size_t i;
int ret = -1;
ret = 0;
cleanup:
- g_strfreev(tokens);
return ret;
}
int rc;
g_autofree char *contStr = NULL;
g_autofree char *contFile = NULL;
- char **contList = NULL;
+ g_auto(GStrv) contList = NULL;
char **tmp;
if (parent) {
tmp++;
}
- g_strfreev(contList);
-
return 0;
}
virFirmwareParse(const char *str, virFirmware *firmware)
{
int ret = -1;
- char **token;
+ g_auto(GStrv) token = NULL;
if (!(token = g_strsplit(str, ":", 0)))
goto cleanup;
ret = 0;
cleanup:
- g_strfreev(token);
return ret;
}
size_t *nfirmwares)
{
int ret = -1;
- char **token;
+ g_auto(GStrv) token = NULL;
size_t i, j;
if (!(token = g_strsplit(list, ":", 0)))
ret = 0;
cleanup:
- g_strfreev(token);
return ret;
}
virURIResolveAlias(virConf *conf, const char *alias, char **uri)
{
int ret = -1;
- char **aliases = NULL;
+ g_auto(GStrv) aliases = NULL;
*uri = NULL;
if (aliases && *aliases) {
ret = virURIFindAliasMatch(aliases, alias, uri);
- g_strfreev(aliases);
} else {
ret = 0;
}
char *currentSnapshotXmlFilePath = NULL;
PRUnichar *machineNameUtf16 = NULL;
char *machineName = NULL;
- char **realReadWriteDisksPath = NULL;
+ g_auto(GStrv) realReadWriteDisksPath = NULL;
int realReadWriteDisksPathSize = 0;
- char **realReadOnlyDisksPath = NULL;
+ g_auto(GStrv) realReadOnlyDisksPath = NULL;
int realReadOnlyDisksPathSize = 0;
virVBoxSnapshotConfSnapshot *newSnapshotPtr = NULL;
unsigned char snapshotUuid[VIR_UUID_BUFLEN];
virVBoxSnapshotConfHardDisk **hardDiskToOpen = NULL;
size_t hardDiskToOpenSize = 0;
virVBoxSnapshotConfHardDisk *newHardDisk = NULL;
- char **searchResultTab = NULL;
+ g_auto(GStrv) searchResultTab = NULL;
ssize_t resultSize = 0;
int it = 0;
int jt = 0;
VIR_FREE(currentSnapshotXmlFilePath);
VBOX_UTF16_FREE(machineNameUtf16);
VBOX_UTF8_FREE(machineName);
- g_strfreev(realReadOnlyDisksPath);
- g_strfreev(realReadWriteDisksPath);
- g_strfreev(searchResultTab);
virVboxSnapshotConfHardDiskFree(newHardDisk);
VIR_FREE(hardDiskToOpen);
VIR_FREE(newSnapshotPtr);
char *settingsFilepath = NULL;
virVBoxSnapshotConfMachine *snapshotMachineDesc = NULL;
int isCurrent = -1;
- char **searchResultTab = NULL;
+ g_auto(GStrv) searchResultTab = NULL;
ssize_t resultSize = 0;
int it = 0;
PRUnichar *machineNameUtf16 = NULL;
VBOX_RELEASE(machine);
VBOX_UTF16_FREE(settingsFilePathUtf16);
VBOX_UTF8_FREE(settingsFilepath);
- g_strfreev(searchResultTab);
VIR_FREE(snapshotMachineDesc);
VBOX_UTF16_FREE(machineNameUtf16);
VBOX_UTF8_FREE(machineName);
virVBoxSnapshotConfHardDisk *hardDisk = NULL;
xmlNodePtr *nodes = NULL;
char *uuid = NULL;
- char **searchTabResult = NULL;
+ g_auto(GStrv) searchTabResult = NULL;
int resultSize = 0;
size_t i = 0;
int result = -1;
VIR_FREE(nodes);
VIR_FREE(location);
VIR_FREE(tmp);
- g_strfreev(searchTabResult);
if (result < 0) {
virVboxSnapshotConfHardDiskFree(hardDisk);
hardDisk = NULL;
xmlNodePtr snapshotsNode = NULL;
xmlNodePtr *nodes = NULL;
char *uuid = NULL;
- char **searchTabResult = NULL;
+ g_auto(GStrv) searchTabResult = NULL;
int resultSize = 0;
size_t i = 0;
int result = -1;
}
VIR_FREE(nodes);
VIR_FREE(uuid);
- g_strfreev(searchTabResult);
return snapshot;
}
char *uuid = NULL;
char *timeStamp = NULL;
- char **firstRegex = NULL;
+ g_auto(GStrv) firstRegex = NULL;
int firstRegexResult = 0;
- char **secondRegex = NULL;
+ g_auto(GStrv) secondRegex = NULL;
int secondRegexResult = 0;
uuid = g_strdup_printf("{%s}", snapshot->uuid);
xmlUnlinkNode(snapshotsNode);
xmlFreeNode(snapshotsNode);
}
- g_strfreev(firstRegex);
- g_strfreev(secondRegex);
VIR_FREE(uuid);
VIR_FREE(timeStamp);
return result;
g_autoptr(xmlXPathContext) xPathContext = NULL;
char *currentStateModifiedString = NULL;
- char **searchResultTab = NULL;
+ g_auto(GStrv) searchResultTab = NULL;
ssize_t searchResultSize = 0;
char *currentSnapshotAttribute = NULL;
VIR_FREE(currentStateModifiedString);
VIR_FREE(currentSnapshotAttribute);
- g_strfreev(searchResultTab);
if (ret < 0) {
virVBoxSnapshotConfMachineFree(machineDescription);
machineDescription = NULL;
char *currentSnapshot = NULL;
char *timeStamp = NULL;
- char **firstRegex = NULL;
+ g_auto(GStrv) firstRegex = NULL;
int firstRegexResult = 0;
- char **secondRegex = NULL;
+ g_auto(GStrv) secondRegex = NULL;
int secondRegexResult = 0;
if (machine == NULL) {
xmlUnlinkNode(machineNode);
xmlFreeNode(machineNode);
-
- g_strfreev(firstRegex);
- g_strfreev(secondRegex);
return ret;
}
{
int result = -1;
size_t i = 0;
- char **ret = NULL;
+ g_auto(GStrv) ret = NULL;
g_autoptr(xmlDoc) xml = NULL;
g_autoptr(xmlXPathContext) xPathContext = NULL;
xmlNodePtr *nodes = NULL;
if (sourceNode)
ret[i] = virXMLPropString(sourceNode, "file");
}
+ *rwDisksPath = g_steal_pointer(&ret);
result = 0;
cleanup:
- if (result < 0) {
- g_strfreev(ret);
+ if (result < 0)
nodeSize = -1;
- } else {
- *rwDisksPath = ret;
- }
VIR_FREE(nodes);
return nodeSize;
}
{
int result = -1;
size_t i = 0;
- char **ret = NULL;
+ g_auto(GStrv) ret = NULL;
g_autoptr(xmlDoc) xml = NULL;
g_autoptr(xmlXPathContext) xPathContext = NULL;
xmlNodePtr *nodes = NULL;
if (sourceNode)
ret[i] = virXMLPropString(sourceNode, "file");
}
+ *roDisksPath = g_steal_pointer(&ret);
result = 0;
cleanup:
- if (result < 0) {
- g_strfreev(ret);
+ if (result < 0)
nodeSize = -1;
- } else {
- *roDisksPath = ret;
- }
VIR_FREE(nodes);
return nodeSize;
}
PRUnichar *VRDEPortsValue = NULL;
PRInt32 port = -1;
ssize_t nmatches = 0;
- char **matches = NULL;
+ g_auto(GStrv) matches = NULL;
char *portUtf8 = NULL;
/* get active (effective) port - available only when VM is running and has
}
cleanup:
- g_strfreev(matches);
VBOX_UTF8_FREE(portUtf8);
VBOX_UTF16_FREE(VRDEPortsValue);
VBOX_UTF16_FREE(VRDEPortsKey);
{
char *buf = NULL;
int ret = -1;
- char **matches = NULL;
+ g_auto(GStrv) matches = NULL;
virURI *uri = NULL;
fs->type = VIR_DOMAIN_FS_TYPE_FILE;
cleanup:
VIR_FREE(buf);
- g_strfreev(matches);
return ret;
}
const testGenericData *data = opaque;
virDomainXMLOption *xmlopt = data->xmlopt;
int ret = -1;
- char **aliases = NULL;
+ g_auto(GStrv) aliases = NULL;
const char **alias;
const char *expected[] = {
"virtio-disk25", "video0", "serial0", "ide0-0-0", "usb", NULL };
}
cleanup:
- g_strfreev(aliases);
return ret;
}
testFilterXML(char *xml)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- char **xmlLines = NULL;
+ g_auto(GStrv) xmlLines = NULL;
char **xmlLine;
char *ret = NULL;
ret = virBufferContentAndReset(&buf);
cleanup:
- g_strfreev(xmlLines);
return ret;
}
int ret = -1;
g_autoptr(virConf) conf = virConfReadString(srcdata, 0);
- char **str = NULL;
+ g_auto(GStrv) str = NULL;
if (!conf)
return -1;
ret = 0;
cleanup:
- g_strfreev(str);
return ret;
}
static int testFileGetMountSubtree(const void *opaque)
{
int ret = -1;
- char **gotmounts = NULL;
+ g_auto(GStrv) gotmounts = NULL;
size_t gotnmounts = 0;
const struct testFileGetMountSubtreeData *data = opaque;
data->mounts, data->nmounts);
cleanup:
- g_strfreev(gotmounts);
return ret;
}
#endif /* ! defined WITH_MNTENT_H && defined WITH_GETMNTENT_R */
testStringSearch(const void *opaque)
{
const struct stringSearchData *data = opaque;
- char **matches = NULL;
+ g_auto(GStrv) matches = NULL;
ssize_t nmatches;
int ret = -1;
ret = 0;
cleanup:
- g_strfreev(matches);
return ret;
}
vshExtractCPUDefXMLs(vshControl *ctl,
const char *xmlFile)
{
- char **cpus = NULL;
+ g_auto(GStrv) cpus = NULL;
g_autofree char *buffer = NULL;
g_autofree char *xmlStr = NULL;
g_autoptr(xmlDoc) xml = NULL;
}
cleanup:
- return cpus;
+ return g_steal_pointer(&cpus);
error:
- g_strfreev(cpus);
goto cleanup;
}
const char *from = NULL;
bool ret = false;
int result;
- char **cpus = NULL;
+ g_auto(GStrv) cpus = NULL;
unsigned int flags = 0;
virshControl *priv = ctl->privData;
ret = true;
cleanup:
- g_strfreev(cpus);
-
return ret;
}
const char *machine = NULL;
bool ret = false;
int result;
- char **cpus = NULL;
+ g_auto(GStrv) cpus = NULL;
unsigned int flags = 0;
virshControl *priv = ctl->privData;
ret = true;
cleanup:
- g_strfreev(cpus);
return ret;
}
const char *machine = NULL;
bool ret = false;
g_autofree char *result = NULL;
- char **list = NULL;
+ g_auto(GStrv) list = NULL;
unsigned int flags = 0;
virshControl *priv = ctl->privData;
ret = true;
}
- g_strfreev(list);
return ret;
}
int ret = -1;
size_t i;
char *gname = NULL;
- char **users = NULL, **entries;
+ g_auto(GStrv) users = NULL;
+ char **entries;
if (virConfGetValueStringList(conf, "allowed_users", false, &users) < 0)
goto cleanup;
name, conf_file);
cleanup:
VIR_FREE(gname);
- g_strfreev(users);
return ret;
}
uid_t uid;
gid_t gid;
char *name = NULL;
- char **shargv = NULL;
+ g_auto(GStrv) shargv = NULL;
size_t shargvlen = 0;
char *shcmd = NULL;
virSecurityModelPtr secmodel = NULL;
virDomainFree(dom);
if (conn)
virConnectClose(conn);
- g_strfreev(shargv);
VIR_FREE(shcmd);
VIR_FREE(term);
VIR_FREE(name);
int stdin_fileno = STDIN_FILENO;
const char *arg = "";
const vshCmdOpt *opt = NULL;
- char **matches = NULL, **iter;
+ g_auto(GStrv) matches = NULL;
+ char **iter;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
if (vshCommandOptStringQuiet(ctl, cmd, "string", &arg) <= 0)
ret = true;
cleanup:
- g_strfreev(matches);
return ret;
}