projects / m6w6 / ext-http / blob
? search:


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