static void _zend_is_inconsistent(const HashTable *ht, const char *file, int line)
{
if (ht->inconsistent==HT_OK) {
return;
}
switch (ht->inconsistent) {
case HT_IS_DESTROYING:
zend_output_debug_string(1, "%s(%d) : ht=%p is being destroyed", file, line, ht);
break;
case HT_DESTROYED:
zend_output_debug_string(1, "%s(%d) : ht=%p is already destroyed", file, line, ht);
break;
case HT_CLEANING:
zend_output_debug_string(1, "%s(%d) : ht=%p is being cleaned", file, line, ht);
break;
default:
zend_output_debug_string(1, "%s(%d) : ht=%p is inconsistent", file, line, ht);
break;
}
zend_bailout();
}
static int sapi_webjames_ub_write(const char *str, uint str_length TSRMLS_DC)
/*unbuffered write - send data straight out to socket*/
{
int totalbytes = 0;
do {
int bytes;
bytes = webjames_writebuffer(WG(conn),str,str_length);
if (bytes<0) {
PG(connection_status) = PHP_CONNECTION_ABORTED;
if (!PG(ignore_user_abort)) {
zend_bailout();
}
return bytes;
}
str += bytes;
str_length -= bytes;
totalbytes += bytes;
} while (str_length);
return totalbytes;
}
/* {{{ proto bool SessionHandler::close()
Wraps the old close handler */
PHP_METHOD(SessionHandler, close)
{
int ret;
PS_SANITY_CHECK_IS_OPEN;
// don't return on failure, since not closing the default handler
// could result in memory leaks or other nasties
zend_parse_parameters_none();
PS(mod_user_is_open) = 0;
zend_try {
ret = PS(default_mod)->s_close(&PS(mod_data));
} zend_catch {
PS(session_status) = php_session_none;
zend_bailout();
} zend_end_try();
RETVAL_BOOL(SUCCESS == ret);
}
static int
php_roxen_sapi_ub_write(const char *str, uint str_length)
{
#ifdef ZTS
PLS_FETCH();
#endif
#ifdef ROXEN_USE_ZTS
GET_THIS();
#endif
int sent_bytes = 0, fd = MY_FD;
if(fd)
{
for(sent_bytes=0;sent_bytes < str_length;)
{
int written;
written = fd_write(fd, str + sent_bytes, str_length - sent_bytes);
if(written < 0)
{
switch(errno)
{
default:
/* This means the connection is closed. Dead. Gone. *sniff* */
PG(connection_status) = PHP_CONNECTION_ABORTED;
zend_bailout();
return sent_bytes;
case EINTR:
case EWOULDBLOCK:
continue;
}
} else {
sent_bytes += written;
}
}
} else {
THREAD_SAFE_RUN(sent_bytes = php_roxen_low_ub_write(str, str_length),
"write");
}
return sent_bytes;
}
static void sapi_webjames_send_header(sapi_header_struct *sapi_header, void *server_context)
/*send an HTTP header*/
{
char *header = sapi_header->header;
int len = sapi_header->header_len;
if (WG(conn)->flags.outputheaders) {
while (sapi_header && len > 0) {
int bytes;
bytes = webjames_writebuffer(WG(conn), header, len);
if (bytes<0) {
PG(connection_status) = PHP_CONNECTION_ABORTED;
if (!PG(ignore_user_abort)) {
zend_bailout();
}
return;
}
header += bytes;
len -= bytes;
}
webjames_writestring(WG(conn), "\r\n");
}
}
/* {{{ proto void Runkit_Sandbox_Parent::die(mixed message)
MALIAS(exit)
PATRICIDE!!!!!!!! */
PHP_METHOD(Runkit_Sandbox_Parent,die)
{
php_runkit_sandbox_parent_object *objval;
zval *message = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|z", &message) == FAILURE) {
RETURN_FALSE;
}
RETVAL_NULL();
if (message && Z_TYPE_P(message) != IS_LONG) {
convert_to_string(message);
}
PHP_RUNKIT_SANDBOX_PARENT_FETCHBOX_VERIFY_ACCESS(objval, this_ptr);
if (!objval->self->parent_die) {
php_error_docref(NULL, E_WARNING, "Patricide is disabled. Shame on you Oedipus.");
/* Sent as a warning, but we'll really implement it as an E_ERROR */
objval->self->active = 0;
RETURN_FALSE;
}
CG(unclean_shutdown) = 1;
CG(in_compilation) = EG(in_execution) = 0;
EG(current_execute_data) = NULL;
PHP_RUNKIT_SANDBOX_PARENT_BEGIN(objval)
if (message) {
if (Z_TYPE_P(message) == IS_LONG) {
EG(exit_status) = Z_LVAL_P(message);
} else {
PHPWRITE(Z_STRVAL_P(message), Z_STRLEN_P(message));
}
}
zend_bailout();
/* More of a murder-suicide really... */
PHP_RUNKIT_SANDBOX_PARENT_END(objval)
}
/* {{{ proto bool SessionHandler::open(string save_path, string session_name)
Wraps the old open handler */
PHP_METHOD(SessionHandler, open)
{
char *save_path = NULL, *session_name = NULL;
size_t save_path_len, session_name_len;
int ret;
PS_SANITY_CHECK;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &save_path, &save_path_len, &session_name, &session_name_len) == FAILURE) {
return;
}
PS(mod_user_is_open) = 1;
zend_try {
ret = PS(default_mod)->s_open(&PS(mod_data), save_path, session_name);
} zend_catch {
PS(session_status) = php_session_none;
zend_bailout();
} zend_end_try();
RETVAL_BOOL(SUCCESS == ret);
}
static int
php_caudium_sapi_ub_write(const char *str, uint str_length TSRMLS_DC)
{
GET_THIS();
int sent_bytes = 0, fd = MY_FD;
if(fd)
{
for(sent_bytes=0;sent_bytes < str_length;)
{
int written;
written = fd_write(fd, str + sent_bytes, str_length - sent_bytes);
if(written < 0)
{
switch(errno)
{
default:
/* This means the connection is closed. Dead. Gone. *sniff* */
PG(connection_status) = PHP_CONNECTION_ABORTED;
zend_bailout();
THIS->written += sent_bytes;
return sent_bytes;
case EINTR:
case EWOULDBLOCK:
continue;
}
} else {
sent_bytes += written;
}
}
THIS->written += sent_bytes;
} else {
THREAD_SAFE_RUN(sent_bytes = php_caudium_low_ub_write(str, str_length TSRMLS_CC),
"write");
}
return sent_bytes;
}
void zend_accel_error(int type, const char *format, ...)
{
va_list args;
time_t timestamp;
char *time_string;
FILE * fLog = NULL;
if (type > ZCG(accel_directives).log_verbosity_level) {
return;
}
timestamp = time(NULL);
time_string = asctime(localtime(×tamp));
time_string[24] = 0;
if (!ZCG(accel_directives).error_log ||
!*ZCG(accel_directives).error_log ||
strcmp(ZCG(accel_directives).error_log, "stderr") == 0) {
fLog = stderr;
} else {
fLog = fopen(ZCG(accel_directives).error_log, "a+");
if (!fLog) {
fLog = stderr;
}
}
#ifdef ZTS
fprintf(fLog, "%s (" ZEND_ULONG_FMT "): ", time_string, (zend_ulong)tsrm_thread_id());
#else
fprintf(fLog, "%s (%d): ", time_string, getpid());
#endif
switch (type) {
case ACCEL_LOG_FATAL:
fprintf(fLog, "Fatal Error ");
break;
case ACCEL_LOG_ERROR:
fprintf(fLog, "Error ");
break;
case ACCEL_LOG_WARNING:
fprintf(fLog, "Warning ");
break;
case ACCEL_LOG_INFO:
fprintf(fLog, "Message ");
break;
case ACCEL_LOG_DEBUG:
fprintf(fLog, "Debug ");
break;
}
va_start(args, format);
vfprintf(fLog, format, args);
va_end(args);
fprintf(fLog, "\n");
switch (type) {
case ACCEL_LOG_ERROR:
zend_bailout();
break;
case ACCEL_LOG_FATAL:
exit(-2);
break;
}
fflush(fLog);
if (fLog != stderr) {
fclose(fLog);
}
}
void zephir_exit_empty()
{
zend_bailout();
}
/* {{{ php_runkit_sandbox_parent_include_or_eval
What's the point of running in a sandbox if you can leave whenever you want to???
*/
static void php_runkit_sandbox_parent_include_or_eval(INTERNAL_FUNCTION_PARAMETERS, int type, int once)
{
php_runkit_sandbox_parent_object *objval;
zval *zcode;
int bailed_out = 0;
zval *retval = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcode) == FAILURE) {
RETURN_FALSE;
}
convert_to_string(zcode);
PHP_RUNKIT_SANDBOX_PARENT_FETCHBOX_VERIFY_ACCESS(objval, this_ptr);
if (type == ZEND_EVAL && !objval->self->parent_eval) {
php_error_docref(NULL, E_WARNING, "Access to eval() code in the parent context is not enabled");
RETURN_FALSE;
}
if (type != ZEND_EVAL && !objval->self->parent_include) {
php_error_docref(NULL, E_WARNING, "Access to include()/include_once()/require()/require_once() in the parent context is not enabled");
RETURN_FALSE;
}
RETVAL_NULL();
PHP_RUNKIT_SANDBOX_PARENT_BEGIN(objval)
zend_op_array *op_array = NULL;
int already_included = 0;
op_array = php_runkit_sandbox_include_or_eval_int(return_value, zcode, type, once, &already_included);
if (op_array) {
HashTable *old_symbol_table = EG(active_symbol_table);
zval **orig_retvalpp = EG(return_value_ptr_ptr);
zend_op_array *orig_act_oparray = EG(active_op_array);
EG(return_value_ptr_ptr) = &retval;
EG(active_op_array) = op_array;
EG(active_symbol_table) = php_runkit_sandbox_parent_resolve_symbol_table(objval);
zend_execute(op_array);
if (retval) {
*return_value = *retval;
} else {
RETVAL_TRUE;
}
destroy_op_array(op_array);
efree(op_array);
EG(return_value_ptr_ptr) = orig_retvalpp;
EG(active_op_array) = orig_act_oparray;
EG(active_symbol_table) = old_symbol_table;
} else if ((type != ZEND_INCLUDE) && !already_included) {
/* include can fail to parse peacefully,
* require and eval should die on failure
*/
bailed_out = 1;
}
PHP_RUNKIT_SANDBOX_PARENT_END(objval)
if (bailed_out) {
CG(unclean_shutdown) = 1;
CG(in_compilation) = EG(in_execution) = 0;
EG(current_execute_data) = NULL;
PHP_RUNKIT_SANDBOX_PARENT_BEGIN(objval)
zend_bailout();
PHP_RUNKIT_SANDBOX_PARENT_END(objval)
}
PHP_SANDBOX_CROSS_SCOPE_ZVAL_COPY_CTOR(return_value);
/* Don't confuse the memory manager */
if (retval) {
PHP_RUNKIT_SANDBOX_PARENT_BEGIN(objval)
zval_ptr_dtor(&retval);
PHP_RUNKIT_SANDBOX_PARENT_END(objval)
}
}
void
ngx_php_error_cb(int type,
const char *error_filename, const uint error_lineno, const char *format, va_list args)
{
TSRMLS_FETCH();
char *buffer;
int buffer_len, display;
buffer_len = vspprintf(&buffer, PG(log_errors_max_len), format, args);
/* check for repeated errors to be ignored */
if (PG(ignore_repeated_errors) && PG(last_error_message)) {
/* no check for PG(last_error_file) is needed since it cannot
* be NULL if PG(last_error_message) is not NULL */
if (strcmp(PG(last_error_message), buffer)
|| (!PG(ignore_repeated_source)
&& ((PG(last_error_lineno) != (int)error_lineno)
|| strcmp(PG(last_error_file), error_filename)))) {
display = 1;
} else {
display = 0;
}
} else {
display = 1;
}
/* store the error if it has changed */
if (display) {
if (PG(last_error_message)) {
free(PG(last_error_message));
PG(last_error_message) = NULL;
}
if (PG(last_error_file)) {
free(PG(last_error_file));
PG(last_error_file) = NULL;
}
if (!error_filename) {
error_filename = "Unknown";
}
PG(last_error_type) = type;
PG(last_error_message) = strdup(buffer);
PG(last_error_file) = strdup(error_filename);
PG(last_error_lineno) = error_lineno;
}
/* according to error handling mode, suppress error, throw exception or show it */
if (EG(error_handling) != EH_NORMAL) {
switch (type) {
case E_ERROR:
case E_CORE_ERROR:
case E_COMPILE_ERROR:
case E_USER_ERROR:
case E_PARSE:
/* fatal errors are real errors and cannot be made exceptions */
break;
case E_STRICT:
case E_DEPRECATED:
case E_USER_DEPRECATED:
/* for the sake of BC to old damaged code */
break;
case E_NOTICE:
case E_USER_NOTICE:
/* notices are no errors and are not treated as such like E_WARNINGS */
break;
default:
/* throw an exception if we are in EH_THROW mode
* but DO NOT overwrite a pending exception
*/
if (EG(error_handling) == EH_THROW && !EG(exception)) {
zend_throw_error_exception(EG(exception_class), buffer, 0, type TSRMLS_CC);
}
efree(buffer);
return;
}
}
/* display/log the error if necessary */
if (display && (EG(error_reporting) & type || (type & E_CORE))
&& (PG(log_errors) || PG(display_errors) ) ) {
char *error_type_str;
switch (type) {
case E_ERROR:
case E_CORE_ERROR:
case E_COMPILE_ERROR:
case E_USER_ERROR:
error_type_str = "Fatal error";
break;
case E_RECOVERABLE_ERROR:
error_type_str = "Catchable fatal error";
break;
case E_WARNING:
case E_CORE_WARNING:
case E_COMPILE_WARNING:
case E_USER_WARNING:
error_type_str = "Warning";
break;
case E_PARSE:
error_type_str = "Parse error";
break;
case E_NOTICE:
case E_USER_NOTICE:
error_type_str = "Notice";
break;
case E_STRICT:
error_type_str = "Strict Standards";
break;
case E_DEPRECATED:
case E_USER_DEPRECATED:
error_type_str = "Deprecated";
break;
default:
error_type_str = "Unknown error";
break;
}
buffer_len = spprintf(&buffer, 0, "%s: %s in %s on line %d", error_type_str, buffer, error_filename, error_lineno);
ngx_buf_t *b;
ngx_http_php_rputs_chain_list_t *chain;
ngx_http_php_ctx_t *ctx;
ngx_http_request_t *r;
u_char *u_str;
ngx_str_t ns;
r = ngx_php_request;
ctx = ngx_http_get_module_ctx(r, ngx_http_php_module);
if ( ctx == NULL ) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "%s", buffer);
ngx_php_debug("ngx_php error handler, ctx is nil.");
efree(buffer);
zend_bailout();
ngx_http_php_zend_uthread_exit(r);
return ;
}
ns.data = (u_char *)buffer;
ns.len = buffer_len;
if (ctx->rputs_chain == NULL){
chain = ngx_pcalloc(r->pool, sizeof(ngx_http_php_rputs_chain_list_t));
chain->out = ngx_alloc_chain_link(r->pool);
chain->last = &chain->out;
}else {
chain = ctx->rputs_chain;
(*chain->last)->next = ngx_alloc_chain_link(r->pool);
chain->last = &(*chain->last)->next;
}
b = ngx_calloc_buf(r->pool);
(*chain->last)->buf = b;
(*chain->last)->next = NULL;
u_str = ngx_pstrdup(r->pool, &ns);
//u_str[ns.len] = '\0';
(*chain->last)->buf->pos = u_str;
(*chain->last)->buf->last = u_str + ns.len;
(*chain->last)->buf->memory = 1;
ctx->rputs_chain = chain;
ngx_http_set_ctx(r, ctx, ngx_http_php_module);
if (r->headers_out.content_length_n == -1){
r->headers_out.content_length_n += ns.len + 1;
}else {
r->headers_out.content_length_n += ns.len;
}
if (!r->headers_out.status) {
r->headers_out.status = NGX_HTTP_INTERNAL_SERVER_ERROR;
}
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "%s", buffer);
ngx_php_debug("ngx_php error handler.");
efree(buffer);
zend_bailout();
ngx_http_php_zend_uthread_exit(r);
return ;
}
/* Log if necessary */
if (!display) {
efree(buffer);
return;
}
efree(buffer);
}
