openkylin
/
libvirt
mirror of https://gitee.com/openkylin/libvirt.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Remove conn parameter from virXPath* functions 

It was used for error reporting only.
This commit is contained in:
Matthias Bolte 2010-02-04 22:52:34 +01:00
parent a5ab900d26
commit d5c6183def
17 changed files with 267 additions and 295 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
docs/api_extension/0007-Step-7-of-8-Implement-the-driver-methods.patch
View File

@ -550,7 +550,7 @@ index 6e04112..5b35b60 100644
+{
+ char *s;
+
+ s = virXPathString(conn, xpath, ctxt);
+ s = virXPathString(xpath, ctxt);
+ if (s == NULL) {
+ virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
+ missing_error_fmt,
@ -611,7 +611,7 @@ index 6e04112..5b35b60 100644
goto out;
+ }
+
+ if ((n = virXPathNodeSet(conn, "./capability", ctxt, &nodes)) < 0) {
+ if ((n = virXPathNodeSet("./capability", ctxt, &nodes)) < 0) {
+ virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
+ _("error parsing SCSI host capabilities for '%s'"),
+ def->name);
@ -713,9 +713,9 @@ index 6e04112..5b35b60 100644
}
/* Extract device name */
- def->name = virXPathString(conn, "string(./name[1])", ctxt);
- def->name = virXPathString("string(./name[1])", ctxt);
+ if (create == EXISTING_DEVICE) {
+ def->name = virXPathString(conn, "string(./name[1])", ctxt);
+ def->name = virXPathString("string(./name[1])", ctxt);
+ } else {
+ def->name = strdup("new device");
+ }

18
src/conf/cpu_conf.c
View File

@ -85,7 +85,7 @@ virCPUDefParseXML(virConnectPtr conn,
}
if (mode == VIR_CPU_TYPE_AUTO) {
if (virXPathBoolean(conn, "boolean(./arch)", ctxt))
if (virXPathBoolean("boolean(./arch)", ctxt))
def->type = VIR_CPU_TYPE_HOST;
else
def->type = VIR_CPU_TYPE_GUEST;
@ -96,7 +96,7 @@ virCPUDefParseXML(virConnectPtr conn,
char *match = virXMLPropString(node, "match");
if (!match) {
if (virXPathBoolean(conn, "boolean(./model)", ctxt)) {
if (virXPathBoolean("boolean(./model)", ctxt)) {
virCPUReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("Missing match attribute for CPU specification"));
goto error;
@ -115,7 +115,7 @@ virCPUDefParseXML(virConnectPtr conn,
}
if (def->type == VIR_CPU_TYPE_HOST) {
def->arch = virXPathString(conn, "string(./arch[1])", ctxt);
def->arch = virXPathString("string(./arch[1])", ctxt);
if (!def->arch) {
virCPUReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("Missing CPU architecture"));
@ -123,18 +123,18 @@ virCPUDefParseXML(virConnectPtr conn,
}
}
if (!(def->model = virXPathString(conn, "string(./model[1])", ctxt)) &&
if (!(def->model = virXPathString("string(./model[1])", ctxt)) &&
def->type == VIR_CPU_TYPE_HOST) {
virCPUReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("Missing CPU model name"));
goto error;
}
if (virXPathNode(conn, "./topology[1]", ctxt)) {
if (virXPathNode("./topology[1]", ctxt)) {
int ret;
unsigned long ul;
ret = virXPathULong(conn, "string(./topology[1]/@sockets)",
ret = virXPathULong("string(./topology[1]/@sockets)",
ctxt, &ul);
if (ret < 0) {
virCPUReportError(conn, VIR_ERR_INTERNAL_ERROR,
@ -143,7 +143,7 @@ virCPUDefParseXML(virConnectPtr conn,
}
def->sockets = (unsigned int) ul;
ret = virXPathULong(conn, "string(./topology[1]/@cores)",
ret = virXPathULong("string(./topology[1]/@cores)",
ctxt, &ul);
if (ret < 0) {
virCPUReportError(conn, VIR_ERR_INTERNAL_ERROR,
@ -152,7 +152,7 @@ virCPUDefParseXML(virConnectPtr conn,
}
def->cores = (unsigned int) ul;
ret = virXPathULong(conn, "string(./topology[1]/@threads)",
ret = virXPathULong("string(./topology[1]/@threads)",
ctxt, &ul);
if (ret < 0) {
virCPUReportError(conn, VIR_ERR_INTERNAL_ERROR,
@ -168,7 +168,7 @@ virCPUDefParseXML(virConnectPtr conn,
}
}
n = virXPathNodeSet(conn, "./feature", ctxt, &nodes);
n = virXPathNodeSet("./feature", ctxt, &nodes);
if (n < 0)
goto error;

98
src/conf/domain_conf.c
View File

@ -3030,7 +3030,7 @@ static int virDomainLifecycleParseXML(virConnectPtr conn,
int *val,
int defaultVal)
{
char *tmp = virXPathString(conn, xpath, ctxt);
char *tmp = virXPathString(xpath, ctxt);
if (tmp == NULL) {
*val = defaultVal;
} else {
@ -3054,10 +3054,10 @@ virSecurityLabelDefParseXML(virConnectPtr conn,
{
char *p;
if (virXPathNode(conn, "./seclabel", ctxt) == NULL)
if (virXPathNode("./seclabel", ctxt) == NULL)
return 0;
p = virXPathStringLimit(conn, "string(./seclabel/@type)",
p = virXPathStringLimit("string(./seclabel/@type)",
VIR_SECURITY_LABEL_BUFLEN-1, ctxt);
if (p == NULL) {
virDomainReportError(conn, VIR_ERR_XML_ERROR,
@ -3077,7 +3077,7 @@ virSecurityLabelDefParseXML(virConnectPtr conn,
*/
if (def->seclabel.type == VIR_DOMAIN_SECLABEL_STATIC ||
!(flags & VIR_DOMAIN_XML_INACTIVE)) {
p = virXPathStringLimit(conn, "string(./seclabel/@model)",
p = virXPathStringLimit("string(./seclabel/@model)",
VIR_SECURITY_MODEL_BUFLEN-1, ctxt);
if (p == NULL) {
virDomainReportError(conn, VIR_ERR_XML_ERROR,
@ -3086,7 +3086,7 @@ virSecurityLabelDefParseXML(virConnectPtr conn,
}
def->seclabel.model = p;
p = virXPathStringLimit(conn, "string(./seclabel/label[1])",
p = virXPathStringLimit("string(./seclabel/label[1])",
VIR_SECURITY_LABEL_BUFLEN-1, ctxt);
if (p == NULL) {
virDomainReportError(conn, VIR_ERR_XML_ERROR,
@ -3100,7 +3100,7 @@ virSecurityLabelDefParseXML(virConnectPtr conn,
/* Only parse imagelabel, if requested live XML for dynamic label */
if (def->seclabel.type == VIR_DOMAIN_SECLABEL_DYNAMIC &&
!(flags & VIR_DOMAIN_XML_INACTIVE)) {
p = virXPathStringLimit(conn, "string(./seclabel/imagelabel[1])",
p = virXPathStringLimit("string(./seclabel/imagelabel[1])",
VIR_SECURITY_LABEL_BUFLEN-1, ctxt);
if (p == NULL) {
virDomainReportError(conn, VIR_ERR_XML_ERROR,
@ -3358,12 +3358,12 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
}
if (!(flags & VIR_DOMAIN_XML_INACTIVE))
if ((virXPathLong(conn, "string(./@id)", ctxt, &id)) < 0)
if ((virXPathLong("string(./@id)", ctxt, &id)) < 0)
id = -1;
def->id = (int)id;
/* Find out what type of virtualization to use */
if (!(tmp = virXPathString(conn, "string(./@type)", ctxt))) {
if (!(tmp = virXPathString("string(./@type)", ctxt))) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("missing domain type attribute"));
goto error;
@ -3377,13 +3377,13 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
VIR_FREE(tmp);
/* Extract domain name */
if (!(def->name = virXPathString(conn, "string(./name[1])", ctxt))) {
if (!(def->name = virXPathString("string(./name[1])", ctxt))) {
virDomainReportError(conn, VIR_ERR_NO_NAME, NULL);
goto error;
}
/* Extract domain uuid */
tmp = virXPathString(conn, "string(./uuid[1])", ctxt);
tmp = virXPathString("string(./uuid[1])", ctxt);
if (!tmp) {
if (virUUIDGenerate(def->uuid)) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
@ -3400,26 +3400,26 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
}
/* Extract documentation if present */
def->description = virXPathString(conn, "string(./description[1])", ctxt);
def->description = virXPathString("string(./description[1])", ctxt);
/* Extract domain memory */
if (virXPathULong(conn, "string(./memory[1])", ctxt, &def->maxmem) < 0) {
if (virXPathULong("string(./memory[1])", ctxt, &def->maxmem) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("missing memory element"));
goto error;
}
if (virXPathULong(conn, "string(./currentMemory[1])", ctxt, &def->memory) < 0)
if (virXPathULong("string(./currentMemory[1])", ctxt, &def->memory) < 0)
def->memory = def->maxmem;
node = virXPathNode(conn, "./memoryBacking/hugepages", ctxt);
node = virXPathNode("./memoryBacking/hugepages", ctxt);
if (node)
def->hugepage_backed = 1;
if (virXPathULong(conn, "string(./vcpu[1])", ctxt, &def->vcpus) < 0)
if (virXPathULong("string(./vcpu[1])", ctxt, &def->vcpus) < 0)
def->vcpus = 1;
tmp = virXPathString(conn, "string(./vcpu[1]/@cpuset)", ctxt);
tmp = virXPathString("string(./vcpu[1]/@cpuset)", ctxt);
if (tmp) {
char *set = tmp;
def->cpumasklen = VIR_DOMAIN_CPUMASK_LEN;
@ -3434,7 +3434,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
VIR_FREE(tmp);
}
n = virXPathNodeSet(conn, "./features/*", ctxt, &nodes);
n = virXPathNodeSet("./features/*", ctxt, &nodes);
if (n < 0)
goto error;
if (n) {
@ -3464,15 +3464,15 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
goto error;
tmp = virXPathString(conn, "string(./clock/@offset)", ctxt);
tmp = virXPathString("string(./clock/@offset)", ctxt);
if (tmp && STREQ(tmp, "localtime"))
def->localtime = 1;
VIR_FREE(tmp);
def->os.bootloader = virXPathString(conn, "string(./bootloader)", ctxt);
def->os.bootloaderArgs = virXPathString(conn, "string(./bootloader_args)", ctxt);
def->os.bootloader = virXPathString("string(./bootloader)", ctxt);
def->os.bootloaderArgs = virXPathString("string(./bootloader_args)", ctxt);
def->os.type = virXPathString(conn, "string(./os/type[1])", ctxt);
def->os.type = virXPathString("string(./os/type[1])", ctxt);
if (!def->os.type) {
if (def->os.bootloader) {
def->os.type = strdup("xen");
@ -3506,7 +3506,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
goto error;
}
def->os.arch = virXPathString(conn, "string(./os/type[1]/@arch)", ctxt);
def->os.arch = virXPathString("string(./os/type[1]/@arch)", ctxt);
if (def->os.arch) {
if (!virCapabilitiesSupportsGuestArch(caps, def->os.type, def->os.arch)) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
@ -3528,7 +3528,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
}
}
def->os.machine = virXPathString(conn, "string(./os/type[1]/@machine)", ctxt);
def->os.machine = virXPathString("string(./os/type[1]/@machine)", ctxt);
if (!def->os.machine) {
const char *defaultMachine = virCapabilitiesDefaultGuestMachine(caps,
def->os.type,
@ -3552,22 +3552,22 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
*/
if (STREQ(def->os.type, "exe")) {
def->os.init = virXPathString(conn, "string(./os/init[1])", ctxt);
def->os.init = virXPathString("string(./os/init[1])", ctxt);
}
if (STREQ(def->os.type, "xen") ||
STREQ(def->os.type, "hvm") ||
STREQ(def->os.type, "uml")) {
def->os.kernel = virXPathString(conn, "string(./os/kernel[1])", ctxt);
def->os.initrd = virXPathString(conn, "string(./os/initrd[1])", ctxt);
def->os.cmdline = virXPathString(conn, "string(./os/cmdline[1])", ctxt);
def->os.root = virXPathString(conn, "string(./os/root[1])", ctxt);
def->os.loader = virXPathString(conn, "string(./os/loader[1])", ctxt);
def->os.kernel = virXPathString("string(./os/kernel[1])", ctxt);
def->os.initrd = virXPathString("string(./os/initrd[1])", ctxt);
def->os.cmdline = virXPathString("string(./os/cmdline[1])", ctxt);
def->os.root = virXPathString("string(./os/root[1])", ctxt);
def->os.loader = virXPathString("string(./os/loader[1])", ctxt);
}
if (STREQ(def->os.type, "hvm")) {
/* analysis of the boot devices */
if ((n = virXPathNodeSet(conn, "./os/boot", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./os/boot", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract boot device"));
goto error;
@ -3597,7 +3597,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
VIR_FREE(nodes);
}
def->emulator = virXPathString(conn, "string(./devices/emulator[1])", ctxt);
def->emulator = virXPathString("string(./devices/emulator[1])", ctxt);
if (!def->emulator && virCapabilitiesIsEmulatorRequired(caps)) {
def->emulator = virDomainDefDefaultEmulator(conn, def, caps);
if (!def->emulator)
@ -3605,7 +3605,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
}
/* analysis of the disk devices */
if ((n = virXPathNodeSet(conn, "./devices/disk", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/disk", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract disk devices"));
goto error;
@ -3624,7 +3624,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
VIR_FREE(nodes);
/* analysis of the controller devices */
if ((n = virXPathNodeSet(conn, "./devices/controller", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/controller", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract controller devices"));
goto error;
@ -3649,7 +3649,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
goto error;
/* analysis of the filesystems */
if ((n = virXPathNodeSet(conn, "./devices/filesystem", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/filesystem", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract filesystem devices"));
goto error;
@ -3668,7 +3668,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
VIR_FREE(nodes);
/* analysis of the network devices */
if ((n = virXPathNodeSet(conn, "./devices/interface", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/interface", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract network devices"));
goto error;
@ -3689,7 +3689,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
/* analysis of the character devices */
if ((n = virXPathNodeSet(conn, "./devices/parallel", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/parallel", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract parallel devices"));
goto error;
@ -3709,7 +3709,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
}
VIR_FREE(nodes);
if ((n = virXPathNodeSet(conn, "./devices/serial", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/serial", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract serial devices"));
goto error;
@ -3729,7 +3729,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
}
VIR_FREE(nodes);
if ((node = virXPathNode(conn, "./devices/console[1]", ctxt)) != NULL) {
if ((node = virXPathNode("./devices/console[1]", ctxt)) != NULL) {
virDomainChrDefPtr chr = virDomainChrDefParseXML(conn,
node,
flags);
@ -3758,7 +3758,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
}
}
if ((n = virXPathNodeSet(conn, "./devices/channel", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/channel", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract channel devices"));
goto error;
@ -3779,7 +3779,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
/* analysis of the input devices */
if ((n = virXPathNodeSet(conn, "./devices/input", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/input", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract input devices"));
goto error;
@ -3814,7 +3814,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
VIR_FREE(nodes);
/* analysis of the graphics devices */
if ((n = virXPathNodeSet(conn, "./devices/graphics", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/graphics", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract graphics devices"));
goto error;
@ -3858,7 +3858,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
/* analysis of the sound devices */
if ((n = virXPathNodeSet(conn, "./devices/sound", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/sound", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract sound devices"));
goto error;
@ -3877,7 +3877,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
VIR_FREE(nodes);
/* analysis of the video devices */
if ((n = virXPathNodeSet(conn, "./devices/video", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/video", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract video devices"));
goto error;
@ -3918,7 +3918,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
}
/* analysis of the host devices */
if ((n = virXPathNodeSet(conn, "./devices/hostdev", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/hostdev", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract host devices"));
goto error;
@ -3938,7 +3938,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
/* analysis of the watchdog devices */
def->watchdog = NULL;
if ((n = virXPathNodeSet(conn, "./devices/watchdog", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./devices/watchdog", ctxt, &nodes)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot extract watchdog devices"));
goto error;
@ -3962,7 +3962,7 @@ static virDomainDefPtr virDomainDefParseXML(virConnectPtr conn,
if (virSecurityLabelDefParseXML(conn, def, ctxt, flags) == -1)
goto error;
if ((node = virXPathNode(conn, "./cpu[1]", ctxt)) != NULL) {
if ((node = virXPathNode("./cpu[1]", ctxt)) != NULL) {
xmlNodePtr oldnode = ctxt->node;
ctxt->node = node;
def->cpu = virCPUDefParseXML(conn, node, ctxt, VIR_CPU_TYPE_GUEST);
@ -3999,7 +3999,7 @@ static virDomainObjPtr virDomainObjParseXML(virConnectPtr conn,
if (!(obj = virDomainObjNew(conn, caps)))
return NULL;
if (!(config = virXPathNode(conn, "./domain", ctxt))) {
if (!(config = virXPathNode("./domain", ctxt))) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("no domain config"));
goto error;
@ -4013,7 +4013,7 @@ static virDomainObjPtr virDomainObjParseXML(virConnectPtr conn,
if (!obj->def)
goto error;
if (!(tmp = virXPathString(conn, "string(./@state)", ctxt))) {
if (!(tmp = virXPathString("string(./@state)", ctxt))) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("missing domain state"));
goto error;
@ -4026,7 +4026,7 @@ static virDomainObjPtr virDomainObjParseXML(virConnectPtr conn,
}
VIR_FREE(tmp);
if ((virXPathLong(conn, "string(./@pid)", ctxt, &val)) < 0) {
if ((virXPathLong("string(./@pid)", ctxt, &val)) < 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("invalid pid"));
goto error;

70
src/conf/interface_conf.c
View File

@ -122,7 +122,7 @@ virInterfaceDefParseName(virConnectPtr conn, virInterfaceDefPtr def,
xmlXPathContextPtr ctxt) {
char *tmp;
tmp = virXPathString(conn, "string(./@name)", ctxt);
tmp = virXPathString("string(./@name)", ctxt);
if (tmp == NULL) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("interface has no name"));
@ -138,7 +138,7 @@ virInterfaceDefParseMtu(virConnectPtr conn, virInterfaceDefPtr def,
unsigned long mtu;
int ret;
ret = virXPathULong(conn, "string(./mtu/@size)", ctxt, &mtu);
ret = virXPathULong("string(./mtu/@size)", ctxt, &mtu);
if ((ret == -2) || ((ret == 0) && (mtu > 100000))) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("interface mtu value is improper"));
@ -154,7 +154,7 @@ virInterfaceDefParseStartMode(virConnectPtr conn, virInterfaceDefPtr def,
xmlXPathContextPtr ctxt) {
char *tmp;
tmp = virXPathString(conn, "string(./start/@mode)", ctxt);
tmp = virXPathString("string(./start/@mode)", ctxt);
if (tmp == NULL)
def->startmode = VIR_INTERFACE_START_UNSPECIFIED;
else if (STREQ(tmp, "onboot"))
@ -178,7 +178,7 @@ virInterfaceDefParseBondMode(virConnectPtr conn, xmlXPathContextPtr ctxt) {
char *tmp;
int ret = 0;
tmp = virXPathString(conn, "string(./@mode)", ctxt);
tmp = virXPathString("string(./@mode)", ctxt);
if (tmp == NULL)
return(VIR_INTERFACE_BOND_NONE);
if (STREQ(tmp, "balance-rr"))
@ -209,7 +209,7 @@ virInterfaceDefParseBondMiiCarrier(virConnectPtr conn, xmlXPathContextPtr ctxt)
char *tmp;
int ret = 0;
tmp = virXPathString(conn, "string(./miimon/@carrier)", ctxt);
tmp = virXPathString("string(./miimon/@carrier)", ctxt);
if (tmp == NULL)
return(VIR_INTERFACE_BOND_MII_NONE);
if (STREQ(tmp, "ioctl"))
@ -230,7 +230,7 @@ virInterfaceDefParseBondArpValid(virConnectPtr conn, xmlXPathContextPtr ctxt) {
char *tmp;
int ret = 0;
tmp = virXPathString(conn, "string(./arpmon/@validate)", ctxt);
tmp = virXPathString("string(./arpmon/@validate)", ctxt);
if (tmp == NULL)
return(VIR_INTERFACE_BOND_ARP_NONE);
if (STREQ(tmp, "active"))
@ -259,7 +259,7 @@ virInterfaceDefParseDhcp(virConnectPtr conn, virInterfaceProtocolDefPtr def,
save = ctxt->node;
ctxt->node = dhcp;
/* Not much to do in the current version */
tmp = virXPathString(conn, "string(./@peerdns)", ctxt);
tmp = virXPathString("string(./@peerdns)", ctxt);
if (tmp) {
if (STREQ(tmp, "yes"))
def->peerdns = 1;
@ -285,10 +285,10 @@ virInterfaceDefParseIp(virConnectPtr conn, virInterfaceIpDefPtr def,
char *tmp;
long l;
tmp = virXPathString(conn, "string(./@address)", ctxt);
tmp = virXPathString("string(./@address)", ctxt);
def->address = tmp;
if (tmp != NULL) {
ret = virXPathLong(conn, "string(./@prefix)", ctxt, &l);
ret = virXPathLong("string(./@prefix)", ctxt, &l);
if (ret == 0)
def->prefix = (int) l;
else if (ret == -2) {
@ -309,17 +309,17 @@ virInterfaceDefParseProtoIPv4(virConnectPtr conn, virInterfaceProtocolDefPtr def
int nIpNodes, ii, ret = -1;
char *tmp;
tmp = virXPathString(conn, "string(./route[1]/@gateway)", ctxt);
tmp = virXPathString("string(./route[1]/@gateway)", ctxt);
def->gateway = tmp;
dhcp = virXPathNode(conn, "./dhcp", ctxt);
dhcp = virXPathNode("./dhcp", ctxt);
if (dhcp != NULL) {
ret = virInterfaceDefParseDhcp(conn, def, dhcp, ctxt);
if (ret != 0)
return(ret);
}
nIpNodes = virXPathNodeSet(conn, "./ip", ctxt, &ipNodes);
nIpNodes = virXPathNodeSet("./ip", ctxt, &ipNodes);
if (nIpNodes < 0)
return -1;
if (ipNodes == NULL)
@ -364,21 +364,21 @@ virInterfaceDefParseProtoIPv6(virConnectPtr conn, virInterfaceProtocolDefPtr def
int nIpNodes, ii, ret = -1;
char *tmp;
tmp = virXPathString(conn, "string(./route[1]/@gateway)", ctxt);
tmp = virXPathString("string(./route[1]/@gateway)", ctxt);
def->gateway = tmp;
autoconf = virXPathNode(conn, "./autoconf", ctxt);
autoconf = virXPathNode("./autoconf", ctxt);
if (autoconf != NULL)
def->autoconf = 1;
dhcp = virXPathNode(conn, "./dhcp", ctxt);
dhcp = virXPathNode("./dhcp", ctxt);
if (dhcp != NULL) {
ret = virInterfaceDefParseDhcp(conn, def, dhcp, ctxt);
if (ret != 0)
return(ret);
}
nIpNodes = virXPathNodeSet(conn, "./ip", ctxt, &ipNodes);
nIpNodes = virXPathNodeSet("./ip", ctxt, &ipNodes);
if (nIpNodes < 0)
return -1;
if (ipNodes == NULL)
@ -425,7 +425,7 @@ virInterfaceDefParseIfAdressing(virConnectPtr conn, virInterfaceDefPtr def,
save = ctxt->node;
nProtoNodes = virXPathNodeSet(conn, "./protocol", ctxt, &protoNodes);
nProtoNodes = virXPathNodeSet("./protocol", ctxt, &protoNodes);
if (nProtoNodes <= 0) {
/* no protocols is an acceptable outcome */
return 0;
@ -447,7 +447,7 @@ virInterfaceDefParseIfAdressing(virConnectPtr conn, virInterfaceDefPtr def,
}
ctxt->node = protoNodes[pp];
tmp = virXPathString(conn, "string(./@family)", ctxt);
tmp = virXPathString("string(./@family)", ctxt);
if (tmp == NULL) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("protocol misses the family attribute"));
@ -495,7 +495,7 @@ virInterfaceDefParseBridge(virConnectPtr conn, virInterfaceDefPtr def,
int ret = 0;
bridge = ctxt->node;
nbItf = virXPathNodeSet(conn, "./interface", ctxt, &interfaces);
nbItf = virXPathNodeSet("./interface", ctxt, &interfaces);
if (nbItf < 0) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("bridge interfaces"));
@ -537,7 +537,7 @@ virInterfaceDefParseBondItfs(virConnectPtr conn, virInterfaceDefPtr def,
int nbItf, i;
int ret = 0;
nbItf = virXPathNodeSet(conn, "./interface", ctxt, &interfaces);
nbItf = virXPathNodeSet("./interface", ctxt, &interfaces);
if (nbItf <= 0) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("bond has no interfaces"));
@ -583,11 +583,11 @@ virInterfaceDefParseBond(virConnectPtr conn, virInterfaceDefPtr def,
if (ret != 0)
goto error;
node = virXPathNode(conn, "./miimon[1]", ctxt);
node = virXPathNode("./miimon[1]", ctxt);
if (node != NULL) {
def->data.bond.monit = VIR_INTERFACE_BOND_MONIT_MII;
ret = virXPathULong(conn, "string(./miimon/@freq)", ctxt, &tmp);
ret = virXPathULong("string(./miimon/@freq)", ctxt, &tmp);
if ((ret == -2) || (ret == -1)) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("bond interface miimon freq missing or invalid"));
@ -595,7 +595,7 @@ virInterfaceDefParseBond(virConnectPtr conn, virInterfaceDefPtr def,
}
def->data.bond.frequency = (int) tmp;
ret = virXPathULong(conn, "string(./miimon/@downdelay)", ctxt, &tmp);
ret = virXPathULong("string(./miimon/@downdelay)", ctxt, &tmp);
if (ret == -2) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("bond interface miimon downdelay invalid"));
@ -604,7 +604,7 @@ virInterfaceDefParseBond(virConnectPtr conn, virInterfaceDefPtr def,
def->data.bond.downdelay = (int) tmp;
}
ret = virXPathULong(conn, "string(./miimon/@updelay)", ctxt, &tmp);
ret = virXPathULong("string(./miimon/@updelay)", ctxt, &tmp);
if (ret == -2) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("bond interface miimon updelay invalid"));
@ -619,11 +619,11 @@ virInterfaceDefParseBond(virConnectPtr conn, virInterfaceDefPtr def,
goto error;
}
} else if ((node = virXPathNode(conn, "./arpmon[1]", ctxt)) != NULL) {
} else if ((node = virXPathNode("./arpmon[1]", ctxt)) != NULL) {
def->data.bond.monit = VIR_INTERFACE_BOND_MONIT_ARP;
ret = virXPathULong(conn, "string(./arpmon/@interval)", ctxt, &tmp);
ret = virXPathULong("string(./arpmon/@interval)", ctxt, &tmp);
if ((ret == -2) || (ret == -1)) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("bond interface arpmon interval missing or invalid"));
@ -632,7 +632,7 @@ virInterfaceDefParseBond(virConnectPtr conn, virInterfaceDefPtr def,
def->data.bond.interval = (int) tmp;
def->data.bond.target =
virXPathString(conn, "string(./arpmon/@target)", ctxt);
virXPathString("string(./arpmon/@target)", ctxt);
if (def->data.bond.target == NULL) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("bond interface arpmon target missing"));
@ -653,7 +653,7 @@ error:
static int
virInterfaceDefParseVlan(virConnectPtr conn, virInterfaceDefPtr def,
xmlXPathContextPtr ctxt) {
def->data.vlan.tag = virXPathString(conn, "string(./@tag)", ctxt);
def->data.vlan.tag = virXPathString("string(./@tag)", ctxt);
if (def->data.vlan.tag == NULL) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("vlan interface misses the tag attribute"));
@ -661,7 +661,7 @@ virInterfaceDefParseVlan(virConnectPtr conn, virInterfaceDefPtr def,
}
def->data.vlan.devname =
virXPathString(conn, "string(./interface/@name)", ctxt);
virXPathString("string(./interface/@name)", ctxt);
if (def->data.vlan.devname == NULL) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("vlan interface misses name attribute"));
@ -679,7 +679,7 @@ virInterfaceDefParseXML(virConnectPtr conn,
xmlNodePtr cur = ctxt->node;
/* check @type */
tmp = virXPathString(conn, "string(./@type)", ctxt);
tmp = virXPathString("string(./@type)", ctxt);
if (tmp == NULL) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("interface misses the type attribute"));
@ -718,7 +718,7 @@ virInterfaceDefParseXML(virConnectPtr conn,
case VIR_INTERFACE_TYPE_ETHERNET:
if (virInterfaceDefParseName(conn, def, ctxt) < 0)
goto error;
tmp = virXPathString(conn, "string(./mac/@address)", ctxt);
tmp = virXPathString("string(./mac/@address)", ctxt);
if (tmp != NULL)
def->mac = tmp;
if (parentIfType == VIR_INTERFACE_TYPE_LAST) {
@ -743,7 +743,7 @@ virInterfaceDefParseXML(virConnectPtr conn,
if (virInterfaceDefParseIfAdressing(conn, def, ctxt) < 0)
goto error;
bridge = virXPathNode(conn, "./bridge[1]", ctxt);
bridge = virXPathNode("./bridge[1]", ctxt);
if (bridge == NULL) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("bridge interface misses the bridge element"));
@ -785,7 +785,7 @@ virInterfaceDefParseXML(virConnectPtr conn,
goto error;
}
bond = virXPathNode(conn, "./bond[1]", ctxt);
bond = virXPathNode("./bond[1]", ctxt);
if (bond == NULL) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("bond interface misses the bond element"));
@ -799,14 +799,14 @@ virInterfaceDefParseXML(virConnectPtr conn,
case VIR_INTERFACE_TYPE_VLAN: {
xmlNodePtr vlan;
tmp = virXPathString(conn, "string(./@name)", ctxt);
tmp = virXPathString("string(./@name)", ctxt);
if (tmp != NULL)
def->name = tmp;
if (virInterfaceDefParseStartMode(conn, def, ctxt) < 0)
goto error;
if (virInterfaceDefParseIfAdressing(conn, def, ctxt) < 0)
goto error;
vlan = virXPathNode(conn, "./vlan[1]", ctxt);
vlan = virXPathNode("./vlan[1]", ctxt);
if (vlan == NULL) {
virInterfaceReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("vlan interface misses the vlan element"));

24
src/conf/network_conf.c
View File

@ -401,14 +401,14 @@ virNetworkDefParseXML(virConnectPtr conn,
}
/* Extract network name */
def->name = virXPathString(conn, "string(./name[1])", ctxt);
def->name = virXPathString("string(./name[1])", ctxt);
if (!def->name) {
virNetworkReportError(conn, VIR_ERR_NO_NAME, NULL);
goto error;
}
/* Extract network uuid */
tmp = virXPathString(conn, "string(./uuid[1])", ctxt);
tmp = virXPathString("string(./uuid[1])", ctxt);
if (!tmp) {
if (virUUIDGenerate(def->uuid)) {
virNetworkReportError(conn, VIR_ERR_INTERNAL_ERROR,
@ -426,19 +426,19 @@ virNetworkDefParseXML(virConnectPtr conn,
}
/* Parse network domain information */
def->domain = virXPathString(conn, "string(./domain[1]/@name)", ctxt);
def->domain = virXPathString("string(./domain[1]/@name)", ctxt);
/* Parse bridge information */
def->bridge = virXPathString(conn, "string(./bridge[1]/@name)", ctxt);
tmp = virXPathString(conn, "string(./bridge[1]/@stp)", ctxt);
def->bridge = virXPathString("string(./bridge[1]/@name)", ctxt);
tmp = virXPathString("string(./bridge[1]/@stp)", ctxt);
def->stp = (tmp && STREQ(tmp, "off")) ? 0 : 1;
VIR_FREE(tmp);
if (virXPathULong(conn, "string(./bridge[1]/@delay)", ctxt, &def->delay) < 0)
if (virXPathULong("string(./bridge[1]/@delay)", ctxt, &def->delay) < 0)
def->delay = 0;
def->ipAddress = virXPathString(conn, "string(./ip[1]/@address)", ctxt);
def->netmask = virXPathString(conn, "string(./ip[1]/@netmask)", ctxt);
def->ipAddress = virXPathString("string(./ip[1]/@address)", ctxt);
def->netmask = virXPathString("string(./ip[1]/@netmask)", ctxt);
if (def->ipAddress &&
def->netmask) {
/* XXX someday we want IPv6 too, so inet_aton won't work there */
@ -467,14 +467,14 @@ virNetworkDefParseXML(virConnectPtr conn,
goto error;
}
if ((ip = virXPathNode(conn, "./ip[1]", ctxt)) &&
if ((ip = virXPathNode("./ip[1]", ctxt)) &&
virNetworkIPParseXML(conn, def, ip) < 0)
goto error;
}
/* IPv4 forwarding setup */
if (virXPathBoolean(conn, "count(./forward) > 0", ctxt)) {
if (virXPathBoolean("count(./forward) > 0", ctxt)) {
if (!def->ipAddress ||
!def->netmask) {
virNetworkReportError(conn, VIR_ERR_INTERNAL_ERROR,
@ -482,7 +482,7 @@ virNetworkDefParseXML(virConnectPtr conn,
goto error;
}
tmp = virXPathString(conn, "string(./forward[1]/@mode)", ctxt);
tmp = virXPathString("string(./forward[1]/@mode)", ctxt);
if (tmp) {
if ((def->forwardType = virNetworkForwardTypeFromString(tmp)) < 0) {
virNetworkReportError(conn, VIR_ERR_INTERNAL_ERROR,
@ -496,7 +496,7 @@ virNetworkDefParseXML(virConnectPtr conn,
}
def->forwardDev = virXPathString(conn, "string(./forward[1]/@dev)", ctxt);
def->forwardDev = virXPathString("string(./forward[1]/@dev)", ctxt);
} else {
def->forwardType = VIR_NETWORK_FORWARD_NONE;
}

70
src/conf/node_device_conf.c
View File

@ -69,7 +69,7 @@ virNodeDevCapsDefParseString(virConnectPtr conn,
{
char *s;
s = virXPathString(conn, xpath, ctxt);
s = virXPathString(xpath, ctxt);
if (s == NULL) {
virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
missing_error_fmt,
@ -509,7 +509,7 @@ virNodeDevCapsDefParseULong(virConnectPtr conn,
int ret;
unsigned long val;
ret = virXPathULong(conn, xpath, ctxt, &val);
ret = virXPathULong(xpath, ctxt, &val);
if (ret < 0) {
virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
ret == -1 ? missing_error_fmt : invalid_error_fmt,
@ -533,7 +533,7 @@ virNodeDevCapsDefParseULongLong(virConnectPtr conn,
int ret;
unsigned long long val;
ret = virXPathULongLong(conn, xpath, ctxt, &val);
ret = virXPathULongLong(xpath, ctxt, &val);
if (ret < 0) {
virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
ret == -1 ? missing_error_fmt : invalid_error_fmt,
@ -559,7 +559,7 @@ virNodeDevCapStorageParseXML(virConnectPtr conn,
orignode = ctxt->node;
ctxt->node = node;
data->storage.block = virXPathString(conn, "string(./block[1])", ctxt);
data->storage.block = virXPathString("string(./block[1])", ctxt);
if (!data->storage.block) {
virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("no block device path supplied for '%s'"),
@ -567,13 +567,13 @@ virNodeDevCapStorageParseXML(virConnectPtr conn,
goto out;
}
data->storage.bus = virXPathString(conn, "string(./bus[1])", ctxt);
data->storage.drive_type = virXPathString(conn, "string(./drive_type[1])", ctxt);
data->storage.model = virXPathString(conn, "string(./model[1])", ctxt);
data->storage.vendor = virXPathString(conn, "string(./vendor[1])", ctxt);
data->storage.serial = virXPathString(conn, "string(./serial[1])", ctxt);
data->storage.bus = virXPathString("string(./bus[1])", ctxt);
data->storage.drive_type = virXPathString("string(./drive_type[1])", ctxt);
data->storage.model = virXPathString("string(./model[1])", ctxt);
data->storage.vendor = virXPathString("string(./vendor[1])", ctxt);
data->storage.serial = virXPathString("string(./serial[1])", ctxt);
if ((n = virXPathNodeSet(conn, "./capability", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./capability", ctxt, &nodes)) < 0) {
virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("error parsing storage capabilities for '%s'"),
def->name);
@ -600,10 +600,10 @@ virNodeDevCapStorageParseXML(virConnectPtr conn,
orignode2 = ctxt->node;
ctxt->node = nodes[i];
if (virXPathBoolean(conn, "count(./media_available[. = '1']) > 0", ctxt))
if (virXPathBoolean("count(./media_available[. = '1']) > 0", ctxt))
data->storage.flags |= VIR_NODE_DEV_CAP_STORAGE_REMOVABLE_MEDIA_AVAILABLE;
data->storage.media_label = virXPathString(conn, "string(./media_label[1])", ctxt);
data->storage.media_label = virXPathString("string(./media_label[1])", ctxt);
val = 0;
if (virNodeDevCapsDefParseULongLong(conn, "number(./media_size[1])", ctxt, &val, def,
@ -680,7 +680,7 @@ virNodeDevCapScsiParseXML(virConnectPtr conn,
_("invalid SCSI LUN ID supplied for '%s'")) < 0)
goto out;
data->scsi.type = virXPathString(conn, "string(./type[1])", ctxt);
data->scsi.type = virXPathString("string(./type[1])", ctxt);
ret = 0;
out:
@ -702,7 +702,7 @@ virNodeDevCapScsiTargetParseXML(virConnectPtr conn,
orignode = ctxt->node;
ctxt->node = node;
data->scsi_target.name = virXPathString(conn, "string(./name[1])", ctxt);
data->scsi_target.name = virXPathString("string(./name[1])", ctxt);
if (!data->scsi_target.name) {
virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("no target name supplied for '%s'"),
@ -741,7 +741,7 @@ virNodeDevCapScsiHostParseXML(virConnectPtr conn,
goto out;
}
if ((n = virXPathNodeSet(conn, "./capability", ctxt, &nodes)) < 0) {
if ((n = virXPathNodeSet("./capability", ctxt, &nodes)) < 0) {
virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("error parsing SCSI host capabilities for '%s'"),
def->name);
@ -822,7 +822,7 @@ virNodeDevCapNetParseXML(virConnectPtr conn,
orignode = ctxt->node;
ctxt->node = node;
data->net.ifname = virXPathString(conn, "string(./interface[1])", ctxt);
data->net.ifname = virXPathString("string(./interface[1])", ctxt);
if (!data->net.ifname) {
virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("no network interface supplied for '%s'"),
@ -830,11 +830,11 @@ virNodeDevCapNetParseXML(virConnectPtr conn,
goto out;
}
data->net.address = virXPathString(conn, "string(./address[1])", ctxt);
data->net.address = virXPathString("string(./address[1])", ctxt);
data->net.subtype = VIR_NODE_DEV_CAP_NET_LAST;
tmp = virXPathString(conn, "string(./capability/@type)", ctxt);
tmp = virXPathString("string(./capability/@type)", ctxt);
if (tmp) {
int val = virNodeDevNetCapTypeFromString(tmp);
VIR_FREE(tmp);
@ -890,7 +890,7 @@ virNodeDevCapUsbInterfaceParseXML(virConnectPtr conn,
_("invalid USB interface protocol supplied for '%s'")) < 0)
goto out;
data->usb_if.description = virXPathString(conn, "string(./description[1])", ctxt);
data->usb_if.description = virXPathString("string(./description[1])", ctxt);
ret = 0;
out:
@ -910,7 +910,7 @@ virNodeDevCapsDefParseHexId(virConnectPtr conn,
int ret;
unsigned long val;
ret = virXPathULongHex(conn, xpath, ctxt, &val);
ret = virXPathULongHex(xpath, ctxt, &val);
if (ret < 0) {
virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
ret == -1 ? missing_error_fmt : invalid_error_fmt,
@ -959,8 +959,8 @@ virNodeDevCapUsbDevParseXML(virConnectPtr conn,
_("invalid USB product ID supplied for '%s'")) < 0)
goto out;
data->usb_dev.vendor_name = virXPathString(conn, "string(./vendor[1])", ctxt);
data->usb_dev.product_name = virXPathString(conn, "string(./product[1])", ctxt);
data->usb_dev.vendor_name = virXPathString("string(./vendor[1])", ctxt);
data->usb_dev.product_name = virXPathString("string(./product[1])", ctxt);
ret = 0;
out:
@ -1017,8 +1017,8 @@ virNodeDevCapPciDevParseXML(virConnectPtr conn,
_("invalid PCI product ID supplied for '%s'")) < 0)
goto out;
data->pci_dev.vendor_name = virXPathString(conn, "string(./vendor[1])", ctxt);
data->pci_dev.product_name = virXPathString(conn, "string(./product[1])", ctxt);
data->pci_dev.vendor_name = virXPathString("string(./vendor[1])", ctxt);
data->pci_dev.product_name = virXPathString("string(./product[1])", ctxt);
ret = 0;
out:
@ -1040,13 +1040,13 @@ virNodeDevCapSystemParseXML(virConnectPtr conn,
orignode = ctxt->node;
ctxt->node = node;
data->system.product_name = virXPathString(conn, "string(./product[1])", ctxt);
data->system.product_name = virXPathString("string(./product[1])", ctxt);
data->system.hardware.vendor_name = virXPathString(conn, "string(./hardware/vendor[1])", ctxt);
data->system.hardware.version = virXPathString(conn, "string(./hardware/version[1])", ctxt);
data->system.hardware.serial = virXPathString(conn, "string(./hardware/serial[1])", ctxt);
data->system.hardware.vendor_name = virXPathString("string(./hardware/vendor[1])", ctxt);
data->system.hardware.version = virXPathString("string(./hardware/version[1])", ctxt);
data->system.hardware.serial = virXPathString("string(./hardware/serial[1])", ctxt);
tmp = virXPathString(conn, "string(./hardware/uuid[1])", ctxt);
tmp = virXPathString("string(./hardware/uuid[1])", ctxt);
if (!tmp) {
virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("no system UUID supplied for '%s'"), def->name);
@ -1061,9 +1061,9 @@ virNodeDevCapSystemParseXML(virConnectPtr conn,
}
VIR_FREE(tmp);
data->system.firmware.vendor_name = virXPathString(conn, "string(./firmware/vendor[1])", ctxt);
data->system.firmware.version = virXPathString(conn, "string(./firmware/version[1])", ctxt);
data->system.firmware.release_date = virXPathString(conn, "string(./firmware/release_date[1])", ctxt);
data->system.firmware.vendor_name = virXPathString("string(./firmware/vendor[1])", ctxt);
data->system.firmware.version = virXPathString("string(./firmware/version[1])", ctxt);
data->system.firmware.release_date = virXPathString("string(./firmware/release_date[1])", ctxt);
ret = 0;
out:
@ -1163,7 +1163,7 @@ virNodeDeviceDefParseXML(virConnectPtr conn, xmlXPathContextPtr ctxt, int create
/* Extract device name */
if (create == EXISTING_DEVICE) {
def->name = virXPathString(conn, "string(./name[1])", ctxt);
def->name = virXPathString("string(./name[1])", ctxt);
if (!def->name) {
virNodeDeviceReportError(conn, VIR_ERR_NO_NAME, NULL);
@ -1179,11 +1179,11 @@ virNodeDeviceDefParseXML(virConnectPtr conn, xmlXPathContextPtr ctxt, int create
}
/* Extract device parent, if any */
def->parent = virXPathString(conn, "string(./parent[1])", ctxt);
def->parent = virXPathString("string(./parent[1])", ctxt);
/* Parse device capabilities */
nodes = NULL;
if ((n = virXPathNodeSet(conn, "./capability", ctxt, &nodes)) <= 0) {
if ((n = virXPathNodeSet("./capability", ctxt, &nodes)) <= 0) {
virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("no device capabilities for '%s'"),
def->name);

15
src/conf/secret_conf.c
View File

@ -66,7 +66,7 @@ virSecretDefParseUsage(virConnectPtr conn, xmlXPathContextPtr ctxt,
char *type_str;
int type;
type_str = virXPathString(conn, "string(./usage/@type)", ctxt);
type_str = virXPathString("string(./usage/@type)", ctxt);
if (type_str == NULL) {
virSecretReportError(conn, VIR_ERR_XML_ERROR, "%s",
_("unknown secret usage type"));
@ -86,8 +86,7 @@ virSecretDefParseUsage(virConnectPtr conn, xmlXPathContextPtr ctxt,
break;
case VIR_SECRET_USAGE_TYPE_VOLUME:
def->usage.volume = virXPathString(conn, "string(./usage/volume)",
ctxt);
def->usage.volume = virXPathString("string(./usage/volume)", ctxt);
if (!def->usage.volume) {
virSecretReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s",
_("volume usage specified, but volume path is missing"));
@ -130,7 +129,7 @@ secretXMLParseNode(virConnectPtr conn, xmlDocPtr xml, xmlNodePtr root)
goto cleanup;
}
prop = virXPathString(conn, "string(./@ephemeral)", ctxt);
prop = virXPathString("string(./@ephemeral)", ctxt);
if (prop != NULL) {
if (STREQ(prop, "yes"))
def->ephemeral = 1;
@ -144,7 +143,7 @@ secretXMLParseNode(virConnectPtr conn, xmlDocPtr xml, xmlNodePtr root)
VIR_FREE(prop);
}
prop = virXPathString(conn, "string(./@private)", ctxt);
prop = virXPathString("string(./@private)", ctxt);
if (prop != NULL) {
if (STREQ(prop, "yes"))
def->private = 1;
@ -158,7 +157,7 @@ secretXMLParseNode(virConnectPtr conn, xmlDocPtr xml, xmlNodePtr root)
VIR_FREE(prop);
}
uuidstr = virXPathString(conn, "string(./uuid)", ctxt);
uuidstr = virXPathString("string(./uuid)", ctxt);
if (!uuidstr) {
if (virUUIDGenerate(def->uuid)) {
virSecretReportError(conn, VIR_ERR_INTERNAL_ERROR,
@ -174,8 +173,8 @@ secretXMLParseNode(virConnectPtr conn, xmlDocPtr xml, xmlNodePtr root)
VIR_FREE(uuidstr);
}
def->description = virXPathString(conn, "string(./description)", ctxt);
if (virXPathNode(conn, "./usage", ctxt) != NULL
def->description = virXPathString("string(./description)", ctxt);
if (virXPathNode("./usage", ctxt) != NULL
&& virSecretDefParseUsage(conn, ctxt, def) < 0)
goto cleanup;
ret = def;

69
src/conf/storage_conf.c
View File

@ -369,14 +369,14 @@ static int
virStoragePoolDefParseAuthChap(virConnectPtr conn,
xmlXPathContextPtr ctxt,
virStoragePoolAuthChapPtr auth) {
auth->login = virXPathString(conn, "string(./auth/@login)", ctxt);
auth->login = virXPathString("string(./auth/@login)", ctxt);
if (auth->login == NULL) {
virStorageReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("missing auth host attribute"));
return -1;
}
auth->passwd = virXPathString(conn, "string(./auth/@passwd)", ctxt);
auth->passwd = virXPathString("string(./auth/@passwd)", ctxt);
if (auth->passwd == NULL) {
virStorageReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("missing auth passwd attribute"));
@ -405,10 +405,10 @@ virStoragePoolDefParseSource(virConnectPtr conn,
goto cleanup;
}
source->name = virXPathString(conn, "string(./name)", ctxt);
source->name = virXPathString("string(./name)", ctxt);
if (options->formatFromString) {
char *format = virXPathString(conn, "string(./format/@type)", ctxt);
char *format = virXPathString("string(./format/@type)", ctxt);
if (format == NULL)
source->format = options->defaultFormat;
else
@ -423,11 +423,10 @@ virStoragePoolDefParseSource(virConnectPtr conn,
VIR_FREE(format);
}
source->host.name = virXPathString(conn, "string(./host/@name)", ctxt);
source->initiator.iqn = virXPathString(conn,
"string(./initiator/iqn/@name)", ctxt);
source->host.name = virXPathString("string(./host/@name)", ctxt);
source->initiator.iqn = virXPathString("string(./initiator/iqn/@name)", ctxt);
nsource = virXPathNodeSet(conn, "./device", ctxt, &nodeset);
nsource = virXPathNodeSet("./device", ctxt, &nodeset);
if (nsource > 0) {
if (VIR_ALLOC_N(source->devices, nsource) < 0) {
VIR_FREE(nodeset);
@ -448,10 +447,10 @@ virStoragePoolDefParseSource(virConnectPtr conn,
source->ndevice = nsource;
}
source->dir = virXPathString(conn, "string(./dir/@path)", ctxt);
source->adapter = virXPathString(conn, "string(./adapter/@name)", ctxt);
source->dir = virXPathString("string(./dir/@path)", ctxt);
source->adapter = virXPathString("string(./adapter/@name)", ctxt);
authType = virXPathString(conn, "string(./auth/@type)", ctxt);
authType = virXPathString("string(./auth/@type)", ctxt);
if (authType == NULL) {
source->authType = VIR_STORAGE_POOL_AUTH_NONE;
} else {
@ -510,7 +509,7 @@ virStoragePoolDefParseSourceString(virConnectPtr conn,
goto cleanup;
}
node = virXPathNode(conn, "/source", xpath_ctxt);
node = virXPathNode("/source", xpath_ctxt);
if (!node) {
virStorageReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("root element was not source"));
@ -543,7 +542,7 @@ virStorageDefParsePerms(virConnectPtr conn,
xmlNodePtr relnode;
xmlNodePtr node;
node = virXPathNode(conn, permxpath, ctxt);
node = virXPathNode(permxpath, ctxt);
if (node == NULL) {
/* Set default values if there is not <permissions> element */
perms->mode = defaultmode;
@ -556,7 +555,7 @@ virStorageDefParsePerms(virConnectPtr conn,
relnode = ctxt->node;
ctxt->node = node;
mode = virXPathString(conn, "string(./mode)", ctxt);
mode = virXPathString("string(./mode)", ctxt);
if (!mode) {
perms->mode = defaultmode;
} else {
@ -571,10 +570,10 @@ virStorageDefParsePerms(virConnectPtr conn,
VIR_FREE(mode);
}
if (virXPathNode(conn, "./owner", ctxt) == NULL) {
if (virXPathNode("./owner", ctxt) == NULL) {
perms->uid = getuid();
} else {
if (virXPathLong(conn, "number(./owner)", ctxt, &v) < 0) {
if (virXPathLong("number(./owner)", ctxt, &v) < 0) {
virStorageReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("malformed owner element"));
goto error;
@ -582,10 +581,10 @@ virStorageDefParsePerms(virConnectPtr conn,
perms->uid = (int)v;
}
if (virXPathNode(conn, "./group", ctxt) == NULL) {
if (virXPathNode("./group", ctxt) == NULL) {
perms->gid = getgid();
} else {
if (virXPathLong(conn, "number(./group)", ctxt, &v) < 0) {
if (virXPathLong("number(./group)", ctxt, &v) < 0) {
virStorageReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("malformed group element"));
goto error;
@ -594,7 +593,7 @@ virStorageDefParsePerms(virConnectPtr conn,
}
/* NB, we're ignoring missing labels here - they'll simply inherit */
perms->label = virXPathString(conn, "string(./label)", ctxt);
perms->label = virXPathString("string(./label)", ctxt);
ret = 0;
error:
@ -616,7 +615,7 @@ virStoragePoolDefParseXML(virConnectPtr conn,
return NULL;
}
type = virXPathString(conn, "string(./@type)", ctxt);
type = virXPathString("string(./@type)", ctxt);
if ((ret->type = virStoragePoolTypeFromString((const char *)type)) < 0) {
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unknown storage pool type %s"), (const char*)type);
@ -630,14 +629,14 @@ virStoragePoolDefParseXML(virConnectPtr conn,
goto cleanup;
}
source_node = virXPathNode(conn, "./source", ctxt);
source_node = virXPathNode("./source", ctxt);
if (source_node) {
if (virStoragePoolDefParseSource(conn, ctxt, &ret->source, ret->type,
source_node) < 0)
goto cleanup;
}
ret->name = virXPathString(conn, "string(./name)", ctxt);
ret->name = virXPathString("string(./name)", ctxt);
if (ret->name == NULL &&
options->flags & VIR_STORAGE_POOL_SOURCE_NAME)
ret->name = ret->source.name;
@ -647,7 +646,7 @@ virStoragePoolDefParseXML(virConnectPtr conn,
goto cleanup;
}
uuid = virXPathString(conn, "string(./uuid)", ctxt);
uuid = virXPathString("string(./uuid)", ctxt);
if (uuid == NULL) {
if (virUUIDGenerate(ret->uuid) < 0) {
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
@ -698,7 +697,7 @@ virStoragePoolDefParseXML(virConnectPtr conn,
}
}
if ((ret->target.path = virXPathString(conn, "string(./target/path)", ctxt)) == NULL) {
if ((ret->target.path = virXPathString("string(./target/path)", ctxt)) == NULL) {
virStorageReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("missing storage pool target path"));
goto cleanup;
@ -1050,7 +1049,7 @@ virStorageVolDefParseXML(virConnectPtr conn,
return NULL;
}
ret->name = virXPathString(conn, "string(./name)", ctxt);
ret->name = virXPathString("string(./name)", ctxt);
if (ret->name == NULL) {
virStorageReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("missing volume name element"));
@ -1058,10 +1057,10 @@ virStorageVolDefParseXML(virConnectPtr conn,
}
/* Auto-generated so deliberately ignore */
/*ret->key = virXPathString(conn, "string(./key)", ctxt);*/
/*ret->key = virXPathString("string(./key)", ctxt);*/
capacity = virXPathString(conn, "string(./capacity)", ctxt);
unit = virXPathString(conn, "string(./capacity/@unit)", ctxt);
capacity = virXPathString("string(./capacity)", ctxt);
unit = virXPathString("string(./capacity/@unit)", ctxt);
if (capacity == NULL) {
virStorageReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("missing capacity element"));
@ -1072,9 +1071,9 @@ virStorageVolDefParseXML(virConnectPtr conn,
VIR_FREE(capacity);
VIR_FREE(unit);
allocation = virXPathString(conn, "string(./allocation)", ctxt);
allocation = virXPathString("string(./allocation)", ctxt);
if (allocation) {
unit = virXPathString(conn, "string(./allocation/@unit)", ctxt);
unit = virXPathString("string(./allocation/@unit)", ctxt);
if (virStorageSize(conn, unit, allocation, &ret->allocation) < 0)
goto cleanup;
VIR_FREE(allocation);
@ -1083,9 +1082,9 @@ virStorageVolDefParseXML(virConnectPtr conn,
ret->allocation = ret->capacity;
}
ret->target.path = virXPathString(conn, "string(./target/path)", ctxt);
ret->target.path = virXPathString("string(./target/path)", ctxt);
if (options->formatFromString) {
char *format = virXPathString(conn, "string(./target/format/@type)", ctxt);
char *format = virXPathString("string(./target/format/@type)", ctxt);
if (format == NULL)
ret->target.format = options->defaultFormat;
else
@ -1104,7 +1103,7 @@ virStorageVolDefParseXML(virConnectPtr conn,
"./target/permissions", 0600) < 0)
goto cleanup;
node = virXPathNode(conn, "./target/encryption", ctxt);
node = virXPathNode("./target/encryption", ctxt);
if (node != NULL) {
ret->target.encryption = virStorageEncryptionParseNode(conn, ctxt->doc,
node);
@ -1114,9 +1113,9 @@ virStorageVolDefParseXML(virConnectPtr conn,
ret->backingStore.path = virXPathString(conn, "string(./backingStore/path)", ctxt);
ret->backingStore.path = virXPathString("string(./backingStore/path)", ctxt);
if (options->formatFromString) {
char *format = virXPathString(conn, "string(./backingStore/format/@type)", ctxt);
char *format = virXPathString("string(./backingStore/format/@type)", ctxt);
if (format == NULL)
ret->backingStore.format = options->defaultFormat;
else

8
src/conf/storage_encryption_conf.c
View File

@ -87,7 +87,7 @@ virStorageEncryptionSecretParse(virConnectPtr conn, xmlXPathContextPtr ctxt,
old_node = ctxt->node;
ctxt->node = node;
type_str = virXPathString(conn, "string(./@type)", ctxt);
type_str = virXPathString("string(./@type)", ctxt);
if (type_str == NULL) {
virStorageReportError(conn, VIR_ERR_XML_ERROR, "%s",
_("unknown volume encryption secret type"));
@ -104,7 +104,7 @@ virStorageEncryptionSecretParse(virConnectPtr conn, xmlXPathContextPtr ctxt,
VIR_FREE(type_str);
ret->type = type;
uuidstr = virXPathString(conn, "string(./@uuid)", ctxt);
uuidstr = virXPathString("string(./@uuid)", ctxt);
if (uuidstr) {
if (virUUIDParse(uuidstr, ret->uuid) < 0) {
virStorageReportError(conn, VIR_ERR_XML_ERROR,
@ -141,7 +141,7 @@ virStorageEncryptionParseXML(virConnectPtr conn, xmlXPathContextPtr ctxt)
return NULL;
}
format_str = virXPathString(conn, "string(./@format)", ctxt);
format_str = virXPathString("string(./@format)", ctxt);
if (format_str == NULL) {
virStorageReportError(conn, VIR_ERR_XML_ERROR, "%s",
_("unknown volume encryption format"));
@ -158,7 +158,7 @@ virStorageEncryptionParseXML(virConnectPtr conn, xmlXPathContextPtr ctxt)
VIR_FREE(format_str);
ret->format = format;
n = virXPathNodeSet(conn, "./secret", ctxt, &nodes);
n = virXPathNodeSet("./secret", ctxt, &nodes);
if (n < 0){
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s",
_("cannot extract volume encryption secrets"));

2
src/cpu/cpu_map.c
View File

@ -101,7 +101,7 @@ int cpuMapLoad(const char *arch,
ctxt->node = xmlDocGetRootElement(xml);
if ((ctxt->node = virXPathNode(NULL, xpath, ctxt)) == NULL) {
if ((ctxt->node = virXPathNode(xpath, ctxt)) == NULL) {
virCPUReportError(NULL, VIR_ERR_INTERNAL_ERROR,
_("cannot find CPU map for %s architecture"), arch);
goto cleanup;

22
src/cpu/cpu_x86.c
View File

@ -332,7 +332,7 @@ x86FeatureLoad(xmlXPathContextPtr ctxt,
if (VIR_ALLOC(feature) < 0)
goto no_memory;
feature->name = virXPathString(NULL, "string(@name)", ctxt);
feature->name = virXPathString("string(@name)", ctxt);
if (feature->name == NULL) {
virCPUReportError(NULL, VIR_ERR_INTERNAL_ERROR,
"%s", _("Missing CPU feature name"));
@ -345,7 +345,7 @@ x86FeatureLoad(xmlXPathContextPtr ctxt,
goto ignore;
}
n = virXPathNodeSet(NULL, "./cpuid", ctxt, &nodes);
n = virXPathNodeSet("./cpuid", ctxt, &nodes);
if (n < 0)
goto ignore;
@ -362,11 +362,11 @@ x86FeatureLoad(xmlXPathContextPtr ctxt,
ctxt->node = nodes[i];
fun = eax = ebx = ecx = edx = 0;
ret_fun = virXPathULongHex(NULL, "string(@function)", ctxt, &fun);
ret_eax = virXPathULongHex(NULL, "string(@eax)", ctxt, &eax);
ret_ebx = virXPathULongHex(NULL, "string(@ebx)", ctxt, &ebx);
ret_ecx = virXPathULongHex(NULL, "string(@ecx)", ctxt, &ecx);
ret_edx = virXPathULongHex(NULL, "string(@edx)", ctxt, &edx);
ret_fun = virXPathULongHex("string(@function)", ctxt, &fun);
ret_eax = virXPathULongHex("string(@eax)", ctxt, &eax);
ret_ebx = virXPathULongHex("string(@ebx)", ctxt, &ebx);
ret_ecx = virXPathULongHex("string(@ecx)", ctxt, &ecx);
ret_edx = virXPathULongHex("string(@edx)", ctxt, &edx);
if (ret_fun < 0 || ret_eax == -2 || ret_ebx == -2
|| ret_ecx == -2 || ret_edx == -2) {
@ -645,18 +645,18 @@ x86ModelLoad(xmlXPathContextPtr ctxt,
if (VIR_ALLOC(model) < 0)
goto no_memory;
model->name = virXPathString(NULL, "string(@name)", ctxt);
model->name = virXPathString("string(@name)", ctxt);
if (model->name == NULL) {
virCPUReportError(NULL, VIR_ERR_INTERNAL_ERROR,
"%s", _("Missing CPU model name"));
goto ignore;
}
if (virXPathNode(NULL, "./model", ctxt) != NULL) {
if (virXPathNode("./model", ctxt) != NULL) {
const struct x86_model *ancestor;
char *name;
name = virXPathString(NULL, "string(./model/@name)", ctxt);
name = virXPathString("string(./model/@name)", ctxt);
if (name == NULL) {
virCPUReportError(NULL, VIR_ERR_INTERNAL_ERROR,
_("Missing ancestor's name in CPU model %s"),
@ -682,7 +682,7 @@ x86ModelLoad(xmlXPathContextPtr ctxt,
sizeof(*model->cpuid) * model->ncpuid);
}
n = virXPathNodeSet(NULL, "./feature", ctxt, &nodes);
n = virXPathNodeSet("./feature", ctxt, &nodes);
if (n < 0)
goto ignore;

7
src/esx/esx_vi.c
View File

@ -667,7 +667,7 @@ esxVI_Context_Execute(esxVI_Context *ctx, const char *methodName,
if ((*response)->responseCode == 500) {
(*response)->node =
virXPathNode(NULL, "/soapenv:Envelope/soapenv:Body/soapenv:Fault",
virXPathNode("/soapenv:Envelope/soapenv:Body/soapenv:Fault",
xpathContext);
if ((*response)->node == NULL) {
@ -705,7 +705,7 @@ esxVI_Context_Execute(esxVI_Context *ctx, const char *methodName,
goto failure;
}
responseNode = virXPathNode(NULL, xpathExpression, xpathContext);
responseNode = virXPathNode(xpathExpression, xpathContext);
if (responseNode == NULL) {
ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR,
@ -715,8 +715,7 @@ esxVI_Context_Execute(esxVI_Context *ctx, const char *methodName,
}
xpathContext->node = responseNode;
(*response)->node = virXPathNode(NULL, "./vim:returnval",
xpathContext);
(*response)->node = virXPathNode("./vim:returnval", xpathContext);
switch (occurrence) {
case esxVI_Occurrence_RequiredItem:

8
src/qemu/qemu_driver.c
View File

@ -217,20 +217,20 @@ static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
}
if (!(monitorpath =
virXPathString(NULL, "string(./monitor[1]/@path)", ctxt))) {
virXPathString("string(./monitor[1]/@path)", ctxt))) {
qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
"%s", _("no monitor path"));
goto error;
}
tmp = virXPathString(NULL, "string(./monitor[1]/@type)", ctxt);
tmp = virXPathString("string(./monitor[1]/@type)", ctxt);
if (tmp)
priv->monConfig->type = virDomainChrTypeFromString(tmp);
else
priv->monConfig->type = VIR_DOMAIN_CHR_TYPE_PTY;
VIR_FREE(tmp);
if (virXPathBoolean(NULL, "count(./monitor[@json = '1']) > 0", ctxt)) {
if (virXPathBoolean("count(./monitor[@json = '1']) > 0", ctxt)) {
priv->monJSON = 1;
} else {
priv->monJSON = 0;
@ -251,7 +251,7 @@ static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
goto error;
}
n = virXPathNodeSet(NULL, "./vcpus/vcpu", ctxt, &nodes);
n = virXPathNodeSet("./vcpus/vcpu", ctxt, &nodes);
if (n < 0)
goto error;
if (n) {

4
src/security/virt-aa-helper.c
View File

@ -626,12 +626,12 @@ caps_mockup(vahControl * ctl, const char *xmlStr)
}
ctxt->node = root;
ctl->hvm = virXPathString(NULL, "string(./os/type[1])", ctxt);
ctl->hvm = virXPathString("string(./os/type[1])", ctxt);
if (!ctl->hvm || STRNEQ(ctl->hvm, "hvm")) {
vah_error(ctl, 0, "os.type is not 'hvm'");
goto cleanup;
}
ctl->arch = virXPathString(NULL, "string(./os/type[1]/@arch)", ctxt);
ctl->arch = virXPathString("string(./os/type[1]/@arch)", ctxt);
if (!ctl->arch) {
/* The XML we are given should have an arch, but in case it doesn't,
* just use the host's arch.

28
src/test/test_driver.c
View File

@ -665,7 +665,7 @@ static int testOpenVolumesForPool(virConnectPtr conn,
goto error;
}
ret = virXPathNodeSet(conn, vol_xpath, ctxt, &vols);
ret = virXPathNodeSet(vol_xpath, ctxt, &vols);
VIR_FREE(vol_xpath);
if (ret < 0) {
testError(NULL, VIR_ERR_XML_ERROR,
@ -805,7 +805,7 @@ static int testOpenFromFile(virConnectPtr conn,
memmove(&privconn->nodeInfo, &defaultNodeInfo, sizeof(defaultNodeInfo));
nodeInfo = &privconn->nodeInfo;
ret = virXPathLong(conn, "string(/node/cpu/nodes[1])", ctxt, &l);
ret = virXPathLong("string(/node/cpu/nodes[1])", ctxt, &l);
if (ret == 0) {
nodeInfo->nodes = l;
} else if (ret == -2) {
@ -813,7 +813,7 @@ static int testOpenFromFile(virConnectPtr conn,
goto error;
}
ret = virXPathLong(conn, "string(/node/cpu/sockets[1])", ctxt, &l);
ret = virXPathLong("string(/node/cpu/sockets[1])", ctxt, &l);
if (ret == 0) {
nodeInfo->sockets = l;
} else if (ret == -2) {
@ -821,7 +821,7 @@ static int testOpenFromFile(virConnectPtr conn,
goto error;
}
ret = virXPathLong(conn, "string(/node/cpu/cores[1])", ctxt, &l);
ret = virXPathLong("string(/node/cpu/cores[1])", ctxt, &l);
if (ret == 0) {
nodeInfo->cores = l;
} else if (ret == -2) {
@ -829,7 +829,7 @@ static int testOpenFromFile(virConnectPtr conn,
goto error;
}
ret = virXPathLong(conn, "string(/node/cpu/threads[1])", ctxt, &l);
ret = virXPathLong("string(/node/cpu/threads[1])", ctxt, &l);
if (ret == 0) {
nodeInfo->threads = l;
} else if (ret == -2) {
@ -838,7 +838,7 @@ static int testOpenFromFile(virConnectPtr conn,
}
nodeInfo->cpus = nodeInfo->cores * nodeInfo->threads * nodeInfo->sockets * nodeInfo->nodes;
ret = virXPathLong(conn, "string(/node/cpu/active[1])", ctxt, &l);
ret = virXPathLong("string(/node/cpu/active[1])", ctxt, &l);
if (ret == 0) {
if (l < nodeInfo->cpus) {
nodeInfo->cpus = l;
@ -847,7 +847,7 @@ static int testOpenFromFile(virConnectPtr conn,
testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node active cpu"));
goto error;
}
ret = virXPathLong(conn, "string(/node/cpu/mhz[1])", ctxt, &l);
ret = virXPathLong("string(/node/cpu/mhz[1])", ctxt, &l);
if (ret == 0) {
nodeInfo->mhz = l;
} else if (ret == -2) {
@ -855,7 +855,7 @@ static int testOpenFromFile(virConnectPtr conn,
goto error;
}
str = virXPathString(conn, "string(/node/cpu/model[1])", ctxt);
str = virXPathString("string(/node/cpu/model[1])", ctxt);
if (str != NULL) {
if (virStrcpyStatic(nodeInfo->model, str) == NULL) {
testError(NULL, VIR_ERR_INTERNAL_ERROR,
@ -866,7 +866,7 @@ static int testOpenFromFile(virConnectPtr conn,
VIR_FREE(str);
}
ret = virXPathLong(conn, "string(/node/memory[1])", ctxt, &l);
ret = virXPathLong("string(/node/memory[1])", ctxt, &l);
if (ret == 0) {
nodeInfo->memory = l;
} else if (ret == -2) {
@ -874,7 +874,7 @@ static int testOpenFromFile(virConnectPtr conn,
goto error;
}
ret = virXPathNodeSet(conn, "/node/domain", ctxt, &domains);
ret = virXPathNodeSet("/node/domain", ctxt, &domains);
if (ret < 0) {
testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node domain list"));
goto error;
@ -918,7 +918,7 @@ static int testOpenFromFile(virConnectPtr conn,
}
VIR_FREE(domains);
ret = virXPathNodeSet(conn, "/node/network", ctxt, &networks);
ret = virXPathNodeSet("/node/network", ctxt, &networks);
if (ret < 0) {
testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node network list"));
goto error;
@ -954,7 +954,7 @@ static int testOpenFromFile(virConnectPtr conn,
VIR_FREE(networks);
/* Parse interface definitions */
ret = virXPathNodeSet(conn, "/node/interface", ctxt, &ifaces);
ret = virXPathNodeSet("/node/interface", ctxt, &ifaces);
if (ret < 0) {
testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node interface list"));
goto error;
@ -990,7 +990,7 @@ static int testOpenFromFile(virConnectPtr conn,
VIR_FREE(ifaces);
/* Parse Storage Pool list */
ret = virXPathNodeSet(conn, "/node/pool", ctxt, &pools);
ret = virXPathNodeSet("/node/pool", ctxt, &pools);
if (ret < 0) {
testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node pool list"));
goto error;
@ -1041,7 +1041,7 @@ static int testOpenFromFile(virConnectPtr conn,
}
VIR_FREE(pools);
ret = virXPathNodeSet(conn, "/node/device", ctxt, &devs);
ret = virXPathNodeSet("/node/device", ctxt, &devs);
if (ret < 0) {
testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node device list"));
goto error;

73
src/util/xml.c
View File

@ -25,9 +25,9 @@
#define VIR_FROM_THIS VIR_FROM_XML
#define virXMLError(conn, code, fmt...) \
virReportErrorHelper(conn, VIR_FROM_XML, code, __FILE__, \
__FUNCTION__, __LINE__, fmt)
#define virXMLError(code, fmt...) \
virReportErrorHelper(NULL, VIR_FROM_XML, code, __FILE__, \
__FUNCTION__, __LINE__, fmt)
/************************************************************************
@ -47,8 +47,7 @@
* if the evaluation failed.
*/
char *
virXPathString(virConnectPtr conn,
const char *xpath,
virXPathString(const char *xpath,
xmlXPathContextPtr ctxt)
{
xmlXPathObjectPtr obj;
@ -56,7 +55,7 @@ virXPathString(virConnectPtr conn,
char *ret;
if ((ctxt == NULL) || (xpath == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathString()"));
return (NULL);
}
@ -89,15 +88,14 @@ virXPathString(virConnectPtr conn,
* the evaluation failed.
*/
char *
virXPathStringLimit(virConnectPtr conn,
const char *xpath,
virXPathStringLimit(const char *xpath,
size_t maxlen,
xmlXPathContextPtr ctxt)
{
char *tmp = virXPathString(conn, xpath, ctxt);
char *tmp = virXPathString(xpath, ctxt);
if (tmp != NULL && strlen(tmp) >= maxlen) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
virXMLError(VIR_ERR_INTERNAL_ERROR,
_("\'%s\' value longer than %Zd bytes in virXPathStringLimit()"),
xpath, maxlen);
return NULL;
@ -118,8 +116,7 @@ virXPathStringLimit(virConnectPtr conn,
* or -1 if the evaluation failed.
*/
int
virXPathNumber(virConnectPtr conn,
const char *xpath,
virXPathNumber(const char *xpath,
xmlXPathContextPtr ctxt,
double *value)
{
@ -127,7 +124,7 @@ virXPathNumber(virConnectPtr conn,
xmlNodePtr relnode;
if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathNumber()"));
return (-1);
}
@ -146,8 +143,7 @@ virXPathNumber(virConnectPtr conn,
}
static int
virXPathLongBase(virConnectPtr conn,
const char *xpath,
virXPathLongBase(const char *xpath,
xmlXPathContextPtr ctxt,
int base,
long *value)
@ -157,7 +153,7 @@ virXPathLongBase(virConnectPtr conn,
int ret = 0;
if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathLong()"));
return (-1);
}
@ -202,12 +198,11 @@ virXPathLongBase(virConnectPtr conn,
* value doesn't have a long format.
*/
int
virXPathLong(virConnectPtr conn,
const char *xpath,
virXPathLong(const char *xpath,
xmlXPathContextPtr ctxt,
long *value)
{
return virXPathLongBase(conn, xpath, ctxt, 10, value);
return virXPathLongBase(xpath, ctxt, 10, value);
}
/**
@ -224,17 +219,15 @@ virXPathLong(virConnectPtr conn,
* value doesn't have a long format.
*/
int
virXPathLongHex(virConnectPtr conn,
const char *xpath,
virXPathLongHex(const char *xpath,
xmlXPathContextPtr ctxt,
long *value)
{
return virXPathLongBase(conn, xpath, ctxt, 16, value);
return virXPathLongBase(xpath, ctxt, 16, value);
}
static int
virXPathULongBase(virConnectPtr conn,
const char *xpath,
virXPathULongBase(const char *xpath,
xmlXPathContextPtr ctxt,
int base,
unsigned long *value)
@ -244,7 +237,7 @@ virXPathULongBase(virConnectPtr conn,
int ret = 0;
if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathULong()"));
return (-1);
}
@ -289,12 +282,11 @@ virXPathULongBase(virConnectPtr conn,
* value doesn't have a long format.
*/
int
virXPathULong(virConnectPtr conn,
const char *xpath,
virXPathULong(const char *xpath,
xmlXPathContextPtr ctxt,
unsigned long *value)
{
return virXPathULongBase(conn, xpath, ctxt, 10, value);
return virXPathULongBase(xpath, ctxt, 10, value);
}
/**
@ -311,12 +303,11 @@ virXPathULong(virConnectPtr conn,
* value doesn't have a long format.
*/
int
virXPathULongHex(virConnectPtr conn,
const char *xpath,
virXPathULongHex(const char *xpath,
xmlXPathContextPtr ctxt,
unsigned long *value)
{
return virXPathULongBase(conn, xpath, ctxt, 16, value);
return virXPathULongBase(xpath, ctxt, 16, value);
}
/**
@ -332,8 +323,7 @@ virXPathULongHex(virConnectPtr conn,
* value doesn't have a long format.
*/
int
virXPathULongLong(virConnectPtr conn,
const char *xpath,
virXPathULongLong(const char *xpath,
xmlXPathContextPtr ctxt,
unsigned long long *value)
{
@ -342,7 +332,7 @@ virXPathULongLong(virConnectPtr conn,
int ret = 0;
if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathULong()"));
return (-1);
}
@ -391,8 +381,7 @@ virXMLPropString(xmlNodePtr node,
* Returns 0 if false, 1 if true, or -1 if the evaluation failed.
*/
int
virXPathBoolean(virConnectPtr conn,
const char *xpath,
virXPathBoolean(const char *xpath,
xmlXPathContextPtr ctxt)
{
xmlXPathObjectPtr obj;
@ -400,7 +389,7 @@ virXPathBoolean(virConnectPtr conn,
int ret;
if ((ctxt == NULL) || (xpath == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathBoolean()"));
return (-1);
}
@ -429,8 +418,7 @@ virXPathBoolean(virConnectPtr conn,
* Returns a pointer to the node or NULL if the evaluation failed.
*/
xmlNodePtr
virXPathNode(virConnectPtr conn,
const char *xpath,
virXPathNode(const char *xpath,
xmlXPathContextPtr ctxt)
{
xmlXPathObjectPtr obj;
@ -438,7 +426,7 @@ virXPathNode(virConnectPtr conn,
xmlNodePtr ret;
if ((ctxt == NULL) || (xpath == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathNode()"));
return (NULL);
}
@ -469,8 +457,7 @@ virXPathNode(virConnectPtr conn,
* must be freed) or -1 if the evaluation failed.
*/
int
virXPathNodeSet(virConnectPtr conn,
const char *xpath,
virXPathNodeSet(const char *xpath,
xmlXPathContextPtr ctxt,
xmlNodePtr **list)
{
@ -479,7 +466,7 @@ virXPathNodeSet(virConnectPtr conn,
int ret;
if ((ctxt == NULL) || (xpath == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathNodeSet()"));
return (-1);
}

38
src/util/xml.h
View File

@ -11,48 +11,36 @@
#include <libxml/tree.h>
#include <libxml/xpath.h>
int virXPathBoolean (virConnectPtr conn,
const char *xpath,
int virXPathBoolean(const char *xpath,
xmlXPathContextPtr ctxt);
char * virXPathString (virConnectPtr conn,
const char *xpath,
char * virXPathString(const char *xpath,
xmlXPathContextPtr ctxt);
char * virXPathStringLimit(virConnectPtr conn,
const char *xpath,
size_t maxlen,
xmlXPathContextPtr ctxt);
int virXPathNumber (virConnectPtr conn,
const char *xpath,
char * virXPathStringLimit(const char *xpath,
size_t maxlen,
xmlXPathContextPtr ctxt);
int virXPathNumber(const char *xpath,
xmlXPathContextPtr ctxt,
double *value);
int virXPathLong (virConnectPtr conn,
const char *xpath,
int virXPathLong(const char *xpath,
xmlXPathContextPtr ctxt,
long *value);
int virXPathULong (virConnectPtr conn,
const char *xpath,
int virXPathULong(const char *xpath,
xmlXPathContextPtr ctxt,
unsigned long *value);
int virXPathULongLong(virConnectPtr conn,
const char *xpath,
int virXPathULongLong(const char *xpath,
xmlXPathContextPtr ctxt,
unsigned long long *value);
int virXPathLongHex (virConnectPtr conn,
const char *xpath,
int virXPathLongHex(const char *xpath,
xmlXPathContextPtr ctxt,
long *value);
int virXPathULongHex(virConnectPtr conn,
const char *xpath,
int virXPathULongHex(const char *xpath,
xmlXPathContextPtr ctxt,
unsigned long *value);
xmlNodePtr virXPathNode (virConnectPtr conn,
const char *xpath,
xmlNodePtr virXPathNode(const char *xpath,
xmlXPathContextPtr ctxt);
int virXPathNodeSet (virConnectPtr conn,
const char *xpath,
int virXPathNodeSet(const char *xpath,
xmlXPathContextPtr ctxt,
xmlNodePtr **list);
char * virXMLPropString(xmlNodePtr node,
const char *name);