Bool CXMLDocument::AddDTD(char *data, unsigned long tlength) { if (!isinited()) return False; xmlParserInputBufferPtr dtdInputBufferPtr; xmlDtdPtr dtd; dtdInputBufferPtr = xmlParserInputBufferCreateMem(data, tlength, XML_CHAR_ENCODING_UTF8); dtd = xmlIOParseDTD(NULL, dtdInputBufferPtr, XML_CHAR_ENCODING_UTF8); if (!dtd) return False; if (dtd->name != NULL) xmlFree((char*)dtd->name); CXMLElement telement; GetRootElement(&telement); dtd->name = xmlStrdup((xmlChar *)telement.GetName()); doc->intSubset = dtd; if (dtd->ExternalID != NULL) { xmlFree((xmlChar *) dtd->ExternalID); dtd->ExternalID = NULL; } if (dtd->SystemID != NULL) { xmlFree((xmlChar *) dtd->SystemID); dtd->SystemID = NULL; } dtd->doc = doc; dtd->parent = doc; if (doc->children == NULL) xmlAddChild((xmlNodePtr)doc, (xmlNodePtr)dtd); else xmlAddPrevSibling(doc->children, (xmlNodePtr)dtd); return Validate(); }
/** * Validate epg document in bstring format against dtd */ int epg_validate(const char *xml) { if (!xml) return -1; int rc; xmlValidCtxtPtr ctx = xmlNewValidCtxt(); error_if(ctx == NULL, error, "Error creating validation context"); xmlDocPtr doc = xmlParseMemory((char *)xml, strlen(xml)); error_if(doc == NULL, error, "Error creating Parser"); /* Validate against in memory dtd */ xmlParserInputBufferPtr buf = xmlParserInputBufferCreateMem( xmltv_dtd, strlen(xmltv_dtd), XML_CHAR_ENCODING_NONE); xmlDtdPtr dtd = xmlIOParseDTD(NULL, buf, XML_CHAR_ENCODING_NONE); xmlFreeParserInputBuffer(buf); /* xmlDtdPtr dtd = xmlParseDTD(NULL, BAD_CAST epg_dtd_file); */ rc = xmlValidateDtd(ctx, doc, dtd); trace("Resultado de validación: %d", rc); xmlCleanupParser(); return rc; error: xmlCleanupParser(); return -1; }
gboolean tpaw_xml_validate_from_resource (xmlDoc *doc, const gchar *dtd_resourcename) { GBytes *resourcecontents; gconstpointer resourcedata; gsize resourcesize; xmlParserInputBufferPtr buffer; xmlValidCtxt cvp; xmlDtd *dtd; GError *error = NULL; gboolean ret; DEBUG ("Loading dtd resource %s", dtd_resourcename); resourcecontents = g_resources_lookup_data (dtd_resourcename, G_RESOURCE_LOOKUP_FLAGS_NONE, &error); if (error != NULL) { g_warning ("Unable to load dtd resource '%s': %s", dtd_resourcename, error->message); g_error_free (error); return FALSE; } resourcedata = g_bytes_get_data (resourcecontents, &resourcesize); buffer = xmlParserInputBufferCreateStatic (resourcedata, resourcesize, XML_CHAR_ENCODING_UTF8); memset (&cvp, 0, sizeof (cvp)); dtd = xmlIOParseDTD (NULL, buffer, XML_CHAR_ENCODING_UTF8); ret = xmlValidateDtd (&cvp, doc, dtd); xmlFreeDtd (dtd); g_bytes_unref (resourcecontents); return ret; }
int validateXML(const char *input_file, const char *DTDdata) { int ret = 0; char *XMLdata; xmlDocPtr doc = 0; xmlDtdPtr dtd = 0; xmlValidCtxtPtr cvp = 0; xmlParserInputBufferPtr bp; doc = xmlParseFile(input_file); if (!doc) { printf("xmlParseFile(\"%s\") failed\n", input_file); ret = 1; goto exit; } bp = xmlParserInputBufferCreateMem(DTDdata, strlen(DTDdata), XML_CHAR_ENCODING_NONE); dtd = xmlIOParseDTD(NULL, bp, XML_CHAR_ENCODING_NONE); if (!dtd) { printf("xmlIOParseDTD() failed\n"); ret = 2; goto exit; } cvp = xmlNewValidCtxt(); if (!cvp) { printf("xmlNewValidCtxt() failed\n"); ret = 3; goto exit; } cvp->userData = (void*)stderr; cvp->error = (xmlValidityErrorFunc)fprintf; cvp->warning = (xmlValidityWarningFunc)fprintf; if (!xmlValidateDtd(cvp, doc, dtd)) { printf("xmlValidateDtd() failed\n"); ret = 4; goto exit; } ret = 0; exit: if (doc) { xmlFreeDoc(doc); } if (dtd) { xmlFreeDtd(dtd); } if (cvp) { xmlFreeValidCtxt(cvp); } return ret; }
static bool is_dtd_valid(FILE *input, const char *filename) { bool rc = true; #if HAVE_LIBXML xmlParserCtxtPtr ctx = NULL; xmlDocPtr doc = NULL; xmlDtdPtr dtd = NULL; xmlValidCtxtPtr dtdctx; xmlParserInputBufferPtr buffer; int fd = fileno(input); dtdctx = xmlNewValidCtxt(); ctx = xmlNewParserCtxt(); if (!ctx || !dtdctx) abort(); buffer = xmlParserInputBufferCreateMem(&DTD_DATA_begin, DTD_DATA_len, XML_CHAR_ENCODING_UTF8); if (!buffer) { fprintf(stderr, "Failed to init buffer for DTD.\n"); abort(); } dtd = xmlIOParseDTD(NULL, buffer, XML_CHAR_ENCODING_UTF8); if (!dtd) { fprintf(stderr, "Failed to parse DTD.\n"); abort(); } doc = xmlCtxtReadFd(ctx, fd, filename, NULL, 0); if (!doc) { fprintf(stderr, "Failed to read XML\n"); abort(); } rc = xmlValidateDtd(dtdctx, doc, dtd); xmlFreeDoc(doc); xmlFreeParserCtxt(ctx); xmlFreeDtd(dtd); xmlFreeValidCtxt(dtdctx); /* xmlIOParseDTD consumes buffer */ if (lseek(fd, 0, SEEK_SET) != 0) { fprintf(stderr, "Failed to reset fd, output would be garbage.\n"); abort(); } #endif return rc; }
/* ############################################################################# * * Description add a DTD to the xml document * Author Harry Brueckner * Date 2005-05-04 * Arguments SHOWERROR_FN - callback function for error messages * Return -1 if the DTD could not be updated, 0 if the document did not * validate and 1 if everything is ok */ int checkDtd(SHOWERROR_FN showerror_cb) { xmlDtd* dtd; xmlParserInputBuffer* inputbuffer; xmlValidCtxt* context = xmlNewValidCtxt(); char* dtdbuffer; TRACE(99, "checkDtd()", NULL); if (!xmldoc) { return -1; } xmlRemoveDtd(); /* first we create the DTD as a whole */ dtdbuffer = memAlloc(__FILE__, __LINE__, strlen(dtd_1) + strlen(dtd_2) + strlen(dtd_3) + 1); if (!dtdbuffer) { return -1; } strStrncpy(dtdbuffer, dtd_1, strlen(dtd_1) + 1); strStrncat(dtdbuffer, dtd_2, strlen(dtd_2) + 1); strStrncat(dtdbuffer, dtd_3, strlen(dtd_3) + 1); /* create the xml buffer */ inputbuffer = xmlParserInputBufferCreateMem(dtdbuffer, strlen(dtdbuffer), XML_CHAR_ENCODING_8859_1); memFreeString(__FILE__, __LINE__, dtdbuffer); if (!dtdbuffer) { return -1; } /* and finally create the DTD */ dtd = xmlIOParseDTD(NULL, inputbuffer, XML_CHAR_ENCODING_8859_1); if (!dtd) { return -1; } /* and attach the DTD to the document */ if (!xmldoc -> children) { xmlAddChild((xmlNode*)xmldoc, (xmlNode*)dtd); } else { xmlAddPrevSibling(xmldoc -> children, (xmlNode*)dtd); } /* we set our own error handler */ validateShowError = showerror_cb; context -> error = xmlValidateError; context -> warning = xmlValidateWarning; return xmlValidateDtd(context, xmldoc, dtd); }
Bool CXMLDocument::ValidateDTD(char *data, unsigned long tlength) { if (!isinited()) return False; xmlParserInputBufferPtr dtdInputBufferPtr; xmlDtdPtr dtd; dtdInputBufferPtr = xmlParserInputBufferCreateMem(data, tlength, XML_CHAR_ENCODING_UTF8); dtd = xmlIOParseDTD(NULL, dtdInputBufferPtr, XML_CHAR_ENCODING_UTF8); if (!dtd) return False; xmlValidCtxt ctxt; ctxt.doc = doc; ctxt.userData = NULL; //point to dtd error handling function ctxt.error = errorCallback; ctxt.warning = warningCallback; Bool isvalid = xmlValidateDtd(&ctxt,doc,dtd); xmlFreeDtd(dtd); return isvalid; }
/* * 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; }
/** * Validation function take first argument as XML type, then check if is * well formated. If so, do the same for DTD document. If both success, check * XML document against DTD schema restrictions. * @return true if pass, false otherwise */ Datum xmlvalidate_dtd(PG_FUNCTION_ARGS) { #ifdef USE_LIBXML int ret = -1; xmlValidCtxtPtr validctxt = NULL; xmlDtdPtr dtd = NULL; bool result = false; text *data = NULL; char *dtdstr = NULL; xmltype *xmldata = NULL; char *xmldataint = NULL; xmlChar *xmldatastr = NULL; int lenxml = -1; // length of xml data xmlDocPtr doc = NULL; // creating xmlChar * from internal xmltype of stored XML xmldata = PG_GETARG_XML_P(0); xmldataint = VARDATA(xmldata); lenxml = VARSIZE(xmldata) - VARHDRSZ; xmldatastr = (xmlChar *) palloc((lenxml + 1) * sizeof(xmlChar)); memcpy(xmldatastr, xmldataint, lenxml); xmldatastr[lenxml] = '\0'; // creating xmlChar* from text representation of DTD data = PG_GETARG_TEXT_P(1); dtdstr = text_to_cstring(data); //initialize LibXML structures, if allready done -> do nothing pg_xml_init(); xmlInitParser(); doc = xmlReadMemory((const char *)xmldatastr, lenxml, "include.xml", NULL, 0); if (doc == NULL) { elog(ERROR, "Failed to parse XML document"); PG_RETURN_BOOL (false); } // create DTD from memory, must use XML_CHAR_ENCODING_NONE dtd = xmlIOParseDTD(NULL, xmlParserInputBufferCreateMem(dtdstr, strlen(dtdstr), XML_CHAR_ENCODING_NONE), XML_CHAR_ENCODING_NONE); if (dtd == NULL) { // unable to create parser context elog(ERROR, "Error with creating DTD schema, check if schema is valid"); PG_RETURN_BOOL (false); } validctxt = xmlNewValidCtxt(); if (validctxt == NULL) { // cant create validation context elog(INFO ,"cant create validation context"); xmlFreeDtd(dtd); PG_RETURN_BOOL (false); } ret = xmlValidateDtd(validctxt, doc, dtd); if (ret == 0) { elog(INFO, "Validates"); result = true; } else if (ret > 0) { elog(INFO, "Dont validates"); result = false; } else { elog(INFO, "Validation generated an internal error"); result = false; } xmlFreeDtd(dtd); xmlFreeValidCtxt(validctxt); xmlFreeDoc(doc); // clean up document in memmory xmlCleanupParser(); // clean up stream parser PG_RETURN_BOOL (result); #else NO_XML_SUPPORT(); PG_RETURN_BOOL (false); #endif }