xref: /PHP-5.3/sapi/apache_hooks/php_apache.c (revision a2045ff3)
1 /*
2    +----------------------------------------------------------------------+
3    | PHP Version 5                                                        |
4    +----------------------------------------------------------------------+
5    | Copyright (c) 1997-2013 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 through the world-wide-web at the following url:           |
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@lerdorf.on.ca>                       |
16    |          Stig S�ther Bakken <ssb@php.net>                            |
17    |          David Sklar <sklar@student.net>                             |
18    +----------------------------------------------------------------------+
19  */
20 /* $Id$ */
21 
22 #include "php_apache_http.h"
23 
24 #if defined(PHP_WIN32) || defined(NETWARE)
25 #include "zend.h"
26 #include "ap_compat.h"
27 #else
28 #include <build-defs.h>
29 #endif
30 
31 #ifdef ZTS
32 int php_apache_info_id;
33 #else
34 php_apache_info_struct php_apache_info;
35 #endif
36 
37 #define SECTION(name)  PUTS("<H2 align=\"center\">" name "</H2>\n")
38 
39 #undef offsetof
40 #define offsetof(s_type,field) ((size_t)&(((s_type*)0)->field))
41 
42 extern module *top_module;
43 extern module **ap_loaded_modules;
44 static int le_apachereq;
45 static zend_class_entry *apacherequest_class_entry;
46 
47 static void apache_table_to_zval(table *, int safe_mode, zval *return_value);
48 
49 PHP_FUNCTION(virtual);
50 PHP_FUNCTION(apache_request_headers);
51 PHP_FUNCTION(apache_response_headers);
52 PHP_FUNCTION(apachelog);
53 PHP_FUNCTION(apache_note);
54 PHP_FUNCTION(apache_lookup_uri);
55 PHP_FUNCTION(apache_child_terminate);
56 PHP_FUNCTION(apache_setenv);
57 PHP_FUNCTION(apache_get_version);
58 PHP_FUNCTION(apache_get_modules);
59 
60 PHP_MINFO_FUNCTION(apache);
61 
62 ZEND_BEGIN_ARG_INFO_EX(arginfo_apachehooks_virtual, 0, 0, 1)
63 	ZEND_ARG_INFO(0, filename)
64 ZEND_END_ARG_INFO()
65 
66 ZEND_BEGIN_ARG_INFO_EX(arginfo_apachehooks_setenv, 0, 0, 2)
67 	ZEND_ARG_INFO(0, variable)
68 	ZEND_ARG_INFO(0, value)
69 	ZEND_ARG_INFO(0, walk_to_top)
70 ZEND_END_ARG_INFO()
71 
72 ZEND_BEGIN_ARG_INFO_EX(arginfo_apachehooks_lookup_uri, 0, 0, 1)
73 	ZEND_ARG_INFO(0, uri)
74 ZEND_END_ARG_INFO()
75 
76 ZEND_BEGIN_ARG_INFO(arginfo_apachehooks__void, 0)
77 ZEND_END_ARG_INFO()
78 
79 ZEND_BEGIN_ARG_INFO_EX(arginfo_apachehooks_note, 0, 0, 1)
80 	ZEND_ARG_INFO(0, note_name)
81 	ZEND_ARG_INFO(0, note_value)
82 ZEND_END_ARG_INFO()
83 
84 const zend_function_entry apache_functions[] = {
85 	PHP_FE(virtual,									arginfo_apachehooks_virtual)
86 	PHP_FE(apache_request_headers,					arginfo_apachehooks__void)
87 	PHP_FE(apache_note,								arginfo_apachehooks_note)
88 	PHP_FE(apache_lookup_uri,						arginfo_apachehooks_lookup_uri)
89 	PHP_FE(apache_child_terminate,					arginfo_apachehooks__void)
90 	PHP_FE(apache_setenv,							arginfo_apachehooks_setenv)
91 	PHP_FE(apache_response_headers,					arginfo_apachehooks__void)
92 	PHP_FE(apache_get_version,						arginfo_apachehooks__void)
93 	PHP_FE(apache_get_modules,						arginfo_apachehooks__void)
94 	PHP_FALIAS(getallheaders, apache_request_headers, arginfo_apachehooks__void)
95 	{NULL, NULL, NULL}
96 };
97 
98 /* {{{ php_apache ini entries
99  */
100 PHP_INI_BEGIN()
101 	STD_PHP_INI_ENTRY("xbithack",			"0",				PHP_INI_ALL,		OnUpdateLong,		xbithack, php_apache_info_struct, php_apache_info)
102 	STD_PHP_INI_ENTRY("engine",				"1",				PHP_INI_ALL,		OnUpdateLong,		engine, php_apache_info_struct, php_apache_info)
103 	STD_PHP_INI_ENTRY("last_modified",		"0",				PHP_INI_ALL,		OnUpdateLong,		last_modified, php_apache_info_struct, php_apache_info)
104 	STD_PHP_INI_ENTRY("child_terminate",	"0",				PHP_INI_ALL,		OnUpdateLong,		terminate_child, php_apache_info_struct, php_apache_info)
PHP_INI_END()105 PHP_INI_END()
106 /* }}} */
107 
108 static void php_apache_globals_ctor(php_apache_info_struct *apache_globals TSRMLS_DC)
109 {
110 	apache_globals->in_request = 0;
111 }
112 
113 
114 #define APREQ_GET_THIS(ZVAL)		if (NULL == (ZVAL = getThis())) { \
115 										php_error(E_WARNING, "%s(): underlying ApacheRequest object missing", \
116 											get_active_function_name(TSRMLS_C)); \
117 										RETURN_FALSE; \
118 									}
119 #define APREQ_GET_REQUEST(ZVAL, R)	APREQ_GET_THIS(ZVAL); \
120 									R = get_apache_request(ZVAL TSRMLS_CC)
121 
php_apache_request_free(zend_rsrc_list_entry * rsrc TSRMLS_DC)122 static void php_apache_request_free(zend_rsrc_list_entry *rsrc TSRMLS_DC)
123 {
124 	zval *z = (zval *)rsrc->ptr;
125 /*	fprintf(stderr, "%s() %p\n", __FUNCTION__, z); */
126 	zval_ptr_dtor(&z);
127 }
128 
get_apache_request(zval * z TSRMLS_DC)129 static request_rec *get_apache_request(zval *z TSRMLS_DC)
130 {
131 	request_rec *r;
132 	zval **addr;
133 
134 	if (NULL == z) {
135 		php_error(E_WARNING, "get_apache_request() invalid wrapper passed");
136 		return NULL;
137 	}
138 
139 	if (Z_TYPE_P(z) != IS_OBJECT) {
140 		php_error(E_WARNING, "%s(): wrapper is not an object", get_active_function_name(TSRMLS_C));
141 		return NULL;
142 	}
143 
144 	if (zend_hash_index_find(Z_OBJPROP_P(z), 0, (void **)&addr) == FAILURE) {
145 		php_error(E_WARNING, "%s(): underlying object missing", get_active_function_name(TSRMLS_C));
146 		return NULL;
147 	}
148 
149 	r = (request_rec *)Z_LVAL_PP(addr);
150 	if (!r) {
151 		php_error(E_WARNING, "%s(): request_rec invalid", get_active_function_name(TSRMLS_C));
152 		return NULL;
153 	}
154 
155 	return r;
156 }
157 
158 /* {{{ php_apache_request_new(request_rec *r)
159  * create a new zval-instance for ApacheRequest that wraps request_rec
160  */
php_apache_request_new(request_rec * r)161 zval *php_apache_request_new(request_rec *r)
162 {
163 	zval *req;
164 	zval *addr;
165 
166 	TSRMLS_FETCH();
167 
168 	MAKE_STD_ZVAL(addr);
169 	Z_TYPE_P(addr) = IS_LONG;
170 	Z_LVAL_P(addr) = (int) r;
171 
172 	MAKE_STD_ZVAL(req);
173 	object_init_ex(req, apacherequest_class_entry);
174 	zend_hash_index_update(Z_OBJPROP_P(req), 0, &addr, sizeof(zval *), NULL);
175 
176 	return req;
177 }
178 /* }}} */
179 
180 /* {{{ apache_request_read_string_slot()
181  */
apache_request_read_string_slot(int offset,INTERNAL_FUNCTION_PARAMETERS)182 static void apache_request_read_string_slot(int offset, INTERNAL_FUNCTION_PARAMETERS)
183 {
184 	zval *id;
185 	request_rec *r;
186 	char *s;
187 
188 	if (zend_parse_parameters_none() == FAILURE) {
189 		return;
190 	}
191 
192 	APREQ_GET_REQUEST(id, r);
193 
194 	s = *(char **)((char*)r + offset);
195 
196 	if (s) {
197 		RETURN_STRING(s, 1);
198 	}
199 
200 	RETURN_EMPTY_STRING();
201 }
202 /* }}} */
203 
204 
205 /* {{{ apache_request_string_slot()
206  */
apache_request_string_slot(int offset,INTERNAL_FUNCTION_PARAMETERS)207 static void apache_request_string_slot(int offset, INTERNAL_FUNCTION_PARAMETERS)
208 {
209 	zval *id;
210 	request_rec *r;
211 	char *old_value, *new_value = NULL;
212 	int new_value_len;
213 	char **target;
214 
215 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &new_value, &new_value_len) == FAILURE) {
216 		return;
217 	}
218 
219 	APREQ_GET_REQUEST(id, r);
220 
221 	target = (char **)((char*)r + offset);
222 	old_value = *target;
223 
224 	if (new_value) {
225 		*target = ap_pstrdup(r->pool, new_value);
226 	}
227 
228 	if (old_value) {
229 		RETURN_STRING(old_value, 1);
230 	}
231 
232 	RETURN_EMPTY_STRING();
233 }
234 /* }}} */
235 
236 /* {{{ apache_request_read_int_slot()
237  */
apache_request_read_int_slot(int offset,INTERNAL_FUNCTION_PARAMETERS)238 static void apache_request_read_int_slot(int offset, INTERNAL_FUNCTION_PARAMETERS)
239 {
240 	zval *id;
241 	request_rec *r;
242 	long l;
243 
244 	if (zend_parse_parameters_none() == FAILURE) {
245 		return;
246 	}
247 
248 	APREQ_GET_REQUEST(id, r);
249 
250 	l = *(long *)((char*)r + offset);
251 
252 	RETURN_LONG(l);
253 }
254 /* }}} */
255 
256 /* {{{ apache_request_int_slot()
257  */
apache_request_int_slot(int offset,INTERNAL_FUNCTION_PARAMETERS)258 static void apache_request_int_slot(int offset, INTERNAL_FUNCTION_PARAMETERS)
259 {
260 	zval *id;
261 	request_rec *r;
262 	long old_value, new_value;
263 	long *target;
264 
265 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &new_value) == FAILURE) {
266 		return;
267 	}
268 
269 	APREQ_GET_REQUEST(id, r);
270 
271 	target = (long *)((char*)r + offset);
272 	old_value = *target;
273 
274 	switch (ZEND_NUM_ARGS()) {
275 		case 0:
276 			break;
277 		case 1:
278 			*target = new_value;
279 			break;
280 		default:
281 			WRONG_PARAM_COUNT;
282 			break;
283 	}
284 
285 	RETURN_LONG(old_value);
286 }
287 /* }}} */
288 
289 
290 /* {{{ access string slots of request rec
291  */
292 
293 /* {{{ proto string ApacheRequest::filename([string new_filename])
294  */
PHP_FUNCTION(apache_request_filename)295 PHP_FUNCTION(apache_request_filename)
296 {
297 	apache_request_string_slot(offsetof(request_rec, filename), INTERNAL_FUNCTION_PARAM_PASSTHRU);
298 }
299 /* }}} */
300 
301 /* {{{ proto string ApacheRequest::uri([string new_uri])
302  */
PHP_FUNCTION(apache_request_uri)303 PHP_FUNCTION(apache_request_uri)
304 {
305 	apache_request_string_slot(offsetof(request_rec, uri), INTERNAL_FUNCTION_PARAM_PASSTHRU);
306 }
307 /* }}} */
308 
309 /* {{{ proto string ApacheRequest::unparsed_uri([string new_unparsed_uri])
310  */
PHP_FUNCTION(apache_request_unparsed_uri)311 PHP_FUNCTION(apache_request_unparsed_uri)
312 {
313 	apache_request_string_slot(offsetof(request_rec, unparsed_uri), INTERNAL_FUNCTION_PARAM_PASSTHRU);
314 }
315 /* }}} */
316 
317 /* {{{ proto string ApacheRequest::path_info([string new_path_info])
318  */
PHP_FUNCTION(apache_request_path_info)319 PHP_FUNCTION(apache_request_path_info)
320 {
321 	apache_request_string_slot(offsetof(request_rec, path_info), INTERNAL_FUNCTION_PARAM_PASSTHRU);
322 }
323 /* }}} */
324 
325 /* {{{ proto string ApacheRequest::args([string new_args])
326  */
PHP_FUNCTION(apache_request_args)327 PHP_FUNCTION(apache_request_args)
328 {
329 	apache_request_string_slot(offsetof(request_rec, args), INTERNAL_FUNCTION_PARAM_PASSTHRU);
330 }
331 /* }}} */
332 
333 /* {{{ proto string ApacheRequest::boundary()
334  */
PHP_FUNCTION(apache_request_boundary)335 PHP_FUNCTION(apache_request_boundary)
336 {
337 	apache_request_read_string_slot(offsetof(request_rec, boundary), INTERNAL_FUNCTION_PARAM_PASSTHRU);
338 }
339 /* }}} */
340 
341 
342 /* {{{ proto string ApacheRequest::content_type([string new_type])
343  */
PHP_FUNCTION(apache_request_content_type)344 PHP_FUNCTION(apache_request_content_type)
345 {
346 	apache_request_string_slot(offsetof(request_rec, content_type), INTERNAL_FUNCTION_PARAM_PASSTHRU);
347 }
348 /* }}} */
349 
350 /* {{{ proto string ApacheRequest::content_encoding([string new_encoding])
351  */
PHP_FUNCTION(apache_request_content_encoding)352 PHP_FUNCTION(apache_request_content_encoding)
353 {
354 	apache_request_string_slot(offsetof(request_rec, content_encoding), INTERNAL_FUNCTION_PARAM_PASSTHRU);
355 }
356 /* }}} */
357 
358 /* {{{ proto string ApacheRequest::handler([string new_handler])
359  */
PHP_FUNCTION(apache_request_handler)360 PHP_FUNCTION(apache_request_handler)
361 {
362 	apache_request_string_slot(offsetof(request_rec, handler), INTERNAL_FUNCTION_PARAM_PASSTHRU);
363 }
364 /* }}} */
365 
366 /* {{{ proto string ApacheRequest::the_request()
367  */
PHP_FUNCTION(apache_request_the_request)368 PHP_FUNCTION(apache_request_the_request)
369 {
370 	apache_request_read_string_slot(offsetof(request_rec, the_request), INTERNAL_FUNCTION_PARAM_PASSTHRU);
371 }
372 /* }}} */
373 
374 /* {{{ proto string ApacheRequest::protocol()
375  */
PHP_FUNCTION(apache_request_protocol)376 PHP_FUNCTION(apache_request_protocol)
377 {
378 	apache_request_read_string_slot(offsetof(request_rec, protocol), INTERNAL_FUNCTION_PARAM_PASSTHRU);
379 }
380 /* }}} */
381 
382 /* {{{ proto string ApacheRequest::hostname()
383  */
PHP_FUNCTION(apache_request_hostname)384 PHP_FUNCTION(apache_request_hostname)
385 {
386 	apache_request_read_string_slot(offsetof(request_rec, hostname), INTERNAL_FUNCTION_PARAM_PASSTHRU);
387 }
388 /* }}} */
389 
390 /* {{{ proto string ApacheRequest::status_line([string new_status_line])
391  */
PHP_FUNCTION(apache_request_status_line)392 PHP_FUNCTION(apache_request_status_line)
393 {
394 	apache_request_string_slot(offsetof(request_rec, status_line), INTERNAL_FUNCTION_PARAM_PASSTHRU);
395 }
396 /* }}} */
397 
398 /* {{{ proto string ApacheRequest::method()
399  */
PHP_FUNCTION(apache_request_method)400 PHP_FUNCTION(apache_request_method)
401 {
402 	apache_request_read_string_slot(offsetof(request_rec, method), INTERNAL_FUNCTION_PARAM_PASSTHRU);
403 }
404 /* }}} */
405 
406 /* }}} access string slots of request rec */
407 
408 /* {{{ access int slots of request_rec
409  */
410 
411 /* {{{ proto int ApacheRequest::proto_num()
412  */
PHP_FUNCTION(apache_request_proto_num)413 PHP_FUNCTION(apache_request_proto_num)
414 {
415 	apache_request_read_int_slot(offsetof(request_rec, proto_num), INTERNAL_FUNCTION_PARAM_PASSTHRU);
416 }
417 /* }}} */
418 
419 /* {{{ proto int ApacheRequest::assbackwards()
420  */
PHP_FUNCTION(apache_request_assbackwards)421 PHP_FUNCTION(apache_request_assbackwards)
422 {
423 	apache_request_read_int_slot(offsetof(request_rec, assbackwards), INTERNAL_FUNCTION_PARAM_PASSTHRU);
424 }
425 /* }}} */
426 
427 
428 /* {{{ proto int ApacheRequest::proxyreq([int new_proxyreq])
429  */
PHP_FUNCTION(apache_request_proxyreq)430 PHP_FUNCTION(apache_request_proxyreq)
431 {
432 	apache_request_int_slot(offsetof(request_rec, proxyreq), INTERNAL_FUNCTION_PARAM_PASSTHRU);
433 }
434 /* }}} */
435 
436 /* {{{ proto int ApacheRequest::chunked()
437  */
PHP_FUNCTION(apache_request_chunked)438 PHP_FUNCTION(apache_request_chunked)
439 {
440 	apache_request_read_int_slot(offsetof(request_rec, chunked), INTERNAL_FUNCTION_PARAM_PASSTHRU);
441 }
442 /* }}} */
443 
444 
445 /* {{{ proto int ApacheRequest::header_only()
446  */
PHP_FUNCTION(apache_request_header_only)447 PHP_FUNCTION(apache_request_header_only)
448 {
449 	apache_request_read_int_slot(offsetof(request_rec, header_only), INTERNAL_FUNCTION_PARAM_PASSTHRU);
450 }
451 /* }}} */
452 
453 /* {{{ proto int ApacheRequest::request_time()
454  */
PHP_FUNCTION(apache_request_request_time)455 PHP_FUNCTION(apache_request_request_time)
456 {
457 	apache_request_read_int_slot(offsetof(request_rec, request_time), INTERNAL_FUNCTION_PARAM_PASSTHRU);
458 }
459 /* }}} */
460 
461 /* {{{ proto int ApacheRequest::status([int new_status])
462  */
PHP_FUNCTION(apache_request_status)463 PHP_FUNCTION(apache_request_status)
464 {
465 	apache_request_int_slot(offsetof(request_rec, status), INTERNAL_FUNCTION_PARAM_PASSTHRU);
466 }
467 /* }}} */
468 
469 /* {{{ proto int ApacheRequest::method_number([int method_number])
470  */
PHP_FUNCTION(apache_request_method_number)471 PHP_FUNCTION(apache_request_method_number)
472 {
473 	apache_request_read_int_slot(offsetof(request_rec, method_number), INTERNAL_FUNCTION_PARAM_PASSTHRU);
474 }
475 /* }}} */
476 
477 /* {{{ proto int ApacheRequest::allowed([int allowed])
478  */
PHP_FUNCTION(apache_request_allowed)479 PHP_FUNCTION(apache_request_allowed)
480 {
481 	apache_request_int_slot(offsetof(request_rec, allowed), INTERNAL_FUNCTION_PARAM_PASSTHRU);
482 }
483 /* }}} */
484 
485 /* {{{ proto int ApacheRequest::bytes_sent()
486  */
PHP_FUNCTION(apache_request_bytes_sent)487 PHP_FUNCTION(apache_request_bytes_sent)
488 {
489 	apache_request_read_int_slot(offsetof(request_rec, bytes_sent), INTERNAL_FUNCTION_PARAM_PASSTHRU);
490 }
491 /* }}} */
492 
493 /* {{{ proto int ApacheRequest::mtime()
494  */
PHP_FUNCTION(apache_request_mtime)495 PHP_FUNCTION(apache_request_mtime)
496 {
497 	apache_request_read_int_slot(offsetof(request_rec, mtime), INTERNAL_FUNCTION_PARAM_PASSTHRU);
498 }
499 /* }}} */
500 
501 /* {{{ proto int ApacheRequest::content_length([int new_content_length])
502  */
PHP_FUNCTION(apache_request_content_length)503 PHP_FUNCTION(apache_request_content_length)
504 {
505 	zval *id;
506 	long zlen;
507 	request_rec *r;
508 
509 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &zlen) == FAILURE) {
510 		return;
511 	}
512 
513 	if (ZEND_NUM_ARGS() == 0) {
514 		apache_request_read_int_slot(offsetof(request_rec, clength), INTERNAL_FUNCTION_PARAM_PASSTHRU);
515 	} else {
516 		APREQ_GET_REQUEST(id, r);
517 
518 		(void)ap_set_content_length(r, zlen);
519 		RETURN_TRUE;
520 	}
521 }
522 /* }}} */
523 
524 /* {{{ proto int ApacheRequest::remaining()
525  */
PHP_FUNCTION(apache_request_remaining)526 PHP_FUNCTION(apache_request_remaining)
527 {
528 	apache_request_read_int_slot(offsetof(request_rec, remaining), INTERNAL_FUNCTION_PARAM_PASSTHRU);
529 }
530 /* }}} */
531 
532 /* {{{ proto int ApacheRequest::no_cache()
533  */
PHP_FUNCTION(apache_request_no_cache)534 PHP_FUNCTION(apache_request_no_cache)
535 {
536 	apache_request_int_slot(offsetof(request_rec, no_cache), INTERNAL_FUNCTION_PARAM_PASSTHRU);
537 }
538 /* }}} */
539 
540 /* {{{ proto int ApacheRequest::no_local_copy()
541  */
PHP_FUNCTION(apache_request_no_local_copy)542 PHP_FUNCTION(apache_request_no_local_copy)
543 {
544 	apache_request_int_slot(offsetof(request_rec, no_local_copy), INTERNAL_FUNCTION_PARAM_PASSTHRU);
545 }
546 /* }}} */
547 
548 /* {{{ proto int ApacheRequest::read_body()
549  */
PHP_FUNCTION(apache_request_read_body)550 PHP_FUNCTION(apache_request_read_body)
551 {
552 	apache_request_int_slot(offsetof(request_rec, read_body), INTERNAL_FUNCTION_PARAM_PASSTHRU);
553 }
554 /* }}} */
555 
556 
557 /* }}} access int slots of request_rec */
558 
559 
560 /* {{{ proto array apache_request_headers_in()
561  * fetch all incoming request headers
562  */
PHP_FUNCTION(apache_request_headers_in)563 PHP_FUNCTION(apache_request_headers_in)
564 {
565 	zval *id;
566 	request_rec *r;
567 
568 	APREQ_GET_REQUEST(id, r);
569 
570 	apache_table_to_zval(r->headers_in, 0, return_value);
571 }
572 /* }}} */
573 
574 
575 /* {{{ add_header_to_table
576 */
add_header_to_table(table * t,INTERNAL_FUNCTION_PARAMETERS)577 static void add_header_to_table(table *t, INTERNAL_FUNCTION_PARAMETERS)
578 {
579 	zval *first = NULL;
580 	zval *second = NULL;
581 	zval **entry, **value;
582 	char *string_key;
583 	uint string_key_len;
584 	ulong num_key;
585 
586 	zend_bool replace = 0;
587 	HashPosition pos;
588 
589 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zb", &first, &second, &replace) == FAILURE) {
590 		RETURN_FALSE;
591 	}
592 
593 	if (Z_TYPE_P(first) == IS_ARRAY) {
594 		switch(ZEND_NUM_ARGS()) {
595 			case 1:
596 			case 3:
597 				zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(first), &pos);
598 				while (zend_hash_get_current_data_ex(Z_ARRVAL_P(first), (void **)&entry, &pos) == SUCCESS) {
599 					switch(zend_hash_get_current_key_ex(Z_ARRVAL_P(first), &string_key, &string_key_len, &num_key, 0, &pos)) {
600 						case HASH_KEY_IS_STRING:
601 							if (zend_hash_find(Z_ARRVAL_P(first), string_key, string_key_len, (void **)&value) == FAILURE) {
602 								zend_hash_move_forward_ex(Z_ARRVAL_P(first), &pos);
603 								continue;
604 							}
605 							if (!value) {
606 								zend_hash_move_forward_ex(Z_ARRVAL_P(first), &pos);
607 								continue;
608 							}
609 
610 							convert_to_string_ex(value);
611 							if (replace) {
612 								ap_table_set(t, string_key, Z_STRVAL_PP(value));
613 							} else {
614 								ap_table_merge(t, string_key, Z_STRVAL_PP(value));
615 							}
616 							break;
617 						case HASH_KEY_IS_LONG:
618 						default:
619 							php_error(E_WARNING, "%s(): Can only add STRING keys to headers!", get_active_function_name(TSRMLS_C));
620 							break;
621 					}
622 
623 					zend_hash_move_forward_ex(Z_ARRVAL_P(first), &pos);
624 				}
625 				break;
626 			default:
627 				WRONG_PARAM_COUNT;
628 				break;
629 		}
630 	} else if (Z_TYPE_P(first) == IS_STRING) {
631 		switch(ZEND_NUM_ARGS()) {
632 			case 2:
633 			case 3:
634 				convert_to_string_ex(&second);
635 				if (replace) {
636 					ap_table_set(t, Z_STRVAL_P(first), Z_STRVAL_P(second));
637 				} else {
638 					ap_table_merge(t, Z_STRVAL_P(first), Z_STRVAL_P(second));
639 				}
640 				break;
641 			default:
642 				WRONG_PARAM_COUNT;
643 				break;
644 		}
645 	} else {
646 		RETURN_FALSE;
647 	}
648 }
649 
650 /* }}} */
651 
652 
653 /* {{{ proto array apache_request_headers_out([{string name|array list} [, string value [, bool replace = false]]])
654  * fetch all outgoing request headers
655  */
PHP_FUNCTION(apache_request_headers_out)656 PHP_FUNCTION(apache_request_headers_out)
657 {
658 	zval *id;
659 	request_rec *r;
660 
661 	APREQ_GET_REQUEST(id, r);
662 
663 	if (ZEND_NUM_ARGS() > 0) {
664 		add_header_to_table(r->headers_out, INTERNAL_FUNCTION_PARAM_PASSTHRU);
665 	}
666 
667 	apache_table_to_zval(r->headers_out, 0, return_value);
668 }
669 /* }}} */
670 
671 
672 /* {{{ proto array apache_request_err_headers_out([{string name|array list} [, string value [, bool replace = false]]])
673  * fetch all headers that go out in case of an error or a subrequest
674  */
PHP_FUNCTION(apache_request_err_headers_out)675 PHP_FUNCTION(apache_request_err_headers_out)
676 {
677 	zval *id;
678 	request_rec *r;
679 
680 	APREQ_GET_REQUEST(id, r);
681 
682 	if (ZEND_NUM_ARGS() > 0) {
683 		add_header_to_table(r->err_headers_out, INTERNAL_FUNCTION_PARAM_PASSTHRU);
684 	}
685 
686 	apache_table_to_zval(r->err_headers_out, 0, return_value);
687 }
688 /* }}} */
689 
690 
691 /* {{{ proxy functions for the ap_* functions family
692  */
693 
694 /* {{{ proto int apache_request_server_port()
695  */
PHP_FUNCTION(apache_request_server_port)696 PHP_FUNCTION(apache_request_server_port)
697 {
698 	zval *id;
699 	request_rec *r;
700 
701 	if (zend_parse_parameters_none() == FAILURE) {
702 		return;
703 	}
704 
705 	APREQ_GET_REQUEST(id, r);
706 
707 	RETURN_LONG(ap_get_server_port(r));
708 }
709 /* }}} */
710 
711 /* {{{ proto int apache_request_remote_host([int type])
712  */
PHP_FUNCTION(apache_request_remote_host)713 PHP_FUNCTION(apache_request_remote_host)
714 {
715 	zval *id;
716 	long type = 0;
717 	request_rec *r;
718 	char *res;
719 
720 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &type) == FAILURE) {
721 		return;
722 	}
723 
724 	if (!type) {
725 		type = REMOTE_NAME;
726 	}
727 
728 	APREQ_GET_REQUEST(id, r);
729 
730 	res = (char *)ap_get_remote_host(r->connection, r->per_dir_config, (int)type);
731 
732 	if (res) {
733 		RETURN_STRING(res, 1);
734 	}
735 
736 	RETURN_EMPTY_STRING();
737 }
738 /* }}} */
739 
740 /* {{{ proto long apache_request_update_mtime([int dependency_mtime])
741  */
PHP_FUNCTION(apache_request_update_mtime)742 PHP_FUNCTION(apache_request_update_mtime)
743 {
744 	zval *id;
745 	request_rec *r;
746 	long mtime = 0;
747 
748 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &mtime) == FAILURE) {
749 		return;
750 	}
751 
752 	APREQ_GET_REQUEST(id, r);
753 
754 	RETURN_LONG(ap_update_mtime(r, (int) mtime));
755 }
756 /* }}} */
757 
758 
759 /* {{{ proto void apache_request_set_etag()
760  */
PHP_FUNCTION(apache_request_set_etag)761 PHP_FUNCTION(apache_request_set_etag)
762 {
763 	zval *id;
764 	request_rec *r;
765 
766 	if (zend_parse_parameters_none() == FAILURE) {
767 		return;
768 	}
769 
770 	APREQ_GET_REQUEST(id, r);
771 
772 	ap_set_etag(r);
773 	RETURN_TRUE;
774 }
775 /* }}} */
776 
777 /* {{{ proto void apache_request_set_last_modified()
778  */
PHP_FUNCTION(apache_request_set_last_modified)779 PHP_FUNCTION(apache_request_set_last_modified)
780 {
781 	zval *id;
782 	request_rec *r;
783 
784 	if (zend_parse_parameters_none() == FAILURE) {
785 		return;
786 	}
787 
788 	APREQ_GET_REQUEST(id, r);
789 
790 	ap_set_last_modified(r);
791 	RETURN_TRUE;
792 }
793 /* }}} */
794 
795 /* {{{ proto long apache_request_meets_conditions()
796  */
PHP_FUNCTION(apache_request_meets_conditions)797 PHP_FUNCTION(apache_request_meets_conditions)
798 {
799 	zval *id;
800 	request_rec *r;
801 
802 	if (zend_parse_parameters_none() == FAILURE) {
803 		return;
804 	}
805 
806 	APREQ_GET_REQUEST(id, r);
807 
808 	RETURN_LONG(ap_meets_conditions(r));
809 }
810 /* }}} */
811 
812 /* {{{ proto long apache_request_discard_request_body()
813  */
PHP_FUNCTION(apache_request_discard_request_body)814 PHP_FUNCTION(apache_request_discard_request_body)
815 {
816 	zval *id;
817 	request_rec *r;
818 
819 	if (zend_parse_parameters_none() == FAILURE) {
820 		return;
821 	}
822 
823 	APREQ_GET_REQUEST(id, r);
824 
825 	RETURN_LONG(ap_discard_request_body(r));
826 }
827 /* }}} */
828 
829 /* {{{ proto long apache_request_satisfies()
830  */
PHP_FUNCTION(apache_request_satisfies)831 PHP_FUNCTION(apache_request_satisfies)
832 {
833 	zval *id;
834 	request_rec *r;
835 
836 	if (zend_parse_parameters_none() == FAILURE) {
837 		return;
838 	}
839 
840 	APREQ_GET_REQUEST(id, r);
841 
842 	RETURN_LONG(ap_satisfies(r));
843 }
844 /* }}} */
845 
846 
847 /* {{{ proto bool apache_request_is_initial_req()
848  */
PHP_FUNCTION(apache_request_is_initial_req)849 PHP_FUNCTION(apache_request_is_initial_req)
850 {
851 	zval *id;
852 	request_rec *r;
853 
854 	if (zend_parse_parameters_none() == FAILURE) {
855 		return;
856 	}
857 
858 	APREQ_GET_REQUEST(id, r);
859 
860 	RETURN_BOOL(ap_is_initial_req(r));
861 }
862 /* }}} */
863 
864 /* {{{ proto bool apache_request_some_auth_required()
865  */
PHP_FUNCTION(apache_request_some_auth_required)866 PHP_FUNCTION(apache_request_some_auth_required)
867 {
868 	zval *id;
869 	request_rec *r;
870 
871 	if (zend_parse_parameters_none() == FAILURE) {
872 		return;
873 	}
874 
875 	APREQ_GET_REQUEST(id, r);
876 
877 	RETURN_BOOL(ap_some_auth_required(r));
878 }
879 /* }}} */
880 
881 /* {{{ proto string apache_request_auth_type()
882  */
PHP_FUNCTION(apache_request_auth_type)883 PHP_FUNCTION(apache_request_auth_type)
884 {
885 	zval *id;
886 	request_rec *r;
887 	char *t;
888 
889 	if (zend_parse_parameters_none() == FAILURE) {
890 		return;
891 	}
892 
893 	APREQ_GET_REQUEST(id, r);
894 
895 	t = (char *)ap_auth_type(r);
896 	if (!t) {
897 		RETURN_NULL();
898 	}
899 
900 	RETURN_STRING(t, 1);
901 }
902 /* }}} */
903 
904 /* {{{ proto string apache_request_auth_name()
905  */
PHP_FUNCTION(apache_request_auth_name)906 PHP_FUNCTION(apache_request_auth_name)
907 {
908 	zval *id;
909 	request_rec *r;
910 	char *t;
911 
912 	if (zend_parse_parameters_none() == FAILURE) {
913 		return;
914 	}
915 
916 	APREQ_GET_REQUEST(id, r);
917 
918 	t = (char *)ap_auth_name(r);
919 	if (!t) {
920 		RETURN_NULL();
921 	}
922 
923 	RETURN_STRING(t, 1);
924 }
925 /* }}} */
926 
927 /* {{{ proto apache_request_basic_auth_pw()
928  */
PHP_FUNCTION(apache_request_basic_auth_pw)929 PHP_FUNCTION(apache_request_basic_auth_pw)
930 {
931 	zval *id, *zpw;
932 	request_rec *r;
933 	const char *pw;
934 	long status;
935 
936 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zpw) == FAILURE) {
937 	    return;
938 	}
939 
940 	if (!PZVAL_IS_REF(zpw)) {
941 	    zend_error(E_WARNING, "Parameter wasn't passed by reference");
942 	    RETURN_NULL();
943 	}
944 
945 	APREQ_GET_REQUEST(id, r);
946 
947 	pw = NULL;
948 	status = ap_get_basic_auth_pw(r, &pw);
949 	if (status == OK && pw) {
950 		ZVAL_STRING(zpw, (char *)pw, 1);
951 	} else {
952 		ZVAL_NULL(zpw);
953 	}
954 	RETURN_LONG(status);
955 }
956 /* }}} */
957 
958 
959 /* http_protocol.h */
960 
PHP_FUNCTION(apache_request_send_http_header)961 PHP_FUNCTION(apache_request_send_http_header)
962 {
963     zval *id;
964     request_rec *r;
965     char *type = NULL;
966     int typelen;
967 
968 	if (zend_parse_parameters(ZEND_NUM_ARGS()  TSRMLS_CC, "|s", &type, &typelen) == FAILURE) {
969         return;
970 	}
971 
972     APREQ_GET_REQUEST(id, r);
973     if(type) {
974         r->content_type = pstrdup(r->pool, type);
975     }
976     ap_send_http_header(r);
977     SG(headers_sent) = 1;
978     AP(headers_sent) = 1;
979     RETURN_TRUE;
980 }
981 
PHP_FUNCTION(apache_request_basic_http_header)982 PHP_FUNCTION(apache_request_basic_http_header)
983 {
984     zval *id;
985     request_rec *r;
986 
987 	if (zend_parse_parameters_none() == FAILURE) {
988 		return;
989 	}
990 
991     APREQ_GET_REQUEST(id, r);
992 
993     ap_basic_http_header((request_rec *)SG(server_context));
994     SG(headers_sent) = 1;
995     AP(headers_sent) = 1;
996     RETURN_TRUE;
997 }
998 
PHP_FUNCTION(apache_request_send_http_trace)999 PHP_FUNCTION(apache_request_send_http_trace)
1000 {
1001     zval *id;
1002     request_rec *r;
1003 
1004 	if (zend_parse_parameters_none() == FAILURE) {
1005 		return;
1006 	}
1007 
1008     APREQ_GET_REQUEST(id, r);
1009 
1010     ap_send_http_trace((request_rec *)SG(server_context));
1011     SG(headers_sent) = 1;
1012     AP(headers_sent) = 1;
1013     RETURN_TRUE;
1014 }
1015 
PHP_FUNCTION(apache_request_send_http_options)1016 PHP_FUNCTION(apache_request_send_http_options)
1017 {
1018     zval *id;
1019     request_rec *r;
1020 
1021 	if (zend_parse_parameters_none() == FAILURE) {
1022 		return;
1023 	}
1024 
1025     APREQ_GET_REQUEST(id, r);
1026 
1027     ap_send_http_options((request_rec *)SG(server_context));
1028     SG(headers_sent) = 1;
1029     AP(headers_sent) = 1;
1030     RETURN_TRUE;
1031 }
1032 
PHP_FUNCTION(apache_request_send_error_response)1033 PHP_FUNCTION(apache_request_send_error_response)
1034 {
1035     zval *id;
1036     request_rec *r;
1037 	long rec = 0;
1038 
1039 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &rec) == FAILURE) {
1040 		return;
1041 	}
1042 
1043     APREQ_GET_REQUEST(id, r);
1044 	ap_send_error_response(r, (int) rec);
1045     RETURN_TRUE;
1046 }
1047 
PHP_FUNCTION(apache_request_set_content_length)1048 PHP_FUNCTION(apache_request_set_content_length)
1049 {
1050 	long length;
1051     zval *id;
1052     request_rec *r;
1053 
1054 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &length) == FAILURE) {
1055 		return;
1056 	}
1057 
1058     APREQ_GET_REQUEST(id, r);
1059 
1060     ap_set_content_length(r, length);
1061     RETURN_TRUE;
1062 }
1063 
PHP_FUNCTION(apache_request_set_keepalive)1064 PHP_FUNCTION(apache_request_set_keepalive)
1065 {
1066     zval *id;
1067     request_rec *r;
1068 
1069 	if (zend_parse_parameters_none() == FAILURE) {
1070 		return;
1071 	}
1072 
1073     APREQ_GET_REQUEST(id, r);
1074     ap_set_keepalive(r);
1075     RETURN_TRUE;
1076 }
1077 
1078 /* This stuff should use streams or however this is implemented now
1079 
1080 PHP_FUNCTION(apache_request_send_fd)
1081 {
1082 }
1083 
1084 PHP_FUNCTION(apache_request_send_fd_length)
1085 {
1086 }
1087 */
1088 
1089 /* These are for overriding default output behaviour */
PHP_FUNCTION(apache_request_rputs)1090 PHP_FUNCTION(apache_request_rputs)
1091 {
1092     char *buffer;
1093 	int buffer_len;
1094     zval *id;
1095     request_rec *r;
1096 
1097 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &buffer, &buffer_len) == FAILURE) {
1098 		return;
1099 	}
1100 
1101     APREQ_GET_REQUEST(id, r);
1102     ap_rwrite(buffer, buffer_len, (request_rec*)SG(server_context));
1103 }
1104 
1105 /* This stuff would be useful for custom POST handlers,
1106    which should be supported.  Probably by not using
1107    sapi_activate at all inside a phpResponseHandler
1108    and instead using a builtin composed of the below
1109    calls as a apache_read_request_body() and allow
1110    people to custom craft their own.
1111 
1112 PHP_FUNCTION(apache_request_setup_client_block)
1113 {
1114 }
1115 
1116 PHP_FUNCTION(apache_request_should_client_block)
1117 {
1118 }
1119 
1120 PHP_FUNCTION(apache_request_get_client_block)
1121 {
1122 }
1123 
1124 PHP_FUNCTION(apache_request_discard_request_body)
1125 {
1126 }
1127 */
1128 
1129 /* http_log.h */
1130 
1131 /* {{{ proto boolean apache_request_log_error(string message, [long facility])
1132  */
PHP_FUNCTION(apache_request_log_error)1133 PHP_FUNCTION(apache_request_log_error)
1134 {
1135     zval *id;
1136 	char *z_errstr;
1137 	int z_errstr_len;
1138     long facility = APLOG_ERR;
1139     request_rec *r;
1140 
1141 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &z_errstr, &z_errstr_len, &facility) == FAILURE) {
1142 		return;
1143 	}
1144 
1145     APREQ_GET_REQUEST(id, r);
1146 	ap_log_error(APLOG_MARK, (int) facility, r->server, "%s", z_errstr);
1147     RETURN_TRUE;
1148 }
1149 /* }}} */
1150 /* http_main.h */
1151 
1152 /* {{{ proto object apache_request_sub_req_lookup_uri(string uri)
1153     Returns sub-request for the specified uri.  You would
1154     need to run it yourself with run()
1155 */
PHP_FUNCTION(apache_request_sub_req_lookup_uri)1156 PHP_FUNCTION(apache_request_sub_req_lookup_uri)
1157 {
1158     zval *id;
1159 	char *file;
1160 	int file_len;
1161     request_rec *r, *sub_r;
1162 
1163 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &file, &file_len) == FAILURE) {
1164 		return;
1165 	}
1166 
1167     APREQ_GET_REQUEST(id, r);
1168     sub_r = ap_sub_req_lookup_uri(file, r);
1169 
1170     if (!sub_r) {
1171         RETURN_FALSE;
1172     }
1173     return_value = php_apache_request_new(sub_r);
1174 }
1175 /* }}} */
1176 
1177 /* {{{ proto object apache_request_sub_req_lookup_file(string file)
1178     Returns sub-request for the specified file.  You would
1179     need to run it yourself with run().
1180 */
PHP_FUNCTION(apache_request_sub_req_lookup_file)1181 PHP_FUNCTION(apache_request_sub_req_lookup_file)
1182 {
1183     zval *id;
1184 	char *file;
1185 	int file_len;
1186     request_rec *r, *sub_r;
1187 
1188 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &file, &file_len) == FAILURE) {
1189 		return;
1190 	}
1191 
1192     APREQ_GET_REQUEST(id, r);
1193 
1194     sub_r = ap_sub_req_lookup_file(file, r);
1195 
1196     if (!sub_r) {
1197         RETURN_FALSE;
1198     }
1199     return_value = php_apache_request_new(sub_r);
1200 }
1201 /* }}} */
1202 
1203 /* {{{ proto object apache_request_sub_req_method_uri(string method, string uri)
1204     Returns sub-request for the specified file.  You would
1205     need to run it yourself with run().
1206 */
PHP_FUNCTION(apache_request_sub_req_method_uri)1207 PHP_FUNCTION(apache_request_sub_req_method_uri)
1208 {
1209     zval *id;
1210 	char *file, *method;
1211 	int file_len, method_len;
1212     request_rec *r, *sub_r;
1213 
1214 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &method, &method_len, &file, &file_len) == FAILURE) {
1215 		return;
1216 	}
1217 
1218     APREQ_GET_REQUEST(id, r);
1219 
1220     sub_r = ap_sub_req_method_uri(method, file, r);
1221 
1222     if (!sub_r) {
1223         RETURN_FALSE;
1224     }
1225     return_value = php_apache_request_new(sub_r);
1226 }
1227 /* }}} */
1228 
1229 /* {{{ proto long apache_request_run()
1230     This is a wrapper for ap_sub_run_req and ap_destory_sub_req.  It takes
1231     sub_request, runs it, destroys it, and returns it's status.
1232 */
PHP_FUNCTION(apache_request_run)1233 PHP_FUNCTION(apache_request_run)
1234 {
1235     zval *id;
1236     request_rec *r;
1237     int status;
1238 
1239     if (zend_parse_parameters_none() == FAILURE) {
1240     	return;
1241 	}
1242 
1243     APREQ_GET_REQUEST(id, r);
1244     if (!r || ap_is_initial_req(r)) {
1245         RETURN_FALSE;
1246 	}
1247     status = ap_run_sub_req(r);
1248     ap_destroy_sub_req(r);
1249     RETURN_LONG(status);
1250 }
1251 /* }}} */
1252 
PHP_FUNCTION(apache_request_internal_redirect)1253 PHP_FUNCTION(apache_request_internal_redirect)
1254 {
1255     zval *id;
1256 	char *new_uri;
1257 	int new_uri_len;
1258     request_rec *r;
1259 
1260 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &new_uri, &new_uri_len) == FAILURE) {
1261 		return;
1262 	}
1263 
1264     APREQ_GET_REQUEST(id, r);
1265 
1266     ap_internal_redirect(new_uri, r);
1267 }
1268 
PHP_FUNCTION(apache_request_send_header_field)1269 PHP_FUNCTION(apache_request_send_header_field)
1270 {
1271 	char *fieldname, *fieldval;
1272 	int fieldname_len, fieldval_len;
1273     zval *id;
1274     request_rec *r;
1275 
1276 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &fieldname, &fieldname_len, &fieldval, &fieldval_len) == FAILURE) {
1277 		return;
1278 	}
1279 
1280     APREQ_GET_REQUEST(id, r);
1281 
1282     ap_send_header_field(r, fieldname, fieldval);
1283     SG(headers_sent) = 1;
1284     AP(headers_sent) = 1;
1285 }
1286 
1287 
1288 
1289 /* }}} */
1290 
1291 /* {{{ php_apache_request_class_functions
1292  */
1293 const static zend_function_entry php_apache_request_class_functions[] = {
1294 	/* string slots */
1295 	PHP_FALIAS(args,						apache_request_args,				NULL)
1296 	PHP_FALIAS(boundary,					apache_request_boundary,			NULL)
1297 	PHP_FALIAS(content_encoding,			apache_request_content_encoding,	NULL)
1298 	PHP_FALIAS(content_type,				apache_request_content_type,		NULL)
1299 	PHP_FALIAS(filename,					apache_request_filename,			NULL)
1300 	PHP_FALIAS(handler,						apache_request_handler,				NULL)
1301 	PHP_FALIAS(hostname,					apache_request_hostname,			NULL)
1302 	PHP_FALIAS(method,						apache_request_method,				NULL)
1303 	PHP_FALIAS(path_info,					apache_request_path_info,			NULL)
1304 	PHP_FALIAS(protocol,					apache_request_protocol,			NULL)
1305 	PHP_FALIAS(status_line,					apache_request_status_line,			NULL)
1306 	PHP_FALIAS(the_request,					apache_request_the_request,			NULL)
1307 	PHP_FALIAS(unparsed_uri,				apache_request_unparsed_uri,		NULL)
1308 	PHP_FALIAS(uri,							apache_request_uri,					NULL)
1309 
1310 	/* int slots */
1311 	PHP_FALIAS(allowed,						apache_request_allowed,				NULL)
1312 	PHP_FALIAS(bytes_sent,					apache_request_bytes_sent,			NULL)
1313 	PHP_FALIAS(chunked,						apache_request_chunked,				NULL)
1314 	PHP_FALIAS(content_length,				apache_request_content_length,		NULL)
1315 	PHP_FALIAS(header_only,					apache_request_header_only,			NULL)
1316 	PHP_FALIAS(method_number,				apache_request_method_number,		NULL)
1317 	PHP_FALIAS(mtime,						apache_request_mtime,				NULL)
1318 	PHP_FALIAS(no_cache,					apache_request_no_cache,			NULL)
1319 	PHP_FALIAS(no_local_copy,				apache_request_no_local_copy,		NULL)
1320 	PHP_FALIAS(proto_num,					apache_request_proto_num,			NULL)
1321 	PHP_FALIAS(proxyreq,					apache_request_proxyreq,			NULL)
1322 	PHP_FALIAS(read_body,					apache_request_read_body,			NULL)
1323 	PHP_FALIAS(remaining,					apache_request_remaining,			NULL)
1324 	PHP_FALIAS(request_time,				apache_request_request_time,		NULL)
1325 	PHP_FALIAS(status,						apache_request_status,				NULL)
1326 
1327 	/* tables & arrays */
1328 	PHP_FALIAS(headers_in,					apache_request_headers_in,			NULL)
1329 	PHP_FALIAS(headers_out,					apache_request_headers_out,			NULL)
1330 	PHP_FALIAS(err_headers_out,				apache_request_err_headers_out,			NULL)
1331 
1332 
1333 	/* proxy functions for the ap_* functions family */
1334 #undef auth_name
1335 #undef auth_type
1336 #undef discard_request_body
1337 #undef is_initial_req
1338 #undef meets_conditions
1339 #undef satisfies
1340 #undef set_etag
1341 #undef set_last_modified
1342 #undef some_auth_required
1343 #undef update_mtime
1344 #undef send_http_header
1345 #undef send_header_field
1346 #undef basic_http_header
1347 #undef send_http_trace
1348 #undef send_http_options
1349 #undef send_error_response
1350 #undef set_content_length
1351 #undef set_keepalive
1352 #undef rputs
1353 #undef log_error
1354 #undef lookup_uri
1355 #undef lookup_file
1356 #undef method_uri
1357 #undef run
1358 #undef internal_redirect
1359 	PHP_FALIAS(auth_name,					apache_request_auth_name,				NULL)
1360 	PHP_FALIAS(auth_type,					apache_request_auth_type,				NULL)
1361 	PHP_FALIAS(basic_auth_pw,				apache_request_basic_auth_pw,			NULL)
1362 	PHP_FALIAS(discard_request_body,		apache_request_discard_request_body,	NULL)
1363 	PHP_FALIAS(is_initial_req,				apache_request_is_initial_req,			NULL)
1364 	PHP_FALIAS(meets_conditions,			apache_request_meets_conditions,		NULL)
1365 	PHP_FALIAS(remote_host,					apache_request_remote_host,				NULL)
1366 	PHP_FALIAS(satisfies,					apache_request_satisfies,				NULL)
1367 	PHP_FALIAS(server_port,					apache_request_server_port,				NULL)
1368 	PHP_FALIAS(set_etag,					apache_request_set_etag,				NULL)
1369 	PHP_FALIAS(set_last_modified,			apache_request_set_last_modified,		NULL)
1370 	PHP_FALIAS(some_auth_required,			apache_request_some_auth_required,		NULL)
1371 	PHP_FALIAS(update_mtime,				apache_request_update_mtime,			NULL)
1372 	PHP_FALIAS(send_http_header,			apache_request_send_http_header,		NULL)
1373 	PHP_FALIAS(basic_http_header,			apache_request_basic_http_header,		NULL)
1374     PHP_FALIAS(send_header_field,           apache_request_send_header_field,       NULL)
1375 	PHP_FALIAS(send_http_trace,			    apache_request_send_http_trace,		    NULL)
1376 	PHP_FALIAS(send_http_options,			apache_request_send_http_trace,		    NULL)
1377 	PHP_FALIAS(send_error_response,			apache_request_send_error_response,	    NULL)
1378     PHP_FALIAS(set_content_length,          apache_request_set_content_length,      NULL)
1379     PHP_FALIAS(set_keepalive,               apache_request_set_keepalive,           NULL)
1380     PHP_FALIAS(rputs,                       apache_request_rputs,                   NULL)
1381     PHP_FALIAS(log_error,                   apache_request_log_error,               NULL)
1382     PHP_FALIAS(lookup_uri,                  apache_request_sub_req_lookup_uri,      NULL)
1383     PHP_FALIAS(lookup_file,                 apache_request_sub_req_lookup_file,     NULL)
1384     PHP_FALIAS(method_uri,                  apache_request_sub_req_method_uri,      NULL)
1385     PHP_FALIAS(run,                         apache_request_run,                     NULL)
1386     PHP_FALIAS(internal_redirect,           apache_request_internal_redirect,       NULL)
1387 	PHP_FE_END
1388 };
1389 /* }}} */
1390 
1391 
PHP_MINIT_FUNCTION(apache)1392 static PHP_MINIT_FUNCTION(apache)
1393 {
1394 	zend_class_entry ce;
1395 
1396 #ifdef ZTS
1397 	ts_allocate_id(&php_apache_info_id, sizeof(php_apache_info_struct), (ts_allocate_ctor) php_apache_globals_ctor, NULL);
1398 #else
1399 	php_apache_globals_ctor(&php_apache_info TSRMLS_CC);
1400 #endif
1401 	REGISTER_INI_ENTRIES();
1402 
1403 
1404 	le_apachereq = zend_register_list_destructors_ex(php_apache_request_free, NULL, "ApacheRequest", module_number);
1405 	INIT_OVERLOADED_CLASS_ENTRY(ce, "ApacheRequest", php_apache_request_class_functions, NULL, NULL, NULL);
1406 	apacherequest_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
1407 
1408 	REGISTER_LONG_CONSTANT("OK",				OK,					CONST_CS | CONST_PERSISTENT);
1409 	REGISTER_LONG_CONSTANT("DECLINED",			DECLINED,			CONST_CS | CONST_PERSISTENT);
1410 	REGISTER_LONG_CONSTANT("FORBIDDEN",			FORBIDDEN,			CONST_CS | CONST_PERSISTENT);
1411 	REGISTER_LONG_CONSTANT("AUTH_REQUIRED",		AUTH_REQUIRED,		CONST_CS | CONST_PERSISTENT);
1412 	REGISTER_LONG_CONSTANT("DONE",				DONE,				CONST_CS | CONST_PERSISTENT);
1413 	REGISTER_LONG_CONSTANT("SERVER_ERROR",		SERVER_ERROR,		CONST_CS | CONST_PERSISTENT);
1414 	REGISTER_LONG_CONSTANT("REDIRECT",			REDIRECT,			CONST_CS | CONST_PERSISTENT);
1415 	REGISTER_LONG_CONSTANT("BAD_REQUEST",		BAD_REQUEST,		CONST_CS | CONST_PERSISTENT);
1416 	REGISTER_LONG_CONSTANT("NOT_FOUND",			NOT_FOUND,			CONST_CS | CONST_PERSISTENT);
1417     REGISTER_LONG_CONSTANT("HTTP_CONTINUE",     HTTP_CONTINUE,   CONST_CS | CONST_PERSISTENT);
1418     REGISTER_LONG_CONSTANT("HTTP_SWITCHING_PROTOCOLS",     HTTP_SWITCHING_PROTOCOLS,   CONST_CS | CONST_PERSISTENT);
1419     REGISTER_LONG_CONSTANT("HTTP_PROCESSING",     HTTP_PROCESSING,   CONST_CS | CONST_PERSISTENT);
1420     REGISTER_LONG_CONSTANT("HTTP_OK",     HTTP_OK,   CONST_CS | CONST_PERSISTENT);
1421     REGISTER_LONG_CONSTANT("HTTP_CREATED",     HTTP_CREATED,   CONST_CS | CONST_PERSISTENT);
1422     REGISTER_LONG_CONSTANT("HTTP_ACCEPTED",     HTTP_ACCEPTED,   CONST_CS | CONST_PERSISTENT);
1423     REGISTER_LONG_CONSTANT("HTTP_NON_AUTHORITATIVE",     HTTP_NON_AUTHORITATIVE,   CONST_CS | CONST_PERSISTENT);
1424     REGISTER_LONG_CONSTANT("HTTP_NO_CONTENT",     HTTP_NO_CONTENT,   CONST_CS | CONST_PERSISTENT);
1425     REGISTER_LONG_CONSTANT("HTTP_RESET_CONTENT",     HTTP_RESET_CONTENT,   CONST_CS | CONST_PERSISTENT);
1426     REGISTER_LONG_CONSTANT("HTTP_PARTIAL_CONTENT",     HTTP_PARTIAL_CONTENT,   CONST_CS | CONST_PERSISTENT);
1427     REGISTER_LONG_CONSTANT("HTTP_MULTI_STATUS",     HTTP_MULTI_STATUS,   CONST_CS | CONST_PERSISTENT);
1428     REGISTER_LONG_CONSTANT("HTTP_MULTIPLE_CHOICES",     HTTP_MULTIPLE_CHOICES,   CONST_CS | CONST_PERSISTENT);
1429     REGISTER_LONG_CONSTANT("HTTP_MOVED_PERMANENTLY",     HTTP_MOVED_PERMANENTLY,   CONST_CS | CONST_PERSISTENT);
1430     REGISTER_LONG_CONSTANT("HTTP_MOVED_TEMPORARILY",     HTTP_MOVED_TEMPORARILY,   CONST_CS | CONST_PERSISTENT);
1431     REGISTER_LONG_CONSTANT("HTTP_SEE_OTHER",     HTTP_SEE_OTHER,   CONST_CS | CONST_PERSISTENT);
1432     REGISTER_LONG_CONSTANT("HTTP_NOT_MODIFIED",     HTTP_NOT_MODIFIED,   CONST_CS | CONST_PERSISTENT);
1433     REGISTER_LONG_CONSTANT("HTTP_USE_PROXY",     HTTP_USE_PROXY,   CONST_CS | CONST_PERSISTENT);
1434     REGISTER_LONG_CONSTANT("HTTP_TEMPORARY_REDIRECT",     HTTP_TEMPORARY_REDIRECT,   CONST_CS | CONST_PERSISTENT);
1435     REGISTER_LONG_CONSTANT("HTTP_BAD_REQUEST",     HTTP_BAD_REQUEST,   CONST_CS | CONST_PERSISTENT);
1436     REGISTER_LONG_CONSTANT("HTTP_UNAUTHORIZED",     HTTP_UNAUTHORIZED,   CONST_CS | CONST_PERSISTENT);
1437     REGISTER_LONG_CONSTANT("HTTP_PAYMENT_REQUIRED",     HTTP_PAYMENT_REQUIRED,   CONST_CS | CONST_PERSISTENT);
1438     REGISTER_LONG_CONSTANT("HTTP_FORBIDDEN",     HTTP_FORBIDDEN,   CONST_CS | CONST_PERSISTENT);
1439     REGISTER_LONG_CONSTANT("HTTP_NOT_FOUND",     HTTP_NOT_FOUND,   CONST_CS | CONST_PERSISTENT);
1440     REGISTER_LONG_CONSTANT("HTTP_METHOD_NOT_ALLOWED",     HTTP_METHOD_NOT_ALLOWED,   CONST_CS | CONST_PERSISTENT);
1441     REGISTER_LONG_CONSTANT("HTTP_NOT_ACCEPTABLE",     HTTP_NOT_ACCEPTABLE,   CONST_CS | CONST_PERSISTENT);
1442     REGISTER_LONG_CONSTANT("HTTP_PROXY_AUTHENTICATION_REQUIRED",     HTTP_PROXY_AUTHENTICATION_REQUIRED,   CONST_CS | CONST_PERSISTENT);
1443     REGISTER_LONG_CONSTANT("HTTP_REQUEST_TIME_OUT",     HTTP_REQUEST_TIME_OUT,   CONST_CS | CONST_PERSISTENT);
1444     REGISTER_LONG_CONSTANT("HTTP_CONFLICT",     HTTP_CONFLICT,   CONST_CS | CONST_PERSISTENT);
1445     REGISTER_LONG_CONSTANT("HTTP_GONE",     HTTP_GONE,   CONST_CS | CONST_PERSISTENT);REGISTER_LONG_CONSTANT("HTTP_LENGTH_REQUIRED",     HTTP_LENGTH_REQUIRED,   CONST_CS | CONST_PERSISTENT);
1446     REGISTER_LONG_CONSTANT("HTTP_PRECONDITION_FAILED",     HTTP_PRECONDITION_FAILED,   CONST_CS | CONST_PERSISTENT);
1447     REGISTER_LONG_CONSTANT("HTTP_REQUEST_ENTITY_TOO_LARGE",     HTTP_REQUEST_ENTITY_TOO_LARGE,   CONST_CS | CONST_PERSISTENT);
1448     REGISTER_LONG_CONSTANT("HTTP_REQUEST_URI_TOO_LARGE",     HTTP_REQUEST_URI_TOO_LARGE,   CONST_CS | CONST_PERSISTENT);
1449     REGISTER_LONG_CONSTANT("HTTP_UNSUPPORTED_MEDIA_TYPE",     HTTP_UNSUPPORTED_MEDIA_TYPE,   CONST_CS | CONST_PERSISTENT);
1450     REGISTER_LONG_CONSTANT("HTTP_RANGE_NOT_SATISFIABLE",     HTTP_RANGE_NOT_SATISFIABLE,   CONST_CS | CONST_PERSISTENT);
1451     REGISTER_LONG_CONSTANT("HTTP_EXPECTATION_FAILED",     HTTP_EXPECTATION_FAILED,   CONST_CS | CONST_PERSISTENT);
1452     REGISTER_LONG_CONSTANT("HTTP_UNPROCESSABLE_ENTITY",     HTTP_UNPROCESSABLE_ENTITY,   CONST_CS | CONST_PERSISTENT);
1453     REGISTER_LONG_CONSTANT("HTTP_LOCKED",     HTTP_LOCKED,   CONST_CS | CONST_PERSISTENT);
1454     REGISTER_LONG_CONSTANT("HTTP_FAILED_DEPENDENCY",     HTTP_FAILED_DEPENDENCY,   CONST_CS | CONST_PERSISTENT);
1455     REGISTER_LONG_CONSTANT("HTTP_INTERNAL_SERVER_ERROR",     HTTP_INTERNAL_SERVER_ERROR,   CONST_CS | CONST_PERSISTENT);
1456     REGISTER_LONG_CONSTANT("HTTP_NOT_IMPLEMENTED",     HTTP_NOT_IMPLEMENTED,   CONST_CS | CONST_PERSISTENT);
1457     REGISTER_LONG_CONSTANT("HTTP_BAD_GATEWAY",     HTTP_BAD_GATEWAY,   CONST_CS | CONST_PERSISTENT);
1458     REGISTER_LONG_CONSTANT("HTTP_SERVICE_UNAVAILABLE",     HTTP_SERVICE_UNAVAILABLE,   CONST_CS | CONST_PERSISTENT);
1459     REGISTER_LONG_CONSTANT("HTTP_GATEWAY_TIME_OUT",     HTTP_GATEWAY_TIME_OUT,   CONST_CS | CONST_PERSISTENT);
1460     REGISTER_LONG_CONSTANT("HTTP_VERSION_NOT_SUPPORTED",     HTTP_VERSION_NOT_SUPPORTED,   CONST_CS | CONST_PERSISTENT);
1461     REGISTER_LONG_CONSTANT("HTTP_VARIANT_ALSO_VARIES",     HTTP_VARIANT_ALSO_VARIES,   CONST_CS | CONST_PERSISTENT);
1462     REGISTER_LONG_CONSTANT("HTTP_INSUFFICIENT_STORAGE",     HTTP_INSUFFICIENT_STORAGE,   CONST_CS | CONST_PERSISTENT);
1463     REGISTER_LONG_CONSTANT("HTTP_NOT_EXTENDED",     HTTP_NOT_EXTENDED,   CONST_CS | CONST_PERSISTENT);
1464 	REGISTER_LONG_CONSTANT("APLOG_EMERG",		APLOG_EMERG,		CONST_CS | CONST_PERSISTENT);
1465 	REGISTER_LONG_CONSTANT("APLOG_ALERT",		APLOG_ALERT,		CONST_CS | CONST_PERSISTENT);
1466 	REGISTER_LONG_CONSTANT("APLOG_CRIT",		APLOG_CRIT,			CONST_CS | CONST_PERSISTENT);
1467 	REGISTER_LONG_CONSTANT("APLOG_ERR",			APLOG_ERR,  		CONST_CS | CONST_PERSISTENT);
1468 	REGISTER_LONG_CONSTANT("APLOG_WARNING",		APLOG_WARNING,		CONST_CS | CONST_PERSISTENT);
1469 	REGISTER_LONG_CONSTANT("APLOG_NOTICE",		APLOG_NOTICE,		CONST_CS | CONST_PERSISTENT);
1470 	REGISTER_LONG_CONSTANT("APLOG_INFO",		APLOG_INFO,			CONST_CS | CONST_PERSISTENT);
1471 	REGISTER_LONG_CONSTANT("APLOG_DEBUG",		APLOG_DEBUG,		CONST_CS | CONST_PERSISTENT);
1472 	REGISTER_LONG_CONSTANT("M_GET",				M_GET,				CONST_CS | CONST_PERSISTENT);
1473 	REGISTER_LONG_CONSTANT("M_PUT",				M_PUT,				CONST_CS | CONST_PERSISTENT);
1474 	REGISTER_LONG_CONSTANT("M_POST",			M_POST,				CONST_CS | CONST_PERSISTENT);
1475 	REGISTER_LONG_CONSTANT("M_DELETE",			M_DELETE,			CONST_CS | CONST_PERSISTENT);
1476 	REGISTER_LONG_CONSTANT("M_CONNECT",			M_CONNECT,			CONST_CS | CONST_PERSISTENT);
1477 	REGISTER_LONG_CONSTANT("M_OPTIONS",			M_OPTIONS,			CONST_CS | CONST_PERSISTENT);
1478 	REGISTER_LONG_CONSTANT("M_TRACE",			M_TRACE,			CONST_CS | CONST_PERSISTENT);
1479 	REGISTER_LONG_CONSTANT("M_PATCH",			M_PATCH,			CONST_CS | CONST_PERSISTENT);
1480 	REGISTER_LONG_CONSTANT("M_PROPFIND",		M_PROPFIND,			CONST_CS | CONST_PERSISTENT);
1481 	REGISTER_LONG_CONSTANT("M_PROPPATCH",		M_PROPPATCH,		CONST_CS | CONST_PERSISTENT);
1482 	REGISTER_LONG_CONSTANT("M_MKCOL",			M_MKCOL,			CONST_CS | CONST_PERSISTENT);
1483 	REGISTER_LONG_CONSTANT("M_COPY",			M_COPY,				CONST_CS | CONST_PERSISTENT);
1484 	REGISTER_LONG_CONSTANT("M_MOVE",			M_MOVE,				CONST_CS | CONST_PERSISTENT);
1485 	REGISTER_LONG_CONSTANT("M_LOCK",			M_LOCK,				CONST_CS | CONST_PERSISTENT);
1486 	REGISTER_LONG_CONSTANT("M_UNLOCK",			M_UNLOCK,			CONST_CS | CONST_PERSISTENT);
1487 	REGISTER_LONG_CONSTANT("M_INVALID",			M_INVALID,			CONST_CS | CONST_PERSISTENT);
1488 
1489 	/* Possible values for request_rec.read_body (set by handling module):
1490 	 *    REQUEST_NO_BODY          Send 413 error if message has any body
1491 	 *    REQUEST_CHUNKED_ERROR    Send 411 error if body without Content-Length
1492 	 *    REQUEST_CHUNKED_DECHUNK  If chunked, remove the chunks for me.
1493 	 *    REQUEST_CHUNKED_PASS     Pass the chunks to me without removal.
1494 	 */
1495 	REGISTER_LONG_CONSTANT("REQUEST_NO_BODY",			REQUEST_NO_BODY,			CONST_CS | CONST_PERSISTENT);
1496 	REGISTER_LONG_CONSTANT("REQUEST_CHUNKED_ERROR", 	REQUEST_CHUNKED_ERROR,		CONST_CS | CONST_PERSISTENT);
1497 	REGISTER_LONG_CONSTANT("REQUEST_CHUNKED_DECHUNK",	REQUEST_CHUNKED_DECHUNK,	CONST_CS | CONST_PERSISTENT);
1498 	REGISTER_LONG_CONSTANT("REQUEST_CHUNKED_PASS",		REQUEST_CHUNKED_PASS,		CONST_CS | CONST_PERSISTENT);
1499 
1500 	/* resolve types for remote_host() */
1501 	REGISTER_LONG_CONSTANT("REMOTE_HOST",			REMOTE_HOST,			CONST_CS | CONST_PERSISTENT);
1502 	REGISTER_LONG_CONSTANT("REMOTE_NAME", 			REMOTE_NAME,			CONST_CS | CONST_PERSISTENT);
1503 	REGISTER_LONG_CONSTANT("REMOTE_NOLOOKUP",		REMOTE_NOLOOKUP,		CONST_CS | CONST_PERSISTENT);
1504 	REGISTER_LONG_CONSTANT("REMOTE_DOUBLE_REV",		REMOTE_DOUBLE_REV,		CONST_CS | CONST_PERSISTENT);
1505 
1506 	return SUCCESS;
1507 }
1508 
1509 
PHP_MSHUTDOWN_FUNCTION(apache)1510 static PHP_MSHUTDOWN_FUNCTION(apache)
1511 {
1512 	UNREGISTER_INI_ENTRIES();
1513 	return SUCCESS;
1514 }
1515 
1516 zend_module_entry apache_module_entry = {
1517 	STANDARD_MODULE_HEADER,
1518 	"apache",
1519 	apache_functions,
1520 	PHP_MINIT(apache),
1521 	PHP_MSHUTDOWN(apache),
1522 	NULL,
1523 	NULL,
1524 	PHP_MINFO(apache),
1525 	NO_VERSION_YET,
1526 	STANDARD_MODULE_PROPERTIES
1527 };
1528 
1529 /* {{{ proto bool apache_child_terminate(void)
1530    Terminate apache process after this request */
PHP_FUNCTION(apache_child_terminate)1531 PHP_FUNCTION(apache_child_terminate)
1532 {
1533 #ifndef MULTITHREAD
1534 	if (AP(terminate_child)) {
1535 		ap_child_terminate( ((request_rec *)SG(server_context)) );
1536 		RETURN_TRUE;
1537 	} else { /* tell them to get lost! */
1538 		php_error(E_WARNING, "apache.child_terminate is disabled");
1539 		RETURN_FALSE;
1540 	}
1541 #else
1542 		php_error(E_WARNING, "apache_child_terminate() is not supported in this build");
1543 		RETURN_FALSE;
1544 #endif
1545 }
1546 /* }}} */
1547 
1548 /* {{{ proto string apache_note(string note_name [, string note_value])
1549    Get and set Apache request notes */
PHP_FUNCTION(apache_note)1550 PHP_FUNCTION(apache_note)
1551 {
1552 	char *arg_name, *arg_val = NULL;
1553 	int arg_name_len, arg_val_len;
1554 	char *note_val;
1555 
1556 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &arg_name, &arg_name_len, &arg_val, &arg_val_len) == FAILURE) {
1557 		return;
1558 	}
1559 
1560 	note_val = (char *) table_get(((request_rec *)SG(server_context))->notes, arg_name);
1561 
1562 	if (arg_val) {
1563 		table_set(((request_rec *)SG(server_context))->notes, arg_name, arg_val);
1564 	}
1565 
1566 	if (!note_val) {
1567 		RETURN_FALSE;
1568 	}
1569 
1570 	RETURN_STRING(note_val, 1);
1571 }
1572 /* }}} */
1573 
1574 /* {{{ PHP_MINFO_FUNCTION
1575  */
PHP_MINFO_FUNCTION(apache)1576 PHP_MINFO_FUNCTION(apache)
1577 {
1578 	module *modp = NULL;
1579 	char output_buf[128];
1580 #if !defined(WIN32) && !defined(WINNT)
1581 	char name[64];
1582 	char modulenames[1024];
1583 	char *p;
1584 #endif
1585 	server_rec *serv;
1586 	extern char server_root[MAX_STRING_LEN];
1587 	extern uid_t user_id;
1588 	extern char *user_name;
1589 	extern gid_t group_id;
1590 	extern int max_requests_per_child;
1591 
1592 	serv = ((request_rec *) SG(server_context))->server;
1593 
1594 
1595 	php_info_print_table_start();
1596 
1597 #ifdef PHP_WIN32
1598 	php_info_print_table_row(1, "Apache for Windows 95/NT");
1599 	php_info_print_table_end();
1600 	php_info_print_table_start();
1601 #elif defined(NETWARE)
1602 	php_info_print_table_row(1, "Apache for NetWare");
1603 	php_info_print_table_end();
1604 	php_info_print_table_start();
1605 #else
1606 	php_info_print_table_row(2, "APACHE_INCLUDE", PHP_APACHE_INCLUDE);
1607 	php_info_print_table_row(2, "APACHE_TARGET", PHP_APACHE_TARGET);
1608 #endif
1609 
1610 	php_info_print_table_row(2, "Apache Version", SERVER_VERSION);
1611 
1612 #ifdef APACHE_RELEASE
1613 	snprintf(output_buf, sizeof(output_buf), "%d", APACHE_RELEASE);
1614 	php_info_print_table_row(2, "Apache Release", output_buf);
1615 #endif
1616 	snprintf(output_buf, sizeof(output_buf), "%d", MODULE_MAGIC_NUMBER);
1617 	php_info_print_table_row(2, "Apache API Version", output_buf);
1618 	snprintf(output_buf, sizeof(output_buf), "%s:%u", serv->server_hostname, serv->port);
1619 	php_info_print_table_row(2, "Hostname:Port", output_buf);
1620 #if !defined(WIN32) && !defined(WINNT)
1621 	snprintf(output_buf, sizeof(output_buf), "%s(%d)/%d", user_name, (int)user_id, (int)group_id);
1622 	php_info_print_table_row(2, "User/Group", output_buf);
1623 	snprintf(output_buf, sizeof(output_buf), "Per Child: %d - Keep Alive: %s - Max Per Connection: %d", max_requests_per_child, serv->keep_alive ? "on":"off", serv->keep_alive_max);
1624 	php_info_print_table_row(2, "Max Requests", output_buf);
1625 #endif
1626 	snprintf(output_buf, sizeof(output_buf), "Connection: %d - Keep-Alive: %d", serv->timeout, serv->keep_alive_timeout);
1627 	php_info_print_table_row(2, "Timeouts", output_buf);
1628 #if !defined(WIN32) && !defined(WINNT)
1629 /*
1630 	This block seems to be working on NetWare; But it seems to be showing
1631 	all modules instead of just the loaded ones
1632 */
1633 	php_info_print_table_row(2, "Server Root", server_root);
1634 
1635 	strcpy(modulenames, "");
1636 	for(modp = top_module; modp; modp = modp->next) {
1637 		strlcpy(name, modp->name, sizeof(name));
1638 		if ((p = strrchr(name, '.'))) {
1639 			*p='\0'; /* Cut off ugly .c extensions on module names */
1640 		}
1641 		strlcat(modulenames, name, sizeof(modulenames));
1642 		if (modp->next) {
1643 			strlcat(modulenames, ", ", sizeof(modulenames));
1644 		}
1645 	}
1646 	php_info_print_table_row(2, "Loaded Modules", modulenames);
1647 #endif
1648 
1649 	php_info_print_table_end();
1650 
1651 	DISPLAY_INI_ENTRIES();
1652 
1653 	{
1654 		register int i;
1655 		array_header *arr;
1656 		table_entry *elts;
1657 		request_rec *r;
1658 
1659 		r = ((request_rec *) SG(server_context));
1660 		arr = table_elts(r->subprocess_env);
1661 		elts = (table_entry *)arr->elts;
1662 
1663 		SECTION("Apache Environment");
1664 		php_info_print_table_start();
1665 		php_info_print_table_header(2, "Variable", "Value");
1666 		for (i=0; i < arr->nelts; i++) {
1667 			php_info_print_table_row(2, elts[i].key, elts[i].val);
1668 		}
1669 		php_info_print_table_end();
1670 	}
1671 
1672 	{
1673 		array_header *env_arr;
1674 		table_entry *env;
1675 		int i;
1676 		request_rec *r;
1677 
1678 		r = ((request_rec *) SG(server_context));
1679 		SECTION("HTTP Headers Information");
1680 		php_info_print_table_start();
1681 		php_info_print_table_colspan_header(2, "HTTP Request Headers");
1682 		php_info_print_table_row(2, "HTTP Request", r->the_request);
1683 		env_arr = table_elts(r->headers_in);
1684 		env = (table_entry *)env_arr->elts;
1685 		for (i = 0; i < env_arr->nelts; ++i) {
1686 			if (env[i].key && (!PG(safe_mode) || (PG(safe_mode) && strncasecmp(env[i].key, "authorization", 13)))) {
1687 				php_info_print_table_row(2, env[i].key, env[i].val);
1688 			}
1689 		}
1690 		php_info_print_table_colspan_header(2, "HTTP Response Headers");
1691 		env_arr = table_elts(r->headers_out);
1692 		env = (table_entry *)env_arr->elts;
1693 		for(i = 0; i < env_arr->nelts; ++i) {
1694 			if (env[i].key) {
1695 				php_info_print_table_row(2, env[i].key, env[i].val);
1696 			}
1697 		}
1698 		php_info_print_table_end();
1699 	}
1700 }
1701 /* }}} */
1702 
1703 /* {{{ proto bool virtual(string filename)
1704    Perform an Apache sub-request */
1705 /* This function is equivalent to <!--#include virtual...-->
1706  * in mod_include. It does an Apache sub-request. It is useful
1707  * for including CGI scripts or .shtml files, or anything else
1708  * that you'd parse through Apache (for .phtml files, you'd probably
1709  * want to use <?Include>. This only works when PHP is compiled
1710  * as an Apache module, since it uses the Apache API for doing
1711  * sub requests.
1712  */
PHP_FUNCTION(virtual)1713 PHP_FUNCTION(virtual)
1714 {
1715 	char *filename;
1716 	int filename_len;
1717 	request_rec *rr = NULL;
1718 
1719 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
1720 		return;
1721 	}
1722 
1723 	if (!(rr = sub_req_lookup_uri (filename, ((request_rec *) SG(server_context))))) {
1724 		php_error(E_WARNING, "Unable to include '%s' - URI lookup failed", filename);
1725 		if (rr)
1726 			destroy_sub_req (rr);
1727 		RETURN_FALSE;
1728 	}
1729 
1730 	if (rr->status != 200) {
1731 		php_error(E_WARNING, "Unable to include '%s' - error finding URI", filename);
1732 		if (rr)
1733 			destroy_sub_req (rr);
1734 		RETURN_FALSE;
1735 	}
1736 
1737 	php_end_ob_buffers(1 TSRMLS_CC);
1738 	php_header(TSRMLS_C);
1739 
1740 	if (run_sub_req(rr)) {
1741 		php_error(E_WARNING, "Unable to include '%s' - request execution failed", filename);
1742 		if (rr)
1743 			destroy_sub_req (rr);
1744 		RETURN_FALSE;
1745 	}
1746 
1747 	if (rr)
1748 		destroy_sub_req (rr);
1749 	RETURN_TRUE;
1750 }
1751 /* }}} */
1752 
1753 
1754 /* {{{ apache_table_to_zval(table *, int safe_mode, zval *return_value)
1755    Fetch all HTTP request headers */
apache_table_to_zval(table * t,int safe_mode,zval * return_value)1756 static void apache_table_to_zval(table *t, int safe_mode, zval *return_value)
1757 {
1758     array_header *env_arr;
1759     table_entry *tenv;
1760     int i;
1761 
1762     array_init(return_value);
1763     env_arr = table_elts(t);
1764     tenv = (table_entry *)env_arr->elts;
1765     for (i = 0; i < env_arr->nelts; ++i) {
1766 		if (!tenv[i].key ||
1767 			(safe_mode && !strncasecmp(tenv[i].key, "authorization", 13))) {
1768 			continue;
1769 		}
1770 		if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val, 1)==FAILURE) {
1771 			RETURN_FALSE;
1772 		}
1773     }
1774 
1775 }
1776 /* }}} */
1777 
1778 
1779 /* {{{ proto array getallheaders(void)
1780 */
1781 /*  Alias for apache_request_headers() */
1782 /* }}} */
1783 
1784 /* {{{ proto array apache_request_headers(void)
1785    Fetch all HTTP request headers */
PHP_FUNCTION(apache_request_headers)1786 PHP_FUNCTION(apache_request_headers)
1787 {
1788 	if (zend_parse_parameters_none() == FAILURE) {
1789  		return;
1790  	}
1791 
1792 	apache_table_to_zval(((request_rec *)SG(server_context))->headers_in, PG(safe_mode), return_value);
1793 }
1794 /* }}} */
1795 
1796 /* {{{ proto array apache_response_headers(void)
1797    Fetch all HTTP response headers */
PHP_FUNCTION(apache_response_headers)1798 PHP_FUNCTION(apache_response_headers)
1799 {
1800 	if (zend_parse_parameters_none() == FAILURE) {
1801  		return;
1802  	}
1803 
1804 	apache_table_to_zval(((request_rec *) SG(server_context))->headers_out, 0, return_value);
1805 }
1806 /* }}} */
1807 
1808 /* {{{ proto bool apache_setenv(string variable, string value [, bool walk_to_top])
1809    Set an Apache subprocess_env variable */
PHP_FUNCTION(apache_setenv)1810 PHP_FUNCTION(apache_setenv)
1811 {
1812 	int var_len, val_len;
1813 	zend_bool top=0;
1814 	char *var = NULL, *val = NULL;
1815 	request_rec *r = (request_rec *) SG(server_context);
1816 
1817     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", &var, &var_len, &val, &val_len, &top) == FAILURE) {
1818         RETURN_FALSE;
1819 	}
1820 
1821 	while(top) {
1822 		if (r->prev) {
1823 			r = r->prev;
1824 		}
1825 		else break;
1826 	}
1827 
1828 	ap_table_setn(r->subprocess_env, ap_pstrndup(r->pool, var, var_len), ap_pstrndup(r->pool, val, val_len));
1829 	RETURN_TRUE;
1830 }
1831 /* }}} */
1832 
1833 /* {{{ proto object apache_lookup_uri(string URI)
1834    Perform a partial request of the given URI to obtain information about it */
PHP_FUNCTION(apache_lookup_uri)1835 PHP_FUNCTION(apache_lookup_uri)
1836 {
1837 	char *filename;
1838 	int filename_len;
1839 	request_rec *rr=NULL;
1840 
1841 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
1842 		return;
1843 	}
1844 
1845 	if(!(rr = sub_req_lookup_uri(filename, ((request_rec *) SG(server_context))))) {
1846 		php_error(E_WARNING, "URI lookup failed", filename);
1847 		RETURN_FALSE;
1848 	}
1849 
1850 	object_init(return_value);
1851 	add_property_long(return_value,"status", rr->status);
1852 
1853 	if (rr->the_request) {
1854 		add_property_string(return_value,"the_request", rr->the_request, 1);
1855 	}
1856 	if (rr->status_line) {
1857 		add_property_string(return_value,"status_line", (char *)rr->status_line, 1);
1858 	}
1859 	if (rr->method) {
1860 		add_property_string(return_value,"method", (char *)rr->method, 1);
1861 	}
1862 	if (rr->content_type) {
1863 		add_property_string(return_value,"content_type", (char *)rr->content_type, 1);
1864 	}
1865 	if (rr->handler) {
1866 		add_property_string(return_value,"handler", (char *)rr->handler, 1);
1867 	}
1868 	if (rr->uri) {
1869 		add_property_string(return_value,"uri", rr->uri, 1);
1870 	}
1871 	if (rr->filename) {
1872 		add_property_string(return_value,"filename", rr->filename, 1);
1873 	}
1874 	if (rr->path_info) {
1875 		add_property_string(return_value,"path_info", rr->path_info, 1);
1876 	}
1877 	if (rr->args) {
1878 		add_property_string(return_value,"args", rr->args, 1);
1879 	}
1880 	if (rr->boundary) {
1881 		add_property_string(return_value,"boundary", rr->boundary, 1);
1882 	}
1883 	add_property_long(return_value,"no_cache", rr->no_cache);
1884 	add_property_long(return_value,"no_local_copy", rr->no_local_copy);
1885 	add_property_long(return_value,"allowed", rr->allowed);
1886 	add_property_long(return_value,"sent_bodyct", rr->sent_bodyct);
1887 	add_property_long(return_value,"bytes_sent", rr->bytes_sent);
1888 	add_property_long(return_value,"byterange", rr->byterange);
1889 	add_property_long(return_value,"clength", rr->clength);
1890 
1891 #if MODULE_MAGIC_NUMBER >= 19980324
1892 	if (rr->unparsed_uri) {
1893 		add_property_string(return_value,"unparsed_uri", rr->unparsed_uri, 1);
1894 	}
1895 	if(rr->mtime) {
1896 		add_property_long(return_value,"mtime", rr->mtime);
1897 	}
1898 #endif
1899 	if(rr->request_time) {
1900 		add_property_long(return_value,"request_time", rr->request_time);
1901 	}
1902 
1903 	destroy_sub_req(rr);
1904 }
1905 /* }}} */
1906 
1907 
1908 #if 0
1909 This function is most likely a bad idea.  Just playing with it for now.
1910 
1911 PHP_FUNCTION(apache_exec_uri)
1912 {
1913 	zval **filename;
1914 	request_rec *rr=NULL;
1915 	TSRMLS_FETCH();
1916 
1917 	if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &filename) == FAILURE) {
1918 		WRONG_PARAM_COUNT;
1919 	}
1920 	convert_to_string_ex(filename);
1921 
1922 	if(!(rr = ap_sub_req_lookup_uri((*filename)->value.str.val, ((request_rec *) SG(server_context))))) {
1923 		php_error(E_WARNING, "URI lookup failed", (*filename)->value.str.val);
1924 		RETURN_FALSE;
1925 	}
1926 	RETVAL_LONG(ap_run_sub_req(rr));
1927 	ap_destroy_sub_req(rr);
1928 }
1929 #endif
1930 
1931 /* {{{ proto string apache_get_version(void)
1932    Fetch Apache version */
PHP_FUNCTION(apache_get_version)1933 PHP_FUNCTION(apache_get_version)
1934 {
1935 	char *apv = (char *) ap_get_server_version();
1936 
1937 	if (apv && *apv) {
1938 		RETURN_STRING(apv, 1);
1939 	} else {
1940 		RETURN_FALSE;
1941 	}
1942 }
1943 /* }}} */
1944 
1945 /* {{{ proto array apache_get_modules(void)
1946    Get a list of loaded Apache modules */
PHP_FUNCTION(apache_get_modules)1947 PHP_FUNCTION(apache_get_modules)
1948 {
1949 	int n;
1950 	char *p;
1951 
1952 	array_init(return_value);
1953 
1954 	for (n = 0; ap_loaded_modules[n]; ++n) {
1955 		char *s = (char *) ap_loaded_modules[n]->name;
1956 		if ((p = strchr(s, '.'))) {
1957 			add_next_index_stringl(return_value, s, (p - s), 1);
1958 		} else {
1959 			add_next_index_string(return_value, s, 1);
1960 		}
1961 	}
1962 }
1963 /* }}} */
1964 
1965 /*
1966  * Local variables:
1967  * tab-width: 4
1968  * c-basic-offset: 4
1969  * End:
1970  * vim600: sw=4 ts=4 fdm=marker
1971  * vim<600: sw=4 ts=4
1972  */
1973