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
}
