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