#if !defined(ZEND_SIGNALS) || defined(_WIN32)

# include <signal.h>

#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"

#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"

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;

#if PHP_VERSION_ID >= 50500

void (*zend_execute_old)(zend_execute_data *execute_data);

void (*zend_execute_old)(zend_op_array *op_array);

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->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->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;

#ifdef PHP_WIN32

pg->sigio_watcher_thread = INVALID_HANDLE_VALUE;

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

pg->eol = PHPDBG_EOL_LF;

} /* }}} */

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

{

ZEND_INIT_MODULE_GLOBALS(phpdbg, php_phpdbg_globals_ctor, NULL);

REGISTER_INI_ENTRIES();

#if PHP_VERSION_ID >= 50500

zend_execute_old = zend_execute_ex;

zend_execute_ex = phpdbg_execute_ex;

zend_execute_old = zend_execute;

zend_execute = 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 void php_phpdbg_destroy_bp_file(zval *brake) /* {{{ */

{

zend_hash_destroy(Z_ARRVAL_P(brake));

} /* }}} */

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

{

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

} /* }}} */

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

{

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

} /* }}} */

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

{

zend_hash_destroy(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) {

if (brake->ops) {

destroy_op_array(brake->ops);

efree(brake->ops);

}

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

}

} /* }}} */

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

{

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

destroy_zend_function(function);

} /* }}} */

static PHP_RINIT_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, NULL, 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);

return SUCCESS;

} /* }}} */

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

{

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

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(seek));

zend_hash_destroy(&PHPDBG_G(file_sources));

zend_hash_destroy(&PHPDBG_G(registered));

zend_hash_destroy(&PHPDBG_G(watchpoints));

zend_llist_destroy(&PHPDBG_G(watchlist_mem));

if (PHPDBG_G(buffer)) {

efree(PHPDBG_G(buffer));

PHPDBG_G(buffer) = NULL;

}

if (PHPDBG_G(exec)) {

efree(PHPDBG_G(exec));

PHPDBG_G(exec) = NULL;

}

if (PHPDBG_G(prompt)[0]) {

free(PHPDBG_G(prompt)[0]);

}

if (PHPDBG_G(prompt)[1]) {

free(PHPDBG_G(prompt)[1]);

}

PHPDBG_G(prompt)[0] = NULL;

PHPDBG_G(prompt)[1] = 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;

}

return SUCCESS;

} /* }}} */

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", exec);

ZVAL_FALSE(return_value);

}

} else {

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

ZVAL_FALSE(return_value);

}

}

} /* }}} */

static PHP_FUNCTION(phpdbg_break_next)

{

if (zend_parse_parameters_none() == FAILURE && EG(current_execute_data)) {

return;

}

phpdbg_set_breakpoint_opline_ex((phpdbg_opline_ptr_t) EG(current_execute_data)->opline + 1);

} /* }}} */

static PHP_FUNCTION(phpdbg_break_file)

{

char *file = NULL;

size_t flen = 0;

long line;

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

return;

}

phpdbg_set_breakpoint_file(file, line);

} /* }}} */

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);

} /* }}} */

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);

} /* }}} */

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]);

} /* }}} */

static PHP_FUNCTION(phpdbg_color)

{

long element = 0L;

char *color = NULL;

size_t color_len = 0;

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");

}

} /* }}} */

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);

} /* }}} */

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 PHP_FUNCTION(phpdbg_end_oplog)

{

phpdbg_oplog_entry *cur = PHPDBG_G(oplog_list)->start;

phpdbg_oplog_list *prev = PHPDBG_G(oplog_list)->prev;

HashTable *options;

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;

}

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;

zval *file_buf;

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

zend_class_entry *last_scope = NULL;

zval *fn_buf;

HashTable *insert_ht;

zend_long insert_idx;

do {

zend_op_array *op_array = cur->op_array;

if (op_array->filename != last_file) {

last_file = op_array->filename;

file_buf = zend_hash_find(Z_ARR_P(return_value), last_file);

if (!file_buf) {

zval ht;

array_init(&ht);

file_buf = zend_hash_add_new(Z_ARR_P(return_value), last_file, &ht);

}

}

insert_ht = Z_ARR_P(file_buf);

if (by_function) {

if (op_array->function_name != last_function || op_array->scope != last_scope) {

zend_string *fn_name;

last_function = op_array->function_name;

last_scope = op_array->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", ZSTR_LEN(last_function), ZSTR_VAL(last_function), ZSTR_LEN(last_scope->name), ZSTR_VAL(last_scope->name));

}

fn_buf = zend_hash_find(Z_ARR_P(return_value), fn_name);

if (!fn_buf) {

zval ht;

array_init(&ht);

fn_buf = zend_hash_add_new(Z_ARR_P(return_value), fn_name, &ht);

}

}

insert_ht = Z_ARR_P(fn_buf);

}

if (by_opcode) {

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

} else {

insert_idx = cur->op->lineno;

}

{

zval *num = zend_hash_index_find(insert_ht, insert_idx);

if (!num) {

zval zv;

ZVAL_LONG(&zv, 0);

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

}

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_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)

#ifdef PHP_FE_END

PHP_FE_END

{NULL,NULL,NULL}

};

static zend_module_entry sapi_phpdbg_module_entry = {

STANDARD_MODULE_HEADER,

PHPDBG_NAME,

phpdbg_user_functions,

PHP_MINIT(phpdbg),

NULL,

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

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) /* {{{ */

{

/*

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);

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());

efree(file);

if (!phpdbg_fully_started) {

return;

}

do {

switch (phpdbg_interactive(1)) {

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_deactivate(void) /* {{{ */

{

if ((PHPDBG_G(flags) & PHPDBG_IS_STOPPING) == PHPDBG_IS_CLEANING) {

zend_phpdbg_globals *pg = PHPDBG_G(backup) = calloc(1, sizeof(zend_phpdbg_globals));

php_phpdbg_globals_ctor(pg);

pg->exec = zend_strndup(PHPDBG_G(exec), PHPDBG_G(exec_len));

pg->exec_len = PHPDBG_G(exec_len);

pg->oplog = PHPDBG_G(oplog);

pg->prompt[0] = PHPDBG_G(prompt)[0];

pg->prompt[1] = PHPDBG_G(prompt)[1];

memcpy(pg->colors, PHPDBG_G(colors), sizeof(pg->colors));

pg->eol = PHPDBG_G(eol);

pg->flags = PHPDBG_G(flags) & PHPDBG_PRESERVE_FLAGS_MASK;

}

fflush(stdout);

if(SG(request_info).argv0) {

free(SG(request_info).argv0);

SG(request_info).argv0 = NULL;

}

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", length, message);

} /* }}} */

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(P_STDERR, "%.*s", (int) count, buf);

return count;

}

break;

}

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

}

#if PHP_VERSION_ID >= 50700

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

{

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

{

if (!phpdbg_active_sigsafe_mem()) {

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

}

} /* }}} */

static 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;

php_stream_to_zval(s_in, &zin);

php_stream_to_zval(s_out, &zout);

php_stream_to_zval(s_err, &zerr);

ic.value = zin;

ic.flags = CONST_CS;

ic.name = zend_string_init(ZEND_STRL("STDIN"), 0);

ic.module_number = 0;

zend_register_constant(&ic);

oc.value = zout;

oc.flags = CONST_CS;

oc.name = zend_string_init(ZEND_STRL("STDOUT"), 0);

oc.module_number = 0;

zend_register_constant(&oc);

ec.value = zerr;

ec.flags = CONST_CS;

ec.name = zend_string_init(ZEND_STRL("STDERR"), 0);

ec.module_number = 0;

zend_register_constant(&ec);

}

static sapi_module_struct phpdbg_sapi_module = {

"phpdbg", /* name */

"phpdbg", /* pretty name */

php_sapi_phpdbg_module_startup, /* startup */

php_module_shutdown_wrapper, /* shutdown */

NULL, /* activate */

php_sapi_phpdbg_deactivate, /* deactivate */

php_sapi_phpdbg_ub_write, /* unbuffered write */

php_sapi_phpdbg_flush, /* flush */

NULL, /* get uid */

NULL, /* getenv */

php_error, /* error handler */

php_sapi_phpdbg_header_handler, /* header handler */

php_sapi_phpdbg_send_headers, /* send headers handler */

php_sapi_phpdbg_send_header, /* send header handler */

NULL, /* read POST data */

php_sapi_phpdbg_read_cookies, /* read Cookies */

php_sapi_phpdbg_register_vars, /* register server variables */

php_sapi_phpdbg_log_message, /* Log message */

NULL, /* Get request time */

NULL, /* Child terminate */

STANDARD_SAPI_MODULE_PROPERTIES

};

const opt_struct OPTIONS[] = { /* {{{ */

{'c', 1, "ini path override"},

{'d', 1, "define ini entry on command line"},

{'n', 0, "no php.ini"},

{'z', 1, "load zend_extension"},

/* phpdbg options */

{'q', 0, "no banner"},

{'v', 0, "disable quietness"},

{'b', 0, "boring colours"},

{'i', 1, "specify init"},

{'I', 0, "ignore init"},

{'O', 1, "opline log"},

{'r', 0, "run"},

{'E', 0, "step-through-eval"},

{'S', 1, "sapi-name"},

#ifndef _WIN32

{'l', 1, "listen"},

{'a', 1, "address-or-any"},

{'x', 0, "xml output"},

{'p', 2, "show opcodes"},

{'h', 0, "help"},

{'V', 0, "version"},

{'-', 0, NULL}

}; /* }}} */

const char phpdbg_ini_hardcoded[] =

"output_buffering=off\n\0";

#define INI_DEFAULT(name, value) \

ZVAL_STRINGL(&tmp, value, sizeof(value) - 1); \

Z_SET_REFCOUNT(tmp, 0); \

zend_hash_str_update(configuration_hash, name, sizeof(name) - 1, &tmp);

void phpdbg_ini_defaults(HashTable *configuration_hash) /* {{{ */

{

zval tmp;

INI_DEFAULT("report_zend_debug", "0");

} /* }}} */

static void phpdbg_welcome(zend_bool cleaning) /* {{{ */

{

/* print blurb */

if (!cleaning) {

phpdbg_xml("<intros>");

phpdbg_notice("intro", "version=\"%s\"", "Welcome to phpdbg, the interactive PHP debugger, v%s", PHPDBG_VERSION);

phpdbg_writeln("intro", "help=\"help\"", "To get help using phpdbg type \"help\" and press enter");

phpdbg_notice("intro", "report=\"%s\"", "Please report bugs to <%s>", PHPDBG_ISSUES);

phpdbg_xml("</intros>");

} else if (phpdbg_startup_run == 0) {

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

phpdbg_notice(NULL, NULL, "Clean Execution Environment");

}

phpdbg_write("cleaninfo", "classes=\"%d\" functions=\"%d\" constants=\"%d\" includes=\"%d\"",

"Classes %d\n"

"Functions %d\n"

"Constants %d\n"

"Includes %d\n",

zend_hash_num_elements(EG(class_table)),

zend_hash_num_elements(EG(function_table)),

zend_hash_num_elements(EG(zend_constants)),

zend_hash_num_elements(&EG(included_files)));

}

} /* }}} */

static inline void phpdbg_sigint_handler(int signo) /* {{{ */

{

if (PHPDBG_G(flags) & PHPDBG_IS_INTERACTIVE) {

/* we quit remote consoles on recv SIGINT */

if (PHPDBG_G(flags) & PHPDBG_IS_REMOTE) {

PHPDBG_G(flags) |= PHPDBG_IS_STOPPING;

zend_bailout();

}

} else {

/* set signalled only when not interactive */

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

if (PHPDBG_G(flags) & PHPDBG_IS_SIGNALED) {

char mem[PHPDBG_SIGSAFE_MEM_SIZE + 1];

phpdbg_set_sigsafe_mem(mem);

zend_try {

phpdbg_force_interruption();

} zend_end_try()

phpdbg_clear_sigsafe_mem();

return;

}

PHPDBG_G(flags) |= PHPDBG_IS_SIGNALED;

}

}

} /* }}} */

static void phpdbg_remote_close(int socket, FILE *stream) {

if (socket >= 0) {

phpdbg_close_socket(socket);

}

if (stream) {