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


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