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