projects / m6w6 / ext-http / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
negotiation test & fixes
[m6w6/ext-http] / php_http_message_body.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 #include <ext/standard/php_lcg.h>
16
17 #define BOUNDARY_OPEN(body) \
18 do {\
19 size_t size = php_http_message_body_size(body); \
20 if (size) { \
21 php_stream_truncate_set_size(php_http_message_body_stream(body), size - lenof("--" PHP_HTTP_CRLF)); \
22 php_http_message_body_append(body, ZEND_STRL(PHP_HTTP_CRLF)); \
23 } else { \
24 php_http_message_body_appendf(body, "--%s" PHP_HTTP_CRLF, php_http_message_body_boundary(body)); \
25 } \
26 } while(0)
27 #define BOUNDARY_CLOSE(body) \
28 php_http_message_body_appendf(body, PHP_HTTP_CRLF "--%s--" PHP_HTTP_CRLF, php_http_message_body_boundary(body))
29
30 static STATUS add_recursive_fields(php_http_message_body_t *body, const char *name, zval *value);
31 static STATUS add_recursive_files(php_http_message_body_t *body, const char *name, zval *value);
32
33 PHP_HTTP_API php_http_message_body_t *php_http_message_body_init(php_http_message_body_t *body, php_stream *stream TSRMLS_DC)
34 {
35 if (!body) {
36 body = emalloc(sizeof(php_http_message_body_t));
37 }
38 memset(body, 0, sizeof(*body));
39
40 if (stream) {
41 php_stream_auto_cleanup(stream);
42 body->stream_id = php_stream_get_resource_id(stream);
43 zend_list_addref(body->stream_id);
44 } else {
45 stream = php_stream_temp_create(TEMP_STREAM_DEFAULT, 0xffff);
46 php_stream_auto_cleanup(stream);
47 body->stream_id = php_stream_get_resource_id(stream);
48 }
49 TSRMLS_SET_CTX(body->ts);
50
51 return body;
52 }
53
54 PHP_HTTP_API php_http_message_body_t *php_http_message_body_copy(php_http_message_body_t *from, php_http_message_body_t *to, zend_bool dup_internal_stream_and_contents)
55 {
56 if (!from) {
57 return NULL;
58 } else {
59 TSRMLS_FETCH_FROM_CTX(from->ts);
60
61 if (dup_internal_stream_and_contents) {
62 to = php_http_message_body_init(to, NULL TSRMLS_CC);
63 php_http_message_body_to_stream(from, php_http_message_body_stream(to), 0, 0);
64 } else {
65 to = php_http_message_body_init(to, php_http_message_body_stream(from) TSRMLS_CC);
66 }
67
68 if (from->boundary) {
69 to->boundary = estrdup(from->boundary);
70 }
71
72 return to;
73 }
74 }
75
76 PHP_HTTP_API void php_http_message_body_dtor(php_http_message_body_t *body)
77 {
78 TSRMLS_FETCH_FROM_CTX(body->ts);
79 /* NO FIXME: shows leakinfo in DEBUG mode */
80 zend_list_delete(body->stream_id);
81 STR_FREE(body->boundary);
82 }
83
84 PHP_HTTP_API void php_http_message_body_free(php_http_message_body_t **body)
85 {
86 if (*body) {
87 php_http_message_body_dtor(*body);
88 efree(*body);
89 *body = NULL;
90 }
91 }
92
93 PHP_HTTP_API const php_stream_statbuf *php_http_message_body_stat(php_http_message_body_t *body)
94 {
95 TSRMLS_FETCH_FROM_CTX(body->ts);
96 php_stream_stat(php_http_message_body_stream(body), &body->ssb);
97 return &body->ssb;
98 }
99
100 PHP_HTTP_API const char *php_http_message_body_boundary(php_http_message_body_t *body)
101 {
102 if (!body->boundary) {
103 union { double dbl; int num[2]; } data;
104 TSRMLS_FETCH_FROM_CTX(body->ts);
105
106 data.dbl = php_combined_lcg(TSRMLS_C);
107 spprintf(&body->boundary, 0, "%x.%x", data.num[0], data.num[1]);
108 }
109 return body->boundary;
110 }
111
112 PHP_HTTP_API char *php_http_message_body_etag(php_http_message_body_t *body)
113 {
114 TSRMLS_FETCH_FROM_CTX(body->ts);
115 const php_stream_statbuf *ssb = php_http_message_body_stat(body);
116
117 /* real file or temp buffer ? */
118 if (ssb && ssb->sb.st_mtime) {
119 char *etag;
120
121 spprintf(&etag, 0, "%lx-%lx-%lx", ssb->sb.st_ino, ssb->sb.st_mtime, ssb->sb.st_size);
122 return etag;
123 } else {
124 php_http_etag_t *etag = php_http_etag_init(PHP_HTTP_G->env.etag_mode TSRMLS_CC);
125
126 php_http_message_body_to_callback(body, (php_http_pass_callback_t) php_http_etag_update, etag, 0, 0);
127 return php_http_etag_finish(etag);
128 }
129 }
130
131 PHP_HTTP_API void php_http_message_body_to_string(php_http_message_body_t *body, char **buf, size_t *len, off_t offset, size_t forlen)
132 {
133 TSRMLS_FETCH_FROM_CTX(body->ts);
134 php_stream *s = php_http_message_body_stream(body);
135
136 php_stream_seek(s, offset, SEEK_SET);
137 if (!forlen) {
138 forlen = -1;
139 }
140 *len = php_stream_copy_to_mem(s, buf, forlen, 0);
141 }
142
143 PHP_HTTP_API void php_http_message_body_to_stream(php_http_message_body_t *body, php_stream *dst, off_t offset, size_t forlen)
144 {
145 TSRMLS_FETCH_FROM_CTX(body->ts);
146 php_stream *s = php_http_message_body_stream(body);
147
148 php_stream_seek(s, offset, SEEK_SET);
149 if (!forlen) {
150 forlen = -1;
151 }
152 php_stream_copy_to_stream_ex(s, dst, forlen, NULL);
153 }
154
155 PHP_HTTP_API void php_http_message_body_to_callback(php_http_message_body_t *body, php_http_pass_callback_t cb, void *cb_arg, off_t offset, size_t forlen)
156 {
157 TSRMLS_FETCH_FROM_CTX(body->ts);
158 php_stream *s = php_http_message_body_stream(body);
159 char *buf = emalloc(0x1000);
160
161 php_stream_seek(s, offset, SEEK_SET);
162
163 if (!forlen) {
164 forlen = -1;
165 }
166 while (!php_stream_eof(s)) {
167 size_t read = php_stream_read(s, buf, MIN(forlen, 0x1000));
168
169 if (read) {
170 cb(cb_arg, buf, read);
171 }
172
173 if (read < MIN(forlen, sizeof(buf))) {
174 break;
175 }
176
177 if (forlen && !(forlen -= read)) {
178 break;
179 }
180 }
181 efree(buf);
182 }
183
184 PHP_HTTP_API size_t php_http_message_body_append(php_http_message_body_t *body, const char *buf, size_t len)
185 {
186 php_stream *s;
187 TSRMLS_FETCH_FROM_CTX(body->ts);
188
189 s = php_http_message_body_stream(body);
190 php_stream_seek(s, 0, SEEK_END);
191 return php_stream_write(s, buf, len);
192 }
193
194 PHP_HTTP_API size_t php_http_message_body_appendf(php_http_message_body_t *body, const char *fmt, ...)
195 {
196 va_list argv;
197 char *print_str;
198 size_t print_len;
199
200 va_start(argv, fmt);
201 print_len = vspprintf(&print_str, 0, fmt, argv);
202 va_end(argv);
203
204 print_len = php_http_message_body_append(body, print_str, print_len);
205 efree(print_str);
206
207 return print_len;
208 }
209
210 PHP_HTTP_API STATUS php_http_message_body_add(php_http_message_body_t *body, HashTable *fields, HashTable *files)
211 {
212 zval tmp;
213
214 if (fields) {
215 INIT_PZVAL_ARRAY(&tmp, fields);
216 if (SUCCESS != add_recursive_fields(body, NULL, &tmp)) {
217 return FAILURE;
218 }
219 }
220 if (files) {
221 INIT_PZVAL_ARRAY(&tmp, files);
222 if (SUCCESS != add_recursive_files(body, NULL, &tmp)) {
223 return FAILURE;
224 }
225 }
226
227 return SUCCESS;
228 }
229
230
231 PHP_HTTP_API STATUS php_http_message_body_add_field(php_http_message_body_t *body, const char *name, const char *value_str, size_t value_len)
232 {
233 char *safe_name;
234 TSRMLS_FETCH_FROM_CTX(body->ts);
235
236 safe_name = php_addslashes(estrdup(name), strlen(name), NULL, 1 TSRMLS_CC);
237
238 BOUNDARY_OPEN(body);
239 php_http_message_body_appendf(
240 body,
241 "Content-Disposition: form-data; name=\"%s\"" PHP_HTTP_CRLF
242 "" PHP_HTTP_CRLF,
243 safe_name
244 );
245 php_http_message_body_append(body, value_str, value_len);
246 BOUNDARY_CLOSE(body);
247
248 efree(safe_name);
249 return SUCCESS;
250 }
251
252 PHP_HTTP_API STATUS php_http_message_body_add_file(php_http_message_body_t *body, const char *name, const char *ctype, const char *path, php_stream *in)
253 {
254 char *safe_name, *path_dup = estrdup(path);
255 TSRMLS_FETCH_FROM_CTX(body->ts);
256
257 safe_name = php_addslashes(estrdup(name), strlen(name), NULL, 1 TSRMLS_CC);
258
259 BOUNDARY_OPEN(body);
260 php_http_message_body_appendf(
261 body,
262 "Content-Disposition: attachment; name=\"%s\"; filename=\"%s\"" PHP_HTTP_CRLF
263 "Content-Transfer-Encoding: binary" PHP_HTTP_CRLF
264 "Content-Type: %s" PHP_HTTP_CRLF
265 PHP_HTTP_CRLF,
266 safe_name, basename(path_dup), ctype
267 );
268 php_stream_copy_to_stream_ex(in, php_http_message_body_stream(body), PHP_STREAM_COPY_ALL, NULL);
269 BOUNDARY_CLOSE(body);
270
271 efree(safe_name);
272 efree(path_dup);
273
274 return SUCCESS;
275 }
276
277 static inline char *format_key(uint type, char *str, ulong num, const char *prefix) {
278 char *new_key = NULL;
279
280 if (prefix && *prefix) {
281 if (type == HASH_KEY_IS_STRING) {
282 spprintf(&new_key, 0, "%s[%s]", prefix, str);
283 } else {
284 spprintf(&new_key, 0, "%s[%lu]", prefix, num);
285 }
286 } else if (type == HASH_KEY_IS_STRING) {
287 new_key = estrdup(str);
288 } else {
289 new_key = estrdup("");
290 }
291
292 return new_key;
293 }
294
295 static STATUS add_recursive_fields(php_http_message_body_t *body, const char *name, zval *value)
296 {
297 if (Z_TYPE_P(value) == IS_ARRAY || Z_TYPE_P(value) == IS_OBJECT) {
298 zval **val;
299 HashTable *ht;
300 HashPosition pos;
301 php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
302 TSRMLS_FETCH_FROM_CTX(body->ts);
303
304 ht = HASH_OF(value);
305 if (!ht->nApplyCount) {
306 ++ht->nApplyCount;
307 FOREACH_KEYVAL(pos, value, key, val) {
308 char *str = format_key(key.type, key.str, key.num, name);
309 if (SUCCESS != add_recursive_fields(body, str, *val)) {
310 efree(str);
311 ht->nApplyCount--;
312 return FAILURE;
313 }
314 efree(str);
315 }
316 --ht->nApplyCount;
317 }
318 } else {
319 zval *cpy = php_http_ztyp(IS_STRING, value);
320 php_http_message_body_add_field(body, name, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy));
321 zval_ptr_dtor(&cpy);
322 }
323
324 return SUCCESS;
325 }
326
327 static STATUS add_recursive_files(php_http_message_body_t *body, const char *name, zval *value)
328 {
329 zval **zdata = NULL, **zfile, **zname, **ztype;
330 HashTable *ht;
331 TSRMLS_FETCH_FROM_CTX(body->ts);
332
333 if (Z_TYPE_P(value) != IS_ARRAY && Z_TYPE_P(value) != IS_OBJECT) {
334 php_http_error(HE_WARNING, PHP_HTTP_E_MESSAGE_BODY, "Expected array or object (name, type, file) for message body file to add");
335 return FAILURE;
336 }
337
338 ht = HASH_OF(value);
339
340 if ((SUCCESS != zend_hash_find(ht, ZEND_STRS("name"), (void *) &zname))
341 || (SUCCESS != zend_hash_find(ht, ZEND_STRS("type"), (void *) &ztype))
342 || (SUCCESS != zend_hash_find(ht, ZEND_STRS("file"), (void *) &zfile))
343 ) {
344 zval **val;
345 HashPosition pos;
346 php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
347
348 if (!ht->nApplyCount) {
349 ++ht->nApplyCount;
350 FOREACH_HASH_KEYVAL(pos, ht, key, val) {
351 if (Z_TYPE_PP(val) == IS_ARRAY || Z_TYPE_PP(val) == IS_OBJECT) {
352 char *str = format_key(key.type, key.str, key.num, name);
353
354 if (SUCCESS != add_recursive_files(body, str, *val)) {
355 efree(str);
356 --ht->nApplyCount;
357 return FAILURE;
358 }
359 efree(str);
360 }
361 }
362 --ht->nApplyCount;
363 }
364 return SUCCESS;
365 } else {
366 php_stream *stream;
367 zval *zfc = php_http_ztyp(IS_STRING, *zfile);
368
369 if (SUCCESS == zend_hash_find(ht, ZEND_STRS("data"), (void *) &zdata)) {
370 if (Z_TYPE_PP(zdata) == IS_RESOURCE) {
371 php_stream_from_zval_no_verify(stream, zdata);
372 } else {
373 zval *tmp = php_http_ztyp(IS_STRING, *zdata);
374
375 stream = php_stream_memory_open(TEMP_STREAM_READONLY, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
376 zval_ptr_dtor(&tmp);
377 }
378 } else {
379 stream = php_stream_open_wrapper(Z_STRVAL_P(zfc), "r", REPORT_ERRORS|USE_PATH, NULL);
380 }
381
382 if (!stream) {
383 zval_ptr_dtor(&zfc);
384 return FAILURE;
385 } else {
386 zval *znc = php_http_ztyp(IS_STRING, *zname), *ztc = php_http_ztyp(IS_STRING, *ztype);
387 char *key = format_key(HASH_KEY_IS_STRING, Z_STRVAL_P(znc), 0, name);
388 STATUS ret = php_http_message_body_add_file(body, key, Z_STRVAL_P(ztc), Z_STRVAL_P(zfc), stream);
389
390 efree(key);
391 zval_ptr_dtor(&znc);
392 zval_ptr_dtor(&ztc);
393 zval_ptr_dtor(&zfc);
394 if (!zdata || Z_TYPE_PP(zdata) != IS_RESOURCE) {
395 php_stream_close(stream);
396 }
397 return ret;
398 }
399
400 }
401 }
402
403 /* PHP */
404
405 #define PHP_HTTP_BEGIN_ARGS(method, req_args) PHP_HTTP_BEGIN_ARGS_EX(HttpMessageBody, method, 0, req_args)
406 #define PHP_HTTP_EMPTY_ARGS(method) PHP_HTTP_EMPTY_ARGS_EX(HttpMessageBody, method, 0)
407 #define PHP_HTTP_MESSAGE_BODY_ME(method, visibility) PHP_ME(HttpMessageBody, method, PHP_HTTP_ARGS(HttpMessageBody, method), visibility)
408
409 PHP_HTTP_BEGIN_ARGS(__construct, 0)
410 PHP_HTTP_ARG_VAL(stream, 0)
411 PHP_HTTP_END_ARGS;
412
413 PHP_HTTP_EMPTY_ARGS(__toString);
414
415 PHP_HTTP_BEGIN_ARGS(toStream, 1)
416 PHP_HTTP_ARG_VAL(stream, 0)
417 PHP_HTTP_END_ARGS;
418
419 PHP_HTTP_BEGIN_ARGS(toCallback, 1)
420 PHP_HTTP_ARG_VAL(callback, 0)
421 PHP_HTTP_END_ARGS;
422
423 PHP_HTTP_BEGIN_ARGS(append, 1)
424 PHP_HTTP_ARG_VAL(string, 0)
425 PHP_HTTP_END_ARGS;
426
427 PHP_HTTP_BEGIN_ARGS(add, 0)
428 PHP_HTTP_ARG_ARR(fields, 1, 0)
429 PHP_HTTP_ARG_ARR(files, 1, 0)
430 PHP_HTTP_END_ARGS;
431
432 PHP_HTTP_EMPTY_ARGS(etag);
433
434 PHP_HTTP_BEGIN_ARGS(stat, 0)
435 PHP_HTTP_ARG_VAL(what, 0)
436 PHP_HTTP_END_ARGS;
437
438 zend_class_entry *php_http_message_body_class_entry;
439 zend_function_entry php_http_message_body_method_entry[] = {
440 PHP_HTTP_MESSAGE_BODY_ME(__construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
441 PHP_HTTP_MESSAGE_BODY_ME(__toString, ZEND_ACC_PUBLIC)
442 PHP_MALIAS(HttpMessageBody, toString, __toString, args_for_HttpMessageBody___toString, ZEND_ACC_PUBLIC)
443 PHP_HTTP_MESSAGE_BODY_ME(toStream, ZEND_ACC_PUBLIC)
444 PHP_HTTP_MESSAGE_BODY_ME(toCallback, ZEND_ACC_PUBLIC)
445 PHP_HTTP_MESSAGE_BODY_ME(append, ZEND_ACC_PUBLIC)
446 PHP_HTTP_MESSAGE_BODY_ME(add, ZEND_ACC_PUBLIC)
447 PHP_HTTP_MESSAGE_BODY_ME(etag, ZEND_ACC_PUBLIC)
448 PHP_HTTP_MESSAGE_BODY_ME(stat, ZEND_ACC_PUBLIC)
449 EMPTY_FUNCTION_ENTRY
450 };
451 static zend_object_handlers php_http_message_body_object_handlers;
452
453 PHP_MINIT_FUNCTION(http_message_body)
454 {
455 PHP_HTTP_REGISTER_CLASS(http\\Message, Body, http_message_body, php_http_object_class_entry, 0);
456 php_http_message_body_class_entry->create_object = php_http_message_body_object_new;
457 memcpy(&php_http_message_body_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
458 php_http_message_body_object_handlers.clone_obj = php_http_message_body_object_clone;
459
460 return SUCCESS;
461 }
462
463 zend_object_value php_http_message_body_object_new(zend_class_entry *ce TSRMLS_DC)
464 {
465 return php_http_message_body_object_new_ex(ce, NULL, NULL TSRMLS_CC);
466 }
467
468 zend_object_value php_http_message_body_object_new_ex(zend_class_entry *ce, php_http_message_body_t *body, php_http_message_body_object_t **ptr TSRMLS_DC)
469 {
470 zend_object_value ov;
471 php_http_message_body_object_t *o;
472
473 o = ecalloc(1, sizeof(php_http_message_body_object_t));
474 zend_object_std_init((zend_object *) o, php_http_message_body_class_entry TSRMLS_CC);
475 object_properties_init((zend_object *) o, ce);
476
477 if (ptr) {
478 *ptr = o;
479 }
480
481 if (body) {
482 o->body = body;
483 }
484
485 ov.handle = zend_objects_store_put((zend_object *) o, NULL, php_http_message_body_object_free, NULL TSRMLS_CC);
486 ov.handlers = &php_http_message_body_object_handlers;
487
488 return ov;
489 }
490
491 zend_object_value php_http_message_body_object_clone(zval *object TSRMLS_DC)
492 {
493 zend_object_value new_ov;
494 php_http_message_body_object_t *new_obj = NULL;
495 php_http_message_body_object_t *old_obj = zend_object_store_get_object(object TSRMLS_CC);
496
497 new_ov = php_http_message_body_object_new_ex(old_obj->zo.ce, php_http_message_body_copy(old_obj->body, NULL, 1), &new_obj TSRMLS_CC);
498 zend_objects_clone_members(&new_obj->zo, new_ov, &old_obj->zo, Z_OBJ_HANDLE_P(object) TSRMLS_CC);
499
500 return new_ov;
501 }
502
503 void php_http_message_body_object_free(void *object TSRMLS_DC)
504 {
505 php_http_message_body_object_t *obj = object;
506
507 php_http_message_body_free(&obj->body);
508
509 zend_object_std_dtor((zend_object *) obj TSRMLS_CC);
510 efree(obj);
511 }
512
513 PHP_METHOD(HttpMessageBody, __construct)
514 {
515 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
516 zval *zstream = NULL;
517 php_stream *stream;
518
519 with_error_handling(EH_THROW, php_http_exception_class_entry) {
520 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r!", &zstream)) {
521 if (zstream) {
522 php_stream_from_zval(stream, &zstream);
523
524 if (stream) {
525 if (obj->body) {
526 php_http_message_body_dtor(obj->body);
527 }
528 obj->body = php_http_message_body_init(obj->body, stream TSRMLS_CC);
529 }
530 }
531 if (!obj->body) {
532 obj->body = php_http_message_body_init(NULL, NULL TSRMLS_CC);
533 }
534 }
535 } end_error_handling();
536 }
537
538 PHP_METHOD(HttpMessageBody, __toString)
539 {
540 if (SUCCESS == zend_parse_parameters_none()) {
541 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
542 char *str;
543 size_t len;
544
545 php_http_message_body_to_string(obj->body, &str, &len, 0, 0);
546 if (str) {
547 RETURN_STRINGL(str, len, 0);
548 }
549 }
550 RETURN_EMPTY_STRING();
551 }
552
553 PHP_METHOD(HttpMessageBody, toStream)
554 {
555 zval *zstream;
556 long offset = 0, forlen = 0;
557
558 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|ll", &zstream, &offset, &forlen)) {
559 php_stream *stream;
560 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
561
562 php_stream_from_zval(stream, &zstream);
563 php_http_message_body_to_stream(obj->body, stream, offset, forlen);
564 RETURN_TRUE;
565 }
566 RETURN_FALSE;
567 }
568
569 struct fcd {
570 zval *fcz;
571 zend_fcall_info fci;
572 zend_fcall_info_cache fcc;
573 #ifdef ZTS
574 void ***ts;
575 #endif
576 };
577
578 static size_t pass(void *cb_arg, const char *str, size_t len)
579 {
580 struct fcd *fcd = cb_arg;
581 zval *zdata;
582 TSRMLS_FETCH_FROM_CTX(fcd->ts);
583
584 MAKE_STD_ZVAL(zdata);
585 ZVAL_STRINGL(zdata, str, len, 1);
586 if (SUCCESS == zend_fcall_info_argn(&fcd->fci TSRMLS_CC, 2, &fcd->fcz, &zdata)) {
587 zend_fcall_info_call(&fcd->fci, &fcd->fcc, NULL, NULL TSRMLS_CC);
588 zend_fcall_info_args_clear(&fcd->fci, 0);
589 }
590 zval_ptr_dtor(&zdata);
591 return len;
592 }
593
594 PHP_METHOD(HttpMessageBody, toCallback)
595 {
596 struct fcd fcd = {0};
597 long offset = 0, forlen = 0;
598
599 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f|ll", &fcd.fci, &fcd.fcc, &offset, &forlen)) {
600 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
601
602 fcd.fcz = getThis();
603 Z_ADDREF_P(fcd.fcz);
604 TSRMLS_SET_CTX(fcd.ts);
605
606 php_http_message_body_to_callback(obj->body, pass, &fcd, offset, forlen);
607 zend_fcall_info_args_clear(&fcd.fci, 1);
608
609 zval_ptr_dtor(&fcd.fcz);
610 RETURN_TRUE;
611 }
612 RETURN_FALSE;
613 }
614
615 PHP_METHOD(HttpMessageBody, append)
616 {
617 char *str;
618 int len;
619
620 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &len)) {
621 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
622
623 RETURN_LONG(php_http_message_body_append(obj->body, str, len));
624 }
625 RETURN_FALSE;
626 }
627
628 PHP_METHOD(HttpMessageBody, add)
629 {
630 HashTable *fields = NULL, *files = NULL;
631
632 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|h!h!", &fields, &files)) {
633 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
634
635 RETURN_SUCCESS(php_http_message_body_add(obj->body, fields, files));
636 }
637 RETURN_FALSE;
638 }
639
640 PHP_METHOD(HttpMessageBody, etag)
641 {
642 if (SUCCESS == zend_parse_parameters_none()) {
643 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
644 char *etag = php_http_message_body_etag(obj->body);
645
646 if (etag) {
647 RETURN_STRING(etag, 0);
648 }
649 }
650 RETURN_FALSE;
651 }
652
653 PHP_METHOD(HttpMessageBody, stat)
654 {
655 char *field_str = NULL;
656 int field_len = 0;
657
658 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &field_str, &field_len)) {
659 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
660 const php_stream_statbuf *sb = php_http_message_body_stat(obj->body);
661
662 if (sb) {
663 if (field_str && field_len) {
664 switch (*field_str) {
665 case 's':
666 case 'S':
667 RETURN_LONG(sb->sb.st_size);
668 break;
669 case 'a':
670 case 'A':
671 RETURN_LONG(sb->sb.st_atime);
672 break;
673 case 'm':
674 case 'M':
675 RETURN_LONG(sb->sb.st_mtime);
676 break;
677 case 'c':
678 case 'C':
679 RETURN_LONG(sb->sb.st_ctime);
680 break;
681 default:
682 php_http_error(HE_WARNING, PHP_HTTP_E_MESSAGE_BODY, "unknown stat field: '%s' (should be one of [s]ize, [a]time, [m]time or [c]time)", field_str);
683 break;
684 }
685 } else {
686 array_init(return_value);
687 add_assoc_long_ex(return_value, ZEND_STRS("size"), sb->sb.st_size);
688 add_assoc_long_ex(return_value, ZEND_STRS("atime"), sb->sb.st_atime);
689 add_assoc_long_ex(return_value, ZEND_STRS("mtime"), sb->sb.st_mtime);
690 add_assoc_long_ex(return_value, ZEND_STRS("ctime"), sb->sb.st_ctime);
691 return;
692 }
693 }
694 }
695 RETURN_FALSE;
696 }
697
698 /*
699 * Local variables:
700 * tab-width: 4
701 * c-basic-offset: 4
702 * End:
703 * vim600: noet sw=4 ts=4 fdm=marker
704 * vim<600: noet sw=4 ts=4
705 */
Extended HTTP Support