/*****************************************************************************
函 数 名 : subdesc_node_to_struct
功能描述 : 将xml节点通过map映射到结构体中
输入参数 : ndoe xml节点 map映射表 map_len 映射表大小
输出参数 : date 保存数据
返 回 值 : ERR_SUCCESS成功 其他失败
调用函数 :
被调函数 :
============================================================================
修改历史 :
1.日 期 : 2008年8月26日
修改内容 : 新生成函数
*****************************************************************************/
int subdesc_node_to_struct(xmlNodePtr node, void * data, const SUB_STRUMAP * map, int map_len)
{
xmlAttrPtr attr;
xmlNodePtr child;
int i;
/*分析属性*/
attr = node->properties;
while(NULL != attr)
{
if(attr->type == XML_ATTRIBUTE_NODE)
{
for(i = 0; i< map_len; i++)
{
/*@开头的为属性*/
if('@' == map[i].name[0] &&
0 == strcmp(map[i].name+1, (s8 *)(attr->name)))
{
*((unsigned long *)((unsigned long)data+(unsigned long)map[i].off)) =
(unsigned long)xmlXPathCastNodeToString((xmlNodePtr)attr);
break;
}
}
//属性被省略
//WEB_SEND_DEBUG_ss("undef attr: ", attr->name);
}
attr = attr->next;
}
/*分析内容*/
child = node->children;
while(NULL != child)
{
if(child->type == XML_ELEMENT_NODE)
{
for(i = 0; i< map_len; i++)
{
/*不需要单独检查@*/
if(0 == strcmp(map[i].name, (s8 *)(child->name)))
{
*((unsigned long *)((unsigned long)data+(unsigned long)map[i].off)) =
(unsigned long)xmlXPathCastNodeToString(child);
break;
}
}
//节点被省略
//WEB_SEND_DEBUG_ss("undef node: ", child->name);
}
child = child->next;
}
return ERROR_SUCCESS;
}
int cDataMap::processData(xmlTextReaderPtr reader)
{
// element callback from read_xmlfile
// args: pointer to the xmlTextreader
xmlNodePtr node ;
xmlChar *content;
string value;
int epgdataid;
int retval;
// get name, type and depth in the xml structure
string name = string((char *)xmlTextReaderConstName(reader));
int type = xmlTextReaderNodeType(reader) ;
int depth = xmlTextReaderDepth(reader) ;
// get ca0/ca1 or g0/g1 depending which file we read
if (type == XML_READER_TYPE_ELEMENT && depth == 2 && (name.compare("ca0") == 0)) {
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
epgdataid = atoi((char *)content);
xmlFree(content);
retval = xmlTextReaderNext(reader); // jump to end element
retval = xmlTextReaderNext(reader); // jump to next start element
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
value = string((char *)content);
xmlFree(content);
datamap[epgdataid] = value;
} else if (type == XML_READER_TYPE_ELEMENT && depth == 2 && ( name.compare("g0") == 0 )) {
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
epgdataid = atoi((char *)content);
xmlFree(content);
retval = xmlTextReaderNext(reader); // jump to end element
retval = xmlTextReaderNext(reader); // jump to next start element
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
value = string((char *)content);
xmlFree(content);
datamap[epgdataid] = value;
}
return 0 ;
}
string WebPage::evaluateRegexOnXPath_first(string exp, string xpath, int pos)
{
evaluateXPath(xpath);
if (xpathObj)
{
string flattened;
for (int i = 0; i < xpathObj->nodesetval->nodeNr; i++)
{
xmlChar *strRep = xmlXPathCastNodeToString(xpathObj->nodesetval->nodeTab[i]);
string nodeStr((char*)strRep);
if (!nodeStr.empty())
flattened += nodeStr + string("\n");
xmlFree(strRep);
}
regex rankREGEX(exp);
smatch match;
regex_search(flattened, match, rankREGEX);
if (pos < match.size())
return match[pos].str();
else
return "";
}
else
return "";
}
vector<string> WebPage::evaluateRegexOnXPath(string exp, string xpath)
{
vector<string> rVal;
evaluateXPath(xpath);
if (xpathObj)
{
string flattened;
for (int i = 0; i < xpathObj->nodesetval->nodeNr; i++)
{
xmlChar *strRep = xmlXPathCastNodeToString(xpathObj->nodesetval->nodeTab[i]);
string nodeStr((char*)strRep);
if (!nodeStr.empty())
flattened += nodeStr + string("\n");
xmlFree(strRep);
}
regex rankREGEX(exp);
sregex_iterator it(flattened.begin(), flattened.end(), rankREGEX);
sregex_iterator it_end;
while (it != it_end)
{
rVal.push_back((*it).str());
it++;
}
return rVal;
}
else
return rVal;
}
/**
* exsltStrConcatFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Takes a node set and returns the concatenation of the string values
* of the nodes in that node set. If the node set is empty, it
* returns an empty string.
*/
static void
exsltStrConcatFunction (xmlXPathParserContextPtr ctxt, int nargs) {
xmlXPathObjectPtr obj;
xmlChar *ret = NULL;
int i;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
if (!xmlXPathStackIsNodeSet(ctxt)) {
xmlXPathSetTypeError(ctxt);
return;
}
obj = valuePop (ctxt);
if (xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
xmlXPathReturnEmptyString(ctxt);
return;
}
for (i = 0; i < obj->nodesetval->nodeNr; i++) {
xmlChar *tmp;
tmp = xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
ret = xmlStrcat (ret, tmp);
xmlFree(tmp);
}
xmlXPathFreeObject (obj);
xmlXPathReturnString(ctxt, ret);
}
static void
xsltp_extension_string_join(xmlXPathParserContextPtr ctxt, int nargs) {
xmlChar *ret = NULL, *sep = NULL, *str = NULL;
xmlNodeSetPtr nodeSet = NULL;
int i, j;
if (nargs < 2) {
xmlXPathSetArityError(ctxt);
return;
}
if (xmlXPathStackIsNodeSet(ctxt)) {
xmlXPathSetTypeError(ctxt);
return;
}
sep = xmlXPathPopString(ctxt);
for (i = 1; i < nargs; i++) {
if (!xmlXPathStackIsNodeSet(ctxt)) {
str = xmlXPathPopString(ctxt);
if (i == 1) {
ret = str;
}
else {
str = xmlStrcat(str, sep);
str = xmlStrcat(str, ret);
xmlFree(ret);
ret = str;
}
}
else {
nodeSet = xmlXPathPopNodeSet(ctxt);
if (xmlXPathCheckError(ctxt)) {
xmlXPathSetTypeError(ctxt);
goto fail;
}
for (j = nodeSet->nodeNr - 1; j >= 0; j--) {
str = xmlXPathCastNodeToString(nodeSet->nodeTab[j]);
if (i == 1 && j == (nodeSet->nodeNr - 1)) {
ret = str;
}
else {
str = xmlStrcat(str, sep);
str = xmlStrcat(str, ret);
xmlFree(ret);
ret = str;
}
}
xmlXPathFreeNodeSet(nodeSet);
}
}
xmlXPathReturnString(ctxt, ret);
fail:
if (sep != NULL)
xmlFree(sep);
}
/**
* exsltStrReplaceFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Takes a string, and two node sets and returns the string with all strings in
* the first node set replaced by all strings in the second node set.
*/
static void
exsltStrReplaceFunction (xmlXPathParserContextPtr ctxt, int nargs) {
int i, i_empty, n, slen0, rlen0, *slen, *rlen;
void *mem = NULL;
const xmlChar *src, *start;
xmlChar *string, *search_str = NULL, *replace_str = NULL;
xmlChar **search, **replace;
xmlNodeSetPtr search_set = NULL, replace_set = NULL;
xmlBufferPtr buf;
if (nargs != 3) {
xmlXPathSetArityError(ctxt);
return;
}
/* get replace argument */
if (!xmlXPathStackIsNodeSet(ctxt))
replace_str = xmlXPathPopString(ctxt);
else
replace_set = xmlXPathPopNodeSet(ctxt);
if (xmlXPathCheckError(ctxt))
goto fail_replace;
/* get search argument */
if (!xmlXPathStackIsNodeSet(ctxt)) {
search_str = xmlXPathPopString(ctxt);
n = 1;
}
else {
search_set = xmlXPathPopNodeSet(ctxt);
n = search_set != NULL ? search_set->nodeNr : 0;
}
if (xmlXPathCheckError(ctxt))
goto fail_search;
/* get string argument */
string = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt))
goto fail_string;
/* check for empty search node list */
if (n <= 0) {
exsltStrReturnString(ctxt, string, xmlStrlen(string));
goto done_empty_search;
}
/* allocate memory for string pointer and length arrays */
if (n == 1) {
search = &search_str;
replace = &replace_str;
slen = &slen0;
rlen = &rlen0;
}
else {
mem = xmlMalloc(2 * n * (sizeof(const xmlChar *) + sizeof(int)));
if (mem == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_malloc;
}
search = (xmlChar **) mem;
replace = search + n;
slen = (int *) (replace + n);
rlen = slen + n;
}
/* process arguments */
i_empty = -1;
for (i=0; i<n; ++i) {
if (search_set != NULL) {
search[i] = xmlXPathCastNodeToString(search_set->nodeTab[i]);
if (search[i] == NULL) {
n = i;
goto fail_process_args;
}
}
slen[i] = xmlStrlen(search[i]);
if (i_empty < 0 && slen[i] == 0)
i_empty = i;
if (replace_set != NULL) {
if (i < replace_set->nodeNr) {
replace[i] = xmlXPathCastNodeToString(replace_set->nodeTab[i]);
if (replace[i] == NULL) {
n = i + 1;
goto fail_process_args;
}
}
else
replace[i] = NULL;
}
else {
if (i == 0)
replace[i] = replace_str;
else
replace[i] = NULL;
}
if (replace[i] == NULL)
rlen[i] = 0;
else
rlen[i] = xmlStrlen(replace[i]);
}
if (i_empty >= 0 && rlen[i_empty] == 0)
i_empty = -1;
/* replace operation */
buf = xmlBufferCreate();
if (buf == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_buffer;
}
src = string;
start = string;
while (*src != 0) {
int max_len = 0, i_match = 0;
for (i=0; i<n; ++i) {
if (*src == search[i][0] &&
slen[i] > max_len &&
xmlStrncmp(src, search[i], slen[i]) == 0)
{
i_match = i;
max_len = slen[i];
}
}
if (max_len == 0) {
if (i_empty >= 0 && start < src) {
if (xmlBufferAdd(buf, start, src - start) ||
xmlBufferAdd(buf, replace[i_empty], rlen[i_empty]))
{
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_buffer_add;
}
start = src;
}
src += xmlUTF8Size(src);
}
else {
if ((start < src &&
xmlBufferAdd(buf, start, src - start)) ||
(rlen[i_match] &&
xmlBufferAdd(buf, replace[i_match], rlen[i_match])))
{
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_buffer_add;
}
src += slen[i_match];
start = src;
}
}
if (start < src && xmlBufferAdd(buf, start, src - start)) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_buffer_add;
}
/* create result node set */
exsltStrReturnString(ctxt, xmlBufferContent(buf), xmlBufferLength(buf));
/* clean up */
fail_buffer_add:
xmlBufferFree(buf);
fail_buffer:
fail_process_args:
if (search_set != NULL) {
for (i=0; i<n; ++i)
xmlFree(search[i]);
}
if (replace_set != NULL) {
for (i=0; i<n; ++i) {
if (replace[i] != NULL)
xmlFree(replace[i]);
}
}
if (mem != NULL)
xmlFree(mem);
fail_malloc:
done_empty_search:
xmlFree(string);
fail_string:
if (search_set != NULL)
xmlXPathFreeNodeSet(search_set);
else
xmlFree(search_str);
fail_search:
if (replace_set != NULL)
xmlXPathFreeNodeSet(replace_set);
else
xmlFree(replace_str);
fail_replace:
return;
}
static int
noit_console_config_show(noit_console_closure_t ncct,
int argc, char **argv,
noit_console_state_t *state, void *closure) {
noit_hash_iter iter = NOIT_HASH_ITER_ZERO;
const char *k;
int klen;
void *data;
int i, cnt, titled = 0, cliplen = 0;
const char *path = "", *basepath = NULL;
char xpath[1024];
noit_conf_t_userdata_t *info = NULL;
noit_hash_table *config;
xmlXPathObjectPtr pobj = NULL;
xmlXPathContextPtr xpath_ctxt = NULL, current_ctxt;
xmlDocPtr master_config = NULL;
xmlNodePtr node = NULL;
noit_conf_xml_xpath(&master_config, &xpath_ctxt);
if(argc > 1) {
nc_printf(ncct, "too many arguments\n");
return -1;
}
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
if(info && info->path) path = basepath = info->path;
if(!info && argc == 0) {
nc_printf(ncct, "argument required when not in configuration mode\n");
return -1;
}
if(argc == 1) path = argv[0];
if(!basepath) basepath = path;
/* { / } is a special case */
if(!strcmp(basepath, "/")) basepath = "";
if(!strcmp(path, "/")) path = "";
if(!master_config) {
nc_printf(ncct, "no config\n");
return -1;
}
/* { / } is the only path that will end with a /
* in XPath { / / * } means something _entirely different than { / * }
* Ever notice how it is hard to describe xpath in C comments?
*/
/* We don't want to show the root node */
cliplen = strlen("/noit/");
/* If we are in configuration mode
* and we are without an argument or the argument is absolute,
* clip the current path off */
if(info && (argc == 0 || path[0] != '/')) cliplen += strlen(basepath);
if(!path[0] || path[0] == '/') /* base only, or absolute path requested */
snprintf(xpath, sizeof(xpath), "/noit%s/@*", path);
else
snprintf(xpath, sizeof(xpath), "/noit%s/%s/@*", basepath, path);
current_ctxt = xpath_ctxt;
pobj = xmlXPathEval((xmlChar *)xpath, current_ctxt);
if(!pobj || pobj->type != XPATH_NODESET) {
nc_printf(ncct, "no such object\n");
goto bad;
}
cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
titled = 0;
for(i=0; i<cnt; i++) {
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i);
if(!strcmp((char *)node->name, "check")) continue;
if(node->children && node->children == xmlGetLastChild(node) &&
xmlNodeIsText(node->children)) {
if(!titled++) nc_printf(ncct, "== Section Settings ==\n");
nc_printf(ncct, "%s: %s\n", xmlGetNodePath(node) + cliplen,
xmlXPathCastNodeToString(node->children));
}
}
xmlXPathFreeObject(pobj);
/* Print out all the config settings */
if(!path[0] || path[0] == '/') /* base only, or absolute path requested */
snprintf(xpath, sizeof(xpath), "/noit%s", path);
else
snprintf(xpath, sizeof(xpath), "/noit%s/%s", basepath, path);
pobj = xmlXPathEval((xmlChar *)xpath, current_ctxt);
if(!pobj || pobj->type != XPATH_NODESET) {
nc_printf(ncct, "no such object\n");
goto bad;
}
cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
if(cnt > 0) {
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, 0);
titled = 0;
config = noit_conf_get_hash(node, "config");
while(noit_hash_next(config, &iter, &k, &klen, &data)) {
if(!titled++) nc_printf(ncct, "== Section [Aggregated] Config ==\n");
nc_printf(ncct, "config::%s: %s\n", k, (const char *)data);
}
noit_hash_destroy(config, free, free);
free(config);
}
xmlXPathFreeObject(pobj);
/* _shorten string_ turning last { / @ * } to { / * } */
if(!path[0] || path[0] == '/') /* base only, or absolute path requested */
snprintf(xpath, sizeof(xpath), "/noit%s/*", path);
else
snprintf(xpath, sizeof(xpath), "/noit%s/%s/*", basepath, path);
pobj = xmlXPathEval((xmlChar *)xpath, current_ctxt);
if(!pobj || pobj->type != XPATH_NODESET) {
nc_printf(ncct, "no such object\n");
goto bad;
}
cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
titled = 0;
for(i=0; i<cnt; i++) {
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i);
if(!strcmp((char *)node->name, "check")) continue;
if(!strcmp((char *)node->name, "filterset")) continue;
if(!strcmp((char *)xmlGetNodePath(node) + cliplen, "config")) continue;
if(!(node->children && node->children == xmlGetLastChild(node) &&
xmlNodeIsText(node->children))) {
if(!titled++) nc_printf(ncct, "== Subsections ==\n");
nc_printf(ncct, "%s\n", xmlGetNodePath(node) + cliplen);
}
}
titled = 0;
for(i=0; i<cnt; i++) {
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i);
if(!strcmp((char *)node->name, "filterset")) {
xmlAttr *attr;
char *filter_name = NULL;
for(attr=node->properties; attr; attr = attr->next) {
if(!strcmp((char *)attr->name, "name"))
filter_name = (char *)xmlXPathCastNodeToString(attr->children);
}
if(filter_name) {
nc_printf(ncct, "filterset[@name=\"%s\"]\n", filter_name);
xmlFree(filter_name);
}
else nc_printf(ncct, "fitlerset\n");
}
else if(!strcmp((char *)node->name, "check")) {
int busted = 1;
xmlAttr *attr;
char *uuid_str = "undefined";
if(!titled++) nc_printf(ncct, "== Checks ==\n");
for(attr=node->properties; attr; attr = attr->next) {
if(!strcmp((char *)attr->name, "uuid"))
uuid_str = (char *)xmlXPathCastNodeToString(attr->children);
}
if(uuid_str) {
uuid_t checkid;
nc_printf(ncct, "check[@uuid=\"%s\"] ", uuid_str);
if(uuid_parse(uuid_str, checkid) == 0) {
noit_check_t *check;
check = noit_poller_lookup(checkid);
if(check) {
busted = 0;
nc_printf(ncct, "%s`%s`%s", check->target, check->module, check->name);
}
}
}
else
nc_printf(ncct, "%s ", xmlGetNodePath(node) + cliplen);
if(busted) nc_printf(ncct, "[check not in running system]");
nc_write(ncct, "\n", 1);
}
}
xmlXPathFreeObject(pobj);
return 0;
bad:
if(pobj) xmlXPathFreeObject(pobj);
return -1;
}
/**
* xsltInitCtxtKey:
* @ctxt: an XSLT transformation context
* @idoc: the document information (holds key values)
* @keyDef: the key definition
*
* Computes the key tables this key and for the current input document.
*
* Returns: 0 on success, -1 on error
*/
int
xsltInitCtxtKey(xsltTransformContextPtr ctxt, xsltDocumentPtr idoc,
xsltKeyDefPtr keyDef)
{
int i, len, k;
xmlNodeSetPtr matchList = NULL, keylist;
xmlXPathObjectPtr matchRes = NULL, useRes = NULL;
xmlChar *str = NULL;
xsltKeyTablePtr table;
xmlNodePtr oldInst, cur;
xmlNodePtr oldContextNode;
xsltDocumentPtr oldDocInfo;
int oldXPPos, oldXPSize;
xmlDocPtr oldXPDoc;
int oldXPNsNr;
xmlNsPtr *oldXPNamespaces;
xmlXPathContextPtr xpctxt;
#ifdef KEY_INIT_DEBUG
fprintf(stderr, "xsltInitCtxtKey %s : %d\n", keyDef->name, ctxt->keyInitLevel);
#endif
if ((keyDef->comp == NULL) || (keyDef->usecomp == NULL))
return(-1);
/*
* Detect recursive keys
*/
if (ctxt->keyInitLevel > ctxt->nbKeys) {
#ifdef WITH_XSLT_DEBUG_KEYS
XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,
xsltGenericDebug(xsltGenericDebugContext,
"xsltInitCtxtKey: key definition of %s is recursive\n",
keyDef->name));
#endif
xsltTransformError(ctxt, NULL, keyDef->inst,
"Key definition for %s is recursive\n", keyDef->name);
ctxt->state = XSLT_STATE_STOPPED;
return(-1);
}
ctxt->keyInitLevel++;
xpctxt = ctxt->xpathCtxt;
idoc->nbKeysComputed++;
/*
* Save context state.
*/
oldInst = ctxt->inst;
oldDocInfo = ctxt->document;
oldContextNode = ctxt->node;
oldXPDoc = xpctxt->doc;
oldXPPos = xpctxt->proximityPosition;
oldXPSize = xpctxt->contextSize;
oldXPNsNr = xpctxt->nsNr;
oldXPNamespaces = xpctxt->namespaces;
/*
* Set up contexts.
*/
ctxt->document = idoc;
ctxt->node = (xmlNodePtr) idoc->doc;
ctxt->inst = keyDef->inst;
xpctxt->doc = idoc->doc;
xpctxt->node = (xmlNodePtr) idoc->doc;
/* TODO : clarify the use of namespaces in keys evaluation */
xpctxt->namespaces = keyDef->nsList;
xpctxt->nsNr = keyDef->nsNr;
/*
* Evaluate the 'match' expression of the xsl:key.
* TODO: The 'match' is a *pattern*.
*/
matchRes = xmlXPathCompiledEval(keyDef->comp, xpctxt);
if (matchRes == NULL) {
#ifdef WITH_XSLT_DEBUG_KEYS
XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
"xsltInitCtxtKey: %s evaluation failed\n", keyDef->match));
#endif
xsltTransformError(ctxt, NULL, keyDef->inst,
"Failed to evaluate the 'match' expression.\n");
ctxt->state = XSLT_STATE_STOPPED;
goto error;
} else {
if (matchRes->type == XPATH_NODESET) {
matchList = matchRes->nodesetval;
#ifdef WITH_XSLT_DEBUG_KEYS
if (matchList != NULL)
XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
"xsltInitCtxtKey: %s evaluates to %d nodes\n",
keyDef->match, matchList->nodeNr));
#endif
} else {
/*
* Is not a node set, but must be.
*/
#ifdef WITH_XSLT_DEBUG_KEYS
XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
"xsltInitCtxtKey: %s is not a node set\n", keyDef->match));
#endif
xsltTransformError(ctxt, NULL, keyDef->inst,
"The 'match' expression did not evaluate to a node set.\n");
ctxt->state = XSLT_STATE_STOPPED;
goto error;
}
}
if ((matchList == NULL) || (matchList->nodeNr <= 0))
goto exit;
/**
* Multiple key definitions for the same name are allowed, so
* we must check if the key is already present for this doc
*/
table = (xsltKeyTablePtr) idoc->keys;
while (table != NULL) {
if (xmlStrEqual(table->name, keyDef->name) &&
(((keyDef->nameURI == NULL) && (table->nameURI == NULL)) ||
((keyDef->nameURI != NULL) && (table->nameURI != NULL) &&
(xmlStrEqual(table->nameURI, keyDef->nameURI)))))
break;
table = table->next;
}
/**
* If the key was not previously defined, create it now and
* chain it to the list of keys for the doc
*/
if (table == NULL) {
table = xsltNewKeyTable(keyDef->name, keyDef->nameURI);
if (table == NULL)
goto error;
table->next = idoc->keys;
idoc->keys = table;
}
/*
* SPEC XSLT 1.0 (XSLT 2.0 does not clarify the context size!)
* "...the use attribute of the xsl:key element is evaluated with x as
" the current node and with a node list containing just x as the
* current node list"
*/
xpctxt->contextSize = 1;
xpctxt->proximityPosition = 1;
for (i = 0; i < matchList->nodeNr; i++) {
cur = matchList->nodeTab[i];
if (! IS_XSLT_REAL_NODE(cur))
continue;
xpctxt->node = cur;
/*
* Process the 'use' of the xsl:key.
* SPEC XSLT 1.0:
* "The use attribute is an expression specifying the values of
* the key; the expression is evaluated once for each node that
* matches the pattern."
*/
if (useRes != NULL)
xmlXPathFreeObject(useRes);
useRes = xmlXPathCompiledEval(keyDef->usecomp, xpctxt);
if (useRes == NULL) {
xsltTransformError(ctxt, NULL, keyDef->inst,
"Failed to evaluate the 'use' expression.\n");
ctxt->state = XSLT_STATE_STOPPED;
break;
}
if (useRes->type == XPATH_NODESET) {
if ((useRes->nodesetval != NULL) &&
(useRes->nodesetval->nodeNr != 0))
{
len = useRes->nodesetval->nodeNr;
str = xmlXPathCastNodeToString(useRes->nodesetval->nodeTab[0]);
} else {
continue;
}
} else {
len = 1;
if (useRes->type == XPATH_STRING) {
/*
* Consume the string value.
*/
str = useRes->stringval;
useRes->stringval = NULL;
} else {
str = xmlXPathCastToString(useRes);
}
}
/*
* Process all strings.
*/
k = 0;
while (1) {
if (str == NULL)
goto next_string;
#ifdef WITH_XSLT_DEBUG_KEYS
XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
"xsl:key : node associated to ('%s', '%s')\n", keyDef->name, str));
#endif
keylist = xmlHashLookup(table->keys, str);
if (keylist == NULL) {
keylist = xmlXPathNodeSetCreate(cur);
if (keylist == NULL)
goto error;
xmlHashAddEntry(table->keys, str, keylist);
} else {
/*
* TODO: How do we know if this function failed?
*/
xmlXPathNodeSetAdd(keylist, cur);
}
switch (cur->type) {
case XML_ELEMENT_NODE:
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_PI_NODE:
case XML_COMMENT_NODE:
cur->psvi = keyDef;
break;
case XML_ATTRIBUTE_NODE:
((xmlAttrPtr) cur)->psvi = keyDef;
break;
case XML_DOCUMENT_NODE:
case XML_HTML_DOCUMENT_NODE:
((xmlDocPtr) cur)->psvi = keyDef;
break;
default:
break;
}
xmlFree(str);
str = NULL;
next_string:
k++;
if (k >= len)
break;
str = xmlXPathCastNodeToString(useRes->nodesetval->nodeTab[k]);
}
}
exit:
error:
ctxt->keyInitLevel--;
/*
* Restore context state.
*/
xpctxt->doc = oldXPDoc;
xpctxt->nsNr = oldXPNsNr;
xpctxt->namespaces = oldXPNamespaces;
xpctxt->proximityPosition = oldXPPos;
xpctxt->contextSize = oldXPSize;
ctxt->node = oldContextNode;
ctxt->document = oldDocInfo;
ctxt->inst = oldInst;
if (str)
xmlFree(str);
if (useRes != NULL)
xmlXPathFreeObject(useRes);
if (matchRes != NULL)
xmlXPathFreeObject(matchRes);
return(0);
}
Datum
xpath_table(PG_FUNCTION_ARGS)
{
/* Function parameters */
char *pkeyfield = text_to_cstring(PG_GETARG_TEXT_PP(0));
char *xmlfield = text_to_cstring(PG_GETARG_TEXT_PP(1));
char *relname = text_to_cstring(PG_GETARG_TEXT_PP(2));
char *xpathset = text_to_cstring(PG_GETARG_TEXT_PP(3));
char *condition = text_to_cstring(PG_GETARG_TEXT_PP(4));
/* SPI (input tuple) support */
SPITupleTable *tuptable;
HeapTuple spi_tuple;
TupleDesc spi_tupdesc;
/* Output tuple (tuplestore) support */
Tuplestorestate *tupstore = NULL;
TupleDesc ret_tupdesc;
HeapTuple ret_tuple;
ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
AttInMetadata *attinmeta;
MemoryContext per_query_ctx;
MemoryContext oldcontext;
char **values;
xmlChar **xpaths;
char *pos;
const char *pathsep = "|";
int numpaths;
int ret;
int proc;
int i;
int j;
int rownr; /* For issuing multiple rows from one original
* document */
bool had_values; /* To determine end of nodeset results */
StringInfoData query_buf;
PgXmlErrorContext *xmlerrcxt;
volatile xmlDocPtr doctree = NULL;
/* We only have a valid tuple description in table function mode */
if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("set-valued function called in context that cannot accept a set")));
if (rsinfo->expectedDesc == NULL)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("xpath_table must be called as a table function")));
/*
* We want to materialise because it means that we don't have to carry
* libxml2 parser state between invocations of this function
*/
if (!(rsinfo->allowedModes & SFRM_Materialize))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("xpath_table requires Materialize mode, but it is not "
"allowed in this context")));
/*
* The tuplestore must exist in a higher context than this function call
* (per_query_ctx is used)
*/
per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
oldcontext = MemoryContextSwitchTo(per_query_ctx);
/*
* Create the tuplestore - work_mem is the max in-memory size before a
* file is created on disk to hold it.
*/
tupstore =
tuplestore_begin_heap(rsinfo->allowedModes & SFRM_Materialize_Random,
false, work_mem);
MemoryContextSwitchTo(oldcontext);
/* get the requested return tuple description */
ret_tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
/* must have at least one output column (for the pkey) */
if (ret_tupdesc->natts < 1)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("xpath_table must have at least one output column")));
/*
* At the moment we assume that the returned attributes make sense for the
* XPath specififed (i.e. we trust the caller). It's not fatal if they get
* it wrong - the input function for the column type will raise an error
* if the path result can't be converted into the correct binary
* representation.
*/
attinmeta = TupleDescGetAttInMetadata(ret_tupdesc);
/* Set return mode and allocate value space. */
rsinfo->returnMode = SFRM_Materialize;
rsinfo->setDesc = ret_tupdesc;
values = (char **) palloc(ret_tupdesc->natts * sizeof(char *));
xpaths = (xmlChar **) palloc(ret_tupdesc->natts * sizeof(xmlChar *));
/*
* Split XPaths. xpathset is a writable CString.
*
* Note that we stop splitting once we've done all needed for tupdesc
*/
numpaths = 0;
pos = xpathset;
while (numpaths < (ret_tupdesc->natts - 1))
{
xpaths[numpaths++] = (xmlChar *) pos;
pos = strstr(pos, pathsep);
if (pos != NULL)
{
*pos = '\0';
pos++;
}
else
break;
}
/* Now build query */
initStringInfo(&query_buf);
/* Build initial sql statement */
appendStringInfo(&query_buf, "SELECT %s, %s FROM %s WHERE %s",
pkeyfield,
xmlfield,
relname,
condition);
if ((ret = SPI_connect()) < 0)
elog(ERROR, "xpath_table: SPI_connect returned %d", ret);
if ((ret = SPI_exec(query_buf.data, 0)) != SPI_OK_SELECT)
elog(ERROR, "xpath_table: SPI execution failed for query %s",
query_buf.data);
proc = SPI_processed;
/* elog(DEBUG1,"xpath_table: SPI returned %d rows",proc); */
tuptable = SPI_tuptable;
spi_tupdesc = tuptable->tupdesc;
/* Switch out of SPI context */
MemoryContextSwitchTo(oldcontext);
/*
* Check that SPI returned correct result. If you put a comma into one of
* the function parameters, this will catch it when the SPI query returns
* e.g. 3 columns.
*/
if (spi_tupdesc->natts != 2)
{
ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("expression returning multiple columns is not valid in parameter list"),
errdetail("Expected two columns in SPI result, got %d.", spi_tupdesc->natts)));
}
/*
* Setup the parser. This should happen after we are done evaluating the
* query, in case it calls functions that set up libxml differently.
*/
xmlerrcxt = pgxml_parser_init(PG_XML_STRICTNESS_LEGACY);
PG_TRY();
{
/* For each row i.e. document returned from SPI */
for (i = 0; i < proc; i++)
{
char *pkey;
char *xmldoc;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
xmlChar *resstr;
xmlXPathCompExprPtr comppath;
/* Extract the row data as C Strings */
spi_tuple = tuptable->vals[i];
pkey = SPI_getvalue(spi_tuple, spi_tupdesc, 1);
xmldoc = SPI_getvalue(spi_tuple, spi_tupdesc, 2);
/*
* Clear the values array, so that not-well-formed documents
* return NULL in all columns. Note that this also means that
* spare columns will be NULL.
*/
for (j = 0; j < ret_tupdesc->natts; j++)
values[j] = NULL;
/* Insert primary key */
values[0] = pkey;
/* Parse the document */
if (xmldoc)
doctree = xmlParseMemory(xmldoc, strlen(xmldoc));
else /* treat NULL as not well-formed */
doctree = NULL;
if (doctree == NULL)
{
/* not well-formed, so output all-NULL tuple */
ret_tuple = BuildTupleFromCStrings(attinmeta, values);
tuplestore_puttuple(tupstore, ret_tuple);
heap_freetuple(ret_tuple);
}
else
{
/* New loop here - we have to deal with nodeset results */
rownr = 0;
do
{
/* Now evaluate the set of xpaths. */
had_values = false;
for (j = 0; j < numpaths; j++)
{
ctxt = xmlXPathNewContext(doctree);
ctxt->node = xmlDocGetRootElement(doctree);
/* compile the path */
comppath = xmlXPathCompile(xpaths[j]);
if (comppath == NULL)
xml_ereport(xmlerrcxt, ERROR,
ERRCODE_EXTERNAL_ROUTINE_EXCEPTION,
"XPath Syntax Error");
/* Now evaluate the path expression. */
res = xmlXPathCompiledEval(comppath, ctxt);
xmlXPathFreeCompExpr(comppath);
if (res != NULL)
{
switch (res->type)
{
case XPATH_NODESET:
/* We see if this nodeset has enough nodes */
if (res->nodesetval != NULL &&
rownr < res->nodesetval->nodeNr)
{
resstr = xmlXPathCastNodeToString(res->nodesetval->nodeTab[rownr]);
had_values = true;
}
else
resstr = NULL;
break;
case XPATH_STRING:
resstr = xmlStrdup(res->stringval);
break;
default:
elog(NOTICE, "unsupported XQuery result: %d", res->type);
resstr = xmlStrdup((const xmlChar *) "<unsupported/>");
}
/*
* Insert this into the appropriate column in the
* result tuple.
*/
values[j + 1] = (char *) resstr;
}
xmlXPathFreeContext(ctxt);
}
/* Now add the tuple to the output, if there is one. */
if (had_values)
{
ret_tuple = BuildTupleFromCStrings(attinmeta, values);
tuplestore_puttuple(tupstore, ret_tuple);
heap_freetuple(ret_tuple);
}
rownr++;
} while (had_values);
}
if (doctree != NULL)
xmlFreeDoc(doctree);
doctree = NULL;
if (pkey)
pfree(pkey);
if (xmldoc)
pfree(xmldoc);
}
}
PG_CATCH();
{
if (doctree != NULL)
xmlFreeDoc(doctree);
pg_xml_done(xmlerrcxt, true);
PG_RE_THROW();
}
PG_END_TRY();
if (doctree != NULL)
xmlFreeDoc(doctree);
pg_xml_done(xmlerrcxt, false);
tuplestore_donestoring(tupstore);
SPI_finish();
rsinfo->setResult = tupstore;
/*
* SFRM_Materialize mode expects us to return a NULL Datum. The actual
* tuples are in our tuplestore and passed back through rsinfo->setResult.
* rsinfo->setDesc is set to the tuple description that we actually used
* to build our tuples with, so the caller can verify we did what it was
* expecting.
*/
return (Datum) 0;
}
/*
* Function translates a nodeset into a text representation
*
* iterates over each node in the set and calls xmlNodeDump to write it to
* an xmlBuffer -from which an xmlChar * string is returned.
*
* each representation is surrounded by <tagname> ... </tagname>
*
* plainsep is an ordinary (not tag) separator - if used, then nodes are
* cast to string as output method
*/
static xmlChar *
pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
xmlChar *toptagname,
xmlChar *septagname,
xmlChar *plainsep)
{
xmlBufferPtr buf;
xmlChar *result;
int i;
buf = xmlBufferCreate();
if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0))
{
xmlBufferWriteChar(buf, "<");
xmlBufferWriteCHAR(buf, toptagname);
xmlBufferWriteChar(buf, ">");
}
if (nodeset != NULL)
{
for (i = 0; i < nodeset->nodeNr; i++)
{
if (plainsep != NULL)
{
xmlBufferWriteCHAR(buf,
xmlXPathCastNodeToString(nodeset->nodeTab[i]));
/* If this isn't the last entry, write the plain sep. */
if (i < (nodeset->nodeNr) - 1)
xmlBufferWriteChar(buf, (char *) plainsep);
}
else
{
if ((septagname != NULL) && (xmlStrlen(septagname) > 0))
{
xmlBufferWriteChar(buf, "<");
xmlBufferWriteCHAR(buf, septagname);
xmlBufferWriteChar(buf, ">");
}
xmlNodeDump(buf,
nodeset->nodeTab[i]->doc,
nodeset->nodeTab[i],
1, 0);
if ((septagname != NULL) && (xmlStrlen(septagname) > 0))
{
xmlBufferWriteChar(buf, "</");
xmlBufferWriteCHAR(buf, septagname);
xmlBufferWriteChar(buf, ">");
}
}
}
}
if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0))
{
xmlBufferWriteChar(buf, "</");
xmlBufferWriteCHAR(buf, toptagname);
xmlBufferWriteChar(buf, ">");
}
result = xmlStrdup(buf->content);
xmlBufferFree(buf);
return result;
}
/**
* exsltStrReplaceFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Takes a string, and two node sets and returns the string with all strings in
* the first node set replaced by all strings in the second node set.
*/
static void
exsltStrReplaceFunction (xmlXPathParserContextPtr ctxt, int nargs) {
xmlChar *str = NULL, *searchStr = NULL, *replaceStr = NULL;
xmlNodeSetPtr replaceSet = NULL, searchSet = NULL;
xmlChar *ret = NULL, *retSwap = NULL;
int i;
if (nargs != 3) {
xmlXPathSetArityError(ctxt);
return;
}
/* pull out replace argument */
if (!xmlXPathStackIsNodeSet(ctxt)) {
replaceStr = xmlXPathPopString(ctxt);
}
else {
replaceSet = xmlXPathPopNodeSet(ctxt);
if (xmlXPathCheckError(ctxt)) {
xmlXPathSetTypeError(ctxt);
goto fail;
}
}
/* behavior driven by search argument from here on */
if (!xmlXPathStackIsNodeSet(ctxt)) {
searchStr = xmlXPathPopString(ctxt);
str = xmlXPathPopString(ctxt);
if (replaceStr == NULL) {
xmlXPathSetTypeError(ctxt);
goto fail;
}
ret = exsltStrReplaceInternal(str, searchStr, replaceStr);
}
else {
searchSet = xmlXPathPopNodeSet(ctxt);
if (searchSet == NULL || xmlXPathCheckError(ctxt)) {
xmlXPathSetTypeError(ctxt);
goto fail;
}
str = xmlXPathPopString(ctxt);
ret = xmlStrdup(str);
for (i = 0; i < searchSet->nodeNr; i++) {
searchStr = xmlXPathCastNodeToString(searchSet->nodeTab[i]);
if (replaceSet != NULL) {
replaceStr = NULL;
if (i < replaceSet->nodeNr) {
replaceStr = xmlXPathCastNodeToString(replaceSet->nodeTab[i]);
}
retSwap = exsltStrReplaceInternal(ret, searchStr, replaceStr);
if (replaceStr != NULL) {
xmlFree(replaceStr);
replaceStr = NULL;
}
}
else {
retSwap = exsltStrReplaceInternal(ret, searchStr, replaceStr);
}
xmlFree(ret);
if (searchStr != NULL) {
xmlFree(searchStr);
searchStr = NULL;
}
ret = retSwap;
}
if (replaceSet != NULL)
xmlXPathFreeNodeSet(replaceSet);
if (searchSet != NULL)
xmlXPathFreeNodeSet(searchSet);
}
xmlXPathReturnString(ctxt, ret);
fail:
if (replaceStr != NULL)
xmlFree(replaceStr);
if (searchStr != NULL)
xmlFree(searchStr);
if (str != NULL)
xmlFree(str);
}
static xmlChar
*
pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
xmlChar * toptagname,
xmlChar * septagname,
xmlChar * plainsep)
{
/* Function translates a nodeset into a text representation */
/*
* iterates over each node in the set and calls xmlNodeDump to write it to
* an xmlBuffer -from which an xmlChar * string is returned.
*/
/* each representation is surrounded by <tagname> ... </tagname> */
/*
* plainsep is an ordinary (not tag) seperator - if used, then nodes are
* cast to string as output method
*/
xmlBufferPtr buf;
xmlChar *result;
int i;
buf = xmlBufferCreate();
if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0))
{
xmlBufferWriteChar(buf, "<");
xmlBufferWriteCHAR(buf, toptagname);
xmlBufferWriteChar(buf, ">");
}
if (nodeset != NULL)
{
for (i = 0; i < nodeset->nodeNr; i++)
{
if (plainsep != NULL)
{
xmlBufferWriteCHAR(buf,
xmlXPathCastNodeToString(nodeset->nodeTab[i]));
/* If this isn't the last entry, write the plain sep. */
if (i < (nodeset->nodeNr) - 1)
xmlBufferWriteChar(buf, plainsep);
}
else
{
if ((septagname != NULL) && (xmlStrlen(septagname) > 0))
{
xmlBufferWriteChar(buf, "<");
xmlBufferWriteCHAR(buf, septagname);
xmlBufferWriteChar(buf, ">");
}
xmlNodeDump(buf,
nodeset->nodeTab[i]->doc,
nodeset->nodeTab[i],
1, 0);
if ((septagname != NULL) && (xmlStrlen(septagname) > 0))
{
xmlBufferWriteChar(buf, "</");
xmlBufferWriteCHAR(buf, septagname);
xmlBufferWriteChar(buf, ">");
}
}
}
}
if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0))
{
xmlBufferWriteChar(buf, "</");
xmlBufferWriteCHAR(buf, toptagname);
xmlBufferWriteChar(buf, ">");
}
result = xmlStrdup(buf->content);
xmlBufferFree(buf);
return result;
}