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