diff options
Diffstat (limited to 'lib/zlib.c')
| -rw-r--r-- | lib/zlib.c | 751 |
1 files changed, 605 insertions, 146 deletions
@@ -17,7 +17,7 @@ /** * # Zlib bindings * - * The `zlib` module provides single-call-oriented functions for interacting with zlib data. + * The `zlib` module provides single-call and stream-oriented functions for interacting with zlib data. * * @module zlib */ @@ -41,6 +41,16 @@ */ #define CHUNK 16384 +static uc_resource_type_t *zstrmd_type, *zstrmi_type; + +static int last_error = 0; +#define err_return(err) do { last_error = err; return NULL; } while(0) + +typedef struct { + z_stream strm; + uc_stringbuf_t *outbuf; + int flush; +} zstrm_t; /* zlib init error message */ static const char * ziniterr(int ret) @@ -68,24 +78,44 @@ static const char * ziniterr(int ret) return msg; } -static uc_stringbuf_t * -uc_zlib_def_object(uc_vm_t *vm, uc_value_t *obj, z_stream *strm) +static int +def_chunks(zstrm_t * const zstrm) +{ + int ret; + + /* run deflate() on input until output buffer not full */ + do { + printbuf_memset(zstrm->outbuf, printbuf_length(zstrm->outbuf) + CHUNK - 1, 0, 1); + zstrm->outbuf->bpos -= CHUNK; + + zstrm->strm.avail_out = CHUNK; + zstrm->strm.next_out = (unsigned char *)(zstrm->outbuf->buf + zstrm->outbuf->bpos); + + ret = deflate(&zstrm->strm, zstrm->flush); + assert(ret != Z_STREAM_ERROR); + + zstrm->outbuf->bpos += CHUNK - zstrm->strm.avail_out; + } while (zstrm->strm.avail_out == 0); + assert(zstrm->strm.avail_in == 0); // all input will be used + + return ret; +} + +static bool +uc_zlib_def_object(uc_vm_t *const vm, uc_value_t * const obj, zstrm_t * const zstrm) { int ret; bool eof = false; uc_value_t *rfn, *rbuf; - uc_stringbuf_t *buf = NULL; rfn = ucv_property_get(obj, "read"); if (!ucv_is_callable(rfn)) { uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Input object does not implement read() method"); - return NULL; + return false; } - buf = ucv_stringbuf_new(); - do { rbuf = NULL; uc_vm_stack_push(vm, ucv_get(obj)); @@ -107,65 +137,33 @@ uc_zlib_def_object(uc_vm_t *vm, uc_value_t *obj, z_stream *strm) /* check EOF */ eof = (rbuf == NULL || ucv_string_length(rbuf) == 0); - strm->next_in = (unsigned char *)ucv_string_get(rbuf); - strm->avail_in = ucv_string_length(rbuf); - - /* run deflate() on input until output buffer not full */ - do { - // enlarge buf by CHUNK amount as needed - printbuf_memset(buf, printbuf_length(buf) + CHUNK - 1, 0, 1); - buf->bpos -= CHUNK; - - strm->avail_out = CHUNK; - strm->next_out = (unsigned char *)(buf->buf + buf->bpos);; - - ret = deflate(strm, eof ? Z_FINISH : Z_NO_FLUSH); // no bad return value here - assert(ret != Z_STREAM_ERROR); // state never clobbered (would be mem corruption) - (void)ret; // XXX make annoying compiler that ignores assert() happy + zstrm->strm.next_in = (unsigned char *)ucv_string_get(rbuf); + zstrm->strm.avail_in = ucv_string_length(rbuf); - // update bpos past data written by deflate() - buf->bpos += CHUNK - strm->avail_out; - } while (strm->avail_out == 0); - assert(strm->avail_in == 0); // all input will be used + zstrm->flush = eof ? Z_FINISH : Z_NO_FLUSH; + ret = def_chunks(zstrm); + (void)ret; // XXX make annoying compiler that ignores assert() happy ucv_put(rbuf); // release rbuf } while (!eof); // finish compression if all of source has been read in assert(ret == Z_STREAM_END); // stream will be complete - return buf; + return true; fail: ucv_put(rbuf); - printbuf_free(buf); - return NULL; + return false; } -static uc_stringbuf_t * -uc_zlib_def_string(uc_vm_t *vm, uc_value_t *str, z_stream *strm) +static bool +uc_zlib_def_string(uc_vm_t * const vm, uc_value_t * const str, zstrm_t * const zstrm) { - int ret; - uc_stringbuf_t *buf = NULL; - - buf = ucv_stringbuf_new(); - - strm->next_in = (unsigned char *)ucv_string_get(str); - strm->avail_in = ucv_string_length(str); - - do { - printbuf_memset(buf, printbuf_length(buf) + CHUNK - 1, 0, 1); - buf->bpos -= CHUNK; - - strm->avail_out = CHUNK; - strm->next_out = (unsigned char *)(buf->buf + buf->bpos); - - ret = deflate(strm, Z_FINISH); - assert(ret != Z_STREAM_ERROR); + zstrm->strm.next_in = (unsigned char *)ucv_string_get(str); + zstrm->strm.avail_in = ucv_string_length(str); - buf->bpos += CHUNK - strm->avail_out; - } while (ret != Z_STREAM_END); - assert(strm->avail_in == 0); + last_error = def_chunks(zstrm); - return buf; + return true; } /** @@ -185,7 +183,7 @@ uc_zlib_def_string(uc_vm_t *vm, uc_value_t *str, z_stream *strm) * @function module:zlib#deflate * * @param {string} str_or_resource - * The string or resource object to be parsed as JSON. + * The string or resource object to be compressed. * * @param {?boolean} [gzip=false] * Add a gzip header if true (creates a gzip-compliant output, otherwise defaults to Zlib) @@ -203,19 +201,22 @@ uc_zlib_def_string(uc_vm_t *vm, uc_value_t *str, z_stream *strm) * const deflated = deflate(content, Z_BEST_SPEED); */ static uc_value_t * -uc_zlib_deflate(uc_vm_t *vm, size_t nargs) +uc_zlib_deflate(uc_vm_t * const vm, const size_t nargs) { uc_value_t *rv = NULL; uc_value_t *src = uc_fn_arg(0); uc_value_t *gzip = uc_fn_arg(1); uc_value_t *level = uc_fn_arg(2); - uc_stringbuf_t *buf = NULL; int ret, lvl = Z_DEFAULT_COMPRESSION; - bool gz = false; - z_stream strm = { - .zalloc = Z_NULL, - .zfree = Z_NULL, - .opaque = Z_NULL, + bool success, gz = false; + zstrm_t zstrm = { + .strm = { + .zalloc = Z_NULL, + .zfree = Z_NULL, + .opaque = Z_NULL, + }, + .outbuf = NULL, + .flush = Z_FINISH, }; if (gzip) { @@ -236,7 +237,7 @@ uc_zlib_deflate(uc_vm_t *vm, size_t nargs) lvl = (int)ucv_int64_get(level); } - ret = deflateInit2(&strm, lvl, + ret = deflateInit2(&zstrm.strm, lvl, Z_DEFLATED, // only allowed method gz ? 15+16 : 15, // 15 Zlib default, +16 for gzip 8, // default value @@ -246,15 +247,17 @@ uc_zlib_deflate(uc_vm_t *vm, size_t nargs) goto out; } + zstrm.outbuf = ucv_stringbuf_new(); + switch (ucv_type(src)) { case UC_STRING: - buf = uc_zlib_def_string(vm, src, &strm); + success = uc_zlib_def_string(vm, src, &zstrm); break; case UC_RESOURCE: case UC_OBJECT: case UC_ARRAY: - buf = uc_zlib_def_object(vm, src, &strm); + success = uc_zlib_def_object(vm, src, &zstrm); break; default: @@ -263,37 +266,63 @@ uc_zlib_deflate(uc_vm_t *vm, size_t nargs) goto out; } - if (!buf) { + if (!success) { if (vm->exception.type == EXCEPTION_NONE) // do not clobber previous exception - uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Zlib error: %s", strm.msg); + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Zlib error: %s", zstrm.strm.msg); + printbuf_free(zstrm.outbuf); goto out; } - rv = ucv_stringbuf_finish(buf); + rv = ucv_stringbuf_finish(zstrm.outbuf); out: - (void)deflateEnd(&strm); + (void)deflateEnd(&zstrm.strm); return rv; } -static uc_stringbuf_t * -uc_zlib_inf_object(uc_vm_t *vm, uc_value_t *obj, z_stream *strm) +static int +inf_chunks(zstrm_t * const zstrm) +{ + int ret; + + /* run inflate() on input until output buffer not full */ + do { + printbuf_memset(zstrm->outbuf, printbuf_length(zstrm->outbuf) + CHUNK - 1, 0, 1); + zstrm->outbuf->bpos -= CHUNK; + + zstrm->strm.avail_out = CHUNK; + zstrm->strm.next_out = (unsigned char *)(zstrm->outbuf->buf + zstrm->outbuf->bpos); + + ret = inflate(&zstrm->strm, zstrm->flush); + assert(ret != Z_STREAM_ERROR); + switch (ret) { + case Z_NEED_DICT: + case Z_DATA_ERROR: + case Z_MEM_ERROR: + return ret; + } + + zstrm->outbuf->bpos += CHUNK - zstrm->strm.avail_out; + } while (zstrm->strm.avail_out == 0); + + return ret; +} + +static bool +uc_zlib_inf_object(uc_vm_t *const vm, uc_value_t * const obj, zstrm_t * const zstrm) { int ret = Z_STREAM_ERROR; // error out if EOF on first loop bool eof = false; uc_value_t *rfn, *rbuf; - uc_stringbuf_t *buf = NULL; rfn = ucv_property_get(obj, "read"); if (!ucv_is_callable(rfn)) { uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Input object does not implement read() method"); - return NULL; + return false; } - buf = ucv_stringbuf_new(); - do { rbuf = NULL; uc_vm_stack_push(vm, ucv_get(obj)); @@ -317,80 +346,43 @@ uc_zlib_inf_object(uc_vm_t *vm, uc_value_t *obj, z_stream *strm) if (eof) break; - strm->next_in = (unsigned char *)ucv_string_get(rbuf); - strm->avail_in = ucv_string_length(rbuf); - - /* run deflate() on input until output buffer not full */ - do { - // enlarge buf by CHUNK amount as needed - printbuf_memset(buf, printbuf_length(buf) + CHUNK - 1, 0, 1); - buf->bpos -= CHUNK; - - strm->avail_out = CHUNK; - strm->next_out = (unsigned char *)(buf->buf + buf->bpos);; + zstrm->strm.next_in = (unsigned char *)ucv_string_get(rbuf); + zstrm->strm.avail_in = ucv_string_length(rbuf); - ret = inflate(strm, Z_NO_FLUSH); - assert(ret != Z_STREAM_ERROR); // state never clobbered (would be mem corruption) - switch (ret) { - case Z_NEED_DICT: - case Z_DATA_ERROR: - case Z_MEM_ERROR: - goto fail; - } - - // update bpos past data written by deflate() - buf->bpos += CHUNK - strm->avail_out; - } while (strm->avail_out == 0); + ret = inf_chunks(zstrm); + switch (ret) { + case Z_NEED_DICT: + case Z_DATA_ERROR: + case Z_MEM_ERROR: + goto fail; + } ucv_put(rbuf); // release rbuf } while (ret != Z_STREAM_END); // done when inflate() says it's done - if (ret != Z_STREAM_END) { // data error - printbuf_free(buf); - buf = NULL; - } + if (ret != Z_STREAM_END) // data error + return false; - return buf; + return true; fail: ucv_put(rbuf); - printbuf_free(buf); - return NULL; + return false; } -static uc_stringbuf_t * -uc_zlib_inf_string(uc_vm_t *vm, uc_value_t *str, z_stream *strm) +static bool +uc_zlib_inf_string(uc_vm_t * const vm, uc_value_t * const str, zstrm_t * const zstrm) { int ret; - uc_stringbuf_t *buf = NULL; - buf = ucv_stringbuf_new(); + zstrm->strm.next_in = (unsigned char *)ucv_string_get(str); + zstrm->strm.avail_in = ucv_string_length(str); - strm->next_in = (unsigned char *)ucv_string_get(str); - strm->avail_in = ucv_string_length(str); + ret = inf_chunks(zstrm); + assert(zstrm->strm.avail_in == 0); + last_error = ret; - do { - printbuf_memset(buf, printbuf_length(buf) + CHUNK - 1, 0, 1); - buf->bpos -= CHUNK; - - strm->avail_out = CHUNK; - strm->next_out = (unsigned char *)(buf->buf + buf->bpos); - - ret = inflate(strm, Z_FINISH); - assert(ret != Z_STREAM_ERROR); - switch (ret) { - case Z_NEED_DICT: - case Z_DATA_ERROR: - case Z_MEM_ERROR: - printbuf_free(buf); - return NULL; - } - - buf->bpos += CHUNK - strm->avail_out; - } while (ret != Z_STREAM_END); - assert(strm->avail_in == 0); - - return buf; + return Z_STREAM_END == ret; } /** @@ -415,36 +407,43 @@ uc_zlib_inf_string(uc_vm_t *vm, uc_value_t *str, z_stream *strm) * @returns {?string} */ static uc_value_t * -uc_zlib_inflate(uc_vm_t *vm, size_t nargs) +uc_zlib_inflate(uc_vm_t * const vm, const size_t nargs) { uc_value_t *rv = NULL; uc_value_t *src = uc_fn_arg(0); - uc_stringbuf_t *buf = NULL; + bool success; int ret; - z_stream strm = { - .zalloc = Z_NULL, - .zfree = Z_NULL, - .opaque = Z_NULL, - .avail_in = 0, // must be initialized before call to inflateInit - .next_in = Z_NULL, // must be initialized before call to inflateInit + zstrm_t zstrm = { + .strm = { + .zalloc = Z_NULL, + .zfree = Z_NULL, + .opaque = Z_NULL, + .avail_in = 0, // must be initialized before call to inflateInit + .next_in = Z_NULL, // must be initialized before call to inflateInit + }, + .outbuf = NULL, }; /* tell inflateInit2 to perform either zlib or gzip decompression: 15+32 */ - ret = inflateInit2(&strm, 15+32); + ret = inflateInit2(&zstrm.strm, 15+32); if (ret != Z_OK) { uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Zlib error: %s", ziniterr(ret)); goto out; } + zstrm.outbuf = ucv_stringbuf_new(); + switch (ucv_type(src)) { case UC_STRING: - buf = uc_zlib_inf_string(vm, src, &strm); + zstrm.flush = Z_FINISH; + success = uc_zlib_inf_string(vm, src, &zstrm); break; case UC_RESOURCE: case UC_OBJECT: case UC_ARRAY: - buf = uc_zlib_inf_object(vm, src, &strm); + zstrm.flush = Z_NO_FLUSH; + success = uc_zlib_inf_object(vm, src, &zstrm); break; default: @@ -453,28 +452,472 @@ uc_zlib_inflate(uc_vm_t *vm, size_t nargs) goto out; } - if (!buf) { + if (!success) { if (vm->exception.type == EXCEPTION_NONE) // do not clobber previous exception - uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Zlib error: %s", strm.msg); + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Zlib error: %s", zstrm.strm.msg); + printbuf_free(zstrm.outbuf); goto out; } - rv = ucv_stringbuf_finish(buf); + rv = ucv_stringbuf_finish(zstrm.outbuf); out: - (void)inflateEnd(&strm); + (void)inflateEnd(&zstrm.strm); return rv; } +/** + * Represents a handle for interacting with a deflate stream initiated by defnew(). + * + * @class module:zlib.zstrmd + * @hideconstructor + * + * @see {@link module:zlib#defnew()} + * + * @example + * + * const zstrmd = defnew(…); + * + * for (let data = ...; data; data = ...) { + * zstrmd.write(data, Z_PARTIAL_FLUSH); // write uncompressed data to stream + * if (foo) + * let defl = zstrmd.read(); // read back compressed stream content + * } + * + * // terminate the stream if needed (for e.g. file output) + * zstrmd.write('', Z_FINISH); + * defl = ztrmd.read(); + * + * zstrmd.error(); + */ + +/** + * Initializes a deflate stream. + * + * Returns a stream handle on success. + * + * Returns `null` if an error occurred. + * + * @function module:zlib#defnew + * + * @param {?boolean} [gzip=false] + * Add a gzip header if true (creates a gzip-compliant output, otherwise defaults to Zlib) + * + * @param {?number} [level=Z_DEFAULT_COMPRESSION] + * The compression level (0-9). + * + * @returns {?module:zlib.zstrmd} + * + * @example + * // initialize a Zlib deflate stream using default compression + * const zstrmd = defnew(); + * + * // initialize a gzip deflate stream using fastest compression + * const zstrmd = defnew(true, Z_BEST_SPEED); + */ + static uc_value_t * +uc_zlib_defnew(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *gzip = uc_fn_arg(0); + uc_value_t *level = uc_fn_arg(1); + int ret, lvl = Z_DEFAULT_COMPRESSION; + bool gz = false; + zstrm_t *zstrm; + + zstrm = calloc(1, sizeof(*zstrm)); + if (!zstrm) + err_return(ENOMEM); + + zstrm->strm.zalloc = Z_NULL; + zstrm->strm.zfree = Z_NULL; + zstrm->strm.opaque = Z_NULL; + + if (gzip) { + if (ucv_type(gzip) != UC_BOOLEAN) { + last_error = EINVAL; + goto fail; + } + + gz = (int)ucv_boolean_get(gzip); + } + + if (level) { + if (ucv_type(level) != UC_INTEGER) { + last_error = EINVAL; + goto fail; + } + + lvl = (int)ucv_int64_get(level); + } + + ret = deflateInit2(&zstrm->strm, lvl, + Z_DEFLATED, // only allowed method + gz ? 15+16 : 15, // 15 Zlib default, +16 for gzip + 8, // default value + Z_DEFAULT_STRATEGY); // default value + if (ret != Z_OK) { + last_error = ret; + goto fail; + } + + return uc_resource_new(zstrmd_type, zstrm); + +fail: + free(zstrm); + return NULL; +} + +/** + * Writes a chunk of data to the deflate stream. + * + * Input data must be a string, it is internally compressed by the zlib deflate() routine, + * the end is buffered according to the requested `flush` mode until read via + * @see {@link module:zlib.zstrmd#read}. + * If `flush` is `Z_FINISH` (the default) then no more data can be written to the stream. + * Valid `flush`values are `Z_NO_FLUSH, Z_SYNC_FLUSH, Z_PARTIAL_FLUSH, Z_FULL_FLUSH, Z_FINISH` + * + * Returns `true` on success. + * + * Returns `null` if an error occurred. + * + * @function module:zlib.zstrmd#write + * + * @param {string} src + * The string of data to deflate. + * + * @param {?number} [flush=Z_FINISH] + * The zlib flush mode. + * + * @returns {?boolean} + */ +static uc_value_t * +uc_zlib_defwrite(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *src = uc_fn_arg(0); + uc_value_t *flush = uc_fn_arg(1); + zstrm_t **z = uc_fn_this("zlib.strmd"); + zstrm_t *zstrm; + + if (!z || !*z) + err_return(EBADF); + + zstrm = *z; + + if (Z_FINISH == zstrm->flush) + err_return(EPIPE); // can't reuse a finished stream + + if (flush) { + if (ucv_type(flush) != UC_INTEGER) + err_return(EINVAL); + + zstrm->flush = (int)ucv_int64_get(flush); + switch (zstrm->flush) { + case Z_NO_FLUSH: + case Z_SYNC_FLUSH: + case Z_PARTIAL_FLUSH: + case Z_FULL_FLUSH: + case Z_FINISH: + break; + default: + err_return(EINVAL); + } + } + else + zstrm->flush = Z_FINISH; + + /* we only accept strings */ + if (!src || ucv_type(src) != UC_STRING) + err_return(EINVAL); + + if (!zstrm->outbuf) + zstrm->outbuf = ucv_stringbuf_new(); + + return ucv_boolean_new(uc_zlib_def_string(vm, src, zstrm)); +} + +/** + * Reads a chunk of compressed data from the deflate stream. + * + * Returns the current content of the deflate buffer, fed through + * @see {@link module:zlib.zstrmd#write}. + * + * Returns compressed chunk on success. + * + * Returns `null` if an error occurred. + * + * @function module:zlib.zstrmd#read + * + * @returns {?string} + */ +static uc_value_t * +uc_zlib_defread(uc_vm_t *vm, size_t nargs) +{ + zstrm_t **z = uc_fn_this("zlib.strmd"); + zstrm_t *zstrm; + uc_value_t *rv; + + if (!z || !*z) + err_return(EBADF); + + zstrm = *z; + + if (!zstrm->outbuf) + err_return(ENODATA); + + if (Z_FINISH == zstrm->flush) + (void)deflateEnd(&zstrm->strm); + + rv = ucv_stringbuf_finish(zstrm->outbuf); + zstrm->outbuf = NULL; // outbuf is now unuseable + return rv; +} + +/** + * Represents a handle for interacting with an inflate stream initiated by infnew(). + * + * @class module:zlib.zstrmi + * @hideconstructor + * + * @see {@link module:zlib#infnew()} + * + * @example + * + * const zstrmi = infnew(); + * + * for (let data = ...; data; data = ...) { + * zstrmi.write(data, Z_SYNC_FLUSH); // write compressed data to stream + * if (foo) + * let defl = zstrmi.read(); // read back decompressed stream content + * } + * + * // terminate the stream if needed (for e.g. file output) + * zstrmi.write('', Z_FINISH); + * defl = ztrmi.read(); + * + * zstrmi.error(); + */ + +/** + * Initializes an inflate stream. Can process either Zlib or gzip data. + * + * Returns a stream handle on success. + * + * Returns `null` if an error occurred. + * + * @function module:zlib#infnew + * + * @returns {?module:zlib.zstrmi} + * + * @example + * // initialize an inflate stream + * const zstrmi = infnew(); + */ + static uc_value_t * +uc_zlib_infnew(uc_vm_t *vm, size_t nargs) +{ + int ret; + zstrm_t *zstrm; + + zstrm = calloc(1, sizeof(*zstrm)); + if (!zstrm) + err_return(ENOMEM); + + zstrm->strm.zalloc = Z_NULL; + zstrm->strm.zfree = Z_NULL; + zstrm->strm.opaque = Z_NULL; + zstrm->strm.avail_in = 0; + zstrm->strm.next_in = Z_NULL; + + /* tell inflateInit2 to perform either zlib or gzip decompression: 15+32 */ + ret = inflateInit2(&zstrm->strm, 15+32); + if (ret != Z_OK) { + last_error = ret; + goto fail; + } + + return uc_resource_new(zstrmi_type, zstrm); + +fail: + free(zstrm); + return NULL; +} + +/** + * Writes a chunk of data to the inflate stream. + * + * Input data must be a string, it is internally decompressed by the zlib deflate() routine, + * the end is buffered according to the requested `flush` mode until read via + * @see {@link module:zlib.zstrmd#read}. + * If `flush` is `Z_FINISH` (the default) then no more data can be written to the stream. + * Valid `flush` values are `Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH` + * + * Returns `true` on success. + * + * Returns `null` if an error occurred. + * + * @function module:zlib.zstrmi#write + * + * @param {string} src + * The string of data to deflate. + * + * @param {?number} [flush=Z_FINISH] + * The zlib flush mode. + * + * @returns {?boolean} + */ +static uc_value_t * +uc_zlib_infwrite(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *src = uc_fn_arg(0); + uc_value_t *flush = uc_fn_arg(1); + zstrm_t **z = uc_fn_this("zlib.strmi"); + zstrm_t *zstrm; + + if (!z || !*z) + err_return(EBADF); + + zstrm = *z; + + if (Z_FINISH == zstrm->flush) + err_return(EPIPE); // can't reuse a finished stream + + if (flush) { + if (ucv_type(flush) != UC_INTEGER) + err_return(EINVAL); + + zstrm->flush = (int)ucv_int64_get(flush); + switch (zstrm->flush) { + case Z_NO_FLUSH: + case Z_SYNC_FLUSH: + case Z_FINISH: + break; + default: + err_return(EINVAL); + } + } + else + zstrm->flush = Z_FINISH; + + /* we only accept strings */ + if (!src || ucv_type(src) != UC_STRING) + err_return(EINVAL); + + if (!zstrm->outbuf) + zstrm->outbuf = ucv_stringbuf_new(); + + return ucv_boolean_new(uc_zlib_inf_string(vm, src, zstrm)); +} + +/** + * Reads a chunk of decompressed data from the inflate stream. + * + * Returns the current content of the inflate buffer, fed through + * @see {@link module:zlib.zstrmi#write}. + * + * Returns compressed chunk on success. + * + * Returns `null` if an error occurred. + * + * @function module:zlib.zstrmd#read + * + * @returns {?string} + */ +static uc_value_t * +uc_zlib_infread(uc_vm_t *vm, size_t nargs) +{ + zstrm_t **z = uc_fn_this("zlib.strmi"); + zstrm_t *zstrm; + uc_value_t *rv; + + if (!z || !*z) + err_return(EBADF); + + zstrm = *z; + + if (!zstrm->outbuf) + err_return(ENODATA); + + if (Z_FINISH == zstrm->flush) + (void)inflateEnd(&zstrm->strm); + + rv = ucv_stringbuf_finish(zstrm->outbuf); + zstrm->outbuf = NULL; // outbuf is now unuseable + return rv; +} + +/** + * Query error information. + * + * Returns a string containing a description of the last occurred error or + * `null` if there is no error information. + * + * @function module:zlib.zstrmd#error + * + * + * @returns {?string} + */ +static uc_value_t * +uc_zlib_error(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *errmsg; + + if (!last_error) + return NULL; + + // negative last_error only happens for zlib init returns + errmsg = ucv_string_new(last_error < 0 ? ziniterr(last_error) : strerror(last_error)); + last_error = 0; + return errmsg; +} + +static const uc_function_list_t strmd_fns[] = { + { "write", uc_zlib_defwrite }, + { "read", uc_zlib_defread }, + { "error", uc_zlib_error }, +}; + +static const uc_function_list_t strmi_fns[] = { + { "write", uc_zlib_infwrite }, + { "read", uc_zlib_infread }, + { "error", uc_zlib_error }, +}; + static const uc_function_list_t global_fns[] = { { "deflate", uc_zlib_deflate }, { "inflate", uc_zlib_inflate }, + { "defnew", uc_zlib_defnew }, + { "infnew", uc_zlib_infnew }, }; +static void destroy_zstrmd(void *z) +{ + zstrm_t *zstrm = z; + + if (zstrm) { + (void)deflateEnd(&zstrm->strm); + printbuf_free(zstrm->outbuf); + free(zstrm); + } +} + +static void destroy_zstrmi(void *z) +{ + zstrm_t *zstrm = z; + + if (zstrm) { + (void)inflateEnd(&zstrm->strm); + printbuf_free(zstrm->outbuf); + free(zstrm); + } +} + void uc_module_init(uc_vm_t *vm, uc_value_t *scope) { uc_function_list_register(scope, global_fns); + zstrmd_type = uc_type_declare(vm, "zlib.strmd", strmd_fns, destroy_zstrmd); + zstrmi_type = uc_type_declare(vm, "zlib.strmi", strmi_fns, destroy_zstrmi); + #define ADD_CONST(x) ucv_object_add(scope, #x, ucv_int64_new(x)) /** @@ -490,4 +933,20 @@ void uc_module_init(uc_vm_t *vm, uc_value_t *scope) ADD_CONST(Z_BEST_SPEED); ADD_CONST(Z_BEST_COMPRESSION); ADD_CONST(Z_DEFAULT_COMPRESSION); + + /** + * @typedef + * @name flush options + * @description Constants representing flush options. + * @property {number} Z_NO_FLUSH. + * @property {number} Z_PARTIAL_FLUSH. + * @property {number} Z_SYNC_FLUSH. + * @property {number} Z_FULL_FLUSH. + * @property {number} Z_FINISH. + */ + ADD_CONST(Z_NO_FLUSH); + ADD_CONST(Z_PARTIAL_FLUSH); + ADD_CONST(Z_SYNC_FLUSH); + ADD_CONST(Z_FULL_FLUSH); + ADD_CONST(Z_FINISH); } |