unsigned int flags)
{
virDomainCheckpointDef *ret = NULL;
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
int keepBlanksDefault = xmlKeepBlanksDefault(0);
if ((xml = virXMLParse(NULL, xmlStr, _("(domain_checkpoint)"),
xmlKeepBlanksDefault(keepBlanksDefault);
ret = virDomainCheckpointDefParseNode(xml, xmlDocGetRootElement(xml),
xmlopt, parseOpaque, flags);
- xmlFreeDoc(xml);
}
xmlKeepBlanksDefault(keepBlanksDefault);
virCPUDef **cpu,
bool validateXML)
{
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
int ret = -1;
ret = 0;
cleanup:
- xmlFreeDoc(doc);
return ret;
}
void *parseOpaque,
unsigned int flags)
{
- xmlDocPtr xml = NULL;
+ g_autoptr(xmlDoc) xml = NULL;
virDomainDef *def = NULL;
int keepBlanksDefault = xmlKeepBlanksDefault(0);
xmlNodePtr root;
def = virDomainDefParseNode(xml, root, xmlopt, parseOpaque, flags);
cleanup:
- xmlFreeDoc(xml);
xmlKeepBlanksDefault(keepBlanksDefault);
return def;
}
virDomainXMLOption *xmlopt,
unsigned int flags)
{
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
virDomainObj *obj = NULL;
int keepBlanksDefault = xmlKeepBlanksDefault(0);
if ((xml = virXMLParseFile(filename))) {
obj = virDomainObjParseNode(xml, xmlDocGetRootElement(xml),
xmlopt, flags);
- xmlFreeDoc(xml);
}
xmlKeepBlanksDefault(keepBlanksDefault);
virInterfaceDefParse(const char *xmlStr,
const char *filename)
{
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
virInterfaceDef *def = NULL;
if ((xml = virXMLParse(filename, xmlStr, _("(interface_definition)"), NULL, false))) {
def = virInterfaceDefParseNode(xml, xmlDocGetRootElement(xml));
- xmlFreeDoc(xml);
}
return def;
virNodeDeviceDefParserCallbacks *parserCallbacks,
void *opaque)
{
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
g_autoptr(virNodeDeviceDef) def = NULL;
if ((xml = virXMLParse(filename, str, _("(node_device_definition)"), NULL, false))) {
def = virNodeDeviceDefParseNode(xml, xmlDocGetRootElement(xml),
create, virt_type);
- xmlFreeDoc(xml);
}
if (parserCallbacks) {
const char *filename)
{
virNWFilterDef *def = NULL;
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
if ((xml = virXMLParse(filename, xmlStr, _("(nwfilter_definition)"), NULL, false))) {
def = virNWFilterDefParseNode(xml, xmlDocGetRootElement(xml));
- xmlFreeDoc(xml);
}
return def;
virSecretDefParse(const char *xmlStr,
const char *filename)
{
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
virSecretDef *ret = NULL;
if ((xml = virXMLParse(filename, xmlStr, _("(definition_of_secret)"), NULL, false))) {
ret = secretXMLParseNode(xml, xmlDocGetRootElement(xml));
- xmlFreeDoc(xml);
}
return ret;
unsigned int flags)
{
virDomainSnapshotDef *ret = NULL;
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
int keepBlanksDefault = xmlKeepBlanksDefault(0);
if ((xml = virXMLParse(NULL, xmlStr, _("(domain_snapshot)"), "domainsnapshot.rng",
ret = virDomainSnapshotDefParseNode(xml, xmlDocGetRootElement(xml),
xmlopt, parseOpaque,
current, flags);
- xmlFreeDoc(xml);
}
xmlKeepBlanksDefault(keepBlanksDefault);
const char *filename)
{
virStoragePoolDef *ret = NULL;
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
if ((xml = virXMLParse(filename, xmlStr, _("(storage_pool_definition)"), NULL, false))) {
ret = virStoragePoolDefParseNode(xml, xmlDocGetRootElement(xml));
- xmlFreeDoc(xml);
}
return ret;
unsigned int flags)
{
virStorageVolDef *ret = NULL;
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
if ((xml = virXMLParse(filename, xmlStr, _("(storage_volume_definition)"), NULL, false))) {
ret = virStorageVolDefParseNode(pool, xml, xmlDocGetRootElement(xml), flags);
- xmlFreeDoc(xml);
}
return ret;
const char *filename)
{
virNetworkPortDef *def = NULL;
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
if ((xml = virXMLParse(filename, xmlStr, _("(networkport_definition)"), NULL, false))) {
def = virNetworkPortDefParseNode(xml, xmlDocGetRootElement(xml));
- xmlFreeDoc(xml);
}
return def;
const char *filename)
{
virNWFilterBindingDef *def = NULL;
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
if ((xml = virXMLParse(filename, xmlStr, _("(nwfilterbinding_definition)"), NULL, false))) {
def = virNWFilterBindingDefParseNode(xml, xmlDocGetRootElement(xml));
- xmlFreeDoc(xml);
}
return def;
const char *filename)
{
virNWFilterBindingObj *obj = NULL;
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
if ((xml = virXMLParse(filename, xmlStr, _("(nwfilterbinding_status)"), NULL, false))) {
obj = virNWFilterBindingObjParseNode(xml, xmlDocGetRootElement(xml));
- xmlFreeDoc(xml);
}
return obj;
virObject **obj,
virSaveCookieCallbacks *saveCookie)
{
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
int ret = -1;
ret = virSaveCookieParseNode(ctxt, obj, saveCookie);
cleanup:
- xmlFreeDoc(doc);
return ret;
}
{
char *stateFile = NULL;
virStoragePoolObj *obj = NULL;
- xmlDocPtr xml = NULL;
+ g_autoptr(xmlDoc) xml = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
xmlNodePtr node = NULL;
g_autoptr(virStoragePoolDef) def = NULL;
cleanup:
VIR_FREE(stateFile);
- xmlFreeDoc(xml);
return obj;
}
libxlMigrationCookie **migout)
{
libxlMigrationCookie *mig = NULL;
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
g_autofree char *uuidstr = NULL;
int ret = -1;
libxlMigrationCookieFree(mig);
cleanup:
- xmlFreeDoc(doc);
return ret;
}
const char *filename,
bool skipInvalidation)
{
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
int ret = -1;
size_t i;
int n;
cleanup:
VIR_FREE(str);
VIR_FREE(nodes);
- xmlFreeDoc(doc);
return ret;
}
const char *xml,
unsigned int flags)
{
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
int ret = -1;
ret = qemuMigrationCookieXMLParse(mig, driver, qemuCaps, doc, ctxt, flags);
cleanup:
- xmlFreeDoc(doc);
return ret;
}
caps_mockup(vahControl * ctl, const char *xmlStr)
{
int rc = -1;
- xmlDocPtr xml = NULL;
+ g_autoptr(xmlDoc) xml = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
char *arch;
rc = 0;
cleanup:
- xmlFreeDoc(xml);
return rc;
}
virStoragePoolSourceList *list,
virStoragePoolType pooltype)
{
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
virStoragePoolSource *src = NULL;
size_t i;
ret = nnodes;
cleanup:
- xmlFreeDoc(doc);
return ret;
}
testParseXMLDocFromFile(xmlNodePtr node, const char *file, const char *type)
{
xmlNodePtr ret = NULL;
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
g_autofree char *absFile = NULL;
g_autofree char *relFile = NULL;
}
error:
- xmlFreeDoc(doc);
return ret;
}
static int
testOpenFromFile(virConnectPtr conn, const char *file)
{
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
testDriver *privconn;
if (testOpenParse(privconn, file, ctxt) < 0)
goto error;
- xmlFreeDoc(doc);
virObjectUnlock(privconn);
return VIR_DRV_OPEN_SUCCESS;
error:
- xmlFreeDoc(doc);
virObjectUnref(privconn);
conn->privateData = NULL;
return VIR_DRV_OPEN_ERROR;
{
int ret = VIR_DRV_OPEN_ERROR;
testDriver *privconn = NULL;
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
size_t i;
ret = VIR_DRV_OPEN_SUCCESS;
cleanup:
virMutexUnlock(&defaultLock);
- xmlFreeDoc(doc);
return ret;
error:
virXMLValidateNodeAgainstSchema(const char *schemafile, xmlNodePtr node)
{
int ret;
- xmlDocPtr copy = xmlNewDoc(NULL);
+ g_autoptr(xmlDoc) copy = xmlNewDoc(NULL);
xmlDocSetRootElement(copy, xmlCopyNode(node, true));
ret = virXMLValidateAgainstSchema(schemafile, copy);
- xmlFreeDoc(copy);
return ret;
}
{
int ret = -1;
virVBoxSnapshotConfMachine *machineDescription = NULL;
- xmlDocPtr xml = NULL;
+ g_autoptr(xmlDoc) xml = NULL;
xmlNodePtr machineNode = NULL;
xmlNodePtr cur = NULL;
g_autoptr(xmlXPathContext) xPathContext = NULL;
ret = 0;
cleanup:
- xmlFreeDoc(xml);
VIR_FREE(currentStateModifiedString);
VIR_FREE(currentSnapshotAttribute);
{
int ret = -1;
size_t i = 0;
- xmlDocPtr xml = NULL;
+ g_autoptr(xmlDoc) xml = NULL;
xmlNodePtr mediaRegistryNode = NULL;
xmlNodePtr snapshotNode = NULL;
xmlNodePtr machineNode = NULL;
xmlUnlinkNode(machineNode);
xmlFreeNode(machineNode);
- xmlFreeDoc(xml);
g_strfreev(firstRegex);
g_strfreev(secondRegex);
int result = -1;
size_t i = 0;
char **ret = NULL;
- xmlDocPtr xml = NULL;
+ g_autoptr(xmlDoc) xml = NULL;
g_autoptr(xmlXPathContext) xPathContext = NULL;
xmlNodePtr *nodes = NULL;
int nodeSize = 0;
result = 0;
cleanup:
- xmlFreeDoc(xml);
if (result < 0) {
g_strfreev(ret);
nodeSize = -1;
int result = -1;
size_t i = 0;
char **ret = NULL;
- xmlDocPtr xml = NULL;
+ g_autoptr(xmlDoc) xml = NULL;
g_autoptr(xmlXPathContext) xPathContext = NULL;
xmlNodePtr *nodes = NULL;
int nodeSize = 0;
result = 0;
cleanup:
- xmlFreeDoc(xml);
if (result < 0) {
g_strfreev(ret);
nodeSize = -1;
static vzMigrationCookie *
vzEatCookie(const char *cookiein, int cookieinlen, unsigned int flags)
{
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctx = NULL;
vzMigrationCookie *mig = NULL;
}
cleanup:
- xmlFreeDoc(doc);
return mig;
error:
prlsdkParseSnapshotTree(const char *treexml)
{
virDomainSnapshotObjList *ret = NULL;
- xmlDocPtr xml = NULL;
+ g_autoptr(xmlDoc) xml = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
xmlNodePtr root;
xmlNodePtr *nodes = NULL;
virDomainSnapshotObjListFree(snapshots);
VIR_FREE(nodes);
VIR_FREE(xmlstr);
- xmlFreeDoc(xml);
VIR_FREE(def);
return ret;
cpuTestLoadXML(virArch arch, const char *name)
{
char *xml = NULL;
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
virCPUDef *cpu = NULL;
virCPUDefParseXML(ctxt, NULL, VIR_CPU_TYPE_AUTO, &cpu, false);
cleanup:
- xmlFreeDoc(doc);
VIR_FREE(xml);
return cpu;
}
unsigned int *count)
{
char *xml = NULL;
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
xmlNodePtr *nodes = NULL;
virCPUDef **cpus = NULL;
cleanup:
VIR_FREE(xml);
VIR_FREE(nodes);
- xmlFreeDoc(doc);
return cpus;
cleanup_cpus:
static char *
getMetadataFromXML(virDomainPtr dom)
{
- xmlDocPtr doc = NULL;
+ g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
xmlNodePtr node;
cleanup:
VIR_FREE(xml);
- xmlFreeDoc(doc);
return ret;
}
testQemuGetCaps(char *caps)
{
virQEMUCaps *qemuCaps = NULL;
- xmlDocPtr xml;
+ g_autoptr(xmlDoc) xml = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
ssize_t i, n;
g_autofree xmlNodePtr *nodes = NULL;
}
}
- xmlFreeDoc(xml);
return qemuCaps;
error:
virObjectUnref(qemuCaps);
- xmlFreeDoc(xml);
return NULL;
}
#define PARSE(xml, var) \
do { \
int rc; \
- xmlDocPtr doc; \
+ g_autoptr(xmlDoc) doc = NULL; \
g_autoptr(xmlXPathContext) ctxt = NULL; \
\
if (!xml) \
NULL, \
ctxt->node, \
true); \
- xmlFreeDoc(doc); \
if (rc < 0) \
goto cleanup; \
} while (0)