2 +--------------------------------------------------------------------+
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-2006, Michael Wallner <mike@php.net> |
10 +--------------------------------------------------------------------+
15 #define HTTP_WANT_SAPI
16 #define HTTP_WANT_MAGIC
19 /* broken static properties in PHP 5.0 */
20 #if defined(ZEND_ENGINE_2) && !defined(WONKY)
24 #include "php_http_api.h"
25 #include "php_http_cache_api.h"
26 #include "php_http_exception_object.h"
27 #include "php_http_headers_api.h"
28 #include "php_http_response_object.h"
29 #include "php_http_send_api.h"
31 #define HTTP_BEGIN_ARGS(method, req_args) HTTP_BEGIN_ARGS_EX(HttpResponse, method, 0, req_args)
32 #define HTTP_EMPTY_ARGS(method) HTTP_EMPTY_ARGS_EX(HttpResponse, method, 0)
33 #define HTTP_RESPONSE_ME(method, visibility) PHP_ME(HttpResponse, method, HTTP_ARGS(HttpResponse, method), visibility|ZEND_ACC_STATIC)
34 #define HTTP_RESPONSE_ALIAS(method, func) HTTP_STATIC_ME_ALIAS(method, func, HTTP_ARGS(HttpResponse, method))
36 HTTP_BEGIN_ARGS(setHeader
, 1)
38 HTTP_ARG_VAL(value
, 0)
39 HTTP_ARG_VAL(replace
, 0)
42 HTTP_BEGIN_ARGS(getHeader
, 0)
46 HTTP_EMPTY_ARGS(getETag
);
47 HTTP_BEGIN_ARGS(setETag
, 1)
51 HTTP_EMPTY_ARGS(getLastModified
);
52 HTTP_BEGIN_ARGS(setLastModified
, 1)
53 HTTP_ARG_VAL(timestamp
, 0)
56 HTTP_EMPTY_ARGS(getCache
);
57 HTTP_BEGIN_ARGS(setCache
, 1)
58 HTTP_ARG_VAL(cache
, 0)
61 HTTP_EMPTY_ARGS(getGzip
);
62 HTTP_BEGIN_ARGS(setGzip
, 1)
66 HTTP_EMPTY_ARGS(getCacheControl
);
67 HTTP_BEGIN_ARGS(setCacheControl
, 1)
68 HTTP_ARG_VAL(cache_control
, 0)
69 HTTP_ARG_VAL(max_age
, 0)
70 HTTP_ARG_VAL(must_revalidate
, 0)
73 HTTP_EMPTY_ARGS(getContentType
);
74 HTTP_BEGIN_ARGS(setContentType
, 1)
75 HTTP_ARG_VAL(content_type
, 0)
78 HTTP_BEGIN_ARGS(guessContentType
, 1)
79 HTTP_ARG_VAL(magic_file
, 0)
80 HTTP_ARG_VAL(magic_mode
, 0)
83 HTTP_EMPTY_ARGS(getContentDisposition
);
84 HTTP_BEGIN_ARGS(setContentDisposition
, 1)
85 HTTP_ARG_VAL(filename
, 0)
86 HTTP_ARG_VAL(send_inline
, 0)
89 HTTP_EMPTY_ARGS(getThrottleDelay
);
90 HTTP_BEGIN_ARGS(setThrottleDelay
, 1)
91 HTTP_ARG_VAL(seconds
, 0)
94 HTTP_EMPTY_ARGS(getBufferSize
);
95 HTTP_BEGIN_ARGS(setBufferSize
, 1)
96 HTTP_ARG_VAL(bytes
, 0)
99 HTTP_EMPTY_ARGS(getData
);
100 HTTP_BEGIN_ARGS(setData
, 1)
101 HTTP_ARG_VAL(data
, 0)
104 HTTP_EMPTY_ARGS(getStream
);
105 HTTP_BEGIN_ARGS(setStream
, 1)
106 HTTP_ARG_VAL(stream
, 0)
109 HTTP_EMPTY_ARGS(getFile
);
110 HTTP_BEGIN_ARGS(setFile
, 1)
111 HTTP_ARG_VAL(filepath
, 0)
114 HTTP_BEGIN_ARGS(send
, 0)
115 HTTP_ARG_VAL(clean_ob
, 0)
118 HTTP_EMPTY_ARGS(capture
);
120 HTTP_BEGIN_ARGS(redirect
, 0)
122 HTTP_ARG_VAL(params
, 0)
123 HTTP_ARG_VAL(session
, 0)
124 HTTP_ARG_VAL(permanent
, 0)
127 HTTP_BEGIN_ARGS(status
, 1)
128 HTTP_ARG_VAL(code
, 0)
131 HTTP_EMPTY_ARGS(getRequestHeaders
);
132 HTTP_EMPTY_ARGS(getRequestBody
);
133 HTTP_EMPTY_ARGS(getRequestBodyStream
);
135 #define http_grab_response_headers _http_grab_response_headers
136 static void _http_grab_response_headers(void *data
, void *arg TSRMLS_DC
);
138 #define OBJ_PROP_CE http_response_object_ce
139 zend_class_entry
*http_response_object_ce
;
140 zend_function_entry http_response_object_fe
[] = {
142 HTTP_RESPONSE_ME(setHeader
, ZEND_ACC_PUBLIC
)
143 HTTP_RESPONSE_ME(getHeader
, ZEND_ACC_PUBLIC
)
145 HTTP_RESPONSE_ME(setETag
, ZEND_ACC_PUBLIC
)
146 HTTP_RESPONSE_ME(getETag
, ZEND_ACC_PUBLIC
)
148 HTTP_RESPONSE_ME(setLastModified
, ZEND_ACC_PUBLIC
)
149 HTTP_RESPONSE_ME(getLastModified
, ZEND_ACC_PUBLIC
)
151 HTTP_RESPONSE_ME(setContentDisposition
, ZEND_ACC_PUBLIC
)
152 HTTP_RESPONSE_ME(getContentDisposition
, ZEND_ACC_PUBLIC
)
154 HTTP_RESPONSE_ME(setContentType
, ZEND_ACC_PUBLIC
)
155 HTTP_RESPONSE_ME(getContentType
, ZEND_ACC_PUBLIC
)
157 HTTP_RESPONSE_ME(guessContentType
, ZEND_ACC_PUBLIC
)
159 HTTP_RESPONSE_ME(setCache
, ZEND_ACC_PUBLIC
)
160 HTTP_RESPONSE_ME(getCache
, ZEND_ACC_PUBLIC
)
162 HTTP_RESPONSE_ME(setCacheControl
, ZEND_ACC_PUBLIC
)
163 HTTP_RESPONSE_ME(getCacheControl
, ZEND_ACC_PUBLIC
)
165 HTTP_RESPONSE_ME(setGzip
, ZEND_ACC_PUBLIC
)
166 HTTP_RESPONSE_ME(getGzip
, ZEND_ACC_PUBLIC
)
168 HTTP_RESPONSE_ME(setThrottleDelay
, ZEND_ACC_PUBLIC
)
169 HTTP_RESPONSE_ME(getThrottleDelay
, ZEND_ACC_PUBLIC
)
171 HTTP_RESPONSE_ME(setBufferSize
, ZEND_ACC_PUBLIC
)
172 HTTP_RESPONSE_ME(getBufferSize
, ZEND_ACC_PUBLIC
)
174 HTTP_RESPONSE_ME(setData
, ZEND_ACC_PUBLIC
)
175 HTTP_RESPONSE_ME(getData
, ZEND_ACC_PUBLIC
)
177 HTTP_RESPONSE_ME(setFile
, ZEND_ACC_PUBLIC
)
178 HTTP_RESPONSE_ME(getFile
, ZEND_ACC_PUBLIC
)
180 HTTP_RESPONSE_ME(setStream
, ZEND_ACC_PUBLIC
)
181 HTTP_RESPONSE_ME(getStream
, ZEND_ACC_PUBLIC
)
183 HTTP_RESPONSE_ME(send
, ZEND_ACC_PUBLIC
)
184 HTTP_RESPONSE_ME(capture
, ZEND_ACC_PUBLIC
)
186 HTTP_RESPONSE_ALIAS(redirect
, http_redirect
)
187 HTTP_RESPONSE_ALIAS(status
, http_send_status
)
188 HTTP_RESPONSE_ALIAS(getRequestHeaders
, http_get_request_headers
)
189 HTTP_RESPONSE_ALIAS(getRequestBody
, http_get_request_body
)
190 HTTP_RESPONSE_ALIAS(getRequestBodyStream
, http_get_request_body_stream
)
195 PHP_MINIT_FUNCTION(http_response_object
)
197 HTTP_REGISTER_CLASS(HttpResponse
, http_response_object
, NULL
, 0);
199 DCL_STATIC_PROP(PRIVATE
, bool, sent
, 0);
200 DCL_STATIC_PROP(PRIVATE
, bool, catch, 0);
201 DCL_STATIC_PROP(PRIVATE
, long, mode
, -1);
202 DCL_STATIC_PROP(PRIVATE
, long, stream
, 0);
203 DCL_STATIC_PROP_N(PRIVATE
, file
);
204 DCL_STATIC_PROP_N(PRIVATE
, data
);
205 DCL_STATIC_PROP(PROTECTED
, bool, cache
, 0);
206 DCL_STATIC_PROP(PROTECTED
, bool, gzip
, 0);
207 DCL_STATIC_PROP_N(PROTECTED
, eTag
);
208 DCL_STATIC_PROP(PROTECTED
, long, lastModified
, 0);
209 DCL_STATIC_PROP_N(PROTECTED
, cacheControl
);
210 DCL_STATIC_PROP_N(PROTECTED
, contentType
);
211 DCL_STATIC_PROP_N(PROTECTED
, contentDisposition
);
212 DCL_STATIC_PROP(PROTECTED
, long, bufferSize
, 0);
213 DCL_STATIC_PROP(PROTECTED
, double, throttleDelay
, 0.0);
216 DCL_CONST(long, "REDIRECT", HTTP_REDIRECT
);
217 DCL_CONST(long, "REDIRECT_PERM", HTTP_REDIRECT_PERM
);
218 DCL_CONST(long, "REDIRECT_FOUND", HTTP_REDIRECT_FOUND
);
219 DCL_CONST(long, "REDIRECT_POST", HTTP_REDIRECT_POST
);
220 DCL_CONST(long, "REDIRECT_PROXY", HTTP_REDIRECT_PROXY
);
221 DCL_CONST(long, "REDIRECT_TEMP", HTTP_REDIRECT_TEMP
);
227 static void _http_grab_response_headers(void *data
, void *arg TSRMLS_DC
)
229 phpstr_appendl(PHPSTR(arg
), ((sapi_header_struct
*)data
)->header
);
230 phpstr_appends(PHPSTR(arg
), HTTP_CRLF
);
233 /* ### USERLAND ### */
235 /* {{{ proto static bool HttpResponse::setHeader(string name[, mixed value[, bool replace = true]])
236 Send an HTTP header. */
237 PHP_METHOD(HttpResponse
, setHeader
)
239 zend_bool replace
= 1;
244 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s|z/!b", &name
, &name_len
, &value
, &replace
)) {
247 if (SG(headers_sent
)) {
248 http_error(HE_WARNING
, HTTP_E_HEADER
, "Cannot add another header when headers have already been sent");
252 http_error(HE_WARNING
, HTTP_E_HEADER
, "Cannot send anonymous headers");
255 http_send_header_zval_ex(name
, name_len
, &value
, replace
);
260 /* {{{ proto static mixed HttpResponse::getHeader([string name])
261 Get header(s) about to be sent. */
262 PHP_METHOD(HttpResponse
, getHeader
)
268 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "|s", &name
, &name_len
)) {
272 phpstr_init(&headers
);
273 zend_llist_apply_with_argument(&SG(sapi_headers
).headers
, http_grab_response_headers
, &headers TSRMLS_CC
);
274 phpstr_fix(&headers
);
276 if (name
&& name_len
) {
278 HashTable headers_ht
;
280 zend_hash_init(&headers_ht
, sizeof(zval
*), NULL
, ZVAL_PTR_DTOR
, 0);
281 if ( (SUCCESS
== http_parse_headers_ex(PHPSTR_VAL(&headers
), &headers_ht
, 1)) &&
282 (SUCCESS
== zend_hash_find(&headers_ht
, name
, name_len
+ 1, (void *) &header
))) {
283 RETVAL_ZVAL(*header
, 1, 0);
287 zend_hash_destroy(&headers_ht
);
289 array_init(return_value
);
290 http_parse_headers_ex(PHPSTR_VAL(&headers
), Z_ARRVAL_P(return_value
), 1);
293 phpstr_dtor(&headers
);
297 /* {{{ proto static bool HttpResponse::setCache(bool cache)
298 Whether it should be attempted to cache the entity. */
299 PHP_METHOD(HttpResponse
, setCache
)
301 zend_bool do_cache
= 0;
303 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "b", &do_cache
)) {
307 RETURN_SUCCESS(UPD_STATIC_PROP(bool, cache
, do_cache
));
311 /* {{{ proto static bool HttpResponse::getCache()
312 Get current caching setting. */
313 PHP_METHOD(HttpResponse
, getCache
)
317 if (return_value_used
) {
318 zval
*cache_p
, *cache
= convert_to_type_ex(IS_BOOL
, GET_STATIC_PROP(cache
), &cache_p
);
320 RETVAL_ZVAL(cache
, 1, 0);
323 zval_ptr_dtor(&cache_p
);
329 /* {{{ proto static bool HttpResponse::setGzip(bool gzip)
330 Enable on-thy-fly gzipping of the sent entity. */
331 PHP_METHOD(HttpResponse
, setGzip
)
333 zend_bool do_gzip
= 0;
335 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "b", &do_gzip
)) {
339 RETURN_SUCCESS(UPD_STATIC_PROP(bool, gzip
, do_gzip
));
343 /* {{{ proto static bool HttpResponse::getGzip()
344 Get current gzipping setting. */
345 PHP_METHOD(HttpResponse
, getGzip
)
349 if (return_value_used
) {
350 zval
*gzip_p
, *gzip
= convert_to_type_ex(IS_BOOL
, GET_STATIC_PROP(gzip
), &gzip_p
);
352 RETVAL_ZVAL(gzip
, 1, 0);
355 zval_ptr_dtor(&gzip_p
);
361 /* {{{ proto static bool HttpResponse::setCacheControl(string control[, int max_age = 0[, bool must_revalidate = true]])
362 Set a custom cache-control header, usually being "private" or "public"; The max_age parameter controls how long the cache entry is valid on the client side. */
363 PHP_METHOD(HttpResponse
, setCacheControl
)
365 char *ccontrol
, *cctl
;
368 zend_bool must_revalidate
= 1;
370 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s|lb", &ccontrol
, &cc_len
, &max_age
, &must_revalidate
)) {
374 if (strcmp(ccontrol
, "public") && strcmp(ccontrol
, "private") && strcmp(ccontrol
, "no-cache")) {
375 http_error_ex(HE_WARNING
, HTTP_E_INVALID_PARAM
, "Cache-Control '%s' doesn't match public, private or no-cache", ccontrol
);
378 size_t cctl_len
= spprintf(&cctl
, 0, "%s,%s max-age=%ld", ccontrol
, must_revalidate
?" must-revalidate,":"", max_age
);
379 RETVAL_SUCCESS(UPD_STATIC_STRL(cacheControl
, cctl
, cctl_len
));
385 /* {{{ proto static string HttpResponse::getCacheControl()
386 Get current Cache-Control header setting. */
387 PHP_METHOD(HttpResponse
, getCacheControl
)
391 if (return_value_used
) {
392 zval
*ccontrol_p
, *ccontrol
= convert_to_type_ex(IS_STRING
, GET_STATIC_PROP(cacheControl
), &ccontrol_p
);
394 RETVAL_ZVAL(ccontrol
, 1, 0);
397 zval_ptr_dtor(&ccontrol_p
);
403 /* {{{ proto static bool HttpResponse::setContentType(string content_type)
404 Set the content-type of the sent entity. */
405 PHP_METHOD(HttpResponse
, setContentType
)
410 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &ctype
, &ctype_len
)) {
414 HTTP_CHECK_CONTENT_TYPE(ctype
, RETURN_FALSE
);
415 RETURN_SUCCESS(UPD_STATIC_STRL(contentType
, ctype
, ctype_len
));
419 /* {{{ proto static string HttpResponse::getContentType()
420 Get current Content-Type header setting. */
421 PHP_METHOD(HttpResponse
, getContentType
)
425 if (return_value_used
) {
426 zval
*ctype_p
, *ctype
= convert_to_type_ex(IS_STRING
, GET_STATIC_PROP(contentType
), &ctype_p
);
428 RETVAL_ZVAL(ctype
, 1, 0);
431 zval_ptr_dtor(&ctype_p
);
437 /* {{{ proto static string HttpResponse::guessContentType(string magic_file[, int magic_mode = MAGIC_MIME])
438 Attempts to guess the content type of supplied payload through libmagic. */
439 PHP_METHOD(HttpResponse
, guessContentType
)
441 #ifdef HTTP_HAVE_MAGIC
442 char *magic_file
, *ct
= NULL
;
444 long magic_mode
= MAGIC_MIME
;
448 if (SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s|l", &magic_file
, &magic_file_len
, &magic_mode
)) {
449 switch (Z_LVAL_P(GET_STATIC_PROP(mode
))) {
452 zval
*data
= GET_STATIC_PROP(data
);
453 ct
= http_guess_content_type(magic_file
, magic_mode
, Z_STRVAL_P(data
), Z_STRLEN_P(data
), SEND_DATA
);
460 zval
*z
= GET_STATIC_PROP(stream
);
461 z
->type
= IS_RESOURCE
;
462 php_stream_from_zval(s
, &z
);
463 ct
= http_guess_content_type(magic_file
, magic_mode
, s
, 0, SEND_RSRC
);
468 ct
= http_guess_content_type(magic_file
, magic_mode
, Z_STRVAL_P(GET_STATIC_PROP(file
)), 0, -1);
472 UPD_STATIC_PROP(string
, contentType
, ct
);
473 RETVAL_STRING(ct
, 0);
478 http_error(HE_THROW
, HTTP_E_RUNTIME
, "Cannot guess Content-Type; libmagic not available");
484 /* {{{ proto static bool HttpResponse::setContentDisposition(string filename[, bool inline = false])
485 Set the Content-Disposition. */
486 PHP_METHOD(HttpResponse
, setContentDisposition
)
491 zend_bool send_inline
= 0;
493 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s|b", &file
, &file_len
, &send_inline
)) {
497 cd_len
= spprintf(&cd
, 0, "%s; filename=\"%s\"", send_inline
? "inline" : "attachment", file
);
498 RETVAL_SUCCESS(UPD_STATIC_STRL(contentDisposition
, cd
, cd_len
));
503 /* {{{ proto static string HttpResponse::getContentDisposition()
504 Get current Content-Disposition setting. */
505 PHP_METHOD(HttpResponse
, getContentDisposition
)
509 if (return_value_used
) {
510 zval
*cd_p
, *cd
= convert_to_type_ex(IS_STRING
, GET_STATIC_PROP(contentDisposition
), &cd_p
);
512 RETVAL_ZVAL(cd
, 1, 0);
515 zval_ptr_dtor(&cd_p
);
521 /* {{{ proto static bool HttpResponse::setETag(string etag)
522 Set a custom ETag. Use this only if you know what you're doing. */
523 PHP_METHOD(HttpResponse
, setETag
)
528 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &etag
, &etag_len
)) {
532 RETURN_SUCCESS(UPD_STATIC_STRL(eTag
, etag
, etag_len
));
536 /* {{{ proto static string HttpResponse::getETag()
537 Get calculated or previously set custom ETag. */
538 PHP_METHOD(HttpResponse
, getETag
)
542 if (return_value_used
) {
543 zval
*etag_p
, *etag
= convert_to_type_ex(IS_STRING
, GET_STATIC_PROP(eTag
), &etag_p
);
545 RETVAL_ZVAL(etag
, 1, 0);
548 zval_ptr_dtor(&etag_p
);
554 /* {{{ proto static bool HttpResponse::setLastModified(int timestamp)
555 Set a custom Last-Modified date. */
556 PHP_METHOD(HttpResponse
, setLastModified
)
560 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "l", &lm
)) {
564 RETURN_SUCCESS(UPD_STATIC_PROP(long, lastModified
, lm
));
568 /* {{{ proto static int HttpResponse::getLastModified()
569 Get calculated or previously set custom Last-Modified date. */
570 PHP_METHOD(HttpResponse
, getLastModified
)
574 if (return_value_used
) {
575 zval
*lm_p
, *lm
= convert_to_type_ex(IS_LONG
, GET_STATIC_PROP(lastModified
), &lm_p
);
577 RETVAL_ZVAL(lm
, 1, 0);
580 zval_ptr_dtor(&lm_p
);
586 /* {{{ proto static bool HttpResponse::setThrottleDelay(double seconds)
587 Sets the throttle delay for use with HttpResponse::setBufferSize(). */
588 PHP_METHOD(HttpResponse
, setThrottleDelay
)
592 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "d", &seconds
)) {
595 RETURN_SUCCESS(UPD_STATIC_PROP(double, throttleDelay
, seconds
));
599 /* {{{ proto static double HttpResponse::getThrottleDelay()
600 Get the current throttle delay. */
601 PHP_METHOD(HttpResponse
, getThrottleDelay
)
605 if (return_value_used
) {
606 zval
*delay_p
, *delay
= convert_to_type_ex(IS_DOUBLE
, GET_STATIC_PROP(throttleDelay
), &delay_p
);
608 RETVAL_ZVAL(delay
, 1, 0);
611 zval_ptr_dtor(&delay_p
);
617 /* {{{ proto static bool HttpResponse::setBufferSize(int bytes)
618 Sets the send buffer size for use with HttpResponse::setThrottleDelay(). */
619 PHP_METHOD(HttpResponse
, setBufferSize
)
623 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "l", &bytes
)) {
626 RETURN_SUCCESS(UPD_STATIC_PROP(long, bufferSize
, bytes
));
630 /* {{{ proto static int HttpResponse::getBufferSize()
631 Get current buffer size. */
632 PHP_METHOD(HttpResponse
, getBufferSize
)
636 if (return_value_used
) {
637 zval
*size_p
, *size
= convert_to_type_ex(IS_LONG
, GET_STATIC_PROP(bufferSize
), &size_p
);
639 RETVAL_ZVAL(size
, 1, 0);
642 zval_ptr_dtor(&size_p
);
648 /* {{{ proto static bool HttpResponse::setData(mixed data)
649 Set the data to be sent. */
650 PHP_METHOD(HttpResponse
, setData
)
655 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "z/", &the_data
)) {
658 if (Z_TYPE_P(the_data
) != IS_STRING
) {
659 convert_to_string_ex(&the_data
);
662 if ( (SUCCESS
!= SET_STATIC_PROP(data
, the_data
)) ||
663 (SUCCESS
!= UPD_STATIC_PROP(long, mode
, SEND_DATA
))) {
667 UPD_STATIC_PROP(long, lastModified
, http_last_modified(the_data
, SEND_DATA
));
668 if ((etag
= http_etag(Z_STRVAL_P(the_data
), Z_STRLEN_P(the_data
), SEND_DATA
))) {
669 UPD_STATIC_PROP(string
, eTag
, etag
);
677 /* {{{ proto static string HttpResponse::getData()
678 Get the previously set data to be sent. */
679 PHP_METHOD(HttpResponse
, getData
)
683 if (return_value_used
) {
684 zval
*the_data
= GET_STATIC_PROP(data
);
686 RETURN_ZVAL(the_data
, 1, 0);
691 /* {{{ proto static bool HttpResponse::setStream(resource stream)
692 Set the resource to be sent. */
693 PHP_METHOD(HttpResponse
, setStream
)
697 php_stream
*the_real_stream
;
698 php_stream_statbuf ssb
;
700 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "r", &the_stream
)) {
704 php_stream_from_zval(the_real_stream
, &the_stream
);
705 if (php_stream_stat(the_real_stream
, &ssb
)) {
709 if ( (SUCCESS
!= UPD_STATIC_PROP(long, stream
, Z_LVAL_P(the_stream
))) ||
710 (SUCCESS
!= UPD_STATIC_PROP(long, mode
, SEND_RSRC
))) {
713 zend_list_addref(Z_LVAL_P(the_stream
));
715 UPD_STATIC_PROP(long, lastModified
, http_last_modified(the_real_stream
, SEND_RSRC
));
716 if ((etag
= http_etag(the_real_stream
, 0, SEND_RSRC
))) {
717 UPD_STATIC_PROP(string
, eTag
, etag
);
725 /* {{{ proto static resource HttpResponse::getStream()
726 Get the previously set resource to be sent. */
727 PHP_METHOD(HttpResponse
, getStream
)
731 if (return_value_used
) {
734 RETVAL_RESOURCE(Z_LVAL_P(convert_to_type_ex(IS_LONG
, GET_STATIC_PROP(stream
), &stream_p
)));
737 zval_ptr_dtor(&stream_p
);
743 /* {{{ proto static bool HttpResponse::setFile(string file)
744 Set the file to be sent. */
745 PHP_METHOD(HttpResponse
, setFile
)
747 char *the_file
, *etag
;
749 php_stream_statbuf ssb
;
751 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &the_file
, &file_len
)) {
755 if (php_stream_stat_path(the_file
, &ssb
)) {
759 if ( (SUCCESS
!= UPD_STATIC_STRL(file
, the_file
, file_len
)) ||
760 (SUCCESS
!= UPD_STATIC_PROP(long, mode
, -1))) {
764 UPD_STATIC_PROP(long, lastModified
, http_last_modified(the_file
, -1));
765 if ((etag
= http_etag(the_file
, 0, -1))) {
766 UPD_STATIC_PROP(string
, eTag
, etag
);
774 /* {{{ proto static string HttpResponse::getFile()
775 Get the previously set file to be sent. */
776 PHP_METHOD(HttpResponse
, getFile
)
780 if (return_value_used
) {
781 zval
*the_file_p
, *the_file
= convert_to_type_ex(IS_STRING
, GET_STATIC_PROP(file
), &the_file_p
);
783 RETVAL_ZVAL(the_file
, 1, 0);
786 zval_ptr_dtor(&the_file_p
);
792 /* {{{ proto static bool HttpResponse::send([bool clean_ob = true])
793 Finally send the entity. */
794 PHP_METHOD(HttpResponse
, send
)
797 zend_bool clean_ob
= 1;
799 if (SUCCESS
!= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "|b", &clean_ob
)) {
803 HTTP_CHECK_HEADERS_SENT(RETURN_FALSE
);
805 sent
= GET_STATIC_PROP(sent
);
806 if (Z_LVAL_P(sent
)) {
807 http_error(HE_WARNING
, HTTP_E_RESPONSE
, "Cannot send HttpResponse, response has already been sent");
814 if (zval_is_true(GET_STATIC_PROP(catch))) {
815 zval
*etag_p
, *the_data
;
817 MAKE_STD_ZVAL(the_data
);
818 php_ob_get_buffer(the_data TSRMLS_CC
);
819 SET_STATIC_PROP(data
, the_data
);
820 ZVAL_LONG(GET_STATIC_PROP(mode
), SEND_DATA
);
822 if (!Z_STRLEN_P(convert_to_type_ex(IS_STRING
, GET_STATIC_PROP(eTag
), &etag_p
))) {
823 char *etag
= http_etag(Z_STRVAL_P(the_data
), Z_STRLEN_P(the_data
), SEND_DATA
);
825 UPD_STATIC_PROP(string
, eTag
, etag
);
829 zval_ptr_dtor(&the_data
);
832 zval_ptr_dtor(&etag_p
);
839 /* interrupt on-the-fly etag generation */
840 HTTP_G
->etag
.started
= 0;
841 /* discard previous output buffers */
842 php_end_ob_buffers(0 TSRMLS_CC
);
846 if (zval_is_true(GET_STATIC_PROP(cache
))) {
847 zval
*cctl
, *cctl_p
, *etag
, *etag_p
, *lmod
, *lmod_p
;
849 etag
= convert_to_type_ex(IS_STRING
, GET_STATIC_PROP(eTag
), &etag_p
);
850 lmod
= convert_to_type_ex(IS_LONG
, GET_STATIC_PROP(lastModified
), &lmod_p
);
851 cctl
= convert_to_type_ex(IS_STRING
, GET_STATIC_PROP(cacheControl
), &cctl_p
);
853 if (Z_LVAL_P(lmod
) || Z_STRLEN_P(etag
)) {
854 if (Z_STRLEN_P(cctl
)) {
855 http_send_cache_control(Z_STRVAL_P(cctl
), Z_STRLEN_P(cctl
));
857 http_send_cache_control(HTTP_DEFAULT_CACHECONTROL
, lenof(HTTP_DEFAULT_CACHECONTROL
));
859 if (Z_STRLEN_P(etag
)) {
860 http_send_etag(Z_STRVAL_P(etag
), Z_STRLEN_P(etag
));
862 if (Z_LVAL_P(lmod
)) {
863 http_send_last_modified(Z_LVAL_P(lmod
));
867 if (etag_p
) zval_ptr_dtor(&etag_p
);
868 if (lmod_p
) zval_ptr_dtor(&lmod_p
);
869 if (cctl_p
) zval_ptr_dtor(&cctl_p
);
874 zval
*ctype_p
, *ctype
= convert_to_type_ex(IS_STRING
, GET_STATIC_PROP(contentType
), &ctype_p
);
875 if (Z_STRLEN_P(ctype
)) {
876 http_send_content_type(Z_STRVAL_P(ctype
), Z_STRLEN_P(ctype
));
878 char *ctypes
= INI_STR("default_mimetype");
879 size_t ctlen
= ctypes
? strlen(ctypes
) : 0;
882 http_send_content_type(ctypes
, ctlen
);
884 http_send_content_type("application/x-octetstream", lenof("application/x-octetstream"));
888 zval_ptr_dtor(&ctype_p
);
892 /* content disposition */
894 zval
*cd_p
, *cd
= convert_to_type_ex(IS_STRING
, GET_STATIC_PROP(contentDisposition
), &cd_p
);
895 if (Z_STRLEN_P(cd
)) {
896 http_send_header_ex("Content-Disposition", lenof("Content-Disposition"), Z_STRVAL_P(cd
), Z_STRLEN_P(cd
), 1, NULL
);
899 zval_ptr_dtor(&cd_p
);
905 zval
*bsize_p
, *bsize
= convert_to_type_ex(IS_LONG
, GET_STATIC_PROP(bufferSize
), &bsize_p
);
906 zval
*delay_p
, *delay
= convert_to_type_ex(IS_DOUBLE
, GET_STATIC_PROP(throttleDelay
), &delay_p
);
907 HTTP_G
->send
.buffer_size
= Z_LVAL_P(bsize
);
908 HTTP_G
->send
.throttle_delay
= Z_DVAL_P(delay
);
909 if (bsize_p
) zval_ptr_dtor(&bsize_p
);
910 if (delay_p
) zval_ptr_dtor(&delay_p
);
914 HTTP_G
->send
.deflate
.response
= zval_is_true(GET_STATIC_PROP(gzip
));
917 switch (Z_LVAL_P(GET_STATIC_PROP(mode
))) {
920 zval
*zdata_p
, *zdata
= convert_to_type_ex(IS_STRING
, GET_STATIC_PROP(data
), &zdata_p
);
921 RETVAL_SUCCESS(http_send_data(Z_STRVAL_P(zdata
), Z_STRLEN_P(zdata
)));
922 if (zdata_p
) zval_ptr_dtor(&zdata_p
);
928 php_stream
*the_real_stream
;
929 zval
*the_stream_p
, *the_stream
= convert_to_type_ex(IS_LONG
, GET_STATIC_PROP(stream
), &the_stream_p
);
930 the_stream
->type
= IS_RESOURCE
;
931 php_stream_from_zval(the_real_stream
, &the_stream
);
932 RETVAL_SUCCESS(http_send_stream(the_real_stream
));
933 if (the_stream_p
) zval_ptr_dtor(&the_stream_p
);
940 RETVAL_SUCCESS(http_send_file(Z_STRVAL_P(convert_to_type_ex(IS_STRING
, GET_STATIC_PROP(file
), &file_p
))));
941 if (file_p
) zval_ptr_dtor(&file_p
);
948 /* {{{ proto static void HttpResponse::capture()
949 Capture script output.
951 PHP_METHOD(HttpResponse
, capture
)
955 HTTP_CHECK_HEADERS_SENT(RETURN_FALSE
);
957 UPD_STATIC_PROP(long, catch, 1);
959 php_end_ob_buffers(0 TSRMLS_CC
);
960 php_start_ob_buffer(NULL
, 0, 0 TSRMLS_CC
);
962 /* register shutdown function */
964 zval func
, retval
, arg
, *argp
[1];
969 ZVAL_STRINGL(&func
, "register_shutdown_function", lenof("register_shutdown_function"), 0);
972 add_next_index_stringl(&arg
, "HttpResponse", lenof("HttpResponse"), 1);
973 add_next_index_stringl(&arg
, "send", lenof("send"), 1);
975 call_user_function(EG(function_table
), NULL
, &func
, &retval
, 1, argp TSRMLS_CC
);
981 #endif /* ZEND_ENGINE_2 && !WONKY */
988 * vim600: noet sw=4 ts=4 fdm=marker
989 * vim<600: noet sw=4 ts=4