- remove http_compress() and http_uncompress() (deflate/inflate ambiguity)

- fix issues with deflated response messages

diff --git a/http.c b/http.c
index 97587f809dfc42ea7c642e1467ea09648b09672e..6fc1af9281c1142bf11f6bc2f486d7ef0121a009 100644 (file)
--- 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 d3529d14c15edb038d1e51eb41c31d99a5d1a895..6c0d4157b2115ca6b917ffa443c2dc1c675e1186 100644 (file)
--- 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 279e4ea02e97777d76feb1a820944bd9b9dd0f11..424a6bde66ad7a41b4857507d09bf3e555ef9d6a 100644 (file)
--- 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 65aeaf254c5ea8b447c52360c0008605e6b73bf9..2a7a1ebbe6bc7ce7ab83672c52ac1bce2d98554e 100644 (file)
--- 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 b2fa5c54aa39bebab7d2c7b1c96d65033e281acb..b1ad7c77ca046c2a8dd713cbc71a7c8b0e0e7a89 100644 (file)
--- 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 7faf96801d6be2840f9701245712606cfeedc618..2cd49b7e67861dc3fc5996d8a84496e472bbadb5 100644 (file)
--- 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
 ]]></notes>

diff --git a/php_http.h b/php_http.h
index dce7b5982899ea34bf6b934b6690478a8bd341af..22d97e13846c1e7a8797ea5cac1ff7adf1aa10f4 100644 (file)
--- 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 bc3e7da6504d050270b83fe6176422ea6fec6a03..aeb75806119ed1ab48554c02443aa22498f65d93 100644 (file)
--- 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 d2172c5a8277fd170719f8d9abe8f505d941155c..2c2fc6b6282d322d76a1ad97427c133bdd2e651c 100644 (file)
--- 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 29d2454d7ae744e3b09b3c17afe12a4691f47de4..2c085faebcef00673010867b9950b92243a3d5f4 100644 (file)
--- 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 e2e08e72d923e56659d0cd315106a12b4c3d7b13..1b44ce5f7ffdc6848c30f1178520d0e70982dc88 100644 (file)
--- 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 104c41ae32f302affd007e4f701f4e4817bc2eea..bbd61e08831ea20a632c70d43e82d7c28c08739c 100644 (file)
--- 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);
                }