/*

+----------------------------------------------------------------------+

| PHP Version 7 |

+----------------------------------------------------------------------+

| Copyright (c) 1997-2016 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: Felipe Pena <felipe@php.net> |

| Authors: Joe Watkins <joe.watkins@live.co.uk> |

| Authors: Bob Weinand <bwoebi@php.net> |

+----------------------------------------------------------------------+

*/

#include "phpdbg.h"

#include "phpdbg_prompt.h"

#include "phpdbg_bp.h"

#include "phpdbg_break.h"

#include "phpdbg_list.h"

#include "phpdbg_utils.h"

#include "phpdbg_set.h"

#include "phpdbg_io.h"

#include "zend_alloc.h"

#include "phpdbg_eol.h"

#include "phpdbg_print.h"

#include "ext/standard/basic_functions.h"

/* {{{ remote console headers */

#ifndef _WIN32

# include <sys/socket.h>

# include <sys/select.h>

# include <sys/time.h>

# include <sys/types.h>

# include <sys/poll.h>

# include <netinet/in.h>

# include <unistd.h>

# include <arpa/inet.h>

#endif /* }}} */

#if defined(PHP_WIN32) && defined(HAVE_OPENSSL)

# include "openssl/applink.c"

#endif

#if defined(PHP_WIN32) && defined(ZTS)

ZEND_TSRMLS_CACHE_DEFINE()

#endif

ZEND_DECLARE_MODULE_GLOBALS(phpdbg);

int phpdbg_startup_run = 0;

static PHP_INI_MH(OnUpdateEol)

{

if (!new_value) {

return FAILURE;

}

return phpdbg_eol_global_update(ZSTR_VAL(new_value));

}

PHP_INI_BEGIN()

STD_PHP_INI_ENTRY("phpdbg.path", "", PHP_INI_SYSTEM | PHP_INI_PERDIR, OnUpdateString, socket_path, zend_phpdbg_globals, phpdbg_globals)

STD_PHP_INI_ENTRY("phpdbg.eol", "2", PHP_INI_ALL, OnUpdateEol, socket_path, zend_phpdbg_globals, phpdbg_globals)

PHP_INI_END()

static zend_bool phpdbg_booted = 0;

static zend_bool phpdbg_fully_started = 0;

zend_bool use_mm_wrappers = 0;

static void php_phpdbg_destroy_bp_file(zval *brake) /* {{{ */

{

zend_hash_destroy(Z_ARRVAL_P(brake));

efree(Z_ARRVAL_P(brake));

} /* }}} */

static void php_phpdbg_destroy_bp_symbol(zval *brake) /* {{{ */

{

efree((char *) ((phpdbg_breaksymbol_t *) Z_PTR_P(brake))->symbol);

efree(Z_PTR_P(brake));

} /* }}} */

static void php_phpdbg_destroy_bp_opcode(zval *brake) /* {{{ */

{

efree((char *) ((phpdbg_breakop_t *) Z_PTR_P(brake))->name);

efree(Z_PTR_P(brake));

} /* }}} */

static void php_phpdbg_destroy_bp_opline(zval *brake) /* {{{ */

{

efree(Z_PTR_P(brake));

} /* }}} */

static void php_phpdbg_destroy_bp_methods(zval *brake) /* {{{ */

{

zend_hash_destroy(Z_ARRVAL_P(brake));

efree(Z_ARRVAL_P(brake));

} /* }}} */

static void php_phpdbg_destroy_bp_condition(zval *data) /* {{{ */

{

phpdbg_breakcond_t *brake = (phpdbg_breakcond_t *) Z_PTR_P(data);

if (brake->ops) {

destroy_op_array(brake->ops);

efree(brake->ops);

}

efree((char*) brake->code);

efree(brake);

} /* }}} */

static void php_phpdbg_destroy_registered(zval *data) /* {{{ */

{

zend_function *function = (zend_function *) Z_PTR_P(data);

destroy_zend_function(function);

} /* }}} */

static void php_phpdbg_destroy_file_source(zval *data) /* {{{ */

{

phpdbg_file_source *source = (phpdbg_file_source *) Z_PTR_P(data);

destroy_op_array(&source->op_array);

if (source->buf) {

efree(source->buf);

}

efree(source);

} /* }}} */

static inline void php_phpdbg_globals_ctor(zend_phpdbg_globals *pg) /* {{{ */

{

pg->prompt[0] = NULL;

pg->prompt[1] = NULL;

pg->colors[0] = NULL;

pg->colors[1] = NULL;

pg->colors[2] = NULL;

pg->lines = phpdbg_get_terminal_height();

pg->exec = NULL;

pg->exec_len = 0;

pg->buffer = NULL;

pg->last_was_newline = 1;

pg->ops = NULL;

pg->vmret = 0;

pg->in_execution = 0;

pg->bp_count = 0;

pg->flags = PHPDBG_DEFAULT_FLAGS;

pg->oplog = NULL;

memset(pg->io, 0, sizeof(pg->io));

pg->frame.num = 0;

pg->sapi_name_ptr = NULL;

pg->socket_fd = -1;

pg->socket_server_fd = -1;

pg->unclean_eval = 0;

pg->req_id = 0;

pg->err_buf.active = 0;

pg->err_buf.type = 0;

pg->input_buflen = 0;

pg->sigsafe_mem.mem = NULL;

pg->sigsegv_bailout = NULL;

pg->oplog_list = NULL;

#ifdef PHP_WIN32

pg->sigio_watcher_thread = INVALID_HANDLE_VALUE;

memset(&pg->swd, 0, sizeof(struct win32_sigio_watcher_data));

#endif

pg->eol = PHPDBG_EOL_LF;

} /* }}} */

static PHP_MINIT_FUNCTION(phpdbg) /* {{{ */

{

zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], 8, NULL, php_phpdbg_destroy_bp_file, 0);

zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], 8, NULL, php_phpdbg_destroy_bp_file, 0);

zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], 8, NULL, php_phpdbg_destroy_bp_symbol, 0);

zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], 8, NULL, php_phpdbg_destroy_bp_methods, 0);

zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], 8, NULL, php_phpdbg_destroy_bp_methods, 0);

zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], 8, NULL, php_phpdbg_destroy_bp_methods, 0);

zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], 8, NULL, php_phpdbg_destroy_bp_opline, 0);

zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], 8, NULL, php_phpdbg_destroy_bp_opcode, 0);

zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], 8, NULL, php_phpdbg_destroy_bp_methods, 0);

zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], 8, NULL, php_phpdbg_destroy_bp_condition, 0);

zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], 8, NULL, NULL, 0);

zend_hash_init(&PHPDBG_G(seek), 8, NULL, NULL, 0);

zend_hash_init(&PHPDBG_G(registered), 8, NULL, php_phpdbg_destroy_registered, 0);

zend_hash_init(&PHPDBG_G(file_sources), 0, NULL, php_phpdbg_destroy_file_source, 0);

phpdbg_setup_watchpoints();

REGISTER_INI_ENTRIES();

zend_execute_ex = phpdbg_execute_ex;

REGISTER_STRINGL_CONSTANT("PHPDBG_VERSION", PHPDBG_VERSION, sizeof(PHPDBG_VERSION)-1, CONST_CS|CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PHPDBG_FILE", FILE_PARAM, CONST_CS|CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PHPDBG_METHOD", METHOD_PARAM, CONST_CS|CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PHPDBG_LINENO", NUMERIC_PARAM, CONST_CS|CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PHPDBG_FUNC", STR_PARAM, CONST_CS|CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PHPDBG_COLOR_PROMPT", PHPDBG_COLOR_PROMPT, CONST_CS|CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PHPDBG_COLOR_NOTICE", PHPDBG_COLOR_NOTICE, CONST_CS|CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PHPDBG_COLOR_ERROR", PHPDBG_COLOR_ERROR, CONST_CS|CONST_PERSISTENT);

return SUCCESS;

} /* }}} */

static PHP_MSHUTDOWN_FUNCTION(phpdbg) /* {{{ */

{

zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE]);

zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING]);

zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM]);

zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE]);

zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE]);

zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE]);

zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]);

zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE]);

zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD]);

zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_COND]);

zend_hash_destroy(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP]);

zend_hash_destroy(&PHPDBG_G(file_sources));

zend_hash_destroy(&PHPDBG_G(seek));

zend_hash_destroy(&PHPDBG_G(registered));

phpdbg_destroy_watchpoints();

if (!(PHPDBG_G(flags) & PHPDBG_IS_QUITTING)) {

phpdbg_notice("stop", "type=\"normal\"", "Script ended normally");

}

/* hack to restore mm_heap->use_custom_heap in order to receive memory leak info */

if (use_mm_wrappers) {

/* ASSUMING that mm_heap->use_custom_heap is the first element of the struct ... */

*(int *) zend_mm_get_heap() = 0;

}

if (PHPDBG_G(buffer)) {

free(PHPDBG_G(buffer));

PHPDBG_G(buffer) = NULL;

}

if (PHPDBG_G(exec)) {

efree(PHPDBG_G(exec));

PHPDBG_G(exec) = NULL;

}

if (PHPDBG_G(oplog)) {

fclose(PHPDBG_G(oplog));

PHPDBG_G(oplog) = NULL;

}

if (PHPDBG_G(ops)) {

destroy_op_array(PHPDBG_G(ops));

efree(PHPDBG_G(ops));

PHPDBG_G(ops) = NULL;

}

if (PHPDBG_G(oplog_list)) {

phpdbg_oplog_list *cur = PHPDBG_G(oplog_list);

do {

phpdbg_oplog_list *prev = cur->prev;

efree(cur);

cur = prev;

} while (cur != NULL);

zend_arena_destroy(PHPDBG_G(oplog_arena));

PHPDBG_G(oplog_list) = NULL;

}

fflush(stdout);

if (SG(request_info).argv0) {

free(SG(request_info).argv0);

SG(request_info).argv0 = NULL;

}

return SUCCESS;

}

/* }}} */

static PHP_RINIT_FUNCTION(phpdbg) /* {{{ */

{

/* deactivate symbol table caching to have these properly destroyed upon stack leaving (especially important for watchpoints) */

EG(symtable_cache_limit) = EG(symtable_cache) - 1;

return SUCCESS;

} /* }}} */

static PHP_RSHUTDOWN_FUNCTION(phpdbg) /* {{{ */

{

if (PHPDBG_G(stdin_file)) {

fclose(PHPDBG_G(stdin_file));

PHPDBG_G(stdin_file) = NULL;

}

return SUCCESS;

} /* }}} */

/* {{{ proto mixed phpdbg_exec(string context)

Attempt to set the execution context for phpdbg

If the execution context was set previously it is returned

If the execution context was not set previously boolean true is returned

If the request to set the context fails, boolean false is returned, and an E_WARNING raised */

static PHP_FUNCTION(phpdbg_exec)

{

zend_string *exec;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &exec) == FAILURE) {

return;

}

{

zend_stat_t sb;

zend_bool result = 1;

if (VCWD_STAT(ZSTR_VAL(exec), &sb) != FAILURE) {

if (sb.st_mode & (S_IFREG|S_IFLNK)) {

if (PHPDBG_G(exec)) {

ZVAL_STRINGL(return_value, PHPDBG_G(exec), PHPDBG_G(exec_len));

efree(PHPDBG_G(exec));

result = 0;

}

PHPDBG_G(exec) = estrndup(ZSTR_VAL(exec), ZSTR_LEN(exec));

PHPDBG_G(exec_len) = ZSTR_LEN(exec);

if (result) {

ZVAL_TRUE(return_value);

}

} else {

zend_error(E_WARNING, "Failed to set execution context (%s), not a regular file or symlink", ZSTR_VAL(exec));

ZVAL_FALSE(return_value);

}

} else {

zend_error(E_WARNING, "Failed to set execution context (%s) the file does not exist", ZSTR_VAL(exec));

ZVAL_FALSE(return_value);

}

}

} /* }}} */

/* {{{ proto void phpdbg_break()

instructs phpdbg to insert a breakpoint at the next opcode */

static PHP_FUNCTION(phpdbg_break_next)

{

zend_execute_data *ex = EG(current_execute_data);

while (ex && ex->func && !ZEND_USER_CODE(ex->func->type)) {

ex = ex->prev_execute_data;

}

if (zend_parse_parameters_none() == FAILURE || !ex) {

return;

}

phpdbg_set_breakpoint_opline_ex((phpdbg_opline_ptr_t) ex->opline + 1);

} /* }}} */

/* {{{ proto void phpdbg_break_file(string file, integer line) */

static PHP_FUNCTION(phpdbg_break_file)

{

char *file;

size_t flen;

zend_long line;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl", &file, &flen, &line) == FAILURE) {

return;

}

phpdbg_set_breakpoint_file(file, line);

} /* }}} */

/* {{{ proto void phpdbg_break_method(string class, string method) */

static PHP_FUNCTION(phpdbg_break_method)

{

char *class = NULL, *method = NULL;

size_t clen = 0, mlen = 0;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &class, &clen, &method, &mlen) == FAILURE) {

return;

}

phpdbg_set_breakpoint_method(class, method);

} /* }}} */

/* {{{ proto void phpdbg_break_function(string function) */

static PHP_FUNCTION(phpdbg_break_function)

{

char *function = NULL;

size_t function_len;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &function, &function_len) == FAILURE) {

return;

}

phpdbg_set_breakpoint_symbol(function, function_len);

} /* }}} */

/* {{{ proto void phpdbg_clear(void)

instructs phpdbg to clear breakpoints */

static PHP_FUNCTION(phpdbg_clear)

{

zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE]);

zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING]);

zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM]);

zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE]);

zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE]);

zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE]);

zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]);

zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD]);

zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_COND]);

} /* }}} */

/* {{{ proto void phpdbg_color(integer element, string color) */

static PHP_FUNCTION(phpdbg_color)

{

zend_long element;

char *color;

size_t color_len;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "ls", &element, &color, &color_len) == FAILURE) {

return;

}

switch (element) {

case PHPDBG_COLOR_NOTICE:

case PHPDBG_COLOR_ERROR:

case PHPDBG_COLOR_PROMPT:

phpdbg_set_color_ex(element, color, color_len);

break;

default: zend_error(E_ERROR, "phpdbg detected an incorrect color constant");

}

} /* }}} */

/* {{{ proto void phpdbg_prompt(string prompt) */

static PHP_FUNCTION(phpdbg_prompt)

{

char *prompt = NULL;

size_t prompt_len = 0;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &prompt, &prompt_len) == FAILURE) {

return;

}

phpdbg_set_prompt(prompt);

} /* }}} */

/* {{{ proto void phpdbg_start_oplog() */

static PHP_FUNCTION(phpdbg_start_oplog)

{

phpdbg_oplog_list *prev;

if (zend_parse_parameters_none() == FAILURE) {

return;

}

prev = PHPDBG_G(oplog_list);

if (!prev) {

PHPDBG_G(oplog_arena) = zend_arena_create(64 * 1024);

PHPDBG_G(oplog_cur) = ((phpdbg_oplog_entry *) zend_arena_alloc(&PHPDBG_G(oplog_arena), sizeof(phpdbg_oplog_entry))) + 1;

PHPDBG_G(oplog_cur)->next = NULL;

}

PHPDBG_G(oplog_list) = emalloc(sizeof(phpdbg_oplog_list));

PHPDBG_G(oplog_list)->prev = prev;

PHPDBG_G(oplog_list)->start = PHPDBG_G(oplog_cur);

}

static void phpdbg_oplog_fill_executable(zend_op_array *op_array, HashTable *insert_ht, zend_bool by_opcode) {

/* ignore RECV_* opcodes */

zend_op *cur = op_array->opcodes + op_array->num_args + !!(op_array->fn_flags & ZEND_ACC_VARIADIC);

zend_op *end = op_array->opcodes + op_array->last;

zend_long insert_idx;

zval zero;

ZVAL_LONG(&zero, 0);

/* ignore autogenerated return (well, not too precise with finally branches, but that's okay) */

if (op_array->last >= 1 && (((end - 1)->opcode == ZEND_RETURN || (end - 1)->opcode == ZEND_RETURN_BY_REF || (end - 1)->opcode == ZEND_GENERATOR_RETURN)

&& ((op_array->last > 1 && ((end - 2)->opcode == ZEND_RETURN || (end - 2)->opcode == ZEND_RETURN_BY_REF || (end - 2)->opcode == ZEND_GENERATOR_RETURN || (end - 2)->opcode == ZEND_THROW))

|| op_array->function_name == NULL || (end - 1)->extended_value == -1))) {

end--;

}

for (; cur < end; cur++) {

if (cur->opcode == ZEND_NOP || cur->opcode == ZEND_OP_DATA || cur->opcode == ZEND_FE_FREE || cur->opcode == ZEND_FREE || cur->opcode == ZEND_ASSERT_CHECK || cur->opcode == ZEND_VERIFY_RETURN_TYPE

|| cur->opcode == ZEND_DECLARE_CONST || cur->opcode == ZEND_DECLARE_CLASS || cur->opcode == ZEND_DECLARE_INHERITED_CLASS || cur->opcode == ZEND_DECLARE_FUNCTION

|| cur->opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED || cur->opcode == ZEND_VERIFY_ABSTRACT_CLASS || cur->opcode == ZEND_ADD_TRAIT || cur->opcode == ZEND_BIND_TRAITS

|| cur->opcode == ZEND_DECLARE_ANON_CLASS || cur->opcode == ZEND_DECLARE_ANON_INHERITED_CLASS || cur->opcode == ZEND_FAST_RET || cur->opcode == ZEND_TICKS

|| cur->opcode == ZEND_EXT_STMT || cur->opcode == ZEND_EXT_FCALL_BEGIN || cur->opcode == ZEND_EXT_FCALL_END || cur->opcode == ZEND_EXT_NOP || cur->opcode == ZEND_BIND_GLOBAL) {

continue;

}

if (by_opcode) {

insert_idx = cur - op_array->opcodes;

} else {

insert_idx = cur->lineno;

}

if (cur->opcode == ZEND_NEW && (cur + 1)->opcode == ZEND_DO_FCALL) {

cur++;

}

zend_hash_index_update(insert_ht, insert_idx, &zero);

}

}

static inline HashTable* phpdbg_add_empty_array(HashTable *ht, zend_string *name) {

zval *ht_zv = zend_hash_find(ht, name);

if (!ht_zv) {

zval zv;

array_init(&zv);

ht_zv = zend_hash_add_new(ht, name, &zv);

}

return Z_ARR_P(ht_zv);

}

/* {{{ proto void phpdbg_end_oplog() */

static PHP_FUNCTION(phpdbg_get_executable)

{

HashTable *options = NULL;

zval *option_buffer;

zend_bool by_function = 0;

zend_bool by_opcode = 0;

HashTable *insert_ht;

zend_function *func;

zend_class_entry *ce;

zend_string *name;

HashTable *files = &PHPDBG_G(file_sources);

HashTable files_tmp;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "|H", &options) == FAILURE) {

return;

}

if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("functions")))) {

by_function = zend_is_true(option_buffer);

}

if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("opcodes")))) {

if (by_function) {

by_opcode = zend_is_true(option_buffer);

}

}

if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("files")))) {

ZVAL_DEREF(option_buffer);

if (Z_TYPE_P(option_buffer) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(option_buffer)) > 0) {

zval *filename;

files = &files_tmp;

zend_hash_init(files, 0, NULL, NULL, 0);

ZEND_HASH_FOREACH_VAL(Z_ARR_P(option_buffer), filename) {

zend_hash_add_empty_element(files, zval_get_string(filename));

} ZEND_HASH_FOREACH_END();

} else {

GC_REFCOUNT(files)++;

}

} else {

GC_REFCOUNT(files)++;

}

array_init(return_value);

ZEND_HASH_FOREACH_STR_KEY_PTR(EG(function_table), name, func) {

if (func->type == ZEND_USER_FUNCTION) {

if (zend_hash_exists(files, func->op_array.filename)) {

insert_ht = phpdbg_add_empty_array(Z_ARR_P(return_value), func->op_array.filename);

if (by_function) {

insert_ht = phpdbg_add_empty_array(insert_ht, name);

}

phpdbg_oplog_fill_executable(&func->op_array, insert_ht, by_opcode);

}

}

} ZEND_HASH_FOREACH_END();

ZEND_HASH_FOREACH_STR_KEY_PTR(EG(class_table), name, ce) {

if (ce->type == ZEND_USER_CLASS) {

if (zend_hash_exists(files, ce->info.user.filename)) {

ZEND_HASH_FOREACH_PTR(&ce->function_table, func) {

if (func->type == ZEND_USER_FUNCTION && zend_hash_exists(files, func->op_array.filename)) {

insert_ht = phpdbg_add_empty_array(Z_ARR_P(return_value), func->op_array.filename);

if (by_function) {

zend_string *fn_name = strpprintf(ZSTR_LEN(name) + ZSTR_LEN(func->op_array.function_name) + 2, "%.*s::%.*s", (int) ZSTR_LEN(name), ZSTR_VAL(name), (int) ZSTR_LEN(func->op_array.function_name), ZSTR_VAL(func->op_array.function_name));

insert_ht = phpdbg_add_empty_array(insert_ht, fn_name);

zend_string_release(fn_name);

}

phpdbg_oplog_fill_executable(&func->op_array, insert_ht, by_opcode);

}

} ZEND_HASH_FOREACH_END();

}

}

} ZEND_HASH_FOREACH_END();

ZEND_HASH_FOREACH_STR_KEY(files, name) {

phpdbg_file_source *source = zend_hash_find_ptr(&PHPDBG_G(file_sources), name);

if (source) {

phpdbg_oplog_fill_executable(

&source->op_array,

phpdbg_add_empty_array(Z_ARR_P(return_value), source->op_array.filename),

by_opcode);

}

} ZEND_HASH_FOREACH_END();

if (!--GC_REFCOUNT(files)) {

zend_hash_destroy(files);

}

}

/* {{{ proto void phpdbg_end_oplog() */

static PHP_FUNCTION(phpdbg_end_oplog)

{

phpdbg_oplog_entry *cur;

phpdbg_oplog_list *prev;

HashTable *options = NULL;

zval *option_buffer;

zend_bool by_function = 0;

zend_bool by_opcode = 0;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "|H", &options) == FAILURE) {

return;

}

if (!PHPDBG_G(oplog_list)) {

zend_error(E_WARNING, "Can not end an oplog without starting it");

return;

}

cur = PHPDBG_G(oplog_list)->start;

prev = PHPDBG_G(oplog_list)->prev;

efree(PHPDBG_G(oplog_list));

PHPDBG_G(oplog_list) = prev;

if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("functions")))) {

by_function = zend_is_true(option_buffer);

}

if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("opcodes")))) {

if (by_function) {

by_opcode = zend_is_true(option_buffer);

}

}

array_init(return_value);

{

zend_string *last_file = NULL;

HashTable *file_ht;

zend_string *last_function = (void *)~(uintptr_t)0;

zend_class_entry *last_scope = NULL;

HashTable *insert_ht;

zend_long insert_idx;

do {

zval zero;

ZVAL_LONG(&zero, 0);

if (cur->filename != last_file) {

last_file = cur->filename;

file_ht = insert_ht = phpdbg_add_empty_array(Z_ARR_P(return_value), last_file);

}

if (by_function) {

if (cur->function_name == NULL) {

if (last_function != NULL) {

insert_ht = file_ht;

}

last_function = NULL;

} else if (cur->function_name != last_function || cur->scope != last_scope) {

zend_string *fn_name;

last_function = cur->function_name;

last_scope = cur->scope;

if (last_scope == NULL) {

fn_name = zend_string_copy(last_function);

} else {

fn_name = strpprintf(ZSTR_LEN(last_function) + ZSTR_LEN(last_scope->name) + 2, "%.*s::%.*s", (int) ZSTR_LEN(last_scope->name), ZSTR_VAL(last_scope->name), (int) ZSTR_LEN(last_function), ZSTR_VAL(last_function));

}

insert_ht = phpdbg_add_empty_array(Z_ARR_P(return_value), fn_name);

zend_string_release(fn_name);

}

}

if (by_opcode) {

insert_idx = cur->op - cur->opcodes;

} else {

insert_idx = cur->op->lineno;

}

{

zval *num = zend_hash_index_find(insert_ht, insert_idx);

if (!num) {

num = zend_hash_index_add_new(insert_ht, insert_idx, &zero);

}

Z_LVAL_P(num)++;

}

cur = cur->next;

} while (cur != NULL);

}

if (!prev) {

zend_arena_destroy(PHPDBG_G(oplog_arena));

}

}

ZEND_BEGIN_ARG_INFO_EX(phpdbg_break_next_arginfo, 0, 0, 0)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(phpdbg_break_file_arginfo, 0, 0, 2)

ZEND_ARG_INFO(0, file)

ZEND_ARG_INFO(0, line)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(phpdbg_break_method_arginfo, 0, 0, 2)

ZEND_ARG_INFO(0, class)

ZEND_ARG_INFO(0, method)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(phpdbg_break_function_arginfo, 0, 0, 1)

ZEND_ARG_INFO(0, function)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(phpdbg_color_arginfo, 0, 0, 0)

ZEND_ARG_INFO(0, element)

ZEND_ARG_INFO(0, color)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(phpdbg_prompt_arginfo, 0, 0, 0)

ZEND_ARG_INFO(0, string)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(phpdbg_exec_arginfo, 0, 0, 0)

ZEND_ARG_INFO(0, context)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(phpdbg_clear_arginfo, 0, 0, 0)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(phpdbg_start_oplog_arginfo, 0, 0, 0)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(phpdbg_end_oplog_arginfo, 0, 0, 0)

ZEND_ARG_INFO(0, options)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(phpdbg_get_executable_arginfo, 0, 0, 0)

ZEND_ARG_INFO(0, options)

ZEND_END_ARG_INFO()

zend_function_entry phpdbg_user_functions[] = {

PHP_FE(phpdbg_clear, phpdbg_clear_arginfo)

PHP_FE(phpdbg_break_next, phpdbg_break_next_arginfo)

PHP_FE(phpdbg_break_file, phpdbg_break_file_arginfo)

PHP_FE(phpdbg_break_method, phpdbg_break_method_arginfo)

PHP_FE(phpdbg_break_function, phpdbg_break_function_arginfo)

PHP_FE(phpdbg_exec, phpdbg_exec_arginfo)

PHP_FE(phpdbg_color, phpdbg_color_arginfo)

PHP_FE(phpdbg_prompt, phpdbg_prompt_arginfo)

PHP_FE(phpdbg_start_oplog, phpdbg_start_oplog_arginfo)

PHP_FE(phpdbg_end_oplog, phpdbg_end_oplog_arginfo)

PHP_FE(phpdbg_get_executable, phpdbg_get_executable_arginfo)

#ifdef PHP_FE_END

PHP_FE_END

#else

{NULL,NULL,NULL}

#endif

};

static zend_module_entry sapi_phpdbg_module_entry = {

STANDARD_MODULE_HEADER,

PHPDBG_NAME,

phpdbg_user_functions,

PHP_MINIT(phpdbg),

PHP_MSHUTDOWN(phpdbg),

PHP_RINIT(phpdbg),

PHP_RSHUTDOWN(phpdbg),

NULL,

PHPDBG_VERSION,

STANDARD_MODULE_PROPERTIES

};

static inline int php_sapi_phpdbg_module_startup(sapi_module_struct *module) /* {{{ */

{

if (php_module_startup(module, &sapi_phpdbg_module_entry, 1) == FAILURE) {

return FAILURE;

}

phpdbg_booted=1;

return SUCCESS;

} /* }}} */

static char* php_sapi_phpdbg_read_cookies(void) /* {{{ */

{

return NULL;

} /* }}} */

static int php_sapi_phpdbg_header_handler(sapi_header_struct *h, sapi_header_op_enum op, sapi_headers_struct *s) /* {{{ */

{

return 0;

}

/* }}} */

static int php_sapi_phpdbg_send_headers(sapi_headers_struct *sapi_headers) /* {{{ */

{

/* We do nothing here, this function is needed to prevent that the fallback

* header handling is called. */

return SAPI_HEADER_SENT_SUCCESSFULLY;

}

/* }}} */

static void php_sapi_phpdbg_send_header(sapi_header_struct *sapi_header, void *server_context) /* {{{ */

{

}

/* }}} */

static void php_sapi_phpdbg_log_message(char *message, int syslog_type_int) /* {{{ */

{

/*

* We must not request TSRM before being booted

*/

if (phpdbg_booted) {

if (PHPDBG_G(flags) & PHPDBG_IN_EVAL) {

phpdbg_error("eval", "msg=\"%s\"", "%s", message);

return;

}

phpdbg_error("php", "msg=\"%s\"", "%s", message);

if (PHPDBG_G(flags) & PHPDBG_PREVENT_INTERACTIVE) {

return;

}

switch (PG(last_error_type)) {

case E_ERROR:

case E_CORE_ERROR:

case E_COMPILE_ERROR:

case E_USER_ERROR:

case E_PARSE:

case E_RECOVERABLE_ERROR: {

const char *file_char = zend_get_executed_filename();

zend_string *file = zend_string_init(file_char, strlen(file_char), 0);

phpdbg_list_file(file, 3, zend_get_executed_lineno() - 1, zend_get_executed_lineno());

zend_string_release(file);

if (!phpdbg_fully_started) {

return;

}

do {

switch (phpdbg_interactive(1, NULL)) {

case PHPDBG_LEAVE:

case PHPDBG_FINISH:

case PHPDBG_UNTIL:

case PHPDBG_NEXT:

return;

}

} while (!(PHPDBG_G(flags) & PHPDBG_IS_STOPPING));

}

}

} else {

fprintf(stdout, "%s\n", message);

}

}

/* }}} */

static int php_sapi_phpdbg_activate(void) /* {{{ */

{

return SUCCESS;

}

static int php_sapi_phpdbg_deactivate(void) /* {{{ */

{

return SUCCESS;

}

static void php_sapi_phpdbg_register_vars(zval *track_vars_array) /* {{{ */

{

size_t len;

char *docroot = "";

/* In phpdbg mode, we consider the environment to be a part of the server variables

*/

php_import_environment_variables(track_vars_array);

if (PHPDBG_G(exec)) {

len = PHPDBG_G(exec_len);

if (sapi_module.input_filter(PARSE_SERVER, "PHP_SELF", &PHPDBG_G(exec), PHPDBG_G(exec_len), &len)) {

php_register_variable("PHP_SELF", PHPDBG_G(exec), track_vars_array);

}

if (sapi_module.input_filter(PARSE_SERVER, "SCRIPT_NAME", &PHPDBG_G(exec), PHPDBG_G(exec_len), &len)) {

php_register_variable("SCRIPT_NAME", PHPDBG_G(exec), track_vars_array);

}

if (sapi_module.input_filter(PARSE_SERVER, "SCRIPT_FILENAME", &PHPDBG_G(exec), PHPDBG_G(exec_len), &len)) {

php_register_variable("SCRIPT_FILENAME", PHPDBG_G(exec), track_vars_array);

}

if (sapi_module.input_filter(PARSE_SERVER, "PATH_TRANSLATED", &PHPDBG_G(exec), PHPDBG_G(exec_len), &len)) {

php_register_variable("PATH_TRANSLATED", PHPDBG_G(exec), track_vars_array);

}

}

/* any old docroot will do */

len = 0;

if (sapi_module.input_filter(PARSE_SERVER, "DOCUMENT_ROOT", &docroot, len, &len)) {

php_register_variable("DOCUMENT_ROOT", docroot, track_vars_array);

}

}

/* }}} */

static inline size_t php_sapi_phpdbg_ub_write(const char *message, size_t length) /* {{{ */

{

if (PHPDBG_G(socket_fd) != -1 && !(PHPDBG_G(flags) & PHPDBG_IS_INTERACTIVE)) {

send(PHPDBG_G(socket_fd), message, length, 0);

}

return phpdbg_script(P_STDOUT, "%.*s", (int) length, message);

} /* }}} */

/* beginning of struct, see main/streams/plain_wrapper.c line 111 */

typedef struct {

FILE *file;

int fd;

} php_stdio_stream_data;

static size_t phpdbg_stdiop_write(php_stream *stream, const char *buf, size_t count) {

php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;

while (data->fd >= 0) {

struct stat stat[3];

memset(stat, 0, sizeof(stat));

if (((fstat(fileno(stderr), &stat[2]) < 0) & (fstat(fileno(stdout), &stat[0]) < 0)) | (fstat(data->fd, &stat[1]) < 0)) {

break;

}

if (stat[0].st_dev == stat[1].st_dev && stat[0].st_ino == stat[1].st_ino) {

phpdbg_script(P_STDOUT, "%.*s", (int) count, buf);

return count;

}

if (stat[2].st_dev == stat[1].st_dev && stat[2].st_ino == stat[1].st_ino) {

phpdbg_script_ex(PHPDBG_G(io)[PHPDBG_STDERR].fd, P_STDERR, "%.*s", (int) count, buf);

return count;

}

break;

}

return PHPDBG_G(php_stdiop_write)(stream, buf, count);

}

static inline void php_sapi_phpdbg_flush(void *context) /* {{{ */

{

if (!phpdbg_active_sigsafe_mem()) {

fflush(PHPDBG_G(io)[PHPDBG_STDOUT].ptr);

}

} /* }}} */

/* copied from sapi/cli/php_cli.c cli_register_file_handles */

void phpdbg_register_file_handles(void) /* {{{ */

{

zval zin, zout, zerr;

php_stream *s_in, *s_out, *s_err;

php_stream_context *sc_in=NULL, *sc_out=NULL, *sc_err=NULL;

zend_constant ic, oc, ec;

s_in = php_stream_open_wrapper_ex("php://stdin", "rb", 0, NULL, sc_in);

s_out = php_stream_open_wrapper_ex("php://stdout", "wb", 0, NULL, sc_out);

s_err = php_stream_open_wrapper_ex("php://stderr", "wb", 0, NULL, sc_err);

if (s_in==NULL || s_out==NULL || s_err==NULL) {

if (s_in) php_stream_close(s_in);

if (s_out) php_stream_close(s_out);

if (s_err) php_stream_close(s_err);

return;

}

#if PHP_DEBUG

/* do not close stdout and stderr */

s_out->flags |= PHP_STREAM_FLAG_NO_CLOSE;

s_err->flags |= PHP_STREAM_FLAG_NO_CLOSE;

#endif

php_stream_to_zval(s_in, &zin);

php_stream_to_zval(s_out, &zout);