�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2F'>php-8.4.5</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fsapi%2F'>sapi</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fsapi%2Fapache2handler%2F'>apache2handler</a>/</p><hr><h3>✏️ Editing: sapi_apache2.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
   +----------------------------------------------------------------------+
   | Copyright (c) The PHP Group                                          |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | https://www.php.net/license/3_01.txt                                 |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
   | Authors: Sascha Schumann &lt;sascha@schumann.cx&gt;                        |
   |          Parts based on Apache 1.3 SAPI module by                    |
   |          Rasmus Lerdorf and Zeev Suraski                             |
   +----------------------------------------------------------------------+
 */

#define ZEND_INCLUDE_FULL_WINDOWS_HEADERS

#include &quot;php.h&quot;
#ifdef strcasecmp
# undef strcasecmp
#endif
#ifdef strncasecmp
# undef strncasecmp
#endif
#include &quot;php_main.h&quot;
#include &quot;php_ini.h&quot;
#include &quot;php_variables.h&quot;
#include &quot;SAPI.h&quot;

#include &lt;fcntl.h&gt;

#include &quot;zend_smart_str.h&quot;
#include &quot;ext/standard/php_standard.h&quot;

#include &quot;apr_strings.h&quot;
#include &quot;ap_config.h&quot;
#include &quot;util_filter.h&quot;
#include &quot;httpd.h&quot;
#include &quot;http_config.h&quot;
#include &quot;http_request.h&quot;
#include &quot;http_core.h&quot;
#include &quot;http_protocol.h&quot;
#include &quot;http_log.h&quot;
#include &quot;http_main.h&quot;
#include &quot;util_script.h&quot;
#include &quot;http_core.h&quot;
#include &quot;ap_mpm.h&quot;

#include &quot;php_apache.h&quot;

/* UnixWare define shutdown to _shutdown, which causes problems later
 * on when using a structure member named shutdown. Since this source
 * file does not use the system call shutdown, it is safe to #undef it.
 */
#undef shutdown

#define PHP_MAGIC_TYPE &quot;application/x-httpd-php&quot;
#define PHP_SOURCE_MAGIC_TYPE &quot;application/x-httpd-php-source&quot;
#define PHP_SCRIPT &quot;php-script&quot;

/* A way to specify the location of the php.ini dir in an apache directive */
char *apache2_php_ini_path_override = NULL;
#if defined(PHP_WIN32) &amp;&amp; defined(ZTS)
ZEND_TSRMLS_CACHE_DEFINE()
#endif

static size_t
php_apache_sapi_ub_write(const char *str, size_t str_length)
{
	request_rec *r;
	php_struct *ctx;

	ctx = SG(server_context);
	r = ctx-&gt;r;

	if (ap_rwrite(str, str_length, r) &lt; 0) {
		php_handle_aborted_connection();
	}

	return str_length; /* we always consume all the data passed to us. */
}

static int
php_apache_sapi_header_handler(sapi_header_struct *sapi_header, sapi_header_op_enum op, sapi_headers_struct *sapi_headers)
{
	php_struct *ctx;
	char *val, *ptr;

	ctx = SG(server_context);

	switch (op) {
		case SAPI_HEADER_DELETE:
			apr_table_unset(ctx-&gt;r-&gt;headers_out, sapi_header-&gt;header);
			return 0;

		case SAPI_HEADER_DELETE_ALL:
			apr_table_clear(ctx-&gt;r-&gt;headers_out);
			return 0;

		case SAPI_HEADER_ADD:
		case SAPI_HEADER_REPLACE:
			val = strchr(sapi_header-&gt;header, &#039;:&#039;);

			if (!val) {
				return 0;
			}
			ptr = val;

			*val = &#039;\0&#039;;

			do {
				val++;
			} while (*val == &#039; &#039;);

			if (!strcasecmp(sapi_header-&gt;header, &quot;content-type&quot;)) {
				if (ctx-&gt;content_type) {
					efree(ctx-&gt;content_type);
				}
				ctx-&gt;content_type = estrdup(val);
			} else if (!strcasecmp(sapi_header-&gt;header, &quot;content-length&quot;)) {
				apr_off_t clen = 0;

				if (APR_SUCCESS != apr_strtoff(&amp;clen, val, (char **) NULL, 10)) {
					/* We&#039;ll fall back to strtol, since that&#039;s what we used to
					 * do anyway. */
					clen = (apr_off_t) strtol(val, (char **) NULL, 10);
				}

				ap_set_content_length(ctx-&gt;r, clen);
			} else if (op == SAPI_HEADER_REPLACE) {
				apr_table_set(ctx-&gt;r-&gt;headers_out, sapi_header-&gt;header, val);
			} else {
				apr_table_add(ctx-&gt;r-&gt;headers_out, sapi_header-&gt;header, val);
			}

			*ptr = &#039;:&#039;;

			return SAPI_HEADER_ADD;

		default:
			return 0;
	}
}

static int
php_apache_sapi_send_headers(sapi_headers_struct *sapi_headers)
{
	php_struct *ctx = SG(server_context);
	const char *sline = SG(sapi_headers).http_status_line;

	ctx-&gt;r-&gt;status = SG(sapi_headers).http_response_code;

	/* httpd requires that r-&gt;status_line is set to the first digit of
	 * the status-code: */
	if (sline &amp;&amp; strlen(sline) &gt; 12 &amp;&amp; strncmp(sline, &quot;HTTP/1.&quot;, 7) == 0 &amp;&amp; sline[8] == &#039; &#039;) {
		ctx-&gt;r-&gt;status_line = apr_pstrdup(ctx-&gt;r-&gt;pool, sline + 9);
		ctx-&gt;r-&gt;proto_num = 1000 + (sline[7]-&#039;0&#039;);
		if ((sline[7]-&#039;0&#039;) == 0) {
			apr_table_set(ctx-&gt;r-&gt;subprocess_env, &quot;force-response-1.0&quot;, &quot;true&quot;);
		}
	}

	/*	call ap_set_content_type only once, else each time we call it,
		configured output filters for that content type will be added */
	if (!ctx-&gt;content_type) {
		ctx-&gt;content_type = sapi_get_default_content_type();
	}
	ap_set_content_type(ctx-&gt;r, apr_pstrdup(ctx-&gt;r-&gt;pool, ctx-&gt;content_type));
	efree(ctx-&gt;content_type);
	ctx-&gt;content_type = NULL;

	return SAPI_HEADER_SENT_SUCCESSFULLY;
}

static apr_size_t
php_apache_sapi_read_post(char *buf, size_t count_bytes)
{
	apr_size_t len, tlen=0;
	php_struct *ctx = SG(server_context);
	request_rec *r;
	apr_bucket_brigade *brigade;
	apr_status_t status;

	r = ctx-&gt;r;
	brigade = ctx-&gt;brigade;
	len = count_bytes;

	/*
	 * This loop is needed because ap_get_brigade() can return us partial data
	 * which would cause premature termination of request read. Therefore we
	 * need to make sure that if data is available we fill the buffer completely.
	 */

	while ((status = ap_get_brigade(r-&gt;input_filters, brigade, AP_MODE_READBYTES, APR_BLOCK_READ, len)) == APR_SUCCESS) {
		apr_brigade_flatten(brigade, buf, &amp;len);
		apr_brigade_cleanup(brigade);
		tlen += len;
		if (tlen == count_bytes || !len) {
			break;
		}
		buf += len;
		len = count_bytes - tlen;
	}

	if (status != APR_SUCCESS) {
		return 0;
	}

	return tlen;
}

static zend_stat_t*
php_apache_sapi_get_stat(void)
{
	php_struct *ctx = SG(server_context);

#ifdef PHP_WIN32
	ctx-&gt;finfo.st_uid = 0;
	ctx-&gt;finfo.st_gid = 0;
#else
	ctx-&gt;finfo.st_uid = ctx-&gt;r-&gt;finfo.user;
	ctx-&gt;finfo.st_gid = ctx-&gt;r-&gt;finfo.group;
#endif
	ctx-&gt;finfo.st_dev = ctx-&gt;r-&gt;finfo.device;
	ctx-&gt;finfo.st_ino = ctx-&gt;r-&gt;finfo.inode;
	ctx-&gt;finfo.st_atime = apr_time_sec(ctx-&gt;r-&gt;finfo.atime);
	ctx-&gt;finfo.st_mtime = apr_time_sec(ctx-&gt;r-&gt;finfo.mtime);
	ctx-&gt;finfo.st_ctime = apr_time_sec(ctx-&gt;r-&gt;finfo.ctime);
	ctx-&gt;finfo.st_size = ctx-&gt;r-&gt;finfo.size;
	ctx-&gt;finfo.st_nlink = ctx-&gt;r-&gt;finfo.nlink;

	return &amp;ctx-&gt;finfo;
}

static char *
php_apache_sapi_read_cookies(void)
{
	php_struct *ctx = SG(server_context);
	const char *http_cookie;

	http_cookie = apr_table_get(ctx-&gt;r-&gt;headers_in, &quot;cookie&quot;);

	/* The SAPI interface should use &#039;const char *&#039; */
	return (char *) http_cookie;
}

static char *
php_apache_sapi_getenv(const char *name, size_t name_len)
{
	php_struct *ctx = SG(server_context);
	const char *env_var;

	if (ctx == NULL) {
		return NULL;
	}

	env_var = apr_table_get(ctx-&gt;r-&gt;subprocess_env, name);

	return (char *) env_var;
}

static void
php_apache_sapi_register_variables(zval *track_vars_array)
{
	php_struct *ctx = SG(server_context);
	const apr_array_header_t *arr = apr_table_elts(ctx-&gt;r-&gt;subprocess_env);
	char *key, *val;
	size_t new_val_len;

	APR_ARRAY_FOREACH_OPEN(arr, key, val)
		if (!val) {
			val = &quot;&quot;;
		}
		if (sapi_module.input_filter(PARSE_SERVER, key, &amp;val, strlen(val), &amp;new_val_len)) {
			php_register_variable_safe(key, val, new_val_len, track_vars_array);
		}
	APR_ARRAY_FOREACH_CLOSE()

	if (sapi_module.input_filter(PARSE_SERVER, &quot;PHP_SELF&quot;, &amp;ctx-&gt;r-&gt;uri, strlen(ctx-&gt;r-&gt;uri), &amp;new_val_len)) {
		php_register_variable_safe(&quot;PHP_SELF&quot;, ctx-&gt;r-&gt;uri, new_val_len, track_vars_array);
	}
}

static void
php_apache_sapi_flush(void *server_context)
{
	php_struct *ctx;
	request_rec *r;

	ctx = server_context;

	/* If we haven&#039;t registered a server_context yet,
	 * then don&#039;t bother flushing. */
	if (!server_context) {
		return;
	}

	r = ctx-&gt;r;

	sapi_send_headers();

	r-&gt;status = SG(sapi_headers).http_response_code;
	SG(headers_sent) = 1;

	if (ap_rflush(r) &lt; 0 || r-&gt;connection-&gt;aborted) {
		php_handle_aborted_connection();
	}
}

static void php_apache_sapi_log_message(const char *msg, int syslog_type_int)
{
	php_struct *ctx;
	int aplog_type = APLOG_ERR;

	ctx = SG(server_context);

	switch (syslog_type_int) {
#if LOG_EMERG != LOG_CRIT
		case LOG_EMERG:
			aplog_type = APLOG_EMERG;
			break;
#endif
#if LOG_ALERT != LOG_CRIT
		case LOG_ALERT:
			aplog_type = APLOG_ALERT;
			break;
#endif
		case LOG_CRIT:
			aplog_type = APLOG_CRIT;
			break;
		case LOG_ERR:
			aplog_type = APLOG_ERR;
			break;
		case LOG_WARNING:
			aplog_type = APLOG_WARNING;
			break;
		case LOG_NOTICE:
			aplog_type = APLOG_NOTICE;
			break;
#if LOG_INFO != LOG_NOTICE
		case LOG_INFO:
			aplog_type = APLOG_INFO;
			break;
#endif
#if LOG_NOTICE != LOG_DEBUG
		case LOG_DEBUG:
			aplog_type = APLOG_DEBUG;
			break;
#endif
	}

	if (ctx == NULL) { /* we haven&#039;t initialized our ctx yet, oh well */
		ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, 0, NULL, &quot;%s&quot;, msg);
	} else {
		ap_log_rerror(APLOG_MARK, aplog_type, 0, ctx-&gt;r, &quot;%s&quot;, msg);
	}
}

static void php_apache_sapi_log_message_ex(const char *msg, request_rec *r)
{
	if (r) {
		ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, msg, r-&gt;filename);
	} else {
		php_apache_sapi_log_message(msg, -1);
	}
}

static zend_result php_apache_sapi_get_request_time(double *request_time)
{
	php_struct *ctx = SG(server_context);
	if (!ctx) {
		return FAILURE;
	}

	*request_time = ((double) ctx-&gt;r-&gt;request_time) / 1000000.0;
	return SUCCESS;
}

extern zend_module_entry php_apache_module;

static int php_apache2_startup(sapi_module_struct *sapi_module)
{
	return php_module_startup(sapi_module, &amp;php_apache_module);
}

static sapi_module_struct apache2_sapi_module = {
	&quot;apache2handler&quot;,
	&quot;Apache 2 Handler&quot;,

	php_apache2_startup,				/* startup */
	php_module_shutdown_wrapper,			/* shutdown */

	NULL,						/* activate */
	NULL,						/* deactivate */

	php_apache_sapi_ub_write,			/* unbuffered write */
	php_apache_sapi_flush,				/* flush */
	php_apache_sapi_get_stat,			/* get uid */
	php_apache_sapi_getenv,				/* getenv */

	php_error,					/* error handler */

	php_apache_sapi_header_handler,			/* header handler */
	php_apache_sapi_send_headers,			/* send headers handler */
	NULL,						/* send header handler */

	php_apache_sapi_read_post,			/* read POST data */
	php_apache_sapi_read_cookies,			/* read Cookies */

	php_apache_sapi_register_variables,
	php_apache_sapi_log_message,			/* Log message */
	php_apache_sapi_get_request_time,		/* Request Time */
	NULL,						/* Child Terminate */

	STANDARD_SAPI_MODULE_PROPERTIES
};

static apr_status_t php_apache_server_shutdown(void *tmp)
{
	apache2_sapi_module.shutdown(&amp;apache2_sapi_module);
	sapi_shutdown();
#ifdef ZTS
	tsrm_shutdown();
#endif
	return APR_SUCCESS;
}

static apr_status_t php_apache_child_shutdown(void *tmp)
{
	apache2_sapi_module.shutdown(&amp;apache2_sapi_module);
#if defined(ZTS) &amp;&amp; !defined(PHP_WIN32)
	tsrm_shutdown();
#endif
	return APR_SUCCESS;
}

static void php_apache_add_version(apr_pool_t *p)
{
	if (PG(expose_php)) {
		ap_add_version_component(p, &quot;PHP/&quot; PHP_VERSION);
	}
}

static int php_pre_config(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp)
{
#ifndef ZTS
	int threaded_mpm;

	ap_mpm_query(AP_MPMQ_IS_THREADED, &amp;threaded_mpm);
	if(threaded_mpm) {
		ap_log_error(APLOG_MARK, APLOG_CRIT, 0, 0, &quot;Apache is running a threaded MPM, but your PHP Module is not compiled to be threadsafe.  You need to recompile PHP.&quot;);
		return DONE;
	}
#endif
	/* When this is NULL, apache won&#039;t override the hard-coded default
	 * php.ini path setting. */
	apache2_php_ini_path_override = NULL;
	return OK;
}

static int
php_apache_server_startup(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
{
	void *data = NULL;
	const char *userdata_key = &quot;apache2hook_post_config&quot;;

	/* Apache will load, unload and then reload a DSO module. This
	 * prevents us from starting PHP until the second load. */
	apr_pool_userdata_get(&amp;data, userdata_key, s-&gt;process-&gt;pool);
	if (data == NULL) {
		/* We must use set() here and *not* setn(), otherwise the
		 * static string pointed to by userdata_key will be mapped
		 * to a different location when the DSO is reloaded and the
		 * pointers won&#039;t match, causing get() to return NULL when
		 * we expected it to return non-NULL. */
		apr_pool_userdata_set((const void *)1, userdata_key, apr_pool_cleanup_null, s-&gt;process-&gt;pool);
		return OK;
	}

	/* Set up our overridden path. */
	if (apache2_php_ini_path_override) {
		apache2_sapi_module.php_ini_path_override = apache2_php_ini_path_override;
	}
#ifdef ZTS
	int expected_threads;
	if (ap_mpm_query(AP_MPMQ_MAX_THREADS, &amp;expected_threads) != APR_SUCCESS) {
		expected_threads = 1;
	}

	php_tsrm_startup_ex(expected_threads);
# ifdef PHP_WIN32
	ZEND_TSRMLS_CACHE_UPDATE();
# endif
#endif

	zend_signal_startup();

	sapi_startup(&amp;apache2_sapi_module);
	if (apache2_sapi_module.startup(&amp;apache2_sapi_module) != SUCCESS) {
		return DONE;
	}
	apr_pool_cleanup_register(pconf, NULL, php_apache_server_shutdown, apr_pool_cleanup_null);
	php_apache_add_version(pconf);

	return OK;
}

static apr_status_t php_server_context_cleanup(void *data_)
{
	void **data = data_;
	*data = NULL;
	return APR_SUCCESS;
}

static int php_apache_request_ctor(request_rec *r, php_struct *ctx)
{
	char *content_length;
	const char *auth;

	SG(sapi_headers).http_response_code = !r-&gt;status ? HTTP_OK : r-&gt;status;
	SG(request_info).content_type = apr_table_get(r-&gt;headers_in, &quot;Content-Type&quot;);
	SG(request_info).query_string = apr_pstrdup(r-&gt;pool, r-&gt;args);
	SG(request_info).request_method = r-&gt;method;
	SG(request_info).proto_num = r-&gt;proto_num;
	SG(request_info).request_uri = apr_pstrdup(r-&gt;pool, r-&gt;uri);
	SG(request_info).path_translated = apr_pstrdup(r-&gt;pool, r-&gt;filename);
	r-&gt;no_local_copy = 1;

	content_length = (char *) apr_table_get(r-&gt;headers_in, &quot;Content-Length&quot;);
	if (content_length) {
		SG(request_info).content_length = ZEND_ATOL(content_length);
	} else {
		SG(request_info).content_length = 0;
	}

	apr_table_unset(r-&gt;headers_out, &quot;Content-Length&quot;);
	apr_table_unset(r-&gt;headers_out, &quot;Last-Modified&quot;);
	apr_table_unset(r-&gt;headers_out, &quot;Expires&quot;);
	apr_table_unset(r-&gt;headers_out, &quot;ETag&quot;);

	auth = apr_table_get(r-&gt;headers_in, &quot;Authorization&quot;);
	php_handle_auth_data(auth);

	if (SG(request_info).auth_user == NULL &amp;&amp; r-&gt;user) {
		SG(request_info).auth_user = estrdup(r-&gt;user);
	}

	ctx-&gt;r-&gt;user = apr_pstrdup(ctx-&gt;r-&gt;pool, SG(request_info).auth_user);

	return php_request_startup();
}

static void php_apache_request_dtor(request_rec *r)
{
	php_request_shutdown(NULL);
}

static void php_apache_ini_dtor(request_rec *r, request_rec *p)
{
	if (strcmp(r-&gt;protocol, &quot;INCLUDED&quot;)) {
		zend_try { zend_ini_deactivate(); } zend_end_try();
	} else {
typedef struct {
	HashTable config;
} php_conf_rec;
		zend_string *str;
		php_conf_rec *c = ap_get_module_config(r-&gt;per_dir_config, &amp;php_module);

		ZEND_HASH_MAP_FOREACH_STR_KEY(&amp;c-&gt;config, str) {
			zend_restore_ini_entry(str, ZEND_INI_STAGE_SHUTDOWN);
		} ZEND_HASH_FOREACH_END();
	}
	if (p) {
		((php_struct *)SG(server_context))-&gt;r = p;
	} else {
		apr_pool_cleanup_run(r-&gt;pool, (void *)&amp;SG(server_context), php_server_context_cleanup);
	}
}

static int php_handler(request_rec *r)
{
	php_struct * volatile ctx;
	void *conf;
	apr_bucket_brigade * volatile brigade;
	apr_bucket *bucket;
	apr_status_t rv;
	request_rec * volatile parent_req = NULL;
#ifdef ZTS
	/* initial resource fetch */
	(void)ts_resource(0);
# ifdef PHP_WIN32
	ZEND_TSRMLS_CACHE_UPDATE();
# endif
#endif

#define PHPAP_INI_OFF php_apache_ini_dtor(r, parent_req);

	conf = ap_get_module_config(r-&gt;per_dir_config, &amp;php_module);

	/* apply_config() needs r in some cases, so allocate server_context early */
	ctx = SG(server_context);
	if (ctx == NULL || (ctx &amp;&amp; ctx-&gt;request_processed &amp;&amp; !strcmp(r-&gt;protocol, &quot;INCLUDED&quot;))) {
normal:
		ctx = SG(server_context) = apr_pcalloc(r-&gt;pool, sizeof(*ctx));
		/* register a cleanup so we clear out the SG(server_context)
		 * after each request. Note: We pass in the pointer to the
		 * server_context in case this is handled by a different thread.
		 */
		apr_pool_cleanup_register(r-&gt;pool, (void *)&amp;SG(server_context), php_server_context_cleanup, apr_pool_cleanup_null);
		ctx-&gt;r = r;
		ctx = NULL; /* May look weird to null it here, but it is to catch the right case in the first_try later on */
	} else {
		parent_req = ctx-&gt;r;
		ctx-&gt;r = r;
	}
	apply_config(conf);

	if (strcmp(r-&gt;handler, PHP_MAGIC_TYPE) &amp;&amp; strcmp(r-&gt;handler, PHP_SOURCE_MAGIC_TYPE) &amp;&amp; strcmp(r-&gt;handler, PHP_SCRIPT)) {
		/* Check for xbithack in this case. */
		if (!AP2(xbithack) || strcmp(r-&gt;handler, &quot;text/html&quot;) || !(r-&gt;finfo.protection &amp; APR_UEXECUTE)) {
			PHPAP_INI_OFF;
			return DECLINED;
		}
	}

	/* Give a 404 if PATH_INFO is used but is explicitly disabled in
	 * the configuration; default behaviour is to accept. */
	if (r-&gt;used_path_info == AP_REQ_REJECT_PATH_INFO
		&amp;&amp; r-&gt;path_info &amp;&amp; r-&gt;path_info[0]) {
		PHPAP_INI_OFF;
		return HTTP_NOT_FOUND;
	}

	/* handle situations where user turns the engine off */
	if (!AP2(engine)) {
		PHPAP_INI_OFF;
		return DECLINED;
	}

	if (r-&gt;finfo.filetype == 0) {
		php_apache_sapi_log_message_ex(&quot;script &#039;%s&#039; not found or unable to stat&quot;, r);
		PHPAP_INI_OFF;
		return HTTP_NOT_FOUND;
	}
	if (r-&gt;finfo.filetype == APR_DIR) {
		php_apache_sapi_log_message_ex(&quot;attempt to invoke directory &#039;%s&#039; as script&quot;, r);
		PHPAP_INI_OFF;
		return HTTP_FORBIDDEN;
	}

	/* Setup the CGI variables if this is the main request */
	if (r-&gt;main == NULL ||
		/* .. or if the sub-request environment differs from the main-request. */
		r-&gt;subprocess_env != r-&gt;main-&gt;subprocess_env
	) {
		/* setup standard CGI variables */
		ap_add_common_vars(r);
		ap_add_cgi_vars(r);
	}

zend_first_try {

	if (ctx == NULL) {
		brigade = apr_brigade_create(r-&gt;pool, r-&gt;connection-&gt;bucket_alloc);
		ctx = SG(server_context);
		ctx-&gt;brigade = brigade;

		if (php_apache_request_ctor(r, ctx)!=SUCCESS) {
			zend_bailout();
		}
	} else {
		if (!parent_req) {
			parent_req = ctx-&gt;r;
		}
		if (parent_req &amp;&amp; parent_req-&gt;handler &amp;&amp;
				strcmp(parent_req-&gt;handler, PHP_MAGIC_TYPE) &amp;&amp;
				strcmp(parent_req-&gt;handler, PHP_SOURCE_MAGIC_TYPE) &amp;&amp;
				strcmp(parent_req-&gt;handler, PHP_SCRIPT)) {
			if (php_apache_request_ctor(r, ctx)!=SUCCESS) {
				zend_bailout();
			}
		}

		/*
		 * check if coming due to ErrorDocument
		 * We make a special exception of 413 (Invalid POST request) as the invalidity of the request occurs
		 * during processing of the request by PHP during POST processing. Therefore we need to re-use the exiting
		 * PHP instance to handle the request rather then creating a new one.
		*/
		if (parent_req &amp;&amp; parent_req-&gt;status != HTTP_OK &amp;&amp; parent_req-&gt;status != 413 &amp;&amp; strcmp(r-&gt;protocol, &quot;INCLUDED&quot;)) {
			parent_req = NULL;
			goto normal;
		}
		ctx-&gt;r = r;
		brigade = ctx-&gt;brigade;
	}

	if (AP2(last_modified)) {
		ap_update_mtime(r, r-&gt;finfo.mtime);
		ap_set_last_modified(r);
	}

	/* Determine if we need to parse the file or show the source */
	if (strncmp(r-&gt;handler, PHP_SOURCE_MAGIC_TYPE, sizeof(PHP_SOURCE_MAGIC_TYPE) - 1) == 0) {
		zend_syntax_highlighter_ini syntax_highlighter_ini;
		php_get_highlight_struct(&amp;syntax_highlighter_ini);
		highlight_file((char *)r-&gt;filename, &amp;syntax_highlighter_ini);
	} else {
		zend_file_handle zfd;
		zend_stream_init_filename(&amp;zfd, (char *) r-&gt;filename);
		zfd.primary_script = 1;

		if (!parent_req) {
			php_execute_script(&amp;zfd);
		} else {
			zend_execute_scripts(ZEND_INCLUDE, NULL, 1, &amp;zfd);
		}
		zend_destroy_file_handle(&amp;zfd);

		apr_table_set(r-&gt;notes, &quot;mod_php_memory_usage&quot;,
			apr_psprintf(ctx-&gt;r-&gt;pool, &quot;%&quot; APR_SIZE_T_FMT, zend_memory_peak_usage(1)));
	}

} zend_end_try();

	if (!parent_req) {
		php_apache_request_dtor(r);
		ctx-&gt;request_processed = 1;
		apr_brigade_cleanup(brigade);
		bucket = apr_bucket_eos_create(r-&gt;connection-&gt;bucket_alloc);
		APR_BRIGADE_INSERT_TAIL(brigade, bucket);

		rv = ap_pass_brigade(r-&gt;output_filters, brigade);
		if (rv != APR_SUCCESS || r-&gt;connection-&gt;aborted) {
zend_first_try {
			php_handle_aborted_connection();
} zend_end_try();
		}
		apr_brigade_cleanup(brigade);
		apr_pool_cleanup_run(r-&gt;pool, (void *)&amp;SG(server_context), php_server_context_cleanup);
	} else {
		ctx-&gt;r = parent_req;
	}

	return OK;
}

static void php_apache_child_init(apr_pool_t *pchild, server_rec *s)
{
	apr_pool_cleanup_register(pchild, NULL, php_apache_child_shutdown, apr_pool_cleanup_null);
}

#ifdef ZEND_SIGNALS
static void php_apache_signal_init(apr_pool_t *pchild, server_rec *s)
{
	zend_signal_init();
}
#endif

void php_ap2_register_hook(apr_pool_t *p)
{
	ap_hook_pre_config(php_pre_config, NULL, NULL, APR_HOOK_MIDDLE);
	ap_hook_post_config(php_apache_server_startup, NULL, NULL, APR_HOOK_MIDDLE);
	ap_hook_handler(php_handler, NULL, NULL, APR_HOOK_MIDDLE);
#ifdef ZEND_SIGNALS
	ap_hook_child_init(php_apache_signal_init, NULL, NULL, APR_HOOK_MIDDLE);
#endif
	ap_hook_child_init(php_apache_child_init, NULL, NULL, APR_HOOK_MIDDLE);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fsapi%2Fapache2handler'>🔙 Back</a></p>