X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-http;a=blobdiff_plain;f=php_http_env.c;h=4f239e509360aad962fcf129884701c85862d166;hp=9fd8e59e74b67f7fa15d41e9920ebb44ce5ab511;hb=f05a032e5e994a8b1ea8b5ab0291f1d1d6d42355;hpb=8c69d38f5215bf073ff0a563b65c6ac067937de4

diff --git a/php_http_env.c b/php_http_env.c
index 9fd8e59..4f239e5 100644
--- a/php_http_env.c
+++ b/php_http_env.c
@@ -11,11 +11,69 @@
 */
 
 #include "php_http_api.h"
+#include "php_variables.h"
 
 PHP_RINIT_FUNCTION(http_env)
 {
 	PHP_HTTP_G->env.request.time = sapi_get_request_time(TSRMLS_C);
 
+	/* populate form data on non-POST requests */
+	if (SG(request_info).request_method && strcasecmp(SG(request_info).request_method, "POST") && SG(request_info).content_type && *SG(request_info).content_type) {
+		uint ct_len = strlen(SG(request_info).content_type);
+		char *ct_str = estrndup(SG(request_info).content_type, ct_len);
+		php_http_params_opts_t opts;
+		HashTable params;
+
+		php_http_params_opts_default_get(&opts);
+		opts.input.str = ct_str;
+		opts.input.len = ct_len;
+
+		SG(request_info).content_type_dup = ct_str;
+
+		ZEND_INIT_SYMTABLE(&params);
+		if (php_http_params_parse(&params, &opts TSRMLS_CC)) {
+			char *key_str;
+			uint key_len;
+			ulong key_num;
+
+			if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(&params, &key_str, &key_len, &key_num, 0, NULL)) {
+				sapi_post_entry *post_entry = NULL;
+
+				if (SUCCESS == zend_hash_find(&SG(known_post_content_types), key_str, key_len, (void *) &post_entry)) {
+					zval *files = PG(http_globals)[TRACK_VARS_FILES];
+
+					if (post_entry) {
+						SG(request_info).post_entry = post_entry;
+
+						if (post_entry->post_reader) {
+							post_entry->post_reader(TSRMLS_C);
+						}
+					}
+
+					if (sapi_module.default_post_reader) {
+						sapi_module.default_post_reader(TSRMLS_C);
+					}
+
+					sapi_handle_post(PG(http_globals)[TRACK_VARS_POST] TSRMLS_CC);
+
+					/*
+					 * the rfc1867 handler is an awkward buddy
+					 */
+					if (files != PG(http_globals)[TRACK_VARS_FILES] && PG(http_globals)[TRACK_VARS_FILES]) {
+						Z_ADDREF_P(PG(http_globals)[TRACK_VARS_FILES]);
+						zend_hash_update(&EG(symbol_table), "_FILES", sizeof("_FILES"), &PG(http_globals)[TRACK_VARS_FILES], sizeof(zval *), NULL);
+						if (files) {
+							zval_ptr_dtor(&files);
+						}
+					}
+				}
+			}
+			zend_hash_destroy(&params);
+		}
+	}
+
+	STR_SET(SG(request_info).content_type_dup, NULL);
+
 	return SUCCESS;
 }
 
@@ -52,7 +110,7 @@ PHP_HTTP_API void php_http_env_get_request_headers(HashTable *headers TSRMLS_DC)
 
 		if (SUCCESS == zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void *) &hsv) && Z_TYPE_PP(hsv) == IS_ARRAY) {
 			FOREACH_KEY(pos, *hsv, key) {
-				if (key.type == HASH_KEY_IS_STRING && key.len > 6 && !strncmp(key.str, "HTTP_", 5)) {
+				if (key.type == HASH_KEY_IS_STRING && key.len > 6 && *key.str == 'H' && !strncmp(key.str, "HTTP_", 5)) {
 					key.len -= 5;
 					key.str = php_http_pretty_key(estrndup(key.str + 5, key.len - 1), key.len - 1, 1, 1);
 
@@ -60,6 +118,14 @@ PHP_HTTP_API void php_http_env_get_request_headers(HashTable *headers TSRMLS_DC)
 					Z_ADDREF_P(*header);
 					zend_symtable_update(PHP_HTTP_G->env.request.headers, key.str, key.len, (void *) header, sizeof(zval *), NULL);
 
+					efree(key.str);
+				} else if (key.type == HASH_KEY_IS_STRING && key.len > 9 && *key.str == 'C' && !strncmp(key.str, "CONTENT_", 8)) {
+					key.str = php_http_pretty_key(estrndup(key.str, key.len - 1), key.len - 1, 1, 1);
+
+					zend_hash_get_current_data_ex(Z_ARRVAL_PP(hsv), (void *) &header, &pos);
+					Z_ADDREF_P(*header);
+					zend_symtable_update(PHP_HTTP_G->env.request.headers, key.str, key.len, (void *) header, sizeof(zval *), NULL);
+
 					efree(key.str);
 				}
 			}
@@ -71,14 +137,20 @@ PHP_HTTP_API void php_http_env_get_request_headers(HashTable *headers TSRMLS_DC)
 	}
 }
 
-PHP_HTTP_API char *php_http_env_get_request_header(const char *name_str, size_t name_len, size_t *len TSRMLS_DC)
+PHP_HTTP_API char *php_http_env_get_request_header(const char *name_str, size_t name_len, size_t *len, php_http_message_t *request TSRMLS_DC)
 {
-	zval **zvalue;
+	HashTable *request_headers;
+	zval **zvalue = NULL;
 	char *val = NULL, *key = php_http_pretty_key(estrndup(name_str, name_len), name_len, 1, 1);
 
-	php_http_env_get_request_headers(NULL TSRMLS_CC);
+	if (request) {
+		request_headers = &request->hdrs;
+	} else {
+		php_http_env_get_request_headers(NULL TSRMLS_CC);
+		request_headers = PHP_HTTP_G->env.request.headers;
+	}
 
-	if (SUCCESS == zend_symtable_find(PHP_HTTP_G->env.request.headers, key, name_len + 1, (void *) &zvalue)) {
+	if (SUCCESS == zend_symtable_find(request_headers, key, name_len + 1, (void *) &zvalue)) {
 		zval *zcopy = php_http_ztyp(IS_STRING, *zvalue);
 
 		val = estrndup(Z_STRVAL_P(zcopy), Z_STRLEN_P(zcopy));
@@ -93,21 +165,40 @@ PHP_HTTP_API char *php_http_env_get_request_header(const char *name_str, size_t
 	return val;
 }
 
-PHP_HTTP_API int php_http_env_got_request_header(const char *name_str, size_t name_len TSRMLS_DC)
+PHP_HTTP_API int php_http_env_got_request_header(const char *name_str, size_t name_len, php_http_message_t *request TSRMLS_DC)
 {
+	HashTable *request_headers;
 	char *key = php_http_pretty_key(estrndup(name_str, name_len), name_len, 1, 1);
 	int got;
 
-	php_http_env_get_request_headers(NULL TSRMLS_CC);
-	got = zend_symtable_exists(PHP_HTTP_G->env.request.headers, key, name_len + 1);
+	if (request) {
+		request_headers = &request->hdrs;
+	} else {
+		php_http_env_get_request_headers(NULL TSRMLS_CC);
+		request_headers = PHP_HTTP_G->env.request.headers;
+	}
+	got = zend_symtable_exists(request_headers, key, name_len + 1);
 	efree(key);
 
 	return got;
 }
 
+PHP_HTTP_API zval *php_http_env_get_superglobal(const char *key, size_t key_len TSRMLS_DC)
+{
+	zval **hsv;
+
+	zend_is_auto_global(key, key_len TSRMLS_CC);
+
+	if ((SUCCESS != zend_hash_find(&EG(symbol_table), key, key_len + 1, (void *) &hsv)) || (Z_TYPE_PP(hsv) != IS_ARRAY)) {
+		return NULL;
+	}
+
+	return *hsv;
+}
+
 PHP_HTTP_API zval *php_http_env_get_server_var(const char *key, size_t key_len, zend_bool check TSRMLS_DC)
 {
-	zval **hsv, **var;
+	zval *hsv, **var;
 	char *env;
 
 	/* if available, this is a lot faster than accessing $_SERVER */
@@ -123,12 +214,10 @@ PHP_HTTP_API zval *php_http_env_get_server_var(const char *key, size_t key_len,
 		return PHP_HTTP_G->env.server_var;
 	}
 
-	zend_is_auto_global(ZEND_STRL("_SERVER") TSRMLS_CC);
-
-	if ((SUCCESS != zend_hash_find(&EG(symbol_table), ZEND_STRS("_SERVER"), (void *) &hsv)) || (Z_TYPE_PP(hsv) != IS_ARRAY)) {
+	if (!(hsv = php_http_env_get_superglobal(ZEND_STRL("_SERVER") TSRMLS_CC))) {
 		return NULL;
 	}
-	if ((SUCCESS != zend_symtable_find(Z_ARRVAL_PP(hsv), key, key_len + 1, (void *) &var))) {
+	if ((SUCCESS != zend_symtable_find(Z_ARRVAL_P(hsv), key, key_len + 1, (void *) &var))) {
 		return NULL;
 	}
 	if (check && !((Z_TYPE_PP(var) == IS_STRING) && Z_STRVAL_PP(var) && Z_STRLEN_PP(var))) {
@@ -176,13 +265,26 @@ PHP_HTTP_API php_http_message_body_t *php_http_env_get_request_body(TSRMLS_D)
 	return PHP_HTTP_G->env.request.body;
 }
 
-PHP_HTTP_API php_http_range_status_t php_http_env_get_request_ranges(HashTable *ranges, size_t length TSRMLS_DC)
+PHP_HTTP_API const char *php_http_env_get_request_method(php_http_message_t *request TSRMLS_DC)
+{
+	const char *m;
+
+	if (PHP_HTTP_MESSAGE_TYPE(REQUEST, request)) {
+		m = request->http.info.request.method;
+	} else {
+		m = SG(request_info).request_method;
+	}
+
+	return m ? m : "GET";
+}
+
+PHP_HTTP_API php_http_range_status_t php_http_env_get_request_ranges(HashTable *ranges, size_t length, php_http_message_t *request TSRMLS_DC)
 {
 	zval *zentry;
 	char *range, *rp, c;
 	long begin = -1, end = -1, *ptr;
 
-	if (!(range = php_http_env_get_request_header(ZEND_STRL("Range"), NULL TSRMLS_CC))) {
+	if (!(range = php_http_env_get_request_header(ZEND_STRL("Range"), NULL, request TSRMLS_CC))) {
 		return PHP_HTTP_RANGE_NO;
 	}
 	if (strncmp(range, "bytes=", lenof("bytes="))) {
@@ -338,7 +440,7 @@ PHP_HTTP_API STATUS php_http_env_get_response_headers(HashTable *headers_ht TSRM
 	zend_llist_apply_with_argument(&SG(sapi_headers).headers, grab_headers, &headers TSRMLS_CC);
 	php_http_buffer_fix(&headers);
 
-	status = php_http_headers_parse(PHP_HTTP_BUFFER_VAL(&headers), PHP_HTTP_BUFFER_LEN(&headers), headers_ht, NULL, NULL TSRMLS_CC);
+	status = php_http_headers_parse(headers.data, headers.used, headers_ht, NULL, NULL TSRMLS_CC);
 	php_http_buffer_dtor(&headers);
 
 	return status;
@@ -349,7 +451,7 @@ PHP_HTTP_API char *php_http_env_get_response_header(const char *name_str, size_t
 	char *val = NULL;
 	HashTable headers;
 
-	zend_hash_init(&headers, 0, NULL, NULL, 0);
+	zend_hash_init(&headers, 0, NULL, ZVAL_PTR_DTOR, 0);
 	if (SUCCESS == php_http_env_get_response_headers(&headers TSRMLS_CC)) {
 		zval **zvalue;
 		char *key = php_http_pretty_key(estrndup(name_str, name_len), name_len, 1, 1);
@@ -381,7 +483,7 @@ PHP_HTTP_API STATUS php_http_env_set_response_code(long http_code TSRMLS_DC)
 
 PHP_HTTP_API STATUS php_http_env_set_response_status_line(long code, php_http_version_t *v TSRMLS_DC)
 {
-	sapi_header_line h = {0};
+	sapi_header_line h = {NULL, 0, 0};
 	STATUS ret;
 
 	h.line_len = spprintf(&h.line, 0, "HTTP/%u.%u %ld %s", v->major, v->minor, code, php_http_env_get_response_status_for_code(code));
@@ -404,15 +506,12 @@ PHP_HTTP_API STATUS php_http_env_set_response_header(long http_code, const char
 	return ret;
 }
 
-PHP_HTTP_API STATUS php_http_env_set_response_header_format(long http_code, zend_bool replace TSRMLS_DC, const char *fmt, ...)
+PHP_HTTP_API STATUS php_http_env_set_response_header_va(long http_code, zend_bool replace, const char *fmt, va_list argv TSRMLS_DC)
 {
-	va_list args;
 	STATUS ret = FAILURE;
 	sapi_header_line h = {NULL, 0, http_code};
 
-	va_start(args, fmt);
-	h.line_len = vspprintf(&h.line, 0, fmt, args);
-	va_end(args);
+	h.line_len = vspprintf(&h.line, 0, fmt, argv);
 
 	if (h.line) {
 		if (h.line_len) {
@@ -423,6 +522,18 @@ PHP_HTTP_API STATUS php_http_env_set_response_header_format(long http_code, zend
 	return ret;
 }
 
+PHP_HTTP_API STATUS php_http_env_set_response_header_format(long http_code, zend_bool replace TSRMLS_DC, const char *fmt, ...)
+{
+	STATUS ret;
+	va_list args;
+
+	va_start(args, fmt);
+	ret = php_http_env_set_response_header_va(http_code, replace, fmt, args TSRMLS_CC);
+	va_end(args);
+
+	return ret;
+}
+
 PHP_HTTP_API STATUS php_http_env_set_response_header_value(long http_code, const char *name_str, size_t name_len, zval *value, zend_bool replace TSRMLS_DC)
 {
 	if (!value) {
@@ -474,6 +585,7 @@ PHP_HTTP_API STATUS php_http_env_set_response_header_value(long http_code, const
 static PHP_HTTP_STRLIST(php_http_env_response_status) =
 	PHP_HTTP_STRLIST_ITEM("Continue")
 	PHP_HTTP_STRLIST_ITEM("Switching Protocols")
+	PHP_HTTP_STRLIST_ITEM("Processing")
 	PHP_HTTP_STRLIST_NEXT
 	PHP_HTTP_STRLIST_ITEM("OK")
 	PHP_HTTP_STRLIST_ITEM("Created")
@@ -482,6 +594,26 @@ static PHP_HTTP_STRLIST(php_http_env_response_status) =
 	PHP_HTTP_STRLIST_ITEM("No Content")
 	PHP_HTTP_STRLIST_ITEM("Reset Content")
 	PHP_HTTP_STRLIST_ITEM("Partial Content")
+	PHP_HTTP_STRLIST_ITEM("Multi-Status")
+	PHP_HTTP_STRLIST_ITEM("Already Reported")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("IM Used")
 	PHP_HTTP_STRLIST_NEXT
 	PHP_HTTP_STRLIST_ITEM("Multiple Choices")
 	PHP_HTTP_STRLIST_ITEM("Moved Permanently")
@@ -491,6 +623,7 @@ static PHP_HTTP_STRLIST(php_http_env_response_status) =
 	PHP_HTTP_STRLIST_ITEM("Use Proxy")
 	PHP_HTTP_STRLIST_ITEM("(Unused)")
 	PHP_HTTP_STRLIST_ITEM("Temporary Redirect")
+	PHP_HTTP_STRLIST_ITEM("Permanent Redirect")
 	PHP_HTTP_STRLIST_NEXT
 	PHP_HTTP_STRLIST_ITEM("Bad Request")
 	PHP_HTTP_STRLIST_ITEM("Unauthorized")
@@ -510,6 +643,20 @@ static PHP_HTTP_STRLIST(php_http_env_response_status) =
 	PHP_HTTP_STRLIST_ITEM("Unsupported Media Type")
 	PHP_HTTP_STRLIST_ITEM("Requested Range Not Satisfiable")
 	PHP_HTTP_STRLIST_ITEM("Expectation Failed")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("Unprocessible Entity")
+	PHP_HTTP_STRLIST_ITEM("Locked")
+	PHP_HTTP_STRLIST_ITEM("Failed Dependency")
+	PHP_HTTP_STRLIST_ITEM("(Reserved)")
+	PHP_HTTP_STRLIST_ITEM("Upgrade Required")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("Precondition Required")
+	PHP_HTTP_STRLIST_ITEM("Too Many Requests")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("Request Header Fields Too Large")
 	PHP_HTTP_STRLIST_NEXT
 	PHP_HTTP_STRLIST_ITEM("Internal Server Error")
 	PHP_HTTP_STRLIST_ITEM("Not Implemented")
@@ -517,6 +664,12 @@ static PHP_HTTP_STRLIST(php_http_env_response_status) =
 	PHP_HTTP_STRLIST_ITEM("Service Unavailable")
 	PHP_HTTP_STRLIST_ITEM("Gateway Timeout")
 	PHP_HTTP_STRLIST_ITEM("HTTP Version Not Supported")
+	PHP_HTTP_STRLIST_ITEM("Variant Also Negotiates")
+	PHP_HTTP_STRLIST_ITEM("Insufficient Storage")
+	PHP_HTTP_STRLIST_ITEM("Loop Detected")
+	PHP_HTTP_STRLIST_ITEM("(Unused)")
+	PHP_HTTP_STRLIST_ITEM("Not Extended")
+	PHP_HTTP_STRLIST_ITEM("Network Authentication Required")
 	PHP_HTTP_STRLIST_STOP
 ;
 
@@ -525,7 +678,6 @@ PHP_HTTP_API const char *php_http_env_get_response_status_for_code(unsigned code
 	return php_http_strlist_find(php_http_env_response_status, 100, code);
 }
 
-zend_class_entry *php_http_env_class_entry;
 
 #define PHP_HTTP_BEGIN_ARGS(method, req_args) 	PHP_HTTP_BEGIN_ARGS_EX(HttpEnv, method, 0, req_args)
 #define PHP_HTTP_EMPTY_ARGS(method)				PHP_HTTP_EMPTY_ARGS_EX(HttpEnv, method, 0)
@@ -543,6 +695,8 @@ PHP_HTTP_BEGIN_ARGS(getResponseStatusForCode, 1)
 	PHP_HTTP_ARG_VAL(code, 0)
 PHP_HTTP_END_ARGS;
 
+PHP_HTTP_EMPTY_ARGS(getResponseStatusForAllCodes);
+
 PHP_HTTP_BEGIN_ARGS(getResponseHeader, 0)
 	PHP_HTTP_ARG_VAL(header_name, 0)
 PHP_HTTP_END_ARGS;
@@ -594,11 +748,19 @@ PHP_HTTP_BEGIN_ARGS(cleanPersistentHandles, 0)
 	PHP_HTTP_ARG_VAL(ident, 0)
 PHP_HTTP_END_ARGS;
 
-zend_function_entry php_http_env_method_entry[] = {
+static zend_class_entry *php_http_env_class_entry;
+
+zend_class_entry *php_http_env_get_class_entry(void)
+{
+	return php_http_env_class_entry;
+}
+
+static zend_function_entry php_http_env_method_entry[] = {
 	PHP_HTTP_ENV_ME(getRequestHeader)
 	PHP_HTTP_ENV_ME(getRequestBody)
 
 	PHP_HTTP_ENV_ME(getResponseStatusForCode)
+	PHP_HTTP_ENV_ME(getResponseStatusForAllCodes)
 
 	PHP_HTTP_ENV_ME(getResponseHeader)
 	PHP_HTTP_ENV_ME(getResponseCode)
@@ -625,7 +787,7 @@ PHP_METHOD(HttpEnv, getRequestHeader)
 	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &header_name_str, &header_name_len)) {
 		if (header_name_str && header_name_len) {
 			size_t header_length;
-			char *header_value = php_http_env_get_request_header(header_name_str, header_name_len, &header_length TSRMLS_CC);
+			char *header_value = php_http_env_get_request_header(header_name_str, header_name_len, &header_length, NULL TSRMLS_CC);
 
 			if (header_value) {
 				RETURN_STRINGL(header_value, header_length, 0);
@@ -642,15 +804,15 @@ PHP_METHOD(HttpEnv, getRequestHeader)
 
 PHP_METHOD(HttpEnv, getRequestBody)
 {
-	with_error_handling(EH_THROW, php_http_exception_class_entry) {
-		zend_class_entry *class_entry = php_http_message_body_class_entry;
+	with_error_handling(EH_THROW, php_http_exception_get_class_entry()) {
+		zend_class_entry *class_entry = php_http_message_body_get_class_entry();
 
 		if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|C", &class_entry)) {
 			zend_object_value ov;
 			php_http_message_body_t *body = php_http_env_get_request_body(TSRMLS_C);
 
-			if (SUCCESS == php_http_new(&ov, class_entry, (php_http_new_t) php_http_message_body_object_new_ex, php_http_message_body_class_entry, body, NULL TSRMLS_CC)) {
-				RETURN_OBJVAL(ov, 0);
+			if (SUCCESS == php_http_new(&ov, class_entry, (php_http_new_t) php_http_message_body_object_new_ex, php_http_message_body_get_class_entry(), php_http_message_body_init(&body, NULL TSRMLS_CC), NULL TSRMLS_CC)) {
+				RETVAL_OBJVAL(ov, 0);
 			}
 		}
 	} end_error_handling();
@@ -666,6 +828,25 @@ PHP_METHOD(HttpEnv, getResponseStatusForCode)
 	RETURN_FALSE;
 }
 
+PHP_METHOD(HttpEnv, getResponseStatusForAllCodes)
+{
+	const char *s;
+	unsigned c;
+	php_http_strlist_iterator_t i;
+
+	if (SUCCESS != zend_parse_parameters_none()) {
+		RETURN_FALSE;
+	}
+
+	array_init(return_value);
+	for (	php_http_strlist_iterator_init(&i, php_http_env_response_status, 100);
+			*(s = php_http_strlist_iterator_this(&i, &c));
+			php_http_strlist_iterator_next(&i)
+	) {
+		add_index_string(return_value, c, s, 1);
+	}
+}
+
 PHP_METHOD(HttpEnv, getResponseHeader)
 {
 	char *header_name_str = NULL;
@@ -832,41 +1013,39 @@ PHP_METHOD(HttpEnv, cleanPersistentHandles)
 	}
 }
 
-zend_class_entry *php_http_env_request_class_entry;
+#ifdef PHP_HTTP_HAVE_JSON
+#include "ext/json/php_json.h"
 
-#undef PHP_HTTP_BEGIN_ARGS
-#undef PHP_HTTP_EMPTY_ARGS
-#define PHP_HTTP_BEGIN_ARGS(method, req_args) 		PHP_HTTP_BEGIN_ARGS_EX(HttpEnvRequest, method, 0, req_args)
-#define PHP_HTTP_EMPTY_ARGS(method)					PHP_HTTP_EMPTY_ARGS_EX(HttpEnvRequest, method, 0)
-#define PHP_HTTP_ENV_REQUEST_ME(method, visibility)	PHP_ME(HttpEnvRequest, method, PHP_HTTP_ARGS(HttpEnvRequest, method), visibility)
+static SAPI_POST_HANDLER_FUNC(php_http_json_post_handler)
+{
+	if (SG(request_info).raw_post_data) {
+		zval_dtor(arg);
+		((zval *) arg)->type = IS_NULL;
+		php_json_decode(arg, SG(request_info).raw_post_data, SG(request_info).raw_post_data_length, 1, PG(max_input_nesting_level) TSRMLS_CC);
+	}
+}
 
-PHP_HTTP_EMPTY_ARGS(__construct);
+#endif
 
-zend_function_entry php_http_env_request_method_entry[] = {
-	PHP_HTTP_ENV_REQUEST_ME(__construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
+PHP_MINIT_FUNCTION(http_env)
+{
+#ifdef PHP_HTTP_HAVE_JSON
+	sapi_post_entry entry = {NULL, 0, NULL, NULL};
 
-	EMPTY_FUNCTION_ENTRY
-};
+	entry.post_reader = sapi_read_standard_form_data;
+	entry.post_handler = php_http_json_post_handler;
 
-PHP_METHOD(HttpEnvRequest, __construct)
-{
-	with_error_handling(EH_THROW, php_http_exception_class_entry) {
-		if (SUCCESS == zend_parse_parameters_none()) {
-			php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
+	entry.content_type = "text/json";
+	entry.content_type_len = lenof("text/json");
+	sapi_register_post_entry(&entry TSRMLS_CC);
 
-			with_error_handling(EH_THROW, php_http_exception_class_entry) {
-				obj->message = php_http_message_init_env(obj->message, PHP_HTTP_REQUEST TSRMLS_CC);
-			} end_error_handling();
-		}
-	} end_error_handling();
-}
+	entry.content_type = "application/json";
+	entry.content_type_len = lenof("application/json");
+	sapi_register_post_entry(&entry TSRMLS_CC);
+#endif
 
-PHP_MINIT_FUNCTION(http_env)
-{
 	PHP_HTTP_REGISTER_CLASS(http, Env, http_env, NULL, 0);
 
-	PHP_HTTP_REGISTER_CLASS(http\\Env, Request, http_env_request, php_http_message_class_entry, 0);
-
 	return SUCCESS;
 }