/** * Initializes the libxml parser. * @param dtd_filename - path to the DTD file * @returns 1 if OK, 0 on error */ int parser_init(char *dtd_filename) { dtd = xmlParseDTD(NULL,(unsigned char*)dtd_filename); if (!dtd){ LOG(L_ERR,"ERR:"M_NAME":parser_init: unsuccesful DTD parsing from file <%s>\n", dtd_filename); return 0; } cvp.userData = (void*)stderr; cvp.error = (xmlValidityErrorFunc) fprintf; cvp.warning = (xmlValidityWarningFunc) fprintf; return 1; }
int xml_validate_dtd(struct xml_node_ctx *ctx, xml_node_t *node, const char *dtd_fname, char **ret_err) { xmlDocPtr doc; xmlNodePtr n; xmlValidCtxt vctx; xmlDtdPtr dtd; int ret; struct str_buf errors; if (ret_err) *ret_err = NULL; doc = xmlNewDoc((xmlChar *) "1.0"); if (doc == NULL) return -1; n = xmlDocCopyNode((xmlNodePtr) node, doc, 1); if (n == NULL) { xmlFreeDoc(doc); return -1; } xmlDocSetRootElement(doc, n); os_memset(&errors, 0, sizeof(errors)); dtd = xmlParseDTD(NULL, (const xmlChar *) dtd_fname); if (dtd == NULL) { xmlFreeDoc(doc); return -1; } os_memset(&vctx, 0, sizeof(vctx)); vctx.userData = &errors; vctx.error = add_str; vctx.warning = add_str; ret = xmlValidateDtd(&vctx, doc, dtd); xmlFreeDoc(doc); xmlFreeDtd(dtd); if (ret == 1) { os_free(errors.buf); return 0; } else { if (ret_err) *ret_err = errors.buf; else os_free(errors.buf); return -1; } }
static gboolean xml_validate (xmlDoc *doc, const gchar *dtd_path) { xmlValidCtxt cvp; xmlDtd *dtd; gboolean ret_val; memset (&cvp, 0, sizeof (cvp)); dtd = xmlParseDTD (NULL, dtd_path); ret_val = xmlValidateDtd (&cvp, doc, dtd); xmlFreeDtd (dtd); return ret_val; }
int _rad_init(void *handle) { if (rad_module_register(handle, RAD_MODVERSION, &modinfo) == -1) return (-1); dtd = xmlParseDTD(NULL, (xmlChar *)"/usr/share/lib/xml/dtd/vpanel.dtd.1"); adr_name_t *name = adr_name_fromstr( "com.oracle.solaris.vp.panel.common.api.panel:type=Panel"); (void) cont_insert_singleton(rad_container, name, &interface_Panel_svr); return (0); }
void XMLParser::setDTD(const std::string& sDTD, const std::string& sDTDName) { AVG_ASSERT(!m_SchemaParserCtxt); AVG_ASSERT(!m_Schema); AVG_ASSERT(!m_SchemaValidCtxt); AVG_ASSERT(!m_DTD); AVG_ASSERT(!m_DTDValidCtxt); registerDTDEntityLoader("memory.dtd", sDTD.c_str()); string sDTDFName = "memory.dtd"; m_DTD = xmlParseDTD(NULL, (const xmlChar*) sDTDFName.c_str()); checkError(!m_DTD, sDTDName); m_DTDValidCtxt = xmlNewValidCtxt(); checkError(!m_DTDValidCtxt, sDTDName); m_DTDValidCtxt->error = xmlParserValidityError; m_DTDValidCtxt->warning = xmlParserValidityWarning; }
/******************* FUNCTION *********************/ void CMRXmlDoc::validateWithDTD ( const string& dtdFile ) { /* vars */ bool status = true; xmlDtdPtr dtd; xmlValidCtxtPtr vctxt; /* errors */ assert(doc != NULL); assert(rootNode != NULL); assert(dtdFile.empty() == false); /* Nothing to do */ if (rootNode == NULL || dtdFile.empty()) return; /* Open XML schema file */ dtd = xmlParseDTD(NULL, BAD_CAST(dtdFile.c_str())); assert(dtd != NULL); //assume_m(pctxt != NULL,"Fail to open XML schema file to validate config : %s.",xml_shema_path); /* Create validation context */ if ((vctxt = xmlNewValidCtxt()) == NULL) { assert(vctxt != NULL); //sctk_fatal("Fail to create validation context from XML schema file : %s.",xml_shema_path); } /* Create validation output system */ vctxt->userData = (void *) stderr; vctxt->error = (xmlValidityErrorFunc) fprintf; vctxt->warning = (xmlValidityWarningFunc) fprintf; /* Validation */ status = (xmlValidateDtd(vctxt, doc,dtd) == 0); /* Free the schema */ xmlFreeDtd(dtd); xmlFreeValidCtxt(vctxt); if (!status) throw LatexException("XML file is invalid."); }
int main(int argc, const char *argv[]) { int status = 0; xmlParserCtxtPtr parser_context = 0; xmlDocPtr doc = 0; xmlDtdPtr dtd = 0; xmlValidCtxtPtr valid_context = 0; do { if (argc < 3) { status = 2; fprintf(stderr, "Too few arguments.\n"); break; } parser_context = xmlNewParserCtxt(); doc = xmlCtxtReadFile(parser_context, argv[1], NULL, 0); if (!doc) { status = 3; fprintf(stderr, "Can't read xml.\n"); break; } dtd = xmlParseDTD(NULL, (const xmlChar *)argv[2]); if (!dtd) { status = 4; fprintf(stderr, "Can't read dtd.\n"); break; } valid_context = xmlNewValidCtxt(); status = xmlValidateDtd(valid_context, doc, dtd) ? 0 : 1; } while (0); if (parser_context) xmlFreeParserCtxt(parser_context); if (doc) xmlFreeDoc(doc); if (dtd) xmlFreeDtd(dtd); if (valid_context) xmlFreeValidCtxt(valid_context); return status; }
void TrackerConfig::loadConfigFile(const string& sFilename) { // TODO: There is duplicated code here and in Player::loadFile which belongs // in a lower-level xml handling class. registerDTDEntityLoader("trackerconfig.dtd", g_pTrackerConfigDTD); xmlDtdPtr dtd; string sDTDFName = "trackerconfig.dtd"; dtd = xmlParseDTD(NULL, (const xmlChar*) sDTDFName.c_str()); if (!dtd) { AVG_LOG_WARNING("DTD not found at " << sDTDFName << ". Not validating trackerconfig files."); } // xmlParseFile crashes for some reason under Lion. string sFileContents; readWholeFile(sFilename, sFileContents); m_Doc = xmlParseMemory(sFileContents.c_str(), sFileContents.length()); if (!m_Doc) { AVG_LOG_ERROR("Could not open tracker config file " << sFilename << ". Using defaults which will probably not work."); return; } xmlValidCtxtPtr cvp = xmlNewValidCtxt(); cvp->error = xmlParserValidityError; cvp->warning = xmlParserValidityWarning; int isValid = xmlValidateDtd(cvp, m_Doc, dtd); xmlFreeValidCtxt(cvp); if (!isValid) { throw (Exception(AVG_ERR_XML_PARSE, sFilename + " does not validate.")); } m_pRoot = xmlDocGetRootElement(m_Doc); xmlFreeDtd(dtd); m_sFilename = sFilename; AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO, "Reading Tracker config file from " << sFilename); }
static xmlEntityPtr xml_process_entities (void *ctxt, const xmlChar *name) { gchar *path; xmlEntityPtr entity; xmlEntityPtr found; xmlChar *tmp; static xmlDocPtr entities = NULL; entity = xmlGetPredefinedEntity (name); if (!entity) { if (!entities) { /* loading HTML entities from external DTD file */ entities = xmlNewDoc (BAD_CAST "1.0"); path = g_build_filename (g_get_user_data_dir (), PACKAGE, "/dtd/html.ent", NULL); xmlCreateIntSubset (entities, BAD_CAST "HTML entities", NULL, BAD_CAST path); g_free (path); entities->extSubset = xmlParseDTD (entities->intSubset->ExternalID, entities->intSubset->SystemID); } if (NULL != (found = xmlGetDocEntity (entities, name))) { /* returning as faked predefined entity... */ tmp = xmlStrdup (found->content); tmp = BAD_CAST unhtmlize ((gchar*) tmp); /* arghh ... slow... */ entity = (xmlEntityPtr) g_new0 (xmlEntity, 1); entity->type = XML_ENTITY_DECL; entity->name = name; entity->orig = NULL; entity->content = tmp; entity->length = g_utf8_strlen ((gchar*) tmp, -1); entity->etype = XML_INTERNAL_PREDEFINED_ENTITY; } } return entity; }
int oph_hier_validate(oph_hier_document * document) { int result; if ((result = oph_hier_basic_control(document)) != OPH_HIER_OK) return result; xmlDtdPtr dtd = xmlParseDTD(NULL, (xmlChar *) OPH_FRAMEWORK_HIERARCHY_DTD_PATH); if (!dtd) { pmesg(LOG_ERROR, __FILE__, __LINE__, "DTD file '%s' not found\n", OPH_FRAMEWORK_HIERARCHY_DTD_PATH); return OPH_HIER_IO_ERR; } xmlValidCtxtPtr cvp = xmlNewValidCtxt(); if (!cvp) { xmlFreeDtd(dtd); pmesg(LOG_ERROR, __FILE__, __LINE__, "Context is not gettable\n"); return OPH_HIER_SYSTEM_ERR; } if (!xmlValidateDtd(cvp, document->document, dtd)) { pmesg(LOG_WARNING, __FILE__, __LINE__, "File is not valid\n"); result = OPH_HIER_XML_ERR; } xmlFreeValidCtxt(cvp); xmlFreeDtd(dtd); return result; }
/* Parse the configuration file. */ int sechk_lib_parse_xml_file(const char *filename, sechk_lib_t * lib) { xmlTextReaderPtr reader = NULL; xmlDtdPtr dtd = NULL; xmlDocPtr xml = NULL; xmlValidCtxtPtr ctxt = NULL; int tmp, ret = 0; char *dtd_path = NULL; /* this initializes the XML library and checks potential ABI mismatches * between the version it was compiled for and the actual shared * library used. */ LIBXML_TEST_VERSION; reader = xmlReaderForFile(filename, NULL, 0); if (!reader) { ret = errno; if (ret != ENOENT) fprintf(stderr, "Error: Could not create xmlReader.\n"); goto exit_err; } dtd_path = build_dtd_path(); if (!dtd_path) { fprintf(stderr, "Error: getting DTD path\n"); goto exit_err; } dtd = xmlParseDTD(NULL, (const xmlChar *)dtd_path); free(dtd_path); if (!dtd) { fprintf(stderr, "Error: parsing DTD\n"); goto exit_err; } xml = xmlParseFile(filename); if (!xml) { fprintf(stderr, "Error: parsing sechecker profile\n"); goto exit_err; } ctxt = xmlNewValidCtxt(); if (!ctxt) { fprintf(stderr, "Error: out of memory\n"); goto exit_err; } /* validate profile against the DTD */ if (xmlValidateDtd(ctxt, xml, dtd) == 0) { fprintf(stderr, "Error: SEChecker profile contains invalid XML. Aborting.\n"); goto exit_err; } xmlFreeValidCtxt(ctxt); xmlFreeDoc(xml); xmlFreeDtd(dtd); while (1) { ret = xmlTextReaderRead(reader); if (ret == -1) { ret = errno; fprintf(stderr, "Error: Error reading xml.\n"); goto exit_err; } if (ret == 0) /* no more nodes to read */ break; tmp = sechk_lib_process_xml_node(reader, lib); if (tmp == -1) goto exit_err; if (tmp == 1) { ret = xmlTextReaderNext(reader); if (ret == 0) break; if (ret == -1) { ret = errno; fprintf(stderr, "Error in xmlTextReaderNext()\n"); goto exit_err; } } } /* cleanup function for the XML library */ xmlCleanupParser(); xmlFreeTextReader(reader); return 0; exit_err: xmlCleanupParser(); if (reader) xmlFreeTextReader(reader); if (ret) errno = ret; return -1; }
/* * call-seq: * XML::Dtd.new("DTD string") -> dtd * XML::Dtd.new("public", "system") -> dtd * XML::Dtd.new("name", "public", "system", document) -> external subset dtd * XML::Dtd.new("name", "public", "system", document, false) -> internal subset dtd * XML::Dtd.new("name", "public", "system", document, true) -> internal subset dtd * * Create a new Dtd from the specified public and system * identifiers. */ static VALUE rxml_dtd_initialize(int argc, VALUE *argv, VALUE self) { VALUE external, system, dtd_string; xmlParserInputBufferPtr buffer; xmlCharEncoding enc = XML_CHAR_ENCODING_NONE; xmlChar *new_string; xmlDtdPtr xdtd; // 1 argument -- string --> parsujeme jako dtd // 2 arguments -- public, system --> bude se hledat // 3 arguments -- public, system, name --> creates an external subset (any parameter may be nil) // 4 arguments -- public, system, name, doc --> creates an external subset (any parameter may be nil) // 5 arguments -- public, system, name, doc, true --> creates an internal subset (all but last parameter may be nil) switch (argc) { case 3: case 4: case 5: { VALUE name, doc, internal; const xmlChar *xname = NULL, *xpublic = NULL, *xsystem = NULL; xmlDocPtr xdoc = NULL; rb_scan_args(argc, argv, "32", &external, &system, &name, &doc, &internal); if (external != Qnil) { Check_Type(external, T_STRING); xpublic = (const xmlChar*) StringValuePtr(external); } if (system != Qnil) { Check_Type(system, T_STRING); xsystem = (const xmlChar*) StringValuePtr(system); } if (name != Qnil) { Check_Type(name, T_STRING); xname = (const xmlChar*) StringValuePtr(name); } if (doc != Qnil) { if (rb_obj_is_kind_of(doc, cXMLDocument) == Qfalse) rb_raise(rb_eTypeError, "Must pass an XML::Document object"); Data_Get_Struct(doc, xmlDoc, xdoc); } if (internal == Qnil || internal == Qfalse) xdtd = xmlNewDtd(xdoc, xname, xpublic, xsystem); else xdtd = xmlCreateIntSubset(xdoc, xname, xpublic, xsystem); if (xdtd == NULL) rxml_raise(&xmlLastError); /* Document will free this dtd now. */ RDATA(self)->dfree = NULL; DATA_PTR(self) = xdtd; xmlSetTreeDoc((xmlNodePtr) xdtd, xdoc); } break; case 2: rb_scan_args(argc, argv, "20", &external, &system); Check_Type(external, T_STRING); Check_Type(system, T_STRING); xdtd = xmlParseDTD((xmlChar*) StringValuePtr(external), (xmlChar*) StringValuePtr(system)); if (xdtd == NULL) rxml_raise(&xmlLastError); DATA_PTR(self) = xdtd; xmlSetTreeDoc((xmlNodePtr) xdtd, NULL); break; case 1: rb_scan_args(argc, argv, "10", &dtd_string); Check_Type(dtd_string, T_STRING); /* Note that buffer is freed by xmlParserInputBufferPush*/ buffer = xmlAllocParserInputBuffer(enc); new_string = xmlStrdup((xmlChar*) StringValuePtr(dtd_string)); xmlParserInputBufferPush(buffer, xmlStrlen(new_string), (const char*) new_string); xdtd = xmlIOParseDTD(NULL, buffer, enc); if (xdtd == NULL) rxml_raise(&xmlLastError); xmlFree(new_string); DATA_PTR(self) = xdtd; break; default: rb_raise(rb_eArgError, "wrong number of arguments"); } return self; }
/** * Validate XML document against DTD */ int valAgainstDtd(valOptionsPtr ops, char* dtdvalid, xmlDocPtr doc, char* filename) { int result = 0; if (dtdvalid != NULL) { xmlDtdPtr dtd; #if !defined(LIBXML_VALID_ENABLED) xmlGenericError(xmlGenericErrorContext, "libxml2 has no validation support"); return 2; #endif dtd = xmlParseDTD(NULL, (const xmlChar *)dtdvalid); if (dtd == NULL) { xmlGenericError(xmlGenericErrorContext, "Could not parse DTD %s\n", dtdvalid); result = 2; } else { xmlValidCtxtPtr cvp; if ((cvp = xmlNewValidCtxt()) == NULL) { xmlGenericError(xmlGenericErrorContext, "Couldn't allocate validation context\n"); exit(-1); } if (ops->err) { cvp->userData = (void *) stderr; cvp->error = (xmlValidityErrorFunc) fprintf; cvp->warning = (xmlValidityWarningFunc) fprintf; } else { cvp->userData = (void *) NULL; cvp->error = (xmlValidityErrorFunc) NULL; cvp->warning = (xmlValidityWarningFunc) NULL; } if (!xmlValidateDtd(cvp, doc, dtd)) { if ((ops->listGood < 0) && !ops->show_val_res) { fprintf(stdout, "%s\n", filename); } else if (ops->listGood == 0) xmlGenericError(xmlGenericErrorContext, "%s: does not match %s\n", filename, dtdvalid); result = 3; } else { if ((ops->listGood > 0) && !ops->show_val_res) { fprintf(stdout, "%s\n", filename); } } xmlFreeDtd(dtd); xmlFreeValidCtxt(cvp); } } return result; }
int LireDictionnaireCMC(char *fichierXML) { int i, j, k; char buf[BUFSIZ]; char *home; char dtdfile[256]; int done; int inlen, outlen; unsigned char *inbuffer,*outbuffer; extern int xmlDoValidityCheckingDefaultValue; xmlDocPtr doc; xmlNsPtr ns; xmlNodePtr cur; MetvarPtr Metvar; xmlDtdPtr dtd ; xmlValidCtxt ctxt; FILE *fh; LIBXML_TEST_VERSION xmlKeepBlanksDefault(0); /* * build an XML tree from the file; */ doc = xmlParseFile(fichierXML); if (doc == NULL) return(1); /* ----------------------------------------- */ /* Check the document is of the right kind */ /* ------------------------------------------ */ inbuffer=(unsigned char *) malloc(256*sizeof(unsigned char)); outbuffer=(unsigned char *) malloc(256*sizeof(unsigned char)); cur = xmlDocGetRootElement(doc); if (cur == NULL ) { fprintf(stderr,"empty document\n"); xmlFreeDoc(doc); return(1); } printf("root:%s\n",cur->name); /* ---------------------- */ /* Parse the DTD! */ /* ---------------------- */ home = (char *) getenv ("AFSISIO"); strcpy(dtdfile, home); strcat(dtdfile, "/datafiles/constants/dict.dtd"); dtd = xmlParseDTD(NULL,dtdfile); if (! dtd ) { printf("Error Parsing DTD\n"); return (1); } else { printf ("dtd->name:%s\n",dtd->name); } /* ----------------------------------------------------------- */ /* Set up xmlValidCtxt for error reporting when validating */ /* ----------------------------------------------------------- */ ctxt.userData = stderr; ctxt.error = (xmlValidityErrorFunc) fprintf; /* register error function */ ctxt.warning = (xmlValidityWarningFunc) fprintf; /* register warning function */ if ( xmlValidateDtd(&ctxt,doc,dtd) ) { printf("=========Validation Ok!============\n"); } else { printf("========Validation error!===========\n"); return (1); } /* * Now, walk the tree. */ cur = cur->children; while (cur != NULL) { Metvar = parseMetvar(doc, ns, cur); cur = cur->next; } for (i=0; i < nbChampsDict; i++) { printf("*--------------------------------------------------------------\n"); strcpy(inbuffer, infoChamps[i].identifVar[FRANCAIS]); inlen = xmlUTF8Strsize(inbuffer, 256); outlen=256; UTF8Toisolat1(outbuffer,&outlen,inbuffer ,&inlen); outbuffer[outlen]='\0'; strcpy(infoChamps[i].identifVar[FRANCAIS], outbuffer); printf("Champ %03d de %03d\n", i, nbChampsDict); printf("nomvar: %s\n", infoChamps[i].nomVar); printf("\tdesc fr:%s\n", infoChamps[i].identifVar[FRANCAIS]); printf("\tdesc en:%s\n", infoChamps[i].identifVar[ENGLISH]); printf("\tunites:%s\n", infoChamps[i].unitesVar); } xmlFreeDtd(dtd); xmlFreeDoc(doc); return(0); }