git.m6w6.name Git - m6w6/ext-http/blob - 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                 zend_string *zs = zend_string_init("_GET", lenof("_GET"), 0);
 353
 354                 zend_is_auto_global(zs);
 355
 356                 if ((_GET = zend_hash_find(&EG(symbol_table).ht, zs))
 357                 &&      (Z_TYPE_P(_GET) == IS_ARRAY)
 358                 ) {
 359                         zval new_instance;
 360
 361                         ZVAL_OBJ(&new_instance, php_http_querystring_object_new(php_http_querystring_class_entry));
 362
 363                         ZVAL_MAKE_REF(_GET);
 364                         zend_update_property(php_http_querystring_class_entry, &new_instance, ZEND_STRL("queryArray"), _GET);
 365
 366                         zend_update_static_property(php_http_querystring_class_entry, ZEND_STRL("instance"), instance);
 367                         instance = &new_instance;
 368                 } else {
 369                         php_http_throw(unexpected_val, "Could not acquire reference to superglobal GET array", NULL);
 370                 }
 371
 372                 zend_string_release(zs);
 373         }
 374
 375         RETVAL_ZVAL_FAST(instance);
 376 }
 377
 378 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_getIterator, 0, 0, 0)
 379 ZEND_END_ARG_INFO();
 380 PHP_METHOD(HttpQueryString, getIterator)
 381 {
 382         zval *qa;
 383
 384         php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
 385
 386         qa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0);
 387
 388         object_init_ex(return_value, spl_ce_RecursiveArrayIterator);
 389         zend_call_method_with_1_params(return_value, spl_ce_RecursiveArrayIterator, NULL, "__construct", NULL, qa);
 390 }
 391
 392 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_toString, 0, 0, 0)
 393 ZEND_END_ARG_INFO();
 394 PHP_METHOD(HttpQueryString, toString)
 395 {
 396         if (SUCCESS != zend_parse_parameters_none()) {
 397                 return;
 398         }
 399         php_http_querystring_str(getThis(), return_value);
 400 }
 401
 402 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_toArray, 0, 0, 0)
 403 ZEND_END_ARG_INFO();
 404 PHP_METHOD(HttpQueryString, toArray)
 405 {
 406         zval *zqa;
 407
 408         if (SUCCESS != zend_parse_parameters_none()) {
 409                 return;
 410         }
 411
 412         zqa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0);
 413         RETURN_ZVAL_FAST(zqa);
 414 }
 415
 416 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_get, 0, 0, 0)
 417         ZEND_ARG_INFO(0, name)
 418         ZEND_ARG_INFO(0, type)
 419         ZEND_ARG_INFO(0, defval)
 420         ZEND_ARG_INFO(0, delete)
 421 ZEND_END_ARG_INFO();
 422 PHP_METHOD(HttpQueryString, get)
 423 {
 424         char *name_str = NULL;
 425         size_t name_len = 0;
 426         zend_long type = 0;
 427         zend_bool del = 0;
 428         zval *ztype = NULL, *defval = NULL;
 429
 430         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|szzb", &name_str, &name_len, &ztype, &defval, &del)) {
 431                 if (name_str && name_len) {
 432                         if (ztype) {
 433                                 if (Z_TYPE_P(ztype) == IS_LONG) {
 434                                         type = Z_LVAL_P(ztype);
 435                                 } else if(Z_TYPE_P(ztype) == IS_STRING) {
 436                                         switch (Z_STRVAL_P(ztype)[0]) {
 437                                                 case 'B':
 438                                                 case 'b':       type = PHP_HTTP_QUERYSTRING_TYPE_BOOL;          break;
 439                                                 case 'L':
 440                                                 case 'l':
 441                                                 case 'I':
 442                                                 case 'i':       type = PHP_HTTP_QUERYSTRING_TYPE_INT;           break;
 443                                                 case 'd':
 444                                                 case 'D':
 445                                                 case 'F':
 446                                                 case 'f':       type = PHP_HTTP_QUERYSTRING_TYPE_FLOAT;         break;
 447                                                 case 'S':
 448                                                 case 's':       type = PHP_HTTP_QUERYSTRING_TYPE_STRING;        break;
 449                                                 case 'A':
 450                                                 case 'a':       type = PHP_HTTP_QUERYSTRING_TYPE_ARRAY;         break;
 451                                                 case 'O':
 452                                                 case 'o':       type = PHP_HTTP_QUERYSTRING_TYPE_OBJECT;        break;
 453                                         }
 454                                 }
 455                         }
 456                         php_http_querystring_get(getThis(), type, name_str, name_len, defval, del, return_value);
 457                 } else {
 458                         php_http_querystring_str(getThis(), return_value);
 459                 }
 460         }
 461 }
 462
 463 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_set, 0, 0, 1)
 464         ZEND_ARG_INFO(0, params)
 465 ZEND_END_ARG_INFO();
 466 PHP_METHOD(HttpQueryString, set)
 467 {
 468         zval *params;
 469
 470         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "z", &params)) {
 471                 return;
 472         }
 473
 474         php_http_querystring_set(getThis(), params, QS_MERGE);
 475         RETVAL_ZVAL(getThis(), 1, 0);
 476 }
 477
 478 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_mod, 0, 0, 0)
 479         ZEND_ARG_INFO(0, params)
 480 ZEND_END_ARG_INFO();
 481 PHP_METHOD(HttpQueryString, mod)
 482 {
 483         zval *params, *instance = getThis();
 484         zend_error_handling zeh;
 485
 486         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "z", &params), invalid_arg, return);
 487
 488         zend_replace_error_handling(EH_THROW, php_http_exception_bad_querystring_class_entry, &zeh);
 489         ZVAL_OBJ(return_value, Z_OBJ_HT_P(instance)->clone_obj(instance));
 490         php_http_querystring_set(return_value, params, QS_MERGE);
 491         zend_restore_error_handling(&zeh);
 492 }
 493
 494 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString___getter, 0, 0, 1)
 495         ZEND_ARG_INFO(0, name)
 496         ZEND_ARG_INFO(0, defval)
 497         ZEND_ARG_INFO(0, delete)
 498 ZEND_END_ARG_INFO();
 499 #define PHP_HTTP_QUERYSTRING_GETTER(method, TYPE) \
 500 PHP_METHOD(HttpQueryString, method) \
 501 { \
 502         char *name; \
 503         size_t name_len; \
 504         zval *defval = NULL; \
 505         zend_bool del = 0; \
 506         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|zb", &name, &name_len, &defval, &del)) { \
 507                 php_http_querystring_get(getThis(), TYPE, name, name_len, defval, del, return_value); \
 508         } \
 509 }
 510 PHP_HTTP_QUERYSTRING_GETTER(getBool, _IS_BOOL);
 511 PHP_HTTP_QUERYSTRING_GETTER(getInt, IS_LONG);
 512 PHP_HTTP_QUERYSTRING_GETTER(getFloat, IS_DOUBLE);
 513 PHP_HTTP_QUERYSTRING_GETTER(getString, IS_STRING);
 514 PHP_HTTP_QUERYSTRING_GETTER(getArray, IS_ARRAY);
 515 PHP_HTTP_QUERYSTRING_GETTER(getObject, IS_OBJECT);
 516
 517 #ifdef PHP_HTTP_HAVE_ICONV
 518 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_xlate, 0, 0, 2)
 519         ZEND_ARG_INFO(0, from_encoding)
 520         ZEND_ARG_INFO(0, to_encoding)
 521 ZEND_END_ARG_INFO();
 522 PHP_METHOD(HttpQueryString, xlate)
 523 {
 524         char *ie, *oe;
 525         size_t ie_len, oe_len;
 526         zval na, *qa;
 527
 528         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &ie, &ie_len, &oe, &oe_len), invalid_arg, return);
 529
 530         array_init(&na);
 531         qa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0);
 532         ZVAL_DEREF(qa);
 533         convert_to_array(qa);
 534
 535         php_http_expect(SUCCESS == php_http_querystring_xlate(&na, qa, ie, oe), bad_conversion,
 536                         zval_ptr_dtor(&na);
 537                         return;
 538         );
 539
 540         php_http_querystring_set(getThis(), &na, 0);
 541         RETVAL_ZVAL_FAST(getThis());
 542
 543         zval_ptr_dtor(&na);
 544 }
 545 #endif /* HAVE_ICONV */
 546
 547 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_serialize, 0, 0, 0)
 548 ZEND_END_ARG_INFO();
 549 PHP_METHOD(HttpQueryString, serialize)
 550 {
 551         if (SUCCESS != zend_parse_parameters_none()) {
 552                 return;
 553         }
 554         php_http_querystring_str(getThis(), return_value);
 555 }
 556
 557 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_unserialize, 0, 0, 1)
 558         ZEND_ARG_INFO(0, serialized)
 559 ZEND_END_ARG_INFO();
 560 PHP_METHOD(HttpQueryString, unserialize)
 561 {
 562         zval *serialized;
 563
 564         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "z", &serialized)) {
 565                 return;
 566         }
 567
 568         if (Z_TYPE_P(serialized) == IS_STRING) {
 569                 php_http_querystring_set(getThis(), serialized, 0);
 570         } else {
 571                 php_error_docref(NULL, E_WARNING, "Expected a string as parameter");
 572         }
 573 }
 574
 575 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_offsetGet, 0, 0, 1)
 576         ZEND_ARG_INFO(0, offset)
 577 ZEND_END_ARG_INFO();
 578 PHP_METHOD(HttpQueryString, offsetGet)
 579 {
 580         zend_string *offset;
 581         zval *value, *qa;
 582
 583         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "S", &offset)) {
 584                 return;
 585         }
 586
 587         qa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0);
 588         ZVAL_DEREF(qa);
 589
 590         if (Z_TYPE_P(qa) == IS_ARRAY) {
 591                 if ((value = zend_symtable_find(Z_ARRVAL_P(qa), offset))) {
 592                         RETVAL_ZVAL_FAST(value);
 593                 }
 594         }
 595 }
 596
 597 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_offsetSet, 0, 0, 2)
 598         ZEND_ARG_INFO(0, offset)
 599         ZEND_ARG_INFO(0, value)
 600 ZEND_END_ARG_INFO();
 601 PHP_METHOD(HttpQueryString, offsetSet)
 602 {
 603         zend_string *offset;
 604         zval *value, param;
 605
 606         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz", &offset, &value)) {
 607                 return;
 608         }
 609
 610         array_init(&param);
 611         Z_TRY_ADDREF_P(value);
 612         zend_symtable_update(Z_ARRVAL(param), offset, value);
 613         php_http_querystring_set(getThis(), &param, 0);
 614         zval_ptr_dtor(&param);
 615 }
 616
 617 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_offsetExists, 0, 0, 1)
 618         ZEND_ARG_INFO(0, offset)
 619 ZEND_END_ARG_INFO();
 620 PHP_METHOD(HttpQueryString, offsetExists)
 621 {
 622         zend_string *offset;
 623         zval *value, *qa;
 624
 625         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "S", &offset)) {
 626                 return;
 627         }
 628
 629         qa = zend_read_property(php_http_querystring_class_entry, getThis(), ZEND_STRL("queryArray"), 0);
 630         ZVAL_DEREF(qa);
 631
 632         if (Z_TYPE_P(qa) == IS_ARRAY) {
 633                 if ((value = zend_symtable_find(Z_ARRVAL_P(qa), offset))) {
 634                         RETURN_BOOL(Z_TYPE_P(value) != IS_NULL);
 635                 }
 636         }
 637         RETURN_FALSE;
 638 }
 639
 640 ZEND_BEGIN_ARG_INFO_EX(ai_HttpQueryString_offsetUnset, 0, 0, 1)
 641         ZEND_ARG_INFO(0, offset)
 642 ZEND_END_ARG_INFO();
 643 PHP_METHOD(HttpQueryString, offsetUnset)
 644 {
 645         zend_string *offset;
 646         zval param, znull;
 647
 648         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &offset)) {
 649                 return;
 650         }
 651
 652         array_init(&param);
 653         ZVAL_NULL(&znull);
 654         zend_symtable_update(Z_ARRVAL(param), offset, &znull);
 655         php_http_querystring_set(getThis(), &param, QS_MERGE);
 656         zval_ptr_dtor(&param);
 657 }
 658
 659 zend_class_entry *php_http_querystring_class_entry;
 660
 661 static zend_function_entry php_http_querystring_methods[] = {
 662         PHP_ME(HttpQueryString, __construct, ai_HttpQueryString___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR|ZEND_ACC_FINAL)
 663
 664         PHP_ME(HttpQueryString, toArray, ai_HttpQueryString_toArray, ZEND_ACC_PUBLIC)
 665         PHP_ME(HttpQueryString, toString, ai_HttpQueryString_toString, ZEND_ACC_PUBLIC)
 666         ZEND_MALIAS(HttpQueryString, __toString, toString, ai_HttpQueryString_toString, ZEND_ACC_PUBLIC)
 667
 668         PHP_ME(HttpQueryString, get, ai_HttpQueryString_get, ZEND_ACC_PUBLIC)
 669         PHP_ME(HttpQueryString, set, ai_HttpQueryString_set, ZEND_ACC_PUBLIC)
 670         PHP_ME(HttpQueryString, mod, ai_HttpQueryString_mod, ZEND_ACC_PUBLIC)
 671
 672         PHP_ME(HttpQueryString, getBool, ai_HttpQueryString___getter, ZEND_ACC_PUBLIC)
 673         PHP_ME(HttpQueryString, getInt, ai_HttpQueryString___getter, ZEND_ACC_PUBLIC)
 674         PHP_ME(HttpQueryString, getFloat, ai_HttpQueryString___getter, ZEND_ACC_PUBLIC)
 675         PHP_ME(HttpQueryString, getString, ai_HttpQueryString___getter, ZEND_ACC_PUBLIC)
 676         PHP_ME(HttpQueryString, getArray, ai_HttpQueryString___getter, ZEND_ACC_PUBLIC)
 677         PHP_ME(HttpQueryString, getObject, ai_HttpQueryString___getter, ZEND_ACC_PUBLIC)
 678
 679         PHP_ME(HttpQueryString, getIterator, ai_HttpQueryString_getIterator, ZEND_ACC_PUBLIC)
 680
 681         PHP_ME(HttpQueryString, getGlobalInstance, ai_HttpQueryString_getGlobalInstance, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 682 #ifdef PHP_HTTP_HAVE_ICONV
 683         PHP_ME(HttpQueryString, xlate, ai_HttpQueryString_xlate, ZEND_ACC_PUBLIC)
 684 #endif
 685
 686         /* Implements Serializable */
 687         PHP_ME(HttpQueryString, serialize, ai_HttpQueryString_serialize, ZEND_ACC_PUBLIC)
 688         PHP_ME(HttpQueryString, unserialize, ai_HttpQueryString_unserialize, ZEND_ACC_PUBLIC)
 689
 690         /* Implements ArrayAccess */
 691         PHP_ME(HttpQueryString, offsetGet, ai_HttpQueryString_offsetGet, ZEND_ACC_PUBLIC)
 692         PHP_ME(HttpQueryString, offsetSet, ai_HttpQueryString_offsetSet, ZEND_ACC_PUBLIC)
 693         PHP_ME(HttpQueryString, offsetExists, ai_HttpQueryString_offsetExists, ZEND_ACC_PUBLIC)
 694         PHP_ME(HttpQueryString, offsetUnset, ai_HttpQueryString_offsetUnset, ZEND_ACC_PUBLIC)
 695
 696         EMPTY_FUNCTION_ENTRY
 697 };
 698
 699 PHP_MINIT_FUNCTION(http_querystring)
 700 {
 701         zend_class_entry ce = {0};
 702
 703         INIT_NS_CLASS_ENTRY(ce, "http", "QueryString", php_http_querystring_methods);
 704         php_http_querystring_class_entry = zend_register_internal_class(&ce);
 705         php_http_querystring_class_entry->create_object = php_http_querystring_object_new;
 706         zend_class_implements(php_http_querystring_class_entry, 3, zend_ce_serializable, zend_ce_arrayaccess, zend_ce_aggregate);
 707
 708         zend_declare_property_null(php_http_querystring_class_entry, ZEND_STRL("instance"), (ZEND_ACC_STATIC|ZEND_ACC_PRIVATE));
 709         zend_declare_property_null(php_http_querystring_class_entry, ZEND_STRL("queryArray"), ZEND_ACC_PRIVATE);
 710
 711         zend_declare_class_constant_long(php_http_querystring_class_entry, ZEND_STRL("TYPE_BOOL"), PHP_HTTP_QUERYSTRING_TYPE_BOOL);
 712         zend_declare_class_constant_long(php_http_querystring_class_entry, ZEND_STRL("TYPE_INT"), PHP_HTTP_QUERYSTRING_TYPE_INT);
 713         zend_declare_class_constant_long(php_http_querystring_class_entry, ZEND_STRL("TYPE_FLOAT"), PHP_HTTP_QUERYSTRING_TYPE_FLOAT);
 714         zend_declare_class_constant_long(php_http_querystring_class_entry, ZEND_STRL("TYPE_STRING"), PHP_HTTP_QUERYSTRING_TYPE_STRING);
 715         zend_declare_class_constant_long(php_http_querystring_class_entry, ZEND_STRL("TYPE_ARRAY"), PHP_HTTP_QUERYSTRING_TYPE_ARRAY);
 716         zend_declare_class_constant_long(php_http_querystring_class_entry, ZEND_STRL("TYPE_OBJECT"), PHP_HTTP_QUERYSTRING_TYPE_OBJECT);
 717
 718         return SUCCESS;
 719 }
 720
 721 /*
 722  * Local variables:
 723  * tab-width: 4
 724  * c-basic-offset: 4
 725  * End:
 726  * vim600: noet sw=4 ts=4 fdm=marker
 727  * vim<600: noet sw=4 ts=4
 728  */