git.m6w6.name Git - m6w6/ext-http/blob - http_response_object.c

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