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