experiments/clixon
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
clixon/lib/src/clixon_xsl.c
Olof Hagsand 9a52cfecf6 variable arg lists for xpath functions
2016-12-18 09:27:42 +00:00

1054 lines
26 KiB
C
Raw Blame History

/*
*
Copyright (C) 2009-2016 Olof Hagsand and Benny Holmgren
This file is part of CLIXON.
CLIXON is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
CLIXON 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with CLIXON; see the file LICENSE. If not, see
<http://www.gnu.org/licenses/>.
* Limited XML XPATH and XSLT functions.
* NOTE: there is a main function at the end of this file where you can test out
* different xpath expressions.
* Look at the end of the file for a test unit program
*/
/*
https://www.w3.org/TR/xpath/
Implementation of a limited xslt xpath syntax. Some examples. Given the following
xml tree:
<aaa>
<bbb x="hello"><ccc>42</ccc></bbb>
<bbb x="bye"><ccc>99</ccc></bbb>
<ddd><ccc>22</ccc></ddd>
</aaa>
With the following xpath examples. There are some diffs and many limitations compared
to the xml standards:
/ whole tree <aaa>...</aaa>
/bbb
/aaa/bbb <bbb x="hello"><ccc>42</ccc></bbb>
<bbb x="bye"><ccc>99</ccc></bbb>
//bbb as above
//b?b as above
//b\* as above
//b\*\/ccc <ccc>42</ccc>
<ccc>99</ccc>
//\*\/ccc <ccc>42</ccc>
<ccc>99</ccc>
<ccc>22</ccc>
-- //bbb@x x="hello"
//bbb[@x] <bbb x="hello"><ccc>42</ccc></bbb>
<bbb x="bye"><ccc>99</ccc></bbb>
//bbb[@x=hello] <bbb x="hello"><ccc>42</ccc></bbb>
//bbb[@x="hello"] as above
//bbb[0] <bbb x="hello"><ccc>42</ccc></bbb>
//bbb[ccc=99] <bbb x="bye"><ccc>99</ccc></bbb>
--- //\*\/[ccc=99] same as above
'//bbb | //ddd' <bbb><ccc>42</ccc></bbb>
<bbb x="hello"><ccc>99</ccc></bbb>
<ddd><ccc>22</ccc></ddd> (NB spaces)
etc
For xpath v1.0 see http://www.w3.org/TR/xpath/
record[name=c][time=d]
in
<record>
<name>c</name>
<time>d</time>
<userid>45654df4-2292-45d3-9ca5-ee72452568a8</userid>
</record>
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <limits.h>
#include <fnmatch.h>
#include <stdint.h>
#include <assert.h>
/* cligen */
#include <cligen/cligen.h>
/* clicon */
#include "clixon_err.h"
#include "clixon_log.h"
#include "clixon_xml.h"
#include "clixon_xsl.h"
/* Constants */
#define XPATH_VEC_START 128
/*
* Types
*/
struct searchvec{
cxobj **sv_v0; /* here is result */
int sv_v0len;
cxobj **sv_v1; /* this is tmp storage */
int sv_v1len;
int sv_max;
};
typedef struct searchvec searchvec;
/* Local types
*/
enum axis_type{
A_SELF,
A_CHILD,
A_PARENT,
A_ROOT,
A_ANCESTOR,
A_DESCENDANT_OR_SELF, /* actually descendant-or-self */
};
struct map_str2int{
char *ms_str; /* string as in 4.2.4 in RFC 6020 */
int ms_int;
};
/* Mapping between axis type string <--> int */
static const struct map_str2int atmap[] = {
{"self", A_SELF},
{"child", A_CHILD},
{"parent", A_PARENT},
{"root", A_ROOT},
{"ancestor", A_ANCESTOR},
{"descendant-or-self", A_DESCENDANT_OR_SELF},
{NULL, -1}
};
struct xpath_predicate{
struct xpath_predicate *xp_next;
char *xp_expr;
};
struct xpath_element{
struct xpath_element *xe_next;
enum axis_type xe_type;
char *xe_str; /* eg for child */
struct xpath_predicate *xe_predicate; /* eg within [] */
};
static int xpath_split(char *xpathstr, char **pathexpr);
static char *axis_type2str(enum axis_type type) __attribute__ ((unused));
static char *
axis_type2str(enum axis_type type)
{
const struct map_str2int *at;
for (at = &atmap[0]; at->ms_str; at++)
if (at->ms_int == type)
return at->ms_str;
return NULL;
}
static int
xpath_print(FILE *f, struct xpath_element *xplist)
{
struct xpath_element *xe;
struct xpath_predicate *xp;
for (xe=xplist; xe; xe=xe->xe_next){
fprintf(f, "\t:%s %s ", axis_type2str(xe->xe_type),
xe->xe_str?xe->xe_str:"");
for (xp=xe->xe_predicate; xp; xp=xp->xp_next)
fprintf(f, "[%s]", xp->xp_expr);
}
return 0;
}
static int
xpath_parse_predicate(struct xpath_element *xe,
char *pred)
{
int retval = -1;
struct xpath_predicate *xp;
char *s;
int i;
int len;
len = strlen(pred);
for (i=len-2; i>=0; i--){ /* -2 since we search for ][ */
s = &pred[i];
if (i==0 ||
(*(s)==']' && *(s+1)=='[')){
if (i) {
*(s)= '\0';
s += 2;
}
if ((xp = malloc(sizeof(*xp))) == NULL){
clicon_err(OE_UNIX, errno, "malloc");
goto done;
}
memset(xp, 0, sizeof(*xp));
if ((xp->xp_expr = strdup(s)) == NULL){
clicon_err(OE_XML, errno, "%s: strdup", __FUNCTION__);
goto done;
}
xp->xp_next = xe->xe_predicate;
xe->xe_predicate = xp;
}
}
retval = 0;
done:
return retval;
}
static int
xpath_element_new(enum axis_type atype,
char *str,
struct xpath_element ***xpnext)
{
int retval = -1;
struct xpath_element *xe;
char *str1 = NULL;
char *pred;
if ((xe = malloc(sizeof(*xe))) == NULL){
clicon_err(OE_UNIX, errno, "malloc");
goto done;
}
memset(xe, 0, sizeof(*xe));
xe->xe_type = atype;
if (str){
if ((str1 = strdup(str)) == NULL){
clicon_err(OE_XML, errno, "%s: strdup", __FUNCTION__);
goto done;
}
if (xpath_split(str1, &pred) < 0) /* Can be more predicates */
goto done;
if (strlen(str1)){
if ((xe->xe_str = strdup(str1)) == NULL){
clicon_err(OE_XML, errno, "%s: strdup", __FUNCTION__);
goto done;
}
}
else{
if ((xe->xe_str = strdup("*")) == NULL){
clicon_err(OE_XML, errno, "%s: strdup", __FUNCTION__);
goto done;
}
}
if (pred && strlen(pred)){
if (xpath_parse_predicate(xe, pred) < 0)
goto done;
}
}
(**xpnext) = xe;
*xpnext = &xe->xe_next;
retval = 0;
done:
if (str1)
free(str1);
return retval;
}
static int
xpath_element_free(struct xpath_element *xe)
{
struct xpath_predicate *xp;
if (xe->xe_str)
free(xe->xe_str);
while ((xp = xe->xe_predicate) != NULL){
xe->xe_predicate = xp->xp_next;
if (xp->xp_expr)
free(xp->xp_expr);
free(xp);
}
free(xe);
return 0;
}
static int
xpath_free(struct xpath_element *xplist)
{
struct xpath_element *xe, *xe_next;
for (xe=xplist; xe; xe=xe_next){
xe_next = xe->xe_next;
xpath_element_free(xe);
}
return 0;
}
/*
* // is short for /descendant-or-self::node()/
*/
static int
xpath_parse(char *xpath,
struct xpath_element **xplist0)
{
int retval = -1;
int nvec = 0;
char *p;
char *s;
char *s0;
int i;
struct xpath_element *xplist = NULL;
struct xpath_element **xpnext = &xplist;
if ((s0 = strdup(xpath)) == NULL){
clicon_err(OE_XML, errno, "%s: strdup", __FUNCTION__);
goto done;
}
s = s0;
if (strlen(s))
nvec = 1;
while ((p = index(s, '/')) != NULL){
nvec++;
*p = '\0';
s = p+1;
}
s = s0;
for (i=0; i<nvec; i++){
if ((i==0 && strcmp(s,"")==0)) /* Initial / or // */
xpath_element_new(A_ROOT, NULL, &xpnext);
else if (i!=nvec-1 && strcmp(s,"")==0)
xpath_element_new(A_DESCENDANT_OR_SELF, NULL, &xpnext);
else if (strncmp(s,"descendant-or-self::", strlen("descendant-or-self::"))==0){
xpath_element_new(A_DESCENDANT_OR_SELF, s+strlen("descendant-or-self::"), &xpnext);
}
else if (strncmp(s,".", strlen("."))==0)
xpath_element_new(A_SELF, s+strlen("."), &xpnext);
else if (strncmp(s,"self::", strlen("self::"))==0)
xpath_element_new(A_SELF, s+strlen("self::"), &xpnext);
else if (strncmp(s,"..", strlen(".."))==0)
xpath_element_new(A_PARENT, s+strlen(".."), &xpnext);
else if (strncmp(s,"parent::", strlen("parent::"))==0)
xpath_element_new(A_PARENT, s+strlen("parent::"), &xpnext);
else if (strncmp(s,"ancestor::", strlen("ancestor::"))==0)
xpath_element_new(A_ANCESTOR, s+strlen("ancestor::"), &xpnext);
else if (strncmp(s,"child::", strlen("child::"))==0)
xpath_element_new(A_CHILD, s+strlen("child::"), &xpnext);
else
xpath_element_new(A_CHILD, s, &xpnext);
s += strlen(s) + 1;
}
retval = 0;
done:
if (s0)
free(s0);
if (retval == 0)
*xplist0 = xplist;
return retval;
}
/*! Find a node 'deep' in an XML tree
*
* The xv_* arguments are filled in nodes found earlier.
* args:
* @param[in] xn_parent Base XML object
* @param[in] name shell wildcard pattern to match with node name
* @param[in] node_type CX_ELMNT, CX_ATTR or CX_BODY
* @param[in,out] vec1 internal buffers with results
* @param[in,out] vec0 internal buffers with results
* @param[in,out] vec_len internal buffers with length of vec0,vec1
* @param[in,out] vec_max internal buffers with max of vec0,vec1
* returns:
* 0 on OK, -1 on error
*/
static int
recursive_find(cxobj *xn,
char *pattern,
int node_type,
uint16_t flags,
cxobj ***vec0,
size_t *vec0len)
{
int retval = -1;
cxobj *xsub;
cxobj **vec = *vec0;
size_t veclen = *vec0len;
xsub = NULL;
while ((xsub = xml_child_each(xn, xsub, node_type)) != NULL) {
if (fnmatch(pattern, xml_name(xsub), 0) == 0){
clicon_debug(2, "%s %x %x", __FUNCTION__, flags, xml_flag(xsub, flags));
if (flags==0x0 || xml_flag(xsub, flags))
if (cxvec_append(xsub, &vec, &veclen) < 0)
goto done;
// continue; /* Dont go deeper */
}
if (recursive_find(xsub, pattern, node_type, flags, &vec, &veclen) < 0)
goto done;
}
retval = 0;
*vec0 = vec;
*vec0len = veclen;
done:
return retval;
}
/*! XPath predicate expression check
* @param[in] predicate_expression xpath expression as a string
* @param[in] flags Extra xml flag checks that must match (apart from predicate)
* @param[in,out] vec0 Vector or xml nodes that are checked. Not matched are filtered
* @param[in,out] vec0len Length of vector or matches
* On input, vec0 contains a list of xml nodes to match.
* On output, vec0 contains only the subset that matched the expression.
* The predicate expression is a subset of the standard, namely:
* - @<attr>=<value>
* - <number>
* - <name>=<value>
* @see https://www.w3.org/TR/xpath/#predicates
*/
static int
xpath_expr(char *predicate_expression,
uint16_t flags,
cxobj ***vec0,
size_t *vec0len)
{
char *e_a;
char *e_v;
int i;
int retval = -1;
cxobj *x;
cxobj *xv;
cxobj **vec = NULL;
size_t veclen = 0;
int oplen;
char *tag;
char *val;
char *e0;
char *e;
if ((e0 = strdup(predicate_expression)) == NULL){
clicon_err(OE_UNIX, errno, "strdup");
goto done;
}
e = e0;
if (*e == '@'){ /* @ attribute */
e++;
e_v=e;
e_a = strsep(&e_v, "=");
if (e_a == NULL){
clicon_err(OE_XML, errno, "%s: malformed expression: [@%s]",
__FUNCTION__, e);
goto done;
}
for (i=0; i<*vec0len; i++){
xv = (*vec0)[i];
if ((x = xml_find(xv, e_a)) != NULL &&
(xml_type(x) == CX_ATTR)){
if (!e_v || strcmp(xml_value(x), e_v) == 0){
clicon_debug(2, "%s %x %x", __FUNCTION__, flags, xml_flag(xv, flags));
if (flags==0x0 || xml_flag(xv, flags)){
if (cxvec_append(xv, &vec, &veclen) < 0)
goto done;
break; /* xv added */
}
}
}
}
}
else{ /* either <n> or <tag><op><value>, where <op>='=' for now */
oplen = strcspn(e, "=");
if (strlen(e+oplen)==0){ /* no operator */
if (sscanf(e, "%d", &i) == 1){ /* number */
if (i < *vec0len){
xv = (*vec0)[i]; /* XXX: cant compress: gcc breaks */
clicon_debug(2, "%s %x %x", __FUNCTION__, flags, xml_flag(xv, flags));
if (flags==0x0 || xml_flag(xv, flags))
if (cxvec_append(xv, &vec, &veclen) < 0)
goto done;
}
}
else{
clicon_err(OE_XML, errno, "%s: malformed expression: [%s]",
__FUNCTION__, e);
goto done;
}
}
else{
if ((tag = strsep(&e, "=")) == NULL){
clicon_err(OE_XML, errno, "%s: malformed expression: [%s]",
__FUNCTION__, e);
goto done;
}
for (i=0; i<*vec0len; i++){
xv = (*vec0)[i];
/* Check if more may match,... */
x = NULL;
while ((x = xml_child_each(xv, x, CX_ELMNT)) != NULL) {
if (strcmp(tag, xml_name(x)) != 0)
continue;
if ((val = xml_body(x)) != NULL &&
strcmp(val, e) == 0){
clicon_debug(2, "%s %x %x", __FUNCTION__, flags, xml_flag(xv, flags));
if (flags==0x0 || xml_flag(xv, flags))
if (cxvec_append(xv, &vec, &veclen) < 0)
goto done;
}
}
}
}
}
/* copy the array from 1 to 0 */
free(*vec0);
*vec0 = vec;
*vec0len = veclen;
retval = 0;
done:
if (e0)
free(e0);
return retval;
}
/*! Given vec0, add matches to vec1
* @param[in] xe XPATH in structured (parsed) form
* @param[in] descendants0
* @param[in] vec0 vector of XML trees
* @param[in] vec0len length of XML trees
* @param[in] flags if != 0, only match xml nodes matching flags
* @param[out] vec2 Result XML node vector
* @param[out] vec2len Length of result vector.
* XXX: Kommer in i funktionen med vec0, resultatet appendas i vec1
* vec0 --> vec
* Det <20>r nog bra om vec0 inte <20>ndras, <20>r input parameter
* Vid utg<74>ng ska vec1 inneh<65>lla resultatet.
* Internt d<>?
* XXX: hantering av (input)vec0-->vec-->vec2-->vec1 (resultat)
*/
static int
xpath_find(struct xpath_element *xe,
int descendants0,
cxobj **vec0,
size_t vec0len,
uint16_t flags,
cxobj ***vec2,
size_t *vec2len
)
{
int retval = -1;
int i;
int j;
cxobj *x = NULL;
cxobj *xv;
int descendants = 0;
cxobj **vec1 = NULL;
size_t vec1len = 0;
struct xpath_predicate *xp;
if (xe == NULL){
/* append */
for (i=0; i<vec0len; i++){
xv = vec0[i];
clicon_debug(2, "%s %x %x", __FUNCTION__, flags, xml_flag(xv, flags));
if (flags==0x0 || xml_flag(xv, flags))
cxvec_append(xv, vec2, vec2len);
}
free(vec0);
return 0;
}
#if 0
fprintf(stderr, "%s: %s: \"%s\"\n", __FUNCTION__,
axis_type2str(xe->xe_type), xe->xe_str?xe->xe_str:"");
#endif
switch (xe->xe_type){
case A_SELF:
break;
case A_PARENT:
for (i=0; i<vec0len; i++){
xv = vec0[i];
vec0[i] = xml_parent(xv);
}
break;
case A_ROOT: /* set list to NULL */
x = vec0[0];
assert(x != NULL);
while (xml_parent(x) != NULL)
x = xml_parent(x);
free(vec0);
if ((vec0 = calloc(1, sizeof(cxobj *))) == NULL){
clicon_err(OE_UNIX, errno, "calloc");
goto done;
}
vec0[0] = x;
vec0len = 1;
break;
case A_CHILD:
if (descendants0){
for (i=0; i<vec0len; i++){
xv = vec0[i];
if (recursive_find(xv, xe->xe_str, CX_ELMNT, flags, &vec1, &vec1len) < 0)
goto done;
}
}
else
for (i=0; i<vec0len; i++){
xv = vec0[i];
x = NULL;
while ((x = xml_child_each(xv, x, -1)) != NULL) {
if (fnmatch(xe->xe_str, xml_name(x), 0) == 0){
clicon_debug(2, "%s %x %x", __FUNCTION__, flags, xml_flag(x, flags));
if (flags==0x0 || xml_flag(x, flags))
if (cxvec_append(x, &vec1, &vec1len) < 0)
goto done;
}
}
}
free(vec0);
vec0 = vec1;
vec0len = vec1len;
break;
case A_DESCENDANT_OR_SELF:
/* Instead of collecting all descendants (which we could)
just set a flag and treat that in the next operation */
descendants++;
break;
default:
break;
}
/* remove duplicates */
for (i=0; i<vec0len; i++){
for (j=i+1; j<vec0len; j++){
if (vec0[i] == vec0[j]){
memmove(vec0[j], vec0[j+1], (vec0len-j)*sizeof(cxobj*));
vec0len--;
}
}
}
for (xp = xe->xe_predicate; xp; xp = xp->xp_next){
if (xpath_expr(xp->xp_expr, flags, &vec0, &vec0len) < 0)
goto done;
}
if (xpath_find(xe->xe_next, descendants,
vec0, vec0len, flags,
vec2, vec2len) < 0)
goto done;
retval = 0;
done:
return retval;
}
/*! Transform eg "a/b[kalle]" -> "a/b" e="kalle"
* @param[in,out] xpathstr Eg "a/b[kalle]" -> "a/b"
* @param[out] pathexpr Eg "kalle"
* Which also means:
* "a/b[foo][bar]" -> pathexpr: "foo][bar"
* @note destructively modify xpathstr, no new strings allocated
*/
static int
xpath_split(char *xpathstr,
char **pathexpr)
{
int retval = -1;
int last;
char *pe = NULL;
if (strlen(xpathstr)){
last = strlen(xpathstr) - 1; /* XXX: this could be -1.. */
if (xpathstr[last] == ']'){
xpathstr[last] = '\0';
if (strlen(xpathstr)){
if ((pe = index(xpathstr,'[')) != NULL){
*pe = '\0';
pe++;
}
}
if (pe==NULL){
clicon_err(OE_XML, errno, "%s: mismatched []: %s", __FUNCTION__, xpathstr);
goto done;
}
}
}
retval = 0;
done:
*pathexpr = pe;
return retval;
}
/*! Process single xpath expression on xml tree
* @param[in] xpath string with XPATH syntax
* @param[in] vec0 vector of XML trees
* @param[in] vec0len length of XML trees
* @param[in] flags if != 0, only match xml nodes matching flags
* @param[out] vec2 Result XML node vector
* @param[out] vec2len Length of result vector.
*/
static int
xpath_exec(char *xpath,
cxobj **vec0,
size_t vec0len,
uint16_t flags,
cxobj ***vec2,
size_t *vec2len)
{
struct xpath_element *xplist;
cxobj **vec1;
size_t vec1len;
if (cxvec_dup(vec0, vec0len, &vec1, &vec1len) < 0)
goto done;
if (xpath_parse(xpath, &xplist) < 0)
goto done;
if (debug > 1)
xpath_print(stderr, xplist);
if (xpath_find(xplist, 0, vec1, vec1len, flags, vec2, vec2len) < 0)
goto done;
if (xpath_free(xplist) < 0)
goto done;
done:
return 0;
} /* xpath_exec */
/*! Intermediate xpath function to handle 'conditional' cases.
* For example: xpath = //a | //b.
* xpath_first+ splits xpath up in several subcalls
* (eg xpath=//a and xpath=//b) and collects the results.
* Note: if a match is found in both, two (or more) same results will be
* returned.
* Note, this could be 'folded' into xpath1 but I judged it too complex.
*/
static int
xpath_choice(cxobj *xtop,
char *xpath0,
uint16_t flags,
cxobj ***vec1,
size_t *vec1len)
{
int retval = -1;
char *s0;
char *s1;
char *s2;
char *xpath;
cxobj **vec0 = NULL;
size_t vec0len = 0;
if ((s0 = strdup(xpath0)) == NULL){
clicon_err(OE_XML, errno, "%s: strdup", __FUNCTION__);
goto done;
}
s2 = s1 = s0;
if ((vec0 = calloc(1, sizeof(cxobj *))) == NULL){
clicon_err(OE_UNIX, errno, "calloc");
goto done;
}
vec0[0] = xtop;
vec0len++;
while (s1 != NULL){
s2 = strstr(s1, " | ");
if (s2 != NULL){
*s2 = '\0'; /* terminate xpath */
s2 += 3;
}
xpath = s1;
s1 = s2;
if (xpath_exec(xpath, vec0, vec0len, flags, vec1, vec1len) < 0)
goto done;
}
retval = 0;
done:
if (s0)
free(s0);
if (vec0)
free(vec0);
return retval;
}
static cxobj *
xpath_first0(cxobj *cxtop,
char *xpath)
{
cxobj **vec0 = NULL;
size_t vec0len = 0;
cxobj *xn = NULL;
if (xpath_choice(cxtop, xpath, 0, &vec0, &vec0len) < 0)
goto done;
if (vec0len)
xn = vec0[0];
else
xn = NULL;
done:
if (vec0)
free(vec0);
return xn;
}
/*! A restricted xpath function where the first matching entry is returned
* See xpath1() on details for subset.
* args:
* @param[in] cxtop xml-tree where to search
* @param[in] xpath string with XPATH syntax
* @retval xml-tree of first match, or NULL on error.
*
* @code
* cxobj *x;
* if ((x = xpath_first(xtop, "//symbol/foo")) != NULL) {
* ...
* }
* @endcode
* Note that the returned pointer points into the original tree so should not be freed
* after use.
* @see also xpath_vec.
*/
cxobj *
xpath_first(cxobj *cxtop,
char *format,
...)
{
cxobj *retval = NULL;
va_list ap;
size_t len;
char *xpath;
va_start(ap, format);
len = vsnprintf(NULL, 0, format, ap);
va_end(ap);
/* allocate a message string exactly fitting the message length */
if ((xpath = malloc(len+1)) == NULL){
clicon_err(OE_UNIX, errno, "malloc");
goto done;
}
/* second round: compute write message from reason and args */
va_start(ap, format);
if (vsnprintf(xpath, len+1, format, ap) < 0){
clicon_err(OE_UNIX, errno, "vsnprintf");
va_end(ap);
goto done;
}
va_end(ap);
retval = xpath_first0(cxtop, xpath);
done:
if (xpath)
free(xpath);
return retval;
}
/*! A restricted xpath iterator that loops over all matching entries. Dont use.
*
* See xpath1() on details for subset.
* @param[in] cxtop xml-tree where to search
* @param[in] xpath string with XPATH syntax
* @param[in] xprev iterator/result should be initiated to NULL
* @retval xml-tree of n:th match, or NULL on error.
*
* @code
* cxobj *x = NULL;
* while ((x = xpath_each(cxtop, "//symbol/foo", x)) != NULL) {
* ...
* }
* @endcode
*
* Note that the returned pointer points into the original tree so should not be freed
* after use.
* @see also xpath, xpath_vec.
* NOTE: uses a static variable: consider replacing with xpath_vec() instead
*/
cxobj *
xpath_each(cxobj *cxtop,
char *xpath,
cxobj *xprev)
{
static cxobj **vec0 = NULL; /* XXX */
static size_t vec0len = 0;
cxobj *xn = NULL;
int i;
if (xprev == NULL){
if (vec0) // XXX
free(vec0); // XXX
vec0len = 0;
if (xpath_choice(cxtop, xpath, 0, &vec0, &vec0len) < 0)
goto done;
}
if (vec0len){
if (xprev==NULL)
xn = vec0[0];
else{
for (i=0; i<vec0len; i++)
if (vec0[i] == xprev)
break;
if (i>=vec0len-1)
xn = NULL;
else
xn = vec0[i+1];
}
}
else
xn = NULL;
done:
return xn;
}
/*! A restricted xpath that returns a vector of matches
*
* See xpath1() on details for subset.
* @param[in] cxtop xml-tree where to search
* @param[in] xpath string with XPATH syntax
* @param[out] vec vector of xml-trees. Vector must be free():d after use
* @param[out] veclen returns length of vector in return value
* @retval 0 OK
* @retval -1 error.
*
* @code
* cxobj **vec;
* size_t veclen;
* if (xpath_vec(cxtop, "//symbol/foo", &vec, &veclen) < 0)
* got err;
* for (i=0; i<veclen; i++){
* xn = vec[i];
* ...
* }
* free(vec);
* @endcode
* Note that although the returned vector must be freed after use, the returned xml
* trees need not be.
* @see also xpath_first, xpath_each.
*/
int
xpath_vec(cxobj *cxtop,
char *format,
cxobj ***vec,
size_t *veclen,
...)
{
int retval = -1;
va_list ap;
size_t len;
char *xpath;
va_start(ap, veclen);
len = vsnprintf(NULL, 0, format, ap);
va_end(ap);
/* allocate a message string exactly fitting the message length */
if ((xpath = malloc(len+1)) == NULL){
clicon_err(OE_UNIX, errno, "malloc");
goto done;
}
/* second round: compute write message from reason and args */
va_start(ap, veclen);
if (vsnprintf(xpath, len+1, format, ap) < 0){
clicon_err(OE_UNIX, errno, "vsnprintf");
va_end(ap);
goto done;
}
va_end(ap);
*vec = NULL;
*veclen = 0;
retval = xpath_choice(cxtop, xpath, 0x0, vec, veclen);
done:
if (xpath)
free(xpath);
return retval;
}
/* A restricted xpath that returns a vector of matches (only nodes marked with flags)
* @param[in] flags Set of flags that return nodes must match (0 if all)
*/
int
xpath_vec_flag(cxobj *cxtop,
char *format,
uint16_t flags,
cxobj ***vec,
size_t *veclen,
...)
{
int retval = -1;
va_list ap;
size_t len;
char *xpath;
va_start(ap, veclen);
len = vsnprintf(NULL, 0, format, ap);
va_end(ap);
/* allocate a message string exactly fitting the message length */
if ((xpath = malloc(len+1)) == NULL){
clicon_err(OE_UNIX, errno, "malloc");
goto done;
}
/* second round: compute write message from reason and args */
va_start(ap, veclen);
if (vsnprintf(xpath, len+1, format, ap) < 0){
clicon_err(OE_UNIX, errno, "vsnprintf");
va_end(ap);
goto done;
}
va_end(ap);
*vec=NULL;
*veclen = 0;
retval = xpath_choice(cxtop, xpath, flags, vec, veclen);
done:
if (xpath)
free(xpath);
return retval;
}
/*
* Turn this on to get an xpath test program
* Usage: xpath [<xpath>]
* read xml from input
* Example compile:
gcc -g -o xpath -I. -I../clixon ./clixon_xsl.c -lclixon -lcligen
* Example run:
echo "<a><b/></a>" | xpath "a"
*/
#if 0 /* Test program */
static int
usage(char *argv0)
{
fprintf(stderr, "usage:%s <xpath>.\n\tInput on stdin\n", argv0);
exit(0);
}
int
main(int argc, char **argv)
{
int i;
cxobj **xv;
cxobj *x;
cxobj *xn;
size_t xlen = 0;
if (argc != 2){
usage(argv[0]);
return 0;
}
if (clicon_xml_parse_file(0, &x, "</clicon>") < 0){
fprintf(stderr, "parsing 2\n");
return -1;
}
printf("\n");
if (xpath_vec(x, argv[1], &xv, &xlen) < 0)
return -1;
if (xv){
for (i=0; i<xlen; i++){
xn = xv[i];
fprintf(stdout, "[%d]:\n", i);
clicon_xml2file(stdout, xn, 0, 1);
}
free(xv);
}
if (x)
xml_free(x);
return 0;
}
#endif /* Test program */
Reference in a new issue View git blame Copy permalink