X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-http;a=blobdiff_plain;f=http_encoding_api.c;h=a31b5b79772cc0533c2af23274674cdb158db89d;hp=bff322882ae8c25dbf4566b8f83c95db324bbaa3;hb=f0bcc141e62c022101d8d19c1d73e7b9ae41d0e9;hpb=4e4645f7a6e147eb1b4cab1a25176a7ea3f8db0d diff --git a/http_encoding_api.c b/http_encoding_api.c index bff3228..a31b5b7 100644 --- a/http_encoding_api.c +++ b/http_encoding_api.c @@ -15,6 +15,8 @@ #ifdef HAVE_CONFIG_H # include "config.h" #endif + +#define HTTP_WANT_ZLIB #include "php_http.h" #include "php_http_api.h" @@ -22,7 +24,49 @@ #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); + return SUCCESS; +} + +PHP_RINIT_FUNCTION(http_encoding) +{ + getGlobals(G); + + if (G->send.inflate.start_auto) { + php_ob_set_internal_handler(_http_ob_inflatehandler, 0x1000, "http inflate", 0 TSRMLS_CC); + } + if (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) +{ + getGlobals(G); + + 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) { @@ -114,184 +158,566 @@ 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 -}; +#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; \ + } + +#define HTTP_INFLATE_WBITS_SET(flags, wbits) \ + if (flags & HTTP_INFLATE_TYPE_RAW) { \ + wbits = HTTP_WINDOW_BITS_RAW; \ + } else { \ + wbits = HTTP_WINDOW_BITS_ANY; \ + } -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) +#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) { + int status, level, wbits, strategy; z_stream Z; - STATUS status = Z_OK; - if (!(data && data_len)) { - return FAILURE; + 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_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; +} + +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 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); + } } - Z.zalloc = Z_NULL; - Z.zfree = Z_NULL; - Z.opaque = Z_NULL; - Z.next_in = (Bytef *) data; - Z.avail_in = data_len; - Z.avail_out = HTTP_ENCODING_BUFLEN(data_len) + HTTP_ENCODING_SAFPAD - 1; + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not inflate data: %s", zError(status)); + return FAILURE; +} + + +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; - *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)); + 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 (mtime) { - (*encoded)[4] = (char) (mtime & 0xFF); - (*encoded)[5] = (char) ((mtime >> 8) & 0xFF); - (*encoded)[6] = (char) ((mtime >> 16) & 0xFF); - (*encoded)[7] = (char) ((mtime >> 24) & 0xFF); + HTTP_DEFLATE_LEVEL_SET(flags, level); + HTTP_DEFLATE_WBITS_SET(flags, wbits); + HTTP_DEFLATE_STRATEGY_SET(flags, strategy); + + 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; } - Z.next_out = (Bytef *) *encoded + sizeof(http_encoding_gzip_header); + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to initialize deflate encoding stream: %s", zError(status)); + if (free_stream) { + efree(s); + } + return NULL; +} + +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 (Z_OK == (status = deflateInit2(&Z, level, Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) { - status = deflate(&Z, Z_FINISH); - deflateEnd(&Z); + 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 (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; - - /* 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 ((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, PHPSTR_LEN(s->stream.opaque) - s->stream.avail_in); - *encoded_len = Z.total_out + sizeof(http_encoding_gzip_header) + 8; + /* 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, 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; + 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; } - 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_gzdecode(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC) +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_deflate_stream_finish(http_encoding_stream *s, char **encoded, size_t *encoded_len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC TSRMLS_DC) { - const char *encoded; - size_t encoded_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); - 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); + 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; } -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) +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) { - z_stream Z; - STATUS status = Z_OK; + int status; - Z.zalloc = Z_NULL; - Z.zfree = Z_NULL; - Z.opaque = Z_NULL; - 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)); + *decoded_len = s->stream.avail_in << 2; + *decoded = emalloc_rel(*decoded_len); - *encoded = (char *) Z.next_out; + /* inflate remaining input */ + s->stream.next_in = (Bytef *) PHPSTR_VAL(s->stream.opaque); + s->stream.avail_in = PHPSTR_LEN(s->stream.opaque); - if (Z_OK == (status = deflateInit2(&Z, level, Z_DEFLATED, zhdr ? MAX_WBITS : -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) { - status = deflate(&Z, Z_FINISH); - deflateEnd(&Z); + 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); - if (Z_STREAM_END == status) { - (*encoded)[*encoded_len = Z.total_out] = '\0'; - return SUCCESS; - } + /* 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 deflate 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; } -PHP_HTTP_API STATUS _http_encoding_inflate(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC) +PHP_HTTP_API void _http_encoding_deflate_stream_dtor(http_encoding_stream *s TSRMLS_DC) { - int max = 0, wbits = -MAX_WBITS; - STATUS status; - z_stream Z; + 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); - do { - Z.zalloc = Z_NULL; - Z.zfree = Z_NULL; + *handled_output = NULL; + *handled_output_len = 0; + + if (mode & PHP_OUTPUT_HANDLER_START) { + int flags; - 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 (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; - if (new_ptr) { - *decoded = new_ptr; - *decoded_len = new_len; - } else { - max = INT_MAX-1; /* avoid integer overflow on increment op */ - } + case HTTP_ENCODING_DEFLATE: + flags = HTTP_DEFLATE_TYPE_ZLIB; + break; + + default: + goto deflate_passthru_plain; + break; } -retry_inflate: - Z.next_in = (Bytef *) data; - Z.avail_in = data_len; - Z.next_out = (Bytef *) *decoded; - Z.avail_out = *decoded_len; + flags |= (G->send.deflate.start_flags &~ 0xf0); + 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 (Z_OK == (status = inflateInit2(&Z, wbits))) { - status = inflate(&Z, Z_FINISH); - inflateEnd(&Z); + if (mode & PHP_OUTPUT_HANDLER_END) { + char *remaining = NULL; + size_t remaining_len = 0; - /* 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; + 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 &~ 0xf0)); + } + + 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; - if (Z_STREAM_END == status) { - (*decoded)[*decoded_len = Z.total_out] = '\0'; - return SUCCESS; + 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); } } - } while (status == Z_BUF_ERROR && ++max < HTTP_ENCODING_MAXTRY); - - efree(*decoded); - http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not inflate data: %s", zError(status)); - return FAILURE; + } 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); @@ -401,102 +827,15 @@ PHP_HTTP_API STATUS _http_encoding_gzdecode_verify(const char *data, size_t data return status; } -#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]; @@ -506,7 +845,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; @@ -515,9 +854,10 @@ 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))) { STATUS hs = FAILURE; @@ -525,13 +865,13 @@ PHP_HTTP_API zend_bool _http_encoding_response_start(size_t content_length TSRML 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) { @@ -544,7 +884,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 } }