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


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