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 };
  23
  24 PHP_HTTP_API php_http_params_opts_t *php_http_params_opts_default_get(php_http_params_opts_t *opts)
  25 {
  26         if (!opts) {
  27                 opts = emalloc(sizeof(*opts));
  28         }
  29
  30         memcpy(opts, &def_opts, sizeof(def_opts));
  31
  32         return opts;
  33 }
  34
  35 typedef struct php_http_params_state {
  36         php_http_params_token_t input;
  37         php_http_params_token_t param;
  38         php_http_params_token_t arg;
  39         php_http_params_token_t val;
  40         struct {
  41                 zval **param;
  42                 zval **args;
  43                 zval **val;
  44         } current;
  45 } php_http_params_state_t;
  46
  47 static void push_param(HashTable *params, php_http_params_state_t *state, const php_http_params_opts_t *opts TSRMLS_DC)
  48 {
  49         if (state->val.str) {
  50                 if (0 < (state->val.len = state->input.str - state->val.str)) {
  51                         php_trim(state->val.str, state->val.len, NULL, 0, *(state->current.val), 3 TSRMLS_CC);
  52                 }
  53         } else if (state->arg.str) {
  54                 if (0 < (state->arg.len = state->input.str - state->arg.str)) {
  55                         zval *val, key;
  56
  57                         INIT_PZVAL(&key);
  58                         php_trim(state->arg.str, state->arg.len, NULL, 0, &key, 3 TSRMLS_CC);
  59                         MAKE_STD_ZVAL(val);
  60                         ZVAL_TRUE(val);
  61                         zend_symtable_update(Z_ARRVAL_PP(state->current.args), Z_STRVAL(key), Z_STRLEN(key) + 1, (void *) &val, sizeof(zval *), (void *) &state->current.val);
  62
  63                         zval_dtor(&key);
  64                 }
  65         } else if (state->param.str) {
  66                 if (0 < (state->param.len = state->input.str - state->param.str)) {
  67                         zval *prm, *arg, *val, key;
  68
  69                         MAKE_STD_ZVAL(prm);
  70                         array_init(prm);
  71                         MAKE_STD_ZVAL(val);
  72                         ZVAL_TRUE(val);
  73                         zend_hash_update(Z_ARRVAL_P(prm), "value", sizeof("value"), (void *) &val, sizeof(zval *), (void *) &state->current.val);
  74
  75                         MAKE_STD_ZVAL(arg);
  76                         array_init(arg);
  77                         zend_hash_update(Z_ARRVAL_P(prm), "arguments", sizeof("arguments"), (void *) &arg, sizeof(zval *), (void *) &state->current.args);
  78
  79                         INIT_PZVAL(&key);
  80                         php_trim(state->param.str, state->param.len, NULL, 0, &key, 3 TSRMLS_CC);
  81                         zend_symtable_update(params, Z_STRVAL(key), Z_STRLEN(key) + 1, (void *) &prm, sizeof(zval *), (void *) &state->current.param);
  82
  83                         zval_dtor(&key);
  84                 }
  85         }
  86 }
  87
  88 static inline zend_bool check_str(const char *chk_str, size_t chk_len, const char *sep_str, size_t sep_len) {
  89         return 0 < sep_len && chk_len >= sep_len && !memcmp(chk_str, sep_str, sep_len);
  90 }
  91
  92 static size_t check_sep(php_http_params_state_t *state, php_http_params_token_t **separators)
  93 {
  94         php_http_params_token_t **sep = separators;
  95
  96         if (sep) while (*sep) {
  97                 if (check_str(state->input.str, state->input.len, (*sep)->str, (*sep)->len)) {
  98                         return (*sep)->len;
  99                 }
 100                 ++sep;
 101         }
 102         return 0;
 103 }
 104
 105 PHP_HTTP_API HashTable *php_http_params_parse(HashTable *params, const php_http_params_opts_t *opts TSRMLS_DC)
 106 {
 107         php_http_params_state_t state = {
 108                 .input.str = opts->input.str,
 109                 .input.len = opts->input.len,
 110                 .param.str = NULL,
 111                 .param.len = 0,
 112                 .arg.str = NULL,
 113                 .arg.len = 0,
 114                 .val.str = NULL,
 115                 .val.len = 0
 116         };
 117
 118         if (!params) {
 119                 ALLOC_HASHTABLE(params);
 120                 ZEND_INIT_SYMTABLE(params);
 121         }
 122
 123         while (state.input.len) {
 124                 if (!state.param.str) {
 125                         /* initialize */
 126                         state.param.str = state.input.str;
 127                 } else {
 128                         size_t sep_len;
 129                         /* are we at a param separator? */
 130                         if (0 < (sep_len = check_sep(&state, opts->param))) {
 131                                 push_param(params, &state, opts TSRMLS_CC);
 132
 133                                 /* start off with a new param */
 134                                 state.param.str = state.input.str + sep_len;
 135                                 state.param.len = 0;
 136                                 state.arg.str = NULL;
 137                                 state.arg.len = 0;
 138                                 state.val.str = NULL;
 139                                 state.val.len = 0;
 140                         } else
 141                         /* are we at an arg separator? */
 142                         if (0 < (sep_len = check_sep(&state, opts->arg))) {
 143                                 push_param(params, &state, opts TSRMLS_CC);
 144
 145                                 /* continue with a new arg */
 146                                 state.arg.str = state.input.str + sep_len;
 147                                 state.arg.len = 0;
 148                                 state.val.str = NULL;
 149                                 state.val.len = 0;
 150                         } else
 151                         /* are we at a val separator? */
 152                         if (0 < (sep_len = check_sep(&state, opts->val))) {
 153                                 /* only handle separator if we're not already reading in a val */
 154                                 if (!state.val.str) {
 155                                         push_param(params, &state, opts TSRMLS_CC);
 156
 157                                         state.val.str = state.input.str + sep_len;
 158                                         state.val.len = 0;
 159                                 }
 160                         }
 161                 }
 162
 163                 ++state.input.str;
 164                 --state.input.len;
 165         }
 166         /* finalize */
 167         push_param(params, &state, opts TSRMLS_CC);
 168
 169         return params;
 170 }
 171
 172 #define PHP_HTTP_BEGIN_ARGS(method, req_args)   PHP_HTTP_BEGIN_ARGS_EX(HttpParams, method, 0, req_args)
 173 #define PHP_HTTP_EMPTY_ARGS(method)                             PHP_HTTP_EMPTY_ARGS_EX(HttpParams, method, 0)
 174 #define PHP_HTTP_PARAMS_ME(method, visibility)  PHP_ME(HttpParams, method, PHP_HTTP_ARGS(HttpParams, method), visibility)
 175 #define PHP_HTTP_PARAMS_GME(method, visibility) PHP_ME(HttpParams, method, PHP_HTTP_ARGS(HttpParams, __getter), visibility)
 176
 177 PHP_HTTP_BEGIN_ARGS(__construct, 0)
 178         PHP_HTTP_ARG_VAL(params, 0)
 179         PHP_HTTP_ARG_VAL(param_sep, 0)
 180         PHP_HTTP_ARG_VAL(arg_sep, 0)
 181         PHP_HTTP_ARG_VAL(val_sep, 0)
 182 PHP_HTTP_END_ARGS;
 183
 184 PHP_HTTP_EMPTY_ARGS(toArray);
 185 PHP_HTTP_EMPTY_ARGS(toString);
 186
 187 PHP_HTTP_BEGIN_ARGS(offsetExists, 1)
 188         PHP_HTTP_ARG_VAL(name, 0)
 189 PHP_HTTP_END_ARGS;
 190
 191 PHP_HTTP_BEGIN_ARGS(offsetUnset, 1)
 192         PHP_HTTP_ARG_VAL(name, 0)
 193 PHP_HTTP_END_ARGS;
 194
 195 PHP_HTTP_BEGIN_ARGS(offsetGet, 1)
 196         PHP_HTTP_ARG_VAL(name, 0)
 197 PHP_HTTP_END_ARGS;
 198
 199 PHP_HTTP_BEGIN_ARGS(offsetSet, 2)
 200         PHP_HTTP_ARG_VAL(name, 0)
 201         PHP_HTTP_ARG_VAL(value, 0)
 202 PHP_HTTP_END_ARGS;
 203
 204 zend_class_entry *php_http_params_class_entry;
 205 zend_function_entry php_http_params_method_entry[] = {
 206         PHP_HTTP_PARAMS_ME(__construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR|ZEND_ACC_FINAL)
 207
 208         PHP_HTTP_PARAMS_ME(toArray, ZEND_ACC_PUBLIC)
 209         PHP_HTTP_PARAMS_ME(toString, ZEND_ACC_PUBLIC)
 210         ZEND_MALIAS(HttpParams, __toString, toString, PHP_HTTP_ARGS(HttpParams, toString), ZEND_ACC_PUBLIC)
 211
 212         PHP_HTTP_PARAMS_ME(offsetExists, ZEND_ACC_PUBLIC)
 213         PHP_HTTP_PARAMS_ME(offsetUnset, ZEND_ACC_PUBLIC)
 214         PHP_HTTP_PARAMS_ME(offsetSet, ZEND_ACC_PUBLIC)
 215         PHP_HTTP_PARAMS_ME(offsetGet, ZEND_ACC_PUBLIC)
 216
 217         EMPTY_FUNCTION_ENTRY
 218 };
 219
 220 PHP_MINIT_FUNCTION(http_params)
 221 {
 222         PHP_HTTP_REGISTER_CLASS(http, Params, http_params, php_http_object_class_entry, 0);
 223
 224         zend_class_implements(php_http_params_class_entry TSRMLS_CC, 1, zend_ce_arrayaccess);
 225
 226         zend_declare_class_constant_stringl(php_http_params_class_entry, ZEND_STRL("DEF_PARAM_SEP"), ZEND_STRL(",") TSRMLS_CC);
 227         zend_declare_class_constant_stringl(php_http_params_class_entry, ZEND_STRL("DEF_ARG_SEP"), ZEND_STRL(";") TSRMLS_CC);
 228         zend_declare_class_constant_stringl(php_http_params_class_entry, ZEND_STRL("DEF_VAL_SEP"), ZEND_STRL("=") TSRMLS_CC);
 229         zend_declare_class_constant_stringl(php_http_params_class_entry, ZEND_STRL("COOKIE_PARAM_SEP"), ZEND_STRL("") TSRMLS_CC);
 230
 231         zend_declare_property_null(php_http_params_class_entry, ZEND_STRL("params"), ZEND_ACC_PUBLIC TSRMLS_CC);
 232         zend_declare_property_stringl(php_http_params_class_entry, ZEND_STRL("param_sep"), ZEND_STRL(","), ZEND_ACC_PUBLIC TSRMLS_CC);
 233         zend_declare_property_stringl(php_http_params_class_entry, ZEND_STRL("arg_sep"), ZEND_STRL(";"), ZEND_ACC_PUBLIC TSRMLS_CC);
 234         zend_declare_property_stringl(php_http_params_class_entry, ZEND_STRL("val_sep"), ZEND_STRL("="), ZEND_ACC_PUBLIC TSRMLS_CC);
 235
 236         return SUCCESS;
 237 }
 238
 239 static php_http_params_token_t **parse_sep(zval *zv TSRMLS_DC)
 240 {
 241         zval **sep;
 242         HashPosition pos;
 243         php_http_params_token_t **ret, **tmp;
 244
 245         if (!zv) {
 246                 return NULL;
 247         }
 248
 249         zv = php_http_ztyp(IS_ARRAY, zv);
 250         ret = ecalloc(zend_hash_num_elements(Z_ARRVAL_P(zv)) + 1, sizeof(*ret));
 251
 252         tmp = ret;
 253         FOREACH_VAL(pos, zv, sep) {
 254                 zval *zt = php_http_ztyp(IS_STRING, *sep);
 255
 256                 if (Z_STRLEN_P(zt)) {
 257                         *tmp = emalloc(sizeof(**tmp));
 258                         (*tmp)->str = estrndup(Z_STRVAL_P(zt), (*tmp)->len = Z_STRLEN_P(zt));
 259                         ++tmp;
 260                 }
 261                 zval_ptr_dtor(&zt);
 262         }
 263         zval_ptr_dtor(&zv);
 264
 265         *tmp = NULL;
 266         return ret;
 267 }
 268
 269 static void free_sep(php_http_params_token_t **separator) {
 270         php_http_params_token_t **sep = separator;
 271         if (sep) {
 272                 while (*sep) {
 273                         STR_FREE((*sep)->str);
 274                         efree(*sep);
 275                         ++sep;
 276                 }
 277                 efree(separator);
 278         }
 279 }
 280
 281 PHP_METHOD(HttpParams, __construct)
 282 {
 283         with_error_handling(EH_THROW, php_http_exception_class_entry) {
 284                 zval *zcopy, *zparams = NULL, *param_sep = NULL, *arg_sep = NULL, *val_sep = NULL;
 285
 286                 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z!/z/z/z/", &zparams, &param_sep, &arg_sep, &val_sep)) {
 287                         switch (ZEND_NUM_ARGS()) {
 288                                 case 4:
 289                                         zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("param_sep"), param_sep TSRMLS_CC);
 290                                         /* no break */
 291                                 case 3:
 292                                         zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("arg_sep"), arg_sep TSRMLS_CC);
 293                                         /* no break */
 294                                 case 2:
 295                                         zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("val_sep"), val_sep TSRMLS_CC);
 296                                         /* no break */
 297                         }
 298
 299                         if (zparams) {
 300                                 switch (Z_TYPE_P(zparams)) {
 301                                         case IS_OBJECT:
 302                                         case IS_ARRAY:
 303                                                 zcopy = php_http_zsep(1, IS_ARRAY, zparams);
 304                                                 zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), zcopy TSRMLS_CC);
 305                                                 zval_ptr_dtor(&zcopy);
 306                                                 break;
 307                                         default:
 308                                                 zcopy = php_http_ztyp(IS_STRING, zparams);
 309                                                 if (Z_STRLEN_P(zcopy)) {
 310                                                         php_http_params_opts_t opts = {
 311                                                                 .input.str = Z_STRVAL_P(zcopy),
 312                                                                 .input.len = Z_STRLEN_P(zcopy),
 313                                                                 .param = parse_sep(zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("param_sep"), 0 TSRMLS_CC) TSRMLS_CC),
 314                                                                 .arg = parse_sep(zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("arg_sep"), 0 TSRMLS_CC) TSRMLS_CC),
 315                                                                 .val = parse_sep(zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("val_sep"), 0 TSRMLS_CC) TSRMLS_CC)
 316                                                         };
 317
 318                                                         MAKE_STD_ZVAL(zparams);
 319                                                         array_init(zparams);
 320                                                         php_http_params_parse(Z_ARRVAL_P(zparams), &opts TSRMLS_CC);
 321                                                         zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), zparams TSRMLS_CC);
 322                                                         zval_ptr_dtor(&zparams);
 323
 324                                                         free_sep(opts.param);
 325                                                         free_sep(opts.arg);
 326                                                         free_sep(opts.val);
 327                                                 }
 328                                                 zval_ptr_dtor(&zcopy);
 329                                                 break;
 330                                 }
 331                         } else {
 332                                 MAKE_STD_ZVAL(zparams);
 333                                 array_init(zparams);
 334                                 zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), zparams TSRMLS_CC);
 335                                 zval_ptr_dtor(&zparams);
 336                         }
 337                 }
 338         } end_error_handling();
 339 }
 340
 341 PHP_METHOD(HttpParams, toArray)
 342 {
 343         if (SUCCESS != zend_parse_parameters_none()) {
 344                 RETURN_FALSE;
 345         }
 346         RETURN_PROP(php_http_params_class_entry, "params");
 347 }
 348
 349 PHP_METHOD(HttpParams, toString)
 350 {
 351         zval *zparams, *zpsep, *zasep, *zvsep;
 352         zval **zparam, **zvalue, **zargs, **zarg;
 353         HashPosition pos1, pos2;
 354         php_http_array_hashkey_t key1 = php_http_array_hashkey_init(0), key2 = php_http_array_hashkey_init(0);
 355         php_http_buffer_t buf;
 356
 357         zparams = php_http_ztyp(IS_ARRAY, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC));
 358         zpsep = php_http_ztyp(IS_STRING, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("param_sep"), 0 TSRMLS_CC));
 359         zasep = php_http_ztyp(IS_STRING, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("arg_sep"), 0 TSRMLS_CC));
 360         zvsep = php_http_ztyp(IS_STRING, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("val_sep"), 0 TSRMLS_CC));
 361         php_http_buffer_init(&buf);
 362
 363         FOREACH_KEYVAL(pos1, zparams, key1, zparam) {
 364                 /* new param ? */
 365                 if (PHP_HTTP_BUFFER_LEN(&buf)) {
 366                         php_http_buffer_append(&buf, Z_STRVAL_P(zpsep), Z_STRLEN_P(zpsep));
 367                 }
 368
 369                 /* add name */
 370                 if (key1.type == HASH_KEY_IS_STRING) {
 371                         php_http_buffer_append(&buf, key1.str, key1.len - 1);
 372                 } else {
 373                         php_http_buffer_appendf(&buf, "%lu", key1.num);
 374                 }
 375
 376                 if (Z_TYPE_PP(zparam) == IS_ARRAY) {
 377                         /* got a value? */
 378                         if (SUCCESS == zend_hash_find(Z_ARRVAL_PP(zparam), ZEND_STRS("value"), (void *) &zvalue)) {
 379                                 if (Z_TYPE_PP(zvalue) != IS_BOOL) {
 380                                         zval *tmp = php_http_ztyp(IS_STRING, *zvalue);
 381
 382                                         php_http_buffer_append(&buf, Z_STRVAL_P(zvsep), Z_STRLEN_P(zvsep));
 383                                         php_http_buffer_append(&buf, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
 384                                         zval_ptr_dtor(&tmp);
 385                                 } else if (!Z_BVAL_PP(zvalue)) {
 386                                         php_http_buffer_append(&buf, Z_STRVAL_P(zvsep), Z_STRLEN_P(zvsep));
 387                                         php_http_buffer_appends(&buf, "0");
 388                                 }
 389                         }
 390                         /* add arguments */
 391                         if (SUCCESS == zend_hash_find(Z_ARRVAL_PP(zparam), ZEND_STRS("arguments"), (void *) &zargs)) {
 392                                 if (Z_TYPE_PP(zargs) == IS_ARRAY) {
 393                                         FOREACH_KEYVAL(pos2, *zargs, key2, zarg) {
 394                                                 /* new arg? */
 395                                                 if (PHP_HTTP_BUFFER_LEN(&buf)) {
 396                                                         php_http_buffer_append(&buf, Z_STRVAL_P(zasep), Z_STRLEN_P(zasep));
 397                                                 }
 398
 399                                                 /* add name */
 400                                                 if (key2.type == HASH_KEY_IS_STRING) {
 401                                                         php_http_buffer_append(&buf, key2.str, key2.len - 1);
 402                                                 } else {
 403                                                         php_http_buffer_appendf(&buf, "%lu", key2.num);
 404                                                 }
 405                                                 /* add value */
 406                                                 if (Z_TYPE_PP(zarg) != IS_BOOL) {
 407                                                         zval *tmp = php_http_ztyp(IS_STRING, *zarg);
 408
 409                                                         php_http_buffer_append(&buf, Z_STRVAL_P(zvsep), Z_STRLEN_P(zvsep));
 410                                                         php_http_buffer_append(&buf, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
 411                                                         zval_ptr_dtor(&tmp);
 412                                                 } else if (!Z_BVAL_PP(zarg)) {
 413                                                         php_http_buffer_append(&buf, Z_STRVAL_P(zvsep), Z_STRLEN_P(zvsep));
 414                                                         php_http_buffer_appends(&buf, "0");
 415                                                 }
 416                                         }
 417                                 }
 418                         }
 419                 }
 420         }
 421
 422         zval_ptr_dtor(&zparams);
 423         zval_ptr_dtor(&zpsep);
 424         zval_ptr_dtor(&zasep);
 425         zval_ptr_dtor(&zvsep);
 426
 427         php_http_buffer_shrink(&buf);
 428         RETVAL_PHP_HTTP_BUFFER_VAL(&buf);
 429 }
 430
 431 PHP_METHOD(HttpParams, offsetExists)
 432 {
 433         char *name_str;
 434         int name_len;
 435
 436         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name_str, &name_len)) {
 437                 zval **zparam, *zparams = php_http_ztyp(IS_ARRAY, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC));
 438
 439                 if (SUCCESS == zend_symtable_find(Z_ARRVAL_P(zparams), name_str, name_len + 1, (void *) &zparam)) {
 440                         RETVAL_BOOL(Z_TYPE_PP(zparam) != IS_NULL);
 441                 } else {
 442                         RETVAL_FALSE;
 443                 }
 444                 zval_ptr_dtor(&zparams);
 445         }
 446 }
 447
 448 PHP_METHOD(HttpParams, offsetGet)
 449 {
 450         char *name_str;
 451         int name_len;
 452
 453         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name_str, &name_len)) {
 454                 zval **zparam, *zparams = php_http_ztyp(IS_ARRAY, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC));
 455
 456                 if (SUCCESS == zend_symtable_find(Z_ARRVAL_P(zparams), name_str, name_len + 1, (void *) &zparam)) {
 457                         RETVAL_ZVAL(*zparam, 1, 0);
 458                 }
 459
 460                 zval_ptr_dtor(&zparams);
 461         }
 462 }
 463
 464
 465 PHP_METHOD(HttpParams, offsetUnset)
 466 {
 467         char *name_str;
 468         int name_len;
 469
 470         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name_str, &name_len)) {
 471                 zval *zparams = php_http_zsep(1, IS_ARRAY, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC));
 472
 473                 zend_symtable_del(Z_ARRVAL_P(zparams), name_str, name_len + 1);
 474                 zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), zparams TSRMLS_CC);
 475
 476                 zval_ptr_dtor(&zparams);
 477         }
 478 }
 479
 480 PHP_METHOD(HttpParams, offsetSet)
 481 {
 482         zval *nvalue;
 483         char *name_str;
 484         int name_len;
 485
 486         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &name_str, &name_len, &nvalue)) {
 487                 zval **zparam, *zparams = php_http_zsep(1, IS_ARRAY, zend_read_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), 0 TSRMLS_CC));
 488
 489                 if (name_len) {
 490                         if (Z_TYPE_P(nvalue) == IS_ARRAY) {
 491                                 zval *new_zparam;
 492
 493                                 if (SUCCESS == zend_symtable_find(Z_ARRVAL_P(zparams), name_str, name_len + 1, (void *) &zparam)) {
 494                                         new_zparam = php_http_zsep(1, IS_ARRAY, *zparam);
 495                                         array_join(Z_ARRVAL_P(nvalue), Z_ARRVAL_P(new_zparam), 0, 0);
 496                                 } else {
 497                                         new_zparam = nvalue;
 498                                         Z_ADDREF_P(new_zparam);
 499                                 }
 500                                 add_assoc_zval_ex(zparams, name_str, name_len + 1, new_zparam);
 501                         } else {
 502                                 zval *tmp;
 503
 504                                 if (SUCCESS == zend_symtable_find(Z_ARRVAL_P(zparams), name_str, name_len + 1, (void *) &zparam)) {
 505                                         tmp = php_http_zsep(1, IS_ARRAY, *zparam);
 506                                 } else {
 507                                         MAKE_STD_ZVAL(tmp);
 508                                         array_init(tmp);
 509                                 }
 510
 511                                 Z_ADDREF_P(nvalue);
 512                                 add_assoc_zval_ex(tmp, ZEND_STRS("value"), nvalue);
 513                                 add_assoc_zval_ex(zparams, name_str, name_len + 1, tmp);
 514                         }
 515                 } else {
 516                         zval *tmp = php_http_ztyp(IS_STRING, nvalue), *arr;
 517
 518                         MAKE_STD_ZVAL(arr);
 519                         array_init(arr);
 520                         add_assoc_bool_ex(arr, ZEND_STRS("value"), 1);
 521                         add_assoc_zval_ex(zparams, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp) + 1, arr);
 522                         zval_ptr_dtor(&tmp);
 523                 }
 524
 525                 zend_update_property(php_http_params_class_entry, getThis(), ZEND_STRL("params"), zparams TSRMLS_CC);
 526                 zval_ptr_dtor(&zparams);
 527         }
 528 }
 529
 530 /*
 531  * Local variables:
 532  * tab-width: 4
 533  * c-basic-offset: 4
 534  * End:
 535  * vim600: noet sw=4 ts=4 fdm=marker
 536  * vim<600: noet sw=4 ts=4
 537  */
 538