2a0cbbd0aaad9db54ec57e4591e469abaf681171
[m6w6/ext-http] / http_response_object.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-2005, Michael Wallner <mike@php.net> |
10 +--------------------------------------------------------------------+
11 */
12
13 /* $Id$ */
14
15
16 #ifdef HAVE_CONFIG_H
17 # include "config.h"
18 #endif
19 #include "php.h"
20
21 #include "missing.h"
22
23 /* broken static properties in PHP 5.0 */
24 #if defined(ZEND_ENGINE_2) && !defined(WONKY)
25
26 #include "SAPI.h"
27 #include "php_ini.h"
28
29 #include "php_http.h"
30 #include "php_http_api.h"
31 #include "php_http_std_defs.h"
32 #include "php_http_response_object.h"
33 #include "php_http_exception_object.h"
34 #include "php_http_send_api.h"
35 #include "php_http_cache_api.h"
36 #include "php_http_headers_api.h"
37
38 #ifdef HTTP_HAVE_MHASH
39 # include <mhash.h>
40 #endif
41 #ifdef HTTP_HAVE_MAGIC
42 # include <magic.h>
43 #endif
44
45 ZEND_EXTERN_MODULE_GLOBALS(http);
46
47 #define GET_STATIC_PROP(n) *GET_STATIC_PROP_EX(http_response_object_ce, n)
48 #define UPD_STATIC_PROP(t, n, v) UPD_STATIC_PROP_EX(http_response_object_ce, t, n, v)
49 #define SET_STATIC_PROP(n, v) SET_STATIC_PROP_EX(http_response_object_ce, n, v)
50 #define UPD_STATIC_STRL(n, v, l) UPD_STATIC_STRL_EX(http_response_object_ce, n, v, l)
51
52 #define HTTP_BEGIN_ARGS(method, req_args) HTTP_BEGIN_ARGS_EX(HttpResponse, method, 0, req_args)
53 #define HTTP_EMPTY_ARGS(method, ret_ref) HTTP_EMPTY_ARGS_EX(HttpResponse, method, ret_ref)
54 #define HTTP_RESPONSE_ME(method, visibility) PHP_ME(HttpResponse, method, HTTP_ARGS(HttpResponse, method), visibility|ZEND_ACC_STATIC)
55 #define HTTP_RESPONSE_ALIAS(method, func) HTTP_STATIC_ME_ALIAS(method, func, HTTP_ARGS(HttpResponse, method))
56
57 HTTP_BEGIN_ARGS(setHeader, 2)
58 HTTP_ARG_VAL(name, 0)
59 HTTP_ARG_VAL(value, 0)
60 HTTP_ARG_VAL(replace, 0)
61 HTTP_END_ARGS;
62
63 HTTP_BEGIN_ARGS(getHeader, 0)
64 HTTP_ARG_VAL(name, 0)
65 HTTP_END_ARGS;
66
67 HTTP_EMPTY_ARGS(getETag, 0);
68 HTTP_BEGIN_ARGS(setETag, 1)
69 HTTP_ARG_VAL(etag, 0)
70 HTTP_END_ARGS;
71
72 HTTP_EMPTY_ARGS(getLastModified, 0);
73 HTTP_BEGIN_ARGS(setLastModified, 1)
74 HTTP_ARG_VAL(timestamp, 0)
75 HTTP_END_ARGS;
76
77 HTTP_EMPTY_ARGS(getCache, 0);
78 HTTP_BEGIN_ARGS(setCache, 1)
79 HTTP_ARG_VAL(cache, 0)
80 HTTP_END_ARGS;
81
82 HTTP_EMPTY_ARGS(getGzip, 0);
83 HTTP_BEGIN_ARGS(setGzip, 1)
84 HTTP_ARG_VAL(gzip, 0)
85 HTTP_END_ARGS;
86
87 HTTP_EMPTY_ARGS(getCacheControl, 0);
88 HTTP_BEGIN_ARGS(setCacheControl, 1)
89 HTTP_ARG_VAL(cache_control, 0)
90 HTTP_ARG_VAL(max_age, 0)
91 HTTP_END_ARGS;
92
93 HTTP_EMPTY_ARGS(getContentType, 0);
94 HTTP_BEGIN_ARGS(setContentType, 1)
95 HTTP_ARG_VAL(content_type, 0)
96 HTTP_END_ARGS;
97
98 HTTP_BEGIN_ARGS(guessContentType, 1)
99 HTTP_ARG_VAL(magic_file, 0)
100 HTTP_ARG_VAL(magic_mode, 0)
101 HTTP_END_ARGS;
102
103 HTTP_EMPTY_ARGS(getContentDisposition, 0);
104 HTTP_BEGIN_ARGS(setContentDisposition, 1)
105 HTTP_ARG_VAL(filename, 0)
106 HTTP_ARG_VAL(send_inline, 0)
107 HTTP_END_ARGS;
108
109 HTTP_EMPTY_ARGS(getThrottleDelay, 0);
110 HTTP_BEGIN_ARGS(setThrottleDelay, 1)
111 HTTP_ARG_VAL(seconds, 0)
112 HTTP_END_ARGS;
113
114 HTTP_EMPTY_ARGS(getBufferSize, 0);
115 HTTP_BEGIN_ARGS(setBufferSize, 1)
116 HTTP_ARG_VAL(bytes, 0)
117 HTTP_END_ARGS;
118
119 HTTP_EMPTY_ARGS(getData, 0);
120 HTTP_BEGIN_ARGS(setData, 1)
121 HTTP_ARG_VAL(data, 0)
122 HTTP_END_ARGS;
123
124 HTTP_EMPTY_ARGS(getStream, 0);
125 HTTP_BEGIN_ARGS(setStream, 1)
126 HTTP_ARG_VAL(stream, 0)
127 HTTP_END_ARGS;
128
129 HTTP_EMPTY_ARGS(getFile, 0);
130 HTTP_BEGIN_ARGS(setFile, 1)
131 HTTP_ARG_VAL(filepath, 0)
132 HTTP_END_ARGS;
133
134 HTTP_BEGIN_ARGS(send, 0)
135 HTTP_ARG_VAL(clean_ob, 0)
136 HTTP_END_ARGS;
137
138 HTTP_EMPTY_ARGS(capture, 0);
139
140 HTTP_BEGIN_ARGS(redirect, 0)
141 HTTP_ARG_VAL(url, 0)
142 HTTP_ARG_VAL(params, 0)
143 HTTP_ARG_VAL(session, 0)
144 HTTP_ARG_VAL(permanent, 0)
145 HTTP_END_ARGS;
146
147 HTTP_BEGIN_ARGS(status, 1)
148 HTTP_ARG_VAL(code, 0)
149 HTTP_END_ARGS;
150
151 HTTP_EMPTY_ARGS(getRequestHeaders, 0);
152 HTTP_EMPTY_ARGS(getRequestBody, 0);
153
154 #define http_response_object_declare_default_properties() _http_response_object_declare_default_properties(TSRMLS_C)
155 static inline void _http_response_object_declare_default_properties(TSRMLS_D);
156 #define http_grab_response_headers _http_grab_response_headers
157 static void _http_grab_response_headers(void *data, void *arg TSRMLS_DC);
158
159 zend_class_entry *http_response_object_ce;
160 zend_function_entry http_response_object_fe[] = {
161
162 HTTP_RESPONSE_ME(setHeader, ZEND_ACC_PUBLIC)
163 HTTP_RESPONSE_ME(getHeader, ZEND_ACC_PUBLIC)
164
165 HTTP_RESPONSE_ME(setETag, ZEND_ACC_PUBLIC)
166 HTTP_RESPONSE_ME(getETag, ZEND_ACC_PUBLIC)
167
168 HTTP_RESPONSE_ME(setLastModified, ZEND_ACC_PUBLIC)
169 HTTP_RESPONSE_ME(getLastModified, ZEND_ACC_PUBLIC)
170
171 HTTP_RESPONSE_ME(setContentDisposition, ZEND_ACC_PUBLIC)
172 HTTP_RESPONSE_ME(getContentDisposition, ZEND_ACC_PUBLIC)
173
174 HTTP_RESPONSE_ME(setContentType, ZEND_ACC_PUBLIC)
175 HTTP_RESPONSE_ME(getContentType, ZEND_ACC_PUBLIC)
176
177 HTTP_RESPONSE_ME(guessContentType, ZEND_ACC_PUBLIC)
178
179 HTTP_RESPONSE_ME(setCache, ZEND_ACC_PUBLIC)
180 HTTP_RESPONSE_ME(getCache, ZEND_ACC_PUBLIC)
181
182 HTTP_RESPONSE_ME(setCacheControl, ZEND_ACC_PUBLIC)
183 HTTP_RESPONSE_ME(getCacheControl, ZEND_ACC_PUBLIC)
184
185 HTTP_RESPONSE_ME(setGzip, ZEND_ACC_PUBLIC)
186 HTTP_RESPONSE_ME(getGzip, ZEND_ACC_PUBLIC)
187
188 HTTP_RESPONSE_ME(setThrottleDelay, ZEND_ACC_PUBLIC)
189 HTTP_RESPONSE_ME(getThrottleDelay, ZEND_ACC_PUBLIC)
190
191 HTTP_RESPONSE_ME(setBufferSize, ZEND_ACC_PUBLIC)
192 HTTP_RESPONSE_ME(getBufferSize, ZEND_ACC_PUBLIC)
193
194 HTTP_RESPONSE_ME(setData, ZEND_ACC_PUBLIC)
195 HTTP_RESPONSE_ME(getData, ZEND_ACC_PUBLIC)
196
197 HTTP_RESPONSE_ME(setFile, ZEND_ACC_PUBLIC)
198 HTTP_RESPONSE_ME(getFile, ZEND_ACC_PUBLIC)
199
200 HTTP_RESPONSE_ME(setStream, ZEND_ACC_PUBLIC)
201 HTTP_RESPONSE_ME(getStream, ZEND_ACC_PUBLIC)
202
203 HTTP_RESPONSE_ME(send, ZEND_ACC_PUBLIC)
204 HTTP_RESPONSE_ME(capture, ZEND_ACC_PUBLIC)
205
206 HTTP_RESPONSE_ALIAS(redirect, http_redirect)
207 HTTP_RESPONSE_ALIAS(status, http_send_status)
208 HTTP_RESPONSE_ALIAS(getRequestHeaders, http_get_request_headers)
209 HTTP_RESPONSE_ALIAS(getRequestBody, http_get_request_body)
210
211 EMPTY_FUNCTION_ENTRY
212 };
213
214 PHP_MINIT_FUNCTION(http_response_object)
215 {
216 HTTP_REGISTER_CLASS(HttpResponse, http_response_object, NULL, 0);
217 http_response_object_declare_default_properties();
218 return SUCCESS;
219 }
220
221 static inline void _http_response_object_declare_default_properties(TSRMLS_D)
222 {
223 zend_class_entry *ce = http_response_object_ce;
224
225 DCL_STATIC_PROP(PRIVATE, bool, sent, 0);
226 DCL_STATIC_PROP(PRIVATE, bool, catch, 0);
227 DCL_STATIC_PROP(PRIVATE, long, mode, -1);
228 DCL_STATIC_PROP(PRIVATE, long, stream, 0);
229 DCL_STATIC_PROP_N(PRIVATE, file);
230 DCL_STATIC_PROP_N(PRIVATE, data);
231 DCL_STATIC_PROP(PROTECTED, bool, cache, 0);
232 DCL_STATIC_PROP(PROTECTED, bool, gzip, 0);
233 DCL_STATIC_PROP_N(PROTECTED, eTag);
234 DCL_STATIC_PROP(PROTECTED, long, lastModified, 0);
235 DCL_STATIC_PROP_N(PROTECTED, cacheControl);
236 DCL_STATIC_PROP_N(PROTECTED, contentType);
237 DCL_STATIC_PROP_N(PROTECTED, contentDisposition);
238 DCL_STATIC_PROP(PROTECTED, long, bufferSize, HTTP_SENDBUF_SIZE);
239 DCL_STATIC_PROP(PROTECTED, double, throttleDelay, 0.0);
240
241 #ifndef WONKY
242 DCL_CONST(long, "REDIRECT", HTTP_REDIRECT);
243 DCL_CONST(long, "REDIRECT_PERM", HTTP_REDIRECT_PERM);
244 DCL_CONST(long, "REDIRECT_POST", HTTP_REDIRECT_POST);
245 DCL_CONST(long, "REDIRECT_TEMP", HTTP_REDIRECT_TEMP);
246
247 DCL_CONST(long, "ETAG_MD5", HTTP_ETAG_MD5);
248 DCL_CONST(long, "ETAG_SHA1", HTTP_ETAG_SHA1);
249 DCL_CONST(long, "ETAG_CRC32", HTTP_ETAG_CRC32);
250
251 # ifdef HTTP_HAVE_MHASH
252 {
253 int l, i, c = mhash_count();
254
255 for (i = 0; i <= c; ++i) {
256 char const_name[256] = {0};
257 const char *hash_name = mhash_get_hash_name_static(i);
258
259 if (hash_name) {
260 l = snprintf(const_name, 255, "ETAG_MHASH_%s", hash_name);
261 zend_declare_class_constant_long(ce, const_name, l, i TSRMLS_CC);
262 }
263 }
264 }
265 # endif /* HTTP_HAVE_MHASH */
266 #endif /* WONKY */
267 }
268
269 static void _http_grab_response_headers(void *data, void *arg TSRMLS_DC)
270 {
271 phpstr_appendl(PHPSTR(arg), ((sapi_header_struct *)data)->header);
272 phpstr_appends(PHPSTR(arg), HTTP_CRLF);
273 }
274
275 /* ### USERLAND ### */
276
277 /* {{{ proto static bool HttpResponse::setHeader(string name, mixed value[, bool replace = true])
278 *
279 * Send an HTTP header.
280 *
281 * Expects a string parameter containing the name of the header and a mixed
282 * parameter containing the value of the header, which will be converted to
283 * a string. Additionally accepts an optional boolean parameter, which
284 * specifies whether an existing header should be replaced. If the second
285 * parameter is unset no header with this name will be sent.
286 *
287 * Returns TRUE on success, or FALSE on failure.
288 *
289 * Throws HttpHeaderException if http.only_exceptions is TRUE.
290 */
291 PHP_METHOD(HttpResponse, setHeader)
292 {
293 zend_bool replace = 1;
294 char *name;
295 int name_len = 0;
296 zval *value = NULL, *orig = NULL;
297
298 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/!|b", &name, &name_len, &value, &replace)) {
299 RETURN_FALSE;
300 }
301 if (SG(headers_sent)) {
302 http_error(HE_WARNING, HTTP_E_HEADER, "Cannot add another header when headers have already been sent");
303 RETURN_FALSE;
304 }
305 if (!name_len) {
306 http_error(HE_WARNING, HTTP_E_HEADER, "Cannot send anonymous headers");
307 RETURN_FALSE;
308 }
309
310 /* delete header if value == null */
311 if (!value || Z_TYPE_P(value) == IS_NULL) {
312 RETURN_SUCCESS(http_send_header_ex(name, name_len, "", 0, replace, NULL));
313 }
314 /* send multiple header if replace is false and value is an array */
315 if (!replace && Z_TYPE_P(value) == IS_ARRAY) {
316 zval **data;
317 HashPosition pos;
318
319 FOREACH_VAL(pos, value, data) {
320 zval *orig = *data;
321
322 convert_to_string_ex(data);
323 if (SUCCESS != http_send_header_ex(name, name_len, Z_STRVAL_PP(data), Z_STRLEN_PP(data), 0, NULL)) {
324 if (orig != *data) {
325 zval_ptr_dtor(data);
326 }
327 RETURN_FALSE;
328 }
329 if (orig != *data) {
330 zval_ptr_dtor(data);
331 }
332 }
333 RETURN_TRUE;
334 }
335 /* send standard header */
336 orig = value;
337 convert_to_string_ex(&value);
338 RETVAL_SUCCESS(http_send_header_ex(name, name_len, Z_STRVAL_P(value), Z_STRLEN_P(value), replace, NULL));
339 if (orig != value) {
340 zval_ptr_dtor(&value);
341 }
342 }
343 /* }}} */
344
345 /* {{{ proto static mixed HttpResponse::getHeader([string name])
346 *
347 * Get header(s) about to be sent.
348 *
349 * Accepts a string as optional parameter which specifies the name of the
350 * header to read. If the parameter is empty or omitted, an associative array
351 * with all headers will be returned.
352 *
353 * Returns either a string containing the value of the header matching name,
354 * FALSE on failure, or an associative array with all headers.
355 */
356 PHP_METHOD(HttpResponse, getHeader)
357 {
358 char *name = NULL;
359 int name_len = 0;
360 phpstr headers;
361
362 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &name, &name_len)) {
363 RETURN_FALSE;
364 }
365
366 phpstr_init(&headers);
367 zend_llist_apply_with_argument(&SG(sapi_headers).headers, http_grab_response_headers, &headers TSRMLS_CC);
368 phpstr_fix(&headers);
369
370 if (name && name_len) {
371 zval **header;
372 HashTable headers_ht;
373
374 zend_hash_init(&headers_ht, sizeof(zval *), NULL, ZVAL_PTR_DTOR, 0);
375 if ( (SUCCESS == http_parse_headers_ex(PHPSTR_VAL(&headers), &headers_ht, 1)) &&
376 (SUCCESS == zend_hash_find(&headers_ht, name, name_len + 1, (void **) &header))) {
377 RETVAL_ZVAL(*header, 1, 0);
378 } else {
379 RETVAL_NULL();
380 }
381 zend_hash_destroy(&headers_ht);
382 } else {
383 array_init(return_value);
384 http_parse_headers_ex(PHPSTR_VAL(&headers), Z_ARRVAL_P(return_value), 1);
385 }
386
387 phpstr_dtor(&headers);
388 }
389 /* }}} */
390
391 /* {{{ proto static bool HttpResponse::setCache(bool cache)
392 *
393 * Whether it sould be attempted to cache the entitity.
394 * This will result in necessary caching headers and checks of clients
395 * "If-Modified-Since" and "If-None-Match" headers. If one of those headers
396 * matches a "304 Not Modified" status code will be issued.
397 *
398 * NOTE: If you're using sessions, be shure that you set session.cache_limiter
399 * to something more appropriate than "no-cache"!
400 *
401 * Expects a boolean as parameter specifying whether caching should be attempted.
402 *
403 * Returns TRUE ons success, or FALSE on failure.
404 */
405 PHP_METHOD(HttpResponse, setCache)
406 {
407 zend_bool do_cache = 0;
408
409 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &do_cache)) {
410 RETURN_FALSE;
411 }
412
413 RETURN_SUCCESS(UPD_STATIC_PROP(bool, cache, do_cache));
414 }
415 /* }}} */
416
417 /* {{{ proto static bool HttpResponse::getCache()
418 *
419 * Get current caching setting.
420 *
421 * Returns TRUE if caching should be attempted, else FALSE.
422 */
423 PHP_METHOD(HttpResponse, getCache)
424 {
425 NO_ARGS;
426
427 IF_RETVAL_USED {
428 zval *cache_p, *cache = convert_to_type_ex(IS_BOOL, GET_STATIC_PROP(cache), &cache_p);
429
430 RETVAL_ZVAL(cache, 1, 0);
431
432 if (cache_p) {
433 zval_ptr_dtor(&cache_p);
434 }
435 }
436 }
437 /* }}}*/
438
439 /* {{{ proto static bool HttpResponse::setGzip(bool gzip)
440 *
441 * Enable on-thy-fly gzipping of the sent entity.
442 *
443 * Expects a boolean as parameter indicating if GZip compression should be enabled.
444 *
445 * Returns TRUE on success, or FALSE on failure.
446 */
447 PHP_METHOD(HttpResponse, setGzip)
448 {
449 zend_bool do_gzip = 0;
450
451 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &do_gzip)) {
452 RETURN_FALSE;
453 }
454
455 RETURN_SUCCESS(UPD_STATIC_PROP(bool, gzip, do_gzip));
456 }
457 /* }}} */
458
459 /* {{{ proto static bool HttpResponse::getGzip()
460 *
461 * Get current gzipping setting.
462 *
463 * Returns TRUE if GZip compression is enabled, else FALSE.
464 */
465 PHP_METHOD(HttpResponse, getGzip)
466 {
467 NO_ARGS;
468
469 IF_RETVAL_USED {
470 zval *gzip_p, *gzip = convert_to_type_ex(IS_BOOL, GET_STATIC_PROP(gzip), &gzip_p);
471
472 RETVAL_ZVAL(gzip, 1, 0);
473
474 if (gzip_p) {
475 zval_ptr_dtor(&gzip_p);
476 }
477 }
478 }
479 /* }}} */
480
481 /* {{{ proto static bool HttpResponse::setCacheControl(string control[, int max_age = 0])
482 *
483 * Set a custom cache-control header, usually being "private" or "public";
484 * The max_age parameter controls how long the cache entry is valid on the client side.
485 *
486 * Expects a string parameter containing the primary cache control setting.
487 * Addtitionally accepts an int parameter specifying the max-age setting.
488 *
489 * Returns TRUE on success, or FALSE if control does not match one of
490 * "public" , "private" or "no-cache".
491 *
492 * Throws HttpInvalidParamException if http.only_exceptions is TRUE.
493 */
494 PHP_METHOD(HttpResponse, setCacheControl)
495 {
496 char *ccontrol, *cctl;
497 int cc_len;
498 long max_age = 0;
499
500 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &ccontrol, &cc_len, &max_age)) {
501 RETURN_FALSE;
502 }
503
504 if (strcmp(ccontrol, "public") && strcmp(ccontrol, "private") && strcmp(ccontrol, "no-cache")) {
505 http_error_ex(HE_WARNING, HTTP_E_INVALID_PARAM, "Cache-Control '%s' doesn't match public, private or no-cache", ccontrol);
506 RETURN_FALSE;
507 } else {
508 size_t cctl_len = spprintf(&cctl, 0, "%s, must-revalidate, max-age=%ld", ccontrol, max_age);
509 RETVAL_SUCCESS(UPD_STATIC_STRL(cacheControl, cctl, cctl_len));
510 efree(cctl);
511 }
512 }
513 /* }}} */
514
515 /* {{{ proto static string HttpResponse::getCacheControl()
516 *
517 * Get current Cache-Control header setting.
518 *
519 * Returns the current cache control setting as a string like sent in a header.
520 */
521 PHP_METHOD(HttpResponse, getCacheControl)
522 {
523 NO_ARGS;
524
525 IF_RETVAL_USED {
526 zval *ccontrol_p, *ccontrol = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(cacheControl), &ccontrol_p);
527
528 RETVAL_ZVAL(ccontrol, 1, 0);
529
530 if (ccontrol_p) {
531 zval_ptr_dtor(&ccontrol_p);
532 }
533 }
534 }
535 /* }}} */
536
537 /* {{{ proto static bool HttpResponse::setContentType(string content_type)
538 *
539 * Set the content-type of the sent entity.
540 *
541 * Expects a string as parameter specifying the content type of the sent entity.
542 *
543 * Returns TRUE on success, or FALSE if the content type does not seem to
544 * contain a primary and secondary content type part.
545 *
546 * Throws HttpInvalidParamException if http.only_exceptions is TRUE.
547 */
548 PHP_METHOD(HttpResponse, setContentType)
549 {
550 char *ctype;
551 int ctype_len;
552
553 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &ctype, &ctype_len)) {
554 RETURN_FALSE;
555 }
556
557 HTTP_CHECK_CONTENT_TYPE(ctype, RETURN_FALSE);
558 RETURN_SUCCESS(UPD_STATIC_STRL(contentType, ctype, ctype_len));
559 }
560 /* }}} */
561
562 /* {{{ proto static string HttpResponse::getContentType()
563 *
564 * Get current Content-Type header setting.
565 *
566 * Returns the currently set content type as string.
567 */
568 PHP_METHOD(HttpResponse, getContentType)
569 {
570 NO_ARGS;
571
572 IF_RETVAL_USED {
573 zval *ctype_p, *ctype = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(contentType), &ctype_p);
574
575 RETVAL_ZVAL(ctype, 1, 0);
576
577 if (ctype_p) {
578 zval_ptr_dtor(&ctype_p);
579 }
580 }
581 }
582 /* }}} */
583
584 /* {{{ proto static string HttpResponse::guessContentType(string magic_file[, int magic_mode = MAGIC_MIME])
585 *
586 * Attempts to guess the content type of supplied payload through libmagic.
587 * If the attempt is successful, the guessed content type will automatically
588 * be set as response content type.
589 *
590 * Expects a string parameter specifying the magic.mime database to use.
591 * Additionally accepts an optional int parameter, being flags for libmagic.
592 *
593 * Returns the guessed content type on success, or FALSE on failure.
594 *
595 * Throws HttpRuntimeException, HttpInvalidParamException
596 * if http.only_exceptions is TRUE.
597 */
598 PHP_METHOD(HttpResponse, guessContentType)
599 {
600 char *magic_file, *ct = NULL;
601 int magic_file_len;
602 long magic_mode = 0;
603
604 RETVAL_FALSE;
605
606 #ifdef HTTP_HAVE_MAGIC
607 magic_mode = MAGIC_MIME;
608
609 SET_EH_THROW_HTTP();
610 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &magic_file, &magic_file_len, &magic_mode)) {
611 switch (Z_LVAL_P(GET_STATIC_PROP(mode))) {
612 case SEND_DATA:
613 {
614 zval *data = GET_STATIC_PROP(data);
615 ct = http_guess_content_type(magic_file, magic_mode, Z_STRVAL_P(data), Z_STRLEN_P(data), SEND_DATA);
616 }
617 break;
618
619 case SEND_RSRC:
620 {
621 php_stream *s;
622 zval *z = GET_STATIC_PROP(stream);
623 z->type = IS_RESOURCE;
624 php_stream_from_zval(s, &z);
625 ct = http_guess_content_type(magic_file, magic_mode, s, 0, SEND_RSRC);
626 }
627 break;
628
629 default:
630 ct = http_guess_content_type(magic_file, magic_mode, Z_STRVAL_P(GET_STATIC_PROP(file)), 0, -1);
631 break;
632 }
633 if (ct) {
634 UPD_STATIC_PROP(string, contentType, ct);
635 RETVAL_STRING(ct, 0);
636 }
637 }
638 SET_EH_NORMAL();
639 #else
640 http_error(HE_THROW, HTTP_E_RUNTIME, "Cannot guess Content-Type; libmagic not available");
641 #endif
642 }
643 /* }}} */
644
645 /* {{{ proto static bool HttpResponse::setContentDisposition(string filename[, bool inline = false])
646 *
647 * Set the Content-Disposition. The Content-Disposition header is very useful
648 * if the data actually sent came from a file or something similar, that should
649 * be "saved" by the client/user (i.e. by browsers "Save as..." popup window).
650 *
651 * Expects a string parameter specifying the file name the "Save as..." dialogue
652 * should display. Optionally accepts a bool parameter, which, if set to true
653 * and the user agent knows how to handle the content type, will probably not
654 * cause the popup window to be shown.
655 *
656 * Returns TRUE on success or FALSE on failure.
657 */
658 PHP_METHOD(HttpResponse, setContentDisposition)
659 {
660 char *file, *cd;
661 int file_len;
662 size_t cd_len;
663 zend_bool send_inline = 0;
664
665 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &file, &file_len, &send_inline)) {
666 RETURN_FALSE;
667 }
668
669 cd_len = spprintf(&cd, 0, "%s; filename=\"%s\"", send_inline ? "inline" : "attachment", file);
670 RETVAL_SUCCESS(UPD_STATIC_STRL(contentDisposition, cd, cd_len));
671 efree(cd);
672 }
673 /* }}} */
674
675 /* {{{ proto static string HttpResponse::getContentDisposition()
676 *
677 * Get current Content-Disposition setting.
678 *
679 * Returns the current content disposition as string like sent in a header.
680 */
681 PHP_METHOD(HttpResponse, getContentDisposition)
682 {
683 NO_ARGS;
684
685 IF_RETVAL_USED {
686 zval *cd_p, *cd = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(contentDisposition), &cd_p);
687
688 RETVAL_ZVAL(cd, 1, 0);
689
690 if (cd_p) {
691 zval_ptr_dtor(&cd_p);
692 }
693 }
694 }
695 /* }}} */
696
697 /* {{{ proto static bool HttpResponse::setETag(string etag)
698 *
699 * Set a custom ETag. Use this only if you know what you're doing.
700 *
701 * Expects an unquoted string as parameter containing the ETag.
702 *
703 * Returns TRUE on success, or FALSE on failure.
704 */
705 PHP_METHOD(HttpResponse, setETag)
706 {
707 char *etag;
708 int etag_len;
709
710 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &etag, &etag_len)) {
711 RETURN_FALSE;
712 }
713
714 RETURN_SUCCESS(UPD_STATIC_STRL(eTag, etag, etag_len));
715 }
716 /* }}} */
717
718 /* {{{ proto static string HttpResponse::getETag()
719 *
720 * Get calculated or previously set custom ETag.
721 *
722 * Returns the calculated or previously set ETag as unquoted string.
723 */
724 PHP_METHOD(HttpResponse, getETag)
725 {
726 NO_ARGS;
727
728 IF_RETVAL_USED {
729 zval *etag_p, *etag = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(eTag), &etag_p);
730
731 RETVAL_ZVAL(etag, 1, 0);
732
733 if (etag_p) {
734 zval_ptr_dtor(&etag_p);
735 }
736 }
737 }
738 /* }}} */
739
740 /* {{{ proto static bool HttpResponse::setLastModified(int timestamp)
741 *
742 * Set a custom Last-Modified date.
743 *
744 * Expects an unix timestamp as parameter representing the last modification
745 * time of the sent entity.
746 *
747 * Returns TRUE on success, or FALSE on failure.
748 */
749 PHP_METHOD(HttpResponse, setLastModified)
750 {
751 long lm;
752
753 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &lm)) {
754 RETURN_FALSE;
755 }
756
757 RETURN_SUCCESS(UPD_STATIC_PROP(long, lastModified, lm));
758 }
759 /* }}} */
760
761 /* {{{ proto static int HttpResponse::getLastModified()
762 *
763 * Get calculated or previously set custom Last-Modified date.
764 *
765 * Returns the calculated or previously set unix timestamp.
766 */
767 PHP_METHOD(HttpResponse, getLastModified)
768 {
769 NO_ARGS;
770
771 IF_RETVAL_USED {
772 zval *lm_p, *lm = convert_to_type_ex(IS_LONG, GET_STATIC_PROP(lastModified), &lm_p);
773
774 RETVAL_ZVAL(lm, 1, 0);
775
776 if (lm_p) {
777 zval_ptr_dtor(&lm_p);
778 }
779 }
780 }
781 /* }}} */
782
783 /* {{{ proto static bool HttpResponse::setThrottleDelay(double seconds)
784 *
785 * Sets the throttle delay for use with HttpResponse::setBufferSize().
786 *
787 * Provides a basic throttling mechanism, which will yield the current process
788 * resp. thread until the entity has been completely sent, though.
789 *
790 * Note: This doesn't really work with the FastCGI SAPI.
791 *
792 * Expects a double parameter specifying the seconds too sleep() after
793 * each chunk sent.
794 *
795 * Returns TRUE on success, or FALSE on failure.
796 */
797 PHP_METHOD(HttpResponse, setThrottleDelay)
798 {
799 double seconds;
800
801 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "d", &seconds)) {
802 RETURN_FALSE;
803 }
804 RETURN_SUCCESS(UPD_STATIC_PROP(double, throttleDelay, seconds));
805 }
806 /* }}} */
807
808 /* {{{ proto static double HttpResponse::getThrottleDelay()
809 *
810 * Get the current throttle delay.
811 *
812 * Returns a double representing the throttle delay in seconds.
813 */
814 PHP_METHOD(HttpResponse, getThrottleDelay)
815 {
816 NO_ARGS;
817
818 IF_RETVAL_USED {
819 zval *delay_p, *delay = convert_to_type_ex(IS_DOUBLE, GET_STATIC_PROP(throttleDelay), &delay_p);
820
821 RETVAL_ZVAL(delay, 1, 0);
822
823 if (delay_p) {
824 zval_ptr_dtor(&delay_p);
825 }
826 }
827 }
828 /* }}} */
829
830 /* {{{ proto static bool HttpResponse::setBufferSize(int bytes)
831 *
832 * Sets the send buffer size for use with HttpResponse::setThrottleDelay().
833 *
834 * Provides a basic throttling mechanism, which will yield the current process
835 * resp. thread until the entity has been completely sent, though.
836 *
837 * Note: This doesn't really work with the FastCGI SAPI.
838 *
839 * Expects an int parameter representing the chunk size in bytes.
840 *
841 * Returns TRUE on success, or FALSE on failure.
842 */
843 PHP_METHOD(HttpResponse, setBufferSize)
844 {
845 long bytes;
846
847 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &bytes)) {
848 RETURN_FALSE;
849 }
850 RETURN_SUCCESS(UPD_STATIC_PROP(long, bufferSize, bytes));
851 }
852 /* }}} */
853
854 /* {{{ proto static int HttpResponse::getBufferSize()
855 *
856 * Get current buffer size.
857 *
858 * Returns an int representing the current buffer size in bytes.
859 */
860 PHP_METHOD(HttpResponse, getBufferSize)
861 {
862 NO_ARGS;
863
864 IF_RETVAL_USED {
865 zval *size_p, *size = convert_to_type_ex(IS_LONG, GET_STATIC_PROP(bufferSize), &size_p);
866
867 RETVAL_ZVAL(size, 1, 0);
868
869 if (size_p) {
870 zval_ptr_dtor(&size_p);
871 }
872 }
873 }
874 /* }}} */
875
876 /* {{{ proto static bool HttpResponse::setData(mixed data)
877 *
878 * Set the data to be sent.
879 *
880 * Expects one parameter, which will be converted to a string and contains
881 * the data to send.
882 *
883 * Returns TRUE on success, or FALSE on failure.
884 */
885 PHP_METHOD(HttpResponse, setData)
886 {
887 char *etag;
888 zval *the_data;
889
890 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &the_data)) {
891 RETURN_FALSE;
892 }
893 if (Z_TYPE_P(the_data) != IS_STRING) {
894 convert_to_string_ex(&the_data);
895 }
896
897 if ( (SUCCESS != SET_STATIC_PROP(data, the_data)) ||
898 (SUCCESS != UPD_STATIC_PROP(long, mode, SEND_DATA))) {
899 RETURN_FALSE;
900 }
901
902 UPD_STATIC_PROP(long, lastModified, http_last_modified(the_data, SEND_DATA));
903 if (etag = http_etag(Z_STRVAL_P(the_data), Z_STRLEN_P(the_data), SEND_DATA)) {
904 UPD_STATIC_PROP(string, eTag, etag);
905 efree(etag);
906 }
907
908 RETURN_TRUE;
909 }
910 /* }}} */
911
912 /* {{{ proto static string HttpResponse::getData()
913 *
914 * Get the previously set data to be sent.
915 *
916 * Returns a string containing the previously set data to send.
917 */
918 PHP_METHOD(HttpResponse, getData)
919 {
920 NO_ARGS;
921
922 IF_RETVAL_USED {
923 zval *the_data = GET_STATIC_PROP(data);
924
925 RETURN_ZVAL(the_data, 1, 0);
926 }
927 }
928 /* }}} */
929
930 /* {{{ proto static bool HttpResponse::setStream(resource stream)
931 *
932 * Set the resource to be sent.
933 *
934 * Expects a resource parameter referencing an already opened stream from
935 * which the data to send will be read.
936 *
937 * Returns TRUE on success, or FALSE on failure.
938 */
939 PHP_METHOD(HttpResponse, setStream)
940 {
941 char *etag;
942 zval *the_stream;
943 php_stream *the_real_stream;
944 php_stream_statbuf ssb;
945
946 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &the_stream)) {
947 RETURN_FALSE;
948 }
949
950 php_stream_from_zval(the_real_stream, &the_stream);
951 if (php_stream_stat(the_real_stream, &ssb)) {
952 RETURN_FALSE;
953 }
954
955 if ( (SUCCESS != UPD_STATIC_PROP(long, stream, Z_LVAL_P(the_stream))) ||
956 (SUCCESS != UPD_STATIC_PROP(long, mode, SEND_RSRC))) {
957 RETURN_FALSE;
958 }
959 zend_list_addref(Z_LVAL_P(the_stream));
960
961 UPD_STATIC_PROP(long, lastModified, http_last_modified(the_real_stream, SEND_RSRC));
962 if (etag = http_etag(the_real_stream, 0, SEND_RSRC)) {
963 UPD_STATIC_PROP(string, eTag, etag);
964 efree(etag);
965 }
966
967 RETURN_TRUE;
968 }
969 /* }}} */
970
971 /* {{{ proto static resource HttpResponse::getStream()
972 *
973 * Get the previously set resource to be sent.
974 *
975 * Returns the previously set resource.
976 */
977 PHP_METHOD(HttpResponse, getStream)
978 {
979 NO_ARGS;
980
981 IF_RETVAL_USED {
982 zval *stream_p;
983
984 RETVAL_RESOURCE(Z_LVAL_P(convert_to_type_ex(IS_LONG, GET_STATIC_PROP(stream), &stream_p)));
985
986 if (stream_p) {
987 zval_ptr_dtor(&stream_p);
988 }
989 }
990 }
991 /* }}} */
992
993 /* {{{ proto static bool HttpResponse::setFile(string file)
994 *
995 * Set the file to be sent.
996 *
997 * Expects a string as parameter, specifying the path to the file to send.
998 *
999 * Returns TRUE on success, or FALSE on failure.
1000 */
1001 PHP_METHOD(HttpResponse, setFile)
1002 {
1003 char *the_file, *etag;
1004 int file_len;
1005 php_stream_statbuf ssb;
1006
1007 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &the_file, &file_len)) {
1008 RETURN_FALSE;
1009 }
1010
1011 if (php_stream_stat_path(the_file, &ssb)) {
1012 RETURN_FALSE;
1013 }
1014
1015 if ( (SUCCESS != UPD_STATIC_STRL(file, the_file, file_len)) ||
1016 (SUCCESS != UPD_STATIC_PROP(long, mode, -1))) {
1017 RETURN_FALSE;
1018 }
1019
1020 UPD_STATIC_PROP(long, lastModified, http_last_modified(the_file, -1));
1021 if (etag = http_etag(the_file, 0, -1)) {
1022 UPD_STATIC_PROP(string, eTag, etag);
1023 efree(etag);
1024 }
1025
1026 RETURN_TRUE;
1027 }
1028 /* }}} */
1029
1030 /* {{{ proto static string HttpResponse::getFile()
1031 *
1032 * Get the previously set file to be sent.
1033 *
1034 * Returns the previously set path to the file to send as string.
1035 */
1036 PHP_METHOD(HttpResponse, getFile)
1037 {
1038 NO_ARGS;
1039
1040 IF_RETVAL_USED {
1041 zval *the_file_p, *the_file = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(file), &the_file_p);
1042
1043 RETVAL_ZVAL(the_file, 1, 0);
1044
1045 if (the_file_p) {
1046 zval_ptr_dtor(&the_file_p);
1047 }
1048 }
1049 }
1050 /* }}} */
1051
1052 /* {{{ proto static bool HttpResponse::send([bool clean_ob = true])
1053 *
1054 * Finally send the entity.
1055 *
1056 * Accepts an optional boolean parameter, specifying wheter the ouput
1057 * buffers should be discarded prior sending. A successful caching attempt
1058 * will cause a script termination, and write a log entry if the INI setting
1059 * http.cache_log is set.
1060 *
1061 * Returns TRUE on success, or FALSE on failure.
1062 *
1063 * Throws HttpHeaderException, HttpResponseException if http.onyl_excpetions is TRUE.
1064 *
1065 * Example:
1066 * <pre>
1067 * <?php
1068 * HttpResponse::setCache(true);
1069 * HttpResponse::setContentType('application/pdf');
1070 * HttpResponse::setContentDisposition("$user.pdf", false);
1071 * HttpResponse::setFile('sheet.pdf');
1072 * HttpResponse::send();
1073 * ?>
1074 * </pre>
1075 */
1076 PHP_METHOD(HttpResponse, send)
1077 {
1078 zval *sent;
1079 zend_bool clean_ob = 1;
1080
1081 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &clean_ob)) {
1082 RETURN_FALSE;
1083 }
1084 if (SG(headers_sent)) {
1085 http_error(HE_WARNING, HTTP_E_RESPONSE, "Cannot send HttpResponse, headers have already been sent");
1086 RETURN_FALSE;
1087 }
1088
1089 sent = GET_STATIC_PROP(sent);
1090 if (zval_is_true(sent)) {
1091 http_error(HE_WARNING, HTTP_E_RESPONSE, "Cannot send HttpResponse, response has already been sent");
1092 RETURN_FALSE;
1093 } else {
1094 Z_LVAL_P(sent) = 1;
1095 }
1096
1097 /* capture mode */
1098 if (zval_is_true(GET_STATIC_PROP(catch))) {
1099 zval *etag_p, *the_data;
1100
1101 MAKE_STD_ZVAL(the_data);
1102 php_ob_get_buffer(the_data TSRMLS_CC);
1103 SET_STATIC_PROP(data, the_data);
1104 ZVAL_LONG(GET_STATIC_PROP(mode), SEND_DATA);
1105
1106 if (!Z_STRLEN_P(convert_to_type_ex(IS_STRING, GET_STATIC_PROP(eTag), &etag_p))) {
1107 char *etag = http_etag(Z_STRVAL_P(the_data), Z_STRLEN_P(the_data), SEND_DATA);
1108 if (etag) {
1109 UPD_STATIC_PROP(string, eTag, etag);
1110 efree(etag);
1111 }
1112 }
1113 zval_ptr_dtor(&the_data);
1114
1115 if (etag_p) {
1116 zval_ptr_dtor(&etag_p);
1117 }
1118
1119 clean_ob = 1;
1120 }
1121
1122 if (clean_ob) {
1123 /* interrupt on-the-fly etag generation */
1124 HTTP_G(etag).started = 0;
1125 /* discard previous output buffers */
1126 php_end_ob_buffers(0 TSRMLS_CC);
1127 }
1128
1129 /* caching */
1130 if (zval_is_true(GET_STATIC_PROP(cache))) {
1131 zval *cctl, *cctl_p, *etag, *etag_p, *lmod, *lmod_p;
1132
1133 etag = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(eTag), &etag_p);
1134 lmod = convert_to_type_ex(IS_LONG, GET_STATIC_PROP(lastModified), &lmod_p);
1135 cctl = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(cacheControl), &cctl_p);
1136
1137 http_cache_etag(Z_STRVAL_P(etag), Z_STRLEN_P(etag), Z_STRVAL_P(cctl), Z_STRLEN_P(cctl));
1138 http_cache_last_modified(Z_LVAL_P(lmod), Z_LVAL_P(lmod) ? Z_LVAL_P(lmod) : time(NULL), Z_STRVAL_P(cctl), Z_STRLEN_P(cctl));
1139
1140 if (etag_p) zval_ptr_dtor(&etag_p);
1141 if (lmod_p) zval_ptr_dtor(&lmod_p);
1142 if (cctl_p) zval_ptr_dtor(&cctl_p);
1143 }
1144
1145 /* content type */
1146 {
1147 zval *ctype_p, *ctype = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(contentType), &ctype_p);
1148 if (Z_STRLEN_P(ctype)) {
1149 http_send_content_type(Z_STRVAL_P(ctype), Z_STRLEN_P(ctype));
1150 } else {
1151 char *ctypes = INI_STR("default_mimetype");
1152 size_t ctlen = ctypes ? strlen(ctypes) : 0;
1153
1154 if (ctlen) {
1155 http_send_content_type(ctypes, ctlen);
1156 } else {
1157 http_send_content_type("application/x-octetstream", lenof("application/x-octetstream"));
1158 }
1159 }
1160 if (ctype_p) {
1161 zval_ptr_dtor(&ctype_p);
1162 }
1163 }
1164
1165 /* content disposition */
1166 {
1167 zval *cd_p, *cd = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(contentDisposition), &cd_p);
1168 if (Z_STRLEN_P(cd)) {
1169 http_send_header_ex("Content-Disposition", lenof("Content-Disposition"), Z_STRVAL_P(cd), Z_STRLEN_P(cd), 1, NULL);
1170 }
1171 if (cd_p) {
1172 zval_ptr_dtor(&cd_p);
1173 }
1174 }
1175
1176 /* throttling */
1177 {
1178 zval *bsize_p, *bsize = convert_to_type_ex(IS_LONG, GET_STATIC_PROP(bufferSize), &bsize_p);
1179 zval *delay_p, *delay = convert_to_type_ex(IS_DOUBLE, GET_STATIC_PROP(throttleDelay), &delay_p);
1180 HTTP_G(send).buffer_size = Z_LVAL_P(bsize);
1181 HTTP_G(send).throttle_delay = Z_DVAL_P(delay);
1182 if (bsize_p) zval_ptr_dtor(&bsize_p);
1183 if (delay_p) zval_ptr_dtor(&delay_p);
1184 }
1185
1186 /* gzip */
1187 HTTP_G(send).gzip_encoding = zval_is_true(GET_STATIC_PROP(gzip));
1188
1189 /* start ob */
1190 php_start_ob_buffer(NULL, HTTP_G(send).buffer_size, 0 TSRMLS_CC);
1191
1192 /* send */
1193 switch (Z_LVAL_P(GET_STATIC_PROP(mode)))
1194 {
1195 case SEND_DATA:
1196 {
1197 zval *zdata_p, *zdata = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(data), &zdata_p);
1198 RETVAL_SUCCESS(http_send_data_ex(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata), 1));
1199 if (zdata_p) zval_ptr_dtor(&zdata_p);
1200 return;
1201 }
1202
1203 case SEND_RSRC:
1204 {
1205 php_stream *the_real_stream;
1206 zval *the_stream_p, *the_stream = convert_to_type_ex(IS_LONG, GET_STATIC_PROP(stream), &the_stream_p);
1207 the_stream->type = IS_RESOURCE;
1208 php_stream_from_zval(the_real_stream, &the_stream);
1209 RETVAL_SUCCESS(http_send_stream_ex(the_real_stream, 0, 1));
1210 if (the_stream_p) zval_ptr_dtor(&the_stream_p);
1211 return;
1212 }
1213
1214 default:
1215 {
1216 zval *file_p;
1217 RETVAL_SUCCESS(http_send_file_ex(Z_STRVAL_P(convert_to_type_ex(IS_STRING, GET_STATIC_PROP(file), &file_p)), 1));
1218 if (file_p) zval_ptr_dtor(&file_p);
1219 return;
1220 }
1221 }
1222 }
1223 /* }}} */
1224
1225 /* {{{ proto static void HttpResponse::capture()
1226 *
1227 * Capture script output.
1228 *
1229 * Example:
1230 * <pre>
1231 * <?php
1232 * HttpResponse::setCache(true);
1233 * HttpResponse::capture();
1234 * // script follows
1235 * ?>
1236 * </pre>
1237 */
1238 PHP_METHOD(HttpResponse, capture)
1239 {
1240 NO_ARGS;
1241
1242 UPD_STATIC_PROP(long, catch, 1);
1243
1244 php_end_ob_buffers(0 TSRMLS_CC);
1245 php_start_ob_buffer(NULL, 40960, 0 TSRMLS_CC);
1246
1247 /* register shutdown function */
1248 {
1249 zval func, retval, arg, *argp[1];
1250
1251 INIT_PZVAL(&arg);
1252 INIT_PZVAL(&func);
1253 INIT_PZVAL(&retval);
1254 ZVAL_STRINGL(&func, "register_shutdown_function", lenof("register_shutdown_function"), 0);
1255
1256 array_init(&arg);
1257 add_next_index_stringl(&arg, "HttpResponse", lenof("HttpResponse"), 1);
1258 add_next_index_stringl(&arg, "send", lenof("send"), 1);
1259 argp[0] = &arg;
1260 call_user_function(EG(function_table), NULL, &func, &retval, 1, argp TSRMLS_CC);
1261 zval_dtor(&arg);
1262 }
1263 }
1264 /* }}} */
1265
1266 #endif /* ZEND_ENGINE_2 && !WONKY */
1267
1268 /*
1269 * Local variables:
1270 * tab-width: 4
1271 * c-basic-offset: 4
1272 * End:
1273 * vim600: noet sw=4 ts=4 fdm=marker
1274 * vim<600: noet sw=4 ts=4
1275 */
1276