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