dl.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: Brian Schaffner <brian@tool.net> |
 | Shane Caraveo <shane@caraveo.com> |
 | Zeev Suraski <zeev@php.net> |
 +----------------------------------------------------------------------+
*/

#include"php.h"
#include"dl.h"
#include"php_globals.h"
#include"php_ini.h"
#include"ext/standard/info.h"

#include"SAPI.h"

#ifdefHAVE_LIBDL
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#ifdefPHP_WIN32
#include"win32/param.h"
#include"win32/winutil.h"
#defineGET_DL_ERROR() php_win_err()
#else
#include<sys/param.h>
#defineGET_DL_ERROR() DL_ERROR()
#endif
#endif/* defined(HAVE_LIBDL) */

/* {{{ Load a PHP extension at runtime */
PHPAPIPHP_FUNCTION(dl)
{
char*filename;
size_tfilename_len;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STRING(filename, filename_len)
ZEND_PARSE_PARAMETERS_END();

if (!PG(enable_dl)) {
php_error_docref(NULL, E_WARNING, "Dynamically loaded extensions aren't enabled");
RETURN_FALSE;
 }

if (filename_len >= MAXPATHLEN) {
php_error_docref(NULL, E_WARNING, "Filename exceeds the maximum allowed length of %d characters", MAXPATHLEN);
RETURN_FALSE;
 }

#ifZEND_RC_DEBUG
boolorig_rc_debug=zend_rc_debug;
/* FIXME: Loading extensions during the request breaks some invariants. In
 * particular, it will create persistent interned strings, which is not
 * allowed at this stage. */
zend_rc_debug= false;
#endif

php_dl(filename, MODULE_TEMPORARY, return_value, 0);
if (Z_TYPE_P(return_value) ==IS_TRUE) {
EG(full_tables_cleanup) =1;
 }

#ifZEND_RC_DEBUG
zend_rc_debug=orig_rc_debug;
#endif
}
/* }}} */

#ifdefHAVE_LIBDL

/* {{{ php_load_shlib */
PHPAPIvoid*php_load_shlib(constchar*path, char**errp)
{
void*handle;
char*err;

handle=DL_LOAD(path);
if (!handle) {
err=GET_DL_ERROR();
#ifdefPHP_WIN32
if (err&& (*err)) {
size_ti=strlen(err);
 (*errp)=estrdup(err);
php_win32_error_msg_free(err);
while (i>0&&isspace((*errp)[i-1])) { (*errp)[i-1] ='\0'; i--; }
 } else {
 (*errp) =estrdup("<No message>");
 }
#else
 (*errp) =estrdup(err);
GET_DL_ERROR(); /* free the buffer storing the error */
#endif
 }
returnhandle;
}
/* }}} */

/* {{{ php_load_extension */
PHPAPIintphp_load_extension(constchar*filename, inttype, intstart_now)
{
void*handle;
char*libpath;
zend_module_entry*module_entry;
zend_module_entry*(*get_module)(void);
interror_type, slash_suffix=0;
char*extension_dir;
char*err1, *err2;

if (type==MODULE_PERSISTENT) {
extension_dir=INI_STR("extension_dir");
 } else {
extension_dir=PG(extension_dir);
 }

if (type==MODULE_TEMPORARY) {
error_type=E_WARNING;
 } else {
error_type=E_CORE_WARNING;
 }

/* Check if passed filename contains directory separators */
if (strchr(filename, '/') !=NULL||strchr(filename, DEFAULT_SLASH) !=NULL) {
/* Passing modules with full path is not supported for dynamically loaded extensions */
if (type==MODULE_TEMPORARY) {
php_error_docref(NULL, E_WARNING, "Temporary module name should contain only filename");
returnFAILURE;
 }
libpath=estrdup(filename);
 } elseif (extension_dir&&extension_dir[0]) {
slash_suffix=IS_SLASH(extension_dir[strlen(extension_dir)-1]);
/* Try as filename first */
if (slash_suffix) {
spprintf(&libpath, 0, "%s%s", extension_dir, filename); /* SAFE */
 } else {
spprintf(&libpath, 0, "%s%c%s", extension_dir, DEFAULT_SLASH, filename); /* SAFE */
 }
 } else {
returnFAILURE; /* Not full path given or extension_dir is not set */
 }

handle=php_load_shlib(libpath, &err1);
if (!handle) {
/* Now, consider 'filename' as extension name and build file name */
char*orig_libpath=libpath;

if (slash_suffix) {
spprintf(&libpath, 0, "%s"PHP_SHLIB_EXT_PREFIX"%s."PHP_SHLIB_SUFFIX, extension_dir, filename); /* SAFE */
 } else {
spprintf(&libpath, 0, "%s%c"PHP_SHLIB_EXT_PREFIX"%s."PHP_SHLIB_SUFFIX, extension_dir, DEFAULT_SLASH, filename); /* SAFE */
 }

handle=php_load_shlib(libpath, &err2);
if (!handle) {
php_error_docref(NULL, error_type, "Unable to load dynamic library '%s' (tried: %s (%s), %s (%s))",
filename, orig_libpath, err1, libpath, err2);
efree(orig_libpath);
efree(err1);
efree(libpath);
efree(err2);
returnFAILURE;
 }
efree(orig_libpath);
efree(err1);
 }
efree(libpath);

#ifdefPHP_WIN32
if (!php_win32_image_compatible(handle, &err1)) {
php_error_docref(NULL, error_type, err1);
efree(err1);
DL_UNLOAD(handle);
returnFAILURE;
 }
#endif

get_module= (zend_module_entry*(*)(void)) DL_FETCH_SYMBOL(handle, "get_module");

/* Some OS prepend _ to symbol names while their dynamic linker
 * does not do that automatically. Thus we check manually for
 * _get_module. */

if (!get_module) {
get_module= (zend_module_entry*(*)(void)) DL_FETCH_SYMBOL(handle, "_get_module");
 }

if (!get_module) {
if (DL_FETCH_SYMBOL(handle, "zend_extension_entry") ||DL_FETCH_SYMBOL(handle, "_zend_extension_entry")) {
DL_UNLOAD(handle);
php_error_docref(NULL, error_type, "Invalid library (appears to be a Zend Extension, try loading using zend_extension=%s from php.ini)", filename);
returnFAILURE;
 }
DL_UNLOAD(handle);
php_error_docref(NULL, error_type, "Invalid library (maybe not a PHP library) '%s'", filename);
returnFAILURE;
 }
module_entry=get_module();
if (zend_hash_str_exists(&module_registry, module_entry->name, strlen(module_entry->name))) {
zend_error(E_CORE_WARNING, "Module \"%s\" is already loaded", module_entry->name);
DL_UNLOAD(handle);
returnFAILURE;
 }
if (module_entry->zend_api!=ZEND_MODULE_API_NO) {
php_error_docref(NULL, error_type,
"%s: Unable to initialize module\n"
"Module compiled with module API=%d\n"
"PHP compiled with module API=%d\n"
"These options need to match\n",
module_entry->name, module_entry->zend_api, ZEND_MODULE_API_NO);
DL_UNLOAD(handle);
returnFAILURE;
 }
if(strcmp(module_entry->build_id, ZEND_MODULE_BUILD_ID)) {
php_error_docref(NULL, error_type,
"%s: Unable to initialize module\n"
"Module compiled with build ID=%s\n"
"PHP compiled with build ID=%s\n"
"These options need to match\n",
module_entry->name, module_entry->build_id, ZEND_MODULE_BUILD_ID);
DL_UNLOAD(handle);
returnFAILURE;
 }

if ((module_entry=zend_register_module_ex(module_entry, type)) ==NULL) {
DL_UNLOAD(handle);
returnFAILURE;
 }

module_entry->handle=handle;

if ((type==MODULE_TEMPORARY||start_now) &&zend_startup_module_ex(module_entry) ==FAILURE) {
DL_UNLOAD(handle);
returnFAILURE;
 }

if ((type==MODULE_TEMPORARY||start_now) &&module_entry->request_startup_func) {
if (module_entry->request_startup_func(type, module_entry->module_number) ==FAILURE) {
php_error_docref(NULL, error_type, "Unable to initialize module '%s'", module_entry->name);
DL_UNLOAD(handle);
returnFAILURE;
 }
 }
returnSUCCESS;
}
/* }}} */

#else

staticvoidphp_dl_error(constchar*filename)
{
php_error_docref(NULL, E_WARNING, "Cannot dynamically load %s - dynamic modules are not supported", filename);
}

PHPAPIvoid*php_load_shlib(constchar*path, char**errp)
{
php_dl_error(path);
 (*errp) =estrdup("No DL support");
returnNULL;
}

PHPAPIintphp_load_extension(constchar*filename, inttype, intstart_now)
{
php_dl_error(filename);

returnFAILURE;
}

#endif

/* {{{ php_dl */
PHPAPIvoidphp_dl(constchar*file, inttype, zval*return_value, intstart_now)
{
/* Load extension */
if (php_load_extension(file, type, start_now) ==FAILURE) {
RETVAL_FALSE;
 } else {
RETVAL_TRUE;
 }
}
/* }}} */

PHP_MINFO_FUNCTION(dl)
{
#if defined(HAVE_LIBDL)
#definePHP_DL_SUPPORT_STATUS "enabled"
#else
#definePHP_DL_SUPPORT_STATUS "unavailable"
#endif
php_info_print_table_row(2, "Dynamic Library Support", PHP_DL_SUPPORT_STATUS);
}