projects / m6w6 / ext-http / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
addendum to #92
[m6w6/ext-http] / src / 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-2014, 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
28 #define BOUNDARY_CLOSE(body) \
29 php_http_message_body_appendf(body, PHP_HTTP_CRLF "--%s--" PHP_HTTP_CRLF, php_http_message_body_boundary(body))
30
31 static ZEND_RESULT_CODE add_recursive_fields(php_http_message_body_t *body, const char *name, HashTable *fields);
32 static ZEND_RESULT_CODE add_recursive_files(php_http_message_body_t *body, const char *name, HashTable *files);
33
34 php_http_message_body_t *php_http_message_body_init(php_http_message_body_t **body_ptr, php_stream *stream)
35 {
36 php_http_message_body_t *body;
37
38 if (body_ptr && *body_ptr) {
39 body = *body_ptr;
40 php_http_message_body_addref(body);
41 return body;
42 }
43
44 body = ecalloc(1, sizeof(php_http_message_body_t));
45 body->refcount = 1;
46
47 if (stream) {
48 body->res = stream->res;
49 GC_ADDREF(body->res);
50 } else {
51 body->res = php_stream_temp_create(TEMP_STREAM_DEFAULT, 0xffff)->res;
52 }
53 php_stream_auto_cleanup(php_http_message_body_stream(body));
54
55 if (body_ptr) {
56 *body_ptr = body;
57 }
58
59 return body;
60 }
61
62 unsigned php_http_message_body_addref(php_http_message_body_t *body)
63 {
64 return ++body->refcount;
65 }
66
67 php_http_message_body_t *php_http_message_body_copy(php_http_message_body_t *from, php_http_message_body_t *to)
68 {
69 if (from) {
70 if (to) {
71 php_stream_truncate_set_size(php_http_message_body_stream(to), 0);
72 } else {
73 to = php_http_message_body_init(NULL, NULL);
74 }
75 php_http_message_body_to_stream(from, php_http_message_body_stream(to), 0, 0);
76
77 if (to->boundary) {
78 efree(to->boundary);
79 }
80 if (from->boundary) {
81 to->boundary = estrdup(from->boundary);
82 }
83 } else {
84 to = NULL;
85 }
86 return to;
87 }
88
89 void php_http_message_body_free(php_http_message_body_t **body_ptr)
90 {
91 if (*body_ptr) {
92 php_http_message_body_t *body = *body_ptr;
93 if (!--body->refcount) {
94 zend_list_delete(body->res);
95 body->res = NULL;
96 PTR_FREE(body->boundary);
97 efree(body);
98 }
99 *body_ptr = NULL;
100 }
101 }
102
103 const php_stream_statbuf *php_http_message_body_stat(php_http_message_body_t *body)
104 {
105 php_stream_stat(php_http_message_body_stream(body), &body->ssb);
106 return &body->ssb;
107 }
108
109 const char *php_http_message_body_boundary(php_http_message_body_t *body)
110 {
111 if (!body->boundary) {
112 union { double dbl; int num[2]; } data;
113
114 data.dbl = php_combined_lcg();
115 spprintf(&body->boundary, 0, "%x.%x", data.num[0], data.num[1]);
116 }
117 return body->boundary;
118 }
119
120 char *php_http_message_body_etag(php_http_message_body_t *body)
121 {
122 php_http_etag_t *etag;
123 php_stream *s = php_http_message_body_stream(body);
124
125 /* real file or temp buffer ? */
126 if (s->ops != &php_stream_temp_ops && s->ops != &php_stream_memory_ops) {
127 php_stream_stat(php_http_message_body_stream(body), &body->ssb);
128
129 if (body->ssb.sb.st_mtime) {
130 char *etag;
131
132 spprintf(&etag, 0, "%lx-%lx-%lx", body->ssb.sb.st_ino, body->ssb.sb.st_mtime, body->ssb.sb.st_size);
133 return etag;
134 }
135 }
136
137 /* content based */
138 if ((etag = php_http_etag_init(PHP_HTTP_G->env.etag_mode))) {
139 php_http_message_body_to_callback(body, (php_http_pass_callback_t) php_http_etag_update, etag, 0, 0);
140 return php_http_etag_finish(etag);
141 }
142
143 return NULL;
144 }
145
146 zend_string *php_http_message_body_to_string(php_http_message_body_t *body, off_t offset, size_t forlen)
147 {
148 php_stream *s = php_http_message_body_stream(body);
149
150 php_stream_seek(s, offset, SEEK_SET);
151 if (!forlen) {
152 forlen = -1;
153 }
154 return php_stream_copy_to_mem(s, forlen, 0);
155 }
156
157 ZEND_RESULT_CODE php_http_message_body_to_stream(php_http_message_body_t *body, php_stream *dst, off_t offset, size_t forlen)
158 {
159 php_stream *s = php_http_message_body_stream(body);
160
161 php_stream_seek(s, offset, SEEK_SET);
162
163 if (!forlen) {
164 forlen = -1;
165 }
166 return php_stream_copy_to_stream_ex(s, dst, forlen, NULL);
167 }
168
169 ZEND_RESULT_CODE 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)
170 {
171 php_stream *s = php_http_message_body_stream(body);
172 char *buf = emalloc(0x1000);
173
174 php_stream_seek(s, offset, SEEK_SET);
175
176 if (!forlen) {
177 forlen = -1;
178 }
179 while (!php_stream_eof(s)) {
180 size_t read = php_stream_read(s, buf, MIN(forlen, 0x1000));
181
182 if (read) {
183 if (-1 == cb(cb_arg, buf, read)) {
184 return FAILURE;
185 }
186 }
187
188 if (read < MIN(forlen, sizeof(buf))) {
189 break;
190 }
191
192 if (forlen && !(forlen -= read)) {
193 break;
194 }
195 }
196 efree(buf);
197
198 return SUCCESS;
199 }
200
201 size_t php_http_message_body_append(php_http_message_body_t *body, const char *buf, size_t len)
202 {
203 php_stream *s;
204 size_t written;
205
206 if (!(s = php_http_message_body_stream(body))) {
207 return -1;
208 }
209
210 if (s->ops->seek) {
211 php_stream_seek(s, 0, SEEK_END);
212 }
213
214 written = php_stream_write(s, buf, len);
215
216 if (written != len) {
217 php_error_docref(NULL, E_WARNING, "Failed to append %zu bytes to body; wrote %zu", len, written == (size_t) -1 ? 0 : written);
218 }
219
220 return len;
221 }
222
223 size_t php_http_message_body_appendf(php_http_message_body_t *body, const char *fmt, ...)
224 {
225 va_list argv;
226 char *print_str;
227 size_t print_len;
228
229 va_start(argv, fmt);
230 print_len = vspprintf(&print_str, 0, fmt, argv);
231 va_end(argv);
232
233 print_len = php_http_message_body_append(body, print_str, print_len);
234 efree(print_str);
235
236 return print_len;
237 }
238
239 ZEND_RESULT_CODE php_http_message_body_add_form(php_http_message_body_t *body, HashTable *fields, HashTable *files)
240 {
241 if (fields) {
242 if (SUCCESS != add_recursive_fields(body, NULL, fields)) {
243 return FAILURE;
244 }
245 }
246 if (files) {
247 if (SUCCESS != add_recursive_files(body, NULL, files)) {
248 return FAILURE;
249 }
250 }
251
252 return SUCCESS;
253 }
254
255 void php_http_message_body_add_part(php_http_message_body_t *body, php_http_message_t *part)
256 {
257 BOUNDARY_OPEN(body);
258 php_http_message_to_callback(part, (php_http_pass_callback_t) php_http_message_body_append, body);
259 BOUNDARY_CLOSE(body);
260 }
261
262
263 ZEND_RESULT_CODE php_http_message_body_add_form_field(php_http_message_body_t *body, const char *name, const char *value_str, size_t value_len)
264 {
265 zend_string *safe_name, *zstr_name = zend_string_init(name, strlen(name), 0);
266
267 #if PHP_VERSION_ID < 70300
268 safe_name = php_addslashes(zstr_name, 1);
269 #else
270 safe_name = php_addslashes(zstr_name);
271 zend_string_release_ex(zstr_name, 0);
272 #endif
273
274 BOUNDARY_OPEN(body);
275 php_http_message_body_appendf(
276 body,
277 "Content-Disposition: form-data; name=\"%s\"" PHP_HTTP_CRLF
278 "" PHP_HTTP_CRLF,
279 safe_name->val
280 );
281 php_http_message_body_append(body, value_str, value_len);
282 BOUNDARY_CLOSE(body);
283
284 zend_string_release(safe_name);
285 return SUCCESS;
286 }
287
288 ZEND_RESULT_CODE php_http_message_body_add_form_file(php_http_message_body_t *body, const char *name, const char *ctype, const char *path, php_stream *in)
289 {
290 size_t path_len = strlen(path);
291 char *path_dup = estrndup(path, path_len);
292 zend_string *base_name, *safe_name, *zstr_name = zend_string_init(name, strlen(name), 0);
293
294 #if PHP_VERSION_ID < 70300
295 safe_name = php_addslashes(zstr_name, 1);
296 #else
297 safe_name = php_addslashes(zstr_name);
298 zend_string_release_ex(zstr_name, 0);
299 #endif
300 base_name = php_basename(path_dup, path_len, NULL, 0);
301
302 BOUNDARY_OPEN(body);
303 php_http_message_body_appendf(
304 body,
305 "Content-Disposition: form-data; name=\"%s\"; filename=\"%s\"" PHP_HTTP_CRLF
306 "Content-Transfer-Encoding: binary" PHP_HTTP_CRLF
307 "Content-Type: %s" PHP_HTTP_CRLF
308 PHP_HTTP_CRLF,
309 safe_name->val, base_name->val, ctype
310 );
311 php_stream_copy_to_stream_ex(in, php_http_message_body_stream(body), PHP_STREAM_COPY_ALL, NULL);
312 BOUNDARY_CLOSE(body);
313
314 zend_string_release(safe_name);
315 zend_string_release(base_name);
316 efree(path_dup);
317
318 return SUCCESS;
319 }
320
321 static inline char *format_key(php_http_arrkey_t *key, const char *prefix) {
322 char *new_key = NULL;
323
324 if (prefix && *prefix) {
325 if (key->key) {
326 spprintf(&new_key, 0, "%s[%s]", prefix, key->key->val);
327 } else {
328 spprintf(&new_key, 0, "%s[%lu]", prefix, key->h);
329 }
330 } else if (key->key) {
331 new_key = estrdup(key->key->val);
332 } else {
333 spprintf(&new_key, 0, "%lu", key->h);
334 }
335
336 return new_key;
337 }
338
339 static ZEND_RESULT_CODE add_recursive_field_value(php_http_message_body_t *body, const char *name, zval *value)
340 {
341 zend_string *zs = zval_get_string(value);
342 ZEND_RESULT_CODE rc = php_http_message_body_add_form_field(body, name, zs->val, zs->len);
343 zend_string_release(zs);
344 return rc;
345 }
346
347 static ZEND_RESULT_CODE add_recursive_fields(php_http_message_body_t *body, const char *name, HashTable *fields)
348 {
349 zval *val;
350 php_http_arrkey_t key;
351
352 if (!HT_IS_RECURSIVE(fields)) {
353 HT_PROTECT_RECURSION(fields);
354 ZEND_HASH_FOREACH_KEY_VAL_IND(fields, key.h, key.key, val)
355 {
356 char *str = format_key(&key, name);
357
358 if (Z_TYPE_P(val) != IS_ARRAY && Z_TYPE_P(val) != IS_OBJECT) {
359 if (SUCCESS != add_recursive_field_value(body, str, val)) {
360 efree(str);
361 HT_UNPROTECT_RECURSION(fields);
362 return FAILURE;
363 }
364 } else if (SUCCESS != add_recursive_fields(body, str, HASH_OF(val))) {
365 efree(str);
366 HT_UNPROTECT_RECURSION(fields);
367 return FAILURE;
368 }
369 efree(str);
370 }
371 ZEND_HASH_FOREACH_END();
372 HT_UNPROTECT_RECURSION(fields);
373 }
374
375 return SUCCESS;
376 }
377
378 static ZEND_RESULT_CODE add_recursive_files(php_http_message_body_t *body, const char *name, HashTable *files)
379 {
380 zval *zdata = NULL, *zfile, *zname, *ztype;
381
382 /* single entry */
383 if (!(zname = zend_hash_str_find(files, ZEND_STRL("name")))
384 || !(ztype = zend_hash_str_find(files, ZEND_STRL("type")))
385 || !(zfile = zend_hash_str_find(files, ZEND_STRL("file")))
386 ) {
387 zval *val;
388 php_http_arrkey_t key;
389
390 if (!HT_IS_RECURSIVE(files)) {
391 HT_PROTECT_RECURSION(files);
392 ZEND_HASH_FOREACH_KEY_VAL_IND(files, key.h, key.key, val)
393 {
394 if (Z_TYPE_P(val) == IS_ARRAY || Z_TYPE_P(val) == IS_OBJECT) {
395 char *str = key.key ? format_key(&key, name) : NULL;
396 const char *prefix = str ?: name;
397
398 if (SUCCESS != add_recursive_files(body, prefix, HASH_OF(val))) {
399 efree(str);
400 HT_UNPROTECT_RECURSION(files);
401 return FAILURE;
402 }
403 if (str) {
404 efree(str);
405 }
406 }
407 }
408 ZEND_HASH_FOREACH_END();
409 HT_UNPROTECT_RECURSION(files);
410 }
411 return SUCCESS;
412 } else {
413 /* stream entry */
414 php_stream *stream;
415 zend_string *zfc = zval_get_string(zfile);
416
417 if ((zdata = zend_hash_str_find(files, ZEND_STRL("data")))) {
418 if (Z_TYPE_P(zdata) == IS_RESOURCE) {
419 php_stream_from_zval_no_verify(stream, zdata);
420 } else {
421 zend_string *tmp = zval_get_string(zdata);
422
423 stream = php_stream_memory_open(TEMP_STREAM_READONLY, tmp->val, tmp->len);
424 zend_string_release(tmp);
425 }
426 } else {
427 stream = php_stream_open_wrapper(zfc->val, "r", REPORT_ERRORS|USE_PATH, NULL);
428 }
429
430 if (!stream) {
431 zend_string_release(zfc);
432 return FAILURE;
433 } else {
434 zend_string *znc = zval_get_string(zname), *ztc = zval_get_string(ztype);
435 php_http_arrkey_t arrkey = {0, znc};
436 char *key = format_key(&arrkey, name);
437 ZEND_RESULT_CODE ret = php_http_message_body_add_form_file(body, key, ztc->val, zfc->val, stream);
438
439 efree(key);
440 zend_string_release(znc);
441 zend_string_release(ztc);
442 zend_string_release(zfc);
443 if (!zdata || Z_TYPE_P(zdata) != IS_RESOURCE) {
444 php_stream_close(stream);
445 }
446 return ret;
447 }
448
449 }
450 }
451
452 struct splitbody_arg {
453 php_http_buffer_t buf;
454 php_http_message_parser_t *parser;
455 char *boundary_str;
456 size_t boundary_len;
457 size_t consumed;
458 };
459
460 static size_t splitbody(void *opaque, char *buf, size_t len)
461 {
462 struct splitbody_arg *arg = opaque;
463 const char *boundary = NULL;
464 size_t consumed = 0;
465 int first_boundary;
466
467 do {
468 first_boundary = !(consumed || arg->consumed);
469
470 if ((boundary = php_http_locate_str(buf, len, arg->boundary_str + first_boundary, arg->boundary_len - first_boundary))) {
471 size_t real_boundary_len = arg->boundary_len - 1, cut;
472 const char *real_boundary = boundary + !first_boundary;
473 int eol_len = 0;
474
475 if (buf + len <= real_boundary + real_boundary_len) {
476 /* if we just have enough data for the boundary, it's just a byte too less */
477 arg->consumed += consumed;
478 return consumed;
479 }
480
481 if (!first_boundary) {
482 /* this is not the first boundary, read rest of this message */
483 php_http_buffer_append(&arg->buf, buf, real_boundary - buf);
484 php_http_message_parser_parse(arg->parser, &arg->buf, 0, &arg->parser->message);
485 }
486
487 /* move after the boundary */
488 cut = real_boundary - buf + real_boundary_len;
489 buf += cut;
490 len -= cut;
491 consumed += cut;
492
493 if (buf == php_http_locate_bin_eol(buf, len, &eol_len)) {
494 /* skip CRLF */
495 buf += eol_len;
496 len -= eol_len;
497 consumed += eol_len;
498
499 if (!first_boundary) {
500 /* advance messages */
501 php_http_message_t *msg;
502
503 msg = php_http_message_init(NULL, 0, NULL);
504 msg->parent = arg->parser->message;
505 arg->parser->message = msg;
506 }
507 } else {
508 /* is this the last boundary? */
509 if (*buf == '-') {
510 /* ignore the rest */
511 consumed += len;
512 len = 0;
513 } else {
514 /* let this be garbage */
515 php_error_docref(NULL, E_WARNING, "Malformed multipart boundary at pos %zu", consumed);
516 return -1;
517 }
518 }
519 }
520 } while (boundary && len);
521
522 /* let there be room for the next boundary */
523 if (len > arg->boundary_len) {
524 consumed += len - arg->boundary_len;
525 php_http_buffer_append(&arg->buf, buf, len - arg->boundary_len);
526 php_http_message_parser_parse(arg->parser, &arg->buf, 0, &arg->parser->message);
527 }
528
529 arg->consumed += consumed;
530 return consumed;
531 }
532
533 php_http_message_t *php_http_message_body_split(php_http_message_body_t *body, const char *boundary)
534 {
535 php_stream *s = php_http_message_body_stream(body);
536 php_http_buffer_t *tmp = NULL;
537 php_http_message_t *msg = NULL;
538 struct splitbody_arg arg;
539
540 php_http_buffer_init(&arg.buf);
541 arg.parser = php_http_message_parser_init(NULL);
542 arg.boundary_len = spprintf(&arg.boundary_str, 0, "\n--%s", boundary);
543 arg.consumed = 0;
544
545 php_stream_rewind(s);
546 while (!php_stream_eof(s)) {
547 php_http_buffer_passthru(&tmp, 0x1000, (php_http_buffer_pass_func_t) _php_stream_read, s, splitbody, &arg);
548 }
549
550 msg = arg.parser->message;
551 arg.parser->message = NULL;
552
553 php_http_buffer_free(&tmp);
554 php_http_message_parser_free(&arg.parser);
555 php_http_buffer_dtor(&arg.buf);
556 PTR_FREE(arg.boundary_str);
557
558 return msg;
559 }
560
561 static zend_class_entry *php_http_message_body_class_entry;
562 zend_class_entry *php_http_get_message_body_class_entry(void)
563 {
564 return php_http_message_body_class_entry;
565 }
566
567 static zend_object_handlers php_http_message_body_object_handlers;
568
569 zend_object *php_http_message_body_object_new(zend_class_entry *ce)
570 {
571 return &php_http_message_body_object_new_ex(ce, NULL)->zo;
572 }
573
574 php_http_message_body_object_t *php_http_message_body_object_new_ex(zend_class_entry *ce, php_http_message_body_t *body)
575 {
576 php_http_message_body_object_t *o;
577
578 o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
579 zend_object_std_init(&o->zo, php_http_message_body_class_entry);
580 object_properties_init(&o->zo, ce);
581
582 o->gc = emalloc(sizeof(zval));
583
584 if (body) {
585 o->body = body;
586 }
587
588 o->zo.handlers = &php_http_message_body_object_handlers;
589
590 return o;
591 }
592
593 zend_object *php_http_message_body_object_clone(zval *object)
594 {
595 php_http_message_body_object_t *new_obj;
596 php_http_message_body_object_t *old_obj = PHP_HTTP_OBJ(NULL, object);
597 php_http_message_body_t *body = php_http_message_body_copy(old_obj->body, NULL);
598
599 new_obj = php_http_message_body_object_new_ex(old_obj->zo.ce, body);
600 zend_objects_clone_members(&new_obj->zo, &old_obj->zo);
601
602 return &new_obj->zo;
603 }
604
605 static HashTable *php_http_message_body_object_get_gc(zval *object, zval **table, int *n)
606 {
607 php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, object);
608 HashTable *props = Z_OBJPROP_P(object);
609 uint32_t count = zend_hash_num_elements(props);
610
611 obj->gc = erealloc(obj->gc, (1 + count) * sizeof(zval));
612
613 if (php_http_message_body_stream(obj->body)) {
614 *n = 1;
615 php_stream_to_zval(php_http_message_body_stream(obj->body), obj->gc);
616 } else {
617 *n = 0;
618 }
619
620 if (count) {
621 zval *val;
622
623 ZEND_HASH_FOREACH_VAL(props, val)
624 {
625 ZVAL_COPY_VALUE(&obj->gc[(*n)++], val);
626 }
627 ZEND_HASH_FOREACH_END();
628 }
629 *table = obj->gc;
630
631 return NULL;
632 }
633
634 void php_http_message_body_object_free(zend_object *object)
635 {
636 php_http_message_body_object_t *obj = PHP_HTTP_OBJ(object, NULL);
637
638 PTR_FREE(obj->gc);
639 php_http_message_body_free(&obj->body);
640 zend_object_std_dtor(object);
641 }
642
643 #define PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj) \
644 do { \
645 if (!obj->body) { \
646 obj->body = php_http_message_body_init(NULL, NULL); \
647 php_stream_to_zval(php_http_message_body_stream(obj->body), obj->gc); \
648 } \
649 } while(0)
650
651 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody___construct, 0, 0, 0)
652 ZEND_ARG_INFO(0, stream)
653 ZEND_END_ARG_INFO();
654 PHP_METHOD(HttpMessageBody, __construct)
655 {
656 php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
657 zval *zstream = NULL;
658 php_stream *stream;
659
660 php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|r!", &zstream), invalid_arg, return);
661
662 if (zstream) {
663 php_http_expect(php_stream_from_zval_no_verify(stream, zstream), unexpected_val, return);
664
665 if (obj->body) {
666 php_http_message_body_free(&obj->body);
667 }
668 obj->body = php_http_message_body_init(NULL, stream);
669 php_stream_to_zval(stream, obj->gc);
670 }
671 }
672
673 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody___toString, 0, 0, 0)
674 ZEND_END_ARG_INFO();
675 PHP_METHOD(HttpMessageBody, __toString)
676 {
677 if (SUCCESS == zend_parse_parameters_none()) {
678 php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
679 zend_string *zs;
680
681 PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
682
683 zs = php_http_message_body_to_string(obj->body, 0, 0);
684 if (zs) {
685 RETURN_STR(zs);
686 }
687 }
688 RETURN_EMPTY_STRING();
689 }
690
691 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody_unserialize, 0, 0, 1)
692 ZEND_ARG_INFO(0, serialized)
693 ZEND_END_ARG_INFO();
694 PHP_METHOD(HttpMessageBody, unserialize)
695 {
696 char *us_str;
697 size_t us_len;
698
699 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &us_str, &us_len)) {
700 php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
701 php_stream *s = php_stream_memory_open(0, us_str, us_len);
702
703 obj->body = php_http_message_body_init(NULL, s);
704 php_stream_to_zval(s, obj->gc);
705 }
706 }
707
708 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody_toStream, 0, 0, 1)
709 ZEND_ARG_INFO(0, stream)
710 ZEND_ARG_INFO(0, offset)
711 ZEND_ARG_INFO(0, maxlen)
712 ZEND_END_ARG_INFO();
713 PHP_METHOD(HttpMessageBody, toStream)
714 {
715 zval *zstream;
716 zend_long offset = 0, forlen = 0;
717
718 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "r|ll", &zstream, &offset, &forlen)) {
719 php_stream *stream;
720 php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
721
722 PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
723
724 php_stream_from_zval(stream, zstream);
725 php_http_message_body_to_stream(obj->body, stream, offset, forlen);
726 RETURN_ZVAL(getThis(), 1, 0);
727 }
728 }
729
730 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody_toCallback, 0, 0, 1)
731 ZEND_ARG_INFO(0, callback)
732 ZEND_ARG_INFO(0, offset)
733 ZEND_ARG_INFO(0, maxlen)
734 ZEND_END_ARG_INFO();
735 PHP_METHOD(HttpMessageBody, toCallback)
736 {
737 php_http_pass_fcall_arg_t fcd;
738 zend_long offset = 0, forlen = 0;
739
740 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "f|ll", &fcd.fci, &fcd.fcc, &offset, &forlen)) {
741 php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
742
743 PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
744
745 ZVAL_COPY(&fcd.fcz, getThis());
746 php_http_message_body_to_callback(obj->body, php_http_pass_fcall_callback, &fcd, offset, forlen);
747 zend_fcall_info_args_clear(&fcd.fci, 1);
748 zval_ptr_dtor(&fcd.fcz);
749 RETURN_ZVAL(getThis(), 1, 0);
750 }
751 }
752
753 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody_getResource, 0, 0, 0)
754 ZEND_END_ARG_INFO();
755 PHP_METHOD(HttpMessageBody, getResource)
756 {
757 if (SUCCESS == zend_parse_parameters_none()) {
758 php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
759
760 PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
761
762 php_stream_to_zval(php_http_message_body_stream(obj->body), return_value);
763 Z_ADDREF_P(return_value);
764 }
765 }
766
767 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody_getBoundary, 0, 0, 0)
768 ZEND_END_ARG_INFO();
769 PHP_METHOD(HttpMessageBody, getBoundary)
770 {
771 if (SUCCESS == zend_parse_parameters_none()) {
772 php_http_message_body_object_t * obj = PHP_HTTP_OBJ(NULL, getThis());
773
774 PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
775
776 if (obj->body->boundary) {
777 RETURN_STRING(obj->body->boundary);
778 }
779 }
780 }
781
782 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody_append, 0, 0, 1)
783 ZEND_ARG_INFO(0, string)
784 ZEND_END_ARG_INFO();
785 PHP_METHOD(HttpMessageBody, append)
786 {
787 char *str;
788 size_t len;
789 php_http_message_body_object_t *obj;
790
791 php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &len), invalid_arg, return);
792
793 obj = PHP_HTTP_OBJ(NULL, getThis());
794 PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
795
796 php_http_expect(len == php_http_message_body_append(obj->body, str, len), runtime, return);
797
798 RETURN_ZVAL(getThis(), 1, 0);
799 }
800
801 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody_addForm, 0, 0, 0)
802 ZEND_ARG_ARRAY_INFO(0, fields, 1)
803 ZEND_ARG_ARRAY_INFO(0, files, 1)
804 ZEND_END_ARG_INFO();
805 PHP_METHOD(HttpMessageBody, addForm)
806 {
807 HashTable *fields = NULL, *files = NULL;
808 php_http_message_body_object_t *obj;
809
810 php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|h!h!", &fields, &files), invalid_arg, return);
811
812 obj = PHP_HTTP_OBJ(NULL, getThis());
813 PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
814
815 php_http_expect(SUCCESS == php_http_message_body_add_form(obj->body, fields, files), runtime, return);
816
817 RETURN_ZVAL(getThis(), 1, 0);
818 }
819
820 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody_addPart, 0, 0, 1)
821 ZEND_ARG_OBJ_INFO(0, message, http\\Message, 0)
822 ZEND_END_ARG_INFO();
823 PHP_METHOD(HttpMessageBody, addPart)
824 {
825 zval *zobj;
826 php_http_message_body_object_t *obj;
827 php_http_message_object_t *mobj;
828 zend_error_handling zeh;
829
830 php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "O", &zobj, php_http_message_get_class_entry()), invalid_arg, return);
831
832 obj = PHP_HTTP_OBJ(NULL, getThis());
833 mobj = PHP_HTTP_OBJ(NULL, zobj);
834
835 PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
836
837 zend_replace_error_handling(EH_THROW, php_http_get_exception_runtime_class_entry(), &zeh);
838 php_http_message_body_add_part(obj->body, mobj->message);
839 zend_restore_error_handling(&zeh);
840
841 if (!EG(exception)) {
842 RETURN_ZVAL(getThis(), 1, 0);
843 }
844 }
845
846 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody_etag, 0, 0, 0)
847 ZEND_END_ARG_INFO();
848 PHP_METHOD(HttpMessageBody, etag)
849 {
850 if (SUCCESS == zend_parse_parameters_none()) {
851 php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
852 char *etag;
853
854 PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
855
856 if ((etag = php_http_message_body_etag(obj->body))) {
857 RETURN_STR(php_http_cs2zs(etag, strlen(etag)));
858 } else {
859 RETURN_FALSE;
860 }
861 }
862 }
863
864 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageBody_stat, 0, 0, 0)
865 ZEND_ARG_INFO(0, field)
866 ZEND_END_ARG_INFO();
867 PHP_METHOD(HttpMessageBody, stat)
868 {
869 char *field_str = NULL;
870 size_t field_len = 0;
871
872 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_str, &field_len)) {
873 php_http_message_body_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
874 const php_stream_statbuf *sb;
875
876 PHP_HTTP_MESSAGE_BODY_OBJECT_INIT(obj);
877
878 if ((sb = php_http_message_body_stat(obj->body))) {
879 if (field_str && field_len) {
880 switch (*field_str) {
881 case 's':
882 case 'S':
883 RETURN_LONG(sb->sb.st_size);
884 break;
885 case 'a':
886 case 'A':
887 RETURN_LONG(sb->sb.st_atime);
888 break;
889 case 'm':
890 case 'M':
891 RETURN_LONG(sb->sb.st_mtime);
892 break;
893 case 'c':
894 case 'C':
895 RETURN_LONG(sb->sb.st_ctime);
896 break;
897 default:
898 php_error_docref(NULL, E_WARNING, "Unknown stat field: '%s' (should be one of [s]ize, [a]time, [m]time or [c]time)", field_str);
899 break;
900 }
901 } else {
902 object_init(return_value);
903 add_property_long_ex(return_value, ZEND_STRL("size"), sb->sb.st_size);
904 add_property_long_ex(return_value, ZEND_STRL("atime"), sb->sb.st_atime);
905 add_property_long_ex(return_value, ZEND_STRL("mtime"), sb->sb.st_mtime);
906 add_property_long_ex(return_value, ZEND_STRL("ctime"), sb->sb.st_ctime);
907 }
908 }
909 }
910 }
911
912 static zend_function_entry php_http_message_body_methods[] = {
913 PHP_ME(HttpMessageBody, __construct, ai_HttpMessageBody___construct, ZEND_ACC_PUBLIC)
914 PHP_ME(HttpMessageBody, __toString, ai_HttpMessageBody___toString, ZEND_ACC_PUBLIC)
915 PHP_MALIAS(HttpMessageBody, toString, __toString, ai_HttpMessageBody___toString, ZEND_ACC_PUBLIC)
916 PHP_MALIAS(HttpMessageBody, serialize, __toString, ai_HttpMessageBody___toString, ZEND_ACC_PUBLIC)
917 PHP_ME(HttpMessageBody, unserialize, ai_HttpMessageBody_unserialize, ZEND_ACC_PUBLIC)
918 PHP_ME(HttpMessageBody, toStream, ai_HttpMessageBody_toStream, ZEND_ACC_PUBLIC)
919 PHP_ME(HttpMessageBody, toCallback, ai_HttpMessageBody_toCallback, ZEND_ACC_PUBLIC)
920 PHP_ME(HttpMessageBody, getResource, ai_HttpMessageBody_getResource, ZEND_ACC_PUBLIC)
921 PHP_ME(HttpMessageBody, getBoundary, ai_HttpMessageBody_getBoundary, ZEND_ACC_PUBLIC)
922 PHP_ME(HttpMessageBody, append, ai_HttpMessageBody_append, ZEND_ACC_PUBLIC)
923 PHP_ME(HttpMessageBody, addForm, ai_HttpMessageBody_addForm, ZEND_ACC_PUBLIC)
924 PHP_ME(HttpMessageBody, addPart, ai_HttpMessageBody_addPart, ZEND_ACC_PUBLIC)
925 PHP_ME(HttpMessageBody, etag, ai_HttpMessageBody_etag, ZEND_ACC_PUBLIC)
926 PHP_ME(HttpMessageBody, stat, ai_HttpMessageBody_stat, ZEND_ACC_PUBLIC)
927 EMPTY_FUNCTION_ENTRY
928 };
929
930 PHP_MINIT_FUNCTION(http_message_body)
931 {
932 zend_class_entry ce = {0};
933
934 INIT_NS_CLASS_ENTRY(ce, "http\\Message", "Body", php_http_message_body_methods);
935 php_http_message_body_class_entry = zend_register_internal_class(&ce);
936 php_http_message_body_class_entry->create_object = php_http_message_body_object_new;
937 memcpy(&php_http_message_body_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
938 php_http_message_body_object_handlers.offset = XtOffsetOf(php_http_message_body_object_t, zo);
939 php_http_message_body_object_handlers.clone_obj = php_http_message_body_object_clone;
940 php_http_message_body_object_handlers.free_obj = php_http_message_body_object_free;
941 php_http_message_body_object_handlers.get_gc = php_http_message_body_object_get_gc;
942 zend_class_implements(php_http_message_body_class_entry, 1, zend_ce_serializable);
943
944 return SUCCESS;
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