PHP 7.4: ulong->unsigned long, uint->uint32_t

[m6w6/ext-http] / src / php_http_filter.c

diff --git a/src/php_http_filter.c b/src/php_http_filter.c
index f145f02b68a70dbd555483cff72fd4d356552b81..52d2b03f584774f931369028cba53d00de8c3987 100644 (file)
--- a/src/php_http_filter.c
+++ b/src/php_http_filter.c
@@ -72,10 +72,10 @@ PHP_MINIT_FUNCTION(http_filter)
 
 typedef struct _http_chunked_decode_filter_buffer_t {
        php_http_buffer_t       buffer;
-       ulong   hexlen;
+       unsigned long   hexlen;
 } PHP_HTTP_FILTER_BUFFER(chunked_decode);
 
-typedef php_http_encoding_stream_t PHP_HTTP_FILTER_BUFFER(zlib);
+typedef php_http_encoding_stream_t PHP_HTTP_FILTER_BUFFER(stream);
 
 static PHP_HTTP_FILTER_FUNCTION(chunked_decode)
 {
@@ -266,22 +266,10 @@ static PHP_HTTP_FILTER_FUNCTION(chunked_encode)
        return PSFS_PASS_ON;
 }
 
-static PHP_HTTP_FILTER_OPS(chunked_decode) = {
-       PHP_HTTP_FILTER_FUNC(chunked_decode),
-       PHP_HTTP_FILTER_DTOR(chunked_decode),
-       "http.chunked_decode"
-};
-
-static PHP_HTTP_FILTER_OPS(chunked_encode) = {
-       PHP_HTTP_FILTER_FUNC(chunked_encode),
-       NULL,
-       "http.chunked_encode"
-};
-
-static PHP_HTTP_FILTER_FUNCTION(zlib)
+static PHP_HTTP_FILTER_FUNCTION(stream)
 {
        php_stream_bucket *ptr, *nxt;
-       PHP_HTTP_FILTER_BUFFER(zlib) *buffer = Z_PTR(this->abstract);
+       PHP_HTTP_FILTER_BUFFER(stream) *buffer = Z_PTR(this->abstract);
        
        if (bytes_consumed) {
                *bytes_consumed = 0;
@@ -302,10 +290,12 @@ static PHP_HTTP_FILTER_FUNCTION(zlib)
                
                nxt = ptr->next;
                php_stream_bucket_unlink(ptr);
-               php_http_encoding_stream_update(buffer, ptr->buf, ptr->buflen, &encoded, &encoded_len);
+               if (SUCCESS != php_http_encoding_stream_update(buffer, ptr->buf, ptr->buflen, &encoded, &encoded_len)) {
+                       return PSFS_ERR_FATAL;
+               }
                
 #if DBG_FILTER
-               fprintf(stderr, "update: deflate (-> %zu) (w: %zu, r: %zu)\n", encoded_len, stream->writepos, stream->readpos);
+               fprintf(stderr, "update: compress (-> %zu) (w: %zu, r: %zu)\n", encoded_len, stream->writepos, stream->readpos);
 #endif
                
                if (encoded) {
@@ -322,10 +312,12 @@ static PHP_HTTP_FILTER_FUNCTION(zlib)
                char *encoded = NULL;
                size_t encoded_len = 0;
                
-               php_http_encoding_stream_flush(buffer, &encoded, &encoded_len);
+               if (SUCCESS != php_http_encoding_stream_flush(buffer, &encoded, &encoded_len)) {
+                       return PSFS_ERR_FATAL;
+               }
                
 #if DBG_FILTER
-               fprintf(stderr, "flush: deflate (-> %zu)\n", encoded_len);
+               fprintf(stderr, "flush: compress (-> %zu)\n", encoded_len);
 #endif
                
                if (encoded) {
@@ -340,10 +332,12 @@ static PHP_HTTP_FILTER_FUNCTION(zlib)
                char *encoded = NULL;
                size_t encoded_len = 0;
                
-               php_http_encoding_stream_finish(buffer, &encoded, &encoded_len);
+               if (SUCCESS != php_http_encoding_stream_finish(buffer, &encoded, &encoded_len)) {
+                       return PSFS_ERR_FATAL;
+               }
                
 #if DBG_FILTER
-               fprintf(stderr, "finish: deflate (-> %zu)\n", encoded_len);
+               fprintf(stderr, "finish: compress (-> %zu)\n", encoded_len);
 #endif
                
                if (encoded) {
@@ -356,25 +350,56 @@ static PHP_HTTP_FILTER_FUNCTION(zlib)
        
        return PSFS_PASS_ON;
 }
-static PHP_HTTP_FILTER_DESTRUCTOR(zlib)
+
+static PHP_HTTP_FILTER_DESTRUCTOR(stream)
 {
-       PHP_HTTP_FILTER_BUFFER(zlib) *buffer = Z_PTR(this->abstract);
+       PHP_HTTP_FILTER_BUFFER(stream) *buffer = Z_PTR(this->abstract);
        php_http_encoding_stream_free(&buffer);
 }
 
+static PHP_HTTP_FILTER_OPS(chunked_decode) = {
+       PHP_HTTP_FILTER_FUNC(chunked_decode),
+       PHP_HTTP_FILTER_DTOR(chunked_decode),
+       "http.chunked_decode"
+};
+
+static PHP_HTTP_FILTER_OPS(chunked_encode) = {
+       PHP_HTTP_FILTER_FUNC(chunked_encode),
+       NULL,
+       "http.chunked_encode"
+};
+
 static PHP_HTTP_FILTER_OPS(deflate) = {
-       PHP_HTTP_FILTER_FUNC(zlib),
-       PHP_HTTP_FILTER_DTOR(zlib),
+       PHP_HTTP_FILTER_FUNC(stream),
+       PHP_HTTP_FILTER_DTOR(stream),
        "http.deflate"
 };
 
 static PHP_HTTP_FILTER_OPS(inflate) = {
-       PHP_HTTP_FILTER_FUNC(zlib),
-       PHP_HTTP_FILTER_DTOR(zlib),
+       PHP_HTTP_FILTER_FUNC(stream),
+       PHP_HTTP_FILTER_DTOR(stream),
        "http.inflate"
 };
 
+#if PHP_HTTP_HAVE_LIBBROTLI
+static PHP_HTTP_FILTER_OPS(brotli_encode) = {
+       PHP_HTTP_FILTER_FUNC(stream),
+       PHP_HTTP_FILTER_DTOR(stream),
+       "http.brotli_encode"
+};
+
+static PHP_HTTP_FILTER_OPS(brotli_decode) = {
+       PHP_HTTP_FILTER_FUNC(stream),
+       PHP_HTTP_FILTER_DTOR(stream),
+       "http.brotli_decode"
+};
+#endif
+
+#if PHP_VERSION_ID >= 70200
+static php_stream_filter *http_filter_create(const char *name, zval *params, uint8_t p)
+#else
 static php_stream_filter *http_filter_create(const char *name, zval *params, int p)
+#endif
 {
        zval *tmp = params;
        php_stream_filter *f = NULL;
@@ -410,7 +435,7 @@ static php_stream_filter *http_filter_create(const char *name, zval *params, int
        } else
        
        if (!strcasecmp(name, "http.inflate")) {
-               PHP_HTTP_FILTER_BUFFER(zlib) *b = NULL;
+               PHP_HTTP_FILTER_BUFFER(stream) *b = NULL;
                
                if ((b = php_http_encoding_stream_init(NULL, php_http_encoding_stream_get_inflate_ops(), flags))) {
                        if (!(f = php_stream_filter_alloc(&PHP_HTTP_FILTER_OP(inflate), b, p))) {
@@ -420,13 +445,35 @@ static php_stream_filter *http_filter_create(const char *name, zval *params, int
        } else
        
        if (!strcasecmp(name, "http.deflate")) {
-               PHP_HTTP_FILTER_BUFFER(zlib) *b = NULL;
+               PHP_HTTP_FILTER_BUFFER(stream) *b = NULL;
                
                if ((b = php_http_encoding_stream_init(NULL, php_http_encoding_stream_get_deflate_ops(), flags))) {
                        if (!(f = php_stream_filter_alloc(&PHP_HTTP_FILTER_OP(deflate), b, p))) {
                                php_http_encoding_stream_free(&b);
                        }
                }
+#if PHP_HTTP_HAVE_LIBBROTLI
+       } else
+
+       if (!strcasecmp(name, "http.brotli_encode")) {
+               PHP_HTTP_FILTER_BUFFER(stream) *b = NULL;
+
+               if ((b = php_http_encoding_stream_init(NULL, php_http_encoding_stream_get_enbrotli_ops(), flags))) {
+                       if (!(f = php_stream_filter_alloc(&PHP_HTTP_FILTER_OP(brotli_encode), b, p))) {
+                               php_http_encoding_stream_free(&b);
+                       }
+               }
+       } else
+
+       if (!strcasecmp(name, "http.brotli_decode")) {
+               PHP_HTTP_FILTER_BUFFER(stream) *b = NULL;
+
+               if ((b = php_http_encoding_stream_init(NULL, php_http_encoding_stream_get_debrotli_ops(), flags))) {
+                       if (!(f = php_stream_filter_alloc(&PHP_HTTP_FILTER_OP(brotli_decode), b, p))) {
+                               php_http_encoding_stream_free(&b);
+                       }
+               }
+#endif
        }
        
        return f;