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;
}
/**
* Parses the given input stream and returns a DOM Document.
* A NULL pointer will be returned if errors occurred
*/
nsresult
txDriver::parse(istream& aInputStream, const nsAString& aUri)
{
mErrorString.Truncate();
if (!aInputStream) {
mErrorString.AppendLiteral("unable to parse xml: invalid or unopen stream encountered.");
return NS_ERROR_FAILURE;
}
static const XML_Memory_Handling_Suite memsuite = {
(void *(*)(size_t))PR_Malloc,
(void *(*)(void *, size_t))PR_Realloc,
PR_Free
};
static const PRUnichar expatSeparator = kExpatSeparatorChar;
mExpatParser = XML_ParserCreate_MM(nsnull, &memsuite, &expatSeparator);
if (!mExpatParser) {
return NS_ERROR_OUT_OF_MEMORY;
}
XML_SetReturnNSTriplet(mExpatParser, XML_TRUE);
XML_SetUserData(mExpatParser, this);
XML_SetElementHandler(mExpatParser, startElement, endElement);
XML_SetCharacterDataHandler(mExpatParser, charData);
#ifdef XML_DTD
XML_SetParamEntityParsing(mExpatParser, XML_PARAM_ENTITY_PARSING_ALWAYS);
#endif
XML_SetExternalEntityRefHandler(mExpatParser, externalEntityRefHandler);
XML_SetExternalEntityRefHandlerArg(mExpatParser, this);
XML_SetBase(mExpatParser,
(const XML_Char*)(PromiseFlatString(aUri).get()));
const int bufferSize = 1024;
char buf[bufferSize];
PRBool done;
int success;
mRV = NS_OK;
do {
aInputStream.read(buf, bufferSize);
done = aInputStream.eof();
success = XML_Parse(mExpatParser, buf, aInputStream.gcount(), done);
// mRV is set in onDoneCompiling in case of an error
if (!success || NS_FAILED(mRV)) {
createErrorString();
done = MB_TRUE;
}
} while (!done);
aInputStream.clear();
// clean up
XML_ParserFree(mExpatParser);
mCompiler->doneLoading();
if (!success) {
return NS_ERROR_FAILURE;
}
return mRV;
}
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 ParserEngine::init()
{
if (_parser)
XML_ParserFree(_parser);
if (!_pBuffer)
_pBuffer = new char[PARSE_BUFFER_SIZE];
if (dynamic_cast<NoNamespacePrefixesStrategy*>(_pNamespaceStrategy))
{
_parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t');
if (_parser)
{
XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl);
}
}
else if (dynamic_cast<NamespacePrefixesStrategy*>(_pNamespaceStrategy))
{
_parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t');
if (_parser)
{
XML_SetReturnNSTriplet(_parser, 1);
XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl);
}
}
else
{
_parser = XML_ParserCreate(_encodingSpecified ? _encoding.c_str() : 0);
}
if (!_parser) throw XMLException("Cannot create Expat parser");
XML_SetUserData(_parser, this);
XML_SetElementHandler(_parser, handleStartElement, handleEndElement);
XML_SetCharacterDataHandler(_parser, handleCharacterData);
XML_SetProcessingInstructionHandler(_parser, handleProcessingInstruction);
if (_expandInternalEntities)
XML_SetDefaultHandlerExpand(_parser, handleDefault);
else
XML_SetDefaultHandler(_parser, handleDefault);
XML_SetUnparsedEntityDeclHandler(_parser, handleUnparsedEntityDecl);
XML_SetNotationDeclHandler(_parser, handleNotationDecl);
XML_SetExternalEntityRefHandler(_parser, handleExternalEntityRef);
XML_SetCommentHandler(_parser, handleComment);
XML_SetCdataSectionHandler(_parser, handleStartCdataSection, handleEndCdataSection);
XML_SetDoctypeDeclHandler(_parser, handleStartDoctypeDecl, handleEndDoctypeDecl);
XML_SetEntityDeclHandler(_parser, handleEntityDecl);
XML_SetSkippedEntityHandler(_parser, handleSkippedEntity);
XML_SetParamEntityParsing(_parser, _externalParameterEntities ? XML_PARAM_ENTITY_PARSING_ALWAYS : XML_PARAM_ENTITY_PARSING_NEVER);
XML_SetUnknownEncodingHandler(_parser, handleUnknownEncoding, this);
}
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);
}
}
/**
* Creates a new Expat parser. Called from the Java ExpatParser constructor.
*
* @param object the Java ExpatParser instance
* @param javaEncoding the character encoding name
* @param processNamespaces true if the parser should handle namespaces
* @returns the pointer to the C Expat parser
*/
static jlong ExpatParser_initialize(JNIEnv* env, jobject object, jstring javaEncoding,
jboolean processNamespaces) {
// Allocate parsing context.
UniquePtr<ParsingContext> context(new ParsingContext(object));
if (context.get() == NULL) {
jniThrowOutOfMemoryError(env, NULL);
return 0;
}
context->processNamespaces = processNamespaces;
// Create a parser.
XML_Parser parser;
ScopedUtfChars encoding(env, javaEncoding);
if (encoding.c_str() == NULL) {
return 0;
}
if (processNamespaces) {
// Use '|' to separate URIs from local names.
parser = XML_ParserCreateNS(encoding.c_str(), '|');
} else {
parser = XML_ParserCreate(encoding.c_str());
}
if (parser != NULL) {
if (processNamespaces) {
XML_SetNamespaceDeclHandler(parser, startNamespace, endNamespace);
XML_SetReturnNSTriplet(parser, 1);
}
XML_SetCdataSectionHandler(parser, startCdata, endCdata);
XML_SetCharacterDataHandler(parser, text);
XML_SetCommentHandler(parser, comment);
XML_SetDoctypeDeclHandler(parser, startDtd, endDtd);
XML_SetElementHandler(parser, startElement, endElement);
XML_SetExternalEntityRefHandler(parser, handleExternalEntity);
XML_SetNotationDeclHandler(parser, notationDecl);
XML_SetProcessingInstructionHandler(parser, processingInstruction);
XML_SetUnparsedEntityDeclHandler(parser, unparsedEntityDecl);
XML_SetUserData(parser, context.release());
} else {
jniThrowOutOfMemoryError(env, NULL);
return 0;
}
return fromXMLParser(parser);
}
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;
}
void document_imp::parse(
istream& data)
{
XML_Parser p = XML_ParserCreateNS(NULL, '=');
if (p == NULL)
THROW_EXCEPTION(("failed to create expat parser object"));
try
{
XML_SetUserData(p, this);
XML_SetElementHandler(p, XML_StartElementHandler, XML_EndElementHandler);
XML_SetCharacterDataHandler(p, XML_CharacterDataHandler);
// XML_SetProcessingInstructionHandler(p, XML_ProcessingInstructionHandler);
// XML_SetCommentHandler(p, XML_CommentHandler);
// XML_SetCdataSectionHandler(p, XML_StartCdataSectionHandler, XML_EndCdataSectionHandler);
// XML_SetDefaultHandler(p, XML_DefaultHandler);
// XML_SetDoctypeDeclHandler(p, XML_StartDoctypeDeclHandler, XML_EndDoctypeDeclHandler);
// XML_SetUnparsedEntityDeclHandler(p, XML_UnparsedEntityDeclHandler);
// XML_SetNotationDeclHandler(p, XML_NotationDeclHandler);
XML_SetNamespaceDeclHandler(p, XML_StartNamespaceDeclHandler, XML_EndNamespaceDeclHandler);
XML_SetReturnNSTriplet(p, true);
while (not data.eof())
{
string line;
getline(data, line);
line += '\n';
XML_Status err = XML_Parse(p, line.c_str(), line.length(), data.eof() or line.empty());
if (err != XML_STATUS_OK)
THROW_EXCEPTION((p));
}
}
catch (std::exception& e)
{
XML_ParserFree(p);
throw;
}
XML_ParserFree(p);
}
END_TEST
/* Regression test for SF bug #566334. */
START_TEST(test_ns_tagname_overwrite_triplet)
{
char *text =
"<n:e xmlns:n='http://xml.libexpat.org/'>\n"
" <n:f n:attr='foo'/>\n"
" <n:g n:attr2='bar'/>\n"
"</n:e>";
char *result =
"start http://xml.libexpat.org/ e n\n"
"start http://xml.libexpat.org/ f n\n"
"attribute http://xml.libexpat.org/ attr n\n"
"end http://xml.libexpat.org/ f n\n"
"start http://xml.libexpat.org/ g n\n"
"attribute http://xml.libexpat.org/ attr2 n\n"
"end http://xml.libexpat.org/ g n\n"
"end http://xml.libexpat.org/ e n\n";
XML_SetReturnNSTriplet(parser, XML_TRUE);
run_ns_tagname_overwrite_test(text, result);
}
END_TEST
/* Regression test #4 for SF bug #673791. */
START_TEST(test_ns_prefix_with_empty_uri_4)
{
char *text =
"<!DOCTYPE doc [\n"
" <!ELEMENT prefix:doc EMPTY>\n"
" <!ATTLIST prefix:doc\n"
" xmlns:prefix CDATA 'http://xml.libexpat.org/'>\n"
"]>\n"
"<prefix:doc/>";
/* Packaged info expected by the end element handler;
the weird structuring lets us re-use the triplet_end_checker()
function also used for another test. */
char *elemstr[] = {
"http://xml.libexpat.org/ doc prefix"
};
XML_SetReturnNSTriplet(parser, XML_TRUE);
XML_SetUserData(parser, elemstr);
XML_SetEndElementHandler(parser, triplet_end_checker);
if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
}
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;
}
NS_IMETHODIMP
nsExpatDriver::WillBuildModel(const CParserContext& aParserContext,
nsITokenizer* aTokenizer,
nsIContentSink* aSink)
{
mSink = do_QueryInterface(aSink);
if (!mSink) {
NS_ERROR("nsExpatDriver didn't get an nsIExpatSink");
// Make sure future calls to us bail out as needed
mInternalState = NS_ERROR_UNEXPECTED;
return mInternalState;
}
mOriginalSink = aSink;
static const XML_Memory_Handling_Suite memsuite =
{
(void *(*)(size_t))PR_Malloc,
(void *(*)(void *, size_t))PR_Realloc,
PR_Free
};
static const PRUnichar kExpatSeparator[] = { kExpatSeparatorChar, '\0' };
mExpatParser = XML_ParserCreate_MM(kUTF16, &memsuite, kExpatSeparator);
NS_ENSURE_TRUE(mExpatParser, NS_ERROR_FAILURE);
XML_SetReturnNSTriplet(mExpatParser, XML_TRUE);
#ifdef XML_DTD
XML_SetParamEntityParsing(mExpatParser, XML_PARAM_ENTITY_PARSING_ALWAYS);
#endif
mURISpec = aParserContext.mScanner->GetFilename();
XML_SetBase(mExpatParser, mURISpec.get());
nsCOMPtr<nsIDocument> doc = do_QueryInterface(mOriginalSink->GetTarget());
if (doc) {
nsCOMPtr<nsPIDOMWindow> win = doc->GetWindow();
if (!win) {
PRBool aHasHadScriptHandlingObject;
nsIScriptGlobalObject *global =
doc->GetScriptHandlingObject(aHasHadScriptHandlingObject);
if (global) {
win = do_QueryInterface(global);
}
}
if (win && !win->IsInnerWindow()) {
win = win->GetCurrentInnerWindow();
}
if (win) {
mInnerWindowID = win->WindowID();
}
}
// Set up the callbacks
XML_SetXmlDeclHandler(mExpatParser, Driver_HandleXMLDeclaration);
XML_SetElementHandler(mExpatParser, Driver_HandleStartElement,
Driver_HandleEndElement);
XML_SetCharacterDataHandler(mExpatParser, Driver_HandleCharacterData);
XML_SetProcessingInstructionHandler(mExpatParser,
Driver_HandleProcessingInstruction);
XML_SetDefaultHandlerExpand(mExpatParser, Driver_HandleDefault);
XML_SetExternalEntityRefHandler(mExpatParser,
(XML_ExternalEntityRefHandler)
Driver_HandleExternalEntityRef);
XML_SetExternalEntityRefHandlerArg(mExpatParser, this);
XML_SetCommentHandler(mExpatParser, Driver_HandleComment);
XML_SetCdataSectionHandler(mExpatParser, Driver_HandleStartCdataSection,
Driver_HandleEndCdataSection);
XML_SetParamEntityParsing(mExpatParser,
XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE);
XML_SetDoctypeDeclHandler(mExpatParser, Driver_HandleStartDoctypeDecl,
Driver_HandleEndDoctypeDecl);
// If the sink is an nsIExtendedExpatSink,
// register some addtional handlers.
mExtendedSink = do_QueryInterface(mSink);
if (mExtendedSink) {
XML_SetNamespaceDeclHandler(mExpatParser,
Driver_HandleStartNamespaceDecl,
Driver_HandleEndNamespaceDecl);
XML_SetUnparsedEntityDeclHandler(mExpatParser,
Driver_HandleUnparsedEntityDecl);
XML_SetNotationDeclHandler(mExpatParser,
Driver_HandleNotationDecl);
}
// Set up the user data.
XML_SetUserData(mExpatParser, this);
// XML must detect invalid character convertion
aParserContext.mScanner->OverrideReplacementCharacter(0xffff);
return mInternalState;
}
/* ============================================================================
* 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_SetReturnNSTriplet(struct ExpatIFace * Self, XML_Parser parser, int do_nst)
{
XML_SetReturnNSTriplet(parser, do_nst);
}
/**
* Parses the given input stream and returns a DOM Document.
* A NULL pointer will be returned if errors occurred
*/
nsresult
txXMLParser::parse(istream& aInputStream, const nsAString& aUri,
txXPathNode** aResultDoc)
{
mErrorString.Truncate();
*aResultDoc = nsnull;
if (!aInputStream) {
mErrorString.AppendLiteral("unable to parse xml: invalid or unopen stream encountered.");
return NS_ERROR_FAILURE;
}
static const XML_Memory_Handling_Suite memsuite = {
(void *(*)(size_t))PR_Malloc,
(void *(*)(void *, size_t))PR_Realloc,
PR_Free
};
static const PRUnichar expatSeparator = kExpatSeparatorChar;
mExpatParser = XML_ParserCreate_MM(nsnull, &memsuite, &expatSeparator);
if (!mExpatParser) {
return NS_ERROR_OUT_OF_MEMORY;
}
mDocument = new Document();
if (!mDocument) {
XML_ParserFree(mExpatParser);
return NS_ERROR_OUT_OF_MEMORY;
}
mDocument->documentBaseURI = aUri;
mCurrentNode = mDocument;
XML_SetReturnNSTriplet(mExpatParser, XML_TRUE);
XML_SetUserData(mExpatParser, this);
XML_SetElementHandler(mExpatParser, startElement, endElement);
XML_SetCharacterDataHandler(mExpatParser, charData);
XML_SetProcessingInstructionHandler(mExpatParser, piHandler);
XML_SetCommentHandler(mExpatParser, commentHandler);
#ifdef XML_DTD
XML_SetParamEntityParsing(mExpatParser, XML_PARAM_ENTITY_PARSING_ALWAYS);
#endif
XML_SetExternalEntityRefHandler(mExpatParser, externalEntityRefHandler);
XML_SetExternalEntityRefHandlerArg(mExpatParser, this);
XML_SetBase(mExpatParser,
(const XML_Char*)(PromiseFlatString(aUri).get()));
const int bufferSize = 1024;
char buf[bufferSize];
PRBool done;
do {
aInputStream.read(buf, bufferSize);
done = aInputStream.eof();
if (!XML_Parse(mExpatParser, buf, aInputStream.gcount(), done)) {
createErrorString();
done = MB_TRUE;
delete mDocument;
mDocument = nsnull;
}
} while (!done);
aInputStream.clear();
// clean up
XML_ParserFree(mExpatParser);
// ownership to the caller
*aResultDoc = txXPathNativeNode::createXPathNode(mDocument);
mDocument = nsnull;
return *aResultDoc ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
