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

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