git.m6w6.name Git - m6w6/ext-http/blob - php_http_cookie.c

   1 /*
   2     +--------------------------------------------------------------------+
   3     | PECL :: http                                                       |
   4     +--------------------------------------------------------------------+
   5     | Redistribution and use in source and binary forms, with or without |
   6     | modification, are permitted provided that the conditions mentioned |
   7     | in the accompanying LICENSE file are met.                          |
   8     +--------------------------------------------------------------------+
   9     | Copyright (c) 2004-2014, Michael Wallner <mike@php.net>            |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 #include "php_http_api.h"
  14
  15 php_http_cookie_list_t *php_http_cookie_list_init(php_http_cookie_list_t *list)
  16 {
  17         if (!list) {
  18                 list = emalloc(sizeof(*list));
  19         }
  20
  21         zend_hash_init(&list->cookies, 0, NULL, ZVAL_PTR_DTOR, 0);
  22         zend_hash_init(&list->extras, 0, NULL, ZVAL_PTR_DTOR, 0);
  23
  24         list->path = NULL;
  25         list->domain = NULL;
  26         list->expires = -1;
  27         list->max_age = -1;
  28         list->flags = 0;
  29
  30         return list;
  31 }
  32
  33 php_http_cookie_list_t *php_http_cookie_list_copy(php_http_cookie_list_t *from, php_http_cookie_list_t *to)
  34 {
  35         to = php_http_cookie_list_init(to);
  36
  37         array_copy(&from->cookies, &to->cookies);
  38         array_copy(&from->extras, &to->extras);
  39
  40         PTR_SET(to->path, from->path ? estrdup(from->path) : NULL);
  41         PTR_SET(to->domain, from->domain ? estrdup(from->domain) : NULL);
  42         to->expires = from->expires;
  43         to->max_age = from->max_age;
  44         to->flags = from->flags;
  45
  46         return to;
  47 }
  48
  49 void php_http_cookie_list_dtor(php_http_cookie_list_t *list)
  50 {
  51         if (list) {
  52                 zend_hash_destroy(&list->cookies);
  53                 zend_hash_destroy(&list->extras);
  54
  55                 PTR_SET(list->path, NULL);
  56                 PTR_SET(list->domain, NULL);
  57         }
  58 }
  59
  60
  61
  62 void php_http_cookie_list_free(php_http_cookie_list_t **list)
  63 {
  64         if (*list) {
  65                 php_http_cookie_list_dtor(*list);
  66                 efree(*list);
  67                 *list = NULL;
  68         }
  69 }
  70
  71 const char *php_http_cookie_list_get_cookie(php_http_cookie_list_t *list, const char *name, size_t name_len, zval *zcookie)
  72 {
  73         zval *cookie = zend_symtable_str_find(&list->cookies, name, name_len);
  74
  75         if (!cookie || (Z_TYPE_P(cookie) != IS_STRING)) {
  76                 return NULL;
  77         }
  78         if (zcookie) {
  79                 *zcookie = *cookie;
  80         }
  81         return Z_STRVAL_P(cookie);
  82 }
  83
  84 const char *php_http_cookie_list_get_extra(php_http_cookie_list_t *list, const char *name, size_t name_len, zval *zextra)
  85 {
  86         zval *extra = zend_symtable_str_find(&list->extras, name, name_len);
  87
  88         if (!extra || (Z_TYPE_P(extra) != IS_STRING)) {
  89                 return NULL;
  90         }
  91         if (zextra) {
  92                 *zextra = *extra;
  93         }
  94         return Z_STRVAL_P(extra);
  95 }
  96
  97 void php_http_cookie_list_add_cookie(php_http_cookie_list_t *list, const char *name, size_t name_len, const char *value, size_t value_len)
  98 {
  99         zval cookie_value;
 100
 101         ZVAL_STRINGL(&cookie_value, value, value_len);
 102         zend_symtable_str_update(&list->cookies, name, name_len, &cookie_value);
 103 }
 104
 105 void php_http_cookie_list_add_extra(php_http_cookie_list_t *list, const char *name, size_t name_len, const char *value, size_t value_len)
 106 {
 107         zval extra_value;
 108
 109         ZVAL_STRINGL(&extra_value, value, value_len);
 110         zend_symtable_str_update(&list->extras, name, name_len, &extra_value);
 111 }
 112
 113 #define _KEY_IS(s) (key->key && key->key->len == sizeof(s)-1 && !strncasecmp(key->key->val, (s), key->key->len))
 114 static void add_entry(php_http_cookie_list_t *list, char **allowed_extras, long flags, zend_hash_key *key, zval *val)
 115 {
 116         zval *arg = val;
 117
 118         Z_TRY_ADDREF_P(arg);
 119         SEPARATE_ZVAL(arg);
 120         convert_to_string(arg);
 121
 122         if (!(flags & PHP_HTTP_COOKIE_PARSE_RAW)) {
 123                 Z_STRLEN_P(arg) = php_raw_url_decode(Z_STRVAL_P(arg), Z_STRLEN_P(arg));
 124                 zend_string_forget_hash_val(Z_STR_P(arg));
 125         }
 126
 127         if _KEY_IS("path") {
 128                 PTR_SET(list->path, estrndup(Z_STRVAL_P(arg), Z_STRLEN_P(arg)));
 129         } else if _KEY_IS("domain") {
 130                 PTR_SET(list->domain, estrndup(Z_STRVAL_P(arg), Z_STRLEN_P(arg)));
 131         } else if _KEY_IS("expires") {
 132                 char *date = estrndup(Z_STRVAL_P(arg), Z_STRLEN_P(arg));
 133                 list->expires = php_parse_date(date, NULL);
 134                 efree(date);
 135         } else if _KEY_IS("max-age") {
 136                 list->max_age = strtol(Z_STRVAL_P(arg), NULL, 10);
 137         } else if _KEY_IS("secure") {
 138                 list->flags |= PHP_HTTP_COOKIE_SECURE;
 139         } else if _KEY_IS("httpOnly") {
 140                 list->flags |= PHP_HTTP_COOKIE_HTTPONLY;
 141         } else {
 142                 php_http_arrkey_t tmp = {0};
 143
 144                 php_http_arrkey_stringify(&tmp, key);
 145
 146                 /* check for extra */
 147                 if (allowed_extras) {
 148                         char **ae = allowed_extras;
 149                         for (; *ae; ++ae) {
 150                                 if (!strncasecmp(*ae, tmp.key->val, tmp.key->len)) {
 151                                         zend_symtable_update(&list->extras, tmp.key, arg);
 152                                         php_http_arrkey_dtor(&tmp);
 153                                         return;
 154                                 }
 155                         }
 156                 }
 157
 158                 /* cookie */
 159                 zend_symtable_update(&list->cookies, key->key, arg);
 160
 161                 php_http_arrkey_dtor(&tmp);
 162                 return;
 163         }
 164
 165         zval_ptr_dtor(arg);
 166 }
 167
 168 php_http_cookie_list_t *php_http_cookie_list_parse(php_http_cookie_list_t *list, const char *str, size_t len, long flags, char **allowed_extras)
 169 {
 170         php_http_params_opts_t opts;
 171         HashTable params;
 172         zend_hash_key k, arg_k;
 173         zval *param, *val, *args, *arg;
 174
 175         php_http_params_opts_default_get(&opts);
 176         opts.input.str = estrndup(str, len);
 177         opts.input.len = len;
 178         opts.param = NULL;
 179         zend_hash_init(&params, 10, NULL, ZVAL_PTR_DTOR, 0);
 180         php_http_params_parse(&params, &opts);
 181         efree(opts.input.str);
 182
 183         list = php_http_cookie_list_init(list);
 184         ZEND_HASH_FOREACH_KEY_VAL(&params, k.h, k.key, param)
 185         {
 186                 if (Z_TYPE_P(param) == IS_ARRAY) {
 187                         if ((val = zend_hash_str_find(Z_ARRVAL_P(param), ZEND_STRL("value")))) {
 188                                 add_entry(list, NULL, flags, &k, val);
 189                         }
 190                         if ((args = zend_hash_str_find(Z_ARRVAL_P(param), ZEND_STRL("arguments"))) && Z_TYPE_P(args) == IS_ARRAY) {
 191                                 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(args), arg_k.h, arg_k.key, arg) {
 192                                         add_entry(list, allowed_extras, flags, &arg_k, arg);
 193                                 } ZEND_HASH_FOREACH_END();
 194                         }
 195                 }
 196         }
 197         ZEND_HASH_FOREACH_END();
 198
 199         zend_hash_destroy(&params);
 200
 201         return list;
 202 }
 203
 204 void php_http_cookie_list_to_struct(php_http_cookie_list_t *list, zval *strct)
 205 {
 206         zval cookies, extras, tmp;
 207         HashTable *ht = HASH_OF(strct);
 208
 209         array_init_size(&cookies, zend_hash_num_elements(&list->cookies));
 210         array_copy(&list->cookies, Z_ARRVAL(cookies));
 211         zend_symtable_str_update(ht, ZEND_STRL("cookies"), &cookies);
 212
 213         array_init_size(&extras, zend_hash_num_elements(&list->extras));
 214         array_copy(&list->extras, Z_ARRVAL(extras));
 215         zend_symtable_str_update(ht, ZEND_STRL("extras"), &extras);
 216
 217         ZVAL_LONG(&tmp, list->flags);
 218         zend_symtable_str_update(ht, ZEND_STRL("flags"), &tmp);
 219         ZVAL_LONG(&tmp, list->expires);
 220         zend_symtable_str_update(ht, ZEND_STRL("expires"), &tmp);
 221         ZVAL_LONG(&tmp, list->max_age);
 222         zend_symtable_str_update(ht, ZEND_STRL("max-age"), &tmp);
 223         ZVAL_STRING(&tmp, STR_PTR(list->path));
 224         zend_symtable_str_update(ht, ZEND_STRL("path"), &tmp);
 225         ZVAL_STRING(&tmp, STR_PTR(list->domain));
 226         zend_symtable_str_update(ht, ZEND_STRL("domain"), &tmp);
 227 }
 228
 229 php_http_cookie_list_t *php_http_cookie_list_from_struct(php_http_cookie_list_t *list, zval *strct)
 230 {
 231         zval *tmp;
 232         HashTable *ht;
 233
 234         ht = HASH_OF(strct);
 235         list = php_http_cookie_list_init(list);
 236
 237         if ((tmp = zend_hash_str_find(ht, ZEND_STRL("cookies"))) && Z_TYPE_P(tmp) == IS_ARRAY){
 238                 array_copy(Z_ARRVAL_P(tmp), &list->cookies);
 239         }
 240         if ((tmp = zend_hash_str_find(ht, ZEND_STRL("extras"))) && Z_TYPE_P(tmp) == IS_ARRAY){
 241                 array_copy(Z_ARRVAL_P(tmp), &list->extras);
 242         }
 243         if ((tmp = zend_hash_str_find(ht, ZEND_STRL("flags")))) {
 244                 list->flags = zval_get_long(tmp);
 245         }
 246         if ((tmp = zend_hash_str_find(ht, ZEND_STRL("expires")))) {
 247                 if (Z_TYPE_P(tmp) == IS_LONG) {
 248                         list->expires = Z_LVAL_P(tmp);
 249                 } else {
 250                         zend_long lval;
 251                         zend_string *lstr = zval_get_string(tmp);
 252
 253                         if (IS_LONG == is_numeric_string(lstr->val, lstr->len, &lval, NULL, 0)) {
 254                                 list->expires = lval;
 255                         } else {
 256                                 list->expires = php_parse_date(lstr->val, NULL);
 257                         }
 258
 259                         zend_string_release(lstr);
 260                 }
 261         }
 262         if ((tmp = zend_hash_str_find(ht, ZEND_STRL("max-age")))) {
 263                 if (Z_TYPE_P(tmp) == IS_LONG) {
 264                         list->max_age = Z_LVAL_P(tmp);
 265                 } else {
 266                         zend_long lval;
 267                         zend_string *lstr = zval_get_string(tmp);
 268
 269                         if (IS_LONG == is_numeric_string(lstr->val, lstr->len, &lval, NULL, 0)) {
 270                                 list->max_age = lval;
 271                         }
 272
 273                         zend_string_release(lstr);
 274                 }
 275         }
 276         if ((tmp = zend_hash_str_find(ht, ZEND_STRL("path")))) {
 277                 zend_string *str = zval_get_string(tmp);
 278
 279                 list->path = estrndup(str->val, str->len);
 280                 zend_string_release(str);
 281         }
 282         if ((tmp = zend_hash_str_find(ht, ZEND_STRL("domain")))) {
 283                 zend_string *str = zval_get_string(tmp);
 284
 285                 list->domain = estrndup(str->val, str->len);
 286                 zend_string_release(str);
 287         }
 288
 289         return list;
 290 }
 291
 292 static inline void append_encoded(php_http_buffer_t *buf, const char *key, size_t key_len, const char *val, size_t val_len)
 293 {
 294         zend_string *enc_str[2];
 295
 296         enc_str[0] = php_raw_url_encode(key, key_len);
 297         enc_str[1] = php_raw_url_encode(val, val_len);
 298
 299         php_http_buffer_append(buf, enc_str[0]->val, enc_str[0]->len);
 300         php_http_buffer_appends(buf, "=");
 301         php_http_buffer_append(buf, enc_str[1]->val, enc_str[1]->len);
 302         php_http_buffer_appends(buf, "; ");
 303
 304         zend_string_release(enc_str[0]);
 305         zend_string_release(enc_str[1]);
 306 }
 307
 308 void php_http_cookie_list_to_string(php_http_cookie_list_t *list, char **str, size_t *len)
 309 {
 310         php_http_buffer_t buf;
 311         zend_hash_key key;
 312         zval *val;
 313
 314         php_http_buffer_init(&buf);
 315
 316         ZEND_HASH_FOREACH_KEY_VAL(&list->cookies, key.h, key.key, val)
 317         {
 318                 zend_string *str = zval_get_string(val);
 319                 php_http_arrkey_t arrkey = {0};
 320
 321                 php_http_arrkey_stringify(&arrkey, &key);
 322                 append_encoded(&buf, arrkey.key->val, arrkey.key->len, str->val, str->len);
 323                 php_http_arrkey_dtor(&arrkey);
 324                 zend_string_release(str);
 325         }
 326         ZEND_HASH_FOREACH_END();
 327
 328         if (list->domain && *list->domain) {
 329                 php_http_buffer_appendf(&buf, "domain=%s; ", list->domain);
 330         }
 331         if (list->path && *list->path) {
 332                 php_http_buffer_appendf(&buf, "path=%s; ", list->path);
 333         }
 334         if (list->expires >= 0) {
 335                 zend_string *date = php_format_date(ZEND_STRL(PHP_HTTP_DATE_FORMAT), list->expires, 0);
 336                 php_http_buffer_appendf(&buf, "expires=%s; ", date->val);
 337                 zend_string_release(date);
 338         }
 339         if (list->max_age >= 0) {
 340                 php_http_buffer_appendf(&buf, "max-age=%ld; ", list->max_age);
 341         }
 342
 343         ZEND_HASH_FOREACH_KEY_VAL(&list->extras, key.h, key.key, val)
 344         {
 345                 zend_string *str = zval_get_string(val);
 346                 php_http_arrkey_t arrkey;
 347
 348                 php_http_arrkey_stringify(&arrkey, &key);
 349                 append_encoded(&buf, arrkey.key->val, arrkey.key->len, str->val, str->len);
 350                 php_http_arrkey_dtor(&arrkey);
 351                 zend_string_release(str);
 352         }
 353         ZEND_HASH_FOREACH_END();
 354
 355         if (list->flags & PHP_HTTP_COOKIE_SECURE) {
 356                 php_http_buffer_appends(&buf, "secure; ");
 357         }
 358         if (list->flags & PHP_HTTP_COOKIE_HTTPONLY) {
 359                 php_http_buffer_appends(&buf, "httpOnly; ");
 360         }
 361
 362         php_http_buffer_fix(&buf);
 363         *str = buf.data;
 364         *len = buf.used;
 365 }
 366
 367
 368
 369 static zend_object_handlers php_http_cookie_object_handlers;
 370
 371 zend_object *php_http_cookie_object_new(zend_class_entry *ce)
 372 {
 373         return &php_http_cookie_object_new_ex(ce, NULL)->zo;
 374 }
 375
 376 php_http_cookie_object_t *php_http_cookie_object_new_ex(zend_class_entry *ce, php_http_cookie_list_t *list)
 377 {
 378         php_http_cookie_object_t *o;
 379
 380         if (!ce) {
 381                 ce = php_http_cookie_class_entry;
 382         }
 383
 384         o = ecalloc(sizeof(*o) + sizeof(zval) * (ce->default_properties_count - 1), 1);
 385         zend_object_std_init(&o->zo, ce);
 386         object_properties_init(&o->zo, ce);
 387         o->zo.handlers = &php_http_cookie_object_handlers;
 388
 389         if (list) {
 390                 o->list = list;
 391         }
 392
 393         return o;
 394 }
 395
 396 #define PHP_HTTP_COOKIE_OBJECT_INIT(obj) \
 397         do { \
 398                 if (!obj->list) { \
 399                         obj->list = php_http_cookie_list_init(NULL); \
 400                 } \
 401         } while(0)
 402
 403 zend_object *php_http_cookie_object_clone(zval *obj)
 404 {
 405         php_http_cookie_object_t *new_obj, *old_obj = PHP_HTTP_OBJ(NULL, obj);
 406
 407         PHP_HTTP_COOKIE_OBJECT_INIT(old_obj);
 408
 409         new_obj = php_http_cookie_object_new_ex(old_obj->zo.ce, php_http_cookie_list_copy(old_obj->list, NULL));
 410         zend_objects_clone_members(&new_obj->zo, &old_obj->zo);
 411
 412         return &new_obj->zo;
 413 }
 414
 415 void php_http_cookie_object_free(zend_object *object TSRMLS_DC)
 416 {
 417         php_http_cookie_object_t *obj = PHP_HTTP_OBJ(object, NULL);
 418
 419         php_http_cookie_list_free(&obj->list);
 420         zend_object_std_dtor(object);
 421 }
 422
 423 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie___construct, 0, 0, 0)
 424         ZEND_ARG_INFO(0, cookie_string)
 425         ZEND_ARG_INFO(0, parser_flags)
 426         ZEND_ARG_INFO(0, allowed_extras)
 427 ZEND_END_ARG_INFO();
 428 static PHP_METHOD(HttpCookie, __construct)
 429 {
 430         php_http_cookie_object_t *obj;
 431         zval *zcookie = NULL;
 432         long flags = 0;
 433         char **ae = NULL;
 434         HashTable *allowed_extras = NULL;
 435         zend_error_handling zeh;
 436
 437         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|z!lH", &zcookie, &flags, &allowed_extras), invalid_arg, return);
 438
 439         obj = PHP_HTTP_OBJ(NULL, getThis());
 440
 441         zend_replace_error_handling(EH_THROW, php_http_exception_runtime_class_entry, &zeh);
 442         if (zcookie) {
 443
 444                 if (allowed_extras && zend_hash_num_elements(allowed_extras)) {
 445                         char **ae_ptr = safe_emalloc(zend_hash_num_elements(allowed_extras) + 1, sizeof(char *), 0);
 446                         zval *val;
 447
 448                         ae = ae_ptr;
 449                         ZEND_HASH_FOREACH_VAL(allowed_extras, val)
 450                         {
 451                                 zend_string *str = zval_get_string(val);
 452
 453                                 *ae_ptr++ = estrndup(str->val, str->len);
 454                                 zend_string_release(str);
 455                         }
 456                         ZEND_HASH_FOREACH_END();
 457                         *ae_ptr = NULL;
 458                 }
 459
 460                 switch (Z_TYPE_P(zcookie)) {
 461                         case IS_OBJECT:
 462                                 if (instanceof_function(Z_OBJCE_P(zcookie), php_http_cookie_class_entry)) {
 463                                         php_http_cookie_object_t *zco = PHP_HTTP_OBJ(NULL, zcookie);
 464
 465                                         if (zco->list) {
 466                                                 obj->list = php_http_cookie_list_copy(zco->list, NULL);
 467                                         }
 468                                         break;
 469                                 }
 470                                 /* no break */
 471                         case IS_ARRAY:
 472                                 obj->list = php_http_cookie_list_from_struct(obj->list, zcookie);
 473                                 break;
 474                         default: {
 475                                 zend_string *str = zval_get_string(zcookie);
 476
 477                                 obj->list = php_http_cookie_list_parse(obj->list, str->val, str->len, flags, ae);
 478                                 zend_string_release(str);
 479                                 break;
 480                         }
 481                 }
 482
 483                 if (ae) {
 484                         char **ae_ptr;
 485
 486                         for (ae_ptr = ae; *ae_ptr; ++ae_ptr) {
 487                                 efree(*ae_ptr);
 488                         }
 489                         efree(ae);
 490                 }
 491         }
 492         zend_restore_error_handling(&zeh);
 493
 494         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 495 }
 496
 497 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getCookies, 0, 0, 0)
 498 ZEND_END_ARG_INFO();;
 499 static PHP_METHOD(HttpCookie, getCookies)
 500 {
 501         php_http_cookie_object_t *obj;
 502
 503         if (SUCCESS != zend_parse_parameters_none()) {
 504                 return;
 505         }
 506
 507         obj = PHP_HTTP_OBJ(NULL, getThis());
 508
 509         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 510
 511         array_init_size(return_value, zend_hash_num_elements(&obj->list->cookies));
 512         array_copy(&obj->list->cookies, Z_ARRVAL_P(return_value));
 513 }
 514
 515 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_setCookies, 0, 0, 0)
 516         ZEND_ARG_INFO(0, cookies)
 517 ZEND_END_ARG_INFO();
 518 static PHP_METHOD(HttpCookie, setCookies)
 519 {
 520         HashTable *cookies = NULL;
 521         php_http_cookie_object_t *obj;
 522
 523         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|H", &cookies), invalid_arg, return);
 524
 525         obj = PHP_HTTP_OBJ(NULL, getThis());
 526
 527         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 528
 529         zend_hash_clean(&obj->list->cookies);
 530         if (cookies) {
 531                 array_copy_strings(cookies, &obj->list->cookies);
 532         }
 533
 534         RETURN_ZVAL_FAST(getThis());
 535 }
 536
 537 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_addCookies, 0, 0, 1)
 538         ZEND_ARG_INFO(0, cookies)
 539 ZEND_END_ARG_INFO();
 540 static PHP_METHOD(HttpCookie, addCookies)
 541 {
 542         HashTable *cookies = NULL;
 543         php_http_cookie_object_t *obj;
 544
 545         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "H", &cookies), invalid_arg, return);
 546
 547         obj = PHP_HTTP_OBJ(NULL, getThis());
 548
 549         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 550
 551         array_join(cookies, &obj->list->cookies, 1, ARRAY_JOIN_STRONLY|ARRAY_JOIN_STRINGIFY);
 552
 553         RETVAL_ZVAL_FAST(getThis());
 554 }
 555
 556 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getExtras, 0, 0, 0)
 557 ZEND_END_ARG_INFO();
 558 static PHP_METHOD(HttpCookie, getExtras)
 559 {
 560         php_http_cookie_object_t *obj;
 561
 562         if (SUCCESS != zend_parse_parameters_none()) {
 563                 return;
 564         }
 565
 566         obj = PHP_HTTP_OBJ(NULL, getThis());
 567
 568         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 569
 570         array_init_size(return_value, zend_hash_num_elements(&obj->list->extras));
 571         array_copy(&obj->list->extras, Z_ARRVAL_P(return_value));
 572 }
 573
 574 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_setExtras, 0, 0, 0)
 575         ZEND_ARG_INFO(0, extras)
 576 ZEND_END_ARG_INFO();
 577 static PHP_METHOD(HttpCookie, setExtras)
 578 {
 579         HashTable *extras = NULL;
 580         php_http_cookie_object_t *obj;
 581
 582         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|H", &extras), invalid_arg, return);
 583
 584         obj = PHP_HTTP_OBJ(NULL, getThis());
 585
 586         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 587
 588         zend_hash_clean(&obj->list->extras);
 589         if (extras) {
 590                 array_copy_strings(extras, &obj->list->extras);
 591         }
 592
 593         RETVAL_ZVAL_FAST(getThis());
 594 }
 595
 596 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_addExtras, 0, 0, 1)
 597         ZEND_ARG_INFO(0, extras)
 598 ZEND_END_ARG_INFO();
 599 static PHP_METHOD(HttpCookie, addExtras)
 600 {
 601         HashTable *extras = NULL;
 602         php_http_cookie_object_t *obj;
 603
 604         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "H", &extras), invalid_arg, return);
 605
 606         obj = PHP_HTTP_OBJ(NULL, getThis());
 607
 608         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 609
 610         array_join(extras, &obj->list->extras, 1, ARRAY_JOIN_STRONLY|ARRAY_JOIN_STRINGIFY);
 611
 612         RETVAL_ZVAL_FAST(getThis());
 613 }
 614
 615 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getCookie, 0, 0, 1)
 616         ZEND_ARG_INFO(0, name)
 617 ZEND_END_ARG_INFO();
 618 static PHP_METHOD(HttpCookie, getCookie)
 619 {
 620         char *name_str;
 621         size_t name_len;
 622         zval zvalue;
 623         php_http_cookie_object_t *obj;
 624
 625         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name_str, &name_len)) {
 626                 return;
 627         }
 628
 629         obj = PHP_HTTP_OBJ(NULL, getThis());
 630
 631         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 632
 633         if (php_http_cookie_list_get_cookie(obj->list, name_str, name_len, &zvalue)) {
 634                 RETURN_ZVAL_FAST(&zvalue);
 635         }
 636 }
 637
 638 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_setCookie, 0, 0, 1)
 639         ZEND_ARG_INFO(0, cookie_name)
 640         ZEND_ARG_INFO(0, cookie_value)
 641 ZEND_END_ARG_INFO();
 642 static PHP_METHOD(HttpCookie, setCookie)
 643 {
 644         char *name_str, *value_str = NULL;
 645         size_t name_len, value_len = 0;
 646         php_http_cookie_object_t *obj;
 647
 648         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!", &name_str, &name_len, &value_str, &value_len), invalid_arg, return);
 649
 650         obj = PHP_HTTP_OBJ(NULL, getThis());
 651
 652         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 653
 654         if (!value_str) {
 655                 php_http_cookie_list_del_cookie(obj->list, name_str, name_len);
 656         } else {
 657                 php_http_cookie_list_add_cookie(obj->list, name_str, name_len, value_str, value_len);
 658         }
 659
 660         RETVAL_ZVAL_FAST(getThis());
 661 }
 662
 663 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_addCookie, 0, 0, 2)
 664         ZEND_ARG_INFO(0, cookie_name)
 665         ZEND_ARG_INFO(0, cookie_value)
 666 ZEND_END_ARG_INFO();
 667 static PHP_METHOD(HttpCookie, addCookie)
 668 {
 669         char *name_str, *value_str;
 670         size_t name_len, value_len;
 671         php_http_cookie_object_t *obj;
 672
 673         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &name_str, &name_len, &value_str, &value_len), invalid_arg, return);
 674
 675         obj = PHP_HTTP_OBJ(NULL, getThis());
 676
 677         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 678
 679         php_http_cookie_list_add_cookie(obj->list, name_str, name_len, value_str, value_len);
 680
 681         RETVAL_ZVAL_FAST(getThis());
 682 }
 683
 684 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getExtra, 0, 0, 1)
 685         ZEND_ARG_INFO(0, name)
 686 ZEND_END_ARG_INFO();
 687 static PHP_METHOD(HttpCookie, getExtra)
 688 {
 689         char *name_str;
 690         size_t name_len;
 691         zval zvalue;
 692         php_http_cookie_object_t *obj;
 693
 694         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name_str, &name_len)) {
 695                 return;
 696         }
 697
 698         obj = PHP_HTTP_OBJ(NULL, getThis());
 699
 700         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 701
 702         if (php_http_cookie_list_get_extra(obj->list, name_str, name_len, &zvalue)) {
 703                 RETURN_ZVAL_FAST(&zvalue);
 704         }
 705 }
 706
 707 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_setExtra, 0, 0, 1)
 708         ZEND_ARG_INFO(0, extra_name)
 709         ZEND_ARG_INFO(0, extra_value)
 710 ZEND_END_ARG_INFO();
 711 static PHP_METHOD(HttpCookie, setExtra)
 712 {
 713         char *name_str, *value_str = NULL;
 714         size_t name_len, value_len = 0;
 715         php_http_cookie_object_t *obj;
 716
 717         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!", &name_str, &name_len, &value_str, &value_len), invalid_arg, return);
 718
 719         obj = PHP_HTTP_OBJ(NULL, getThis());
 720
 721         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 722
 723         if (!value_str) {
 724                 php_http_cookie_list_del_extra(obj->list, name_str, name_len);
 725         } else {
 726                 php_http_cookie_list_add_extra(obj->list, name_str, name_len, value_str, value_len);
 727         }
 728
 729         RETVAL_ZVAL_FAST(getThis());
 730 }
 731
 732 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_addExtra, 0, 0, 2)
 733         ZEND_ARG_INFO(0, extra_name)
 734         ZEND_ARG_INFO(0, extra_value)
 735 ZEND_END_ARG_INFO();
 736 static PHP_METHOD(HttpCookie, addExtra)
 737 {
 738         char *name_str, *value_str;
 739         size_t name_len, value_len;
 740         php_http_cookie_object_t *obj;
 741
 742         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &name_str, &name_len, &value_str, &value_len), invalid_arg, return);
 743
 744         obj = PHP_HTTP_OBJ(NULL, getThis());
 745
 746         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 747
 748         php_http_cookie_list_add_extra(obj->list, name_str, name_len, value_str, value_len);
 749
 750         RETVAL_ZVAL_FAST(getThis());
 751 }
 752
 753 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getDomain, 0, 0, 0)
 754 ZEND_END_ARG_INFO();;
 755 static PHP_METHOD(HttpCookie, getDomain)
 756 {
 757         php_http_cookie_object_t *obj;
 758
 759         if (SUCCESS != zend_parse_parameters_none()) {
 760                 return;
 761         }
 762
 763         obj = PHP_HTTP_OBJ(NULL, getThis());
 764
 765         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 766
 767         if (obj->list->domain) {
 768                 RETURN_STRING(obj->list->domain);
 769         }
 770 }
 771
 772 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_setDomain, 0, 0, 0)
 773         ZEND_ARG_INFO(0, value)
 774 ZEND_END_ARG_INFO();
 775 static PHP_METHOD(HttpCookie, setDomain)
 776 {
 777         char *domain_str = NULL;
 778         size_t domain_len = 0;
 779         php_http_cookie_object_t *obj;
 780
 781         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|s!", &domain_str, &domain_len), invalid_arg, return);
 782
 783         obj = PHP_HTTP_OBJ(NULL, getThis());
 784
 785         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 786
 787         PTR_SET(obj->list->domain, domain_str ? estrndup(domain_str, domain_len) : NULL);
 788
 789         RETVAL_ZVAL_FAST(getThis());
 790 }
 791
 792 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getPath, 0, 0, 0)
 793 ZEND_END_ARG_INFO();;
 794 static PHP_METHOD(HttpCookie, getPath)
 795 {
 796         php_http_cookie_object_t *obj;
 797
 798         if (SUCCESS != zend_parse_parameters_none()) {
 799                 return;
 800         }
 801
 802         obj = PHP_HTTP_OBJ(NULL, getThis());
 803
 804         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 805
 806         if (obj->list->path) {
 807                 RETURN_STRING(obj->list->path);
 808         }
 809 }
 810
 811 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_setPath, 0, 0, 0)
 812         ZEND_ARG_INFO(0, value)
 813 ZEND_END_ARG_INFO();
 814 static PHP_METHOD(HttpCookie, setPath)
 815 {
 816         char *path_str = NULL;
 817         size_t path_len = 0;
 818         php_http_cookie_object_t *obj;
 819
 820         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|s!", &path_str, &path_len), invalid_arg, return);
 821
 822         obj = PHP_HTTP_OBJ(NULL, getThis());
 823
 824         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 825
 826         PTR_SET(obj->list->path, path_str ? estrndup(path_str, path_len) : NULL);
 827
 828         RETVAL_ZVAL_FAST(getThis());
 829 }
 830
 831 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getExpires, 0, 0, 0)
 832 ZEND_END_ARG_INFO();;
 833 static PHP_METHOD(HttpCookie, getExpires)
 834 {
 835         php_http_cookie_object_t *obj;
 836
 837         if (SUCCESS != zend_parse_parameters_none()) {
 838                 return;
 839         }
 840
 841         obj = PHP_HTTP_OBJ(NULL, getThis());
 842
 843         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 844
 845         RETURN_LONG(obj->list->expires);
 846 }
 847
 848 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_setExpires, 0, 0, 0)
 849         ZEND_ARG_INFO(0, value)
 850 ZEND_END_ARG_INFO();
 851 static PHP_METHOD(HttpCookie, setExpires)
 852 {
 853         long ts = -1;
 854         php_http_cookie_object_t *obj;
 855
 856         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &ts), invalid_arg, return);
 857
 858         obj = PHP_HTTP_OBJ(NULL, getThis());
 859
 860         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 861
 862         obj->list->expires = ts;
 863
 864         RETVAL_ZVAL_FAST(getThis());
 865 }
 866
 867 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getMaxAge, 0, 0, 0)
 868 ZEND_END_ARG_INFO();;
 869 static PHP_METHOD(HttpCookie, getMaxAge)
 870 {
 871         php_http_cookie_object_t *obj;
 872
 873         if (SUCCESS != zend_parse_parameters_none()) {
 874                 return;
 875         }
 876
 877         obj = PHP_HTTP_OBJ(NULL, getThis());
 878
 879         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 880
 881         RETURN_LONG(obj->list->max_age);
 882 }
 883
 884 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_setMaxAge, 0, 0, 0)
 885         ZEND_ARG_INFO(0, value)
 886 ZEND_END_ARG_INFO();
 887 static PHP_METHOD(HttpCookie, setMaxAge)
 888 {
 889         long ma = -1;
 890         php_http_cookie_object_t *obj;
 891
 892         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &ma), invalid_arg, return);
 893
 894         obj = PHP_HTTP_OBJ(NULL, getThis());
 895
 896         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 897
 898         obj->list->max_age = ma;
 899
 900         RETVAL_ZVAL_FAST(getThis());
 901 }
 902
 903 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_getFlags, 0, 0, 0)
 904 ZEND_END_ARG_INFO();
 905 static PHP_METHOD(HttpCookie, getFlags)
 906 {
 907         php_http_cookie_object_t *obj;
 908
 909         if (SUCCESS != zend_parse_parameters_none()) {
 910                 return;
 911         }
 912
 913         obj = PHP_HTTP_OBJ(NULL, getThis());
 914
 915         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 916
 917         RETURN_LONG(obj->list->flags);
 918 }
 919
 920 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_setFlags, 0, 0, 0)
 921         ZEND_ARG_INFO(0, value)
 922 ZEND_END_ARG_INFO();
 923 static PHP_METHOD(HttpCookie, setFlags)
 924 {
 925         long flags = 0;
 926         php_http_cookie_object_t *obj;
 927
 928         php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flags), invalid_arg, return);
 929
 930         obj = PHP_HTTP_OBJ(NULL, getThis());
 931
 932         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 933
 934         obj->list->flags = flags;
 935
 936         RETVAL_ZVAL_FAST(getThis());
 937 }
 938
 939 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_toString, 0, 0, 0)
 940 ZEND_END_ARG_INFO();;
 941 static PHP_METHOD(HttpCookie, toString)
 942 {
 943         php_http_cookie_object_t *obj;
 944         char *str;
 945         size_t len;
 946
 947         if (SUCCESS != zend_parse_parameters_none()) {
 948                 RETURN_EMPTY_STRING();
 949         }
 950
 951         obj = PHP_HTTP_OBJ(NULL, getThis());
 952
 953         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 954
 955         php_http_cookie_list_to_string(obj->list, &str, &len);
 956
 957         RETURN_NEW_STR(php_http_cs2zs(str, len));
 958 }
 959
 960 ZEND_BEGIN_ARG_INFO_EX(ai_HttpCookie_toArray, 0, 0, 0)
 961 ZEND_END_ARG_INFO();;
 962 static PHP_METHOD(HttpCookie, toArray)
 963 {
 964         php_http_cookie_object_t *obj;
 965
 966         if (SUCCESS != zend_parse_parameters_none()) {
 967                 return;
 968         }
 969
 970         obj = PHP_HTTP_OBJ(NULL, getThis());
 971
 972         PHP_HTTP_COOKIE_OBJECT_INIT(obj);
 973
 974         array_init_size(return_value, 8);
 975         php_http_cookie_list_to_struct(obj->list, return_value);
 976 }
 977
 978 static zend_function_entry php_http_cookie_methods[] = {
 979         PHP_ME(HttpCookie, __construct,   ai_HttpCookie___construct,  ZEND_ACC_PUBLIC)
 980         PHP_ME(HttpCookie, getCookies,    ai_HttpCookie_getCookies,   ZEND_ACC_PUBLIC)
 981         PHP_ME(HttpCookie, setCookies,    ai_HttpCookie_setCookies,   ZEND_ACC_PUBLIC)
 982         PHP_ME(HttpCookie, addCookies,    ai_HttpCookie_addCookies,   ZEND_ACC_PUBLIC)
 983         PHP_ME(HttpCookie, getCookie,     ai_HttpCookie_getCookie,    ZEND_ACC_PUBLIC)
 984         PHP_ME(HttpCookie, setCookie,     ai_HttpCookie_setCookie,    ZEND_ACC_PUBLIC)
 985         PHP_ME(HttpCookie, addCookie,     ai_HttpCookie_addCookie,    ZEND_ACC_PUBLIC)
 986
 987         PHP_ME(HttpCookie, getExtras,     ai_HttpCookie_getExtras,    ZEND_ACC_PUBLIC)
 988         PHP_ME(HttpCookie, setExtras,     ai_HttpCookie_setExtras,    ZEND_ACC_PUBLIC)
 989         PHP_ME(HttpCookie, addExtras,     ai_HttpCookie_addExtras,    ZEND_ACC_PUBLIC)
 990         PHP_ME(HttpCookie, getExtra,      ai_HttpCookie_getExtra,     ZEND_ACC_PUBLIC)
 991         PHP_ME(HttpCookie, setExtra,      ai_HttpCookie_setExtra,     ZEND_ACC_PUBLIC)
 992         PHP_ME(HttpCookie, addExtra,      ai_HttpCookie_addExtra,     ZEND_ACC_PUBLIC)
 993
 994         PHP_ME(HttpCookie, getDomain,     ai_HttpCookie_getDomain,    ZEND_ACC_PUBLIC)
 995         PHP_ME(HttpCookie, setDomain,     ai_HttpCookie_setDomain,    ZEND_ACC_PUBLIC)
 996         PHP_ME(HttpCookie, getPath,       ai_HttpCookie_getPath,      ZEND_ACC_PUBLIC)
 997         PHP_ME(HttpCookie, setPath,       ai_HttpCookie_setPath,      ZEND_ACC_PUBLIC)
 998         PHP_ME(HttpCookie, getExpires,    ai_HttpCookie_getExpires,   ZEND_ACC_PUBLIC)
 999         PHP_ME(HttpCookie, setExpires,    ai_HttpCookie_setExpires,   ZEND_ACC_PUBLIC)
1000         PHP_ME(HttpCookie, getMaxAge,     ai_HttpCookie_getMaxAge,    ZEND_ACC_PUBLIC)
1001         PHP_ME(HttpCookie, setMaxAge,     ai_HttpCookie_setMaxAge,    ZEND_ACC_PUBLIC)
1002         PHP_ME(HttpCookie, getFlags,      ai_HttpCookie_getFlags,     ZEND_ACC_PUBLIC)
1003         PHP_ME(HttpCookie, setFlags,      ai_HttpCookie_setFlags,     ZEND_ACC_PUBLIC)
1004
1005         PHP_ME(HttpCookie, toArray,       ai_HttpCookie_toArray,      ZEND_ACC_PUBLIC)
1006         PHP_ME(HttpCookie, toString,      ai_HttpCookie_toString,     ZEND_ACC_PUBLIC)
1007         ZEND_MALIAS(HttpCookie, __toString, toString, ai_HttpCookie_toString, ZEND_ACC_PUBLIC)
1008
1009         EMPTY_FUNCTION_ENTRY
1010 };
1011
1012 zend_class_entry *php_http_cookie_class_entry;
1013
1014 PHP_MINIT_FUNCTION(http_cookie)
1015 {
1016         zend_class_entry ce = {0};
1017
1018         INIT_NS_CLASS_ENTRY(ce, "http", "Cookie", php_http_cookie_methods);
1019         php_http_cookie_class_entry = zend_register_internal_class(&ce);
1020         php_http_cookie_class_entry->create_object = php_http_cookie_object_new;
1021         memcpy(&php_http_cookie_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1022         php_http_cookie_object_handlers.offset = XtOffsetOf(php_http_cookie_object_t, zo);
1023         php_http_cookie_object_handlers.clone_obj = php_http_cookie_object_clone;
1024         php_http_cookie_object_handlers.dtor_obj = php_http_cookie_object_free;
1025
1026         zend_declare_class_constant_long(php_http_cookie_class_entry, ZEND_STRL("PARSE_RAW"), PHP_HTTP_COOKIE_PARSE_RAW TSRMLS_CC);
1027         zend_declare_class_constant_long(php_http_cookie_class_entry, ZEND_STRL("SECURE"), PHP_HTTP_COOKIE_SECURE TSRMLS_CC);
1028         zend_declare_class_constant_long(php_http_cookie_class_entry, ZEND_STRL("HTTPONLY"), PHP_HTTP_COOKIE_HTTPONLY TSRMLS_CC);
1029
1030         return SUCCESS;
1031 }
1032
1033
1034
1035 /*
1036  * Local variables:
1037  * tab-width: 4
1038  * c-basic-offset: 4
1039  * End:
1040  * vim600: noet sw=4 ts=4 fdm=marker
1041  * vim<600: noet sw=4 ts=4
1042  */