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