nad_t nad_parse(const char *buf, int len) {
struct build_data bd;
XML_Parser p;
if(len == 0)
len = strlen(buf);
p = XML_ParserCreateNS(NULL, '|');
if(p == NULL)
return NULL;
XML_SetReturnNSTriplet(p, 1);
bd.nad = nad_new();
bd.depth = 0;
XML_SetUserData(p, (void *) &bd);
XML_SetElementHandler(p, _nad_parse_element_start, _nad_parse_element_end);
XML_SetCharacterDataHandler(p, _nad_parse_cdata);
XML_SetStartNamespaceDeclHandler(p, _nad_parse_namespace_start);
if(!XML_Parse(p, buf, len, 1)) {
XML_ParserFree(p);
nad_free(bd.nad);
return NULL;
}
XML_ParserFree(p);
if(bd.depth != 0)
return NULL;
return bd.nad;
}
void xmlg_parser_error_abort(
xmlGParser *xml_parser,
HqBool fire_error_handler,
uint8 *detail,
int32 detail_len)
{
xmlGParserCommon *c ;
xmlGFilterChain *filter_chain ;
uint32 line, column ;
XMLGASSERT(xml_parser != NULL, "xml_parser is NULL") ;
c = xmlg_get_parser_common(xml_parser);
XMLGASSERT(c != NULL, "common is NULL");
filter_chain = c->filter_chain ;
/* setting the callback functions to NULL ensures we stop */
XML_SetElementHandler(xml_parser->ctxt, NULL, NULL) ;
XML_SetStartNamespaceDeclHandler(xml_parser->ctxt, NULL) ;
XML_SetCharacterDataHandler(xml_parser->ctxt, NULL) ;
XML_SetXmlDeclHandler(xml_parser->ctxt, NULL) ;
XML_SetStartDoctypeDeclHandler(xml_parser->ctxt, NULL) ;
if (fire_error_handler) {
xmlg_parser_line_and_column(xml_parser, &line, &column) ;
/* only ever invoke the error handler once */
if (c->parse_error_cb != NULL && fire_error_handler && ! c->success_abort)
c->parse_error_cb(xml_parser, xmlg_fc_get_uri(filter_chain), line, column,
detail, detail_len) ;
}
if (! c->success_abort)
c->error_abort = TRUE ;
}
static void init_parser(XML_Parser parser, expat_parser *parser_data)
{
XML_SetUserData(parser, parser_data);
XML_SetStartElementHandler(parser, (XML_StartElementHandler)start_element_handler);
XML_SetEndElementHandler(parser, (XML_EndElementHandler)end_element_handler);
XML_SetCharacterDataHandler(parser, (XML_CharacterDataHandler)character_data_handler);
XML_SetStartNamespaceDeclHandler(parser, (XML_StartNamespaceDeclHandler)namespace_decl_handler);
XML_SetReturnNSTriplet(parser, 1);
XML_SetDefaultHandler(parser, NULL);
};
void
OMXMLReaderExpat::reset()
{
TRACE("OMXMLReaderExpat::reset");
XML_ParserFree(_parser);
if (_workBuffer != 0)
{
delete [] _workBuffer;
}
OMListIterator<OMXMLAttribute*> iter(_attributes, OMBefore);
while (++iter)
{
delete iter.value();
}
_attributes.clear();
OMUInt32 elementCount = _startNmspaceDecls.count();
for (OMUInt32 i = 0; i < elementCount; i++)
{
delete _startNmspaceDecls.getAt(i);
}
_startNmspaceDecls.clear();
_endNmspaceDecls.clear();
clearEvents();
_parser = XML_ParserCreateNS(0, NAMESPACE_SEPARATOR);
XML_SetNotationDeclHandler(_parser, ::expat_NotationDeclHandler);
XML_SetEntityDeclHandler(_parser, ::expat_EntityDeclHandler);
XML_SetStartNamespaceDeclHandler(_parser, ::expat_StartNamespaceDeclHandler);
XML_SetEndNamespaceDeclHandler(_parser, ::expat_EndNamespaceDeclHandler);
XML_SetStartElementHandler(_parser, ::expat_StartElementHandler);
XML_SetEndElementHandler(_parser, ::expat_EndElementHandler);
XML_SetCharacterDataHandler(_parser, ::expat_CharacterDataHandler);
XML_SetUserData(_parser, this);
_workBuffer = new wchar_t[WORK_BUFFER_MIN_SIZE];
_workBufferSize = WORK_BUFFER_MIN_SIZE;
_readNextChunk = true;
_status = true;
_numInBuffer = 0;
_xmlStream->setPosition(0);
}
static void init_parser(struct xmpp_parser *parser, bool is_stream_start) {
XML_SetReturnNSTriplet(parser->parser, true);
XML_SetElementHandler(parser->parser, start, end);
XML_SetCharacterDataHandler(parser->parser, chardata);
XML_SetUserData(parser->parser, parser);
XML_SetStartNamespaceDeclHandler(parser->parser, ns_start);
/* Inhibit the expansion of any external entities. */
XML_SetParamEntityParsing(parser->parser, XML_PARAM_ENTITY_PARSING_NEVER);
parser->needs_reset = false;
if (is_stream_start) {
XML_SetStartElementHandler(parser->parser, stream_start);
}
}
/* ============================================================================
* Abort and information functions.
*/
void xmlg_p_abort_parse(
xmlGParser *xml_parser)
{
xmlGParserCommon *c;
XMLGASSERT(xml_parser != NULL, "xml_parser is NULL");
c = xmlg_get_parser_common(xml_parser);
XMLGASSERT(c != NULL, "common is NULL");
c->success_abort = TRUE;
/* setting the callback functions to NULL ensures we stop */
XML_SetElementHandler(xml_parser->ctxt, NULL, NULL);
XML_SetStartNamespaceDeclHandler(xml_parser->ctxt, NULL);
XML_SetCharacterDataHandler(xml_parser->ctxt, NULL);
XML_SetXmlDeclHandler(xml_parser->ctxt, NULL) ;
XML_SetStartDoctypeDeclHandler(xml_parser->ctxt, NULL) ;
}
nad_t nad_parse(const char *buf, int len) {
struct build_data bd;
XML_Parser p;
if(len == 0)
len = strlen(buf);
p = XML_ParserCreateNS(NULL, '|');
if(p == NULL)
return NULL;
bd.p = p;
XML_SetReturnNSTriplet(p, 1);
/* Prevent the "billion laughs" attack against expat by disabling
* internal entity expansion. With 2.x, forcibly stop the parser
* if an entity is declared - this is safer and a more obvious
* failure mode. With older versions, simply prevent expenansion
* of such entities. */
#ifdef HAVE_XML_STOPPARSER
XML_SetEntityDeclHandler(p, (void *) _nad_parse_entity_declaration);
#else
XML_SetDefaultHandler(p, NULL);
#endif
bd.nad = nad_new();
bd.depth = 0;
XML_SetUserData(p, (void *) &bd);
XML_SetElementHandler(p, _nad_parse_element_start, _nad_parse_element_end);
XML_SetCharacterDataHandler(p, _nad_parse_cdata);
XML_SetStartNamespaceDeclHandler(p, _nad_parse_namespace_start);
if(!XML_Parse(p, buf, len, 1)) {
XML_ParserFree(p);
nad_free(bd.nad);
return NULL;
}
XML_ParserFree(p);
if(bd.depth != 0)
return NULL;
return bd.nad;
}
static ErlDrvData expat_erl_start(ErlDrvPort port, char *buff)
{
expat_data* d = (expat_data*)driver_alloc(sizeof(expat_data));
d->port = port;
d->parser = XML_ParserCreate_MM("UTF-8", &ms, "\n");
XML_SetUserData(d->parser, d);
set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
XML_SetStartElementHandler(
d->parser, (XML_StartElementHandler)erlXML_StartElementHandler);
XML_SetEndElementHandler(
d->parser, (XML_EndElementHandler)erlXML_EndElementHandler);
XML_SetCharacterDataHandler(
d->parser, (XML_CharacterDataHandler)erlXML_CharacterDataHandler);
XML_SetStartNamespaceDeclHandler(
d->parser, (XML_StartNamespaceDeclHandler) erlXML_StartNamespaceDeclHandler);
XML_SetReturnNSTriplet(d->parser, 1);
XML_SetDefaultHandler(d->parser, NULL);
return (ErlDrvData)d;
}
OMXMLReaderExpat::OMXMLReaderExpat(OMRawStorage* xmlStream)
: _appendData(false), _xmlStream(xmlStream), _parser(0)
{
TRACE("OMXMLReaderExpat::OMXMLReaderExpat");
clearEvents();
_parser = XML_ParserCreateNS(0, NAMESPACE_SEPARATOR);
XML_SetNotationDeclHandler(_parser, ::expat_NotationDeclHandler);
XML_SetEntityDeclHandler(_parser, ::expat_EntityDeclHandler);
XML_SetStartNamespaceDeclHandler(_parser, ::expat_StartNamespaceDeclHandler);
XML_SetEndNamespaceDeclHandler(_parser, ::expat_EndNamespaceDeclHandler);
XML_SetStartElementHandler(_parser, ::expat_StartElementHandler);
XML_SetEndElementHandler(_parser, ::expat_EndElementHandler);
XML_SetCharacterDataHandler(_parser, ::expat_CharacterDataHandler);
XML_SetUserData(_parser, this);
_workBuffer = new wchar_t[WORK_BUFFER_MIN_SIZE];
_workBufferSize = WORK_BUFFER_MIN_SIZE;
_readNextChunk = true;
_status = true;
_numInBuffer = 0;
}
bool f_xml_set_start_namespace_decl_handler(CObjRef parser, CVarRef handler) {
XmlParser * p = parser.getTyped<XmlParser>();
xml_set_handler(&p->startNamespaceDeclHandler, handler);
XML_SetStartNamespaceDeclHandler(p->parser, _xml_startNamespaceDeclHandler);
return true;
}
/* ============================================================================
* Create/Destroy XML parse handler.
*/
HqBool xmlg_p_new(
xmlGContext *xml_ctxt,
xmlGParser **xml_parser,
xmlGMemoryHandler *memory_handler,
xmlGFilterChain *filter_chain)
{
xmlGParser *new_xml_parser;
XMLGASSERT(xml_ctxt != NULL, "xml_ctxt is NULL");
XMLGASSERT(xml_parser != NULL, "xml_parser is NULL");
XMLGASSERT(filter_chain != NULL, "filter_chain is NULL");
*xml_parser = NULL;
/* Although this code is going to be common to all back end XML parsers,
we need to do it here because only this file knows about the size of
xmlGParser - which is back end specific. */
if (memory_handler != NULL) {
if (memory_handler->f_malloc == NULL ||
memory_handler->f_realloc == NULL ||
memory_handler->f_free == NULL) {
XMLGASSERT(FALSE, "incomplete memory handler") ;
return FALSE ;
}
/* Use the pluged memory handler to allocate this structure */
if ((new_xml_parser = memory_handler->f_malloc(sizeof(xmlGParser))) == NULL)
return FALSE;
} else {
/* use the XML sub-system memory management */
if ((new_xml_parser = xmlg_subsystem_malloc(xml_ctxt, sizeof(xmlGParser))) == NULL)
return FALSE;
}
if (! xmlg_parser_common_init(new_xml_parser,
xml_ctxt,
memory_handler,
filter_chain)) {
/* We need to do this as we don't know if the memory handlers have
been plugged successfuly. Better safe than sorry. */
if (memory_handler != NULL) {
memory_handler->f_free(new_xml_parser);
} else {
xmlg_subsystem_free(xml_ctxt, new_xml_parser);
}
return FALSE;
}
/* xmlg_parser_malloc and friends are now available for this
handler. */
/* Do backend XML parser specific stuff. */
/* setup expat memory handler structure */
if (memory_handler != NULL) {
new_xml_parser->expat_mem.malloc_fcn = memory_handler->f_malloc ;
new_xml_parser->expat_mem.realloc_fcn = memory_handler->f_realloc ;
new_xml_parser->expat_mem.free_fcn = memory_handler->f_free ;
} else {
new_xml_parser->expat_mem.malloc_fcn = xml_ctxt->memory_handler.f_malloc ;
new_xml_parser->expat_mem.realloc_fcn = xml_ctxt->memory_handler.f_realloc ;
new_xml_parser->expat_mem.free_fcn = xml_ctxt->memory_handler.f_free ;
}
new_xml_parser->ctxt = XML_ParserCreate_MM(NULL, &new_xml_parser->expat_mem, &sep);
if (new_xml_parser->ctxt == NULL) {
xmlg_parser_free(new_xml_parser, new_xml_parser);
return FALSE;
}
/* Turn prefix mapping on. */
XML_SetReturnNSTriplet(new_xml_parser->ctxt, 1);
XML_SetUserData(new_xml_parser->ctxt, (void *)(new_xml_parser)) ;
XML_SetElementHandler(new_xml_parser->ctxt, expat_start_element_ns_cb,
expat_end_element_ns_cb) ;
XML_SetStartNamespaceDeclHandler(new_xml_parser->ctxt, expat_start_namespace_cb) ;
XML_SetCharacterDataHandler(new_xml_parser->ctxt, expat_characters_data_cb) ;
XML_SetXmlDeclHandler(new_xml_parser->ctxt, expat_xml_decl_cb) ;
XML_SetStartDoctypeDeclHandler(new_xml_parser->ctxt, expat_xml_dtd_cb) ;
if (filter_chain != NULL) {
xmlg_p_set_parse_error_cb(new_xml_parser, filter_chain->parse_error_cb) ;
}
*xml_parser = new_xml_parser;
return TRUE;
}
void _Expat_XML_SetStartNamespaceDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_StartNamespaceDeclHandler start)
{
XML_SetStartNamespaceDeclHandler(parser, start);
}
void XMLParser::EnableStartNamespaceDeclHandler(bool enable)
{
assert(m_parser != NULL);
XML_SetStartNamespaceDeclHandler(m_parser, enable ? StartNamespaceDeclHandler : NULL);
}
bool f_xml_set_start_namespace_decl_handler(const Resource& parser, const Variant& handler) {
XmlParser * p = parser.getTyped<XmlParser>();
xml_set_handler(&p->startNamespaceDeclHandler, handler);
XML_SetStartNamespaceDeclHandler(p->parser, _xml_startNamespaceDeclHandler);
return true;
}
void bmx_expat_XML_SetStartNamespaceDeclHandler(XML_Parser parser) {
XML_SetStartNamespaceDeclHandler(parser, bmx_expat_StartNamespaceDeclHandler);
}
