[Libvirt-cim] [PATCH 2 of 3] [RFC][CU] Add EI CIMXML parser

Friday, 8 February 2008

# HG changeset patch
# User Dan Smith <danms(a)us.ibm.com&gt;
# Date 1202512655 28800
# Node ID f6559a2f55abab85baeabd56faaf7804c3ea30f3
# Parent  03126c9af41607dcaa8b197736dd5059c108261a
[RFC][CU] Add EI CIMXML parser

This handles strings, bools, integers, and arrays of those.  It doesn't yet
handle nested objects, as we will need for RASD.HostResource[].  I need
to do some further investigation of what the XML for that will look like.

I have tested this by taking an existing XML for DefineSystem() and
changing the MemResourceAllocationSettingData field to this:

    &lt;INSTANCE
CLASSNAME=&quot;Xen_MemResourceAllocationSettingData&quot;&gt;
    &lt;PROPERTY NAME=&quot;CreationClassName&quot;
TYPE=&quot;string&quot;&gt;
      &lt;VALUE&gt;Xen_MemResourceAllocationSettingData&lt;/VALUE&gt;
    &lt;/PROPERTY&gt;
    &lt;PROPERTY NAME=&quot;InstanceID&quot;
TYPE=&quot;string&quot;&gt;
      &lt;VALUE&gt;test/mem&lt;/VALUE&gt;
    &lt;/PROPERTY&gt;
    &lt;PROPERTY NAME=&quot;ResourceType&quot;
TYPE=&quot;uint16&quot;&gt;
       &lt;VALUE&gt;4&lt;/VALUE&gt;
    &lt;/PROPERTY&gt;
    &lt;PROPERTY NAME=&quot;VirtualQuantity&quot;
TYPE=&quot;uint64&quot;&gt;
       &lt;VALUE&gt;256 &lt;/VALUE&gt;
    &lt;/PROPERTY&gt;
    &lt;PROPERTY.ARRAY NAME=&quot;Foo&quot;
TYPE=&quot;string&quot;&gt;
      &lt;VALUE.ARRAY&gt;
        &lt;VALUE&gt;Bar&lt;/VALUE&gt;
        &lt;VALUE&gt;Baz&lt;/VALUE&gt;
      &lt;/VALUE.ARRAY&gt;
    &lt;/PROPERTY.ARRAY&gt;
  &lt;/INSTANCE&gt;

(The Foo[] parameter in there is just for testing :)

Signed-off-by: Dan Smith <danms(a)us.ibm.com&gt;

diff -r 03126c9af416 -r f6559a2f55ab Makefile.am

--- a/Makefile.am	Fri Feb 08 15:17:30 2008 -0800
+++ b/Makefile.am	Fri Feb 08 15:17:35 2008 -0800
@@ -10,6 +10,8 @@ pkgconfig_DATA = libcmpiutil.pc
 
 libcmpiutilincdir = $(includedir)/libcmpiutil
 
+noinst_HEADERS = eo_parser_xml.h
+
 libcmpiutilinc_HEADERS = libcmpiutil.h \
                   std_invokemethod.h \
                   std_association.h \
@@ -18,7 +20,7 @@ libcmpiutilinc_HEADERS = libcmpiutil.h \
 
 libcmpiutil_la_SOURCES = args_util.c instance_util.c std_invokemethod.c \
                          std_association.c inst_list.c std_indication.c \
-                         debug_util.c
+                         debug_util.c eo_parser_xml.c
 libcmpiutil_la_CFLAGS = $(CFLAGS) $(CFLAGS_STRICT)
 libcmpiutil_la_LIBADD =
 libcmpiutil_la_DEPENDENCIES =
diff -r 03126c9af416 -r f6559a2f55ab eo_parser_xml.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/eo_parser_xml.c	Fri Feb 08 15:17:35 2008 -0800
@@ -0,0 +1,482 @@
+/*
+ * Copyright IBM Corp. 2007
+ *
+ * Authors:
+ *  Dan Smith <danms(a)us.ibm.com&gt;
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+
+#include <cmpidt.h>
+#include <cmpift.h>
+#include <cmpimacs.h>
+
+#include "libcmpiutil.h"
+
+#include "eo_parser_xml.h"
+
+static char *get_attr(xmlNode *node, const char *name)
+{
+        return (char *)xmlGetProp(node, (xmlChar *)name);
+}
+
+static char *get_content(xmlNode *node)
+{
+        return (char *)xmlNodeGetContent(node);
+}
+
+static CMPIType parse_string_property(const CMPIBroker *broker,
+                                      const char *string,
+                                      const char *type,
+                                      CMPIValue *val)
+{
+        CMPIString *str;
+        CMPIStatus s;
+
+        str = CMNewString(broker, string, &s);
+        if ((str == NULL) || (s.rc != CMPI_RC_OK))
+                return CMPI_null;
+
+        val->string = str;
+        return CMPI_string;
+}
+
+static CMPIType parse_bool_property(const char *string,
+                                    const char *type,
+                                    CMPIValue *val)
+{
+        val->boolean = STREQC(string, "true");
+
+        return CMPI_boolean;
+}
+
+static CMPIType parse_int_property(const char *string,
+                                   const char *type,
+                                   CMPIValue *val)
+{
+        int size;
+        bool sign;
+        CMPIType t;
+        int ret;
+
+        if (sscanf(type, "uint%i", &size) == 1)
+                sign = false;
+        else if (sscanf(type, "int%i", &size) == 1)
+                sign = true;
+        else {
+                printf("Unknown integer type: `%s'", type);
+                return 0;
+        }
+
+        if (sign) {
+                int64_t _val;
+                ret = sscanf(string, "%" SCNi64, &_val);
+                val->sint64 = _val;
+        } else {
+                uint64_t _val;
+                ret = sscanf(string, "%" SCNu64, &_val);
+                val->uint64 = _val;
+        }
+
+        if (ret != 1) {
+                printf("Failed to scan value `%s'\n", string);
+                return 0;
+        }
+
+        switch (size) {
+        case 8:  t = sign ? CMPI_sint8  : CMPI_uint8;  break;
+        case 16: t = sign ? CMPI_sint16 : CMPI_uint16; break;
+        case 32: t = sign ? CMPI_sint32 : CMPI_uint32; break;
+        default:
+        case 64: t = sign ? CMPI_sint64 : CMPI_uint64; break;
+        };
+
+        return t;
+}
+
+static CMPIType get_property_value(const CMPIBroker *broker,
+                                   const char *tstr,
+                                   const char *content,
+                                   CMPIValue *value)
+{
+        CMPIType type = CMPI_null;
+
+        if (STREQC(tstr, "string"))
+                type = parse_string_property(broker, content, tstr, value);
+        else if (STREQC(tstr, "boolean"))
+                type = parse_bool_property(content, tstr, value);
+        else if (strstr(tstr, "int"))
+                type = parse_int_property(content, tstr, value);
+        else {
+                printf("Unhandled type: %s\n", tstr);
+                goto out;
+        }
+
+        if (type == CMPI_null) {
+                printf("Unable to parse type %s\n", tstr);
+                goto out;
+        }
+
+ out:
+        return type;
+}
+
+static CMPIType get_node_value(const CMPIBroker *broker,
+                               xmlNode *node,
+                               const char *tstr,
+                               CMPIValue *val)
+{
+        CMPIType type = CMPI_null;
+        char *content = NULL;
+
+        if (node->type != XML_ELEMENT_NODE) {
+                CU_DEBUG("Non-element node: %s", node->name);
+                goto out;
+        }
+
+        if (!STREQC((char *)node->name, "value")) {
+                CU_DEBUG("Expected <VALUE> but got <%s>",
node->name);
+                goto out;
+        }
+
+        content = get_content(node);
+        CU_DEBUG("Node content: %s", content);
+        type = get_property_value(broker, tstr, content, val);
+        free(content);
+ out:
+        return type;
+}
+
+static CMPIType parse_array(const CMPIBroker *broker,
+                            const char *tstr,
+                            xmlNode *root,
+                            CMPIArray **array)
+{
+        xmlNode *value;
+        CMPIValue *list = NULL;
+        int size = 0;
+        int cur = 0;
+        CMPIStatus s;
+        CMPIType type = CMPI_null;
+        int i;
+
+        for (value = root->children; value; value = value->next) {
+
+                if (value->type != XML_ELEMENT_NODE)
+                        continue;
+
+                if (cur == size) {
+                        CMPIValue *tmp;
+
+                        size += 4;
+                        tmp = realloc(list, sizeof(CMPIValue) * size);
+                        if (tmp == NULL) {
+                                CU_DEBUG("Failed to alloc %i",
+                                         sizeof(CMPIValue) * size);
+                                goto out;
+                        }
+
+                        list = tmp;
+                }
+
+                type = get_node_value(broker, value, tstr, &list[cur]);
+                if (type == CMPI_null) {
+                        CU_DEBUG("Got nothing from child");
+                } else {
+                        CU_DEBUG("Array value type %i", type);
+                        cur++;
+                }
+        }
+
+        if (cur == 0)
+                return CMPI_null;
+
+        *array = CMNewArray(broker, cur, type, &s);
+        if ((*array == NULL) || (s.rc != CMPI_RC_OK)) {
+                CU_DEBUG("Failed to alloc CMPIArray of %i", cur);
+                goto out;
+        }
+
+        for (i = 0; i < cur; i++)
+                CMSetArrayElementAt((*array), i, &list[i], type);
+
+ out:
+        free(list);
+
+        return type;
+}
+
+static bool parse_array_property(const CMPIBroker *broker,
+                                 xmlNode *node,
+                                 CMPIInstance *inst)
+{
+        char *name = NULL;
+        char *tstr = NULL;
+        bool ret = false;
+        xmlNode *val_arr;
+        CMPIArray *array;
+        CMPIType type;
+
+        name = get_attr(node, "NAME");
+        if (name == NULL) {
+                printf("Unnamed property\n");
+                goto out;
+        }
+
+        tstr = get_attr(node, "TYPE");
+        if (tstr == NULL) {
+                printf("No type\n");
+                goto out;
+        }
+
+        printf("Array property `%s' of type `%s'\n", name, tstr);
+
+        for (val_arr = node->children; val_arr; val_arr = val_arr->next) {
+                if (val_arr->type != XML_ELEMENT_NODE)
+                        continue;
+
+                if (!STREQC((char *)val_arr->name, "value.array")) {
+                        printf("Expected <value.array> but got
<%s>",
+                               val_arr->name);
+                        goto out;
+                }
+
+                break;
+        }
+
+        type = parse_array(broker, tstr, val_arr, &array);
+        if (type != CMPI_null) {
+                CU_DEBUG("Setting array property");
+                CMSetProperty(inst, name, &array, (CMPI_ARRAY | type));
+        }
+
+ out:
+        free(name);
+        free(tstr);
+
+        return ret;
+}
+
+static bool parse_property(const CMPIBroker *broker,
+                           xmlNode *node,
+                           CMPIInstance *inst)
+{
+        char *name = NULL;
+        char *tstr = NULL;
+        CMPIValue value;
+        CMPIType type = CMPI_null;
+        xmlNode *ptr;
+
+        name = get_attr(node, "NAME");
+        if (name == NULL) {
+                printf("Unnamed property\n");
+                goto out;
+        }
+
+        tstr = get_attr(node, "TYPE");
+        if (tstr == NULL) {
+                printf("No type\n");
+                goto out;
+        }
+
+        CU_DEBUG("Property %s: %s", name, tstr);
+
+        for (ptr = node->children; ptr; ptr = ptr->next) {
+                type = get_node_value(broker, ptr, tstr, &value);
+                if (type != CMPI_null) {
+                        CMSetProperty(inst, name, &value, type);
+                        break;
+                }
+        }
+ out:
+        free(name);
+        free(tstr);
+
+        return type != CMPI_null;
+}
+
+static CMPIStatus parse_instance(const CMPIBroker *broker,
+                                 const char *ns,
+                                 xmlNode *root,
+                                 CMPIInstance **inst)
+{
+        char *class = NULL;
+        xmlNode *child;
+        CMPIStatus s;
+        CMPIObjectPath *op;
+
+        if (root->type != XML_ELEMENT_NODE) {
+                printf("First node is not <INSTANCE>\n");
+                goto out;
+        }
+
+        if (!STREQC((char *)root->name, "instance")) {
+                printf("Got node %s, expecting INSTANCE\n", root->name);
+                goto out;
+        }
+
+        class = get_attr(root, "CLASSNAME");
+        if (class == NULL) {
+                printf("No Classname\n");
+                goto out;
+        }
+
+        CU_DEBUG("Instance of %s", class);
+
+        op = CMNewObjectPath(broker, ns, class, &s);
+        if ((op == NULL) || (s.rc != CMPI_RC_OK)) {
+                CU_DEBUG("Unable to create path for %s:%s", ns, class);
+                goto out;
+        }
+
+        *inst = CMNewInstance(broker, op, &s);
+        if ((*inst == NULL) || (s.rc != CMPI_RC_OK)) {
+                CU_DEBUG("Unable to create inst for %s:%s", ns, class);
+                goto out;
+        }
+
+        for (child = root->children; child; child = child->next) {
+                if (child->type == XML_ELEMENT_NODE){
+                        if (STREQC((char *)child->name, "property"))
+                                parse_property(broker, child, *inst);
+                        else if (STREQC((char *)child->name,
"property.array"))
+                                parse_array_property(broker, child, *inst);
+                        else
+                                printf("Unexpected node: %s\n",
child->name);
+                }
+        }
+
+ out:
+        free(class);
+
+        return s;
+}
+
+#if 0
+
+/* This isn't currently used but I think I might need it for nested
+ * instances, depending on how they look.
+ */
+
+static char *parse_esc(const char *start, char *result)
+{
+        char *delim;
+        char *escape = NULL;
+        int len = 1;
+
+        delim = strchr(start, ';');
+        if (delim == NULL)
+                goto out;
+
+        escape = strndup(start, delim - start + 1);
+        if (escape == NULL) {
+                CU_DEBUG("Memory alloc failed (%i)", delim-start);
+                return NULL;
+        }
+
+        CU_DEBUG("Escape is: %s", escape);
+
+        if (STREQC(escape, "&lt;"))
+                *result = '<';
+        else if (STREQC(escape, "&gt;"))
+                *result = '>';
+        else if (STREQC(escape, "&quot;"))
+                *result = '\"';
+        else
+                CU_DEBUG("Unhandled escape: `%s'", escape);
+
+        len = strlen(escape);
+
+ out:
+        free(escape);
+
+        return (char *)start + len;
+}
+
+static char *xml_decode(const char *input)
+{
+        const char *iptr = input;
+        char *optr;
+        char *res = NULL;
+
+        res = malloc(strlen(input) + 1);
+        if (res == NULL)
+                return res;
+
+        optr = res;
+
+        while (iptr && (*iptr != '\0')) {
+                if (*iptr == '&') {
+                        iptr = parse_esc(iptr, optr);
+                } else {
+                        *optr = *iptr;
+                        iptr++;
+                }
+
+                optr++;
+        }
+
+        return res;
+}
+
+#endif
+
+int cu_parse_ei_xml(const CMPIBroker *broker,
+                    const char *ns,
+                    const char *xml,
+                    CMPIInstance **instance)
+{
+        xmlDoc *doc = NULL;
+        xmlNode *root = NULL;
+        int ret = 0;
+
+        doc = xmlReadMemory(xml, strlen(xml), NULL, NULL, 0);
+        if (doc == NULL) {
+                CU_DEBUG("Error reading decoded XML from memory");
+                goto out;
+        }
+
+        root = xmlDocGetRootElement(doc);
+        if (root == NULL) {
+                CU_DEBUG("Error getting root XML node");
+                goto out;
+        }
+
+        parse_instance(broker, ns, root, instance);
+
+ out:
+        xmlFreeDoc(doc);
+
+        return ret;
+}
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-set-style: "K&R"
+ * tab-width: 8
+ * c-basic-offset: 8
+ * indent-tabs-mode: nil
+ * End:
+ */
diff -r 03126c9af416 -r f6559a2f55ab eo_parser_xml.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/eo_parser_xml.h	Fri Feb 08 15:17:35 2008 -0800
@@ -0,0 +1,40 @@
+/*
+ * Copyright IBM Corp. 2007
+ *
+ * Authors:
+ *  Dan Smith <danms(a)us.ibm.com&gt;
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#ifndef __EO_PARSER_XML_H
+#define __EO_PARSER_XML_H
+
+int cu_parse_ei_xml(const CMPIBroker *broker,
+                    const char *ns,
+                    const char *xml,
+                    CMPIInstance **instance);
+
+#endif
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-set-style: "K&R"
+ * tab-width: 8
+ * c-basic-offset: 8
+ * indent-tabs-mode: nil
+ * End:
+ */


    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

[Libvirt-cim] [PATCH 2 of 3] [RFC][CU] Add EI CIMXML parser