git.m6w6.name Git - m6w6/ext-http/blob - php_http_params.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 static php_http_params_token_t def_param_sep = {",", 1}, *def_param_sep_ptr[] = {&def_param_sep, NULL};
  16 static php_http_params_token_t def_arg_sep = {";", 1}, *def_arg_sep_ptr[] = {&def_arg_sep, NULL};
  17 static php_http_params_token_t def_val_sep = {"=", 1}, *def_val_sep_ptr[] = {&def_val_sep, NULL};
  18 static php_http_params_opts_t def_opts = {
  19         .param = def_param_sep_ptr,
  20         .arg = def_arg_sep_ptr,
  21         .val = def_val_sep_ptr,
  22         .defval = NULL,
  23         .flags = PHP_HTTP_PARAMS_DEFAULT
  24 };
  25
  26 PHP_HTTP_API php_http_params_opts_t *php_http_params_opts_default_get(php_http_params_opts_t *opts)
  27 {
  28         if (!opts) {
  29                 opts = emalloc(sizeof(*opts));
  30         }
  31
  32         memcpy(opts, &def_opts, sizeof(def_opts));
  33
  34         return opts;
  35 }
  36
  37 typedef struct php_http_params_state {
  38         php_http_params_token_t input;
  39         php_http_params_token_t param;
  40         php_http_params_token_t arg;
  41         php_http_params_token_t val;
  42         struct {
  43                 zval **param;
  44                 zval **args;
  45                 zval **val;
  46         } current;
  47 } php_http_params_state_t;
  48
  49 static void sanitize_default(zval *zv TSRMLS_DC)
  50 {
  51         if (Z_STRVAL_P(zv)[0] == '"' && Z_STRVAL_P(zv)[Z_STRLEN_P(zv) - 1] == '"') {
  52                 size_t deq_len = Z_STRLEN_P(zv) - 2;
  53                 char *deq = estrndup(Z_STRVAL_P(zv) + 1, deq_len);
  54
  55                 zval_dtor(zv);
  56                 ZVAL_STRINGL(zv, deq, deq_len, 0);
  57         }
  58
  59         php_stripslashes(Z_STRVAL_P(zv), &Z_STRLEN_P(zv) TSRMLS_CC);
  60 }
  61
  62 static void prepare_default(zval *zv TSRMLS_DC)
  63 {
  64         int len = Z_STRLEN_P(zv);
  65
  66         Z_STRVAL_P(zv) = php_addslashes(Z_STRVAL_P(zv), Z_STRLEN_P(zv), &Z_STRLEN_P(zv), 1 TSRMLS_CC);
  67
  68         if (len != Z_STRLEN_P(zv)) {
  69                 zval tmp = *zv;
  70                 int len = Z_STRLEN_P(zv) + 2;
  71                 char *str = emalloc(len + 1);
  72
  73                 str[0] = '"';
  74                 memcpy(&str[1], Z_STRVAL_P(zv), Z_STRLEN_P(zv));
  75                 str[len-1] = '"';
  76                 str[len] = '\0';
  77
  78                 zval_dtor(&tmp);
  79                 ZVAL_STRINGL(zv, str, len, 0);
  80         }
  81 }
  82
  83 static void sanitize_urlencoded(zval *zv TSRMLS_DC)
  84 {
  85         Z_STRLEN_P(zv) = php_raw_url_decode(Z_STRVAL_P(zv), Z_STRLEN_P(zv));
  86 }
  87
  88 static void prepare_urlencoded(zval *zv TSRMLS_DC)
  89 {
  90         int len;
  91         char *str =     php_raw_url_encode(Z_STRVAL_P(zv), Z_STRLEN_P(zv), &len);
  92
  93         zval_dtor(zv);
  94         ZVAL_STRINGL(zv, str, len, 0);
  95 }
  96
  97 static void sanitize_dimension(zval *zv TSRMLS_DC)
  98 {
  99         zval *arr = NULL, *tmp = NULL, **cur = NULL;
 100         char *var = NULL, *ptr = Z_STRVAL_P(zv), *end = Z_STRVAL_P(zv) + Z_STRLEN_P(zv);
 101         long level = 0;
 102
 103         MAKE_STD_ZVAL(arr);
 104         array_init(arr);
 105         cur = &arr;
 106
 107         while (ptr < end) {
 108                 if (!var) {
 109                         var = ptr;
 110                 }
 111
 112                 switch (*ptr) {
 113                         case '[':
 114                                 if (++level > PG(max_input_nesting_level)) {
 115                                         zval_ptr_dtor(&arr);
 116                                         php_http_error(HE_WARNING, PHP_HTTP_E_QUERYSTRING, "Max input nesting level of %ld exceeded", PG(max_input_nesting_level));
 117                                         return;
 118                                 }
 119                                 if (ptr - var == 0) {
 120                                         ++var;
 121                                         break;
 122                                 }
 123                                 /* no break */
 124
 125                         case ']':
 126
 127                                 MAKE_STD_ZVAL(tmp);
 128                                 ZVAL_NULL(tmp);
 129                                 convert_to_array(*cur);
 130
 131                                 if (ptr - var) {
 132                                         char chr = *ptr;
 133                                         *ptr = '\0';
 134                                         zend_symtable_update(Z_ARRVAL_PP(cur), var, ptr - var + 1, (void *) &tmp, sizeof(zval *), (void *) &cur);
 135                                         *ptr = chr;
 136                                 } else {
 137                                         zend_hash_next_index_insert(Z_ARRVAL_PP(cur), (void *) &tmp, sizeof(zval *), (void *) &cur);
 138                                 }
 139
 140                                 var = NULL;
 141                                 break;
 142                 }
 143
 144                 ++ptr;
 145         }
 146
 147         if (zend_hash_num_elements(Z_ARRVAL_P(arr))) {
 148                 zval_dtor(zv);
 149                 ZVAL_COPY_VALUE(zv, arr);
 150                 FREE_ZVAL(arr);
 151         } else {
 152                 zval_ptr_dtor(&arr);
 153         }
 154 }
 155
 156 static void prepare_dimension(zval *zv TSRMLS_DC)
 157 {
 158         if (Z_TYPE_P(zv) == IS_ARRAY) {
 159                 zval **zdata = &zv;
 160                 php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
 161                 php_http_buffer_t buf;
 162
 163                 php_http_buffer_init(&buf);
 164
 165                 do {
 166                         if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(Z_ARRVAL_PP(zdata), &key.str, &key.len, &key.num, key.dup, NULL)) {
 167                                 php_http_buffer_appendf(&buf, "[%s]", key.str);
 168                         } else {
 169                                 php_http_buffer_appendf(&buf, "[%lu]", key.num);
 170                         }
 171                 } while (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_PP(zdata), (void *) &zdata) && Z_TYPE_PP(zdata) == IS_ARRAY);
 172
 173                 php_http_buffer_fix(&buf);
 174                 zval_dtor(zv);
 175                 ZVAL_STRINGL(zv, buf.data, buf.used, 0);
 176         }
 177 }
 178
 179 static void sanitize_key(unsigned flags, char *str, size_t len, zval *zv TSRMLS_DC)
 180 {
 181         php_trim(str, len, NULL, 0, zv, 3 TSRMLS_CC);
 182
 183         if (flags & PHP_HTTP_PARAMS_DEFAULT) {
 184                 sanitize_default(zv TSRMLS_CC);
 185         }
 186
 187         if (flags & PHP_HTTP_PARAMS_URLENCODED) {
 188                 sanitize_urlencoded(zv TSRMLS_CC);
 189         }
 190
 191         if (flags & PHP_HTTP_PARAMS_DIMENSION) {
 192                 sanitize_dimension(zv TSRMLS_CC);
 193         }
 194 }
 195
 196 static void sanitize_value(unsigned flags, char *str, size_t len, zval *zv TSRMLS_DC)
 197 {
 198         php_trim(str, len, NULL, 0, zv, 3 TSRMLS_CC);
 199
 200         if (flags & PHP_HTTP_PARAMS_DEFAULT) {
 201                 sanitize_default(zv TSRMLS_CC);
 202         }
 203
 204         if (flags & PHP_HTTP_PARAMS_URLENCODED) {
 205                 sanitize_urlencoded(zv TSRMLS_CC);
 206         }
 207 }
 208
 209 static void prepare_key(unsigned flags, char *old_key, size_t old_len, char **new_key, size_t *new_len TSRMLS_DC)
 210 {
 211         zval zv;
 212
 213         INIT_PZVAL(&zv);
 214         ZVAL_STRINGL(&zv, old_key, old_len, 1);
 215
 216         if (flags & PHP_HTTP_PARAMS_DIMENSION) {
 217                 prepare_dimension(&zv TSRMLS_CC);
 218         }
 219
 220         if (flags & PHP_HTTP_PARAMS_URLENCODED) {
 221                 prepare_urlencoded(&zv TSRMLS_CC);
 222         }
 223
 224         if (flags & PHP_HTTP_PARAMS_DEFAULT) {
 225                 prepare_default(&zv TSRMLS_CC);
 226         }
 227
 228         *new_key = Z_STRVAL(zv);
 229         *new_len = Z_STRLEN(zv);
 230 }
 231
 232 static void prepare_value(unsigned flags, zval *zv TSRMLS_DC)
 233 {
 234         if (flags & PHP_HTTP_PARAMS_DIMENSION) {
 235                 prepare_dimension(zv TSRMLS_CC);
 236         }
 237
 238         if (flags & PHP_HTTP_PARAMS_URLENCODED) {
 239                 prepare_urlencoded(zv TSRMLS_CC);
 240         }
 241
 242         if (flags & PHP_HTTP_PARAMS_DEFAULT) {
 243                 prepare_default(zv TSRMLS_CC);
 244         }
 245 }
 246
 247 static void merge_param(HashTable *params, zval *zdata, zval ***cur TSRMLS_DC)
 248 {
 249         zval **ptr, **zdata_ptr;
 250         php_http_array_hashkey_t hkey = php_http_array_hashkey_init(0);
 251
 252 #if 0
 253         {
 254                 zval tmp;
 255                 INIT_PZVAL_ARRAY(&tmp, params);
 256                 fprintf(stderr, "params = ");
 257                 zend_print_zval_r(&tmp, 1 TSRMLS_CC);
 258                 fprintf(stderr, "\n");
 259         }
 260 #endif
 261
 262         hkey.type = zend_hash_get_current_key_ex(Z_ARRVAL_P(zdata), &hkey.str, &hkey.len, &hkey.num, hkey.dup, NULL);
 263
 264         if ((hkey.type == HASH_KEY_IS_STRING && !zend_hash_exists(params, hkey.str, hkey.len))
 265         ||      (hkey.type == HASH_KEY_IS_LONG && !zend_hash_index_exists(params, hkey.num))
 266         ) {
 267                 zval *tmp;
 268
 269                 /* create the entry if it doesn't exist */
 270                 zend_hash_get_current_data(Z_ARRVAL_P(zdata), (void *) &ptr);
 271                 Z_ADDREF_PP(ptr);
 272                 MAKE_STD_ZVAL(tmp);
 273                 array_init(tmp);
 274                 add_assoc_zval_ex(tmp, ZEND_STRS("value"), *ptr);
 275
 276                 if (hkey.type == HASH_KEY_IS_STRING) {
 277                         zend_hash_update(params, hkey.str, hkey.len, (void *) &tmp, sizeof(zval *), (void *) &ptr);
 278                 } else {
 279                         zend_hash_index_update(params, hkey.num, (void *) &tmp, sizeof(zval *), (void *) &ptr);
 280                 }
 281         } else {
 282                 /* merge */
 283                 if (hkey.type == HASH_KEY_IS_STRING) {
 284                         zend_hash_find(params, hkey.str, hkey.len, (void *) &ptr);
 285                 } else {
 286                         zend_hash_index_find(params, hkey.num, (void *) &ptr);
 287                 }
 288
 289                 zdata_ptr = &zdata;
 290
 291                 if (Z_TYPE_PP(ptr) == IS_ARRAY
 292                 &&      SUCCESS == zend_hash_find(Z_ARRVAL_PP(ptr), "value", sizeof("value"), (void *) &ptr)
 293                 &&      SUCCESS == zend_hash_get_current_data(Z_ARRVAL_PP(zdata_ptr), (void *) &zdata_ptr)
 294                 ) {
 295                         /*
 296                          * params = [arr => [value => [0 => 1]]]
 297                          *                            ^- ptr
 298                          * zdata  = [arr => [0 => NULL]]
 299                          *                  ^- zdata_ptr
 300                          */
 301                         zval **test_ptr;
 302
 303                         while (Z_TYPE_PP(zdata_ptr) == IS_ARRAY
 304                         &&      SUCCESS == zend_hash_get_current_data(Z_ARRVAL_PP(zdata_ptr), (void *) &test_ptr)
 305                         ) {
 306                                 if (Z_TYPE_PP(test_ptr) == IS_ARRAY) {
 307
 308                                         /* now find key in ptr */
 309                                         if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(Z_ARRVAL_PP(zdata_ptr), &hkey.str, &hkey.len, &hkey.num, hkey.dup, NULL)) {
 310                                                 if (SUCCESS == zend_hash_find(Z_ARRVAL_PP(ptr), hkey.str, hkey.len, (void *) &ptr)) {
 311                                                         zdata_ptr = test_ptr;
 312                                                 } else {
 313                                                         Z_ADDREF_PP(test_ptr);
 314                                                         zend_hash_update(Z_ARRVAL_PP(ptr), hkey.str, hkey.len, (void *) test_ptr, sizeof(zval *), (void *) &ptr);
 315                                                         break;
 316                                                 }
 317                                         } else {
 318                                                 if (SUCCESS == zend_hash_find(Z_ARRVAL_PP(ptr), hkey.str, hkey.len, (void *) &ptr)) {
 319                                                         zdata_ptr = test_ptr;
 320                                                 } else if (hkey.num) {
 321                                                         Z_ADDREF_PP(test_ptr);
 322                                                         zend_hash_index_update(Z_ARRVAL_PP(ptr), hkey.num, (void *) test_ptr, sizeof(zval *), (void *) &ptr);
 323                                                         break;
 324                                                 } else {
 325                                                         Z_ADDREF_PP(test_ptr);
 326                                                         zend_hash_next_index_insert(Z_ARRVAL_PP(ptr), (void *) test_ptr, sizeof(zval *), (void *) &ptr);
 327                                                         break;
 328                                                 }
 329                                         }
 330                                 } else {
 331                                         /* this is the leaf */
 332                                         Z_ADDREF_PP(test_ptr);
 333                                         if (Z_TYPE_PP(ptr) != IS_ARRAY) {
 334                                                 zval_dtor(*ptr);
 335                                                 array_init(*ptr);
 336                                         }
 337                                         if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(Z_ARRVAL_PP(zdata_ptr), &hkey.str, &hkey.len, &hkey.num, hkey.dup, NULL)) {
 338                                                 zend_hash_update(Z_ARRVAL_PP(ptr), hkey.str, hkey.len, (void *) test_ptr, sizeof(zval *), (void *) &ptr);
 339                                         } else if (hkey.num) {
 340                                                 zend_hash_index_update(Z_ARRVAL_PP(ptr), hkey.num, (void *) test_ptr, sizeof(zval *), (void *) &ptr);
 341                                         } else {
 342                                                 zend_hash_next_index_insert(Z_ARRVAL_PP(ptr), (void *) test_ptr, sizeof(zval *), (void *) &ptr);
 343                                         }
 344                                         break;
 345                                 }
 346                         }
 347
 348                 }
 349         }
 350
 351         /* bubble up */
 352         while (Z_TYPE_PP(ptr) == IS_ARRAY && SUCCESS == zend_hash_get_current_data(Z_ARRVAL_PP(ptr), (void *) &ptr));
 353         *cur = ptr;
 354 }
 355
 356 static void push_param(HashTable *params, php_http_params_state_t *state, const php_http_params_opts_t *opts TSRMLS_DC)
 357 {
 358         if (state->val.str) {
 359                 if (0 < (state->val.len = state->input.str - state->val.str)) {
 360                         sanitize_value(opts->flags, state->val.str, state->val.len, *(state->current.val) TSRMLS_CC);
 361                 }
 362         } else if (state->arg.str) {
 363                 if (0 < (state->arg.len = state->input.str - state->arg.str)) {
 364                         zval *val, key;
 365
 366                         INIT_PZVAL(&key);
 367                         sanitize_key(opts->flags, state->arg.str, state->arg.len, &key TSRMLS_CC);
 368                         if (Z_STRLEN(key)) {
 369                                 MAKE_STD_ZVAL(val);
 370                                 ZVAL_TRUE(val);
 371                                 zend_symtable_update(Z_ARRVAL_PP(state->current.args), Z_STRVAL(key), Z_STRLEN(key) + 1, (void *) &val, sizeof(zval *), (void *) &state->current.val);
 372                         }
 373                         zval_dtor(&key);
 374                 }
 375         } else if (state->param.str) {
 376                 if (0 < (state->param.len = state->input.str - state->param.str)) {
 377                         zval *prm, *arg, *val, *key;
 378
 379                         MAKE_STD_ZVAL(key);
 380                         ZVAL_NULL(key);
 381                         sanitize_key(opts->flags, state->param.str, state->param.len, key TSRMLS_CC);
 382                         if (Z_TYPE_P(key) != IS_STRING) {
 383                                 merge_param(params, key, &state->current.val TSRMLS_CC);
 384                         } else if (Z_STRLEN_P(key)) {
 385                                 MAKE_STD_ZVAL(prm);
 386                                 array_init(prm);
 387
 388                                 MAKE_STD_ZVAL(val);
 389                                 if (opts->defval) {
 390                                         ZVAL_COPY_VALUE(val, opts->defval);
 391                                         zval_copy_ctor(val);
 392                                 } else {
 393                                         ZVAL_TRUE(val);
 394                                 }
 395                                 zend_hash_update(Z_ARRVAL_P(prm), "value", sizeof("value"), (void *) &val, sizeof(zval *), (void *) &state->current.val);
 396
 397                                 MAKE_STD_ZVAL(arg);
 398                                 array_init(arg);
 399                                 zend_hash_update(Z_ARRVAL_P(prm), "arguments", sizeof("arguments"), (void *) &arg, sizeof(zval *), (void *) &state->current.args);
 400
 401                                 zend_symtable_update(params, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void *) &prm, sizeof(zval *), (void *) &state->current.param);
 402                         }
 403                         zval_ptr_dtor(&key);
 404                 }
 405         }
 406 }
 407
 408 static inline zend_bool check_str(const char *chk_str, size_t chk_len, const char *sep_str, size_t sep_len) {
 409         return 0 < sep_len && chk_len >= sep_len && !memcmp(chk_str, sep_str, sep_len);
 410 }
 411
 412 static size_t check_sep(php_http_params_state_t *state, php_http_params_token_t **separators)
 413 {
 414         php_http_params_token_t **sep = separators;
 415
 416         if (sep) while (*sep) {
 417                 if (check_str(state->input.str, state->input.len, (*sep)->str, (*sep)->len)) {
 418                         return (*sep)->len;
 419                 }
 420                 ++sep;
 421         }
 422         return 0;
 423 }
 424
 425 static void skip_sep(size_t skip, php_http_params_state_t *state, php_http_params_token_t **param, php_http_params_token_t **arg, php_http_params_token_t **val TSRMLS_DC)
 426 {
 427         size_t sep_len;
 428
 429         state->input.str += skip;
 430         state->input.len -= skip;
 431
 432         while ( (param && (sep_len = check_sep(state, param)))
 433         ||              (arg && (sep_len = check_sep(state, arg)))
 434         ||              (val && (sep_len = check_sep(state, val)))
 435         ) {
 436                 state->input.str += sep_len;
 437                 state->input.len -= sep_len;
 438         }
 439 }
 440
 441 PHP_HTTP_API HashTable *php_http_params_parse(HashTable *params, const php_http_params_opts_t *opts TSRMLS_DC)
 442 {
 443         php_http_params_state_t state = {{NULL,0}, {NULL,0}, {NULL,0}, {NULL,0}, {NULL,NULL,NULL}};
 444
 445         state.input.str = opts->input.str;
 446         state.input.len = opts->input.len;
 447
 448         if (!params) {
 449                 ALLOC_HASHTABLE(params);
 450                 ZEND_INIT_SYMTABLE(params);
 451         }
 452
 453         while (state.input.len) {
 454                 if (*state.input.str == '\\') {
 455                         ++state.input.str;
 456                         --state.input.len;
 457                 } else if (!state.param.str) {
 458                         /* initialize */
 459                         skip_sep(0, &state, opts->param, opts->arg, opts->val TSRMLS_CC);
 460                         state.param.str = state.input.str;
 461                 } else {
 462                         size_t sep_len;
 463                         /* are we at a param separator? */
 464                         if (0 < (sep_len = check_sep(&state, opts->param))) {
 465                                 push_param(params, &state, opts TSRMLS_CC);
 466
 467                                 skip_sep(sep_len, &state, opts->param, opts->arg, opts->val TSRMLS_CC);
 468
 469                                 /* start off with a new param */
 470                                 state.param.str = state.input.str;
 471                                 state.param.len = 0;
 472                                 state.arg.str = NULL;
 473                                 state.arg.len = 0;
 474                                 state.val.str = NULL;
 475                                 state.val.len = 0;
 476
 477                                 continue;
 478
 479                         } else
 480                         /* are we at an arg separator? */
 481                         if (0 < (sep_len = check_sep(&state, opts->arg))) {
 482                                 push_param(params, &state, opts TSRMLS_CC);
 483
 484                                 skip_sep(sep_len, &state, NULL, opts->arg, opts->val TSRMLS_CC);
 485
 486                                 /* continue with a new arg */
 487                                 state.arg.str = state.input.str;
 488                                 state.arg.len = 0;
 489                                 state.val.str = NULL;
 490                                 state.val.len = 0;
 491
 492                                 continue;
 493
 494                         } else
 495                         /* are we at a val separator? */
 496                         if (0 < (sep_len = check_sep(&state, opts->val))) {
 497                                 /* only handle separator if we're not already reading in a val */
 498                                 if (!state.val.str) {
 499                                         push_param(params, &state, opts TSRMLS_CC);
 500
 501                                         skip_sep(sep_len, &state, NULL, NULL, opts->val TSRMLS_CC);
 502
 503                                         state.val.str = state.input.str;
 504                                         state.val.len = 0;
 505
 506                                         continue;
 507                                 }
 508                         }
 509                 }
 510
 511                 if (state.input.len) {
 512                         ++state.input.str;
 513                         --state.input.len;
 514                 }
 515         }
 516         /* finalize */
 517         push_param(params, &state, opts TSRMLS_CC);
 518
 519         return params;
 520 }
 521
 522 static void shift_param(php_http_buffer_t *buf, char *key_str, size_t key_len, zval **zvalue, const char *css, size_t csl, const char *vss, size_t vsl, unsigned flags TSRMLS_DC)
 523 {
 524         if (Z_TYPE_PP(zvalue) == IS_ARRAY) {
 525                 zval *tmp = php_http_zsep(1, IS_ARRAY, *zvalue);
 526
 527                 do {
 528                         char *str;
 529                         size_t len;
 530                         zval *tmp2;
 531
 532                         if (PHP_HTTP_BUFFER_LEN(buf)) {
 533                                 php_http_buffer_append(buf, css, csl);
 534                         }
 535
 536                         prepare_key(flags, key_str, key_len, &str, &len TSRMLS_CC);
 537                         php_http_buffer_append(buf, str, len);
 538                         efree(str);
 539
 540                         tmp2 = php_http_zsep(1, IS_ARRAY, tmp);
 541                         prepare_value(flags, tmp2 TSRMLS_CC);
 542                         php_http_buffer_append(buf, Z_STRVAL_P(tmp2), Z_STRLEN_P(tmp2));
 543                         zval_ptr_dtor(&tmp2);
 544
 545                         zvalue = &tmp;
 546                         while (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_PP(zvalue), (void *) &zvalue) && Z_TYPE_PP(zvalue) == IS_ARRAY);
 547
 548                         if (Z_TYPE_PP(zvalue) != IS_BOOL) {
 549                                 php_http_buffer_append(buf, vss, vsl);
 550
 551                                 tmp2 = php_http_ztyp(IS_STRING, *zvalue);
 552                                 prepare_value(flags, tmp2 TSRMLS_CC);
 553                                 php_http_buffer_append(buf, Z_STRVAL_P(tmp2), Z_STRLEN_P(tmp2));
 554                                 zval_ptr_dtor(&tmp2);
 555                         } else if (!Z_BVAL_PP(zvalue)) {
 556                                 php_http_buffer_append(buf, vss, vsl);
 557                                 php_http_buffer_appends(buf, "0");
 558                         }
 559
 560                 } while (SUCCESS == zend_hash_move_forward(Z_ARRVAL_P(tmp)) && SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(tmp), (void *) &zvalue));
 561
 562                 zval_ptr_dtor(&tmp);
 563
 564         } else {
 565                 zval *tmp;
 566                 char *str;
 567                 size_t len;
 568
 569                 if (PHP_HTTP_BUFFER_LEN(buf)) {
 570                         php_http_buffer_append(buf, css, csl);
 571                 }
 572
 573                 prepare_key(flags, key_str, key_len, &str, &len TSRMLS_CC);
 574                 php_http_buffer_append(buf, str, len);
 575                 efree(str);
 576
 577                 if (Z_TYPE_PP(zvalue) != IS_BOOL) {
 578                         tmp = php_http_ztyp(IS_STRING, *zvalue);
 579                         prepare_value(flags, tmp TSRMLS_CC);
 580                         php_http_buffer_append(buf, vss, vsl);
 581                         php_http_buffer_append(buf, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
 582                         zval_ptr_dtor(&tmp);
 583                 } else if (!Z_BVAL_PP(zvalue)) {
 584                         php_http_buffer_append(buf, vss, vsl);
 585                         php_http_buffer_appends(buf, "0");
 586                 }
 587         }
 588 }
 589
 590 PHP_HTTP_API php_http_buffer_t *php_http_params_to_string(php_http_buffer_t *buf, HashTable *params, const char *pss, size_t psl, const char *ass, size_t asl, const char *vss, size_t vsl, unsigned flags TSRMLS_DC)
 591 {
 592         zval **zparam;
 593         HashPosition pos, pos1;
 594         php_http_array_hashkey_t key = php_http_array_hashkey_init(0), key1 = php_http_array_hashkey_init(0);
 595
 596         if (!buf) {
 597                 buf = php_http_buffer_init(NULL);
 598         }
 599
 600         FOREACH_HASH_KEYVAL(pos, params, key, zparam) {
 601                 zval **zvalue, **zargs;
 602
 603                 if (Z_TYPE_PP(zparam) != IS_ARRAY || SUCCESS != zend_hash_find(Z_ARRVAL_PP(zparam), ZEND_STRS("value"), (void *) &zvalue)) {
 604                         zvalue = zparam;
 605                 }
 606
 607                 php_http_array_hashkey_stringify(&key);
 608                 shift_param(buf, key.str, key.len - 1, zvalue, pss, psl, vss, vsl, flags TSRMLS_CC);
 609                 php_http_array_hashkey_stringfree(&key);
 610
 611                 if (Z_TYPE_PP(zparam) == IS_ARRAY && SUCCESS != zend_hash_find(Z_ARRVAL_PP(zparam), ZEND_STRS("arguments"), (void *) &zvalue)) {
 612                         zvalue = zparam;
 613                 }
 614
 615                 FOREACH_KEYVAL(pos1, *zvalue, key1, zargs) {
 616                         if (zvalue == zparam && key1.type == HASH_KEY_IS_STRING && !strcmp(key1.str, "value")) {
 617                                 continue;
 618                         }
 619
 620                         php_http_array_hashkey_stringify(&key1);
 621                         shift_param(buf, key1.str, key1.len - 1, zargs, ass, asl, vss, vsl, flags TSRMLS_CC);
 622                         php_http_array_hashkey_stringfree(&key1);
 623                 }
 624         }
 625
 626         php_http_buffer_shrink(buf);
 627         php_http_buffer_fix(buf);
 628
 629         return buf;
 630 }
 631
 632 #define PHP_HTTP_BEGIN_ARGS(method, req_args)   PHP_HTTP_BEGIN_ARGS_EX(HttpParams, method, 0, req_args)
 633 #define PHP_HTTP_EMPTY_ARGS(method)                             PHP_HTTP_EMPTY_ARGS_EX(HttpParams, method, 0)
 634 #define PHP_HTTP_PARAMS_ME(method, visibility)  PHP_ME(HttpParams, method, PHP_HTTP_ARGS(HttpParams, method), visibility)
 635 #define PHP_HTTP_PARAMS_GME(method, visibility) PHP_ME(HttpParams, method, PHP_HTTP_ARGS(HttpParams, __getter), visibility)
 636
 637 PHP_HTTP_BEGIN_ARGS(__construct, 0)
 638         PHP_HTTP_ARG_VAL(params, 0)
 639         PHP_HTTP_ARG_VAL(param_sep, 0)
 640         PHP_HTTP_ARG_VAL(arg_sep, 0)
 641         PHP_HTTP_ARG_VAL(val_sep, 0)
 642         PHP_HTTP_ARG_VAL(flags, 0)
 643 PHP_HTTP_END_ARGS;
 644
 645 PHP_HTTP_EMPTY_ARGS(toArray);
 646 PHP_HTTP_EMPTY_ARGS(toString);
 647
 648 PHP_HTTP_BEGIN_ARGS(offsetExists, 1)
 649         PHP_HTTP_ARG_VAL(name, 0)
 650 PHP_HTTP_END_ARGS;
 651
 652 PHP_HTTP_BEGIN_ARGS(offsetUnset, 1)
 653         PHP_HTTP_ARG_VAL(name, 0)
 654 PHP_HTTP_END_ARGS;
 655
 656 PHP_HTTP_BEGIN_ARGS(offsetGet, 1)
 657         PHP_HTTP_ARG_VAL(name, 0)
 658 PHP_HTTP_END_ARGS;
 659
 660 PHP_HTTP_BEGIN_ARGS(offsetSet, 2)
 661         PHP_HTTP_ARG_VAL(name, 0)
 662         PHP_HTTP_ARG_VAL(value, 0)
 663 PHP_HTTP_END_ARGS;
 664
 665 static zend_class_entry *php_http_params_class_entry;
 666
 667 zend_class_entry *php_http_params_get_class_entry(void)
 668 {
 669         return php_http_params_class_entry;
 670 }
 671
 672 static zend_function_entry php_http_params_method_entry[] = {
 673         PHP_HTTP_PARAMS_ME(__construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR|ZEND_ACC_FINAL)
 674
 675         PHP_HTTP_PARAMS_ME(toArray, ZEND_ACC_PUBLIC)
 676         PHP_HTTP_PARAMS_ME(toString, ZEND_ACC_PUBLIC)
 677         ZEND_MALIAS(HttpParams, __toString, toString, PHP_HTTP_ARGS(HttpParams, toString), ZEND_ACC_PUBLIC)
 678
 679         PHP_HTTP_PARAMS_ME(offsetExists, ZEND_ACC_PUBLIC)
 680         PHP_HTTP_PARAMS_ME(offsetUnset, ZEND_ACC_PUBLIC)
 681         PHP_HTTP_PARAMS_ME(offsetSet, ZEND_ACC_PUBLIC)
 682         PHP_HTTP_PARAMS_ME(offsetGet, ZEND_ACC_PUBLIC)
 683
 684         EMPTY_FUNCTION_ENTRY
 685 };
 686
 687 PHP_MINIT_FUNCTION(http_params)
 688 {
 689         PHP_HTTP_REGISTER_CLASS(http, Params, http_params, php_http_object_get_class_entry(), 0);
 690
 691         zend_class_implements(php_http_params_class_entry TSRMLS_CC, 1, zend_ce_arrayaccess);
 692
 693         zend_declare_class_constant_stringl(php_http_params_class_entry, ZEND_STRL("DEF_PARAM_SEP"), ZEND_STRL(",") TSRMLS_CC);
 694         zend_declare_class_constant_stringl(php_http_params_class_entry, ZEND_STRL("DEF_ARG_SEP"), ZEND_STRL(";") TSRMLS_CC);
 695         zend_declare_class_constant_stringl(php_http_params_class_entry, ZEND_STRL("DEF_VAL_SEP"), ZEND_STRL("=") TSRMLS_CC);
 696         zend_declare_class_constant_stringl(php_http_params_class_entry, ZEND_STRL("COOKIE_PARAM_SEP"), ZEND_STRL("") TSRMLS_CC);
 697
 698         zend_declare_class_constant_long(php_http_params_class_entry, ZEND_STRL("PARSE_RAW"), PHP_HTTP_PARAMS_RAW TSRMLS_CC);
 699         zend_declare_class_constant_long(php_http_params_class_entry, ZEND_STRL("PARSE_DEFAULT"), PHP_HTTP_PARAMS_DEFAULT TSRMLS_CC);
 700         zend_declare_class_constant_long(php_http_params_class_entry, ZEND_STRL("PARSE_URLENCODED"), PHP_HTTP_PARAMS_URLENCODED TSRMLS_CC);
 701         zend_declare_class_constant_long(php_http_params_class_entry, ZEND_STRL("PARSE_DIMENSION"), PHP_HTTP_PARAMS_DIMENSION TSRMLS_CC);
 702         zend_declare_class_constant_long(php_http_params_class_entry, ZEND_STRL("PARSE_QUERY"), PHP_HTTP_PARAMS_QUERY TSRMLS_CC);
 703
 704         zend_declare_property_null(php_http_params_class_entry, ZEND_STRL("params"), ZEND_ACC_PUBLIC TSRMLS_CC);
 705         zend_declare_property_stringl(php_http_params_class_entry, ZEND_STRL("param_sep"), ZEND_STRL(","), ZEND_ACC_PUBLIC TSRMLS_CC);
 706         zend_declare_property_stringl(php_http_params_class_entry, ZEND_STRL("arg_sep"), ZEND_STRL(";"), ZEND_ACC_PUBLIC TSRMLS_CC);
 707         zend_declare_property_stringl(php_http_params_class_entry, ZEND_STRL("val_sep"), ZEND_STRL("="), ZEND_ACC_PUBLIC TSRMLS_CC);
 708         zend_declare_property_long(php_http_params_class_entry, ZEND_STRL("flags"), PHP_HTTP_PARAMS_DEFAULT, ZEND_ACC_PUBLIC TSRMLS_CC);
 709
 710         return SUCCESS;
 711 }
 712
 713 PHP_HTTP_API php_http_params_token_t **php_http_params_separator_init(zval *zv TSRMLS_DC)
 714 {
 715         zval **sep;
 716         HashPosition pos;
 717         php_http_params_token_t **ret, **tmp;
 718
 719         if (!zv) {
 720                 return NULL;
 721         }
 722
 723         zv = php_http_ztyp(IS_ARRAY, zv);
 724         ret = ecalloc(zend_hash_num_elements(Z_ARRVAL_P(zv)) + 1, sizeof(*ret));
 725
 726         tmp = ret;
 727         FOREACH_VAL(pos, zv, sep) {
 728                 zval *zt = php_http_ztyp(IS_STRING, *sep);
 729
 730                 if (Z_STRLEN_P(zt)) {
 731                         *tmp = emalloc(sizeof(**tmp));
 732                         (*tmp)->str = estrndup(Z_STRVAL_P(zt), (*tmp)->len = Z_STRLEN_P(zt));
 733                         ++tmp;
 734                 }
 735                 zval_ptr_dtor(&zt);
 736         }
 737         zval_ptr_dtor(&zv);
 738
 739         *tmp = NULL;
 740         return ret;
 741 }
 742
 743 PHP_HTTP_API void php_http_params_separator_free(php_http_params_token_t **separator)
 744 {
 745         php_http_params_token_t **sep = separator;
 746         if (sep) {
 747                 while (*sep) {
 748                         STR_FREE((*sep)->str);
 749                         efree(*sep);
 750                         ++sep;
 751                 }
 752                 efree(separator);
 753         }
 754 }
 755
 756 PHP_METHOD(HttpParams, __construct)
 757 {
 758         with_error_handling(EH_THROW, php_http_exception_get_class_entry()) {
 759                 zval *zcopy, *zparams = NULL, *param_sep = NULL, *arg_sep = NULL, *val_sep = NULL;
 760                 long flags = PHP_HTTP_PARAMS_DEFAULT;
 761
 762                 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z!/z/z/z/l", &zparams, &param_sep, &arg_sep, &val_sep, &flags)) {
 763                         switch (ZEND_NUM_ARGS()) {
 764                                 case 5:
 765                                         zend_update_property_long(php_http_params_class_entry, getThis(), ZEND_STRL("flags"), flags TSRMLS_CC);
 766                                         /* no break */
 767                                 case 4:
 768                                         zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("val_sep"), val_sep TSRMLS_CC);
 769                                         /* no break */
 770                                 case 3:
 771                                         zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("arg_sep"), arg_sep TSRMLS_CC);
 772                                         /* no break */
 773                                 case 2:
 774                                         zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("param_sep"), param_sep TSRMLS_CC);
 775                                         /* no break */
 776                         }
 777
 778                         if (zparams) {
 779                                 switch (Z_TYPE_P(zparams)) {
 780                                         case IS_OBJECT:
 781                                         case IS_ARRAY:
 782                                                 zcopy = php_http_zsep(1, IS_ARRAY, zparams);
 783                                                 zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), zcopy TSRMLS_CC);
 784                                                 zval_ptr_dtor(&zcopy);
 785                                                 break;
 786                                         default:
 787                                                 zcopy = php_http_ztyp(IS_STRING, zparams);
 788                                                 if (Z_STRLEN_P(zcopy)) {
 789                                                         php_http_params_opts_t opts = {
 790                                                                 .input = {
 791                                                                         .str = Z_STRVAL_P(zcopy),
 792                                                                         .len = Z_STRLEN_P(zcopy)
 793                                                                 },
 794                                                                 .param = php_http_params_separator_init(zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("param_sep"), 0 TSRMLS_CC) TSRMLS_CC),
 795                                                                 .arg = php_http_params_separator_init(zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("arg_sep"), 0 TSRMLS_CC) TSRMLS_CC),
 796                                                                 .val = php_http_params_separator_init(zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("val_sep"), 0 TSRMLS_CC) TSRMLS_CC),
 797                                                                 .flags = flags
 798                                                         };
 799
 800                                                         MAKE_STD_ZVAL(zparams);
 801                                                         array_init(zparams);
 802                                                         php_http_params_parse(Z_ARRVAL_P(zparams), &opts TSRMLS_CC);
 803                                                         zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), zparams TSRMLS_CC);
 804                                                         zval_ptr_dtor(&zparams);
 805
 806                                                         php_http_params_separator_free(opts.param);
 807                                                         php_http_params_separator_free(opts.arg);
 808                                                         php_http_params_separator_free(opts.val);
 809                                                 }
 810                                                 zval_ptr_dtor(&zcopy);
 811                                                 break;
 812                                 }
 813                         } else {
 814                                 MAKE_STD_ZVAL(zparams);
 815                                 array_init(zparams);
 816                                 zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), zparams TSRMLS_CC);
 817                                 zval_ptr_dtor(&zparams);
 818                         }
 819                 }
 820         } end_error_handling();
 821 }
 822
 823 PHP_METHOD(HttpParams, toArray)
 824 {
 825         if (SUCCESS != zend_parse_parameters_none()) {
 826                 RETURN_FALSE;
 827         }
 828         RETURN_PROP(php_http_params_class_entry, "params");
 829 }
 830
 831 PHP_METHOD(HttpParams, toString)
 832 {
 833         zval **tmp, *zparams, *zpsep, *zasep, *zvsep, *zflags;
 834         php_http_buffer_t buf;
 835
 836         zparams = php_http_ztyp(IS_ARRAY, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC));
 837         zflags = php_http_ztyp(IS_LONG, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("flags"), 0 TSRMLS_CC));
 838         zpsep = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("param_sep"), 0 TSRMLS_CC);
 839         zasep = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("arg_sep"), 0 TSRMLS_CC);
 840         zvsep = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("val_sep"), 0 TSRMLS_CC);
 841
 842         zpsep = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("param_sep"), 0 TSRMLS_CC);
 843         if (Z_TYPE_P(zpsep) == IS_ARRAY && SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(zpsep), (void *) &tmp)) {
 844                 zpsep = php_http_ztyp(IS_STRING, *tmp);
 845         } else {
 846                 zpsep = php_http_ztyp(IS_STRING, zpsep);
 847         }
 848         zasep = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("arg_sep"), 0 TSRMLS_CC);
 849         if (Z_TYPE_P(zasep) == IS_ARRAY && SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(zasep), (void *) &tmp)) {
 850                 zasep = php_http_ztyp(IS_STRING, *tmp);
 851         } else {
 852                 zasep = php_http_ztyp(IS_STRING, zasep);
 853         }
 854         zvsep = zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("val_sep"), 0 TSRMLS_CC);
 855         if (Z_TYPE_P(zvsep) == IS_ARRAY && SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(zvsep), (void *) &tmp)) {
 856                 zvsep = php_http_ztyp(IS_STRING, *tmp);
 857         } else {
 858                 zvsep = php_http_ztyp(IS_STRING, zvsep);
 859         }
 860
 861         php_http_buffer_init(&buf);
 862         php_http_params_to_string(&buf, Z_ARRVAL_P(zparams), Z_STRVAL_P(zpsep), Z_STRLEN_P(zpsep), Z_STRVAL_P(zasep), Z_STRLEN_P(zasep), Z_STRVAL_P(zvsep), Z_STRLEN_P(zvsep), Z_LVAL_P(zflags) TSRMLS_CC);
 863
 864         zval_ptr_dtor(&zparams);
 865         zval_ptr_dtor(&zpsep);
 866         zval_ptr_dtor(&zasep);
 867         zval_ptr_dtor(&zvsep);
 868         zval_ptr_dtor(&zflags);
 869
 870         RETVAL_PHP_HTTP_BUFFER_VAL(&buf);
 871 }
 872
 873 PHP_METHOD(HttpParams, offsetExists)
 874 {
 875         char *name_str;
 876         int name_len;
 877
 878         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name_str, &name_len)) {
 879                 zval **zparam, *zparams = php_http_ztyp(IS_ARRAY, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC));
 880
 881                 if (SUCCESS == zend_symtable_find(Z_ARRVAL_P(zparams), name_str, name_len + 1, (void *) &zparam)) {
 882                         RETVAL_BOOL(Z_TYPE_PP(zparam) != IS_NULL);
 883                 } else {
 884                         RETVAL_FALSE;
 885                 }
 886                 zval_ptr_dtor(&zparams);
 887         }
 888 }
 889
 890 PHP_METHOD(HttpParams, offsetGet)
 891 {
 892         char *name_str;
 893         int name_len;
 894
 895         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name_str, &name_len)) {
 896                 zval **zparam, *zparams = php_http_ztyp(IS_ARRAY, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC));
 897
 898                 if (SUCCESS == zend_symtable_find(Z_ARRVAL_P(zparams), name_str, name_len + 1, (void *) &zparam)) {
 899                         RETVAL_ZVAL(*zparam, 1, 0);
 900                 }
 901
 902                 zval_ptr_dtor(&zparams);
 903         }
 904 }
 905
 906
 907 PHP_METHOD(HttpParams, offsetUnset)
 908 {
 909         char *name_str;
 910         int name_len;
 911
 912         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name_str, &name_len)) {
 913                 zval *zparams = php_http_zsep(1, IS_ARRAY, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC));
 914
 915                 zend_symtable_del(Z_ARRVAL_P(zparams), name_str, name_len + 1);
 916                 zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), zparams TSRMLS_CC);
 917
 918                 zval_ptr_dtor(&zparams);
 919         }
 920 }
 921
 922 PHP_METHOD(HttpParams, offsetSet)
 923 {
 924         zval *nvalue;
 925         char *name_str;
 926         int name_len;
 927
 928         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &name_str, &name_len, &nvalue)) {
 929                 zval **zparam, *zparams = php_http_zsep(1, IS_ARRAY, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC));
 930
 931                 if (name_len) {
 932                         if (Z_TYPE_P(nvalue) == IS_ARRAY) {
 933                                 zval *new_zparam;
 934
 935                                 if (SUCCESS == zend_symtable_find(Z_ARRVAL_P(zparams), name_str, name_len + 1, (void *) &zparam)) {
 936                                         new_zparam = php_http_zsep(1, IS_ARRAY, *zparam);
 937                                         array_join(Z_ARRVAL_P(nvalue), Z_ARRVAL_P(new_zparam), 0, 0);
 938                                 } else {
 939                                         new_zparam = nvalue;
 940                                         Z_ADDREF_P(new_zparam);
 941                                 }
 942                                 add_assoc_zval_ex(zparams, name_str, name_len + 1, new_zparam);
 943                         } else {
 944                                 zval *tmp;
 945
 946                                 if (SUCCESS == zend_symtable_find(Z_ARRVAL_P(zparams), name_str, name_len + 1, (void *) &zparam)) {
 947                                         tmp = php_http_zsep(1, IS_ARRAY, *zparam);
 948                                 } else {
 949                                         MAKE_STD_ZVAL(tmp);
 950                                         array_init(tmp);
 951                                 }
 952
 953                                 Z_ADDREF_P(nvalue);
 954                                 add_assoc_zval_ex(tmp, ZEND_STRS("value"), nvalue);
 955                                 add_assoc_zval_ex(zparams, name_str, name_len + 1, tmp);
 956                         }
 957                 } else {
 958                         zval *tmp = php_http_ztyp(IS_STRING, nvalue), *arr;
 959
 960                         MAKE_STD_ZVAL(arr);
 961                         array_init(arr);
 962                         add_assoc_bool_ex(arr, ZEND_STRS("value"), 1);
 963                         add_assoc_zval_ex(zparams, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp) + 1, arr);
 964                         zval_ptr_dtor(&tmp);
 965                 }
 966
 967                 zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), zparams TSRMLS_CC);
 968                 zval_ptr_dtor(&zparams);
 969         }
 970 }
 971
 972 /*
 973  * Local variables:
 974  * tab-width: 4
 975  * c-basic-offset: 4
 976  * End:
 977  * vim600: noet sw=4 ts=4 fdm=marker
 978  * vim<600: noet sw=4 ts=4
 979  */
 980