projects / m6w6 / ext-http / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
flush WIP
[m6w6/ext-http] / php_http_querystring.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-2014, Michael Wallner <mike@php.net> |
10 +--------------------------------------------------------------------+
11 */
12
13 #include "php_http_api.h"
14
15 #include <php_variables.h>
16 #include <ext/spl/spl_array.h>
17
18 #ifdef PHP_HTTP_HAVE_ICONV
19 # undef PHP_ATOM_INC
20 # include <ext/iconv/php_iconv.h>
21 #endif
22
23 #define QS_MERGE 1
24
25 static inline void php_http_querystring_set(zval *instance, zval *params, int flags)
26 {
27 zval qa;
28
29 array_init(&qa);
30
31 if (flags & QS_MERGE) {
32 zval *old = zend_read_property(php_http_querystring_class_entry, instance, ZEND_STRL("queryArray"), 0);
33
34 ZVAL_DEREF(old);
35 if (Z_TYPE_P(old) == IS_ARRAY) {
36 array_copy(Z_ARRVAL_P(old), Z_ARRVAL(qa));
37 }
38 }
39
40 php_http_querystring_update(&qa, params, NULL);
41 zend_update_property(php_http_querystring_class_entry, instance, ZEND_STRL("queryArray"), &qa);
42 }
43
44 static inline void php_http_querystring_str(zval *instance, zval *return_value)
45 {
46 zval *qa = zend_read_property(php_http_querystring_class_entry, instance, ZEND_STRL("queryArray"), 0);
47
48 ZVAL_DEREF(qa);
49 if (Z_TYPE_P(qa) == IS_ARRAY) {
50 php_http_querystring_update(qa, NULL, return_value);
51 } else {
52 RETURN_EMPTY_STRING();
53 }
54 }
55
56 static inline void php_http_querystring_get(zval *instance, int type, char *name, uint name_len, zval *defval, zend_bool del, zval *return_value TSRMLS_DC)
57 {
58 zval *arrval, *qarray = zend_read_property(php_http_querystring_class_entry, instance, ZEND_STRL("queryArray"), 0 TSRMLS_CC);
59
60 ZVAL_DEREF(qarray);
61 if ((Z_TYPE_P(qarray) == IS_ARRAY) && (arrval = zend_symtable_str_find(Z_ARRVAL_P(qarray), name, name_len))) {
62 if (type && type != Z_TYPE_P(arrval)) {
63 SEPARATE_ZVAL(arrval);
64 convert_to_explicit_type(arrval, type);
65 RETVAL_ZVAL(arrval, 1, 1);
66 } else {
67 RETVAL_ZVAL_FAST(arrval);
68 }
69
70 if (del) {
71 zval delarr;
72
73 array_init(&delarr);
74 add_assoc_null_ex(&delarr, name, name_len);
75 php_http_querystring_set(instance, &delarr, QS_MERGE);
76 zval_ptr_dtor(&delarr);
77 }
78 } else if(defval) {
79 RETURN_ZVAL_FAST(defval);
80 }
81 }
82
83 #ifdef PHP_HTTP_HAVE_ICONV
84 ZEND_RESULT_CODE php_http_querystring_xlate(zval *dst, zval *src, const char *ie, const char *oe)
85 {
86 zval *entry;
87 zend_string *xkey, *xstr;
88 php_http_arrkey_t key;
89
90 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(src), key.h, key.key, entry)
91 {
92 if (key.key) {
93 if (PHP_ICONV_ERR_SUCCESS != php_iconv_string(key.key->val, key.key->len, &xkey, oe, ie)) {
94 php_error_docref(NULL, E_WARNING, "Failed to convert '%.*s' from '%s' to '%s'", key.key->len, key.key->val, ie, oe);
95 return FAILURE;
96 }
97 }
98
99 if (Z_TYPE_P(entry) == IS_STRING) {
100 if (PHP_ICONV_ERR_SUCCESS != php_iconv_string(Z_STRVAL_P(entry), Z_STRLEN_P(entry), &xstr, oe, ie)) {
101 if (key.key) {
102 zend_string_release(xkey);
103 }
104 php_error_docref(NULL, E_WARNING, "Failed to convert '%.*s' from '%s' to '%s'", Z_STRLEN_P(entry), Z_STRVAL_P(entry), ie, oe);
105 return FAILURE;
106 }
107 if (key.key) {
108 add_assoc_str_ex(dst, xkey->val, xkey->len, xstr);
109 } else {
110 add_index_str(dst, key.h, xstr);
111 }
112 } else if (Z_TYPE_P(entry) == IS_ARRAY) {
113 zval subarray;
114
115 array_init(&subarray);
116 if (key.key) {
117 add_assoc_zval_ex(dst, xkey->val, xkey->len, &subarray);
118 } else {
119 add_index_zval(dst, key.h, &subarray);
120 }
121 if (SUCCESS != php_http_querystring_xlate(&subarray, entry, ie, oe)) {
122 if (key.key) {
123 zend_string_release(xkey);
124 }
125 return FAILURE;
126 }
127 }
128
129 if (key.key) {
130 zend_string_release(xkey);
131 }
132 }
133 ZEND_HASH_FOREACH_END();
134
135 return SUCCESS;
136 }
137 #endif /* HAVE_ICONV */
138
139 ZEND_RESULT_CODE php_http_querystring_ctor(zval *instance, zval *params)
140 {
141 php_http_querystring_set(instance, params, 0);
142 return SUCCESS;
143 }
144
145 static int apply_querystring(zval *val)
146 {
147 if (Z_TYPE_P(val) == IS_ARRAY) {
148 zval *zvalue;
149
150 if ((zvalue = zend_hash_str_find(Z_ARRVAL_P(val), ZEND_STRL("value")))) {
151 zval tmp;
152
153 ZVAL_COPY(&tmp, zvalue);
154 zval_dtor(val);
155 ZVAL_COPY_VALUE(val, &tmp);
156 }
157 }
158
159 return ZEND_HASH_APPLY_KEEP;
160 }
161
162 ZEND_RESULT_CODE php_http_querystring_parse(HashTable *ht, const char *str, size_t len)
163 {
164 ZEND_RESULT_CODE rv = FAILURE;
165 php_http_params_opts_t opts;
166 php_http_params_token_t psep = { ZEND_STRL("&") }, *psepp[] = { &psep, NULL };
167 php_http_params_token_t vsep = { ZEND_STRL("=") }, *vsepp[] = { &vsep, NULL };
168 const char *asi_str = NULL;
169 size_t asi_len = 0;
170
171 opts.input.str = estrndup(str, len);
172 opts.input.len = len;
173 opts.param = psepp;
174 opts.arg = NULL;
175 opts.val = vsepp;
176 opts.flags = PHP_HTTP_PARAMS_QUERY;
177
178 if (SUCCESS == php_http_ini_entry(ZEND_STRL("arg_separator.input"), &asi_str, &asi_len, 0 TSRMLS_CC) && asi_len) {
179 zval arr;
180
181 array_init_size(&arr, asi_len);
182
183 do {
184 add_next_index_stringl(&arr, asi_str++, 1);
185 } while (*asi_str);
186
187 opts.param = php_http_params_separator_init(&arr);
188
189 zval_ptr_dtor(&arr);
190 }
191
192 ZVAL_NULL(&opts.defval);
193
194 if (php_http_params_parse(ht, &opts)) {
195 zend_hash_apply(ht, apply_querystring);
196 rv = SUCCESS;
197 }
198
199 if (asi_len) {
200 php_http_params_separator_free(opts.param);
201 }
202
203 zval_ptr_dtor(&opts.defval);
204 efree(opts.input.str);
205 return rv;
206 }
207
208 ZEND_RESULT_CODE php_http_querystring_update(zval *qarray, zval *params, zval *outstring)
209 {
210 /* enforce proper type */
211 if (Z_TYPE_P(qarray) != IS_ARRAY) {
212 convert_to_array(qarray);
213 }
214
215 /* modify qarray */
216 if (params) {
217 HashTable *ht;
218 php_http_arrkey_t key;
219 zval zv, *params_entry, *qarray_entry;
220
221 ZVAL_NULL(&zv);
222
223 /* squeeze the hash out of the zval */
224 if (Z_TYPE_P(params) == IS_OBJECT && instanceof_function(Z_OBJCE_P(params), php_http_querystring_class_entry)) {
225 zval *qa = zend_read_property(php_http_querystring_class_entry, params, ZEND_STRL("queryArray"), 0);
226
227 ZVAL_DEREF(qa);
228 convert_to_array(qa);
229 ht = Z_ARRVAL_P(qa);
230 } else if (Z_TYPE_P(params) == IS_OBJECT || Z_TYPE_P(params) == IS_ARRAY) {
231 ht = HASH_OF(params);
232 } else {
233 zend_string *zs = zval_get_string(params);
234
235 array_init(&zv);
236 php_http_querystring_parse(Z_ARRVAL(zv), zs->val, zs->len);
237 zend_string_release(zs);
238
239 ht = Z_ARRVAL(zv);
240 }
241
242 ZEND_HASH_FOREACH_KEY_VAL(ht, key.h, key.key, params_entry)
243 {
244 /* only public properties */
245 if (!key.key || *key.key->val) {
246 if (Z_TYPE_P(params_entry) == IS_NULL) {
247 /*
248 * delete
249 */
250 if (key.key) {
251 zend_hash_del(Z_ARRVAL_P(qarray), key.key);
252 } else {
253 zend_hash_index_del(Z_ARRVAL_P(qarray), key.h);
254 }
255 } else if ( ((key.key) && (qarray_entry = zend_hash_find(Z_ARRVAL_P(qarray), key.key)))
256 || ((!key.key) && (qarray_entry = zend_hash_index_find(Z_ARRVAL_P(qarray), key.h)))) {
257 /*
258 * update
259 */
260 zval equal, *entry = NULL;
261
262 /* recursive */
263 if (Z_TYPE_P(params_entry) == IS_ARRAY || Z_TYPE_P(params_entry) == IS_OBJECT) {
264 entry = qarray_entry;
265 SEPARATE_ZVAL(entry);
266 convert_to_array(entry);
267 php_http_querystring_update(entry, params_entry, NULL);
268 } else if ((FAILURE == is_equal_function(&equal, qarray_entry, params_entry)) || Z_TYPE(equal) != IS_TRUE) {
269 Z_TRY_ADDREF_P(params_entry);
270 entry = params_entry;
271 }
272
273 if (entry) {
274 if (key.key) {
275 zend_hash_update(Z_ARRVAL_P(qarray), key.key, entry);
276 } else {
277 zend_hash_index_update(Z_ARRVAL_P(qarray), key.h, entry);
278 }
279 }
280 } else {
281 zval entry, *entry_ptr = &entry;
282 /*
283 * add
284 */
285 if (Z_TYPE_P(params_entry) == IS_OBJECT) {
286 array_init(&entry);
287 php_http_querystring_update(&entry, params_entry, NULL);
288 } else {
289 Z_TRY_ADDREF_P(params_entry);
290 entry_ptr = params_entry;
291 }
292 if (key.key) {
293 add_assoc_zval_ex(qarray, key.key->val, key.key->len, entry_ptr);
294 } else {
295 add_index_zval(qarray, key.h, entry_ptr);
296 }
297 }
298 }
299 }
300 ZEND_HASH_FOREACH_END();
301
302 zval_dtor(&zv);
303 }
304
305 /* serialize to string */
306 if (outstring) {
307 char *s;
308 size_t l;
309
310 if (SUCCESS == php_http_url_encode_hash(Z_ARRVAL_P(qarray), NULL, 0, &s, &l)) {
311 zval_dtor(outstring);
312 ZVAL_STR(outstring, php_http_cs2zs(s, l));
313 } else {
314 php_error_docref(NULL, E_WARNING, "Failed to encode query string");
315 return FAILURE;
316 }
317 }
318
319 return SUCCESS;
320 }
321
322 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString___construct, 0, 0, 0)
323 ZEND_ARG_INFO(0, params)
324 ZEND_END_ARG_INFO();
325 PHP_METHOD(HttpQueryString, __construct)
326 {
327 zval *params = NULL;
328 zend_error_handling zeh;
329
330 php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &params), invalid_arg, return);
331
332 zend_replace_error_handling(EH_THROW, php_http_exception_bad_querystring_class_entry, &zeh);
333 php_http_querystring_set(getThis(), params, 0);
334 zend_restore_error_handling(&zeh);
335 }
336
337 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_getGlobalInstance, 0, 0, 0)
338 ZEND_END_ARG_INFO();
339 PHP_METHOD(HttpQueryString, getGlobalInstance)
340 {
341 zval *instance;
342 zend_string *zs;
343
344 php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
345
346 zs = zend_string_init(ZEND_STRL("instance"), 0);
347 instance = zend_std_get_static_property(php_http_querystring_class_entry, zs, 0, NULL);
348 zend_string_release(zs);
349
350 if (Z_TYPE_P(instance) != IS_OBJECT) {
351 zval *_GET = NULL;
352
353 if ((_GET = php_http_env_get_superglobal(ZEND_STRL("_GET")))) {
354 zval new_instance;
355
356 ZVAL_OBJ(&new_instance, php_http_querystring_object_new(php_http_querystring_class_entry));
357
358 ZVAL_MAKE_REF(_GET);
359 zend_update_property(php_http_querystring_class_entry, &new_instance, ZEND_STRL("queryArray"), _GET);
360
361 zend_update_static_property(php_http_querystring_class_entry, ZEND_STRL("instance"), instance);
362 instance = &new_instance;
363 } else {
364 php_http_throw(unexpected_val, "Could not acquire reference to superglobal GET array", NULL);
365 }
366 }
367
368 RETVAL_ZVAL_FAST(instance);
369 }
370
371 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_getIterator, 0, 0, 0)
372 ZEND_END_ARG_INFO();
373 PHP_METHOD(HttpQueryString, getIterator)
374 {
375 zval *qa;
376
377 php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
378
379 qa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0);
380
381 object_init_ex(return_value, spl_ce_RecursiveArrayIterator);
382 zend_call_method_with_1_params(return_value, spl_ce_RecursiveArrayIterator, NULL, "__construct", NULL, qa);
383 }
384
385 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_toString, 0, 0, 0)
386 ZEND_END_ARG_INFO();
387 PHP_METHOD(HttpQueryString, toString)
388 {
389 if (SUCCESS != zend_parse_parameters_none()) {
390 return;
391 }
392 php_http_querystring_str(getThis(), return_value);
393 }
394
395 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_toArray, 0, 0, 0)
396 ZEND_END_ARG_INFO();
397 PHP_METHOD(HttpQueryString, toArray)
398 {
399 zval *zqa;
400
401 if (SUCCESS != zend_parse_parameters_none()) {
402 return;
403 }
404
405 zqa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0);
406 RETURN_ZVAL_FAST(zqa);
407 }
408
409 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_get, 0, 0, 0)
410 ZEND_ARG_INFO(0, name)
411 ZEND_ARG_INFO(0, type)
412 ZEND_ARG_INFO(0, defval)
413 ZEND_ARG_INFO(0, delete)
414 ZEND_END_ARG_INFO();
415 PHP_METHOD(HttpQueryString, get)
416 {
417 char *name_str = NULL;
418 size_t name_len = 0;
419 zend_long type = 0;
420 zend_bool del = 0;
421 zval *ztype = NULL, *defval = NULL;
422
423 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|szzb", &name_str, &name_len, &ztype, &defval, &del)) {
424 if (name_str && name_len) {
425 if (ztype) {
426 if (Z_TYPE_P(ztype) == IS_LONG) {
427 type = Z_LVAL_P(ztype);
428 } else if(Z_TYPE_P(ztype) == IS_STRING) {
429 switch (Z_STRVAL_P(ztype)[0]) {
430 case 'B':
431 case 'b': type = PHP_HTTP_QUERYSTRING_TYPE_BOOL; break;
432 case 'L':
433 case 'l':
434 case 'I':
435 case 'i': type = PHP_HTTP_QUERYSTRING_TYPE_INT; break;
436 case 'd':
437 case 'D':
438 case 'F':
439 case 'f': type = PHP_HTTP_QUERYSTRING_TYPE_FLOAT; break;
440 case 'S':
441 case 's': type = PHP_HTTP_QUERYSTRING_TYPE_STRING; break;
442 case 'A':
443 case 'a': type = PHP_HTTP_QUERYSTRING_TYPE_ARRAY; break;
444 case 'O':
445 case 'o': type = PHP_HTTP_QUERYSTRING_TYPE_OBJECT; break;
446 }
447 }
448 }
449 php_http_querystring_get(getThis(), type, name_str, name_len, defval, del, return_value);
450 } else {
451 php_http_querystring_str(getThis(), return_value);
452 }
453 }
454 }
455
456 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_set, 0, 0, 1)
457 ZEND_ARG_INFO(0, params)
458 ZEND_END_ARG_INFO();
459 PHP_METHOD(HttpQueryString, set)
460 {
461 zval *params;
462
463 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "z", &params)) {
464 return;
465 }
466
467 php_http_querystring_set(getThis(), params, QS_MERGE);
468 RETVAL_ZVAL(getThis(), 1, 0);
469 }
470
471 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_mod, 0, 0, 0)
472 ZEND_ARG_INFO(0, params)
473 ZEND_END_ARG_INFO();
474 PHP_METHOD(HttpQueryString, mod)
475 {
476 zval *params, *instance = getThis();
477 zend_error_handling zeh;
478
479 php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "z", &params), invalid_arg, return);
480
481 zend_replace_error_handling(EH_THROW, php_http_exception_bad_querystring_class_entry, &zeh);
482 ZVAL_OBJ(return_value, Z_OBJ_HT_P(instance)->clone_obj(instance));
483 php_http_querystring_set(return_value, params, QS_MERGE);
484 zend_restore_error_handling(&zeh);
485 }
486
487 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString___getter, 0, 0, 1)
488 ZEND_ARG_INFO(0, name)
489 ZEND_ARG_INFO(0, defval)
490 ZEND_ARG_INFO(0, delete)
491 ZEND_END_ARG_INFO();
492 #define PHP_HTTP_QUERYSTRING_GETTER(method, TYPE) \
493 PHP_METHOD(HttpQueryString, method) \
494 { \
495 char *name; \
496 size_t name_len; \
497 zval *defval = NULL; \
498 zend_bool del = 0; \
499 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|zb", &name, &name_len, &defval, &del)) { \
500 php_http_querystring_get(getThis(), TYPE, name, name_len, defval, del, return_value); \
501 } \
502 }
503 PHP_HTTP_QUERYSTRING_GETTER(getBool, _IS_BOOL);
504 PHP_HTTP_QUERYSTRING_GETTER(getInt, IS_LONG);
505 PHP_HTTP_QUERYSTRING_GETTER(getFloat, IS_DOUBLE);
506 PHP_HTTP_QUERYSTRING_GETTER(getString, IS_STRING);
507 PHP_HTTP_QUERYSTRING_GETTER(getArray, IS_ARRAY);
508 PHP_HTTP_QUERYSTRING_GETTER(getObject, IS_OBJECT);
509
510 #ifdef PHP_HTTP_HAVE_ICONV
511 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_xlate, 0, 0, 2)
512 ZEND_ARG_INFO(0, from_encoding)
513 ZEND_ARG_INFO(0, to_encoding)
514 ZEND_END_ARG_INFO();
515 PHP_METHOD(HttpQueryString, xlate)
516 {
517 char *ie, *oe;
518 size_t ie_len, oe_len;
519 zval na, *qa;
520
521 php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &ie, &ie_len, &oe, &oe_len), invalid_arg, return);
522
523 array_init(&na);
524 qa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0);
525 ZVAL_DEREF(qa);
526 convert_to_array(qa);
527
528 php_http_expect(SUCCESS == php_http_querystring_xlate(&na, qa, ie, oe), bad_conversion,
529 zval_ptr_dtor(&na);
530 return;
531 );
532
533 php_http_querystring_set(getThis(), &na, 0);
534 RETVAL_ZVAL_FAST(getThis());
535
536 zval_ptr_dtor(&na);
537 }
538 #endif /* HAVE_ICONV */
539
540 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_serialize, 0, 0, 0)
541 ZEND_END_ARG_INFO();
542 PHP_METHOD(HttpQueryString, serialize)
543 {
544 if (SUCCESS != zend_parse_parameters_none()) {
545 return;
546 }
547 php_http_querystring_str(getThis(), return_value);
548 }
549
550 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_unserialize, 0, 0, 1)
551 ZEND_ARG_INFO(0, serialized)
552 ZEND_END_ARG_INFO();
553 PHP_METHOD(HttpQueryString, unserialize)
554 {
555 zval *serialized;
556
557 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "z", &serialized)) {
558 return;
559 }
560
561 if (Z_TYPE_P(serialized) == IS_STRING) {
562 php_http_querystring_set(getThis(), serialized, 0);
563 } else {
564 php_error_docref(NULL, E_WARNING, "Expected a string as parameter");
565 }
566 }
567
568 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_offsetGet, 0, 0, 1)
569 ZEND_ARG_INFO(0, offset)
570 ZEND_END_ARG_INFO();
571 PHP_METHOD(HttpQueryString, offsetGet)
572 {
573 zend_string *offset;
574 zval *value, *qa;
575
576 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "S", &offset)) {
577 return;
578 }
579
580 qa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0);
581 ZVAL_DEREF(qa);
582
583 if (Z_TYPE_P(qa) == IS_ARRAY) {
584 if ((value = zend_symtable_find(Z_ARRVAL_P(qa), offset))) {
585 RETVAL_ZVAL_FAST(value);
586 }
587 }
588 }
589
590 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_offsetSet, 0, 0, 2)
591 ZEND_ARG_INFO(0, offset)
592 ZEND_ARG_INFO(0, value)
593 ZEND_END_ARG_INFO();
594 PHP_METHOD(HttpQueryString, offsetSet)
595 {
596 zend_string *offset;
597 zval *value, param;
598
599 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz", &offset, &value)) {
600 return;
601 }
602
603 array_init(&param);
604 Z_TRY_ADDREF_P(value);
605 zend_symtable_update(Z_ARRVAL(param), offset, value);
606 php_http_querystring_set(getThis(), &param, 0);
607 zval_ptr_dtor(&param);
608 }
609
610 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_offsetExists, 0, 0, 1)
611 ZEND_ARG_INFO(0, offset)
612 ZEND_END_ARG_INFO();
613 PHP_METHOD(HttpQueryString, offsetExists)
614 {
615 zend_string *offset;
616 zval *value, *qa;
617
618 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "S", &offset)) {
619 return;
620 }
621
622 qa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0);
623 ZVAL_DEREF(qa);
624
625 if (Z_TYPE_P(qa) == IS_ARRAY) {
626 if ((value = zend_symtable_find(Z_ARRVAL_P(qa), offset))) {
627 RETURN_BOOL(Z_TYPE_P(value) != IS_NULL);
628 }
629 }
630 RETURN_FALSE;
631 }
632
633 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_offsetUnset, 0, 0, 1)
634 ZEND_ARG_INFO(0, offset)
635 ZEND_END_ARG_INFO();
636 PHP_METHOD(HttpQueryString, offsetUnset)
637 {
638 zend_string *offset;
639 zval param, znull;
640
641 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &offset)) {
642 return;
643 }
644
645 array_init(&param);
646 ZVAL_NULL(&znull);
647 zend_symtable_update(Z_ARRVAL(param), offset, &znull);
648 php_http_querystring_set(getThis(), &param, QS_MERGE);
649 zval_ptr_dtor(&param);
650 }
651
652 zend_class_entry *php_http_querystring_class_entry;
653
654 static zend_function_entry php_http_querystring_methods[] = {
655 PHP_ME(HttpQueryString, __construct, ai_HttpQueryString___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR|ZEND_ACC_FINAL)
656
657 PHP_ME(HttpQueryString, toArray, ai_HttpQueryString_toArray, ZEND_ACC_PUBLIC)
658 PHP_ME(HttpQueryString, toString, ai_HttpQueryString_toString, ZEND_ACC_PUBLIC)
659 ZEND_MALIAS(HttpQueryString, __toString, toString, ai_HttpQueryString_toString, ZEND_ACC_PUBLIC)
660
661 PHP_ME(HttpQueryString, get, ai_HttpQueryString_get, ZEND_ACC_PUBLIC)
662 PHP_ME(HttpQueryString, set, ai_HttpQueryString_set, ZEND_ACC_PUBLIC)
663 PHP_ME(HttpQueryString, mod, ai_HttpQueryString_mod, ZEND_ACC_PUBLIC)
664
665 PHP_ME(HttpQueryString, getBool, ai_HttpQueryString___getter, ZEND_ACC_PUBLIC)
666 PHP_ME(HttpQueryString, getInt, ai_HttpQueryString___getter, ZEND_ACC_PUBLIC)
667 PHP_ME(HttpQueryString, getFloat, ai_HttpQueryString___getter, ZEND_ACC_PUBLIC)
668 PHP_ME(HttpQueryString, getString, ai_HttpQueryString___getter, ZEND_ACC_PUBLIC)
669 PHP_ME(HttpQueryString, getArray, ai_HttpQueryString___getter, ZEND_ACC_PUBLIC)
670 PHP_ME(HttpQueryString, getObject, ai_HttpQueryString___getter, ZEND_ACC_PUBLIC)
671
672 PHP_ME(HttpQueryString, getIterator, ai_HttpQueryString_getIterator, ZEND_ACC_PUBLIC)
673
674 PHP_ME(HttpQueryString, getGlobalInstance, ai_HttpQueryString_getGlobalInstance, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
675 #ifdef PHP_HTTP_HAVE_ICONV
676 PHP_ME(HttpQueryString, xlate, ai_HttpQueryString_xlate, ZEND_ACC_PUBLIC)
677 #endif
678
679 /* Implements Serializable */
680 PHP_ME(HttpQueryString, serialize, ai_HttpQueryString_serialize, ZEND_ACC_PUBLIC)
681 PHP_ME(HttpQueryString, unserialize, ai_HttpQueryString_unserialize, ZEND_ACC_PUBLIC)
682
683 /* Implements ArrayAccess */
684 PHP_ME(HttpQueryString, offsetGet, ai_HttpQueryString_offsetGet, ZEND_ACC_PUBLIC)
685 PHP_ME(HttpQueryString, offsetSet, ai_HttpQueryString_offsetSet, ZEND_ACC_PUBLIC)
686 PHP_ME(HttpQueryString, offsetExists, ai_HttpQueryString_offsetExists, ZEND_ACC_PUBLIC)
687 PHP_ME(HttpQueryString, offsetUnset, ai_HttpQueryString_offsetUnset, ZEND_ACC_PUBLIC)
688
689 EMPTY_FUNCTION_ENTRY
690 };
691
692 PHP_MINIT_FUNCTION(http_querystring)
693 {
694 zend_class_entry ce = {0};
695
696 INIT_NS_CLASS_ENTRY(ce, "http", "QueryString", php_http_querystring_methods);
697 php_http_querystring_class_entry = zend_register_internal_class(&ce);
698 php_http_querystring_class_entry->create_object = php_http_querystring_object_new;
699 zend_class_implements(php_http_querystring_class_entry, 3, zend_ce_serializable, zend_ce_arrayaccess, zend_ce_aggregate);
700
701 zend_declare_property_null(php_http_querystring_class_entry, ZEND_STRL("instance"), (ZEND_ACC_STATIC|ZEND_ACC_PRIVATE));
702 zend_declare_property_null(php_http_querystring_class_entry, ZEND_STRL("queryArray"), ZEND_ACC_PRIVATE);
703
704 zend_declare_class_constant_long(php_http_querystring_class_entry, ZEND_STRL("TYPE_BOOL"), PHP_HTTP_QUERYSTRING_TYPE_BOOL);
705 zend_declare_class_constant_long(php_http_querystring_class_entry, ZEND_STRL("TYPE_INT"), PHP_HTTP_QUERYSTRING_TYPE_INT);
706 zend_declare_class_constant_long(php_http_querystring_class_entry, ZEND_STRL("TYPE_FLOAT"), PHP_HTTP_QUERYSTRING_TYPE_FLOAT);
707 zend_declare_class_constant_long(php_http_querystring_class_entry, ZEND_STRL("TYPE_STRING"), PHP_HTTP_QUERYSTRING_TYPE_STRING);
708 zend_declare_class_constant_long(php_http_querystring_class_entry, ZEND_STRL("TYPE_ARRAY"), PHP_HTTP_QUERYSTRING_TYPE_ARRAY);
709 zend_declare_class_constant_long(php_http_querystring_class_entry, ZEND_STRL("TYPE_OBJECT"), PHP_HTTP_QUERYSTRING_TYPE_OBJECT);
710
711 return SUCCESS;
712 }
713
714 /*
715 * Local variables:
716 * tab-width: 4
717 * c-basic-offset: 4
718 * End:
719 * vim600: noet sw=4 ts=4 fdm=marker
720 * vim<600: noet sw=4 ts=4
721 */
Extended HTTP Support