bool XMLReader::set_relaxng_schema(String source, int type) { SYNC_VM_REGS_SCOPED(); if (source.empty()) { raise_warning("Schema data source is required"); return false; } if (m_ptr) { int ret = -1; xmlRelaxNGPtr schema = nullptr; if (!source.empty()) { schema = _xmlreader_get_relaxNG(source, type, nullptr, nullptr); if (schema) { ret = xmlTextReaderRelaxNGSetSchema(m_ptr, schema); } } else { ret = xmlTextReaderRelaxNGSetSchema(m_ptr, nullptr); } if (ret == 0) { if (m_schema) { xmlRelaxNGFree((xmlRelaxNGPtr) m_schema); } m_schema = schema; return true; } } raise_warning("Unable to set schema. This must be set prior to reading or schema contains errors."); return false; }
/* {{{ php_xmlreader_set_relaxng_schema */ static void php_xmlreader_set_relaxng_schema(INTERNAL_FUNCTION_PARAMETERS, int type) { #ifdef LIBXML_SCHEMAS_ENABLED zval *id; size_t source_len = 0; int retval = -1; xmlreader_object *intern; xmlRelaxNGPtr schema = NULL; char *source; if (zend_parse_parameters(ZEND_NUM_ARGS(), "p!", &source, &source_len) == FAILURE) { return; } if (source != NULL && !source_len) { php_error_docref(NULL, E_WARNING, "Schema data source is required"); RETURN_FALSE; } id = getThis(); intern = Z_XMLREADER_P(id); if (intern && intern->ptr) { if (source) { schema = _xmlreader_get_relaxNG(source, source_len, type, NULL, NULL); if (schema) { retval = xmlTextReaderRelaxNGSetSchema(intern->ptr, schema); } } else { /* unset the associated relaxNG context and schema if one exists */ retval = xmlTextReaderRelaxNGSetSchema(intern->ptr, NULL); } if (retval == 0) { if (intern->schema) { xmlRelaxNGFree((xmlRelaxNGPtr) intern->schema); } intern->schema = schema; RETURN_TRUE; } } php_error_docref(NULL, E_WARNING, "Unable to set schema. This must be set prior to reading or schema contains errors."); RETURN_FALSE; #else php_error_docref(NULL, E_WARNING, "No Schema support built into libxml."); RETURN_FALSE; #endif }
//----------------------------------------- bool RngValidator::run(const std::string& xml_file_pathname, const std::string& rng_file_pathname) //----------------------------------------- { // TODO handle multiple RNG files (eg viz) // RELAX NG Parser Context xmlRelaxNGParserCtxtPtr ctxt = xmlRelaxNGNewParserCtxt(rng_file_pathname.c_str()); xmlRelaxNGSetParserErrors(ctxt, (xmlRelaxNGValidityErrorFunc)RngValidator::rngErr, (xmlRelaxNGValidityWarningFunc)RngValidator::rngWarn, NULL); xmlRelaxNGPtr schema = xmlRelaxNGParse(ctxt); xmlRelaxNGFreeParserCtxt(ctxt); xmlTextReaderPtr reader = xmlNewTextReaderFilename(xml_file_pathname.c_str()); xmlTextReaderRelaxNGSetSchema(reader, schema); xmlTextReaderSetErrorHandler(reader, (xmlTextReaderErrorFunc)RngValidator::readerErr, NULL); xmlTextReaderSetStructuredErrorHandler(reader, (xmlStructuredErrorFunc)RngValidator::structErr, NULL); while (xmlTextReaderRead(reader)); const bool valid = xmlTextReaderIsValid(reader) == 1; xmlFreeTextReader(reader); xmlRelaxNGFree(schema); return valid; }
bool XMLValidationRelaxNG::validate(xmlTextReader * reader, std::string * error) const { int last; int valid; if (errorBuffer) { delete errorBuffer; } errorBuffer = new std::string(); xmlTextReaderSetErrorHandler(reader, (xmlTextReaderErrorFunc) XMLValidation::errorReaderFunction, 0); xmlTextReaderRelaxNGSetSchema(reader, getValidationFile < xmlRelaxNG > ()); while ((last = xmlTextReaderRead(reader)) == 1) ; valid = xmlTextReaderIsValid(reader); xmlTextReaderSetErrorHandler(reader, 0, 0); xmlFreeTextReader(reader); if (last == -1 || valid != 1) { *error = *errorBuffer; return false; } return true; }
/* * call-seq: * reader.relax_ng_validate(rng) -> boolean * * Use RelaxNG to validate the document as it is processed. Activation is only * possible before the first read. If +rng+ is nil, the RelaxNG validation is * desactivated. * * Return true in case the RelaxNG validation could be (des)activated and false in * case of error. */ static VALUE rxml_reader_relax_ng_validate(VALUE self, VALUE rng) { xmlTextReaderPtr xreader = rxml_text_reader_get(self); xmlRelaxNGPtr xrelax; int status; Data_Get_Struct(rng, xmlRelaxNG, xrelax); status = xmlTextReaderRelaxNGSetSchema(xreader, xrelax); return (status == 0 ? Qtrue : Qfalse); }
/** * This is the main function for 'validate' option */ int valMain(int argc, char **argv) { int start; static valOptions ops; static ErrorInfo errorInfo; int invalidFound = 0; int options = XML_PARSE_DTDLOAD | XML_PARSE_DTDATTR; if (argc <= 2) valUsage(argc, argv, EXIT_BAD_ARGS); valInitOptions(&ops); start = valParseOptions(&ops, argc, argv); if (ops.nonet) options |= XML_PARSE_NONET; errorInfo.verbose = ops.err; xmlSetStructuredErrorFunc(&errorInfo, reportError); xmlLineNumbersDefault(1); if (ops.dtd) { /* xmlReader doesn't work with external dtd, have to use SAX * interface */ int i; for (i=start; i<argc; i++) { xmlDocPtr doc; int ret; ret = 0; doc = NULL; errorInfo.filename = argv[i]; doc = xmlReadFile(argv[i], NULL, options); if (doc) { /* TODO: precompile DTD once */ ret = valAgainstDtd(&ops, ops.dtd, doc, argv[i]); xmlFreeDoc(doc); } else { ret = 1; /* Malformed XML or could not open file */ if ((ops.listGood < 0) && !ops.show_val_res) { fprintf(stdout, "%s\n", argv[i]); } } if (ret) invalidFound = 1; if (ops.show_val_res) { if (ret == 0) fprintf(stdout, "%s - valid\n", argv[i]); else fprintf(stdout, "%s - invalid\n", argv[i]); } } } else if (ops.schema || ops.relaxng || ops.embed || ops.wellFormed) { int i; xmlTextReaderPtr reader = NULL; #ifdef LIBXML_SCHEMAS_ENABLED xmlSchemaPtr schema = NULL; xmlSchemaParserCtxtPtr schemaParserCtxt = NULL; xmlSchemaValidCtxtPtr schemaCtxt = NULL; xmlRelaxNGPtr relaxng = NULL; xmlRelaxNGParserCtxtPtr relaxngParserCtxt = NULL; /* there is no xmlTextReaderRelaxNGValidateCtxt() !? */ /* TODO: Do not print debug stuff */ if (ops.schema) { schemaParserCtxt = xmlSchemaNewParserCtxt(ops.schema); if (!schemaParserCtxt) { invalidFound = 2; goto schemaCleanup; } errorInfo.filename = ops.schema; schema = xmlSchemaParse(schemaParserCtxt); if (!schema) { invalidFound = 2; goto schemaCleanup; } xmlSchemaFreeParserCtxt(schemaParserCtxt); schemaCtxt = xmlSchemaNewValidCtxt(schema); if (!schemaCtxt) { invalidFound = 2; goto schemaCleanup; } } else if (ops.relaxng) { relaxngParserCtxt = xmlRelaxNGNewParserCtxt(ops.relaxng); if (!relaxngParserCtxt) { invalidFound = 2; goto schemaCleanup; } errorInfo.filename = ops.relaxng; relaxng = xmlRelaxNGParse(relaxngParserCtxt); if (!relaxng) { invalidFound = 2; goto schemaCleanup; } } #endif /* LIBXML_SCHEMAS_ENABLED */ for (i=start; i<argc; i++) { int ret = 0; if (ops.embed) options |= XML_PARSE_DTDVALID; if (!reader) { reader = xmlReaderForFile(argv[i], NULL, options); } else { ret = xmlReaderNewFile(reader, argv[i], NULL, options); } errorInfo.xmlReader = reader; errorInfo.filename = argv[i]; if (reader && ret == 0) { #ifdef LIBXML_SCHEMAS_ENABLED if (schemaCtxt) { ret = xmlTextReaderSchemaValidateCtxt(reader, schemaCtxt, 0); } else if (relaxng) { ret = xmlTextReaderRelaxNGSetSchema(reader, relaxng); } #endif /* LIBXML_SCHEMAS_ENABLED */ if (ret == 0) { do { ret = xmlTextReaderRead(reader); } while (ret == 1); if (ret != -1 && (schema || relaxng || ops.embed)) ret = !xmlTextReaderIsValid(reader); } } else { if (ops.err) fprintf(stderr, "couldn't read file '%s'\n", errorInfo.filename); ret = 1; /* could not open file */ } if (ret) invalidFound = 1; if (!ops.show_val_res) { if ((ops.listGood > 0) && (ret == 0)) fprintf(stdout, "%s\n", argv[i]); if ((ops.listGood < 0) && (ret != 0)) fprintf(stdout, "%s\n", argv[i]); } else { if (ret == 0) fprintf(stdout, "%s - valid\n", argv[i]); else fprintf(stdout, "%s - invalid\n", argv[i]); } } errorInfo.xmlReader = NULL; xmlFreeTextReader(reader); #ifdef LIBXML_SCHEMAS_ENABLED schemaCleanup: xmlSchemaFreeValidCtxt(schemaCtxt); xmlRelaxNGFree(relaxng); xmlSchemaFree(schema); xmlRelaxNGCleanupTypes(); xmlSchemaCleanupTypes(); #endif /* LIBXML_SCHEMAS_ENABLED */ } xmlCleanupParser(); return invalidFound; }