X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-http;a=blobdiff_plain;f=http_encoding_api.c;h=8ce0280ca22c5e0911d2e5115674f972b47ba27f;hp=efbaa7f8669065d006803847406f01e0a8e85bd1;hb=ad5f896b03adaa073134a00108a9cdf00720673a;hpb=05c863a6faa9a3ddd83ac1bdf62edbfc7a6ccf4f diff --git a/http_encoding_api.c b/http_encoding_api.c index efbaa7f..8ce0280 100644 --- a/http_encoding_api.c +++ b/http_encoding_api.c @@ -6,16 +6,12 @@ | modification, are permitted provided that the conditions mentioned | | in the accompanying LICENSE file are met. | +--------------------------------------------------------------------+ - | Copyright (c) 2004-2005, Michael Wallner | + | Copyright (c) 2004-2010, Michael Wallner | +--------------------------------------------------------------------+ */ /* $Id$ */ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - #define HTTP_WANT_ZLIB #include "php_http.h" @@ -24,13 +20,59 @@ #include "php_http_send_api.h" #include "php_http_headers_api.h" -ZEND_EXTERN_MODULE_GLOBALS(http); +/* {{{ */ +#ifdef HTTP_HAVE_ZLIB +PHP_MINIT_FUNCTION(http_encoding) +{ + HTTP_LONG_CONSTANT("HTTP_DEFLATE_LEVEL_DEF", HTTP_DEFLATE_LEVEL_DEF); + HTTP_LONG_CONSTANT("HTTP_DEFLATE_LEVEL_MIN", HTTP_DEFLATE_LEVEL_MIN); + HTTP_LONG_CONSTANT("HTTP_DEFLATE_LEVEL_MAX", HTTP_DEFLATE_LEVEL_MAX); + HTTP_LONG_CONSTANT("HTTP_DEFLATE_TYPE_ZLIB", HTTP_DEFLATE_TYPE_ZLIB); + HTTP_LONG_CONSTANT("HTTP_DEFLATE_TYPE_GZIP", HTTP_DEFLATE_TYPE_GZIP); + HTTP_LONG_CONSTANT("HTTP_DEFLATE_TYPE_RAW", HTTP_DEFLATE_TYPE_RAW); + HTTP_LONG_CONSTANT("HTTP_DEFLATE_STRATEGY_DEF", HTTP_DEFLATE_STRATEGY_DEF); + HTTP_LONG_CONSTANT("HTTP_DEFLATE_STRATEGY_FILT", HTTP_DEFLATE_STRATEGY_FILT); + HTTP_LONG_CONSTANT("HTTP_DEFLATE_STRATEGY_HUFF", HTTP_DEFLATE_STRATEGY_HUFF); + HTTP_LONG_CONSTANT("HTTP_DEFLATE_STRATEGY_RLE", HTTP_DEFLATE_STRATEGY_RLE); + HTTP_LONG_CONSTANT("HTTP_DEFLATE_STRATEGY_FIXED", HTTP_DEFLATE_STRATEGY_FIXED); + + HTTP_LONG_CONSTANT("HTTP_ENCODING_STREAM_FLUSH_NONE", HTTP_ENCODING_STREAM_FLUSH_NONE); + HTTP_LONG_CONSTANT("HTTP_ENCODING_STREAM_FLUSH_SYNC", HTTP_ENCODING_STREAM_FLUSH_SYNC); + HTTP_LONG_CONSTANT("HTTP_ENCODING_STREAM_FLUSH_FULL", HTTP_ENCODING_STREAM_FLUSH_FULL); + + return SUCCESS; +} + +PHP_RINIT_FUNCTION(http_encoding) +{ + if (HTTP_G->send.inflate.start_auto) { + php_ob_set_internal_handler(_http_ob_inflatehandler, HTTP_INFLATE_BUFFER_SIZE, "http inflate", 0 TSRMLS_CC); + } + if (HTTP_G->send.deflate.start_auto) { + php_ob_set_internal_handler(_http_ob_deflatehandler, HTTP_DEFLATE_BUFFER_SIZE, "http deflate", 0 TSRMLS_CC); + } + return SUCCESS; +} + +PHP_RSHUTDOWN_FUNCTION(http_encoding) +{ + if (HTTP_G->send.deflate.stream) { + http_encoding_deflate_stream_free((http_encoding_stream **) &HTTP_G->send.deflate.stream); + } + if (HTTP_G->send.inflate.stream) { + http_encoding_inflate_stream_free((http_encoding_stream **) &HTTP_G->send.inflate.stream); + } + return SUCCESS; +} +#endif +/* }}} */ +/* {{{ eol_match(char **, int *) */ static inline int eol_match(char **line, int *eol_len) { char *ptr = *line; - while (0x20 == *ptr) ++ptr; + while (' ' == *ptr) ++ptr; if (ptr == http_locate_eol(*line, eol_len)) { *line = ptr; @@ -39,6 +81,7 @@ static inline int eol_match(char **line, int *eol_len) return 0; } } +/* }}} */ /* {{{ char *http_encoding_dechunk(char *, size_t, char **, size_t *) */ PHP_HTTP_API const char *_http_encoding_dechunk(const char *encoded, size_t encoded_len, char **decoded, size_t *decoded_len TSRMLS_DC) @@ -114,450 +157,621 @@ PHP_HTTP_API const char *_http_encoding_dechunk(const char *encoded, size_t enco } /* }}} */ -#ifdef HTTP_HAVE_ZLIB - -static const char http_encoding_gzip_header[] = { - (const char) 0x1f, // fixed value - (const char) 0x8b, // fixed value - (const char) Z_DEFLATED, // compression algorithm - (const char) 0, // none of the possible flags defined by the GZIP "RFC" - (const char) 0, // MTIME - (const char) 0, // =*= - (const char) 0, // =*= - (const char) 0, // =*= - (const char) 0, // two possible flag values for 9 compression levels? o_O -#ifdef PHP_WIN32 - (const char) 0x0b // OS_CODE -#else - (const char) 0x03 // OS_CODE -#endif -}; - -PHP_HTTP_API STATUS _http_encoding_gzencode(int level, int mtime, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC) +/* {{{ int http_encoding_response_start(size_t) */ +PHP_HTTP_API int _http_encoding_response_start(size_t content_length, zend_bool ignore_http_ohandler TSRMLS_DC) { - z_stream Z; - STATUS status = Z_OK; - - if (!(data && data_len)) { - return FAILURE; - } - - *encoded = NULL; - *encoded_len = 0; - memset(&Z, 0, sizeof(z_stream)); - - Z.next_in = (Bytef *) data; - Z.avail_in = data_len; - Z.avail_out = HTTP_ENCODING_BUFLEN(data_len) + HTTP_ENCODING_SAFPAD - 1; - - *encoded = emalloc(HTTP_ENCODING_BUFLEN(data_len) + sizeof(http_encoding_gzip_header) + HTTP_ENCODING_SAFPAD); - memcpy(*encoded, http_encoding_gzip_header, sizeof(http_encoding_gzip_header)); + int response = HTTP_G->send.deflate.response; + int ohandler = php_ob_handler_used("ob_gzhandler" TSRMLS_CC) || php_ob_handler_used("zlib output compression" TSRMLS_CC); - if (mtime) { - (*encoded)[4] = (char) (mtime & 0xFF); - (*encoded)[5] = (char) ((mtime >> 8) & 0xFF); - (*encoded)[6] = (char) ((mtime >> 16) & 0xFF); - (*encoded)[7] = (char) ((mtime >> 24) & 0xFF); + if (!ohandler && !ignore_http_ohandler) { + ohandler = php_ob_handler_used("ob_deflatehandler" TSRMLS_CC) || php_ob_handler_used("http deflate" TSRMLS_CC); } - Z.next_out = (Bytef *) *encoded + sizeof(http_encoding_gzip_header); - - if (Z_OK == (status = deflateInit2(&Z, level, Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) { - status = deflate(&Z, Z_FINISH); - deflateEnd(&Z); + if (response && !ohandler) { +#ifdef HTTP_HAVE_ZLIB + HashTable *selected; + zval zsupported; - if (Z_STREAM_END == status) { - ulong crc; - char *trailer; - - crc = crc32(0L, Z_NULL, 0); - crc = crc32(crc, (const Bytef *) data, data_len); - - trailer = *encoded + sizeof(http_encoding_gzip_header) + Z.total_out; + HTTP_G->send.deflate.encoding = 0; + + INIT_PZVAL(&zsupported); + array_init(&zsupported); + add_next_index_stringl(&zsupported, "gzip", lenof("gzip"), 1); + add_next_index_stringl(&zsupported, "x-gzip", lenof("x-gzip"), 1); + add_next_index_stringl(&zsupported, "deflate", lenof("deflate"), 1); + + if ((selected = http_negotiate_encoding(&zsupported))) { + STATUS hs = FAILURE; + char *encoding = NULL; + ulong idx; - /* LSB */ - trailer[0] = (char) (crc & 0xFF); - trailer[1] = (char) ((crc >> 8) & 0xFF); - trailer[2] = (char) ((crc >> 16) & 0xFF); - trailer[3] = (char) ((crc >> 24) & 0xFF); - trailer[4] = (char) ((Z.total_in) & 0xFF); - trailer[5] = (char) ((Z.total_in >> 8) & 0xFF); - trailer[6] = (char) ((Z.total_in >> 16) & 0xFF); - trailer[7] = (char) ((Z.total_in >> 24) & 0xFF); + if (HASH_KEY_IS_STRING == zend_hash_get_current_key(selected, &encoding, &idx, 0) && encoding) { + if (!strcmp(encoding, "gzip") || !strcmp(encoding, "x-gzip")) { + if (SUCCESS == (hs = http_send_header_string("Content-Encoding: gzip"))) { + HTTP_G->send.deflate.encoding = HTTP_ENCODING_GZIP; + } + } else if (!strcmp(encoding, "deflate")) { + if (SUCCESS == (hs = http_send_header_string("Content-Encoding: deflate"))) { + HTTP_G->send.deflate.encoding = HTTP_ENCODING_DEFLATE; + } + } + if (SUCCESS == hs) { + http_send_header_string("Vary: Accept-Encoding"); + } + } - *encoded_len = Z.total_out + sizeof(http_encoding_gzip_header) + 8; - (*encoded)[*encoded_len] = '\0'; - return SUCCESS; + zend_hash_destroy(selected); + FREE_HASHTABLE(selected); } + + zval_dtor(&zsupported); +#else + HTTP_G->send.deflate.encoding = 0; + php_start_ob_buffer_named("ob_gzhandler", 0, 0 TSRMLS_CC); +#endif /* HTTP_HAVE_ZLIB */ + } else if (content_length && !ohandler) { + /* emit a content-length header */ + phpstr header; + + phpstr_init(&header); + phpstr_appendf(&header, "Content-Length: %zu", content_length); + phpstr_fix(&header); + http_send_header_string_ex(PHPSTR_VAL(&header), PHPSTR_LEN(&header), 1); + phpstr_dtor(&header); + } else { + HTTP_G->send.deflate.encoding = 0; } - STR_SET(*encoded, NULL); - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not gzencode data: %s", zError(status)); - return FAILURE; + return HTTP_G->send.deflate.encoding; } +/* }}} */ -PHP_HTTP_API STATUS _http_encoding_gzdecode(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC) +#ifdef HTTP_HAVE_ZLIB + +/* {{{ inline int http_inflate_rounds */ +static inline int http_inflate_rounds(z_stream *Z, int flush, char **buf, size_t *len) { - const char *encoded; - size_t encoded_len; + int status = 0, round = 0; + phpstr buffer; - if ( (data && data_len) && - (SUCCESS == http_encoding_gzencode_verify(data, data_len, &encoded, &encoded_len)) && - (SUCCESS == http_encoding_inflate(encoded, encoded_len, decoded, decoded_len))) { - http_encoding_gzdecode_verify(data, data_len, *decoded, *decoded_len); - return SUCCESS; + *buf = NULL; + *len = 0; + + phpstr_init_ex(&buffer, Z->avail_in, PHPSTR_INIT_PREALLOC); + + do { + if (PHPSTR_NOMEM == phpstr_resize_ex(&buffer, buffer.size, 0, 1)) { + status = Z_MEM_ERROR; + } else { + Z->avail_out = buffer.free; + Z->next_out = (Bytef *) buffer.data + buffer.used; +#if 0 + fprintf(stderr, "\n%3d: %3d PRIOR: size=%7lu,\tfree=%7lu,\tused=%7lu,\tavail_in=%7lu,\tavail_out=%7lu\n", round, status, buffer.size, buffer.free, buffer.used, Z->avail_in, Z->avail_out); +#endif + status = inflate(Z, flush); + + buffer.used += buffer.free - Z->avail_out; + buffer.free = Z->avail_out; +#if 0 + fprintf(stderr, "%3d: %3d AFTER: size=%7lu,\tfree=%7lu,\tused=%7lu,\tavail_in=%7lu,\tavail_out=%7lu\n", round, status, buffer.size, buffer.free, buffer.used, Z->avail_in, Z->avail_out); +#endif + HTTP_INFLATE_BUFFER_SIZE_ALIGN(buffer.size); + } + } while ((Z_BUF_ERROR == status || (Z_OK == status && Z->avail_in)) && ++round < HTTP_INFLATE_ROUNDS); + + if (status == Z_OK || status == Z_STREAM_END) { + phpstr_shrink(&buffer); + phpstr_fix(&buffer); + *buf = buffer.data; + *len = buffer.used; + } else { + phpstr_dtor(&buffer); } - return FAILURE; + return status; } +/* }}} */ -PHP_HTTP_API STATUS _http_encoding_deflate(int level, int zhdr, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC) +/* {{{ STATUS http_encoding_deflate(int, char *, size_t, char **, size_t *) */ +PHP_HTTP_API STATUS _http_encoding_deflate(int flags, const char *data, size_t data_len, char **encoded, size_t *encoded_len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC TSRMLS_DC) { + int status, level, wbits, strategy; z_stream Z; - STATUS status = Z_OK; + HTTP_DEFLATE_LEVEL_SET(flags, level); + HTTP_DEFLATE_WBITS_SET(flags, wbits); + HTTP_DEFLATE_STRATEGY_SET(flags, strategy); + + memset(&Z, 0, sizeof(z_stream)); *encoded = NULL; *encoded_len = 0; - memset(&Z, 0, sizeof(z_stream)); - - Z.data_type = Z_UNKNOWN; - Z.next_in = (Bytef *) data; - Z.avail_in = data_len; - Z.avail_out = HTTP_ENCODING_BUFLEN(data_len) - 1; - Z.next_out = emalloc(HTTP_ENCODING_BUFLEN(data_len)); - *encoded = (char *) Z.next_out; - - if (Z_OK == (status = deflateInit2(&Z, level, Z_DEFLATED, zhdr ? MAX_WBITS : -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) { + status = deflateInit2(&Z, level, Z_DEFLATED, wbits, MAX_MEM_LEVEL, strategy); + if (Z_OK == status) { + *encoded_len = HTTP_DEFLATE_BUFFER_SIZE_GUESS(data_len); + *encoded = emalloc_rel(*encoded_len); + + Z.next_in = (Bytef *) data; + Z.next_out = (Bytef *) *encoded; + Z.avail_in = data_len; + Z.avail_out = *encoded_len; + status = deflate(&Z, Z_FINISH); deflateEnd(&Z); if (Z_STREAM_END == status) { + /* size buffer down to actual length */ + *encoded = erealloc_rel(*encoded, Z.total_out + 1); (*encoded)[*encoded_len = Z.total_out] = '\0'; return SUCCESS; + } else { + STR_SET(*encoded, NULL); + *encoded_len = 0; } } - STR_SET(*encoded, NULL); http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not deflate data: %s", zError(status)); return FAILURE; } +/* }}} */ -PHP_HTTP_API STATUS _http_encoding_inflate(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC) +/* {{{ STATUS http_encoding_inflate(char *, size_t, char **, size_t) */ +PHP_HTTP_API STATUS _http_encoding_inflate(const char *data, size_t data_len, char **decoded, size_t *decoded_len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC TSRMLS_DC) { - int max = 0, wbits = -MAX_WBITS; - STATUS status; z_stream Z; + int status, wbits = HTTP_WINDOW_BITS_ANY; - *decoded = NULL; - *decoded_len = 0; memset(&Z, 0, sizeof(z_stream)); - do { - if (!max) { - *decoded_len = data_len * 2; - *decoded = emalloc(*decoded_len + 1); - } else { - size_t new_len = *decoded_len << 2; - char *new_ptr = erealloc_recoverable(*decoded, new_len + 1); - - if (new_ptr) { - *decoded = new_ptr; - *decoded_len = new_len; - } else { - max = INT_MAX-1; /* avoid integer overflow on increment op */ - } - } - -retry_inflate: - Z.next_in = (Bytef *) data; - Z.avail_in = data_len; - Z.next_out = (Bytef *) *decoded; - Z.avail_out = *decoded_len; +retry_raw_inflate: + status = inflateInit2(&Z, wbits); + if (Z_OK == status) { + Z.next_in = (Bytef *) data; + Z.avail_in = data_len; - if (Z_OK == (status = inflateInit2(&Z, wbits))) { - status = inflate(&Z, Z_FINISH); - inflateEnd(&Z); - - /* retry if it looks like we've got a zlib header */ - if (wbits == -MAX_WBITS && status == Z_DATA_ERROR) { - wbits = MAX_WBITS; - goto retry_inflate; - } - - if (Z_STREAM_END == status) { - (*decoded)[*decoded_len = Z.total_out] = '\0'; + switch (status = http_inflate_rounds(&Z, Z_NO_FLUSH, decoded, decoded_len)) { + case Z_STREAM_END: + inflateEnd(&Z); return SUCCESS; - } + + case Z_OK: + status = Z_DATA_ERROR; + break; + + case Z_DATA_ERROR: + /* raw deflated data? */ + if (HTTP_WINDOW_BITS_ANY == wbits) { + inflateEnd(&Z); + wbits = HTTP_WINDOW_BITS_RAW; + goto retry_raw_inflate; + } + } + inflateEnd(&Z); + + if (decoded_len && *decoded) { + efree(*decoded); } - } while (status == Z_BUF_ERROR && ++max < HTTP_ENCODING_MAXTRY); + } - STR_SET(*decoded, NULL); http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not inflate data: %s", zError(status)); return FAILURE; } +/* }}} */ -PHP_HTTP_API STATUS _http_encoding_gzencode_verify(const char *data, size_t data_len, const char **encoded, size_t *encoded_len, int error_level TSRMLS_DC) +/* {{{ http_encoding_stream *_http_encoding_deflate_stream_init(http_encoding_stream *, int) */ +PHP_HTTP_API http_encoding_stream *_http_encoding_deflate_stream_init(http_encoding_stream *s, int flags ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC TSRMLS_DC) { - size_t offset = sizeof(http_encoding_gzip_header); + int status, level, wbits, strategy, free_stream; - if (data_len < offset) { - goto really_bad_gzip_header; + if ((free_stream = !s)) { + s = pemalloc_rel(sizeof(http_encoding_stream), (flags & HTTP_ENCODING_STREAM_PERSISTENT)); } + memset(s, 0, sizeof(http_encoding_stream)); + s->flags = flags; - if (data[0] != (const char) 0x1F || data[1] != (const char) 0x8B) { - http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "Unrecognized GZIP header start: 0x%02X 0x%02X", (int) data[0], (int) (data[1] & 0xFF)); - return FAILURE; - } + HTTP_DEFLATE_LEVEL_SET(flags, level); + HTTP_DEFLATE_WBITS_SET(flags, wbits); + HTTP_DEFLATE_STRATEGY_SET(flags, strategy); - if (data[2] != (const char) Z_DEFLATED) { - http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "Unrecognized compression format (%d)", (int) (data[2] & 0xFF)); - /* still try to decode */ - } - if ((data[3] & 0x4) == 0x4) { - if (data_len < offset + 2) { - goto really_bad_gzip_header; - } - /* there are extra fields, the length follows the common header as 2 bytes LSB */ - offset += (unsigned) ((data[offset] & 0xFF)); - offset += 1; - offset += (unsigned) ((data[offset] & 0xFF) << 8); - offset += 1; - } - if ((data[3] & 0x8) == 0x8) { - if (data_len <= offset) { - goto really_bad_gzip_header; + if (Z_OK == (status = deflateInit2(&s->stream, level, Z_DEFLATED, wbits, MAX_MEM_LEVEL, strategy))) { + int p = (flags & HTTP_ENCODING_STREAM_PERSISTENT) ? PHPSTR_INIT_PERSISTENT:0; + + if ((s->stream.opaque = phpstr_init_ex(NULL, HTTP_DEFLATE_BUFFER_SIZE, p))) { + return s; } - /* there's a file name */ - offset += strlen(&data[offset]) + 1 /*NUL*/; + deflateEnd(&s->stream); + status = Z_MEM_ERROR; } - if ((data[3] & 0x10) == 0x10) { - if (data_len <= offset) { - goto really_bad_gzip_header; - } - /* there's a comment */ - offset += strlen(&data[offset]) + 1 /* NUL */; + + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to initialize deflate encoding stream: %s", zError(status)); + if (free_stream) { + efree(s); } - if ((data[3] & 0x2) == 0x2) { - /* there's a CRC16 of the header */ - offset += 2; - if (data_len <= offset) { - goto really_bad_gzip_header; - } else { - ulong crc, cmp; - - cmp = (unsigned) ((data[offset-2] & 0xFF)); - cmp += (unsigned) ((data[offset-1] & 0xFF) << 8); - - crc = crc32(0L, Z_NULL, 0); - crc = crc32(crc, (const Bytef *) data, sizeof(http_encoding_gzip_header)); - - if (cmp != (crc & 0xFFFF)) { - http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "GZIP headers CRC checksums so not match (%lu, %lu)", cmp, crc & 0xFFFF); - return FAILURE; - } - } + return NULL; +} +/* }}} */ + +/* {{{ http_encoding_stream *http_encoding_inflate_stream_init(http_encoding_stream *, int) */ +PHP_HTTP_API http_encoding_stream *_http_encoding_inflate_stream_init(http_encoding_stream *s, int flags ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC TSRMLS_DC) +{ + int status, wbits, free_stream; + + if ((free_stream = !s)) { + s = pemalloc_rel(sizeof(http_encoding_stream), (flags & HTTP_ENCODING_STREAM_PERSISTENT)); } + memset(s, 0, sizeof(http_encoding_stream)); + s->flags = flags; - if (data_len < offset + 8) { - http_error(error_level TSRMLS_CC, HTTP_E_ENCODING, "Missing or truncated GZIP footer"); - return FAILURE; + HTTP_INFLATE_WBITS_SET(flags, wbits); + + if (Z_OK == (status = inflateInit2(&s->stream, wbits))) { + int p = (flags & HTTP_ENCODING_STREAM_PERSISTENT) ? PHPSTR_INIT_PERSISTENT:0; + + if ((s->stream.opaque = phpstr_init_ex(NULL, HTTP_DEFLATE_BUFFER_SIZE, p))) { + return s; + } + inflateEnd(&s->stream); + status = Z_MEM_ERROR; } - if (encoded) { - *encoded = data + offset; + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to initialize inflate stream: %s", zError(status)); + if (free_stream) { + efree(s); } - if (encoded_len) { - *encoded_len = data_len - offset - 8 /* size of the assumed GZIP footer */; + return NULL; +} +/* }}} */ + +/* {{{ STATUS http_encoding_deflate_stream_update(http_encoding_stream *, char *, size_t, char **, size_t *) */ +PHP_HTTP_API STATUS _http_encoding_deflate_stream_update(http_encoding_stream *s, const char *data, size_t data_len, char **encoded, size_t *encoded_len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC TSRMLS_DC) +{ + int status; + + /* append input to our buffer */ + phpstr_append(PHPSTR(s->stream.opaque), data, data_len); + + s->stream.next_in = (Bytef *) PHPSTR_VAL(s->stream.opaque); + s->stream.avail_in = PHPSTR_LEN(s->stream.opaque); + + /* deflate */ + *encoded_len = HTTP_DEFLATE_BUFFER_SIZE_GUESS(data_len); + *encoded = emalloc_rel(*encoded_len); + s->stream.avail_out = *encoded_len; + s->stream.next_out = (Bytef *) *encoded; + + switch (status = deflate(&s->stream, HTTP_ENCODING_STREAM_FLUSH_FLAG(s->flags))) { + case Z_OK: + case Z_STREAM_END: + /* cut processed chunk off the buffer */ + if (s->stream.avail_in) { + phpstr_cut(PHPSTR(s->stream.opaque), 0, PHPSTR_LEN(s->stream.opaque) - s->stream.avail_in); + } else { + phpstr_reset(PHPSTR(s->stream.opaque)); + } + + /* size buffer down to actual size */ + *encoded_len -= s->stream.avail_out; + *encoded = erealloc_rel(*encoded, *encoded_len + 1); + (*encoded)[*encoded_len] = '\0'; + return SUCCESS; } - return SUCCESS; - -really_bad_gzip_header: - http_error(error_level TSRMLS_CC, HTTP_E_ENCODING, "Missing or truncated GZIP header"); + STR_SET(*encoded, NULL); + *encoded_len = 0; + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to update deflate stream: %s", zError(status)); return FAILURE; } +/* }}} */ -PHP_HTTP_API STATUS _http_encoding_gzdecode_verify(const char *data, size_t data_len, const char *decoded, size_t decoded_len, int error_level TSRMLS_DC) +/* {{{ STATUS http_encoding_inflate_stream_update(http_encoding_stream *, char *, size_t, char **, size_t *) */ +PHP_HTTP_API STATUS _http_encoding_inflate_stream_update(http_encoding_stream *s, const char *data, size_t data_len, char **decoded, size_t *decoded_len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC TSRMLS_DC) { - STATUS status = SUCCESS; - ulong len, cmp, crc; - - crc = crc32(0L, Z_NULL, 0); - crc = crc32(crc, (const Bytef *) decoded, decoded_len); - - cmp = (unsigned) ((data[data_len-8] & 0xFF)); - cmp += (unsigned) ((data[data_len-7] & 0xFF) << 8); - cmp += (unsigned) ((data[data_len-6] & 0xFF) << 16); - cmp += (unsigned) ((data[data_len-5] & 0xFF) << 24); - len = (unsigned) ((data[data_len-4] & 0xFF)); - len += (unsigned) ((data[data_len-3] & 0xFF) << 8); - len += (unsigned) ((data[data_len-2] & 0xFF) << 16); - len += (unsigned) ((data[data_len-1] & 0xFF) << 24); - - if (cmp != crc) { - http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "Could not verify data integrity: CRC checksums do not match (%lu, %lu)", cmp, crc); - status = FAILURE; - } - if (len != decoded_len) { - http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "Could not verify data integrity: data sizes do not match (%lu, %lu)", len, decoded_len); - status = FAILURE; + int status; + + /* append input to buffer */ + phpstr_append(PHPSTR(s->stream.opaque), data, data_len); + +retry_raw_inflate: + s->stream.next_in = (Bytef *) PHPSTR_VAL(s->stream.opaque); + s->stream.avail_in = PHPSTR_LEN(s->stream.opaque); + + switch (status = http_inflate_rounds(&s->stream, HTTP_ENCODING_STREAM_FLUSH_FLAG(s->flags), decoded, decoded_len)) { + case Z_OK: + case Z_STREAM_END: + /* cut off */ + if (s->stream.avail_in) { + phpstr_cut(PHPSTR(s->stream.opaque), 0, PHPSTR_LEN(s->stream.opaque) - s->stream.avail_in); + } else { + phpstr_reset(PHPSTR(s->stream.opaque)); + } + return SUCCESS; + + case Z_DATA_ERROR: + /* raw deflated data ? */ + if (!(s->flags & HTTP_INFLATE_TYPE_RAW) && !s->stream.total_out) { + inflateEnd(&s->stream); + s->flags |= HTTP_INFLATE_TYPE_RAW; + inflateInit2(&s->stream, HTTP_WINDOW_BITS_RAW); + goto retry_raw_inflate; + } } - return status; + + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to update inflate stream: %s", zError(status)); + return FAILURE; } +/* }}} */ -#define HTTP_ENCODING_STREAM_ERROR(status, tofree) \ - { \ - if (tofree) efree(tofree); \ - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "GZIP stream error: %s", zError(status)); \ - return FAILURE; \ - } - -PHP_HTTP_API STATUS _http_encoding_stream_init(http_encoding_stream *s, int flags, int level, char **encoded, size_t *encoded_len TSRMLS_DC) +/* {{{ STATUS http_encoding_deflate_stream_flush(http_encoding_stream *, char **, size_t *) */ +PHP_HTTP_API STATUS _http_encoding_deflate_stream_flush(http_encoding_stream *s, char **encoded, size_t *encoded_len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC TSRMLS_DC) { - STATUS status; - int wbits = (flags & HTTP_ENCODING_STREAM_ZLIB_HEADER) ? MAX_WBITS : -MAX_WBITS; + int status; - memset(s, 0, sizeof(http_encoding_stream)); - if (Z_OK != (status = deflateInit2(&s->Z, level, Z_DEFLATED, wbits, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) { - HTTP_ENCODING_STREAM_ERROR(status, NULL); - } + *encoded_len = HTTP_DEFLATE_BUFFER_SIZE; + *encoded = emalloc_rel(*encoded_len); - s->persistent = (flags & HTTP_ENCODING_STREAM_PERSISTENT); - if ((s->gzip = (flags & HTTP_ENCODING_STREAM_GZIP_HEADER))) { - s->crc = crc32(0L, Z_NULL, 0); - *encoded_len = sizeof(http_encoding_gzip_header); - *encoded = pemalloc(*encoded_len, s->persistent); - memcpy(*encoded, http_encoding_gzip_header, *encoded_len); - } else { - *encoded_len = 0; - *encoded = NULL; + s->stream.avail_in = 0; + s->stream.next_in = NULL; + s->stream.avail_out = *encoded_len; + s->stream.next_out = (Bytef *) *encoded; + + switch (status = deflate(&s->stream, Z_FULL_FLUSH)) { + case Z_OK: + case Z_STREAM_END: + *encoded_len = HTTP_DEFLATE_BUFFER_SIZE - s->stream.avail_out; + *encoded = erealloc_rel(*encoded, *encoded_len + 1); + (*encoded)[*encoded_len] = '\0'; + return SUCCESS; } + STR_SET(*encoded, NULL); + *encoded_len = 0; + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to flush deflate stream: %s", zError(status)); + return FAILURE; +} +/* }}} */ + +/* {{{ STATUS http_encoding_inflate_straem_flush(http_encoding_stream *, char **, size_t *) */ +PHP_HTTP_API STATUS _http_encoding_inflate_stream_flush(http_encoding_stream *s, char **decoded, size_t *decoded_len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC TSRMLS_DC) +{ + /* noop */ + *decoded = estrndup("", *decoded_len = 0); return SUCCESS; } +/* }}} */ -PHP_HTTP_API STATUS _http_encoding_stream_update(http_encoding_stream *s, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC) +/* {{{ STATUS http_encoding_deflate_stream_finish(http_encoding_stream *, char **, size_t *) */ +PHP_HTTP_API STATUS _http_encoding_deflate_stream_finish(http_encoding_stream *s, char **encoded, size_t *encoded_len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC TSRMLS_DC) { - STATUS status; + int status; - *encoded_len = HTTP_ENCODING_BUFLEN(data_len); - *encoded = pemalloc(*encoded_len, s->persistent); + *encoded_len = HTTP_DEFLATE_BUFFER_SIZE; + *encoded = emalloc_rel(*encoded_len); - s->Z.next_in = (Bytef *) data; - s->Z.avail_in = data_len; - s->Z.next_out = (Bytef *) *encoded; - s->Z.avail_out = *encoded_len; + /* deflate remaining input */ + s->stream.next_in = (Bytef *) PHPSTR_VAL(s->stream.opaque); + s->stream.avail_in = PHPSTR_LEN(s->stream.opaque); - status = deflate(&s->Z, Z_SYNC_FLUSH); + s->stream.avail_out = *encoded_len; + s->stream.next_out = (Bytef *) *encoded; - if (Z_OK != status && Z_STREAM_END != status) { - HTTP_ENCODING_STREAM_ERROR(status, *encoded); - } - *encoded_len -= s->Z.avail_out; + do { + status = deflate(&s->stream, Z_FINISH); + } while (Z_OK == status); - if (s->gzip) { - s->crc = crc32(s->crc, (const Bytef *) data, data_len); + if (Z_STREAM_END == status) { + /* cut processed intp off */ + phpstr_cut(PHPSTR(s->stream.opaque), 0, PHPSTR_LEN(s->stream.opaque) - s->stream.avail_in); + + /* size down */ + *encoded_len -= s->stream.avail_out; + *encoded = erealloc_rel(*encoded, *encoded_len + 1); + (*encoded)[*encoded_len] = '\0'; + return SUCCESS; } - return SUCCESS; + STR_SET(*encoded, NULL); + *encoded_len = 0; + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to finish deflate stream: %s", zError(status)); + return FAILURE; } +/* }}} */ -PHP_HTTP_API STATUS _http_encoding_stream_finish(http_encoding_stream *s, char **encoded, size_t *encoded_len TSRMLS_DC) +/* {{{ STATUS http_encoding_inflate_stream_finish(http_encoding_stream *, char **, size_t *) */ +PHP_HTTP_API STATUS _http_encoding_inflate_stream_finish(http_encoding_stream *s, char **decoded, size_t *decoded_len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC TSRMLS_DC) { - STATUS status; + int status; + + if (!PHPSTR_LEN(s->stream.opaque)) { + *decoded = NULL; + *decoded_len = 0; + return SUCCESS; + } - *encoded_len = 1024; - *encoded = pemalloc(*encoded_len, s->persistent); + *decoded_len = (PHPSTR_LEN(s->stream.opaque) + 1) * HTTP_INFLATE_ROUNDS; + *decoded = emalloc_rel(*decoded_len); - s->Z.next_out = (Bytef *) *encoded; - s->Z.avail_out = *encoded_len; + /* inflate remaining input */ + s->stream.next_in = (Bytef *) PHPSTR_VAL(s->stream.opaque); + s->stream.avail_in = PHPSTR_LEN(s->stream.opaque); - if (Z_STREAM_END != (status = deflate(&s->Z, Z_FINISH)) || Z_OK != (status = deflateEnd(&s->Z))) { - HTTP_ENCODING_STREAM_ERROR(status, *encoded); + s->stream.avail_out = *decoded_len; + s->stream.next_out = (Bytef *) *decoded; + + if (Z_STREAM_END == (status = inflate(&s->stream, Z_FINISH))) { + /* cut processed input off */ + phpstr_cut(PHPSTR(s->stream.opaque), 0, PHPSTR_LEN(s->stream.opaque) - s->stream.avail_in); + + /* size down */ + *decoded_len -= s->stream.avail_out; + *decoded = erealloc_rel(*decoded, *decoded_len + 1); + (*decoded)[*decoded_len] = '\0'; + return SUCCESS; } - *encoded_len -= s->Z.avail_out; - if (s->gzip) { - if (s->Z.avail_out < 8) { - *encoded = perealloc(*encoded, *encoded_len + 8, s->persistent); + STR_SET(*decoded, NULL); + *decoded_len = 0; + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to finish inflate stream: %s", zError(status)); + return FAILURE; +} +/* }}} */ + +/* {{{ void http_encoding_deflate_stream_dtor(http_encoding_stream *) */ +PHP_HTTP_API void _http_encoding_deflate_stream_dtor(http_encoding_stream *s TSRMLS_DC) +{ + if (s) { + if (s->stream.opaque) { + phpstr_free((phpstr **) &s->stream.opaque); } - (*encoded)[(*encoded_len)++] = (char) (s->crc & 0xFF); - (*encoded)[(*encoded_len)++] = (char) ((s->crc >> 8) & 0xFF); - (*encoded)[(*encoded_len)++] = (char) ((s->crc >> 16) & 0xFF); - (*encoded)[(*encoded_len)++] = (char) ((s->crc >> 24) & 0xFF); - (*encoded)[(*encoded_len)++] = (char) ((s->Z.total_in) & 0xFF); - (*encoded)[(*encoded_len)++] = (char) ((s->Z.total_in >> 8) & 0xFF); - (*encoded)[(*encoded_len)++] = (char) ((s->Z.total_in >> 16) & 0xFF); - (*encoded)[(*encoded_len)++] = (char) ((s->Z.total_in >> 24) & 0xFF); + deflateEnd(&s->stream); } - - return SUCCESS; } +/* }}} */ -#endif /* HTTP_HAVE_ZLIB */ +/* {{{ void http_encoding_inflate_stream_dtor(http_encoding_stream *) */ +PHP_HTTP_API void _http_encoding_inflate_stream_dtor(http_encoding_stream *s TSRMLS_DC) +{ + if (s) { + if (s->stream.opaque) { + phpstr_free((phpstr **) &s->stream.opaque); + } + inflateEnd(&s->stream); + } +} +/* }}} */ -PHP_HTTP_API zend_bool _http_encoding_response_start(size_t content_length TSRMLS_DC) +/* {{{ void http_encoding_deflate_stream_free(http_encoding_stream **) */ +PHP_HTTP_API void _http_encoding_deflate_stream_free(http_encoding_stream **s TSRMLS_DC) { - if ( php_ob_handler_used("ob_gzhandler" TSRMLS_CC) || - php_ob_handler_used("zlib output compression" TSRMLS_CC)) { - HTTP_G(send).gzip_encoding = 0; - } else { - if (!HTTP_G(send).gzip_encoding) { - /* emit a content-length header */ - if (content_length) { - char cl_header_str[128]; - size_t cl_header_len; - cl_header_len = snprintf(cl_header_str, lenof(cl_header_str), "Content-Length: %zu", content_length); - http_send_header_string_ex(cl_header_str, cl_header_len, 1); - } - } else { -#ifndef HTTP_HAVE_ZLIB - HTTP_G(send).gzip_encoding = 0; - php_start_ob_buffer_named("ob_gzhandler", 0, 0 TSRMLS_CC); -#else - HashTable *selected; - zval zsupported; + if (s) { + http_encoding_deflate_stream_dtor(*s); + if (*s) { + pefree(*s, (*s)->flags & HTTP_ENCODING_STREAM_PERSISTENT); + } + *s = NULL; + } +} +/* }}} */ + +/* {{{ void http_encoding_inflate_stream_free(http_encoding_stream **) */ +PHP_HTTP_API void _http_encoding_inflate_stream_free(http_encoding_stream **s TSRMLS_DC) +{ + if (s) { + http_encoding_inflate_stream_dtor(*s); + if (*s) { + pefree(*s, (*s)->flags & HTTP_ENCODING_STREAM_PERSISTENT); + } + *s = NULL; + } +} +/* }}} */ + +/* {{{ void http_ob_deflatehandler(char *, uint, char **, uint *, int) */ +void _http_ob_deflatehandler(char *output, uint output_len, char **handled_output, uint *handled_output_len, int mode TSRMLS_DC) +{ + int encoding; + + *handled_output = NULL; + *handled_output_len = 0; + + if (mode & PHP_OUTPUT_HANDLER_START) { + int flags; + + if (HTTP_G->send.deflate.stream) { + zend_error(E_ERROR, "ob_deflatehandler() can only be used once"); + return; + } + + HTTP_G->send.deflate.response = 1; + encoding = http_encoding_response_start(0, 1); + HTTP_G->send.deflate.response = 0; + + switch (encoding) { + case HTTP_ENCODING_GZIP: + flags = HTTP_DEFLATE_TYPE_GZIP; + break; - INIT_PZVAL(&zsupported); - array_init(&zsupported); - add_next_index_stringl(&zsupported, "gzip", lenof("gzip"), 1); - add_next_index_stringl(&zsupported, "x-gzip", lenof("x-gzip"), 1); - add_next_index_stringl(&zsupported, "deflate", lenof("deflate"), 1); + case HTTP_ENCODING_DEFLATE: + flags = HTTP_DEFLATE_TYPE_ZLIB; + break; - HTTP_G(send).gzip_encoding = 0; + default: + goto deflate_passthru_plain; + } + + flags |= (HTTP_G->send.deflate.start_flags &~ 0xf0); + HTTP_G->send.deflate.stream = http_encoding_deflate_stream_init(NULL, flags); + } + + if (HTTP_G->send.deflate.stream) { + if (output_len) { + size_t tmp_len; - if ((selected = http_negotiate_encoding(&zsupported))) { - STATUS hs = FAILURE; - char *encoding = NULL; - ulong idx; - - if (HASH_KEY_IS_STRING == zend_hash_get_current_key(selected, &encoding, &idx, 0) && encoding) { - if (!strcmp(encoding, "gzip") || !strcmp(encoding, "x-gzip")) { - if (SUCCESS == (hs = http_send_header_string("Content-Encoding: gzip"))) { - HTTP_G(send).gzip_encoding = HTTP_ENCODING_GZIP; - } - } else if (!strcmp(encoding, "deflate")) { - if (SUCCESS == (hs = http_send_header_string("Content-Encoding: deflate"))) { - HTTP_G(send).gzip_encoding = HTTP_ENCODING_DEFLATE; - } - } - if (SUCCESS == hs) { - http_send_header_string("Vary: Accept-Encoding"); - } - } - - zend_hash_destroy(selected); - FREE_HASHTABLE(selected); + http_encoding_deflate_stream_update((http_encoding_stream *) HTTP_G->send.deflate.stream, output, output_len, handled_output, &tmp_len); + *handled_output_len = tmp_len; + } + + if (mode & PHP_OUTPUT_HANDLER_END) { + char *remaining = NULL; + size_t remaining_len = 0; + + http_encoding_deflate_stream_finish((http_encoding_stream *) HTTP_G->send.deflate.stream, &remaining, &remaining_len); + http_encoding_deflate_stream_free((http_encoding_stream **) &HTTP_G->send.deflate.stream); + if (remaining) { + *handled_output = erealloc(*handled_output, *handled_output_len + remaining_len + 1); + memcpy(*handled_output + *handled_output_len, remaining, remaining_len); + (*handled_output)[*handled_output_len += remaining_len] = '\0'; + efree(remaining); } + } + } else { +deflate_passthru_plain: + *handled_output = estrndup(output, *handled_output_len = output_len); + } +} +/* }}} */ + +/* {{{ void http_ob_inflatehandler(char *, uint, char **, uint *, int) */ +void _http_ob_inflatehandler(char *output, uint output_len, char **handled_output, uint *handled_output_len, int mode TSRMLS_DC) +{ + *handled_output = NULL; + *handled_output_len = 0; + + if (mode & PHP_OUTPUT_HANDLER_START) { + if (HTTP_G->send.inflate.stream) { + zend_error(E_ERROR, "ob_inflatehandler() can only be used once"); + return; + } + HTTP_G->send.inflate.stream = http_encoding_inflate_stream_init(NULL, (HTTP_G->send.inflate.start_flags &~ 0xf0)); + } + + if (HTTP_G->send.inflate.stream) { + if (output_len) { + size_t tmp_len; - zval_dtor(&zsupported); - return HTTP_G(send).gzip_encoding; -#endif + http_encoding_inflate_stream_update((http_encoding_stream *) HTTP_G->send.inflate.stream, output, output_len, handled_output, &tmp_len); + *handled_output_len = tmp_len; } + + if (mode & PHP_OUTPUT_HANDLER_END) { + char *remaining = NULL; + size_t remaining_len = 0; + + http_encoding_inflate_stream_finish((http_encoding_stream *) HTTP_G->send.inflate.stream, &remaining, &remaining_len); + http_encoding_inflate_stream_free((http_encoding_stream **) &HTTP_G->send.inflate.stream); + if (remaining) { + *handled_output = erealloc(*handled_output, *handled_output_len + remaining_len + 1); + memcpy(*handled_output + *handled_output_len, remaining, remaining_len); + (*handled_output)[*handled_output_len += remaining_len] = '\0'; + efree(remaining); + } + } + } else { + *handled_output = estrndup(output, *handled_output_len = output_len); } - return 0; } +/* }}} */ + +#endif /* HTTP_HAVE_ZLIB */ /* * Local variables: