zlib-streams 1.1.0 → 1.1.1

package/Makefile

@@ -292,6 +292,8 @@ run_all_tests: dist/zlib-streams-dev.wasm
 	# Output buffer filling before any input is consumed, including a deflate64
 	# match longer than the buffer, which no encoder we have can produce
 	@node src/wasm/tests/test_output_buffer_boundary.js dist/zlib-streams-dev.wasm
+	# Error codes packed the same way as a success, on both directions
+	@node src/wasm/tests/test_process_error_encoding.js dist/zlib-streams-dev.wasm
 	@echo "Completed run_all_tests"
 
 dist/zlib-streams-dev.wasm: $(WASM_SRCS)

package/dist/zlib-streams.js

@@ -138,18 +138,17 @@ function _make(isCompress, type, options = {}) {
 					}
 					heap.set(buffer.subarray(offset, offset + toRead), this.in);
 					const result = process(this.streamHandle, this.in, toRead, out, outBufferSize, 0);
+					// checked before the byte count is used, so a status code can never be read as one
+					const code = (result >> 24) & 0xff;
+					const signedCode = (code & 0x80) ? code - 256 : code;
+					if (signedCode < 0) {
+						throw new Error("process error:" + signedCode);
+					}
 					const prod = result & 0x00ffffff;
 					if (prod) {
 						scratch.set(heap.subarray(out, out + prod), 0);
 						controller.enqueue(scratch.slice(0, prod));
 					}
-					if (!isCompress) {
-						const code = (result >> 24) & 0xff;
-						const signedCode = (code & 0x80) ? code - 256 : code;
-						if (signedCode < 0) {
-							throw new Error("process error:" + signedCode);
-						}
-					}
 					const consumed = last_consumed(this.streamHandle);
 					if (consumed === 0 && prod === 0) {
 						break;
@@ -169,14 +168,12 @@ function _make(isCompress, type, options = {}) {
 				const scratch = this._scratch;
 				while (true) {
 					const result = process(this.streamHandle, 0, 0, out, outBufferSize, 4);
-					const produced = result & 0x00ffffff;
 					const code = (result >> 24) & 0xff;
-					if (!isCompress) {
-						const signedCode = (code & 0x80) ? code - 256 : code;
-						if (signedCode < 0) {
-							throw new Error("process error:" + signedCode);
-						}
+					const signedCode = (code & 0x80) ? code - 256 : code;
+					if (signedCode < 0) {
+						throw new Error("process error:" + signedCode);
 					}
+					const produced = result & 0x00ffffff;
 					if (produced) {
 						scratch.set(heap.subarray(out, out + produced), 0);
 						controller.enqueue(scratch.slice(0, produced));

package/package.json

@@ -3,7 +3,7 @@
   "description": "WASM-based Compression Streams API implementation using zlib, with support for deflate64 decompression.",
   "author": "Gildas Lormeau",
   "license": "BSD-3-Clause",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "type": "module",
   "keywords": [
     "deflate",

package/src/wasm/api/zlib-streams.js

@@ -138,18 +138,17 @@ function _make(isCompress, type, options = {}) {
 					}
 					heap.set(buffer.subarray(offset, offset + toRead), this.in);
 					const result = process(this.streamHandle, this.in, toRead, out, outBufferSize, 0);
+					// checked before the byte count is used, so a status code can never be read as one
+					const code = (result >> 24) & 0xff;
+					const signedCode = (code & 0x80) ? code - 256 : code;
+					if (signedCode < 0) {
+						throw new Error("process error:" + signedCode);
+					}
 					const prod = result & 0x00ffffff;
 					if (prod) {
 						scratch.set(heap.subarray(out, out + prod), 0);
 						controller.enqueue(scratch.slice(0, prod));
 					}
-					if (!isCompress) {
-						const code = (result >> 24) & 0xff;
-						const signedCode = (code & 0x80) ? code - 256 : code;
-						if (signedCode < 0) {
-							throw new Error("process error:" + signedCode);
-						}
-					}
 					const consumed = last_consumed(this.streamHandle);
 					if (consumed === 0 && prod === 0) {
 						break;
@@ -169,14 +168,12 @@ function _make(isCompress, type, options = {}) {
 				const scratch = this._scratch;
 				while (true) {
 					const result = process(this.streamHandle, 0, 0, out, outBufferSize, 4);
-					const produced = result & 0x00ffffff;
 					const code = (result >> 24) & 0xff;
-					if (!isCompress) {
-						const signedCode = (code & 0x80) ? code - 256 : code;
-						if (signedCode < 0) {
-							throw new Error("process error:" + signedCode);
-						}
+					const signedCode = (code & 0x80) ? code - 256 : code;
+					if (signedCode < 0) {
+						throw new Error("process error:" + signedCode);
 					}
+					const produced = result & 0x00ffffff;
 					if (produced) {
 						scratch.set(heap.subarray(out, out + produced), 0);
 						controller.enqueue(scratch.slice(0, produced));

package/src/wasm/wasm_stream_common.c

@@ -34,17 +34,22 @@ unsigned wasm_stream_last_consumed(unsigned zptr) {
   return c->last_consumed;
 }
 
+/* the process functions pack the produced byte count and the zlib status code into one int, so
+   every return path has to use this shape: a bare negative code decodes as a huge byte count */
+#define WASM_STREAM_RESULT(produced, code)                                     \
+  (((produced) & 0x00ffffff) | (((code) & 0xff) << 24))
+
 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;
+    return WASM_STREAM_RESULT(0, 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;
+      return WASM_STREAM_RESULT(0, Z_MEM_ERROR);
     c->inbuf = nb;
     c->inbuf_sz = in_len;
   }
@@ -58,6 +63,5 @@ int wasm_stream_process_common(unsigned zptr, unsigned in_ptr, unsigned in_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);
+  return WASM_STREAM_RESULT(produced, ret);
 }