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