This source file includes following definitions.
- sapi_stack_init_ex
- sapi_stack_push
- sapi_stack_pop
- sapi_stack_destroy
- sapi_stack_apply_with_argument_all
- sapi_stack_apply_with_argument_stop_if_equals
- sapi_stack_apply_with_argument_stop_if_http_error
- php_handler_stack_destroy
- php_save_umask
- sapi_apache_ub_write
- sapi_apache_flush
- sapi_apache_read_post
- sapi_apache_read_cookies
- sapi_apache_header_handler
- sapi_apache_send_headers
- sapi_apache_register_server_variables
- php_apache_startup
- php_apache_log_message
- php_apache_request_shutdown
- php_apache_sapi_activate
- php_apache_get_stat
- php_apache_getenv
- php_restore_umask
- init_request_info
- php_apache_alter_ini_entries
- php_apache_get_default_mimetype
- send_php
- send_parsed_php
- send_parsed_php_source
- destroy_per_dir_entry
- copy_per_dir_entry
- should_overwrite_per_dir_entry
- php_destroy_per_server_info
- php_destroy_per_dir_info
- php_create_server
- php_create_dir
- php_merge_dir
- php_apache_value_handler_ex
- php_set_server_handler
- php_set_dir_handler
- php_set_uri_handler
- php_set_uri_handler_code
- php_set_header_handler
- php_set_header_handler_code
- php_set_auth_handler
- php_set_auth_handler_code
- php_set_access_handler
- php_set_access_handler_code
- php_set_type_handler
- php_set_type_handler_code
- php_set_fixup_handler
- php_set_fixup_handler_code
- php_set_logger_handler
- php_set_logger_handler_code
- php_set_post_read_handler
- php_set_post_read_handler_code
- php_set_require
- php_set_response_handler
- php_set_response_handler_code
- php_apache_value_handler
- php_apache_admin_value_handler
- php_apache_flag_handler_ex
- php_apache_flag_handler
- php_apache_admin_flag_handler
- php_apache_phpini_set
- php_xbithack_handler
- apache_php_module_shutdown_wrapper
- php_child_exit_handler
- php_init_handler
- php_run_hook
- php_uri_translation
- php_header_hook
- php_auth_hook
- php_access_hook
- php_type_hook
- php_fixup_hook
- php_logger_hook
- php_post_read_hook
- php_response_handler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 #include "php_apache_http.h"
23
24 #ifdef NETWARE
25 #define SIGPIPE SIGINT
26 #endif
27
28 #undef shutdown
29
30
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
88 #define USE_PATH 1
89 #define IGNORE_URL 2
90
91 module MODULE_VAR_EXPORT php5_module;
92
93 int saved_umask;
94
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
106
107
108
109
110
111
112
113
114
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 }
127 int sapi_stack_push(sapi_stack *stack, void *element)
128 {
129 if (stack->top >= stack->max) {
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 }
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
148 int sapi_stack_destroy(sapi_stack *stack)
149 {
150 return SUCCESS;
151 }
152
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
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
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
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
230
231 static void php_save_umask(void)
232 {
233 saved_umask = umask(077);
234 umask(saved_umask);
235 }
236
237
238
239
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
255
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
269
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
278
279
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);
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
302
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
310
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 = ':';
353
354 return SAPI_HEADER_ADD;
355
356 default:
357 return 0;
358 }
359 }
360
361
362
363
364 static int sapi_apache_send_headers(sapi_headers_struct *sapi_headers TSRMLS_DC)
365 {
366 if(SG(server_context) == NULL) {
367 return SAPI_HEADER_SEND_FAILED;
368 }
369
370 ((request_rec *) SG(server_context))->status = SG(sapi_headers).http_response_code;
371
372
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
383
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
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
420
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
432
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
449
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;
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
470
471 static int php_apache_sapi_activate(TSRMLS_D)
472 {
473 request_rec *r = (request_rec *) SG(server_context);
474
475
476
477
478
479
480
481
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
489
490
491 SG(request_info).headers_only = r->header_only;
492 return SUCCESS;
493 }
494
495
496
497
498 static struct stat *php_apache_get_stat(TSRMLS_D)
499 {
500 return &((request_rec *) SG(server_context))->finfo;
501 }
502
503
504
505
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
513
514 static sapi_module_struct apache_sapi_module = {
515 "apache",
516 "Apache",
517
518 php_apache_startup,
519 php_module_shutdown_wrapper,
520
521 php_apache_sapi_activate,
522 NULL,
523
524 sapi_apache_ub_write,
525 sapi_apache_flush,
526 php_apache_get_stat,
527 php_apache_getenv,
528
529 php_error,
530
531 sapi_apache_header_handler,
532 sapi_apache_send_headers,
533 NULL,
534
535 sapi_apache_read_post,
536 sapi_apache_read_cookies,
537
538 sapi_apache_register_server_variables,
539 php_apache_log_message,
540 NULL,
541 NULL,
542
543 NULL,
544
545 #ifdef PHP_WIN32
546 NULL,
547 NULL,
548 #else
549 block_alarms,
550 unblock_alarms,
551 #endif
552
553 NULL,
554 NULL,
555 NULL,
556 0,
557 NULL
558
559 };
560
561
562
563
564 static void php_restore_umask(void)
565 {
566 umask(saved_umask);
567 }
568
569
570
571
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
616
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
625
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
632
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
645
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
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
676
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
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
715
716 r->content_type = php_apache_get_default_mimetype(r TSRMLS_CC);
717
718
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
733 php_restore_umask();
734 kill_timeout(r);
735 } zend_end_try();
736
737 return OK;
738 }
739
740
741
742
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
756
757 static int send_parsed_php_source(request_rec * r)
758 {
759 return send_php(r, 1, NULL);
760 }
761
762
763
764
765
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
774
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
790
791
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;
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
809
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
818
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
835
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
851
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
874
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
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
894
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
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
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
990
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
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
1005
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 }
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
1017
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 }
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
1030
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 }
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
1043
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 }
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
1056
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 }
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
1068
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 }
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
1081
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 }
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
1095
1096
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
1104
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 }
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
1116
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
1124
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
1132
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
1149
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
1157
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
1165
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
1177
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
1203
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
1211
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
1224
1225 static void php_child_exit_handler(server_rec *s, pool *p)
1226 {
1227
1228 apache_sapi_module.shutdown(&apache_sapi_module);
1229
1230 #ifdef ZTS
1231 tsrm_shutdown();
1232 #endif
1233 }
1234
1235 #endif
1236
1237
1238
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
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
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
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
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
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
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
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
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
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
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
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
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
1453
1454 module MODULE_VAR_EXPORT php5_module =
1455 {
1456 STANDARD_MODULE_STUFF,
1457 php_init_handler,
1458 php_create_dir,
1459 php_merge_dir,
1460 php_create_server,
1461 NULL,
1462 php_commands,
1463 php_handlers,
1464 php_uri_translation,
1465 NULL,
1466 php_auth_hook,
1467 php_access_hook,
1468 php_type_hook,
1469 php_fixup_hook,
1470 php_logger_hook
1471 #if MODULE_MAGIC_NUMBER >= 19970103
1472 , php_header_hook
1473 #endif
1474 #if MODULE_MAGIC_NUMBER >= 19970719
1475 , NULL
1476 #endif
1477 #if MODULE_MAGIC_NUMBER >= 19970728
1478 , php_child_exit_handler
1479 #endif
1480 #if MODULE_MAGIC_NUMBER >= 19970902
1481 , php_post_read_hook
1482 #endif
1483 };
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493