X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-http;a=blobdiff_plain;f=http_encoding_api.c;h=f896be4ca8f57c701e5e7712f211934b0389e776;hp=eecbbab5dad9650ac4107fa37034c8d7e1ed5c3f;hb=7b88d9022c90eb12e5fe195af8644935141c9d68;hpb=8009e79e3a7b10eea99bb8534ff96189ffa281b5 diff --git a/http_encoding_api.c b/http_encoding_api.c index eecbbab..f896be4 100644 --- a/http_encoding_api.c +++ b/http_encoding_api.c @@ -15,19 +15,54 @@ #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 -# include "php_http_send_api.h" -# include "php_http_headers_api.h" -# include -#endif +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); + return SUCCESS; +} -ZEND_EXTERN_MODULE_GLOBALS(http); +PHP_RINIT_FUNCTION(http_encoding) +{ + if (HTTP_G(send).inflate.start_auto) { + php_ob_set_internal_handler(_http_ob_inflatehandler, 0x1000, "http inflate", 0 TSRMLS_CC); + } + if (HTTP_G(send).deflate.start_auto) { + php_ob_set_internal_handler(_http_ob_deflatehandler, 0x8000, "http deflate", 0 TSRMLS_CC); + } + return SUCCESS; +} + +PHP_RSHUTDOWN_FUNCTION(http_encoding) +{ + if (G->send.deflate.stream) { + http_encoding_deflate_stream_free((http_encoding_stream **) &G->send.deflate.stream); + } + if (G->send.inflate.stream) { + http_encoding_inflate_stream_free((http_encoding_stream **) &G->send.inflate.stream); + } + return SUCCESS; +} +#endif static inline int eol_match(char **line, int *eol_len) { @@ -79,6 +114,8 @@ PHP_HTTP_API const char *_http_encoding_dechunk(const char *encoded, size_t enco /* reached the end */ if (!chunk_len) { + /* move over '0' chunked encoding terminator */ + while (*e_ptr == '0') ++e_ptr; break; } @@ -117,111 +154,589 @@ 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, // no MTIME available (4 bytes) - (const char) 0, // =*= - (const char) 0, // =*= - (const char) 0, // =*= - (const char) 0, // two possible flag values for 9 compression levels? o_O - (const char) 0x03 // assume *nix OS -}; +#define HTTP_DEFLATE_LEVEL_SET(flags, level) \ + switch (flags & 0xf) \ + { \ + default: \ + if ((flags & 0xf) < 10) { \ + level = flags & 0xf; \ + break; \ + } \ + case HTTP_DEFLATE_LEVEL_DEF: \ + level = Z_DEFAULT_COMPRESSION; \ + break; \ + } + +#define HTTP_DEFLATE_WBITS_SET(flags, wbits) \ + switch (flags & 0xf0) \ + { \ + case HTTP_DEFLATE_TYPE_GZIP: \ + wbits = HTTP_WINDOW_BITS_GZIP; \ + break; \ + case HTTP_DEFLATE_TYPE_RAW: \ + wbits = HTTP_WINDOW_BITS_RAW; \ + break; \ + default: \ + wbits = HTTP_WINDOW_BITS_ZLIB; \ + break; \ + } -inline void http_init_gzencode_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr) +#define HTTP_INFLATE_WBITS_SET(flags, wbits) \ + if (flags & HTTP_INFLATE_TYPE_RAW) { \ + wbits = HTTP_WINDOW_BITS_RAW; \ + } else { \ + wbits = HTTP_WINDOW_BITS_ANY; \ + } + +#define HTTP_DEFLATE_STRATEGY_SET(flags, strategy) \ + switch (flags & 0xf00) \ + { \ + case HTTP_DEFLATE_STRATEGY_FILT: \ + strategy = Z_FILTERED; \ + break; \ + case HTTP_DEFLATE_STRATEGY_HUFF: \ + strategy = Z_HUFFMAN_ONLY; \ + break; \ + case HTTP_DEFLATE_STRATEGY_RLE: \ + strategy = Z_RLE; \ + break; \ + case HTTP_DEFLATE_STRATEGY_FIXED: \ + strategy = Z_FIXED; \ + break; \ + default: \ + strategy = Z_DEFAULT_STRATEGY; \ + break; \ + } + +#define HTTP_WINDOW_BITS_ZLIB 0x0000000f +#define HTTP_WINDOW_BITS_GZIP 0x0000001f +#define HTTP_WINDOW_BITS_ANY 0x0000002f +#define HTTP_WINDOW_BITS_RAW -0x000000f + +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; - Z->next_in = (Bytef *) data; - Z->avail_in = data_len; - Z->avail_out = HTTP_ENCODING_BUFLEN(data_len) + HTTP_ENCODING_SAFPAD - 1; + HTTP_DEFLATE_LEVEL_SET(flags, level); + HTTP_DEFLATE_WBITS_SET(flags, wbits); + HTTP_DEFLATE_STRATEGY_SET(flags, strategy); - *buf_ptr = emalloc(HTTP_ENCODING_BUFLEN(data_len) + sizeof(http_encoding_gzip_header) + HTTP_ENCODING_SAFPAD); - memcpy(*buf_ptr, http_encoding_gzip_header, sizeof(http_encoding_gzip_header)); + memset(&Z, 0, sizeof(z_stream)); + *encoded = NULL; + *encoded_len = 0; - Z->next_out = (Bytef *) *buf_ptr + sizeof(http_encoding_gzip_header); + status = deflateInit2(&Z, level, Z_DEFLATED, wbits, MAX_MEM_LEVEL, strategy); + if (Z_OK == status) { + *encoded_len = HTTP_ENCODING_BUFLEN(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 (%s)", zError(status)); + return FAILURE; } -inline void http_init_deflate_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr) +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->zalloc = Z_NULL; - Z->zfree = Z_NULL; - Z->opaque = Z_NULL; + int status, max = 0, wbits = HTTP_WINDOW_BITS_ANY; + z_stream Z; + phpstr buffer; + + memset(&Z, 0, sizeof(z_stream)); + *decoded = NULL; + *decoded_len = 0; + + phpstr_init_ex(&buffer, data_len << 2, PHPSTR_INIT_PREALLOC); + buffer.size = data_len; + +retry_inflate: + status = inflateInit2(&Z, wbits); + if (Z_OK == status) { + Z.next_in = (Bytef *) data; + Z.avail_in = data_len; + + do { + phpstr_resize(&buffer, data_len << 2); + + do { + Z.avail_out = (buffer.free -= Z.total_out - buffer.used); + Z.next_out = (Bytef *) buffer.data + (buffer.used = Z.total_out); + status = inflate(&Z, Z_NO_FLUSH); + } while (Z_OK == status); + } while (Z_BUF_ERROR == status && ++max < HTTP_ENCODING_MAXTRY); + + if (Z_DATA_ERROR == status && HTTP_WINDOW_BITS_ANY == wbits) { + /* raw deflated data? */ + inflateEnd(&Z); + wbits = HTTP_WINDOW_BITS_RAW; + goto retry_inflate; + } + + inflateEnd(&Z); + + if (Z_STREAM_END == status) { + *decoded_len = Z.total_out; + *decoded = erealloc_rel(buffer.data, *decoded_len + 1); + (*decoded)[*decoded_len] = '\0'; + return SUCCESS; + } else { + phpstr_dtor(&buffer); + } + } + + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not inflate 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_ENCODING_BUFLEN(data_len) - 1; - Z->next_out = emalloc(HTTP_ENCODING_BUFLEN(data_len)); +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) +{ + int status, level, wbits, strategy, 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_DEFLATE_LEVEL_SET(flags, level); + HTTP_DEFLATE_WBITS_SET(flags, wbits); + HTTP_DEFLATE_STRATEGY_SET(flags, strategy); - *buf_ptr = (char *) Z->next_out; + 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, 0x8000, 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 void http_init_uncompress_buffer(size_t data_len, char **buf_ptr, size_t *buf_len, int *iteration) +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) { - if (!*iteration) { - *buf_len = data_len * 2; - *buf_ptr = emalloc(*buf_len + 1); - } else { - size_t new_len = *buf_len << 2; - char *new_ptr = erealloc_recoverable(*buf_ptr, new_len + 1); + 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 (new_ptr) { - *buf_ptr = new_ptr; - *buf_len = new_len; - } else { - *iteration = INT_MAX-1; /* avoid integer overflow on increment op */ + if ((s->stream.opaque = phpstr_init_ex(NULL, 0x8000, 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; +} + +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_ENCODING_BUFLEN(data_len); + *encoded = emalloc_rel(*encoded_len); + s->stream.avail_out = *encoded_len; + s->stream.next_out = (Bytef *) *encoded; + + switch (status = deflate(&s->stream, Z_NO_FLUSH)) + { + case Z_OK: + case Z_STREAM_END: + /* cut processed chunk off the buffer */ + phpstr_cut(PHPSTR(s->stream.opaque), 0, data_len - s->stream.avail_in); + + /* 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; + } + + 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_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, max = 0; + + /* append input to buffer */ + phpstr_append(PHPSTR(s->stream.opaque), data, data_len); + + /* for realloc() */ + *decoded = NULL; + *decoded_len = data_len << 1; + + /* inflate */ + do { + *decoded_len <<= 1; + *decoded = erealloc_rel(*decoded, *decoded_len); + +retry_raw_inflate: + s->stream.next_in = (Bytef *) PHPSTR_VAL(s->stream.opaque); + s->stream.avail_in = PHPSTR_LEN(s->stream.opaque); + + s->stream.next_out = (Bytef *) *decoded; + s->stream.avail_out = *decoded_len; + + switch (status = inflate(&s->stream, Z_NO_FLUSH)) + { + case Z_OK: + case Z_STREAM_END: + /* cut off */ + phpstr_cut(PHPSTR(s->stream.opaque), 0, data_len - 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; + 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; } + } while (Z_BUF_ERROR == status && ++max < HTTP_ENCODING_MAXTRY); + + STR_SET(*decoded, NULL); + *decoded_len = 0; + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to update inflate stream: %s", zError(status)); + return FAILURE; +} + +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) +{ + int status; + + *encoded_len = 0x800; + *encoded = emalloc_rel(*encoded_len); + + 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_SYNC_FLUSH)) + { + case Z_OK: + case Z_STREAM_END: + *encoded_len = 0x800 - s->stream.avail_out; + *encoded = erealloc_rel(*encoded, *encoded_len + 1); + (*encoded)[*encoded_len] = '\0'; + return SUCCESS; + break; } + + 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; } -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) +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->zalloc = Z_NULL; - Z->zfree = Z_NULL; + int status; + + *decoded_len = 0x800; + *decoded = emalloc_rel(*decoded_len); - http_init_uncompress_buffer(data_len, buf_ptr, buf_len, iteration); + s->stream.avail_in = 0; + s->stream.next_in = NULL; + s->stream.avail_out = *decoded_len; + s->stream.next_out = (Bytef *) *decoded; - Z->next_in = (Bytef *) data; - Z->avail_in = data_len; - Z->avail_out = *buf_len; - Z->next_out = (Bytef *) *buf_ptr; + switch (status = inflate(&s->stream, Z_SYNC_FLUSH)) + { + case Z_OK: + case Z_STREAM_END: + *decoded_len = 0x800 - s->stream.avail_out; + *decoded = erealloc_rel(*decoded, *decoded_len + 1); + (*decoded)[*decoded_len] = '\0'; + return SUCCESS; + break; + } + + STR_SET(*decoded, NULL); + *decoded_len = 0; + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to flush inflate stream: %s", zError(status)); + return FAILURE; } -inline size_t http_finish_buffer(size_t buf_len, char **buf_ptr) +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) { - (*buf_ptr)[buf_len] = '\0'; - return buf_len; + int status; + + *encoded_len = 0x800; + *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); + + s->stream.avail_out = *encoded_len; + s->stream.next_out = (Bytef *) *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; + } + + 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; } -inline size_t http_finish_gzencode_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr) +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) { - ulong crc; - char *trailer; + int status; - crc = crc32(0L, Z_NULL, 0); - crc = crc32(crc, (const Bytef *) data, data_len); + *decoded_len = s->stream.avail_in << 2; + *decoded = emalloc_rel(*decoded_len); - trailer = *buf_ptr + sizeof(http_encoding_gzip_header) + Z->total_out; + /* inflate remaining input */ + s->stream.next_in = (Bytef *) PHPSTR_VAL(s->stream.opaque); + s->stream.avail_in = PHPSTR_LEN(s->stream.opaque); - /* 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); + s->stream.avail_out = *decoded_len; + s->stream.next_out = (Bytef *) *decoded; - return http_finish_buffer(Z->total_out + sizeof(http_encoding_gzip_header) + 8, buf_ptr); + 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; + } + + 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; } -inline STATUS http_verify_gzencode_buffer(const char *data, size_t data_len, const char **encoded, size_t *encoded_len, int error_level TSRMLS_DC) +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); + } +} + +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 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; + } +} + +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 *output, uint output_len, char **handled_output, uint *handled_output_len, int mode TSRMLS_DC) +{ + getGlobals(G); + + *handled_output = NULL; + *handled_output_len = 0; + + if (mode & PHP_OUTPUT_HANDLER_START) { + int flags; + + if (G->send.deflate.stream) { + zend_error(E_ERROR, "ob_deflatehandler() can only be used once"); + return; + } + + G->send.deflate.encoding = !0; + + switch (http_encoding_response_start(0)) + { + case HTTP_ENCODING_GZIP: + flags = HTTP_DEFLATE_TYPE_GZIP; + break; + + case HTTP_ENCODING_DEFLATE: + flags = HTTP_DEFLATE_TYPE_ZLIB; + break; + + default: + goto deflate_passthru_plain; + break; + } + + flags |= (G->send.deflate.start_flags &~ 0xf); + G->send.deflate.stream = http_encoding_deflate_stream_init(NULL, flags); + } + + if (G->send.deflate.stream) { + http_encoding_deflate_stream_update((http_encoding_stream *) 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 *) G->send.deflate.stream, &remaining, &remaining_len); + http_encoding_deflate_stream_free((http_encoding_stream **) &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 *output, uint output_len, char **handled_output, uint *handled_output_len, int mode TSRMLS_DC) +{ + getGlobals(G); + + *handled_output = NULL; + *handled_output_len = 0; + + if (mode & PHP_OUTPUT_HANDLER_START) { + if (G->send.inflate.stream) { + zend_error(E_ERROR, "ob_inflatehandler() can only be used once"); + return; + } + G->send.inflate.stream = http_encoding_inflate_stream_init(NULL, (HTTP_G(send).inflate.start_flags &~ 0xf)); + } + + if (G->send.inflate.stream) { + http_encoding_inflate_stream_update((http_encoding_stream *) 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 *) G->send.inflate.stream, &remaining, &remaining_len); + http_encoding_inflate_stream_free((http_encoding_stream **) &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); + } +} + +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_verify(const char *data, size_t data_len, const char **encoded, size_t *encoded_len, int error_level TSRMLS_DC) { size_t offset = sizeof(http_encoding_gzip_header); @@ -302,7 +817,7 @@ really_bad_gzip_header: return FAILURE; } -inline STATUS http_verify_gzdecode_buffer(const char *data, size_t data_len, const char *decoded, size_t decoded_len, int error_level TSRMLS_DC) +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 status = SUCCESS; ulong len, cmp, crc; @@ -330,276 +845,15 @@ inline STATUS http_verify_gzdecode_buffer(const char *data, size_t data_len, con return status; } -PHP_HTTP_API STATUS _http_encode(http_encoding_type type, int level, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC) -{ - STATUS status = SUCCESS; - - switch (type) - { - case HTTP_ENCODING_ANY: - case HTTP_ENCODING_GZIP: - status = http_encoding_gzencode(level, data, data_len, encoded, encoded_len); - break; - - case HTTP_ENCODING_DEFLATE: - status = http_encoding_deflate(level, data, data_len, encoded, encoded_len); - break; - - case HTTP_ENCODING_COMPRESS: - status = http_encoding_compress(level, data, data_len, encoded, encoded_len); - break; - - case HTTP_ENCODING_NONE: - default: - *encoded = estrndup(data, data_len); - *encoded_len = data_len; - break; - } - - return status; -} - -PHP_HTTP_API STATUS _http_decode(http_encoding_type type, const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC) -{ - STATUS status = SUCCESS; - - switch (type) - { - case HTTP_ENCODING_ANY: - if ( SUCCESS != http_encoding_gzdecode(data, data_len, decoded, decoded_len) && - SUCCESS != http_encoding_inflate(data, data_len, decoded, decoded_len) && - SUCCESS != http_encoding_uncompress(data, data_len, decoded, decoded_len)) { - status = FAILURE; - } - break; - - case HTTP_ENCODING_GZIP: - status = http_encoding_gzdecode(data, data_len, decoded, decoded_len); - break; - - case HTTP_ENCODING_DEFLATE: - status = http_encoding_inflate(data, data_len, decoded, decoded_len); - break; - - case HTTP_ENCODING_COMPRESS: - status = http_encoding_uncompress(data, data_len, decoded, decoded_len); - break; - - case HTTP_ENCODING_NONE: - default: - *decoded = estrndup(data, data_len); - *decoded_len = data_len; - break; - } - - return status; -} - -PHP_HTTP_API STATUS _http_encoding_gzencode(int level, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC) -{ - z_stream Z; - STATUS status = Z_OK; - - http_init_gzencode_buffer(&Z, data, data_len, 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_gzencode_buffer(&Z, data, data_len, encoded); - return SUCCESS; - } - - efree(*encoded); - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not gzencode data: %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) -{ - z_stream Z; - STATUS status = Z_OK; - - http_init_deflate_buffer(&Z, data, data_len, 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); - return SUCCESS; - } - - efree(encoded); - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not deflate data: %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 status; - - *encoded = emalloc(*encoded_len = HTTP_ENCODING_BUFLEN(data_len)); - - if (Z_OK == (status = compress2((Bytef *) *encoded, (uLongf *) encoded_len, (const Bytef *) data, data_len, level))) { - http_finish_buffer(*encoded_len, encoded); - return SUCCESS; - } - - efree(encoded); - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not compress data: %s", zError(status)); - return FAILURE; -} - -PHP_HTTP_API STATUS _http_encoding_gzdecode(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC) -{ - const char *encoded; - size_t encoded_len; - - if ( (SUCCESS == http_verify_gzencode_buffer(data, data_len, &encoded, &encoded_len, HE_NOTICE)) && - (SUCCESS == http_encoding_inflate(encoded, encoded_len, decoded, decoded_len))) { - http_verify_gzdecode_buffer(data, data_len, *decoded, *decoded_len, HE_NOTICE); - return SUCCESS; - } - - 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; - } - } - } - } while (++max < HTTP_ENCODING_MAXTRY && status == Z_BUF_ERROR); - - efree(*decoded); - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not inflate data: %s", zError(status)); - return FAILURE; -} - -PHP_HTTP_API STATUS _http_encoding_uncompress(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC) -{ - int max = 0; - STATUS status; - - do { - http_init_uncompress_buffer(data_len, decoded, decoded_len, &max); - if (Z_OK == (status = uncompress((Bytef *) *decoded, (uLongf *) decoded_len, (const Bytef *) data, data_len))) { - http_finish_buffer(*decoded_len, decoded); - return SUCCESS; - } - } while (++max < HTTP_ENCODING_MAXTRY && status == Z_BUF_ERROR); - - efree(*decoded); - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not uncompress data: %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 gzip, int level, char **encoded, size_t *encoded_len TSRMLS_DC) -{ - STATUS status; - - memset(s, 0, sizeof(http_encoding_stream)); - if (Z_OK != (status = deflateInit2(&s->Z, level, Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) { - HTTP_ENCODING_STREAM_ERROR(status, NULL); - } - - if (s->gzip = gzip) { - s->crc = crc32(0L, Z_NULL, 0); - *encoded_len = sizeof(http_encoding_gzip_header); - *encoded = emalloc(*encoded_len); - memcpy(*encoded, http_encoding_gzip_header, *encoded_len); - } else { - *encoded_len = 0; - *encoded = NULL; - } - - 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 status; - - *encoded_len = HTTP_ENCODING_BUFLEN(data_len); - *encoded = emalloc(*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; - - status = deflate(&s->Z, Z_SYNC_FLUSH); - - if (Z_OK != status && Z_STREAM_END != status) { - HTTP_ENCODING_STREAM_ERROR(status, *encoded); - } - *encoded_len -= s->Z.avail_out; - - if (s->gzip) { - s->crc = crc32(s->crc, (const Bytef *) data, data_len); - } - - return SUCCESS; -} - -PHP_HTTP_API STATUS _http_encoding_stream_finish(http_encoding_stream *s, char **encoded, size_t *encoded_len TSRMLS_DC) -{ - STATUS status; - - *encoded_len = 1024; - *encoded = emalloc(*encoded_len); - - s->Z.next_out = (Bytef *) *encoded; - s->Z.avail_out = *encoded_len; - - if (Z_STREAM_END != (status = deflate(&s->Z, Z_FINISH)) || Z_OK != (status = deflateEnd(&s->Z))) { - HTTP_ENCODING_STREAM_ERROR(status, *encoded); - } - - *encoded_len -= s->Z.avail_out; - if (s->gzip) { - if (s->Z.avail_out < 8) { - *encoded = erealloc(*encoded, *encoded_len + 8); - } - (*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); - } - - return SUCCESS; -} - #endif /* HTTP_HAVE_ZLIB */ -PHP_HTTP_API zend_bool _http_encoding_response_start(size_t content_length TSRMLS_DC) +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).gzip_encoding = 0; + HTTP_G(send).deflate.encoding = 0; } else { - if (!HTTP_G(send).gzip_encoding) { + if (!HTTP_G(send).deflate.encoding) { /* emit a content-length header */ if (content_length) { char cl_header_str[128]; @@ -609,7 +863,7 @@ PHP_HTTP_API zend_bool _http_encoding_response_start(size_t content_length TSRML } } else { #ifndef HTTP_HAVE_ZLIB - HTTP_G(send).gzip_encoding = 0; + HTTP_G(send).deflate.encoding = 0; php_start_ob_buffer_named("ob_gzhandler", 0, 0 TSRMLS_CC); #else HashTable *selected; @@ -618,23 +872,24 @@ PHP_HTTP_API zend_bool _http_encoding_response_start(size_t content_length TSRML 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).gzip_encoding = 0; + HTTP_G(send).deflate.encoding = 0; - if (selected = http_negotiate_encoding(&zsupported)) { + 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")) { + 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; + 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).gzip_encoding = HTTP_ENCODING_DEFLATE; + HTTP_G(send).deflate.encoding = HTTP_ENCODING_DEFLATE; } } if (SUCCESS == hs) { @@ -647,7 +902,7 @@ PHP_HTTP_API zend_bool _http_encoding_response_start(size_t content_length TSRML } zval_dtor(&zsupported); - return HTTP_G(send).gzip_encoding; + return HTTP_G(send).deflate.encoding; #endif } }