Back to index

php5  5.3.10
Defines | Functions | Variables
main.c File Reference
#include "php.h"
#include <stdio.h>
#include <fcntl.h>
#include "zend.h"
#include "zend_extensions.h"
#include "php_ini.h"
#include "php_globals.h"
#include "php_main.h"
#include "fopen_wrappers.h"
#include "ext/standard/php_standard.h"
#include "ext/standard/php_string.h"
#include "ext/date/php_date.h"
#include "php_variables.h"
#include "ext/standard/credits.h"
#include "php_syslog.h"
#include "Zend/zend_exceptions.h"
#include "zend_compile.h"
#include "zend_execute.h"
#include "zend_highlight.h"
#include "zend_indent.h"
#include "zend_ini.h"
#include "php_content_types.h"
#include "php_ticks.h"
#include "php_logos.h"
#include "php_streams.h"
#include "php_open_temporary_file.h"
#include "SAPI.h"
#include "rfc1867.h"

Go to the source code of this file.

Defines

#define ZEND_INCLUDE_FULL_WINDOWS_HEADERS
#define SAFE_FILENAME(f)   ((f)?(f):"-")
#define PHP_SAFE_MODE_EXEC_DIR   ""
#define DEFAULT_SENDMAIL_PATH   "/usr/sbin/sendmail -t -i"
#define OLD_CWD_SIZE   4096
#define OLD_CWD_SIZE   4096

Functions

static PHP_INI_MH (OnSetPrecision)
static PHP_INI_MH (OnChangeMemoryLimit)
static void php_disable_functions (TSRMLS_D)
static void php_disable_classes (TSRMLS_D)
static PHP_INI_MH (OnUpdateTimeout)
static int php_get_display_errors_mode (char *value, int value_length)
static PHP_INI_MH (OnUpdateDisplayErrors)
static PHP_INI_DISP (display_errors_mode)
static PHP_INI_MH (OnUpdateErrorLog)
static PHP_INI_MH (OnUpdateMailLog)
static PHP_INI_MH (OnChangeMailForceExtra)
 PHP_INI_MH (OnChangeBrowscap)
static int php_during_module_startup (void)
static int php_during_module_shutdown (void)
PHPAPI void php_log_err (char *log_message TSRMLS_DC)
PHPAPI int php_write (void *buf, uint size TSRMLS_DC)
PHPAPI int php_printf (const char *format,...)
PHPAPI void php_verror (const char *docref, const char *params, int type, const char *format, va_list args TSRMLS_DC)
PHPAPI void php_error_docref0 (const char *docref TSRMLS_DC, int type, const char *format,...)
PHPAPI void php_error_docref1 (const char *docref TSRMLS_DC, const char *param1, int type, const char *format,...)
PHPAPI void php_error_docref2 (const char *docref TSRMLS_DC, const char *param1, const char *param2, int type, const char *format,...)
PHPAPI void php_html_puts (const char *str, uint size TSRMLS_DC)
static void php_error_cb (int type, const char *error_filename, const uint error_lineno, const char *format, va_list args)
 PHP_FUNCTION (set_time_limit)
static FILE * php_fopen_wrapper_for_zend (const char *filename, char **opened_path TSRMLS_DC)
static void php_zend_stream_closer (void *handle TSRMLS_DC)
static void php_zend_stream_mmap_closer (void *handle TSRMLS_DC)
static size_t php_zend_stream_fsizer (void *handle TSRMLS_DC)
static int php_stream_open_for_zend (const char *filename, zend_file_handle *handle TSRMLS_DC)
PHPAPI int php_stream_open_for_zend_ex (const char *filename, zend_file_handle *handle, int mode TSRMLS_DC)
static char * php_resolve_path_for_zend (const char *filename, int filename_len TSRMLS_DC)
static int php_get_configuration_directive_for_zend (const char *name, uint name_length, zval *contents)
static void php_message_handler_for_zend (long message, void *data TSRMLS_DC)
void php_on_timeout (int seconds TSRMLS_DC)
static int php_start_sapi (TSRMLS_D)
int php_request_startup (TSRMLS_D)
int php_request_startup_for_hook (TSRMLS_D)
void php_request_shutdown_for_exec (void *dummy)
void php_request_shutdown_for_hook (void *dummy)
void php_request_shutdown (void *dummy)
PHPAPI void php_com_initialize (TSRMLS_D)
static int php_body_write_wrapper (const char *str, uint str_length)
static void core_globals_dtor (php_core_globals *core_globals TSRMLS_DC)
 PHP_MINFO_FUNCTION (php_core)
int php_register_extensions (zend_module_entry **ptr, int count TSRMLS_DC)
int php_module_startup (sapi_module_struct *sf, zend_module_entry *additional_modules, uint num_additional_modules)
void php_module_shutdown_for_exec (void)
int php_module_shutdown_wrapper (sapi_module_struct *sapi_globals)
void php_module_shutdown (TSRMLS_D)
PHPAPI int php_execute_script (zend_file_handle *primary_file TSRMLS_DC)
PHPAPI int php_execute_simple_script (zend_file_handle *primary_file, zval **ret TSRMLS_DC)
PHPAPI void php_handle_aborted_connection (void)
PHPAPI int php_handle_auth_data (const char *auth TSRMLS_DC)
PHPAPI int php_lint_script (zend_file_handle *file TSRMLS_DC)

Variables

PHPAPI int(* php_register_internal_extensions_func )(TSRMLS_D) = php_register_internal_extensions
php_core_globals core_globals
static int module_initialized = 0
static int module_startup = 1
static int module_shutdown = 0

Define Documentation

#define DEFAULT_SENDMAIL_PATH   "/usr/sbin/sendmail -t -i"

Definition at line 438 of file main.c.

#define OLD_CWD_SIZE   4096
#define OLD_CWD_SIZE   4096
#define PHP_SAFE_MODE_EXEC_DIR   ""

Definition at line 429 of file main.c.

#define SAFE_FILENAME (   f)    ((f)?(f):"-")

Definition at line 153 of file main.c.

Definition at line 26 of file main.c.


Function Documentation

static void core_globals_dtor ( php_core_globals *core_globals  TSRMLS_DC) [static]

Definition at line 1734 of file main.c.

{
       if (core_globals->last_error_message) {
              free(core_globals->last_error_message);
       }
       if (core_globals->last_error_file) {
              free(core_globals->last_error_file);
       }
       if (core_globals->disable_functions) {
              free(core_globals->disable_functions);
       }
       if (core_globals->disable_classes) {
              free(core_globals->disable_classes);
       }

       php_shutdown_ticks(TSRMLS_C);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int php_body_write_wrapper ( const char *  str,
uint  str_length 
) [static]

Definition at line 1713 of file main.c.

{
       TSRMLS_FETCH();
       return php_body_write(str, str_length TSRMLS_CC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1699 of file main.c.

{
#ifdef PHP_WIN32
       if (!PG(com_initialized)) {
              if (CoInitialize(NULL) == S_OK) {
                     PG(com_initialized) = 1;
              }
       }
#endif
}

Here is the caller graph for this function:

static void php_disable_classes ( TSRMLS_D  ) [static]

Definition at line 223 of file main.c.

{
       char *s = NULL, *e;

       if (!*(INI_STR("disable_classes"))) {
              return;
       }

       e = PG(disable_classes) = strdup(INI_STR("disable_classes"));

       while (*e) {
              switch (*e) {
                     case ' ':
                     case ',':
                            if (s) {
                                   *e = '\0';
                                   zend_disable_class(s, e-s TSRMLS_CC);
                                   s = NULL;
                            }
                            break;
                     default:
                            if (!s) {
                                   s = e;
                            }
                            break;
              }
              e++;
       }
       if (s) {
              zend_disable_class(s, e-s TSRMLS_CC);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void php_disable_functions ( TSRMLS_D  ) [static]

Definition at line 185 of file main.c.

{
       char *s = NULL, *e;

       if (!*(INI_STR("disable_functions"))) {
              return;
       }

       e = PG(disable_functions) = strdup(INI_STR("disable_functions"));
       if (e == NULL) {
              return;
       }
       while (*e) {
              switch (*e) {
                     case ' ':
                     case ',':
                            if (s) {
                                   *e = '\0';
                                   zend_disable_function(s, e-s TSRMLS_CC);
                                   s = NULL;
                            }
                            break;
                     default:
                            if (!s) {
                                   s = e;
                            }
                            break;
              }
              e++;
       }
       if (s) {
              zend_disable_function(s, e-s TSRMLS_CC);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int php_during_module_shutdown ( void  ) [static]

Definition at line 568 of file main.c.

{
       return module_shutdown;
}

Here is the caller graph for this function:

static int php_during_module_startup ( void  ) [static]

Definition at line 561 of file main.c.

{
       return module_startup;
}

Here is the caller graph for this function:

static void php_error_cb ( int  type,
const char *  error_filename,
const uint  error_lineno,
const char *  format,
va_list  args 
) [static]

Definition at line 901 of file main.c.

{
       char *buffer;
       int buffer_len, display;
       TSRMLS_FETCH();

       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) || (!module_initialized))) {
              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;
              }

              if (!module_initialized || PG(log_errors)) {
                     char *log_buffer;
#ifdef PHP_WIN32
                     if ((type == E_CORE_ERROR || type == E_CORE_WARNING) && PG(display_startup_errors)) {
                            MessageBox(NULL, buffer, error_type_str, MB_OK|ZEND_SERVICE_MB_STYLE);
                     }
#endif
                     spprintf(&log_buffer, 0, "PHP %s:  %s in %s on line %d", error_type_str, buffer, error_filename, error_lineno);
                     php_log_err(log_buffer TSRMLS_CC);
                     efree(log_buffer);
              }

              if (PG(display_errors)
                     && ((module_initialized && !PG(during_request_startup))
                            || (PG(display_startup_errors) 
                                   && (OG(php_body_write)==php_default_output_func || OG(php_body_write)==php_ub_body_write_no_header || OG(php_body_write)==php_ub_body_write)
                                   )
                            )
                     ) {

                     if (PG(xmlrpc_errors)) {
                            php_printf("<?xml version=\"1.0\"?><methodResponse><fault><value><struct><member><name>faultCode</name><value><int>%ld</int></value></member><member><name>faultString</name><value><string>%s:%s in %s on line %d</string></value></member></struct></value></fault></methodResponse>", PG(xmlrpc_error_number), error_type_str, buffer, error_filename, error_lineno);
                     } else {
                            char *prepend_string = INI_STR("error_prepend_string");
                            char *append_string = INI_STR("error_append_string");

                            if (PG(html_errors)) {
                                   if (type == E_ERROR) {
                                          int len;
                                          char *buf = php_escape_html_entities(buffer, buffer_len, &len, 0, ENT_COMPAT, NULL TSRMLS_CC);
                                          php_printf("%s<br />\n<b>%s</b>:  %s in <b>%s</b> on line <b>%d</b><br />\n%s", STR_PRINT(prepend_string), error_type_str, buf, error_filename, error_lineno, STR_PRINT(append_string));
                                          efree(buf);
                                   } else {
                                          php_printf("%s<br />\n<b>%s</b>:  %s in <b>%s</b> on line <b>%d</b><br />\n%s", STR_PRINT(prepend_string), error_type_str, buffer, error_filename, error_lineno, STR_PRINT(append_string));
                                   }
                            } else {
                                   /* Write CLI/CGI errors to stderr if display_errors = "stderr" */
                                   if ((!strcmp(sapi_module.name, "cli") || !strcmp(sapi_module.name, "cgi")) &&
                                          PG(display_errors) == PHP_DISPLAY_ERRORS_STDERR
                                   ) {
#ifdef PHP_WIN32
                                          fprintf(stderr, "%s: %s in %s on line%d\n", error_type_str, buffer, error_filename, error_lineno);
                                          fflush(stderr);
#else
                                          fprintf(stderr, "%s: %s in %s on line %d\n", error_type_str, buffer, error_filename, error_lineno);
#endif
                                   } else {
                                          php_printf("%s\n%s: %s in %s on line %d\n%s", STR_PRINT(prepend_string), error_type_str, buffer, error_filename, error_lineno, STR_PRINT(append_string));
                                   }
                            }
                     }
              }
#if ZEND_DEBUG
              if (PG(report_zend_debug)) {
                     zend_bool trigger_break;

                     switch (type) {
                            case E_ERROR:
                            case E_CORE_ERROR:
                            case E_COMPILE_ERROR:
                            case E_USER_ERROR:
                                   trigger_break=1;
                                   break;
                            default:
                                   trigger_break=0;
                                   break;
                     }
                     zend_output_debug_string(trigger_break, "%s(%d) : %s - %s", error_filename, error_lineno, error_type_str, buffer);
              }
#endif
       }

       /* Bail out if we can't recover */
       switch (type) {
              case E_CORE_ERROR:
                     if(!module_initialized) {
                            /* bad error in module startup - no way we can live with this */
                            exit(-2);
                     }
              /* no break - intentionally */
              case E_ERROR:
              case E_RECOVERABLE_ERROR:
              case E_PARSE:
              case E_COMPILE_ERROR:
              case E_USER_ERROR:
                     EG(exit_status) = 255;
                     if (module_initialized) {
                            if (!PG(display_errors) &&
                                !SG(headers_sent) &&
                                   SG(sapi_headers).http_response_code == 200
                            ) {
                                   sapi_header_line ctr = {0};

                                   ctr.line = "HTTP/1.0 500 Internal Server Error";
                                   ctr.line_len = strlen(ctr.line);
                                   sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
                            }
                            /* the parser would return 1 (failure), we can bail out nicely */
                            if (type != E_PARSE) {
                                   /* restore memory limit */
                                   zend_set_memory_limit(PG(memory_limit));
                                   efree(buffer);
                                   zend_objects_store_mark_destructed(&EG(objects_store) TSRMLS_CC);
                                   zend_bailout();
                                   return;
                            }
                     }
                     break;
       }

       /* Log if necessary */
       if (!display) {
              efree(buffer);
              return;
       }

       if (PG(track_errors) && module_initialized) {
              if (!EG(active_symbol_table)) {
                     zend_rebuild_symbol_table(TSRMLS_C);
              }
              if (EG(active_symbol_table)) {
                     zval *tmp;
                     ALLOC_INIT_ZVAL(tmp);
                     ZVAL_STRINGL(tmp, buffer, buffer_len, 1);
                     zend_hash_update(EG(active_symbol_table), "php_errormsg", sizeof("php_errormsg"), (void **) & tmp, sizeof(zval *), NULL);
              }
       }

       efree(buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI void php_error_docref0 ( const char *docref  TSRMLS_DC,
int  type,
const char *  format,
  ... 
)

Definition at line 832 of file main.c.

{
       va_list args;

       va_start(args, format);
       php_verror(docref, "", type, format, args TSRMLS_CC);
       va_end(args);
}

Here is the call graph for this function:

PHPAPI void php_error_docref1 ( const char *docref  TSRMLS_DC,
const char *  param1,
int  type,
const char *  format,
  ... 
)

Definition at line 844 of file main.c.

{
       va_list args;

       va_start(args, format);
       php_verror(docref, param1, type, format, args TSRMLS_CC);
       va_end(args);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI void php_error_docref2 ( const char *docref  TSRMLS_DC,
const char *  param1,
const char *  param2,
int  type,
const char *  format,
  ... 
)

Definition at line 856 of file main.c.

{
       char *params;
       va_list args;

       spprintf(&params, 0, "%s,%s", param1, param2);
       va_start(args, format);
       php_verror(docref, params ? params : "...", type, format, args TSRMLS_CC);
       va_end(args);
       if (params) {
              efree(params);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int php_execute_script ( zend_file_handle *primary_file  TSRMLS_DC)

Definition at line 2221 of file main.c.

{
       zend_file_handle *prepend_file_p, *append_file_p;
       zend_file_handle prepend_file = {0}, append_file = {0};
#if HAVE_BROKEN_GETCWD 
       int old_cwd_fd = -1;
#else
       char *old_cwd;
       ALLOCA_FLAG(use_heap)
#endif
       int retval = 0;

       EG(exit_status) = 0;
       if (php_handle_special_queries(TSRMLS_C)) {
              zend_file_handle_dtor(primary_file TSRMLS_CC);
              return 0;
       }
#ifndef HAVE_BROKEN_GETCWD
# define OLD_CWD_SIZE 4096
       old_cwd = do_alloca(OLD_CWD_SIZE, use_heap);
       old_cwd[0] = '\0';
#endif

       zend_try {
              char realfile[MAXPATHLEN];

#ifdef PHP_WIN32
              if(primary_file->filename) {
                     UpdateIniFromRegistry(primary_file->filename TSRMLS_CC);
              }
#endif

              PG(during_request_startup) = 0;

              if (primary_file->filename && !(SG(options) & SAPI_OPTION_NO_CHDIR)) {
#if HAVE_BROKEN_GETCWD
                     /* this looks nasty to me */
                     old_cwd_fd = open(".", 0);
#else
                     VCWD_GETCWD(old_cwd, OLD_CWD_SIZE-1);
#endif
                     VCWD_CHDIR_FILE(primary_file->filename);
              }

              /* Only lookup the real file path and add it to the included_files list if already opened
               *   otherwise it will get opened and added to the included_files list in zend_execute_scripts
               */
              if (primary_file->filename &&
                  (primary_file->filename[0] != '-' || primary_file->filename[1] != 0) &&
                     primary_file->opened_path == NULL &&
                     primary_file->type != ZEND_HANDLE_FILENAME
              ) {
                     int realfile_len;
                     int dummy = 1;

                     if (expand_filepath(primary_file->filename, realfile TSRMLS_CC)) {
                            realfile_len =  strlen(realfile);
                            zend_hash_add(&EG(included_files), realfile, realfile_len+1, (void *)&dummy, sizeof(int), NULL);
                            primary_file->opened_path = estrndup(realfile, realfile_len);
                     }
              }

              if (PG(auto_prepend_file) && PG(auto_prepend_file)[0]) {
                     prepend_file.filename = PG(auto_prepend_file);
                     prepend_file.opened_path = NULL;
                     prepend_file.free_filename = 0;
                     prepend_file.type = ZEND_HANDLE_FILENAME;
                     prepend_file_p = &prepend_file;
              } else {
                     prepend_file_p = NULL;
              }

              if (PG(auto_append_file) && PG(auto_append_file)[0]) {
                     append_file.filename = PG(auto_append_file);
                     append_file.opened_path = NULL;
                     append_file.free_filename = 0;
                     append_file.type = ZEND_HANDLE_FILENAME;
                     append_file_p = &append_file;
              } else {
                     append_file_p = NULL;
              }
              if (PG(max_input_time) != -1) {
#ifdef PHP_WIN32
                     zend_unset_timeout(TSRMLS_C);
#endif
                     zend_set_timeout(INI_INT("max_execution_time"), 0);
              }
              retval = (zend_execute_scripts(ZEND_REQUIRE TSRMLS_CC, NULL, 3, prepend_file_p, primary_file, append_file_p) == SUCCESS);

       } zend_end_try();

#if HAVE_BROKEN_GETCWD
       if (old_cwd_fd != -1) {
              fchdir(old_cwd_fd);
              close(old_cwd_fd);
       }
#else
       if (old_cwd[0] != '\0') {
              VCWD_CHDIR(old_cwd);
       }
       free_alloca(old_cwd, use_heap);
#endif
       return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int php_execute_simple_script ( zend_file_handle primary_file,
zval **ret  TSRMLS_DC 
)

Definition at line 2329 of file main.c.

{
       char *old_cwd;
       ALLOCA_FLAG(use_heap)

       EG(exit_status) = 0;
#define OLD_CWD_SIZE 4096
       old_cwd = do_alloca(OLD_CWD_SIZE, use_heap);
       old_cwd[0] = '\0';

       zend_try {
#ifdef PHP_WIN32
              if(primary_file->filename) {
                     UpdateIniFromRegistry(primary_file->filename TSRMLS_CC);
              }
#endif

              PG(during_request_startup) = 0;

              if (primary_file->filename && !(SG(options) & SAPI_OPTION_NO_CHDIR)) {
                     VCWD_GETCWD(old_cwd, OLD_CWD_SIZE-1);
                     VCWD_CHDIR_FILE(primary_file->filename);
              }
              zend_execute_scripts(ZEND_REQUIRE TSRMLS_CC, ret, 1, primary_file);
       } zend_end_try();

       if (old_cwd[0] != '\0') {
              VCWD_CHDIR(old_cwd);
       }

       free_alloca(old_cwd, use_heap);
       return EG(exit_status);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static FILE* php_fopen_wrapper_for_zend ( const char *  filename,
char **opened_path  TSRMLS_DC 
) [static]

Definition at line 1177 of file main.c.

Here is the caller graph for this function:

PHP_FUNCTION ( set_time_limit  )

Definition at line 1149 of file main.c.

{
       long new_timeout;
       char *new_timeout_str;
       int new_timeout_strlen;

       if (PG(safe_mode)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot set time limit in safe mode");
              RETURN_FALSE;
       }

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &new_timeout) == FAILURE) {
              return;
       }
       
       new_timeout_strlen = zend_spprintf(&new_timeout_str, 0, "%ld", new_timeout);

       if (zend_alter_ini_entry_ex("max_execution_time", sizeof("max_execution_time"), new_timeout_str, new_timeout_strlen, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC) == SUCCESS) {
              RETVAL_TRUE;
       } else {
              RETVAL_FALSE;
       }
       efree(new_timeout_str);
}

Here is the call graph for this function:

static int php_get_configuration_directive_for_zend ( const char *  name,
uint  name_length,
zval *  contents 
) [static]

Definition at line 1263 of file main.c.

{
       zval *retval = cfg_get_entry(name, name_length);

       if (retval) {
              *contents = *retval;
              return SUCCESS;
       } else {
              return FAILURE;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int php_get_display_errors_mode ( char *  value,
int  value_length 
) [static]

Definition at line 275 of file main.c.

{
       int mode;

       if (!value) {
              return PHP_DISPLAY_ERRORS_STDOUT;
       }

       if (value_length == 2 && !strcasecmp("on", value)) {
              mode = PHP_DISPLAY_ERRORS_STDOUT;
       } else if (value_length == 3 && !strcasecmp("yes", value)) {
              mode = PHP_DISPLAY_ERRORS_STDOUT;
       } else if (value_length == 4 && !strcasecmp("true", value)) {
              mode = PHP_DISPLAY_ERRORS_STDOUT;
       } else if (value_length == 6 && !strcasecmp(value, "stderr")) {
              mode = PHP_DISPLAY_ERRORS_STDERR;
       } else if (value_length == 6 && !strcasecmp(value, "stdout")) {
              mode = PHP_DISPLAY_ERRORS_STDOUT;
       } else {
              mode = atoi(value);
              if (mode && mode != PHP_DISPLAY_ERRORS_STDOUT && mode != PHP_DISPLAY_ERRORS_STDERR) {
                     mode = PHP_DISPLAY_ERRORS_STDOUT;
              }
       }

       return mode;
}

Here is the caller graph for this function:

Definition at line 2366 of file main.c.

{
       TSRMLS_FETCH();

       PG(connection_status) = PHP_CONNECTION_ABORTED;
       php_output_set_status(0 TSRMLS_CC);

       if (!PG(ignore_user_abort)) {
              zend_bailout();
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int php_handle_auth_data ( const char *auth  TSRMLS_DC)

Definition at line 2381 of file main.c.

{
       int ret = -1;

       if (auth && auth[0] != '\0' && strncmp(auth, "Basic ", 6) == 0) {
              char *pass;
              char *user;

              user = php_base64_decode(auth + 6, strlen(auth) - 6, NULL);
              if (user) {
                     pass = strchr(user, ':');
                     if (pass) {
                            *pass++ = '\0';
                            SG(request_info).auth_user = user;
                            SG(request_info).auth_password = estrdup(pass);
                            ret = 0;
                     } else {
                            efree(user);
                     }
              }
       }

       if (ret == -1) {
              SG(request_info).auth_user = SG(request_info).auth_password = NULL;
       } else {
              SG(request_info).auth_digest = NULL;
       }

       if (ret == -1 && auth && auth[0] != '\0' && strncmp(auth, "Digest ", 7) == 0) {
              SG(request_info).auth_digest = estrdup(auth + 7);
              ret = 0;
       }

       if (ret == -1) {
              SG(request_info).auth_digest = NULL;
       }

       return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI void php_html_puts ( const char *  str,
uint size  TSRMLS_DC 
)

Definition at line 893 of file main.c.

{
       zend_html_puts(str, size TSRMLS_CC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PHP_INI_DISP ( display_errors_mode  ) [static]

Definition at line 316 of file main.c.

{
       int mode, tmp_value_length, cgi_or_cli;
       char *tmp_value;
       TSRMLS_FETCH();

       if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
              tmp_value = (ini_entry->orig_value ? ini_entry->orig_value : NULL );
              tmp_value_length = ini_entry->orig_value_length;
       } else if (ini_entry->value) {
              tmp_value = ini_entry->value;
              tmp_value_length = ini_entry->value_length;
       } else {
              tmp_value = NULL;
              tmp_value_length = 0;
       }

       mode = php_get_display_errors_mode(tmp_value, tmp_value_length);

       /* Display 'On' for other SAPIs instead of STDOUT or STDERR */
       cgi_or_cli = (!strcmp(sapi_module.name, "cli") || !strcmp(sapi_module.name, "cgi"));

       switch (mode) {
              case PHP_DISPLAY_ERRORS_STDERR:
                     if (cgi_or_cli ) {
                            PUTS("STDERR");
                     } else {
                            PUTS("On");
                     }
                     break;

              case PHP_DISPLAY_ERRORS_STDOUT:
                     if (cgi_or_cli ) {
                            PUTS("STDOUT");
                     } else {
                            PUTS("On");
                     }
                     break;

              default:
                     PUTS("Off");
                     break;
       }
}

Here is the call graph for this function:

static PHP_INI_MH ( OnSetPrecision  ) [static]

Definition at line 157 of file main.c.

{
       int i = atoi(new_value);
       if (i >= 0) {
              EG(precision) = i;
              return SUCCESS;
       } else {
              return FAILURE;
       }
}
static PHP_INI_MH ( OnChangeMemoryLimit  ) [static]

Definition at line 171 of file main.c.

{
       if (new_value) {
              PG(memory_limit) = zend_atol(new_value, new_value_length);
       } else {
              PG(memory_limit) = 1<<30;          /* effectively, no limit */
       }
       return zend_set_memory_limit(PG(memory_limit));
}

Here is the call graph for this function:

static PHP_INI_MH ( OnUpdateTimeout  ) [static]

Definition at line 259 of file main.c.

{
       if (stage==PHP_INI_STAGE_STARTUP) {
              /* Don't set a timeout on startup, only per-request */
              EG(timeout_seconds) = atoi(new_value);
              return SUCCESS;
       }
       zend_unset_timeout(TSRMLS_C);
       EG(timeout_seconds) = atoi(new_value);
       zend_set_timeout(EG(timeout_seconds), 0);
       return SUCCESS;
}

Here is the call graph for this function:

static PHP_INI_MH ( OnUpdateDisplayErrors  ) [static]

Definition at line 306 of file main.c.

{
       PG(display_errors) = (zend_bool) php_get_display_errors_mode(new_value, new_value_length);

       return SUCCESS;
}

Here is the call graph for this function:

static PHP_INI_MH ( OnUpdateErrorLog  ) [static]

Definition at line 364 of file main.c.

{
       /* Only do the safemode/open_basedir check at runtime */
       if ((stage == PHP_INI_STAGE_RUNTIME || stage == PHP_INI_STAGE_HTACCESS) && new_value && strcmp(new_value, "syslog")) {
              if (PG(safe_mode) && (!php_checkuid(new_value, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
                     return FAILURE;
              }

              if (PG(open_basedir) && php_check_open_basedir(new_value TSRMLS_CC)) {
                     return FAILURE;
              }

       }
       OnUpdateString(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
       return SUCCESS;
}

Here is the call graph for this function:

static PHP_INI_MH ( OnUpdateMailLog  ) [static]

Definition at line 384 of file main.c.

{
       /* Only do the safemode/open_basedir check at runtime */
       if ((stage == PHP_INI_STAGE_RUNTIME || stage == PHP_INI_STAGE_HTACCESS) && new_value) {
              if (PG(safe_mode) && (!php_checkuid(new_value, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
                     return FAILURE;
              }

              if (PG(open_basedir) && php_check_open_basedir(new_value TSRMLS_CC)) {
                     return FAILURE;
              }

       }
       OnUpdateString(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
       return SUCCESS;
}

Here is the call graph for this function:

static PHP_INI_MH ( OnChangeMailForceExtra  ) [static]

Definition at line 404 of file main.c.

{
       /* Don't allow changing it in htaccess */
       if (stage == PHP_INI_STAGE_HTACCESS) {
                     return FAILURE;
       }
       return SUCCESS;
}
PHP_INI_MH ( OnChangeBrowscap  )

Definition at line 313 of file browscap.c.

{
       if (stage == PHP_INI_STAGE_STARTUP) {
              /* value handled in browscap.c's MINIT */
              return SUCCESS;
       } else if (stage == PHP_INI_STAGE_ACTIVATE) {
              browser_data *bdata = &BROWSCAP_G(activation_bdata);
              if (bdata->filename[0] != '\0') {
                     browscap_bdata_dtor(bdata, 0 TSRMLS_CC);
              }
              if (VCWD_REALPATH(new_value, bdata->filename) == NULL) {
                     return FAILURE;
              }
              return SUCCESS;
       }
       
       return FAILURE;
}

Here is the call graph for this function:

Definition at line 2424 of file main.c.

{
       zend_op_array *op_array;
       int retval = FAILURE;

       zend_try {
              op_array = zend_compile_file(file, ZEND_INCLUDE TSRMLS_CC);
              zend_destroy_file_handle(file TSRMLS_CC);

              if (op_array) {
                     destroy_op_array(op_array TSRMLS_CC);
                     efree(op_array);
                     retval = SUCCESS;
              }
       } zend_end_try();

       return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI void php_log_err ( char *log_message  TSRMLS_DC)

Definition at line 576 of file main.c.

{
       int fd = -1;
       time_t error_time;

       if (PG(in_error_log)) {
              /* prevent recursive invocation */
              return;
       }
       PG(in_error_log) = 1;

       /* Try to use the specified logging location. */
       if (PG(error_log) != NULL) {
#ifdef HAVE_SYSLOG_H
              if (!strcmp(PG(error_log), "syslog")) {
                     php_syslog(LOG_NOTICE, "%s", log_message);
                     PG(in_error_log) = 0;
                     return;
              }
#endif
              fd = VCWD_OPEN_MODE(PG(error_log), O_CREAT | O_APPEND | O_WRONLY, 0644);
              if (fd != -1) {
                     char *tmp;
                     int len;
                     char *error_time_str;

                     time(&error_time);
                     error_time_str = php_format_date("d-M-Y H:i:s e", 13, error_time, 0 TSRMLS_CC);
                     len = spprintf(&tmp, 0, "[%s] %s%s", error_time_str, log_message, PHP_EOL);
#ifdef PHP_WIN32
                     php_flock(fd, 2);
#endif
                     write(fd, tmp, len);
                     efree(tmp);
                     efree(error_time_str);
                     close(fd);
                     PG(in_error_log) = 0;
                     return;
              }
       }

       /* Otherwise fall back to the default logging location, if we have one */

       if (sapi_module.log_message) {
              sapi_module.log_message(log_message);
       }
       PG(in_error_log) = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void php_message_handler_for_zend ( long  message,
void *data  TSRMLS_DC 
) [static]

Definition at line 1278 of file main.c.

{
       switch (message) {
              case ZMSG_FAILED_INCLUDE_FOPEN:
                     php_error_docref("function.include" TSRMLS_CC, E_WARNING, "Failed opening '%s' for inclusion (include_path='%s')", php_strip_url_passwd((char *) data), STR_PRINT(PG(include_path)));
                     break;
              case ZMSG_FAILED_REQUIRE_FOPEN:
                     php_error_docref("function.require" TSRMLS_CC, E_COMPILE_ERROR, "Failed opening required '%s' (include_path='%s')", php_strip_url_passwd((char *) data), STR_PRINT(PG(include_path)));
                     break;
              case ZMSG_FAILED_HIGHLIGHT_FOPEN:
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed opening '%s' for highlighting", php_strip_url_passwd((char *) data));
                     break;
              case ZMSG_MEMORY_LEAK_DETECTED:
              case ZMSG_MEMORY_LEAK_REPEATED:
#if ZEND_DEBUG
                     if (EG(error_reporting) & E_WARNING) {
                            char memory_leak_buf[1024];

                            if (message==ZMSG_MEMORY_LEAK_DETECTED) {
                                   zend_leak_info *t = (zend_leak_info *) data;

                                   snprintf(memory_leak_buf, 512, "%s(%d) :  Freeing 0x%.8lX (%zu bytes), script=%s\n", t->filename, t->lineno, (zend_uintptr_t)t->addr, t->size, SAFE_FILENAME(SG(request_info).path_translated));
                                   if (t->orig_filename) {
                                          char relay_buf[512];

                                          snprintf(relay_buf, 512, "%s(%d) : Actual location (location was relayed)\n", t->orig_filename, t->orig_lineno);
                                          strlcat(memory_leak_buf, relay_buf, sizeof(memory_leak_buf));
                                   }
                            } else {
                                   unsigned long leak_count = (zend_uintptr_t) data;

                                   snprintf(memory_leak_buf, 512, "Last leak repeated %ld time%s\n", leak_count, (leak_count>1?"s":""));
                            }
#      if defined(PHP_WIN32)
                            OutputDebugString(memory_leak_buf);
#      else
                            fprintf(stderr, "%s", memory_leak_buf);
#      endif
                     }
#endif
                     break;
              case ZMSG_MEMORY_LEAKS_GRAND_TOTAL:
#if ZEND_DEBUG
                     if (EG(error_reporting) & E_WARNING) {
                            char memory_leak_buf[512];

                            snprintf(memory_leak_buf, 512, "=== Total %d memory leaks detected ===\n", *((zend_uint *) data));
#      if defined(PHP_WIN32)
                            OutputDebugString(memory_leak_buf);
#      else
                            fprintf(stderr, "%s", memory_leak_buf);
#      endif
                     }
#endif
                     break;
              case ZMSG_LOG_SCRIPT_NAME: {
                            struct tm *ta, tmbuf;
                            time_t curtime;
                            char *datetime_str, asctimebuf[52];
                            char memory_leak_buf[4096];

                            time(&curtime);
                            ta = php_localtime_r(&curtime, &tmbuf);
                            datetime_str = php_asctime_r(ta, asctimebuf);
                            if (datetime_str) {
                                   datetime_str[strlen(datetime_str)-1]=0;   /* get rid of the trailing newline */
                                   snprintf(memory_leak_buf, sizeof(memory_leak_buf), "[%s]  Script:  '%s'\n", datetime_str, SAFE_FILENAME(SG(request_info).path_translated));
                            } else {
                                   snprintf(memory_leak_buf, sizeof(memory_leak_buf), "[null]  Script:  '%s'\n", SAFE_FILENAME(SG(request_info).path_translated));
                            }
#      if defined(PHP_WIN32)
                            OutputDebugString(memory_leak_buf);
#      else
                            fprintf(stderr, "%s", memory_leak_buf);
#      endif
                     }
                     break;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHP_MINFO_FUNCTION ( php_core  )

Definition at line 1753 of file main.c.

Here is the call graph for this function:

Definition at line 2161 of file main.c.

{
       int module_number=0; /* for UNREGISTER_INI_ENTRIES() */

       module_shutdown = 1;

       if (!module_initialized) {
              return;
       }

#ifdef ZTS
       ts_free_worker_threads();
#endif

#if defined(PHP_WIN32) || (defined(NETWARE) && defined(USE_WINSOCK))
       /*close winsock */
       WSACleanup();
#endif

#ifdef PHP_WIN32
       php_win32_free_rng_lock();
#endif

       sapi_flush(TSRMLS_C);

       zend_shutdown(TSRMLS_C);
       
       /* Destroys filter & transport registries too */
       php_shutdown_stream_wrappers(module_number TSRMLS_CC);

       php_shutdown_info_logos();
       UNREGISTER_INI_ENTRIES();

       /* close down the ini config */
       php_shutdown_config();

#ifndef ZTS
       zend_ini_shutdown(TSRMLS_C);
       shutdown_memory_manager(CG(unclean_shutdown), 1 TSRMLS_CC);
       core_globals_dtor(&core_globals TSRMLS_CC);
       gc_globals_dtor(TSRMLS_C);
#else
       zend_ini_global_shutdown(TSRMLS_C);
       ts_free_id(core_globals_id);
#endif

       php_shutdown_temporary_directory();

       module_initialized = 0;

#if defined(PHP_WIN32) && defined(_MSC_VER) && (_MSC_VER >= 1400)
       if (old_invalid_parameter_handler == NULL) {
              _set_invalid_parameter_handler(old_invalid_parameter_handler);
       }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2144 of file main.c.

{
       /* used to close fd's in the range 3.255 here, but it's problematic */
}

Here is the caller graph for this function:

int php_module_shutdown_wrapper ( sapi_module_struct *  sapi_globals)

Definition at line 2151 of file main.c.

Here is the call graph for this function:

int php_module_startup ( sapi_module_struct *  sf,
zend_module_entry *  additional_modules,
uint  num_additional_modules 
)

Definition at line 1815 of file main.c.

{
       zend_utility_functions zuf;
       zend_utility_values zuv;
       int module_number=0; /* for REGISTER_INI_ENTRIES() */
       char *php_os;
       zend_module_entry *module;
#ifdef ZTS
       zend_executor_globals *executor_globals;
       void ***tsrm_ls;
       php_core_globals *core_globals;
#endif
#if defined(PHP_WIN32) || (defined(NETWARE) && defined(USE_WINSOCK))
       WORD wVersionRequested = MAKEWORD(2, 0);
       WSADATA wsaData;
#endif
#ifdef PHP_WIN32
       DWORD dwVersion = GetVersion();
       /* Get build numbers for Windows NT or Win95 */
       if (dwVersion < 0x80000000){
              php_os="WINNT";
       } else {
              php_os="WIN32";
       }
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
       old_invalid_parameter_handler =
              _set_invalid_parameter_handler(dummy_invalid_parameter_handler);
       if (old_invalid_parameter_handler != NULL) {
              _set_invalid_parameter_handler(old_invalid_parameter_handler);
       }

       /* Disable the message box for assertions.*/
       _CrtSetReportMode(_CRT_ASSERT, 0);
#endif
#else
       php_os=PHP_OS;
#endif

#ifdef ZTS
       tsrm_ls = ts_resource(0);
#endif

#ifdef PHP_WIN32
       php_win32_init_rng_lock();
#endif

       module_shutdown = 0;
       module_startup = 1;
       sapi_initialize_empty_request(TSRMLS_C);
       sapi_activate(TSRMLS_C);

       if (module_initialized) {
              return SUCCESS;
       }

       sapi_module = *sf;

       php_output_startup();

       zuf.error_function = php_error_cb;
       zuf.printf_function = php_printf;
       zuf.write_function = php_body_write_wrapper;
       zuf.fopen_function = php_fopen_wrapper_for_zend;
       zuf.message_handler = php_message_handler_for_zend;
       zuf.block_interruptions = sapi_module.block_interruptions;
       zuf.unblock_interruptions = sapi_module.unblock_interruptions;
       zuf.get_configuration_directive = php_get_configuration_directive_for_zend;
       zuf.ticks_function = php_run_ticks;
       zuf.on_timeout = php_on_timeout;
       zuf.stream_open_function = php_stream_open_for_zend;
       zuf.vspprintf_function = vspprintf;
       zuf.getenv_function = sapi_getenv;
       zuf.resolve_path_function = php_resolve_path_for_zend;
       zend_startup(&zuf, NULL TSRMLS_CC);

#ifdef ZTS
       executor_globals = ts_resource(executor_globals_id);
       ts_allocate_id(&core_globals_id, sizeof(php_core_globals), (ts_allocate_ctor) core_globals_ctor, (ts_allocate_dtor) core_globals_dtor);
       core_globals = ts_resource(core_globals_id);
#ifdef PHP_WIN32
       ts_allocate_id(&php_win32_core_globals_id, sizeof(php_win32_core_globals), (ts_allocate_ctor) php_win32_core_globals_ctor, (ts_allocate_dtor) php_win32_core_globals_dtor);
#endif
#else
       php_startup_ticks(TSRMLS_C);
#endif
       gc_globals_ctor(TSRMLS_C);

#ifdef PHP_WIN32
       {
              OSVERSIONINFOEX *osvi = &EG(windows_version_info);

              ZeroMemory(osvi, sizeof(OSVERSIONINFOEX));
              osvi->dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
              if( !GetVersionEx((OSVERSIONINFO *) osvi)) {
                     php_printf("\nGetVersionEx unusable. %d\n", GetLastError());
                     return FAILURE;
              }
       }
#endif
       EG(bailout) = NULL;
       EG(error_reporting) = E_ALL & ~E_NOTICE;
       EG(active_symbol_table) = NULL;
       PG(header_is_being_sent) = 0;
       SG(request_info).headers_only = 0;
       SG(request_info).argv0 = NULL;
       SG(request_info).argc=0;
       SG(request_info).argv=(char **)NULL;
       PG(connection_status) = PHP_CONNECTION_NORMAL;
       PG(during_request_startup) = 0;
       PG(last_error_message) = NULL;
       PG(last_error_file) = NULL;
       PG(last_error_lineno) = 0;
       EG(error_handling)  = EH_NORMAL;
       EG(exception_class) = NULL;
       PG(disable_functions) = NULL;
       PG(disable_classes) = NULL;

#if HAVE_SETLOCALE
       setlocale(LC_CTYPE, "");
       zend_update_current_locale();
#endif

#if HAVE_TZSET
       tzset();
#endif

#if defined(PHP_WIN32) || (defined(NETWARE) && defined(USE_WINSOCK))
       /* start up winsock services */
       if (WSAStartup(wVersionRequested, &wsaData) != 0) {
              php_printf("\nwinsock.dll unusable. %d\n", WSAGetLastError());
              return FAILURE;
       }
#endif

       le_index_ptr = zend_register_list_destructors_ex(NULL, NULL, "index pointer", 0);

       /* Register constants */
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_VERSION", PHP_VERSION, sizeof(PHP_VERSION)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_MAJOR_VERSION", PHP_MAJOR_VERSION, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_MINOR_VERSION", PHP_MINOR_VERSION, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_RELEASE_VERSION", PHP_RELEASE_VERSION, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_EXTRA_VERSION", PHP_EXTRA_VERSION, sizeof(PHP_EXTRA_VERSION) - 1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_VERSION_ID", PHP_VERSION_ID, CONST_PERSISTENT | CONST_CS);
#ifdef ZTS
       REGISTER_MAIN_LONG_CONSTANT("PHP_ZTS", 1, CONST_PERSISTENT | CONST_CS);
#else
       REGISTER_MAIN_LONG_CONSTANT("PHP_ZTS", 0, CONST_PERSISTENT | CONST_CS);
#endif
       REGISTER_MAIN_LONG_CONSTANT("PHP_DEBUG", PHP_DEBUG, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_OS", php_os, strlen(php_os), CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_SAPI", sapi_module.name, strlen(sapi_module.name), CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("DEFAULT_INCLUDE_PATH", PHP_INCLUDE_PATH, sizeof(PHP_INCLUDE_PATH)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PEAR_INSTALL_DIR", PEAR_INSTALLDIR, sizeof(PEAR_INSTALLDIR)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PEAR_EXTENSION_DIR", PHP_EXTENSION_DIR, sizeof(PHP_EXTENSION_DIR)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_EXTENSION_DIR", PHP_EXTENSION_DIR, sizeof(PHP_EXTENSION_DIR)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_PREFIX", PHP_PREFIX, sizeof(PHP_PREFIX)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_BINDIR", PHP_BINDIR, sizeof(PHP_BINDIR)-1, CONST_PERSISTENT | CONST_CS);
#ifndef PHP_WIN32
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_MANDIR", PHP_MANDIR, sizeof(PHP_MANDIR)-1, CONST_PERSISTENT | CONST_CS);
#endif
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_LIBDIR", PHP_LIBDIR, sizeof(PHP_LIBDIR)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_DATADIR", PHP_DATADIR, sizeof(PHP_DATADIR)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_SYSCONFDIR", PHP_SYSCONFDIR, sizeof(PHP_SYSCONFDIR)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_LOCALSTATEDIR", PHP_LOCALSTATEDIR, sizeof(PHP_LOCALSTATEDIR)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_CONFIG_FILE_PATH", PHP_CONFIG_FILE_PATH, strlen(PHP_CONFIG_FILE_PATH), CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_CONFIG_FILE_SCAN_DIR", PHP_CONFIG_FILE_SCAN_DIR, sizeof(PHP_CONFIG_FILE_SCAN_DIR)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_SHLIB_SUFFIX", PHP_SHLIB_SUFFIX, sizeof(PHP_SHLIB_SUFFIX)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_STRINGL_CONSTANT("PHP_EOL", PHP_EOL, sizeof(PHP_EOL)-1, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_MAXPATHLEN", MAXPATHLEN, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_INT_MAX", LONG_MAX, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_INT_SIZE", sizeof(long), CONST_PERSISTENT | CONST_CS);
#ifdef ZEND_MULTIBYTE
       REGISTER_MAIN_LONG_CONSTANT("ZEND_MULTIBYTE", 1, CONST_PERSISTENT | CONST_CS);
#else
       REGISTER_MAIN_LONG_CONSTANT("ZEND_MULTIBYTE", 0, CONST_PERSISTENT | CONST_CS);
#endif

#ifdef PHP_WIN32
       REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_MAJOR",      EG(windows_version_info).dwMajorVersion, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_MINOR",      EG(windows_version_info).dwMinorVersion, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_BUILD",      EG(windows_version_info).dwBuildNumber, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_PLATFORM",   EG(windows_version_info).dwPlatformId, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_SP_MAJOR",   EG(windows_version_info).wServicePackMajor, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_SP_MINOR",   EG(windows_version_info).wServicePackMinor, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_SUITEMASK",  EG(windows_version_info).wSuiteMask, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_PRODUCTTYPE", EG(windows_version_info).wProductType, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_NT_DOMAIN_CONTROLLER", VER_NT_DOMAIN_CONTROLLER, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_NT_SERVER", VER_NT_SERVER, CONST_PERSISTENT | CONST_CS);
       REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_NT_WORKSTATION", VER_NT_WORKSTATION, CONST_PERSISTENT | CONST_CS);
#endif

       php_output_register_constants(TSRMLS_C);
       php_rfc1867_register_constants(TSRMLS_C);

       /* this will read in php.ini, set up the configuration parameters,
          load zend extensions and register php function extensions
          to be loaded later */
       if (php_init_config(TSRMLS_C) == FAILURE) {
              return FAILURE;
       }

       /* Register PHP core ini entries */
       REGISTER_INI_ENTRIES();

       /* Register Zend ini entries */
       zend_register_standard_ini_entries(TSRMLS_C);

       /* Disable realpath cache if safe_mode or open_basedir are set */
       if (PG(safe_mode) || (PG(open_basedir) && *PG(open_basedir))) {
              CWDG(realpath_cache_size_limit) = 0;
       }

       /* initialize stream wrappers registry
        * (this uses configuration parameters from php.ini)
        */
       if (php_init_stream_wrappers(module_number TSRMLS_CC) == FAILURE)     {
              php_printf("PHP:  Unable to initialize stream url wrappers.\n");
              return FAILURE;
       }

       /* initialize registry for images to be used in phpinfo() 
          (this uses configuration parameters from php.ini)
        */
       if (php_init_info_logos() == FAILURE) {
              php_printf("PHP:  Unable to initialize info phpinfo logos.\n");
              return FAILURE;
       }

       zuv.html_errors = 1;
       zuv.import_use_extension = ".php";
       php_startup_auto_globals(TSRMLS_C);
       zend_set_utility_values(&zuv);
       php_startup_sapi_content_types(TSRMLS_C);

       /* startup extensions staticly compiled in */
       if (php_register_internal_extensions_func(TSRMLS_C) == FAILURE) {
              php_printf("Unable to start builtin modules\n");
              return FAILURE;
       }

       /* start additional PHP extensions */
       php_register_extensions(&additional_modules, num_additional_modules TSRMLS_CC);

       /* load and startup extensions compiled as shared objects (aka DLLs)
          as requested by php.ini entries
          theese are loaded after initialization of internal extensions
          as extensions *might* rely on things from ext/standard
          which is always an internal extension and to be initialized
          ahead of all other internals
        */
       php_ini_register_extensions(TSRMLS_C);
       zend_startup_modules(TSRMLS_C);

       /* start Zend extensions */
       zend_startup_extensions();

       /* register additional functions */
       if (sapi_module.additional_functions) {
              if (zend_hash_find(&module_registry, "standard", sizeof("standard"), (void**)&module)==SUCCESS) {
                     EG(current_module) = module;
                     zend_register_functions(NULL, sapi_module.additional_functions, NULL, MODULE_PERSISTENT TSRMLS_CC);
                     EG(current_module) = NULL;
              }
       }
       
       /* disable certain classes and functions as requested by php.ini */
       php_disable_functions(TSRMLS_C);
       php_disable_classes(TSRMLS_C);

       /* make core report what it should */
       if (zend_hash_find(&module_registry, "core", sizeof("core"), (void**)&module)==SUCCESS) {
              module->version = PHP_VERSION;
              module->info_func = PHP_MINFO(php_core);
       }


#ifdef PHP_WIN32
       /* Disable incompatible functions for the running platform */
       if (php_win32_disable_functions() == FAILURE) {
              php_printf("Unable to disable unsupported functions\n");
              return FAILURE;
       }
#endif

#ifdef ZTS
       zend_post_startup(TSRMLS_C);
#endif

       module_initialized = 1;

       /* Check for deprecated directives */
       /* NOTE: If you add anything here, remember to add it also in Makefile.global! */
       {
              static const char *directives[] = {
                     "define_syslog_variables", 
                     "register_globals", 
                     "register_long_arrays", 
                     "safe_mode", 
                     "magic_quotes_gpc", 
                     "magic_quotes_runtime", 
                     "magic_quotes_sybase", 
                     NULL
              };
              const char **p = directives;
              long val;

              while (*p) {
                     if (cfg_get_long((char*)*p, &val) == SUCCESS && val) {
                            zend_error(E_DEPRECATED, "Directive '%s' is deprecated in PHP 5.3 and greater", *p);
                     }
                     ++p;
              }

              /* This is not too nice, but since its the only one theres no need for extra stuff here */
              if (cfg_get_long("zend.ze1_compatibility_mode", &val) == SUCCESS && val) {
                     zend_error(E_CORE_ERROR, "zend.ze1_compatibility_mode is no longer supported in PHP 5.3 and greater");
              }
       }
       
       sapi_deactivate(TSRMLS_C);
       module_startup = 0;

       shutdown_memory_manager(1, 0 TSRMLS_CC);

       /* we're done */
       return SUCCESS;
}

Here is the caller graph for this function:

void php_on_timeout ( int seconds  TSRMLS_DC)

Definition at line 1360 of file main.c.

{
       PG(connection_status) |= PHP_CONNECTION_TIMEOUT;
       zend_set_timeout(EG(timeout_seconds), 1);
       if(PG(exit_on_timeout)) sapi_terminate_process(TSRMLS_C);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int php_printf ( const char *  format,
  ... 
)

Definition at line 636 of file main.c.

{
       va_list args;
       int ret;
       char *buffer;
       int size;
       TSRMLS_FETCH();

       va_start(args, format);
       size = vspprintf(&buffer, 0, format, args);
       ret = PHPWRITE(buffer, size);
       efree(buffer);
       va_end(args);

       return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int php_register_extensions ( zend_module_entry **  ptr,
int count  TSRMLS_DC 
)

Definition at line 1763 of file main.c.

{
       zend_module_entry **end = ptr + count;

       while (ptr < end) {
              if (*ptr) {
                     if (zend_register_internal_module(*ptr TSRMLS_CC)==NULL) {
                            return FAILURE;
                     }
              }
              ptr++;
       }
       return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void php_request_shutdown ( void *  dummy)

Definition at line 1593 of file main.c.

{
       zend_bool report_memleaks;
       TSRMLS_FETCH();

       report_memleaks = PG(report_memleaks);

       /* EG(opline_ptr) points into nirvana and therefore cannot be safely accessed
        * inside zend_executor callback functions.
        */
       EG(opline_ptr) = NULL;
       EG(active_op_array) = NULL;

       php_deactivate_ticks(TSRMLS_C);

       /* 1. Call all possible shutdown functions registered with register_shutdown_function() */
       if (PG(modules_activated)) zend_try {
              php_call_shutdown_functions(TSRMLS_C);
       } zend_end_try();

       /* 2. Call all possible __destruct() functions */
       zend_try {
              zend_call_destructors(TSRMLS_C);
       } zend_end_try();

       /* 3. Flush all output buffers */
       zend_try {
              zend_bool send_buffer = SG(request_info).headers_only ? 0 : 1;
              if (CG(unclean_shutdown) && PG(last_error_type) == E_ERROR &&
                            OG(ob_nesting_level) && !OG(active_ob_buffer).chunk_size && PG(memory_limit) < zend_memory_usage(1 TSRMLS_CC)) {
                     send_buffer = 0;
              }
              php_end_ob_buffers(send_buffer TSRMLS_CC);
       } zend_end_try();

       /* 4. Send the set HTTP headers (note: This must be done AFTER php_end_ob_buffers() !!) */
       zend_try {
              sapi_send_headers(TSRMLS_C);
       } zend_end_try();

       /* 5. Call all extensions RSHUTDOWN functions */
       if (PG(modules_activated)) {
              zend_deactivate_modules(TSRMLS_C);
              php_free_shutdown_functions(TSRMLS_C);
       }

       /* 6. Destroy super-globals */
       zend_try {
              int i;

              for (i=0; i<NUM_TRACK_VARS; i++) {
                     if (PG(http_globals)[i]) {
                            zval_ptr_dtor(&PG(http_globals)[i]);
                     }
              }
       } zend_end_try();

       /* 6.5 free last error information */
       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;
       }

       /* 7. Shutdown scanner/executor/compiler and restore ini entries */
       zend_deactivate(TSRMLS_C);

       /* 8. Call all extensions post-RSHUTDOWN functions */
       zend_try {
              zend_post_deactivate_modules(TSRMLS_C);
       } zend_end_try();

       /* 9. SAPI related shutdown (free stuff) */
       zend_try {
              sapi_deactivate(TSRMLS_C);
       } zend_end_try();

       /* 10. Destroy stream hashes */
       zend_try {
              php_shutdown_stream_hashes(TSRMLS_C);
       } zend_end_try();

       /* 11. Free Willy (here be crashes) */
       zend_try {
              shutdown_memory_manager(CG(unclean_shutdown) || !report_memleaks, 0 TSRMLS_CC);
       } zend_end_try();

       /* 12. Reset max_execution_time */
       zend_try {
              zend_unset_timeout(TSRMLS_C);
       } zend_end_try();

#ifdef PHP_WIN32
       if (PG(com_initialized)) {
              CoUninitialize();
              PG(com_initialized) = 0;
       }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void php_request_shutdown_for_exec ( void *  dummy)

Definition at line 1535 of file main.c.

{
       TSRMLS_FETCH();

       /* used to close fd's in the 3..255 range here, but it's problematic
        */
       shutdown_memory_manager(1, 1 TSRMLS_CC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void php_request_shutdown_for_hook ( void *  dummy)

Definition at line 1547 of file main.c.

Here is the call graph for this function:

Definition at line 1411 of file main.c.

{
       int retval = SUCCESS;

#ifdef PHP_WIN32
       PG(com_initialized) = 0;
#endif

#if PHP_SIGCHILD
       signal(SIGCHLD, sigchld_handler);
#endif

       zend_try {
              PG(in_error_log) = 0;
              PG(during_request_startup) = 1;

              php_output_activate(TSRMLS_C);

              /* initialize global variables */
              PG(modules_activated) = 0;
              PG(header_is_being_sent) = 0;
              PG(connection_status) = PHP_CONNECTION_NORMAL;
              PG(in_user_include) = 0;

              zend_activate(TSRMLS_C);
              sapi_activate(TSRMLS_C);

              if (PG(max_input_time) == -1) {
                     zend_set_timeout(EG(timeout_seconds), 1);
              } else {
                     zend_set_timeout(PG(max_input_time), 1);
              }

              /* Disable realpath cache if safe_mode or open_basedir are set */
              if (PG(safe_mode) || (PG(open_basedir) && *PG(open_basedir))) {
                     CWDG(realpath_cache_size_limit) = 0;
              }

              if (PG(expose_php)) {
                     sapi_add_header(SAPI_PHP_VERSION_HEADER, sizeof(SAPI_PHP_VERSION_HEADER)-1, 1);
              }

              if (PG(output_handler) && PG(output_handler)[0]) {
                     php_start_ob_buffer_named(PG(output_handler), 0, 1 TSRMLS_CC);
              } else if (PG(output_buffering)) {
                     if (PG(output_buffering)>1) {
                            php_start_ob_buffer(NULL, PG(output_buffering), 1 TSRMLS_CC);
                     } else {
                            php_start_ob_buffer(NULL, 0, 1 TSRMLS_CC);
                     }
              } else if (PG(implicit_flush)) {
                     php_start_implicit_flush(TSRMLS_C);
              }

              /* We turn this off in php_execute_script() */
              /* PG(during_request_startup) = 0; */

              php_hash_environment(TSRMLS_C);
              zend_activate_modules(TSRMLS_C);
              PG(modules_activated)=1;
       } zend_catch {
              retval = FAILURE;
       } zend_end_try();

       SG(sapi_started) = 1;

       return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1513 of file main.c.

{
       int retval = SUCCESS;

#if PHP_SIGCHLD
       signal(SIGCHLD, sigchld_handler);
#endif

       if (php_start_sapi(TSRMLS_C) == FAILURE) {
              return FAILURE;
       }

       php_output_activate(TSRMLS_C);
       sapi_activate_headers_only(TSRMLS_C);
       php_hash_environment(TSRMLS_C);

       return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* php_resolve_path_for_zend ( const char *  filename,
int filename_len  TSRMLS_DC 
) [static]

Definition at line 1255 of file main.c.

{
       return php_resolve_path(filename, filename_len, PG(include_path) TSRMLS_CC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int php_start_sapi ( TSRMLS_D  ) [static]

Definition at line 1380 of file main.c.

{
       int retval = SUCCESS;

       if(!SG(sapi_started)) {
              zend_try {
                     PG(during_request_startup) = 1;

                     /* initialize global variables */
                     PG(modules_activated) = 0;
                     PG(header_is_being_sent) = 0;
                     PG(connection_status) = PHP_CONNECTION_NORMAL;

                     zend_activate(TSRMLS_C);
                     zend_set_timeout(EG(timeout_seconds), 1);
                     zend_activate_modules(TSRMLS_C);
                     PG(modules_activated)=1;
              } zend_catch {
                     retval = FAILURE;
              } zend_end_try();

              SG(sapi_started) = 1;
       }
       return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int php_stream_open_for_zend ( const char *  filename,
zend_file_handle *handle  TSRMLS_DC 
) [static]

Definition at line 1206 of file main.c.

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int php_stream_open_for_zend_ex ( const char *  filename,
zend_file_handle handle,
int mode  TSRMLS_DC 
)

Definition at line 1212 of file main.c.

{
       char *p;
       size_t len, mapped_len;
       php_stream *stream = php_stream_open_wrapper((char *)filename, "rb", mode, &handle->opened_path);

       if (stream) {
#if HAVE_MMAP
              size_t page_size = REAL_PAGE_SIZE;
#endif

              handle->filename = (char*)filename;
              handle->free_filename = 0;
              handle->handle.stream.handle  = stream;
              handle->handle.stream.reader  = (zend_stream_reader_t)_php_stream_read;
              handle->handle.stream.fsizer  = php_zend_stream_fsizer;
              handle->handle.stream.isatty  = 0;
              /* can we mmap immeadiately? */
              memset(&handle->handle.stream.mmap, 0, sizeof(handle->handle.stream.mmap));
              len = php_zend_stream_fsizer(stream TSRMLS_CC);
              if (len != 0
#if HAVE_MMAP
              && ((len - 1) % page_size) <= page_size - ZEND_MMAP_AHEAD
#endif
              && php_stream_mmap_possible(stream)
              && (p = php_stream_mmap_range(stream, 0, len, PHP_STREAM_MAP_MODE_SHARED_READONLY, &mapped_len)) != NULL) {
                     handle->handle.stream.closer   = php_zend_stream_mmap_closer;
                     handle->handle.stream.mmap.buf = p;
                     handle->handle.stream.mmap.len = mapped_len;
                     handle->type = ZEND_HANDLE_MAPPED;
              } else {
                     handle->handle.stream.closer = php_zend_stream_closer;
                     handle->type = ZEND_HANDLE_STREAM;
              }
              /* suppress warning if this stream is not explicitly closed */
              php_stream_auto_cleanup(stream);

              return SUCCESS;
       }
       return FAILURE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI void php_verror ( const char *  docref,
const char *  params,
int  type,
const char *  format,
va_list args  TSRMLS_DC 
)

Definition at line 660 of file main.c.

{
       char *buffer = NULL, *docref_buf = NULL, *target = NULL;
       char *docref_target = "", *docref_root = "";
       char *p;
       int buffer_len = 0;
       char *space = "";
       char *class_name = "";
       char *function;
       int origin_len;
       char *origin;
       char *message;
       int is_function = 0;

       /* get error text into buffer and escape for html if necessary */
       buffer_len = vspprintf(&buffer, 0, format, args);
       if (PG(html_errors)) {
              int len;
              char *replace = php_escape_html_entities(buffer, buffer_len, &len, 0, ENT_COMPAT, NULL TSRMLS_CC);
              efree(buffer);
              buffer = replace;
              buffer_len = len;
       }

       /* which function caused the problem if any at all */
       if (php_during_module_startup()) {
              function = "PHP Startup";
       } else if (php_during_module_shutdown()) {
              function = "PHP Shutdown";
       } else if (EG(current_execute_data) &&
                            EG(current_execute_data)->opline &&
                            EG(current_execute_data)->opline->opcode == ZEND_INCLUDE_OR_EVAL
       ) {
              switch (EG(current_execute_data)->opline->op2.u.constant.value.lval) {
                     case ZEND_EVAL:
                            function = "eval";
                            is_function = 1;
                            break;
                     case ZEND_INCLUDE:
                            function = "include";
                            is_function = 1;
                            break;
                     case ZEND_INCLUDE_ONCE:
                            function = "include_once";
                            is_function = 1;
                            break;
                     case ZEND_REQUIRE:
                            function = "require";
                            is_function = 1;
                            break;
                     case ZEND_REQUIRE_ONCE:
                            function = "require_once";
                            is_function = 1;
                            break;
                     default:
                            function = "Unknown";
              }
       } else {
              function = get_active_function_name(TSRMLS_C);
              if (!function || !strlen(function)) {
                     function = "Unknown";
              } else {
                     is_function = 1;
                     class_name = get_active_class_name(&space TSRMLS_CC);
              }
       }

       /* if we still have memory then format the origin */
       if (is_function) {
              origin_len = spprintf(&origin, 0, "%s%s%s(%s)", class_name, space, function, params);
       } else {
              origin_len = spprintf(&origin, 0, "%s", function);
       }

       if (PG(html_errors)) {
              int len;
              char *replace = php_escape_html_entities(origin, origin_len, &len, 0, ENT_COMPAT, NULL TSRMLS_CC);
              efree(origin);
              origin = replace;
       }

       /* origin and buffer available, so lets come up with the error message */
       if (docref && docref[0] == '#') {
              docref_target = strchr(docref, '#');
              docref = NULL;
       }

       /* no docref given but function is known (the default) */
       if (!docref && is_function) {
              int doclen;
              if (space[0] == '\0') {
                     doclen = spprintf(&docref_buf, 0, "function.%s", function);
              } else {
                     doclen = spprintf(&docref_buf, 0, "%s.%s", class_name, function);
              }
              while((p = strchr(docref_buf, '_')) != NULL) {
                     *p = '-';
              }
              docref = php_strtolower(docref_buf, doclen);
       }

       /* we have a docref for a function AND
        * - we show erroes in html mode OR
        * - the user wants to see the links anyway
        */
       if (docref && is_function && (PG(html_errors) || strlen(PG(docref_root)))) {
              if (strncmp(docref, "http://", 7)) {
                     /* We don't have 'http://' so we use docref_root */

                     char *ref;  /* temp copy for duplicated docref */

                     docref_root = PG(docref_root);

                     ref = estrdup(docref);
                     if (docref_buf) {
                            efree(docref_buf);
                     }
                     docref_buf = ref;
                     /* strip of the target if any */
                     p = strrchr(ref, '#');
                     if (p) {
                            target = estrdup(p);
                            if (target) {
                                   docref_target = target;
                                   *p = '\0';
                            }
                     }
                     /* add the extension if it is set in ini */
                     if (PG(docref_ext) && strlen(PG(docref_ext))) {
                            spprintf(&docref_buf, 0, "%s%s", ref, PG(docref_ext));
                            efree(ref);
                     }
                     docref = docref_buf;
              }
              /* display html formatted or only show the additional links */
              if (PG(html_errors)) {
                     spprintf(&message, 0, "%s [<a href='%s%s%s'>%s</a>]: %s", origin, docref_root, docref, docref_target, docref, buffer);
              } else {
                     spprintf(&message, 0, "%s [%s%s%s]: %s", origin, docref_root, docref, docref_target, buffer);
              }
              if (target) {
                     efree(target);
              }
       } else {
              spprintf(&message, 0, "%s: %s", origin, buffer);
       }
       efree(origin);
       if (docref_buf) {
              efree(docref_buf);
       }

       if (PG(track_errors) && module_initialized && 
                     (!EG(user_error_handler) || !(EG(user_error_handler_error_reporting) & type))) {
              if (!EG(active_symbol_table)) {
                     zend_rebuild_symbol_table(TSRMLS_C);
              }
              if (EG(active_symbol_table)) {
                     zval *tmp;
                     ALLOC_INIT_ZVAL(tmp);
                     ZVAL_STRINGL(tmp, buffer, buffer_len, 1);
                     zend_hash_update(EG(active_symbol_table), "php_errormsg", sizeof("php_errormsg"), (void **) &tmp, sizeof(zval *), NULL);
              }
       }
       efree(buffer);

       php_error(type, "%s", message);
       efree(message);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int php_write ( void *  buf,
uint size  TSRMLS_DC 
)

Definition at line 628 of file main.c.

{
       return PHPWRITE(buf, size);
}

Here is the caller graph for this function:

static void php_zend_stream_closer ( void *handle  TSRMLS_DC) [static]

Definition at line 1183 of file main.c.

{
       php_stream_close((php_stream*)handle);
}

Here is the caller graph for this function:

static size_t php_zend_stream_fsizer ( void *handle  TSRMLS_DC) [static]

Definition at line 1196 of file main.c.

{
       php_stream_statbuf  ssb;
       if (php_stream_stat((php_stream*)handle, &ssb) == 0) {
              return ssb.sb.st_size;
       }
       return 0;
}

Here is the caller graph for this function:

static void php_zend_stream_mmap_closer ( void *handle  TSRMLS_DC) [static]

Definition at line 1189 of file main.c.

{
       php_stream_mmap_unmap((php_stream*)handle);
       php_zend_stream_closer(handle TSRMLS_CC);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

php_core_globals core_globals

Definition at line 120 of file main.c.

int module_initialized = 0 [static]

Definition at line 556 of file main.c.

int module_shutdown = 0 [static]

Definition at line 558 of file main.c.

int module_startup = 1 [static]

Definition at line 557 of file main.c.

Definition at line 117 of file main.c.