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         char *magic_file, *ct = NULL;
 571         int magic_file_len;
 572         long magic_mode = 0;
 573
 574         RETVAL_FALSE;
 575
 576 #ifdef HTTP_HAVE_MAGIC
 577         magic_mode = MAGIC_MIME;
 578
 579         SET_EH_THROW_HTTP();
 580         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &magic_file, &magic_file_len, &magic_mode)) {
 581                 switch (Z_LVAL_P(GET_STATIC_PROP(mode))) {
 582                         case SEND_DATA:
 583                         {
 584                                 zval *data = GET_STATIC_PROP(data);
 585                                 ct = http_guess_content_type(magic_file, magic_mode, Z_STRVAL_P(data), Z_STRLEN_P(data), SEND_DATA);
 586                         }
 587                         break;
 588
 589                         case SEND_RSRC:
 590                         {
 591                                 php_stream *s;
 592                                 zval *z = GET_STATIC_PROP(stream);
 593                                 z->type = IS_RESOURCE;
 594                                 php_stream_from_zval(s, &z);
 595                                 ct = http_guess_content_type(magic_file, magic_mode, s, 0, SEND_RSRC);
 596                         }
 597                         break;
 598
 599                         default:
 600                                 ct = http_guess_content_type(magic_file, magic_mode, Z_STRVAL_P(GET_STATIC_PROP(file)), 0, -1);
 601                         break;
 602                 }
 603                 if (ct) {
 604                         UPD_STATIC_PROP(string, contentType, ct);
 605                         RETVAL_STRING(ct, 0);
 606                 }
 607         }
 608         SET_EH_NORMAL();
 609 #else
 610         http_error(HE_THROW, HTTP_E_RUNTIME, "Cannot guess Content-Type; libmagic not available");
 611 #endif
 612 }
 613 /* }}} */
 614
 615 /* {{{ proto static bool HttpResponse::setContentDisposition(string filename[, bool inline = false])
 616  *
 617  * Set the Content-Disposition.  The Content-Disposition header is very useful
 618  * if the data actually sent came from a file or something similar, that should
 619  * be "saved" by the client/user (i.e. by browsers "Save as..." popup window).
 620  *
 621  * Expects a string parameter specifying the file name the "Save as..." dialog
 622  * should display.  Optionally accepts a bool parameter, which, if set to true
 623  * and the user agent knows how to handle the content type, will probably not
 624  * cause the popup window to be shown.
 625  *
 626  * Returns TRUE on success or FALSE on failure.
 627  */
 628 PHP_METHOD(HttpResponse, setContentDisposition)
 629 {
 630         char *file, *cd;
 631         int file_len;
 632         size_t cd_len;
 633         zend_bool send_inline = 0;
 634
 635         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &file, &file_len, &send_inline)) {
 636                 RETURN_FALSE;
 637         }
 638
 639         cd_len = spprintf(&cd, 0, "%s; filename=\"%s\"", send_inline ? "inline" : "attachment", file);
 640         RETVAL_SUCCESS(UPD_STATIC_STRL(contentDisposition, cd, cd_len));
 641         efree(cd);
 642 }
 643 /* }}} */
 644
 645 /* {{{ proto static string HttpResponse::getContentDisposition()
 646  *
 647  * Get current Content-Disposition setting.
 648  *
 649  * Returns the current content disposition as string like sent in a header.
 650  */
 651 PHP_METHOD(HttpResponse, getContentDisposition)
 652 {
 653         NO_ARGS;
 654
 655         IF_RETVAL_USED {
 656                 zval *cd_p, *cd = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(contentDisposition), &cd_p);
 657
 658                 RETVAL_ZVAL(cd, 1, 0);
 659
 660                 if (cd_p) {
 661                         zval_ptr_dtor(&cd_p);
 662                 }
 663         }
 664 }
 665 /* }}} */
 666
 667 /* {{{ proto static bool HttpResponse::setETag(string etag)
 668  *
 669  * Set a custom ETag.  Use this only if you know what you're doing.
 670  *
 671  * Expects an unquoted string as parameter containing the ETag.
 672  *
 673  * Returns TRUE on success, or FALSE on failure.
 674  */
 675 PHP_METHOD(HttpResponse, setETag)
 676 {
 677         char *etag;
 678         int etag_len;
 679
 680         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &etag, &etag_len)) {
 681                 RETURN_FALSE;
 682         }
 683
 684         RETURN_SUCCESS(UPD_STATIC_STRL(eTag, etag, etag_len));
 685 }
 686 /* }}} */
 687
 688 /* {{{ proto static string HttpResponse::getETag()
 689  *
 690  * Get calculated or previously set custom ETag.
 691  *
 692  * Returns the calculated or previously set ETag as unquoted string.
 693  */
 694 PHP_METHOD(HttpResponse, getETag)
 695 {
 696         NO_ARGS;
 697
 698         IF_RETVAL_USED {
 699                 zval *etag_p, *etag = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(eTag), &etag_p);
 700
 701                 RETVAL_ZVAL(etag, 1, 0);
 702
 703                 if (etag_p) {
 704                         zval_ptr_dtor(&etag_p);
 705                 }
 706         }
 707 }
 708 /* }}} */
 709
 710 /* {{{ proto static bool HttpResponse::setLastModified(int timestamp)
 711  *
 712  * Set a custom Last-Modified date.
 713  *
 714  * Expects an unix timestamp as parameter representing the last modification
 715  * time of the sent entity.
 716  *
 717  * Returns TRUE on success, or FALSE on failure.
 718  */
 719 PHP_METHOD(HttpResponse, setLastModified)
 720 {
 721         long lm;
 722
 723         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &lm)) {
 724                 RETURN_FALSE;
 725         }
 726
 727         RETURN_SUCCESS(UPD_STATIC_PROP(long, lastModified, lm));
 728 }
 729 /* }}} */
 730
 731 /* {{{ proto static int HttpResponse::getLastModified()
 732  *
 733  * Get calculated or previously set custom Last-Modified date.
 734  *
 735  * Returns the calculated or previously set unix timestamp.
 736  */
 737 PHP_METHOD(HttpResponse, getLastModified)
 738 {
 739         NO_ARGS;
 740
 741         IF_RETVAL_USED {
 742                 zval *lm_p, *lm = convert_to_type_ex(IS_LONG, GET_STATIC_PROP(lastModified), &lm_p);
 743
 744                 RETVAL_ZVAL(lm, 1, 0);
 745
 746                 if (lm_p) {
 747                         zval_ptr_dtor(&lm_p);
 748                 }
 749         }
 750 }
 751 /* }}} */
 752
 753 /* {{{ proto static bool HttpResponse::setThrottleDelay(double seconds)
 754  *
 755  * Sets the throttle delay for use with HttpResponse::setBufferSize().
 756  *
 757  * Provides a basic throttling mechanism, which will yield the current process
 758  * resp. thread until the entity has been completely sent, though.
 759  *
 760  * Note: This doesn't really work with the FastCGI SAPI.
 761  *
 762  * Expects a double parameter specifying the seconds too sleep() after
 763  * each chunk sent.
 764  *
 765  * Returns TRUE on success, or FALSE on failure.
 766  */
 767 PHP_METHOD(HttpResponse, setThrottleDelay)
 768 {
 769         double seconds;
 770
 771         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "d", &seconds)) {
 772                 RETURN_FALSE;
 773         }
 774         RETURN_SUCCESS(UPD_STATIC_PROP(double, throttleDelay, seconds));
 775 }
 776 /* }}} */
 777
 778 /* {{{ proto static double HttpResponse::getThrottleDelay()
 779  *
 780  * Get the current throttle delay.
 781  *
 782  * Returns a double representing the throttle delay in seconds.
 783  */
 784 PHP_METHOD(HttpResponse, getThrottleDelay)
 785 {
 786         NO_ARGS;
 787
 788         IF_RETVAL_USED {
 789                 zval *delay_p, *delay = convert_to_type_ex(IS_DOUBLE, GET_STATIC_PROP(throttleDelay), &delay_p);
 790
 791                 RETVAL_ZVAL(delay, 1, 0);
 792
 793                 if (delay_p) {
 794                         zval_ptr_dtor(&delay_p);
 795                 }
 796         }
 797 }
 798 /* }}} */
 799
 800 /* {{{ proto static bool HttpResponse::setBufferSize(int bytes)
 801  *
 802  * Sets the send buffer size for use with HttpResponse::setThrottleDelay().
 803  *
 804  * Provides a basic throttling mechanism, which will yield the current process
 805  * resp. thread until the entity has been completely sent, though.
 806  *
 807  * Note: This doesn't really work with the FastCGI SAPI.
 808  *
 809  * Expects an int parameter representing the chunk size in bytes.
 810  *
 811  * Returns TRUE on success, or FALSE on failure.
 812  */
 813 PHP_METHOD(HttpResponse, setBufferSize)
 814 {
 815         long bytes;
 816
 817         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &bytes)) {
 818                 RETURN_FALSE;
 819         }
 820         RETURN_SUCCESS(UPD_STATIC_PROP(long, bufferSize, bytes));
 821 }
 822 /* }}} */
 823
 824 /* {{{ proto static int HttpResponse::getBufferSize()
 825  *
 826  * Get current buffer size.
 827  *
 828  * Returns an int representing the current buffer size in bytes.
 829  */
 830 PHP_METHOD(HttpResponse, getBufferSize)
 831 {
 832         NO_ARGS;
 833
 834         IF_RETVAL_USED {
 835                 zval *size_p, *size = convert_to_type_ex(IS_LONG, GET_STATIC_PROP(bufferSize), &size_p);
 836
 837                 RETVAL_ZVAL(size, 1, 0);
 838
 839                 if (size_p) {
 840                         zval_ptr_dtor(&size_p);
 841                 }
 842         }
 843 }
 844 /* }}} */
 845
 846 /* {{{ proto static bool HttpResponse::setData(mixed data)
 847  *
 848  * Set the data to be sent.
 849  *
 850  * Expects one parameter, which will be converted to a string and contains
 851  * the data to send.
 852  *
 853  * Returns TRUE on success, or FALSE on failure.
 854  */
 855 PHP_METHOD(HttpResponse, setData)
 856 {
 857         char *etag;
 858         zval *the_data;
 859
 860         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &the_data)) {
 861                 RETURN_FALSE;
 862         }
 863         if (Z_TYPE_P(the_data) != IS_STRING) {
 864                 convert_to_string_ex(&the_data);
 865         }
 866
 867         if (    (SUCCESS != SET_STATIC_PROP(data, the_data)) ||
 868                         (SUCCESS != UPD_STATIC_PROP(long, mode, SEND_DATA))) {
 869                 RETURN_FALSE;
 870         }
 871
 872         UPD_STATIC_PROP(long, lastModified, http_last_modified(the_data, SEND_DATA));
 873         if ((etag = http_etag(Z_STRVAL_P(the_data), Z_STRLEN_P(the_data), SEND_DATA))) {
 874                 UPD_STATIC_PROP(string, eTag, etag);
 875                 efree(etag);
 876         }
 877
 878         RETURN_TRUE;
 879 }
 880 /* }}} */
 881
 882 /* {{{ proto static string HttpResponse::getData()
 883  *
 884  * Get the previously set data to be sent.
 885  *
 886  * Returns a string containing the previously set data to send.
 887  */
 888 PHP_METHOD(HttpResponse, getData)
 889 {
 890         NO_ARGS;
 891
 892         IF_RETVAL_USED {
 893                 zval *the_data = GET_STATIC_PROP(data);
 894
 895                 RETURN_ZVAL(the_data, 1, 0);
 896         }
 897 }
 898 /* }}} */
 899
 900 /* {{{ proto static bool HttpResponse::setStream(resource stream)
 901  *
 902  * Set the resource to be sent.
 903  *
 904  * Expects a resource parameter referencing an already opened stream from
 905  * which the data to send will be read.
 906  *
 907  * Returns TRUE on success, or FALSE on failure.
 908  */
 909 PHP_METHOD(HttpResponse, setStream)
 910 {
 911         char *etag;
 912         zval *the_stream;
 913         php_stream *the_real_stream;
 914         php_stream_statbuf ssb;
 915
 916         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &the_stream)) {
 917                 RETURN_FALSE;
 918         }
 919
 920         php_stream_from_zval(the_real_stream, &the_stream);
 921         if (php_stream_stat(the_real_stream, &ssb)) {
 922                 RETURN_FALSE;
 923         }
 924
 925         if (    (SUCCESS != UPD_STATIC_PROP(long, stream, Z_LVAL_P(the_stream))) ||
 926                         (SUCCESS != UPD_STATIC_PROP(long, mode, SEND_RSRC))) {
 927                 RETURN_FALSE;
 928         }
 929         zend_list_addref(Z_LVAL_P(the_stream));
 930
 931         UPD_STATIC_PROP(long, lastModified, http_last_modified(the_real_stream, SEND_RSRC));
 932         if ((etag = http_etag(the_real_stream, 0, SEND_RSRC))) {
 933                 UPD_STATIC_PROP(string, eTag, etag);
 934                 efree(etag);
 935         }
 936
 937         RETURN_TRUE;
 938 }
 939 /* }}} */
 940
 941 /* {{{ proto static resource HttpResponse::getStream()
 942  *
 943  * Get the previously set resource to be sent.
 944  *
 945  * Returns the previously set resource.
 946  */
 947 PHP_METHOD(HttpResponse, getStream)
 948 {
 949         NO_ARGS;
 950
 951         IF_RETVAL_USED {
 952                 zval *stream_p;
 953
 954                 RETVAL_RESOURCE(Z_LVAL_P(convert_to_type_ex(IS_LONG, GET_STATIC_PROP(stream), &stream_p)));
 955
 956                 if (stream_p) {
 957                         zval_ptr_dtor(&stream_p);
 958                 }
 959         }
 960 }
 961 /* }}} */
 962
 963 /* {{{ proto static bool HttpResponse::setFile(string file)
 964  *
 965  * Set the file to be sent.
 966  *
 967  * Expects a string as parameter, specifying the path to the file to send.
 968  *
 969  * Returns TRUE on success, or FALSE on failure.
 970  */
 971 PHP_METHOD(HttpResponse, setFile)
 972 {
 973         char *the_file, *etag;
 974         int file_len;
 975         php_stream_statbuf ssb;
 976
 977         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &the_file, &file_len)) {
 978                 RETURN_FALSE;
 979         }
 980
 981         if (php_stream_stat_path(the_file, &ssb)) {
 982                 RETURN_FALSE;
 983         }
 984
 985         if (    (SUCCESS != UPD_STATIC_STRL(file, the_file, file_len)) ||
 986                         (SUCCESS != UPD_STATIC_PROP(long, mode, -1))) {
 987                 RETURN_FALSE;
 988         }
 989
 990         UPD_STATIC_PROP(long, lastModified, http_last_modified(the_file, -1));
 991         if ((etag = http_etag(the_file, 0, -1))) {
 992                 UPD_STATIC_PROP(string, eTag, etag);
 993                 efree(etag);
 994         }
 995
 996         RETURN_TRUE;
 997 }
 998 /* }}} */
 999
1000 /* {{{ proto static string HttpResponse::getFile()
1001  *
1002  * Get the previously set file to be sent.
1003  *
1004  * Returns the previously set path to the file to send as string.
1005  */
1006 PHP_METHOD(HttpResponse, getFile)
1007 {
1008         NO_ARGS;
1009
1010         IF_RETVAL_USED {
1011                 zval *the_file_p, *the_file = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(file), &the_file_p);
1012
1013                 RETVAL_ZVAL(the_file, 1, 0);
1014
1015                 if (the_file_p) {
1016                         zval_ptr_dtor(&the_file_p);
1017                 }
1018         }
1019 }
1020 /* }}} */
1021
1022 /* {{{ proto static bool HttpResponse::send([bool clean_ob = true])
1023  *
1024  * Finally send the entity.
1025  *
1026  * Accepts an optional boolean parameter, specifying whether the output
1027  * buffers should be discarded prior sending.  A successful caching attempt
1028  * will cause a script termination, and write a log entry if the INI setting
1029  * http.cache_log is set.
1030  *
1031  * Returns TRUE on success, or FALSE on failure.
1032  *
1033  * Throws HttpHeaderException, HttpResponseException if http.only_exceptions is TRUE.
1034  *
1035  * Example:
1036  * <pre>
1037  * <?php
1038  * HttpResponse::setCache(true);
1039  * HttpResponse::setContentType('application/pdf');
1040  * HttpResponse::setContentDisposition("$user.pdf", false);
1041  * HttpResponse::setFile('sheet.pdf');
1042  * HttpResponse::send();
1043  * ?>
1044  * </pre>
1045  */
1046 PHP_METHOD(HttpResponse, send)
1047 {
1048         zval *sent;
1049         zend_bool clean_ob = 1;
1050
1051         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &clean_ob)) {
1052                 RETURN_FALSE;
1053         }
1054
1055         HTTP_CHECK_HEADERS_SENT(RETURN_FALSE);
1056
1057         sent = GET_STATIC_PROP(sent);
1058         if (Z_LVAL_P(sent)) {
1059                 http_error(HE_WARNING, HTTP_E_RESPONSE, "Cannot send HttpResponse, response has already been sent");
1060                 RETURN_FALSE;
1061         } else {
1062                 Z_LVAL_P(sent) = 1;
1063         }
1064
1065         /* capture mode */
1066         if (zval_is_true(GET_STATIC_PROP(catch))) {
1067                 zval *etag_p, *the_data;
1068
1069                 MAKE_STD_ZVAL(the_data);
1070                 php_ob_get_buffer(the_data TSRMLS_CC);
1071                 SET_STATIC_PROP(data, the_data);
1072                 ZVAL_LONG(GET_STATIC_PROP(mode), SEND_DATA);
1073
1074                 if (!Z_STRLEN_P(convert_to_type_ex(IS_STRING, GET_STATIC_PROP(eTag), &etag_p))) {
1075                         char *etag = http_etag(Z_STRVAL_P(the_data), Z_STRLEN_P(the_data), SEND_DATA);
1076                         if (etag) {
1077                                 UPD_STATIC_PROP(string, eTag, etag);
1078                                 efree(etag);
1079                         }
1080                 }
1081                 zval_ptr_dtor(&the_data);
1082
1083                 if (etag_p) {
1084                         zval_ptr_dtor(&etag_p);
1085                 }
1086
1087                 clean_ob = 1;
1088         }
1089
1090         if (clean_ob) {
1091                 /* interrupt on-the-fly etag generation */
1092                 HTTP_G->etag.started = 0;
1093                 /* discard previous output buffers */
1094                 php_end_ob_buffers(0 TSRMLS_CC);
1095         }
1096
1097         /* caching */
1098         if (zval_is_true(GET_STATIC_PROP(cache))) {
1099                 zval *cctl, *cctl_p, *etag, *etag_p, *lmod, *lmod_p;
1100
1101                 etag = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(eTag), &etag_p);
1102                 lmod = convert_to_type_ex(IS_LONG, GET_STATIC_PROP(lastModified), &lmod_p);
1103                 cctl = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(cacheControl), &cctl_p);
1104
1105                 http_cache_etag(Z_STRVAL_P(etag), Z_STRLEN_P(etag), Z_STRVAL_P(cctl), Z_STRLEN_P(cctl));
1106                 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));
1107
1108                 if (etag_p) zval_ptr_dtor(&etag_p);
1109                 if (lmod_p) zval_ptr_dtor(&lmod_p);
1110                 if (cctl_p) zval_ptr_dtor(&cctl_p);
1111
1112                 if (php_ob_handler_used("blackhole" TSRMLS_CC)) {
1113                         RETURN_TRUE;
1114                 }
1115         }
1116
1117         /* content type */
1118         {
1119                 zval *ctype_p, *ctype = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(contentType), &ctype_p);
1120                 if (Z_STRLEN_P(ctype)) {
1121                         http_send_content_type(Z_STRVAL_P(ctype), Z_STRLEN_P(ctype));
1122                 } else {
1123                         char *ctypes = INI_STR("default_mimetype");
1124                         size_t ctlen = ctypes ? strlen(ctypes) : 0;
1125
1126                         if (ctlen) {
1127                                 http_send_content_type(ctypes, ctlen);
1128                         } else {
1129                                 http_send_content_type("application/x-octetstream", lenof("application/x-octetstream"));
1130                         }
1131                 }
1132                 if (ctype_p) {
1133                         zval_ptr_dtor(&ctype_p);
1134                 }
1135         }
1136
1137         /* content disposition */
1138         {
1139                 zval *cd_p, *cd = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(contentDisposition), &cd_p);
1140                 if (Z_STRLEN_P(cd)) {
1141                         http_send_header_ex("Content-Disposition", lenof("Content-Disposition"), Z_STRVAL_P(cd), Z_STRLEN_P(cd), 1, NULL);
1142                 }
1143                 if (cd_p) {
1144                         zval_ptr_dtor(&cd_p);
1145                 }
1146         }
1147
1148         /* throttling */
1149         {
1150                 zval *bsize_p, *bsize = convert_to_type_ex(IS_LONG, GET_STATIC_PROP(bufferSize), &bsize_p);
1151                 zval *delay_p, *delay = convert_to_type_ex(IS_DOUBLE, GET_STATIC_PROP(throttleDelay), &delay_p);
1152                 HTTP_G->send.buffer_size    = Z_LVAL_P(bsize);
1153                 HTTP_G->send.throttle_delay = Z_DVAL_P(delay);
1154                 if (bsize_p) zval_ptr_dtor(&bsize_p);
1155                 if (delay_p) zval_ptr_dtor(&delay_p);
1156         }
1157
1158         /* gzip */
1159         HTTP_G->send.deflate.encoding = zval_is_true(GET_STATIC_PROP(gzip));
1160
1161         /* start ob */
1162         php_start_ob_buffer(NULL, HTTP_G->send.buffer_size, 0 TSRMLS_CC);
1163
1164         /* send */
1165         switch (Z_LVAL_P(GET_STATIC_PROP(mode)))
1166         {
1167                 case SEND_DATA:
1168                 {
1169                         zval *zdata_p, *zdata = convert_to_type_ex(IS_STRING, GET_STATIC_PROP(data), &zdata_p);
1170                         RETVAL_SUCCESS(http_send_data_ex(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata), 1));
1171                         if (zdata_p) zval_ptr_dtor(&zdata_p);
1172                         return;
1173                 }
1174
1175                 case SEND_RSRC:
1176                 {
1177                         php_stream *the_real_stream;
1178                         zval *the_stream_p, *the_stream = convert_to_type_ex(IS_LONG, GET_STATIC_PROP(stream), &the_stream_p);
1179                         the_stream->type = IS_RESOURCE;
1180                         php_stream_from_zval(the_real_stream, &the_stream);
1181                         RETVAL_SUCCESS(http_send_stream_ex(the_real_stream, 0, 1));
1182                         if (the_stream_p) zval_ptr_dtor(&the_stream_p);
1183                         return;
1184                 }
1185
1186                 default:
1187                 {
1188                         zval *file_p;
1189                         RETVAL_SUCCESS(http_send_file_ex(Z_STRVAL_P(convert_to_type_ex(IS_STRING, GET_STATIC_PROP(file), &file_p)), 1));
1190                         if (file_p) zval_ptr_dtor(&file_p);
1191                         return;
1192                 }
1193         }
1194 }
1195 /* }}} */
1196
1197 /* {{{ proto static void HttpResponse::capture()
1198  *
1199  * Capture script output.
1200  *
1201  * Example:
1202  * <pre>
1203  * <?php
1204  * HttpResponse::setCache(true);
1205  * HttpResponse::capture();
1206  * // script follows
1207  * ?>
1208  * </pre>
1209  */
1210 PHP_METHOD(HttpResponse, capture)
1211 {
1212         NO_ARGS;
1213
1214         HTTP_CHECK_HEADERS_SENT(RETURN_FALSE);
1215
1216         UPD_STATIC_PROP(long, catch, 1);
1217
1218         php_end_ob_buffers(0 TSRMLS_CC);
1219         php_start_ob_buffer(NULL, 40960, 0 TSRMLS_CC);
1220
1221         /* register shutdown function */
1222         {
1223                 zval func, retval, arg, *argp[1];
1224
1225                 INIT_PZVAL(&arg);
1226                 INIT_PZVAL(&func);
1227                 INIT_PZVAL(&retval);
1228                 ZVAL_STRINGL(&func, "register_shutdown_function", lenof("register_shutdown_function"), 0);
1229
1230                 array_init(&arg);
1231                 add_next_index_stringl(&arg, "HttpResponse", lenof("HttpResponse"), 1);
1232                 add_next_index_stringl(&arg, "send", lenof("send"), 1);
1233                 argp[0] = &arg;
1234                 call_user_function(EG(function_table), NULL, &func, &retval, 1, argp TSRMLS_CC);
1235                 zval_dtor(&arg);
1236         }
1237 }
1238 /* }}} */
1239
1240 #endif /* ZEND_ENGINE_2 && !WONKY */
1241
1242 /*
1243  * Local variables:
1244  * tab-width: 4
1245  * c-basic-offset: 4
1246  * End:
1247  * vim600: noet sw=4 ts=4 fdm=marker
1248  * vim<600: noet sw=4 ts=4
1249  */
1250