projects / m6w6 / ext-http / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
names changing )
[m6w6/ext-http] / php_http_env.c
1 /*
2 +--------------------------------------------------------------------+
3 | PECL :: http |
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-2013, Michael Wallner <mike@php.net> |
10 +--------------------------------------------------------------------+
11 */
12
13 #include "php_http_api.h"
14 #include "php_variables.h"
15
16 PHP_RINIT_FUNCTION(http_env)
17 {
18 PHP_HTTP_G->env.request.time = sapi_get_request_time(TSRMLS_C);
19
20 /* populate form data on non-POST requests */
21 if (SG(request_info).request_method && strcasecmp(SG(request_info).request_method, "POST") && SG(request_info).content_type && *SG(request_info).content_type) {
22 uint ct_len = strlen(SG(request_info).content_type);
23 char *ct_str = estrndup(SG(request_info).content_type, ct_len);
24 php_http_params_opts_t opts;
25 HashTable params;
26
27 php_http_params_opts_default_get(&opts);
28 opts.input.str = ct_str;
29 opts.input.len = ct_len;
30
31 SG(request_info).content_type_dup = ct_str;
32
33 ZEND_INIT_SYMTABLE(&params);
34 if (php_http_params_parse(&params, &opts TSRMLS_CC)) {
35 char *key_str;
36 uint key_len;
37 ulong key_num;
38
39 if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(&params, &key_str, &key_len, &key_num, 0, NULL)) {
40 sapi_post_entry *post_entry = NULL;
41
42 if (SUCCESS == zend_hash_find(&SG(known_post_content_types), key_str, key_len, (void *) &post_entry)) {
43 zval *files = PG(http_globals)[TRACK_VARS_FILES];
44
45 if (post_entry) {
46 SG(request_info).post_entry = post_entry;
47
48 if (post_entry->post_reader) {
49 post_entry->post_reader(TSRMLS_C);
50 }
51 }
52
53 if (sapi_module.default_post_reader) {
54 sapi_module.default_post_reader(TSRMLS_C);
55 }
56
57 sapi_handle_post(PG(http_globals)[TRACK_VARS_POST] TSRMLS_CC);
58
59 /*
60 * the rfc1867 handler is an awkward buddy
61 */
62 if (files != PG(http_globals)[TRACK_VARS_FILES] && PG(http_globals)[TRACK_VARS_FILES]) {
63 Z_ADDREF_P(PG(http_globals)[TRACK_VARS_FILES]);
64 zend_hash_update(&EG(symbol_table), "_FILES", sizeof("_FILES"), &PG(http_globals)[TRACK_VARS_FILES], sizeof(zval *), NULL);
65 if (files) {
66 zval_ptr_dtor(&files);
67 }
68 }
69 }
70 }
71 zend_hash_destroy(&params);
72 }
73 }
74
75 STR_SET(SG(request_info).content_type_dup, NULL);
76
77 return SUCCESS;
78 }
79
80 PHP_RSHUTDOWN_FUNCTION(http_env)
81 {
82 if (PHP_HTTP_G->env.request.headers) {
83 zend_hash_destroy(PHP_HTTP_G->env.request.headers);
84 FREE_HASHTABLE(PHP_HTTP_G->env.request.headers);
85 PHP_HTTP_G->env.request.headers = NULL;
86 }
87 if (PHP_HTTP_G->env.request.body) {
88 php_http_message_body_free(&PHP_HTTP_G->env.request.body);
89 }
90
91 if (PHP_HTTP_G->env.server_var) {
92 zval_ptr_dtor(&PHP_HTTP_G->env.server_var);
93 PHP_HTTP_G->env.server_var = NULL;
94 }
95
96 return SUCCESS;
97 }
98
99 PHP_HTTP_API void php_http_env_get_request_headers(HashTable *headers TSRMLS_DC)
100 {
101 php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
102 zval **hsv, **header;
103 HashPosition pos;
104
105 if (!PHP_HTTP_G->env.request.headers) {
106 ALLOC_HASHTABLE(PHP_HTTP_G->env.request.headers);
107 zend_hash_init(PHP_HTTP_G->env.request.headers, 0, NULL, ZVAL_PTR_DTOR, 0);
108
109 zend_is_auto_global("_SERVER", lenof("_SERVER") TSRMLS_CC);
110
111 if (SUCCESS == zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void *) &hsv) && Z_TYPE_PP(hsv) == IS_ARRAY) {
112 FOREACH_KEY(pos, *hsv, key) {
113 if (key.type == HASH_KEY_IS_STRING && key.len > 6 && *key.str == 'H' && !strncmp(key.str, "HTTP_", 5)) {
114 key.len -= 5;
115 key.str = php_http_pretty_key(estrndup(key.str + 5, key.len - 1), key.len - 1, 1, 1);
116
117 zend_hash_get_current_data_ex(Z_ARRVAL_PP(hsv), (void *) &header, &pos);
118 Z_ADDREF_P(*header);
119 zend_symtable_update(PHP_HTTP_G->env.request.headers, key.str, key.len, (void *) header, sizeof(zval *), NULL);
120
121 efree(key.str);
122 } else if (key.type == HASH_KEY_IS_STRING && key.len > 9 && *key.str == 'C' && !strncmp(key.str, "CONTENT_", 8)) {
123 key.str = php_http_pretty_key(estrndup(key.str, key.len - 1), key.len - 1, 1, 1);
124
125 zend_hash_get_current_data_ex(Z_ARRVAL_PP(hsv), (void *) &header, &pos);
126 Z_ADDREF_P(*header);
127 zend_symtable_update(PHP_HTTP_G->env.request.headers, key.str, key.len, (void *) header, sizeof(zval *), NULL);
128
129 efree(key.str);
130 }
131 }
132 }
133 }
134
135 if (headers) {
136 zend_hash_copy(headers, PHP_HTTP_G->env.request.headers, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
137 }
138 }
139
140 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)
141 {
142 HashTable *request_headers;
143 zval **zvalue = NULL;
144 char *val = NULL, *key = php_http_pretty_key(estrndup(name_str, name_len), name_len, 1, 1);
145
146 if (request) {
147 request_headers = &request->hdrs;
148 } else {
149 php_http_env_get_request_headers(NULL TSRMLS_CC);
150 request_headers = PHP_HTTP_G->env.request.headers;
151 }
152
153 if (SUCCESS == zend_symtable_find(request_headers, key, name_len + 1, (void *) &zvalue)) {
154 zval *zcopy = php_http_ztyp(IS_STRING, *zvalue);
155
156 val = estrndup(Z_STRVAL_P(zcopy), Z_STRLEN_P(zcopy));
157 if (len) {
158 *len = Z_STRLEN_P(zcopy);
159 }
160 zval_ptr_dtor(&zcopy);
161 }
162
163 efree(key);
164
165 return val;
166 }
167
168 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)
169 {
170 HashTable *request_headers;
171 char *key = php_http_pretty_key(estrndup(name_str, name_len), name_len, 1, 1);
172 int got;
173
174 if (request) {
175 request_headers = &request->hdrs;
176 } else {
177 php_http_env_get_request_headers(NULL TSRMLS_CC);
178 request_headers = PHP_HTTP_G->env.request.headers;
179 }
180 got = zend_symtable_exists(request_headers, key, name_len + 1);
181 efree(key);
182
183 return got;
184 }
185
186 PHP_HTTP_API zval *php_http_env_get_superglobal(const char *key, size_t key_len TSRMLS_DC)
187 {
188 zval **hsv;
189
190 zend_is_auto_global(key, key_len TSRMLS_CC);
191
192 if ((SUCCESS != zend_hash_find(&EG(symbol_table), key, key_len + 1, (void *) &hsv)) || (Z_TYPE_PP(hsv) != IS_ARRAY)) {
193 return NULL;
194 }
195
196 return *hsv;
197 }
198
199 PHP_HTTP_API zval *php_http_env_get_server_var(const char *key, size_t key_len, zend_bool check TSRMLS_DC)
200 {
201 zval *hsv, **var;
202 char *env;
203
204 /* if available, this is a lot faster than accessing $_SERVER */
205 if (sapi_module.getenv) {
206 if ((!(env = sapi_module.getenv((char *) key, key_len TSRMLS_CC))) || (check && !*env)) {
207 return NULL;
208 }
209 if (PHP_HTTP_G->env.server_var) {
210 zval_ptr_dtor(&PHP_HTTP_G->env.server_var);
211 }
212 MAKE_STD_ZVAL(PHP_HTTP_G->env.server_var);
213 ZVAL_STRING(PHP_HTTP_G->env.server_var, env, 1);
214 return PHP_HTTP_G->env.server_var;
215 }
216
217 if (!(hsv = php_http_env_get_superglobal(ZEND_STRL("_SERVER") TSRMLS_CC))) {
218 return NULL;
219 }
220 if ((SUCCESS != zend_symtable_find(Z_ARRVAL_P(hsv), key, key_len + 1, (void *) &var))) {
221 return NULL;
222 }
223 if (check && !((Z_TYPE_PP(var) == IS_STRING) && Z_STRVAL_PP(var) && Z_STRLEN_PP(var))) {
224 return NULL;
225 }
226 return *var;
227 }
228
229 PHP_HTTP_API php_http_message_body_t *php_http_env_get_request_body(TSRMLS_D)
230 {
231 if (!PHP_HTTP_G->env.request.body) {
232 php_stream *s = NULL;
233
234 if (SG(request_info).post_data || SG(request_info).raw_post_data) {
235 if ((s = php_stream_temp_new())) {
236 /* php://input does not support seek() */
237 if (SG(request_info).raw_post_data) {
238 php_stream_write(s, SG(request_info).raw_post_data, SG(request_info).raw_post_data_length);
239 } else {
240 php_stream_write(s, SG(request_info).post_data, SG(request_info).post_data_length);
241 }
242 php_stream_rewind(s);
243 }
244 } else if (sapi_module.read_post && !SG(read_post_bytes)) {
245 if ((s = php_stream_temp_new())) {
246 char *buf = emalloc(4096);
247 int len;
248
249 while (0 < (len = sapi_module.read_post(buf, 4096 TSRMLS_CC))) {
250 SG(read_post_bytes) += len;
251 php_stream_write(s, buf, len);
252
253 if (len < 4096) {
254 break;
255 }
256 }
257 efree(buf);
258
259 php_stream_rewind(s);
260 }
261 }
262 PHP_HTTP_G->env.request.body = php_http_message_body_init(NULL, s TSRMLS_CC);
263 }
264
265 return PHP_HTTP_G->env.request.body;
266 }
267
268 PHP_HTTP_API const char *php_http_env_get_request_method(php_http_message_t *request TSRMLS_DC)
269 {
270 const char *m;
271
272 if (PHP_HTTP_MESSAGE_TYPE(REQUEST, request)) {
273 m = request->http.info.request.method;
274 } else {
275 m = SG(request_info).request_method;
276 }
277
278 return m ? m : "GET";
279 }
280
281 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)
282 {
283 zval *zentry;
284 char *range, *rp, c;
285 long begin = -1, end = -1, *ptr;
286
287 if (!(range = php_http_env_get_request_header(ZEND_STRL("Range"), NULL, request TSRMLS_CC))) {
288 return PHP_HTTP_RANGE_NO;
289 }
290 if (strncmp(range, "bytes=", lenof("bytes="))) {
291 STR_FREE(range);
292 return PHP_HTTP_RANGE_NO;
293 }
294
295 rp = range + lenof("bytes=");
296 ptr = &begin;
297
298 do {
299 switch (c = *(rp++)) {
300 case '0':
301 /* allow 000... - shall we? */
302 if (*ptr != -10) {
303 *ptr *= 10;
304 }
305 break;
306
307 case '1': case '2': case '3':
308 case '4': case '5': case '6':
309 case '7': case '8': case '9':
310 /*
311 * If the value of the pointer is already set (non-negative)
312 * then multiply its value by ten and add the current value,
313 * else initialise the pointers value with the current value
314 * --
315 * This let us recognize empty fields when validating the
316 * ranges, i.e. a "-10" for begin and "12345" for the end
317 * was the following range request: "Range: bytes=0-12345";
318 * While a "-1" for begin and "12345" for the end would
319 * have been: "Range: bytes=-12345".
320 */
321 if (*ptr > 0) {
322 *ptr *= 10;
323 *ptr += c - '0';
324 } else {
325 *ptr = c - '0';
326 }
327 break;
328
329 case '-':
330 ptr = &end;
331 break;
332
333 case ' ':
334 break;
335
336 case 0:
337 case ',':
338
339 if (length) {
340 /* validate ranges */
341 switch (begin) {
342 /* "0-12345" */
343 case -10:
344 switch (end) {
345 /* "0-" */
346 case -1:
347 STR_FREE(range);
348 return PHP_HTTP_RANGE_NO;
349
350 /* "0-0" */
351 case -10:
352 end = 0;
353 break;
354
355 default:
356 if (length <= (size_t) end) {
357 end = length - 1;
358 }
359 break;
360 }
361 begin = 0;
362 break;
363
364 /* "-12345" */
365 case -1:
366 /* "-", "-0" */
367 if (end == -1 || end == -10) {
368 STR_FREE(range);
369 return PHP_HTTP_RANGE_ERR;
370 }
371 begin = length - end;
372 end = length - 1;
373 break;
374
375 /* "12345-(NNN)" */
376 default:
377 if (length <= (size_t) begin) {
378 STR_FREE(range);
379 return PHP_HTTP_RANGE_ERR;
380 }
381 switch (end) {
382 /* "12345-0" */
383 case -10:
384 STR_FREE(range);
385 return PHP_HTTP_RANGE_ERR;
386
387 /* "12345-" */
388 case -1:
389 end = length - 1;
390 break;
391
392 /* "12345-67890" */
393 default:
394 if (length <= (size_t) end) {
395 end = length - 1;
396 } else if (end < begin) {
397 STR_FREE(range);
398 return PHP_HTTP_RANGE_ERR;
399 }
400 break;
401 }
402 break;
403 }
404 }
405
406 MAKE_STD_ZVAL(zentry);
407 array_init(zentry);
408 add_index_long(zentry, 0, begin);
409 add_index_long(zentry, 1, end);
410 zend_hash_next_index_insert(ranges, &zentry, sizeof(zval *), NULL);
411
412 begin = -1;
413 end = -1;
414 ptr = &begin;
415
416 break;
417
418 default:
419 STR_FREE(range);
420 return PHP_HTTP_RANGE_NO;
421 }
422 } while (c != 0);
423
424 STR_FREE(range);
425 return PHP_HTTP_RANGE_OK;
426 }
427
428 static void grab_headers(void *data, void *arg TSRMLS_DC)
429 {
430 php_http_buffer_appendl(PHP_HTTP_BUFFER(arg), ((sapi_header_struct *)data)->header);
431 php_http_buffer_appends(PHP_HTTP_BUFFER(arg), PHP_HTTP_CRLF);
432 }
433
434 PHP_HTTP_API STATUS php_http_env_get_response_headers(HashTable *headers_ht TSRMLS_DC)
435 {
436 STATUS status;
437 php_http_buffer_t headers;
438
439 php_http_buffer_init(&headers);
440 zend_llist_apply_with_argument(&SG(sapi_headers).headers, grab_headers, &headers TSRMLS_CC);
441 php_http_buffer_fix(&headers);
442
443 status = php_http_headers_parse(headers.data, headers.used, headers_ht, NULL, NULL TSRMLS_CC);
444 php_http_buffer_dtor(&headers);
445
446 return status;
447 }
448
449 PHP_HTTP_API char *php_http_env_get_response_header(const char *name_str, size_t name_len TSRMLS_DC)
450 {
451 char *val = NULL;
452 HashTable headers;
453
454 zend_hash_init(&headers, 0, NULL, ZVAL_PTR_DTOR, 0);
455 if (SUCCESS == php_http_env_get_response_headers(&headers TSRMLS_CC)) {
456 zval **zvalue;
457 char *key = php_http_pretty_key(estrndup(name_str, name_len), name_len, 1, 1);
458
459 if (SUCCESS == zend_symtable_find(&headers, key, name_len + 1, (void *) &zvalue)) {
460 zval *zcopy = php_http_ztyp(IS_STRING, *zvalue);
461
462 val = estrndup(Z_STRVAL_P(zcopy), Z_STRLEN_P(zcopy));
463 zval_ptr_dtor(&zcopy);
464 }
465
466 efree(key);
467 }
468 zend_hash_destroy(&headers);
469
470 return val;
471 }
472
473 PHP_HTTP_API long php_http_env_get_response_code(TSRMLS_D)
474 {
475 long code = SG(sapi_headers).http_response_code;
476 return code ? code : 200;
477 }
478
479 PHP_HTTP_API STATUS php_http_env_set_response_code(long http_code TSRMLS_DC)
480 {
481 return sapi_header_op(SAPI_HEADER_SET_STATUS, (void *) http_code TSRMLS_CC);
482 }
483
484 PHP_HTTP_API STATUS php_http_env_set_response_status_line(long code, php_http_version_t *v TSRMLS_DC)
485 {
486 sapi_header_line h = {NULL, 0, 0};
487 STATUS ret;
488
489 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));
490 ret = sapi_header_op(SAPI_HEADER_REPLACE, (void *) &h TSRMLS_CC);
491 efree(h.line);
492
493 return ret;
494 }
495
496 PHP_HTTP_API STATUS php_http_env_set_response_protocol_version(php_http_version_t *v TSRMLS_DC)
497 {
498 return php_http_env_set_response_status_line(php_http_env_get_response_code(TSRMLS_C), v TSRMLS_CC);
499 }
500
501 PHP_HTTP_API STATUS php_http_env_set_response_header(long http_code, const char *header_str, size_t header_len, zend_bool replace TSRMLS_DC)
502 {
503 sapi_header_line h = {estrndup(header_str, header_len), header_len, http_code};
504 STATUS ret = sapi_header_op(replace ? SAPI_HEADER_REPLACE : SAPI_HEADER_ADD, (void *) &h TSRMLS_CC);
505 efree(h.line);
506 return ret;
507 }
508
509 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)
510 {
511 STATUS ret = FAILURE;
512 sapi_header_line h = {NULL, 0, http_code};
513
514 h.line_len = vspprintf(&h.line, 0, fmt, argv);
515
516 if (h.line) {
517 if (h.line_len) {
518 ret = sapi_header_op(replace ? SAPI_HEADER_REPLACE : SAPI_HEADER_ADD, (void *) &h TSRMLS_CC);
519 }
520 efree(h.line);
521 }
522 return ret;
523 }
524
525 PHP_HTTP_API STATUS php_http_env_set_response_header_format(long http_code, zend_bool replace TSRMLS_DC, const char *fmt, ...)
526 {
527 STATUS ret;
528 va_list args;
529
530 va_start(args, fmt);
531 ret = php_http_env_set_response_header_va(http_code, replace, fmt, args TSRMLS_CC);
532 va_end(args);
533
534 return ret;
535 }
536
537 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)
538 {
539 if (!value) {
540 sapi_header_line h = {(char *) name_str, name_len, http_code};
541
542 return sapi_header_op(SAPI_HEADER_DELETE, (void *) &h TSRMLS_CC);
543 }
544
545 if(Z_TYPE_P(value) == IS_ARRAY || Z_TYPE_P(value) == IS_OBJECT) {
546 HashPosition pos;
547 int first = replace;
548 zval **data_ptr;
549
550 FOREACH_HASH_VAL(pos, HASH_OF(value), data_ptr) {
551 if (SUCCESS != php_http_env_set_response_header_value(http_code, name_str, name_len, *data_ptr, first TSRMLS_CC)) {
552 return FAILURE;
553 }
554 first = 0;
555 }
556
557 return SUCCESS;
558 } else {
559 zval *data = php_http_ztyp(IS_STRING, value);
560
561 if (!Z_STRLEN_P(data)) {
562 zval_ptr_dtor(&data);
563 return php_http_env_set_response_header_value(http_code, name_str, name_len, NULL, replace TSRMLS_CC);
564 } else {
565 sapi_header_line h;
566 STATUS ret;
567
568 if (name_len > INT_MAX) {
569 name_len = INT_MAX;
570 }
571 h.response_code = http_code;
572 h.line_len = spprintf(&h.line, 0, "%.*s: %.*s", (int) name_len, name_str, Z_STRLEN_P(data), Z_STRVAL_P(data));
573
574 ret = sapi_header_op(replace ? SAPI_HEADER_REPLACE : SAPI_HEADER_ADD, (void *) &h TSRMLS_CC);
575
576 zval_ptr_dtor(&data);
577 STR_FREE(h.line);
578
579 return ret;
580 }
581 }
582 }
583
584 static PHP_HTTP_STRLIST(php_http_env_response_status) =
585 PHP_HTTP_STRLIST_ITEM("Continue")
586 PHP_HTTP_STRLIST_ITEM("Switching Protocols")
587 PHP_HTTP_STRLIST_ITEM("Processing")
588 PHP_HTTP_STRLIST_NEXT
589 PHP_HTTP_STRLIST_ITEM("OK")
590 PHP_HTTP_STRLIST_ITEM("Created")
591 PHP_HTTP_STRLIST_ITEM("Accepted")
592 PHP_HTTP_STRLIST_ITEM("Non-Authoritative Information")
593 PHP_HTTP_STRLIST_ITEM("No Content")
594 PHP_HTTP_STRLIST_ITEM("Reset Content")
595 PHP_HTTP_STRLIST_ITEM("Partial Content")
596 PHP_HTTP_STRLIST_ITEM("Multi-Status")
597 PHP_HTTP_STRLIST_ITEM("Already Reported")
598 PHP_HTTP_STRLIST_ITEM("(Unused)")
599 PHP_HTTP_STRLIST_ITEM("(Unused)")
600 PHP_HTTP_STRLIST_ITEM("(Unused)")
601 PHP_HTTP_STRLIST_ITEM("(Unused)")
602 PHP_HTTP_STRLIST_ITEM("(Unused)")
603 PHP_HTTP_STRLIST_ITEM("(Unused)")
604 PHP_HTTP_STRLIST_ITEM("(Unused)")
605 PHP_HTTP_STRLIST_ITEM("(Unused)")
606 PHP_HTTP_STRLIST_ITEM("(Unused)")
607 PHP_HTTP_STRLIST_ITEM("(Unused)")
608 PHP_HTTP_STRLIST_ITEM("(Unused)")
609 PHP_HTTP_STRLIST_ITEM("(Unused)")
610 PHP_HTTP_STRLIST_ITEM("(Unused)")
611 PHP_HTTP_STRLIST_ITEM("(Unused)")
612 PHP_HTTP_STRLIST_ITEM("(Unused)")
613 PHP_HTTP_STRLIST_ITEM("(Unused)")
614 PHP_HTTP_STRLIST_ITEM("(Unused)")
615 PHP_HTTP_STRLIST_ITEM("IM Used")
616 PHP_HTTP_STRLIST_NEXT
617 PHP_HTTP_STRLIST_ITEM("Multiple Choices")
618 PHP_HTTP_STRLIST_ITEM("Moved Permanently")
619 PHP_HTTP_STRLIST_ITEM("Found")
620 PHP_HTTP_STRLIST_ITEM("See Other")
621 PHP_HTTP_STRLIST_ITEM("Not Modified")
622 PHP_HTTP_STRLIST_ITEM("Use Proxy")
623 PHP_HTTP_STRLIST_ITEM("(Unused)")
624 PHP_HTTP_STRLIST_ITEM("Temporary Redirect")
625 PHP_HTTP_STRLIST_ITEM("Permanent Redirect")
626 PHP_HTTP_STRLIST_NEXT
627 PHP_HTTP_STRLIST_ITEM("Bad Request")
628 PHP_HTTP_STRLIST_ITEM("Unauthorized")
629 PHP_HTTP_STRLIST_ITEM("Payment Required")
630 PHP_HTTP_STRLIST_ITEM("Forbidden")
631 PHP_HTTP_STRLIST_ITEM("Not Found")
632 PHP_HTTP_STRLIST_ITEM("Method Not Allowed")
633 PHP_HTTP_STRLIST_ITEM("Not Acceptable")
634 PHP_HTTP_STRLIST_ITEM("Proxy Authentication Required")
635 PHP_HTTP_STRLIST_ITEM("Request Timeout")
636 PHP_HTTP_STRLIST_ITEM("Conflict")
637 PHP_HTTP_STRLIST_ITEM("Gone")
638 PHP_HTTP_STRLIST_ITEM("Length Required")
639 PHP_HTTP_STRLIST_ITEM("Precondition Failed")
640 PHP_HTTP_STRLIST_ITEM("Request Entity Too Large")
641 PHP_HTTP_STRLIST_ITEM("Request URI Too Long")
642 PHP_HTTP_STRLIST_ITEM("Unsupported Media Type")
643 PHP_HTTP_STRLIST_ITEM("Requested Range Not Satisfiable")
644 PHP_HTTP_STRLIST_ITEM("Expectation Failed")
645 PHP_HTTP_STRLIST_ITEM("(Unused)")
646 PHP_HTTP_STRLIST_ITEM("(Unused)")
647 PHP_HTTP_STRLIST_ITEM("(Unused)")
648 PHP_HTTP_STRLIST_ITEM("(Unused)")
649 PHP_HTTP_STRLIST_ITEM("Unprocessible Entity")
650 PHP_HTTP_STRLIST_ITEM("Locked")
651 PHP_HTTP_STRLIST_ITEM("Failed Dependency")
652 PHP_HTTP_STRLIST_ITEM("(Reserved)")
653 PHP_HTTP_STRLIST_ITEM("Upgrade Required")
654 PHP_HTTP_STRLIST_ITEM("(Unused)")
655 PHP_HTTP_STRLIST_ITEM("Precondition Required")
656 PHP_HTTP_STRLIST_ITEM("Too Many Requests")
657 PHP_HTTP_STRLIST_ITEM("(Unused)")
658 PHP_HTTP_STRLIST_ITEM("Request Header Fields Too Large")
659 PHP_HTTP_STRLIST_NEXT
660 PHP_HTTP_STRLIST_ITEM("Internal Server Error")
661 PHP_HTTP_STRLIST_ITEM("Not Implemented")
662 PHP_HTTP_STRLIST_ITEM("Bad Gateway")
663 PHP_HTTP_STRLIST_ITEM("Service Unavailable")
664 PHP_HTTP_STRLIST_ITEM("Gateway Timeout")
665 PHP_HTTP_STRLIST_ITEM("HTTP Version Not Supported")
666 PHP_HTTP_STRLIST_ITEM("Variant Also Negotiates")
667 PHP_HTTP_STRLIST_ITEM("Insufficient Storage")
668 PHP_HTTP_STRLIST_ITEM("Loop Detected")
669 PHP_HTTP_STRLIST_ITEM("(Unused)")
670 PHP_HTTP_STRLIST_ITEM("Not Extended")
671 PHP_HTTP_STRLIST_ITEM("Network Authentication Required")
672 PHP_HTTP_STRLIST_STOP
673 ;
674
675 PHP_HTTP_API const char *php_http_env_get_response_status_for_code(unsigned code)
676 {
677 return php_http_strlist_find(php_http_env_response_status, 100, code);
678 }
679
680 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_getRequestHeader, 0, 0, 0)
681 ZEND_ARG_INFO(0, header_name)
682 ZEND_END_ARG_INFO();
683 static PHP_METHOD(HttpEnv, getRequestHeader)
684 {
685 char *header_name_str = NULL;
686 int header_name_len = 0;
687
688 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &header_name_str, &header_name_len)) {
689 if (header_name_str && header_name_len) {
690 size_t header_length;
691 char *header_value = php_http_env_get_request_header(header_name_str, header_name_len, &header_length, NULL TSRMLS_CC);
692
693 if (header_value) {
694 RETURN_STRINGL(header_value, header_length, 0);
695 }
696 RETURN_NULL();
697 } else {
698 array_init(return_value);
699 php_http_env_get_request_headers(Z_ARRVAL_P(return_value) TSRMLS_CC);
700 return;
701 }
702 }
703 RETURN_FALSE;
704 }
705
706 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_getRequestBody, 0, 0, 0)
707 ZEND_ARG_INFO(0, body_class_name)
708 ZEND_END_ARG_INFO();
709 static PHP_METHOD(HttpEnv, getRequestBody)
710 {
711 with_error_handling(EH_THROW, php_http_exception_class_entry) {
712 zend_class_entry *class_entry = php_http_message_body_class_entry;
713
714 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|C", &class_entry)) {
715 zend_object_value ov;
716 php_http_message_body_t *body = php_http_env_get_request_body(TSRMLS_C);
717
718 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, php_http_message_body_init(&body, NULL TSRMLS_CC), NULL TSRMLS_CC)) {
719 RETVAL_OBJVAL(ov, 0);
720 }
721 }
722 } end_error_handling();
723 }
724
725 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_getResponseStatusForCode, 0, 0, 1)
726 ZEND_ARG_INFO(0, code)
727 ZEND_END_ARG_INFO();
728 static PHP_METHOD(HttpEnv, getResponseStatusForCode)
729 {
730 long code;
731
732 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &code)) {
733 RETURN_STRING(php_http_env_get_response_status_for_code(code), 1);
734 }
735 RETURN_FALSE;
736 }
737
738 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_getResponseStatusForAllCodes, 0, 0, 0)
739 ZEND_END_ARG_INFO();
740 static PHP_METHOD(HttpEnv, getResponseStatusForAllCodes)
741 {
742 const char *s;
743 unsigned c;
744 php_http_strlist_iterator_t i;
745
746 if (SUCCESS != zend_parse_parameters_none()) {
747 RETURN_FALSE;
748 }
749
750 array_init(return_value);
751 for ( php_http_strlist_iterator_init(&i, php_http_env_response_status, 100);
752 *(s = php_http_strlist_iterator_this(&i, &c));
753 php_http_strlist_iterator_next(&i)
754 ) {
755 add_index_string(return_value, c, s, 1);
756 }
757 }
758
759 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_getResponseHeader, 0, 0, 0)
760 ZEND_ARG_INFO(0, header_name)
761 ZEND_END_ARG_INFO();
762 static PHP_METHOD(HttpEnv, getResponseHeader)
763 {
764 char *header_name_str = NULL;
765 int header_name_len = 0;
766
767 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &header_name_str, &header_name_len)) {
768 if (header_name_str && header_name_len) {
769 char *header_value = php_http_env_get_response_header(header_name_str, header_name_len TSRMLS_CC);
770
771 if (header_value) {
772 RETURN_STRING(header_value, 0);
773 }
774 RETURN_NULL();
775 } else {
776 array_init(return_value);
777 php_http_env_get_response_headers(Z_ARRVAL_P(return_value) TSRMLS_CC);
778 return;
779 }
780 }
781 RETURN_FALSE;
782 }
783
784 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_getResponseCode, 0, 0, 0)
785 ZEND_END_ARG_INFO();
786 static PHP_METHOD(HttpEnv, getResponseCode)
787 {
788 if (SUCCESS == zend_parse_parameters_none()) {
789 RETURN_LONG(php_http_env_get_response_code(TSRMLS_C));
790 }
791 RETURN_FALSE;
792 }
793
794 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_setResponseHeader, 0, 0, 1)
795 ZEND_ARG_INFO(0, header_name)
796 ZEND_ARG_INFO(0, header_value)
797 ZEND_ARG_INFO(0, response_code)
798 ZEND_ARG_INFO(0, replace_header)
799 ZEND_END_ARG_INFO();
800 static PHP_METHOD(HttpEnv, setResponseHeader)
801 {
802 char *header_name_str;
803 int header_name_len;
804 zval *header_value = NULL;
805 long code = 0;
806 zend_bool replace_header = 1;
807
808 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z!lb", &header_name_str, &header_name_len, &header_value, &code, &replace_header)) {
809 RETURN_BOOL(SUCCESS == php_http_env_set_response_header_value(code, header_name_str, header_name_len, header_value, replace_header TSRMLS_CC));
810 }
811 RETURN_FALSE;
812 }
813
814 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_setResponseCode, 0, 0, 1)
815 ZEND_ARG_INFO(0, code)
816 ZEND_END_ARG_INFO();
817 static PHP_METHOD(HttpEnv, setResponseCode)
818 {
819 long code;
820
821 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &code)) {
822 RETURN_BOOL(SUCCESS == php_http_env_set_response_code(code TSRMLS_CC));
823 }
824 RETURN_FALSE;
825 }
826
827 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_negotiateLanguage, 0, 0, 1)
828 ZEND_ARG_INFO(0, supported)
829 ZEND_ARG_INFO(1, result_array)
830 ZEND_END_ARG_INFO();
831 static PHP_METHOD(HttpEnv, negotiateLanguage)
832 {
833 HashTable *supported;
834 zval *rs_array = NULL;
835
836 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H|z", &supported, &rs_array)) {
837 if (rs_array) {
838 zval_dtor(rs_array);
839 array_init(rs_array);
840 }
841
842 PHP_HTTP_DO_NEGOTIATE(language, supported, rs_array);
843 } else {
844 RETURN_FALSE;
845 }
846 }
847
848 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_negotiateCharset, 0, 0, 1)
849 ZEND_ARG_INFO(0, supported)
850 ZEND_ARG_INFO(1, result_array)
851 ZEND_END_ARG_INFO();
852 static PHP_METHOD(HttpEnv, negotiateCharset)
853 {
854 HashTable *supported;
855 zval *rs_array = NULL;
856
857 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H|z", &supported, &rs_array)) {
858 if (rs_array) {
859 zval_dtor(rs_array);
860 array_init(rs_array);
861 }
862 PHP_HTTP_DO_NEGOTIATE(charset, supported, rs_array);
863 } else {
864 RETURN_FALSE;
865 }
866 }
867
868 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_negotiateEncoding, 0, 0, 1)
869 ZEND_ARG_INFO(0, supported)
870 ZEND_ARG_INFO(1, result_array)
871 ZEND_END_ARG_INFO();
872 static PHP_METHOD(HttpEnv, negotiateEncoding)
873 {
874 HashTable *supported;
875 zval *rs_array = NULL;
876
877 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H|z", &supported, &rs_array)) {
878 if (rs_array) {
879 zval_dtor(rs_array);
880 array_init(rs_array);
881 }
882 PHP_HTTP_DO_NEGOTIATE(encoding, supported, rs_array);
883 } else {
884 RETURN_FALSE;
885 }
886 }
887
888 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_negotiateContentType, 0, 0, 1)
889 ZEND_ARG_INFO(0, supported)
890 ZEND_ARG_INFO(1, result_array)
891 ZEND_END_ARG_INFO();
892 static PHP_METHOD(HttpEnv, negotiateContentType)
893 {
894 HashTable *supported;
895 zval *rs_array = NULL;
896
897 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H|z", &supported, &rs_array)) {
898 if (rs_array) {
899 zval_dtor(rs_array);
900 array_init(rs_array);
901 }
902 PHP_HTTP_DO_NEGOTIATE(content_type, supported, rs_array);
903 } else {
904 RETURN_FALSE;
905 }
906 }
907
908 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEnv_negotiate, 0, 0, 2)
909 ZEND_ARG_INFO(0, value)
910 ZEND_ARG_INFO(0, supported)
911 ZEND_ARG_INFO(0, primary_type_separator)
912 ZEND_ARG_INFO(1, result_array)
913 ZEND_END_ARG_INFO();
914 static PHP_METHOD(HttpEnv, negotiate)
915 {
916 HashTable *supported;
917 zval *rs_array = NULL;
918 char *value_str, *sep_str = NULL;
919 int value_len, sep_len = 0;
920
921 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sH|s!z", &value_str, &value_len, &supported, &sep_str, &sep_len, &rs_array)) {
922 HashTable *rs;
923
924 if (rs_array) {
925 zval_dtor(rs_array);
926 array_init(rs_array);
927 }
928
929 if ((rs = php_http_negotiate(value_str, value_len, supported, sep_str, sep_len TSRMLS_CC))) {
930 PHP_HTTP_DO_NEGOTIATE_HANDLE_RESULT(rs, supported, rs_array);
931 } else {
932 PHP_HTTP_DO_NEGOTIATE_HANDLE_DEFAULT(supported, rs_array);
933 }
934 } else {
935 RETURN_FALSE;
936 }
937 }
938
939 static zend_function_entry php_http_env_methods[] = {
940 PHP_ME(HttpEnv, getRequestHeader, ai_HttpEnv_getRequestHeader, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
941 PHP_ME(HttpEnv, getRequestBody, ai_HttpEnv_getRequestBody, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
942
943 PHP_ME(HttpEnv, getResponseStatusForCode, ai_HttpEnv_getResponseStatusForCode, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
944 PHP_ME(HttpEnv, getResponseStatusForAllCodes, ai_HttpEnv_getResponseStatusForAllCodes, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
945
946 PHP_ME(HttpEnv, getResponseHeader, ai_HttpEnv_getResponseHeader, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
947 PHP_ME(HttpEnv, getResponseCode, ai_HttpEnv_getResponseCode, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
948 PHP_ME(HttpEnv, setResponseHeader, ai_HttpEnv_setResponseHeader, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
949 PHP_ME(HttpEnv, setResponseCode, ai_HttpEnv_setResponseCode, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
950
951 PHP_ME(HttpEnv, negotiateLanguage, ai_HttpEnv_negotiateLanguage, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
952 PHP_ME(HttpEnv, negotiateContentType, ai_HttpEnv_negotiateContentType, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
953 PHP_ME(HttpEnv, negotiateEncoding, ai_HttpEnv_negotiateEncoding, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
954 PHP_ME(HttpEnv, negotiateCharset, ai_HttpEnv_negotiateCharset, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
955 PHP_ME(HttpEnv, negotiate, ai_HttpEnv_negotiate, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
956
957 EMPTY_FUNCTION_ENTRY
958 };
959
960 #ifdef PHP_HTTP_HAVE_JSON
961 #include "ext/json/php_json.h"
962
963 static SAPI_POST_HANDLER_FUNC(php_http_json_post_handler)
964 {
965 if (SG(request_info).raw_post_data) {
966 zval *zarg = arg;
967 zval_dtor(zarg);
968 ZVAL_NULL(zarg);
969 php_json_decode(zarg, SG(request_info).raw_post_data, SG(request_info).raw_post_data_length, 1, PG(max_input_nesting_level) TSRMLS_CC);
970 if (Z_TYPE_P(zarg) == IS_NULL) {
971 array_init(zarg);
972 }
973 }
974 }
975
976 static void php_http_env_register_json_handler(TSRMLS_D)
977 {
978 sapi_post_entry entry = {NULL, 0, NULL, NULL};
979
980 entry.post_reader = sapi_read_standard_form_data;
981 entry.post_handler = php_http_json_post_handler;
982
983 entry.content_type = "text/json";
984 entry.content_type_len = lenof("text/json");
985 sapi_register_post_entry(&entry TSRMLS_CC);
986
987 entry.content_type = "application/json";
988 entry.content_type_len = lenof("application/json");
989 sapi_register_post_entry(&entry TSRMLS_CC);
990 }
991 #endif
992
993 zend_class_entry *php_http_env_class_entry;
994
995 PHP_MINIT_FUNCTION(http_env)
996 {
997 zend_class_entry ce = {0};
998
999 INIT_NS_CLASS_ENTRY(ce, "http", "Env", php_http_env_methods);
1000 php_http_env_class_entry = zend_register_internal_class_ex(&ce, php_http_object_class_entry, NULL TSRMLS_CC);
1001
1002 #ifdef PHP_HTTP_HAVE_JSON
1003 php_http_env_register_json_handler(TSRMLS_C);
1004 #endif
1005
1006 return SUCCESS;
1007 }
1008
1009
1010 /*
1011 * Local variables:
1012 * tab-width: 4
1013 * c-basic-offset: 4
1014 * End:
1015 * vim600: noet sw=4 ts=4 fdm=marker
1016 * vim<600: noet sw=4 ts=4
1017 */
Extended HTTP Support