mirror of
https://github.com/php/php-src.git
synced 2025-08-17 06:28:50 +02:00
d11734b4b0
TLS is already used in TSRM, the way exporting the tsrm cache through a thread local variable is not portable. Additionally, the current patch suffers from bugs which are hard to find, but prevent it to be worky with apache. What is done here is mainly uses the idea from the RFC patch, but - __thread variable is removed - offset math and declarations are removed - extra macros and definitions are removed What is done merely is - use an inline function to access the tsrm cache. The function uses the portable tsrm_tls_get macro which is cheap - all the TSRM_* macros are set to placebo. Thus this opens the way remove them later Except that, the logic is old. TSRMLS_FETCH will have to be done once per thread, then tsrm_get_ls_cache() can be used. Things seeming to be worky are cli, cli server and apache. I also tried to enable bz2 shared and it has worked out of the box. The change is yet minimal diffing to the current master bus is a worky start, IMHO. Though will have to recheck the other previously done SAPIs - embed and cgi. The offsets can be added to the tsrm_resource_type struct, then it'll not be needed to declare them in the userspace. Even the "done" member type can be changed to int16 or smaller, then adding the offset as int16 will not change the struct size. As well on the todo might be removing the hashed storage, thread_id != thread_id and linked list logic in favour of the explicit TLS operations.
1970 lines
54 KiB
C
1970 lines
54 KiB
C
/*
|
|
+----------------------------------------------------------------------+
|
|
| PHP Version 7 |
|
|
+----------------------------------------------------------------------+
|
|
| Copyright (c) 1997-2014 The PHP Group |
|
|
+----------------------------------------------------------------------+
|
|
| This source file is subject to version 3.01 of the PHP license, |
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
| available through the world-wide-web at the following url: |
|
|
| http://www.php.net/license/3_01.txt |
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
+----------------------------------------------------------------------+
|
|
| Authors: Rasmus Lerdorf <rasmus@lerdorf.on.ca> |
|
|
| Stig Sæther Bakken <ssb@php.net> |
|
|
| David Sklar <sklar@student.net> |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
/* $Id$ */
|
|
|
|
#include "php_apache_http.h"
|
|
|
|
#if defined(PHP_WIN32) || defined(NETWARE)
|
|
#include "zend.h"
|
|
#include "ap_compat.h"
|
|
#else
|
|
#include <build-defs.h>
|
|
#endif
|
|
|
|
#ifdef ZTS
|
|
int php_apache_info_id;
|
|
#else
|
|
php_apache_info_struct php_apache_info;
|
|
#endif
|
|
|
|
#define SECTION(name) PUTS("<H2 align=\"center\">" name "</H2>\n")
|
|
|
|
#undef offsetof
|
|
#define offsetof(s_type,field) ((size_t)&(((s_type*)0)->field))
|
|
|
|
extern module *top_module;
|
|
extern module **ap_loaded_modules;
|
|
static int le_apachereq;
|
|
static zend_class_entry *apacherequest_class_entry;
|
|
|
|
static void apache_table_to_zval(table *, zval *return_value);
|
|
|
|
PHP_FUNCTION(virtual);
|
|
PHP_FUNCTION(apache_request_headers);
|
|
PHP_FUNCTION(apache_response_headers);
|
|
PHP_FUNCTION(apachelog);
|
|
PHP_FUNCTION(apache_note);
|
|
PHP_FUNCTION(apache_lookup_uri);
|
|
PHP_FUNCTION(apache_child_terminate);
|
|
PHP_FUNCTION(apache_setenv);
|
|
PHP_FUNCTION(apache_get_version);
|
|
PHP_FUNCTION(apache_get_modules);
|
|
|
|
PHP_MINFO_FUNCTION(apache);
|
|
|
|
ZEND_BEGIN_ARG_INFO_EX(arginfo_apachehooks_virtual, 0, 0, 1)
|
|
ZEND_ARG_INFO(0, filename)
|
|
ZEND_END_ARG_INFO()
|
|
|
|
ZEND_BEGIN_ARG_INFO_EX(arginfo_apachehooks_setenv, 0, 0, 2)
|
|
ZEND_ARG_INFO(0, variable)
|
|
ZEND_ARG_INFO(0, value)
|
|
ZEND_ARG_INFO(0, walk_to_top)
|
|
ZEND_END_ARG_INFO()
|
|
|
|
ZEND_BEGIN_ARG_INFO_EX(arginfo_apachehooks_lookup_uri, 0, 0, 1)
|
|
ZEND_ARG_INFO(0, uri)
|
|
ZEND_END_ARG_INFO()
|
|
|
|
ZEND_BEGIN_ARG_INFO(arginfo_apachehooks__void, 0)
|
|
ZEND_END_ARG_INFO()
|
|
|
|
ZEND_BEGIN_ARG_INFO_EX(arginfo_apachehooks_note, 0, 0, 1)
|
|
ZEND_ARG_INFO(0, note_name)
|
|
ZEND_ARG_INFO(0, note_value)
|
|
ZEND_END_ARG_INFO()
|
|
|
|
const zend_function_entry apache_functions[] = {
|
|
PHP_FE(virtual, arginfo_apachehooks_virtual)
|
|
PHP_FE(apache_request_headers, arginfo_apachehooks__void)
|
|
PHP_FE(apache_note, arginfo_apachehooks_note)
|
|
PHP_FE(apache_lookup_uri, arginfo_apachehooks_lookup_uri)
|
|
PHP_FE(apache_child_terminate, arginfo_apachehooks__void)
|
|
PHP_FE(apache_setenv, arginfo_apachehooks_setenv)
|
|
PHP_FE(apache_response_headers, arginfo_apachehooks__void)
|
|
PHP_FE(apache_get_version, arginfo_apachehooks__void)
|
|
PHP_FE(apache_get_modules, arginfo_apachehooks__void)
|
|
PHP_FALIAS(getallheaders, apache_request_headers, arginfo_apachehooks__void)
|
|
{NULL, NULL, NULL}
|
|
};
|
|
|
|
/* {{{ php_apache ini entries
|
|
*/
|
|
PHP_INI_BEGIN()
|
|
STD_PHP_INI_ENTRY("xbithack", "0", PHP_INI_ALL, OnUpdateLong, xbithack, php_apache_info_struct, php_apache_info)
|
|
STD_PHP_INI_ENTRY("engine", "1", PHP_INI_ALL, OnUpdateLong, engine, php_apache_info_struct, php_apache_info)
|
|
STD_PHP_INI_ENTRY("last_modified", "0", PHP_INI_ALL, OnUpdateLong, last_modified, php_apache_info_struct, php_apache_info)
|
|
STD_PHP_INI_ENTRY("child_terminate", "0", PHP_INI_ALL, OnUpdateLong, terminate_child, php_apache_info_struct, php_apache_info)
|
|
PHP_INI_END()
|
|
/* }}} */
|
|
|
|
static void php_apache_globals_ctor(php_apache_info_struct *apache_globals TSRMLS_DC)
|
|
{
|
|
apache_globals->in_request = 0;
|
|
}
|
|
|
|
|
|
#define APREQ_GET_THIS(ZVAL) if (NULL == (ZVAL = getThis())) { \
|
|
php_error(E_WARNING, "%s(): underlying ApacheRequest object missing", \
|
|
get_active_function_name(TSRMLS_C)); \
|
|
RETURN_FALSE; \
|
|
}
|
|
#define APREQ_GET_REQUEST(ZVAL, R) APREQ_GET_THIS(ZVAL); \
|
|
R = get_apache_request(ZVAL TSRMLS_CC)
|
|
|
|
static void php_apache_request_free(zend_rsrc_list_entry *rsrc TSRMLS_DC)
|
|
{
|
|
zval *z = (zval *)rsrc->ptr;
|
|
/* fprintf(stderr, "%s() %p\n", __FUNCTION__, z); */
|
|
zval_ptr_dtor(&z);
|
|
}
|
|
|
|
static request_rec *get_apache_request(zval *z TSRMLS_DC)
|
|
{
|
|
request_rec *r;
|
|
zval **addr;
|
|
|
|
if (NULL == z) {
|
|
php_error(E_WARNING, "get_apache_request() invalid wrapper passed");
|
|
return NULL;
|
|
}
|
|
|
|
if (Z_TYPE_P(z) != IS_OBJECT) {
|
|
php_error(E_WARNING, "%s(): wrapper is not an object", get_active_function_name(TSRMLS_C));
|
|
return NULL;
|
|
}
|
|
|
|
if (zend_hash_index_find(Z_OBJPROP_P(z), 0, (void **)&addr) == FAILURE) {
|
|
php_error(E_WARNING, "%s(): underlying object missing", get_active_function_name(TSRMLS_C));
|
|
return NULL;
|
|
}
|
|
|
|
r = (request_rec *)Z_LVAL_PP(addr);
|
|
if (!r) {
|
|
php_error(E_WARNING, "%s(): request_rec invalid", get_active_function_name(TSRMLS_C));
|
|
return NULL;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
/* {{{ php_apache_request_new(request_rec *r TSRMLS_DC)
|
|
* create a new zval-instance for ApacheRequest that wraps request_rec
|
|
*/
|
|
zval *php_apache_request_new(request_rec *r TSRMLS_DC)
|
|
{
|
|
zval *req;
|
|
zval *addr;
|
|
|
|
MAKE_STD_ZVAL(addr);
|
|
Z_TYPE_P(addr) = IS_LONG;
|
|
Z_LVAL_P(addr) = (int) r;
|
|
|
|
MAKE_STD_ZVAL(req);
|
|
object_init_ex(req, apacherequest_class_entry);
|
|
zend_hash_index_update(Z_OBJPROP_P(req), 0, &addr, sizeof(zval *), NULL);
|
|
|
|
return req;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ apache_request_read_string_slot()
|
|
*/
|
|
static void apache_request_read_string_slot(int offset, INTERNAL_FUNCTION_PARAMETERS)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
char *s;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
s = *(char **)((char*)r + offset);
|
|
|
|
if (s) {
|
|
RETURN_STRING(s, 1);
|
|
}
|
|
|
|
RETURN_EMPTY_STRING();
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ apache_request_string_slot()
|
|
*/
|
|
static void apache_request_string_slot(int offset, INTERNAL_FUNCTION_PARAMETERS)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
char *old_value, *new_value = NULL;
|
|
int new_value_len;
|
|
char **target;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &new_value, &new_value_len) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
target = (char **)((char*)r + offset);
|
|
old_value = *target;
|
|
|
|
if (new_value) {
|
|
*target = ap_pstrdup(r->pool, new_value);
|
|
}
|
|
|
|
if (old_value) {
|
|
RETURN_STRING(old_value, 1);
|
|
}
|
|
|
|
RETURN_EMPTY_STRING();
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ apache_request_read_int_slot()
|
|
*/
|
|
static void apache_request_read_int_slot(int offset, INTERNAL_FUNCTION_PARAMETERS)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
long l;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
l = *(long *)((char*)r + offset);
|
|
|
|
RETURN_LONG(l);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ apache_request_int_slot()
|
|
*/
|
|
static void apache_request_int_slot(int offset, INTERNAL_FUNCTION_PARAMETERS)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
long old_value, new_value;
|
|
long *target;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &new_value) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
target = (long *)((char*)r + offset);
|
|
old_value = *target;
|
|
|
|
switch (ZEND_NUM_ARGS()) {
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
*target = new_value;
|
|
break;
|
|
default:
|
|
WRONG_PARAM_COUNT;
|
|
break;
|
|
}
|
|
|
|
RETURN_LONG(old_value);
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ access string slots of request rec
|
|
*/
|
|
|
|
/* {{{ proto string ApacheRequest::filename([string new_filename])
|
|
*/
|
|
PHP_FUNCTION(apache_request_filename)
|
|
{
|
|
apache_request_string_slot(offsetof(request_rec, filename), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string ApacheRequest::uri([string new_uri])
|
|
*/
|
|
PHP_FUNCTION(apache_request_uri)
|
|
{
|
|
apache_request_string_slot(offsetof(request_rec, uri), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string ApacheRequest::unparsed_uri([string new_unparsed_uri])
|
|
*/
|
|
PHP_FUNCTION(apache_request_unparsed_uri)
|
|
{
|
|
apache_request_string_slot(offsetof(request_rec, unparsed_uri), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string ApacheRequest::path_info([string new_path_info])
|
|
*/
|
|
PHP_FUNCTION(apache_request_path_info)
|
|
{
|
|
apache_request_string_slot(offsetof(request_rec, path_info), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string ApacheRequest::args([string new_args])
|
|
*/
|
|
PHP_FUNCTION(apache_request_args)
|
|
{
|
|
apache_request_string_slot(offsetof(request_rec, args), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string ApacheRequest::boundary()
|
|
*/
|
|
PHP_FUNCTION(apache_request_boundary)
|
|
{
|
|
apache_request_read_string_slot(offsetof(request_rec, boundary), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ proto string ApacheRequest::content_type([string new_type])
|
|
*/
|
|
PHP_FUNCTION(apache_request_content_type)
|
|
{
|
|
apache_request_string_slot(offsetof(request_rec, content_type), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string ApacheRequest::content_encoding([string new_encoding])
|
|
*/
|
|
PHP_FUNCTION(apache_request_content_encoding)
|
|
{
|
|
apache_request_string_slot(offsetof(request_rec, content_encoding), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string ApacheRequest::handler([string new_handler])
|
|
*/
|
|
PHP_FUNCTION(apache_request_handler)
|
|
{
|
|
apache_request_string_slot(offsetof(request_rec, handler), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string ApacheRequest::the_request()
|
|
*/
|
|
PHP_FUNCTION(apache_request_the_request)
|
|
{
|
|
apache_request_read_string_slot(offsetof(request_rec, the_request), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string ApacheRequest::protocol()
|
|
*/
|
|
PHP_FUNCTION(apache_request_protocol)
|
|
{
|
|
apache_request_read_string_slot(offsetof(request_rec, protocol), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string ApacheRequest::hostname()
|
|
*/
|
|
PHP_FUNCTION(apache_request_hostname)
|
|
{
|
|
apache_request_read_string_slot(offsetof(request_rec, hostname), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string ApacheRequest::status_line([string new_status_line])
|
|
*/
|
|
PHP_FUNCTION(apache_request_status_line)
|
|
{
|
|
apache_request_string_slot(offsetof(request_rec, status_line), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string ApacheRequest::method()
|
|
*/
|
|
PHP_FUNCTION(apache_request_method)
|
|
{
|
|
apache_request_read_string_slot(offsetof(request_rec, method), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* }}} access string slots of request rec */
|
|
|
|
/* {{{ access int slots of request_rec
|
|
*/
|
|
|
|
/* {{{ proto int ApacheRequest::proto_num()
|
|
*/
|
|
PHP_FUNCTION(apache_request_proto_num)
|
|
{
|
|
apache_request_read_int_slot(offsetof(request_rec, proto_num), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::assbackwards()
|
|
*/
|
|
PHP_FUNCTION(apache_request_assbackwards)
|
|
{
|
|
apache_request_read_int_slot(offsetof(request_rec, assbackwards), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ proto int ApacheRequest::proxyreq([int new_proxyreq])
|
|
*/
|
|
PHP_FUNCTION(apache_request_proxyreq)
|
|
{
|
|
apache_request_int_slot(offsetof(request_rec, proxyreq), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::chunked()
|
|
*/
|
|
PHP_FUNCTION(apache_request_chunked)
|
|
{
|
|
apache_request_read_int_slot(offsetof(request_rec, chunked), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ proto int ApacheRequest::header_only()
|
|
*/
|
|
PHP_FUNCTION(apache_request_header_only)
|
|
{
|
|
apache_request_read_int_slot(offsetof(request_rec, header_only), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::request_time()
|
|
*/
|
|
PHP_FUNCTION(apache_request_request_time)
|
|
{
|
|
apache_request_read_int_slot(offsetof(request_rec, request_time), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::status([int new_status])
|
|
*/
|
|
PHP_FUNCTION(apache_request_status)
|
|
{
|
|
apache_request_int_slot(offsetof(request_rec, status), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::method_number([int method_number])
|
|
*/
|
|
PHP_FUNCTION(apache_request_method_number)
|
|
{
|
|
apache_request_read_int_slot(offsetof(request_rec, method_number), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::allowed([int allowed])
|
|
*/
|
|
PHP_FUNCTION(apache_request_allowed)
|
|
{
|
|
apache_request_int_slot(offsetof(request_rec, allowed), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::bytes_sent()
|
|
*/
|
|
PHP_FUNCTION(apache_request_bytes_sent)
|
|
{
|
|
apache_request_read_int_slot(offsetof(request_rec, bytes_sent), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::mtime()
|
|
*/
|
|
PHP_FUNCTION(apache_request_mtime)
|
|
{
|
|
apache_request_read_int_slot(offsetof(request_rec, mtime), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::content_length([int new_content_length])
|
|
*/
|
|
PHP_FUNCTION(apache_request_content_length)
|
|
{
|
|
zval *id;
|
|
long zlen;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &zlen) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
if (ZEND_NUM_ARGS() == 0) {
|
|
apache_request_read_int_slot(offsetof(request_rec, clength), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
} else {
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
(void)ap_set_content_length(r, zlen);
|
|
RETURN_TRUE;
|
|
}
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::remaining()
|
|
*/
|
|
PHP_FUNCTION(apache_request_remaining)
|
|
{
|
|
apache_request_read_int_slot(offsetof(request_rec, remaining), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::no_cache()
|
|
*/
|
|
PHP_FUNCTION(apache_request_no_cache)
|
|
{
|
|
apache_request_int_slot(offsetof(request_rec, no_cache), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::no_local_copy()
|
|
*/
|
|
PHP_FUNCTION(apache_request_no_local_copy)
|
|
{
|
|
apache_request_int_slot(offsetof(request_rec, no_local_copy), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int ApacheRequest::read_body()
|
|
*/
|
|
PHP_FUNCTION(apache_request_read_body)
|
|
{
|
|
apache_request_int_slot(offsetof(request_rec, read_body), INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* }}} access int slots of request_rec */
|
|
|
|
|
|
/* {{{ proto array apache_request_headers_in()
|
|
* fetch all incoming request headers
|
|
*/
|
|
PHP_FUNCTION(apache_request_headers_in)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
apache_table_to_zval(r->headers_in, return_value);
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ add_header_to_table
|
|
*/
|
|
static void add_header_to_table(table *t, INTERNAL_FUNCTION_PARAMETERS)
|
|
{
|
|
zval *first = NULL;
|
|
zval *second = NULL;
|
|
zval **entry, **value;
|
|
char *string_key;
|
|
uint string_key_len;
|
|
ulong num_key;
|
|
|
|
zend_bool replace = 0;
|
|
HashPosition pos;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zb", &first, &second, &replace) == FAILURE) {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if (Z_TYPE_P(first) == IS_ARRAY) {
|
|
switch(ZEND_NUM_ARGS()) {
|
|
case 1:
|
|
case 3:
|
|
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(first), &pos);
|
|
while (zend_hash_get_current_data_ex(Z_ARRVAL_P(first), (void **)&entry, &pos) == SUCCESS) {
|
|
switch(zend_hash_get_current_key_ex(Z_ARRVAL_P(first), &string_key, &string_key_len, &num_key, 0, &pos)) {
|
|
case HASH_KEY_IS_STRING:
|
|
if (zend_hash_find(Z_ARRVAL_P(first), string_key, string_key_len, (void **)&value) == FAILURE) {
|
|
zend_hash_move_forward_ex(Z_ARRVAL_P(first), &pos);
|
|
continue;
|
|
}
|
|
if (!value) {
|
|
zend_hash_move_forward_ex(Z_ARRVAL_P(first), &pos);
|
|
continue;
|
|
}
|
|
|
|
convert_to_string_ex(value);
|
|
if (replace) {
|
|
ap_table_set(t, string_key, Z_STRVAL_PP(value));
|
|
} else {
|
|
ap_table_merge(t, string_key, Z_STRVAL_PP(value));
|
|
}
|
|
break;
|
|
case HASH_KEY_IS_LONG:
|
|
default:
|
|
php_error(E_WARNING, "%s(): Can only add STRING keys to headers!", get_active_function_name(TSRMLS_C));
|
|
break;
|
|
}
|
|
|
|
zend_hash_move_forward_ex(Z_ARRVAL_P(first), &pos);
|
|
}
|
|
break;
|
|
default:
|
|
WRONG_PARAM_COUNT;
|
|
break;
|
|
}
|
|
} else if (Z_TYPE_P(first) == IS_STRING) {
|
|
switch(ZEND_NUM_ARGS()) {
|
|
case 2:
|
|
case 3:
|
|
convert_to_string_ex(&second);
|
|
if (replace) {
|
|
ap_table_set(t, Z_STRVAL_P(first), Z_STRVAL_P(second));
|
|
} else {
|
|
ap_table_merge(t, Z_STRVAL_P(first), Z_STRVAL_P(second));
|
|
}
|
|
break;
|
|
default:
|
|
WRONG_PARAM_COUNT;
|
|
break;
|
|
}
|
|
} else {
|
|
RETURN_FALSE;
|
|
}
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ proto array apache_request_headers_out([{string name|array list} [, string value [, bool replace = false]]])
|
|
* fetch all outgoing request headers
|
|
*/
|
|
PHP_FUNCTION(apache_request_headers_out)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
if (ZEND_NUM_ARGS() > 0) {
|
|
add_header_to_table(r->headers_out, INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
|
|
apache_table_to_zval(r->headers_out, return_value);
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ proto array apache_request_err_headers_out([{string name|array list} [, string value [, bool replace = false]]])
|
|
* fetch all headers that go out in case of an error or a subrequest
|
|
*/
|
|
PHP_FUNCTION(apache_request_err_headers_out)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
if (ZEND_NUM_ARGS() > 0) {
|
|
add_header_to_table(r->err_headers_out, INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
}
|
|
|
|
apache_table_to_zval(r->err_headers_out, return_value);
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ proxy functions for the ap_* functions family
|
|
*/
|
|
|
|
/* {{{ proto int apache_request_server_port()
|
|
*/
|
|
PHP_FUNCTION(apache_request_server_port)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
RETURN_LONG(ap_get_server_port(r));
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int apache_request_remote_host([int type])
|
|
*/
|
|
PHP_FUNCTION(apache_request_remote_host)
|
|
{
|
|
zval *id;
|
|
long type = 0;
|
|
request_rec *r;
|
|
char *res;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &type) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
if (!type) {
|
|
type = REMOTE_NAME;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
res = (char *)ap_get_remote_host(r->connection, r->per_dir_config, (int)type);
|
|
|
|
if (res) {
|
|
RETURN_STRING(res, 1);
|
|
}
|
|
|
|
RETURN_EMPTY_STRING();
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto long apache_request_update_mtime([int dependency_mtime])
|
|
*/
|
|
PHP_FUNCTION(apache_request_update_mtime)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
long mtime = 0;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &mtime) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
RETURN_LONG(ap_update_mtime(r, (int) mtime));
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ proto void apache_request_set_etag()
|
|
*/
|
|
PHP_FUNCTION(apache_request_set_etag)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
ap_set_etag(r);
|
|
RETURN_TRUE;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto void apache_request_set_last_modified()
|
|
*/
|
|
PHP_FUNCTION(apache_request_set_last_modified)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
ap_set_last_modified(r);
|
|
RETURN_TRUE;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto long apache_request_meets_conditions()
|
|
*/
|
|
PHP_FUNCTION(apache_request_meets_conditions)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
RETURN_LONG(ap_meets_conditions(r));
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto long apache_request_discard_request_body()
|
|
*/
|
|
PHP_FUNCTION(apache_request_discard_request_body)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
RETURN_LONG(ap_discard_request_body(r));
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto long apache_request_satisfies()
|
|
*/
|
|
PHP_FUNCTION(apache_request_satisfies)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
RETURN_LONG(ap_satisfies(r));
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ proto bool apache_request_is_initial_req()
|
|
*/
|
|
PHP_FUNCTION(apache_request_is_initial_req)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
RETURN_BOOL(ap_is_initial_req(r));
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto bool apache_request_some_auth_required()
|
|
*/
|
|
PHP_FUNCTION(apache_request_some_auth_required)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
RETURN_BOOL(ap_some_auth_required(r));
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string apache_request_auth_type()
|
|
*/
|
|
PHP_FUNCTION(apache_request_auth_type)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
char *t;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
t = (char *)ap_auth_type(r);
|
|
if (!t) {
|
|
RETURN_NULL();
|
|
}
|
|
|
|
RETURN_STRING(t, 1);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string apache_request_auth_name()
|
|
*/
|
|
PHP_FUNCTION(apache_request_auth_name)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
char *t;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
t = (char *)ap_auth_name(r);
|
|
if (!t) {
|
|
RETURN_NULL();
|
|
}
|
|
|
|
RETURN_STRING(t, 1);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto apache_request_basic_auth_pw()
|
|
*/
|
|
PHP_FUNCTION(apache_request_basic_auth_pw)
|
|
{
|
|
zval *id, *zpw;
|
|
request_rec *r;
|
|
const char *pw;
|
|
long status;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zpw) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
if (!PZVAL_IS_REF(zpw)) {
|
|
zend_error(E_WARNING, "Parameter wasn't passed by reference");
|
|
RETURN_NULL();
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
pw = NULL;
|
|
status = ap_get_basic_auth_pw(r, &pw);
|
|
if (status == OK && pw) {
|
|
ZVAL_STRING(zpw, (char *)pw, 1);
|
|
} else {
|
|
ZVAL_NULL(zpw);
|
|
}
|
|
RETURN_LONG(status);
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* http_protocol.h */
|
|
|
|
PHP_FUNCTION(apache_request_send_http_header)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
char *type = NULL;
|
|
int typelen;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &type, &typelen) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
if(type) {
|
|
r->content_type = pstrdup(r->pool, type);
|
|
}
|
|
ap_send_http_header(r);
|
|
SG(headers_sent) = 1;
|
|
AP(headers_sent) = 1;
|
|
RETURN_TRUE;
|
|
}
|
|
|
|
PHP_FUNCTION(apache_request_basic_http_header)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
ap_basic_http_header((request_rec *)SG(server_context));
|
|
SG(headers_sent) = 1;
|
|
AP(headers_sent) = 1;
|
|
RETURN_TRUE;
|
|
}
|
|
|
|
PHP_FUNCTION(apache_request_send_http_trace)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
ap_send_http_trace((request_rec *)SG(server_context));
|
|
SG(headers_sent) = 1;
|
|
AP(headers_sent) = 1;
|
|
RETURN_TRUE;
|
|
}
|
|
|
|
PHP_FUNCTION(apache_request_send_http_options)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
ap_send_http_options((request_rec *)SG(server_context));
|
|
SG(headers_sent) = 1;
|
|
AP(headers_sent) = 1;
|
|
RETURN_TRUE;
|
|
}
|
|
|
|
PHP_FUNCTION(apache_request_send_error_response)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
long rec = 0;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &rec) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
ap_send_error_response(r, (int) rec);
|
|
RETURN_TRUE;
|
|
}
|
|
|
|
PHP_FUNCTION(apache_request_set_content_length)
|
|
{
|
|
long length;
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &length) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
ap_set_content_length(r, length);
|
|
RETURN_TRUE;
|
|
}
|
|
|
|
PHP_FUNCTION(apache_request_set_keepalive)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
ap_set_keepalive(r);
|
|
RETURN_TRUE;
|
|
}
|
|
|
|
/* This stuff should use streams or however this is implemented now
|
|
|
|
PHP_FUNCTION(apache_request_send_fd)
|
|
{
|
|
}
|
|
|
|
PHP_FUNCTION(apache_request_send_fd_length)
|
|
{
|
|
}
|
|
*/
|
|
|
|
/* These are for overriding default output behaviour */
|
|
PHP_FUNCTION(apache_request_rputs)
|
|
{
|
|
char *buffer;
|
|
int buffer_len;
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &buffer, &buffer_len) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
ap_rwrite(buffer, buffer_len, (request_rec*)SG(server_context));
|
|
}
|
|
|
|
/* This stuff would be useful for custom POST handlers,
|
|
which should be supported. Probably by not using
|
|
sapi_activate at all inside a phpResponseHandler
|
|
and instead using a builtin composed of the below
|
|
calls as a apache_read_request_body() and allow
|
|
people to custom craft their own.
|
|
|
|
PHP_FUNCTION(apache_request_setup_client_block)
|
|
{
|
|
}
|
|
|
|
PHP_FUNCTION(apache_request_should_client_block)
|
|
{
|
|
}
|
|
|
|
PHP_FUNCTION(apache_request_get_client_block)
|
|
{
|
|
}
|
|
|
|
PHP_FUNCTION(apache_request_discard_request_body)
|
|
{
|
|
}
|
|
*/
|
|
|
|
/* http_log.h */
|
|
|
|
/* {{{ proto boolean apache_request_log_error(string message, [long facility])
|
|
*/
|
|
PHP_FUNCTION(apache_request_log_error)
|
|
{
|
|
zval *id;
|
|
char *z_errstr;
|
|
int z_errstr_len;
|
|
long facility = APLOG_ERR;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &z_errstr, &z_errstr_len, &facility) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
ap_log_error(APLOG_MARK, (int) facility, r->server, "%s", z_errstr);
|
|
RETURN_TRUE;
|
|
}
|
|
/* }}} */
|
|
/* http_main.h */
|
|
|
|
/* {{{ proto object apache_request_sub_req_lookup_uri(string uri)
|
|
Returns sub-request for the specified uri. You would
|
|
need to run it yourself with run()
|
|
*/
|
|
PHP_FUNCTION(apache_request_sub_req_lookup_uri)
|
|
{
|
|
zval *id;
|
|
char *file;
|
|
int file_len;
|
|
request_rec *r, *sub_r;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &file, &file_len) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
sub_r = ap_sub_req_lookup_uri(file, r);
|
|
|
|
if (!sub_r) {
|
|
RETURN_FALSE;
|
|
}
|
|
return_value = php_apache_request_new(sub_r TSRMLS_CC);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto object apache_request_sub_req_lookup_file(string file)
|
|
Returns sub-request for the specified file. You would
|
|
need to run it yourself with run().
|
|
*/
|
|
PHP_FUNCTION(apache_request_sub_req_lookup_file)
|
|
{
|
|
zval *id;
|
|
char *file;
|
|
int file_len;
|
|
request_rec *r, *sub_r;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &file, &file_len) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
sub_r = ap_sub_req_lookup_file(file, r);
|
|
|
|
if (!sub_r) {
|
|
RETURN_FALSE;
|
|
}
|
|
return_value = php_apache_request_new(sub_r TSRMLS_CC);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto object apache_request_sub_req_method_uri(string method, string uri)
|
|
Returns sub-request for the specified file. You would
|
|
need to run it yourself with run().
|
|
*/
|
|
PHP_FUNCTION(apache_request_sub_req_method_uri)
|
|
{
|
|
zval *id;
|
|
char *file, *method;
|
|
int file_len, method_len;
|
|
request_rec *r, *sub_r;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &method, &method_len, &file, &file_len) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
sub_r = ap_sub_req_method_uri(method, file, r);
|
|
|
|
if (!sub_r) {
|
|
RETURN_FALSE;
|
|
}
|
|
return_value = php_apache_request_new(sub_r TSRMLS_CC);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto long apache_request_run()
|
|
This is a wrapper for ap_sub_run_req and ap_destory_sub_req. It takes
|
|
sub_request, runs it, destroys it, and returns it's status.
|
|
*/
|
|
PHP_FUNCTION(apache_request_run)
|
|
{
|
|
zval *id;
|
|
request_rec *r;
|
|
int status;
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
if (!r || ap_is_initial_req(r)) {
|
|
RETURN_FALSE;
|
|
}
|
|
status = ap_run_sub_req(r);
|
|
ap_destroy_sub_req(r);
|
|
RETURN_LONG(status);
|
|
}
|
|
/* }}} */
|
|
|
|
PHP_FUNCTION(apache_request_internal_redirect)
|
|
{
|
|
zval *id;
|
|
char *new_uri;
|
|
int new_uri_len;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &new_uri, &new_uri_len) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
ap_internal_redirect(new_uri, r);
|
|
}
|
|
|
|
PHP_FUNCTION(apache_request_send_header_field)
|
|
{
|
|
char *fieldname, *fieldval;
|
|
int fieldname_len, fieldval_len;
|
|
zval *id;
|
|
request_rec *r;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &fieldname, &fieldname_len, &fieldval, &fieldval_len) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
APREQ_GET_REQUEST(id, r);
|
|
|
|
ap_send_header_field(r, fieldname, fieldval);
|
|
SG(headers_sent) = 1;
|
|
AP(headers_sent) = 1;
|
|
}
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
/* {{{ php_apache_request_class_functions
|
|
*/
|
|
const static zend_function_entry php_apache_request_class_functions[] = {
|
|
/* string slots */
|
|
PHP_FALIAS(args, apache_request_args, NULL)
|
|
PHP_FALIAS(boundary, apache_request_boundary, NULL)
|
|
PHP_FALIAS(content_encoding, apache_request_content_encoding, NULL)
|
|
PHP_FALIAS(content_type, apache_request_content_type, NULL)
|
|
PHP_FALIAS(filename, apache_request_filename, NULL)
|
|
PHP_FALIAS(handler, apache_request_handler, NULL)
|
|
PHP_FALIAS(hostname, apache_request_hostname, NULL)
|
|
PHP_FALIAS(method, apache_request_method, NULL)
|
|
PHP_FALIAS(path_info, apache_request_path_info, NULL)
|
|
PHP_FALIAS(protocol, apache_request_protocol, NULL)
|
|
PHP_FALIAS(status_line, apache_request_status_line, NULL)
|
|
PHP_FALIAS(the_request, apache_request_the_request, NULL)
|
|
PHP_FALIAS(unparsed_uri, apache_request_unparsed_uri, NULL)
|
|
PHP_FALIAS(uri, apache_request_uri, NULL)
|
|
|
|
/* int slots */
|
|
PHP_FALIAS(allowed, apache_request_allowed, NULL)
|
|
PHP_FALIAS(bytes_sent, apache_request_bytes_sent, NULL)
|
|
PHP_FALIAS(chunked, apache_request_chunked, NULL)
|
|
PHP_FALIAS(content_length, apache_request_content_length, NULL)
|
|
PHP_FALIAS(header_only, apache_request_header_only, NULL)
|
|
PHP_FALIAS(method_number, apache_request_method_number, NULL)
|
|
PHP_FALIAS(mtime, apache_request_mtime, NULL)
|
|
PHP_FALIAS(no_cache, apache_request_no_cache, NULL)
|
|
PHP_FALIAS(no_local_copy, apache_request_no_local_copy, NULL)
|
|
PHP_FALIAS(proto_num, apache_request_proto_num, NULL)
|
|
PHP_FALIAS(proxyreq, apache_request_proxyreq, NULL)
|
|
PHP_FALIAS(read_body, apache_request_read_body, NULL)
|
|
PHP_FALIAS(remaining, apache_request_remaining, NULL)
|
|
PHP_FALIAS(request_time, apache_request_request_time, NULL)
|
|
PHP_FALIAS(status, apache_request_status, NULL)
|
|
|
|
/* tables & arrays */
|
|
PHP_FALIAS(headers_in, apache_request_headers_in, NULL)
|
|
PHP_FALIAS(headers_out, apache_request_headers_out, NULL)
|
|
PHP_FALIAS(err_headers_out, apache_request_err_headers_out, NULL)
|
|
|
|
|
|
/* proxy functions for the ap_* functions family */
|
|
#undef auth_name
|
|
#undef auth_type
|
|
#undef discard_request_body
|
|
#undef is_initial_req
|
|
#undef meets_conditions
|
|
#undef satisfies
|
|
#undef set_etag
|
|
#undef set_last_modified
|
|
#undef some_auth_required
|
|
#undef update_mtime
|
|
#undef send_http_header
|
|
#undef send_header_field
|
|
#undef basic_http_header
|
|
#undef send_http_trace
|
|
#undef send_http_options
|
|
#undef send_error_response
|
|
#undef set_content_length
|
|
#undef set_keepalive
|
|
#undef rputs
|
|
#undef log_error
|
|
#undef lookup_uri
|
|
#undef lookup_file
|
|
#undef method_uri
|
|
#undef run
|
|
#undef internal_redirect
|
|
PHP_FALIAS(auth_name, apache_request_auth_name, NULL)
|
|
PHP_FALIAS(auth_type, apache_request_auth_type, NULL)
|
|
PHP_FALIAS(basic_auth_pw, apache_request_basic_auth_pw, NULL)
|
|
PHP_FALIAS(discard_request_body, apache_request_discard_request_body, NULL)
|
|
PHP_FALIAS(is_initial_req, apache_request_is_initial_req, NULL)
|
|
PHP_FALIAS(meets_conditions, apache_request_meets_conditions, NULL)
|
|
PHP_FALIAS(remote_host, apache_request_remote_host, NULL)
|
|
PHP_FALIAS(satisfies, apache_request_satisfies, NULL)
|
|
PHP_FALIAS(server_port, apache_request_server_port, NULL)
|
|
PHP_FALIAS(set_etag, apache_request_set_etag, NULL)
|
|
PHP_FALIAS(set_last_modified, apache_request_set_last_modified, NULL)
|
|
PHP_FALIAS(some_auth_required, apache_request_some_auth_required, NULL)
|
|
PHP_FALIAS(update_mtime, apache_request_update_mtime, NULL)
|
|
PHP_FALIAS(send_http_header, apache_request_send_http_header, NULL)
|
|
PHP_FALIAS(basic_http_header, apache_request_basic_http_header, NULL)
|
|
PHP_FALIAS(send_header_field, apache_request_send_header_field, NULL)
|
|
PHP_FALIAS(send_http_trace, apache_request_send_http_trace, NULL)
|
|
PHP_FALIAS(send_http_options, apache_request_send_http_trace, NULL)
|
|
PHP_FALIAS(send_error_response, apache_request_send_error_response, NULL)
|
|
PHP_FALIAS(set_content_length, apache_request_set_content_length, NULL)
|
|
PHP_FALIAS(set_keepalive, apache_request_set_keepalive, NULL)
|
|
PHP_FALIAS(rputs, apache_request_rputs, NULL)
|
|
PHP_FALIAS(log_error, apache_request_log_error, NULL)
|
|
PHP_FALIAS(lookup_uri, apache_request_sub_req_lookup_uri, NULL)
|
|
PHP_FALIAS(lookup_file, apache_request_sub_req_lookup_file, NULL)
|
|
PHP_FALIAS(method_uri, apache_request_sub_req_method_uri, NULL)
|
|
PHP_FALIAS(run, apache_request_run, NULL)
|
|
PHP_FALIAS(internal_redirect, apache_request_internal_redirect, NULL)
|
|
PHP_FE_END
|
|
};
|
|
/* }}} */
|
|
|
|
|
|
static PHP_MINIT_FUNCTION(apache)
|
|
{
|
|
zend_class_entry ce;
|
|
|
|
#ifdef ZTS
|
|
ts_allocate_id(&php_apache_info_id, sizeof(php_apache_info_struct), (ts_allocate_ctor) php_apache_globals_ctor, NULL);
|
|
#else
|
|
php_apache_globals_ctor(&php_apache_info TSRMLS_CC);
|
|
#endif
|
|
REGISTER_INI_ENTRIES();
|
|
|
|
|
|
le_apachereq = zend_register_list_destructors_ex(php_apache_request_free, NULL, "ApacheRequest", module_number);
|
|
INIT_OVERLOADED_CLASS_ENTRY(ce, "ApacheRequest", php_apache_request_class_functions, NULL, NULL, NULL);
|
|
apacherequest_class_entry = zend_register_internal_class_ex(&ce, NULL TSRMLS_CC);
|
|
|
|
REGISTER_LONG_CONSTANT("OK", OK, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("DECLINED", DECLINED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("FORBIDDEN", FORBIDDEN, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("AUTH_REQUIRED", AUTH_REQUIRED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("DONE", DONE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("SERVER_ERROR", SERVER_ERROR, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("REDIRECT", REDIRECT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("BAD_REQUEST", BAD_REQUEST, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("NOT_FOUND", NOT_FOUND, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_CONTINUE", HTTP_CONTINUE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_SWITCHING_PROTOCOLS", HTTP_SWITCHING_PROTOCOLS, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_PROCESSING", HTTP_PROCESSING, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_OK", HTTP_OK, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_CREATED", HTTP_CREATED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_ACCEPTED", HTTP_ACCEPTED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_NON_AUTHORITATIVE", HTTP_NON_AUTHORITATIVE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_NO_CONTENT", HTTP_NO_CONTENT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_RESET_CONTENT", HTTP_RESET_CONTENT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_PARTIAL_CONTENT", HTTP_PARTIAL_CONTENT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_MULTI_STATUS", HTTP_MULTI_STATUS, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_MULTIPLE_CHOICES", HTTP_MULTIPLE_CHOICES, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_MOVED_PERMANENTLY", HTTP_MOVED_PERMANENTLY, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_MOVED_TEMPORARILY", HTTP_MOVED_TEMPORARILY, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_SEE_OTHER", HTTP_SEE_OTHER, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_NOT_MODIFIED", HTTP_NOT_MODIFIED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_USE_PROXY", HTTP_USE_PROXY, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_TEMPORARY_REDIRECT", HTTP_TEMPORARY_REDIRECT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_BAD_REQUEST", HTTP_BAD_REQUEST, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_UNAUTHORIZED", HTTP_UNAUTHORIZED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_PAYMENT_REQUIRED", HTTP_PAYMENT_REQUIRED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_FORBIDDEN", HTTP_FORBIDDEN, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_NOT_FOUND", HTTP_NOT_FOUND, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_METHOD_NOT_ALLOWED", HTTP_METHOD_NOT_ALLOWED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_NOT_ACCEPTABLE", HTTP_NOT_ACCEPTABLE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_PROXY_AUTHENTICATION_REQUIRED", HTTP_PROXY_AUTHENTICATION_REQUIRED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_REQUEST_TIME_OUT", HTTP_REQUEST_TIME_OUT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_CONFLICT", HTTP_CONFLICT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_GONE", HTTP_GONE, CONST_CS | CONST_PERSISTENT);REGISTER_LONG_CONSTANT("HTTP_LENGTH_REQUIRED", HTTP_LENGTH_REQUIRED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_PRECONDITION_FAILED", HTTP_PRECONDITION_FAILED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_REQUEST_ENTITY_TOO_LARGE", HTTP_REQUEST_ENTITY_TOO_LARGE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_REQUEST_URI_TOO_LARGE", HTTP_REQUEST_URI_TOO_LARGE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_UNSUPPORTED_MEDIA_TYPE", HTTP_UNSUPPORTED_MEDIA_TYPE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_RANGE_NOT_SATISFIABLE", HTTP_RANGE_NOT_SATISFIABLE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_EXPECTATION_FAILED", HTTP_EXPECTATION_FAILED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_UNPROCESSABLE_ENTITY", HTTP_UNPROCESSABLE_ENTITY, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_LOCKED", HTTP_LOCKED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_FAILED_DEPENDENCY", HTTP_FAILED_DEPENDENCY, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_INTERNAL_SERVER_ERROR", HTTP_INTERNAL_SERVER_ERROR, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_NOT_IMPLEMENTED", HTTP_NOT_IMPLEMENTED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_BAD_GATEWAY", HTTP_BAD_GATEWAY, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_SERVICE_UNAVAILABLE", HTTP_SERVICE_UNAVAILABLE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_GATEWAY_TIME_OUT", HTTP_GATEWAY_TIME_OUT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_VERSION_NOT_SUPPORTED", HTTP_VERSION_NOT_SUPPORTED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_VARIANT_ALSO_VARIES", HTTP_VARIANT_ALSO_VARIES, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_INSUFFICIENT_STORAGE", HTTP_INSUFFICIENT_STORAGE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("HTTP_NOT_EXTENDED", HTTP_NOT_EXTENDED, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("APLOG_EMERG", APLOG_EMERG, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("APLOG_ALERT", APLOG_ALERT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("APLOG_CRIT", APLOG_CRIT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("APLOG_ERR", APLOG_ERR, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("APLOG_WARNING", APLOG_WARNING, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("APLOG_NOTICE", APLOG_NOTICE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("APLOG_INFO", APLOG_INFO, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("APLOG_DEBUG", APLOG_DEBUG, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_GET", M_GET, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_PUT", M_PUT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_POST", M_POST, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_DELETE", M_DELETE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_CONNECT", M_CONNECT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_OPTIONS", M_OPTIONS, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_TRACE", M_TRACE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_PATCH", M_PATCH, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_PROPFIND", M_PROPFIND, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_PROPPATCH", M_PROPPATCH, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_MKCOL", M_MKCOL, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_COPY", M_COPY, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_MOVE", M_MOVE, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_LOCK", M_LOCK, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_UNLOCK", M_UNLOCK, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("M_INVALID", M_INVALID, CONST_CS | CONST_PERSISTENT);
|
|
|
|
/* Possible values for request_rec.read_body (set by handling module):
|
|
* REQUEST_NO_BODY Send 413 error if message has any body
|
|
* REQUEST_CHUNKED_ERROR Send 411 error if body without Content-Length
|
|
* REQUEST_CHUNKED_DECHUNK If chunked, remove the chunks for me.
|
|
* REQUEST_CHUNKED_PASS Pass the chunks to me without removal.
|
|
*/
|
|
REGISTER_LONG_CONSTANT("REQUEST_NO_BODY", REQUEST_NO_BODY, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("REQUEST_CHUNKED_ERROR", REQUEST_CHUNKED_ERROR, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("REQUEST_CHUNKED_DECHUNK", REQUEST_CHUNKED_DECHUNK, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("REQUEST_CHUNKED_PASS", REQUEST_CHUNKED_PASS, CONST_CS | CONST_PERSISTENT);
|
|
|
|
/* resolve types for remote_host() */
|
|
REGISTER_LONG_CONSTANT("REMOTE_HOST", REMOTE_HOST, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("REMOTE_NAME", REMOTE_NAME, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("REMOTE_NOLOOKUP", REMOTE_NOLOOKUP, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("REMOTE_DOUBLE_REV", REMOTE_DOUBLE_REV, CONST_CS | CONST_PERSISTENT);
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
|
|
static PHP_MSHUTDOWN_FUNCTION(apache)
|
|
{
|
|
UNREGISTER_INI_ENTRIES();
|
|
return SUCCESS;
|
|
}
|
|
|
|
zend_module_entry apache_module_entry = {
|
|
STANDARD_MODULE_HEADER,
|
|
"apache",
|
|
apache_functions,
|
|
PHP_MINIT(apache),
|
|
PHP_MSHUTDOWN(apache),
|
|
NULL,
|
|
NULL,
|
|
PHP_MINFO(apache),
|
|
NO_VERSION_YET,
|
|
STANDARD_MODULE_PROPERTIES
|
|
};
|
|
|
|
/* {{{ proto bool apache_child_terminate(void)
|
|
Terminate apache process after this request */
|
|
PHP_FUNCTION(apache_child_terminate)
|
|
{
|
|
#ifndef MULTITHREAD
|
|
if (AP(terminate_child)) {
|
|
ap_child_terminate( ((request_rec *)SG(server_context)) );
|
|
RETURN_TRUE;
|
|
} else { /* tell them to get lost! */
|
|
php_error(E_WARNING, "apache.child_terminate is disabled");
|
|
RETURN_FALSE;
|
|
}
|
|
#else
|
|
php_error(E_WARNING, "apache_child_terminate() is not supported in this build");
|
|
RETURN_FALSE;
|
|
#endif
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string apache_note(string note_name [, string note_value])
|
|
Get and set Apache request notes */
|
|
PHP_FUNCTION(apache_note)
|
|
{
|
|
char *arg_name, *arg_val = NULL;
|
|
int arg_name_len, arg_val_len;
|
|
char *note_val;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &arg_name, &arg_name_len, &arg_val, &arg_val_len) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
note_val = (char *) table_get(((request_rec *)SG(server_context))->notes, arg_name);
|
|
|
|
if (arg_val) {
|
|
table_set(((request_rec *)SG(server_context))->notes, arg_name, arg_val);
|
|
}
|
|
|
|
if (!note_val) {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
RETURN_STRING(note_val, 1);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ PHP_MINFO_FUNCTION
|
|
*/
|
|
PHP_MINFO_FUNCTION(apache)
|
|
{
|
|
module *modp = NULL;
|
|
char output_buf[128];
|
|
#if !defined(WIN32) && !defined(WINNT)
|
|
char name[64];
|
|
char modulenames[1024];
|
|
char *p;
|
|
#endif
|
|
server_rec *serv;
|
|
extern char server_root[MAX_STRING_LEN];
|
|
extern uid_t user_id;
|
|
extern char *user_name;
|
|
extern gid_t group_id;
|
|
extern int max_requests_per_child;
|
|
|
|
serv = ((request_rec *) SG(server_context))->server;
|
|
|
|
|
|
php_info_print_table_start();
|
|
|
|
#ifdef PHP_WIN32
|
|
php_info_print_table_row(1, "Apache for Windows 95/NT");
|
|
php_info_print_table_end();
|
|
php_info_print_table_start();
|
|
#elif defined(NETWARE)
|
|
php_info_print_table_row(1, "Apache for NetWare");
|
|
php_info_print_table_end();
|
|
php_info_print_table_start();
|
|
#else
|
|
php_info_print_table_row(2, "APACHE_INCLUDE", PHP_APACHE_INCLUDE);
|
|
php_info_print_table_row(2, "APACHE_TARGET", PHP_APACHE_TARGET);
|
|
#endif
|
|
|
|
php_info_print_table_row(2, "Apache Version", SERVER_VERSION);
|
|
|
|
#ifdef APACHE_RELEASE
|
|
snprintf(output_buf, sizeof(output_buf), "%d", APACHE_RELEASE);
|
|
php_info_print_table_row(2, "Apache Release", output_buf);
|
|
#endif
|
|
snprintf(output_buf, sizeof(output_buf), "%d", MODULE_MAGIC_NUMBER);
|
|
php_info_print_table_row(2, "Apache API Version", output_buf);
|
|
snprintf(output_buf, sizeof(output_buf), "%s:%u", serv->server_hostname, serv->port);
|
|
php_info_print_table_row(2, "Hostname:Port", output_buf);
|
|
#if !defined(WIN32) && !defined(WINNT)
|
|
snprintf(output_buf, sizeof(output_buf), "%s(%d)/%d", user_name, (int)user_id, (int)group_id);
|
|
php_info_print_table_row(2, "User/Group", output_buf);
|
|
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);
|
|
php_info_print_table_row(2, "Max Requests", output_buf);
|
|
#endif
|
|
snprintf(output_buf, sizeof(output_buf), "Connection: %d - Keep-Alive: %d", serv->timeout, serv->keep_alive_timeout);
|
|
php_info_print_table_row(2, "Timeouts", output_buf);
|
|
#if !defined(WIN32) && !defined(WINNT)
|
|
/*
|
|
This block seems to be working on NetWare; But it seems to be showing
|
|
all modules instead of just the loaded ones
|
|
*/
|
|
php_info_print_table_row(2, "Server Root", server_root);
|
|
|
|
strcpy(modulenames, "");
|
|
for(modp = top_module; modp; modp = modp->next) {
|
|
strlcpy(name, modp->name, sizeof(name));
|
|
if ((p = strrchr(name, '.'))) {
|
|
*p='\0'; /* Cut off ugly .c extensions on module names */
|
|
}
|
|
strlcat(modulenames, name, sizeof(modulenames));
|
|
if (modp->next) {
|
|
strlcat(modulenames, ", ", sizeof(modulenames));
|
|
}
|
|
}
|
|
php_info_print_table_row(2, "Loaded Modules", modulenames);
|
|
#endif
|
|
|
|
php_info_print_table_end();
|
|
|
|
DISPLAY_INI_ENTRIES();
|
|
|
|
{
|
|
register int i;
|
|
array_header *arr;
|
|
table_entry *elts;
|
|
request_rec *r;
|
|
|
|
r = ((request_rec *) SG(server_context));
|
|
arr = table_elts(r->subprocess_env);
|
|
elts = (table_entry *)arr->elts;
|
|
|
|
SECTION("Apache Environment");
|
|
php_info_print_table_start();
|
|
php_info_print_table_header(2, "Variable", "Value");
|
|
for (i=0; i < arr->nelts; i++) {
|
|
php_info_print_table_row(2, elts[i].key, elts[i].val);
|
|
}
|
|
php_info_print_table_end();
|
|
}
|
|
|
|
{
|
|
array_header *env_arr;
|
|
table_entry *env;
|
|
int i;
|
|
request_rec *r;
|
|
|
|
r = ((request_rec *) SG(server_context));
|
|
SECTION("HTTP Headers Information");
|
|
php_info_print_table_start();
|
|
php_info_print_table_colspan_header(2, "HTTP Request Headers");
|
|
php_info_print_table_row(2, "HTTP Request", r->the_request);
|
|
env_arr = table_elts(r->headers_in);
|
|
env = (table_entry *)env_arr->elts;
|
|
for (i = 0; i < env_arr->nelts; ++i) {
|
|
if (env[i].key) {
|
|
php_info_print_table_row(2, env[i].key, env[i].val);
|
|
}
|
|
}
|
|
php_info_print_table_colspan_header(2, "HTTP Response Headers");
|
|
env_arr = table_elts(r->headers_out);
|
|
env = (table_entry *)env_arr->elts;
|
|
for(i = 0; i < env_arr->nelts; ++i) {
|
|
if (env[i].key) {
|
|
php_info_print_table_row(2, env[i].key, env[i].val);
|
|
}
|
|
}
|
|
php_info_print_table_end();
|
|
}
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto bool virtual(string filename)
|
|
Perform an Apache sub-request */
|
|
/* This function is equivalent to <!--#include virtual...-->
|
|
* in mod_include. It does an Apache sub-request. It is useful
|
|
* for including CGI scripts or .shtml files, or anything else
|
|
* that you'd parse through Apache (for .phtml files, you'd probably
|
|
* want to use <?Include>. This only works when PHP is compiled
|
|
* as an Apache module, since it uses the Apache API for doing
|
|
* sub requests.
|
|
*/
|
|
PHP_FUNCTION(virtual)
|
|
{
|
|
char *filename;
|
|
int filename_len;
|
|
request_rec *rr = NULL;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
if (!(rr = sub_req_lookup_uri (filename, ((request_rec *) SG(server_context))))) {
|
|
php_error(E_WARNING, "Unable to include '%s' - URI lookup failed", filename);
|
|
if (rr)
|
|
destroy_sub_req (rr);
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if (rr->status != 200) {
|
|
php_error(E_WARNING, "Unable to include '%s' - error finding URI", filename);
|
|
if (rr)
|
|
destroy_sub_req (rr);
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
php_output_end_all(TSRMLS_C);
|
|
php_header(TSRMLS_C);
|
|
|
|
if (run_sub_req(rr)) {
|
|
php_error(E_WARNING, "Unable to include '%s' - request execution failed", filename);
|
|
if (rr)
|
|
destroy_sub_req (rr);
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if (rr)
|
|
destroy_sub_req (rr);
|
|
RETURN_TRUE;
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ apache_table_to_zval(table *, zval *return_value)
|
|
Fetch all HTTP request headers */
|
|
static void apache_table_to_zval(table *t, zval *return_value)
|
|
{
|
|
array_header *env_arr;
|
|
table_entry *tenv;
|
|
int i;
|
|
|
|
array_init(return_value);
|
|
env_arr = table_elts(t);
|
|
tenv = (table_entry *)env_arr->elts;
|
|
for (i = 0; i < env_arr->nelts; ++i) {
|
|
if (!tenv[i].key) {
|
|
continue;
|
|
}
|
|
if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val)==FAILURE) {
|
|
RETURN_FALSE;
|
|
}
|
|
}
|
|
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* {{{ proto array getallheaders(void)
|
|
*/
|
|
/* Alias for apache_request_headers() */
|
|
/* }}} */
|
|
|
|
/* {{{ proto array apache_request_headers(void)
|
|
Fetch all HTTP request headers */
|
|
PHP_FUNCTION(apache_request_headers)
|
|
{
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
apache_table_to_zval(((request_rec *)SG(server_context))->headers_in, return_value);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto array apache_response_headers(void)
|
|
Fetch all HTTP response headers */
|
|
PHP_FUNCTION(apache_response_headers)
|
|
{
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
apache_table_to_zval(((request_rec *) SG(server_context))->headers_out, return_value);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto bool apache_setenv(string variable, string value [, bool walk_to_top])
|
|
Set an Apache subprocess_env variable */
|
|
PHP_FUNCTION(apache_setenv)
|
|
{
|
|
int var_len, val_len;
|
|
zend_bool top=0;
|
|
char *var = NULL, *val = NULL;
|
|
request_rec *r = (request_rec *) SG(server_context);
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", &var, &var_len, &val, &val_len, &top) == FAILURE) {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
while(top) {
|
|
if (r->prev) {
|
|
r = r->prev;
|
|
}
|
|
else break;
|
|
}
|
|
|
|
ap_table_setn(r->subprocess_env, ap_pstrndup(r->pool, var, var_len), ap_pstrndup(r->pool, val, val_len));
|
|
RETURN_TRUE;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto object apache_lookup_uri(string URI)
|
|
Perform a partial request of the given URI to obtain information about it */
|
|
PHP_FUNCTION(apache_lookup_uri)
|
|
{
|
|
char *filename;
|
|
int filename_len;
|
|
request_rec *rr=NULL;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
if(!(rr = sub_req_lookup_uri(filename, ((request_rec *) SG(server_context))))) {
|
|
php_error(E_WARNING, "URI lookup failed", filename);
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
object_init(return_value);
|
|
add_property_long(return_value,"status", rr->status);
|
|
|
|
if (rr->the_request) {
|
|
add_property_string(return_value,"the_request", rr->the_request);
|
|
}
|
|
if (rr->status_line) {
|
|
add_property_string(return_value,"status_line", (char *)rr->status_line);
|
|
}
|
|
if (rr->method) {
|
|
add_property_string(return_value,"method", (char *)rr->method);
|
|
}
|
|
if (rr->content_type) {
|
|
add_property_string(return_value,"content_type", (char *)rr->content_type);
|
|
}
|
|
if (rr->handler) {
|
|
add_property_string(return_value,"handler", (char *)rr->handler);
|
|
}
|
|
if (rr->uri) {
|
|
add_property_string(return_value,"uri", rr->uri);
|
|
}
|
|
if (rr->filename) {
|
|
add_property_string(return_value,"filename", rr->filename);
|
|
}
|
|
if (rr->path_info) {
|
|
add_property_string(return_value,"path_info", rr->path_info);
|
|
}
|
|
if (rr->args) {
|
|
add_property_string(return_value,"args", rr->args);
|
|
}
|
|
if (rr->boundary) {
|
|
add_property_string(return_value,"boundary", rr->boundary);
|
|
}
|
|
add_property_long(return_value,"no_cache", rr->no_cache);
|
|
add_property_long(return_value,"no_local_copy", rr->no_local_copy);
|
|
add_property_long(return_value,"allowed", rr->allowed);
|
|
add_property_long(return_value,"sent_bodyct", rr->sent_bodyct);
|
|
add_property_long(return_value,"bytes_sent", rr->bytes_sent);
|
|
add_property_long(return_value,"byterange", rr->byterange);
|
|
add_property_long(return_value,"clength", rr->clength);
|
|
|
|
#if MODULE_MAGIC_NUMBER >= 19980324
|
|
if (rr->unparsed_uri) {
|
|
add_property_string(return_value,"unparsed_uri", rr->unparsed_uri);
|
|
}
|
|
if(rr->mtime) {
|
|
add_property_long(return_value,"mtime", rr->mtime);
|
|
}
|
|
#endif
|
|
if(rr->request_time) {
|
|
add_property_long(return_value,"request_time", rr->request_time);
|
|
}
|
|
|
|
destroy_sub_req(rr);
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
#if 0
|
|
/*
|
|
This function is most likely a bad idea. Just playing with it for now.
|
|
*/
|
|
|
|
PHP_FUNCTION(apache_exec_uri)
|
|
{
|
|
zval **filename;
|
|
request_rec *rr=NULL;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &filename) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
convert_to_string_ex(filename);
|
|
|
|
if(!(rr = ap_sub_req_lookup_uri((*filename)->value.str.val, ((request_rec *) SG(server_context))))) {
|
|
php_error(E_WARNING, "URI lookup failed", (*filename)->value.str.val);
|
|
RETURN_FALSE;
|
|
}
|
|
RETVAL_LONG(ap_run_sub_req(rr));
|
|
ap_destroy_sub_req(rr);
|
|
}
|
|
#endif
|
|
|
|
/* {{{ proto string apache_get_version(void)
|
|
Fetch Apache version */
|
|
PHP_FUNCTION(apache_get_version)
|
|
{
|
|
char *apv = (char *) ap_get_server_version();
|
|
|
|
if (apv && *apv) {
|
|
RETURN_STRING(apv, 1);
|
|
} else {
|
|
RETURN_FALSE;
|
|
}
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto array apache_get_modules(void)
|
|
Get a list of loaded Apache modules */
|
|
PHP_FUNCTION(apache_get_modules)
|
|
{
|
|
int n;
|
|
char *p;
|
|
|
|
array_init(return_value);
|
|
|
|
for (n = 0; ap_loaded_modules[n]; ++n) {
|
|
char *s = (char *) ap_loaded_modules[n]->name;
|
|
if ((p = strchr(s, '.'))) {
|
|
add_next_index_stringl(return_value, s, (p - s));
|
|
} else {
|
|
add_next_index_string(return_value, s);
|
|
}
|
|
}
|
|
}
|
|
/* }}} */
|
|
|
|
/*
|
|
* Local variables:
|
|
* tab-width: 4
|
|
* c-basic-offset: 4
|
|
* End:
|
|
* vim600: sw=4 ts=4 fdm=marker
|
|
* vim<600: sw=4 ts=4
|
|
*/
|