zlib-streams 1.0.3 → 1.0.4

package/src/wasm/inflate9_stream_wasm.c

@@ -3,7 +3,7 @@
 #include <stdint.h>
 #include "zlib.h"
 #include "inflate9.h"
-#include "allocator.h"
+#include "wasm_stream_common.h"
 #ifndef DEFLATE64_WBITS
 #if defined(MAX_WBITS) && (MAX_WBITS >= 16)
 #define DEFLATE64_WBITS MAX_WBITS
@@ -13,24 +13,10 @@
 #endif
 
 struct wasm_inflate9_ctx {
-  z_stream strm;
-  unsigned char *inbuf;
-  unsigned inbuf_sz;
-  unsigned last_consumed;
+  WASM_STREAM_COMMON_FIELDS;
 };
 
-unsigned inflate9_new(void) {
-  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)malloc(sizeof(*c));
-  if (!c)
-    return 0;
-  memset(c, 0, sizeof(*c));
-  c->strm.zalloc = my_zalloc;
-  c->strm.zfree = my_zfree;
-  c->strm.opaque = Z_NULL;
-  c->inbuf = NULL;
-  c->inbuf_sz = 0;
-  return (unsigned)(uintptr_t)c;
-}
+unsigned inflate9_new(void) { return wasm_stream_new(); }
 
 int inflate9_init(unsigned zptr) {
   struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
@@ -49,42 +35,12 @@ int inflate9_init_raw(unsigned zptr) {
 
 int inflate9_process(unsigned zptr, unsigned in_ptr, unsigned in_len,
                      unsigned out_ptr, unsigned out_len, int flush) {
-  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return Z_STREAM_ERROR;
-  if (in_len > c->inbuf_sz) {
-    unsigned char *nb = (unsigned char *)realloc(c->inbuf, in_len);
-    if (!nb)
-      return Z_MEM_ERROR;
-    c->inbuf = nb;
-    c->inbuf_sz = in_len;
-  }
-  memcpy(c->inbuf, (unsigned char *)(uintptr_t)in_ptr, in_len);
-  c->strm.next_in = c->inbuf;
-  c->strm.avail_in = in_len;
-  c->strm.next_out = (unsigned char *)(uintptr_t)out_ptr;
-  c->strm.avail_out = out_len;
-
-  int ret = inflate9(&c->strm, flush);
-  int produced = (int)(out_len - c->strm.avail_out);
-  c->last_consumed = (unsigned)(in_len - c->strm.avail_in);
-  int code = ret & 0xff;
-  return (produced & 0x00ffffff) | ((code & 0xff) << 24);
+  return wasm_stream_process_common(zptr, in_ptr, in_len, out_ptr, out_len,
+                                    flush, inflate9);
 }
 
-int inflate9_end(unsigned zptr) {
-  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return Z_STREAM_ERROR;
-  int r = inflate9End(&c->strm);
-  free(c->inbuf);
-  free(c);
-  return r;
-}
+int inflate9_end(unsigned zptr) { return wasm_stream_end(zptr, inflate9End); }
 
 unsigned inflate9_last_consumed(unsigned zptr) {
-  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return 0;
-  return c->last_consumed;
+  return wasm_stream_last_consumed(zptr);
 }

package/src/wasm/inflate_stream_wasm.c

@@ -3,6 +3,7 @@
 #include <stdint.h>
 #include "zlib.h"
 #include "allocator.h"
+#include "wasm_stream_common.h"
 
 #ifndef RAW_WBITS
 #if defined(MAX_WBITS)
@@ -13,24 +14,10 @@
 #endif
 
 struct wasm_inflate_ctx {
-  z_stream strm;
-  unsigned char *inbuf;
-  unsigned inbuf_sz;
-  unsigned last_consumed;
+  WASM_STREAM_COMMON_FIELDS
 };
 
-unsigned inflate_new(void) {
-  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)malloc(sizeof(*c));
-  if (!c)
-    return 0;
-  memset(c, 0, sizeof(*c));
-  c->strm.zalloc = my_zalloc;
-  c->strm.zfree = my_zfree;
-  c->strm.opaque = NULL;
-  c->inbuf = NULL;
-  c->inbuf_sz = 0;
-  return (unsigned)(uintptr_t)c;
-}
+unsigned inflate_new(void) { return wasm_stream_new(); }
 
 int inflate_init(unsigned zptr) {
   struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
@@ -59,42 +46,12 @@ int inflate_init_gzip(unsigned zptr) {
 
 int inflate_process(unsigned zptr, unsigned in_ptr, unsigned in_len,
                     unsigned out_ptr, unsigned out_len, int flush) {
-  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return Z_STREAM_ERROR;
-  if (in_len > c->inbuf_sz) {
-    unsigned char *nb = (unsigned char *)realloc(c->inbuf, in_len);
-    if (!nb)
-      return Z_MEM_ERROR;
-    c->inbuf = nb;
-    c->inbuf_sz = in_len;
-  }
-  memcpy(c->inbuf, (unsigned char *)(uintptr_t)in_ptr, in_len);
-  c->strm.next_in = c->inbuf;
-  c->strm.avail_in = in_len;
-  c->strm.next_out = (unsigned char *)(uintptr_t)out_ptr;
-  c->strm.avail_out = out_len;
-
-  int ret = inflate(&c->strm, flush);
-  int produced = (int)(out_len - c->strm.avail_out);
-  c->last_consumed = (unsigned)(in_len - c->strm.avail_in);
-  int code = ret & 0xff;
-  return (produced & 0x00ffffff) | ((code & 0xff) << 24);
+  return wasm_stream_process_common(zptr, in_ptr, in_len, out_ptr, out_len,
+                                    flush, inflate);
 }
 
-int inflate_end(unsigned zptr) {
-  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return Z_STREAM_ERROR;
-  int r = inflateEnd(&c->strm);
-  free(c->inbuf);
-  free(c);
-  return r;
-}
+int inflate_end(unsigned zptr) { return wasm_stream_end(zptr, inflateEnd); }
 
 unsigned inflate_last_consumed(unsigned zptr) {
-  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return 0;
-  return c->last_consumed;
+  return wasm_stream_last_consumed(zptr);
 }

package/src/wasm/wasm_stream_common.c

@@ -0,0 +1,63 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include "wasm_stream_common.h"
+#include "allocator.h"
+
+unsigned wasm_stream_new(void) {
+  struct wasm_stream_ctx *c = (struct wasm_stream_ctx *)malloc(sizeof(*c));
+  if (!c)
+    return 0;
+  memset(c, 0, sizeof(*c));
+  c->strm.zalloc = my_zalloc;
+  c->strm.zfree = my_zfree;
+  c->strm.opaque = Z_NULL;
+  c->inbuf = NULL;
+  c->inbuf_sz = 0;
+  return (unsigned)(uintptr_t)c;
+}
+
+int wasm_stream_end(unsigned zptr, int (*end_func)(z_stream *)) {
+  struct wasm_stream_ctx *c = (struct wasm_stream_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  int r = end_func(&c->strm);
+  free(c->inbuf);
+  free(c);
+  return r;
+}
+
+unsigned wasm_stream_last_consumed(unsigned zptr) {
+  struct wasm_stream_ctx *c = (struct wasm_stream_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return 0;
+  return c->last_consumed;
+}
+
+int wasm_stream_process_common(unsigned zptr, unsigned in_ptr, unsigned in_len,
+                               unsigned out_ptr, unsigned out_len, int flush,
+                               int (*process_func)(z_streamp, int)) {
+  struct wasm_stream_ctx *c = (struct wasm_stream_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+
+  if (in_len > c->inbuf_sz) {
+    unsigned char *nb = (unsigned char *)realloc(c->inbuf, in_len);
+    if (!nb)
+      return Z_MEM_ERROR;
+    c->inbuf = nb;
+    c->inbuf_sz = in_len;
+  }
+
+  memcpy(c->inbuf, (unsigned char *)(uintptr_t)in_ptr, in_len);
+  c->strm.next_in = c->inbuf;
+  c->strm.avail_in = in_len;
+  c->strm.next_out = (unsigned char *)(uintptr_t)out_ptr;
+  c->strm.avail_out = out_len;
+
+  int ret = process_func(&c->strm, flush);
+  int produced = (int)(out_len - c->strm.avail_out);
+  c->last_consumed = (unsigned)(in_len - c->strm.avail_in);
+  int code = ret & 0xff;
+  return (produced & 0x00ffffff) | ((code & 0xff) << 24);
+}

package/src/wasm/wasm_stream_common.h

@@ -0,0 +1,26 @@
+#ifndef WASM_STREAM_COMMON_H
+#define WASM_STREAM_COMMON_H
+
+#include "zlib.h"
+#include "allocator.h"
+
+// Common fields for all WASM stream contexts
+#define WASM_STREAM_COMMON_FIELDS                                              \
+  z_stream strm;                                                               \
+  unsigned char *inbuf;                                                        \
+  unsigned inbuf_sz;                                                           \
+  unsigned last_consumed;
+
+struct wasm_stream_ctx {
+  WASM_STREAM_COMMON_FIELDS;
+};
+
+// Common function declarations
+unsigned wasm_stream_new(void);
+int wasm_stream_end(unsigned zptr, int (*end_func)(z_stream *));
+unsigned wasm_stream_last_consumed(unsigned zptr);
+int wasm_stream_process_common(unsigned zptr, unsigned in_ptr, unsigned in_len,
+                               unsigned out_ptr, unsigned out_len, int flush,
+                               int (*process_func)(z_stream *, int));
+
+#endif // WASM_STREAM_COMMON_H