php_xsl.c

Go to the documentation of this file.

/*
  +----------------------------------------------------------------------+
  | 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.               |
  +----------------------------------------------------------------------+
  | Author: Christian Stocker <chregu@php.net>                           |
  +----------------------------------------------------------------------+
*/
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include "php.h"
#include "ext/standard/info.h"
#include "php_xsl.h"
#include "php_xsl_arginfo.h"
 
zend_class_entry *xsl_xsltprocessor_class_entry;
static zend_object_handlers xsl_object_handlers;
 
static const zend_module_dep xsl_deps[] = {
    ZEND_MOD_REQUIRED("libxml")
    ZEND_MOD_REQUIRED("dom")
    ZEND_MOD_END
};
 
/* {{{ xsl_module_entry */
zend_module_entry xsl_module_entry = {
    STANDARD_MODULE_HEADER_EX, NULL,
    xsl_deps,
    "xsl",
    NULL,
    PHP_MINIT(xsl),
    PHP_MSHUTDOWN(xsl),
    NULL,
    NULL,
    PHP_MINFO(xsl),
    PHP_XSL_VERSION,
    STANDARD_MODULE_PROPERTIES
};
/* }}} */
 
#ifdef COMPILE_DL_XSL
ZEND_GET_MODULE(xsl)
#endif
 
static HashTable *xsl_objects_get_gc(zend_object *object, zval **table, int *n)
{
    xsl_object *intern = php_xsl_fetch_object(object);
    return php_dom_xpath_callbacks_get_gc_for_whole_object(&intern->xpath_callbacks, object, table, n);
}
 
void xsl_free_sheet(xsl_object *intern)
{
    if (intern->ptr) {
        xsltStylesheetPtr sheet = intern->ptr;
 
        /* Free wrapper */
        if (sheet->_private != NULL) {
            sheet->_private = NULL;
        }
 
        xsltFreeStylesheet(sheet);
        intern->ptr = NULL;
    }
}
 
/* {{{ xsl_objects_free_storage */
void xsl_objects_free_storage(zend_object *object)
{
    xsl_object *intern = php_xsl_fetch_object(object);
 
    zend_object_std_dtor(&intern->std);
 
    if (intern->parameter) {
        zend_hash_destroy(intern->parameter);
        FREE_HASHTABLE(intern->parameter);
    }
 
    php_dom_xpath_callbacks_dtor(&intern->xpath_callbacks);
 
    xsl_free_sheet(intern);
 
    if (intern->doc) {
        php_libxml_decrement_doc_ref(intern->doc);
        efree(intern->doc);
    }
 
    if (intern->sheet_ref_obj) {
        php_libxml_decrement_doc_ref_directly(intern->sheet_ref_obj);
    }
 
    if (intern->profiling) {
        zend_string_release(intern->profiling);
    }
}
/* }}} */
 
/* {{{ xsl_objects_new */
zend_object *xsl_objects_new(zend_class_entry *class_type)
{
    xsl_object *intern;
 
    intern = zend_object_alloc(sizeof(xsl_object), class_type);
    intern->securityPrefs = XSL_SECPREF_DEFAULT;
 
    zend_object_std_init(&intern->std, class_type);
    object_properties_init(&intern->std, class_type);
    intern->parameter = zend_new_array(0);
    php_dom_xpath_callbacks_ctor(&intern->xpath_callbacks);
 
    /* Default initialize properties that could not be default initialized at the stub because they depend on library
     * configuration parameters. */
    ZVAL_LONG(xsl_prop_max_template_depth(&intern->std), xsltMaxDepth);
    ZVAL_LONG(xsl_prop_max_template_vars(&intern->std), xsltMaxVars);
 
    return &intern->std;
}
/* }}} */
 
#if ZEND_DEBUG
# define XSL_DEFINE_PROP_ACCESSOR(c_name, php_name, prop_index) \
    zval *xsl_prop_##c_name(zend_object *object) \
    { \
        zend_string *prop_name = ZSTR_INIT_LITERAL(php_name, false); \
        const zend_property_info *prop_info = zend_get_property_info(xsl_xsltprocessor_class_entry, prop_name, 0); \
        zend_string_release_ex(prop_name, false); \
        ZEND_ASSERT(OBJ_PROP_TO_NUM(prop_info->offset) == (prop_index)); \
        return OBJ_PROP_NUM(object, (prop_index)); \
    }
#else
# define XSL_DEFINE_PROP_ACCESSOR(c_name, php_name, prop_index) \
    zval *xsl_prop_##c_name(zend_object *object) \
    { \
        return OBJ_PROP_NUM(object, (prop_index)); \
    }
#endif
 
XSL_DEFINE_PROP_ACCESSOR(max_template_depth, "maxTemplateDepth", 2)
XSL_DEFINE_PROP_ACCESSOR(max_template_vars, "maxTemplateVars", 3)
 
static zval *xsl_objects_write_property_with_validation(zend_object *object, zend_string *member, zval *value, void **cache_slot, zval *property)
{
    /* Read old value so we can restore it if necessary. The value is not refcounted as its type is IS_LONG. */
    ZEND_ASSERT(Z_TYPE_P(property) == IS_LONG);
    zend_long old_property_value = Z_LVAL_P(property);
 
    /* Write new property, which will also potentially perform coercions. */
    zend_std_write_property(object, member, value, NULL);
 
    /* Validate value *after* coercions have been performed, and restore the old value if necessary. */
    if (UNEXPECTED(Z_LVAL_P(property) < 0)) {
        Z_LVAL_P(property) = old_property_value;
        zend_value_error("%s::$%s must be greater than or equal to 0", ZSTR_VAL(object->ce->name), ZSTR_VAL(member));
        return &EG(error_zval);
    }
 
    return property;
}
 
static zval *xsl_objects_write_property(zend_object *object, zend_string *member, zval *value, void **cache_slot)
{
    /* Extra validation for maxTemplateDepth and maxTemplateVars */
    if (zend_string_equals_literal(member, "maxTemplateDepth")) {
        zval *property = xsl_prop_max_template_depth(object);
        return xsl_objects_write_property_with_validation(object, member, value, cache_slot, property);
    } else if (zend_string_equals_literal(member, "maxTemplateVars")) {
        zval *property = xsl_prop_max_template_vars(object);
        return xsl_objects_write_property_with_validation(object, member, value, cache_slot, property);
    } else {
        return zend_std_write_property(object, member, value, cache_slot);
    }
}
 
static bool xsl_is_validated_property(const zend_string *member)
{
    return zend_string_equals_literal(member, "maxTemplateDepth") || zend_string_equals_literal(member, "maxTemplateVars");
}
 
static zval *xsl_objects_get_property_ptr_ptr(zend_object *object, zend_string *member, int type, void **cache_slot)
{
    if (xsl_is_validated_property(member)) {
        return NULL;
    }
 
    return zend_std_get_property_ptr_ptr(object, member, type, cache_slot);
}
 
static zval *xsl_objects_read_property(zend_object *object, zend_string *member, int type, void **cache_slot, zval *rv)
{
    /* read handler is being called as a fallback after get_property_ptr_ptr returned NULL */
    if (type != BP_VAR_IS && type != BP_VAR_R && xsl_is_validated_property(member)) {
        zend_throw_error(NULL, "Indirect modification of %s::$%s is not allowed", ZSTR_VAL(object->ce->name), ZSTR_VAL(member));
        return &EG(uninitialized_zval);
    }
 
    return zend_std_read_property(object, member, type, cache_slot, rv);
}
 
static void xsl_objects_unset_property(zend_object *object, zend_string *member, void **cache_slot)
{
    if (xsl_is_validated_property(member)) {
        zend_throw_error(NULL, "Cannot unset %s::$%s", ZSTR_VAL(object->ce->name), ZSTR_VAL(member));
        return;
    }
 
    zend_std_unset_property(object, member, cache_slot);
}
 
/* Tries to output an error message where a part was replaced by another string.
 * Returns true if the search string was found and the error message with replacement was outputted.
 * Return false otherwise. */
static bool xsl_try_output_replaced_error_message(
    void *ctx,
    const char *msg,
    const char *search,
    size_t search_len,
    const char *replace
)
{
    const char *msg_replace_location = strstr(msg, search);
    if (msg_replace_location != NULL) {
        php_libxml_ctx_error(ctx, "%.*s%s%s", (int) (msg_replace_location - msg), msg, replace, msg_replace_location + search_len);
        return true;
    }
    return false;
}
 
/* Helper macro so the string length doesn't need to be passed separately.
 * Only allows literal strings for `search` and `replace`. */
#define XSL_TRY_OUTPUT_REPLACED_ERROR_MESSAGE(ctx, msg, search, replace) \
    xsl_try_output_replaced_error_message(ctx, msg, "" search, sizeof("" search) - 1, "" replace)
 
/* We want to output PHP-tailored error messages for some libxslt error messages, such that
 * the errors refer to PHP properties instead of libxslt-specific fields. */
static void xsl_libxslt_error_handler(void *ctx, const char *msg, ...)
{
    va_list args;
    va_start(args, msg);
 
    if (strcmp(msg, "%s") == 0) {
        /* Adjust error message to be more descriptive */
        const char *msg_arg = va_arg(args, const char *);
        bool output = XSL_TRY_OUTPUT_REPLACED_ERROR_MESSAGE(ctx, msg_arg, "xsltMaxDepth (--maxdepth)", "$maxTemplateDepth")
                   || XSL_TRY_OUTPUT_REPLACED_ERROR_MESSAGE(ctx, msg_arg, "maxTemplateVars (--maxvars)", "$maxTemplateVars");
 
        if (!output) {
            php_libxml_ctx_error(ctx, "%s", msg_arg);
        }
    } else {
        php_libxml_error_handler_va(PHP_LIBXML_ERROR, ctx, msg, args);
    }
 
    va_end(args);
}
 
/* {{{ PHP_MINIT_FUNCTION */
PHP_MINIT_FUNCTION(xsl)
{
    memcpy(&xsl_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
    xsl_object_handlers.offset = XtOffsetOf(xsl_object, std);
    xsl_object_handlers.clone_obj = NULL;
    xsl_object_handlers.free_obj = xsl_objects_free_storage;
    xsl_object_handlers.get_gc = xsl_objects_get_gc;
    xsl_object_handlers.write_property = xsl_objects_write_property;
    xsl_object_handlers.get_property_ptr_ptr = xsl_objects_get_property_ptr_ptr;
    xsl_object_handlers.read_property = xsl_objects_read_property;
    xsl_object_handlers.unset_property = xsl_objects_unset_property;
 
    xsl_xsltprocessor_class_entry = register_class_XSLTProcessor();
    xsl_xsltprocessor_class_entry->create_object = xsl_objects_new;
    xsl_xsltprocessor_class_entry->default_object_handlers = &xsl_object_handlers;
 
#ifdef HAVE_XSL_EXSLT
    exsltRegisterAll();
#endif
 
    xsltRegisterExtModuleFunction ((const xmlChar *) "functionString",
                   (const xmlChar *) "http://php.net/xsl",
                   xsl_ext_function_string_php);
    xsltRegisterExtModuleFunction ((const xmlChar *) "function",
                   (const xmlChar *) "http://php.net/xsl",
                   xsl_ext_function_object_php);
    xsltSetGenericErrorFunc(NULL, xsl_libxslt_error_handler);
 
    register_php_xsl_symbols(module_number);
 
    return SUCCESS;
}
/* }}} */
 
/* {{{ xsl_object_set_data */
static void xsl_object_set_data(void *obj, zval *wrapper)
{
    ((xsltStylesheetPtr) obj)->_private = wrapper;
}
/* }}} */
 
/* {{{ php_xsl_set_object */
void php_xsl_set_object(zval *wrapper, void *obj)
{
    xsl_object *object;
 
    object = Z_XSL_P(wrapper);
    object->ptr = obj;
    xsl_object_set_data(obj, wrapper);
}
/* }}} */
 
/* {{{ PHP_MSHUTDOWN_FUNCTION */
PHP_MSHUTDOWN_FUNCTION(xsl)
{
    xsltUnregisterExtModuleFunction ((const xmlChar *) "functionString",
                   (const xmlChar *) "http://php.net/xsl");
    xsltUnregisterExtModuleFunction ((const xmlChar *) "function",
                   (const xmlChar *) "http://php.net/xsl");
    xsltSetGenericErrorFunc(NULL, NULL);
    xsltCleanupGlobals();
 
    return SUCCESS;
}
/* }}} */
 
/* {{{ PHP_MINFO_FUNCTION */
PHP_MINFO_FUNCTION(xsl)
{
    php_info_print_table_start();
    {
        char buffer[128];
        int major, minor, subminor;
 
        php_info_print_table_row(2, "XSL", "enabled");
        major = xsltLibxsltVersion/10000;
        minor = (xsltLibxsltVersion - major * 10000) / 100;
        subminor = (xsltLibxsltVersion - major * 10000 - minor * 100);
        snprintf(buffer, 128, "%d.%d.%d", major, minor, subminor);
        php_info_print_table_row(2, "libxslt Version", buffer);
        major = xsltLibxmlVersion/10000;
        minor = (xsltLibxmlVersion - major * 10000) / 100;
        subminor = (xsltLibxmlVersion - major * 10000 - minor * 100);
        snprintf(buffer, 128, "%d.%d.%d", major, minor, subminor);
        php_info_print_table_row(2, "libxslt compiled against libxml Version", buffer);
    }
#ifdef HAVE_XSL_EXSLT
    php_info_print_table_row(2, "EXSLT", "enabled");
    php_info_print_table_row(2, "libexslt Version", LIBEXSLT_DOTTED_VERSION);
#endif
    php_info_print_table_end();
}
/* }}} */