#include <Python.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include <libxml/tree.h>

#include <libxml/xpath.h>

#include "util.h"

#include "dmixml.h"

#include "dmierror.h"

#include "xmlpythonizer.h"

#include "version.h"

ptzMAP *ptzmap_AppendMap(const ptzMAP *chain, ptzMAP *newmap)

{

if( chain != NULL ) {

newmap->next = (ptzMAP *) chain;

}

return newmap;

}

ptzMAP *ptzmap_Add(const ptzMAP *chain, char *rootp,

ptzTYPES ktyp, const char *key,

ptzTYPES vtyp, const char *value,

ptzMAP *child)

{

ptzMAP *ret = NULL;

assert( (ktyp == ptzCONST) || (ktyp == ptzSTR) || (ktyp == ptzINT) || (ktyp == ptzFLOAT) );

assert( key != NULL );

ret = (ptzMAP *) malloc(sizeof(ptzMAP)+2);

assert( ret != NULL );

memset(ret, 0, sizeof(ptzMAP)+2);

if( rootp != NULL ) {

ret->rootpath = strdup(rootp);

}

ret->type_key = ktyp;

ret->key = strdup(key);

ret->type_value = vtyp;

if( value != NULL ) {

ret->value = strdup(value);

}

if( child != NULL ) {

ret->child = child;

}

return ptzmap_AppendMap(chain, ret);

};

void ptzmap_SetFixedList(ptzMAP *map_p, const char *index, int size)

{

assert( map_p != NULL );

switch( map_p->type_value ) {

case ptzLIST_STR:

case ptzLIST_INT:

case ptzLIST_FLOAT:

case ptzLIST_BOOL:

map_p->list_index = strdup(index);

map_p->fixed_list_size = size;

break;

default:

break;

}

}

void ptzmap_Free_func(ptzMAP *ptr)

{

if( ptr == NULL ) {

return;

}

if( ptr->rootpath != NULL ) {

free(ptr->rootpath);

ptr->rootpath = NULL;

}

if( ptr->list_index != NULL ) {

free(ptr->list_index);

ptr->list_index = NULL;

}

if( ptr->emptyValue != NULL ) {

free(ptr->emptyValue);

ptr->emptyValue = NULL;

}

free(ptr->key);

ptr->key = NULL;

if( ptr->value != NULL ) {

free(ptr->value);

ptr->value = NULL;

}

if( ptr->child != NULL ) {

ptzmap_Free(ptr->child);

}

if( ptr->next != NULL ) {

ptzmap_Free(ptr->next);

}

free(ptr);

}

#if 0

static const char *ptzTYPESstr[] = { "ptzCONST", "ptzSTR", "ptzINT", "ptzFLOAT", "ptzBOOL",

"ptzLIST_STR", "ptzLIST_INT", "ptzLIST_FLOAT", "ptzLIST_BOOL",

"ptzDICT", "ptzLIST_DICT", NULL };

void indent(int lvl)

{

int i = 0;

if( lvl == 0 ) {

return;

}

for( i = 0; i < (lvl * 3); i++ ) {

printf(" ");

}

}

#define ptzmap_Dump(ptr) { ptzmap_Dump_func(ptr, 0); }

void ptzmap_Dump_func(const ptzMAP *ptr, int level)

{

if( ptr == NULL ) {

return;

}

if( ptr->rootpath != NULL ) {

indent(level); printf("root path: %s\n", ptr->rootpath);

}

indent(level); printf("key type: (%i) %-13.13s - key: %s\n",

ptr->type_key, ptzTYPESstr[ptr->type_key], ptr->key);

indent(level); printf("value type: (%i) %-13.13s - value: %s %s\n",

ptr->type_value, ptzTYPESstr[ptr->type_value], ptr->value,

(ptr->emptyIsNone ? "(EmptyIsNone)": ""));

if( ptr->list_index != NULL ) {

indent(level);

printf("List index: %s - Fixed size: %i\n",

ptr->list_index, ptr->fixed_list_size);

}

if( ptr->child != NULL ) {

indent(level); printf(" ** CHILD\n");

ptzmap_Dump_func(ptr->child, level + 1);

indent(level); printf(" ** ---------\n");

}

if( ptr->next != NULL ) {

printf("\n");

ptzmap_Dump_func(ptr->next, level);

}

}

#endif // END OF DEBUG FUNCTIONS

inline ptzTYPES _convert_maptype(const char *str) {

if( strcmp(str, "string") == 0 ) {

return ptzSTR;

} else if( strcmp(str, "constant") == 0 ) {

return ptzCONST;

} else if( strcmp(str, "integer") == 0 ) {

return ptzINT;

} else if( strcmp(str, "float") == 0 ) {

return ptzFLOAT;

} else if( strcmp(str, "boolean") == 0 ) {

return ptzBOOL;

} else if( strcmp(str, "list:string") == 0 ) {

return ptzLIST_STR;

} else if( strcmp(str, "list:integer") == 0 ) {

return ptzLIST_INT;

} else if( strcmp(str, "list:float") == 0 ) {

return ptzLIST_FLOAT;

} else if( strcmp(str, "list:boolean") == 0 ) {

return ptzLIST_BOOL;

} else if( strcmp(str, "dict") == 0 ) {

return ptzDICT;

} else if( strcmp(str, "list:dict") == 0 ) {

return ptzLIST_DICT;

} else {

fprintf(stderr, "Unknown field type: %s - defaulting to 'constant'\n", str);

return ptzCONST;

}

}

ptzMAP *_do_dmimap_parsing_typeid(xmlNode *node) {

ptzMAP *retmap = NULL;

xmlNode *ptr_n = NULL, *map_n = NULL;;

// Go to the next XML_ELEMENT_NODE

foreach_xmlnode(node, map_n) {

if( map_n->type == XML_ELEMENT_NODE ) {

break;

}

}

if( map_n == NULL ) {

PyReturnError(PyExc_NameError, "No mapping nodes were found");

}

// Go to the first <Map> node

if( xmlStrcmp(node->name, (xmlChar *) "Map") != 0 ) {

map_n = dmixml_FindNode(node, "Map");

if( map_n == NULL ) {

// If we don't find a <Map> node, we just exit now.

// Other checks will raise an exception if needed.

return NULL;

}

}

// Loop through it's children

foreach_xmlnode(map_n, ptr_n) {

ptzTYPES type_key, type_value;

char *key = NULL, *value = NULL;

char *rootpath = NULL;

char *listidx = NULL;

int fixedsize = 0;

if( ptr_n->type != XML_ELEMENT_NODE ) {

continue;

}

// Get the attributes defining key, keytype, value and valuetype

key = dmixml_GetAttrValue(ptr_n, "key");

type_key = _convert_maptype(dmixml_GetAttrValue(ptr_n, "keytype"));

value = dmixml_GetAttrValue(ptr_n, "value");

type_value = _convert_maptype(dmixml_GetAttrValue(ptr_n, "valuetype"));

rootpath = dmixml_GetAttrValue(ptr_n, "rootpath");

listidx = dmixml_GetAttrValue(ptr_n, "index_attr");

if( listidx != NULL ) {

char *fsz = dmixml_GetAttrValue(ptr_n, "fixedsize");

fixedsize = (fsz != NULL ? atoi(fsz) : 0);

}

if( (type_value == ptzDICT) || (type_value == ptzLIST_DICT) ) {

// When value type is ptzDICT, traverse the children nodes

// - should contain another Map set instead of a value attribute

if( ptr_n->children == NULL ) {

continue;

}

// Recursion

retmap = ptzmap_Add(retmap, rootpath, type_key, key, type_value,

(type_value == ptzLIST_DICT ? value : NULL),

_do_dmimap_parsing_typeid(ptr_n->children->next));

} else {

char *tmpstr = NULL;

// Append the value as a normal value when the

// value type is not a Python Dict

retmap = ptzmap_Add(retmap, rootpath, type_key, key, type_value, value, NULL);

// Set emptyIsNone flag

if( (tmpstr = dmixml_GetAttrValue(ptr_n, "emptyIsNone")) != NULL ) {

switch( retmap->type_value ) {

case ptzSTR:

case ptzINT:

case ptzFLOAT:

case ptzBOOL:

case ptzLIST_STR:

case ptzLIST_INT:

case ptzLIST_FLOAT:

case ptzLIST_BOOL:

retmap->emptyIsNone = (tmpstr[0] == '1' ? 1 : 0);

break;

default:

break;

}

}

if( (tmpstr = dmixml_GetAttrValue(ptr_n, "emptyValue")) != NULL ) {

retmap->emptyValue = strdup(tmpstr);

}

}

if( (retmap != NULL) && (listidx != NULL) && (fixedsize > 0) ) {

ptzmap_SetFixedList(retmap, listidx, fixedsize);

}

value = NULL;

key = NULL;

}

return retmap;

}

xmlNode *dmiMAP_GetRootElement(xmlDoc *mapdoc) {

xmlNode *rootnode = NULL;

// Find the root tag and locate our mapping

rootnode = xmlDocGetRootElement(mapdoc);

assert( rootnode != NULL );

// Verify that the root node got the right name

if( (rootnode == NULL)

|| (xmlStrcmp(rootnode->name, (xmlChar *) "dmidecode_mapping") != 0 )) {

PyReturnError(PyExc_IOError, "Invalid XML-Python mapping file. "

"Root node is not 'dmidecode_mapping'");

}

// Verify that it's of a version we support

if( strcmp(dmixml_GetAttrValue(rootnode, "version"), "1") != 0 ) {

PyReturnError(PyExc_RuntimeError, "Unsupported XML-Python mapping file format. "

"Only version 1 is supported");

}

return rootnode;

}

ptzMAP *_dmimap_parse_mapping_node_typeid(xmlNode *mapnode, const char *typeid) {

xmlNode *node = NULL;

assert( mapnode != NULL);

// Find the <TypeMap> tag with our type ID

node = dmixml_FindNodeByAttr_NoCase(mapnode, "TypeMap", "id", typeid);

if( node == NULL ) {

// No exception handling possible here, as we don't return PyObject

fprintf(stderr,"** WARNING: Could not find any XML->Python "

"mapping for type ID '%s'", typeid);

return NULL;

}

// Create an internal map structure and return this structure

return _do_dmimap_parsing_typeid(node);

}

ptzMAP *dmiMAP_ParseMappingXML_TypeID(xmlDoc *xmlmap, int typeid) {

xmlNode *node = NULL;

char typeid_s[16];

node = dmiMAP_GetRootElement(xmlmap);

if( node == NULL ) {

PyReturnError(PyExc_RuntimeError, "Could not locate root XML node for mapping file");

}

memset(&typeid_s, 0, 16);

snprintf(typeid_s, 14, "0x%02X", typeid);

// Find the <TypeMapping> section

node = dmixml_FindNode(node, "TypeMapping");

assert( node != NULL );

return _dmimap_parse_mapping_node_typeid(node, typeid_s);

}

ptzMAP *_do_dmimap_parsing_group(xmlNode *node, xmlDoc *xmlmap) {

ptzMAP *retmap = NULL;

xmlNode *ptr_n = NULL, *map_n = NULL, *typemap = NULL;

char *type_id;

// Go to the next XML_ELEMENT_NODE

foreach_xmlnode(node, map_n) {

if( map_n->type == XML_ELEMENT_NODE ) {

break;

}

}

if( map_n == NULL ) {

PyReturnError(PyExc_RuntimeError, "Could not find any valid XML nodes");

}

// Check that our "root" node is as expected

if( xmlStrcmp(node->name, (xmlChar *) "Mapping") != 0 ) {

PyReturnError(PyExc_NameError, "Expected to find <Mapping> node");

}

// Go to the first <TypeMap> node

map_n = dmixml_FindNode(node, "TypeMap");

if( map_n == NULL ) {

PyReturnError(PyExc_NameError, "Could not locate any <TypeMap> nodes");

}

// Get the root element of the <TypeMapping> tag, needed for further parsing

typemap = dmixml_FindNode(xmlDocGetRootElement(xmlmap), "TypeMapping");

if( typemap == NULL ) {

PyReturnError(PyExc_NameError, "Could not locate the <TypeMapping> node");

}

// Loop through it's children

foreach_xmlnode(map_n, ptr_n) {

// Validate if we have the right node name

if( xmlStrcmp(ptr_n->name, (xmlChar *) "TypeMap") != 0 ) {

continue; // Skip unexpected tag names

}

// Make sure that we have an id attribute before trying to locate that in th

if( (type_id = dmixml_GetAttrValue(ptr_n, "id")) != NULL) {

ptzMAP *map = NULL;

map = _dmimap_parse_mapping_node_typeid(typemap, type_id);

if( map ) {

retmap = ptzmap_AppendMap(retmap, map);

}

}

}

return retmap;

}

ptzMAP *dmiMAP_ParseMappingXML_GroupName(xmlDoc *xmlmap, const char *mapname) {

xmlNode *node = NULL;

// Validate the XML mapping document and get the root element

node = dmiMAP_GetRootElement(xmlmap);

if( node == NULL ) {

PyReturnError(PyExc_RuntimeError, "No valid mapping XML recieved");

}

// Find the <GroupMapping> section

node = dmixml_FindNode(node, "GroupMapping");

if( node == NULL ) {

PyReturnError(PyExc_NameError, "Could not find the <GroupMapping> node");

}

// Find the <Mapping> section matching our request (mapname)

node = dmixml_FindNodeByAttr(node, "Mapping", "name", mapname);

if( node == NULL ) {

PyReturnError(PyExc_NameError, "No group mapping for '%s' was found "

"in the XML-Python mapping file", mapname);

}

// Create an internal map structure and return this structure

return _do_dmimap_parsing_group(node, xmlmap);

}

inline PyObject *StringToPyObj(ptzMAP *val_m, const char *instr) {

PyObject *value;

const char *workstr = NULL;

if( instr == NULL ) {

return Py_None;

}

if( (val_m->emptyIsNone == 1) || (val_m->emptyValue != NULL) ) {

char *cp = strdup(instr);

char *cp_p = NULL;

assert( cp != NULL );

// Trim the string for trailing spaces

cp_p = cp + strlen(cp) - 1;

while( (cp_p >= cp) && (*cp_p == ' ') ) {

*cp_p = 0;

cp_p--;

}

// If our copy pointer is the same

// or less than the starting point,

// there is no data here

if( cp_p <= cp ) {

free(cp);

if( val_m->emptyIsNone == 1 ) {

return Py_None;

}

if( val_m->emptyValue != NULL ) {

workstr = (const char *)val_m->emptyValue;

}

} else {

free(cp);

}

}

if( workstr == NULL ) {

workstr = instr;

}

switch( val_m->type_value ) {

case ptzINT:

case ptzLIST_INT:

value = PyInt_FromLong(atoi(workstr));

break;

case ptzFLOAT:

case ptzLIST_FLOAT:

value = PyFloat_FromDouble(atof(workstr));

break;

case ptzBOOL:

case ptzLIST_BOOL:

value = PyBool_FromLong((atoi(workstr) == 1 ? 1:0));

break;

case ptzSTR:

case ptzLIST_STR:

value = PyString_FromString(workstr);

break;

default:

fprintf(stderr, "Invalid type '%i' for value '%s'\n", val_m->type_value, instr);

value = Py_None;

}

return value;

}

xmlXPathObject *_get_xpath_values(xmlXPathContext *xpctx, const char *xpath) {

xmlChar *xp_xpr = NULL;

xmlXPathObject *xp_obj = NULL;

if( xpath == NULL ) {

return NULL;

}

xp_xpr = xmlCharStrdup(xpath);

xp_obj = xmlXPathEvalExpression(xp_xpr, xpctx);

assert( xp_obj != NULL );

free(xp_xpr);

return xp_obj;

}

char *_get_key_value(char *key, size_t buflen, ptzMAP *map_p, xmlXPathContext *xpctx, int idx) {

xmlXPathObject *xpobj = NULL;

memset(key, 0, buflen);

switch( map_p->type_key ) {

case ptzCONST:

strncpy(key, map_p->key, buflen-1);

break;

case ptzSTR:

case ptzINT:

case ptzFLOAT:

xpobj = _get_xpath_values(xpctx, map_p->key);

if( xpobj == NULL ) {

return NULL;

}

if( dmixml_GetXPathContent(key, buflen, xpobj, idx) == NULL ) {

xmlXPathFreeObject(xpobj);

return NULL;

}

xmlXPathFreeObject(xpobj);

break;

default:

fprintf(stderr, "Unknown key type: %i\n", map_p->type_key);

return NULL;

}

// We consider to have a key, if the first byte is a readable

// character (usually starting at 0x20/32d)

return ((key != NULL) && (strlen(key) > 0) ? key : NULL) ;

}

#define PyADD_DICT_VALUE(p, k, v) { \

PyDict_SetItemString(p, k, v); \

if( v != Py_None ) { \

Py_DECREF(v); \

} \

}

inline void _add_xpath_result(PyObject *pydat, xmlXPathContext *xpctx, ptzMAP *map_p, xmlXPathObject *value) {

int i = 0;

char *key = NULL;

char *val = NULL;

assert( pydat != NULL && value != NULL );

key = (char *) malloc(258);

assert( key != NULL );

val = (char *) malloc(4098);

assert( val != NULL );

switch( value->type ) {

case XPATH_NODESET:

if( value->nodesetval == NULL ) {

break;

}

if( value->nodesetval->nodeNr == 0 ) {

if( _get_key_value(key, 256, map_p, xpctx, 0) != NULL ) {

PyADD_DICT_VALUE(pydat, key, Py_None);

}

} else {

for( i = 0; i < value->nodesetval->nodeNr; i++ ) {

if( _get_key_value(key, 256, map_p, xpctx, i) != NULL ) {

dmixml_GetXPathContent(val, 4097, value, i);

PyADD_DICT_VALUE(pydat, key, StringToPyObj(map_p, val));

}

}

}

break;

default:

if( _get_key_value(key, 256, map_p, xpctx, 0) != NULL ) {

dmixml_GetXPathContent(val, 4097, value, 0);

PyADD_DICT_VALUE(pydat, key, StringToPyObj(map_p, val));

}

break;

}

free(key);

free(val);

}

PyObject *_deep_pythonize(PyObject *retdata, ptzMAP *map_p, xmlNode *data_n, int elmtid) {

char *key = NULL;

xmlXPathContext *xpctx = NULL;

xmlDoc *xpdoc = NULL;

xmlXPathObject *xpo = NULL;

PyObject *value = NULL;

int i;

xpdoc = xmlNewDoc((xmlChar *) "1.0");

assert( xpdoc != NULL );

xmlDocSetRootElement(xpdoc, xmlCopyNode(data_n, 1));

xpctx = xmlXPathNewContext(xpdoc);

assert( xpctx != NULL );

xpctx->node = data_n;

key = (char *) malloc(258);

assert( key != NULL );

// Extract value

switch( map_p->type_value ) {

case ptzCONST:

if( _get_key_value(key, 256, map_p, xpctx, 0) != NULL ) {

value = PyString_FromString(map_p->value);

PyADD_DICT_VALUE(retdata, key, value);

} else {

PyReturnError(PyExc_ValueError, "Could not get key value: %s [%i] (Defining key: %s)",

map_p->rootpath, elmtid, map_p->key);

}

break;

case ptzSTR:

case ptzINT:

case ptzFLOAT:

case ptzBOOL:

xpo = _get_xpath_values(xpctx, map_p->value);

if( xpo != NULL ) {

_add_xpath_result(retdata, xpctx, map_p, xpo);

xmlXPathFreeObject(xpo);

}

break;

case ptzLIST_STR:

case ptzLIST_INT:

case ptzLIST_FLOAT:

case ptzLIST_BOOL:

xpo = _get_xpath_values(xpctx, map_p->value);

if( xpo != NULL ) {

if( _get_key_value(key, 256, map_p, xpctx, 0) != NULL ) {

if( (xpo->nodesetval != NULL) && (xpo->nodesetval->nodeNr > 0) ) {

value = PyList_New(0);

// If we're working on a fixed list, create one which contains

// only Py_None objects. Otherwise the list will be filled with

// <nil> elements.

if( map_p->fixed_list_size > 0 ) {

for( i = 0; i < map_p->fixed_list_size; i++ ) {

PyList_Append(value, Py_None);

}

}

for( i = 0; i < xpo->nodesetval->nodeNr; i++ ) {

char *valstr = NULL;

valstr = (char *) malloc(4098);

dmixml_GetXPathContent(valstr, 4097, xpo, i);

// If we have a fixed list and we have a index value for the list

if( (map_p->fixed_list_size > 0) && (map_p->list_index != NULL) ) {

char *idx = NULL;

idx = dmixml_GetAttrValue(xpo->nodesetval->nodeTab[i],

map_p->list_index);

if( idx != NULL ) {

PyList_SetItem(value, atoi(idx)-1,

StringToPyObj(map_p, valstr)

);

}

} else {

// No list index - append the value

PyList_Append(value, StringToPyObj(map_p, valstr));

}

free(valstr);

}

} else {

value = Py_None;

}

PyADD_DICT_VALUE(retdata, key, value);

xmlXPathFreeObject(xpo);

} else {

PyReturnError(PyExc_ValueError, "Could not get key value: "

"%s [%i] (Defining key: %s)",

map_p->rootpath, elmtid, map_p->key);

}

}

break;

case ptzDICT:

// Traverse children nodes

if( map_p->child == NULL ) {

break;

}

if( _get_key_value(key, 256, map_p, xpctx, 0) == NULL ) {

PyReturnError(PyExc_ValueError,

"Could not get key value: %s [%i] (Defining key: %s)",

map_p->rootpath, elmtid, map_p->key);

}

// Use recursion when procession child elements

value = pythonizeXMLnode(map_p->child, data_n);

PyADD_DICT_VALUE(retdata, key, (value != NULL ? value : Py_None));

break;

case ptzLIST_DICT: // List of dict arrays

if( map_p->child == NULL ) {

break;

}

if( _get_key_value(key, 256, map_p, xpctx, 0) == NULL ) {

PyReturnError(PyExc_ValueError,

"Could not get key value: %s [%i] (Defining key: %s)",

map_p->rootpath, elmtid, map_p->key);

}

// Iterate all nodes which is found in the 'value' XPath

xpo = _get_xpath_values(xpctx, map_p->value);

if( (xpo == NULL) || (xpo->nodesetval == NULL) || (xpo->nodesetval->nodeNr == 0) ) {

if( xpo != NULL ) {

xmlXPathFreeObject(xpo);

}

PyReturnError(PyExc_ValueError,

"Could not get key value: %s [%i] (Defining key: %s)",

map_p->rootpath, elmtid, map_p->key);

}

// Prepare a data list

value = PyList_New(0);

// If we're working on a fixed list, create one which contains

// only Py_None objects. Otherwise the list will be filled with

// <nil> elements.

if( map_p->fixed_list_size > 0 ) {

for( i = 0; i < map_p->fixed_list_size; i++ ) {

PyList_Append(value, Py_None);

}

}

for( i = 0; i < xpo->nodesetval->nodeNr; i++ ) {

PyObject *dataset = NULL;

dataset = pythonizeXMLnode(map_p->child, xpo->nodesetval->nodeTab[i]);

if( dataset != NULL ) {

// If we have a fixed list and we have a index value for the list

if( (map_p->fixed_list_size > 0) && (map_p->list_index != NULL) ) {

char *idx = NULL;

idx = dmixml_GetAttrValue(xpo->nodesetval->nodeTab[i],

map_p->list_index);

if( idx != NULL ) {

PyList_SetItem(value, atoi(idx)-1, dataset);

}

} else {

// No list index - append the value

PyList_Append(value, dataset);

}

} else {

// If NULL, something is wrong - exception is already set.

return NULL;

}

}

PyADD_DICT_VALUE(retdata, key, value);

xmlXPathFreeObject(xpo);

break;

default:

fprintf(stderr, "Unknown value type: %i\n", map_p->type_value);

break;

}

free(key);

xmlXPathFreeContext(xpctx);

xmlFreeDoc(xpdoc);

return retdata;