/**
* 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);
}
