XMLParser::XMLParser(ReadStream &stream, bool makeLower) : _rootNode(0) {
xmlDocPtr xml = 0;
try {
const int options = XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS | XML_PARSE_NONET |
XML_PARSE_NSCLEAN | XML_PARSE_NOCDATA;
xml = xmlReadIO(readStream, closeStream, static_cast<void *>(&stream), "stream.xml", 0, options);
if (!xml)
throw Exception("XML document failed to parse");
xmlNodePtr root = xmlDocGetRootElement(xml);
if (!root)
throw Exception("XML document has no root node");
_rootNode = new XMLNode(*root, makeLower);
} catch (...) {
delete _rootNode;
xmlFreeDoc(xml);
throw;
}
xmlFreeDoc(xml);
}
Bool
compAddMetadataFromIO (CompMetadata *metadata,
xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void *ioctx)
{
xmlDoc **d, *doc;
doc = xmlReadIO (ioread, ioclose, ioctx, NULL, NULL, 0);
if (!doc)
{
compLogMessage ("core", CompLogLevelWarn,
"Unable to parse XML metadata");
return FALSE;
}
d = realloc (metadata->doc, (metadata->nDoc + 1) * sizeof (xmlDoc *));
if (!d)
{
xmlFreeDoc (doc);
return FALSE;
}
d[metadata->nDoc++] = doc;
metadata->doc = d;
return TRUE;
}
/*
* call-seq:
* read_io(io, url, encoding, options)
*
* Create a new document from an IO object
*/
static VALUE read_io( VALUE klass,
VALUE io,
VALUE url,
VALUE encoding,
VALUE options )
{
const char * c_url = (url == Qnil) ? NULL : StringValuePtr(url);
const char * c_enc = (encoding == Qnil) ? NULL : StringValuePtr(encoding);
xmlInitParser();
xmlDocPtr doc = xmlReadIO(
(xmlInputReadCallback)io_read_callback,
(xmlInputCloseCallback)io_close_callback,
(void *)io,
c_url,
c_enc,
NUM2INT(options)
);
if(doc == NULL) {
xmlFreeDoc(doc);
rb_raise(rb_eRuntimeError, "Couldn't create a document");
return Qnil;
}
return Nokogiri_wrap_xml_document(klass, doc);
}
XMLParser::XMLParser(Common::ReadStream &stream, bool makeLower, const Common::UString &fileName) {
initXML();
Common::UString parseError;
xmlSetGenericErrorFunc(static_cast<void *>(&parseError), errorFuncUString);
const int options = XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS | XML_PARSE_NONET |
XML_PARSE_NSCLEAN | XML_PARSE_NOCDATA;
xmlDocPtr xml = xmlReadIO(readStream, closeStream, static_cast<void *>(&stream),
fileName.c_str(), 0, options);
if (!xml) {
Common::Exception e;
if (!parseError.empty())
e.add("%s", parseError.c_str());
e.add("XML document failed to parse");
throw e;
}
BOOST_SCOPE_EXIT( (&xml) ) {
xmlFreeDoc(xml);
} BOOST_SCOPE_EXIT_END
xmlNodePtr root = xmlDocGetRootElement(xml);
if (!root)
throw Common::Exception("XML document has no root node");
_rootNode.reset(new XMLNode(*root, makeLower));
deinitXML();
}
xmlDoc *bz2_fd_read_doc(int fd)
{
struct bz2_file *bzfile = bz2_fd_open(fd);
if (bzfile == NULL) {
return NULL;
}
return xmlReadIO((xmlInputReadCallback) bz2_file_read, bz2_file_close, bzfile, "url", NULL, XML_PARSE_PEDANTIC);
}
xmlDoc *bz2_mem_read_doc(const char *buffer, size_t size)
{
struct bz2_mem *bzmem = bz2_mem_open(buffer, size);
if (bzmem == NULL) {
return NULL;
}
return xmlReadIO((xmlInputReadCallback) bz2_mem_read, bz2_mem_close, bzmem, "url", NULL, XML_PARSE_PEDANTIC);
}
herror_t
soap_env_new_from_stream(http_input_stream_t * in, SoapEnv ** out, int gbk)
{
xmlDocPtr doc;
if (gbk)
doc = xmlReadIO(_soap_env_xml_io_read_gbk,
_soap_env_xml_io_close, in, "", NULL, 0);
else
doc = xmlReadIO(_soap_env_xml_io_read,
_soap_env_xml_io_close, in, "", NULL, 0);
if (in->err != H_OK)
return in->err;
if (doc == NULL)
return herror_new("soap_env_new_from_stream",
XML_ERROR_PARSE, "Trying to parse not valid xml");
return soap_env_new_from_doc(doc, out);
}
static gboolean xspf_playlist_load (const gchar * filename, VFSFile * file,
gchar * * title, Index * filenames, Index * tuples)
{
xmlDoc * doc = xmlReadIO (read_cb, close_cb, file, filename, NULL,
XML_PARSE_RECOVER);
if (! doc)
return FALSE;
* title = NULL;
xmlNode *nptr, *nptr2;
// find trackList
for (nptr = doc->children; nptr != NULL; nptr = nptr->next) {
if (nptr->type == XML_ELEMENT_NODE &&
!xmlStrcmp(nptr->name, (xmlChar *)"playlist")) {
gchar * base;
base = (gchar *)xmlNodeGetBase(doc, nptr);
for (nptr2 = nptr->children; nptr2; nptr2 = nptr2->next)
{
if (nptr2->type != XML_ELEMENT_NODE)
continue;
if (! xmlStrcmp (nptr2->name, (xmlChar *) "title"))
{
xmlChar * xml_title = xmlNodeGetContent (nptr2);
if (xml_title && xml_title[0])
{
str_unref (* title);
* title = str_get ((gchar *) xml_title);
}
xmlFree (xml_title);
}
else if (! xmlStrcmp (nptr2->name, (xmlChar *) "trackList"))
xspf_find_track (nptr2, filename, base, filenames, tuples);
}
xmlFree (base);
}
}
xmlFreeDoc(doc);
return TRUE;
}
Core::BaseObject *Importer::get(std::streambuf* buf) {
if ( _typemap == NULL ) return NULL;
if ( buf == NULL ) return NULL;
_result = NULL;
xmlDocPtr doc;
doc = xmlReadIO(streamBufReadCallback,
streamBufCloseCallback,
buf, NULL, NULL, 0);
if ( doc == NULL )
return NULL;
xmlNodePtr cur = xmlDocGetRootElement(doc);
if ( cur == NULL ) {
xmlFreeDoc(doc);
return NULL;
}
_any.mapper = _typemap;
bool saveStrictNsCheck = NodeHandler::strictNsCheck;
if ( !_headerNode.empty() ) {
// Check the root tag matching "seiscomp"
if ( xmlStrcmp(cur->name, (const xmlChar*)_headerNode.c_str()) ) {
SEISCOMP_WARNING("Invalid root tag: %s, expected: %s", cur->name, _headerNode.c_str());
xmlFreeDoc(doc);
return NULL;
}
NodeHandler::strictNsCheck = _strictNamespaceCheck;
_hasErrors = traverse(&_any, cur, cur->children, NULL) == false;
}
else {
NodeHandler::strictNsCheck = _strictNamespaceCheck;
_hasErrors = traverse(&_any, NULL, cur, NULL) == false;
}
NodeHandler::strictNsCheck = saveStrictNsCheck;
xmlFreeDoc(doc);
return _result;
}
/*
* call-seq:
* read_io(io, url, encoding, options)
*
* Create a new document from an IO object
*/
static VALUE read_io( VALUE klass,
VALUE io,
VALUE url,
VALUE encoding,
VALUE options )
{
const char * c_url = NIL_P(url) ? NULL : StringValuePtr(url);
const char * c_enc = NIL_P(encoding) ? NULL : StringValuePtr(encoding);
VALUE error_list = rb_ary_new();
VALUE document;
xmlDocPtr doc;
xmlResetLastError();
Nokogiri_install_error_catcher(error_list);
doc = xmlReadIO(
(xmlInputReadCallback)io_read_callback,
(xmlInputCloseCallback)io_close_callback,
(void *)io,
c_url,
c_enc,
(int)NUM2INT(options)
);
Nokogiri_remove_error_catcher();
if(doc == NULL) {
xmlErrorPtr error;
xmlFreeDoc(doc);
error = xmlGetLastError();
if(error)
rb_exc_raise(Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error));
else
rb_raise(rb_eRuntimeError, "Could not parse document");
return Qnil;
}
document = Nokogiri_wrap_xml_document(klass, doc);
rb_iv_set(document, "@errors", error_list);
return document;
}
/*
* call-seq:
* read_io(io, url, encoding, options)
*
* Create a new document from an IO object
*/
static VALUE read_io( VALUE klass,
VALUE io,
VALUE url,
VALUE encoding,
VALUE options )
{
const char * c_url = (url == Qnil) ? NULL : StringValuePtr(url);
const char * c_enc = (encoding == Qnil) ? NULL : StringValuePtr(encoding);
VALUE error_list = rb_ary_new();
xmlInitParser();
xmlResetLastError();
xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
xmlDocPtr doc = xmlReadIO(
(xmlInputReadCallback)io_read_callback,
(xmlInputCloseCallback)io_close_callback,
(void *)io,
c_url,
c_enc,
NUM2INT(options)
);
xmlSetStructuredErrorFunc(NULL, NULL);
if(doc == NULL) {
xmlFreeDoc(doc);
xmlErrorPtr error = xmlGetLastError();
if(error)
rb_funcall(rb_mKernel, rb_intern("raise"), 1,
Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error)
);
else
rb_raise(rb_eRuntimeError, "Could not parse document");
return Qnil;
}
VALUE document = Nokogiri_wrap_xml_document(klass, doc);
rb_funcall(document, rb_intern("errors="), 1, error_list);
return document;
}
xmlDocPtr InputBuffer::xmlReadDocument(const char * url, const char * encoding, int options)
{
return xmlReadIO(_buf->readcallback, _buf->closecallback, _buf->context, url, encoding, options);
}
std::shared_ptr<Document> InputBuffer::xmlReadDocument(const char * url, const char * encoding, int options)
{
xmlDocPtr raw = xmlReadIO(_buf->readcallback, _buf->closecallback, _buf->context, url, encoding, options);
return Wrapped<Document>(raw);
}
static InfSession*
infd_note_plugin_text_session_read(InfdStorage* storage,
InfIo* io,
InfCommunicationManager* manager,
const gchar* path,
gpointer user_data,
GError** error)
{
InfUserTable* user_table;
InfTextBuffer* buffer;
InfTextSession* session;
FILE* stream;
xmlDocPtr doc;
xmlErrorPtr xmlerror;
xmlNodePtr root;
xmlNodePtr child;
gboolean result;
g_assert(INFD_IS_FILESYSTEM_STORAGE(storage));
user_table = inf_user_table_new();
buffer = INF_TEXT_BUFFER(inf_text_default_buffer_new("UTF-8"));
/* TODO: Use a SAX parser for better performance */
stream = infd_filesystem_storage_open(
INFD_FILESYSTEM_STORAGE(storage),
"InfText",
path,
"r",
error
);
if(stream == NULL) return FALSE;
doc = xmlReadIO(
infd_note_plugin_text_session_read_read_func,
infd_note_plugin_text_sesison_read_close_func,
stream,
path, /* TODO: Get some "infinote-filesystem-storage://" URL? */
"UTF-8",
XML_PARSE_NOWARNING | XML_PARSE_NOERROR
);
if(doc == NULL)
{
xmlerror = xmlGetLastError();
g_set_error(
error,
g_quark_from_static_string("LIBXML2_PARSER_ERROR"),
xmlerror->code,
"Error parsing XML in file '%s': [%d]: %s",
path,
xmlerror->line,
xmlerror->message
);
result = FALSE;
}
else
{
root = xmlDocGetRootElement(doc);
if(strcmp((const char*)root->name, "inf-text-session") != 0)
{
g_set_error(
error,
g_quark_from_static_string("INF_NOTE_PLUGIN_TEXT_ERROR"),
INFD_NOTE_PLUGIN_TEXT_ERROR_NOT_A_TEXT_SESSION,
"Error processing file '%s': %s",
path,
"The document is not a text session"
);
result = FALSE;
}
else
{
for(child = root->children; child != NULL; child = child->next)
{
if(child->type != XML_ELEMENT_NODE)
continue;
if(strcmp((const char*)child->name, "user") == 0)
{
if(!infd_note_plugin_text_read_user(user_table, child, error))
{
g_prefix_error(error, "Error processing file '%s': ", path);
result = FALSE;
break;
}
}
else if(strcmp((const char*)child->name, "buffer") == 0)
{
if(!infd_note_plugin_text_read_buffer(buffer, user_table,
child, error))
{
g_prefix_error(error, "Error processing file '%s': ", path);
result = FALSE;
break;
}
}
else
{
infd_note_plugin_text_session_unexpected_node(child, error);
g_prefix_error(error, "Error processing file '%s': ", path);
result = FALSE;
break;
}
}
if(child == NULL)
result = TRUE;
}
xmlFreeDoc(doc);
}
if(result == FALSE)
return NULL;
session = inf_text_session_new_with_user_table(
manager,
buffer,
io,
user_table,
INF_SESSION_RUNNING,
NULL,
NULL
);
return INF_SESSION(session);
}
/**
* infd_chat_filesystem_format_read:
* @storage: A #InfdFilesystemStorage.
* @path: Storage path to retrieve the session from.
* @buffer: An empty #InfTextBuffer to use as the new session's buffer.
* @error: Location to store error information, if any, or %NULL.
*
* Reads a chat session from @path in @storage. The file is expected to have
* been saved with infd_chat_filesystem_format_write() before. The @buffer
* parameter should be an empty #InfChatBuffer, and the document will be
* written into this buffer. If the function succeeds, the buffer can be used
* to create an #InfChatSession with inf_chat_session_new(). If the function
* fails, %FALSE is returned and @error is set.
*
* Returns: %TRUE on success or %FALSE on error.
*/
gboolean
infd_chat_filesystem_format_read(InfdFilesystemStorage* storage,
const gchar* path,
InfChatBuffer* buffer,
GError** error)
{
FILE* stream;
gchar* full_path;
gchar* uri;
xmlDocPtr doc;
xmlErrorPtr xmlerror;
xmlNodePtr root;
xmlNodePtr child;
gboolean result;
g_return_val_if_fail(INFD_IS_FILESYSTEM_STORAGE(storage), FALSE);
g_return_val_if_fail(path != NULL, FALSE);
g_return_val_if_fail(INF_IS_CHAT_BUFFER(buffer), FALSE);
g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
/* TODO: Use a SAX parser for better performance */
full_path = NULL;
stream = infd_filesystem_storage_open(
INFD_FILESYSTEM_STORAGE(storage),
"InfChat",
path,
"r",
&full_path,
error
);
if(stream == NULL)
{
g_free(full_path);
return FALSE;
}
uri = g_filename_to_uri(full_path, NULL, error);
g_free(full_path);
if(uri == NULL)
return FALSE;
doc = xmlReadIO(
infd_chat_filesystem_format_read_read_func,
infd_chat_filesystem_format_read_close_func,
stream,
uri,
"UTF-8",
XML_PARSE_NOWARNING | XML_PARSE_NOERROR
);
g_free(uri);
if(doc == NULL)
{
xmlerror = xmlGetLastError();
g_set_error(
error,
g_quark_from_static_string("LIBXML2_PARSER_ERROR"),
xmlerror->code,
_("Error parsing XML in file \"%s\": [%d]: %s"),
path,
xmlerror->line,
xmlerror->message
);
result = FALSE;
}
else
{
root = xmlDocGetRootElement(doc);
if(strcmp((const char*)root->name, "inf-chat-session") != 0)
{
g_set_error(
error,
infd_chat_filesystem_format_error_quark(),
INFD_CHAT_FILESYSTEM_FORMAT_ERROR_NOT_A_CHAT_SESSION,
_("Error processing file \"%s\": %s"),
path,
_("The document is not a chat session")
);
result = FALSE;
}
else
{
result = TRUE;
}
xmlFreeDoc(doc);
}
if(result == FALSE)
return FALSE;
return TRUE;
}
