SEXP
RS_XML_xmlSchemaValidateDoc(SEXP r_schema, SEXP r_doc, SEXP r_options, SEXP r_errorHandlers)
{
xmlSchemaValidCtxtPtr ctxt;
xmlDocPtr doc = (xmlDocPtr) R_ExternalPtrAddr(r_doc);
xmlSchemaPtr schema = (xmlSchemaPtr) R_ExternalPtrAddr(r_schema);
// ctxt = (xmlSchemaValidCtxtPtr) R_ExternalPtrAddr(r_ctxt);
int status;
int numErrHandlers;
ctxt = xmlSchemaNewValidCtxt(schema);
if(LENGTH(r_options))
xmlSchemaSetValidOptions(ctxt, INTEGER(r_options)[0]);
numErrHandlers = Rf_length(r_errorHandlers);
if(numErrHandlers > 0) {
R_SchemaValidCallback cbinfo;
PROTECT(cbinfo.fun = allocVector(LANGSXP, 2));
SETCAR(cbinfo.fun, VECTOR_ELT(r_errorHandlers, 0));
xmlSchemaSetValidErrors(ctxt, (xmlSchemaValidityErrorFunc) R_schemaValidityErrorFunc,
(xmlSchemaValidityWarningFunc) R_schemaValidityWarningFunc, &cbinfo);
}
status = xmlSchemaValidateDoc(ctxt, doc);
xmlSchemaFreeValidCtxt(ctxt); /* R_alloc this if possible. */
if(numErrHandlers > 0)
UNPROTECT(1);
return(ScalarInteger(status));
}
validity schema::validate(document& doc) const
{
// Check if the schema has been loaded.
if (raw_ == 0)
{
throw bad_dom_operation("failed to validate XML document: schema not loaded");
}
// Create a schema validation context from the schema.
schema_valid_context valid_ctxt(raw_);
if (valid_ctxt.get() == 0)
{
throw internal_dom_error("failed to create xmlSchemaValidCtxt from xmlSchema");
}
// Set validation callback functions, and validate the XML document.
validity result;
xmlSchemaSetValidErrors( valid_ctxt.get(),
&detail::on_validity_error,
&detail::on_validity_warning,
static_cast<void*>(&result) );
int ret_code = xmlSchemaValidateDoc(valid_ctxt.get(), doc.raw_doc());
// Check the return code: 0 if the document is schemas valid, a positive error code number
// otherwise, -1 in case of internal or API error.
if (ret_code >= 0)
{
return result;
}
else
{
throw internal_dom_error("fail to validate: xmlSchemaValidateDoc returned -1");
}
}
int xml_validate(struct xml_node_ctx *ctx, xml_node_t *node,
const char *xml_schema_fname, char **ret_err)
{
xmlDocPtr doc;
xmlNodePtr n;
xmlSchemaParserCtxtPtr pctx;
xmlSchemaValidCtxtPtr vctx;
xmlSchemaPtr schema;
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));
pctx = xmlSchemaNewParserCtxt(xml_schema_fname);
xmlSchemaSetParserErrors(pctx, (xmlSchemaValidityErrorFunc) add_str,
(xmlSchemaValidityWarningFunc) add_str,
&errors);
schema = xmlSchemaParse(pctx);
xmlSchemaFreeParserCtxt(pctx);
vctx = xmlSchemaNewValidCtxt(schema);
xmlSchemaSetValidErrors(vctx, (xmlSchemaValidityErrorFunc) add_str,
(xmlSchemaValidityWarningFunc) add_str,
&errors);
ret = xmlSchemaValidateDoc(vctx, doc);
xmlSchemaFreeValidCtxt(vctx);
xmlFreeDoc(doc);
xmlSchemaFree(schema);
if (ret == 0) {
os_free(errors.buf);
return 0;
} else if (ret > 0) {
if (ret_err)
*ret_err = errors.buf;
else
os_free(errors.buf);
return -1;
} else {
if (ret_err)
*ret_err = errors.buf;
else
os_free(errors.buf);
return -1;
}
}
/**
* Initializes the libxml2 parser.
* @param dtd_filename - path to the DTD or NULL if none
* @param xsd_filename - path to the XSD or NULL if none
* @returns 1 on success or 0 on error
*/
int parser_init(char *dtd_filename, char *xsd_filename)
{
if (dtd_filename){
dtd = xmlParseDTD(NULL,(unsigned char*)dtd_filename);
if (!dtd){
LM_ERR("unsuccesful DTD parsing from file <%s>\n",
dtd_filename);
return 0;
}
dtdCtxt = xmlNewValidCtxt();
dtdCtxt->userData = (void*)stderr;
dtdCtxt->error = (xmlValidityErrorFunc) fprintf;
dtdCtxt->warning = (xmlValidityWarningFunc) fprintf;
}
if (xsd_filename){
xmlSchemaParserCtxtPtr ctxt;
ctxt = xmlSchemaNewParserCtxt(xsd_filename);
if (!ctxt) {
LM_ERR("unsuccesful XSD parsing from file <%s>\n",
xsd_filename);
return 0;
}
xmlSchemaSetParserErrors(ctxt,(xmlValidityErrorFunc) fprintf,(xmlValidityWarningFunc) fprintf,stderr);
xsd = xmlSchemaParse(ctxt);
xmlSchemaFreeParserCtxt(ctxt);
xsdCtxt = xmlSchemaNewValidCtxt(xsd);
xmlSchemaSetValidErrors(xsdCtxt,(xmlValidityErrorFunc) fprintf,(xmlValidityWarningFunc) fprintf,stderr);
}
ctxtInit=1;
return 1;
}
/*
* call-seq:
* document.validate_schema(schema) -> (true|false)
*
* Validate this document against the specified XML::Schema.
*
* If a block is provided it is used as an error handler for validaten errors.
* The block is called with two argument, the message and a flag indication
* if the message is an error (true) or a warning (false).
*/
static VALUE rxml_document_validate_schema(VALUE self, VALUE schema)
{
xmlSchemaValidCtxtPtr vptr;
xmlDocPtr xdoc;
xmlSchemaPtr xschema;
int is_invalid;
Data_Get_Struct(self, xmlDoc, xdoc);
Data_Get_Struct(schema, xmlSchema, xschema);
vptr = xmlSchemaNewValidCtxt(xschema);
xmlSchemaSetValidErrors(vptr,
(xmlSchemaValidityErrorFunc) LibXML_validity_error,
(xmlSchemaValidityWarningFunc) LibXML_validity_warning, NULL);
is_invalid = xmlSchemaValidateDoc(vptr, xdoc);
xmlSchemaFreeValidCtxt(vptr);
if (is_invalid)
{
rxml_raise(&xmlLastError);
return Qfalse;
}
else
{
return Qtrue;
}
}
HRESULT SchemaCache_validate_tree(IXMLDOMSchemaCollection2* iface, xmlNodePtr tree)
{
schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
cache_entry* entry;
xmlChar const* ns = NULL;
TRACE("(%p, %p)\n", This, tree);
if (!tree)
return E_POINTER;
if ((xmlNodePtr)tree->doc == tree)
{
xmlNodePtr root = xmlDocGetRootElement(tree->doc);
if (root && root->ns)
ns = root->ns->href;
}
else if (tree->ns)
{
ns = tree->ns->href;
}
entry = xmlHashLookup(This->cache, ns);
/* TODO: if the ns is not in the cache, and it's a URL,
* do we try to load from that? */
if (entry)
{
if (entry->type == SCHEMA_TYPE_XDR)
{
FIXME("partial stub: XDR schema support not implemented\n");
return S_OK;
}
else if (entry->type == SCHEMA_TYPE_XSD)
{
xmlSchemaValidCtxtPtr svctx;
int err;
/* TODO: if validateOnLoad property is false,
* we probably need to validate the schema here. */
svctx = xmlSchemaNewValidCtxt(entry->schema);
xmlSchemaSetValidErrors(svctx, validate_error, validate_warning, NULL);
#ifdef HAVE_XMLSCHEMASSETVALIDSTRUCTUREDERRORS
xmlSchemaSetValidStructuredErrors(svctx, validate_serror, NULL);
#endif
if ((xmlNodePtr)tree->doc == tree)
err = xmlSchemaValidateDoc(svctx, (xmlDocPtr)tree);
else
err = xmlSchemaValidateOneElement(svctx, tree);
xmlSchemaFreeValidCtxt(svctx);
return err? S_FALSE : S_OK;
}
}
return E_FAIL;
}
/******************* FUNCTION *********************/
void CMRXmlDoc::validateWithSchema ( const string& xsltFile )
{
/* vars */
bool status = true;
xmlSchemaPtr schema;
xmlSchemaValidCtxtPtr vctxt;
xmlSchemaParserCtxtPtr pctxt;
/* errors */
assert(doc != NULL);
assert(rootNode != NULL);
assert(xsltFile.empty() == false);
/* Nothing to do */
if (rootNode == NULL || xsltFile.empty())
return;
/* Open XML schema file */
pctxt = xmlSchemaNewParserCtxt(xsltFile.c_str());
assert(pctxt != NULL);
//assume_m(pctxt != NULL,"Fail to open XML schema file to validate config : %s.",xml_shema_path);
/* Parse the schema */
schema = xmlSchemaParse(pctxt);
xmlSchemaFreeParserCtxt(pctxt);
assert(schema != NULL);
//assume_m(schema != NULL,"Fail to parse the XML schema file to validate config : %s.",xml_shema_path);
/* Create validation context */
if ((vctxt = xmlSchemaNewValidCtxt(schema)) == NULL) {
assert(vctxt != NULL);
//sctk_fatal("Fail to create validation context from XML schema file : %s.",xml_shema_path);
}
/* Create validation output system */
xmlSchemaSetValidErrors(vctxt, (xmlSchemaValidityErrorFunc) fprintf, (xmlSchemaValidityWarningFunc) fprintf, stderr);
/* Validation */
status = (xmlSchemaValidateDoc(vctxt, doc) == 0);
/* Free the schema */
xmlSchemaFree(schema);
xmlSchemaFreeValidCtxt(vctxt);
if (!status)
throw LatexException("XML file is invalid.");
}
void validateDoc(xmlDocPtr doc, std::string baseUri, std::string schemaFile) {
xmlSchemaParserCtxtPtr ctx = xmlSchemaNewParserCtxt(schemaFile.c_str());
if (ctx) {
xmlSchemaSetParserErrors(ctx,(xmlSchemaValidityErrorFunc)errorHandler,(xmlSchemaValidityWarningFunc)warningHandler,nullptr);
xmlSchemaPtr schema = xmlSchemaParse(ctx);
xmlSchemaFreeParserCtxt(ctx);
// validate
xmlSchemaValidCtxtPtr vctx = xmlSchemaNewValidCtxt(schema);
xmlSchemaSetValidErrors(vctx, (xmlSchemaValidityErrorFunc)errorHandler, (xmlSchemaValidityErrorFunc)warningHandler,nullptr);
int ret = xmlSchemaValidateDoc(vctx, doc);
xmlSchemaFreeValidCtxt(vctx);
xmlSchemaFree(schema);
if (ret != 0) {
THROW_EXC("xml file '" << baseUri << "' is not valid");
}
}
}
SEXP
RS_XML_xmlSchemaNewValidCtxt(SEXP r_schema, SEXP r_options, SEXP r_errorHandlers)
{
xmlSchemaPtr schema = (xmlSchemaPtr) R_ExternalPtrAddr(r_schema);
xmlSchemaValidCtxtPtr ctxt;
int numErrHandlers;
ctxt = xmlSchemaNewValidCtxt(schema);
if(LENGTH(r_options))
xmlSchemaSetValidOptions(ctxt, INTEGER(r_options)[0]);
numErrHandlers = LENGTH(r_errorHandlers);
if(numErrHandlers > 0) {
R_SchemaValidCallback *cbinfo = (R_SchemaValidCallback*) malloc(sizeof(R_SchemaValidCallback));
cbinfo->fun = VECTOR_ELT(r_errorHandlers);
xmlSchemaSetValidErrors(routine);
}
return();
}
/*-----------------------------------------------------------------------------------------------------------------------*/
static FIXErrCode xml_validate(xmlDoc* doc, FIXError** error)
{
xmlSchemaParserCtxtPtr pctx = xmlSchemaNewMemParserCtxt(fix_xsd, strlen(fix_xsd));
xmlSchemaPtr schema = xmlSchemaParse(pctx);
if (!schema)
{
return FIX_FAILED;
}
xmlSchemaValidCtxtPtr validCtx = xmlSchemaNewValidCtxt(schema);
xmlSchemaSetValidErrors(validCtx, &xmlErrorHandler, &xmlErrorHandler, error);
int32_t res = xmlSchemaValidateDoc(validCtx, doc);
xmlSchemaFreeValidCtxt(validCtx);
xmlSchemaFree(schema);
xmlSchemaFreeParserCtxt(pctx);
return res ? FIX_FAILED : FIX_SUCCESS;
}
void CLibXmlValidator::validate()
{
if (!xmlFile.length() && !xml.length())
throw MakeStringException(XMLERR_MissingSource, "Source XML not provided");
if (!xsdFile.length() && !xsd.length())
throw MakeStringException(XMLERR_MissingSource, "XML Schema not provided");
xmlParserInputBufferPtr input;
if (xmlFile.length())
input = xmlParserInputBufferCreateFilename(xmlFile.get(), XML_CHAR_ENCODING_NONE);
else
input = xmlParserInputBufferCreateMem(xml.str(), xml.length()+1, XML_CHAR_ENCODING_NONE);
if (!input)
throw MakeStringException(XMLERR_InvalidXml, "Failed to create XML input stream");
xmlSchemaParserCtxtPtr xsdParser;
if (xsdFile.length())
xsdParser = xmlSchemaNewParserCtxt(xsdFile.get());
else
xsdParser = xmlSchemaNewMemParserCtxt(xsd.str(), xsd.length());
if (!xsdParser)
throw MakeStringException(XMLERR_InvalidXsd, "Failed to load XML Schema");
xmlSchemaSetParserErrors(xsdParser, libxmlXsdErrorMsgHandler, libxmlXsdErrorMsgHandler, this);
xmlSchemaPtr schema = xmlSchemaParse(xsdParser);
xmlSchemaFreeParserCtxt(xsdParser);
if (!schema)
throw MakeStringException(XMLERR_InvalidXsd, "XSD schema parsing failed");
xmlSchemaValidCtxtPtr validator = xmlSchemaNewValidCtxt(schema);
xmlSchemaSetValidErrors(validator, libxmlXsdErrorMsgHandler, libxmlXsdErrorMsgHandler, this);
int ret = xmlSchemaValidateStream(validator, input, XML_CHAR_ENCODING_NONE, emptySAXHandler, (void *)this);
if (ret != 0)
{
ensureExceptions()->append(*MakeStringException(XMLERR_XsdValidationFailed, "XML validation failed"));
throw exceptions.getClear();
}
xmlSchemaFreeValidCtxt(validator);
}
int xml2lpc_validate(xml2lpc_context *xmlCtx) {
xmlSchemaValidCtxtPtr validCtx;
xmlSchemaParserCtxtPtr parserCtx;
int ret;
xml2lpc_context_clear_logs(xmlCtx);
parserCtx = xmlSchemaNewDocParserCtxt(xmlCtx->xsd);
validCtx = xmlSchemaNewValidCtxt(xmlSchemaParse(parserCtx));
xmlSchemaSetValidErrors(validCtx, xml2lpc_genericxml_error, xml2lpc_genericxml_warning, xmlCtx);
ret = xmlSchemaValidateDoc(validCtx, xmlCtx->doc);
if(ret > 0) {
if(strlen(xmlCtx->warningBuffer) > 0)
xml2lpc_log(xmlCtx, XML2LPC_WARNING, "%s", xmlCtx->warningBuffer);
if(strlen(xmlCtx->errorBuffer) > 0)
xml2lpc_log(xmlCtx, XML2LPC_ERROR, "%s", xmlCtx->errorBuffer);
} else if(ret < 0) {
xml2lpc_log(xmlCtx, XML2LPC_ERROR, "Internal error");
}
xmlSchemaFreeValidCtxt(validCtx);
return ret;
}
/* process interface.cfg file
iface - name of the interface to process, or "" for all interfaces
dry_run = 1 - test xml without applying anything
dry_run = 0 - test + apply
*/
void opt_process(char *iface, int dry_run) {
char cfg_file_name[FILENAME_MAX];
sprintf(cfg_file_name, "%s/%s", KB_CONFIG_DIR, KB_IFACE_CFG);
xmlDocPtr document = xmlReadFile(cfg_file_name, NULL, 0);
if (NULL == document) { /* can't load */
form_sys_result(KB_ERR, "Can't parse config file");
} else { /* process */
/* check schema compliance */
char schema_file_name[FILENAME_MAX];
sprintf(schema_file_name, "%s/%s", KB_CONFIG_DIR, KB_IFACE_SCHEMA);
xmlSchemaParserCtxtPtr schemaParser = xmlSchemaNewParserCtxt(schema_file_name);
if (NULL != schemaParser) {
xmlSchemaPtr schema = xmlSchemaParse(schemaParser);
if (NULL != schema) {
xmlSchemaValidCtxtPtr validityContext = xmlSchemaNewValidCtxt(schema);
xmlSchemaSetValidErrors(validityContext, schemaErrorCallback, schemaWarningCallback, 0);
if (NULL != validityContext) {
if (0 != xmlSchemaValidateFile(validityContext, cfg_file_name, 0)) {
/* validation error */
schema_error_end();
} else {
/* additional processing */
kb_process_xml(document, iface, dry_run);
}
xmlSchemaFreeValidCtxt(validityContext);
} else {
form_sys_result(KB_ERR, "Can't create validation context");
}
xmlSchemaFree(schema);
} else {
form_sys_result(KB_ERR, "Can't parse schema");
}
xmlSchemaFreeParserCtxt(schemaParser);
} else {
form_sys_result(KB_ERR, "Can't parse schema file");
}
xmlFreeDoc(document);
}
}
bool XMLSchema::validate(xmlDocPtr doc, const std::string& xsd)
{
xmlParserOption parserOption(XML_PARSE_NONET);
xmlDocPtr schemaDoc = xmlReadMemory(xsd.c_str(), xsd.size(),
NULL, NULL, parserOption);
xmlSchemaParserCtxtPtr parserCtxt = xmlSchemaNewDocParserCtxt(schemaDoc);
xmlSchemaSetParserStructuredErrors(parserCtxt,
&OCISchemaParserStructuredErrorHandler, m_global_context);
xmlSchemaPtr schema = xmlSchemaParse(parserCtxt);
xmlSchemaValidCtxtPtr validCtxt = xmlSchemaNewValidCtxt(schema);
xmlSchemaSetValidErrors(validCtxt, &OCISchemaValidityError,
&OCISchemaValidityDebug, m_global_context);
bool valid = (xmlSchemaValidateDoc(validCtxt, doc) == 0);
xmlFreeDoc(schemaDoc);
xmlSchemaFreeParserCtxt(parserCtxt);
xmlSchemaFree(schema);
xmlSchemaFreeValidCtxt(validCtxt);
return valid;
}
static inline HRESULT Schema_validate_tree(xmlSchemaPtr schema, xmlNodePtr tree)
{
xmlSchemaValidCtxtPtr svctx;
int err;
TRACE("(%p, %p)\n", schema, tree);
/* TODO: if validateOnLoad property is false,
* we probably need to validate the schema here. */
svctx = xmlSchemaNewValidCtxt(schema);
xmlSchemaSetValidErrors(svctx, validate_error, validate_warning, NULL);
#ifdef HAVE_XMLSCHEMASSETVALIDSTRUCTUREDERRORS
xmlSchemaSetValidStructuredErrors(svctx, validate_serror, NULL);
#endif
if (tree->type == XML_DOCUMENT_NODE)
err = xmlSchemaValidateDoc(svctx, (xmlDocPtr)tree);
else
err = xmlSchemaValidateOneElement(svctx, tree);
xmlSchemaFreeValidCtxt(svctx);
return err? S_FALSE : S_OK;
}
int main(int argc, char **argv) {
int i;
int files = 0;
xmlSchemaPtr schema = NULL;
for (i = 1; i < argc ; i++) {
#ifdef LIBXML_DEBUG_ENABLED
if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
debug++;
else
#endif
#ifdef HAVE_SYS_MMAN_H
if ((!strcmp(argv[i], "-memory")) || (!strcmp(argv[i], "--memory"))) {
memory++;
} else
#endif
if ((!strcmp(argv[i], "-noout")) || (!strcmp(argv[i], "--noout"))) {
noout++;
}
}
/*xmlLineNumbersDefault(1);*/
for (i = 1; i < argc ; i++) {
if (argv[i][0] != '-') {
if (schema == NULL) {
xmlSchemaParserCtxtPtr ctxt;
#ifdef HAVE_SYS_MMAN_H
if (memory) {
int fd;
struct stat info;
const char *base;
if (stat(argv[i], &info) < 0)
break;
if ((fd = open(argv[i], O_RDONLY)) < 0)
break;
base = mmap(NULL, info.st_size, PROT_READ,
MAP_SHARED, fd, 0) ;
if (base == (void *) MAP_FAILED)
break;
ctxt = xmlSchemaNewMemParserCtxt((char *)base,info.st_size);
xmlSchemaSetParserErrors(ctxt,
(xmlSchemaValidityErrorFunc) fprintf,
(xmlSchemaValidityWarningFunc) fprintf,
stderr);
schema = xmlSchemaParse(ctxt);
xmlSchemaFreeParserCtxt(ctxt);
munmap((char *) base, info.st_size);
} else
#endif
{
/*printf("\n**** CALLING :: xmlSchemaNewParserCtxt argv[i] = %s \n ", argv[i]);*/
printf("\n**** CALLING :: xmlSchemaNewParserCtxt \n ");
ctxt = xmlSchemaNewParserCtxt(argv[i]);
//ctxt = xmlSchemaNewParserCtxt("/root/Code/libxml2-2.6.15/ixml/basic/memory_test.xsd");
printf("\n**** CALLING :: xmlSchemaParse \n ");
xmlSchemaSetParserErrors(ctxt,
(xmlSchemaValidityErrorFunc) fprintf,
(xmlSchemaValidityWarningFunc) fprintf,
stderr);
printf("\n**** CALLING :: xmlSchemaParse \n ");
schema = xmlSchemaParse(ctxt);
xmlSchemaFreeParserCtxt(ctxt);
}
#if 0
#ifdef LIBXML_OUTPUT_ENABLED
#ifdef LIBXML_DEBUG_ENABLED
if (debug)
xmlSchemaDump(stdout, schema);
#endif
#endif /* LIBXML_OUTPUT_ENABLED */
#endif /*#if 0*/
if (schema == NULL)
goto failed_schemas;
} else {
IXML_Document *doc;
printf("\n ***** CALLING :: xmlReadFile:> %s ", argv[i]);
//doc = xmlReadFile(argv[i],NULL,0);
//doc = ixmlLoadDocument("/root/Code/libxml2-2.6.15/ixml/basic/memory_test.xml");
doc = ixmlLoadDocument(argv[i]);
#if 0
printf("nodeName = %s\n",doc->n.firstChild->nodeName);
printf("firstAttr->nodeName = %s\n",doc->n.firstChild->firstChild->firstAttr->nodeName);
printf("firstAttr->nodeValue = %s\n",doc->n.firstChild->firstChild->firstAttr->nodeValue);
printf("firstAttr->nextSibling->nodeName = %s\n",doc->n.firstChild->firstChild->firstAttr->nextSibling->nodeName);
printf("firstAttr->nextSibling->nodeValue = %s\n",doc->n.firstChild->firstChild->firstAttr->nextSibling->nodeValue);
#endif
if (doc == NULL) {
fprintf(stderr, "Could not parse %s\n", argv[i]);
} else {
xmlSchemaValidCtxtPtr ctxt;
int ret;
printf("\n ***** CALLING :: xmlSchemaNewValidCtxt *****\n ");
ctxt = xmlSchemaNewValidCtxt(schema);
printf("\n ***** CALLING :: xmlSchemaSetValidErrors *****\n ");
xmlSchemaSetValidErrors(ctxt,
(xmlSchemaValidityErrorFunc) fprintf,
(xmlSchemaValidityWarningFunc) fprintf,
stderr);
ret = xmlSchemaValidateDoc(ctxt, doc);
#if 0
printf("nodeName = %s\n",doc->n.firstChild->nodeName);
printf("firstAttr->nodeName = %s\n",doc->n.firstChild->firstChild->firstAttr->nodeName);
printf("firstAttr->nodeValue = %s\n",doc->n.firstChild->firstChild->firstAttr->nodeValue);
printf("firstAttr->nextSibling->nodeName = %s\n",doc->n.firstChild->firstChild->firstAttr->nextSibling->nodeName);
printf("firstAttr->nextSibling->nodeValue = %s\n",doc->n.firstChild->firstChild->firstAttr->nextSibling->nodeValue);
#endif
if (ret == 0) {
printf("%s validates\n", argv[i]);
} else if (ret > 0) {
printf("%s fails to validate\n", argv[i]);
} else {
printf("%s validation generated an internal error\n",
argv[i]);
}
xmlSchemaFreeValidCtxt(ctxt);
ixmlDocument_free(doc);
}
}
files ++;
}
}
if (schema != NULL)
xmlSchemaFree(schema);
if (files == 0) {
printf("Usage : %s [--debug] [--noout] schemas XMLfiles ...\n",
argv[0]);
printf("\tParse the HTML files and output the result of the parsing\n");
#ifdef LIBXML_DEBUG_ENABLED
printf("\t--debug : dump a debug tree of the in-memory document\n");
#endif
printf("\t--noout : do not print the result\n");
#ifdef HAVE_SYS_MMAN_H
printf("\t--memory : test the schemas in memory parsing\n");
#endif
}
failed_schemas:
/*printf("\n**** failed_schemas\n");*/
xmlSchemaCleanupTypes();
/*xmlCleanupParser();
xmlResetLastError();
xmlMemoryDump();*/
return(0);
}
int main( int argc, char * argv[] )
{
char * inputname = NULL;
char * dirname = NULL, * dummy = NULL;
int fd = -1, errcode = 0, rc = 0, debug = 0;
size_t length, i, j;
int separator = -1;
psocOptionHandle optHandle;
char * buff = NULL;
bool ok;
#if HAVE_STAT || HAVE__STAT
struct stat status;
struct psocOptStruct opts[2] = {
{ 'i', "input", 0, "input_filename", "Filename for the input (XML)" },
{ 'o', "output", 0, "output_dirname", "Directory name for the output files" }
};
#else
struct psocOptStruct opts[3] = {
{ 'i', "input", 0, "input_filename", "Filename for the input (XML)" },
{ 'l', "length", 0, "input length", "Length of input if stat() not supported" },
{ 'o', "output", 0, "output_dirname", "Directory name for the output files" }
};
#endif
xmlSchemaPtr schema = NULL;
xmlSchemaValidCtxtPtr validCtxt = NULL;
xmlSchemaParserCtxtPtr parserCtxt = NULL;
xmlNode * root = NULL;
xmlDoc * doc = NULL;
xmlChar * prop = NULL;
#if HAVE_STAT || HAVE__STAT
ok = psocSetSupportedOptions( 2, opts, &optHandle );
#else
ok = psocSetSupportedOptions( 3, opts, &optHandle );
#endif
PSO_POST_CONDITION( ok == true || ok == false );
if ( ! ok ) {
fprintf( stderr, "Internal error in psocSetSupportedOptions\n" );
return 1;
}
errcode = psocValidateUserOptions( optHandle, argc, argv, 1 );
if ( errcode < 0 ) {
psocShowUsage( optHandle, argv[0], "" );
return 1;
}
if ( errcode > 0 ) {
psocShowUsage( optHandle, argv[0], "" );
return 0;
}
psocGetShortOptArgument( optHandle, 'i', &inputname );
psocGetShortOptArgument( optHandle, 'o', &dirname );
#if HAVE_STAT || HAVE__STAT
errcode = stat( inputname, &status );
if ( errcode != 0) {
fprintf( stderr, "Cannot access the size of the input file\n" );
return 1;
}
length = status.st_size;
#else
psocGetShortOptArgument( optHandle, 'o', &dummy );
sscanf( dummy, PSO_SIZE_T_FORMAT, &length );
#endif
fd = open( inputname, O_RDONLY );
if ( fd == -1 ) {
fprintf( stderr, "Cannot open the input file\n" );
return 1;
}
buff = (char *)malloc(length + 1 );
if ( buff == NULL ) {
fprintf( stderr, "Memory allocation error\n" );
goto cleanup;
}
i = read( fd, buff, length );
if ( i != length ) {
fprintf( stderr, "Cannot read the input file\n" );
goto cleanup;
}
buff[length] = 0;
if ( debug ) {
doc = xmlReadMemory( buff, i, NULL, NULL, 0 );
}
else {
doc = xmlReadMemory( buff, i, NULL, NULL, XML_PARSE_NOERROR | XML_PARSE_NOWARNING );
}
if ( doc == NULL ) {
fprintf( stderr, "Error reading xml in memory\n" );
errcode = -1;
goto cleanup;
}
root = xmlDocGetRootElement( doc );
if ( root == NULL ) {
fprintf( stderr, "Error: no root\n" );
goto cleanup;
}
// if ( xmlStrcmp( root->name, BAD_CAST "quasar_config") != 0 ) {
// errcode = PSOW_XML_INVALID_ROOT;
// goto cleanup;
// }
prop = xmlGetProp( root, BAD_CAST "schemaLocation" );
if ( prop == NULL ) {
fprintf( stderr, "Error: no schemaLocation property (of root)\n" );
goto cleanup;
}
for ( i = 0; i < xmlStrlen(prop)-1; ++i ) {
if ( isspace(prop[i]) ) {
for ( j = i+1; j < xmlStrlen(prop)-1; ++j ) {
if ( isspace(prop[j]) == 0 ) {
separator = j;
break;
}
}
break;
}
}
if ( separator == -1 ) {
fprintf( stderr, "Error: invalid schemaLocation property (of root)\n" );
goto cleanup;
}
parserCtxt = xmlSchemaNewParserCtxt( (char*)&prop[separator] );
if ( parserCtxt == NULL ) {
fprintf( stderr, "Error: creating new parser context failed\n" );
goto cleanup;
}
schema = xmlSchemaParse( parserCtxt );
if ( schema == NULL ) {
fprintf( stderr, "Error: parsing the schema failed\n" );
goto cleanup;
}
xmlFree( prop );
prop = NULL;
validCtxt = xmlSchemaNewValidCtxt( schema );
if ( validCtxt == NULL ) {
fprintf( stderr, "Error: creating new validation context failed\n" );
goto cleanup;
}
if ( debug ) {
xmlSchemaSetValidErrors( validCtxt,
(xmlSchemaValidityErrorFunc) fprintf,
(xmlSchemaValidityWarningFunc) fprintf,
stderr );
}
else {
xmlSchemaSetValidErrors( validCtxt,
(xmlSchemaValidityErrorFunc) dummyErrorFunc,
(xmlSchemaValidityWarningFunc) dummyErrorFunc,
stderr );
}
if ( xmlSchemaValidateDoc( validCtxt, doc ) != 0 ) {
fprintf( stderr, "Error: document validation failed\n" );
goto cleanup;
}
if ( xmlStrcmp( root->name, BAD_CAST "photon" ) == 0 ) {
/* This is a topFolder and has no name */
errcode = doFolder( root, dirname );
}
else {
prop = xmlGetProp( root, BAD_CAST "objName" );
if ( prop == NULL ) {
fprintf( stderr, "Error getting the name of the root\n" );
goto cleanup;
}
if ( validateName( prop ) != 0 ) {
fprintf( stderr, "Invalid object name = %s\n", (char *) prop );
goto cleanup;
}
rc = mkdir( dirname, 0755 );
if ( rc != 0 ) {
if ( errno != EEXIST ) {
fprintf( stderr, "Creating directory %s failed\n", dirname );
goto cleanup;
}
}
rc = chdir( dirname );
if ( rc != 0 ) {
fprintf( stderr, "cd to directory %s failed\n", dirname );
goto cleanup;
}
if ( xmlStrcmp( root->name, BAD_CAST "folder" ) == 0 ) {
errcode = doFolder( root, (char *)prop );
}
else if ( xmlStrcmp( root->name, BAD_CAST "hashmap") == 0 ) {
rc = doHashMap( root, (char *)prop );
}
else if ( xmlStrcmp( root->name, BAD_CAST "queue") == 0 ) {
rc = doQueue( root, (char *)prop );
}
else {
fprintf( stderr, "Error: root type is invalid\n" );
errcode = -1;
}
rc = chdir( ".." );
if ( rc != 0 ) {
fprintf( stderr, "cd to directory \"..\" failed\n" );
}
}
cleanup:
if ( buff != NULL ) free( buff );
if ( fd != -1 ) close(fd);
if ( parserCtxt ) xmlSchemaFreeParserCtxt( parserCtxt );
if ( schema ) xmlSchemaFree( schema );
if ( validCtxt ) xmlSchemaFreeValidCtxt( validCtxt );
if ( prop ) xmlFree( prop );
if ( doc ) xmlFreeDoc( doc );
/* In case this program is include in a script */
if ( errcode != 0 || rc != 0 ) return 1;
return 0;
}
/**
* \fn msiXmlDocSchemaValidate(msParam_t *xmlObj, msParam_t *xsdObj, msParam_t *status, ruleExecInfo_t *rei)
*
* \brief This microservice validates an XML file against an XSD schema, both iRODS objects.
*
* \module xml
*
* \since pre-2.1
*
* \author Antoine de Torcy
* \date 2008/05/29
*
* \usage See clients/icommands/test/rules3.0/
*
* \param[in] xmlObj - a msParam of type DataObjInp_MS_T or STR_MS_T which is irods path of the XML object.
* \param[in] xsdObj - a msParam of type DataObjInp_MS_T or STR_MS_T which is irods path of the XSD object.
* \param[out] status - a msParam of type INT_MS_T which is a validation result.
* \param[in,out] rei - The RuleExecInfo structure that is automatically
* handled by the rule engine. The user does not include rei as a
* parameter in the rule invocation.
*
* \DolVarDependence None
* \DolVarModified None
* \iCatAttrDependence None
* \iCatAttrModified None
* \sideeffect None
*
* \return integer
* \retval 0 on success
* \pre None
* \post None
* \sa None
**/
int
msiXmlDocSchemaValidate(msParam_t *xmlObj, msParam_t *xsdObj, msParam_t *status, ruleExecInfo_t *rei)
{
/* for parsing msParams and to open iRODS objects */
dataObjInp_t xmlObjInp, *myXmlObjInp;
dataObjInp_t xsdObjInp, *myXsdObjInp;
int xmlObjID, xsdObjID;
/* for getting size of objects to read from */
rodsObjStat_t *rodsObjStatOut = NULL;
/* for reading from iRODS objects */
openedDataObjInp_t openedDataObjInp;
bytesBuf_t *xmlBuf = NULL;
char *tail;
/* for xml parsing and validating */
xmlDocPtr doc, xsd_doc;
xmlSchemaParserCtxtPtr parser_ctxt;
xmlSchemaPtr schema;
xmlSchemaValidCtxtPtr valid_ctxt;
bytesBuf_t *errBuf;
/* misc. to avoid repeating rei->rsComm */
rsComm_t *rsComm;
/************************************* USUAL INIT PROCEDURE **********************************/
/* For testing mode when used with irule --test */
RE_TEST_MACRO (" Calling msiXmlDocSchemaValidate")
/* Sanity checks */
if (rei == NULL || rei->rsComm == NULL)
{
rodsLog (LOG_ERROR, "msiXmlDocSchemaValidate: input rei or rsComm is NULL.");
return (SYS_INTERNAL_NULL_INPUT_ERR);
}
rsComm = rei->rsComm;
/************************************ ADDITIONAL INIT SETTINGS *********************************/
/* XML constants */
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
/* allocate memory for output error buffer */
errBuf = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
errBuf->buf = strdup("");
errBuf->len = strlen((char*)errBuf->buf);
/* Default status is failure, overwrite if success */
fillBufLenInMsParam (status, -1, NULL);
/********************************** RETRIEVE INPUT PARAMS **************************************/
/* Get path of XML document */
rei->status = parseMspForDataObjInp (xmlObj, &xmlObjInp, &myXmlObjInp, 0);
if (rei->status < 0)
{
rodsLog (LOG_ERROR, "msiXmlDocSchemaValidate: input xmlObj error. status = %d", rei->status);
free(errBuf);
return (rei->status);
}
/* Get path of schema */
rei->status = parseMspForDataObjInp (xsdObj, &xsdObjInp, &myXsdObjInp, 0);
if (rei->status < 0)
{
rodsLog (LOG_ERROR, "msiXmlDocSchemaValidate: input xsdObj error. status = %d", rei->status);
free(errBuf);
return (rei->status);
}
/******************************** OPEN AND READ FROM XML OBJECT ********************************/
/* Open XML file */
if ((xmlObjID = rsDataObjOpen(rsComm, &xmlObjInp)) < 0)
{
rodsLog (LOG_ERROR, "msiXmlDocSchemaValidate: Cannot open XML data object. status = %d", xmlObjID);
free(errBuf);
return (xmlObjID);
}
/* Get size of XML file */
rei->status = rsObjStat (rsComm, &xmlObjInp, &rodsObjStatOut);
if (rei->status < 0 || !rodsObjStatOut)
{
rodsLog (LOG_ERROR, "msiXmlDocSchemaValidate: Cannot stat XML data object. status = %d", rei->status);
free(errBuf);
return (rei->status);
}
/* xmlBuf init */
/* memory for xmlBuf->buf is allocated in rsFileRead() */
xmlBuf = (bytesBuf_t *) malloc (sizeof (bytesBuf_t));
memset (xmlBuf, 0, sizeof (bytesBuf_t));
/* Read content of XML file */
memset (&openedDataObjInp, 0, sizeof (openedDataObjInp_t));
openedDataObjInp.l1descInx = xmlObjID;
openedDataObjInp.len = (int)rodsObjStatOut->objSize + 1; /* extra byte to add a null char */
rei->status = rsDataObjRead (rsComm, &openedDataObjInp, xmlBuf);
/* add terminating null character */
tail = (char*)xmlBuf->buf;
tail[openedDataObjInp.len - 1] = '\0';
/* Close XML file */
rei->status = rsDataObjClose (rsComm, &openedDataObjInp);
/* cleanup */
freeRodsObjStat (rodsObjStatOut);
/*************************************** PARSE XML DOCUMENT **************************************/
/* Parse xmlBuf.buf into an xmlDocPtr */
doc = xmlParseDoc((xmlChar*)xmlBuf->buf);
clearBBuf(xmlBuf);
if (doc == NULL)
{
rodsLog (LOG_ERROR, "msiXmlDocSchemaValidate: XML document cannot be loaded or is not well-formed.");
free(errBuf);
xmlCleanupParser();
return (USER_INPUT_FORMAT_ERR);
}
/******************************** OPEN AND READ FROM XSD OBJECT ********************************/
/* Open schema file */
if ((xsdObjID = rsDataObjOpen(rsComm, &xsdObjInp)) < 0)
{
rodsLog (LOG_ERROR, "msiXmlDocSchemaValidate: Cannot open XSD data object. status = %d", xsdObjID);
free(errBuf);
xmlFreeDoc(doc);
xmlCleanupParser();
return (xsdObjID);
}
/* Get size of schema file */
rei->status = rsObjStat (rsComm, &xsdObjInp, &rodsObjStatOut);
/* Read entire schema file */
memset (&openedDataObjInp, 0, sizeof (openedDataObjInp_t));
openedDataObjInp.l1descInx = xsdObjID;
openedDataObjInp.len = (int)rodsObjStatOut->objSize + 1; /* to add null char */
rei->status = rsDataObjRead (rsComm, &openedDataObjInp, xmlBuf);
/* add terminating null character */
tail = (char*)xmlBuf->buf;
tail[openedDataObjInp.len - 1] = '\0';
/* Close schema file */
rei->status = rsDataObjClose (rsComm, &openedDataObjInp);
/* cleanup */
freeRodsObjStat (rodsObjStatOut);
/*************************************** PARSE XSD DOCUMENT **************************************/
/* Parse xmlBuf.buf into an xmlDocPtr */
xsd_doc = xmlParseDoc((xmlChar*)xmlBuf->buf);
clearBBuf(xmlBuf);
if (xsd_doc == NULL)
{
rodsLog (LOG_ERROR, "msiXmlDocSchemaValidate: XML Schema cannot be loaded or is not well-formed.");
free(errBuf);
xmlFreeDoc(doc);
xmlCleanupParser();
return (USER_INPUT_FORMAT_ERR);
}
/**************************************** VALIDATE DOCUMENT **************************************/
/* Create a parser context */
parser_ctxt = xmlSchemaNewDocParserCtxt(xsd_doc);
if (parser_ctxt == NULL)
{
rodsLog (LOG_ERROR, "msiXmlDocSchemaValidate: Unable to create a parser context for the schema.");
free(errBuf);
xmlFreeDoc(xsd_doc);
xmlFreeDoc(doc);
xmlCleanupParser();
return (USER_INPUT_FORMAT_ERR);
}
/* Parse the XML schema */
schema = xmlSchemaParse(parser_ctxt);
if (schema == NULL)
{
rodsLog (LOG_ERROR, "msiXmlDocSchemaValidate: Invalid schema.");
free(errBuf);
xmlSchemaFreeParserCtxt(parser_ctxt);
xmlFreeDoc(doc);
xmlFreeDoc(xsd_doc);
xmlCleanupParser();
return (USER_INPUT_FORMAT_ERR);
}
/* Create a validation context */
valid_ctxt = xmlSchemaNewValidCtxt(schema);
if (valid_ctxt == NULL)
{
rodsLog (LOG_ERROR, "msiXmlDocSchemaValidate: Unable to create a validation context for the schema.");
free(errBuf);
xmlSchemaFree(schema);
xmlSchemaFreeParserCtxt(parser_ctxt);
xmlFreeDoc(xsd_doc);
xmlFreeDoc(doc);
xmlCleanupParser();
return (USER_INPUT_FORMAT_ERR);
}
/* Set myErrorCallback() as the default handler for error messages and warnings */
xmlSchemaSetValidErrors(valid_ctxt, (xmlSchemaValidityErrorFunc)myErrorCallback, (xmlSchemaValidityWarningFunc)myErrorCallback, errBuf);
/* Validate XML doc */
rei->status = xmlSchemaValidateDoc(valid_ctxt, doc);
/******************************************* WE'RE DONE ******************************************/
/* return both error code and messages through status */
resetMsParam (status);
fillBufLenInMsParam (status, rei->status, errBuf);
/* cleanup of all xml parsing stuff */
xmlSchemaFreeValidCtxt(valid_ctxt);
xmlSchemaFree(schema);
xmlSchemaFreeParserCtxt(parser_ctxt);
xmlFreeDoc(doc);
xmlFreeDoc(xsd_doc);
xmlCleanupParser();
return (rei->status);
}
/**
* Validation function take first argument as XML type, then check if is
* well formated. If so, do the same for XSD document. If both success, check
* XML document against XSD schema restrictions.
* @return true if pass, false otherwise
*/
Datum
xmlvalidate_xsd(PG_FUNCTION_ARGS)
{
#ifdef USE_LIBXML
text *data = NULL;
unsigned char *xsd = NULL;
xmlChar *utf8xsd = NULL;
xmltype *xmldata = NULL;
char *xmldataint = NULL;
xmlChar *xmldatastr = NULL;
bool result = false;
int lenxml = -1; // length of xml data
int lenxsd = -1; // length of xsd data
xmlDocPtr doc = NULL;
int ret = -1;
xmlSchemaParserCtxtPtr ctxt = NULL;
xmlSchemaPtr schema = NULL;
xmlSchemaValidCtxtPtr validctxt = NULL;
// creating xmlChar * from internal XML type
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 XSD
data = PG_GETARG_TEXT_P(1);
lenxsd = VARSIZE(data) - VARHDRSZ;
xsd = (unsigned char*)text_to_cstring(data);
//encode XML to internal representation with UTF-8, only one used in LibXML
utf8xsd = pg_do_encoding_conversion(xsd,
lenxsd,
GetDatabaseEncoding(),
PG_UTF8);
//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) {
ereport(ERROR,
(errcode(ERRCODE_INVALID_XML_DOCUMENT),
errmsg("Failed to parse XML document")));
PG_RETURN_BOOL (false);
}
ctxt = xmlSchemaNewMemParserCtxt((const char*)xsd, lenxsd);
if (ctxt == NULL)
{ // unable to create parser context
ereport(ERROR,
(errcode(ERRCODE_INVALID_XML_DOCUMENT),
errmsg("Error with creating schema, check if XSD schema is valid")));
PG_RETURN_BOOL (false);
}
schema = xmlSchemaParse(ctxt); // parse schema
xmlSchemaFreeParserCtxt(ctxt); // realease parser context
validctxt = xmlSchemaNewValidCtxt(schema);
if (validctxt == NULL)
{ // cant create validation context
xmlSchemaFree(schema);
elog(ERROR, "Cant create validation context");
PG_RETURN_BOOL (false);
}
// set errors to SQL errors
xmlSchemaSetValidErrors(validctxt,
xml_error_handler,
NULL,
stderr);
ret = xmlSchemaValidateDoc(validctxt, doc);
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;
}
xmlSchemaFree(schema);
xmlSchemaFreeValidCtxt(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
}
int CPLValidateXML(const char* pszXMLFilename,
const char* pszXSDFilename,
CPL_UNUSED char** papszOptions)
{
char szHeader[2048];
CPLString osTmpXSDFilename;
if( pszXMLFilename[0] == '<' )
{
strncpy(szHeader, pszXMLFilename, sizeof(szHeader));
szHeader[sizeof(szHeader)-1] = '\0';
}
else
{
VSILFILE* fpXML = VSIFOpenL(pszXMLFilename, "rb");
if (fpXML == NULL)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Cannot open %s", pszXMLFilename);
return FALSE;
}
int nRead = (int)VSIFReadL(szHeader, 1, sizeof(szHeader)-1, fpXML);
szHeader[nRead] = '\0';
CPL_IGNORE_RET_VAL(VSIFCloseL(fpXML));
}
/* Workaround following bug : "element FeatureCollection: Schemas validity error : Element '{http://www.opengis.net/wfs}FeatureCollection': No matching global declaration available for the validation root" */
/* We create a wrapping XSD that imports the WFS .xsd (and possibly the GML .xsd too) and the application schema */
/* This is a known libxml2 limitation */
if (strstr(szHeader, "<wfs:FeatureCollection") ||
(strstr(szHeader, "<FeatureCollection") && strstr(szHeader, "xmlns:wfs=\"http://www.opengis.net/wfs\"")))
{
const char* pszWFSSchemaNamespace = "http://www.opengis.net/wfs";
const char* pszWFSSchemaLocation = NULL;
const char* pszGMLSchemaLocation = NULL;
if (strstr(szHeader, "wfs/1.0.0/WFS-basic.xsd"))
{
pszWFSSchemaLocation = "http://schemas.opengis.net/wfs/1.0.0/WFS-basic.xsd";
}
else if (strstr(szHeader, "wfs/1.1.0/wfs.xsd"))
{
pszWFSSchemaLocation = "http://schemas.opengis.net/wfs/1.1.0/wfs.xsd";
}
else if (strstr(szHeader, "wfs/2.0/wfs.xsd"))
{
pszWFSSchemaNamespace = "http://www.opengis.net/wfs/2.0";
pszWFSSchemaLocation = "http://schemas.opengis.net/wfs/2.0/wfs.xsd";
}
VSILFILE* fpXSD = VSIFOpenL(pszXSDFilename, "rb");
if (fpXSD == NULL)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Cannot open %s", pszXSDFilename);
return FALSE;
}
int nRead = (int)VSIFReadL(szHeader, 1, sizeof(szHeader)-1, fpXSD);
szHeader[nRead] = '\0';
CPL_IGNORE_RET_VAL(VSIFCloseL(fpXSD));
if (strstr(szHeader, "gml/3.1.1") != NULL &&
strstr(szHeader, "gml/3.1.1/base/gml.xsd") == NULL)
{
pszGMLSchemaLocation = "http://schemas.opengis.net/gml/3.1.1/base/gml.xsd";
}
if (pszWFSSchemaLocation != NULL)
{
osTmpXSDFilename = CPLSPrintf("/vsimem/CPLValidateXML_%p_%p.xsd", pszXMLFilename, pszXSDFilename);
char* pszEscapedXSDFilename = CPLEscapeString(pszXSDFilename, -1, CPLES_XML);
VSILFILE* fpMEM = VSIFOpenL(osTmpXSDFilename, "wb");
CPL_IGNORE_RET_VAL(VSIFPrintfL(fpMEM, "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">\n"));
CPL_IGNORE_RET_VAL(VSIFPrintfL(fpMEM, " <xs:import namespace=\"%s\" schemaLocation=\"%s\"/>\n", pszWFSSchemaNamespace, pszWFSSchemaLocation));
CPL_IGNORE_RET_VAL(VSIFPrintfL(fpMEM, " <xs:import namespace=\"ignored\" schemaLocation=\"%s\"/>\n", pszEscapedXSDFilename));
if (pszGMLSchemaLocation)
CPL_IGNORE_RET_VAL(VSIFPrintfL(fpMEM, " <xs:import namespace=\"http://www.opengis.net/gml\" schemaLocation=\"%s\"/>\n", pszGMLSchemaLocation));
CPL_IGNORE_RET_VAL(VSIFPrintfL(fpMEM, "</xs:schema>\n"));
CPL_IGNORE_RET_VAL(VSIFCloseL(fpMEM));
CPLFree(pszEscapedXSDFilename);
}
}
CPLXMLSchemaPtr pSchema = CPLLoadXMLSchema(osTmpXSDFilename.size() ? osTmpXSDFilename.c_str() : pszXSDFilename);
if (osTmpXSDFilename.size())
VSIUnlink(osTmpXSDFilename);
if (pSchema == NULL)
return FALSE;
xmlSchemaValidCtxtPtr pSchemaValidCtxt;
pSchemaValidCtxt = xmlSchemaNewValidCtxt((xmlSchemaPtr)pSchema);
if (pSchemaValidCtxt == NULL)
{
CPLFreeXMLSchema(pSchema);
return FALSE;
}
xmlSchemaSetValidErrors(pSchemaValidCtxt,
CPLLibXMLWarningErrorCallback,
CPLLibXMLWarningErrorCallback,
(void*) pszXMLFilename);
bool bValid = false;
if( pszXMLFilename[0] == '<' )
{
xmlDocPtr pDoc = xmlParseDoc((const xmlChar *)pszXMLFilename);
if (pDoc != NULL)
{
bValid = xmlSchemaValidateDoc(pSchemaValidCtxt, pDoc) == 0;
}
xmlFreeDoc(pDoc);
}
else if (!STARTS_WITH(pszXMLFilename, "/vsi"))
{
bValid =
xmlSchemaValidateFile(pSchemaValidCtxt, pszXMLFilename, 0) == 0;
}
else
{
char* pszXML = CPLLoadContentFromFile(pszXMLFilename);
if (pszXML != NULL)
{
xmlDocPtr pDoc = xmlParseDoc((const xmlChar *)pszXML);
if (pDoc != NULL)
{
bValid = xmlSchemaValidateDoc(pSchemaValidCtxt, pDoc) == 0;
}
xmlFreeDoc(pDoc);
}
CPLFree(pszXML);
}
xmlSchemaFreeValidCtxt(pSchemaValidCtxt);
CPLFreeXMLSchema(pSchema);
return bValid;
}
int
test (const char* base) {
xmlDocPtr docPtr = NULL;
char filename[100];
xmlSchemaPtr wxschemas = NULL;
Handle2Path = xmlHashCreate(0);
/* Read the schema. */
{
/* There is no visitibility into parserCtxt. */
xmlSchemaParserCtxtPtr parserCtxt;
/* parserCtxt->ctxtType is xmlSchemaTypePtr */
snprintf(filename, 100, "%s.xsd", base);
printf("\n\n\n----------------------------------------------------------------\n\n\n");
printf("\n----> Reading schema %s...\n", filename);
parserCtxt = xmlSchemaNewParserCtxt(filename);
xmlSchemaSetParserErrors(parserCtxt,
(xmlSchemaValidityErrorFunc) fprintf,
(xmlSchemaValidityWarningFunc) fprintf,
stdout);
xmlSchemaSetParserAnnotation(parserCtxt, schema_annotation_callback, NULL);
wxschemas = xmlSchemaParse(parserCtxt);
if (wxschemas == NULL)
{
printf("***** schema parsing failed!\n");
}
xmlSchemaFreeParserCtxt(parserCtxt);
printf("\n<---- Schema read!\n\n");
}
/* Read the XML. */
{
snprintf(filename, 100, "%s.xml", base);
if ((docPtr = xmlReadFile(filename, NULL, 0)) == NULL)
{
printf("failed to parse \"%s\".\n", filename);
return -1;
}
}
if (!SKIP) {
/* There is no visibility into schemaCtxt. */
xmlSchemaValidCtxtPtr schemaCtxt;
int ret;
printf("\n----------------------------------------------------------------\n");
printf("\n----> Validating document %s...\n", filename);
/* This sets up the schemaCtxt, including a pointer to wxschemas. */
schemaCtxt = xmlSchemaNewValidCtxt(wxschemas);
xmlSchemaSetValidErrors(schemaCtxt,
(xmlSchemaValidityErrorFunc) fprintf,
(xmlSchemaValidityWarningFunc) fprintf,
stdout);
ret = xmlSchemaValidateDoc(schemaCtxt, docPtr); /* read me! */
if (ret == 0)
{
/* printf("%s validates\n", filename); */
}
else if (ret > 0)
{
printf("%s fails to validate\n", filename);
}
else
{
printf("%s validation generated an internal error\n",
filename);
}
xmlSchemaFreeValidCtxt(schemaCtxt);
printf("\n<---- Document validated!\n");
}
/* Generate a doc and validate it. */
{
xmlDocPtr newDoc = xmlNewDoc(BAD_CAST "1.0");
{
xmlSchemaValidCtxtPtr schemaCtxt;
int ret;
schemaCtxt = xmlSchemaNewValidCtxt(wxschemas);
xmlSchemaSetValidErrors(schemaCtxt,
(xmlSchemaValidityErrorFunc) fprintf,
(xmlSchemaValidityWarningFunc) fprintf,
stdout);
xmlSchemaSetGeneratorCallback(schemaCtxt, BAD_CAST "people", NULL, &generation_callback, newDoc);
ret = xmlSchemaValidateDoc(schemaCtxt, newDoc);
if (ret == 0) {
/* xmlDocSetRootElement(newDoc, vctxt->node); */
dump_doc(newDoc, NULL);
} else if (ret > 0)
printf("%s fails to validate\n", filename);
else
printf("%s validation generated an internal error\n",
filename);
xmlSchemaFreeValidCtxt(schemaCtxt);
printf("\n<---- Schema read!\n\n");
}
{
xmlSchemaValidCtxtPtr schemaCtxt;
int ret;
schemaCtxt = xmlSchemaNewValidCtxt(wxschemas);
xmlSchemaSetValidErrors(schemaCtxt,
(xmlSchemaValidityErrorFunc) fprintf,
(xmlSchemaValidityWarningFunc) fprintf,
stdout);
ret = xmlSchemaValidateDoc(schemaCtxt, newDoc);
if (ret == 0)
;
else if (ret > 0)
printf("%s fails to validate\n", filename);
else
printf("%s validation generated an internal error\n",
filename);
xmlSchemaFreeValidCtxt(schemaCtxt);
printf("\n<---- Schema read!\n\n");
}
xmlFreeDoc(newDoc);
}
#if 0
/* why can't I just start with doc->children? */
tree_trunk = xmlDocGetRootElement(docPtr);
#endif
#if 0
tree_trunk = docPtr->children;
printf("\n\n\n----------------------------------------------------------------\n\n\n");
printf("\nWalking doc tree...\n");
walk_doc_tree(tree_trunk, 0);
printf("\n");
#endif
printf("\n\n\n----------------------------------------------------------------\n\n\n");
printf("\nWalking schema tree...\n");
walk_schema_tree(wxschemas);
printf("\n");
/*****************************************************************/
/*****************************************************************/
/*****************************************************************/
/*****************************************************************/
/* This will tell me, for example, how to decode sequences. */
printf("\n\n\n----------------------------------------------------------------\n\n\n");
xmlSchemaDump(stdout, wxschemas);
/*****************************************************************/
/*****************************************************************/
/*****************************************************************/
/*****************************************************************/
xmlFreeDoc(docPtr);
xmlCleanupParser();
xmlHashFree(Handle2Path, NULL);
return 0;
}
/* ************************************************** */
int do_configuration(void) {
xmlSchemaValidCtxtPtr sv_ctxt = NULL;
xmlSchemaParserCtxtPtr sp_ctxt = NULL;
xmlSchemaPtr schema = NULL;
xmlParserCtxtPtr p_ctxt = NULL;
xmlDocPtr doc = NULL;
xmlXPathContextPtr xp_ctx = NULL;
xmlXPathObjectPtr simul_xobj = NULL;
xmlXPathObjectPtr entity_xobj = NULL;
xmlXPathObjectPtr environment_xobj = NULL;
xmlXPathObjectPtr bundle_xobj = NULL;
xmlXPathObjectPtr node_xobj = NULL;
xmlNodeSetPtr nodeset;
xmlpathobj_t xpathobj[] = {{&simul_xobj, (xmlChar *) XML_X_SIMULATION},
{&entity_xobj, (xmlChar *) XML_X_ENTITY},
{&environment_xobj, (xmlChar *) XML_X_ENVIRONMENT},
{&bundle_xobj, (xmlChar *) XML_X_BUNDLE},
{&node_xobj, (xmlChar *) XML_X_NODE}};
int ok = 0, i;
/* Check XML version */
LIBXML_TEST_VERSION;
/* Initialise and parse schema */
sp_ctxt = xmlSchemaNewParserCtxt(schemafile);
if (sp_ctxt == NULL) {
fprintf(stderr, "config: XML schema parser initialisation failure (do_configuration())\n");
ok = -1;
goto cleanup;
}
xmlSchemaSetParserErrors(sp_ctxt,
(xmlSchemaValidityErrorFunc) xml_error,
(xmlSchemaValidityWarningFunc) xml_warning,
NULL);
schema = xmlSchemaParse(sp_ctxt);
if (schema == NULL) {
fprintf(stderr, "config: error in schema %s (do_configuration())\n", schemafile);
ok = -1;
goto cleanup;
}
xmlSchemaSetValidErrors(sv_ctxt,
(xmlSchemaValidityErrorFunc) xml_error,
(xmlSchemaValidityWarningFunc) xml_warning,
NULL);
sv_ctxt = xmlSchemaNewValidCtxt(schema);
if (sv_ctxt == NULL) {
fprintf(stderr, "config: XML schema validator initialisation failure (do_configuration())\n");
ok = -1;
goto cleanup;
}
/* Initialise and parse document */
p_ctxt = xmlNewParserCtxt();
if (p_ctxt == NULL) {
fprintf(stderr, "config: XML parser initialisation failure (do_configuration())\n");
ok = -1;
goto cleanup;
}
doc = xmlCtxtReadFile(p_ctxt, configfile, NULL, XML_PARSE_NONET | XML_PARSE_NOBLANKS | XML_PARSE_NSCLEAN);
if (doc == NULL) {
fprintf(stderr, "config: failed to parse %s (do_configuration())\n", configfile);
ok = -1;
goto cleanup;
}
/* Validate document */
if (xmlSchemaValidateDoc(sv_ctxt, doc)) {
fprintf(stderr, "config: error in configuration file %s (do_configuration())\n", configfile);
ok = -1;
goto cleanup;
}
/* Create xpath context */
xp_ctx = xmlXPathNewContext(doc);
if (xp_ctx == NULL) {
fprintf(stderr, "config: XPath initialisation failure (do_configuration())\n");
ok = -1;
goto cleanup;
}
xmlXPathRegisterNs(xp_ctx, (xmlChar *) XML_NS_ID, (xmlChar *) XML_NS_URL);
/* Get xpath obj */
for (i = 0 ; i < (int) (sizeof(xpathobj) / sizeof(xpathobj[0])); i++) {
*xpathobj[i].ptr = xmlXPathEvalExpression(xpathobj[i].expr, xp_ctx);
if (*xpathobj[i].ptr == NULL) {
fprintf(stderr, "config: unable to evaluate xpath \"%s\" (do_configuration())\n", xpathobj[i].expr);
ok = -1;
goto cleanup;
}
}
/***************/
/* Counting... */
/***************/
nodeset = entity_xobj->nodesetval;
if ((entities.size = (nodeset) ? nodeset->nodeNr : 0) == 0) {
fprintf(stderr, "config: no entity defined (do_configuration())\n");
ok = -1;
goto cleanup;
}
fprintf(stderr, "\nFound %d entities...\n", entities.size);
nodeset = environment_xobj->nodesetval;
if (((nodeset) ? nodeset->nodeNr : 0) == 0) {
fprintf(stderr, "config: no environment defined (do_configuration())\n");
ok = -1;
goto cleanup;
}
fprintf(stderr, "Found 1 environment...\n");
nodeset = bundle_xobj->nodesetval;
if ((bundles.size = (nodeset) ? nodeset->nodeNr : 0) == 0) {
fprintf(stderr, "config: no bundle defined (do_configuration())\n");
ok = -1;
goto cleanup;
}
fprintf(stderr, "Found %d bundles...\n", bundles.size);
if ((dflt_params = das_create()) == NULL) {
ok = -1;
goto cleanup;
}
/**************/
/* Simulation */
/**************/
if (parse_simulation(simul_xobj->nodesetval)) {
ok = -1;
goto cleanup;
}
/**********/
/* Entity */
/**********/
/* initialize library paths */
config_set_usr_modulesdir();
user_path_list = g_strsplit(user_modulesdir, ":", 0); /* TOCLEAN */
sys_path_list = g_strsplit(sys_modulesdir, ":", 0); /* TOCLEAN */
/* parse */
if (parse_entities(entity_xobj->nodesetval)) {
ok = -1;
goto cleanup;
}
/**************/
/* Measure */
/**************/
if (parse_measure()) {
ok = -1;
goto cleanup;
}
/***************/
/* Environment */
/***************/
if (parse_environment(environment_xobj->nodesetval)) {
ok = -1;
goto cleanup;
}
/***************/
/* Bundle */
/***************/
if (parse_bundles(bundle_xobj->nodesetval)) {
ok = -1;
goto cleanup;
}
/***************/
/* Nodes */
/***************/
if (parse_nodes(node_xobj->nodesetval)) {
ok = -1;
goto cleanup;
}
/* edit by Quentin Lampin <*****@*****.**> */
gchar **path = NULL;
for (path = user_path_list ; *path ; path++) {
g_free(*path);
}
path = NULL;
for (path = sys_path_list ; *path ; path++) {
g_free(*path);
}
/* end of edition */
cleanup:
clean_params();
for (i = 0 ; i < (int) (sizeof(xpathobj) / sizeof(xpathobj[0])); i++) {
xmlXPathFreeObject(*xpathobj[i].ptr);
}
if (xp_ctx) {
xmlXPathFreeContext(xp_ctx);
}
if (sp_ctxt) {
xmlSchemaFreeParserCtxt(sp_ctxt);
}
if (schema) {
xmlSchemaFree(schema);
}
if (sv_ctxt) {
xmlSchemaFreeValidCtxt(sv_ctxt);
}
if (doc) {
xmlFreeDoc(doc);
}
if (p_ctxt) {
xmlFreeParserCtxt(p_ctxt);
}
xmlCleanupParser();
return ok;
}
