X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-http;a=blobdiff_plain;f=http_encoding_api.c;h=08a41a87da82df75afcd9bcd823b406688621368;hp=b87f1c08ed3d420064a2675eccb8f1c1196e77bb;hb=e37040ebf8a470c77c7ae3498ee582ca20db259c;hpb=a04675773914229e067f48ad0912f3cf70cffdcf diff --git a/http_encoding_api.c b/http_encoding_api.c index b87f1c0..08a41a8 100644 --- a/http_encoding_api.c +++ b/http_encoding_api.c @@ -1,332 +1,757 @@ /* - +----------------------------------------------------------------------+ - | 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 | - +----------------------------------------------------------------------+ + +--------------------------------------------------------------------+ + | 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-2006, Michael Wallner | + +--------------------------------------------------------------------+ */ /* $Id$ */ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif -#include "php.h" - -#include "php_http_encoding_api.h" +#define HTTP_WANT_ZLIB #include "php_http.h" + #include "php_http_api.h" +#include "php_http_encoding_api.h" +#include "php_http_send_api.h" +#include "php_http_headers_api.h" + +/* {{{ */ +#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; +} -ZEND_EXTERN_MODULE_GLOBALS(http); +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 (' ' == *ptr) ++ptr; + + if (ptr == http_locate_eol(*line, eol_len)) { + *line = ptr; + return 1; + } else { + 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) { - const char *e_ptr; - char *d_ptr; - long rest; + int eol_len = 0; + char *n_ptr = NULL; + const char *e_ptr = encoded; *decoded_len = 0; *decoded = ecalloc(1, encoded_len); - d_ptr = *decoded; - e_ptr = encoded; - - while ((rest = encoded + encoded_len - e_ptr) > 0) { - long chunk_len = 0; - int EOL_len = 0, eol_mismatch = 0; - char *n_ptr; - - chunk_len = strtol(e_ptr, &n_ptr, 16); - - /* check if: - * - we could not read in chunk size - * - we got a negative chunk size - * - chunk size is greater then remaining size - * - chunk size is not followed by (CR)LF|NUL - */ - if ( (n_ptr == e_ptr) || (chunk_len < 0) || (chunk_len > rest) || - (*n_ptr && (eol_mismatch = (n_ptr != http_locate_eol(e_ptr, &EOL_len))))) { - /* don't fail on apperently not encoded data */ + + while ((encoded + encoded_len - e_ptr) > 0) { + ulong chunk_len = 0, rest; + + chunk_len = strtoul(e_ptr, &n_ptr, 16); + + /* we could not read in chunk size */ + if (n_ptr == e_ptr) { + /* + * if this is the first turn and there doesn't seem to be a chunk + * size at the begining of the body, do not fail on apparently + * not encoded data and return a copy + */ if (e_ptr == encoded) { + http_error(HE_NOTICE, HTTP_E_ENCODING, "Data does not seem to be chunked encoded"); memcpy(*decoded, encoded, encoded_len); *decoded_len = encoded_len; return encoded + encoded_len; } else { efree(*decoded); - if (eol_mismatch) { - if (EOL_len == 2) { - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Invalid character (expected 0x0D 0x0A; got: 0x%X 0x%X)", *n_ptr, *(n_ptr + 1)); - } else { - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Invalid character (expected 0x0A; got: 0x%X)", *n_ptr); - } - } else { - char *error = estrndup(n_ptr, strcspn(n_ptr, "\r\n ")); - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Invalid chunk size: '%s' at pos %d", error, n_ptr - encoded); - efree(error); - } + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Expected chunk size at pos %tu of %zu but got trash", n_ptr - encoded, encoded_len); return NULL; } - } else { - e_ptr = n_ptr; } - + /* reached the end */ if (!chunk_len) { + /* move over '0' chunked encoding terminator */ + while (*e_ptr == '0') ++e_ptr; break; } - memcpy(d_ptr, e_ptr += EOL_len, chunk_len); - d_ptr += chunk_len; - e_ptr += chunk_len + EOL_len; + /* there should be CRLF after the chunk size, but we'll ignore SP+ too */ + if (*n_ptr && !eol_match(&n_ptr, &eol_len)) { + if (eol_len == 2) { + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Expected CRLF at pos %tu of %zu but got 0x%02X 0x%02X", n_ptr - encoded, encoded_len, *n_ptr, *(n_ptr + 1)); + } else { + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Expected LF at pos %tu of %zu but got 0x%02X", n_ptr - encoded, encoded_len, *n_ptr); + } + } + n_ptr += eol_len; + + /* chunk size pretends more data than we actually got, so it's probably a truncated message */ + if (chunk_len > (rest = encoded + encoded_len - n_ptr)) { + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Truncated message: chunk size %lu exceeds remaining data size %lu at pos %tu of %zu", chunk_len, rest, n_ptr - encoded, encoded_len); + chunk_len = rest; + } + + /* copy the chunk */ + memcpy(*decoded + *decoded_len, n_ptr, chunk_len); *decoded_len += chunk_len; + + if (chunk_len == rest) { + e_ptr = n_ptr + chunk_len; + break; + } else { + /* advance to next chunk */ + e_ptr = n_ptr + chunk_len + eol_len; + } } return e_ptr; } /* }}} */ +/* {{{ int http_encoding_response_start(size_t) */ +PHP_HTTP_API int _http_encoding_response_start(size_t content_length TSRMLS_DC) +{ + if ( php_ob_handler_used("ob_gzhandler" TSRMLS_CC) || + php_ob_handler_used("zlib output compression" TSRMLS_CC)) { + HTTP_G->send.deflate.encoding = 0; + } else { + if (!HTTP_G->send.deflate.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.deflate.encoding = 0; + php_start_ob_buffer_named("ob_gzhandler", 0, 0 TSRMLS_CC); +#else + HashTable *selected; + zval zsupported; + + 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); + + HTTP_G->send.deflate.encoding = 0; + + 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.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"); + } + } + + zend_hash_destroy(selected); + FREE_HASHTABLE(selected); + } + + zval_dtor(&zsupported); + return HTTP_G->send.deflate.encoding; +#endif + } + } + return 0; +} +/* }}} */ + #ifdef HTTP_HAVE_ZLIB -#include - -/* max count of uncompress trials, alloc_size <<= 2 for each try */ -#define HTTP_GZMAXTRY 10 -/* safe padding */ -#define HTTP_GZSAFPAD 10 -/* add 1% extra space in case we need to encode widely differing (binary) data */ -#define HTTP_GZBUFLEN(l) (l + (l / 100) + HTTP_GZSAFPAD) - -static const char http_gzencode_header[] = { - (const char) 0x1f, - (const char) 0x8b, - (const char) Z_DEFLATED, - 0, 0, 0, 0, 0, 0, - (const char) 0x03 -}; - -inline void http_init_gzencode_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr) + +/* {{{ inline int http_inflate_rounds */ +static inline int http_inflate_rounds(z_stream *Z, int flush, char **buf, size_t *len) { - Z->zalloc = Z_NULL; - Z->zfree = Z_NULL; - Z->opaque = Z_NULL; + int status = 0, round = 0; + phpstr buffer; - Z->next_in = (Bytef *) data; - Z->avail_in = data_len; - Z->avail_out = HTTP_GZBUFLEN(data_len) + HTTP_GZSAFPAD - 1; + *buf = NULL; + *len = 0; + + phpstr_init_ex(&buffer, Z->avail_in, PHPSTR_INIT_PREALLOC); + + do { + if (phpstr_resize_ex(&buffer, buffer.size, 0, 1) == (size_t) -1) { + status = Z_MEM_ERROR; + } else { + do { + Z->avail_out = buffer.free; + Z->next_out = (Bytef *) buffer.data + buffer.used; +#if 0 + fprintf(stderr, "PRIOR: size=%lu, avail=%lu, used=%lu, (%d/%d)\n", buffer.size, Z->avail_out, buffer.used, status, round); +#endif + status = inflate(Z, flush); + + buffer.used += buffer.free - Z->avail_out; + buffer.free = Z->avail_out; +#if 0 + fprintf(stderr, "AFTER: size=%lu, avail=%lu, used=%lu, (%d/%d)\n", buffer.size, Z->avail_out, buffer.used, status, round); +#endif + } while (Z_OK == status && Z->avail_in); + + HTTP_INFLATE_BUFFER_SIZE_ALIGN(buffer.size); + } + } while (Z_BUF_ERROR == status && ++round < HTTP_INFLATE_ROUNDS); - *buf_ptr = emalloc(HTTP_GZBUFLEN(data_len) + sizeof(http_gzencode_header) + HTTP_GZSAFPAD); - memcpy(*buf_ptr, http_gzencode_header, sizeof(http_gzencode_header)); + if (status == Z_OK || status == Z_STREAM_END) { + phpstr_shrink(&buffer); + phpstr_fix(&buffer); + *buf = buffer.data; + *len = buffer.used; + } else { + phpstr_dtor(&buffer); + } - Z->next_out = *buf_ptr + sizeof(http_gzencode_header); + return status; } +/* }}} */ -inline void http_init_deflate_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr) +/* {{{ 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) { - Z->zalloc = Z_NULL; - Z->zfree = Z_NULL; - Z->opaque = Z_NULL; + int status, level, wbits, strategy; + z_stream Z; + + 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; + + 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; + } + } + + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not deflate data: %s", zError(status)); + return FAILURE; +} +/* }}} */ - Z->data_type = Z_UNKNOWN; - Z->next_in = (Bytef *) data; - Z->avail_in = data_len; - Z->avail_out = HTTP_GZBUFLEN(data_len) - 1; - Z->next_out = emalloc(HTTP_GZBUFLEN(data_len)); +/* {{{ 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) +{ + z_stream Z; + int status, wbits = HTTP_WINDOW_BITS_ANY; + + memset(&Z, 0, sizeof(z_stream)); - *buf_ptr = Z->next_out; +retry_raw_inflate: + status = inflateInit2(&Z, wbits); + if (Z_OK == status) { + Z.next_in = (Bytef *) data; + Z.avail_in = data_len; + + switch (status = http_inflate_rounds(&Z, Z_NO_FLUSH, decoded, decoded_len)) + { + case Z_OK: + case Z_STREAM_END: + return SUCCESS; + 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; + } + break; + } + inflateEnd(&Z); + } + + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not inflate data: %s", zError(status)); + return FAILURE; } +/* }}} */ -inline void http_init_inflate_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr, size_t *buf_len, int iteration) +/* {{{ 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) { - Z->zalloc = Z_NULL; - Z->zfree = Z_NULL; + int status, level, wbits, strategy, free_stream; - if (!iteration) { - *buf_len = data_len * 2; - *buf_ptr = emalloc(*buf_len + 1); - } else { - *buf_len <<= 2; - *buf_ptr = erealloc(*buf_ptr, *buf_len + 1); + 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; + + HTTP_DEFLATE_LEVEL_SET(flags, level); + HTTP_DEFLATE_WBITS_SET(flags, wbits); + HTTP_DEFLATE_STRATEGY_SET(flags, strategy); - Z->next_in = (Bytef *) data; - Z->avail_in = data_len; - Z->avail_out = *buf_len; - Z->next_out = *buf_ptr; + 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; + } + deflateEnd(&s->stream); + status = Z_MEM_ERROR; + } + + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to initialize deflate encoding stream: %s", zError(status)); + if (free_stream) { + efree(s); + } + return NULL; } +/* }}} */ -inline size_t http_finish_buffer(size_t buf_len, char **buf_ptr) +/* {{{ 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) { - (*buf_ptr)[buf_len] = '\0'; - return buf_len; + 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; + + 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; + } + + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to initialize inflate stream: %s", zError(status)); + if (free_stream) { + efree(s); + } + return NULL; } +/* }}} */ -inline size_t http_finish_gzencode_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr) +/* {{{ 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) { - unsigned long crc; - char *trailer; + int status; + + /* append input to our buffer */ + phpstr_append(PHPSTR(s->stream.opaque), data, data_len); - crc = crc32(0L, Z_NULL, 0); - crc = crc32(crc, (const Bytef *) data, data_len); + s->stream.next_in = (Bytef *) PHPSTR_VAL(s->stream.opaque); + s->stream.avail_in = PHPSTR_LEN(s->stream.opaque); - trailer = *buf_ptr + sizeof(http_gzencode_header) + Z->total_out; + /* 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; - /* 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); + 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; + break; + } - return http_finish_buffer(Z->total_out + sizeof(http_gzencode_header) + 8, buf_ptr); + 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; } +/* }}} */ +/* {{{ 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) +{ + 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; + break; + + 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; + } + break; + } + + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to update inflate stream: %s", zError(status)); + return FAILURE; +} +/* }}} */ -PHP_HTTP_API STATUS _http_encoding_gzencode(int level, const char *data, size_t data_len, 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) { - z_stream Z; - STATUS status = Z_OK; + int status; - http_init_gzencode_buffer(&Z, data, data_len, encoded); + *encoded_len = HTTP_DEFLATE_BUFFER_SIZE; + *encoded = emalloc_rel(*encoded_len); - if ( (Z_OK == (status = deflateInit2(&Z, level, Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) && - (Z_STREAM_END == (status = deflate(&Z, Z_FINISH))) && - (Z_OK == (status = deflateEnd(&Z)))) { - *encoded_len = http_finish_gzencode_buffer(&Z, data, data_len, encoded); - return SUCCESS; + 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; + break; } - efree(*encoded); - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not gzencode data: %s", zError(status)); + 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; } +/* }}} */ -PHP_HTTP_API STATUS _http_encoding_deflate(int level, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC) +/* {{{ 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) { - z_stream Z; - STATUS status = Z_OK; + /* noop */ + *decoded = estrndup("", *decoded_len = 0); + return SUCCESS; +} +/* }}} */ + +/* {{{ 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) +{ + int status; + + *encoded_len = HTTP_DEFLATE_BUFFER_SIZE; + *encoded = emalloc_rel(*encoded_len); + + /* deflate remaining input */ + s->stream.next_in = (Bytef *) PHPSTR_VAL(s->stream.opaque); + s->stream.avail_in = PHPSTR_LEN(s->stream.opaque); - http_init_deflate_buffer(&Z, data, data_len, encoded); + s->stream.avail_out = *encoded_len; + s->stream.next_out = (Bytef *) *encoded; - if ( (Z_OK == (status = deflateInit2(&Z, level, Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) && - (Z_STREAM_END == (status = deflate(&Z, Z_FINISH))) && - (Z_OK == (status = deflateEnd(&Z)))) { - *encoded_len = http_finish_buffer(Z.total_out, encoded); + do { + status = deflate(&s->stream, Z_FINISH); + } while (Z_OK == status); + + 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; } - efree(encoded); - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not deflate data: %s", zError(status)); + 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_compress(int level, const char *data, size_t data_len, 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; + + *decoded_len = (PHPSTR_LEN(s->stream.opaque) + 1) * HTTP_INFLATE_ROUNDS; + *decoded = emalloc_rel(*decoded_len); + + /* inflate remaining input */ + s->stream.next_in = (Bytef *) PHPSTR_VAL(s->stream.opaque); + s->stream.avail_in = PHPSTR_LEN(s->stream.opaque); - *encoded = emalloc(*encoded_len = HTTP_GZBUFLEN(data_len)); + s->stream.avail_out = *decoded_len; + s->stream.next_out = (Bytef *) *decoded; - if (Z_OK == (status = compress2(*encoded, encoded_len, data, data_len, level))) { - http_finish_buffer(*encoded_len, encoded); + 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; } - efree(encoded); - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not compress data: %s", zError(status)); + 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); + } + deflateEnd(&s->stream); + } +} +/* }}} */ + +/* {{{ 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); + } +} +/* }}} */ + +/* {{{ 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 (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; + } +} +/* }}} */ -PHP_HTTP_API STATUS _http_encoding_gzdecode(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC) +/* {{{ 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) { - const char *encoded = data + sizeof(http_gzencode_header); - size_t encoded_len; + *handled_output = NULL; + *handled_output_len = 0; - if (data_len <= sizeof(http_gzencode_header) + 8) { - http_error(HE_WARNING, HTTP_E_ENCODING, "Could not gzdecode data: too short data length"); - } else { - encoded_len = data_len - sizeof(http_gzencode_header) - 8; + if (mode & PHP_OUTPUT_HANDLER_START) { + int flags; - if (SUCCESS == http_encoding_inflate(encoded, encoded_len, decoded, decoded_len)) { - unsigned long len = 0, cmp = 0, 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 (HTTP_G->send.deflate.stream) { + zend_error(E_ERROR, "ob_deflatehandler() can only be used once"); + return; + } + + HTTP_G->send.deflate.encoding = !0; + + switch (http_encoding_response_start(0)) + { + case HTTP_ENCODING_GZIP: + flags = HTTP_DEFLATE_TYPE_GZIP; + break; - if (cmp != crc) { - http_error_ex(HE_NOTICE, HTTP_E_ENCODING, "Could not verify data integrity: CRC checksums do not match (%lu, %lu)", cmp, crc); - } - if (len != *decoded_len) { - http_error_ex(HE_NOTICE, HTTP_E_ENCODING, "Could not verify data integrity: data sizes do not match (%lu, %lu)", len, *decoded_len); - } + case HTTP_ENCODING_DEFLATE: + flags = HTTP_DEFLATE_TYPE_ZLIB; + break; - return SUCCESS; + default: + goto deflate_passthru_plain; + break; } + + flags |= (HTTP_G->send.deflate.start_flags &~ 0xf0); + HTTP_G->send.deflate.stream = http_encoding_deflate_stream_init(NULL, flags); } - return FAILURE; -} - -PHP_HTTP_API STATUS _http_encoding_inflate(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC) -{ - int max = 0; - STATUS status; - z_stream Z; - do { - http_init_inflate_buffer(&Z, data, data_len, decoded, decoded_len, max++); - if (Z_OK == (status = inflateInit2(&Z, -MAX_WBITS))) { - if (Z_STREAM_END == (status = inflate(&Z, Z_FINISH))) { - if (Z_OK == (status = inflateEnd(&Z))) { - *decoded_len = http_finish_buffer(Z.total_out, decoded); - return SUCCESS; - } + if (HTTP_G->send.deflate.stream) { + http_encoding_deflate_stream_update((http_encoding_stream *) HTTP_G->send.deflate.stream, output, output_len, handled_output, handled_output_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); } } - } while (max < HTTP_GZMAXTRY && status == Z_BUF_ERROR); - - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not inflate data: %s", zError(status)); - return FAILURE; + } else { +deflate_passthru_plain: + *handled_output = estrndup(output, *handled_output_len = output_len); + } } +/* }}} */ -PHP_HTTP_API STATUS _http_encoding_uncompress(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC) +/* {{{ 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) { - int max = 0; - STATUS status; - size_t want = data_len * 2; - - *decoded = emalloc(want + 1); - if (Z_BUF_ERROR == (status = uncompress(*decoded, &want, data, data_len))) do { - /* this is a lot faster with large data than gzuncompress(), - but could be a problem with a low memory limit */ - want <<= 2; - *decoded = erealloc(*decoded, want + 1); - status = uncompress(*decoded, &want, data, data_len); - } while (++max < HTTP_GZMAXTRY && status == Z_BUF_ERROR); + *handled_output = NULL; + *handled_output_len = 0; - if (Z_OK == status) { - *decoded_len = http_finish_buffer(want, decoded); - return SUCCESS; + 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)); } - efree(*decoded); - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not uncompress data: %s", zError(status)); - return FAILURE; + if (HTTP_G->send.inflate.stream) { + http_encoding_inflate_stream_update((http_encoding_stream *) HTTP_G->send.inflate.stream, output, output_len, handled_output, handled_output_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); + } } +/* }}} */ #endif /* HTTP_HAVE_ZLIB */