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"
15 static php_http_params_token_t def_param_sep
= {",", 1}, *def_param_sep_ptr
[] = {&def_param_sep
, NULL
};
16 static php_http_params_token_t def_arg_sep
= {";", 1}, *def_arg_sep_ptr
[] = {&def_arg_sep
, NULL
};
17 static php_http_params_token_t def_val_sep
= {"=", 1}, *def_val_sep_ptr
[] = {&def_val_sep
, NULL
};
18 static php_http_params_opts_t def_opts
= {
24 PHP_HTTP_PARAMS_DEFAULT
27 php_http_params_opts_t
*php_http_params_opts_default_get(php_http_params_opts_t
*opts
)
30 opts
= emalloc(sizeof(*opts
));
33 memcpy(opts
, &def_opts
, sizeof(def_opts
));
38 typedef struct php_http_params_state
{
39 php_http_params_token_t input
;
40 php_http_params_token_t param
;
41 php_http_params_token_t arg
;
42 php_http_params_token_t val
;
51 } php_http_params_state_t
;
53 static inline void sanitize_escaped(zval
*zv TSRMLS_DC
)
55 if (Z_STRVAL_P(zv
)[0] == '"' && Z_STRVAL_P(zv
)[Z_STRLEN_P(zv
) - 1] == '"') {
56 size_t deq_len
= Z_STRLEN_P(zv
) - 2;
57 char *deq
= estrndup(Z_STRVAL_P(zv
) + 1, deq_len
);
60 ZVAL_STRINGL(zv
, deq
, deq_len
, 0);
63 php_stripcslashes(Z_STRVAL_P(zv
), &Z_STRLEN_P(zv
));
66 static inline void quote_string(zval
*zv
, zend_bool force TSRMLS_DC
)
68 int len
= Z_STRLEN_P(zv
);
70 Z_STRVAL_P(zv
) = php_addcslashes(Z_STRVAL_P(zv
), Z_STRLEN_P(zv
), &Z_STRLEN_P(zv
), 1,
71 ZEND_STRL("\0..\37\173\\\"") TSRMLS_CC
);
73 if (force
|| len
!= Z_STRLEN_P(zv
) || strpbrk(Z_STRVAL_P(zv
), "()<>@,;:\"[]?={} ")) {
75 int len
= Z_STRLEN_P(zv
) + 2;
76 char *str
= emalloc(len
+ 1);
79 memcpy(&str
[1], Z_STRVAL_P(zv
), Z_STRLEN_P(zv
));
84 ZVAL_STRINGL(zv
, str
, len
, 0);
88 static inline void prepare_escaped(zval
*zv TSRMLS_DC
)
90 if (Z_TYPE_P(zv
) == IS_STRING
) {
91 quote_string(zv
, 0 TSRMLS_CC
);
94 ZVAL_EMPTY_STRING(zv
);
98 static inline void sanitize_urlencoded(zval
*zv TSRMLS_DC
)
100 Z_STRLEN_P(zv
) = php_raw_url_decode(Z_STRVAL_P(zv
), Z_STRLEN_P(zv
));
103 static inline void prepare_urlencoded(zval
*zv TSRMLS_DC
)
106 char *str
= php_raw_url_encode(Z_STRVAL_P(zv
), Z_STRLEN_P(zv
), &len
);
109 ZVAL_STRINGL(zv
, str
, len
, 0);
112 static void sanitize_dimension(zval
*zv TSRMLS_DC
)
114 zval
*arr
= NULL
, *tmp
= NULL
, **cur
= NULL
;
115 char *var
= NULL
, *ptr
= Z_STRVAL_P(zv
), *end
= Z_STRVAL_P(zv
) + Z_STRLEN_P(zv
);
129 if (++level
> PG(max_input_nesting_level
)) {
131 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Max input nesting level of %ld exceeded", (long) PG(max_input_nesting_level
));
134 if (ptr
- var
== 0) {
144 convert_to_array(*cur
);
149 zend_symtable_update(Z_ARRVAL_PP(cur
), var
, ptr
- var
+ 1, (void *) &tmp
, sizeof(zval
*), (void *) &cur
);
152 zend_hash_next_index_insert(Z_ARRVAL_PP(cur
), (void *) &tmp
, sizeof(zval
*), (void *) &cur
);
162 if (zend_hash_num_elements(Z_ARRVAL_P(arr
))) {
164 #if PHP_VERSION_ID >= 50400
165 ZVAL_COPY_VALUE(zv
, arr
);
167 zv
->value
= arr
->value
;
168 Z_TYPE_P(zv
) = Z_TYPE_P(arr
);
176 static inline void shift_key(php_http_buffer_t
*buf
, char *key_str
, size_t key_len
, const char *ass
, size_t asl
, unsigned flags TSRMLS_DC
);
177 static inline void shift_val(php_http_buffer_t
*buf
, zval
*zvalue
, const char *vss
, size_t vsl
, unsigned flags TSRMLS_DC
);
179 static void prepare_dimension(php_http_buffer_t
*buf
, php_http_buffer_t
*keybuf
, zval
*zvalue
, const char *pss
, size_t psl
, const char *vss
, size_t vsl
, unsigned flags TSRMLS_DC
)
181 HashTable
*ht
= HASH_OF(zvalue
);
183 php_http_array_hashkey_t key
= php_http_array_hashkey_init(0);
185 php_http_buffer_t prefix
;
187 if (!ht
->nApplyCount
++) {
188 php_http_buffer_init(&prefix
);
189 php_http_buffer_append(&prefix
, keybuf
->data
, keybuf
->used
);
191 FOREACH_HASH_KEYVAL(pos
, ht
, key
, val
) {
192 if (key
.type
== HASH_KEY_IS_STRING
&& !*key
.str
) {
193 /* only public properties */
197 php_http_buffer_appends(&prefix
, "[");
198 if (key
.type
== HASH_KEY_IS_STRING
) {
199 php_http_buffer_append(&prefix
, key
.str
, key
.len
- 1);
201 php_http_buffer_appendf(&prefix
, "%lu", key
.num
);
203 php_http_buffer_appends(&prefix
, "]");
205 if (Z_TYPE_PP(val
) == IS_ARRAY
|| Z_TYPE_PP(val
) == IS_OBJECT
) {
206 prepare_dimension(buf
, &prefix
, *val
, pss
, psl
, vss
, vsl
, flags TSRMLS_CC
);
208 zval
*cpy
= php_http_ztyp(IS_STRING
, *val
);
210 shift_key(buf
, prefix
.data
, prefix
.used
, pss
, psl
, flags TSRMLS_CC
);
211 shift_val(buf
, cpy
, vss
, vsl
, flags TSRMLS_CC
);
215 php_http_buffer_cut(&prefix
, keybuf
->used
, prefix
.used
- keybuf
->used
);
217 php_http_buffer_dtor(&prefix
);
222 static inline void sanitize_key(unsigned flags
, char *str
, size_t len
, zval
*zv
, zend_bool
*rfc5987 TSRMLS_DC
)
227 php_trim(str
, len
, NULL
, 0, zv
, 3 TSRMLS_CC
);
229 if (flags
& PHP_HTTP_PARAMS_ESCAPED
) {
230 sanitize_escaped(zv TSRMLS_CC
);
233 if (!Z_STRLEN_P(zv
)) {
237 if (flags
& PHP_HTTP_PARAMS_RFC5987
) {
238 eos
= &Z_STRVAL_P(zv
)[Z_STRLEN_P(zv
)-1];
246 if (flags
& PHP_HTTP_PARAMS_URLENCODED
) {
247 sanitize_urlencoded(zv TSRMLS_CC
);
250 if (flags
& PHP_HTTP_PARAMS_DIMENSION
) {
251 sanitize_dimension(zv TSRMLS_CC
);
255 static inline void sanitize_rfc5987(zval
*zv
, char **language
, zend_bool
*latin1 TSRMLS_DC
)
260 * iso-8850-1'de'bl%f6der%20schei%df%21
261 * utf-8'de-DE'bl%c3%b6der%20schei%c3%9f%21
264 switch (Z_STRVAL_P(zv
)[0]) {
267 if (!strncasecmp(Z_STRVAL_P(zv
), "iso-8859-1", lenof("iso-8859-1"))) {
269 ptr
= Z_STRVAL_P(zv
) + lenof("iso-8859-1");
275 if (!strncasecmp(Z_STRVAL_P(zv
), "utf-8", lenof("utf-8"))) {
277 ptr
= Z_STRVAL_P(zv
) + lenof("utf-8");
285 /* extract language */
287 for (*language
= ++ptr
; *ptr
&& *ptr
!= '\''; ++ptr
);
292 *language
= estrndup(*language
, ptr
- *language
);
295 ptr
= estrdup(++ptr
);
297 ZVAL_STRING(zv
, ptr
, 0);
301 static inline void sanitize_rfc5988(char *str
, size_t len
, zval
*zv TSRMLS_DC
)
304 php_trim(str
, len
, " ><", 3, zv
, 3 TSRMLS_CC
);
307 static inline void prepare_rfc5988(zval
*zv TSRMLS_DC
)
309 if (Z_TYPE_P(zv
) != IS_STRING
) {
311 ZVAL_EMPTY_STRING(zv
);
315 static void utf8encode(zval
*zv
)
318 unsigned char *ptr
= (unsigned char *) Z_STRVAL_P(zv
);
321 if (*ptr
++ >= 0x80) {
327 ptr
= safe_emalloc(1, len
, 1);
328 for (len
= 0, pos
= 0; len
<= Z_STRLEN_P(zv
); ++len
, ++pos
) {
329 ptr
[pos
] = Z_STRVAL_P(zv
)[len
];
330 if ((ptr
[pos
]) >= 0x80) {
331 ptr
[pos
+ 1] = 0x80 | (ptr
[pos
] & 0x3f);
332 ptr
[pos
] = 0xc0 | ((ptr
[pos
] >> 6) & 0x1f);
337 ZVAL_STRINGL(zv
, (char *) ptr
, pos
-1, 0);
340 static inline void sanitize_value(unsigned flags
, char *str
, size_t len
, zval
*zv
, zend_bool rfc5987 TSRMLS_DC
)
342 char *language
= NULL
;
343 zend_bool latin1
= 0;
346 php_trim(str
, len
, NULL
, 0, zv
, 3 TSRMLS_CC
);
349 sanitize_rfc5987(zv
, &language
, &latin1 TSRMLS_CC
);
352 if (flags
& PHP_HTTP_PARAMS_ESCAPED
) {
353 sanitize_escaped(zv TSRMLS_CC
);
356 if ((flags
& PHP_HTTP_PARAMS_URLENCODED
) || (rfc5987
&& language
)) {
357 sanitize_urlencoded(zv TSRMLS_CC
);
360 if (rfc5987
&& language
) {
368 ZVAL_COPY_VALUE(tmp
, zv
);
370 add_assoc_zval(zv
, language
, tmp
);
375 static inline void prepare_key(unsigned flags
, char *old_key
, size_t old_len
, char **new_key
, size_t *new_len TSRMLS_DC
)
380 ZVAL_STRINGL(&zv
, old_key
, old_len
, 1);
382 if (flags
& PHP_HTTP_PARAMS_URLENCODED
) {
383 prepare_urlencoded(&zv TSRMLS_CC
);
386 if (flags
& PHP_HTTP_PARAMS_ESCAPED
) {
387 if (flags
& PHP_HTTP_PARAMS_RFC5988
) {
388 prepare_rfc5988(&zv TSRMLS_CC
);
390 prepare_escaped(&zv TSRMLS_CC
);
394 *new_key
= Z_STRVAL(zv
);
395 *new_len
= Z_STRLEN(zv
);
398 static inline void prepare_value(unsigned flags
, zval
*zv TSRMLS_DC
)
400 if (flags
& PHP_HTTP_PARAMS_URLENCODED
) {
401 prepare_urlencoded(zv TSRMLS_CC
);
404 if (flags
& PHP_HTTP_PARAMS_ESCAPED
) {
405 prepare_escaped(zv TSRMLS_CC
);
409 static void merge_param(HashTable
*params
, zval
*zdata
, zval
***current_param
, zval
***current_args TSRMLS_DC
)
411 zval
**ptr
, **zdata_ptr
;
412 php_http_array_hashkey_t hkey
= php_http_array_hashkey_init(0);
417 INIT_PZVAL_ARRAY(&tmp
, params
);
418 fprintf(stderr
, "params = ");
419 zend_print_zval_r(&tmp
, 1 TSRMLS_CC
);
420 fprintf(stderr
, "\n");
424 hkey
.type
= zend_hash_get_current_key_ex(Z_ARRVAL_P(zdata
), &hkey
.str
, &hkey
.len
, &hkey
.num
, hkey
.dup
, NULL
);
426 if ((hkey
.type
== HASH_KEY_IS_STRING
&& !zend_hash_exists(params
, hkey
.str
, hkey
.len
))
427 || (hkey
.type
== HASH_KEY_IS_LONG
&& !zend_hash_index_exists(params
, hkey
.num
))
429 zval
*tmp
, *arg
, **args
;
431 /* create the entry if it doesn't exist */
432 zend_hash_get_current_data(Z_ARRVAL_P(zdata
), (void *) &ptr
);
436 add_assoc_zval_ex(tmp
, ZEND_STRS("value"), *ptr
);
440 zend_hash_update(Z_ARRVAL_P(tmp
), "arguments", sizeof("arguments"), (void *) &arg
, sizeof(zval
*), (void *) &args
);
441 *current_args
= args
;
443 if (hkey
.type
== HASH_KEY_IS_STRING
) {
444 zend_hash_update(params
, hkey
.str
, hkey
.len
, (void *) &tmp
, sizeof(zval
*), (void *) &ptr
);
446 zend_hash_index_update(params
, hkey
.num
, (void *) &tmp
, sizeof(zval
*), (void *) &ptr
);
450 if (hkey
.type
== HASH_KEY_IS_STRING
) {
451 zend_hash_find(params
, hkey
.str
, hkey
.len
, (void *) &ptr
);
453 zend_hash_index_find(params
, hkey
.num
, (void *) &ptr
);
458 if (Z_TYPE_PP(ptr
) == IS_ARRAY
459 && SUCCESS
== zend_hash_find(Z_ARRVAL_PP(ptr
), "value", sizeof("value"), (void *) &ptr
)
460 && SUCCESS
== zend_hash_get_current_data(Z_ARRVAL_PP(zdata_ptr
), (void *) &zdata_ptr
)
463 * params = [arr => [value => [0 => 1]]]
465 * zdata = [arr => [0 => NULL]]
470 while (Z_TYPE_PP(zdata_ptr
) == IS_ARRAY
471 && SUCCESS
== zend_hash_get_current_data(Z_ARRVAL_PP(zdata_ptr
), (void *) &test_ptr
)
473 if (Z_TYPE_PP(test_ptr
) == IS_ARRAY
) {
475 /* now find key in ptr */
476 if (HASH_KEY_IS_STRING
== zend_hash_get_current_key_ex(Z_ARRVAL_PP(zdata_ptr
), &hkey
.str
, &hkey
.len
, &hkey
.num
, hkey
.dup
, NULL
)) {
477 if (SUCCESS
== zend_hash_find(Z_ARRVAL_PP(ptr
), hkey
.str
, hkey
.len
, (void *) &ptr
)) {
478 zdata_ptr
= test_ptr
;
480 Z_ADDREF_PP(test_ptr
);
481 zend_hash_update(Z_ARRVAL_PP(ptr
), hkey
.str
, hkey
.len
, (void *) test_ptr
, sizeof(zval
*), (void *) &ptr
);
485 if (SUCCESS
== zend_hash_index_find(Z_ARRVAL_PP(ptr
), hkey
.num
, (void *) &ptr
)) {
486 zdata_ptr
= test_ptr
;
487 } else if (hkey
.num
) {
488 Z_ADDREF_PP(test_ptr
);
489 zend_hash_index_update(Z_ARRVAL_PP(ptr
), hkey
.num
, (void *) test_ptr
, sizeof(zval
*), (void *) &ptr
);
492 Z_ADDREF_PP(test_ptr
);
493 zend_hash_next_index_insert(Z_ARRVAL_PP(ptr
), (void *) test_ptr
, sizeof(zval
*), (void *) &ptr
);
498 /* this is the leaf */
499 Z_ADDREF_PP(test_ptr
);
500 if (Z_TYPE_PP(ptr
) != IS_ARRAY
) {
504 if (HASH_KEY_IS_STRING
== zend_hash_get_current_key_ex(Z_ARRVAL_PP(zdata_ptr
), &hkey
.str
, &hkey
.len
, &hkey
.num
, hkey
.dup
, NULL
)) {
505 zend_hash_update(Z_ARRVAL_PP(ptr
), hkey
.str
, hkey
.len
, (void *) test_ptr
, sizeof(zval
*), (void *) &ptr
);
506 } else if (hkey
.num
) {
507 zend_hash_index_update(Z_ARRVAL_PP(ptr
), hkey
.num
, (void *) test_ptr
, sizeof(zval
*), (void *) &ptr
);
509 zend_hash_next_index_insert(Z_ARRVAL_PP(ptr
), (void *) test_ptr
, sizeof(zval
*), (void *) &ptr
);
519 while (Z_TYPE_PP(ptr
) == IS_ARRAY
&& SUCCESS
== zend_hash_get_current_data(Z_ARRVAL_PP(ptr
), (void *) &ptr
));
520 *current_param
= ptr
;
523 static void push_param(HashTable
*params
, php_http_params_state_t
*state
, const php_http_params_opts_t
*opts TSRMLS_DC
)
525 if (state
->val
.str
) {
526 if (0 < (state
->val
.len
= state
->input
.str
- state
->val
.str
)) {
527 sanitize_value(opts
->flags
, state
->val
.str
, state
->val
.len
, *(state
->current
.val
), state
->rfc5987 TSRMLS_CC
);
529 ZVAL_EMPTY_STRING(*(state
->current
.val
));
532 } else if (state
->arg
.str
) {
533 if (0 < (state
->arg
.len
= state
->input
.str
- state
->arg
.str
)) {
535 zend_bool rfc5987
= 0;
539 sanitize_key(opts
->flags
, state
->arg
.str
, state
->arg
.len
, &key
, &rfc5987 TSRMLS_CC
);
540 state
->rfc5987
= rfc5987
;
541 if (Z_TYPE(key
) == IS_STRING
&& Z_STRLEN(key
)) {
548 if (SUCCESS
== zend_hash_find(Z_ARRVAL_PP(state
->current
.args
), ZEND_STRS("*rfc5987*"), (void *) &rfc
)) {
549 zend_symtable_update(Z_ARRVAL_PP(rfc
), Z_STRVAL(key
), Z_STRLEN(key
) + 1, (void *) &val
, sizeof(zval
*), (void *) &state
->current
.val
);
554 array_init_size(tmp
, 1);
555 zend_symtable_update(Z_ARRVAL_P(tmp
), Z_STRVAL(key
), Z_STRLEN(key
) + 1, (void *) &val
, sizeof(zval
*), (void *) &state
->current
.val
);
556 zend_symtable_update(Z_ARRVAL_PP(state
->current
.args
), ZEND_STRS("*rfc5987*"), (void *) &tmp
, sizeof(zval
*), NULL
);
559 zend_symtable_update(Z_ARRVAL_PP(state
->current
.args
), Z_STRVAL(key
), Z_STRLEN(key
) + 1, (void *) &val
, sizeof(zval
*), (void *) &state
->current
.val
);
564 } else if (state
->param
.str
) {
565 if (0 < (state
->param
.len
= state
->input
.str
- state
->param
.str
)) {
566 zval
*prm
, *arg
, *val
, *key
;
567 zend_bool rfc5987
= 0;
571 if (opts
->flags
& PHP_HTTP_PARAMS_RFC5988
) {
572 sanitize_rfc5988(state
->param
.str
, state
->param
.len
, key TSRMLS_CC
);
574 sanitize_key(opts
->flags
, state
->param
.str
, state
->param
.len
, key
, &rfc5987 TSRMLS_CC
);
575 state
->rfc5987
= rfc5987
;
577 if (Z_TYPE_P(key
) != IS_STRING
) {
578 merge_param(params
, key
, &state
->current
.val
, &state
->current
.args TSRMLS_CC
);
579 } else if (Z_STRLEN_P(key
)) {
581 array_init_size(prm
, 2);
585 ZVAL_COPY_VALUE(val
, opts
->defval
);
590 if (rfc5987
&& (opts
->flags
& PHP_HTTP_PARAMS_RFC5987
)) {
591 zend_hash_update(Z_ARRVAL_P(prm
), "*rfc5987*", sizeof("*rfc5987*"), (void *) &val
, sizeof(zval
*), (void *) &state
->current
.val
);
593 zend_hash_update(Z_ARRVAL_P(prm
), "value", sizeof("value"), (void *) &val
, sizeof(zval
*), (void *) &state
->current
.val
);
597 array_init_size(arg
, 3);
598 zend_hash_update(Z_ARRVAL_P(prm
), "arguments", sizeof("arguments"), (void *) &arg
, sizeof(zval
*), (void *) &state
->current
.args
);
600 zend_symtable_update(params
, Z_STRVAL_P(key
), Z_STRLEN_P(key
) + 1, (void *) &prm
, sizeof(zval
*), (void *) &state
->current
.param
);
607 static inline zend_bool
check_str(const char *chk_str
, size_t chk_len
, const char *sep_str
, size_t sep_len
) {
608 return 0 < sep_len
&& chk_len
>= sep_len
&& *chk_str
== *sep_str
&& !memcmp(chk_str
+ 1, sep_str
+ 1, sep_len
- 1);
611 static size_t check_sep(php_http_params_state_t
*state
, php_http_params_token_t
**separators
)
613 php_http_params_token_t
**sep
= separators
;
615 if (state
->quotes
|| state
->escape
) {
619 if (sep
) while (*sep
) {
620 if (check_str(state
->input
.str
, state
->input
.len
, (*sep
)->str
, (*sep
)->len
)) {
628 static void skip_sep(size_t skip
, php_http_params_state_t
*state
, php_http_params_token_t
**param
, php_http_params_token_t
**arg
, php_http_params_token_t
**val TSRMLS_DC
)
632 state
->input
.str
+= skip
;
633 state
->input
.len
-= skip
;
635 while ( (param
&& (sep_len
= check_sep(state
, param
)))
636 || (arg
&& (sep_len
= check_sep(state
, arg
)))
637 || (val
&& (sep_len
= check_sep(state
, val
)))
639 state
->input
.str
+= sep_len
;
640 state
->input
.len
-= sep_len
;
644 HashTable
*php_http_params_parse(HashTable
*params
, const php_http_params_opts_t
*opts TSRMLS_DC
)
646 php_http_params_state_t state
= {{NULL
,0}, {NULL
,0}, {NULL
,0}, {NULL
,0}, {NULL
,NULL
,NULL
}, 0, 0};
648 state
.input
.str
= opts
->input
.str
;
649 state
.input
.len
= opts
->input
.len
;
652 ALLOC_HASHTABLE(params
);
653 ZEND_INIT_SYMTABLE(params
);
656 while (state
.input
.len
) {
657 if ((opts
->flags
& PHP_HTTP_PARAMS_RFC5988
) && !state
.arg
.str
) {
658 if (*state
.input
.str
== '<') {
660 } else if (*state
.input
.str
== '>') {
663 } else if (*state
.input
.str
== '"' && !state
.escape
) {
664 state
.quotes
= !state
.quotes
;
666 state
.escape
= (*state
.input
.str
== '\\');
669 if (!state
.param
.str
) {
671 skip_sep(0, &state
, opts
->param
, opts
->arg
, opts
->val TSRMLS_CC
);
672 state
.param
.str
= state
.input
.str
;
675 /* are we at a param separator? */
676 if (0 < (sep_len
= check_sep(&state
, opts
->param
))) {
677 push_param(params
, &state
, opts TSRMLS_CC
);
679 skip_sep(sep_len
, &state
, opts
->param
, opts
->arg
, opts
->val TSRMLS_CC
);
681 /* start off with a new param */
682 state
.param
.str
= state
.input
.str
;
684 state
.arg
.str
= NULL
;
686 state
.val
.str
= NULL
;
692 /* are we at an arg separator? */
693 if (0 < (sep_len
= check_sep(&state
, opts
->arg
))) {
694 push_param(params
, &state
, opts TSRMLS_CC
);
696 skip_sep(sep_len
, &state
, NULL
, opts
->arg
, opts
->val TSRMLS_CC
);
698 /* continue with a new arg */
699 state
.arg
.str
= state
.input
.str
;
701 state
.val
.str
= NULL
;
707 /* are we at a val separator? */
708 if (0 < (sep_len
= check_sep(&state
, opts
->val
))) {
709 /* only handle separator if we're not already reading in a val */
710 if (!state
.val
.str
) {
711 push_param(params
, &state
, opts TSRMLS_CC
);
713 skip_sep(sep_len
, &state
, NULL
, NULL
, opts
->val TSRMLS_CC
);
715 state
.val
.str
= state
.input
.str
;
723 if (state
.input
.len
) {
729 push_param(params
, &state
, opts TSRMLS_CC
);
734 static inline void shift_key(php_http_buffer_t
*buf
, char *key_str
, size_t key_len
, const char *ass
, size_t asl
, unsigned flags TSRMLS_DC
)
740 php_http_buffer_append(buf
, ass
, asl
);
743 prepare_key(flags
, key_str
, key_len
, &str
, &len TSRMLS_CC
);
744 php_http_buffer_append(buf
, str
, len
);
748 static inline void shift_rfc5987(php_http_buffer_t
*buf
, zval
*zvalue
, const char *vss
, size_t vsl
, unsigned flags TSRMLS_DC
)
750 HashTable
*ht
= HASH_OF(zvalue
);
752 php_http_array_hashkey_t key
= php_http_array_hashkey_init(0);
754 if (SUCCESS
== zend_hash_get_current_data(ht
, (void *) &zdata
)
755 && HASH_KEY_NON_EXISTENT
!= (key
.type
= zend_hash_get_current_key_ex(ht
, &key
.str
, &key
.len
, &key
.num
, key
.dup
, NULL
))
757 php_http_array_hashkey_stringify(&key
);
758 php_http_buffer_appendf(buf
, "*%.*sutf-8'%.*s'",
759 (int) (vsl
> INT_MAX
? INT_MAX
: vsl
), vss
,
760 (int) (key
.len
> INT_MAX
? INT_MAX
: key
.len
), key
.str
);
761 php_http_array_hashkey_stringfree(&key
);
763 tmp
= php_http_zsep(1, IS_STRING
, *zdata
);
764 prepare_value(flags
| PHP_HTTP_PARAMS_URLENCODED
, tmp TSRMLS_CC
);
765 php_http_buffer_append(buf
, Z_STRVAL_P(tmp
), Z_STRLEN_P(tmp
));
770 static inline void shift_rfc5988(php_http_buffer_t
*buf
, char *key_str
, size_t key_len
, const char *ass
, size_t asl
, unsigned flags TSRMLS_DC
)
776 php_http_buffer_append(buf
, ass
, asl
);
779 prepare_key(flags
, key_str
, key_len
, &str
, &len TSRMLS_CC
);
780 php_http_buffer_appends(buf
, "<");
781 php_http_buffer_append(buf
, str
, len
);
782 php_http_buffer_appends(buf
, ">");
786 static inline void shift_rfc5988_val(php_http_buffer_t
*buf
, zval
*zv
, const char *vss
, size_t vsl
, unsigned flags TSRMLS_DC
)
788 zval
*tmp
= php_http_zsep(1, IS_STRING
, zv
);
790 quote_string(tmp
, 1 TSRMLS_CC
);
791 php_http_buffer_append(buf
, vss
, vsl
);
792 php_http_buffer_append(buf
, Z_STRVAL_P(tmp
), Z_STRLEN_P(tmp
));
797 static inline void shift_val(php_http_buffer_t
*buf
, zval
*zvalue
, const char *vss
, size_t vsl
, unsigned flags TSRMLS_DC
)
799 if (Z_TYPE_P(zvalue
) != IS_BOOL
) {
800 zval
*tmp
= php_http_zsep(1, IS_STRING
, zvalue
);
802 prepare_value(flags
, tmp TSRMLS_CC
);
803 php_http_buffer_append(buf
, vss
, vsl
);
804 php_http_buffer_append(buf
, Z_STRVAL_P(tmp
), Z_STRLEN_P(tmp
));
807 } else if (!Z_BVAL_P(zvalue
)) {
808 php_http_buffer_append(buf
, vss
, vsl
);
809 php_http_buffer_appends(buf
, "0");
813 static void shift_arg(php_http_buffer_t
*buf
, char *key_str
, size_t key_len
, zval
*zvalue
, const char *ass
, size_t asl
, const char *vss
, size_t vsl
, unsigned flags TSRMLS_DC
)
815 if (Z_TYPE_P(zvalue
) == IS_ARRAY
|| Z_TYPE_P(zvalue
) == IS_OBJECT
) {
817 php_http_array_hashkey_t key
= php_http_array_hashkey_init(0);
819 zend_bool rfc5987
= !strcmp(key_str
, "*rfc5987*");
822 shift_key(buf
, key_str
, key_len
, ass
, asl
, flags TSRMLS_CC
);
824 FOREACH_KEYVAL(pos
, zvalue
, key
, val
) {
825 /* did you mean recursion? */
826 php_http_array_hashkey_stringify(&key
);
827 if (rfc5987
&& (Z_TYPE_PP(val
) == IS_ARRAY
|| Z_TYPE_PP(val
) == IS_OBJECT
)) {
828 shift_key(buf
, key
.str
, key
.len
-1, ass
, asl
, flags TSRMLS_CC
);
829 shift_rfc5987(buf
, *val
, vss
, vsl
, flags TSRMLS_CC
);
831 shift_arg(buf
, key
.str
, key
.len
-1, *val
, ass
, asl
, vss
, vsl
, flags TSRMLS_CC
);
833 php_http_array_hashkey_stringfree(&key
);
836 shift_key(buf
, key_str
, key_len
, ass
, asl
, flags TSRMLS_CC
);
838 if (flags
& PHP_HTTP_PARAMS_RFC5988
) {
842 case lenof("anchor"):
843 /* some args must be quoted */
844 if (0 <= php_http_select_str(key_str
, 3, "rel", "title", "anchor")) {
845 shift_rfc5988_val(buf
, zvalue
, vss
, vsl
, flags TSRMLS_CC
);
852 shift_val(buf
, zvalue
, vss
, vsl
, flags TSRMLS_CC
);
856 static void shift_param(php_http_buffer_t
*buf
, char *key_str
, size_t key_len
, zval
*zvalue
, const char *pss
, size_t psl
, const char *ass
, size_t asl
, const char *vss
, size_t vsl
, unsigned flags
, zend_bool rfc5987 TSRMLS_DC
)
858 if (Z_TYPE_P(zvalue
) == IS_ARRAY
|| Z_TYPE_P(zvalue
) == IS_OBJECT
) {
859 /* treat as arguments, unless we care for dimensions or rfc5987 */
860 if (flags
& PHP_HTTP_PARAMS_DIMENSION
) {
861 php_http_buffer_t
*keybuf
= php_http_buffer_from_string(key_str
, key_len
);
862 prepare_dimension(buf
, keybuf
, zvalue
, pss
, psl
, vss
, vsl
, flags TSRMLS_CC
);
863 php_http_buffer_free(&keybuf
);
864 } else if (rfc5987
) {
865 shift_key(buf
, key_str
, key_len
, pss
, psl
, flags TSRMLS_CC
);
866 shift_rfc5987(buf
, zvalue
, vss
, vsl
, flags TSRMLS_CC
);
868 shift_arg(buf
, key_str
, key_len
, zvalue
, ass
, asl
, vss
, vsl
, flags TSRMLS_CC
);
871 if (flags
& PHP_HTTP_PARAMS_RFC5988
) {
872 shift_rfc5988(buf
, key_str
, key_len
, pss
, psl
, flags TSRMLS_CC
);
874 shift_key(buf
, key_str
, key_len
, pss
, psl
, flags TSRMLS_CC
);
876 shift_val(buf
, zvalue
, vss
, vsl
, flags TSRMLS_CC
);
880 php_http_buffer_t
*php_http_params_to_string(php_http_buffer_t
*buf
, HashTable
*params
, const char *pss
, size_t psl
, const char *ass
, size_t asl
, const char *vss
, size_t vsl
, unsigned flags TSRMLS_DC
)
883 HashPosition pos
, pos1
;
884 php_http_array_hashkey_t key
= php_http_array_hashkey_init(0), key1
= php_http_array_hashkey_init(0);
885 zend_bool rfc5987
= 0;
888 buf
= php_http_buffer_init(NULL
);
891 FOREACH_HASH_KEYVAL(pos
, params
, key
, zparam
) {
892 zval
**zvalue
, **zargs
;
894 if (Z_TYPE_PP(zparam
) != IS_ARRAY
) {
897 if (SUCCESS
!= zend_hash_find(Z_ARRVAL_PP(zparam
), ZEND_STRS("value"), (void *) &zvalue
)) {
898 if (SUCCESS
!= zend_hash_find(Z_ARRVAL_PP(zparam
), ZEND_STRS("*rfc5987*"), (void *) &zvalue
)) {
906 php_http_array_hashkey_stringify(&key
);
907 shift_param(buf
, key
.str
, key
.len
- 1, *zvalue
, pss
, psl
, ass
, asl
, vss
, vsl
, flags
, rfc5987 TSRMLS_CC
);
908 php_http_array_hashkey_stringfree(&key
);
910 if (Z_TYPE_PP(zparam
) == IS_ARRAY
&& SUCCESS
!= zend_hash_find(Z_ARRVAL_PP(zparam
), ZEND_STRS("arguments"), (void *) &zvalue
)) {
911 if (zvalue
== zparam
) {
917 if (Z_TYPE_PP(zvalue
) == IS_ARRAY
) {
918 FOREACH_KEYVAL(pos1
, *zvalue
, key1
, zargs
) {
919 if (zvalue
== zparam
&& key1
.type
== HASH_KEY_IS_STRING
&& !strcmp(key1
.str
, "value")) {
923 php_http_array_hashkey_stringify(&key1
);
924 shift_arg(buf
, key1
.str
, key1
.len
- 1, *zargs
, ass
, asl
, vss
, vsl
, flags TSRMLS_CC
);
925 php_http_array_hashkey_stringfree(&key1
);
930 php_http_buffer_shrink(buf
);
931 php_http_buffer_fix(buf
);
936 php_http_params_token_t
**php_http_params_separator_init(zval
*zv TSRMLS_DC
)
940 php_http_params_token_t
**ret
, **tmp
;
946 zv
= php_http_ztyp(IS_ARRAY
, zv
);
947 ret
= ecalloc(zend_hash_num_elements(Z_ARRVAL_P(zv
)) + 1, sizeof(*ret
));
950 FOREACH_VAL(pos
, zv
, sep
) {
951 zval
*zt
= php_http_ztyp(IS_STRING
, *sep
);
953 if (Z_STRLEN_P(zt
)) {
954 *tmp
= emalloc(sizeof(**tmp
));
955 (*tmp
)->str
= estrndup(Z_STRVAL_P(zt
), (*tmp
)->len
= Z_STRLEN_P(zt
));
966 void php_http_params_separator_free(php_http_params_token_t
**separator
)
968 php_http_params_token_t
**sep
= separator
;
971 PTR_FREE((*sep
)->str
);
979 ZEND_BEGIN_ARG_INFO_EX(ai_HttpParams___construct
, 0, 0, 0)
980 ZEND_ARG_INFO(0, params
)
981 ZEND_ARG_INFO(0, param_sep
)
982 ZEND_ARG_INFO(0, arg_sep
)
983 ZEND_ARG_INFO(0, val_sep
)
984 ZEND_ARG_INFO(0, flags
)
986 PHP_METHOD(HttpParams
, __construct
)
988 zval
*zcopy
, *zparams
= NULL
, *param_sep
= NULL
, *arg_sep
= NULL
, *val_sep
= NULL
;
989 long flags
= PHP_HTTP_PARAMS_DEFAULT
;
990 zend_error_handling zeh
;
992 php_http_expect(SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "|z!/z/z/z/l", &zparams
, ¶m_sep
, &arg_sep
, &val_sep
, &flags
), invalid_arg
, return);
994 zend_replace_error_handling(EH_THROW
, php_http_exception_runtime_class_entry
, &zeh TSRMLS_CC
);
996 switch (ZEND_NUM_ARGS()) {
998 zend_update_property_long(php_http_params_class_entry
, getThis(), ZEND_STRL("flags"), flags TSRMLS_CC
);
1001 zend_update_property(php_http_params_class_entry
, getThis(), ZEND_STRL("val_sep"), val_sep TSRMLS_CC
);
1004 zend_update_property(php_http_params_class_entry
, getThis(), ZEND_STRL("arg_sep"), arg_sep TSRMLS_CC
);
1007 zend_update_property(php_http_params_class_entry
, getThis(), ZEND_STRL("param_sep"), param_sep TSRMLS_CC
);
1012 switch (Z_TYPE_P(zparams
)) {
1015 zcopy
= php_http_zsep(1, IS_ARRAY
, zparams
);
1016 zend_update_property(php_http_params_class_entry
, getThis(), ZEND_STRL("params"), zcopy TSRMLS_CC
);
1017 zval_ptr_dtor(&zcopy
);
1020 zcopy
= php_http_ztyp(IS_STRING
, zparams
);
1021 if (Z_STRLEN_P(zcopy
)) {
1022 php_http_params_opts_t opts
= {
1023 {Z_STRVAL_P(zcopy
), Z_STRLEN_P(zcopy
)},
1024 php_http_params_separator_init(zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("param_sep"), 0 TSRMLS_CC
) TSRMLS_CC
),
1025 php_http_params_separator_init(zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("arg_sep"), 0 TSRMLS_CC
) TSRMLS_CC
),
1026 php_http_params_separator_init(zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("val_sep"), 0 TSRMLS_CC
) TSRMLS_CC
),
1030 MAKE_STD_ZVAL(zparams
);
1031 array_init(zparams
);
1032 php_http_params_parse(Z_ARRVAL_P(zparams
), &opts TSRMLS_CC
);
1033 zend_update_property(php_http_params_class_entry
, getThis(), ZEND_STRL("params"), zparams TSRMLS_CC
);
1034 zval_ptr_dtor(&zparams
);
1036 php_http_params_separator_free(opts
.param
);
1037 php_http_params_separator_free(opts
.arg
);
1038 php_http_params_separator_free(opts
.val
);
1040 zval_ptr_dtor(&zcopy
);
1044 MAKE_STD_ZVAL(zparams
);
1045 array_init(zparams
);
1046 zend_update_property(php_http_params_class_entry
, getThis(), ZEND_STRL("params"), zparams TSRMLS_CC
);
1047 zval_ptr_dtor(&zparams
);
1050 zend_restore_error_handling(&zeh TSRMLS_CC
);
1053 ZEND_BEGIN_ARG_INFO_EX(ai_HttpParams_toArray
, 0, 0, 0)
1054 ZEND_END_ARG_INFO();
1055 PHP_METHOD(HttpParams
, toArray
)
1059 if (SUCCESS
!= zend_parse_parameters_none()) {
1062 zparams
= zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC
);
1063 RETURN_ZVAL(zparams
, 1, 0);
1066 ZEND_BEGIN_ARG_INFO_EX(ai_HttpParams_toString
, 0, 0, 0)
1067 ZEND_END_ARG_INFO();
1068 PHP_METHOD(HttpParams
, toString
)
1070 zval
**tmp
, *zparams
, *zpsep
, *zasep
, *zvsep
, *zflags
;
1071 php_http_buffer_t buf
;
1073 zparams
= php_http_zsep(1, IS_ARRAY
, zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC
));
1074 zflags
= php_http_ztyp(IS_LONG
, zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("flags"), 0 TSRMLS_CC
));
1076 zpsep
= zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("param_sep"), 0 TSRMLS_CC
);
1077 if (Z_TYPE_P(zpsep
) == IS_ARRAY
&& SUCCESS
== zend_hash_get_current_data(Z_ARRVAL_P(zpsep
), (void *) &tmp
)) {
1078 zpsep
= php_http_ztyp(IS_STRING
, *tmp
);
1080 zpsep
= php_http_ztyp(IS_STRING
, zpsep
);
1082 zasep
= zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("arg_sep"), 0 TSRMLS_CC
);
1083 if (Z_TYPE_P(zasep
) == IS_ARRAY
&& SUCCESS
== zend_hash_get_current_data(Z_ARRVAL_P(zasep
), (void *) &tmp
)) {
1084 zasep
= php_http_ztyp(IS_STRING
, *tmp
);
1086 zasep
= php_http_ztyp(IS_STRING
, zasep
);
1088 zvsep
= zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("val_sep"), 0 TSRMLS_CC
);
1089 if (Z_TYPE_P(zvsep
) == IS_ARRAY
&& SUCCESS
== zend_hash_get_current_data(Z_ARRVAL_P(zvsep
), (void *) &tmp
)) {
1090 zvsep
= php_http_ztyp(IS_STRING
, *tmp
);
1092 zvsep
= php_http_ztyp(IS_STRING
, zvsep
);
1095 php_http_buffer_init(&buf
);
1096 php_http_params_to_string(&buf
, Z_ARRVAL_P(zparams
), Z_STRVAL_P(zpsep
), Z_STRLEN_P(zpsep
), Z_STRVAL_P(zasep
), Z_STRLEN_P(zasep
), Z_STRVAL_P(zvsep
), Z_STRLEN_P(zvsep
), Z_LVAL_P(zflags
) TSRMLS_CC
);
1098 zval_ptr_dtor(&zparams
);
1099 zval_ptr_dtor(&zpsep
);
1100 zval_ptr_dtor(&zasep
);
1101 zval_ptr_dtor(&zvsep
);
1102 zval_ptr_dtor(&zflags
);
1104 RETVAL_PHP_HTTP_BUFFER_VAL(&buf
);
1107 ZEND_BEGIN_ARG_INFO_EX(ai_HttpParams_offsetExists
, 0, 0, 1)
1108 ZEND_ARG_INFO(0, name
)
1109 ZEND_END_ARG_INFO();
1110 PHP_METHOD(HttpParams
, offsetExists
)
1114 zval
**zparam
, *zparams
;
1116 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &name_str
, &name_len
)) {
1120 zparams
= php_http_ztyp(IS_ARRAY
, zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC
));
1122 if (SUCCESS
== zend_symtable_find(Z_ARRVAL_P(zparams
), name_str
, name_len
+ 1, (void *) &zparam
)) {
1123 RETVAL_BOOL(Z_TYPE_PP(zparam
) != IS_NULL
);
1127 zval_ptr_dtor(&zparams
);
1130 ZEND_BEGIN_ARG_INFO_EX(ai_HttpParams_offsetGet
, 0, 0, 1)
1131 ZEND_ARG_INFO(0, name
)
1132 ZEND_END_ARG_INFO();
1133 PHP_METHOD(HttpParams
, offsetGet
)
1137 zval
**zparam
, *zparams
;
1139 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &name_str
, &name_len
)) {
1143 zparams
= php_http_ztyp(IS_ARRAY
, zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC
));
1145 if (SUCCESS
== zend_symtable_find(Z_ARRVAL_P(zparams
), name_str
, name_len
+ 1, (void *) &zparam
)) {
1146 RETVAL_ZVAL(*zparam
, 1, 0);
1149 zval_ptr_dtor(&zparams
);
1152 ZEND_BEGIN_ARG_INFO_EX(ai_HttpParams_offsetUnset
, 0, 0, 1)
1153 ZEND_ARG_INFO(0, name
)
1154 ZEND_END_ARG_INFO();
1155 PHP_METHOD(HttpParams
, offsetUnset
)
1161 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &name_str
, &name_len
)) {
1165 zparams
= php_http_zsep(1, IS_ARRAY
, zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC
));
1167 zend_symtable_del(Z_ARRVAL_P(zparams
), name_str
, name_len
+ 1);
1168 zend_update_property(php_http_params_class_entry
, getThis(), ZEND_STRL("params"), zparams TSRMLS_CC
);
1170 zval_ptr_dtor(&zparams
);
1173 ZEND_BEGIN_ARG_INFO_EX(ai_HttpParams_offsetSet
, 0, 0, 2)
1174 ZEND_ARG_INFO(0, name
)
1175 ZEND_ARG_INFO(0, value
)
1176 ZEND_END_ARG_INFO();
1177 PHP_METHOD(HttpParams
, offsetSet
)
1182 zval
**zparam
, *zparams
;
1184 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "sz", &name_str
, &name_len
, &nvalue
)) {
1188 zparams
= php_http_zsep(1, IS_ARRAY
, zend_read_property(php_http_params_class_entry
, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC
));
1191 if (Z_TYPE_P(nvalue
) == IS_ARRAY
) {
1194 if (SUCCESS
== zend_symtable_find(Z_ARRVAL_P(zparams
), name_str
, name_len
+ 1, (void *) &zparam
)) {
1195 new_zparam
= php_http_zsep(1, IS_ARRAY
, *zparam
);
1196 array_join(Z_ARRVAL_P(nvalue
), Z_ARRVAL_P(new_zparam
), 0, 0);
1198 new_zparam
= nvalue
;
1199 Z_ADDREF_P(new_zparam
);
1201 add_assoc_zval_ex(zparams
, name_str
, name_len
+ 1, new_zparam
);
1205 if (SUCCESS
== zend_symtable_find(Z_ARRVAL_P(zparams
), name_str
, name_len
+ 1, (void *) &zparam
)) {
1206 tmp
= php_http_zsep(1, IS_ARRAY
, *zparam
);
1213 add_assoc_zval_ex(tmp
, ZEND_STRS("value"), nvalue
);
1214 add_assoc_zval_ex(zparams
, name_str
, name_len
+ 1, tmp
);
1217 zval
*tmp
= php_http_ztyp(IS_STRING
, nvalue
), *arr
;
1221 add_assoc_bool_ex(arr
, ZEND_STRS("value"), 1);
1222 add_assoc_zval_ex(zparams
, Z_STRVAL_P(tmp
), Z_STRLEN_P(tmp
) + 1, arr
);
1223 zval_ptr_dtor(&tmp
);
1226 zend_update_property(php_http_params_class_entry
, getThis(), ZEND_STRL("params"), zparams TSRMLS_CC
);
1227 zval_ptr_dtor(&zparams
);
1230 static zend_function_entry php_http_params_methods
[] = {
1231 PHP_ME(HttpParams
, __construct
, ai_HttpParams___construct
, ZEND_ACC_PUBLIC
|ZEND_ACC_CTOR
|ZEND_ACC_FINAL
)
1233 PHP_ME(HttpParams
, toArray
, ai_HttpParams_toArray
, ZEND_ACC_PUBLIC
)
1234 PHP_ME(HttpParams
, toString
, ai_HttpParams_toString
, ZEND_ACC_PUBLIC
)
1235 ZEND_MALIAS(HttpParams
, __toString
, toString
, ai_HttpParams_toString
, ZEND_ACC_PUBLIC
)
1237 PHP_ME(HttpParams
, offsetExists
, ai_HttpParams_offsetExists
, ZEND_ACC_PUBLIC
)
1238 PHP_ME(HttpParams
, offsetUnset
, ai_HttpParams_offsetUnset
, ZEND_ACC_PUBLIC
)
1239 PHP_ME(HttpParams
, offsetSet
, ai_HttpParams_offsetSet
, ZEND_ACC_PUBLIC
)
1240 PHP_ME(HttpParams
, offsetGet
, ai_HttpParams_offsetGet
, ZEND_ACC_PUBLIC
)
1242 EMPTY_FUNCTION_ENTRY
1245 zend_class_entry
*php_http_params_class_entry
;
1247 PHP_MINIT_FUNCTION(http_params
)
1249 zend_class_entry ce
= {0};
1251 INIT_NS_CLASS_ENTRY(ce
, "http", "Params", php_http_params_methods
);
1252 php_http_params_class_entry
= zend_register_internal_class(&ce TSRMLS_CC
);
1253 php_http_params_class_entry
->create_object
= php_http_params_object_new
;
1254 zend_class_implements(php_http_params_class_entry TSRMLS_CC
, 1, zend_ce_arrayaccess
);
1256 zend_declare_class_constant_stringl(php_http_params_class_entry
, ZEND_STRL("DEF_PARAM_SEP"), ZEND_STRL(",") TSRMLS_CC
);
1257 zend_declare_class_constant_stringl(php_http_params_class_entry
, ZEND_STRL("DEF_ARG_SEP"), ZEND_STRL(";") TSRMLS_CC
);
1258 zend_declare_class_constant_stringl(php_http_params_class_entry
, ZEND_STRL("DEF_VAL_SEP"), ZEND_STRL("=") TSRMLS_CC
);
1259 zend_declare_class_constant_stringl(php_http_params_class_entry
, ZEND_STRL("COOKIE_PARAM_SEP"), ZEND_STRL("") TSRMLS_CC
);
1261 zend_declare_class_constant_long(php_http_params_class_entry
, ZEND_STRL("PARSE_RAW"), PHP_HTTP_PARAMS_RAW TSRMLS_CC
);
1262 zend_declare_class_constant_long(php_http_params_class_entry
, ZEND_STRL("PARSE_ESCAPED"), PHP_HTTP_PARAMS_ESCAPED TSRMLS_CC
);
1263 zend_declare_class_constant_long(php_http_params_class_entry
, ZEND_STRL("PARSE_URLENCODED"), PHP_HTTP_PARAMS_URLENCODED TSRMLS_CC
);
1264 zend_declare_class_constant_long(php_http_params_class_entry
, ZEND_STRL("PARSE_DIMENSION"), PHP_HTTP_PARAMS_DIMENSION TSRMLS_CC
);
1265 zend_declare_class_constant_long(php_http_params_class_entry
, ZEND_STRL("PARSE_RFC5987"), PHP_HTTP_PARAMS_RFC5987 TSRMLS_CC
);
1266 zend_declare_class_constant_long(php_http_params_class_entry
, ZEND_STRL("PARSE_RFC5988"), PHP_HTTP_PARAMS_RFC5988 TSRMLS_CC
);
1267 zend_declare_class_constant_long(php_http_params_class_entry
, ZEND_STRL("PARSE_DEFAULT"), PHP_HTTP_PARAMS_DEFAULT TSRMLS_CC
);
1268 zend_declare_class_constant_long(php_http_params_class_entry
, ZEND_STRL("PARSE_QUERY"), PHP_HTTP_PARAMS_QUERY TSRMLS_CC
);
1270 zend_declare_property_null(php_http_params_class_entry
, ZEND_STRL("params"), ZEND_ACC_PUBLIC TSRMLS_CC
);
1271 zend_declare_property_stringl(php_http_params_class_entry
, ZEND_STRL("param_sep"), ZEND_STRL(","), ZEND_ACC_PUBLIC TSRMLS_CC
);
1272 zend_declare_property_stringl(php_http_params_class_entry
, ZEND_STRL("arg_sep"), ZEND_STRL(";"), ZEND_ACC_PUBLIC TSRMLS_CC
);
1273 zend_declare_property_stringl(php_http_params_class_entry
, ZEND_STRL("val_sep"), ZEND_STRL("="), ZEND_ACC_PUBLIC TSRMLS_CC
);
1274 zend_declare_property_long(php_http_params_class_entry
, ZEND_STRL("flags"), PHP_HTTP_PARAMS_DEFAULT
, ZEND_ACC_PUBLIC TSRMLS_CC
);
1284 * vim600: noet sw=4 ts=4 fdm=marker
1285 * vim<600: noet sw=4 ts=4