projects / m6w6 / ext-http / blob
? search:


14486a9edaeb7240f0ae0315d649428080849839
[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 php_http_message_body_append(body, value_str, value_len);
245 BOUNDARY_CLOSE(body);
246
247 efree(safe_name);
248 return SUCCESS;
249 }
250
251 PHP_HTTP_API STATUS php_http_message_body_add_file(php_http_message_body_t *body, const char *name, const char *path, const char *ctype)
252 {
253 php_stream *in;
254 char *path_dup = estrdup(path);
255 TSRMLS_FETCH_FROM_CTX(body->ts);
256
257 if ((in = php_stream_open_wrapper(path_dup, "r", REPORT_ERRORS|USE_PATH|STREAM_MUST_SEEK, NULL))) {
258 php_stream_statbuf ssb = {{0}};
259
260 if (SUCCESS == php_stream_stat(in, &ssb) && S_ISREG(ssb.sb.st_mode)) {
261 char *safe_name = php_addslashes(estrdup(name), strlen(name), NULL, 1 TSRMLS_CC);
262
263 BOUNDARY_OPEN(body);
264 php_http_message_body_appendf(
265 body,
266 "Content-Disposition: attachment; name=\"%s\"; filename=\"%s\"" PHP_HTTP_CRLF
267 "Content-Type: %s" PHP_HTTP_CRLF
268 "Content-Length: %zu" PHP_HTTP_CRLF
269 "" PHP_HTTP_CRLF,
270 safe_name, basename(path_dup), ctype, ssb.sb.st_size);
271 php_stream_copy_to_stream_ex(in, php_http_message_body_stream(body), PHP_STREAM_COPY_ALL, NULL);
272 BOUNDARY_CLOSE(body);
273
274 efree(safe_name);
275 efree(path_dup);
276 php_stream_close(in);
277 return SUCCESS;
278 } else {
279 efree(path_dup);
280 php_stream_close(in);
281 php_http_error(HE_WARNING, PHP_HTTP_E_MESSAGE_BODY, "Not a valid regular file: %s", path);
282 return FAILURE;
283 }
284 } else {
285 efree(path_dup);
286 return FAILURE;
287 }
288
289 }
290
291 static inline char *format_key(uint type, char *str, ulong num, const char *prefix) {
292 char *new_key = NULL;
293
294 if (prefix && *prefix) {
295 if (type == HASH_KEY_IS_STRING) {
296 spprintf(&new_key, 0, "%s[%s]", prefix, str);
297 } else {
298 spprintf(&new_key, 0, "%s[%lu]", prefix, num);
299 }
300 } else if (type == HASH_KEY_IS_STRING) {
301 new_key = estrdup(str);
302 } else {
303 spprintf(&new_key, 0, "%lu", num);
304 }
305
306 return new_key;
307 }
308
309 static STATUS add_recursive_fields(php_http_message_body_t *body, const char *name, zval *value)
310 {
311 if (Z_TYPE_P(value) == IS_ARRAY || Z_TYPE_P(value) == IS_OBJECT) {
312 zval **val;
313 HashPosition pos;
314 php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
315 TSRMLS_FETCH_FROM_CTX(body->ts);
316
317 if (!HASH_OF(value)->nApplyCount) {
318 ++HASH_OF(value)->nApplyCount;
319 FOREACH_KEYVAL(pos, value, key, val) {
320 char *str = format_key(key.type, key.str, key.num, name);
321 if (SUCCESS != add_recursive_fields(body, str, *val)) {
322 efree(str);
323 HASH_OF(value)->nApplyCount--;
324 return FAILURE;
325 }
326 efree(str);
327 }
328 --HASH_OF(value)->nApplyCount;
329 }
330 } else {
331 zval *cpy = php_http_ztyp(IS_STRING, value);
332 php_http_message_body_add_field(body, name, Z_STRVAL_P(cpy), Z_STRLEN_P(cpy));
333 zval_ptr_dtor(&cpy);
334 }
335
336 return SUCCESS;
337 }
338
339 static STATUS add_recursive_files(php_http_message_body_t *body, const char *name, zval *value)
340 {
341 if (Z_TYPE_P(value) == IS_ARRAY || Z_TYPE_P(value) == IS_OBJECT) {
342 zval **zfile, **zname, **ztype;
343 TSRMLS_FETCH_FROM_CTX(body->ts);
344
345 if ((SUCCESS == zend_hash_find(HASH_OF(value), ZEND_STRS("name"), (void *) &zname))
346 && (SUCCESS == zend_hash_find(HASH_OF(value), ZEND_STRS("file"), (void *) &zfile))
347 && (SUCCESS == zend_hash_find(HASH_OF(value), ZEND_STRS("type"), (void *) &ztype))
348 ) {
349 zval *zfc = php_http_ztyp(IS_STRING, *zfile), *znc = php_http_ztyp(IS_STRING, *zname), *ztc = php_http_ztyp(IS_STRING, *ztype);
350 char *str = format_key(HASH_KEY_IS_STRING, Z_STRVAL_P(znc), 0, name);
351 STATUS ret = php_http_message_body_add_file(body, str, Z_STRVAL_P(zfc), Z_STRVAL_P(ztc));
352
353 efree(str);
354 zval_ptr_dtor(&znc);
355 zval_ptr_dtor(&zfc);
356 zval_ptr_dtor(&ztc);
357
358 if (ret != SUCCESS) {
359 return ret;
360 }
361 } else {
362 zval **val;
363 HashPosition pos;
364 php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
365
366 if (!HASH_OF(value)->nApplyCount) {
367 ++HASH_OF(value)->nApplyCount;
368 FOREACH_KEYVAL(pos, value, key, val) {
369 char *str = format_key(key.type, key.str, key.num, name);
370 if (SUCCESS != add_recursive_files(body, str, *val)) {
371 efree(str);
372 --HASH_OF(value)->nApplyCount;
373 return FAILURE;
374 }
375 efree(str);
376 }
377 --HASH_OF(value)->nApplyCount;
378 }
379 }
380 } else {
381 TSRMLS_FETCH_FROM_CTX(body->ts);
382 php_http_error(HE_WARNING, PHP_HTTP_E_MESSAGE_BODY, "Unrecognized array format for message body file to add");
383 return FAILURE;
384 }
385
386 return SUCCESS;
387 }
388
389 /* PHP */
390
391 #define PHP_HTTP_BEGIN_ARGS(method, req_args) PHP_HTTP_BEGIN_ARGS_EX(HttpMessageBody, method, 0, req_args)
392 #define PHP_HTTP_EMPTY_ARGS(method) PHP_HTTP_EMPTY_ARGS_EX(HttpMessageBody, method, 0)
393 #define PHP_HTTP_MESSAGE_BODY_ME(method, visibility) PHP_ME(HttpMessageBody, method, PHP_HTTP_ARGS(HttpMessageBody, method), visibility)
394
395 PHP_HTTP_BEGIN_ARGS(__construct, 0)
396 PHP_HTTP_ARG_VAL(stream, 0)
397 PHP_HTTP_END_ARGS;
398
399 PHP_HTTP_EMPTY_ARGS(__toString);
400
401 PHP_HTTP_BEGIN_ARGS(toStream, 1)
402 PHP_HTTP_ARG_VAL(stream, 0)
403 PHP_HTTP_END_ARGS;
404
405 PHP_HTTP_BEGIN_ARGS(toCallback, 1)
406 PHP_HTTP_ARG_VAL(callback, 0)
407 PHP_HTTP_END_ARGS;
408
409 PHP_HTTP_BEGIN_ARGS(append, 1)
410 PHP_HTTP_ARG_VAL(string, 0)
411 PHP_HTTP_END_ARGS;
412
413 PHP_HTTP_BEGIN_ARGS(add, 0)
414 PHP_HTTP_ARG_VAL(fields, 0)
415 PHP_HTTP_ARG_VAL(files, 0)
416 PHP_HTTP_END_ARGS;
417
418 PHP_HTTP_EMPTY_ARGS(etag);
419
420 PHP_HTTP_BEGIN_ARGS(stat, 0)
421 PHP_HTTP_ARG_VAL(what, 0)
422 PHP_HTTP_END_ARGS;
423
424 zend_class_entry *php_http_message_body_class_entry;
425 zend_function_entry php_http_message_body_method_entry[] = {
426 PHP_HTTP_MESSAGE_BODY_ME(__construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
427 PHP_HTTP_MESSAGE_BODY_ME(__toString, ZEND_ACC_PUBLIC)
428 PHP_MALIAS(HttpMessageBody, toString, __toString, args_for_HttpMessageBody___toString, ZEND_ACC_PUBLIC)
429 PHP_HTTP_MESSAGE_BODY_ME(toStream, ZEND_ACC_PUBLIC)
430 PHP_HTTP_MESSAGE_BODY_ME(toCallback, ZEND_ACC_PUBLIC)
431 PHP_HTTP_MESSAGE_BODY_ME(append, ZEND_ACC_PUBLIC)
432 PHP_HTTP_MESSAGE_BODY_ME(add, ZEND_ACC_PUBLIC)
433 PHP_HTTP_MESSAGE_BODY_ME(etag, ZEND_ACC_PUBLIC)
434 PHP_HTTP_MESSAGE_BODY_ME(stat, ZEND_ACC_PUBLIC)
435 EMPTY_FUNCTION_ENTRY
436 };
437 static zend_object_handlers php_http_message_body_object_handlers;
438
439 PHP_MINIT_FUNCTION(http_message_body)
440 {
441 PHP_HTTP_REGISTER_CLASS(http\\Message, Body, http_message_body, php_http_object_class_entry, 0);
442 php_http_message_body_class_entry->create_object = php_http_message_body_object_new;
443 memcpy(&php_http_message_body_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
444 php_http_message_body_object_handlers.clone_obj = php_http_message_body_object_clone;
445
446 return SUCCESS;
447 }
448
449 zend_object_value php_http_message_body_object_new(zend_class_entry *ce TSRMLS_DC)
450 {
451 return php_http_message_body_object_new_ex(ce, NULL, NULL TSRMLS_CC);
452 }
453
454 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)
455 {
456 zend_object_value ov;
457 php_http_message_body_object_t *o;
458
459 o = ecalloc(1, sizeof(php_http_message_body_object_t));
460 zend_object_std_init((zend_object *) o, php_http_message_body_class_entry TSRMLS_CC);
461 object_properties_init((zend_object *) o, ce);
462
463 if (ptr) {
464 *ptr = o;
465 }
466
467 if (body) {
468 o->body = body;
469 }
470
471 ov.handle = zend_objects_store_put((zend_object *) o, NULL, php_http_message_body_object_free, NULL TSRMLS_CC);
472 ov.handlers = &php_http_message_body_object_handlers;
473
474 return ov;
475 }
476
477 zend_object_value php_http_message_body_object_clone(zval *object TSRMLS_DC)
478 {
479 zend_object_value new_ov;
480 php_http_message_body_object_t *new_obj = NULL;
481 php_http_message_body_object_t *old_obj = zend_object_store_get_object(object TSRMLS_CC);
482
483 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);
484 zend_objects_clone_members(&new_obj->zo, new_ov, &old_obj->zo, Z_OBJ_HANDLE_P(object) TSRMLS_CC);
485
486 return new_ov;
487 }
488
489 void php_http_message_body_object_free(void *object TSRMLS_DC)
490 {
491 php_http_message_body_object_t *obj = object;
492
493 php_http_message_body_free(&obj->body);
494
495 zend_object_std_dtor((zend_object *) obj TSRMLS_CC);
496 efree(obj);
497 }
498
499 PHP_METHOD(HttpMessageBody, __construct)
500 {
501 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
502 zval *zstream = NULL;
503 php_stream *stream;
504
505 with_error_handling(EH_THROW, php_http_exception_class_entry) {
506 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r!", &zstream)) {
507 if (zstream) {
508 php_stream_from_zval(stream, &zstream);
509
510 if (stream) {
511 if (obj->body) {
512 php_http_message_body_dtor(obj->body);
513 }
514 obj->body = php_http_message_body_init(obj->body, stream TSRMLS_CC);
515 }
516 }
517 if (!obj->body) {
518 obj->body = php_http_message_body_init(NULL, NULL TSRMLS_CC);
519 }
520 }
521 } end_error_handling();
522 }
523
524 PHP_METHOD(HttpMessageBody, __toString)
525 {
526 if (SUCCESS == zend_parse_parameters_none()) {
527 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
528 char *str;
529 size_t len;
530
531 php_http_message_body_to_string(obj->body, &str, &len, 0, 0);
532 if (str) {
533 RETURN_STRINGL(str, len, 0);
534 }
535 }
536 RETURN_EMPTY_STRING();
537 }
538
539 PHP_METHOD(HttpMessageBody, toStream)
540 {
541 zval *zstream;
542 long offset = 0, forlen = 0;
543
544 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|ll", &zstream, &offset, &forlen)) {
545 php_stream *stream;
546 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
547
548 php_stream_from_zval(stream, &zstream);
549 php_http_message_body_to_stream(obj->body, stream, offset, forlen);
550 RETURN_TRUE;
551 }
552 RETURN_FALSE;
553 }
554
555 struct fcd {
556 zval *fcz;
557 zend_fcall_info fci;
558 zend_fcall_info_cache fcc;
559 #ifdef ZTS
560 void ***ts;
561 #endif
562 };
563
564 static size_t pass(void *cb_arg, const char *str, size_t len)
565 {
566 struct fcd *fcd = cb_arg;
567 zval *zdata;
568 TSRMLS_FETCH_FROM_CTX(fcd->ts);
569
570 MAKE_STD_ZVAL(zdata);
571 ZVAL_STRINGL(zdata, str, len, 1);
572 if (SUCCESS == zend_fcall_info_argn(&fcd->fci TSRMLS_CC, 2, &fcd->fcz, &zdata)) {
573 zend_fcall_info_call(&fcd->fci, &fcd->fcc, NULL, NULL TSRMLS_CC);
574 zend_fcall_info_args_clear(&fcd->fci, 0);
575 }
576 zval_ptr_dtor(&zdata);
577 return len;
578 }
579
580 PHP_METHOD(HttpMessageBody, toCallback)
581 {
582 struct fcd fcd = {0};
583 long offset = 0, forlen = 0;
584
585 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f|ll", &fcd.fci, &fcd.fcc, &offset, &forlen)) {
586 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
587
588 fcd.fcz = getThis();
589 Z_ADDREF_P(fcd.fcz);
590 TSRMLS_SET_CTX(fcd.ts);
591
592 php_http_message_body_to_callback(obj->body, pass, &fcd, offset, forlen);
593 zend_fcall_info_args_clear(&fcd.fci, 1);
594
595 zval_ptr_dtor(&fcd.fcz);
596 RETURN_TRUE;
597 }
598 RETURN_FALSE;
599 }
600
601 PHP_METHOD(HttpMessageBody, append)
602 {
603 char *str;
604 int len;
605
606 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &len)) {
607 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
608
609 RETURN_LONG(php_http_message_body_append(obj->body, str, len));
610 }
611 RETURN_FALSE;
612 }
613
614 PHP_METHOD(HttpMessageBody, add)
615 {
616 HashTable *fields = NULL, *files = NULL;
617
618 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|hh", &fields, &files)) {
619 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
620
621 RETURN_SUCCESS(php_http_message_body_add(obj->body, fields, files));
622 }
623 RETURN_FALSE;
624 }
625
626 PHP_METHOD(HttpMessageBody, etag)
627 {
628 if (SUCCESS == zend_parse_parameters_none()) {
629 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
630 char *etag = php_http_message_body_etag(obj->body);
631
632 if (etag) {
633 RETURN_STRING(etag, 0);
634 }
635 }
636 RETURN_FALSE;
637 }
638
639 PHP_METHOD(HttpMessageBody, stat)
640 {
641 char *field_str = NULL;
642 int field_len = 0;
643
644 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &field_str, &field_len)) {
645 php_http_message_body_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
646 const php_stream_statbuf *sb = php_http_message_body_stat(obj->body);
647
648 if (sb) {
649 if (field_str && field_len) {
650 switch (*field_str) {
651 case 's':
652 case 'S':
653 RETURN_LONG(sb->sb.st_size);
654 break;
655 case 'a':
656 case 'A':
657 RETURN_LONG(sb->sb.st_atime);
658 break;
659 case 'm':
660 case 'M':
661 RETURN_LONG(sb->sb.st_mtime);
662 break;
663 case 'c':
664 case 'C':
665 RETURN_LONG(sb->sb.st_ctime);
666 break;
667 default:
668 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);
669 break;
670 }
671 } else {
672 array_init(return_value);
673 add_assoc_long_ex(return_value, ZEND_STRS("size"), sb->sb.st_size);
674 add_assoc_long_ex(return_value, ZEND_STRS("atime"), sb->sb.st_atime);
675 add_assoc_long_ex(return_value, ZEND_STRS("mtime"), sb->sb.st_mtime);
676 add_assoc_long_ex(return_value, ZEND_STRS("ctime"), sb->sb.st_ctime);
677 return;
678 }
679 }
680 }
681 RETURN_FALSE;
682 }
683
684 /*
685 * Local variables:
686 * tab-width: 4
687 * c-basic-offset: 4
688 * End:
689 * vim600: noet sw=4 ts=4 fdm=marker
690 * vim<600: noet sw=4 ts=4
691 */
Extended HTTP Support