/*
* Copyright © 2009 CNRS
* Copyright © 2009-2018 Inria. All rights reserved.
* Copyright © 2009-2011 Université Bordeaux
* Copyright © 2009-2011 Cisco Systems, Inc. All rights reserved.
* See COPYING in top-level directory.
*/
#include <private/autogen/config.h>
#include <hwloc.h>
#include <hwloc/plugins.h>
/* private headers allowed because this plugin is built within hwloc */
#include <private/xml.h>
#include <private/debug.h>
#include <private/misc.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
/*******************
* Common routines *
*******************/
static void hwloc_libxml2_error_callback(void * ctx __hwloc_attribute_unused, const char * msg __hwloc_attribute_unused, ...) { /* do nothing */ }
/* by default, do not cleanup to avoid issues with concurrent libxml users */
static int hwloc_libxml2_needs_cleanup = 0;
static void
hwloc_libxml2_init_once(void)
{
static int checked = 0;
if (!checked) {
/* disable stderr warnings */
xmlSetGenericErrorFunc(NULL, hwloc__xml_verbose() ? xmlGenericError : hwloc_libxml2_error_callback);
/* enforce libxml2 cleanup ? */
if (getenv("HWLOC_LIBXML_CLEANUP"))
hwloc_libxml2_needs_cleanup = 1;
checked = 1;
}
}
static void
hwloc_libxml2_cleanup(void)
{
if (hwloc_libxml2_needs_cleanup) {
xmlCleanupParser();
}
}
/*******************
* Import routines *
*******************/
typedef struct hwloc__libxml_import_state_data_s {
xmlNode *node; /* current libxml node, always valid */
xmlNode *child; /* next processed child, or NULL if none yet */
xmlAttr *attr; /* last processed attribute, or NULL if none yet */
} __hwloc_attribute_may_alias * hwloc__libxml_import_state_data_t;
static int
hwloc__libxml_import_next_attr(hwloc__xml_import_state_t state, char **namep, char **valuep)
{
hwloc__libxml_import_state_data_t lstate = (void*) state->data;
xmlAttr *attr;
if (lstate->attr)
attr = lstate->attr->next;
else
attr = lstate->node->properties;
for (; attr; attr = attr->next)
if (attr->type == XML_ATTRIBUTE_NODE) {
/* use the first valid attribute content */
xmlNode *subnode;
for (subnode = attr->children; subnode; subnode = subnode->next) {
if (subnode->type == XML_TEXT_NODE) {
if (subnode->content) {
*namep = (char *) attr->name;
*valuep = (char *) subnode->content;
lstate->attr = attr;
return 0;
}
} else {
if (hwloc__xml_verbose())
fprintf(stderr, "%s: ignoring unexpected xml attr node type %u\n",
state->global->msgprefix, subnode->type);
}
}
} else {
if (hwloc__xml_verbose())
fprintf(stderr, "%s: ignoring unexpected xml attr type %u\n",
state->global->msgprefix, attr->type);
}
return -1;
}
static int
hwloc__libxml_import_find_child(hwloc__xml_import_state_t state,
hwloc__xml_import_state_t childstate,
char **tagp)
{
hwloc__libxml_import_state_data_t lstate = (void*) state->data;
hwloc__libxml_import_state_data_t lchildstate = (void*) childstate->data;
xmlNode *child;
childstate->parent = state;
childstate->global = state->global;
if (!lstate->child)
/* All children proceeded */
return 0;
child = lstate->child;
if (child->type == XML_ELEMENT_NODE) {
lstate->child = child->next;
lchildstate->node = child;
lchildstate->child = child->children;
lchildstate->attr = NULL;
*tagp = (char*) child->name;
return 1;
} else if (child->type == XML_TEXT_NODE) {
if (child->content && child->content[0] != '\0' && child->content[0] != '\n')
if (hwloc__xml_verbose())
fprintf(stderr, "%s: ignoring object text content %s\n",
state->global->msgprefix, (const char*) child->content);
} else if (child->type != XML_COMMENT_NODE) {
if (hwloc__xml_verbose())
fprintf(stderr, "%s: ignoring unexpected xml node type %u\n",
state->global->msgprefix, child->type);
}
return 0;
}
static int
hwloc__libxml_import_close_tag(hwloc__xml_import_state_t state __hwloc_attribute_unused)
{
return 0;
}
static void
hwloc__libxml_import_close_child(hwloc__xml_import_state_t state __hwloc_attribute_unused)
{
/* nothing to do */
}
static int
hwloc__libxml_import_get_content(hwloc__xml_import_state_t state,
char **beginp, size_t expected_length)
{
hwloc__libxml_import_state_data_t lstate = (void*) state->data;
xmlNode *child;
size_t length;
child = lstate->node->children;
if (!child || child->type != XML_TEXT_NODE) {
if (expected_length)
return -1;
*beginp = (char *) "";
return 0;
}
length = strlen((char *) child->content);
if (length != expected_length)
return -1;
*beginp = (char *) child->content;
return 1;
}
static void
hwloc__libxml_import_close_content(hwloc__xml_import_state_t state __hwloc_attribute_unused)
{
/* nothing to do */
}
static int
hwloc_libxml_look_init(struct hwloc_xml_backend_data_s *bdata,
struct hwloc__xml_import_state_s *state)
{
hwloc__libxml_import_state_data_t lstate = (void*) state->data;
xmlNodePtr root_node;
xmlDtdPtr dtd;
HWLOC_BUILD_ASSERT(sizeof(*lstate) <= sizeof(state->data));
dtd = xmlGetIntSubset((xmlDocPtr) bdata->data);
if (!dtd) {
if (hwloc__xml_verbose())
fprintf(stderr, "%s: Loading XML topology without DTD\n",
state->global->msgprefix);
} else if (strcmp((char *) dtd->SystemID, "hwloc.dtd")
&& strcmp((char *) dtd->SystemID, "hwloc2.dtd")) {
if (hwloc__xml_verbose())
fprintf(stderr, "%s: Loading XML topology with wrong DTD SystemID (%s instead of %s)\n",
state->global->msgprefix, (char *) dtd->SystemID, "hwloc.dtd or hwloc2.dtd");
}
root_node = xmlDocGetRootElement((xmlDocPtr) bdata->data);
if (!strcmp((const char *) root_node->name, "root")) {
bdata->version_major = 0;
bdata->version_minor = 9;
} else if (!strcmp((const char *) root_node->name, "topology")) {
unsigned major, minor;
xmlChar *version = xmlGetProp(root_node, (xmlChar*) "version");
if (version && sscanf((const char *)version, "%u.%u", &major, &minor) == 2) {
bdata->version_major = major;
bdata->version_minor = minor;
} else {
bdata->version_major = 1;
bdata->version_minor = 0;
}
xmlFree(version);
} else {
/* root node should be in "topology" class (or "root" if importing from < 1.0) */
if (hwloc__xml_verbose())
fprintf(stderr, "%s: ignoring object of class `%s' not at the top the xml hierarchy\n",
state->global->msgprefix, (const char *) root_node->name);
goto failed;
}
state->global->next_attr = hwloc__libxml_import_next_attr;
state->global->find_child = hwloc__libxml_import_find_child;
state->global->close_tag = hwloc__libxml_import_close_tag;
state->global->close_child = hwloc__libxml_import_close_child;
state->global->get_content = hwloc__libxml_import_get_content;
state->global->close_content = hwloc__libxml_import_close_content;
state->parent = NULL;
lstate->node = root_node;
lstate->child = root_node->children;
lstate->attr = NULL;
return 0; /* success */
failed:
return -1; /* failed */
}
/* can be called at the end of the import (to cleanup things early),
* or by backend_exit() if load failed for other reasons.
*/
static void
hwloc_libxml_free_buffers(struct hwloc_xml_backend_data_s *bdata)
{
if (bdata->data) {
xmlFreeDoc((xmlDoc*)bdata->data);
bdata->data = NULL;
}
}
static void
hwloc_libxml_look_done(struct hwloc_xml_backend_data_s *bdata, int result __hwloc_attribute_unused)
{
hwloc_libxml_free_buffers(bdata);
}
static int
hwloc_libxml_import_diff(struct hwloc__xml_import_state_s *state, const char *xmlpath, const char *xmlbuffer, int xmlbuflen, hwloc_topology_diff_t *firstdiffp, char **refnamep)
{
hwloc__libxml_import_state_data_t lstate = (void*) state->data;
char *refname = NULL;
xmlDoc *doc = NULL;
xmlNode* root_node;
xmlDtd *dtd;
int ret;
HWLOC_BUILD_ASSERT(sizeof(*lstate) <= sizeof(state->data));
LIBXML_TEST_VERSION;
hwloc_libxml2_init_once();
errno = 0; /* set to 0 so that we know if libxml2 changed it */
if (xmlpath)
doc = xmlReadFile(xmlpath, NULL, XML_PARSE_NOBLANKS);
else if (xmlbuffer)
doc = xmlReadMemory(xmlbuffer, xmlbuflen, "", NULL, XML_PARSE_NOBLANKS);
if (!doc) {
if (!errno)
/* libxml2 read the file fine, but it got an error during parsing */
errno = EINVAL;
hwloc_libxml2_cleanup();
goto out;
}
dtd = xmlGetIntSubset(doc);
if (!dtd) {
if (hwloc__xml_verbose())
fprintf(stderr, "%s: Loading XML topologydiff without DTD\n",
state->global->msgprefix);
} else if (strcmp((char *) dtd->SystemID, "hwloc2-diff.dtd")) {
if (hwloc__xml_verbose())
fprintf(stderr, "%s: Loading XML topologydiff with wrong DTD SystemID (%s instead of %s)\n",
state->global->msgprefix, (char *) dtd->SystemID, "hwloc2-diff.dtd");
}
root_node = xmlDocGetRootElement(doc);
if (strcmp((const char *) root_node->name, "topologydiff")) {
/* root node should be in "topologydiff" class */
if (hwloc__xml_verbose())
fprintf(stderr, "%s: ignoring object of class `%s' not at the top the xml hierarchy\n",
state->global->msgprefix, (const char *) root_node->name);
goto out_with_doc;
}
state->global->next_attr = hwloc__libxml_import_next_attr;
state->global->find_child = hwloc__libxml_import_find_child;
state->global->close_tag = hwloc__libxml_import_close_tag;
state->global->close_child = hwloc__libxml_import_close_child;
state->global->get_content = hwloc__libxml_import_get_content;
state->global->close_content = hwloc__libxml_import_close_content;
state->parent = NULL;
lstate->node = root_node;
lstate->child = root_node->children;
lstate->attr = NULL;
while (1) {
char *attrname, *attrvalue;
if (state->global->next_attr(state, &attrname, &attrvalue) < 0)
break;
if (!strcmp(attrname, "refname")) {
free(refname);
refname = strdup(attrvalue);
} else
goto out_with_doc;
}
ret = hwloc__xml_import_diff(state, firstdiffp);
if (refnamep && !ret)
*refnamep = refname;
else
free(refname);
xmlFreeDoc(doc);
hwloc_libxml2_cleanup();
return ret;
out_with_doc:
free(refname);
xmlFreeDoc(doc);
hwloc_libxml2_cleanup();
out:
return -1; /* failed */
}
/********************
* Backend routines *
********************/
static void
hwloc_libxml_backend_exit(struct hwloc_xml_backend_data_s *bdata)
{
hwloc_libxml_free_buffers(bdata);
hwloc_libxml2_cleanup();
}
static int
hwloc_libxml_backend_init(struct hwloc_xml_backend_data_s *bdata,
const char *xmlpath, const char *xmlbuffer, int xmlbuflen)
{
xmlDoc *doc = NULL;
LIBXML_TEST_VERSION;
hwloc_libxml2_init_once();
errno = 0; /* set to 0 so that we know if libxml2 changed it */
if (xmlpath)
doc = xmlReadFile(xmlpath, NULL, XML_PARSE_NOBLANKS);
else if (xmlbuffer)
doc = xmlReadMemory(xmlbuffer, xmlbuflen, "", NULL, XML_PARSE_NOBLANKS);
if (!doc) {
if (!errno)
/* libxml2 read the file fine, but it got an error during parsing */
errno = EINVAL;
hwloc_libxml2_cleanup();
return -1;
}
bdata->look_init = hwloc_libxml_look_init;
bdata->look_done = hwloc_libxml_look_done;
bdata->backend_exit = hwloc_libxml_backend_exit;
bdata->data = doc;
return 0;
}
/*******************
* Export routines *
*******************/
typedef struct hwloc__libxml_export_state_data_s {
xmlNodePtr current_node; /* current node to output */
} __hwloc_attribute_may_alias * hwloc__libxml_export_state_data_t;
static void
hwloc__libxml_export_new_child(hwloc__xml_export_state_t parentstate,
hwloc__xml_export_state_t state,
const char *name)
{
hwloc__libxml_export_state_data_t lpdata = (void *) parentstate->data;
hwloc__libxml_export_state_data_t ldata = (void *) state->data;
state->parent = parentstate;
state->new_child = parentstate->new_child;
state->new_prop = parentstate->new_prop;
state->add_content = parentstate->add_content;
state->end_object = parentstate->end_object;
state->global = parentstate->global;
ldata->current_node = xmlNewChild(lpdata->current_node, NULL, BAD_CAST name, NULL);
}
static void
hwloc__libxml_export_new_prop(hwloc__xml_export_state_t state, const char *name, const char *value)
{
hwloc__libxml_export_state_data_t ldata = (void *) state->data;
xmlNewProp(ldata->current_node, BAD_CAST name, BAD_CAST value);
}
static void
hwloc__libxml_export_end_object(hwloc__xml_export_state_t state __hwloc_attribute_unused, const char *name __hwloc_attribute_unused)
{
/* nothing to do */
}
static void
hwloc__libxml_export_add_content(hwloc__xml_export_state_t state, const char *buffer, size_t length)
{
hwloc__libxml_export_state_data_t ldata = (void *) state->data;
xmlNodeAddContentLen(ldata->current_node, BAD_CAST buffer, length);
}
static xmlDocPtr
hwloc__libxml2_prepare_export(hwloc_topology_t topology, struct hwloc__xml_export_data_s *edata,
unsigned long flags)
{
struct hwloc__xml_export_state_s state;
hwloc__libxml_export_state_data_t data = (void *) state.data;
int v1export = flags & HWLOC_TOPOLOGY_EXPORT_XML_FLAG_V1;
xmlDocPtr doc = NULL; /* document pointer */
xmlNodePtr root_node = NULL; /* root pointer */
HWLOC_BUILD_ASSERT(sizeof(*data) <= sizeof(state.data));
LIBXML_TEST_VERSION;
hwloc_libxml2_init_once();
/* Creates a new document, a node and set it as a root node. */
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL, BAD_CAST "topology");
if (!(flags & HWLOC_TOPOLOGY_EXPORT_XML_FLAG_V1))
xmlNewProp(root_node, BAD_CAST "version", BAD_CAST "2.0");
xmlDocSetRootElement(doc, root_node);
/* Creates a DTD declaration. Isn't mandatory. */
(void) xmlCreateIntSubset(doc, BAD_CAST "topology", NULL, v1export ? BAD_CAST "hwloc.dtd" : BAD_CAST "hwloc2.dtd");
state.new_child = hwloc__libxml_export_new_child;
state.new_prop = hwloc__libxml_export_new_prop;
state.add_content = hwloc__libxml_export_add_content;
state.end_object = hwloc__libxml_export_end_object;
state.global = edata;
data->current_node = root_node;
hwloc__xml_export_topology (&state, topology, flags);
return doc;
}
static int
hwloc_libxml_export_file(hwloc_topology_t topology, struct hwloc__xml_export_data_s *edata,
const char *filename, unsigned long flags)
{
xmlDocPtr doc;
int ret;
errno = 0; /* set to 0 so that we know if libxml2 changed it */
doc = hwloc__libxml2_prepare_export(topology, edata, flags);
ret = xmlSaveFormatFileEnc(filename, doc, "UTF-8", 1);
xmlFreeDoc(doc);
hwloc_libxml2_cleanup();
if (ret < 0) {
if (!errno)
/* libxml2 likely got an error before doing I/O */
errno = EINVAL;
return ret;
}
return 0;
}
static int
hwloc_libxml_export_buffer(hwloc_topology_t topology, struct hwloc__xml_export_data_s *edata,
char **xmlbuffer, int *buflen, unsigned long flags)
{
xmlDocPtr doc;
doc = hwloc__libxml2_prepare_export(topology, edata, flags);
xmlDocDumpFormatMemoryEnc(doc, (xmlChar **)xmlbuffer, buflen, "UTF-8", 1);
xmlFreeDoc(doc);
hwloc_libxml2_cleanup();
if (!*xmlbuffer) {
*buflen = 0;
return -1;
}
*buflen += 1; /* ending \0 was added but not counted in the length */
return 0;
}
static xmlDocPtr
hwloc__libxml2_prepare_export_diff(hwloc_topology_diff_t diff, const char *refname)
{
struct hwloc__xml_export_state_s state;
hwloc__libxml_export_state_data_t data = (void *) state.data;
xmlDocPtr doc = NULL; /* document pointer */
xmlNodePtr root_node = NULL; /* root pointer */
HWLOC_BUILD_ASSERT(sizeof(*data) <= sizeof(state.data));
LIBXML_TEST_VERSION;
hwloc_libxml2_init_once();
/* Creates a new document, a node and set it as a root node. */
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL, BAD_CAST "topologydiff");
if (refname)
xmlNewProp(root_node, BAD_CAST "refname", BAD_CAST refname);
xmlDocSetRootElement(doc, root_node);
/* Creates a DTD declaration. Isn't mandatory. */
(void) xmlCreateIntSubset(doc, BAD_CAST "topologydiff", NULL, BAD_CAST "hwloc2-diff.dtd");
state.new_child = hwloc__libxml_export_new_child;
state.new_prop = hwloc__libxml_export_new_prop;
state.add_content = hwloc__libxml_export_add_content;
state.end_object = hwloc__libxml_export_end_object;
data->current_node = root_node;
hwloc__xml_export_diff (&state, diff);
return doc;
}
static int
hwloc_libxml_export_diff_file(hwloc_topology_diff_t diff, const char *refname, const char *filename)
{
xmlDocPtr doc;
int ret;
errno = 0; /* set to 0 so that we know if libxml2 changed it */
doc = hwloc__libxml2_prepare_export_diff(diff, refname);
ret = xmlSaveFormatFileEnc(filename, doc, "UTF-8", 1);
xmlFreeDoc(doc);
hwloc_libxml2_cleanup();
if (ret < 0) {
if (!errno)
/* libxml2 likely got an error before doing I/O */
errno = EINVAL;
return ret;
}
return 0;
}
static int
hwloc_libxml_export_diff_buffer(hwloc_topology_diff_t diff, const char *refname, char **xmlbuffer, int *buflen)
{
xmlDocPtr doc;
doc = hwloc__libxml2_prepare_export_diff(diff, refname);
xmlDocDumpFormatMemoryEnc(doc, (xmlChar **)xmlbuffer, buflen, "UTF-8", 1);
xmlFreeDoc(doc);
hwloc_libxml2_cleanup();
if (!*xmlbuffer) {
*buflen = 0;
return -1;
}
*buflen += 1; /* ending \0 was added but not counted in the length */
return 0;
}
static void
hwloc_libxml_free_buffer(void *xmlbuffer)
{
xmlFree(BAD_CAST xmlbuffer);
}
/*************
* Callbacks *
*************/
static struct hwloc_xml_callbacks hwloc_xml_libxml_callbacks = {
hwloc_libxml_backend_init,
hwloc_libxml_export_file,
hwloc_libxml_export_buffer,
hwloc_libxml_free_buffer,
hwloc_libxml_import_diff,
hwloc_libxml_export_diff_file,
hwloc_libxml_export_diff_buffer
};
static struct hwloc_xml_component hwloc_libxml_xml_component = {
NULL,
&hwloc_xml_libxml_callbacks
};
static int
hwloc_xml_libxml_component_init(unsigned long flags)
{
if (flags)
return -1;
if (hwloc_plugin_check_namespace("xml_libxml", "hwloc__xml_verbose") < 0)
return -1;
return 0;
}
#ifdef HWLOC_INSIDE_PLUGIN
HWLOC_DECLSPEC extern const struct hwloc_component hwloc_xml_libxml_component;
#endif
const struct hwloc_component hwloc_xml_libxml_component = {
HWLOC_COMPONENT_ABI,
hwloc_xml_libxml_component_init, NULL,
HWLOC_COMPONENT_TYPE_XML,
0,
&hwloc_libxml_xml_component
};