int xslDbgShellCat(xsltTransformContextPtr styleCtxt, xmlShellCtxtPtr ctxt, xmlChar * arg) { xmlXPathObjectPtr list; int result = 0; static const char * QUIET_STR = "-q"; bool silenceCtxtErrors = false; if ((arg == NULL) || (xmlStrLen(arg) == 0)) arg = (xmlChar *) "."; /* Do we quietly ingore style context errors */ if (strncasecmp((char*)arg, QUIET_STR, strlen(QUIET_STR))== 0){ silenceCtxtErrors = true; arg = arg + strlen(QUIET_STR); while (isspace(*arg)){ arg++; } } if (!styleCtxt || !ctxt || !ctxt->node) { if (!(!xsldbgReachedFirstTemplate && silenceCtxtErrors)) xsldbgGenericErrorFunc(i18n("Warning: Unable to print expression. No stylesheet was properly loaded.\n")); return 0; } if ((arg == NULL) || (xmlStrLen(arg) == 0)) arg = (xmlChar *) "."; ctxt->pctxt->node = ctxt->node; if (!styleCtxt) { list = xmlXPathEval((xmlChar *) arg, ctxt->pctxt); } else { xmlNodePtr savenode = styleCtxt->xpathCtxt->node; ctxt->pctxt->node = ctxt->node; styleCtxt->xpathCtxt->node = ctxt->node; if (!xmlXPathNsLookup(styleCtxt->xpathCtxt, (xmlChar *) "xsl")) xmlXPathRegisterNs(styleCtxt->xpathCtxt, (xmlChar *) "xsl", XSLT_NAMESPACE); list = xmlXPathEval((xmlChar *) arg, styleCtxt->xpathCtxt); styleCtxt->xpathCtxt->node = savenode; } if (list != NULL) { result = printXPathObject(list, arg); xmlXPathFreeObject(list); } else { xsldbgGenericErrorFunc(i18n("Error: XPath %1 results in an empty Node Set.\n").arg(xsldbgText(arg))); } ctxt->pctxt->node = NULL; return result; }
const char * config_get_value(const char * _xpath) { xmlXPathObjectPtr xmlobject = NULL; const xmlChar * xpath = BAD_CAST(_xpath); const xmlChar * value = NULL; /* Rquete XPath*/ xmlobject = xmlXPathEval(xpath, config->context); if (!xmlobject) return NULL; if (xmlobject->type == XPATH_NODESET) { if (xmlobject->nodesetval) { /* nodeNr = nb nodes in struct nodesetval */ if (xmlobject->nodesetval->nodeNr > 0) { xmlNodePtr n; n = xmlobject->nodesetval->nodeTab[0]; if ((n->type == XML_TEXT_NODE) || (n->type == XML_CDATA_SECTION_NODE)) value = n->content; } } } xmlXPathFreeObject(xmlobject); return (char *)value; }
XPathContext::NodeSet_t XPathContext::find_nodes(const std::string& xpath, const Node* context) { if (context != NULL) { m_cobj->node = *const_cast<Node*>(context); } else { m_cobj->node = NULL; } boost::shared_ptr<xmlXPathObject> result( xmlXPathEval(reinterpret_cast<const xmlChar*>(xpath.c_str()), m_cobj), xmlXPathFreeObject); if (result->type != XPATH_NODESET || result->nodesetval == NULL) { return NodeSet_t(); } NodeSet_t result_nodes; result_nodes.reserve(result->nodesetval->nodeNr); for (int i = 0; i < result->nodesetval->nodeNr; ++i) { result_nodes.push_back(reinterpret_cast<Node*>(result->nodesetval->nodeTab[i]->_private)); } return result_nodes; }
/// Return the text result (if any) of the xpath expression TIXML_STRING S_xpath_expr (const xmlDoc * Dp_ptr, const char * cp_xpath_expr) { xmlXPathObjectPtr XPOp_ptr; xmlXPathContextPtr XPCp_ptr; const xmlChar * Cp_ptr; TIXML_STRING S_out; S_out = ""; if (Dp_ptr) { XPCp_ptr = xmlXPathNewContext ((xmlDoc *) Dp_ptr); if (XPCp_ptr) { // Evaluate XPOp_ptr = xmlXPathEval ((const xmlChar *) cp_xpath_expr, XPCp_ptr); if (XPOp_ptr) { Cp_ptr = xmlXPathCastToString (XPOp_ptr); if (Cp_ptr) S_out = (const char *) Cp_ptr; xmlXPathFreeObject (XPOp_ptr); } } if (XPCp_ptr) xmlXPathFreeContext (XPCp_ptr); } return S_out; }
Node* XPathContext::find(const std::string& xpath, const Node* context) { if (context) { m_cobj->node = *const_cast<Node*>(context); } else { m_cobj->node = *(reinterpret_cast<Document*>(m_cobj->doc->_private)->get_root_element()); } boost::shared_ptr<xmlXPathObject> result( xmlXPathEval(reinterpret_cast<const xmlChar*>(xpath.c_str()), m_cobj), xmlXPathFreeObject); if (result->type != XPATH_NODESET) { return NULL; } if (result->nodesetval->nodeNr <= 0) { return NULL; } return reinterpret_cast<Node*>(result->nodesetval->nodeTab[0]->_private); }
/** * virXPathNode: * @xpath: the XPath string to evaluate * @ctxt: an XPath context * * Convenience function to evaluate an XPath node set and returning * only one node, the first one in the set if any * * Returns a pointer to the node or NULL if the evaluation failed. */ xmlNodePtr virXPathNode(const char *xpath, xmlXPathContextPtr ctxt) { xmlXPathObjectPtr obj; xmlNodePtr relnode; xmlNodePtr ret; if ((ctxt == NULL) || (xpath == NULL)) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid parameter to virXPathNode()")); return NULL; } relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); ctxt->node = relnode; if ((obj == NULL) || (obj->type != XPATH_NODESET) || (obj->nodesetval == NULL) || (obj->nodesetval->nodeNr <= 0) || (obj->nodesetval->nodeTab == NULL)) { xmlXPathFreeObject(obj); return NULL; } ret = obj->nodesetval->nodeTab[0]; xmlXPathFreeObject(obj); return ret; }
/** * virXPathNumber: * @xpath: the XPath string to evaluate * @ctxt: an XPath context * @value: the returned double value * * Convenience function to evaluate an XPath number * * Returns 0 in case of success in which case @value is set, * or -1 if the evaluation failed. */ int virXPathNumber(const char *xpath, xmlXPathContextPtr ctxt, double *value) { xmlXPathObjectPtr obj; xmlNodePtr relnode; if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid parameter to virXPathNumber()")); return -1; } relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); ctxt->node = relnode; if ((obj == NULL) || (obj->type != XPATH_NUMBER) || (isnan(obj->floatval))) { xmlXPathFreeObject(obj); return -1; } *value = obj->floatval; xmlXPathFreeObject(obj); return 0; }
static xmlChar * makeCloneXML(const char *origxml, const char *newname) { xmlDocPtr doc = NULL; xmlXPathContextPtr ctxt = NULL; xmlXPathObjectPtr obj = NULL; xmlChar *newxml = NULL; int size; doc = virXMLParseStringCtxt(origxml, _("(volume_definition)"), &ctxt); if (!doc) goto cleanup; obj = xmlXPathEval(BAD_CAST "/volume/name", ctxt); if (obj == NULL || obj->nodesetval == NULL || obj->nodesetval->nodeTab == NULL) goto cleanup; xmlNodeSetContent(obj->nodesetval->nodeTab[0], (const xmlChar *)newname); xmlDocDumpMemory(doc, &newxml, &size); cleanup: xmlXPathFreeObject(obj); xmlXPathFreeContext(ctxt); xmlFreeDoc(doc); return newxml; }
static void exsltDynEvaluateFunction(xmlXPathParserContextPtr ctxt, int nargs) { xmlChar *str = NULL; xmlXPathObjectPtr ret = NULL; if (ctxt == NULL) return; if (nargs != 1) { xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL); xsltGenericError(xsltGenericErrorContext, "dyn:evalute() : invalid number of args %d\n", nargs); ctxt->error = XPATH_INVALID_ARITY; return; } str = xmlXPathPopString(ctxt); if (!str||!xmlStrlen(str)) { if (str) xmlFree(str); valuePush(ctxt,xmlXPathNewNodeSet(NULL)); return; } ret = xmlXPathEval(str,ctxt->context); if (ret) valuePush(ctxt,ret); else { xsltGenericError(xsltGenericErrorContext, "dyn:evaluate() : unable to evaluate expression '%s'\n",str); valuePush(ctxt,xmlXPathNewNodeSet(NULL)); } xmlFree(str); return; }
static SeedValue seed_xml_xpath_eval (SeedContext ctx, SeedObject function, SeedObject this_object, gsize argument_count, const SeedValue arguments[], SeedException * exception) { xmlXPathObjectPtr xpath_obj; xmlXPathContextPtr xpath_ctx; guchar *xpath; if (argument_count != 1) { seed_make_exception (ctx, exception, "ArgumentError", "xpathEval expected 1 argument, got %zd", argument_count); return seed_make_null (ctx); } xpath_ctx = XML_XPATH_PRIV (this_object); xpath = (guchar *)seed_value_to_string (ctx, arguments[0], exception); xpath_obj = xmlXPathEval (xpath, xpath_ctx); g_free (xpath); return seed_make_object (ctx, xml_xpathobj_class, xpath_obj); }
/* If the tag ignor_autoconf if set, disable this feature by * setting the variables * /proc/sys/net/ipv6/conf/all/autoconf * /proc/sys/net/ipv6/conf/all/accept_ra * /proc/sys/net/ipv6/conf/all/accept_ra_defrtr * /proc/sys/net/ipv6/conf/all/accept_ra_pinfo * /proc/sys/net/ipv6/conf/all/accept_redirects * to 0 to avoid the monitoring host to be attacked */ void autoconf() { char *request ="/config_ndpmon/ignor_autoconf/text()"; char *flag; xmlXPathObjectPtr xmlobject = xmlXPathEval ((xmlChar*)request, xpctxt); if( xmlobject != NULL) { flag = (char *)xmlobject->nodesetval->nodeTab[0]->content; ignor_autoconf = atoi(flag); /* Not working for BSD */ #ifdef _LINUX_ /** note: it may be a good option to save values, and restore * them when exiting */ write_proc("/proc/sys/net/ipv6/conf/all/autoconf",flag); write_proc("/proc/sys/net/ipv6/conf/all/accept_ra",flag); write_proc("/proc/sys/net/ipv6/conf/all/accept_ra_defrtr",flag); write_proc("/proc/sys/net/ipv6/conf/all/accept_ra_pinfo",flag); write_proc("/proc/sys/net/ipv6/conf/all/accept_redirects",flag); } #endif xmlXPathFreeObject (xmlobject); return; }
int xml_config_for_each_obj(const xml_config_t *config, const char *pattern, xml_config_cb_t cb, void *arg1, void *arg2) { xmlXPathObject *objs; xmlNode *node; int i, ret = 0; if (!(objs = xmlXPathEval(BAD_CAST pattern, config->xpc))) { return -1; } if (xmlXPathNodeSetIsEmpty(objs->nodesetval) == 0) { for (i = 0; i < xmlXPathNodeSetGetLength(objs->nodesetval); i++) { if (!(node = xmlXPathNodeSetItem(objs->nodesetval, i))) { continue; } if ((ret = cb(node, arg1, arg2)) < 0) { break; } } } xmlXPathFreeObject(objs); return ret; }
/** * virXPathULongLong: * @xpath: the XPath string to evaluate * @ctxt: an XPath context * @value: the returned long long value * * Convenience function to evaluate an XPath number * * Returns 0 in case of success in which case @value is set, * or -1 if the XPath evaluation failed or -2 if the * value doesn't have a long format. */ int virXPathLongLong(const char *xpath, xmlXPathContextPtr ctxt, long long *value) { xmlXPathObjectPtr obj; xmlNodePtr relnode; int ret = 0; if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid parameter to virXPathLongLong()")); return -1; } relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); ctxt->node = relnode; if ((obj != NULL) && (obj->type == XPATH_STRING) && (obj->stringval != NULL) && (obj->stringval[0] != 0)) { if (virStrToLong_ll((char *) obj->stringval, NULL, 10, value) < 0) ret = -2; } else if ((obj != NULL) && (obj->type == XPATH_NUMBER) && (!(isnan(obj->floatval)))) { *value = (long long) obj->floatval; if (*value != obj->floatval) { ret = -2; } } else { ret = -1; } xmlXPathFreeObject(obj); return ret; }
/** * virXPathString: * @xpath: the XPath string to evaluate * @ctxt: an XPath context * * Convenience function to evaluate an XPath string * * Returns a new string which must be deallocated by the caller or NULL * if the evaluation failed. */ char * virXPathString(const char *xpath, xmlXPathContextPtr ctxt) { xmlXPathObjectPtr obj; xmlNodePtr relnode; char *ret; if ((ctxt == NULL) || (xpath == NULL)) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid parameter to virXPathString()")); return NULL; } relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); ctxt->node = relnode; if ((obj == NULL) || (obj->type != XPATH_STRING) || (obj->stringval == NULL) || (obj->stringval[0] == 0)) { xmlXPathFreeObject(obj); return NULL; } ignore_value(VIR_STRDUP(ret, (char *) obj->stringval)); xmlXPathFreeObject(obj); return ret; }
/* Get sha1file */ static void get_sha1(const char *ident) { char *path = NULL; char xpath[SIZE]; xmlXPathContextPtr xml_context = NULL; xmlXPathObjectPtr xmlobject; (void)crv_strncpy(xpath, "/database/file[@id='", sizeof(xpath)); (void)crv_strncat(xpath, ident, sizeof(xpath)); (void)crv_strncat(xpath, "']" , sizeof(xpath)); path = crv_strdup(xpath); xmlXPathInit(); xml_context = xmlXPathNewContext (xmldoc); xmlobject = xmlXPathEval (path, xml_context); crv_free(path); if ((xmlobject->type == XPATH_NODESET) ) { int j; xmlNodePtr node; for (j = 0; j < xmlobject->nodesetval->nodeNr; j++) { node = xmlobject->nodesetval->nodeTab[j]; xmlChar *Sha1 = xmlGetProp(node, "sha1"); sha1 = crv_strdup(Sha1); xmlFree (Sha1); } } xmlXPathFreeObject (xmlobject); xmlXPathFreeContext (xml_context); }
/** * virXPathBoolean: * @xpath: the XPath string to evaluate * @ctxt: an XPath context * * Convenience function to evaluate an XPath boolean * * Returns 0 if false, 1 if true, or -1 if the evaluation failed. */ int virXPathBoolean(const char *xpath, xmlXPathContextPtr ctxt) { xmlXPathObjectPtr obj; xmlNodePtr relnode; int ret; if ((ctxt == NULL) || (xpath == NULL)) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid parameter to virXPathBoolean()")); return -1; } relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); ctxt->node = relnode; if ((obj == NULL) || (obj->type != XPATH_BOOLEAN) || (obj->boolval < 0) || (obj->boolval > 1)) { xmlXPathFreeObject(obj); return -1; } ret = obj->boolval; xmlXPathFreeObject(obj); return ret; }
/* * call-seq: * context.find("xpath") -> true|false|number|string|XML::XPath::Object * * Executes the provided xpath function. The result depends on the execution * of the xpath statement. It may be true, false, a number, a string or * a node set. */ static VALUE rxml_xpath_context_find(VALUE self, VALUE xpath_expr) { xmlXPathContextPtr xctxt; xmlXPathObjectPtr xobject; xmlXPathCompExprPtr xcompexpr; Data_Get_Struct(self, xmlXPathContext, xctxt); if (TYPE(xpath_expr) == T_STRING) { VALUE expression = rb_check_string_type(xpath_expr); xobject = xmlXPathEval((xmlChar*) StringValueCStr(expression), xctxt); } else if (rb_obj_is_kind_of(xpath_expr, cXMLXPathExpression)) { Data_Get_Struct(xpath_expr, xmlXPathCompExpr, xcompexpr); xobject = xmlXPathCompiledEval(xcompexpr, xctxt); } else { rb_raise(rb_eTypeError, "Argument should be an intance of a String or XPath::Expression"); } return rxml_xpath_to_value(xctxt, xobject); }
/* * query from root * Note: need to be cautious that the result from xmlXPathEval call is not freed within this API * it is up to user to call xmlXPathFreeObject to free it */ xmlXPathObjectPtr wsNode::xpath(string xpath) { xmlXPathContextPtr ctxt=xmlXPathNewContext(thisNode->doc); xmlXPathObjectPtr res=xmlXPathEval((xmlChar *)xpath.c_str(),ctxt); xmlXPathFreeContext(ctxt); check_xmlXPathObjectPtr(res, xpath); return res; }
static void parse_forecast_xml (GWeatherInfo *master_info, SoupMessageBody *body) { GWeatherInfoPrivate *priv; xmlDocPtr doc; xmlXPathContextPtr xpath_ctx; xmlXPathObjectPtr xpath_result; int i; priv = master_info->priv; doc = xmlParseMemory (body->data, body->length); if (!doc) return; xpath_ctx = xmlXPathNewContext (doc); xpath_result = xmlXPathEval (XC("/weatherdata/forecast/time"), xpath_ctx); if (!xpath_result || xpath_result->type != XPATH_NODESET) goto out; for (i = 0; i < xpath_result->nodesetval->nodeNr; i++) { xmlNodePtr node; GWeatherInfo *info; node = xpath_result->nodesetval->nodeTab[i]; info = make_info_from_node (master_info, node); priv->forecast_list = g_slist_append (priv->forecast_list, info); } xmlXPathFreeObject (xpath_result); xpath_result = xmlXPathEval (XC("/weatherdata/credit/link"), xpath_ctx); if (!xpath_result || xpath_result->type != XPATH_NODESET) goto out; priv->forecast_attribution = g_strdup(_("Weather data from the <a href=\"http://openweathermap.org\">Open Weather Map project</a>")); out: if (xpath_result) xmlXPathFreeObject (xpath_result); xmlXPathFreeContext (xpath_ctx); xmlFreeDoc (doc); }
/** Parse counter measures configuration. */ void parse_countermeasures() { char *config_kill_illegitimate_router=NULL, *config_kill_wrong_prefix=NULL, *config_propagate_router_params=NULL, *config_indicate_ndpmon_presence=NULL, *request; xmlXPathObjectPtr xmlobject; request ="/config_ndpmon/countermeasures/kill_illegitimate_router/text()"; xmlobject = xmlXPathEval ((xmlChar*)request, xpctxt); if (xmlobject->nodesetval!=NULL) { config_kill_illegitimate_router = (char*)xmlobject->nodesetval->nodeTab[0]->content; } xmlXPathFreeObject (xmlobject); request ="/config_ndpmon/countermeasures/kill_wrong_prefix/text()"; xmlobject = xmlXPathEval ((xmlChar*)request, xpctxt); if (xmlobject->nodesetval!=NULL) { config_kill_wrong_prefix = (char*)xmlobject->nodesetval->nodeTab[0]->content; } xmlXPathFreeObject (xmlobject); request ="/config_ndpmon/countermeasures/propagate_router_params/text()"; xmlobject = xmlXPathEval ((xmlChar*)request, xpctxt); if (xmlobject->nodesetval!=NULL) { config_propagate_router_params = (char*)xmlobject->nodesetval->nodeTab[0]->content; } xmlXPathFreeObject (xmlobject); request ="/config_ndpmon/countermeasures/indicate_ndpmon_presence/text()"; xmlobject = xmlXPathEval ((xmlChar*)request, xpctxt); if (xmlobject->nodesetval!=NULL) { config_indicate_ndpmon_presence = (char*)xmlobject->nodesetval->nodeTab[0]->content; } xmlXPathFreeObject (xmlobject); cm_guard_init_all( config_kill_illegitimate_router, config_kill_wrong_prefix, config_propagate_router_params, config_indicate_ndpmon_presence ); }
/* * call-seq: * context.find("xpath") -> true|false|number|string|XML::XPath::Object * * Executes the provided xpath function. The result depends on the execution * of the xpath statement. It may be true, false, a number, a string or * a node set. */ static VALUE rxml_xpath_context_find(VALUE self, VALUE xpath_expr) { xmlXPathContextPtr xctxt; xmlXPathObjectPtr xobject; xmlXPathCompExprPtr xcompexpr; VALUE result; Data_Get_Struct(self, xmlXPathContext, xctxt); if (TYPE(xpath_expr) == T_STRING) { VALUE expression = rb_check_string_type(xpath_expr); xobject = xmlXPathEval((xmlChar*) StringValueCStr(expression), xctxt); } else if (rb_obj_is_kind_of(xpath_expr, cXMLXPathExpression)) { Data_Get_Struct(xpath_expr, xmlXPathCompExpr, xcompexpr); xobject = xmlXPathCompiledEval(xcompexpr, xctxt); } else { rb_raise(rb_eTypeError, "Argument should be an intance of a String or XPath::Expression"); } if (xobject == NULL) { /* xmlLastError is different than xctxt->lastError. Use xmlLastError since it has the message set while xctxt->lastError does not. */ xmlErrorPtr xerror = xmlGetLastError(); rxml_raise(xerror); } switch (xobject->type) { case XPATH_NODESET: result = rxml_xpath_object_wrap(xctxt->doc, xobject); break; case XPATH_BOOLEAN: result = (xobject->boolval != 0) ? Qtrue : Qfalse; xmlXPathFreeObject(xobject); break; case XPATH_NUMBER: result = rb_float_new(xobject->floatval); xmlXPathFreeObject(xobject); break; case XPATH_STRING: result = rb_str_new2((const char*)xobject->stringval); xmlXPathFreeObject(xobject); break; default: result = Qnil; xmlXPathFreeObject(xobject); } return result; }
/** * xslDbgShellPrintList: * @ctxt: The current shell context * @arg: What xpath to display and in UTF-8 * @dir: If 1 print in dir mode?, * otherwise ls mode * * Print list of nodes in either ls or dir format * * Returns 1 on success, * 0 otherwise */ int xslDbgShellPrintList(xmlShellCtxtPtr ctxt, xmlChar * arg, int dir) { xmlXPathObjectPtr list; int result = 0; if (!ctxt || !arg) { #ifdef WITH_XSLDBG_DEBUG_PROCESS xsltGenericError(xsltGenericErrorContext, "Error: NULL arguments provided\n"); #endif return result; } if (arg[0] == 0) { if (dir) xmlShellDir(ctxt, NULL, ctxt->node, NULL); else xmlShellList(ctxt, NULL, ctxt->node, NULL); result = 1; /*assume that this worked */ } else { ctxt->pctxt->node = ctxt->node; ctxt->pctxt->node = ctxt->node; if (!xmlXPathNsLookup(ctxt->pctxt, (xmlChar *) "xsl")) xmlXPathRegisterNs(ctxt->pctxt, (xmlChar *) "xsl", XSLT_NAMESPACE); list = xmlXPathEval(arg, ctxt->pctxt); if (list != NULL) { switch (list->type) { case XPATH_NODESET:{ int indx; for (indx = 0; indx < list->nodesetval->nodeNr; indx++) { if (dir) xmlShellList(ctxt, NULL, list->nodesetval-> nodeTab[indx], NULL); else xmlShellList(ctxt, NULL, list->nodesetval-> nodeTab[indx], NULL); } result = 1; break; } default: xmlShellPrintXPathError(list->type, (char *) arg); } xmlXPathFreeObject(list); } else { xsldbgGenericErrorFunc(i18n("Error: XPath %1 results in an empty Node Set.\n").arg(xsldbgText(arg))); } ctxt->pctxt->node = NULL; } return result; }
/*Admin mail from the config file to send warnings */ void get_mail() { char* request ="/config_ndpmon/admin_mail/text()"; xmlXPathObjectPtr xmlobject = xmlXPathEval ((xmlChar*)request, xpctxt); strncpy(admin_mail,(char*)xmlobject->nodesetval->nodeTab[0]->content, ADMIN_MAIL_SIZE); xmlXPathFreeObject (xmlobject); return; }
/* Should we do reverse DNS lookups on an action that is logged? */ void get_use_reverse_hostlookups() { char* request ="/config_ndpmon/use_reverse_hostlookups/text()"; xmlXPathObjectPtr xmlobject = xmlXPathEval ((xmlChar*)request, xpctxt); if ((xmlobject->nodesetval==NULL) || (strcmp("1", (char*)xmlobject->nodesetval->nodeTab[0]->content)!=0)) use_reverse_hostlookups=0; else use_reverse_hostlookups=1; xmlXPathFreeObject (xmlobject); return; }
static bool image_add(GHashTable *images, xmlDocPtr args, xmlNodePtr image_args, GError **err) { struct vmnetfs_image *img; xmlXPathContextPtr ctx; xmlXPathObjectPtr obj; xmlChar *content; int i; ctx = make_xpath_context(args); ctx->node = image_args; img = g_slice_new0(struct vmnetfs_image); img->url = xpath_get_str(ctx, "v:origin/v:url/text()"); img->username = xpath_get_str(ctx, "v:origin/v:credentials/v:username/text()"); img->password = xpath_get_str(ctx, "v:origin/v:credentials/v:password/text()"); img->read_base = xpath_get_str(ctx, "v:cache/v:path/text()"); img->fetch_offset = xpath_get_uint(ctx, "v:origin/v:offset/text()"); img->initial_size = xpath_get_uint(ctx, "v:size/text()"); img->chunk_size = xpath_get_uint(ctx, "v:cache/v:chunk-size/text()"); img->etag = xpath_get_str(ctx, "v:origin/v:validators/v:etag/text()"); img->last_modified = xpath_get_uint(ctx, "v:origin/v:validators/v:last-modified/text()"); obj = xmlXPathEval(BAD_CAST "v:origin/v:cookies/v:cookie/text()", ctx); for (i = 0; obj && obj->nodesetval && i < obj->nodesetval->nodeNr; i++) { content = xmlNodeGetContent(obj->nodesetval->nodeTab[i]); img->cookies = g_list_prepend(img->cookies, g_strdup((const char *) content)); xmlFree(content); } xmlXPathFreeObject(obj); img->io_stream = _vmnetfs_stream_group_new(NULL, NULL); img->bytes_read = _vmnetfs_stat_new(); img->bytes_written = _vmnetfs_stat_new(); img->chunk_fetches = _vmnetfs_stat_new(); img->chunk_dirties = _vmnetfs_stat_new(); img->io_errors = _vmnetfs_stat_new(); if (!_vmnetfs_io_init(img, err)) { _image_free(img); xmlXPathFreeContext(ctx); return false; } g_hash_table_insert(images, xpath_get_str(ctx, "v:name/text()"), img); xmlXPathFreeContext(ctx); return true; }
static void xpath_censor(xmlXPathContextPtr ctx, const char *xpath) { xmlXPathObjectPtr result; int i; result = xmlXPathEval(BAD_CAST xpath, ctx); if (result && result->nodesetval) { for (i = 0; i < result->nodesetval->nodeNr; i++) { xmlNodeSetContent(result->nodesetval->nodeTab[i], (const xmlChar *) "XXXXX"); } } xmlXPathFreeObject(result); }
/** * virXPathNodeSet: * @xpath: the XPath string to evaluate * @ctxt: an XPath context * @list: the returned list of nodes (or NULL if only count matters) * * Convenience function to evaluate an XPath node set * * Returns the number of nodes found in which case @list is set (and * must be freed) or -1 if the evaluation failed. */ int virXPathNodeSet(const char *xpath, xmlXPathContextPtr ctxt, xmlNodePtr **list) { xmlXPathObjectPtr obj; xmlNodePtr relnode; int ret; if ((ctxt == NULL) || (xpath == NULL)) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid parameter to virXPathNodeSet()")); return -1; } if (list != NULL) *list = NULL; relnode = ctxt->node; obj = xmlXPathEval(BAD_CAST xpath, ctxt); ctxt->node = relnode; if (obj == NULL) return 0; if (obj->type != XPATH_NODESET) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Incorrect xpath '%s'"), xpath); xmlXPathFreeObject(obj); return -1; } if ((obj->nodesetval == NULL) || (obj->nodesetval->nodeNr < 0)) { xmlXPathFreeObject(obj); return 0; } ret = obj->nodesetval->nodeNr; if (list != NULL && ret) { if (VIR_ALLOC_N(*list, ret) < 0) { virReportOOMError(); ret = -1; } else { memcpy(*list, obj->nodesetval->nodeTab, ret * sizeof(xmlNodePtr)); } } xmlXPathFreeObject(obj); return ret; }
/* Get Info server */ static void get_server_info(const char *ident) { char *path = NULL; char xpath[SIZE]; xmlXPathContextPtr xml_context = NULL; xmlXPathObjectPtr xmlobject; long lval; char *ep; (void)crv_strncpy(xpath, "/database/file[@id='", sizeof(xpath)); (void)crv_strncat(xpath, ident, sizeof(xpath)); (void)crv_strncat(xpath, "']/server" , sizeof(xpath)); path = crv_strdup(xpath); xmlXPathInit(); xml_context = xmlXPathNewContext (xmldoc); xmlobject = xmlXPathEval (path, xml_context); crv_free(path); if ((xmlobject->type == XPATH_NODESET) ) { int j; xmlNodePtr node; for (j = 0; j < xmlobject->nodesetval->nodeNr; j++) { node = xmlobject->nodesetval->nodeTab[j]; xmlChar *Host = xmlGetProp(node, "host"); if (Host != NULL) { server = crv_strdup(Host); } xmlChar *Port = xmlGetProp(node, "port"); if (Port != NULL) { lval = strtol(Port, &ep, 10); if (Port[0] == '\0' || *ep != '\0') { fprintf(stderr, "%s%s", Port, " is not a number"); return; } port = lval; } xmlFree (Host); xmlFree (Port); } } xmlXPathFreeObject (xmlobject); xmlXPathFreeContext (xml_context); }
/** * Evaluates an XPath expression on the passed-in context. * * @param pContext Pointer to the context. * @param pczExpression The XPath expression to evaluate * * @return xmlNodeSetPtr pointing to the resulting node set, must be * freed by the caller. */ static xmlNodeSetPtr evaluateXPathExpression(xmlXPathContextPtr pContext, const char * pczExpression) { xmlXPathObjectPtr pObject = xmlXPathEval(CONSTXMLCHAR_P(pczExpression), pContext); if (!pObject || !pObject->nodesetval) { return NULL; } xmlNodeSetPtr pNodeSet = pObject->nodesetval; xmlXPathFreeNodeSetList(pObject); return pNodeSet; }
/** * This is identical to xpath_foreach_match, except that it takes the context * as parameter. */ static void inoreader_source_xpath_foreach_match (const gchar* expr, xmlXPathContextPtr xpathCtxt, xpathMatchFunc func, gpointer user_data) { xmlXPathObjectPtr xpathObj = NULL; xpathObj = xmlXPathEval ((xmlChar*)expr, xpathCtxt); if (xpathObj && xpathObj->nodesetval && xpathObj->nodesetval->nodeMax) { int i; for (i = 0; i < xpathObj->nodesetval->nodeNr; i++) { (*func) (xpathObj->nodesetval->nodeTab[i], user_data); xpathObj->nodesetval->nodeTab[i] = NULL ; } } if (xpathObj) xmlXPathFreeObject (xpathObj); }