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