#include "zend.h"
#include "zend_compile.h"
#include "phpdbg.h"
+
+ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
+
#include "phpdbg_help.h"
#include "phpdbg_print.h"
#include "phpdbg_info.h"
#include "phpdbg_frame.h"
#include "phpdbg_lexer.h"
#include "phpdbg_parser.h"
+#include "phpdbg_webdata_transfer.h"
+
+#ifdef HAVE_LIBDL
+#ifdef PHP_WIN32
+#include "win32/param.h"
+#include "win32/winutil.h"
+#define GET_DL_ERROR() php_win_err()
+#elif defined(NETWARE)
+#include <sys/param.h>
+#define GET_DL_ERROR() dlerror()
+#else
+#include <sys/param.h>
+#define GET_DL_ERROR() DL_ERROR()
+#endif
+#endif
/* {{{ command declarations */
const phpdbg_command_t phpdbg_prompt_commands[] = {
PHPDBG_COMMAND_D(register,"register a function", 'R', NULL, "s"),
PHPDBG_COMMAND_D(source, "execute a phpdbginit", '<', NULL, "s"),
PHPDBG_COMMAND_D(export, "export breaks to a .phpdbginit script", '>', NULL, "s"),
+ PHPDBG_COMMAND_D(dl, "load module or zend extension", 0, NULL, "|s"),
PHPDBG_COMMAND_D(sh, "shell a command", 0, NULL, "i"),
PHPDBG_COMMAND_D(quit, "exit phpdbg", 'q', NULL, 0),
+ PHPDBG_COMMAND_D(wait, "wait for other process", 'W', NULL, 0),
PHPDBG_COMMAND_D(watch, "set watchpoint", 'w', phpdbg_watch_commands, "|ss"),
PHPDBG_END_COMMAND
}; /* }}} */
-ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
-
static inline int phpdbg_call_register(phpdbg_param_t *stack TSRMLS_DC) /* {{{ */
{
phpdbg_param_t *name = NULL;
return SUCCESS;
} /* }}} */
+static int add_extension_info(zend_module_entry *module TSRMLS_DC) {
+ phpdbg_write("%s\n", module->name);
+ return 0;
+}
+
+static int add_zendext_info(zend_extension *ext TSRMLS_DC) {
+ phpdbg_write("%s\n", ext->name);
+ return 0;
+}
+
+PHPDBG_API const char *phpdbg_load_module_or_extension(char **path, char **str TSRMLS_DC) {
+ DL_HANDLE handle;
+ char *extension_dir;
+
+ extension_dir = INI_STR("extension_dir");
+
+ if (strchr(*path, '/') != NULL || strchr(*path, DEFAULT_SLASH) != NULL) {
+ /* path is fine */
+ } else if (extension_dir && extension_dir[0]) {
+ char *libpath;
+ int extension_dir_len = strlen(extension_dir);
+ if (IS_SLASH(extension_dir[extension_dir_len-1])) {
+ spprintf(&libpath, 0, "%s%s", extension_dir, *path); /* SAFE */
+ } else {
+ spprintf(&libpath, 0, "%s%c%s", extension_dir, DEFAULT_SLASH, *path); /* SAFE */
+ }
+ efree(*path);
+ *path = libpath;
+ } else {
+ *str = estrdup("Not a full path given or extension_dir ini setting is not set");
+
+ return NULL;
+ }
+
+ handle = DL_LOAD(*path);
+
+ if (!handle) {
+#if PHP_WIN32
+ char *err = GET_DL_ERROR();
+ if (err && (*err != "")) {
+ *str = estrdup(err);
+ LocalFree(err);
+ } else {
+ *str = estrdup("Unknown reason");
+ }
+#else
+ *str = estrdup(GET_DL_ERROR());
+ GET_DL_ERROR(); /* free the buffer storing the error */
+#endif
+ return NULL;
+ }
+
+#if ZEND_EXTENSIONS_SUPPORT
+ do {
+ zend_extension *new_extension;
+ zend_extension_version_info *extension_version_info;
+
+ extension_version_info = (zend_extension_version_info *) DL_FETCH_SYMBOL(handle, "extension_version_info");
+ if (!extension_version_info) {
+ extension_version_info = (zend_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) {
+ break;
+ }
+ 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)) {
+ asprintf(str, "%s requires Zend Engine API version %d, which does not match the installed Zend Engine API version %d", new_extension->name, extension_version_info->zend_extension_api_no, ZEND_EXTENSION_API_NO);
+
+ goto quit;
+ } else if (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)) {
+ asprintf(str, "%s was built with configuration %s, whereas running engine is %s", new_extension->name, extension_version_info->build_id, ZEND_EXTENSION_BUILD_ID);
+
+ goto quit;
+ }
+
+ *str = new_extension->name;
+
+ zend_register_extension(new_extension, handle);
+
+ if (new_extension->startup) {
+ if (new_extension->startup(new_extension) != SUCCESS) {
+ asprintf(str, "Unable to startup Zend extension %s", new_extension->name);
+
+ goto quit;
+ }
+ zend_append_version_info(new_extension);
+ }
+
+ return "Zend extension";
+ } while (0);
+#endif
+
+ do {
+ zend_module_entry *module_entry;
+ zend_module_entry *(*get_module)(void);
+
+ get_module = (zend_module_entry *(*)(void)) DL_FETCH_SYMBOL(handle, "get_module");
+ if (!get_module) {
+ get_module = (zend_module_entry *(*)(void)) DL_FETCH_SYMBOL(handle, "_get_module");
+ }
+
+ if (!get_module) {
+ break;
+ }
+
+ module_entry = get_module();
+
+ if (strcmp(ZEND_EXTENSION_BUILD_ID, module_entry->build_id)) {
+ asprintf(str, "%s was built with configuration %s, whereas running engine is %s", module_entry->name, module_entry->build_id, ZEND_EXTENSION_BUILD_ID);
+
+ goto quit;
+ }
+
+ module_entry->type = MODULE_PERSISTENT;
+ module_entry->module_number = zend_next_free_module();
+ module_entry->handle = handle;
+
+ if ((module_entry = zend_register_module_ex(module_entry TSRMLS_CC)) == NULL) {
+ asprintf(str, "Unable to register module %s", module_entry->name);
+
+ goto quit;
+ }
+
+ if (zend_startup_module_ex(module_entry TSRMLS_CC) == FAILURE) {
+ asprintf(str, "Unable to startup module %s", module_entry->name);
+
+ goto quit;
+ }
+
+ if (module_entry->request_startup_func) {
+ if (module_entry->request_startup_func(MODULE_PERSISTENT, module_entry->module_number TSRMLS_CC) == FAILURE) {
+ asprintf(str, "Unable to initialize module %s", module_entry->name);
+
+ goto quit;
+ }
+ }
+
+ return "module";
+ } while (0);
+
+ *str = estrdup("This shared object is nor a Zend extension nor a module");
+
+quit:
+ DL_UNLOAD(handle);
+ return NULL;
+}
+
+PHPDBG_COMMAND(dl) /* {{{ */
+{
+ const char *type;
+ char *name, *path;
+
+ if (!param || param->type == EMPTY_PARAM) {
+ phpdbg_notice("Zend extensions");
+ zend_llist_apply(&zend_extensions, (llist_apply_func_t) add_zendext_info TSRMLS_CC);
+ phpdbg_writeln("");
+ phpdbg_notice("Modules");
+ zend_hash_apply(&module_registry, (apply_func_t) add_extension_info TSRMLS_CC);
+ } else switch (param->type) {
+ case STR_PARAM:
+#ifdef HAVE_LIBDL
+ path = estrndup(param->str, param->len);
+
+ if ((type = phpdbg_load_module_or_extension(&path, &name TSRMLS_CC)) == NULL) {
+ phpdbg_error("Could not load %s, not found or invalid zend extension / module: %s", path, name);
+ efree(name);
+ } else {
+ phpdbg_notice("Successfully loaded the %s %s at path %s", type, name, path);
+ }
+ efree(path);
+#else
+ phpdbg_error("Cannot dynamically load %.*s - dynamic modules are not supported", (int) param->len, param->str);
+#endif
+ break;
+
+ phpdbg_default_switch_case();
+ }
+
+ return SUCCESS;
+} /* }}} */
+
PHPDBG_COMMAND(source) /* {{{ */
{
struct stat sb;
return SUCCESS;
} /* }}} */
+PHPDBG_COMMAND(wait) /* {{{ */
+{
+ struct sockaddr_un local, remote;
+ int rlen, len, sr, sl = socket(AF_UNIX, SOCK_STREAM, 0);
+ unlink(PHPDBG_G(socket_path));
+
+ local.sun_family = AF_UNIX;
+ strcpy(local.sun_path, PHPDBG_G(socket_path));
+ len = strlen(local.sun_path) + sizeof(local.sun_family);
+ if (bind(sl, (struct sockaddr *)&local, len) == -1) {
+ phpdbg_error("Unable to connect to UNIX domain socket at %s defined by phpdbg.path ini setting", PHPDBG_G(socket_path));
+ return FAILURE;
+ }
+
+ chmod(PHPDBG_G(socket_path), 0666);
+
+ listen(sl, 2);
+
+ rlen = sizeof(remote);
+ sr = accept(sl, (struct sockaddr *) &remote, (socklen_t *) &rlen);
+
+ char msglen[5];
+ int recvd = 4;
+
+ do {
+ recvd -= recv(sr, &(msglen[4 - recvd]), recvd, 0);
+ } while (recvd > 0);
+
+ recvd = *(size_t *) msglen;
+ char *data = emalloc(recvd);
+
+ do {
+ recvd -= recv(sr, &(data[(*(int *) msglen) - recvd]), recvd, 0);
+ } while (recvd > 0);
+
+ phpdbg_webdata_decompress(data, *(int *) msglen TSRMLS_CC);
+
+ efree(data);
+
+ phpdbg_notice("Successfully imported request data, stopped before executing");
+
+ return SUCCESS;
+} /* }}} */
+
int phpdbg_interactive(TSRMLS_D) /* {{{ */
{
int ret = SUCCESS;
--- /dev/null
+/*
+ +----------------------------------------------------------------------+
+ | PHP Version 5 |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 1997-2014 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: |
+ | http://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: Bob Weinand <bwoebi@php.net> |
+ +----------------------------------------------------------------------+
+*/
+
+#ifndef PHPDBG_WEBDATA_TRANSFER_H
+#define PHPDBG_WEBDATA_TRANSFER_H
+
+/* {{{ remote console headers */
+#ifndef _WIN32
+# include <sys/socket.h>
+# include <sys/un.h>
+# include <sys/select.h>
+# include <sys/types.h>
+#endif /* }}} */
+
+#include "zend.h"
+#include "phpdbg.h"
+#include "ext/json/php_json.h"
+#include "ext/standard/basic_functions.h"
+
+static inline void phpdbg_webdata_compress(char **msg, int *len TSRMLS_DC) {
+ smart_str buf = {0};
+ zval array;
+ HashTable *ht;
+ /* I really need to change that to an array of zvals... */
+ zval zv1, *zvp1 = &zv1;
+ zval zv2, *zvp2 = &zv2;
+ zval zv3, *zvp3 = &zv3;
+ zval zv4, *zvp4 = &zv4;
+ zval zv5, *zvp5 = &zv5;
+ zval zv6, *zvp6 = &zv6;
+ zval zv7, *zvp7 = &zv7;
+ zval zv8, *zvp8 = &zv8;
+
+ array_init(&array);
+ ht = Z_ARRVAL(array);
+
+ /* fetch superglobals */
+ {
+ zend_is_auto_global(ZEND_STRL("GLOBALS") TSRMLS_CC);
+ /* might be JIT */
+ zend_is_auto_global(ZEND_STRL("_ENV") TSRMLS_CC);
+ zend_is_auto_global(ZEND_STRL("_SERVER") TSRMLS_CC);
+ zend_is_auto_global(ZEND_STRL("_REQUEST") TSRMLS_CC);
+ array_init(&zv1);
+ zend_hash_copy(Z_ARRVAL(zv1), &EG(symbol_table), NULL, (void *) NULL, sizeof(zval *));
+ Z_ARRVAL(zv1)->pDestructor = NULL; /* we're operating on a copy! Don't double free zvals */
+ zend_hash_del(Z_ARRVAL(zv1), "GLOBALS", sizeof("GLOBALS")); /* do not use the reference to itself in json */
+ zend_hash_add(ht, "GLOBALS", sizeof("GLOBALS"), &zvp1, sizeof(zval *), NULL);
+ }
+
+ /* save php://input */
+ {
+ php_stream *stream;
+ int len;
+ char *contents;
+
+ stream = php_stream_temp_create_ex(TEMP_STREAM_DEFAULT, SAPI_POST_BLOCK_SIZE, PG(upload_tmp_dir));
+ if ((len = php_stream_copy_to_mem(stream, &contents, PHP_STREAM_COPY_ALL, 0)) > 0) {
+ ZVAL_STRINGL(&zv2, contents, len, 0);
+ } else {
+ ZVAL_EMPTY_STRING(&zv2);
+ }
+ zend_hash_add(ht, "input", sizeof("input"), &zvp2, sizeof(zval *), NULL);
+ }
+
+ /* change sapi name */
+ {
+ if (sapi_module.name) {
+ ZVAL_STRING(&zv6, sapi_module.name, 1);
+ } else {
+ Z_TYPE(zv6) = IS_NULL;
+ }
+ zend_hash_add(ht, "sapi_name", sizeof("sapi_name"), &zvp6, sizeof(zval *), NULL);
+ }
+
+ /* handle modules / extensions */
+ {
+ HashPosition position;
+ zend_module_entry *module;
+ zend_extension *extension;
+ zend_llist_position pos;
+
+ array_init(&zv7);
+ for (zend_hash_internal_pointer_reset_ex(&module_registry, &position);
+ zend_hash_get_current_data_ex(&module_registry, (void**) &module, &position) == SUCCESS;
+ zend_hash_move_forward_ex(&module_registry, &position)) {
+ zval **value = emalloc(sizeof(zval *));
+ ALLOC_ZVAL(*value);
+ ZVAL_STRING(*value, module->name, 1);
+ zend_hash_next_index_insert(Z_ARRVAL(zv7), value, sizeof(zval *), NULL);
+ }
+ zend_hash_add(ht, "modules", sizeof("modules"), &zvp7, sizeof(zval *), NULL);
+
+ array_init(&zv8);
+ extension = (zend_extension *) zend_llist_get_first_ex(&zend_extensions, &pos);
+ while (extension) {
+ zval **value = emalloc(sizeof(zval *));
+ ALLOC_ZVAL(*value);
+ ZVAL_STRING(*value, extension->name, 1);
+ zend_hash_next_index_insert(Z_ARRVAL(zv8), value, sizeof(zval *), NULL);
+ extension = (zend_extension *) zend_llist_get_next_ex(&zend_extensions, &pos);
+ }
+ zend_hash_add(ht, "extensions", sizeof("extensions"), &zvp8, sizeof(zval *), NULL);
+ }
+
+ /* switch cwd */
+ {
+ char *ret = NULL;
+ char path[MAXPATHLEN];
+
+#if HAVE_GETCWD
+ ret = VCWD_GETCWD(path, MAXPATHLEN);
+#elif HAVE_GETWD
+ ret = VCWD_GETWD(path);
+#endif
+ if (ret) {
+ ZVAL_STRING(&zv5, path, 1);
+ zend_hash_add(ht, "cwd", sizeof("cwd"), &zvp5, sizeof(zval *), NULL);
+ }
+ }
+
+ /* get system ini entries */
+ {
+ HashPosition position;
+ zend_ini_entry *ini_entry;
+
+ array_init(&zv3);
+ for (zend_hash_internal_pointer_reset_ex(EG(ini_directives), &position);
+ zend_hash_get_current_data_ex(EG(ini_directives), (void**) &ini_entry, &position) == SUCCESS;
+ zend_hash_move_forward_ex(EG(ini_directives), &position)) {
+ zval **value = emalloc(sizeof(zval *));
+ if (ini_entry->modified) {
+ if (!ini_entry->orig_value) {
+ efree(value);
+ continue;
+ }
+ ALLOC_ZVAL(*value);
+ ZVAL_STRINGL(*value, ini_entry->orig_value, ini_entry->orig_value_length, 1);
+ } else {
+ if (!ini_entry->value) {
+ efree(value);
+ continue;
+ }
+ ALLOC_ZVAL(*value);
+ ZVAL_STRINGL(*value, ini_entry->value, ini_entry->value_length, 1);
+ }
+ zend_hash_add(Z_ARRVAL(zv3), ini_entry->name, ini_entry->name_length, value, sizeof(zval *), NULL);
+ }
+ zend_hash_add(ht, "systemini", sizeof("systemini"), &zvp3, sizeof(zval *), NULL);
+ }
+
+ /* get perdir ini entries */
+ if (EG(modified_ini_directives)) {
+ HashPosition position;
+ zend_ini_entry *ini_entry;
+
+ array_init(&zv4);
+ for (zend_hash_internal_pointer_reset_ex(EG(modified_ini_directives), &position);
+ zend_hash_get_current_data_ex(EG(modified_ini_directives), (void**) &ini_entry, &position) == SUCCESS;
+ zend_hash_move_forward_ex(EG(modified_ini_directives), &position)) {
+ zval **value = emalloc(sizeof(zval *));
+ if (!ini_entry->value) {
+ efree(value);
+ continue;
+ }
+ ALLOC_ZVAL(*value);
+ ZVAL_STRINGL(*value, ini_entry->value, ini_entry->value_length, 1);
+ zend_hash_add(Z_ARRVAL(zv4), ini_entry->name, ini_entry->name_length, value, sizeof(zval *), NULL);
+ }
+ zend_hash_add(ht, "userini", sizeof("userini"), &zvp4, sizeof(zval *), NULL);
+ }
+
+ /* encode data */
+ php_json_encode(&buf, &array, 0 TSRMLS_CC);
+ *msg = buf.c;
+ *len = buf.len;
+ zval_dtor(&array);
+}
+
+static void phpdbg_rebuild_http_globals_array(int type, const char *name TSRMLS_DC) {
+ zval **zvpp;
+ if (PG(http_globals)[type]) {
+ zval_dtor(PG(http_globals)[type]);
+ }
+ if (zend_hash_find(&EG(symbol_table), name, strlen(name) + 1, (void **) &zvpp) == SUCCESS) {
+ Z_SET_REFCOUNT_PP(zvpp, 2);
+ PG(http_globals)[type] = *zvpp;
+ }
+}
+
+/*
+static int phpdbg_remove_rearm_autoglobals(zend_auto_global *auto_global TSRMLS_DC) {
+// zend_hash_del(&EG(symbol_table), auto_global->name, auto_global->name_len + 1);
+
+ return 1;
+}*/
+
+typedef struct {
+ HashTable *ht[2];
+ HashPosition pos[2];
+} phpdbg_intersect_ptr;
+
+static void phpdbg_array_intersect_init(phpdbg_intersect_ptr *info, HashTable *ht1, HashTable *ht2 TSRMLS_DC) {
+ info->ht[0] = ht1;
+ info->ht[1] = ht2;
+
+ zend_hash_sort(info->ht[0], zend_qsort, (compare_func_t) string_compare_function, 0 TSRMLS_CC);
+ zend_hash_sort(info->ht[1], zend_qsort, (compare_func_t) string_compare_function, 0 TSRMLS_CC);
+
+ zend_hash_internal_pointer_reset_ex(info->ht[0], &info->pos[0]);
+ zend_hash_internal_pointer_reset_ex(info->ht[1], &info->pos[1]);
+}
+
+/* -1 => first array, 0 => both arrays equal, 1 => second array */
+static int phpdbg_array_intersect(phpdbg_intersect_ptr *info, zval ***ptr) {
+ int ret;
+ zval **zvpp[2];
+ int invalid = !info->ht[0] + !info->ht[1];
+
+ if (invalid > 0) {
+ invalid = !!info->ht[0];
+
+ if (zend_hash_get_current_data_ex(info->ht[invalid], (void **) ptr, &info->pos[invalid]) == FAILURE) {
+ *ptr = NULL;
+ return 0;
+ }
+
+ zend_hash_move_forward_ex(info->ht[invalid], &info->pos[invalid]);
+
+ return invalid ? -1 : 1;
+ }
+
+ if (zend_hash_get_current_data_ex(info->ht[0], (void **) &zvpp[0], &info->pos[0]) == FAILURE) {
+ info->ht[0] = NULL;
+ return phpdbg_array_intersect(info, ptr);
+ }
+ if (zend_hash_get_current_data_ex(info->ht[1], (void **) &zvpp[1], &info->pos[1]) == FAILURE) {
+ info->ht[1] = NULL;
+ return phpdbg_array_intersect(info, ptr);
+ }
+
+ ret = zend_binary_zval_strcmp(*zvpp[0], *zvpp[1]);
+
+ if (ret <= 0) {
+ *ptr = zvpp[0];
+ zend_hash_move_forward_ex(info->ht[0], &info->pos[0]);
+ }
+ if (ret >= 0) {
+ *ptr = zvpp[1];
+ zend_hash_move_forward_ex(info->ht[1], &info->pos[1]);
+ }
+
+ return ret;
+}
+
+static inline void phpdbg_webdata_decompress(char *msg, int len TSRMLS_DC) {
+ zval *free_zv = NULL;
+ zval zv, **zvpp;
+ HashTable *ht;
+ php_json_decode(&zv, msg, len, 1, 1000 /* enough */ TSRMLS_CC);
+ ht = Z_ARRVAL(zv);
+
+ /* Reapply symbol table */
+ if (zend_hash_find(ht, "GLOBALS", sizeof("GLOBALS"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_ARRAY) {
+ zend_hash_clean(&EG(symbol_table));
+ EG(symbol_table) = *Z_ARRVAL_PP(zvpp);
+
+ /* Rebuild cookies, env vars etc. from GLOBALS (PG(http_globals)) */
+ phpdbg_rebuild_http_globals_array(TRACK_VARS_POST, "_POST" TSRMLS_CC);
+ phpdbg_rebuild_http_globals_array(TRACK_VARS_GET, "_GET" TSRMLS_CC);
+ phpdbg_rebuild_http_globals_array(TRACK_VARS_COOKIE, "_COOKIE" TSRMLS_CC);
+ phpdbg_rebuild_http_globals_array(TRACK_VARS_SERVER, "_SERVER" TSRMLS_CC);
+ phpdbg_rebuild_http_globals_array(TRACK_VARS_ENV, "_ENV" TSRMLS_CC);
+ phpdbg_rebuild_http_globals_array(TRACK_VARS_FILES, "_FILES" TSRMLS_CC);
+
+ Z_ADDREF_PP(zvpp);
+ free_zv = *zvpp;
+ }
+
+ if (zend_hash_find(ht, "input", sizeof("input"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_STRING) {
+ if (SG(request_info).request_body) {
+ php_stream_close(SG(request_info).request_body);
+ }
+ SG(request_info).request_body = php_stream_temp_create_ex(TEMP_STREAM_DEFAULT, SAPI_POST_BLOCK_SIZE, PG(upload_tmp_dir));
+ php_stream_truncate_set_size(SG(request_info).request_body, 0);
+ php_stream_write(SG(request_info).request_body, Z_STRVAL_PP(zvpp), Z_STRLEN_PP(zvpp));
+ }
+
+ if (zend_hash_find(ht, "cwd", sizeof("cwd"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_STRING) {
+ if (VCWD_CHDIR(Z_STRVAL_PP(zvpp)) == SUCCESS) {
+ if (BG(CurrentStatFile) && !IS_ABSOLUTE_PATH(BG(CurrentStatFile), strlen(BG(CurrentStatFile)))) {
+ efree(BG(CurrentStatFile));
+ BG(CurrentStatFile) = NULL;
+ }
+ if (BG(CurrentLStatFile) && !IS_ABSOLUTE_PATH(BG(CurrentLStatFile), strlen(BG(CurrentLStatFile)))) {
+ efree(BG(CurrentLStatFile));
+ BG(CurrentLStatFile) = NULL;
+ }
+ }
+ }
+
+ if (zend_hash_find(ht, "sapi_name", sizeof("sapi_name"), (void **) &zvpp) == SUCCESS && (Z_TYPE_PP(zvpp) == IS_STRING || Z_TYPE_PP(zvpp) == IS_NULL)) {
+ if (sapi_module.name) {
+ efree(sapi_module.name);
+ }
+ if (Z_TYPE_PP(zvpp) == IS_STRING) {
+ sapi_module.name = estrndup(Z_STRVAL_PP(zvpp), Z_STRLEN_PP(zvpp));
+ } else {
+ sapi_module.name = NULL;
+ }
+ }
+
+ if (zend_hash_find(ht, "modules", sizeof("modules"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_ARRAY) {
+ HashPosition position;
+ phpdbg_intersect_ptr pos;
+ zval **module;
+ zend_module_entry *mod;
+ HashTable zv_registry;
+
+ /* intersect modules, unregister mpdules loaded "too much", announce not yet registered modules (phpdbg_notice) */
+
+ zend_hash_init(&zv_registry, zend_hash_num_elements(&zv_registry), 0, ZVAL_PTR_DTOR, 0);
+ for (zend_hash_internal_pointer_reset_ex(&module_registry, &position);
+ zend_hash_get_current_data_ex(&module_registry, (void **) &mod, &position) == SUCCESS;
+ zend_hash_move_forward_ex(&module_registry, &position)) {
+ zval **value = emalloc(sizeof(zval *));
+ ALLOC_ZVAL(*value);
+ ZVAL_STRING(*value, mod->name, 1);
+ zend_hash_next_index_insert(&zv_registry, value, sizeof(zval *), NULL);
+ }
+
+ phpdbg_array_intersect_init(&pos, &zv_registry, Z_ARRVAL_PP(zvpp) TSRMLS_CC);
+ do {
+ int mode = phpdbg_array_intersect(&pos, &module);
+ if (mode < 0) {
+ // loaded module, but not needed
+ zend_hash_del(&module_registry, Z_STRVAL_PP(module), Z_STRLEN_PP(module) + 1);
+ } else if (mode > 0) {
+ // not loaded module
+ phpdbg_notice("The module %.*s isn't present in " PHPDBG_NAME ", you still can load via dl /path/to/module.so", Z_STRLEN_PP(module), Z_STRVAL_PP(module));
+ }
+ } while (module);
+
+ zend_hash_clean(&zv_registry);
+ }
+
+ if (zend_hash_find(ht, "extensions", sizeof("extensions"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_ARRAY) {
+ zend_extension *extension;
+ zend_llist_position pos;
+ HashPosition hpos;
+ zval **name, key;
+
+ extension = (zend_extension *) zend_llist_get_first_ex(&zend_extensions, &pos);
+ while (extension) {
+ extension = (zend_extension *) zend_llist_get_next_ex(&zend_extensions, &pos);
+
+ /* php_serach_array() body should be in some ZEND_API function */
+ for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(zvpp), &hpos);
+ zend_hash_get_current_data_ex(Z_ARRVAL_PP(zvpp), (void **) &name, &hpos) == SUCCESS;
+ zend_hash_move_forward_ex(Z_ARRVAL_PP(zvpp), &hpos)) {
+ if (Z_TYPE_PP(name) == IS_STRING && !zend_binary_strcmp(extension->name, strlen(extension->name), Z_STRVAL_PP(name), Z_STRLEN_PP(name))) {
+ break;
+ }
+ }
+
+ if (zend_hash_get_current_data_ex(Z_ARRVAL_PP(zvpp), (void **) &zvpp, &hpos) == FAILURE) {
+ /* sigh, breaking the encapsulation, there aren't any functions manipulating the llist at the place of the zend_llist_position */
+ zend_llist_element *elm = pos;
+ if (elm->prev) {
+ elm->prev->next = elm->next;
+ } else {
+ zend_extensions.head = elm->next;
+ }
+ if (elm->next) {
+ elm->next->prev = elm->prev;
+ } else {
+ zend_extensions.tail = elm->prev;
+ }
+#if ZEND_EXTENSIONS_SUPPORT
+ if (extension->shutdown) {
+ extension->shutdown(extension);
+ }
+#endif
+ if (zend_extensions.dtor) {
+ zend_extensions.dtor(elm->data);
+ }
+ pefree(elm, zend_extensions.persistent);
+ zend_extensions.count--;
+ } else {
+ zend_hash_get_current_key_zval_ex(Z_ARRVAL_PP(zvpp), &key, &hpos);
+ if (Z_TYPE(key) == IS_LONG) {
+ zend_hash_index_del(Z_ARRVAL_PP(zvpp), Z_LVAL(key));
+ }
+ }
+
+ for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(zvpp), &hpos);
+ zend_hash_get_current_data_ex(Z_ARRVAL_PP(zvpp), (void **) &name, &hpos) == SUCCESS;
+ zend_hash_move_forward_ex(Z_ARRVAL_PP(zvpp), &hpos)) {
+ phpdbg_notice("The (zend) extension %.*s isn't present in " PHPDBG_NAME ", you still can load via dl /path/to/extension.so", Z_STRLEN_PP(name), Z_STRVAL_PP(name));
+ }
+ }
+ }
+
+ zend_ini_deactivate(TSRMLS_C);
+
+ if (zend_hash_find(ht, "systemini", sizeof("systemini"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_ARRAY) {
+ HashPosition position;
+ zval **ini_entry;
+ zend_ini_entry *original_ini;
+ zval key;
+
+ for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(zvpp), &position);
+ zend_hash_get_current_data_ex(Z_ARRVAL_PP(zvpp), (void**) &ini_entry, &position) == SUCCESS;
+ zend_hash_move_forward_ex(Z_ARRVAL_PP(zvpp), &position)) {
+ zend_hash_get_current_key_zval_ex(Z_ARRVAL_PP(zvpp), &key, &position);
+ if (Z_TYPE(key) == IS_STRING) {
+ if (Z_TYPE_PP(ini_entry) == IS_STRING) {
+ if (zend_hash_find(EG(ini_directives), Z_STRVAL(key), Z_STRLEN(key) + 1, (void **) &original_ini) == SUCCESS) {
+ if (!original_ini->on_modify || original_ini->on_modify(original_ini, Z_STRVAL_PP(ini_entry), Z_STRLEN_PP(ini_entry), original_ini->mh_arg1, original_ini->mh_arg2, original_ini->mh_arg3, ZEND_INI_STAGE_ACTIVATE TSRMLS_CC) == SUCCESS) {
+ original_ini->value = Z_STRVAL_PP(ini_entry);
+ original_ini->value_length = Z_STRLEN_PP(ini_entry);
+ continue; /* don't free the string */
+ }
+ }
+ }
+ efree(Z_STRVAL(key));
+ }
+ }
+ }
+
+ if (zend_hash_find(ht, "userini", sizeof("userini"), (void **) &zvpp) == SUCCESS && Z_TYPE_PP(zvpp) == IS_ARRAY) {
+ HashPosition position;
+ zval **ini_entry;
+ zval key;
+
+ for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(zvpp), &position);
+ zend_hash_get_current_data_ex(Z_ARRVAL_PP(zvpp), (void**) &ini_entry, &position) == SUCCESS;
+ zend_hash_move_forward_ex(Z_ARRVAL_PP(zvpp), &position)) {
+ zend_hash_get_current_key_zval_ex(Z_ARRVAL_PP(zvpp), &key, &position);
+ if (Z_TYPE(key) == IS_STRING) {
+ if (Z_TYPE_PP(ini_entry) == IS_STRING) {
+ zend_alter_ini_entry_ex(Z_STRVAL(key), Z_STRLEN(key) + 1, Z_STRVAL_PP(ini_entry), Z_STRLEN_PP(ini_entry), ZEND_INI_PERDIR, ZEND_INI_STAGE_HTACCESS, 1 TSRMLS_CC);
+ }
+ efree(Z_STRVAL(key));
+ }
+ }
+ }
+
+ zval_dtor(&zv);
+ if (free_zv) {
+ /* separate freeing to not dtor the symtable too, just the container zval... */
+ efree(free_zv);
+ }
+
+ /* Remove and readd autoglobals */
+/* php_hash_environment(TSRMLS_C);
+ zend_hash_apply(CG(auto_globals), (apply_func_t) phpdbg_remove_rearm_autoglobals TSRMLS_CC);
+ php_startup_auto_globals(TSRMLS_C);
+ zend_activate_auto_globals(TSRMLS_C);
+*/
+ /* Reapply raw input */
+ /* ??? */
+}
+
+#endif /* PHPDBG_WEBDATA_TRANSFER_H */
projects / php / commitdiff