From: Michael Wallner Date: Tue, 13 Dec 2005 22:16:03 +0000 (+0000) Subject: - remove http_compress() and http_uncompress() (deflate/inflate ambiguity) X-Git-Tag: RELEASE_0_20_0~11 X-Git-Url: https://git.m6w6.name/?a=commitdiff_plain;h=eabc03de1d511ce49640322859c6175f27a413e5;p=m6w6%2Fext-http - remove http_compress() and http_uncompress() (deflate/inflate ambiguity) - fix issues with deflated response messages --- diff --git a/http.c b/http.c index 97587f8..6fc1af9 100644 --- a/http.c +++ b/http.c @@ -107,8 +107,6 @@ zend_function_entry http_functions[] = { PHP_FE(http_gzdecode, NULL) PHP_FE(http_deflate, NULL) PHP_FE(http_inflate, NULL) - PHP_FE(http_compress, NULL) - PHP_FE(http_uncompress, NULL) #endif PHP_FE(http_support, NULL) diff --git a/http_encoding_api.c b/http_encoding_api.c index d3529d1..6c0d415 100644 --- a/http_encoding_api.c +++ b/http_encoding_api.c @@ -119,106 +119,185 @@ static const char http_encoding_gzip_header[] = { (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, // MTIME (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 +#ifdef PHP_WIN32 + (const char) 0x0b // OS_CODE +#else + (const char) 0x03 // OS_CODE +#endif }; -inline void http_init_gzencode_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr) +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) { - Z->zalloc = Z_NULL; - Z->zfree = Z_NULL; - Z->opaque = Z_NULL; + z_stream Z; + STATUS status = Z_OK; - Z->next_in = (Bytef *) data; - Z->avail_in = data_len; - Z->avail_out = HTTP_ENCODING_BUFLEN(data_len) + HTTP_ENCODING_SAFPAD - 1; + if (!(data && data_len)) { + return FAILURE; + } - *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)); + 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; + + *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 (mtime) { + (*encoded)[4] = (char) (mtime & 0xFF); + (*encoded)[5] = (char) ((mtime >> 8) & 0xFF); + (*encoded)[6] = (char) ((mtime >> 16) & 0xFF); + (*encoded)[7] = (char) ((mtime >> 24) & 0xFF); + } - Z->next_out = (Bytef *) *buf_ptr + sizeof(http_encoding_gzip_header); -} - -inline void http_init_deflate_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr) -{ - 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)); + Z.next_out = (Bytef *) *encoded + sizeof(http_encoding_gzip_header); - *buf_ptr = (char *) Z->next_out; -} - -inline void http_init_uncompress_buffer(size_t data_len, char **buf_ptr, size_t *buf_len, int *iteration) -{ - 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); + 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 (new_ptr) { - *buf_ptr = new_ptr; - *buf_len = new_len; - } else { - *iteration = INT_MAX-1; /* avoid integer overflow on increment op */ + 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); + + *encoded_len = Z.total_out + sizeof(http_encoding_gzip_header) + 8; + (*encoded)[*encoded_len] = '\0'; + return SUCCESS; } } + + efree(*encoded); + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not gzencode 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) +PHP_HTTP_API STATUS _http_encoding_gzdecode(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC) { - Z->zalloc = Z_NULL; - Z->zfree = Z_NULL; + const char *encoded; + size_t encoded_len; - http_init_uncompress_buffer(data_len, buf_ptr, buf_len, iteration); + if ( (data && data_len) && + (SUCCESS == http_encoding_gzencode_verify(data, data_len, &encoded, &encoded_len)) && + (SUCCESS == http_encoding_inflate(encoded, encoded_len, decoded, decoded_len))) { + http_encoding_gzdecode_verify(data, data_len, *decoded, *decoded_len); + return SUCCESS; + } - Z->next_in = (Bytef *) data; - Z->avail_in = data_len; - Z->avail_out = *buf_len; - Z->next_out = (Bytef *) *buf_ptr; + return FAILURE; } -inline size_t http_finish_buffer(size_t buf_len, char **buf_ptr) +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) { - (*buf_ptr)[buf_len] = '\0'; - return buf_len; + z_stream Z; + STATUS status = Z_OK; + + 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)); + + *encoded = (char *) Z.next_out; + + if (Z_OK == (status = deflateInit2(&Z, level, Z_DEFLATED, zhdr ? MAX_WBITS : -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) { + status = deflate(&Z, Z_FINISH); + deflateEnd(&Z); + + if (Z_STREAM_END == status) { + (*encoded)[*encoded_len = Z.total_out] = '\0'; + return SUCCESS; + } + } + + efree(encoded); + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not deflate data: %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(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC) { - ulong crc; - char *trailer; - - crc = crc32(0L, Z_NULL, 0); - crc = crc32(crc, (const Bytef *) data, data_len); + int max = 0, wbits = -MAX_WBITS; + STATUS status; + z_stream Z; - trailer = *buf_ptr + sizeof(http_encoding_gzip_header) + Z->total_out; + *decoded = NULL; + *decoded_len = 0; - /* 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); +retry_inflate: + do { + Z.zalloc = Z_NULL; + Z.zfree = Z_NULL; + + if (!max) { + if (!*decoded) { + *decoded_len = data_len * 2; + *decoded = emalloc(*decoded_len + 1); + } + } else { + size_t new_len = *decoded_len << 2; + char *new_ptr = erealloc_recoverable(*decoded, new_len + 1); + + if (new_ptr) { + *decoded = new_ptr; + *decoded_len = new_len; + } else { + max = INT_MAX-1; /* avoid integer overflow on increment op */ + } + } + + Z.next_in = (Bytef *) data; + Z.avail_in = data_len; + Z.next_out = (Bytef *) *decoded; + Z.avail_out = *decoded_len; + + if (Z_OK == (status = inflateInit2(&Z, wbits))) { + status = inflate(&Z, Z_FINISH); + inflateEnd(&Z); + + /* retry if it looks like we've got a zlib header */ + if (wbits == -MAX_WBITS && status == Z_DATA_ERROR) { + wbits = MAX_WBITS; + goto retry_inflate; + } + + if (Z_STREAM_END == status) { + (*decoded)[*decoded_len = Z.total_out] = '\0'; + return SUCCESS; + } + } + } while (status == Z_BUF_ERROR && ++max < HTTP_ENCODING_MAXTRY); - return http_finish_buffer(Z->total_out + sizeof(http_encoding_gzip_header) + 8, buf_ptr); + efree(*decoded); + http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not inflate data: %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 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); @@ -299,7 +378,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; @@ -327,187 +406,6 @@ 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))) { - status = deflate(&Z, Z_FINISH); - deflateEnd(&Z); - - if (Z_STREAM_END == status) { - *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))) { - status = deflate(&Z, Z_FINISH); - deflateEnd(&Z); - - if (Z_STREAM_END == status) { - *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))) { - status = inflate(&Z, Z_FINISH); - inflateEnd(&Z); - - if (Z_STREAM_END == status) { - *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); \ diff --git a/http_functions.c b/http_functions.c index 279e4ea..424a6bd 100644 --- a/http_functions.c +++ b/http_functions.c @@ -1495,7 +1495,7 @@ PHP_FUNCTION(http_build_query) /* {{{ */ #ifdef HTTP_HAVE_ZLIB -/* {{{ proto string http_gzencode(string data[, int level = -1]) +/* {{{ proto string http_gzencode(string data[, int level = -1[, int mtime = 0]]) * * Compress data with the HTTP compatible GZIP encoding. * @@ -1510,17 +1510,17 @@ PHP_FUNCTION(http_gzencode) { char *data; int data_len; - long level = -1; + long level = -1, mtime = 0; RETVAL_NULL(); - if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &data, &data_len, &level)) { + if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &data, &data_len, &level, &mtime)) { HTTP_CHECK_GZIP_LEVEL(level, return); { char *encoded; size_t encoded_len; - if (SUCCESS == http_encoding_gzencode(level, data, data_len, &encoded, &encoded_len)) { + if (SUCCESS == http_encoding_gzencode(level, mtime, data, data_len, &encoded, &encoded_len)) { RETURN_STRINGL(encoded, (int) encoded_len, 0); } } @@ -1554,7 +1554,7 @@ PHP_FUNCTION(http_gzdecode) } /* }}} */ -/* {{{ proto string http_deflate(string data[, int level = -1]) +/* {{{ proto string http_deflate(string data[, int level = -1[, bool zlib_header = false]]) * * Compress data with the HTTP compatible DEFLATE encoding. * @@ -1570,16 +1570,17 @@ PHP_FUNCTION(http_deflate) char *data; int data_len; long level = -1; + zend_bool zhdr = 0; RETVAL_NULL(); - if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &data, &data_len, &level)) { + if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lb", &data, &data_len, &level, &zhdr)) { HTTP_CHECK_GZIP_LEVEL(level, return); { char *encoded; size_t encoded_len; - if (SUCCESS == http_encoding_deflate(level, data, data_len, &encoded, &encoded_len)) { + if (SUCCESS == http_encoding_deflate(level, zhdr, data, data_len, &encoded, &encoded_len)) { RETURN_STRINGL(encoded, (int) encoded_len, 0); } } @@ -1613,64 +1614,6 @@ PHP_FUNCTION(http_inflate) } /* }}} */ -/* {{{ proto string http_compress(string data[, int level = -1]) - * - * Compress data with the HTTP compatible COMPRESS encoding. - * - * Expects the first parameter to be a string containing the data which should - * be encoded. Additionally accepts an optional int parameter specifying the - * compression level, where -1 is default, 0 is no compression and 9 is best - * compression ratio. - * - * Returns the encoded string on success, or NULL on failure. - */ -PHP_FUNCTION(http_compress) -{ - char *data; - int data_len; - long level = -1; - - RETVAL_NULL(); - - if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &data, &data_len, &level)) { - HTTP_CHECK_GZIP_LEVEL(level, return); - { - char *encoded; - size_t encoded_len; - - if (SUCCESS == http_encoding_compress(level, data, data_len, &encoded, &encoded_len)) { - RETURN_STRINGL(encoded, (int) encoded_len, 0); - } - } - } -} -/* }}} */ - -/* {{{ proto string http_uncompress(string data) - * - * Uncompress data compressed with the HTTP compatible COMPRESS encoding. - * - * Expects a string as parameter containing the compressed data. - * - * Returns the decoded string on success, or NULL on failure. - */ -PHP_FUNCTION(http_uncompress) -{ - char *data; - int data_len; - - RETVAL_NULL(); - - if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &data, &data_len)) { - char *decoded; - size_t decoded_len; - - if (SUCCESS == http_encoding_uncompress(data, data_len, &decoded, &decoded_len)) { - RETURN_STRINGL(decoded, (int) decoded_len, 0); - } - } -} -/* }}} */ #endif /* HTTP_HAVE_ZLIB */ /* }}} */ diff --git a/http_message_api.c b/http_message_api.c index 65aeaf2..2a7a1eb 100644 --- a/http_message_api.c +++ b/http_message_api.c @@ -250,22 +250,12 @@ PHP_HTTP_API http_message *_http_message_parse_ex(http_message *msg, const char } if (!strcasecmp(Z_STRVAL_P(c), "gzip") || !strcasecmp(Z_STRVAL_P(c), "x-gzip")) { -# ifdef HTTP_HAVE_ZLIB - http_encoding_gzdecode(PHPSTR_VAL(msg), PHPSTR_LEN(msg), &decoded, &decoded_len); -# else +# ifndef HTTP_HAVE_ZLIB DECODE_WITH_EXT_ZLIB("gzinflate", PHPSTR_VAL(msg) + 10, PHPSTR_LEN(msg) - 18); -# endif /* HTTP_HAVE_ZLIB */ - } else if (!strcasecmp(Z_STRVAL_P(c), "deflate")) { -# ifdef HTTP_HAVE_ZLIB - http_encoding_inflate(PHPSTR_VAL(msg), PHPSTR_LEN(msg), &decoded, &decoded_len); # else - DECODE_WITH_EXT_ZLIB("gzinflate", PHPSTR_VAL(msg), PHPSTR_LEN(msg)); -# endif /* HTTP_HAVE_ZLIB */ - } else if (!strcasecmp(Z_STRVAL_P(c), "compress") || !strcasecmp(Z_STRVAL_P(c), "x-compress")) { -# ifdef HTTP_HAVE_ZLIB - http_encoding_uncompress(PHPSTR_VAL(msg), PHPSTR_LEN(msg), &decoded, &decoded_len); -# else - DECODE_WITH_EXT_ZLIB("gzuncompress", PHPSTR_VAL(msg), PHPSTR_LEN(msg)); + http_encoding_gzdecode(PHPSTR_VAL(msg), PHPSTR_LEN(msg), &decoded, &decoded_len); + } else if (!strcasecmp(Z_STRVAL_P(c), "deflate") || !strcasecmp(Z_STRVAL_P(c), "compress") || !strcasecmp(Z_STRVAL_P(c), "x-compress")) { + http_encoding_inflate(PHPSTR_VAL(msg), PHPSTR_LEN(msg), &decoded, &decoded_len); # endif /* HTTP_HAVE_ZLIB */ } diff --git a/http_util_object.c b/http_util_object.c index b2fa5c5..b1ad7c7 100644 --- a/http_util_object.c +++ b/http_util_object.c @@ -85,6 +85,7 @@ HTTP_END_ARGS; HTTP_BEGIN_ARGS(gzEncode, 1) HTTP_ARG_VAL(plain, 0) HTTP_ARG_VAL(level, 0) + HTTP_ARG_VAL(mtime, 0) HTTP_END_ARGS; HTTP_BEGIN_ARGS(gzDecode, 1) @@ -94,21 +95,13 @@ HTTP_END_ARGS; HTTP_BEGIN_ARGS(deflate, 1) HTTP_ARG_VAL(plain, 0) HTTP_ARG_VAL(level, 0) + HTTP_ARG_VAL(zlib_header, 0) HTTP_END_ARGS; HTTP_BEGIN_ARGS(inflate, 1) HTTP_ARG_VAL(encoded, 0) HTTP_END_ARGS; -HTTP_BEGIN_ARGS(compress, 1) - HTTP_ARG_VAL(plain, 0) - HTTP_ARG_VAL(level, 0) -HTTP_END_ARGS; - -HTTP_BEGIN_ARGS(uncompress, 1) - HTTP_ARG_VAL(encoded, 0) -HTTP_END_ARGS; - HTTP_BEGIN_ARGS(support, 0) HTTP_ARG_VAL(feature, 0) HTTP_END_ARGS; @@ -131,8 +124,6 @@ zend_function_entry http_util_object_fe[] = { HTTP_UTIL_ALIAS(gzDecode, http_gzdecode) HTTP_UTIL_ALIAS(deflate, http_deflate) HTTP_UTIL_ALIAS(inflate, http_inflate) - HTTP_UTIL_ALIAS(compress, http_compress) - HTTP_UTIL_ALIAS(uncompress, http_uncompress) #endif /* HTTP_HAVE_ZLIB */ HTTP_UTIL_ALIAS(support, http_support) diff --git a/package2.xml b/package2.xml index 7faf968..2cd49b7 100644 --- a/package2.xml +++ b/package2.xml @@ -49,15 +49,16 @@ HttpUtil, HttpMessage, HttpRequest, HttpRequestPool; HttpResponse (PHP-5.1) + Added ssl_engines array and cookies array to the request info array - Renamed http_connectcode to connect_code in the request info array -- Rewrote internal request API - Enable "original headers" previously stripped off by the message parser: o X-Original-Transfer-Encoding (Transfer-Encoding) o X-Original-Content-Encoding (Content-Encoding) o X-Original-Content-Length (Content-Length) - RequestExceptions thrown by HttpRequestPool::__construct() and send() are now wrapped into the HttpRequestPoolException object's $exceptionStack property +- Removed http_compress() and http_uncompress() (http_deflate/inflate ambiguity) * Fixed bug which caused GZIP encoded archives to be decoded +* Fixed bug with DEFLATE encoded response messages * Fixed several memory leaks and inconspicuous access violations * Fixed some logical errors in the uri builder ]]> diff --git a/php_http.h b/php_http.h index dce7b59..22d97e1 100644 --- a/php_http.h +++ b/php_http.h @@ -151,8 +151,6 @@ PHP_FUNCTION(http_gzencode); PHP_FUNCTION(http_gzdecode); PHP_FUNCTION(http_deflate); PHP_FUNCTION(http_inflate); -PHP_FUNCTION(http_compress); -PHP_FUNCTION(http_uncompress); #endif PHP_FUNCTION(http_support); diff --git a/php_http_encoding_api.h b/php_http_encoding_api.h index bc3e7da..aeb7580 100644 --- a/php_http_encoding_api.h +++ b/php_http_encoding_api.h @@ -61,18 +61,19 @@ PHP_HTTP_API STATUS _http_encoding_stream_update(http_encoding_stream *s, const #define http_encoding_stream_finish(s, e, el) _http_encoding_stream_finish((s), (e), (el) TSRMLS_CC) PHP_HTTP_API STATUS _http_encoding_stream_finish(http_encoding_stream *s, char **encoded, size_t *encoded_len TSRMLS_DC); -#define http_encoding_gzencode(l, d, dl, r, rl) _http_encoding_gzencode((l), (d), (dl), (r), (rl) TSRMLS_CC) -PHP_HTTP_API STATUS _http_encoding_gzencode(int level, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC); +#define http_encoding_gzencode_verify(d, dl, e, el) _http_encoding_gzencode_verify((d), (dl), (e), (el), HE_NOTICE) +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); +#define http_encoding_gzdecode_verify(e, el, d, dl) _http_encoding_gzdecode_verify((e), (el), (d), (dl), HE_NOTICE) +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); + +#define http_encoding_gzencode(l, m, d, dl, r, rl) _http_encoding_gzencode((l), (m), (d), (dl), (r), (rl) TSRMLS_CC) +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_encoding_gzdecode(d, dl, r, rl) _http_encoding_gzdecode((d), (dl), (r), (rl) TSRMLS_CC) PHP_HTTP_API STATUS _http_encoding_gzdecode(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC); -#define http_encoding_deflate(l, d, dl, r, rl) _http_encoding_deflate((l), (d), (dl), (r), (rl) TSRMLS_CC) -PHP_HTTP_API STATUS _http_encoding_deflate(int level, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC); +#define http_encoding_deflate(l, h, d, dl, r, rl) _http_encoding_deflate((l), (h), (d), (dl), (r), (rl) TSRMLS_CC) +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); #define http_encoding_inflate(d, dl, r, rl) _http_encoding_inflate((d), (dl), (r), (rl) TSRMLS_CC) PHP_HTTP_API STATUS _http_encoding_inflate(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC); -#define http_encoding_compress(l, d, dl, r, rl) _http_encoding_compress((l), (d), (dl), (r), (rl) TSRMLS_CC) -PHP_HTTP_API STATUS _http_encoding_compress(int level, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC); -#define http_encoding_uncompress(d, dl, r, rl) _http_encoding_uncompress((d), (dl), (r), (rl) TSRMLS_CC) -PHP_HTTP_API STATUS _http_encoding_uncompress(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC); #endif /* HTTP_HAVE_ZLIB */ diff --git a/php_http_request_api.h b/php_http_request_api.h index d2172c5..2c2fc6b 100644 --- a/php_http_request_api.h +++ b/php_http_request_api.h @@ -41,7 +41,7 @@ typedef struct { struct curl_slist *headers; } _cache; - char _error[CURL_ERROR_SIZE]; + char _error[CURL_ERROR_SIZE+1]; zval *_progress_callback; #ifdef ZTS diff --git a/php_http_util_object.h b/php_http_util_object.h index 29d2454..2c085fa 100644 --- a/php_http_util_object.h +++ b/php_http_util_object.h @@ -35,8 +35,6 @@ PHP_METHOD(HttpUtil, gzEncode); PHP_METHOD(HttpUtil, gzDecode); PHP_METHOD(HttpUtil, deflate); PHP_METHOD(HttpUtil, inflate); -PHP_METHOD(HttpUtil, compress); -PHP_METHOD(HttpUtil, uncompress); PHP_METHOD(HttpUtil, support); #endif diff --git a/tests/encodings.phpt b/tests/encodings.phpt index e2e08e7..1b44ce5 100644 --- a/tests/encodings.phpt +++ b/tests/encodings.phpt @@ -19,12 +19,9 @@ for ($i = 0; $i < 1000000; $i++) { $s .= chr(rand(0,255)); } -/* cannot test ext/zlib against this generated data, - because it will fail with such widely differing binary data */ - var_dump($s == http_gzdecode(http_gzencode($s))); var_dump($s == http_inflate(http_deflate($s))); -var_dump($s == http_uncompress(http_compress($s))); +var_dump($s == http_inflate(http_deflate($s, -1, true))); if (extension_loaded('zlib')) { @@ -32,16 +29,10 @@ if (extension_loaded('zlib')) { ($s == http_gzdecode(gzencode($s))) or print "GZIP Failed\n"; ($s == http_inflate(gzdeflate($s))) or print "DEFLATE Failed\n"; - ($s == http_uncompress(gzcompress($s))) or print "COMPRESS Failed\n"; - - /* no gzdecode in ext/zlib - ($s == gzdecode(http_gzencode($s))) or print "GZIP Failed\n"; */ - ($s == gzinflate(http_deflate($s))) or print "DEFLATE Failed\n"; - ($s == gzuncompress(http_compress($s))) or print "COMPRESS Failed\n"; + ($s == http_inflate(gzcompress($s))) or print "COMPRESS Failed\n"; - (gzencode($s) == http_gzencode($s)) or print "GZIP Failed\n"; - (gzdeflate($s) == http_deflate($s)) or print "DEFLATE Failed\n"; - (gzcompress($s) == http_compress($s)) or print "COMPRESS Failed\n"; + ($s == gzinflate(http_deflate($s))) or print "INFLATE Failed\n"; + ($s == gzuncompress(http_deflate($s, -1, true))) or print "UNCOMPRESS Failed\n"; } echo "Done\n"; diff --git a/tests/ut_HttpUtil.phpt b/tests/ut_HttpUtil.phpt index 104c41a..bbd61e0 100644 --- a/tests/ut_HttpUtil.phpt +++ b/tests/ut_HttpUtil.phpt @@ -102,7 +102,6 @@ class HttpUtilTest extends PHPUnit2_Framework_TestCase if ($support = http_support(HTTP_SUPPORT_ENCODINGS)) { $this->assertEquals(file_get_contents(__FILE__), http_gzdecode(http_gzencode(file_get_contents(__FILE__)))); $this->assertEquals(file_get_contents(__FILE__), http_inflate(http_deflate(file_get_contents(__FILE__)))); - $this->assertEquals(file_get_contents(__FILE__), http_uncompress(http_compress(file_get_contents(__FILE__)))); } else { $this->assertFalse($support); }