/* XXX: Handle quoted? */
blargs = virStringSplit(def->os.bootloaderArgs, " ", 0);
virCommandAddArgSet(cmd, (const char * const *)blargs);
- virStringListFree(blargs);
+ g_strfreev(blargs);
}
static virCommandPtr
} else {
/* To prevent a use-after-free here, only free the argument list
* when it is definitely not going to be used */
- virStringListFree(arglist);
+ g_strfreev(arglist);
}
}
if (!(*bhyve_argv = _bhyve_argv))
goto error;
- virStringListFree(lines);
+ g_strfreev(lines);
return 0;
error:
VIR_FREE(_loader_argv);
VIR_FREE(_bhyve_argv);
- virStringListFree(lines);
+ g_strfreev(lines);
return -1;
}
}
cleanup:
- virStringListFree(loader_argv);
- virStringListFree(bhyve_argv);
+ g_strfreev(loader_argv);
+ g_strfreev(bhyve_argv);
return def;
error:
virDomainDefFree(def);
for (i = 0; i < cpuModels->nmodels; i++) {
VIR_FREE(cpuModels->models[i].name);
- virStringListFree(cpuModels->models[i].blockers);
+ g_strfreev(cpuModels->models[i].blockers);
}
VIR_FREE(cpuModels->models);
VIR_FREE(def->sysfs_path);
VIR_FREE(def->parent_sysfs_path);
VIR_FREE(def->devnode);
- virStringListFree(def->devlinks);
+ g_strfreev(def->devlinks);
caps = def->caps;
while (caps) {
if (!data)
return;
- virStringListFree(data->features);
+ g_strfreev(data->features);
}
static void
error:
if (models) {
- virStringListFree(*models);
+ g_strfreev(*models);
*models = NULL;
}
goto cleanup;
goto cleanup;
}
}
- virStringListFree(mem_tokens);
+ g_strfreev(mem_tokens);
mem_tokens = NULL;
}
ret = 0;
cleanup:
- virStringListFree(cmd_tokens);
- virStringListFree(mem_tokens);
+ g_strfreev(cmd_tokens);
+ g_strfreev(mem_tokens);
return ret;
}
nvlans++;
if (VIR_ALLOC_N(net->vlan.tag, nvlans) < 0) {
- virStringListFree(vlanstr_list);
+ g_strfreev(vlanstr_list);
return -1;
}
for (i = 1; i <= nvlans; i++) {
if (virStrToLong_ui(vlanstr_list[i], NULL, 10, &tag) < 0) {
- virStringListFree(vlanstr_list);
+ g_strfreev(vlanstr_list);
return -1;
}
net->vlan.tag[i - 1] = tag;
}
net->vlan.nTags = nvlans;
net->vlan.trunk = true;
- virStringListFree(vlanstr_list);
+ g_strfreev(vlanstr_list);
if (VIR_ALLOC(net->virtPortProfile) < 0)
return -1;
for (i = 0; ip_list[i]; i++) {
if (virDomainNetAppendIPAddress(net, ip_list[i], 0, 0) < 0) {
- virStringListFree(ip_list);
+ g_strfreev(ip_list);
goto cleanup;
}
}
- virStringListFree(ip_list);
+ g_strfreev(ip_list);
}
if (script && script[0])
ret = virStringListJoin((const char**)address_array, " ");
cleanup:
- virStringListFree(address_array);
+ g_strfreev(address_array);
return ret;
}
policy) < 0)
goto cleanup;
- virStringListFree(name_and_value);
+ g_strfreev(name_and_value);
name_and_value = NULL;
}
ret = 0;
cleanup:
- virStringListFree(name_and_value);
- virStringListFree(cpuid_pairs);
+ g_strfreev(name_and_value);
+ g_strfreev(cpuid_pairs);
return ret;
}
VIR_FREE(tmp);
tmp = g_strdup(vtoken);
- virStringListFree(token);
+ g_strfreev(token);
if (!(token = virStringSplitCount(tmp, ",", 0, &ndistances)))
goto cleanup;
cleanup:
if (ret)
VIR_FREE(cpu);
- virStringListFree(token);
+ g_strfreev(token);
VIR_FREE(tmp);
return ret;
ret = 0;
cleanup:
- virStringListFree(cpuid_pairs);
+ g_strfreev(cpuid_pairs);
VIR_FREE(cpuid_string);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(disks);
+ g_strfreev(disks);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(mounts);
+ g_strfreev(mounts);
return ret;
}
result[ntokens - 2] = g_strdup(parts[i]);
}
- virStringListFree(parts);
+ g_strfreev(parts);
return result;
error:
- virStringListFree(parts);
- virStringListFree(result);
+ g_strfreev(parts);
+ g_strfreev(result);
return NULL;
}
fstab->type = g_strdup(parts[2]);
fstab->options = g_strdup(parts[3]);
- virStringListFree(parts);
+ g_strfreev(parts);
return fstab;
error:
lxcFstabFree(fstab);
- virStringListFree(parts);
+ g_strfreev(parts);
return NULL;
}
ret = 1;
cleanup:
- virStringListFree(options);
+ g_strfreev(options);
return ret;
}
virReportError(VIR_ERR_INVALID_ARG,
_("Invalid CIDR address: '%s'"), value->str);
- virStringListFree(ipparts);
+ g_strfreev(ipparts);
return -1;
}
- virStringListFree(ipparts);
+ g_strfreev(ipparts);
if (VIR_APPEND_ELEMENT(parseData->ips, parseData->nips, ip) < 0)
return -1;
ret = 0;
cleanup:
- virStringListFree(parts);
+ g_strfreev(parts);
return ret;
}
def->features[VIR_DOMAIN_FEATURE_CAPABILITIES] = VIR_DOMAIN_CAPABILITIES_POLICY_ALLOW;
- virStringListFree(toDrop);
+ g_strfreev(toDrop);
}
virDomainDefPtr
}
/* Has to be freed for each interface. */
- virStringListFree(ifname);
+ g_strfreev(ifname);
/* as well as IP address which - moreover -
* can be presented multiple times */
virDomainInterfaceFree(ifaces_ret[i]);
}
VIR_FREE(ifaces_ret);
- virStringListFree(ifname);
+ g_strfreev(ifname);
goto cleanup;
}
else
ret = 0;
- virStringListFree(list);
+ g_strfreev(list);
return ret;
}
virQEMUCapsTPMModelsToCaps[i].caps);
}
}
- virStringListFree(entries);
+ g_strfreev(entries);
if ((nentries = qemuMonitorGetTPMTypes(mon, &entries)) < 0)
return -1;
virQEMUCapsSet(qemuCaps, virQEMUCapsTPMTypesToCaps[i].caps);
}
}
- virStringListFree(entries);
+ g_strfreev(entries);
return 0;
}
break;
}
}
- virStringListFree(values);
+ g_strfreev(values);
}
return 0;
virBitmapFree(cfg->namespaces);
- virStringListFree(cfg->cgroupDeviceACL);
+ g_strfreev(cfg->cgroupDeviceACL);
VIR_FREE(cfg->uri);
VIR_FREE(cfg->configBaseDir);
VIR_FREE(cfg->snapshotImageFormat);
VIR_FREE(cfg->autoDumpPath);
- virStringListFree(cfg->securityDriverNames);
+ g_strfreev(cfg->securityDriverNames);
VIR_FREE(cfg->lockManagerName);
VIR_FREE(cfg->memoryBackingDir);
VIR_FREE(cfg->swtpmStorageDir);
- virStringListFree(cfg->capabilityfilters);
+ g_strfreev(cfg->capabilityfilters);
}
void
qemuDomainObjPrivateDataClear(qemuDomainObjPrivatePtr priv)
{
- virStringListFree(priv->qemuDevices);
+ g_strfreev(priv->qemuDevices);
priv->qemuDevices = NULL;
virCgroupFree(&priv->cgroup);
priv->dbusDaemonRunning = false;
- virStringListFree(priv->dbusVMStateIds);
+ g_strfreev(priv->dbusVMStateIds);
priv->dbusVMStateIds = NULL;
priv->dbusVMState = false;
priv->namespaces = NULL;
virObjectUnref(priv->monConfig);
priv->monConfig = NULL;
- virStringListFree(priv->qemuDevices);
+ g_strfreev(priv->qemuDevices);
priv->qemuDevices = NULL;
return -1;
}
if (rc < 0)
return -1;
- virStringListFree(priv->qemuDevices);
+ g_strfreev(priv->qemuDevices);
priv->qemuDevices = aliases;
return 0;
}
ret = 0;
cleanup:
- virStringListFree(lines);
+ g_strfreev(lines);
return ret;
}
cleanup:
virCPUDefListFree(cpus);
virCPUDefFree(cpu);
- virStringListFree(features);
+ g_strfreev(features);
return cpustr;
}
cleanup:
virBitmapFree(migEvent);
virJSONValueFree(json);
- virStringListFree(caps);
+ g_strfreev(caps);
return ret;
}
cleanup:
- virStringListFree(commandlist);
+ g_strfreev(commandlist);
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
eventlist = NULL;
cleanup:
- virStringListFree(eventlist);
+ g_strfreev(eventlist);
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
if (!qemuMonitorGetOptions(mon))
qemuMonitorSetOptions(mon, virJSONValueNewArray());
- virStringListFree(paramlist);
+ g_strfreev(paramlist);
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
typelist = NULL;
cleanup:
- virStringListFree(typelist);
+ g_strfreev(typelist);
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
proplist = NULL;
cleanup:
- virStringListFree(proplist);
+ g_strfreev(proplist);
return ret;
}
list = NULL;
cleanup:
- virStringListFree(list);
+ g_strfreev(list);
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
list = NULL;
cleanup:
- virStringListFree(list);
+ g_strfreev(list);
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = 0;
cleanup:
- virStringListFree(old);
+ g_strfreev(old);
return ret;
}
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
- virStringListFree(models);
+ g_strfreev(models);
return rv;
}
rv = ret.ret;
cleanup:
- virStringListFree(retmodels);
+ g_strfreev(retmodels);
xdr_free((xdrproc_t) xdr_remote_connect_get_cpu_model_names_ret, (char *) &ret);
ret = 0;
cleanup:
- virStringListFree(names);
+ g_strfreev(names);
virStorageBackendRBDFreeState(&ptr);
return ret;
}
return -1;
}
- virStringListFree(cells);
+ g_strfreev(cells);
cells = NULL;
}
if (STREQ(lines[i], ""))
continue;
- virStringListFree(tokens);
+ g_strfreev(tokens);
if (!(tokens = virStringSplitCount(lines[i], "\t", 0, &count)))
goto cleanup;
ret = 0;
error:
- virStringListFree(lines);
+ g_strfreev(lines);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(tokens);
+ g_strfreev(tokens);
return ret;
}
tmp++;
}
- virStringListFree(contList);
+ g_strfreev(contList);
return 0;
}
if (!cval)
return 0;
- virStringListFree(*values);
+ g_strfreev(*values);
*values = NULL;
switch (cval->type) {
cleanup:
if (ret < 0)
- virStringListFree(mounts);
+ g_strfreev(mounts);
endmntent(procmnt);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(token);
+ g_strfreev(token);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(token);
+ g_strfreev(token);
return ret;
}
}
cleanup:
- virStringListFree(tokens);
+ g_strfreev(tokens);
return ret;
}
goto cleanup;
cleanup:
- virStringListFree(tokens);
+ g_strfreev(tokens);
return ret;
}
*outputs = list;
list = NULL;
cleanup:
- virStringListFree(strings);
+ g_strfreev(strings);
return ret;
}
*filters = list;
list = NULL;
cleanup:
- virStringListFree(strings);
+ g_strfreev(strings);
return ret;
}
const void *name G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
- virStringListFree(payload);
+ g_strfreev(payload);
return 0;
}
}
if (resctrl->monitor_info)
- virStringListFree(resctrl->monitor_info->features);
+ g_strfreev(resctrl->monitor_info->features);
VIR_FREE(resctrl->membw_info);
VIR_FREE(resctrl->levels);
if (!mon)
return;
- virStringListFree(mon->features);
+ g_strfreev(mon->features);
VIR_FREE(mon);
}
ret = 0;
cleanup:
VIR_FREE(featurestr);
- virStringListFree(features);
+ g_strfreev(features);
VIR_FREE(info_monitor);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(mbs);
+ g_strfreev(mbs);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(caches);
+ g_strfreev(caches);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(lines);
+ g_strfreev(lines);
return ret;
}
if (!stat)
return;
- virStringListFree(stat->features);
+ g_strfreev(stat->features);
VIR_FREE(stat->vals);
VIR_FREE(stat);
}
if (!*strings)
return;
- virStringListFree(*strings);
+ g_strfreev(*strings);
*strings = NULL;
}
cleanup:
if (ret < 0) {
- virStringListFree(*matches);
+ g_strfreev(*matches);
*matches = NULL;
}
return ret;
if (aliases && *aliases) {
ret = virURIFindAliasMatch(aliases, alias, uri);
- virStringListFree(aliases);
+ g_strfreev(aliases);
} else {
ret = 0;
}
tmp = virStringReplace(newSnapshotPtr->storageController,
searchResultTab[it],
uuidReplacing);
- virStringListFree(searchResultTab);
+ g_strfreev(searchResultTab);
searchResultTab = NULL;
VIR_FREE(newSnapshotPtr->storageController);
if (!tmp)
VIR_FREE(currentSnapshotXmlFilePath);
VBOX_UTF16_FREE(machineNameUtf16);
VBOX_UTF8_FREE(machineName);
- virStringListFree(realReadOnlyDisksPath);
- virStringListFree(realReadWriteDisksPath);
- virStringListFree(searchResultTab);
+ g_strfreev(realReadOnlyDisksPath);
+ g_strfreev(realReadWriteDisksPath);
+ g_strfreev(searchResultTab);
virVboxSnapshotConfHardDiskFree(newHardDisk);
VIR_FREE(hardDiskToOpen);
VIR_FREE(newSnapshotPtr);
VBOX_RELEASE(machine);
VBOX_UTF16_FREE(settingsFilePathUtf16);
VBOX_UTF8_FREE(settingsFilepath);
- virStringListFree(searchResultTab);
+ g_strfreev(searchResultTab);
VIR_FREE(snapshotMachineDesc);
VBOX_UTF16_FREE(machineNameUtf16);
VBOX_UTF8_FREE(machineName);
VIR_FREE(nodes);
VIR_FREE(location);
VIR_FREE(tmp);
- virStringListFree(searchTabResult);
+ g_strfreev(searchTabResult);
if (result < 0) {
virVboxSnapshotConfHardDiskFree(hardDisk);
hardDisk = NULL;
}
VIR_FREE(nodes);
VIR_FREE(uuid);
- virStringListFree(searchTabResult);
+ g_strfreev(searchTabResult);
return snapshot;
}
xmlUnlinkNode(snapshotsNode);
xmlFreeNode(snapshotsNode);
}
- virStringListFree(firstRegex);
- virStringListFree(secondRegex);
+ g_strfreev(firstRegex);
+ g_strfreev(secondRegex);
VIR_FREE(uuid);
VIR_FREE(timeStamp);
return result;
VIR_FREE(currentStateModifiedString);
VIR_FREE(currentSnapshotAttribute);
- virStringListFree(searchResultTab);
+ g_strfreev(searchResultTab);
if (ret < 0) {
virVBoxSnapshotConfMachineFree(machineDescription);
machineDescription = NULL;
xmlFreeDoc(xml);
- virStringListFree(firstRegex);
- virStringListFree(secondRegex);
+ g_strfreev(firstRegex);
+ g_strfreev(secondRegex);
return ret;
}
xmlFreeDoc(xml);
xmlXPathFreeContext(xPathContext);
if (result < 0) {
- virStringListFree(ret);
+ g_strfreev(ret);
nodeSize = -1;
} else {
*rwDisksPath = ret;
xmlFreeDoc(xml);
xmlXPathFreeContext(xPathContext);
if (result < 0) {
- virStringListFree(ret);
+ g_strfreev(ret);
nodeSize = -1;
} else {
*roDisksPath = ret;
}
cleanup:
- virStringListFree(matches);
+ g_strfreev(matches);
VBOX_UTF8_FREE(portUtf8);
VBOX_UTF16_FREE(VRDEPortsValue);
VBOX_UTF16_FREE(VRDEPortsKey);
cleanup:
VIR_FREE(buf);
- virStringListFree(matches);
+ g_strfreev(matches);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(tpmmodels);
+ g_strfreev(tpmmodels);
return ret;
}
#undef CHECK
- virStringListFree(params);
+ g_strfreev(params);
params = NULL;
/* present but empty */
goto cleanup;
}
- virStringListFree(params);
+ g_strfreev(params);
params = NULL;
/* no such option */
ret = 0;
cleanup:
- virStringListFree(params);
+ g_strfreev(params);
return ret;
}
}
cleanup:
- virStringListFree(aliases);
+ g_strfreev(aliases);
return ret;
}
cleanup:
virJSONValueFree(json);
- virStringListFree(caps);
+ g_strfreev(caps);
virBitmapFree(bitmap);
return ret;
}
ret = virBufferContentAndReset(&buf);
cleanup:
- virStringListFree(xmlLines);
+ g_strfreev(xmlLines);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(str);
+ g_strfreev(str);
return ret;
}
data->mounts, data->nmounts);
cleanup:
- virStringListFree(gotmounts);
+ g_strfreev(gotmounts);
return ret;
}
#endif /* ! defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R */
ret = 0;
cleanup:
- virStringListFree(got);
+ g_strfreev(got);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(list);
+ g_strfreev(list);
VIR_FREE(got);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(list);
+ g_strfreev(list);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(matches);
+ g_strfreev(matches);
return ret;
}
cleanup:
if (ret < 0)
vshError(ctl, _("unable to parse diskspec: %s"), str);
- virStringListFree(array);
+ g_strfreev(array);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(tok);
+ g_strfreev(tok);
return ret;
}
fds[nfds - 1] = fd;
}
- virStringListFree(fdlist);
+ g_strfreev(fdlist);
*fdsret = fds;
*nfdsret = nfds;
return 0;
error:
- virStringListFree(fdlist);
+ g_strfreev(fdlist);
VIR_FREE(fds);
return -1;
}
ret = true;
cleanup:
virshDomainFree(dom);
- virStringListFree(modes);
+ g_strfreev(modes);
return ret;
}
ret = true;
cleanup:
virshDomainFree(dom);
- virStringListFree(modes);
+ g_strfreev(modes);
return ret;
}
ret = 0;
cleanup:
- virStringListFree(tok);
+ g_strfreev(tok);
return ret;
}
return cpus;
error:
- virStringListFree(cpus);
+ g_strfreev(cpus);
goto cleanup;
}
ret = true;
cleanup:
- virStringListFree(cpus);
+ g_strfreev(cpus);
return ret;
}
}
VIR_FREE(result);
- virStringListFree(list);
+ g_strfreev(list);
return ret;
}
ret = true;
cleanup:
- virStringListFree(cpus);
+ g_strfreev(cpus);
return ret;
}
}
VIR_FREE(result);
- virStringListFree(list);
+ g_strfreev(list);
return ret;
}
ret = true;
cleanup:
- virStringListFree(arr);
+ g_strfreev(arr);
if (dev)
virNodeDeviceFree(dev);
return ret;
}
cleanup:
- virStringListFree(caps);
+ g_strfreev(caps);
virshNodeDeviceListFree(list);
return ret;
}
ret = true;
cleanup:
- virStringListFree(arr);
+ g_strfreev(arr);
VIR_FREE(xml);
if (device)
virNodeDeviceFree(device);
for (i = 0; i < npoolTypes; i++) {
if ((poolType = virStoragePoolTypeFromString(poolTypes[i])) < 0) {
vshError(ctl, _("Invalid pool type '%s'"), poolTypes[i]);
- virStringListFree(poolTypes);
+ g_strfreev(poolTypes);
return false;
}
break;
}
}
- virStringListFree(poolTypes);
+ g_strfreev(poolTypes);
}
if (!(list = virshStoragePoolListCollect(ctl, flags)))
cleanup:
if (ret < 0)
vshError(ctl, _("unable to parse memspec: %s"), str);
- virStringListFree(array);
+ g_strfreev(array);
return ret;
}
cleanup:
if (ret < 0)
vshError(ctl, _("unable to parse diskspec: %s"), str);
- virStringListFree(array);
+ g_strfreev(array);
return ret;
}
name, conf_file);
cleanup:
VIR_FREE(gname);
- virStringListFree(users);
+ g_strfreev(users);
return ret;
}
if (autoshell) {
tmp = virGetUserShell(uid);
if (tmp) {
- virStringListFree(shargv);
+ g_strfreev(shargv);
shargvlen = 1;
if (VIR_ALLOC_N(shargv[0], shargvlen + 1) < 0) {
VIR_FREE(tmp);
virDomainFree(dom);
if (conn)
virConnectClose(conn);
- virStringListFree(shargv);
+ g_strfreev(shargv);
VIR_FREE(shcmd);
VIR_FREE(term);
VIR_FREE(name);
if (STREQLEN(name, text, len)) {
if (VIR_REALLOC_N(ret, ret_size + 2) < 0) {
- virStringListFree(ret);
+ g_strfreev(ret);
return NULL;
}
ret[ret_size] = g_strdup(name);
continue;
if (VIR_REALLOC_N(ret, ret_size + 2) < 0) {
- virStringListFree(ret);
+ g_strfreev(ret);
return NULL;
}
vshCommandFree(partial);
partial = NULL;
- virStringListFree(list);
+ g_strfreev(list);
list = NULL;
list_index = 0;
if (completer_list &&
(vshCompleterFilter(&completer_list, text) < 0 ||
virStringListMerge(&list, &completer_list) < 0)) {
- virStringListFree(completer_list);
+ g_strfreev(completer_list);
goto cleanup;
}
}
if (!ret) {
vshCommandFree(partial);
partial = NULL;
- virStringListFree(list);
+ g_strfreev(list);
list = NULL;
list_index = 0;
}
ret = true;
cleanup:
- virStringListFree(matches);
+ g_strfreev(matches);
return ret;
}
projects / thirdparty / libvirt.git / commitdiff
