template <typename Traits> inline shared_ptr<typename detector_impl<Traits>::definition_type> detector_impl<Traits>::parse_complex_definition(char const *name, xmlNodePtr node) const { typedef complex_definition<Traits> complex_type; shared_ptr<complex_type> parent(new complex_type(name)); xml_elems elems(node, "pattern"); for (xml_elems::const_iterator i = elems.begin(), end = elems.end(); i != end; ++i) { if (disabled(*i)) { continue; } char const *value = xml_attr_text(*i, "value"), *type = xml_attr_text(*i, "type"); if (strncasecmp(type, "string", sizeof("string")) == 0) { parent->add(shared_ptr<definition_type>(new string_definition<Traits>(name, xml_node_text(*i), value))); } else if (strncasecmp(type, "regex", sizeof("regex")) == 0) { parent->add(shared_ptr<definition_type>(new regex_definition<Traits>(name, xml_node_text(*i), value))); } else { resource<xmlChar*, xml_string_traits> path(xmlGetNodePath(node)); throw error("unknown pattern type %s in [%s]", type, (char const*) path.get()); } } return parent->has_only_one() ? parent->release_child() : parent.template cast<definition_type>(); }
static void debug_report_signature_error(xmlNode *node, lasso_error_t result) { xmlChar *path; path = xmlGetNodePath(node); debug("Could not check signature whose xpath is '%s': %s", path, lasso_strerror(result)); lasso_release_xml_string(path); }
string Node::Path() const { xmlChar * path = xmlGetNodePath(_xml); if ( path == nullptr ) return string(); string r(path); xmlFree(path); return r; }
gchar * xml_tree_model_get_xpath_from_position (xmlTreeModel *model, gint position) { xmlNodePtr node; node = xml_tree_model_get_node_from_position(model, position); g_return_val_if_fail(node != NULL, NULL); return (gchar *)xmlGetNodePath(node); }
QString CSpmXml::GetPath(xmlNodePtr pNode) { QString strRes; pNode = GetNode(pNode); if (0 == pNode) return strRes; return QString::fromUtf8((char *)xmlGetNodePath(pNode)); }
static void nc_attr_show(noit_console_closure_t ncct, const char *name, xmlNodePtr cnode, xmlNodePtr anode, const char *value) { const char *cpath, *apath; cpath = cnode ? (char *)xmlGetNodePath(cnode) : ""; apath = anode ? (char *)xmlGetNodePath(anode) : ""; nc_printf(ncct, " %s: %s", name, value ? value : "[undef]"); if(value && cpath && apath) { int clen = strlen(cpath); int plen = strlen("/noit/checks/"); if(!strncmp(cpath, apath, clen) && apath[clen] == '/') { /* we have a match, which means it isn't inherited */ } else { nc_printf(ncct, " [inherited from %s]", strlen(apath) > plen ? apath + plen : apath); } } nc_write(ncct, "\n", 1); }
/* * call-seq: * path * * Returns the path associated with this Node */ static VALUE path(VALUE self) { xmlNodePtr node; xmlChar *path ; VALUE rval ; Data_Get_Struct(self, xmlNode, node); path = xmlGetNodePath(node); rval = rb_str_new2((char *)path); xmlFree(path); return rval ; }
/* * call-seq: * node.path -> path * * Obtain this node's path. */ static VALUE rxml_node_path(VALUE self) { xmlNodePtr xnode; xmlChar *path; Data_Get_Struct(self, xmlNode, xnode); path = xmlGetNodePath(xnode); if (path == NULL) return (Qnil); else return (rxml_str_new2((const char*) path, xnode->doc ? xnode->doc->encoding : NULL)); }
/* * call-seq: * node.path -> path * * Obtain this node's path. */ static VALUE rxml_node_path(VALUE self) { xmlNodePtr xnode; xmlChar *path; xnode = rxml_get_xnode(self); path = xmlGetNodePath(xnode); if (path == NULL) return (Qnil); else return (rxml_new_cstr((const char*) path, NULL)); }
//------------------------------------------------------------------------------ std::string Node::get_path() const { xmlChar* const path = xmlGetNodePath(cobj); if (path == NULL) { // WTF: How is this suposed to happen? throw exception("Node::get_path(): failed to allocated path"); } std::string value(reinterpret_cast<const char*>(path)); xmlFree(path); return value; }
template <typename Traits> inline shared_ptr<typename detector_impl<Traits>::definition_type> detector_impl<Traits>::parse_definition(xmlNodePtr node) const { char const *name = xml_attr_text(node, "name"), *value = xml_attr_text(node, "value"); if (static_cast<char const*>(0) == name) { resource<xmlChar*, xml_string_traits> path(xmlGetNodePath(node)); throw error("definition without name in [%s]", (char const*) path.get()); } else if (static_cast<char const*>(0) == value) { return parse_complex_definition(name, node); } else { return shared_ptr<definition_type>(new static_definition<Traits>(name, value)); } }
/** * xmlSchematronReportSuccess: * @ctxt: the validation context * @test: the compiled test * @cur: the current node tested * @success: boolean value for the result * * called from the validation engine when an assert or report test have * been done. */ static void xmlSchematronReportSuccess(xmlSchematronValidCtxtPtr ctxt, xmlSchematronTestPtr test, xmlNodePtr cur, int success) { if ((ctxt == NULL) || (cur == NULL) || (test == NULL)) return; /* if quiet and not SVRL report only failures */ if ((ctxt->flags & XML_SCHEMATRON_OUT_QUIET) && ((ctxt->flags & XML_SCHEMATRON_OUT_XML) == 0) && (test->type == XML_SCHEMATRON_REPORT)) return; if (ctxt->flags & XML_SCHEMATRON_OUT_XML) { TODO } else { xmlChar *path; char msg[1000]; long line; const xmlChar *report = NULL; if (((test->type == XML_SCHEMATRON_REPORT) & (!success)) || ((test->type == XML_SCHEMATRON_ASSERT) & (success))) return; line = xmlGetLineNo(cur); path = xmlGetNodePath(cur); if (path == NULL) path = (xmlChar *) cur->name; #if 0 if ((test->report != NULL) && (test->report[0] != 0)) report = test->report; #endif if (test->node != NULL) report = xmlSchematronFormatReport(ctxt, test->node, cur); if (report == NULL) { if (test->type == XML_SCHEMATRON_ASSERT) { snprintf(msg, 999, "%s line %ld: node failed assert\n", (const char *) path, line); } else { snprintf(msg, 999, "%s line %ld: node failed report\n", (const char *) path, line); } } else { snprintf(msg, 999, "%s line %ld: %s\n", (const char *) path, line, (const char *) report); xmlFree((char *) report); } xmlSchematronReportOutput(ctxt, cur, &msg[0]); if ((path != NULL) && (path != (xmlChar *) cur->name)) xmlFree(path); } }
xmlNodePtr CSpmXml::MoveFirst(const QString& strXPathQuery, xmlNodePtr pParent, int* pnCount) { if (strXPathQuery.isEmpty()) return 0; pParent = GetNode(pParent); if (0 == pParent) return 0; QString strQuery; if (strXPathQuery.left(2) != "//") // локальный запрос { strQuery = (char *)xmlGetNodePath(pParent); strQuery += strXPathQuery; } else strQuery = strXPathQuery; xmlXPathContextPtr pContext = xmlXPathNewContext(m_pXMLDoc); if (0 == pContext) return 0; xmlXPathObjectPtr pQuery = xmlXPathEvalExpression(BAD_CAST strQuery.toUtf8().data(), pContext); xmlXPathFreeContext(pContext); if (0 == pQuery) return 0; if (m_pCurNodeSet) { xmlXPathFreeNodeSet(m_pCurNodeSet); m_pCurNodeSet = 0; } m_nCurItem = 0; m_pCurNodeSet = pQuery->nodesetval; if (0 == m_pCurNodeSet) return 0; if (pnCount) *pnCount = m_pCurNodeSet->nodeNr; if (0 == m_pCurNodeSet->nodeNr) return 0; m_pCurNode = m_pCurNodeSet->nodeTab[m_nCurItem]; return m_pCurNode; }
static char *xml_conf_parse_file(xmlNode *element) { char *ret = 0; for ( ; element; element = element->next) { if (element->parent && element->type == XML_ELEMENT_NODE && !strcmp((const char *) element->name, "section")) { xmlChar *name = xmlGetProp(element, (unsigned char *) "name"); if (name) { char *parent_name = (char *) xmlGetNodePath(element->parent); char *full_name; int i; struct xml_conf_section *section = NULL; #ifdef XML_CONF_DEBUG fprintf(stderr, "got a section: %s/%s\n", parent_name, name); #endif full_name = alloca(strlen(parent_name) + strlen((char *) name) + 1 + 1); sprintf(full_name, "%s/%s", parent_name, (char *) name); xmlFree(parent_name); xmlFree(name); for (i = 0; i < xml_conf_sections_used; i++) { if (!strcmp(xml_conf_sections[i]->path, full_name)) { section = xml_conf_sections[i]; } } if (section) { /* found a registered section */ void *conf = section->conf(); ret = xml_conf_parse_section(&conf, section, element->children); if (ret) break; } } } if (element->children) { ret = xml_conf_parse_file(element->children); if (ret) break; } } return ret; }
char* XPathExpressionGetElementPath(TixiDocument* tixiDocument, const char* xPathExpression, int index) { xmlDocPtr doc; xmlXPathObjectPtr xpathObject; xmlNodeSetPtr nodes = NULL; xmlNodePtr cur; int size = 0; /* Load XML document */ doc = tixiDocument->docPtr; xpathObject = XPathEvaluateExpression(doc, xPathExpression); if (xpathObject == NULL) { return NULL; } nodes = xpathObject->nodesetval; size = (nodes) ? nodes->nodeNr : 0; if (size == 0) { printMsg(MESSAGETYPE_ERROR, "Error: XPath Expression '%s' returns 0 nodes.\n", xPathExpression); xmlXPathFreeObject(xpathObject); return NULL; } if (size < index) { printMsg(MESSAGETYPE_ERROR, "Error: Index number too high, XPath expression only returns %d nodes.\n", size); xmlXPathFreeObject(xpathObject); return NULL; } if (index <= 0) { printMsg(MESSAGETYPE_ERROR, "Error: Index number less or equal zero.\n"); xmlXPathFreeObject(xpathObject); return NULL; } cur = nodes->nodeTab[--index]; xmlXPathFreeObject(xpathObject); return (char*) xmlGetNodePath(cur); }
static void simpleXpathMakeTag (xmlNode *node, const tagXpathMakeTagSpec *spec, const kindOption* const kinds, void *userData) { tagEntryInfo tag; xmlChar* str; const kindOption *kind; char *path; str = xmlNodeGetContent(node); if (str == NULL) return; kind = kinds + spec->kind; if (spec->role == ROLE_INDEX_DEFINITION) initTagEntry (&tag, (char *)str, kind); else if (isXtagEnabled(XTAG_REFERENCE_TAGS)) initRefTagEntry (&tag, (char *)str, kind, spec->role); else goto out; tag.lineNumber = xmlGetLineNo (node); tag.filePosition = getInputFilePositionForLine (tag.lineNumber); path = (char *)xmlGetNodePath (node); tag.extensionFields.xpath = path; if (spec->make) spec->make (node, spec, &tag, userData); else makeTagEntry (&tag); if (path) xmlFree (path); out: xmlFree (str); }
bool CSpmXml::DeleteNodes(const QString& strXPathQuery, xmlNodePtr pParent) { if (strXPathQuery.isEmpty()) return false; pParent = GetNode(pParent); if (0 == pParent) return false; QString strQuery; if (strXPathQuery.left(2) != "//") // локальный запрос { strQuery = (char *)xmlGetNodePath(pParent); strQuery += strXPathQuery; } else strQuery = strXPathQuery; xmlXPathContextPtr pContext = xmlXPathNewContext(m_pXMLDoc); if (0 == pContext) return false; xmlXPathObjectPtr pQuery = xmlXPathEvalExpression(BAD_CAST strQuery.toUtf8().data(), pContext); xmlXPathFreeContext(pContext); if (0 == pQuery) return false; xmlNodeSetPtr pNodeSet = pQuery->nodesetval; if ((0 == pNodeSet) || (0 == pNodeSet->nodeNr)) return false; for (int i = 0; i < pNodeSet->nodeNr; i++) { xmlNodePtr pNode = pNodeSet->nodeTab[i]; xmlUnlinkNode(pNode); SetModified(); } xmlXPathFreeNodeSet(pNodeSet); return true; }
template <typename Traits> inline shared_ptr<typename detector_impl<Traits>::branch_type> detector_impl<Traits>::parse_branch(xmlNodePtr node) const { shared_ptr<branch_type> result(new branch_type()); for (xmlNodePtr n = xmlFirstElementChild(node); 0 != n; n = xmlNextElementSibling(n)) { if (disabled(n)) { continue; } else if (xmlStrncasecmp(n->name, (xmlChar const*) "match", sizeof("match")) == 0) { xml_elems elems(n, "pattern"); for (xml_elems::iterator i = elems.begin(), end = elems.end(); i != end; ++i) { if (disabled(*i)) { continue; } char const *type = xml_attr_text(*i, "type"); if (strncasecmp(type, "string", sizeof("string")) == 0) { result->add_match(xml_node_text(*i)); } else if (strncasecmp(type, "regex", sizeof("regex")) == 0) { result->add_regex_match(xml_node_text(*i)); } else { resource<xmlChar*, xml_string_traits> path(xmlGetNodePath(*i)); throw error("unknown pattern type %s in [%s]", type, (char const*) path.get()); } } } else if (xmlStrncasecmp(n->name, (xmlChar const*) "branch", sizeof("branch")) == 0) { result->add_child(parse_branch(n)); } else if (xmlStrncasecmp(n->name, (xmlChar const*) "define", sizeof("definition")) == 0) { result->add_definition(parse_definition(n)); } } return result; }
int cib_process_modify(const char *op, int options, const char *section, xmlNode * req, xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib, xmlNode ** answer) { xmlNode *obj_root = NULL; crm_trace("Processing \"%s\" event", op); if (options & cib_xpath) { return cib_process_xpath(op, options, section, req, input, existing_cib, result_cib, answer); } if (input == NULL) { crm_err("Cannot perform modification with no data"); return -EINVAL; } obj_root = get_object_root(section, *result_cib); if (obj_root == NULL) { xmlNode *tmp_section = NULL; const char *path = get_object_parent(section); if (path == NULL) { return -EINVAL; } tmp_section = create_xml_node(NULL, section); cib_process_xpath(CIB_OP_CREATE, 0, path, NULL, tmp_section, NULL, result_cib, answer); free_xml(tmp_section); obj_root = get_object_root(section, *result_cib); } CRM_CHECK(obj_root != NULL, return -EINVAL); if (update_xml_child(obj_root, input) == FALSE) { if (options & cib_can_create) { add_node_copy(obj_root, input); } else { return -ENXIO; } } if(options & cib_mixed_update) { int max = 0, lpc; xmlXPathObjectPtr xpathObj = xpath_search(*result_cib, "//@__delete__"); if (xpathObj) { max = numXpathResults(xpathObj); crm_log_xml_trace(*result_cib, "Mixed result"); } for (lpc = 0; lpc < max; lpc++) { xmlNode *match = getXpathResult(xpathObj, lpc); xmlChar *match_path = xmlGetNodePath(match); crm_debug("Destroying %s", match_path); free(match_path); free_xml(match); } freeXpathObject(xpathObj); } return pcmk_ok; }
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; }
static int noit_console_config_nocheck(noit_console_closure_t ncct, int argc, char **argv, noit_console_state_t *state, void *closure) { int i, cnt; const char *err = "internal error"; noit_conf_t_userdata_t *info; xmlXPathObjectPtr pobj = NULL; xmlXPathContextPtr xpath_ctxt = NULL; char xpath[1024]; uuid_t checkid; noit_conf_xml_xpath(NULL, &xpath_ctxt); if(argc < 1) { nc_printf(ncct, "requires one argument\n"); return -1; } info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA); if(noit_console_mkcheck_xpath(xpath, sizeof(xpath), info, argv[0])) { nc_printf(ncct, "could not find check '%s'\n", argv[0]); return -1; } pobj = xmlXPathEval((xmlChar *)xpath, xpath_ctxt); if(!pobj || pobj->type != XPATH_NODESET || xmlXPathNodeSetIsEmpty(pobj->nodesetval)) { err = "no checks found"; goto bad; } cnt = xmlXPathNodeSetGetLength(pobj->nodesetval); for(i=0; i<cnt; i++) { xmlNodePtr node; char *uuid_conf; node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i); uuid_conf = (char *)xmlGetProp(node, (xmlChar *)"uuid"); if(!uuid_conf || uuid_parse(uuid_conf, checkid)) { nc_printf(ncct, "%s has invalid or missing UUID!\n", (char *)xmlGetNodePath(node) + strlen("/noit")); } else { if(argc > 1) { int j; for(j=1;j<argc;j++) xmlUnsetProp(node, (xmlChar *)argv[j]); } else { nc_printf(ncct, "descheduling %s\n", uuid_conf); noit_poller_deschedule(checkid); xmlUnlinkNode(node); } noit_conf_mark_changed(); } } if(argc > 1) { noit_poller_process_checks(xpath); noit_poller_reload(xpath); } nc_printf(ncct, "rebuilding causal map...\n"); noit_poller_make_causal_map(); if(pobj) xmlXPathFreeObject(pobj); return 0; bad: if(pobj) xmlXPathFreeObject(pobj); nc_printf(ncct, "%s\n", err); return -1; }
static int noit_console_show_check(noit_console_closure_t ncct, int argc, char **argv, noit_console_state_t *state, void *closure) { int i, cnt; noit_conf_t_userdata_t *info; char xpath[1024]; xmlXPathObjectPtr pobj = NULL; xmlXPathContextPtr xpath_ctxt = NULL; noit_conf_xml_xpath(NULL, &xpath_ctxt); if(argc > 1) { nc_printf(ncct, "requires zero or one arguments\n"); return -1; } info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA); /* We many not be in conf-t mode -- that's fine */ if(noit_console_mkcheck_xpath(xpath, sizeof(xpath), info, argc ? argv[0] : NULL)) { nc_printf(ncct, "could not find check '%s'\n", argv[0]); return -1; } pobj = xmlXPathEval((xmlChar *)xpath, xpath_ctxt); if(!pobj || pobj->type != XPATH_NODESET || xmlXPathNodeSetIsEmpty(pobj->nodesetval)) { nc_printf(ncct, "no checks found\n"); goto out; } cnt = xmlXPathNodeSetGetLength(pobj->nodesetval); if(info && cnt != 1) { nc_printf(ncct, "Ambiguous check specified\n"); goto out; } for(i=0; i<cnt; i++) { noit_hash_iter iter = NOIT_HASH_ITER_ZERO; const char *k; int klen; void *data; uuid_t checkid; noit_check_t *check; noit_hash_table *config; xmlNodePtr node, anode, mnode = NULL; char *uuid_conf; char *module, *value; node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i); uuid_conf = (char *)xmlGetProp(node, (xmlChar *)"uuid"); if(!uuid_conf || uuid_parse(uuid_conf, checkid)) { nc_printf(ncct, "%s has invalid or missing UUID!\n", (char *)xmlGetNodePath(node) + strlen("/noit")); continue; } nc_printf(ncct, "==== %s ====\n", uuid_conf); #define MYATTR(a,n,b) _noit_conf_get_string(node, &(n), "@" #a, &(b)) #define INHERIT(a,n,b) \ _noit_conf_get_string(node, &(n), "ancestor-or-self::node()/@" #a, &(b)) #define SHOW_ATTR(a) do { \ anode = NULL; \ value = NULL; \ INHERIT(a, anode, value); \ nc_attr_show(ncct, #a, node, anode, value); \ } while(0) if(!INHERIT(module, mnode, module)) module = NULL; if(MYATTR(name, anode, value)) nc_printf(ncct, " name: %s\n", value); else nc_printf(ncct, " name: %s [from module]\n", module ? module : "[undef]"); nc_attr_show(ncct, "module", node, mnode, module); SHOW_ATTR(target); SHOW_ATTR(period); SHOW_ATTR(timeout); SHOW_ATTR(oncheck); SHOW_ATTR(filterset); SHOW_ATTR(disable); /* Print out all the config settings */ config = noit_conf_get_hash(node, "config"); while(noit_hash_next(config, &iter, &k, &klen, &data)) { nc_printf(ncct, " config::%s: %s\n", k, (const char *)data); } noit_hash_destroy(config, free, free); free(config); check = noit_poller_lookup(checkid); if(!check) { nc_printf(ncct, " ERROR: not in running system\n"); } else { int idx = 0; nc_printf(ncct, " currently: "); if(NOIT_CHECK_RUNNING(check)) nc_printf(ncct, "%srunning", idx++?",":""); if(NOIT_CHECK_KILLED(check)) nc_printf(ncct, "%skilled", idx++?",":""); if(!NOIT_CHECK_CONFIGURED(check)) nc_printf(ncct, "%sunconfig", idx++?",":""); if(NOIT_CHECK_DISABLED(check)) nc_printf(ncct, "%sdisabled", idx++?",":""); if(!idx) nc_printf(ncct, "idle"); nc_write(ncct, "\n", 1); if(check->stats.current.whence.tv_sec == 0) { nc_printf(ncct, " last run: never\n"); } else { stats_t *c = &check->stats.current; struct timeval now, diff; gettimeofday(&now, NULL); sub_timeval(now, c->whence, &diff); nc_printf(ncct, " last run: %0.3f seconds ago\n", diff.tv_sec + (diff.tv_usec / 1000000.0)); nc_printf(ncct, " availability/state: %s/%s\n", noit_check_available_string(c->available), noit_check_state_string(c->state)); nc_printf(ncct, " status: %s\n", c->status ? c->status : "[[null]]"); nc_printf(ncct, " metrics:\n"); memset(&iter, 0, sizeof(iter)); while(noit_hash_next(&c->metrics, &iter, &k, &klen, &data)) { char buff[256]; noit_boolean filtered; noit_stats_snprint_metric(buff, sizeof(buff), (metric_t *)data); filtered = !noit_apply_filterset(check->filterset, check, (metric_t *)data); nc_printf(ncct, " %c%s\n", filtered ? '*' : ' ', buff); } } } } out: if(pobj) xmlXPathFreeObject(pobj); return 0; }
static int noit_console_watch_check(noit_console_closure_t ncct, int argc, char **argv, noit_console_state_t *state, void *closure) { int i, cnt; int adding = (int)(vpsized_int)closure; int period = 0; char xpath[1024]; xmlXPathObjectPtr pobj = NULL; xmlXPathContextPtr xpath_ctxt = NULL; noit_conf_xml_xpath(NULL, &xpath_ctxt); if(argc < 1 || argc > 2) { nc_printf(ncct, "requires one or two arguments\n"); return -1; } /* An alternate period */ if(argc == 2) period = atoi(argv[1]); if(noit_console_mkcheck_xpath(xpath, sizeof(xpath), NULL, argc ? argv[0] : NULL)) { nc_printf(ncct, "ERROR: could not find check '%s'\n", argv[0]); return -1; } pobj = xmlXPathEval((xmlChar *)xpath, xpath_ctxt); if(!pobj || pobj->type != XPATH_NODESET || xmlXPathNodeSetIsEmpty(pobj->nodesetval)) { nc_printf(ncct, "no checks found\n"); goto out; } cnt = xmlXPathNodeSetGetLength(pobj->nodesetval); for(i=0; i<cnt; i++) { uuid_t checkid; noit_check_t *check; xmlNodePtr node; char *uuid_conf; node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i); uuid_conf = (char *)xmlGetProp(node, (xmlChar *)"uuid"); if(!uuid_conf || uuid_parse(uuid_conf, checkid)) { nc_printf(ncct, "%s has invalid or missing UUID!\n", (char *)xmlGetNodePath(node) + strlen("/noit")); continue; } if(period == 0) { check = noit_poller_lookup(checkid); if(!check) continue; if(adding) noit_check_transient_add_feed(check, ncct->feed_path); else noit_check_transient_remove_feed(check, ncct->feed_path); } else { if(adding) { check = noit_check_watch(checkid, period); /* This check must be watched from the console */ noit_check_transient_add_feed(check, ncct->feed_path); /* Note the check */ noit_check_log_check(check); /* kick it off, if it isn't running already */ if(!NOIT_CHECK_LIVE(check)) noit_check_activate(check); } else { check = noit_check_get_watch(checkid, period); if(check) noit_check_transient_remove_feed(check, ncct->feed_path); } } } out: if(pobj) xmlXPathFreeObject(pobj); return 0; }
static int noit_console_check(noit_console_closure_t ncct, int argc, char **argv, noit_console_state_t *state, void *closure) { int cnt; noit_conf_t_userdata_t *info; char xpath[1024], newuuid_str[37]; char *uuid_conf, *wanted; uuid_t checkid; xmlXPathContextPtr xpath_ctxt = NULL; xmlXPathObjectPtr pobj = NULL; xmlNodePtr node = NULL; noit_boolean creating_new = noit_false; if(closure) { char *fake_argv[1] = { ".." }; noit_console_state_pop(ncct, 0, argv, NULL, NULL); noit_console_config_cd(ncct, 1, fake_argv, NULL, NULL); } noit_conf_xml_xpath(NULL, &xpath_ctxt); if(argc < 1) { nc_printf(ncct, "requires at least one argument\n"); return -1; } if(argc % 2 == 0) { nc_printf(ncct, "wrong number of arguments\n"); return -1; } info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA); wanted = strcmp(argv[0], "new") ? argv[0] : NULL; if(info && !wanted) { /* We are creating a new node */ uuid_t out; creating_new = noit_true; if(strncmp(info->path, "/checks/", strlen("/checks/")) && strcmp(info->path, "/checks")) { nc_printf(ncct, "New checks must be under /checks/\n"); return -1; } if(noit_conf_mkcheck_under(info->path, argc - 1, argv + 1, out)) { nc_printf(ncct, "Error creating new check\n"); return -1; } newuuid_str[0] = '\0'; uuid_unparse_lower(out, newuuid_str); wanted = newuuid_str; } /* We many not be in conf-t mode -- that's fine */ if(noit_console_mkcheck_xpath(xpath, sizeof(xpath), info, wanted)) { nc_printf(ncct, "could not find check '%s'\n", wanted); return -1; } pobj = xmlXPathEval((xmlChar *)xpath, xpath_ctxt); if(!pobj || pobj->type != XPATH_NODESET || xmlXPathNodeSetIsEmpty(pobj->nodesetval)) { nc_printf(ncct, "no checks found for '%s'\n", wanted); goto out; } cnt = xmlXPathNodeSetGetLength(pobj->nodesetval); if(info && cnt != 1) { nc_printf(ncct, "Ambiguous check specified\n"); goto out; } node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, 0); uuid_conf = (char *)xmlGetProp(node, (xmlChar *)"uuid"); if(!uuid_conf || uuid_parse(uuid_conf, checkid)) { nc_printf(ncct, "%s has invalid or missing UUID!\n", (char *)xmlGetNodePath(node) + strlen("/noit")); goto out; } if(argc > 1 && !creating_new) if(noit_config_check_update_attrs(node, argc - 1, argv + 1)) nc_printf(ncct, "Partially successful, error setting some attributes\n"); if(info) { if(info->path) free(info->path); info->path = strdup((char *)xmlGetNodePath(node) + strlen("/noit")); uuid_copy(info->current_check, checkid); if(argc > 1) refresh_subchecks(ncct, info); if(state) { noit_console_state_push_state(ncct, state); noit_console_state_init(ncct); } goto out; } out: if(pobj) xmlXPathFreeObject(pobj); return 0; }
int cib_process_xpath(const char *op, int options, const char *section, xmlNode * req, xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib, xmlNode ** answer) { int lpc = 0; int max = 0; int rc = pcmk_ok; gboolean is_query = safe_str_eq(op, CIB_OP_QUERY); xmlXPathObjectPtr xpathObj = NULL; crm_trace("Processing \"%s\" event", op); if (is_query) { xpathObj = xpath_search(existing_cib, section); } else { xpathObj = xpath_search(*result_cib, section); } max = numXpathResults(xpathObj); if (max < 1 && safe_str_eq(op, CIB_OP_DELETE)) { crm_debug("%s was already removed", section); } else if (max < 1) { crm_debug("%s: %s does not exist", op, section); rc = -ENXIO; } else if (is_query) { if (max > 1) { *answer = create_xml_node(NULL, "xpath-query"); } } if (safe_str_eq(op, CIB_OP_DELETE) && (options & cib_multiple)) { dedupXpathResults(xpathObj); } for (lpc = 0; lpc < max; lpc++) { xmlChar *path = NULL; xmlNode *match = getXpathResult(xpathObj, lpc); if (match == NULL) { continue; } path = xmlGetNodePath(match); crm_debug("Processing %s op for %s (%s)", op, section, path); free(path); if (safe_str_eq(op, CIB_OP_DELETE)) { if (match == *result_cib) { /* Attempting to delete the whole "/cib" */ crm_warn("Cannot perform %s for %s: The xpath is addressing the whole /cib", op, section); rc = -EINVAL; break; } free_xml(match); if ((options & cib_multiple) == 0) { break; } } else if (safe_str_eq(op, CIB_OP_MODIFY)) { if (update_xml_child(match, input) == FALSE) { rc = -ENXIO; } else if ((options & cib_multiple) == 0) { break; } } else if (safe_str_eq(op, CIB_OP_CREATE)) { add_node_copy(match, input); break; } else if (safe_str_eq(op, CIB_OP_QUERY)) { if (options & cib_no_children) { const char *tag = TYPE(match); xmlNode *shallow = create_xml_node(*answer, tag); copy_in_properties(shallow, match); if (*answer == NULL) { *answer = shallow; } } else if (options & cib_xpath_address) { int path_len = 0; char *path = NULL; xmlNode *parent = match; while (parent && parent->type == XML_ELEMENT_NODE) { int extra = 1; char *new_path = NULL; const char *id = crm_element_value(parent, XML_ATTR_ID); extra += strlen((const char *)parent->name); if (id) { extra += 8; /* [@id=""] */ extra += strlen(id); } path_len += extra; new_path = malloc(path_len + 1); if(new_path == NULL) { break; } else if (id) { snprintf(new_path, path_len + 1, "/%s[@id='%s']%s", parent->name, id, path ? path : ""); } else { snprintf(new_path, path_len + 1, "/%s%s", parent->name, path ? path : ""); } free(path); path = new_path; parent = parent->parent; } crm_trace("Got: %s\n", path); if (*answer == NULL) { *answer = create_xml_node(NULL, "xpath-query"); } parent = create_xml_node(*answer, "xpath-query-path"); crm_xml_add(parent, XML_ATTR_ID, path); free(path); } else if (*answer) { add_node_copy(*answer, match); } else { *answer = match; } } else if (safe_str_eq(op, CIB_OP_REPLACE)) { xmlNode *parent = match->parent; free_xml(match); if (input != NULL) { add_node_copy(parent, input); } if ((options & cib_multiple) == 0) { break; } } } freeXpathObject(xpathObj); return rc; }
ReturnCode saveExternalFiles(xmlNodePtr aNodePtr, TixiDocument* aTixiDocument) { TixiDocumentHandle handle = aTixiDocument->handle; xmlNodePtr cur_node = NULL; xmlNodePtr copiedNode = NULL; char* externalDataDirectory = NULL; char* externalFileName = NULL; char* fullExternalFileName = NULL; char* externalDataNodePath = NULL; char* fullExternalDataNodePath = NULL; xmlDocPtr xmlDocument = NULL; /* find external data nodes */ for (cur_node = aNodePtr; cur_node; cur_node = cur_node->next) { /* recurse down with the next element */ saveExternalFiles(cur_node->children, aTixiDocument); if( checkExternalNode( cur_node ) != SUCCESS) { continue; } if ( cur_node->type == XML_ELEMENT_NODE ) { char* dirResolved = NULL; char* includetNodeName = (char*) xmlGetNodePath(cur_node); /* collect node information - externalFileName */ tixiGetTextAttribute(handle, includetNodeName, EXTERNAL_DATA_XML_ATTR_FILENAME, &externalFileName); /* collect node information - externalDataDirectory */ tixiGetTextAttribute(handle, includetNodeName, EXTERNAL_DATA_XML_ATTR_DIRECTORY, &externalDataDirectory); /* collect node information - externalDataNodePath */ tixiGetTextAttribute(handle, includetNodeName, EXTERNAL_DATA_XML_ATTR_NODEPATH, &externalDataNodePath); free(includetNodeName); /* remove attributes */ xmlUnsetProp(cur_node, (xmlChar*) EXTERNAL_DATA_XML_ATTR_FILENAME); xmlUnsetProp(cur_node, (xmlChar*) EXTERNAL_DATA_XML_ATTR_DIRECTORY); xmlUnsetProp(cur_node, (xmlChar*) EXTERNAL_DATA_XML_ATTR_NODEPATH); /* create new document */ xmlDocument = xmlNewDoc((xmlChar*) "1.0"); if (!xmlDocument) { printMsg(MESSAGETYPE_ERROR, "Error in TIXI::saveExternalFiles ==> Could not create new document.\n"); return FAILED; } /* deep copy of nodes from external files */ copiedNode = xmlDocCopyNode(cur_node, xmlDocument, 1); xmlDocSetRootElement(xmlDocument, copiedNode); dirResolved = resolveDirectory(aTixiDocument->dirname, externalDataDirectory); /* only save to local paths */ if(string_startsWith(dirResolved, "file://") == 0) { char* externalDataDirectoryNotUrl = uriToLocalPath(dirResolved); assert(externalDataDirectoryNotUrl); fullExternalFileName = buildString("%s%s", externalDataDirectoryNotUrl, externalFileName); xmlSaveFormatFileEnc(fullExternalFileName, xmlDocument, "utf-8", 1); free(fullExternalFileName); free(externalDataDirectoryNotUrl); } free(dirResolved); xmlFreeDoc(xmlDocument); /* create external data node structure */ fullExternalDataNodePath = buildString("%s/%s", externalDataNodePath, EXTERNAL_DATA_NODE_NAME); /* add parent node if not exists */ if(tixiCheckElement(handle, fullExternalDataNodePath) != SUCCESS) { tixiAddTextElement(handle, externalDataNodePath, EXTERNAL_DATA_NODE_NAME, ""); tixiAddTextElement(handle, fullExternalDataNodePath, EXTERNAL_DATA_NODE_NAME_PATH, externalDataDirectory); } /* add node for external reference */ tixiAddTextElement(handle, fullExternalDataNodePath, EXTERNAL_DATA_NODE_NAME_FILENAME, externalFileName); /* remove the copied nodes from document*/ copiedNode = cur_node->prev; xmlUnlinkNode(cur_node); xmlFreeNode(cur_node); free(fullExternalDataNodePath); cur_node = copiedNode; } } return SUCCESS; }
ReturnCode openExternalFiles(TixiDocument* aTixiDocument, int* number) { int iNode = 0; int handle = aTixiDocument->handle; xmlNodePtr cur = NULL; ReturnCode error = SUCCESS; assert(aTixiDocument != NULL); *number = 0; while(1) { // loop until there are no externaldata nodes included xmlXPathObjectPtr xpathObject = XPathEvaluateExpression(aTixiDocument->docPtr, "//externaldata"); xmlNodeSetPtr nodeset = NULL; char* externalDataNodeXPath, *externalDataDirectoryXPath, *externalDataDirectory, *resolvedDirectory; int externalFileCount = 0; if (!xpathObject) { // no more external data, stop break; } nodeset = xpathObject->nodesetval; if (!nodeset || nodeset->nodeNr < 1) { break; } // goto the first node that is an element for (iNode = 0; iNode < nodeset->nodeNr; ++iNode) { cur = nodeset->nodeTab[iNode]; if (cur->type == XML_ELEMENT_NODE) { break; // for loop } } if (iNode == nodeset->nodeNr) { // no element node found xmlXPathFreeObject(xpathObject); break; // while loop } // found external data node xmlXPathFreeObject(xpathObject); /* get nodes XPath */ externalDataNodeXPath = (char*) xmlGetNodePath(cur); /* now get the subdirectory */ externalDataDirectoryXPath = buildString("%s/%s", externalDataNodeXPath, EXTERNAL_DATA_NODE_NAME_PATH); error = tixiGetTextElement(handle, externalDataDirectoryXPath, &externalDataDirectory); free(externalDataDirectoryXPath); if (error) { printMsg(MESSAGETYPE_ERROR, "Error: openExternalFiles returns %d. No path defined in externaldata node!\n", error); xmlFree(externalDataNodeXPath); return OPEN_FAILED; } // resolv data directory (in case of relative paths) resolvedDirectory = resolveDirectory(aTixiDocument->dirname, externalDataDirectory); /* now get number and names of all external files */ tixiGetNamedChildrenCount(handle, externalDataNodeXPath, EXTERNAL_DATA_NODE_NAME_FILENAME, &externalFileCount); if (externalFileCount == 0) { printMsg(MESSAGETYPE_ERROR, "Error: no filename nodes defined in externalData node.\n"); xmlFree(externalDataNodeXPath); free(resolvedDirectory); return OPEN_FAILED; } for (iNode = 1; iNode <= externalFileCount; iNode++) { char* externalFileName, *externalFullFileName, *newDocumentString, *fileNameXPath; xmlDocPtr xmlDocument = NULL; fileNameXPath = buildString("%s/filename[%d]", externalDataNodeXPath, iNode); tixiGetTextElement(handle, fileNameXPath, &externalFileName); free(fileNameXPath); /* Build complete filename */ externalFullFileName = buildString("%s%s", resolvedDirectory, externalFileName); /* open files */ newDocumentString = loadExternalFileToString(externalFullFileName); if (newDocumentString == NULL) { printMsg(MESSAGETYPE_ERROR, "\nError in fetching external file \"%s\".\n", externalFullFileName); free(externalFullFileName); xmlFree(externalDataNodeXPath); free(resolvedDirectory); return OPEN_FAILED; } /* now parse the file to DOM */ xmlDocument = xmlReadMemory(newDocumentString, (int) strlen(newDocumentString), "urlResource", NULL, 0); free(newDocumentString); if (xmlDocument) { xmlNodePtr rootToInsert = xmlDocGetRootElement(xmlDocument); xmlNodePtr parent = cur->parent; if (parent) { xmlChar* nodePathNew = NULL; char* dataURI = localPathToURI(externalDataDirectory); xmlNodePtr nodeToInsert = xmlDocCopyNode(rootToInsert, aTixiDocument->docPtr, 1); /* add metadata to node, to allow saving external node data */ xmlSetProp(nodeToInsert, (xmlChar*) EXTERNAL_DATA_XML_ATTR_FILENAME, (xmlChar*) externalFileName); /* save the sub-directory */ xmlSetProp(nodeToInsert, (xmlChar*) EXTERNAL_DATA_XML_ATTR_DIRECTORY, (xmlChar*) dataURI); free(dataURI); /* save the external data node position */ nodePathNew = xmlGetNodePath(parent); xmlSetProp(nodeToInsert, (xmlChar*) EXTERNAL_DATA_XML_ATTR_NODEPATH, nodePathNew); xmlFree(nodePathNew); /* replace externalData node with xml file's content */ xmlReplaceNode(cur, nodeToInsert); /* file could be loaded and parsed, increase the counter */ (*number)++; } xmlFreeDoc(xmlDocument); } else { printMsg(MESSAGETYPE_WARNING, "Document %s will be ignored. No valid XML document!\n", externalFullFileName); /* remove external data node */ xmlUnlinkNode(cur); } free(externalFullFileName); } /* end for files */ free(resolvedDirectory); free(externalDataNodeXPath); xmlFreeNode(cur); } if (*number == 0) { printMsg(MESSAGETYPE_WARNING, "WARNING: Unable to load any externaldata files.\n"); } return SUCCESS; }
/** * xmlSchematronReportSuccess: * @ctxt: the validation context * @test: the compiled test * @cur: the current node tested * @success: boolean value for the result * * called from the validation engine when an assert or report test have * been done. */ static void xmlSchematronReportSuccess(xmlSchematronValidCtxtPtr ctxt, xmlSchematronTestPtr test, xmlNodePtr cur, xmlSchematronPatternPtr pattern, int success) { if ((ctxt == NULL) || (cur == NULL) || (test == NULL)) return; /* if quiet and not SVRL report only failures */ if ((ctxt->flags & XML_SCHEMATRON_OUT_QUIET) && ((ctxt->flags & XML_SCHEMATRON_OUT_XML) == 0) && (test->type == XML_SCHEMATRON_REPORT)) return; if (ctxt->flags & XML_SCHEMATRON_OUT_XML) { TODO } else { xmlChar *path; char msg[1000]; long line; const xmlChar *report = NULL; if (((test->type == XML_SCHEMATRON_REPORT) & (!success)) || ((test->type == XML_SCHEMATRON_ASSERT) & (success))) return; line = xmlGetLineNo(cur); path = xmlGetNodePath(cur); if (path == NULL) path = (xmlChar *) cur->name; #if 0 if ((test->report != NULL) && (test->report[0] != 0)) report = test->report; #endif if (test->node != NULL) report = xmlSchematronFormatReport(ctxt, test->node, cur); if (report == NULL) { if (test->type == XML_SCHEMATRON_ASSERT) { report = xmlStrdup((const xmlChar *) "node failed assert"); } else { report = xmlStrdup((const xmlChar *) "node failed report"); } } snprintf(msg, 999, "%s line %ld: %s\n", (const char *) path, line, (const char *) report); if (ctxt->flags & XML_SCHEMATRON_OUT_ERROR) { xmlStructuredErrorFunc schannel = NULL; xmlGenericErrorFunc channel = NULL; void *data = NULL; if (ctxt != NULL) { if (ctxt->serror != NULL) schannel = ctxt->serror; else channel = ctxt->error; data = ctxt->userData; } __xmlRaiseError(schannel, channel, data, NULL, cur, XML_FROM_SCHEMATRONV, (test->type == XML_SCHEMATRON_ASSERT)?XML_SCHEMATRONV_ASSERT:XML_SCHEMATRONV_REPORT, XML_ERR_ERROR, NULL, line, (pattern == NULL)?NULL:((const char *) pattern->name), (const char *) path, (const char *) report, 0, 0, msg); } else { xmlSchematronReportOutput(ctxt, cur, &msg[0]); } xmlFree((char *) report); if ((path != NULL) && (path != (xmlChar *) cur->name)) xmlFree(path); } }
gboolean loadConfig(const gchar *filename, CfgFile *lcfg) { /* Parse hosts.xml document. */ xmlDocPtr xcfg = xmlParseFile(filename); if(xcfg == NULL) return(FALSE); /* Handle Xincludes. */ xmlSetGenericErrorFunc(NULL, xmlErrIgnoreHandler); xmlXIncludeProcess(xcfg); handleXMLError( xmlGetLastError() ); xmlSetGenericErrorFunc(NULL, NULL); /* Validate against DTD. */ xmlValidCtxtPtr xval = xmlNewValidCtxt(); if(xmlValidateDocument(xval, xcfg) == 0) { xmlFreeValidCtxt(xval); return(FALSE); } xmlFreeValidCtxt(xval); /* Allocate XPath context. */ xmlXPathContextPtr xctx = xmlXPathNewContext(xcfg); if(!xctx) { g_error("%s: xmlXPathNewContext failed!\n", filename); return(FALSE); } xmlNodePtr s_ssh[2] = {getXNode(xctx, "/apt-dater/ssh"), NULL}; xmlNodePtr s_path[2] = {getXNode(xctx, "/apt-dater/paths"), NULL}; #ifdef FEAT_TMUX xmlNodePtr s_tmux[2] = {getXNode(xctx, "/apt-dater/tmux"), NULL}; #else xmlNodePtr s_screen[2] = {getXNode(xctx, "/apt-dater/screen"), NULL}; #endif xmlNodePtr s_appearance[2] = {getXNode(xctx, "/apt-dater/appearance"), NULL}; xmlNodePtr s_notify[2] = {getXNode(xctx, "/apt-dater/notify"), NULL}; xmlNodePtr s_hooks[2] = {getXNode(xctx, "/apt-dater/hooks"), NULL}; #ifdef FEAT_AUTOREF xmlNodePtr s_autoref[2] = {getXNode(xctx, "/apt-dater/auto-ref"), NULL}; #endif #ifdef FEAT_HISTORY xmlNodePtr s_history[2] = {getXNode(xctx, "/apt-dater/history"), NULL}; #endif #ifdef FEAT_TCLFILTER xmlNodePtr s_tclfilter[2] = {getXNode(xctx, "/apt-dater/tcl-filter"), NULL}; #endif lcfg->ssh_optflags = getXPropStr(s_ssh, "opt-cmd-flags", "-t"); lcfg->ssh_cmd = getXPropStr(s_ssh, "cmd", "/usr/bin/ssh"); lcfg->sftp_cmd = getXPropStr(s_ssh, "sftp-cmd", "/usr/bin/sftp"); lcfg->umask = getXPropInt(s_path, "umask", S_IRWXG | S_IRWXO); umask(lcfg->umask); lcfg->hostsfile = getXPropStr(s_path, "hosts-file", g_strdup_printf("%s/%s/%s", g_get_user_config_dir(), PROG_NAME, "hosts.xml")); lcfg->statsdir = getXPropStr(s_path, "stats-dir", g_strdup_printf("%s/%s/%s", g_get_user_cache_dir(), PROG_NAME, "stats")); if(g_mkdir_with_parents(lcfg->statsdir, S_IRWXU | S_IRWXG) == -1) { g_warning("Failed to create %s: %s", lcfg->statsdir, g_strerror(errno)); exit(1); } #ifdef FEAT_TMUX lcfg->tmuxconffile = getXPropStr(s_tmux, "conf-file", g_strdup_printf("%s/%s/%s", g_get_user_config_dir(), PROG_NAME, "tmux.conf")); lcfg->tmuxsockpath = getXPropStr(s_tmux, "socket-path", g_strdup_printf("%s/%s/%s", g_get_user_cache_dir(), PROG_NAME, "tmux")); if(g_mkdir_with_parents(lcfg->tmuxsockpath, S_IRWXU | S_IRWXG) == -1) { g_warning("Failed to create %s: %s", lcfg->tmuxsockpath, g_strerror(errno)); exit(1); } #else lcfg->screenrcfile = getXPropStr(s_screen, "rc-file", g_strdup_printf("%s/%s/%s", g_get_user_config_dir(), PROG_NAME, "screenrc")); lcfg->screentitle = getXPropStr(s_screen, "title", g_strdup("%m # %U%H")); #endif lcfg->ssh_agent = getXPropBool(s_ssh, "spawn-agent", FALSE); xmlNodeSetPtr s_addkeys = getXNodes(xctx, "/apt-dater/ssh/add-key"); if(!xmlXPathNodeSetIsEmpty(s_addkeys)) { lcfg->ssh_add = g_new0(char*, s_addkeys->nodeNr + 1); int i; for(i = 0; i < s_addkeys->nodeNr; i++) { lcfg->ssh_add[i] = g_strdup((gchar *)xmlGetProp(s_addkeys->nodeTab[i], BAD_CAST("name"))); xmlChar *c = xmlGetProp(s_addkeys->nodeTab[i], BAD_CAST("fn")); if(!c) { g_printerr(_("Empty SSH key filename (%s/@fn) in configuration."), xmlGetNodePath(s_addkeys->nodeTab[i])); exit(1); } lcfg->ssh_add[i] = g_strdup((gchar *)c); } lcfg->ssh_numadd = s_addkeys->nodeNr; }
static int noit_console_filter_configure(noit_console_closure_t ncct, int argc, char **argv, noit_console_state_t *state, void *closure) { xmlNodePtr parent, fsnode = NULL; int rv = -1; noit_conf_t_userdata_t *info; char xpath[1024]; info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA); if(!info) { nc_printf(ncct, "internal error\n"); goto cleanup; } if(strncmp(info->path, "/filtersets/", strlen("/filtersets/")) && strcmp(info->path, "/filtersets")) { nc_printf(ncct, "filterset only allows inside /filtersets (not %s)\n", info->path); goto cleanup; } if(argc != 1) { nc_printf(ncct, "filterset requires one argument\n"); goto cleanup; } snprintf(xpath, sizeof(xpath), "/%s", info->path); parent = noit_conf_get_section(NULL, xpath); if(!parent) { nc_printf(ncct, "internal error, can't final current working path\n"); goto cleanup; } snprintf(xpath, sizeof(xpath), "filterset[@name=\"%s\"]", argv[0]); fsnode = noit_conf_get_section(parent, xpath); if(closure) { int removed; removed = noit_filter_remove(fsnode); nc_printf(ncct, "%sremoved filterset '%s'\n", removed ? "" : "failed to ", argv[0]); if(removed) { xmlUnlinkNode(fsnode); xmlFreeNode(fsnode); } rv = !removed; goto cleanup; } if(!fsnode) { void *vfs; nc_printf(ncct, "Cannot find filterset '%s'\n", argv[0]); LOCKFS(); if(noit_hash_retrieve(filtersets, argv[0], strlen(argv[0]), &vfs)) { UNLOCKFS(); nc_printf(ncct, "filter of the same name already exists\n"); goto cleanup; } UNLOCKFS(); /* Fine the parent path */ fsnode = xmlNewNode(NULL, (xmlChar *)"filterset"); xmlSetProp(fsnode, (xmlChar *)"name", (xmlChar *)argv[0]); xmlAddChild(parent, fsnode); nc_printf(ncct, "created new filterset\n"); } if(info) { char *xmlpath = NULL; if(info->path) free(info->path); xmlpath = (char *)xmlGetNodePath(fsnode); info->path = strdup(xmlpath + strlen("/noit")); free(xmlpath); strlcpy(info->filter_name, argv[0], sizeof(info->filter_name)); if(state) { noit_console_state_push_state(ncct, state); noit_console_state_init(ncct); } } cleanup: return rv; }