Add new functions to allow parsing integers with base 16 This will be used to e.g. parse PCI vendor IDs. Signed-off-by: Mark McLoughlin <markmc(a)redhat.com&gt; --- src/xml.c | 112 ++++++++++++++++++++++++++++++++++++++++++++++++------------- src/xml.h | 8 ++++ 2 files changed, 96 insertions(+), 24 deletions(-) diff --git a/src/xml.c b/src/xml.c index 9c27a10..edfdc17 100644 --- a/src/xml.c +++ b/src/xml.c @@ -116,23 +116,12 @@ virXPathNumber(virConnectPtr conn, return (0); } -/** - * virXPathLong: - * @xpath: the XPath string to evaluate - * @ctxt: an XPath context - * @value: the returned long value - * - * Convenience function to evaluate an XPath number - * - * Returns 0 in case of success in which case @value is set, - * or -1 if the XPath evaluation failed or -2 if the - * value doesn't have a long format. - */ -int -virXPathLong(virConnectPtr conn, - const char *xpath, - xmlXPathContextPtr ctxt, - long *value) +static int +virXPathLongBase(virConnectPtr conn, + const char *xpath, + xmlXPathContextPtr ctxt, + int base, + long *value) { xmlXPathObjectPtr obj; xmlNodePtr relnode; @@ -150,7 +139,7 @@ virXPathLong(virConnectPtr conn, char *conv = NULL; long val; - val = strtol((const char *) obj->stringval, &conv, 10); + val = strtol((const char *) obj->stringval, &conv, base); if (conv == (const char *) obj->stringval) { ret = -2; } else { @@ -172,7 +161,7 @@ virXPathLong(virConnectPtr conn, } /** - * virXPathULong: + * virXPathLong: * @xpath: the XPath string to evaluate * @ctxt: an XPath context * @value: the returned long value @@ -184,10 +173,42 @@ virXPathLong(virConnectPtr conn, * value doesn't have a long format. */ int -virXPathULong(virConnectPtr conn, - const char *xpath, - xmlXPathContextPtr ctxt, - unsigned long *value) +virXPathLong(virConnectPtr conn, + const char *xpath, + xmlXPathContextPtr ctxt, + long *value) +{ + return virXPathLongBase(conn, xpath, ctxt, 10, value); +} + +/** + * virXPathLongHex: + * @xpath: the XPath string to evaluate + * @ctxt: an XPath context + * @value: the returned long value + * + * Convenience function to evaluate an XPath number + * according to a base of 16 + * + * Returns 0 in case of success in which case @value is set, + * or -1 if the XPath evaluation failed or -2 if the + * value doesn't have a long format. + */ +int +virXPathLongHex(virConnectPtr conn, + const char *xpath, + xmlXPathContextPtr ctxt, + long *value) +{ + return virXPathLongBase(conn, xpath, ctxt, 16, value); +} + +static int +virXPathULongBase(virConnectPtr conn, + const char *xpath, + xmlXPathContextPtr ctxt, + int base, + unsigned long *value) { xmlXPathObjectPtr obj; xmlNodePtr relnode; @@ -205,7 +226,7 @@ virXPathULong(virConnectPtr conn, char *conv = NULL; long val; - val = strtoul((const char *) obj->stringval, &conv, 10); + val = strtoul((const char *) obj->stringval, &conv, base); if (conv == (const char *) obj->stringval) { ret = -2; } else { @@ -226,6 +247,49 @@ virXPathULong(virConnectPtr conn, return (ret); } +/** + * virXPathULong: + * @xpath: the XPath string to evaluate + * @ctxt: an XPath context + * @value: the returned long value + * + * Convenience function to evaluate an XPath number + * + * Returns 0 in case of success in which case @value is set, + * or -1 if the XPath evaluation failed or -2 if the + * value doesn't have a long format. + */ +int +virXPathULong(virConnectPtr conn, + const char *xpath, + xmlXPathContextPtr ctxt, + unsigned long *value) +{ + return virXPathULongBase(conn, xpath, ctxt, 10, value); +} + +/** + * virXPathUHex: + * @xpath: the XPath string to evaluate + * @ctxt: an XPath context + * @value: the returned long value + * + * Convenience function to evaluate an XPath number + * according to base of 16 + * + * Returns 0 in case of success in which case @value is set, + * or -1 if the XPath evaluation failed or -2 if the + * value doesn't have a long format. + */ +int +virXPathULongHex(virConnectPtr conn, + const char *xpath, + xmlXPathContextPtr ctxt, + unsigned long *value) +{ + return virXPathULongBase(conn, xpath, ctxt, 16, value); +} + char * virXMLPropString(xmlNodePtr node, const char *name) diff --git a/src/xml.h b/src/xml.h index da9d3b5..3754af2 100644 --- a/src/xml.h +++ b/src/xml.h @@ -29,6 +29,14 @@ int virXPathULong (virConnectPtr conn, const char *xpath, xmlXPathContextPtr ctxt, unsigned long *value); +int virXPathLongHex (virConnectPtr conn, + const char *xpath, + xmlXPathContextPtr ctxt, + long *value); +int virXPathULongHex(virConnectPtr conn, + const char *xpath, + xmlXPathContextPtr ctxt, + unsigned long *value); xmlNodePtr virXPathNode (virConnectPtr conn, const char *xpath, xmlXPathContextPtr ctxt); -- 1.6.0.6

Add support for parsing node device XML descriptions. This will be used by PCI passthrough related functions to obtain the PCI device address for a given node device. Signed-off-by: Mark McLoughlin <markmc(a)redhat.com&gt; --- src/libvirt_private.syms | 1 + src/node_device_conf.c | 687 ++++++++++++++++++++++++++++++++++++++++++++++ src/node_device_conf.h | 3 +- 3 files changed, 690 insertions(+), 1 deletions(-) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 9e9b3e5..fdda478 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -223,6 +223,7 @@ virNodeDeviceObjListFree; virNodeDeviceDefFree; virNodeDevCapsDefFree; virNodeDeviceDefFormat; +virNodeDeviceDefParseString; virNodeDeviceObjLock; virNodeDeviceObjUnlock; virNodeDeviceAssignDef; diff --git a/src/node_device_conf.c b/src/node_device_conf.c index af2f9a3..6e04112 100644 --- a/src/node_device_conf.c +++ b/src/node_device_conf.c @@ -27,6 +27,7 @@ #include <errno.h> #include "virterror_internal.h" +#include "datatypes.h" #include "memory.h" #include "node_device_conf.h" @@ -367,6 +368,692 @@ char *virNodeDeviceDefFormat(virConnectPtr conn, return NULL; } +static int +virNodeDevCapsDefParseULong(virConnectPtr conn, + const char *xpath, + xmlXPathContextPtr ctxt, + unsigned *value, + virNodeDeviceDefPtr def, + const char *missing_error_fmt, + const char *invalid_error_fmt) +{ + int ret; + unsigned long val; + + ret = virXPathULong(conn, xpath, ctxt, &val); + if (ret < 0) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + ret == -1 ? missing_error_fmt : invalid_error_fmt, + def->name); + return -1; + } + + *value = val; + return 0; +} + +static int +virNodeDevCapsDefParseULongLong(virConnectPtr conn, + const char *xpath, + xmlXPathContextPtr ctxt, + unsigned long long *value, + virNodeDeviceDefPtr def, + const char *missing_error_fmt, + const char *invalid_error_fmt) +{ + int ret; + unsigned long long val; + + ret = virXPathULongLong(conn, xpath, ctxt, &val); + if (ret < 0) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + ret == -1 ? missing_error_fmt : invalid_error_fmt, + def->name); + return -1; + } + + *value = val; + return 0; +} + +static int +virNodeDevCapStorageParseXML(virConnectPtr conn, + xmlXPathContextPtr ctxt, + virNodeDeviceDefPtr def, + xmlNodePtr node, + union _virNodeDevCapData *data) +{ + xmlNodePtr orignode, *nodes = NULL; + int i, n, ret = -1; + unsigned long long val; + + orignode = ctxt->node; + ctxt->node = node; + + data->storage.block = virXPathString(conn, "string(./block[1])", ctxt); + if (!data->storage.block) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("no block device path supplied for '%s'"), + def->name); + 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); + + if ((n = virXPathNodeSet(conn, "./capability", ctxt, &nodes)) < 0) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("error parsing storage capabilities for '%s'"), + def->name); + goto out; + } + + for (i = 0 ; i < n ; i++) { + char *type = virXMLPropString(nodes[i], "type"); + + if (!type) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("missing storage capability type for '%s'"), + def->name); + goto out; + } + + if (STREQ(type, "hotpluggable")) + data->storage.flags |= VIR_NODE_DEV_CAP_STORAGE_HOTPLUGGABLE; + else if (STREQ(type, "removable")) { + xmlNodePtr orignode2; + + data->storage.flags |= VIR_NODE_DEV_CAP_STORAGE_REMOVABLE; + + orignode2 = ctxt->node; + ctxt->node = nodes[i]; + + if (virXPathBoolean(conn, "count(./media_available[. = '1']) > 0", ctxt)) + data->storage.flags |= VIR_NODE_DEV_CAP_STORAGE_REMOVABLE_MEDIA_AVAILABLE; + + val = 0; + if (virNodeDevCapsDefParseULongLong(conn, "number(./media_size[1])", ctxt, &val, def, + _("no removable media size supplied for '%s'"), + _("invalid removable media size supplied for '%s'")) < 0) { + ctxt->node = orignode2; + VIR_FREE(type); + goto out; + } + data->storage.removable_media_size = val; + + ctxt->node = orignode2; + } else { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown storage capability type '%s' for '%s'"), + type, def->name); + VIR_FREE(type); + goto out; + } + + VIR_FREE(type); + } + + if (!(data->storage.flags & VIR_NODE_DEV_CAP_STORAGE_REMOVABLE)) { + val = 0; + if (virNodeDevCapsDefParseULongLong(conn, "number(./size[1])", ctxt, &val, def, + _("no size supplied for '%s'"), + _("invalid size supplied for '%s'")) < 0) + goto out; + data->storage.size = val; + } + + ret = 0; +out: + VIR_FREE(nodes); + ctxt->node = orignode; + return ret; +} + +static int +virNodeDevCapScsiParseXML(virConnectPtr conn, + xmlXPathContextPtr ctxt, + virNodeDeviceDefPtr def, + xmlNodePtr node, + union _virNodeDevCapData *data) +{ + xmlNodePtr orignode; + int ret = -1; + + orignode = ctxt->node; + ctxt->node = node; + + if (virNodeDevCapsDefParseULong(conn, "number(./host[1])", ctxt, + &data->scsi.host, def, + _("no SCSI host ID supplied for '%s'"), + _("invalid SCSI host ID supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseULong(conn, "number(./bus[1])", ctxt, + &data->scsi.bus, def, + _("no SCSI bus ID supplied for '%s'"), + _("invalid SCSI bus ID supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseULong(conn, "number(./target[1])", ctxt, + &data->scsi.target, def, + _("no SCSI target ID supplied for '%s'"), + _("invalid SCSI target ID supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseULong(conn, "number(./lun[1])", ctxt, + &data->scsi.lun, def, + _("no SCSI LUN ID supplied for '%s'"), + _("invalid SCSI LUN ID supplied for '%s'")) < 0) + goto out; + + data->scsi.type = virXPathString(conn, "string(./type[1])", ctxt); + + ret = 0; +out: + ctxt->node = orignode; + return ret; +} + +static int +virNodeDevCapScsiHostParseXML(virConnectPtr conn, + xmlXPathContextPtr ctxt, + virNodeDeviceDefPtr def, + xmlNodePtr node, + union _virNodeDevCapData *data) +{ + xmlNodePtr orignode; + int ret = -1; + + orignode = ctxt->node; + ctxt->node = node; + + if (virNodeDevCapsDefParseULong(conn, "number(./host[1])", ctxt, + &data->scsi_host.host, def, + _("no SCSI host ID supplied for '%s'"), + _("invalid SCSI host ID supplied for '%s'")) < 0) + goto out; + + ret = 0; +out: + ctxt->node = orignode; + return ret; +} + +static int +virNodeDevCapNetParseXML(virConnectPtr conn, + xmlXPathContextPtr ctxt, + virNodeDeviceDefPtr def, + xmlNodePtr node, + union _virNodeDevCapData *data) +{ + xmlNodePtr orignode; + int ret = -1; + char *tmp; + + orignode = ctxt->node; + ctxt->node = node; + + data->net.ifname = virXPathString(conn, "string(./interface[1])", ctxt); + if (!data->net.ifname) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("no network interface supplied for '%s'"), + def->name); + goto out; + } + + data->net.address = virXPathString(conn, "string(./address[1])", ctxt); + + data->net.subtype = VIR_NODE_DEV_CAP_NET_LAST; + + tmp = virXPathString(conn, "string(./capability/@type)", ctxt); + if (tmp) { + int val = virNodeDevNetCapTypeFromString(tmp); + VIR_FREE(tmp); + if (val < 0) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("invalid network type supplied for '%s'"), + def->name); + goto out; + } + data->net.subtype = val; + } + + ret = 0; +out: + ctxt->node = orignode; + return ret; +} + +static int +virNodeDevCapUsbInterfaceParseXML(virConnectPtr conn, + xmlXPathContextPtr ctxt, + virNodeDeviceDefPtr def, + xmlNodePtr node, + union _virNodeDevCapData *data) +{ + xmlNodePtr orignode; + int ret = -1; + + orignode = ctxt->node; + ctxt->node = node; + + if (virNodeDevCapsDefParseULong(conn, "number(./number[1])", ctxt, + &data->usb_if.number, def, + _("no USB interface number supplied for '%s'"), + _("invalid USB interface number supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseULong(conn, "number(./class[1])", ctxt, + &data->usb_if._class, def, + _("no USB interface class supplied for '%s'"), + _("invalid USB interface class supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseULong(conn, "number(./subclass[1])", ctxt, + &data->usb_if.subclass, def, + _("no USB interface subclass supplied for '%s'"), + _("invalid USB interface subclass supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseULong(conn, "number(./protocol[1])", ctxt, + &data->usb_if.protocol, def, + _("no USB interface protocol supplied for '%s'"), + _("invalid USB interface protocol supplied for '%s'")) < 0) + goto out; + + data->usb_if.description = virXPathString(conn, "string(./description[1])", ctxt); + + ret = 0; +out: + ctxt->node = orignode; + return ret; +} + +static int +virNodeDevCapsDefParseHexId(virConnectPtr conn, + const char *xpath, + xmlXPathContextPtr ctxt, + unsigned *value, + virNodeDeviceDefPtr def, + const char *missing_error_fmt, + const char *invalid_error_fmt) +{ + int ret; + unsigned long val; + + ret = virXPathULongHex(conn, xpath, ctxt, &val); + if (ret < 0) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + ret == -1 ? missing_error_fmt : invalid_error_fmt, + def->name); + return -1; + } + + *value = val; + return 0; +} + +static int +virNodeDevCapUsbDevParseXML(virConnectPtr conn, + xmlXPathContextPtr ctxt, + virNodeDeviceDefPtr def, + xmlNodePtr node, + union _virNodeDevCapData *data) +{ + xmlNodePtr orignode; + int ret = -1; + + orignode = ctxt->node; + ctxt->node = node; + + if (virNodeDevCapsDefParseULong(conn, "number(./bus[1])", ctxt, + &data->usb_dev.bus, def, + _("no USB bus number supplied for '%s'"), + _("invalid USB bus number supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseULong(conn, "number(./device[1])", ctxt, + &data->usb_dev.device, def, + _("no USB device number supplied for '%s'"), + _("invalid USB device number supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseHexId(conn, "string(./vendor[1]/@id)", ctxt, + &data->usb_dev.vendor, def, + _("no USB vendor ID supplied for '%s'"), + _("invalid USB vendor ID supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseHexId(conn, "string(./product[1]/@id)", ctxt, + &data->usb_dev.product, def, + _("no USB product ID supplied for '%s'"), + _("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); + + ret = 0; +out: + ctxt->node = orignode; + return ret; +} + +static int +virNodeDevCapPciDevParseXML(virConnectPtr conn, + xmlXPathContextPtr ctxt, + virNodeDeviceDefPtr def, + xmlNodePtr node, + union _virNodeDevCapData *data) +{ + xmlNodePtr orignode; + int ret = -1; + + orignode = ctxt->node; + ctxt->node = node; + + if (virNodeDevCapsDefParseULong(conn, "number(./domain[1])", ctxt, + &data->pci_dev.domain, def, + _("no PCI domain ID supplied for '%s'"), + _("invalid PCI domain ID supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseULong(conn, "number(./bus[1])", ctxt, + &data->pci_dev.bus, def, + _("no PCI bus ID supplied for '%s'"), + _("invalid PCI bus ID supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseULong(conn, "number(./slot[1])", ctxt, + &data->pci_dev.slot, def, + _("no PCI slot ID supplied for '%s'"), + _("invalid PCI slot ID supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseULong(conn, "number(./function[1])", ctxt, + &data->pci_dev.function, def, + _("no PCI function ID supplied for '%s'"), + _("invalid PCI function ID supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseHexId(conn, "string(./vendor[1]/@id)", ctxt, + &data->pci_dev.vendor, def, + _("no PCI vendor ID supplied for '%s'"), + _("invalid PCI vendor ID supplied for '%s'")) < 0) + goto out; + + if (virNodeDevCapsDefParseHexId(conn, "string(./product[1]/@id)", ctxt, + &data->pci_dev.product, def, + _("no PCI product ID supplied for '%s'"), + _("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); + + ret = 0; +out: + ctxt->node = orignode; + return ret; +} + +static int +virNodeDevCapSystemParseXML(virConnectPtr conn, + xmlXPathContextPtr ctxt, + virNodeDeviceDefPtr def, + xmlNodePtr node, + union _virNodeDevCapData *data) +{ + xmlNodePtr orignode; + int ret = -1; + char *tmp; + + orignode = ctxt->node; + ctxt->node = node; + + data->system.product_name = virXPathString(conn, "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); + + tmp = virXPathString(conn, "string(./hardware/uuid[1])", ctxt); + if (!tmp) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("no system UUID supplied for '%s'"), def->name); + goto out; + } + + if (virUUIDParse(tmp, data->system.hardware.uuid) < 0) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("malformed uuid element for '%s'"), def->name); + VIR_FREE(tmp); + goto out; + } + 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); + + ret = 0; +out: + ctxt->node = orignode; + return ret; +} + +static virNodeDevCapsDefPtr +virNodeDevCapsDefParseXML(virConnectPtr conn, + xmlXPathContextPtr ctxt, + virNodeDeviceDefPtr def, + xmlNodePtr node) +{ + virNodeDevCapsDefPtr caps; + char *tmp; + int val, ret; + + if (VIR_ALLOC(caps) < 0) { + virReportOOMError(conn); + return NULL; + } + + tmp = virXMLPropString(node, "type"); + if (!tmp) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("missing capability type")); + goto error; + } + + if ((val = virNodeDevCapTypeFromString(tmp)) < 0) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown capability type '%s'"), tmp); + VIR_FREE(tmp); + goto error; + } + caps->type = val; + VIR_FREE(tmp); + + switch (caps->type) { + case VIR_NODE_DEV_CAP_SYSTEM: + ret = virNodeDevCapSystemParseXML(conn, ctxt, def, node, &caps->data); + break; + case VIR_NODE_DEV_CAP_PCI_DEV: + ret = virNodeDevCapPciDevParseXML(conn, ctxt, def, node, &caps->data); + break; + case VIR_NODE_DEV_CAP_USB_DEV: + ret = virNodeDevCapUsbDevParseXML(conn, ctxt, def, node, &caps->data); + break; + case VIR_NODE_DEV_CAP_USB_INTERFACE: + ret = virNodeDevCapUsbInterfaceParseXML(conn, ctxt, def, node, &caps->data); + break; + case VIR_NODE_DEV_CAP_NET: + ret = virNodeDevCapNetParseXML(conn, ctxt, def, node, &caps->data); + break; + case VIR_NODE_DEV_CAP_SCSI_HOST: + ret = virNodeDevCapScsiHostParseXML(conn, ctxt, def, node, &caps->data); + break; + case VIR_NODE_DEV_CAP_SCSI: + ret = virNodeDevCapScsiParseXML(conn, ctxt, def, node, &caps->data); + break; + case VIR_NODE_DEV_CAP_STORAGE: + ret = virNodeDevCapStorageParseXML(conn, ctxt, def, node, &caps->data); + break; + default: + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("unknown capability type '%d' for '%s'"), + caps->type, def->name); + ret = -1; + break; + } + + if (ret < 0) + goto error; + return caps; + +error: + virNodeDevCapsDefFree(caps); + return NULL; +} + +static virNodeDeviceDefPtr +virNodeDeviceDefParseXML(virConnectPtr conn, xmlXPathContextPtr ctxt) +{ + virNodeDeviceDefPtr def; + virNodeDevCapsDefPtr *next_cap; + xmlNodePtr *nodes; + int n, i; + + if (VIR_ALLOC(def) < 0) { + virReportOOMError(conn); + return NULL; + } + + /* Extract device name */ + def->name = virXPathString(conn, "string(./name[1])", ctxt); + if (!def->name) { + virNodeDeviceReportError(conn, VIR_ERR_NO_NAME, NULL); + goto error; + } + + /* Extract device parent, if any */ + def->parent = virXPathString(conn, "string(./parent[1])", ctxt); + + /* Parse device capabilities */ + nodes = NULL; + if ((n = virXPathNodeSet(conn, "./capability", ctxt, &nodes)) <= 0) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + _("no device capabilities for '%s'"), + def->name); + goto error; + } + + next_cap = &def->caps; + for (i = 0 ; i < n ; i++) { + *next_cap = virNodeDevCapsDefParseXML(conn, ctxt, def, nodes[i]); + if (!*next_cap) { + VIR_FREE(nodes); + goto error; + } + + next_cap = &(*next_cap)->next; + } + VIR_FREE(nodes); + + return def; + + error: + virNodeDeviceDefFree(def); + return NULL; +} + +static virNodeDeviceDefPtr +virNodeDeviceDefParseNode(virConnectPtr conn, xmlDocPtr xml, xmlNodePtr root) +{ + xmlXPathContextPtr ctxt = NULL; + virNodeDeviceDefPtr def = NULL; + + if (!xmlStrEqual(root->name, BAD_CAST "device")) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("incorrect root element")); + return NULL; + } + + ctxt = xmlXPathNewContext(xml); + if (ctxt == NULL) { + virReportOOMError(conn); + goto cleanup; + } + + ctxt->node = root; + def = virNodeDeviceDefParseXML(conn, ctxt); + +cleanup: + xmlXPathFreeContext(ctxt); + return def; +} + +/* Called from SAX on parsing errors in the XML. */ +static void +catchXMLError(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...) +{ + xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; + + if (ctxt) { + virConnectPtr conn = ctxt->_private; + + if (virGetLastError() == NULL && + ctxt->lastError.level == XML_ERR_FATAL && + ctxt->lastError.message != NULL) { + virNodeDeviceReportError(conn, VIR_ERR_XML_DETAIL, + _("at line %d: %s"), + ctxt->lastError.line, + ctxt->lastError.message); + } + } +} + +virNodeDeviceDefPtr +virNodeDeviceDefParseString(virConnectPtr conn, const char *str) +{ + xmlParserCtxtPtr pctxt; + xmlDocPtr xml = NULL; + xmlNodePtr root; + virNodeDeviceDefPtr def = NULL; + + /* Set up a parser context so we can catch the details of XML errors. */ + pctxt = xmlNewParserCtxt (); + if (!pctxt || !pctxt->sax) + goto cleanup; + pctxt->sax->error = catchXMLError; + pctxt->_private = conn; + + if (conn) virResetError (&conn->err); + xml = xmlCtxtReadDoc(pctxt, BAD_CAST str, "device.xml", NULL, + XML_PARSE_NOENT | XML_PARSE_NONET | + XML_PARSE_NOWARNING); + if (!xml) { + if (conn && conn->err.code == VIR_ERR_NONE) + virNodeDeviceReportError(conn, VIR_ERR_XML_ERROR, + "%s", _("failed to parse xml document")); + goto cleanup; + } + + if ((root = xmlDocGetRootElement(xml)) == NULL) { + virNodeDeviceReportError(conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("missing root element")); + goto cleanup; + } + + def = virNodeDeviceDefParseNode(conn, xml, root); + +cleanup: + xmlFreeParserCtxt(pctxt); + xmlFreeDoc(xml); + return def; +} + void virNodeDevCapsDefFree(virNodeDevCapsDefPtr caps) { union _virNodeDevCapData *data = &caps->data; diff --git a/src/node_device_conf.h b/src/node_device_conf.h index 2024755..26e5558 100644 --- a/src/node_device_conf.h +++ b/src/node_device_conf.h @@ -184,7 +184,8 @@ void virNodeDeviceObjRemove(virNodeDeviceObjListPtr devs, char *virNodeDeviceDefFormat(virConnectPtr conn, const virNodeDeviceDefPtr def); -// TODO: virNodeDeviceDefParseString/File/Node for virNodeDeviceCreate +virNodeDeviceDefPtr virNodeDeviceDefParseString(virConnectPtr conn, + const char *str); void virNodeDeviceDefFree(virNodeDeviceDefPtr def); -- 1.6.0.6