zend_extensions.c

/*
 +----------------------------------------------------------------------+
 | Zend Engine |
 +----------------------------------------------------------------------+
 | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
 +----------------------------------------------------------------------+
 | This source file is subject to version 2.00 of the Zend license, |
 | that is bundled with this package in the file LICENSE, and is |
 | available through the world-wide-web at the following url: |
 | http://www.zend.com/license/2_00.txt. |
 | If you did not receive a copy of the Zend license and are unable to |
 | obtain it through the world-wide-web, please send a note to |
 | license@zend.com so we can mail you a copy immediately. |
 +----------------------------------------------------------------------+
 | Authors: Andi Gutmans <andi@php.net> |
 | Zeev Suraski <zeev@php.net> |
 +----------------------------------------------------------------------+
*/

#include"zend_extensions.h"
#include"zend_system_id.h"

ZEND_APIzend_llistzend_extensions;
ZEND_APIuint32_tzend_extension_flags=0;
ZEND_APIintzend_op_array_extension_handles=0;
ZEND_APIintzend_internal_function_extension_handles=0;
staticintlast_resource_number;

zend_resultzend_load_extension(constchar*path)
{
#ifZEND_EXTENSIONS_SUPPORT
DL_HANDLEhandle;

handle=DL_LOAD(path);
if (!handle) {
#ifndefZEND_WIN32
fprintf(stderr, "Failed loading %s: %s\n", path, DL_ERROR());
#else
fprintf(stderr, "Failed loading %s\n", path);
/* See http://support.microsoft.com/kb/190351 */
fflush(stderr);
#endif
returnFAILURE;
 }
#ifdefZEND_WIN32
char*err;
if (!php_win32_image_compatible(handle, &err)) {
zend_error(E_CORE_WARNING, err);
returnFAILURE;
 }
#endif
returnzend_load_extension_handle(handle, path);
#else
fprintf(stderr, "Extensions are not supported on this platform.\n");
/* See http://support.microsoft.com/kb/190351 */
#ifdefZEND_WIN32
fflush(stderr);
#endif
returnFAILURE;
#endif
}

zend_resultzend_load_extension_handle(DL_HANDLEhandle, constchar*path)
{
#ifZEND_EXTENSIONS_SUPPORT
zend_extension*new_extension;

constzend_extension_version_info*extension_version_info= (constzend_extension_version_info*) DL_FETCH_SYMBOL(handle, "extension_version_info");
if (!extension_version_info) {
extension_version_info= (constzend_extension_version_info*) DL_FETCH_SYMBOL(handle, "_extension_version_info");
 }
new_extension= (zend_extension*) DL_FETCH_SYMBOL(handle, "zend_extension_entry");
if (!new_extension) {
new_extension= (zend_extension*) DL_FETCH_SYMBOL(handle, "_zend_extension_entry");
 }
if (!extension_version_info|| !new_extension) {
fprintf(stderr, "%s doesn't appear to be a valid Zend extension\n", path);
/* See http://support.microsoft.com/kb/190351 */
#ifdefZEND_WIN32
fflush(stderr);
#endif
DL_UNLOAD(handle);
returnFAILURE;
 }

/* allow extension to proclaim compatibility with any Zend version */
if (extension_version_info->zend_extension_api_no!=ZEND_EXTENSION_API_NO&&(!new_extension->api_no_check||new_extension->api_no_check(ZEND_EXTENSION_API_NO) !=SUCCESS)) {
if (extension_version_info->zend_extension_api_no>ZEND_EXTENSION_API_NO) {
fprintf(stderr, "%s requires Zend Engine API version %d.\n"
"The Zend Engine API version %d which is installed, is outdated.\n\n",
new_extension->name,
extension_version_info->zend_extension_api_no,
ZEND_EXTENSION_API_NO);
/* See http://support.microsoft.com/kb/190351 */
#ifdefZEND_WIN32
fflush(stderr);
#endif
DL_UNLOAD(handle);
returnFAILURE;
 } elseif (extension_version_info->zend_extension_api_no<ZEND_EXTENSION_API_NO) {
fprintf(stderr, "%s requires Zend Engine API version %d.\n"
"The Zend Engine API version %d which is installed, is newer.\n"
"Contact %s at %s for a later version of %s.\n\n",
new_extension->name,
extension_version_info->zend_extension_api_no,
ZEND_EXTENSION_API_NO,
new_extension->author,
new_extension->URL,
new_extension->name);
/* See http://support.microsoft.com/kb/190351 */
#ifdefZEND_WIN32
fflush(stderr);
#endif
DL_UNLOAD(handle);
returnFAILURE;
 }
 } elseif (strcmp(ZEND_EXTENSION_BUILD_ID, extension_version_info->build_id) &&
 (!new_extension->build_id_check||new_extension->build_id_check(ZEND_EXTENSION_BUILD_ID) !=SUCCESS)) {
fprintf(stderr, "Cannot load %s - it was built with configuration %s, whereas running engine is %s\n",
new_extension->name, extension_version_info->build_id, ZEND_EXTENSION_BUILD_ID);
/* See http://support.microsoft.com/kb/190351 */
#ifdefZEND_WIN32
fflush(stderr);
#endif
DL_UNLOAD(handle);
returnFAILURE;
 } elseif (zend_get_extension(new_extension->name)) {
fprintf(stderr, "Cannot load %s - it was already loaded\n", new_extension->name);
/* See http://support.microsoft.com/kb/190351 */
#ifdefZEND_WIN32
fflush(stderr);
#endif
DL_UNLOAD(handle);
returnFAILURE;
 }

zend_register_extension(new_extension, handle);
returnSUCCESS;
#else
fprintf(stderr, "Extensions are not supported on this platform.\n");
/* See http://support.microsoft.com/kb/190351 */
#ifdefZEND_WIN32
fflush(stderr);
#endif
returnFAILURE;
#endif
}


voidzend_register_extension(zend_extension*new_extension, DL_HANDLEhandle)
{
#ifZEND_EXTENSIONS_SUPPORT
zend_extensionextension;

extension=*new_extension;
extension.handle=handle;

zend_extension_dispatch_message(ZEND_EXTMSG_NEW_EXTENSION, &extension);

zend_llist_add_element(&zend_extensions, &extension);

if (extension.op_array_ctor) {
zend_extension_flags |= ZEND_EXTENSIONS_HAVE_OP_ARRAY_CTOR;
 }
if (extension.op_array_dtor) {
zend_extension_flags |= ZEND_EXTENSIONS_HAVE_OP_ARRAY_DTOR;
 }
if (extension.op_array_handler) {
zend_extension_flags |= ZEND_EXTENSIONS_HAVE_OP_ARRAY_HANDLER;
 }
if (extension.op_array_persist_calc) {
zend_extension_flags |= ZEND_EXTENSIONS_HAVE_OP_ARRAY_PERSIST_CALC;
 }
if (extension.op_array_persist) {
zend_extension_flags |= ZEND_EXTENSIONS_HAVE_OP_ARRAY_PERSIST;
 }
/*fprintf(stderr, "Loaded %s, version %s\n", extension.name, extension.version);*/
#endif
}


staticvoidzend_extension_shutdown(zend_extension*extension)
{
#ifZEND_EXTENSIONS_SUPPORT
if (extension->shutdown) {
extension->shutdown(extension);
 }
#endif
}

/* int return due to zend linked list API */
staticintzend_extension_startup(zend_extension*extension)
{
#ifZEND_EXTENSIONS_SUPPORT
if (extension->startup) {
if (extension->startup(extension)!=SUCCESS) {
return1;
 }
zend_append_version_info(extension);
 }
#endif
return0;
}


voidzend_startup_extensions_mechanism(void)
{
/* Startup extensions mechanism */
zend_llist_init(&zend_extensions, sizeof(zend_extension), (void (*)(void*)) zend_extension_dtor, 1);
zend_op_array_extension_handles=0;
zend_internal_function_extension_handles=0;
last_resource_number=0;
}


voidzend_startup_extensions(void)
{
zend_llist_apply_with_del(&zend_extensions, (int (*)(void*)) zend_extension_startup);
}


voidzend_shutdown_extensions(void)
{
zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_shutdown);
zend_llist_destroy(&zend_extensions);
}


voidzend_extension_dtor(zend_extension*extension)
{
#ifZEND_EXTENSIONS_SUPPORT&& !ZEND_DEBUG
if (extension->handle&& !getenv("ZEND_DONT_UNLOAD_MODULES")) {
DL_UNLOAD(extension->handle);
 }
#endif
}


staticvoidzend_extension_message_dispatcher(constzend_extension*extension, intnum_args, va_listargs)
{
intmessage;
void*arg;

if (!extension->message_handler||num_args!=2) {
return;
 }
message=va_arg(args, int);
arg=va_arg(args, void*);
extension->message_handler(message, arg);
}


ZEND_APIvoidzend_extension_dispatch_message(intmessage, void*arg)
{
zend_llist_apply_with_arguments(&zend_extensions, (llist_apply_with_args_func_t) zend_extension_message_dispatcher, 2, message, arg);
}


ZEND_APIintzend_get_resource_handle(constchar*module_name)
{
if (last_resource_number<ZEND_MAX_RESERVED_RESOURCES) {
zend_add_system_entropy(module_name, "zend_get_resource_handle", &last_resource_number, sizeof(int));
returnlast_resource_number++;
 } else {
return-1;
 }
}

/**
 * The handle returned by this function can be used with
 * `ZEND_OP_ARRAY_EXTENSION(op_array, handle)`.
 *
 * The extension slot has been available since PHP 7.4 on user functions and
 * has been available since PHP 8.2 on internal functions.
 *
 * # Safety
 * The extension slot made available by calling this function is initialized on
 * the first call made to the function in that request. If you need to
 * initialize it before this point, call `zend_init_func_run_time_cache`.
 *
 * The function cache slots are not available if the function is a trampoline,
 * which can be checked with something like:
 *
 * if (fbc->type == ZEND_USER_FUNCTION
 * && !(fbc->op_array.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)
 * ) {
 * // Use ZEND_OP_ARRAY_EXTENSION somehow
 * }
 */
ZEND_APIintzend_get_op_array_extension_handle(constchar*module_name)
{
inthandle=zend_op_array_extension_handles++;
zend_add_system_entropy(module_name, "zend_get_op_array_extension_handle", &zend_op_array_extension_handles, sizeof(int));
returnhandle;
}

/** See zend_get_op_array_extension_handle for important usage information. */
ZEND_APIintzend_get_op_array_extension_handles(constchar*module_name, inthandles)
{
inthandle=zend_op_array_extension_handles;
zend_op_array_extension_handles+=handles;
zend_add_system_entropy(module_name, "zend_get_op_array_extension_handle", &zend_op_array_extension_handles, sizeof(int));
returnhandle;
}

ZEND_APIintzend_get_internal_function_extension_handle(constchar*module_name)
{
inthandle=zend_internal_function_extension_handles++;
zend_add_system_entropy(module_name, "zend_get_internal_function_extension_handle", &zend_internal_function_extension_handles, sizeof(int));
returnhandle;
}

ZEND_APIintzend_get_internal_function_extension_handles(constchar*module_name, inthandles)
{
inthandle=zend_internal_function_extension_handles;
zend_internal_function_extension_handles+=handles;
zend_add_system_entropy(module_name, "zend_get_internal_function_extension_handle", &zend_internal_function_extension_handles, sizeof(int));
returnhandle;
}

ZEND_APIsize_tzend_internal_run_time_cache_reserved_size(void) {
returnzend_internal_function_extension_handles*sizeof(void*);
}

ZEND_APIvoidzend_init_internal_run_time_cache(void) {
size_trt_size=zend_internal_run_time_cache_reserved_size();
if (rt_size) {
size_tfunctions=zend_hash_num_elements(CG(function_table));
zend_class_entry*ce;
ZEND_HASH_MAP_FOREACH_PTR(CG(class_table), ce) {
functions+=zend_hash_num_elements(&ce->function_table);
 } ZEND_HASH_FOREACH_END();

size_talloc_size=functions*rt_size;
char*ptr=pemalloc(alloc_size, 1);

CG(internal_run_time_cache) =ptr;
CG(internal_run_time_cache_size) =alloc_size;

zend_internal_function*zif;
ZEND_HASH_MAP_FOREACH_PTR(CG(function_table), zif) {
if (!ZEND_USER_CODE(zif->type) &&ZEND_MAP_PTR_GET(zif->run_time_cache) ==NULL) {
ZEND_MAP_PTR_SET(zif->run_time_cache, (void*)ptr);
ptr+=rt_size;
 }
 } ZEND_HASH_FOREACH_END();
ZEND_HASH_MAP_FOREACH_PTR(CG(class_table), ce) {
ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, zif) {
if (!ZEND_USER_CODE(zif->type) &&ZEND_MAP_PTR_GET(zif->run_time_cache) ==NULL) {
ZEND_MAP_PTR_SET(zif->run_time_cache, (void*)ptr);
ptr+=rt_size;
 }
 } ZEND_HASH_FOREACH_END();
 } ZEND_HASH_FOREACH_END();
 }
}

ZEND_APIvoidzend_reset_internal_run_time_cache(void) {
if (CG(internal_run_time_cache)) {
memset(CG(internal_run_time_cache), 0, CG(internal_run_time_cache_size));
 }
}

ZEND_APIzend_extension*zend_get_extension(constchar*extension_name)
{
zend_llist_element*element;

for (element=zend_extensions.head; element; element=element->next) {
zend_extension*extension= (zend_extension*) element->data;

if (!strcmp(extension->name, extension_name)) {
returnextension;
 }
 }
returnNULL;
}

typedefstruct_zend_extension_persist_data {
zend_op_array*op_array;
size_tsize;
char*mem;
} zend_extension_persist_data;

staticvoidzend_extension_op_array_persist_calc_handler(zend_extension*extension, zend_extension_persist_data*data)
{
if (extension->op_array_persist_calc) {
data->size+=extension->op_array_persist_calc(data->op_array);
 }
}

staticvoidzend_extension_op_array_persist_handler(zend_extension*extension, zend_extension_persist_data*data)
{
if (extension->op_array_persist) {
size_tsize=extension->op_array_persist(data->op_array, data->mem);
if (size) {
data->mem= (void*)((char*)data->mem+size);
data->size+=size;
 }
 }
}

ZEND_APIsize_tzend_extensions_op_array_persist_calc(zend_op_array*op_array)
{
if (zend_extension_flags&ZEND_EXTENSIONS_HAVE_OP_ARRAY_PERSIST_CALC) {
zend_extension_persist_datadata;

data.op_array=op_array;
data.size=0;
data.mem=NULL;
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_persist_calc_handler, &data);
returndata.size;
 }
return0;
}

ZEND_APIsize_tzend_extensions_op_array_persist(zend_op_array*op_array, void*mem)
{
if (zend_extension_flags&ZEND_EXTENSIONS_HAVE_OP_ARRAY_PERSIST) {
zend_extension_persist_datadata;

data.op_array=op_array;
data.size=0;
data.mem=mem;
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_persist_handler, &data);
returndata.size;
 }
return0;
}