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