libxml.c

/*
 +----------------------------------------------------------------------+
 | Copyright (c) The PHP Group |
 +----------------------------------------------------------------------+
 | This source file is subject to version 3.01 of the PHP license, |
 | that is bundled with this package in the file LICENSE, and is |
 | available through the world-wide-web at the following url: |
 | https://www.php.net/license/3_01.txt |
 | If you did not receive a copy of the PHP license and are unable to |
 | obtain it through the world-wide-web, please send a note to |
 | license@php.net so we can mail you a copy immediately. |
 +----------------------------------------------------------------------+
 | Authors: Shane Caraveo <shane@php.net> |
 | Wez Furlong <wez@thebrainroom.com> |
 +----------------------------------------------------------------------+
 */

#ifdefHAVE_CONFIG_H
#include"config.h"
#endif

#include"php.h"
#include"SAPI.h"

#include"zend_attributes.h"
#include"zend_variables.h"
#include"ext/standard/info.h"
#include"ext/standard/file.h"

#ifdefHAVE_LIBXML

#include<libxml/parser.h>
#include<libxml/parserInternals.h>
#include<libxml/tree.h>
#include<libxml/uri.h>
#include<libxml/xmlerror.h>
#include<libxml/xmlsave.h>
#include<libxml/xmlerror.h>
#include<libxml/entities.h>
#ifdefLIBXML_SCHEMAS_ENABLED
#include<libxml/relaxng.h>
#include<libxml/xmlschemas.h>
#endif

#include"php_libxml.h"

#definePHP_LIBXML_LOADED_VERSION ((char *)xmlParserVersion)

#include"libxml_arginfo.h"

/* a true global for initialization */
staticint_php_libxml_initialized=0;
staticint_php_libxml_per_request_initialization=1;
staticxmlExternalEntityLoader_php_libxml_default_entity_loader;

typedefstruct_php_libxml_func_handler {
php_libxml_export_nodeexport_func;
} php_libxml_func_handler;

staticHashTablephp_libxml_exports;

staticZEND_DECLARE_MODULE_GLOBALS(libxml)
staticPHP_GINIT_FUNCTION(libxml);

staticzend_class_entry*libxmlerror_class_entry;

/* {{{ dynamically loadable module stuff */
#ifdefCOMPILE_DL_LIBXML
#ifdefZTS
ZEND_TSRMLS_CACHE_DEFINE()
#endif
ZEND_GET_MODULE(libxml)
#endif/* COMPILE_DL_LIBXML */
/* }}} */

/* {{{ function prototypes */
staticPHP_MINIT_FUNCTION(libxml);
staticPHP_RINIT_FUNCTION(libxml);
staticPHP_RSHUTDOWN_FUNCTION(libxml);
staticPHP_MSHUTDOWN_FUNCTION(libxml);
staticPHP_MINFO_FUNCTION(libxml);
staticzend_resultphp_libxml_post_deactivate(void);

staticzend_string*php_libxml_default_dump_node_to_str(xmlDocPtrdoc, xmlNodePtrnode, boolformat, constchar*encoding);
staticzend_string*php_libxml_default_dump_doc_to_str(xmlDocPtrdoc, intoptions, constchar*encoding);
staticzend_longphp_libxml_dump_node_to_file(constchar*filename, xmlDocPtrdoc, xmlNodePtrnode, boolformat, constchar*encoding);
staticzend_longphp_libxml_default_dump_doc_to_file(constchar*filename, xmlDocPtrdoc, boolformat, constchar*encoding);

/* }}} */

zend_module_entrylibxml_module_entry= {
STANDARD_MODULE_HEADER,
"libxml", /* extension name */
ext_functions, /* extension function list */
PHP_MINIT(libxml), /* extension-wide startup function */
PHP_MSHUTDOWN(libxml), /* extension-wide shutdown function */
PHP_RINIT(libxml), /* per-request startup function */
PHP_RSHUTDOWN(libxml), /* per-request shutdown function */
PHP_MINFO(libxml), /* information function */
PHP_LIBXML_VERSION,
PHP_MODULE_GLOBALS(libxml), /* globals descriptor */
PHP_GINIT(libxml), /* globals ctor */
NULL, /* globals dtor */
php_libxml_post_deactivate, /* post deactivate */
STANDARD_MODULE_PROPERTIES_EX
};

/* }}} */

staticconstphp_libxml_document_handlersphp_libxml_default_document_handlers= {
 .dump_node_to_str=php_libxml_default_dump_node_to_str,
 .dump_doc_to_str=php_libxml_default_dump_doc_to_str,
 .dump_node_to_file=php_libxml_dump_node_to_file,
 .dump_doc_to_file=php_libxml_default_dump_doc_to_file,
};

staticvoidphp_libxml_set_old_ns_list(xmlDocPtrdoc, xmlNsPtrfirst, xmlNsPtrlast)
{
if (UNEXPECTED(doc==NULL)) {
return;
 }

ZEND_ASSERT(last->next==NULL);

/* Note: we'll use a prepend strategy instead of append to
 * make sure we don't lose performance when the list is long.
 * As libxml2 could assume the xml node is the first one, we'll place our
 * new entries after the first one. */

if (UNEXPECTED(doc->oldNs==NULL)) {
doc->oldNs= (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
if (doc->oldNs==NULL) {
return;
 }
memset(doc->oldNs, 0, sizeof(xmlNs));
doc->oldNs->type=XML_LOCAL_NAMESPACE;
doc->oldNs->href=xmlStrdup(XML_XML_NAMESPACE);
doc->oldNs->prefix=xmlStrdup((constxmlChar*)"xml");
 } else {
last->next=doc->oldNs->next;
 }
doc->oldNs->next=first;
}

PHP_LIBXML_APIvoidphp_libxml_set_old_ns(xmlDocPtrdoc, xmlNsPtrns)
{
php_libxml_set_old_ns_list(doc, ns, ns);
}

/* Function pointer typedef changed in 2.9.8, see https://github.com/GNOME/libxml2/commit/e03f0a199a67017b2f8052354cf732b2b4cae787 */
#ifLIBXML_VERSION >= 20908
staticvoidphp_libxml_unlink_entity(void*data, void*table, constxmlChar*name)
#else
staticvoidphp_libxml_unlink_entity(void*data, void*table, xmlChar*name)
#endif
{
xmlEntityPtrentity=data;
if (entity->_private!=NULL) {
xmlHashRemoveEntry(table, name, NULL);
 }
}

/* {{{ internal functions for interoperability */
staticvoidphp_libxml_unregister_node(xmlNodePtrnodep)
{
php_libxml_node_ptr*nodeptr=nodep->_private;

if (nodeptr!=NULL) {
php_libxml_node_object*wrapper=nodeptr->_private;
if (wrapper) {
php_libxml_decrement_node_ptr(wrapper);
php_libxml_decrement_doc_ref(wrapper);
 } else {
if (nodep->type!=XML_DOCUMENT_NODE) {
nodep->_private=NULL;
 }
nodeptr->node=NULL;
 }
 }
}

/* Workaround for libxml2 peculiarity */
staticvoidphp_libxml_unlink_entity_decl(xmlEntityPtrentity)
{
xmlDtdPtrdtd=entity->parent;
if (dtd!=NULL) {
if (xmlHashLookup(dtd->entities, entity->name) ==entity) {
xmlHashRemoveEntry(dtd->entities, entity->name, NULL);
 }
if (xmlHashLookup(dtd->pentities, entity->name) ==entity) {
xmlHashRemoveEntry(dtd->pentities, entity->name, NULL);
 }
 }
}

staticvoidphp_libxml_node_free(xmlNodePtrnode)
{
if (node->_private!=NULL) {
 ((php_libxml_node_ptr*) node->_private)->node=NULL;
 }
switch (node->type) {
caseXML_ATTRIBUTE_NODE:
xmlFreeProp((xmlAttrPtr) node);
break;
/* libxml2 has a peculiarity where if you unlink an entity it'll only unlink it from the dtd if the
 * dtd is attached to the document. This works around the issue by inspecting the parent directly. */
caseXML_ENTITY_DECL: {
xmlEntityPtrentity= (xmlEntityPtr) node;
if (entity->etype!=XML_INTERNAL_PREDEFINED_ENTITY) {
php_libxml_unlink_entity_decl(entity);
#ifLIBXML_VERSION >= 21200
xmlFreeEntity(entity);
#else
if (entity->children!=NULL&&entity->owner&&entity== (xmlEntityPtr) entity->children->parent) {
xmlFreeNodeList(entity->children);
 }
xmlDictPtrdict=entity->doc!=NULL ? entity->doc->dict : NULL;
if (dict==NULL|| !xmlDictOwns(dict, entity->name)) {
xmlFree((xmlChar*) entity->name);
 }
if (dict==NULL|| !xmlDictOwns(dict, entity->ExternalID)) {
xmlFree((xmlChar*) entity->ExternalID);
 }
if (dict==NULL|| !xmlDictOwns(dict, entity->SystemID)) {
xmlFree((xmlChar*) entity->SystemID);
 }
if (dict==NULL|| !xmlDictOwns(dict, entity->URI)) {
xmlFree((xmlChar*) entity->URI);
 }
if (dict==NULL|| !xmlDictOwns(dict, entity->content)) {
xmlFree(entity->content);
 }
if (dict==NULL|| !xmlDictOwns(dict, entity->orig)) {
xmlFree(entity->orig);
 }
xmlFree(entity);
#endif
 }
break;
 }
caseXML_NOTATION_NODE: {
/* See create_notation(), these aren't regular XML_NOTATION_NODE, but entities in disguise... */
xmlEntityPtrentity= (xmlEntityPtr) node;
if (node->name!=NULL) {
xmlFree((char*) node->name);
 }
if (entity->ExternalID!=NULL) {
xmlFree((char*) entity->ExternalID);
 }
if (entity->SystemID!=NULL) {
xmlFree((char*) entity->SystemID);
 }
xmlFree(node);
break;
 }
caseXML_ELEMENT_DECL:
caseXML_ATTRIBUTE_DECL:
break;
caseXML_NAMESPACE_DECL:
if (node->ns) {
xmlFreeNs(node->ns);
node->ns=NULL;
 }
node->type=XML_ELEMENT_NODE;
xmlFreeNode(node);
break;
caseXML_DTD_NODE: {
xmlDtdPtrdtd= (xmlDtdPtr) node;
if (dtd->_private==NULL) {
/* There's no userland reference to the dtd,
 * but there might be entities referenced from userland. Unlink those. */
xmlHashScan(dtd->entities, php_libxml_unlink_entity, dtd->entities);
xmlHashScan(dtd->pentities, php_libxml_unlink_entity, dtd->pentities);
/* No unlinking of notations, see remark above at case XML_NOTATION_NODE. */
 }
xmlFreeDtd(dtd);
break;
 }
caseXML_ELEMENT_NODE: {
if (node->ns&& (((uintptr_t) node->ns->_private) &1) ==LIBXML_NS_TAG_HOOK) {
/* Special destruction routine hook should be called because it belongs to a "special" namespace. */
php_libxml_private_data_header*header= (php_libxml_private_data_header*) (((uintptr_t) node->ns->_private) & ~1);
header->ns_hook(header, node);
 }
if (node->nsDef&&node->doc) {
/* Make the namespace declaration survive the destruction of the holding element.
 * This prevents a use-after-free on the namespace declaration.
 *
 * The main problem is that libxml2 doesn't have a reference count on the namespace declaration.
 * We don't actually need to save the namespace declaration if we know the subtree it belongs to
 * has no references from userland. However, we can't know that without traversing the whole subtree
 * (=> slow), or without adding some subtree metadata (=> also slow).
 * So we have to assume we need to save everything.
 *
 * However, namespace declarations are quite rare in comparison to other node types.
 * Most node types are either elements, text or attributes.
 * And you only need one namespace declaration per namespace (in principle).
 * So I expect the number of namespace declarations to be low for an average XML document.
 *
 * In the worst possible case we have to save all namespace declarations when we for example remove
 * the whole document. But given the above reasoning this likely won't be a lot of declarations even
 * in the worst case.
 * A single declaration only takes about 48 bytes of memory, and I don't expect the worst case to occur
 * very often (why would you remove the whole document?).
 */
xmlNsPtrns=node->nsDef;
xmlNsPtrlast=ns;
while (last->next) {
last=last->next;
 }
php_libxml_set_old_ns_list(node->doc, ns, last);
node->nsDef=NULL;
 }
xmlFreeNode(node);
break;
 }
default:
xmlFreeNode(node);
break;
 }
}

PHP_LIBXML_APIvoidphp_libxml_node_free_list(xmlNodePtrnode)
{
xmlNodePtrcurnode;

if (node!=NULL) {
curnode=node;
while (curnode!=NULL) {
/* If the _private field is set, there's still a userland reference somewhere. We'll delay freeing in this case. */
if (curnode->_private) {
xmlNodePtrnext=curnode->next;
/* Must unlink such that freeing of the parent doesn't free this child. */
xmlUnlinkNode(curnode);
if (curnode->type==XML_ELEMENT_NODE) {
/* This ensures that namespace references in this subtree are defined within this subtree,
 * otherwise a use-after-free would be possible when the original namespace holder gets freed. */
php_libxml_node_ptr*ptr=curnode->_private;

/* Checking in case it runs out of reference */
if (ptr->_private) {
php_libxml_node_object*obj=ptr->_private;
if (!obj->document||obj->document->class_type<PHP_LIBXML_CLASS_MODERN) {
xmlReconciliateNs(curnode->doc, curnode);
 }
 }
 }
/* Skip freeing */
curnode=next;
continue;
 }

node=curnode;
switch (node->type) {
/* Skip property freeing for the following types */
caseXML_ENTITY_REF_NODE:
caseXML_NOTATION_NODE:
break;
caseXML_ENTITY_DECL:
php_libxml_unlink_entity_decl((xmlEntityPtr) node);
break;
caseXML_ATTRIBUTE_NODE:
if ((node->doc!=NULL) && (((xmlAttrPtr) node)->atype==XML_ATTRIBUTE_ID)) {
xmlRemoveID(node->doc, (xmlAttrPtr) node);
 }
ZEND_FALLTHROUGH;
caseXML_ATTRIBUTE_DECL:
caseXML_DTD_NODE:
caseXML_DOCUMENT_TYPE_NODE:
caseXML_NAMESPACE_DECL:
caseXML_TEXT_NODE:
php_libxml_node_free_list(node->children);
break;
default:
php_libxml_node_free_list(node->children);
php_libxml_node_free_list((xmlNodePtr) node->properties);
 }

curnode=node->next;
xmlUnlinkNode(node);
php_libxml_unregister_node(node);
php_libxml_node_free(node);
 }
 }
}

/* }}} */

/* {{{ startup, shutdown and info functions */
staticPHP_GINIT_FUNCTION(libxml)
{
#if defined(COMPILE_DL_LIBXML) && defined(ZTS)
ZEND_TSRMLS_CACHE_UPDATE();
#endif
ZVAL_UNDEF(&libxml_globals->stream_context);
libxml_globals->error_buffer.s=NULL;
libxml_globals->error_list=NULL;
libxml_globals->entity_loader_callback=empty_fcall_info_cache;
}

PHP_LIBXML_APIphp_stream_context*php_libxml_get_stream_context(void)
{
returnphp_stream_context_from_zval(Z_ISUNDEF(LIBXML(stream_context)) ? NULL : &LIBXML(stream_context), false);
}

/* Channel libxml file io layer through the PHP streams subsystem.
 * This allows use of ftps:// and https:// urls */

staticvoid*php_libxml_streams_IO_open_wrapper(constchar*filename, constchar*mode, constintread_only)
{
php_stream_statbufssbuf;
char*resolved_path;
constchar*path_to_open=NULL;
boolisescaped= false;

if (strstr(filename, "%00")) {
php_error_docref(NULL, E_WARNING, "URI must not contain percent-encoded NUL bytes");
returnNULL;
 }

xmlURI*uri=xmlParseURI(filename);
if (uri&& (uri->scheme==NULL||
 (xmlStrncmp(BAD_CASTuri->scheme, BAD_CAST"file", 4) ==0))) {
resolved_path=xmlURIUnescapeString(filename, 0, NULL);
isescaped=1;
#ifLIBXML_VERSION >= 20902&&LIBXML_VERSION<21300&& defined(PHP_WIN32)
/* Libxml 2.9.2 prefixes local paths with file:/ instead of file://,
 thus the php stream wrapper will fail on a valid case. For this
 reason the prefix is rather better cut off.
 As of libxml 2.13.0 this issue is resolved. */
 {
size_tpre_len=sizeof("file:/") -1;

if (strncasecmp(resolved_path, "file:/", pre_len) ==0
&&'/'!=resolved_path[pre_len]) {
xmlChar*tmp=xmlStrdup(resolved_path+pre_len);
xmlFree(resolved_path);
resolved_path=tmp;
 }
 }
#endif
 } else {
resolved_path= (char*)filename;
 }

if (uri) {
xmlFreeURI(uri);
 }

if (resolved_path==NULL) {
returnNULL;
 }

/* logic copied from _php_stream_stat, but we only want to fail
 if the wrapper supports stat, otherwise, figure it out from
 the open. This logic is only to support hiding warnings
 that the streams layer puts out at times, but for libxml we
 may try to open files that don't exist, but it is not a failure
 in xml processing (eg. DTD files) */
php_stream_wrapper*wrapper=php_stream_locate_url_wrapper(resolved_path, &path_to_open, 0);
if (wrapper&&read_only&&wrapper->wops->url_stat) {
if (wrapper->wops->url_stat(wrapper, path_to_open, PHP_STREAM_URL_STAT_QUIET, &ssbuf, NULL) ==-1) {
if (isescaped) {
xmlFree(resolved_path);
 }
returnNULL;
 }
 }

php_stream_context*context=php_libxml_get_stream_context();

php_stream*ret_val=php_stream_open_wrapper_ex(path_to_open, mode, REPORT_ERRORS, NULL, context);
if (ret_val) {
/* Prevent from closing this by fclose() */
ret_val->flags |= PHP_STREAM_FLAG_NO_FCLOSE;
 }
if (isescaped) {
xmlFree(resolved_path);
 }
returnret_val;
}

staticvoid*php_libxml_streams_IO_open_read_wrapper(constchar*filename)
{
returnphp_libxml_streams_IO_open_wrapper(filename, "rb", 1);
}

staticvoid*php_libxml_streams_IO_open_write_wrapper(constchar*filename)
{
returnphp_libxml_streams_IO_open_wrapper(filename, "wb", 0);
}

staticintphp_libxml_streams_IO_read(void*context, char*buffer, intlen)
{
returnphp_stream_read((php_stream*)context, buffer, len);
}

staticintphp_libxml_streams_IO_write(void*context, constchar*buffer, intlen)
{
returnphp_stream_write((php_stream*)context, buffer, len);
}

staticintphp_libxml_streams_IO_close(void*context)
{
returnphp_stream_close((php_stream*)context);
}

staticxmlParserInputBufferPtr
php_libxml_input_buffer_create_filename(constchar*URI, xmlCharEncodingenc)
{
xmlParserInputBufferPtrret;
void*context=NULL;

if (LIBXML(entity_loader_disabled)) {
returnNULL;
 }

if (URI==NULL)
return(NULL);

context=php_libxml_streams_IO_open_read_wrapper(URI);

if (context==NULL) {
return(NULL);
 }

/* Check if there's been an external transport protocol with an encoding information */
if (enc==XML_CHAR_ENCODING_NONE) {
php_stream*s= (php_stream*) context;
zend_string*charset=php_libxml_sniff_charset_from_stream(s);
if (charset!=NULL) {
enc=xmlParseCharEncoding(ZSTR_VAL(charset));
if (enc <= XML_CHAR_ENCODING_NONE) {
enc=XML_CHAR_ENCODING_NONE;
 }
zend_string_release_ex(charset, false);
 }
 }

/* Allocate the Input buffer front-end. */
ret=xmlAllocParserInputBuffer(enc);
if (ret!=NULL) {
ret->context=context;
ret->readcallback=php_libxml_streams_IO_read;
ret->closecallback=php_libxml_streams_IO_close;
 } else
php_libxml_streams_IO_close(context);

return(ret);
}

staticxmlOutputBufferPtr
php_libxml_output_buffer_create_filename(constchar*URI,
xmlCharEncodingHandlerPtrencoder,
intcompression)
{
ZEND_IGNORE_VALUE(compression);

xmlOutputBufferPtrret;
xmlURIPtrpuri;
void*context=NULL;
char*unescaped=NULL;

if (URI==NULL)
 goto err;

if (strstr(URI, "%00")) {
php_error_docref(NULL, E_WARNING, "URI must not contain percent-encoded NUL bytes");
 goto err;
 }

puri=xmlParseURI(URI);
if (puri!=NULL) {
if (puri->scheme!=NULL)
unescaped=xmlURIUnescapeString(URI, 0, NULL);
xmlFreeURI(puri);
 }

if (unescaped!=NULL) {
context=php_libxml_streams_IO_open_write_wrapper(unescaped);
xmlFree(unescaped);
 }

/* try with a non-escaped URI this may be a strange filename */
if (context==NULL) {
context=php_libxml_streams_IO_open_write_wrapper(URI);
 }

if (context==NULL) {
 goto err;
 }

/* Allocate the Output buffer front-end. */
ret=xmlAllocOutputBuffer(encoder);
if (ret!=NULL) {
ret->context=context;
ret->writecallback=php_libxml_streams_IO_write;
ret->closecallback=php_libxml_streams_IO_close;
 }

return(ret);

err:
/* Similarly to __xmlOutputBufferCreateFilename we should also close the encoder on failure. */
xmlCharEncCloseFunc(encoder);
returnNULL;
}

staticvoid_php_libxml_free_error(void*ptr)
{
/* This will free the libxml alloc'd memory */
xmlResetError((xmlErrorPtr) ptr);
}

#ifLIBXML_VERSION >= 21200
staticvoid_php_list_set_error_structure(constxmlError*error, constchar*msg, intline, intcolumn)
#else
staticvoid_php_list_set_error_structure(xmlError*error, constchar*msg, intline, intcolumn)
#endif
{
xmlErrorerror_copy;
intret;


memset(&error_copy, 0, sizeof(xmlError));

if (error) {
ret=xmlCopyError(error, &error_copy);
 } else {
error_copy.code=XML_ERR_INTERNAL_ERROR;
error_copy.level=XML_ERR_ERROR;
error_copy.line=line;
error_copy.int2=column;
error_copy.message= (char*)xmlStrdup((constxmlChar*)msg);
ret=0;
 }

if (ret==0) {
zend_llist_add_element(LIBXML(error_list), &error_copy);
 }
}

staticvoidphp_libxml_ctx_error_level(intlevel, void*ctx, constchar*msg, intline)
{
xmlParserCtxtPtrparser;

parser= (xmlParserCtxtPtr) ctx;

if (parser!=NULL&&parser->input!=NULL) {
if (parser->input->filename) {
php_error_docref(NULL, level, "%s in %s, line: %d", msg, parser->input->filename, line);
 } else {
php_error_docref(NULL, level, "%s in Entity, line: %d", msg, line);
 }
 } else {
php_error_docref(NULL, E_WARNING, "%s", msg);
 }
}

voidphp_libxml_issue_error(intlevel, constchar*msg)
{
if (LIBXML(error_list)) {
_php_list_set_error_structure(NULL, msg, 0, 0);
 } else {
php_error_docref(NULL, level, "%s", msg);
 }
}

staticvoidphp_libxml_internal_error_handler_ex(php_libxml_error_levelerror_type, void*ctx, constchar*msg, va_listap, intline, intcolumn)
{
char*buf;
booloutput= false;

size_tlen=vspprintf(&buf, 0, msg, ap);
size_tlen_iter=len;

/* remove any trailing \n */
while (len_iter&&buf[--len_iter] =='\n') {
buf[len_iter] ='\0';
output= true;
 }

smart_str_appendl(&LIBXML(error_buffer), buf, len);

efree(buf);

if (output) {
if (LIBXML(error_list)) {
_php_list_set_error_structure(NULL, ZSTR_VAL(LIBXML(error_buffer).s), line, column);
 } elseif (!EG(exception)) {
/* Don't throw additional notices/warnings if an exception has already been thrown. */
switch (error_type) {
casePHP_LIBXML_CTX_ERROR:
php_libxml_ctx_error_level(E_WARNING, ctx, ZSTR_VAL(LIBXML(error_buffer).s), line);
break;
casePHP_LIBXML_CTX_WARNING:
php_libxml_ctx_error_level(E_NOTICE, ctx, ZSTR_VAL(LIBXML(error_buffer).s), line);
break;
default:
php_error_docref(NULL, E_WARNING, "%s", ZSTR_VAL(LIBXML(error_buffer).s));
 }
 }
smart_str_free(&LIBXML(error_buffer));
 }
}

PHP_LIBXML_APIvoidphp_libxml_error_handler_va(php_libxml_error_levelerror_type, void*ctx, constchar*msg, va_listap)
{
intline=0;
intcolumn=0;
xmlParserCtxtPtrparser= (xmlParserCtxtPtr) ctx;
/* Context is not valid for PHP_LIBXML_ERROR, don't dereference it in that case */
if (error_type!=PHP_LIBXML_ERROR&&parser!=NULL&&parser->input!=NULL) {
line=parser->input->line;
column=parser->input->col;
 }
php_libxml_internal_error_handler_ex(error_type, ctx, msg, ap, line, column);
}

staticxmlParserInputPtr_php_libxml_external_entity_loader(constchar*URL,
constchar*ID, xmlParserCtxtPtrcontext)
{
xmlParserInputPtrret=NULL;
constchar*resource=NULL;
zval*ctxzv, retval;
zvalparams[3];

/* no custom user-land callback set up; delegate to original loader */
if (!ZEND_FCC_INITIALIZED(LIBXML(entity_loader_callback))) {
return_php_libxml_default_entity_loader(URL, ID, context);
 }

if (ID!=NULL) {
ZVAL_STRING(&params[0], ID);
 } else {
ZVAL_NULL(&params[0]);
 }
if (URL!=NULL) {
ZVAL_STRING(&params[1], URL);
 } else {
ZVAL_NULL(&params[1]);
 }
ctxzv=&params[2];
array_init_size(ctxzv, 4);

#defineADD_NULL_OR_STRING_KEY(memb) \
 if (context->memb == NULL) { \
 add_assoc_null_ex(ctxzv, #memb, sizeof(#memb) - 1); \
 } else { \
 add_assoc_string_ex(ctxzv, #memb, sizeof(#memb) - 1, \
 (char *)context->memb); \
 }

ADD_NULL_OR_STRING_KEY(directory)
ADD_NULL_OR_STRING_KEY(intSubName)
ADD_NULL_OR_STRING_KEY(extSubURI)
ADD_NULL_OR_STRING_KEY(extSubSystem)

#undefADD_NULL_OR_STRING_KEY

zend_call_known_fcc(&LIBXML(entity_loader_callback), &retval, 3, params, /* named_params */NULL);

if (Z_ISUNDEF(retval)) {
php_libxml_ctx_error(context,
"Call to user entity loader callback '%s' has failed",
ZSTR_VAL(LIBXML(entity_loader_callback).function_handler->common.function_name));
 } else {
if (Z_TYPE(retval) ==IS_STRING) {
is_string:
resource=Z_STRVAL(retval);
 } elseif (Z_TYPE(retval) ==IS_RESOURCE) {
php_stream*stream;
php_stream_from_zval_no_verify(stream, &retval);
if (stream==NULL) {
php_libxml_ctx_error(context,
"The user entity loader callback '%s' has returned a "
"resource, but it is not a stream",
ZSTR_VAL(LIBXML(entity_loader_callback).function_handler->common.function_name));
 } else {
/* TODO: allow storing the encoding in the stream context? */
xmlCharEncodingenc=XML_CHAR_ENCODING_NONE;
xmlParserInputBufferPtrpib=xmlAllocParserInputBuffer(enc);
if (pib==NULL) {
php_libxml_ctx_error(context, "Could not allocate parser "
"input buffer");
 } else {
/* make stream not being closed when the zval is freed */
GC_ADDREF(stream->res);
pib->context=stream;
pib->readcallback=php_libxml_streams_IO_read;
pib->closecallback=php_libxml_streams_IO_close;

ret=xmlNewIOInputStream(context, pib, enc);
if (ret==NULL) {
xmlFreeParserInputBuffer(pib);
 }
 }
 }
 } elseif (Z_TYPE(retval) !=IS_NULL) {
/* retval not string nor resource nor null; convert to string */
if (try_convert_to_string(&retval)) {
 goto is_string;
 }
 } /* else is null; don't try anything */
 }

if (ret==NULL) {
if (resource==NULL) {
if (ID==NULL) {
php_libxml_ctx_error(context,
"Failed to load external entity because the resolver function returned null\n");
 } else {
php_libxml_ctx_error(context,
"Failed to load external entity \"%s\"\n", ID);
 }
 } else {
/* we got the resource in the form of a string; open it */
ret=xmlNewInputFromFile(context, resource);
 }
 }

zval_ptr_dtor(&params[0]);
zval_ptr_dtor(&params[1]);
zval_ptr_dtor(&params[2]);
zval_ptr_dtor(&retval);
returnret;
}

staticxmlParserInputPtr_php_libxml_pre_ext_ent_loader(constchar*URL,
constchar*ID, xmlParserCtxtPtrcontext)
{

/* Check whether we're running in a PHP context, since the entity loader
 * we've defined is an application level (true global) setting.
 * If we are, we also want to check whether we've finished activating
 * the modules (RINIT phase). Using our external entity loader during a
 * RINIT should not be problem per se (though during MINIT it is, because
 * we don't even have a resource list by then), but then whether one
 * extension would be using the custom external entity loader or not
 * could depend on extension loading order
 * (if _php_libxml_per_request_initialization */
if (xmlGenericError==php_libxml_error_handler&&PG(modules_activated)) {
return_php_libxml_external_entity_loader(URL, ID, context);
 } else {
return_php_libxml_default_entity_loader(URL, ID, context);
 }
}

PHP_LIBXML_APIvoidphp_libxml_pretend_ctx_error_ex(constchar*file, intline, intcolumn, constchar*msg,...)
{
va_listargs;
va_start(args, msg);
php_libxml_internal_error_handler_ex(PHP_LIBXML_CTX_ERROR, NULL, msg, args, line, column);
va_end(args);

/* Propagate back into libxml */
if (LIBXML(error_list)) {
xmlErrorPtrlast=zend_llist_get_last(LIBXML(error_list));
if (last&& !last->file) {
last->file=strdup(file);
 }
 }
}

PHP_LIBXML_APIvoidphp_libxml_ctx_error(void*ctx, constchar*msg, ...)
{
va_listargs;
va_start(args, msg);
php_libxml_error_handler_va(PHP_LIBXML_CTX_ERROR, ctx, msg, args);
va_end(args);
}

PHP_LIBXML_APIvoidphp_libxml_ctx_warning(void*ctx, constchar*msg, ...)
{
va_listargs;
va_start(args, msg);
php_libxml_error_handler_va(PHP_LIBXML_CTX_WARNING, ctx, msg, args);
va_end(args);
}

#ifLIBXML_VERSION >= 21200
staticvoidphp_libxml_structured_error_handler(void*userData, constxmlError*error)
#else
staticvoidphp_libxml_structured_error_handler(void*userData, xmlErrorPtrerror)
#endif
{
_php_list_set_error_structure(error, NULL, 0, 0);
}

PHP_LIBXML_APIvoidphp_libxml_error_handler(void*ctx, constchar*msg, ...)
{
va_listargs;
va_start(args, msg);
php_libxml_error_handler_va(PHP_LIBXML_ERROR, ctx, msg, args);
va_end(args);
}

staticvoidphp_libxml_exports_dtor(zval*zv)
{
free(Z_PTR_P(zv));
}

PHP_LIBXML_APIvoidphp_libxml_initialize(void)
{
if (!_php_libxml_initialized) {
/* we should be the only one's to ever init!! */
ZEND_IGNORE_LEAKS_BEGIN();
xmlInitParser();
ZEND_IGNORE_LEAKS_END();

_php_libxml_default_entity_loader=xmlGetExternalEntityLoader();
xmlSetExternalEntityLoader(_php_libxml_pre_ext_ent_loader);

zend_hash_init(&php_libxml_exports, 0, NULL, php_libxml_exports_dtor, 1);

_php_libxml_initialized=1;
 }
}

PHP_LIBXML_APIvoidphp_libxml_shutdown(void)
{
if (_php_libxml_initialized) {
#if defined(LIBXML_SCHEMAS_ENABLED) &&LIBXML_VERSION<21000
xmlRelaxNGCleanupTypes();
#endif
/* xmlCleanupParser(); */
zend_hash_destroy(&php_libxml_exports);

xmlSetExternalEntityLoader(_php_libxml_default_entity_loader);
_php_libxml_initialized=0;
 }
}

PHP_LIBXML_APIvoidphp_libxml_switch_context(zval*context, zval*oldcontext)
{
if (oldcontext) {
ZVAL_COPY_VALUE(oldcontext, &LIBXML(stream_context));
 }
if (context) {
ZVAL_COPY_VALUE(&LIBXML(stream_context), context);
 }
}

staticPHP_MINIT_FUNCTION(libxml)
{
php_libxml_initialize();

register_libxml_symbols(module_number);

libxmlerror_class_entry=register_class_LibXMLError();

if (sapi_module.name) {
staticconstchar*constsupported_sapis[] = {
"cgi-fcgi",
"litespeed",
NULL
 };
constchar*const*sapi_name;

for (sapi_name=supported_sapis; *sapi_name; sapi_name++) {
if (strcmp(sapi_module.name, *sapi_name) ==0) {
_php_libxml_per_request_initialization=0;
break;
 }
 }
 }

if (!_php_libxml_per_request_initialization) {
/* report errors via handler rather than stderr */
xmlSetGenericErrorFunc(NULL, php_libxml_error_handler);
xmlParserInputBufferCreateFilenameDefault(php_libxml_input_buffer_create_filename);
xmlOutputBufferCreateFilenameDefault(php_libxml_output_buffer_create_filename);
 }

returnSUCCESS;
}


staticPHP_RINIT_FUNCTION(libxml)
{
if (_php_libxml_per_request_initialization) {
/* report errors via handler rather than stderr */
xmlSetGenericErrorFunc(NULL, php_libxml_error_handler);
xmlParserInputBufferCreateFilenameDefault(php_libxml_input_buffer_create_filename);
xmlOutputBufferCreateFilenameDefault(php_libxml_output_buffer_create_filename);
 }

/* Enable the entity loader by default. This ensures that
 * other threads/requests that might have disabled the loader
 * do not affect the current request.
 */
LIBXML(entity_loader_disabled) =0;

returnSUCCESS;
}

staticPHP_RSHUTDOWN_FUNCTION(libxml)
{
if (ZEND_FCC_INITIALIZED(LIBXML(entity_loader_callback))) {
zend_fcc_dtor(&LIBXML(entity_loader_callback));