libxml2获取验证错误

Question

I am using libxml2 to validate an xml file against an xsd schema. Using xmlSchemaSetParserErrors function, errors are output to stderr. I need to get these validation errors, store them in memory and display to the user. How can I redirect these errors ? Could you provide me some examples ? Thanks, Andrea

Answer 1

This example uses the validation callback mechanism of the parser module. The signature of callbacks expected by xmlSchemaSetParserErrors seems to be the same.

#include <iostream>
#include <cstdarg>
#include <cstdio>
#include <vector>
#include <string>
#include <iterator>
#include <libxml/parser.h>
#include <libxml/tree.h>

struct ParserContext
{
    ParserContext() : context(xmlNewParserCtxt()) {}
    ~ParserContext() { xmlFreeParserCtxt(context); }
    xmlParserCtxtPtr context;
private:
    ParserContext(ParserContext&);
    void operator=(ParserContext&);
};



struct ErrorHandler
{
    std::vector<std::string> errors;

    void RegisterErrorHandling(xmlValidCtxt& validationContext)
    {
        // Change this to register for schema errors...
        validationContext.userData = this;
        validationContext.error = &ErrorHandler::Handle;
    }

private:
    static void Handle(void *handler, const char *format, ...)
    {
        va_list arguments;
        va_start(arguments, format);
        std::string message = MakeMessage(format, arguments);
        va_end(arguments);

        ErrorHandler* errorHandler = static_cast<ErrorHandler*>(handler);
        errorHandler->errors.push_back(message);
    }

    static std::string MakeMessage(const char* format, va_list arguments)
    {
        const size_t bufferSize = 200;
        std::vector<char> buffer(bufferSize, 0);

        size_t charactersWritten = 
            vsnprintf(&buffer.front(), bufferSize, format, arguments);
        if (charactersWritten == -1)
            buffer.back() = 0;  // Message truncated!
        return std::string(&buffer.front());
    }
};


struct XmlDocument
{
    static XmlDocument FromFile(const char* fileName)
    {
        ParserContext parser;
        ErrorHandler errorHandler;
        errorHandler.RegisterErrorHandling(parser.context->vctxt);
        XmlDocument document(xmlCtxtReadFile(
            parser.context, fileName, NULL, XML_PARSE_DTDVALID));
        document.errors = move(errorHandler.errors);
        return document;
    }

    XmlDocument(XmlDocument&& other) : 
        xmlPointer(other.xmlPointer),
        errors(move(other.errors))
    {
        other.xmlPointer = nullptr;
    }

    ~XmlDocument() 
    { 
        xmlFreeDoc(xmlPointer); 
    }

    xmlDocPtr xmlPointer;
    std::vector<std::string> errors;

private:
    XmlDocument(xmlDocPtr pointer) : xmlPointer(pointer) {}
    XmlDocument(XmlDocument&);
    void operator=(XmlDocument&);
};


void DisplayErrorsToUser(
    const XmlDocument& document, 
    std::ostream& displayStream = std::cout)
{
    using namespace std;
    copy(begin(document.errors), end(document.errors),
        ostream_iterator<string>(displayStream, "\n"));
}

int main()
{
    auto xml = XmlDocument::FromFile("test.xml");
    DisplayErrorsToUser(xml);
}

Answer 2

Or even more concise:

void err(void *ctx, const char *msg, ...)
{
    va_list args;
    va_start(args, msg);
    char *val = va_arg(args,char*);
    va_end(args);
}

val now contains validation errors

Answer 3

As said in the API documentation, xmlSchemaSetParserErrors() Set the callback functions used to handle errors for a validation context.

You need to write two callback functions with respect to defined signature :

• xmlSchemaValidityErrorFunc err
• xmlSchemaValidityWarningFunc warn

An example could be :

void err(void *ctx, const char *msg, ...)
{
  char buf[1024];
  va_list args;

  va_start(args, msg);
  int len = vsnprintf_s(buf, sizeof(buf), sizeof(buf)/sizeof(buf[0]), msg, args);
  va_end(args);

  if(len==0) // Can't create schema validity error!
  else       // Do something to store `buf`, 
             // you may need to use void *ctx to achieve this

  return;
}

Then just call

xmlSchemaSetValidErrors(valid_ctxt_ptr, (xmlSchemaValidityErrorFunc) err, (xmlSchemaValidityWarningFunc) warn, ctx);

before calling

xmlSchemaValidateDoc()