END_TEST
/* Regression test for SF bug #616863. */
static int XMLCALL
external_entity_handler(XML_Parser parser,
const XML_Char *context,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId)
{
int callno = 1 + (int)XML_GetUserData(parser);
char *text;
XML_Parser p2;
if (callno == 1)
text = ("<!ELEMENT doc (e+)>\n"
"<!ATTLIST doc xmlns CDATA #IMPLIED>\n"
"<!ELEMENT e EMPTY>\n");
else
text = ("<?xml version='1.0' encoding='us-ascii'?>"
"<e/>");
XML_SetUserData(parser, (void *) callno);
p2 = XML_ExternalEntityParserCreate(parser, context, NULL);
if (XML_Parse(p2, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR) {
xml_failure(p2);
return 0;
}
XML_ParserFree(p2);
return 1;
}
END_TEST
/* Regression test for SF bug #620106. */
static int XMLCALL
external_entity_loader_set_encoding(XML_Parser parser,
const XML_Char *context,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId)
{
/* This text says it's an unsupported encoding, but it's really
UTF-8, which we tell Expat using XML_SetEncoding().
*/
char *text =
"<?xml encoding='iso-8859-3'?>"
"\xC3\xA9";
XML_Parser extparser;
extparser = XML_ExternalEntityParserCreate(parser, context, NULL);
if (extparser == NULL)
fail("Could not create external entity parser.");
if (!XML_SetEncoding(extparser, "utf-8"))
fail("XML_SetEncoding() ignored for external entity");
if ( XML_Parse(extparser, text, strlen(text), XML_TRUE)
== XML_STATUS_ERROR) {
xml_failure(parser);
return 0;
}
return 1;
}
static int
pdb_xml_external_entity_ref_cb (XML_Parser xml_parser,
const XML_Char *context,
const XML_Char *base,
const XML_Char *system_id,
const XML_Char *public_id)
{
PdbXmlParser *parser = XML_GetUserData (xml_parser);
PdbXmlStackEntry *stack_top;
XML_Parser external_parser;
GError *error = NULL;
char *filename;
gboolean ret;
if (system_id == NULL)
{
g_set_error (&parser->abort_error,
PDB_ERROR,
PDB_ERROR_BAD_FORMAT,
_("%s:%i:%i: An external entity was encountered "
"without a system id"),
pdb_xml_get_current_filename (parser),
pdb_xml_get_current_line_number (parser),
pdb_xml_get_current_column_number (parser));
return XML_STATUS_ERROR;
}
external_parser = XML_ExternalEntityParserCreate (xml_parser,
context,
NULL);
pdb_xml_init_parser (parser, external_parser);
if (base)
filename = g_strconcat (base, "/", system_id, NULL);
else
filename = g_strdup (system_id);
g_array_set_size (parser->stack, parser->stack->len + 1);
stack_top = &g_array_index (parser->stack,
PdbXmlStackEntry,
parser->stack->len - 1);
stack_top->parser = external_parser;
stack_top->filename = NULL;
ret = pdb_xml_parse (parser, filename, &error);
g_free (filename);
XML_ParserFree (external_parser);
g_array_set_size (parser->stack, parser->stack->len - 1);
if (ret)
return XML_STATUS_OK;
else
{
parser->abort_error = error;
return XML_STATUS_ERROR;
}
}
/* this external entity handler allows us to do things like this:
*
* <!DOCTYPE tests
* [
* <!ENTITY mamekey_esc SYSTEM "http://www.mess.org/messtest/">
* ]>
*/
static int external_entity_handler(XML_Parser parser,
const XML_Char *context,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId)
{
XML_Parser extparser = NULL;
int rc = 0;
char buf[256];
static const char *mamekey_prefix = "mamekey_";
input_code c;
buf[0] = '\0';
/* only supportr our own schema */
if (strcmp(systemId, "http://www.mess.org/messtest/"))
goto done;
extparser = XML_ExternalEntityParserCreate(parser, context, "us-ascii");
if (!extparser)
goto done;
/* does this use the 'mamekey' prefix? */
if ((strlen(context) > strlen(mamekey_prefix)) && !memcmp(context,
mamekey_prefix, strlen(mamekey_prefix)))
{
context += strlen(mamekey_prefix);
c = messtest_token_to_code(context);
if (c != CODE_NONE)
{
snprintf(buf, sizeof(buf) / sizeof(buf[0]), "<%s%s>&#%d;</%s%s>",
mamekey_prefix, context,
UCHAR_MAMEKEY_BEGIN + c,
mamekey_prefix, context);
if (XML_Parse(extparser, buf, strlen(buf), 0) == XML_STATUS_ERROR)
goto done;
}
}
else if (!strcmp(context, "eoln"))
{
snprintf(buf, sizeof(buf) / sizeof(buf[0]), "<eoln>%s</eoln>", EOLN);
if (XML_Parse(extparser, buf, strlen(buf), 0) == XML_STATUS_ERROR)
goto done;
}
if (XML_Parse(extparser, NULL, 0, 1) == XML_STATUS_ERROR)
goto done;
rc = 1;
done:
if (extparser)
XML_ParserFree(extparser);
return rc;
}
int ParserEngine::handleExternalEntityRef(XML_Parser parser, const XML_Char* context, const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId)
{
ParserEngine* pThis = reinterpret_cast<ParserEngine*>(XML_GetUserData(parser));
if (!context && !pThis->_externalParameterEntities) return XML_STATUS_ERROR;
if (context && !pThis->_externalGeneralEntities) return XML_STATUS_ERROR;
InputSource* pInputSource = 0;
EntityResolver* pEntityResolver = 0;
EntityResolverImpl defaultResolver;
XMLString sysId(systemId);
XMLString pubId;
if (publicId) pubId.assign(publicId);
URI uri(fromXMLString(pThis->_context.back()->getSystemId()));
uri.resolve(fromXMLString(sysId));
if (pThis->_pEntityResolver)
{
pEntityResolver = pThis->_pEntityResolver;
pInputSource = pEntityResolver->resolveEntity(publicId ? &pubId : 0, toXMLString(uri.toString()));
}
if (!pInputSource && pThis->_externalGeneralEntities)
{
pEntityResolver = &defaultResolver;
pInputSource = pEntityResolver->resolveEntity(publicId ? &pubId : 0, toXMLString(uri.toString()));
}
if (pInputSource)
{
XML_Parser extParser = XML_ExternalEntityParserCreate(pThis->_parser, context, 0);
if (!extParser) throw XMLException("Cannot create external entity parser");
try
{
pThis->parseExternal(extParser, pInputSource);
}
catch (XMLException&)
{
pEntityResolver->releaseInputSource(pInputSource);
XML_ParserFree(extParser);
throw;
}
pEntityResolver->releaseInputSource(pInputSource);
XML_ParserFree(extParser);
return XML_STATUS_OK;
}
else return XML_STATUS_ERROR;
}
static void parseExtraDTDEntities(XML_Parser parser, const std::map<std::string, std::string> &entityMap) {
XML_Parser entityParser = XML_ExternalEntityParserCreate(parser, 0, 0);
std::string buffer;
std::map<std::string, std::string>::const_iterator it = entityMap.begin();
for (; it != entityMap.end(); ++it) {
buffer.clear();
buffer.append("<!ENTITY ").append(it->first).append(" \"").append(it->second).append("\">");
if (XML_Parse(entityParser, buffer.data(), buffer.size(), 0) == XML_STATUS_ERROR) {
break;
}
}
XML_ParserFree(entityParser);
}
/**
* Creates a new entity parser.
*
* @param object the Java ExpatParser instance
* @param parentParser pointer
* @param javaEncoding the character encoding name
* @param javaContext that was provided to handleExternalEntity
* @returns the pointer to the C Expat entity parser
*/
static jlong ExpatParser_createEntityParser(JNIEnv* env, jobject, jlong parentParser, jstring javaContext) {
ScopedUtfChars context(env, javaContext);
if (context.c_str() == NULL) {
return 0;
}
XML_Parser parent = toXMLParser(parentParser);
XML_Parser entityParser = XML_ExternalEntityParserCreate(parent, context.c_str(), NULL);
if (entityParser == NULL) {
jniThrowOutOfMemoryError(env, NULL);
}
return fromXMLParser(entityParser);
}
int
nsExpatDriver::HandleExternalEntityRef(const PRUnichar *openEntityNames,
const PRUnichar *base,
const PRUnichar *systemId,
const PRUnichar *publicId)
{
if (mInInternalSubset && !mInExternalDTD && openEntityNames) {
mInternalSubset.Append(PRUnichar('%'));
mInternalSubset.Append(nsDependentString(openEntityNames));
mInternalSubset.Append(PRUnichar(';'));
}
// Load the external entity into a buffer.
nsCOMPtr<nsIInputStream> in;
nsAutoString absURL;
nsresult rv = OpenInputStreamFromExternalDTD(publicId, systemId, base,
getter_AddRefs(in), absURL);
NS_ENSURE_SUCCESS(rv, 1);
nsCOMPtr<nsIUnicharInputStream> uniIn;
rv = nsSimpleUnicharStreamFactory::GetInstance()->
CreateInstanceFromUTF8Stream(in, getter_AddRefs(uniIn));
NS_ENSURE_SUCCESS(rv, 1);
int result = 1;
if (uniIn) {
XML_Parser entParser = XML_ExternalEntityParserCreate(mExpatParser, 0,
kUTF16);
if (entParser) {
XML_SetBase(entParser, absURL.get());
mInExternalDTD = PR_TRUE;
PRUint32 totalRead;
do {
rv = uniIn->ReadSegments(ExternalDTDStreamReaderFunc, entParser,
PRUint32(-1), &totalRead);
} while (NS_SUCCEEDED(rv) && totalRead > 0);
result = XML_Parse(entParser, nsnull, 0, 1);
mInExternalDTD = PR_FALSE;
XML_ParserFree(entParser);
}
}
return result;
}
int
txXMLParser::ExternalEntityRef(const XML_Char *aContext,
const XML_Char *aBase,
const XML_Char *aSystemId,
const XML_Char *aPublicId)
{
if (aPublicId) {
// not supported, this is "http://some.site.net/foo.dtd" stuff
return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
}
nsAutoString absUrl;
URIUtils::resolveHref(nsDependentString((PRUnichar*)aSystemId),
nsDependentString((PRUnichar*)aBase), absUrl);
istream* extInput = URIUtils::getInputStream(absUrl, mErrorString);
if (!extInput) {
return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
}
XML_Parser parent = mExpatParser;
mExpatParser =
XML_ExternalEntityParserCreate(mExpatParser, aContext, nsnull);
if (!mExpatParser) {
mExpatParser = parent;
delete extInput;
return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
}
XML_SetBase(mExpatParser, absUrl.get());
const int bufSize = 1024;
char buffer[bufSize];
int result;
PRBool done;
do {
extInput->read(buffer, bufSize);
done = extInput->eof();
if (!(result =
XML_Parse(mExpatParser, buffer, extInput->gcount(), done))) {
createErrorString();
mErrorString.Append(PRUnichar('\n'));
done = MB_TRUE;
}
} while (!done);
delete extInput;
XML_ParserFree(mExpatParser);
mExpatParser = parent;
return result;
}
static void parseDTD(XML_Parser parser, const std::string &fileName) {
XML_Parser entityParser = XML_ExternalEntityParserCreate(parser, 0, 0);
ZLFile dtdFile(fileName);
shared_ptr<ZLInputStream> entityStream = dtdFile.inputStream();
if (!entityStream.isNull() && entityStream->open()) {
char buffer[BUFSIZE];
size_t length;
do {
length = entityStream->read(buffer, BUFSIZE);
if (XML_Parse(entityParser, buffer, length, 0) == XML_STATUS_ERROR) {
break;
}
} while (length == BUFSIZE);
}
XML_ParserFree(entityParser);
}
static int
externalEntityRefStream(XML_Parser parser,
const XML_Char *context,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId)
{
XML_Char *s;
const XML_Char *filename;
int ret;
XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
filename = resolveSystemId(base, systemId, &s);
XML_SetBase(entParser, filename);
ret = processStream(filename, entParser);
free(s);
XML_ParserFree(entParser);
return ret;
}
MeaXMLParser::MeaXMLParser(const MeaXMLParser& parentParser) :
IValidationHandler(),
m_isSubParser(true),
m_validator(parentParser.m_validator),
m_handler(parentParser.m_handler),
m_elementStack(parentParser.m_elementStack),
m_pathnameStack(parentParser.m_pathnameStack),
m_haveDTD(parentParser.m_haveDTD),
m_context(parentParser.m_context),
m_buildDOM(parentParser.m_buildDOM),
m_dom(parentParser.m_dom),
m_nodeStack(parentParser.m_nodeStack)
{
m_parser = XML_ExternalEntityParserCreate(parentParser.m_parser,
m_context, NULL);
MeaAssert(m_parser != NULL);
XML_SetUserData(m_parser, this);
XML_SetExternalEntityRefHandlerArg(m_parser, this);
}
END_TEST
static int
external_entity_loader(XML_Parser parser,
const XML_Char *context,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId)
{
char *text = (char *)XML_GetUserData(parser);
XML_Parser extparser;
extparser = XML_ExternalEntityParserCreate(parser, context, NULL);
if (extparser == NULL)
fail("Could not create external entity parser.");
if (XML_Parse(extparser, text, strlen(text), 1) == XML_STATUS_ERROR) {
xml_failure(parser);
return 0;
}
return 1;
}
static int
externalEntityRefFilemap(XML_Parser parser,
const XML_Char *context,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId)
{
int result;
XML_Char *s;
const XML_Char *filename;
XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
PROCESS_ARGS args;
args.retPtr = &result;
args.parser = entParser;
filename = resolveSystemId(base, systemId, &s);
XML_SetBase(entParser, filename);
if (!filemap(filename, processFile, &args))
result = 0;
free(s);
XML_ParserFree(entParser);
return result;
}
static int f_ExternaEntity (XML_Parser p, const char *context,
const char *base,
const char *systemId,
const char *publicId) {
lxp_userdata *xpu = (lxp_userdata *)XML_GetUserData(p);
lua_State *L = xpu->L;
lxp_userdata *child;
int status;
if (getHandle(xpu, ExternalEntityKey) == 0) return 1; /* no handle */
child = createlxp(L);
child->parser = XML_ExternalEntityParserCreate(p, context, NULL);
if (!child->parser)
luaL_error(L, "XML_ParserCreate failed");
lua_getref(L, xpu->tableref); /* child uses the same table of its father */
child->tableref = luaL_ref(L, LUA_REGISTRYINDEX);
lua_pushstring(L, base);
lua_pushstring(L, systemId);
lua_pushstring(L, publicId);
docall(xpu, 4, 1);
status = lua_toboolean(L, -1);
lua_pop(L, 1);
lxpclose(L, child);
return status;
}
int CSAX2ParserBase::HandleExternalEntityRef(const XML_Char* context, const XML_Char* base,
const XML_Char* systemId, const XML_Char* publicId)
{
csl_assert (systemId != NULL);
if (context == NULL && !m_includeExtParEntities) return 0;
if (context != NULL && !m_includeExtGenEntities) return 0;
CInputSource* pInputSource = NULL;
XMLString resolvedSystemId;
if (base)
resolvedSystemId = ResolveSystemId(base, systemId);
else
resolvedSystemId = systemId;
CEntityResolver* pEntityResolver = NULL;
CEntityResolverImp defaultResolver;
XMLString pId;
if (publicId) pId = XMLString(publicId);
if (m_pEntityResolver)
{
pInputSource = m_pEntityResolver->ResolveEntity(publicId ? &pId : NULL, resolvedSystemId);
pEntityResolver = m_pEntityResolver;
}
if (!pInputSource && m_includeExtGenEntities)
{
pInputSource = defaultResolver.ResolveEntity(publicId ? &pId : NULL, resolvedSystemId);
pEntityResolver = &defaultResolver;
}
if (pInputSource)
{
XML_Parser extParser = XML_ExternalEntityParserCreate(GetExpatParser(), context, 0);
XML_SetBase(extParser, resolvedSystemId.c_str());
try
{
if (pInputSource->GetCharacterStream())
{
ParseCharExternal(extParser, pInputSource->GetCharacterStream());
}
else if (pInputSource->GetByteStream())
{
ParseExternal(extParser, pInputSource->GetByteStream());
}
else
{
throw CSAXParseException("no input stream", EMPTY_STRING, pInputSource->GetSystemId(), 0, 0, CXMLException(CXMLException::EXMLBadInputSource, string()));
}
}
catch (CXMLException& e)
{
// cleanup before we propagate the exception
pEntityResolver->DoneWithInputSource(pInputSource);
XML_ParserFree(extParser);
throw e;
}
pEntityResolver->DoneWithInputSource(pInputSource);
XML_ParserFree(extParser);
return 1;
}
else
{
return 0;
}
}
XML_Parser _Expat_XML_ExternalEntityParserCreate(struct ExpatIFace * Self, XML_Parser parser, const XML_Char *context, const XML_Char *encoding)
{
return XML_ExternalEntityParserCreate(parser, context, encoding);
}
int
nsExpatDriver::HandleExternalEntityRef(const char16_t *openEntityNames,
const char16_t *base,
const char16_t *systemId,
const char16_t *publicId)
{
if (mInInternalSubset && !mInExternalDTD && openEntityNames) {
mInternalSubset.Append(char16_t('%'));
mInternalSubset.Append(nsDependentString(openEntityNames));
mInternalSubset.Append(char16_t(';'));
}
// Load the external entity into a buffer.
nsCOMPtr<nsIInputStream> in;
nsAutoString absURL;
nsresult rv = OpenInputStreamFromExternalDTD(publicId, systemId, base,
getter_AddRefs(in), absURL);
if (NS_FAILED(rv)) {
#ifdef DEBUG
nsCString message("Failed to open external DTD: publicId \"");
AppendUTF16toUTF8(publicId, message);
message += "\" systemId \"";
AppendUTF16toUTF8(systemId, message);
message += "\" base \"";
AppendUTF16toUTF8(base, message);
message += "\" URL \"";
AppendUTF16toUTF8(absURL, message);
message += "\"";
NS_WARNING(message.get());
#endif
return 1;
}
nsCOMPtr<nsIUnicharInputStream> uniIn;
rv = nsSimpleUnicharStreamFactory::GetInstance()->
CreateInstanceFromUTF8Stream(in, getter_AddRefs(uniIn));
NS_ENSURE_SUCCESS(rv, 1);
int result = 1;
if (uniIn) {
XML_Parser entParser = XML_ExternalEntityParserCreate(mExpatParser, 0,
kUTF16);
if (entParser) {
XML_SetBase(entParser, absURL.get());
mInExternalDTD = true;
uint32_t totalRead;
do {
rv = uniIn->ReadSegments(ExternalDTDStreamReaderFunc, entParser,
uint32_t(-1), &totalRead);
} while (NS_SUCCEEDED(rv) && totalRead > 0);
result = XML_Parse(entParser, nullptr, 0, 1);
mInExternalDTD = false;
XML_ParserFree(entParser);
}
}
return result;
}
