- fix previous commit and adjust tests

diff --git a/http_encoding_api.c b/http_encoding_api.c
index cba2d2547a595721790007a3d6cfc47610debff6..87a4b175ceae4225d881a5acf654a2b0070a47a1 100644 (file)
--- a/http_encoding_api.c
+++ b/http_encoding_api.c
@@ -531,7 +531,7 @@ PHP_HTTP_API STATUS _http_encoding_stream_update(http_encoding_stream *s, const
        status = deflate(&s->Z, Z_SYNC_FLUSH);
        
        if (Z_OK != status && Z_STREAM_END != status) {
-               HTTP_GZSTREAM_ERROR(status, *encoded);
+               HTTP_ENCODING_STREAM_ERROR(status, *encoded);
        }
        *encoded_len -= s->Z.avail_out;
        
@@ -556,8 +556,6 @@ PHP_HTTP_API STATUS _http_encoding_stream_finish(http_encoding_stream *s, char *
                HTTP_ENCODING_STREAM_ERROR(status, *encoded);
        }
        
-       fprintf(stderr, "Needed %d bytes\n", *encoded_len - s->Z.avail_out);
-       
        *encoded_len -= s->Z.avail_out;
        if (s->gzip) {
                if (s->Z.avail_out < 8) {
@@ -580,16 +578,17 @@ PHP_HTTP_API STATUS _http_encoding_stream_finish(http_encoding_stream *s, char *
 
 PHP_HTTP_API zend_bool _http_encoding_response_start(size_t content_length TSRMLS_DC)
 {
-       if (php_ob_handler_used("ob_gzhandler" TSRMLS_DC)||php_ob_handler_used("zlib output compression" 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;
        } else {
                if (!HTTP_G(send).gzip_encoding) {
                        /* emit a content-length header */
                        if (content_length) {
-                               char *cl;
-                               spprintf(&cl, 0, "Content-Length: %lu", (unsigned long) content_length);
-                               http_send_header_string(cl);
-                               efree(cl);
+                               char cl_header_str[128];
+                               size_t cl_header_len;
+                               cl_header_len = snprintf(cl_header_str, lenof(cl_header_str), "Content-Length: %lu", (unsigned long) content_length);
+                               http_send_header_string_ex(cl_header_str, cl_header_len, 1);
                        }
                } else {
 #ifndef HTTP_HAVE_ZLIB

diff --git a/http_functions.c b/http_functions.c
index dd24050b00ae818878e2f1c7c36ca98424a1950f..98463a0027160a3afc039d10c4653d92bd21f874 100644 (file)
--- a/http_functions.c
+++ b/http_functions.c
@@ -513,7 +513,7 @@ PHP_FUNCTION(ob_etaghandler)
 }
 /* }}} */
 
-/* {{{ proto void http_throttle(double sec[, int bytes = 2097152])
+/* {{{ proto void http_throttle(double sec[, int bytes = 40960])
  *
  * Sets the throttle delay and send buffer size for use with http_send() API.
  * Provides a basic throttling mechanism, which will yield the current process

diff --git a/http_send_api.c b/http_send_api.c
index 82c3f7fd6ca3ec25e3cca267fdbaedf835ccf623..bfdcaab97f0d732d8652bfa56b7deb677e8bb6a1 100644 (file)
--- a/http_send_api.c
+++ b/http_send_api.c
@@ -38,7 +38,7 @@ ZEND_EXTERN_MODULE_GLOBALS(http);
 
 #define http_flush(d, l) _http_flush((d), (l) SRMLS_CC)
 /* {{{ static inline void http_flush() */
-static inline void _http_flush(const char *data, size_t data_len, TSRMLS_DC)
+static inline void _http_flush(const char *data, size_t data_len TSRMLS_DC)
 {
        PHPWRITE(data, data_len);
        php_end_ob_buffer(1, 1 TSRMLS_CC);
@@ -70,46 +70,51 @@ static inline void _http_flush(const char *data, size_t data_len, TSRMLS_DC)
 }
 /* }}} */
 
-/* {{{ http_send_start_response */
-#define http_send_start_response(b, cl) _http_send_start_response((b), (cl) TSRMLS_CC)
-static void _http_send_response_start(void *buffer, size_t content_length TSRMLS_DC)
+/* {{{ http_send_response_start */
+#define http_send_response_start(b, cl) _http_send_response_start((b), (cl) TSRMLS_CC)
+static inline void _http_send_response_start(void **buffer, size_t content_length TSRMLS_DC)
 {
        if (http_encoding_response_start(content_length)) {
 #ifdef HTTP_HAVE_ZLIB
                char *encoded;
-               size_t *encoded_len;
-               http_encoding_stream *s = (http_encoding_stream *) buffer;
+               size_t encoded_len;
+               http_encoding_stream *s = emalloc(sizeof(http_encoding_stream));
                
-               http_encoding_stream_init(s, HTTP_G(gzip).encoding == HTTP_ENCODING_GZIP, -1, &encoded, &encoded_len);
-               phpstr_chunked_output(s.storage, encoded, encoded_len, HTTP_G(send).buffer_size, _http_flush TSRMLS_CC);
+               http_encoding_stream_init(s, HTTP_G(send).gzip_encoding == HTTP_ENCODING_GZIP, -1, &encoded, &encoded_len);
+               phpstr_chunked_output(&s->storage, encoded, encoded_len, HTTP_G(send).buffer_size, _http_flush TSRMLS_CC);
                STR_FREE(encoded);
+               *buffer = s;
 #endif
        }
 }
+/* }}} */
 
+/* {{{ http_send_response_data_plain */
 #define http_send_response_data_plain(b, d, dl) _http_send_response_data_plain((b), (d), (dl) TSRMLS_CC)
-static void _http_send_response_data_plain(void *buffer, const char *data, size_t data_len TSRMLS_DC)
+static inline void _http_send_response_data_plain(void **buffer, const char *data, size_t data_len TSRMLS_DC)
 {
        if (HTTP_G(send).gzip_encoding) {
 #ifdef HTTP_HAVE_ZLIB
                char *encoded;
                size_t encoded_len;
+               http_encoding_stream *s = *((http_encoding_stream **) buffer);
                
-               http_encoding_stream_update(buffer, data, data_len, &encoded, &encoded_len);
-               phpstr_chunked_output(&(((http_encoding_stream *) buffer)->storage), data, data_len, HTTP_G(send).buffer_size, _http_flush);
+               http_encoding_stream_update(s, data, data_len, &encoded, &encoded_len);
+               phpstr_chunked_output(&s->storage, data, data_len, HTTP_G(send).buffer_size, _http_flush TSRMLS_CC);
                efree(encoded);
 #else
                http_error(HE_ERROR, HTTP_E_RESPONSE, "Attempt to send GZIP response despite being able to do so; please report this bug");
 #endif
        } else {
-               phpstr_chunked_output(&buffer, data, data_len, HTTP_G(send).buffer_size, _http_flush);
+               phpstr_chunked_output((phpstr **) buffer, data, data_len, HTTP_G(send).buffer_size, _http_flush TSRMLS_CC);
        }
 }
+/* }}} */
 
 #define HTTP_CHUNK_AVAIL(len, cs) ((len -= cs) >= 0)
 /* {{{ http_send_response_data_fetch */
-#define http_send_response_data_fetch(b, t, d, l, b, e) _http_send_response_data_fetch((b), (t), (d), (l), (b), (e) TSRMLS_CC)
-static void _http_send_response_data_fetch(void *buffer, const void *data, size_t data_len, http_send_mode mode, size_t begin, size_t end TSRMLS_DC)
+#define http_send_response_data_fetch(b, d, l, m, s, e) _http_send_response_data_fetch((b), (d), (l), (m), (s), (e) TSRMLS_CC)
+static inline void _http_send_response_data_fetch(void **buffer, const void *data, size_t data_len, http_send_mode mode, size_t begin, size_t end TSRMLS_DC)
 {
        long len = end - begin, chunk_size = 40960;
        
@@ -117,24 +122,21 @@ static void _http_send_response_data_fetch(void *buffer, const void *data, size_
        {
                case SEND_RSRC:
                {
-                       char *buf;
                        php_stream *s = (php_stream *) data;
 
-                       if (php_stream_seek(s, begin, SEEK_SET)) {
-                               return FAILURE;
-                       }
-
-                       buf = emalloc(chunk_size);
+                       if (SUCCESS == php_stream_seek(s, begin, SEEK_SET)) {
+                               char *buf = emalloc(chunk_size);
 
-                       while (HTTP_CHUNK_AVAIL(len, chunk_size)) {
-                               http_send_response_data_plain(buffer, buf, php_stream_read(s, buf, chunk_size));
-                       }
-                       /* read & write left over */
-                       if (len) {
-                               http_send_response_data_plain(buffer, buf, php_stream_read(s, buf, chunk_size + len));
+                               while (HTTP_CHUNK_AVAIL(len, chunk_size)) {
+                                       http_send_response_data_plain(buffer, buf, php_stream_read(s, buf, chunk_size));
+                               }
+                               /* read & write left over */
+                               if (len) {
+                                       http_send_response_data_plain(buffer, buf, php_stream_read(s, buf, chunk_size + len));
+                               }
+       
+                               efree(buf);
                        }
-
-                       efree(buf);
                }
                break;
 
@@ -153,29 +155,30 @@ static void _http_send_response_data_fetch(void *buffer, const void *data, size_
                }
                break;
 
-               EMPTY_DEFAULT_SWITCH_CASE();
+               EMPTY_SWITCH_DEFAULT_CASE();
        }
 }
 /* }}} */
 
 /* {{{ http_send_response_finish */
 #define http_send_response_finish(b) _http_send_response_finish((b) TSRMLS_CC)
-static void _http_send_response_finish(void *buffer TSRMLS_DC)
+static inline void _http_send_response_finish(void **buffer TSRMLS_DC)
 {
        if (HTTP_G(send).gzip_encoding) {
 #ifdef HTTP_HAVE_ZLIB
                char *encoded = NULL;
                size_t encoded_len;
+               http_encoding_stream *s = *((http_encoding_stream **) buffer);
                
-               http_encoding_stream_finish(buffer, &encoded, &encoded_len);
-               buffer = ((http_encoding_stream *) buffer)->storage;
-               phpstr_chunked_output(buffer, encoded, encoded_len, HTTP_G(send).buffer_size, _http_flush);
+               http_encoding_stream_finish(s, &encoded, &encoded_len);
+               buffer = &s->storage;
+               phpstr_chunked_output((phpstr **) buffer, encoded, encoded_len, HTTP_G(send).buffer_size, _http_flush TSRMLS_CC);
                STR_FREE(encoded);
 #else
                http_error(HE_ERROR, HTTP_E_RESPONSE, "Attempt to send GZIP response despite being able to do so; please report this bug");
 #endif
        }
-       phpstr_chunked_output(buffer, NULL, 0, 0, _http_flush);
+       phpstr_chunked_output((phpstr **) buffer, NULL, 0, 0, _http_flush TSRMLS_CC);
 }
 /* }}} */
 
@@ -294,14 +297,10 @@ PHP_HTTP_API STATUS _http_send_content_disposition(const char *filename, size_t
 /* {{{ STATUS http_send(void *, size_t, http_send_mode) */
 PHP_HTTP_API STATUS _http_send_ex(const void *data_ptr, size_t data_size, http_send_mode data_mode, zend_bool no_cache TSRMLS_DC)
 {
+       void *s = NULL;
        HashTable ranges;
        http_range_status range_status;
-       int cache_etag = http_interrupt_etag_handler();
-#ifdef HTTP_HAVE_ZLIB
-       http_encoding_stream s;
-#else
-       phpstr *s = NULL;
-#endif
+       int cache_etag = http_interrupt_ob_etaghandler();
        
        if (!data_ptr) {
                return FAILURE;
@@ -325,6 +324,7 @@ PHP_HTTP_API STATUS _http_send_ex(const void *data_ptr, size_t data_size, http_s
        switch (range_status)
        {
                case RANGE_OK:
+               {
                        /* Range Request - only send ranges if entity hasn't changed */
                        if (    http_match_etag_ex("HTTP_IF_MATCH", HTTP_G(send).unquoted_etag, 0) &&
                                        http_match_last_modified_ex("HTTP_IF_UNMODIFIED_SINCE", HTTP_G(send).last_modified, 0) &&
@@ -334,17 +334,17 @@ PHP_HTTP_API STATUS _http_send_ex(const void *data_ptr, size_t data_size, http_s
                                        /* single range */
                                        zval **range, **begin, **end;
                                        
-                                       if (    SUCCESS == zend_hash_index_find(ranges, 0, (void **) &range) &&
+                                       if (    SUCCESS == zend_hash_index_find(&ranges, 0, (void **) &range) &&
                                                        SUCCESS == zend_hash_index_find(Z_ARRVAL_PP(range), 0, (void **) &begin) &&
                                                        SUCCESS == zend_hash_index_find(Z_ARRVAL_PP(range), 1, (void **) &end)) {
                                                char range_header_str[256];
                                                size_t range_header_len;
                                                
-                                               range_header_len = snprintf(range_header_str, "Content-Range: bytes %ld-%ld/%lu", Z_LVAL_PP(begin), Z_LVAL_PP(end), (unsigned long) data_size);
+                                               range_header_len = snprintf(range_header_str, lenof(range_header_str), "Content-Range: bytes %ld-%ld/%lu", Z_LVAL_PP(begin), Z_LVAL_PP(end), (unsigned long) data_size);
                                                http_send_status_header_ex(206, range_header_str, range_header_len, 1);
-                                               http_send_response_start(s, Z_LVAL_PP(end)-Z_LVAL_PP(begin));
-                                               http_send_response_data_fetch(s, data_ptr, data_size, data_mode, Z_LVAL_PP(begin), Z_LVAL_PP(end) + 1);
-                                               http_send_response_finish(s);
+                                               http_send_response_start(&s, Z_LVAL_PP(end)-Z_LVAL_PP(begin)+1);
+                                               http_send_response_data_fetch(&s, data_ptr, data_size, data_mode, Z_LVAL_PP(begin), Z_LVAL_PP(end) + 1);
+                                               http_send_response_finish(&s);
                                                zend_hash_destroy(&ranges);
                                                return SUCCESS;
                                        }
@@ -352,15 +352,14 @@ PHP_HTTP_API STATUS _http_send_ex(const void *data_ptr, size_t data_size, http_s
                                        /* multi range */
                                        zval **range, **begin, **end;
                                        const char *content_type = HTTP_G(send).content_type;
-                                       char *boundary_str, *range_header_str;
+                                       char boundary_str[32], range_header_str[256];
                                        size_t boundary_len, range_header_len;
                                        
-                                       boundary_len = spprintf(&boundary_str, 0, "%lu%0.9f", (unsigned long) time(NULL), (float) php_combined_lcg(TSRMLS_C))
-                                       range_header_len = spprintf(&range_header_str, 0, "Content-Type: multipart/byteranges; boundary=%s", boundary_str);
+                                       boundary_len = snprintf(boundary_str, lenof(boundary_str), "%lu%0.9f", (unsigned long) time(NULL), (float) php_combined_lcg(TSRMLS_C));
+                                       range_header_len = snprintf(range_header_str, lenof(range_header_str), "Content-Type: multipart/byteranges; boundary=%s", boundary_str);
                                        
-                                       http_send_status_header_ex(206, range_header, range_header_len, 1);
-                                       efree(range_header_str);
-                                       http_send_response_start(s, 0);
+                                       http_send_status_header_ex(206, range_header_str, range_header_len, 1);
+                                       http_send_response_start(&s, 0);
                                        
                                        if (!content_type) {
                                                content_type = "application/x-octetstream";
@@ -368,34 +367,34 @@ PHP_HTTP_API STATUS _http_send_ex(const void *data_ptr, size_t data_size, http_s
                                        
                                        FOREACH_HASH_VAL(&ranges, range) {
                                                if (    SUCCESS == zend_hash_index_find(Z_ARRVAL_PP(range), 0, (void **) &begin) &&
-                                                               SUCCESS == zend_hash_index_find(Z_ARRVAL_PP(range), 1, (void **) &begin)) {
+                                                               SUCCESS == zend_hash_index_find(Z_ARRVAL_PP(range), 1, (void **) &end)) {
                                                        char preface_str[512];
                                                        size_t preface_len;
 
 #define HTTP_RANGE_PREFACE \
-       HTTP_CRLF "%s" \
+       HTTP_CRLF "--%s" \
        HTTP_CRLF "Content-Type: %s" \
-       HTTP_CRLF "Content-Range: %ld-%ld/%lu" \
+       HTTP_CRLF "Content-Range: bytes %ld-%ld/%lu" \
        HTTP_CRLF HTTP_CRLF
                                                        
                                                        preface_len = snprintf(preface_str, lenof(preface_str), HTTP_RANGE_PREFACE, boundary_str, content_type, Z_LVAL_PP(begin), Z_LVAL_PP(end), data_size);
-                                                       http_send_response_data_plain(s, preface, preface_len);
-                                                       http_send_response_data_fetch(s, data_ptr, data_len, data_mode, Z_LVAL_PP(begin), Z_LVAL_PP(end) + 1);
+                                                       http_send_response_data_plain(&s, preface_str, preface_len);
+                                                       http_send_response_data_fetch(&s, data_ptr, data_size, data_mode, Z_LVAL_PP(begin), Z_LVAL_PP(end) + 1);
                                                }
                                        }
                                        
-                                       http_send_response_data_plain(s, HTTP_CRLF, lenof(HTTP_CRLF));
-                                       http_send_response_data_plain(s, boundary_str, boundary_len);
-                                       http_send_response_data_plain(s, "--", lenof("--"));
-                                       
-                                       efree(boundary_str);
+                                       http_send_response_data_plain(&s, HTTP_CRLF "--", lenof(HTTP_CRLF "--"));
+                                       http_send_response_data_plain(&s, boundary_str, boundary_len);
+                                       http_send_response_data_plain(&s, "--", lenof("--"));
                                        
-                                       http_send_response_finish(s);
+                                       http_send_response_finish(&s);
                                        zend_hash_destroy(&ranges);
                                        return SUCCESS;
                                }
                        }
+               }
                case RANGE_NO:
+               {
                        zend_hash_destroy(&ranges);
                        
                        /* send 304 Not Modified if etag matches - DON'T return on ETag generation failure */
@@ -423,11 +422,13 @@ PHP_HTTP_API STATUS _http_send_ex(const void *data_ptr, size_t data_size, http_s
                        }
                        
                        /* send full response */
-                       http_send_response_start(s, data_size);
-                       http_send_response_data_fetch(s, data_ptr, data_size, data_mode, 0, data_size);
-                       http_send_response_finish(s);
+                       http_send_response_start(&s, data_size);
+                       http_send_response_data_fetch(&s, data_ptr, data_size, data_mode, 0, data_size);
+                       http_send_response_finish(&s);
                        return SUCCESS;
+               }
        }
+       return FAILURE;
 }
 /* }}} */
 

diff --git a/php_http_encoding_api.h b/php_http_encoding_api.h
index 8c651a5261bf6c91bfed18b08d0b0c0d56b519d4..44fedd8893c28d82ff0c5f6c509e2eb8389bacfb 100644 (file)
--- a/php_http_encoding_api.h
+++ b/php_http_encoding_api.h
@@ -19,11 +19,17 @@
 #define PHP_HTTP_ENCODING_API_H
 
 #include "php_http_std_defs.h"
-#include "phpstr/phpstr.h"
+
+#ifdef HTTP_HAVE_ZLIB
+#      include "phpstr/phpstr.h"
+#      include <zlib.h>
+#endif
 
 #define http_encoding_dechunk(e, el, d, dl) _http_encoding_dechunk((e), (el), (d), (dl) TSRMLS_CC)
 PHP_HTTP_API const char *_http_encoding_dechunk(const char *encoded, size_t encoded_len, char **decoded, size_t *decoded_len TSRMLS_DC);
 
+#define http_encoding_response_start(cl) _http_encoding_response_start((cl) TSRMLS_CC)
+PHP_HTTP_API zend_bool _http_encoding_response_start(size_t content_length TSRMLS_DC);
 
 #ifdef HTTP_HAVE_ZLIB
 
@@ -54,16 +60,13 @@ typedef struct {
        phpstr *storage;
 } http_encoding_stream;
 
-#define http_encoding_stream_init(s, g, l, e, el) _http_encoding_stream_init((s), g, (l), (e), (el) TSRMLS_CC)
+#define http_encoding_stream_init(s, g, l, e, el) _http_encoding_stream_init((s), (g), (l), (e), (el) TSRMLS_CC)
 PHP_HTTP_API STATUS _http_encoding_stream_init(http_encoding_stream *s, int gzip, int level, char **encoded, size_t *encoded_len TSRMLS_DC);
 #define http_encoding_stream_update(s, d, dl, e, el) _http_encoding_stream_update((s), (d), (dl), (e), (el) TSRMLS_CC)
 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);
 #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_response_start(cl) _http_encoding_response_start((cl) TSRMS_CC)
-PHP_HTTP_API zend_bool _http_encoding_response_start(size_t content_length 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_gzdecode(d, dl, r, rl) _http_encoding_gzdecode((d), (dl), (r), (rl) TSRMLS_CC)

diff --git a/php_http_std_defs.h b/php_http_std_defs.h
index c13f3bd4fe1990bd76dd993f79ee877520e9e2cb..c297b6489b0dbb9c7dc454601cacf90008c9fc31 100644 (file)
--- a/php_http_std_defs.h
+++ b/php_http_std_defs.h
@@ -108,7 +108,7 @@ typedef int STATUS;
 #define HTTP_URI_ARGSEP HTTP_URL_ARGSEP
 
 /* send buffer size */
-#define HTTP_SENDBUF_SIZE 2097152
+#define HTTP_SENDBUF_SIZE 40960
 
 /* CURL buffer size */
 #define HTTP_CURLBUF_SIZE 16384

diff --git a/phpstr/phpstr.c b/phpstr/phpstr.c
index 3e8e311ee464246e24ce0e9383e79039b46cf488..f9ae25c41440d8817bcd01028c69999993b6cbc2 100644 (file)
--- a/phpstr/phpstr.c
+++ b/phpstr/phpstr.c
@@ -4,7 +4,7 @@
 #include "php.h"
 #include "phpstr.h"
 
-PHPSTR_API phpstr *phpstr_init_ex(phpstr *buf, size_t chunk_size, zend_bool pre_alloc)
+PHPSTR_API phpstr *phpstr_init_ex(phpstr *buf, size_t chunk_size, int pre_alloc)
 {
        if (!buf) {
                buf = emalloc(sizeof(phpstr));
@@ -287,6 +287,9 @@ PHPSTR_API void phpstr_chunked_output(phpstr **s, const char *data, size_t data_
                efree(chunk);
                data = NULL;
                data_len = 0;
+               if (!chunk_len) {
+                       break;
+               }
        }
 }
 

diff --git a/phpstr/phpstr.h b/phpstr/phpstr.h
index 872bf0612e14e15bde2a083bcebba0e94252da1c..04a74ed05718a7cd1076df8fa0fb03a5b1a90357 100644 (file)
--- a/phpstr/phpstr.h
+++ b/phpstr/phpstr.h
@@ -89,7 +89,7 @@ typedef enum {
 #define phpstr_new() phpstr_init(NULL)
 #define phpstr_init(b) phpstr_init_ex(b, 0, 0)
 #define phpstr_clone(phpstr_pointer) phpstr_init_ex(NULL, (phpstr_pointer)->size, 0)
-PHPSTR_API phpstr *phpstr_init_ex(phpstr *buf, size_t chunk_size, zend_bool pre_alloc);
+PHPSTR_API phpstr *phpstr_init_ex(phpstr *buf, size_t chunk_size, int pre_alloc);
 
 /* create a phpstr from a zval or c-string */
 #define phpstr_from_zval(z) phpstr_from_string(Z_STRVAL(z), Z_STRLEN(z))

diff --git a/tests/send_data_001.phpt b/tests/send_data_001.phpt
index ce8bcc029a4ec816ddda039a3ea6207e9862080e..210f68d4fbcf2ab7faf0a814270f6104a10b0fd7 100644 (file)
--- a/tests/send_data_001.phpt
+++ b/tests/send_data_001.phpt
@@ -18,5 +18,6 @@ X-Powered-By: PHP/%s
 Content-Type: text/plain
 Accept-Ranges: bytes
 Content-Range: bytes 5995-5999/6000
+Content-Length: 5
 
 23abc
\ No newline at end of file

diff --git a/tests/send_data_002.phpt b/tests/send_data_002.phpt
index 91ffd0851d5931e69f52092c96728a79a2a0bcd1..3e982dffe87aa811a17ac2855015f702ec2fcc9d 100644 (file)
--- a/tests/send_data_002.phpt
+++ b/tests/send_data_002.phpt
@@ -18,5 +18,6 @@ X-Powered-By: PHP/%s
 Content-Type: text/plain
 Accept-Ranges: bytes
 Content-Range: bytes 5-6/6000
+Content-Length: 2
 
 c1
\ No newline at end of file

diff --git a/tests/send_data_003.phpt b/tests/send_data_003.phpt
index be7d70b75b6b7e1fcb43b3b55ab2f31906b97015..bbc8d785b4ea72a0afd501157f5e8b31436bb60e 100644 (file)
--- a/tests/send_data_003.phpt
+++ b/tests/send_data_003.phpt
@@ -18,5 +18,6 @@ X-Powered-By: PHP/%s
 Content-Type: text/plain
 Accept-Ranges: bytes
 Content-Range: bytes 5981-5999/6000
+Content-Length: 19
 
 c123abc123abc123abc
\ No newline at end of file

diff --git a/tests/send_file_002.phpt b/tests/send_file_002.phpt
index e949157cc10bf22373637cb37ce4be7cb6903204..da87c5ff616e3da3f8482a95b0d07d2096cbdec4 100644 (file)
--- a/tests/send_file_002.phpt
+++ b/tests/send_file_002.phpt
@@ -17,5 +17,6 @@ Content-type: text/html
 X-Powered-By: PHP/%s
 Accept-Ranges: bytes
 Content-Range: bytes 5-9/1010
+Content-Length: 5
 
 56789
\ No newline at end of file

diff --git a/tests/send_file_003.phpt b/tests/send_file_003.phpt
index 7aa8b49f442c93d65dccb32d6eb7534e5d97193e..9e3986b34b1c88c92f5c803f817b73c29fe9b5a5 100644 (file)
--- a/tests/send_file_003.phpt
+++ b/tests/send_file_003.phpt
@@ -17,5 +17,6 @@ Content-type: text/html
 X-Powered-By: PHP/%s
 Accept-Ranges: bytes
 Content-Range: bytes 1001-1009/1010
+Content-Length: 9
 
 23456789

diff --git a/tests/send_file_004.phpt b/tests/send_file_004.phpt
index 034c1f9688439a9df83036ecf0106aca1da3c9a6..54c0212043cfe057752edf9b627ea71722414080 100644 (file)
--- a/tests/send_file_004.phpt
+++ b/tests/send_file_004.phpt
@@ -17,5 +17,6 @@ Content-type: text/html
 X-Powered-By: PHP/%s
 Accept-Ranges: bytes
 Content-Range: bytes 1000-1009/1010
+Content-Length: 10
 
 123456789