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