/*
- +----------------------------------------------------------------------+
- | PECL :: http |
- +----------------------------------------------------------------------+
- | This source file is subject to version 3.0 of the PHP license, that |
- | is bundled with this package in the file LICENSE, and is available |
- | through the world-wide-web at http://www.php.net/license/3_0.txt. |
- | If you did not receive a copy of the PHP license and are unable to |
- | obtain it through the world-wide-web, please send a note to |
- | license@php.net so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
- | Copyright (c) 2004-2005 Michael Wallner <mike@php.net> |
- +----------------------------------------------------------------------+
+ +--------------------------------------------------------------------+
+ | PECL :: http |
+ +--------------------------------------------------------------------+
+ | Redistribution and use in source and binary forms, with or without |
+ | modification, are permitted provided that the conditions mentioned |
+ | in the accompanying LICENSE file are met. |
+ +--------------------------------------------------------------------+
+ | Copyright (c) 2004-2005, Michael Wallner <mike@php.net> |
+ +--------------------------------------------------------------------+
*/
/* $Id$ */
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
-#include "php.h"
+
+#define HTTP_WANT_ZLIB
+#define HTTP_WANT_MAGIC
+#include "php_http.h"
#include "SAPI.h"
#include "php_streams.h"
#include "ext/standard/php_lcg.h"
-#include "php_http.h"
-#include "php_http_std_defs.h"
#include "php_http_api.h"
-#include "php_http_date_api.h"
-#include "php_http_send_api.h"
-#include "php_http_headers_api.h"
-#include "php_http_date_api.h"
#include "php_http_cache_api.h"
+#include "php_http_date_api.h"
#include "php_http_encoding_api.h"
+#include "php_http_headers_api.h"
+#include "php_http_send_api.h"
-ZEND_EXTERN_MODULE_GLOBALS(http);
-
-#define http_flush(d, l) _http_flush((d), (l) SRMLS_CC)
+#define http_flush(d, l) _http_flush((d), (l) TSRMLS_CC)
/* {{{ static inline void http_flush() */
-static inline void _http_flush(const char *data, size_t data_len, TSRMLS_DC)
+static inline void _http_flush(const char *data, size_t data_len TSRMLS_DC)
{
PHPWRITE(data, data_len);
php_end_ob_buffer(1, 1 TSRMLS_CC);
}
/* }}} */
-/* {{{ http_send_start_response */
-#define http_send_start_response(b, cl) _http_send_start_response((b), (cl) TSRMLS_CC)
-static void _http_send_response_start(void *buffer, size_t content_length TSRMLS_DC)
+/* {{{ http_send_response_start */
+#define http_send_response_start(b, cl) _http_send_response_start((b), (cl) TSRMLS_CC)
+static inline void _http_send_response_start(void **buffer, size_t content_length TSRMLS_DC)
{
- if (http_encoding_response_start(content_length)) {
+ int encoding;
+
+ if ((encoding = http_encoding_response_start(content_length))) {
#ifdef HTTP_HAVE_ZLIB
- char *encoded;
- size_t *encoded_len;
- http_encoding_stream *s = (http_encoding_stream *) buffer;
-
- http_encoding_stream_init(s, HTTP_G(gzip).encoding == HTTP_ENCODING_GZIP, -1, &encoded, &encoded_len);
- phpstr_chunked_output(s.storage, encoded, encoded_len, HTTP_G(send).buffer_size, _http_flush TSRMLS_CC);
- STR_FREE(encoded);
+ *buffer = http_encoding_deflate_stream_init(NULL,
+ (encoding == HTTP_ENCODING_GZIP) ?
+ HTTP_DEFLATE_TYPE_GZIP : HTTP_DEFLATE_TYPE_ZLIB);
#endif
}
}
+/* }}} */
+/* {{{ http_send_response_data_plain */
#define http_send_response_data_plain(b, d, dl) _http_send_response_data_plain((b), (d), (dl) TSRMLS_CC)
-static void _http_send_response_data_plain(void *buffer, const char *data, size_t data_len TSRMLS_DC)
+static inline void _http_send_response_data_plain(void **buffer, const char *data, size_t data_len TSRMLS_DC)
{
- if (HTTP_G(send).gzip_encoding) {
+ if (HTTP_G(send).deflate.encoding) {
#ifdef HTTP_HAVE_ZLIB
char *encoded;
size_t encoded_len;
+ http_encoding_stream *s = *((http_encoding_stream **) buffer);
- http_encoding_stream_update(buffer, data, data_len, &encoded, &encoded_len);
- phpstr_chunked_output(&(((http_encoding_stream *) buffer)->storage), data, data_len, HTTP_G(send).buffer_size, _http_flush);
+ http_encoding_deflate_stream_update(s, data, data_len, &encoded, &encoded_len);
+ phpstr_chunked_output((phpstr **) &s->storage, encoded, encoded_len, HTTP_G(send).buffer_size, _http_flush TSRMLS_CC);
efree(encoded);
#else
http_error(HE_ERROR, HTTP_E_RESPONSE, "Attempt to send GZIP response despite being able to do so; please report this bug");
#endif
} else {
- phpstr_chunked_output(&buffer, data, data_len, HTTP_G(send).buffer_size, _http_flush);
+ phpstr_chunked_output((phpstr **) buffer, data, data_len, HTTP_G(send).buffer_size, _http_flush TSRMLS_CC);
}
}
+/* }}} */
#define HTTP_CHUNK_AVAIL(len, cs) ((len -= cs) >= 0)
/* {{{ http_send_response_data_fetch */
-#define http_send_response_data_fetch(b, t, d, l, b, e) _http_send_response_data_fetch((b), (t), (d), (l), (b), (e) TSRMLS_CC)
-static void _http_send_response_data_fetch(void *buffer, const void *data, size_t data_len, http_send_mode mode, size_t begin, size_t end TSRMLS_DC)
+#define http_send_response_data_fetch(b, d, l, m, s, e) _http_send_response_data_fetch((b), (d), (l), (m), (s), (e) TSRMLS_CC)
+static inline void _http_send_response_data_fetch(void **buffer, const void *data, size_t data_len, http_send_mode mode, size_t begin, size_t end TSRMLS_DC)
{
long len = end - begin, chunk_size = 40960;
{
case SEND_RSRC:
{
- char *buf;
php_stream *s = (php_stream *) data;
- if (php_stream_seek(s, begin, SEEK_SET)) {
- return FAILURE;
- }
-
- buf = emalloc(chunk_size);
+ if (SUCCESS == php_stream_seek(s, begin, SEEK_SET)) {
+ char *buf = emalloc(chunk_size);
- while (HTTP_CHUNK_AVAIL(len, chunk_size)) {
- http_send_response_data_plain(buffer, buf, php_stream_read(s, buf, chunk_size));
- }
- /* read & write left over */
- if (len) {
- http_send_response_data_plain(buffer, buf, php_stream_read(s, buf, chunk_size + len));
+ while (HTTP_CHUNK_AVAIL(len, chunk_size)) {
+ http_send_response_data_plain(buffer, buf, php_stream_read(s, buf, chunk_size));
+ }
+ /* read & write left over */
+ if (len) {
+ http_send_response_data_plain(buffer, buf, php_stream_read(s, buf, chunk_size + len));
+ }
+
+ efree(buf);
}
-
- efree(buf);
}
break;
}
break;
- EMPTY_DEFAULT_SWITCH_CASE();
+ EMPTY_SWITCH_DEFAULT_CASE();
}
}
/* }}} */
/* {{{ http_send_response_finish */
#define http_send_response_finish(b) _http_send_response_finish((b) TSRMLS_CC)
-static void _http_send_response_finish(void *buffer TSRMLS_DC)
+static inline void _http_send_response_finish(void **buffer TSRMLS_DC)
{
- if (HTTP_G(send).gzip_encoding) {
+ if (HTTP_G(send).deflate.encoding) {
#ifdef HTTP_HAVE_ZLIB
char *encoded = NULL;
- size_t encoded_len;
+ size_t encoded_len = 0;
+ http_encoding_stream *s = *((http_encoding_stream **) buffer);
- http_encoding_stream_finish(buffer, &encoded, &encoded_len);
- buffer = ((http_encoding_stream *) buffer)->storage;
- phpstr_chunked_output(buffer, encoded, encoded_len, HTTP_G(send).buffer_size, _http_flush);
+ http_encoding_deflate_stream_finish(s, &encoded, &encoded_len);
+ phpstr_chunked_output((phpstr **) &s->storage, encoded, encoded_len, 0, _http_flush TSRMLS_CC);
+ http_encoding_deflate_stream_free(&s);
STR_FREE(encoded);
#else
http_error(HE_ERROR, HTTP_E_RESPONSE, "Attempt to send GZIP response despite being able to do so; please report this bug");
#endif
+ } else {
+ phpstr_chunked_output((phpstr **) buffer, NULL, 0, 0, _http_flush TSRMLS_CC);
}
- phpstr_chunked_output(buffer, NULL, 0, 0, _http_flush);
}
/* }}} */
/* {{{ STATUS http_send(void *, size_t, http_send_mode) */
PHP_HTTP_API STATUS _http_send_ex(const void *data_ptr, size_t data_size, http_send_mode data_mode, zend_bool no_cache TSRMLS_DC)
{
+ void *s = NULL;
HashTable ranges;
http_range_status range_status;
- int cache_etag = http_interrupt_etag_handler();
-#ifdef HTTP_HAVE_ZLIB
- http_encoding_stream s;
-#else
- phpstr *s = NULL;
-#endif
+ int cache_etag = http_interrupt_ob_etaghandler();
if (!data_ptr) {
return FAILURE;
zend_hash_init(&ranges, 0, NULL, ZVAL_PTR_DTOR, 0);
range_status = http_get_request_ranges(&ranges, data_size);
- if (range_status == RANGE_ERR) {
- zend_hash_destroy(&ranges);
- http_send_status(416);
- return FAILURE;
- }
-
switch (range_status)
{
+ case RANGE_ERR:
+ {
+ zend_hash_destroy(&ranges);
+ http_send_status(416);
+ return FAILURE;
+ }
case RANGE_OK:
+ {
/* Range Request - only send ranges if entity hasn't changed */
if ( http_match_etag_ex("HTTP_IF_MATCH", HTTP_G(send).unquoted_etag, 0) &&
http_match_last_modified_ex("HTTP_IF_UNMODIFIED_SINCE", HTTP_G(send).last_modified, 0) &&
/* single range */
zval **range, **begin, **end;
- if ( SUCCESS == zend_hash_index_find(ranges, 0, (void **) &range) &&
+ if ( SUCCESS == zend_hash_index_find(&ranges, 0, (void **) &range) &&
SUCCESS == zend_hash_index_find(Z_ARRVAL_PP(range), 0, (void **) &begin) &&
SUCCESS == zend_hash_index_find(Z_ARRVAL_PP(range), 1, (void **) &end)) {
char range_header_str[256];
size_t range_header_len;
- range_header_len = snprintf(range_header_str, "Content-Range: bytes %ld-%ld/%lu", Z_LVAL_PP(begin), Z_LVAL_PP(end), (unsigned long) data_size);
+ range_header_len = snprintf(range_header_str, lenof(range_header_str), "Content-Range: bytes %ld-%ld/%zu", Z_LVAL_PP(begin), Z_LVAL_PP(end), data_size);
http_send_status_header_ex(206, range_header_str, range_header_len, 1);
- http_send_response_start(s, Z_LVAL_PP(end)-Z_LVAL_PP(begin));
- http_send_response_data_fetch(s, data_ptr, data_size, data_mode, Z_LVAL_PP(begin), Z_LVAL_PP(end) + 1);
- http_send_response_finish(s);
+ http_send_response_start(&s, Z_LVAL_PP(end)-Z_LVAL_PP(begin)+1);
+ http_send_response_data_fetch(&s, data_ptr, data_size, data_mode, Z_LVAL_PP(begin), Z_LVAL_PP(end) + 1);
+ http_send_response_finish(&s);
zend_hash_destroy(&ranges);
return SUCCESS;
}
} else {
/* multi range */
+ HashPosition pos;
zval **range, **begin, **end;
const char *content_type = HTTP_G(send).content_type;
- char *boundary_str, *range_header_str;
+ char boundary_str[32], range_header_str[256];
size_t boundary_len, range_header_len;
- boundary_len = spprintf(&boundary_str, 0, "%lu%0.9f", (unsigned long) time(NULL), (float) php_combined_lcg(TSRMLS_C))
- range_header_len = spprintf(&range_header_str, 0, "Content-Type: multipart/byteranges; boundary=%s", boundary_str);
+ boundary_len = snprintf(boundary_str, lenof(boundary_str), "%lu%0.9f", (ulong) time(NULL), (float) php_combined_lcg(TSRMLS_C));
+ range_header_len = snprintf(range_header_str, lenof(range_header_str), "Content-Type: multipart/byteranges; boundary=%s", boundary_str);
- http_send_status_header_ex(206, range_header, range_header_len, 1);
- efree(range_header_str);
- http_send_response_start(s, 0);
+ http_send_status_header_ex(206, range_header_str, range_header_len, 1);
+ http_send_response_start(&s, 0);
if (!content_type) {
content_type = "application/x-octetstream";
}
- FOREACH_HASH_VAL(&ranges, range) {
+ FOREACH_HASH_VAL(pos, &ranges, range) {
if ( SUCCESS == zend_hash_index_find(Z_ARRVAL_PP(range), 0, (void **) &begin) &&
- SUCCESS == zend_hash_index_find(Z_ARRVAL_PP(range), 1, (void **) &begin)) {
+ SUCCESS == zend_hash_index_find(Z_ARRVAL_PP(range), 1, (void **) &end)) {
char preface_str[512];
size_t preface_len;
#define HTTP_RANGE_PREFACE \
- HTTP_CRLF "%s" \
+ HTTP_CRLF "--%s" \
HTTP_CRLF "Content-Type: %s" \
- HTTP_CRLF "Content-Range: %ld-%ld/%lu" \
+ HTTP_CRLF "Content-Range: bytes %ld-%ld/%zu" \
HTTP_CRLF HTTP_CRLF
preface_len = snprintf(preface_str, lenof(preface_str), HTTP_RANGE_PREFACE, boundary_str, content_type, Z_LVAL_PP(begin), Z_LVAL_PP(end), data_size);
- http_send_response_data_plain(s, preface, preface_len);
- http_send_response_data_fetch(s, data_ptr, data_len, data_mode, Z_LVAL_PP(begin), Z_LVAL_PP(end) + 1);
+ http_send_response_data_plain(&s, preface_str, preface_len);
+ http_send_response_data_fetch(&s, data_ptr, data_size, data_mode, Z_LVAL_PP(begin), Z_LVAL_PP(end) + 1);
}
}
- http_send_response_data_plain(s, HTTP_CRLF, lenof(HTTP_CRLF));
- http_send_response_data_plain(s, boundary_str, boundary_len);
- http_send_response_data_plain(s, "--", lenof("--"));
+ http_send_response_data_plain(&s, HTTP_CRLF "--", lenof(HTTP_CRLF "--"));
+ http_send_response_data_plain(&s, boundary_str, boundary_len);
+ http_send_response_data_plain(&s, "--", lenof("--"));
- efree(boundary_str);
-
- http_send_response_finish(s);
+ http_send_response_finish(&s);
zend_hash_destroy(&ranges);
return SUCCESS;
}
}
+ }
case RANGE_NO:
+ {
zend_hash_destroy(&ranges);
/* send 304 Not Modified if etag matches - DON'T return on ETag generation failure */
if (!no_cache && cache_etag) {
char *etag = NULL;
- if (etag = http_etag(data_ptr, data_size, data_mode)) {
+ if ((etag = http_etag(data_ptr, data_size, data_mode))) {
char *sent_header = NULL;
http_send_etag_ex(etag, strlen(etag), &sent_header);
}
/* send full response */
- http_send_response_start(s, data_size);
- http_send_response_data_fetch(s, data_ptr, data_size, data_mode, 0, data_size);
- http_send_response_finish(s);
+ http_send_response_start(&s, data_size);
+ http_send_response_data_fetch(&s, data_ptr, data_size, data_mode, 0, data_size);
+ http_send_response_finish(&s);
return SUCCESS;
+ }
}
+ return FAILURE;
}
/* }}} */
}
/* }}} */
+/* {{{ char *http_guess_content_type(char *magic_file, long magic_mode, void *data, size_t size, http_send_mode mode) */
+PHP_HTTP_API char *_http_guess_content_type(const char *magicfile, long magicmode, void *data_ptr, size_t data_len, http_send_mode data_mode TSRMLS_DC)
+{
+ char *ct = NULL;
+
+#ifdef HTTP_HAVE_MAGIC
+ struct magic_set *magic;
+
+ HTTP_CHECK_OPEN_BASEDIR(magicfile, return NULL);
+
+ /* magic_load() fails if MAGIC_MIME is set because it
+ cowardly adds .mime to the file name */
+ magic = magic_open(magicmode &~ MAGIC_MIME);
+
+ if (!magic) {
+ http_error_ex(HE_WARNING, HTTP_E_INVALID_PARAM, "Invalid magic mode: %ld", magicmode);
+ } else if (-1 == magic_load(magic, magicfile)) {
+ http_error_ex(HE_WARNING, HTTP_E_RUNTIME, "Failed to load magic database '%s' (%s)", magicfile, magic_error(magic));
+ } else {
+ const char *ctype = NULL;
+
+ magic_setflags(magic, magicmode);
+
+ switch (data_mode)
+ {
+ case SEND_RSRC:
+ {
+ char *buffer;
+ size_t b_len;
+
+ b_len = php_stream_copy_to_mem(data_ptr, &buffer, 65536, 0);
+ ctype = magic_buffer(magic, buffer, b_len);
+ efree(buffer);
+ }
+ break;
+
+ case SEND_DATA:
+ ctype = magic_buffer(magic, data_ptr, data_len);
+ break;
+
+ default:
+ HTTP_CHECK_OPEN_BASEDIR(data_ptr, magic_close(magic); return NULL);
+ ctype = magic_file(magic, data_ptr);
+ break;
+ }
+
+ if (ctype) {
+ ct = estrdup(ctype);
+ } else {
+ http_error_ex(HE_WARNING, HTTP_E_RUNTIME, "Failed to guess Content-Type: %s", magic_error(magic));
+ }
+ }
+ if (magic) {
+ magic_close(magic);
+ }
+#else
+ http_error(HE_WARNING, HTTP_E_RUNTIME, "Cannot guess Content-Type; libmagic not available");
+#endif
+
+ return ct;
+}
+/* }}} */
+
/*
* Local variables:
* tab-width: 4
projects / m6w6 / ext-http / blobdiff