1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2016 The PHP Group |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 3.01 of the PHP license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available at through the world-wide-web at |
10 | http://www.php.net/license/3_01.txt |
11 | If you did not receive a copy of the PHP license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@php.net so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Rasmus Lerdorf <rasmus@php.net> |
16 | (with helpful hints from Dean Gaudet <dgaudet@arctic.org> |
17 | PHP 4.0 patches by Zeev Suraski <zeev@zend.com> |
18 +----------------------------------------------------------------------+
19 */
20 /* $Id$ */
21
22 #include "php_apache_http.h"
23
24 #ifdef NETWARE
25 #define SIGPIPE SIGINT
26 #endif
27
28 #undef shutdown
29
30 /* {{{ Prototypes
31 */
32 int apache_php_module_main(request_rec *r, int display_source_mode TSRMLS_DC);
33 static void php_save_umask(void);
34 static void php_restore_umask(void);
35 static int sapi_apache_read_post(char *buffer, uint count_bytes TSRMLS_DC);
36 static char *sapi_apache_read_cookies(TSRMLS_D);
37 static int sapi_apache_header_handler(sapi_header_struct *sapi_header, sapi_header_op_enum op, sapi_headers_struct *sapi_headers TSRMLS_DC);
38 static int sapi_apache_send_headers(sapi_headers_struct *sapi_headers TSRMLS_DC);
39 static int send_php(request_rec *r, int display_source_mode, char *filename);
40 static int send_parsed_php(request_rec * r);
41 static int send_parsed_php_source(request_rec * r);
42 static int php_xbithack_handler(request_rec * r);
43 static void php_init_handler(server_rec *s, pool *p);
44 /* }}} */
45
46 #if MODULE_MAGIC_NUMBER >= 19970728
47 static void php_child_exit_handler(server_rec *s, pool *p);
48 #endif
49
50 #if MODULE_MAGIC_NUMBER > 19961007
51 #define CONST_PREFIX const
52 #else
53 #define CONST_PREFIX
54 #endif
55
56
57 typedef struct _sapi_stack {
58 int top, max, persistent;
59 void **elements;
60 } sapi_stack;
61
62 typedef struct _php_per_dir_config {
63 HashTable *ini_settings;
64 sapi_stack headers_handlers;
65 sapi_stack auth_handlers;
66 sapi_stack access_handlers;
67 sapi_stack type_handlers;
68 sapi_stack fixup_handlers;
69 sapi_stack logger_handlers;
70 sapi_stack post_read_handlers;
71 sapi_stack response_handlers;
72 } php_per_dir_config;
73
74 typedef struct _php_per_server_config {
75 sapi_stack uri_handlers;
76 sapi_stack requires;
77 } php_per_server_config;
78
79
80 static CONST_PREFIX char *php_apache_value_handler_ex(cmd_parms *cmd, HashTable *conf, char *arg1, char *arg2, int mode);
81 static CONST_PREFIX char *php_apache_value_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1, char *arg2);
82 static CONST_PREFIX char *php_apache_admin_value_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1, char *arg2);
83 static CONST_PREFIX char *php_apache_flag_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1, char *arg2);
84 static CONST_PREFIX char *php_apache_flag_handler_ex(cmd_parms *cmd, HashTable *conf, char *arg1, char *arg2, int mode);
85 static CONST_PREFIX char *php_apache_admin_flag_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1, char *arg2);
86
87 /* ### these should be defined in mod_php5.h or somewhere else */
88 #define USE_PATH 1
89 #define IGNORE_URL 2
90
91 module MODULE_VAR_EXPORT php5_module;
92
93 int saved_umask;
94 /* static int setup_env = 0; */
95 static unsigned char apache_php_initialized;
96
97 typedef struct _php_per_dir_entry {
98 char *key;
99 char *value;
100 uint key_length;
101 uint value_length;
102 int type;
103 } php_per_dir_entry;
104
105 /* some systems are missing these from their header files */
106
107 /* {{{ zend stack utility functions
108 */
109
110 /* This code is ripped part and parcel from zend_stack.[ch]. Assuming that the
111 patch supporting zend_stack_init_ex is applied, all but the bottom two
112 module-specific iterators will be removed
113 */
114
sapi_stack_init_ex(sapi_stack * stack,int persistent)115 int sapi_stack_init_ex(sapi_stack *stack, int persistent)
116 {
117 stack->top = 0;
118 stack->persistent = persistent;
119 stack->elements = (void **) pemalloc(sizeof(void **) * STACK_BLOCK_SIZE, persistent);
120 if (!stack->elements) {
121 return FAILURE;
122 } else {
123 stack->max = STACK_BLOCK_SIZE;
124 return SUCCESS;
125 }
126 }
sapi_stack_push(sapi_stack * stack,void * element)127 int sapi_stack_push(sapi_stack *stack, void *element)
128 {
129 if (stack->top >= stack->max) { /* we need to allocate more memory */
130 stack->elements = (void **) perealloc(stack->elements,
131 (sizeof(void **) * (stack->max += STACK_BLOCK_SIZE)), stack->persistent);
132 if (!stack->elements) {
133 return FAILURE;
134 }
135 }
136 stack->elements[stack->top] = (void *) element;
137 return stack->top++;
138 }
sapi_stack_pop(sapi_stack * stack)139 void* sapi_stack_pop(sapi_stack *stack) {
140 if(stack->top == 0) {
141 return NULL;
142 }
143 else {
144 return stack->elements[--stack->top];
145 }
146 }
147
sapi_stack_destroy(sapi_stack * stack)148 int sapi_stack_destroy(sapi_stack *stack)
149 {
150 return SUCCESS;
151 }
152
sapi_stack_apply_with_argument_all(sapi_stack * stack,int type,int (* apply_function)(void * element,void * arg),void * arg)153 int sapi_stack_apply_with_argument_all(sapi_stack *stack, int type, int (*apply_function)(void *element, void *arg), void *arg)
154 {
155 int i, retval;
156
157 switch (type) {
158 case ZEND_STACK_APPLY_TOPDOWN:
159 for (i=stack->top-1; i>=0; i--) {
160 retval = apply_function(stack->elements[i], arg);
161 }
162 break;
163 case ZEND_STACK_APPLY_BOTTOMUP:
164 for (i=0; i<stack->top; i++) {
165 retval = apply_function(stack->elements[i], arg);
166 }
167 break;
168 }
169 return retval;
170 }
171
172
sapi_stack_apply_with_argument_stop_if_equals(sapi_stack * stack,int type,int (* apply_function)(void * element,void * arg),void * arg,int stopval)173 int sapi_stack_apply_with_argument_stop_if_equals(sapi_stack *stack, int type, int (*apply_function)(void *element, void *arg), void *arg, int stopval)
174 {
175 int i;
176 int ret = DECLINED;
177 switch (type) {
178 case ZEND_STACK_APPLY_TOPDOWN:
179 for (i=stack->top-1; i>=0; i--) {
180 if ((ret = apply_function(stack->elements[i], arg)) == stopval) {
181 break;
182 }
183 }
184 break;
185 case ZEND_STACK_APPLY_BOTTOMUP:
186 for (i=0; i<stack->top; i++) {
187 if ((ret = apply_function(stack->elements[i], arg)) == stopval) {
188 break;
189 }
190 }
191 break;
192 }
193 return ret;
194 }
195
sapi_stack_apply_with_argument_stop_if_http_error(sapi_stack * stack,int type,int (* apply_function)(void * element,void * arg),void * arg)196 int sapi_stack_apply_with_argument_stop_if_http_error(sapi_stack *stack, int type, int (*apply_function)(void *element, void *arg), void *arg)
197 {
198 int i;
199 int ret = DECLINED;
200 switch (type) {
201 case ZEND_STACK_APPLY_TOPDOWN:
202 for (i=stack->top-1; i>=0; i--) {
203 if ((ret = apply_function(stack->elements[i], arg)) > 0) {
204 break;
205 }
206 }
207 break;
208 case ZEND_STACK_APPLY_BOTTOMUP:
209 for (i=0; i<stack->top; i++) {
210 if ((ret = apply_function(stack->elements[i], arg)) > 0) {
211 break;
212 }
213 }
214 break;
215 }
216 return ret;
217 }
218
php_handler_stack_destroy(sapi_stack * stack)219 void php_handler_stack_destroy(sapi_stack *stack)
220 {
221 php_handler *ph;
222 while((ph = (php_handler *)sapi_stack_pop(stack)) != NULL) {
223 free(ph->name);
224 free(ph);
225 }
226 }
227 /* }}} */
228
229 /* {{{ php_save_umask
230 */
php_save_umask(void)231 static void php_save_umask(void)
232 {
233 saved_umask = umask(077);
234 umask(saved_umask);
235 }
236 /* }}} */
237
238 /* {{{ sapi_apache_ub_write
239 */
sapi_apache_ub_write(const char * str,uint str_length TSRMLS_DC)240 static int sapi_apache_ub_write(const char *str, uint str_length TSRMLS_DC)
241 {
242 int ret=0;
243
244 if (SG(server_context)) {
245 ret = rwrite(str, str_length, (request_rec *) SG(server_context));
246 }
247 if (ret != str_length) {
248 php_handle_aborted_connection();
249 }
250 return ret;
251 }
252 /* }}} */
253
254 /* {{{ sapi_apache_flush
255 */
sapi_apache_flush(void * server_context)256 static void sapi_apache_flush(void *server_context)
257 {
258 if (server_context) {
259 #if MODULE_MAGIC_NUMBER > 19970110
260 rflush((request_rec *) server_context);
261 #else
262 bflush((request_rec *) server_context->connection->client);
263 #endif
264 }
265 }
266 /* }}} */
267
268 /* {{{ sapi_apache_read_post
269 */
sapi_apache_read_post(char * buffer,uint count_bytes TSRMLS_DC)270 static int sapi_apache_read_post(char *buffer, uint count_bytes TSRMLS_DC)
271 {
272 uint total_read_bytes=0, read_bytes;
273 request_rec *r = (request_rec *) SG(server_context);
274 void (*handler)(int);
275
276 /*
277 * This handles the situation where the browser sends a Expect: 100-continue header
278 * and needs to receive confirmation from the server on whether or not it can send
279 * the rest of the request. RFC 2616
280 *
281 */
282 if (!SG(read_post_bytes) && !ap_should_client_block(r)) {
283 return total_read_bytes;
284 }
285
286 handler = signal(SIGPIPE, SIG_IGN);
287 while (total_read_bytes<count_bytes) {
288 hard_timeout("Read POST information", r); /* start timeout timer */
289 read_bytes = get_client_block(r, buffer+total_read_bytes, count_bytes-total_read_bytes);
290 reset_timeout(r);
291 if (read_bytes<=0) {
292 break;
293 }
294 total_read_bytes += read_bytes;
295 }
296 signal(SIGPIPE, handler);
297 return total_read_bytes;
298 }
299 /* }}} */
300
301 /* {{{ sapi_apache_read_cookies
302 */
sapi_apache_read_cookies(TSRMLS_D)303 static char *sapi_apache_read_cookies(TSRMLS_D)
304 {
305 return (char *) table_get(((request_rec *) SG(server_context))->subprocess_env, "HTTP_COOKIE");
306 }
307 /* }}} */
308
309 /* {{{ sapi_apache_header_handler
310 */
sapi_apache_header_handler(sapi_header_struct * sapi_header,sapi_header_op_enum op,sapi_headers_struct * sapi_headers TSRMLS_DC)311 static int sapi_apache_header_handler(sapi_header_struct *sapi_header, sapi_header_op_enum op, sapi_headers_struct *sapi_headers TSRMLS_DC)
312 {
313 char *header_name, *header_content, *p;
314 request_rec *r = (request_rec *) SG(server_context);
315 if(!r) {
316 return 0;
317 }
318
319 switch(op) {
320 case SAPI_HEADER_DELETE_ALL:
321 clear_table(r->headers_out);
322 return 0;
323
324 case SAPI_HEADER_DELETE:
325 table_unset(r->headers_out, sapi_header->header);
326 return 0;
327
328 case SAPI_HEADER_ADD:
329 case SAPI_HEADER_REPLACE:
330 header_name = sapi_header->header;
331
332 header_content = p = strchr(header_name, ':');
333 if (!p) {
334 return 0;
335 }
336
337 *p = 0;
338 do {
339 header_content++;
340 } while (*header_content==' ');
341
342 if (!strcasecmp(header_name, "Content-Type")) {
343 r->content_type = pstrdup(r->pool, header_content);
344 } else if (!strcasecmp(header_name, "Set-Cookie")) {
345 table_add(r->headers_out, header_name, header_content);
346 } else if (op == SAPI_HEADER_REPLACE) {
347 table_set(r->headers_out, header_name, header_content);
348 } else {
349 table_add(r->headers_out, header_name, header_content);
350 }
351
352 *p = ':'; /* a well behaved header handler shouldn't change its original arguments */
353
354 return SAPI_HEADER_ADD;
355
356 default:
357 return 0;
358 }
359 }
360 /* }}} */
361
362 /* {{{ sapi_apache_send_headers
363 */
sapi_apache_send_headers(sapi_headers_struct * sapi_headers TSRMLS_DC)364 static int sapi_apache_send_headers(sapi_headers_struct *sapi_headers TSRMLS_DC)
365 {
366 if(SG(server_context) == NULL) { /* server_context is not here anymore */
367 return SAPI_HEADER_SEND_FAILED;
368 }
369
370 ((request_rec *) SG(server_context))->status = SG(sapi_headers).http_response_code;
371 /* check that we haven't sent headers already, we use our own
372 * headers_sent since we may send headers at anytime
373 */
374 if(!AP(headers_sent)) {
375 send_http_header((request_rec *) SG(server_context));
376 AP(headers_sent) = 1;
377 }
378 return SAPI_HEADER_SENT_SUCCESSFULLY;
379 }
380 /* }}} */
381
382 /* {{{ sapi_apache_register_server_variables
383 */
sapi_apache_register_server_variables(zval * track_vars_array TSRMLS_DC)384 static void sapi_apache_register_server_variables(zval *track_vars_array TSRMLS_DC)
385 {
386 register int i;
387 array_header *arr = table_elts(((request_rec *) SG(server_context))->subprocess_env);
388 table_entry *elts = (table_entry *) arr->elts;
389 zval **path_translated;
390 HashTable *symbol_table;
391
392 for (i = 0; i < arr->nelts; i++) {
393 char *val;
394
395 if (elts[i].val) {
396 val = elts[i].val;
397 } else {
398 val = "";
399 }
400 php_register_variable(elts[i].key, val, track_vars_array TSRMLS_CC);
401 }
402
403 /* If PATH_TRANSLATED doesn't exist, copy it from SCRIPT_FILENAME */
404 if (track_vars_array) {
405 symbol_table = track_vars_array->value.ht;
406 } else {
407 symbol_table = NULL;
408 }
409 if (symbol_table
410 && !zend_hash_exists(symbol_table, "PATH_TRANSLATED", sizeof("PATH_TRANSLATED"))
411 && zend_hash_find(symbol_table, "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME"), (void **) &path_translated)==SUCCESS) {
412 php_register_variable("PATH_TRANSLATED", Z_STRVAL_PP(path_translated), track_vars_array TSRMLS_CC);
413 }
414
415 php_register_variable("PHP_SELF", ((request_rec *) SG(server_context))->uri, track_vars_array TSRMLS_CC);
416 }
417 /* }}} */
418
419 /* {{{ php_apache_startup
420 */
php_apache_startup(sapi_module_struct * sapi_module)421 static int php_apache_startup(sapi_module_struct *sapi_module)
422 {
423 if (php_module_startup(sapi_module, &apache_module_entry, 1) == FAILURE) {
424 return FAILURE;
425 } else {
426 return SUCCESS;
427 }
428 }
429 /* }}} */
430
431 /* {{{ php_apache_log_message
432 */
php_apache_log_message(char * message TSRMLS_DC)433 static void php_apache_log_message(char *message TSRMLS_DC)
434 {
435 if (SG(server_context)) {
436 #if MODULE_MAGIC_NUMBER >= 19970831
437 aplog_error(NULL, 0, APLOG_ERR | APLOG_NOERRNO, ((request_rec *) SG(server_context))->server, "%s", message);
438 #else
439 log_error(message, ((request_rec *) SG(server_context))->server);
440 #endif
441 } else {
442 fprintf(stderr, "%s", message);
443 fprintf(stderr, "\n");
444 }
445 }
446 /* }}} */
447
448 /* {{{ php_apache_request_shutdown
449 */
php_apache_request_shutdown(void * dummy)450 static void php_apache_request_shutdown(void *dummy)
451 {
452 TSRMLS_FETCH();
453 AP(current_hook) = AP_CLEANUP;
454 php_output_set_status(PHP_OUTPUT_DISABLED TSRMLS_CC);
455 SG(server_context) = NULL; /* The server context (request) is invalid by the time run_cleanups() is called */
456 if(SG(sapi_started)) {
457 php_request_shutdown(dummy);
458 SG(sapi_started) = 0;
459 }
460 AP(in_request) = 0;
461 if(AP(setup_env)) {
462 AP(setup_env) = 0;
463 }
464 AP(current_hook) = AP_WAITING_FOR_REQUEST;
465 AP(headers_sent) = 0;
466 }
467 /* }}} */
468
469 /* {{{ php_apache_sapi_activate
470 */
php_apache_sapi_activate(TSRMLS_D)471 static int php_apache_sapi_activate(TSRMLS_D)
472 {
473 request_rec *r = (request_rec *) SG(server_context);
474
475 /*
476 * For the Apache module version, this bit of code registers a cleanup
477 * function that gets triggered when our request pool is destroyed.
478 * We need this because at any point in our code we can be interrupted
479 * and that may happen before we have had time to free our memory.
480 * The php_request_shutdown function needs to free all outstanding allocated
481 * memory.
482 */
483 block_alarms();
484 register_cleanup(r->pool, NULL, php_apache_request_shutdown, php_request_shutdown_for_exec);
485 AP(in_request)=1;
486 unblock_alarms();
487
488 /* Override the default headers_only value - sometimes "GET" requests should actually only
489 * send headers.
490 */
491 SG(request_info).headers_only = r->header_only;
492 return SUCCESS;
493 }
494 /* }}} */
495
496 /* {{{ php_apache_get_stat
497 */
php_apache_get_stat(TSRMLS_D)498 static struct stat *php_apache_get_stat(TSRMLS_D)
499 {
500 return &((request_rec *) SG(server_context))->finfo;
501 }
502 /* }}} */
503
504 /* {{{ php_apache_getenv
505 */
php_apache_getenv(char * name,size_t name_len TSRMLS_DC)506 static char *php_apache_getenv(char *name, size_t name_len TSRMLS_DC)
507 {
508 return (char *) table_get(((request_rec *) SG(server_context))->subprocess_env, name);
509 }
510 /* }}} */
511
512 /* {{{ sapi_module_struct apache_sapi_module
513 */
514 static sapi_module_struct apache_sapi_module = {
515 "apache", /* name */
516 "Apache", /* pretty name */
517
518 php_apache_startup, /* startup */
519 php_module_shutdown_wrapper, /* shutdown */
520
521 php_apache_sapi_activate, /* activate */
522 NULL, /* deactivate */
523
524 sapi_apache_ub_write, /* unbuffered write */
525 sapi_apache_flush, /* flush */
526 php_apache_get_stat, /* get uid */
527 php_apache_getenv, /* getenv */
528
529 php_error, /* error handler */
530
531 sapi_apache_header_handler, /* header handler */
532 sapi_apache_send_headers, /* send headers handler */
533 NULL, /* send header handler */
534
535 sapi_apache_read_post, /* read POST data */
536 sapi_apache_read_cookies, /* read Cookies */
537
538 sapi_apache_register_server_variables, /* register server variables */
539 php_apache_log_message, /* Log message */
540 NULL, /* Get request time */
541 NULL, /* child terminate */
542
543 NULL, /* php.ini path override */
544
545 #ifdef PHP_WIN32
546 NULL,
547 NULL,
548 #else
549 block_alarms, /* Block interruptions */
550 unblock_alarms, /* Unblock interruptions */
551 #endif
552
553 NULL, /* default post reader */
554 NULL, /* treat data */
555 NULL, /* exe location */
556 0, /* ini ignore */
557 NULL
558
559 };
560 /* }}} */
561
562 /* {{{ php_restore_umask
563 */
php_restore_umask(void)564 static void php_restore_umask(void)
565 {
566 umask(saved_umask);
567 }
568 /* }}} */
569
570 /* {{{ init_request_info
571 */
init_request_info(TSRMLS_D)572 static void init_request_info(TSRMLS_D)
573 {
574 request_rec *r = ((request_rec *) SG(server_context));
575 char *content_length = (char *) table_get(r->subprocess_env, "CONTENT_LENGTH");
576 const char *authorization=NULL;
577 char *tmp, *tmp_user;
578
579 SG(request_info).query_string = r->args;
580 SG(request_info).path_translated = r->filename;
581 SG(request_info).request_uri = r->uri;
582 SG(request_info).request_method = (char *)r->method;
583 SG(request_info).proto_num = r->proto_num;
584 SG(request_info).content_type = (char *) table_get(r->subprocess_env, "CONTENT_TYPE");
585 SG(request_info).content_length = (content_length ? atol(content_length) : 0);
586 SG(sapi_headers).http_response_code = r->status;
587
588 if (r->headers_in) {
589 authorization = table_get(r->headers_in, "Authorization");
590 }
591
592 SG(request_info).auth_user = NULL;
593 SG(request_info).auth_password = NULL;
594
595 if (authorization && !auth_type(r)) {
596 if (!strcasecmp(getword(r->pool, &authorization, ' '), "Basic")) {
597 tmp = uudecode(r->pool, authorization);
598 tmp_user = getword_nulls_nc(r->pool, &tmp, ':');
599 if (tmp_user) {
600 r->connection->user = pstrdup(r->connection->pool, tmp_user);
601 r->connection->ap_auth_type = "Basic";
602 SG(request_info).auth_user = estrdup(tmp_user);
603 }
604 if (tmp) {
605 SG(request_info).auth_password = estrdup(tmp);
606 }
607 } else if (!strcasecmp(getword(r->pool, &authorization, ' '), "Digest")) {
608 r->connection->ap_auth_type = "Digest";
609 SG(request_info).auth_digest = estrdup(authorization);
610 }
611 }
612 }
613 /* }}} */
614
615 /* {{{ php_apache_alter_ini_entries
616 */
php_apache_alter_ini_entries(php_per_dir_entry * per_dir_entry TSRMLS_DC)617 static int php_apache_alter_ini_entries(php_per_dir_entry *per_dir_entry TSRMLS_DC)
618 {
619 zend_alter_ini_entry(per_dir_entry->key, per_dir_entry->key_length+1, per_dir_entry->value, per_dir_entry->value_length, per_dir_entry->type, PHP_INI_STAGE_ACTIVATE);
620 return 0;
621 }
622 /* }}} */
623
624 /* {{{ php_apache_get_default_mimetype
625 */
php_apache_get_default_mimetype(request_rec * r TSRMLS_DC)626 static char *php_apache_get_default_mimetype(request_rec *r TSRMLS_DC)
627 {
628
629 char *mimetype;
630 if (SG(default_mimetype) || SG(default_charset)) {
631 /* Assume output will be of the default MIME type. Individual
632 scripts may change this later. */
633 char *tmpmimetype;
634 tmpmimetype = sapi_get_default_content_type(TSRMLS_C);
635 mimetype = pstrdup(r->pool, tmpmimetype);
636 efree(tmpmimetype);
637 } else {
638 mimetype = SAPI_DEFAULT_MIMETYPE "; charset=" SAPI_DEFAULT_CHARSET;
639 }
640 return mimetype;
641 }
642 /* }}} */
643
644 /* {{{ send_php
645 */
send_php(request_rec * r,int display_source_mode,char * filename)646 static int send_php(request_rec *r, int display_source_mode, char *filename)
647 {
648 int retval;
649 php_per_dir_config *per_dir_conf;
650 TSRMLS_FETCH();
651 if (AP(in_request)) {
652 zend_file_handle fh;
653
654 fh.filename = r->filename;
655 fh.opened_path = NULL;
656 fh.free_filename = 0;
657 fh.type = ZEND_HANDLE_FILENAME;
658
659 zend_execute_scripts(ZEND_INCLUDE TSRMLS_CC, NULL, 1, &fh);
660 return OK;
661 }
662
663 zend_first_try {
664
665 /* Make sure file exists */
666 if (filename == NULL && r->finfo.st_mode == 0) {
667 return DECLINED;
668 }
669
670 per_dir_conf = (php_per_dir_config *) get_module_config(r->per_dir_config, &php5_module);
671 if (per_dir_conf) {
672 zend_hash_apply((HashTable *) per_dir_conf->ini_settings, (apply_func_t) php_apache_alter_ini_entries TSRMLS_CC);
673 }
674
675 /* If PHP parser engine has been turned off with an "engine off"
676 * directive, then decline to handle this request
677 */
678 if (!AP(engine)) {
679 r->content_type = php_apache_get_default_mimetype(r TSRMLS_CC);
680 r->allowed |= (1 << METHODS) - 1;
681 zend_try {
682 zend_ini_deactivate(TSRMLS_C);
683 } zend_end_try();
684 return DECLINED;
685 }
686 if (filename == NULL) {
687 filename = r->filename;
688 }
689
690 /* Apache 1.2 has a more complex mechanism for reading POST data */
691 #if MODULE_MAGIC_NUMBER > 19961007
692 if ((retval = setup_client_block(r, REQUEST_CHUNKED_ERROR))) {
693 zend_try {
694 zend_ini_deactivate(TSRMLS_C);
695 } zend_end_try();
696 return retval;
697 }
698 #endif
699
700 if (AP(last_modified)) {
701 #if MODULE_MAGIC_NUMBER < 19970912
702 if ((retval = set_last_modified(r, r->finfo.st_mtime))) {
703 zend_try {
704 zend_ini_deactivate(TSRMLS_C);
705 } zend_end_try();
706 return retval;
707 }
708 #else
709 update_mtime (r, r->finfo.st_mtime);
710 set_last_modified(r);
711 set_etag(r);
712 #endif
713 }
714 /* Assume output will be of the default MIME type. Individual
715 scripts may change this later in the request. */
716 r->content_type = php_apache_get_default_mimetype(r TSRMLS_CC);
717
718 /* Init timeout */
719 hard_timeout("send", r);
720
721 SG(server_context) = r;
722
723 php_save_umask();
724 if(!AP(setup_env)) {
725 AP(setup_env) = 1;
726 add_common_vars(r);
727 add_cgi_vars(r);
728 }
729 init_request_info(TSRMLS_C);
730 apache_php_module_main(r, display_source_mode TSRMLS_CC);
731
732 /* Done, restore umask, turn off timeout, close file and return */
733 php_restore_umask();
734 kill_timeout(r);
735 } zend_end_try();
736
737 return OK;
738 }
739 /* }}} */
740
741 /* {{{ send_parsed_php
742 */
send_parsed_php(request_rec * r)743 static int send_parsed_php(request_rec * r)
744 {
745 int result = send_php(r, 0, NULL);
746 TSRMLS_FETCH();
747
748 ap_table_setn(r->notes, "mod_php_memory_usage",
749 ap_psprintf(r->pool, "%u", zend_memory_peak_usage(1 TSRMLS_CC)));
750
751 return result;
752 }
753 /* }}} */
754
755 /* {{{ send_parsed_php_source
756 */
send_parsed_php_source(request_rec * r)757 static int send_parsed_php_source(request_rec * r)
758 {
759 return send_php(r, 1, NULL);
760 }
761 /* }}} */
762
763
764 /* {{{ destroy_per_dir_entry
765 */
destroy_per_dir_entry(php_per_dir_entry * per_dir_entry)766 static void destroy_per_dir_entry(php_per_dir_entry *per_dir_entry)
767 {
768 free(per_dir_entry->key);
769 free(per_dir_entry->value);
770 }
771 /* }}} */
772
773 /* {{{ copy_per_dir_entry
774 */
copy_per_dir_entry(php_per_dir_entry * per_dir_entry)775 static void copy_per_dir_entry(php_per_dir_entry *per_dir_entry)
776 {
777 php_per_dir_entry tmp = *per_dir_entry;
778
779 per_dir_entry->key = (char *) malloc(tmp.key_length+1);
780 memcpy(per_dir_entry->key, tmp.key, tmp.key_length);
781 per_dir_entry->key[per_dir_entry->key_length] = 0;
782
783 per_dir_entry->value = (char *) malloc(tmp.value_length+1);
784 memcpy(per_dir_entry->value, tmp.value, tmp.value_length);
785 per_dir_entry->value[per_dir_entry->value_length] = 0;
786 }
787 /* }}} */
788
789 /* {{{ should_overwrite_per_dir_entry;
790
791 */
should_overwrite_per_dir_entry(HashTable * target_ht,php_per_dir_entry * orig_per_dir_entry,zend_hash_key * hash_key,void * pData)792 static zend_bool should_overwrite_per_dir_entry(HashTable *target_ht, php_per_dir_entry *orig_per_dir_entry, zend_hash_key *hash_key, void *pData)
793 {
794 php_per_dir_entry *new_per_dir_entry;
795
796 if (zend_hash_find(target_ht, hash_key->arKey, hash_key->nKeyLength, (void **) &new_per_dir_entry)==FAILURE) {
797 return 1; /* does not exist in dest, copy from source */
798 }
799
800 if (new_per_dir_entry->type==PHP_INI_SYSTEM
801 && orig_per_dir_entry->type!=PHP_INI_SYSTEM) {
802 return 1;
803 } else {
804 return 0;
805 }
806 }
807 /* }}} */
808 /* {{{ php_destroy_per_server_info
809 */
php_destroy_per_server_info(php_per_server_config * conf)810 static void php_destroy_per_server_info(php_per_server_config *conf)
811 {
812 php_handler_stack_destroy(&conf->requires);
813 php_handler_stack_destroy(&conf->uri_handlers);
814 }
815 /* }}} */
816
817 /* {{{ php_destroy_per_dir_info
818 */
php_destroy_per_dir_info(php_per_dir_config * conf)819 static void php_destroy_per_dir_info(php_per_dir_config *conf)
820 {
821 zend_hash_destroy(conf->ini_settings);
822 php_handler_stack_destroy(&conf->response_handlers);
823 php_handler_stack_destroy(&conf->auth_handlers);
824 php_handler_stack_destroy(&conf->access_handlers);
825 php_handler_stack_destroy(&conf->type_handlers);
826 php_handler_stack_destroy(&conf->fixup_handlers);
827 php_handler_stack_destroy(&conf->logger_handlers);
828 php_handler_stack_destroy(&conf->post_read_handlers);
829 php_handler_stack_destroy(&conf->headers_handlers);
830 free(conf->ini_settings);
831 }
832 /* }}} */
833
834 /* {{{ php_create_server
835 */
php_create_server(pool * p,char * dummy)836 static void *php_create_server(pool *p, char *dummy)
837 {
838 php_per_server_config *conf;
839 conf = (php_per_server_config *) malloc(sizeof(php_per_server_config));
840 register_cleanup(p, (void *) conf, (void (*)(void *)) php_destroy_per_server_info, (void (*)(void *)) php_destroy_per_server_info);
841
842 sapi_stack_init_ex(&conf->requires, 1);
843 sapi_stack_init_ex(&conf->uri_handlers, 1);
844 return conf;
845 }
846
847 /* }}} */
848
849
850 /* {{{ php_create_dir
851 */
php_create_dir(pool * p,char * dummy)852 static void *php_create_dir(pool *p, char *dummy)
853 {
854 php_per_dir_config *conf;
855 conf = (php_per_dir_config *) malloc(sizeof(php_per_dir_config));
856 conf->ini_settings = (HashTable *) malloc(sizeof(HashTable));
857 zend_hash_init_ex(conf->ini_settings, 5, NULL, (void (*)(void *)) destroy_per_dir_entry, 1, 0);
858 sapi_stack_init_ex(&conf->response_handlers, 1);
859 sapi_stack_init_ex(&conf->headers_handlers, 1);
860 sapi_stack_init_ex(&conf->auth_handlers, 1);
861 sapi_stack_init_ex(&conf->access_handlers, 1);
862 sapi_stack_init_ex(&conf->type_handlers, 1);
863 sapi_stack_init_ex(&conf->fixup_handlers, 1);
864 sapi_stack_init_ex(&conf->logger_handlers, 1);
865 sapi_stack_init_ex(&conf->post_read_handlers, 1);
866 register_cleanup(p, (void *) conf, (void (*)(void *)) php_destroy_per_dir_info, (void (*)(void *)) php_destroy_per_dir_info);
867
868 return conf;
869 }
870
871 /* }}} */
872
873 /* {{{ php_merge_dir
874 */
php_merge_dir(pool * p,void * basev,void * addv)875 static void *php_merge_dir(pool *p, void *basev, void *addv)
876 {
877 php_per_dir_config *a = (php_per_dir_config *) addv;
878 php_per_dir_config *b = (php_per_dir_config *) basev;
879 /* This function *must* return addv, and not modify basev */
880 zend_hash_merge_ex((HashTable *) a->ini_settings, (HashTable *) b->ini_settings, (copy_ctor_func_t) copy_per_dir_entry, sizeof(php_per_dir_entry), (merge_checker_func_t) should_overwrite_per_dir_entry, NULL);
881 a->headers_handlers = (a->headers_handlers.top)?a->headers_handlers:b->headers_handlers;
882 a->auth_handlers = (a->auth_handlers.top)?a->auth_handlers:b->auth_handlers;
883 a->access_handlers = (a->access_handlers.top)?a->access_handlers:b->access_handlers;
884 a->type_handlers = (a->type_handlers.top)?a->type_handlers:b->type_handlers;
885 a->fixup_handlers = (a->fixup_handlers.top)?a->fixup_handlers:b->fixup_handlers;
886 a->logger_handlers = (a->logger_handlers.top)?a->logger_handlers:b->logger_handlers;
887 a->post_read_handlers = (a->post_read_handlers.top)?a->post_read_handlers:b->post_read_handlers;
888 a->response_handlers = (a->response_handlers.top)?a->response_handlers:b->response_handlers;
889 return a;
890 }
891 /* }}} */
892
893 /* {{{ php_apache_value_handler_ex
894 */
php_apache_value_handler_ex(cmd_parms * cmd,HashTable * conf,char * arg1,char * arg2,int mode)895 static CONST_PREFIX char *php_apache_value_handler_ex(cmd_parms *cmd, HashTable *conf, char *arg1, char *arg2, int mode)
896 {
897 php_per_dir_entry per_dir_entry;
898
899 if (!apache_php_initialized) {
900 apache_php_initialized = 1;
901 #ifdef ZTS
902 tsrm_startup(1, 1, 0, NULL);
903 #endif
904 sapi_startup(&apache_sapi_module);
905 php_apache_startup(&apache_sapi_module);
906 }
907 per_dir_entry.type = mode;
908
909 if (strcasecmp(arg2, "none") == 0) {
910 arg2 = "";
911 }
912
913 per_dir_entry.key_length = strlen(arg1);
914 per_dir_entry.value_length = strlen(arg2);
915
916 per_dir_entry.key = (char *) malloc(per_dir_entry.key_length+1);
917 memcpy(per_dir_entry.key, arg1, per_dir_entry.key_length);
918 per_dir_entry.key[per_dir_entry.key_length] = 0;
919
920 per_dir_entry.value = (char *) malloc(per_dir_entry.value_length+1);
921 memcpy(per_dir_entry.value, arg2, per_dir_entry.value_length);
922 per_dir_entry.value[per_dir_entry.value_length] = 0;
923
924 zend_hash_update(conf, per_dir_entry.key, per_dir_entry.key_length, &per_dir_entry, sizeof(php_per_dir_entry), NULL);
925 return NULL;
926 }
927 /* }}} */
928
php_set_server_handler(server_rec * s,char * arg1,long handler_stage,long handler_type)929 static CONST_PREFIX char *php_set_server_handler(server_rec *s, char *arg1, long handler_stage, long handler_type)
930 {
931 php_per_server_config *conf;
932 php_handler *handler;
933 handler = (php_handler *) malloc(sizeof(php_handler));
934 handler->type = handler_type;
935 handler->stage = handler_stage;
936 handler->name = strdup(arg1);
937 conf = get_module_config(s->module_config, &php5_module);
938 switch(handler_stage) {
939 case AP_URI_TRANS:
940 sapi_stack_push(&conf->uri_handlers, handler);
941 break;
942 default:
943 sapi_stack_push(&conf->requires, handler);
944 break;
945 }
946 return NULL;
947 }
948
php_set_dir_handler(php_per_dir_config * conf,char * arg1,long handler_stage,long handler_type)949 static CONST_PREFIX char *php_set_dir_handler(php_per_dir_config *conf, char *arg1, long handler_stage, long handler_type)
950 {
951 php_handler *handler;
952 handler = (php_handler *) malloc(sizeof(php_handler));
953 handler->type = handler_type;
954 handler->stage = handler_stage;
955 handler->name = strdup(arg1);
956 switch(handler_stage) {
957 case AP_POST_READ:
958 sapi_stack_push(&conf->post_read_handlers, handler);
959 break;
960 case AP_HEADER_PARSE:
961 sapi_stack_push(&conf->headers_handlers, handler);
962 break;
963 case AP_ACCESS_CONTROL:
964 sapi_stack_push(&conf->access_handlers, handler);
965 break;
966 case AP_AUTHENTICATION:
967 sapi_stack_push(&conf->auth_handlers, handler);
968 break;
969 case AP_AUTHORIZATION:
970 break;
971 case AP_TYPE_CHECKING:
972 sapi_stack_push(&conf->type_handlers, handler);
973 break;
974 case AP_FIXUP:
975 sapi_stack_push(&conf->fixup_handlers, handler);
976 break;
977 case AP_RESPONSE:
978 sapi_stack_push(&conf->response_handlers, handler);
979 break;
980 case AP_LOGGING:
981 sapi_stack_push(&conf->logger_handlers, handler);
982 break;
983 default:
984 break;
985 }
986 return NULL;
987 }
988
989 /* {{{ php_set_uri_handler
990 */
php_set_uri_handler(cmd_parms * cmd,void * dummy,char * arg1)991 static CONST_PREFIX char *php_set_uri_handler(cmd_parms *cmd, void *dummy, char *arg1)
992 {
993 return php_set_server_handler(cmd->server, arg1, AP_URI_TRANS, AP_HANDLER_TYPE_FILE);
994 }
995 /* }}} */
996
997 /* {{{ php_set_uri_handler_code */
php_set_uri_handler_code(cmd_parms * cmd,void * dummy,char * arg1)998 static CONST_PREFIX char *php_set_uri_handler_code(cmd_parms *cmd, void *dummy, char *arg1)
999 {
1000 return php_set_server_handler(cmd->server, arg1, AP_URI_TRANS, AP_HANDLER_TYPE_METHOD);
1001 }
1002 /* }}} */
1003
1004 /* {{{ php_set_header_handler
1005 */
php_set_header_handler(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1006 static CONST_PREFIX char *php_set_header_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1007 {
1008 return php_set_dir_handler(conf, arg1, AP_HEADER_PARSE, AP_HANDLER_TYPE_FILE);
1009 }
php_set_header_handler_code(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1010 static CONST_PREFIX char *php_set_header_handler_code(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1011 {
1012 return php_set_dir_handler(conf, arg1, AP_HEADER_PARSE, AP_HANDLER_TYPE_METHOD);
1013 }
1014 /* }}} */
1015
1016 /* {{{ php_set_auth_handler
1017 */
php_set_auth_handler(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1018 static CONST_PREFIX char *php_set_auth_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1019 {
1020 return php_set_dir_handler(conf, arg1, AP_AUTHENTICATION, AP_HANDLER_TYPE_FILE);
1021 }
php_set_auth_handler_code(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1022 static CONST_PREFIX char *php_set_auth_handler_code(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1023 {
1024 return php_set_dir_handler(conf, arg1, AP_AUTHENTICATION, AP_HANDLER_TYPE_METHOD);
1025 }
1026
1027 /* }}} */
1028
1029 /* {{{ php_set_access_handler
1030 */
php_set_access_handler(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1031 static CONST_PREFIX char *php_set_access_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1032 {
1033 return php_set_dir_handler(conf, arg1, AP_ACCESS_CONTROL, AP_HANDLER_TYPE_FILE);
1034 }
php_set_access_handler_code(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1035 static CONST_PREFIX char *php_set_access_handler_code(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1036 {
1037 return php_set_dir_handler(conf, arg1, AP_ACCESS_CONTROL, AP_HANDLER_TYPE_METHOD);
1038 }
1039
1040 /* }}} */
1041
1042 /* {{{ php_set_type_handler
1043 */
php_set_type_handler(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1044 static CONST_PREFIX char *php_set_type_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1045 {
1046 return php_set_dir_handler(conf, arg1, AP_TYPE_CHECKING, AP_HANDLER_TYPE_FILE);
1047 }
php_set_type_handler_code(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1048 static CONST_PREFIX char *php_set_type_handler_code(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1049 {
1050 return php_set_dir_handler(conf, arg1, AP_TYPE_CHECKING, AP_HANDLER_TYPE_METHOD);
1051 }
1052
1053 /* }}} */
1054
1055 /* {{{ php_set_fixup_handler
1056 */
php_set_fixup_handler(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1057 static CONST_PREFIX char *php_set_fixup_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1058 {
1059 return php_set_dir_handler(conf, arg1, AP_FIXUP, AP_HANDLER_TYPE_FILE);
1060 }
php_set_fixup_handler_code(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1061 static CONST_PREFIX char *php_set_fixup_handler_code(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1062 {
1063 return php_set_dir_handler(conf, arg1, AP_FIXUP, AP_HANDLER_TYPE_METHOD);
1064 }
1065 /* }}} */
1066
1067 /* {{{ php_set_logger_handler
1068 */
php_set_logger_handler(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1069 static CONST_PREFIX char *php_set_logger_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1070 {
1071 return php_set_dir_handler(conf, arg1, AP_LOGGING, AP_HANDLER_TYPE_FILE);
1072 }
php_set_logger_handler_code(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1073 static CONST_PREFIX char *php_set_logger_handler_code(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1074 {
1075 return php_set_dir_handler(conf, arg1, AP_LOGGING, AP_HANDLER_TYPE_METHOD);
1076 }
1077
1078 /* }}} */
1079
1080 /* {{{ php_set_post_read_handler
1081 */
php_set_post_read_handler(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1082 static CONST_PREFIX char *php_set_post_read_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1083 {
1084 return php_set_dir_handler(conf, arg1, AP_POST_READ, AP_HANDLER_TYPE_FILE);
1085 }
php_set_post_read_handler_code(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1086 static CONST_PREFIX char *php_set_post_read_handler_code(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1087 {
1088 return php_set_dir_handler(conf, arg1, AP_POST_READ, AP_HANDLER_TYPE_METHOD);
1089 }
1090
1091
1092 /* }}} */
1093
1094 /* {{{ php_set_require
1095 */
1096
php_set_require(cmd_parms * cmd,void * dummy,char * arg1)1097 static CONST_PREFIX char *php_set_require(cmd_parms *cmd, void *dummy, char *arg1)
1098 {
1099 return php_set_server_handler(cmd->server, arg1, 0, AP_HANDLER_TYPE_FILE);
1100 }
1101 /* }}} */
1102
1103 /* {{{ php_set_response_handler
1104 */
php_set_response_handler(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1105 static CONST_PREFIX char *php_set_response_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1106 {
1107 return php_set_dir_handler(conf, arg1, AP_RESPONSE, AP_HANDLER_TYPE_FILE);
1108 }
php_set_response_handler_code(cmd_parms * cmd,php_per_dir_config * conf,char * arg1)1109 static CONST_PREFIX char *php_set_response_handler_code(cmd_parms *cmd, php_per_dir_config *conf, char *arg1)
1110 {
1111 return php_set_dir_handler(conf, arg1, AP_RESPONSE, AP_HANDLER_TYPE_METHOD);
1112 }
1113 /* }}} */
1114
1115 /* {{{ php_apache_value_handler
1116 */
php_apache_value_handler(cmd_parms * cmd,php_per_dir_config * conf,char * arg1,char * arg2)1117 static CONST_PREFIX char *php_apache_value_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1, char *arg2)
1118 {
1119 return php_apache_value_handler_ex(cmd, conf->ini_settings, arg1, arg2, PHP_INI_PERDIR);
1120 }
1121 /* }}} */
1122
1123 /* {{{ php_apache_admin_value_handler
1124 */
php_apache_admin_value_handler(cmd_parms * cmd,php_per_dir_config * conf,char * arg1,char * arg2)1125 static CONST_PREFIX char *php_apache_admin_value_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1, char *arg2)
1126 {
1127 return php_apache_value_handler_ex(cmd, conf->ini_settings, arg1, arg2, PHP_INI_SYSTEM);
1128 }
1129 /* }}} */
1130
1131 /* {{{ php_apache_flag_handler_ex
1132 */
php_apache_flag_handler_ex(cmd_parms * cmd,HashTable * conf,char * arg1,char * arg2,int mode)1133 static CONST_PREFIX char *php_apache_flag_handler_ex(cmd_parms *cmd, HashTable *conf, char *arg1, char *arg2, int mode)
1134 {
1135 char bool_val[2];
1136
1137 if (!strcasecmp(arg2, "On")) {
1138 bool_val[0] = '1';
1139 } else {
1140 bool_val[0] = '0';
1141 }
1142 bool_val[1] = 0;
1143
1144 return php_apache_value_handler_ex(cmd, conf, arg1, bool_val, mode);
1145 }
1146 /* }}} */
1147
1148 /* {{{ php_apache_flag_handler
1149 */
php_apache_flag_handler(cmd_parms * cmd,php_per_dir_config * conf,char * arg1,char * arg2)1150 static CONST_PREFIX char *php_apache_flag_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1, char *arg2)
1151 {
1152 return php_apache_flag_handler_ex(cmd, conf->ini_settings, arg1, arg2, PHP_INI_PERDIR);
1153 }
1154 /* }}} */
1155
1156 /* {{{ php_apache_admin_flag_handler
1157 */
php_apache_admin_flag_handler(cmd_parms * cmd,php_per_dir_config * conf,char * arg1,char * arg2)1158 static CONST_PREFIX char *php_apache_admin_flag_handler(cmd_parms *cmd, php_per_dir_config *conf, char *arg1, char *arg2)
1159 {
1160 return php_apache_flag_handler_ex(cmd, conf->ini_settings, arg1, arg2, PHP_INI_SYSTEM);
1161 }
1162 /* }}} */
1163
1164 /* {{{ php_apache_phpini_set
1165 */
php_apache_phpini_set(cmd_parms * cmd,HashTable * conf,char * arg)1166 static CONST_PREFIX char *php_apache_phpini_set(cmd_parms *cmd, HashTable *conf, char *arg)
1167 {
1168 if (apache_sapi_module.php_ini_path_override) {
1169 return "Only first PHPINIDir directive honored per configuration tree - subsequent ones ignored";
1170 }
1171 apache_sapi_module.php_ini_path_override = ap_server_root_relative(cmd->pool, arg);
1172 return NULL;
1173 }
1174 /* }}} */
1175
1176 /* {{{ int php_xbithack_handler(request_rec * r)
1177 */
php_xbithack_handler(request_rec * r)1178 static int php_xbithack_handler(request_rec * r)
1179 {
1180 php_per_dir_config *conf;
1181 TSRMLS_FETCH();
1182
1183 if (!(r->finfo.st_mode & S_IXUSR)) {
1184 r->allowed |= (1 << METHODS) - 1;
1185 return DECLINED;
1186 }
1187 conf = (php_per_dir_config *) get_module_config(r->per_dir_config, &php5_module);
1188 if (conf) {
1189 zend_hash_apply((HashTable *) conf->ini_settings, (apply_func_t) php_apache_alter_ini_entries TSRMLS_CC);
1190 }
1191 if(!AP(xbithack)) {
1192 r->allowed |= (1 << METHODS) - 1;
1193 zend_try {
1194 zend_ini_deactivate(TSRMLS_C);
1195 } zend_end_try();
1196 return DECLINED;
1197 }
1198 return send_parsed_php(r);
1199 }
1200 /* }}} */
1201
1202 /* {{{ apache_php_module_shutdown_wrapper
1203 */
apache_php_module_shutdown_wrapper(void)1204 static void apache_php_module_shutdown_wrapper(void)
1205 {
1206 apache_php_initialized = 0;
1207 apache_sapi_module.shutdown(&apache_sapi_module);
1208
1209 #if MODULE_MAGIC_NUMBER >= 19970728
1210 /* This function is only called on server exit if the apache API
1211 * child_exit handler exists, so shutdown globally
1212 */
1213 sapi_shutdown();
1214 #endif
1215
1216 #ifdef ZTS
1217 tsrm_shutdown();
1218 #endif
1219 }
1220 /* }}} */
1221
1222 #if MODULE_MAGIC_NUMBER >= 19970728
1223 /* {{{ php_child_exit_handler
1224 */
php_child_exit_handler(server_rec * s,pool * p)1225 static void php_child_exit_handler(server_rec *s, pool *p)
1226 {
1227 /* apache_php_initialized = 0; */
1228 apache_sapi_module.shutdown(&apache_sapi_module);
1229
1230 #ifdef ZTS
1231 tsrm_shutdown();
1232 #endif
1233 }
1234 /* }}} */
1235 #endif
1236
1237 /* {{{ void php_init_handler(server_rec *s, pool *p)
1238 */
php_init_handler(server_rec * s,pool * p)1239 static void php_init_handler(server_rec *s, pool *p)
1240 {
1241 register_cleanup(p, NULL, (void (*)(void *))apache_php_module_shutdown_wrapper, (void (*)(void *))php_module_shutdown_for_exec);
1242 if (!apache_php_initialized) {
1243 apache_php_initialized = 1;
1244 #ifdef ZTS
1245 tsrm_startup(1, 1, 0, NULL);
1246 #endif
1247 sapi_startup(&apache_sapi_module);
1248 php_apache_startup(&apache_sapi_module);
1249 }
1250 #if MODULE_MAGIC_NUMBER >= 19980527
1251 {
1252 TSRMLS_FETCH();
1253 if (PG(expose_php)) {
1254 ap_add_version_component("PHP/" PHP_VERSION);
1255 }
1256 }
1257 #endif
1258 }
1259 /* }}} */
1260
php_run_hook(php_handler * handler,request_rec * r)1261 static int php_run_hook(php_handler *handler, request_rec *r)
1262 {
1263 zval *ret = NULL;
1264 php_per_dir_config *conf;
1265
1266 TSRMLS_FETCH();
1267
1268 if(!AP(apache_config_loaded)) {
1269 conf = (php_per_dir_config *) get_module_config(r->per_dir_config, &php5_module);
1270 if (conf)
1271 zend_hash_apply((HashTable *)conf->ini_settings, (apply_func_t) php_apache_alter_ini_entries TSRMLS_CC);
1272 AP(apache_config_loaded) = 1;
1273 }
1274 if (!handler->name) {
1275 return DECLINED;
1276 }
1277 php_save_umask();
1278 if (!AP(setup_env)) {
1279 AP(setup_env) = 1;
1280 add_common_vars(r);
1281 add_cgi_vars(r);
1282 }
1283 SG(server_context) = r;
1284 init_request_info(TSRMLS_C);
1285 apache_php_module_hook(r, handler, &ret TSRMLS_CC);
1286 php_restore_umask();
1287 kill_timeout(r);
1288 if (ret) {
1289 convert_to_long(ret);
1290 return Z_LVAL_P(ret);
1291 }
1292 return HTTP_INTERNAL_SERVER_ERROR;
1293 }
1294
1295
php_uri_translation(request_rec * r)1296 static int php_uri_translation(request_rec *r)
1297 {
1298 php_per_server_config *conf;
1299 TSRMLS_FETCH();
1300 AP(current_hook) = AP_URI_TRANS;
1301 conf = (php_per_server_config *) get_module_config(r->server->module_config, &php5_module);
1302 return sapi_stack_apply_with_argument_stop_if_equals(&conf->uri_handlers,
1303 ZEND_STACK_APPLY_BOTTOMUP,
1304 (int (*)(void *element, void *)) php_run_hook, r, OK);
1305 }
1306
php_header_hook(request_rec * r)1307 static int php_header_hook(request_rec *r)
1308 {
1309 php_per_dir_config *conf;
1310 TSRMLS_FETCH();
1311 AP(current_hook) = AP_HEADER_PARSE;
1312 conf = (php_per_dir_config *) get_module_config(r->per_dir_config, &php5_module);
1313 return sapi_stack_apply_with_argument_stop_if_http_error(&conf->headers_handlers,
1314 ZEND_STACK_APPLY_BOTTOMUP,
1315 (int (*)(void *element, void *)) php_run_hook, r);
1316 }
1317
php_auth_hook(request_rec * r)1318 static int php_auth_hook(request_rec *r)
1319 {
1320 php_per_dir_config *conf;
1321 TSRMLS_FETCH();
1322 AP(current_hook) = AP_AUTHENTICATION;
1323 conf = (php_per_dir_config *) get_module_config(r->per_dir_config, &php5_module);
1324 return sapi_stack_apply_with_argument_stop_if_equals(&conf->auth_handlers,
1325 ZEND_STACK_APPLY_BOTTOMUP,
1326 (int (*)(void *element, void *)) php_run_hook, r, OK);
1327 }
1328
php_access_hook(request_rec * r)1329 static int php_access_hook(request_rec *r)
1330 {
1331 php_per_dir_config *conf;
1332 int status = DECLINED;
1333 TSRMLS_FETCH();
1334 AP(current_hook) = AP_ACCESS_CONTROL;
1335 conf = (php_per_dir_config *) get_module_config(r->per_dir_config, &php5_module);
1336 status = sapi_stack_apply_with_argument_stop_if_http_error(&conf->access_handlers,
1337 ZEND_STACK_APPLY_BOTTOMUP,
1338 (int (*)(void *element, void *)) php_run_hook, r);
1339 return status;
1340
1341 }
1342
php_type_hook(request_rec * r)1343 static int php_type_hook(request_rec *r)
1344 {
1345 php_per_dir_config *conf;
1346 TSRMLS_FETCH();
1347 AP(current_hook) = AP_TYPE_CHECKING;
1348 conf = (php_per_dir_config *) get_module_config(r->per_dir_config, &php5_module);
1349 return sapi_stack_apply_with_argument_stop_if_equals(&conf->type_handlers,
1350 ZEND_STACK_APPLY_BOTTOMUP,
1351 (int (*)(void *element, void *)) php_run_hook,
1352 r, OK);
1353 }
1354
php_fixup_hook(request_rec * r)1355 static int php_fixup_hook(request_rec *r)
1356 {
1357 php_per_dir_config *conf;
1358 TSRMLS_FETCH();
1359 AP(current_hook) = AP_FIXUP;
1360 conf = (php_per_dir_config *) get_module_config(r->per_dir_config, &php5_module);
1361 return sapi_stack_apply_with_argument_stop_if_http_error(&conf->fixup_handlers,
1362 ZEND_STACK_APPLY_BOTTOMUP,
1363 (int (*)(void *element, void *)) php_run_hook,
1364 r);
1365 }
1366
php_logger_hook(request_rec * r)1367 static int php_logger_hook(request_rec *r)
1368 {
1369 php_per_dir_config *conf;
1370 TSRMLS_FETCH();
1371 AP(current_hook) = AP_LOGGING;
1372 conf = (php_per_dir_config *) get_module_config(r->per_dir_config, &php5_module);
1373 return sapi_stack_apply_with_argument_stop_if_http_error(&conf->logger_handlers,
1374 ZEND_STACK_APPLY_BOTTOMUP,
1375 (int (*)(void *element, void *)) php_run_hook,
1376 r);
1377 }
1378
php_post_read_hook(request_rec * r)1379 static int php_post_read_hook(request_rec *r)
1380 {
1381 php_per_dir_config *conf;
1382 php_per_server_config *svr;
1383 TSRMLS_FETCH();
1384 AP(current_hook) = AP_POST_READ;
1385 svr = get_module_config(r->server->module_config, &php5_module);
1386 if(ap_is_initial_req(r)) {
1387 sapi_stack_apply_with_argument_all(&svr->requires, ZEND_STACK_APPLY_BOTTOMUP, (int (*)(void *element, void *)) php_run_hook, r);
1388 }
1389 conf = (php_per_dir_config *) get_module_config(r->per_dir_config, &php5_module);
1390 return sapi_stack_apply_with_argument_stop_if_http_error(&conf->post_read_handlers,
1391 ZEND_STACK_APPLY_BOTTOMUP,
1392 (int (*)(void *element, void *)) php_run_hook, r);
1393 }
1394
php_response_handler(request_rec * r)1395 static int php_response_handler(request_rec *r)
1396 {
1397 php_per_dir_config *conf;
1398 TSRMLS_FETCH();
1399 AP(current_hook) = AP_RESPONSE;
1400 conf = (php_per_dir_config *) get_module_config(r->per_dir_config, &php5_module);
1401 return sapi_stack_apply_with_argument_all(&conf->response_handlers, ZEND_STACK_APPLY_BOTTOMUP, (int (*)(void *element, void *)) php_run_hook, r);
1402 }
1403
1404 /* {{{ handler_rec php_handlers[]
1405 */
1406 handler_rec php_handlers[] =
1407 {
1408 {"application/x-httpd-php", send_parsed_php},
1409 {"application/x-httpd-php-source", send_parsed_php_source},
1410 {"text/html", php_xbithack_handler},
1411 {"php-script", php_response_handler},
1412 {NULL}
1413 };
1414 /* }}} */
1415
1416 /* {{{ command_rec php_commands[]
1417 */
1418 command_rec php_commands[] =
1419 {
1420 {"php_value", php_apache_value_handler, NULL, OR_OPTIONS, TAKE2, "PHP Value Modifier"},
1421 {"phpUriHandler", php_set_uri_handler, NULL, RSRC_CONF, TAKE1, "PHP Value Modifier"},
1422 {"phpUriHandlerMethod", php_set_uri_handler_code, NULL, RSRC_CONF, TAKE1, "PHP Value Modifier"},
1423 #if MODULE_MAGIC_NUMBER >= 19970103
1424 {"phpHeaderHandler", php_set_header_handler, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1425 {"phpHeaderHandlerMethod", php_set_header_handler_code, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1426 #endif
1427 {"phpAuthHandler", php_set_auth_handler, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1428 {"phpAuthHandlerMethod", php_set_auth_handler_code, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1429 {"phpAccessHandler", php_set_access_handler, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1430 {"phpAccessHandlerMethod", php_set_access_handler_code, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1431 {"phpTypeHandler", php_set_type_handler, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1432 {"phpTypeHandlerMethod", php_set_type_handler_code, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1433 {"phpFixupHandler", php_set_fixup_handler, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1434 {"phpFixupHandlerMethod", php_set_fixup_handler_code, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1435 {"phpLoggerHandler", php_set_logger_handler, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1436 {"phpLoggerHandlerMethod", php_set_logger_handler_code, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1437 #if MODULE_MAGIC_NUMBER >= 19970902
1438 {"phpPostReadHandler", php_set_post_read_handler, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1439 {"phpPostReadHandlerMethod", php_set_post_read_handler_code, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1440 {"phpRequire", php_set_require, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1441 {"phpResponseHandler", php_set_response_handler, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1442 {"phpResponseHandlerMethod", php_set_response_handler_code, NULL, OR_OPTIONS, TAKE1, "PHP Value Modifier"},
1443 #endif
1444 {"php_flag", php_apache_flag_handler, NULL, OR_OPTIONS, TAKE2, "PHP Flag Modifier"},
1445 {"php_admin_value", php_apache_admin_value_handler, NULL, ACCESS_CONF|RSRC_CONF, TAKE2, "PHP Value Modifier (Admin)"},
1446 {"php_admin_flag", php_apache_admin_flag_handler, NULL, ACCESS_CONF|RSRC_CONF, TAKE2, "PHP Flag Modifier (Admin)"},
1447 {"PHPINIDir", php_apache_phpini_set, NULL, RSRC_CONF, TAKE1, "Directory containing the php.ini file"},
1448 {NULL}
1449 };
1450 /* }}} */
1451
1452 /* {{{ module MODULE_VAR_EXPORT php5_module
1453 */
1454 module MODULE_VAR_EXPORT php5_module =
1455 {
1456 STANDARD_MODULE_STUFF,
1457 php_init_handler, /* initializer */
1458 php_create_dir, /* per-directory config creator */
1459 php_merge_dir, /* dir merger */
1460 php_create_server, /* per-server config creator */
1461 NULL, /* merge server config */
1462 php_commands, /* command table */
1463 php_handlers, /* handlers */
1464 php_uri_translation, /* filename translation */
1465 NULL, /* check_user_id */
1466 php_auth_hook, /* check auth */
1467 php_access_hook, /* check access */
1468 php_type_hook, /* type_checker */
1469 php_fixup_hook, /* fixups */
1470 php_logger_hook /* logger */
1471 #if MODULE_MAGIC_NUMBER >= 19970103
1472 , php_header_hook /* header parser */
1473 #endif
1474 #if MODULE_MAGIC_NUMBER >= 19970719
1475 , NULL /* child_init */
1476 #endif
1477 #if MODULE_MAGIC_NUMBER >= 19970728
1478 , php_child_exit_handler /* child_exit */
1479 #endif
1480 #if MODULE_MAGIC_NUMBER >= 19970902
1481 , php_post_read_hook /* post read-request */
1482 #endif
1483 };
1484 /* }}} */
1485
1486 /*
1487 * Local variables:
1488 * tab-width: 4
1489 * c-basic-offset: 4
1490 * End:
1491 * vim600: sw=4 ts=4 fdm=marker
1492 * vim<600: sw=4 ts=4
1493 */
1494