2 +--------------------------------------------------------------------+
4 +--------------------------------------------------------------------+
5 | Redistribution and use in source and binary forms, with or without |
6 | modification, are permitted provided that the conditions mentioned |
7 | in the accompanying LICENSE file are met. |
8 +--------------------------------------------------------------------+
9 | Copyright (c) 2004-2014, Michael Wallner <mike@php.net> |
10 +--------------------------------------------------------------------+
13 #include "php_http_api.h"
14 #include "php_variables.h"
17 PHP_RSHUTDOWN_FUNCTION(http_env
)
23 void php_http_env_reset()
25 if (PHP_HTTP_G
->env
.request
.headers
) {
26 zend_hash_destroy(PHP_HTTP_G
->env
.request
.headers
);
27 FREE_HASHTABLE(PHP_HTTP_G
->env
.request
.headers
);
28 PHP_HTTP_G
->env
.request
.headers
= NULL
;
30 if (PHP_HTTP_G
->env
.request
.body
) {
31 php_http_message_body_free(&PHP_HTTP_G
->env
.request
.body
);
33 if (PHP_HTTP_G
->env
.server_var
) {
34 zval_ptr_dtor(PHP_HTTP_G
->env
.server_var
);
35 PHP_HTTP_G
->env
.server_var
= NULL
;
39 void php_http_env_get_request_headers(HashTable
*headers
)
41 php_http_arrkey_t key
;
44 if (!PHP_HTTP_G
->env
.request
.headers
) {
45 ALLOC_HASHTABLE(PHP_HTTP_G
->env
.request
.headers
);
46 ZEND_INIT_SYMTABLE(PHP_HTTP_G
->env
.request
.headers
);
48 if ((hsv
= php_http_env_get_superglobal(ZEND_STRL("_SERVER")))) {
49 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(hsv
), key
.h
, key
.key
, header
)
51 if (key
.key
&& key
.key
->len
> 5 && *key
.key
->val
== 'H' && !strncmp(key
.key
->val
, "HTTP_", 5)) {
52 size_t key_len
= key
.key
->len
- 5;
53 char *key_str
= php_http_pretty_key(estrndup(&key
.key
->val
[5], key_len
), key_len
, 1, 1);
55 Z_TRY_ADDREF_P(header
);
56 zend_symtable_str_update(PHP_HTTP_G
->env
.request
.headers
, key_str
, key_len
, header
);
59 } else if (key
.key
&& key
.key
->len
> 8 && *key
.key
->val
== 'C' && !strncmp(key
.key
->val
, "CONTENT_", 8)) {
60 char *key_str
= php_http_pretty_key(estrndup(key
.key
->val
, key
.key
->len
), key
.key
->len
, 1, 1);
62 Z_TRY_ADDREF_P(header
);
63 zend_symtable_str_update(PHP_HTTP_G
->env
.request
.headers
, key_str
, key
.key
->len
, header
);
68 ZEND_HASH_FOREACH_END();
73 array_copy(PHP_HTTP_G
->env
.request
.headers
, headers
);
77 char *php_http_env_get_request_header(const char *name_str
, size_t name_len
, size_t *len
, php_http_message_t
*request
)
79 HashTable
*request_headers
;
81 char *val
= NULL
, *key
= php_http_pretty_key(estrndup(name_str
, name_len
), name_len
, 1, 1);
84 request_headers
= &request
->hdrs
;
86 php_http_env_get_request_headers(NULL
);
87 request_headers
= PHP_HTTP_G
->env
.request
.headers
;
90 if ((zvalue
= zend_symtable_str_find(request_headers
, key
, name_len
))) {
91 zend_string
*zs
= zval_get_string(zvalue
);
93 val
= estrndup(zs
->val
, zs
->len
);
97 zend_string_release(zs
);
105 zend_bool
php_http_env_got_request_header(const char *name_str
, size_t name_len
, php_http_message_t
*request
)
107 HashTable
*request_headers
;
108 char *key
= php_http_pretty_key(estrndup(name_str
, name_len
), name_len
, 1, 1);
112 request_headers
= &request
->hdrs
;
114 php_http_env_get_request_headers(NULL
);
115 request_headers
= PHP_HTTP_G
->env
.request
.headers
;
117 got
= zend_symtable_str_exists(request_headers
, key
, name_len
);
123 zval
*php_http_env_get_superglobal(const char *key
, size_t key_len
)
126 zend_string
*key_str
= zend_string_init(key
, key_len
, 0);
128 zend_is_auto_global(key_str
);
129 hsv
= zend_hash_find(&EG(symbol_table
), key_str
);
130 zend_string_release(key_str
);
132 if (Z_TYPE_P(hsv
) != IS_ARRAY
) {
139 zval
*php_http_env_get_server_var(const char *key
, size_t key_len
, zend_bool check
)
143 /* if available, this is a lot faster than accessing $_SERVER * /
144 if (sapi_module.getenv) {
147 if ((!(env = sapi_module.getenv((char *) key, key_len))) || (check && !*env)) {
150 if (PHP_HTTP_G->env.server_var) {
151 zval_ptr_dtor(&PHP_HTTP_G->env.server_var);
153 MAKE_STD_ZVAL(PHP_HTTP_G->env.server_var);
154 ZVAL_STRING(PHP_HTTP_G->env.server_var, env, 1);
155 return PHP_HTTP_G->env.server_var;
159 if (!(hsv
= php_http_env_get_superglobal(ZEND_STRL("_SERVER")))) {
162 if (!(var
= zend_symtable_str_find(Z_ARRVAL_P(hsv
), key
, key_len
))) {
165 if (check
&& !((Z_TYPE_P(var
) == IS_STRING
) && Z_STRVAL_P(var
) && Z_STRLEN_P(var
))) {
171 php_http_message_body_t
*php_http_env_get_request_body(void)
173 if (!PHP_HTTP_G
->env
.request
.body
) {
174 php_stream
*s
= php_stream_temp_new();
175 php_stream
*input
= php_stream_open_wrapper("php://input", "r", 0, NULL
);
177 /* php://input does not support stat */
178 php_stream_copy_to_stream_ex(input
, s
, -1, NULL
);
179 php_stream_close(input
);
181 php_stream_rewind(s
);
182 PHP_HTTP_G
->env
.request
.body
= php_http_message_body_init(NULL
, s
);
185 return PHP_HTTP_G
->env
.request
.body
;
188 const char *php_http_env_get_request_method(php_http_message_t
*request
)
192 if (PHP_HTTP_MESSAGE_TYPE(REQUEST
, request
)) {
193 m
= request
->http
.info
.request
.method
;
195 m
= SG(request_info
).request_method
;
198 return m
? m
: "GET";
201 php_http_range_status_t
php_http_env_get_request_ranges(HashTable
*ranges
, size_t length
, php_http_message_t
*request
)
205 long begin
= -1, end
= -1, *ptr
;
207 if (!(range
= php_http_env_get_request_header(ZEND_STRL("Range"), NULL
, request
))) {
208 return PHP_HTTP_RANGE_NO
;
210 if (strncmp(range
, "bytes=", lenof("bytes="))) {
212 return PHP_HTTP_RANGE_NO
;
215 rp
= range
+ lenof("bytes=");
219 switch (c
= *(rp
++)) {
221 /* allow 000... - shall we? */
227 case '1': case '2': case '3':
228 case '4': case '5': case '6':
229 case '7': case '8': case '9':
231 * If the value of the pointer is already set (non-negative)
232 * then multiply its value by ten and add the current value,
233 * else initialise the pointers value with the current value
235 * This let us recognize empty fields when validating the
236 * ranges, i.e. a "-10" for begin and "12345" for the end
237 * was the following range request: "Range: bytes=0-12345";
238 * While a "-1" for begin and "12345" for the end would
239 * have been: "Range: bytes=-12345".
260 /* validate ranges */
268 return PHP_HTTP_RANGE_NO
;
276 if (length
<= (size_t) end
) {
287 if (end
== -1 || end
== -10) {
289 return PHP_HTTP_RANGE_ERR
;
291 begin
= length
- end
;
297 if (length
<= (size_t) begin
) {
299 return PHP_HTTP_RANGE_ERR
;
305 return PHP_HTTP_RANGE_ERR
;
314 if (length
<= (size_t) end
) {
316 } else if (end
< begin
) {
318 return PHP_HTTP_RANGE_ERR
;
327 add_index_long(&zentry
, 0, begin
);
328 add_index_long(&zentry
, 1, end
);
329 zend_hash_next_index_insert(ranges
, &zentry
);
339 return PHP_HTTP_RANGE_NO
;
344 return PHP_HTTP_RANGE_OK
;
347 static void grab_headers(void *data
, void *arg
)
349 php_http_buffer_appendl(PHP_HTTP_BUFFER(arg
), ((sapi_header_struct
*)data
)->header
);
350 php_http_buffer_appends(PHP_HTTP_BUFFER(arg
), PHP_HTTP_CRLF
);
353 static void grab_header(void *data
, void *arg
)
360 sapi_header_struct
*header
= data
;
362 if ( header
->header_len
> args
->name_len
363 && header
->header
[args
->name_len
] == ':'
364 && !strncmp(header
->header
, args
->name_str
, args
->name_len
)
366 args
->value_ptr
= &header
->header
[args
->name_len
+ 1];
367 while (PHP_HTTP_IS_CTYPE(space
, *args
->value_ptr
)) {
373 ZEND_RESULT_CODE
php_http_env_get_response_headers(HashTable
*headers_ht
)
375 ZEND_RESULT_CODE status
;
376 php_http_buffer_t headers
;
378 php_http_buffer_init(&headers
);
379 zend_llist_apply_with_argument(&SG(sapi_headers
).headers
, grab_headers
, &headers
);
380 php_http_buffer_fix(&headers
);
382 status
= php_http_header_parse(headers
.data
, headers
.used
, headers_ht
, NULL
, NULL
);
383 php_http_buffer_dtor(&headers
);
388 char *php_http_env_get_response_header(const char *name_str
, size_t name_len
)
396 args
.name_str
= php_http_pretty_key(estrndup(name_str
, name_len
), name_len
, 1, 1);
397 args
.name_len
= name_len
;
398 args
.value_ptr
= NULL
;
399 zend_llist_apply_with_argument(&SG(sapi_headers
).headers
, grab_header
, &args
);
400 efree(args
.name_str
);
402 return args
.value_ptr
? estrdup(args
.value_ptr
) : NULL
;
405 long php_http_env_get_response_code(void)
407 long code
= SG(sapi_headers
).http_response_code
;
408 return code
? code
: 200;
411 ZEND_RESULT_CODE
php_http_env_set_response_code(long http_code
)
413 return sapi_header_op(SAPI_HEADER_SET_STATUS
, (void *) (zend_intptr_t
) http_code
);
416 ZEND_RESULT_CODE
php_http_env_set_response_status_line(long code
, php_http_version_t
*v
)
418 sapi_header_line h
= {NULL
, 0, 0};
419 ZEND_RESULT_CODE ret
;
422 h
.line_len
= spprintf(&line
, 0, "HTTP/%u.%u %ld %s", v
->major
, v
->minor
, code
, php_http_env_get_response_status_for_code(code
));
424 ret
= sapi_header_op(SAPI_HEADER_REPLACE
, (void *) &h
);
430 ZEND_RESULT_CODE
php_http_env_set_response_protocol_version(php_http_version_t
*v
)
432 return php_http_env_set_response_status_line(php_http_env_get_response_code(), v
);
435 ZEND_RESULT_CODE
php_http_env_set_response_header(long http_code
, const char *header_str
, size_t header_len
, zend_bool replace
)
437 sapi_header_line h
= {header_str
, header_len
, http_code
};
438 ZEND_RESULT_CODE ret
= sapi_header_op(replace
? SAPI_HEADER_REPLACE
: SAPI_HEADER_ADD
, (void *) &h
);
443 ZEND_RESULT_CODE
php_http_env_set_response_header_va(long http_code
, zend_bool replace
, const char *fmt
, va_list argv
)
445 ZEND_RESULT_CODE ret
= FAILURE
;
446 sapi_header_line h
= {NULL
, 0, http_code
};
449 h
.line_len
= vspprintf(&line
, 0, fmt
, argv
);
454 ret
= sapi_header_op(replace
? SAPI_HEADER_REPLACE
: SAPI_HEADER_ADD
, (void *) &h
);
461 ZEND_RESULT_CODE
php_http_env_set_response_header_format(long http_code
, zend_bool replace
, const char *fmt
, ...)
463 ZEND_RESULT_CODE ret
;
467 ret
= php_http_env_set_response_header_va(http_code
, replace
, fmt
, args
);
473 ZEND_RESULT_CODE
php_http_env_set_response_header_value(long http_code
, const char *name_str
, size_t name_len
, zval
*value
, zend_bool replace
)
476 sapi_header_line h
= {(char *) name_str
, name_len
, http_code
};
478 return sapi_header_op(SAPI_HEADER_DELETE
, (void *) &h
);
481 if (Z_TYPE_P(value
) == IS_ARRAY
|| Z_TYPE_P(value
) == IS_OBJECT
) {
484 HashTable
*ht
= HASH_OF(value
);
486 ZEND_HASH_FOREACH_VAL_IND(ht
, data_ptr
)
488 if (SUCCESS
!= php_http_env_set_response_header_value(http_code
, name_str
, name_len
, data_ptr
, first
)) {
493 ZEND_HASH_FOREACH_END();
497 zend_string
*data
= zval_get_string(value
);
500 zend_string_release(data
);
501 return php_http_env_set_response_header_value(http_code
, name_str
, name_len
, NULL
, replace
);
504 ZEND_RESULT_CODE ret
;
507 if (name_len
> INT_MAX
) {
510 h
.response_code
= http_code
;
511 h
.line_len
= spprintf(&line
, 0, "%s: %s", name_str
, data
->val
);
514 ret
= sapi_header_op(replace
? SAPI_HEADER_REPLACE
: SAPI_HEADER_ADD
, (void *) &h
);
516 zend_string_release(data
);
524 const char *php_http_env_get_response_status_for_code(unsigned code
)
527 #define PHP_HTTP_RESPONSE_CODE(c, s) case c: return s;
528 #include "php_http_response_codes.h"
529 #undef PHP_HTTP_RESPONSE_CODE
535 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_getRequestHeader
, 0, 0, 0)
536 ZEND_ARG_INFO(0, header_name
)
538 static PHP_METHOD(HttpEnv
, getRequestHeader
)
540 char *header_name_str
= NULL
;
541 size_t header_name_len
= 0;
543 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS(), "|s!", &header_name_str
, &header_name_len
)) {
546 if (header_name_str
&& header_name_len
) {
547 size_t header_length
;
548 char *header_value
= php_http_env_get_request_header(header_name_str
, header_name_len
, &header_length
, NULL
);
551 RETURN_STR(php_http_cs2zs(header_value
, header_length
));
554 array_init(return_value
);
555 php_http_env_get_request_headers(Z_ARRVAL_P(return_value
));
559 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_getRequestBody
, 0, 0, 0)
560 ZEND_ARG_INFO(0, body_class_name
)
562 static PHP_METHOD(HttpEnv
, getRequestBody
)
564 php_http_message_body_t
*body
;
565 php_http_message_body_object_t
*body_obj
;
566 zend_class_entry
*class_entry
= php_http_get_message_body_class_entry();
568 php_http_expect(SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS(), "|C", &class_entry
), invalid_arg
, return);
570 body
= php_http_env_get_request_body();
571 if (SUCCESS
== php_http_new((void *) &body_obj
, class_entry
, (php_http_new_t
) php_http_message_body_object_new_ex
, php_http_get_message_body_class_entry(), body
)) {
572 php_http_message_body_addref(body
);
573 RETVAL_OBJ(&body_obj
->zo
);
577 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_getResponseStatusForCode
, 0, 0, 1)
578 ZEND_ARG_INFO(0, code
)
580 static PHP_METHOD(HttpEnv
, getResponseStatusForCode
)
585 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS(), "l", &code
)) {
589 if ((status
= php_http_env_get_response_status_for_code(code
))) {
590 RETURN_STRING(status
);
594 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_getResponseStatusForAllCodes
, 0, 0, 0)
596 static PHP_METHOD(HttpEnv
, getResponseStatusForAllCodes
)
598 if (SUCCESS
!= zend_parse_parameters_none()) {
602 array_init(return_value
);
603 #define PHP_HTTP_RESPONSE_CODE(code, status) add_index_string(return_value, code, status);
604 #include "php_http_response_codes.h"
605 #undef PHP_HTTP_RESPONSE_CODE
608 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_getResponseHeader
, 0, 0, 0)
609 ZEND_ARG_INFO(0, header_name
)
611 static PHP_METHOD(HttpEnv
, getResponseHeader
)
613 char *header_name_str
= NULL
;
614 size_t header_name_len
= 0;
616 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS(), "|s!", &header_name_str
, &header_name_len
)) {
619 if (header_name_str
&& header_name_len
) {
620 char *header_value
= php_http_env_get_response_header(header_name_str
, header_name_len
);
623 RETURN_STR(php_http_cs2zs(header_value
, strlen(header_value
)));
626 array_init(return_value
);
627 php_http_env_get_response_headers(Z_ARRVAL_P(return_value
));
631 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_getResponseCode
, 0, 0, 0)
633 static PHP_METHOD(HttpEnv
, getResponseCode
)
635 if (SUCCESS
!= zend_parse_parameters_none()) {
638 RETURN_LONG(php_http_env_get_response_code());
641 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_setResponseHeader
, 0, 0, 1)
642 ZEND_ARG_INFO(0, header_name
)
643 ZEND_ARG_INFO(0, header_value
)
644 ZEND_ARG_INFO(0, response_code
)
645 ZEND_ARG_INFO(0, replace_header
)
647 static PHP_METHOD(HttpEnv
, setResponseHeader
)
649 char *header_name_str
;
650 size_t header_name_len
;
651 zval
*header_value
= NULL
;
653 zend_bool replace_header
= 1;
655 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS(), "s|z!lb", &header_name_str
, &header_name_len
, &header_value
, &code
, &replace_header
)) {
658 RETURN_BOOL(SUCCESS
== php_http_env_set_response_header_value(code
, header_name_str
, header_name_len
, header_value
, replace_header
));
661 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_setResponseCode
, 0, 0, 1)
662 ZEND_ARG_INFO(0, code
)
664 static PHP_METHOD(HttpEnv
, setResponseCode
)
668 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS(), "l", &code
)) {
671 RETURN_BOOL(SUCCESS
== php_http_env_set_response_code(code
));
674 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_negotiateLanguage
, 0, 0, 1)
675 ZEND_ARG_INFO(0, supported
)
676 ZEND_ARG_INFO(1, result_array
)
678 static PHP_METHOD(HttpEnv
, negotiateLanguage
)
680 HashTable
*supported
;
681 zval
*rs_array
= NULL
;
683 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS(), "H|z", &supported
, &rs_array
)) {
687 ZVAL_DEREF(rs_array
);
689 array_init(rs_array
);
692 PHP_HTTP_DO_NEGOTIATE(language
, supported
, rs_array
);
695 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_negotiateCharset
, 0, 0, 1)
696 ZEND_ARG_INFO(0, supported
)
697 ZEND_ARG_INFO(1, result_array
)
699 static PHP_METHOD(HttpEnv
, negotiateCharset
)
701 HashTable
*supported
;
702 zval
*rs_array
= NULL
;
704 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS(), "H|z", &supported
, &rs_array
)) {
708 ZVAL_DEREF(rs_array
);
710 array_init(rs_array
);
712 PHP_HTTP_DO_NEGOTIATE(charset
, supported
, rs_array
);
715 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_negotiateEncoding
, 0, 0, 1)
716 ZEND_ARG_INFO(0, supported
)
717 ZEND_ARG_INFO(1, result_array
)
719 static PHP_METHOD(HttpEnv
, negotiateEncoding
)
721 HashTable
*supported
;
722 zval
*rs_array
= NULL
;
724 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS(), "H|z", &supported
, &rs_array
)) {
728 ZVAL_DEREF(rs_array
);
730 array_init(rs_array
);
732 PHP_HTTP_DO_NEGOTIATE(encoding
, supported
, rs_array
);
735 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_negotiateContentType
, 0, 0, 1)
736 ZEND_ARG_INFO(0, supported
)
737 ZEND_ARG_INFO(1, result_array
)
739 static PHP_METHOD(HttpEnv
, negotiateContentType
)
741 HashTable
*supported
;
742 zval
*rs_array
= NULL
;
744 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS(), "H|z", &supported
, &rs_array
)) {
748 ZVAL_DEREF(rs_array
);
750 array_init(rs_array
);
752 PHP_HTTP_DO_NEGOTIATE(content_type
, supported
, rs_array
);
755 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_negotiate
, 0, 0, 2)
756 ZEND_ARG_INFO(0, params
)
757 ZEND_ARG_INFO(0, supported
)
758 ZEND_ARG_INFO(0, primary_type_separator
)
759 ZEND_ARG_INFO(1, result_array
)
761 static PHP_METHOD(HttpEnv
, negotiate
)
763 HashTable
*supported
, *rs
;
764 zval
*rs_array
= NULL
;
765 char *value_str
, *sep_str
= NULL
;
766 size_t value_len
, sep_len
= 0;
768 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS(), "sH|s!z", &value_str
, &value_len
, &supported
, &sep_str
, &sep_len
, &rs_array
)) {
773 ZVAL_DEREF(rs_array
);
775 array_init(rs_array
);
778 if ((rs
= php_http_negotiate(value_str
, value_len
, supported
, sep_str
, sep_len
))) {
779 PHP_HTTP_DO_NEGOTIATE_HANDLE_RESULT(rs
, supported
, rs_array
);
781 PHP_HTTP_DO_NEGOTIATE_HANDLE_DEFAULT(supported
, rs_array
);
785 ZEND_BEGIN_ARG_INFO(ai_HttpEnv_reset
, 0)
787 static PHP_METHOD(HttpEnv
, reset
)
789 zend_parse_parameters_none();
790 php_http_env_reset();
794 static zend_function_entry php_http_env_methods
[] = {
795 PHP_ME(HttpEnv
, getRequestHeader
, ai_HttpEnv_getRequestHeader
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
796 PHP_ME(HttpEnv
, getRequestBody
, ai_HttpEnv_getRequestBody
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
798 PHP_ME(HttpEnv
, getResponseStatusForCode
, ai_HttpEnv_getResponseStatusForCode
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
799 PHP_ME(HttpEnv
, getResponseStatusForAllCodes
, ai_HttpEnv_getResponseStatusForAllCodes
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
801 PHP_ME(HttpEnv
, getResponseHeader
, ai_HttpEnv_getResponseHeader
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
802 PHP_ME(HttpEnv
, getResponseCode
, ai_HttpEnv_getResponseCode
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
803 PHP_ME(HttpEnv
, setResponseHeader
, ai_HttpEnv_setResponseHeader
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
804 PHP_ME(HttpEnv
, setResponseCode
, ai_HttpEnv_setResponseCode
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
806 PHP_ME(HttpEnv
, negotiateLanguage
, ai_HttpEnv_negotiateLanguage
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
807 PHP_ME(HttpEnv
, negotiateContentType
, ai_HttpEnv_negotiateContentType
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
808 PHP_ME(HttpEnv
, negotiateEncoding
, ai_HttpEnv_negotiateEncoding
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
809 PHP_ME(HttpEnv
, negotiateCharset
, ai_HttpEnv_negotiateCharset
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
810 PHP_ME(HttpEnv
, negotiate
, ai_HttpEnv_negotiate
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
812 PHP_ME(HttpEnv
, reset
, ai_HttpEnv_reset
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
817 static zend_class_entry
*php_http_env_class_entry
;
818 zend_class_entry
*php_http_env_get_class_entry(void)
820 return php_http_env_class_entry
;
823 PHP_MINIT_FUNCTION(http_env
)
825 zend_class_entry ce
= {0};
827 INIT_NS_CLASS_ENTRY(ce
, "http", "Env", php_http_env_methods
);
828 php_http_env_class_entry
= zend_register_internal_class(&ce
);
839 * vim600: noet sw=4 ts=4 fdm=marker
840 * vim<600: noet sw=4 ts=4