Replace the zlib driver with a NIF

All operations will now yield appropriately, allowing them to be used
freely in concurrent applications. This commit also deprecates the
functions listed below, although they won't raise deprecation
warnings until OTP 21:

zlib:adler32
zlib:crc32
zlib:inflateChunk
zlib:getBufSize
zlib:setBufSize

The behavior of throwing an error when a dictionary is required for
decompression has also been deprecated.

3 files changed, 1001 insertions, 795 deletions

diff --git a/erts/emulator/Makefile.in b/erts/emulator/Makefile.in
index cc1fa571df..1916b97a89 100644
--- a/erts/emulator/Makefile.in
+++ b/erts/emulator/Makefile.in
@@ -819,14 +819,15 @@ RUN_OBJS = \
 	$(OBJDIR)/erl_io_queue.o
 
 LTTNG_OBJS = $(OBJDIR)/erlang_lttng.o
-NIF_OBJS = $(OBJDIR)/erl_tracer_nif.o
+NIF_OBJS = \
+	   $(OBJDIR)/erl_tracer_nif.o \
+	   $(OBJDIR)/zlib_nif.o
 
 ifeq ($(TARGET),win32)
 DRV_OBJS = \
 	$(OBJDIR)/registry_drv.o \
 	$(OBJDIR)/efile_drv.o \
 	$(OBJDIR)/inet_drv.o \
-	$(OBJDIR)/zlib_drv.o \
 	$(OBJDIR)/ram_file_drv.o \
 	$(OBJDIR)/ttsl_drv.o
 OS_OBJS = \
@@ -856,7 +857,6 @@ OS_OBJS = \
 DRV_OBJS = \
 	$(OBJDIR)/efile_drv.o \
 	$(OBJDIR)/inet_drv.o \
-	$(OBJDIR)/zlib_drv.o \
 	$(OBJDIR)/ram_file_drv.o \
 	$(OBJDIR)/ttsl_drv.o
 endif
diff --git a/erts/emulator/drivers/common/zlib_drv.c b/erts/emulator/drivers/common/zlib_drv.c
deleted file mode 100644
index e342e414b5..0000000000
--- a/erts/emulator/drivers/common/zlib_drv.c
+++ /dev/null
@@ -1,792 +0,0 @@
-/*
- * %CopyrightBegin%
- *
- * Copyright Ericsson AB 2003-2017. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * %CopyrightEnd%
- */
-
-/*
- * ZLib interface for erlang
- *
- */
-#ifdef HAVE_CONFIG_H
-#  include "config.h"
-#endif
-#include <stdio.h>
-#include <zlib.h>
-#include <errno.h>
-#include <string.h>
-
-#include "erl_driver.h"
-
-
-#define DEFLATE_INIT    1
-#define DEFLATE_INIT2   2
-#define DEFLATE_SETDICT 3
-#define DEFLATE_RESET   4
-#define DEFLATE_END     5
-#define DEFLATE_PARAMS  6
-#define DEFLATE         7
-
-#define INFLATE_INIT    8
-#define INFLATE_INIT2   9
-#define INFLATE_SETDICT 10
-#define INFLATE_GETDICT 11
-#define INFLATE_SYNC    12
-#define INFLATE_RESET   13
-#define INFLATE_END     14
-#define INFLATE         15
-
-#define CRC32_0         16
-#define CRC32_1         17
-#define CRC32_2         18
-
-#define SET_BUFSZ       19
-#define GET_BUFSZ       20
-#define GET_QSIZE       21
-
-#define ADLER32_1       22
-#define ADLER32_2       23
-
-#define CRC32_COMBINE   24
-#define ADLER32_COMBINE 25
-
-#define INFLATE_CHUNK   26
-
-
-#define DEFAULT_BUFSZ   4000
-
-/* According to zlib documentation, it can never exceed this */
-#define INFL_DICT_SZ    32768
-
-/* This flag is used in the same places, where zlib return codes
- * (Z_OK, Z_STREAM_END, Z_NEED_DICT) are. So, we need to set it to
- * relatively large value to avoid possible value clashes in future.
- * */
-#define INFLATE_HAS_MORE 100
-
-static int zlib_init(void);
-static ErlDrvData zlib_start(ErlDrvPort port, char* buf);
-static void zlib_stop(ErlDrvData e);
-static void zlib_flush(ErlDrvData e);
-static ErlDrvSSizeT zlib_ctl(ErlDrvData drv_data, unsigned int command, char *buf,
-			     ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen);
-static void zlib_outputv(ErlDrvData drv_data, ErlIOVec *ev);
-
-ErlDrvEntry zlib_driver_entry = {
-    zlib_init,
-    zlib_start,
-    zlib_stop,
-    NULL,                           /* output */
-    NULL,                           /* ready_input */
-    NULL,                           /* ready_output */
-    "zlib_drv",
-    NULL,                           /* finish */
-    NULL,                           /* handle */
-    zlib_ctl,
-    NULL,                           /* timeout */
-    zlib_outputv,
-    NULL,                           /* read_async */
-    zlib_flush,
-    NULL,                           /* call */
-    NULL,                           /* event */
-    ERL_DRV_EXTENDED_MARKER,
-    ERL_DRV_EXTENDED_MAJOR_VERSION,
-    ERL_DRV_EXTENDED_MINOR_VERSION,
-    ERL_DRV_FLAG_USE_PORT_LOCKING,
-    NULL,                           /* handle2 */
-    NULL,                           /* process_exit */
-};
-
-typedef enum {
-    ST_NONE    = 0,
-    ST_DEFLATE = 1,
-    ST_INFLATE = 2
-} ZLibState;
-
-
-typedef struct {
-    z_stream s;
-    ZLibState state;
-    ErlDrvBinary* bin;
-    int binsz;
-    int binsz_need;
-    uLong crc;
-    int inflate_eos_seen;
-    int want_crc;       /* 1 if crc is calculated on clear text */
-    ErlDrvPort port;    /* the associcated port */
-} ZLibData;
-
-static int zlib_inflate(ZLibData* d, int flush);
-static int zlib_deflate(ZLibData* d, int flush);
-
-#if defined(__WIN32__)
-static int i32(char* buf)
-#else
-static __inline__ int i32(char* buf)
-#endif
-{
-    return (int) (
-		  (((int)((unsigned char*)buf)[0]) << 24) |
-		  (((int)((unsigned char*)buf)[1]) << 16) |
-		  (((int)((unsigned char*)buf)[2]) << 8) |
-		  (((int)((unsigned char*)buf)[3]) << 0));
-}
-
-static char* zlib_reason(int code, int* err)
-{
-    switch(code) {
-    case Z_OK:
-	*err = 0;
-	return "ok";
-    case Z_STREAM_END:
-	*err = 0;
-	return "stream_end"; 
-    case Z_ERRNO:
-	*err = 1;
-	return erl_errno_id(errno);
-    case Z_STREAM_ERROR:
-	*err = 1;
-	return "stream_error";
-    case Z_DATA_ERROR:
-	*err = 1;
-	return "data_error";
-    case Z_MEM_ERROR:
-	*err = 1;
-	return "mem_error";
-    case Z_BUF_ERROR:
-	*err = 1;
-	return "buf_error";
-    case Z_VERSION_ERROR:
-	*err = 1;
-	return "version_error";
-    default:
-	*err = 1;
-	return "unknown_error";
-    }
-}
-
-
-static ErlDrvSSizeT zlib_return(int code, char** rbuf, ErlDrvSizeT rlen)
-{
-    int msg_code = 0; /* 0=ok, 1=error */
-    char* dst = *rbuf;
-    char* src;
-    ErlDrvSizeT len = 0;
-
-    src = zlib_reason(code, &msg_code);
-    *dst++ = msg_code;
-    rlen--;
-    len = 1;
-
-    while((rlen > 0) && *src) {
-	*dst++ = *src++;
-	rlen--;
-	len++;
-    }
-    return len;
-}
-
-static ErlDrvSSizeT zlib_value2(int msg_code, int value,
-				char** rbuf, ErlDrvSizeT rlen)
-{
-    char* dst = *rbuf;
-
-    if (rlen  < 5) {
-	return -1;
-    }
-    *dst++ = msg_code;
-    *dst++ = (value >> 24) & 0xff;
-    *dst++ = (value >> 16) & 0xff;
-    *dst++ = (value >> 8) & 0xff;
-    *dst++ = value & 0xff;
-    return 5;
-}
-
-static ErlDrvSSizeT zlib_value(int value, char** rbuf, ErlDrvSizeT rlen)
-{
-    return zlib_value2(2, value, rbuf, rlen);
-}
-
-static int zlib_output_init(ZLibData* d)
-{
-    if (d->bin != NULL)
-	driver_free_binary(d->bin);
-    if ((d->bin = driver_alloc_binary(d->binsz_need)) == NULL)
-	return -1;
-    d->binsz = d->binsz_need;
-    d->s.next_out = (unsigned char*)d->bin->orig_bytes;
-    d->s.avail_out = d->binsz;
-    return 0;
-}
-
-/*
- * Send compressed or uncompressed data
- * and restart output procesing
- */
-static int zlib_output(ZLibData* d)
-{
-    if (d->bin != NULL) {
-	int len = d->binsz - d->s.avail_out;
-	if (len > 0) {
-	    if (driver_output_binary(d->port, NULL, 0, d->bin, 0, len) < 0) 
-		return -1;
-	}
-	driver_free_binary(d->bin);
-	d->bin = NULL;
-	d->binsz = 0;
-    }
-    return zlib_output_init(d);
-}
-
-static int zlib_inflate_get_dictionary(ZLibData* d)
-{
-#ifdef HAVE_ZLIB_INFLATEGETDICTIONARY
-    ErlDrvBinary* dbin = driver_alloc_binary(INFL_DICT_SZ);
-    uInt dlen = 0;
-    int res = inflateGetDictionary(&d->s, (unsigned char*)dbin->orig_bytes, &dlen);
-    if ((res == Z_OK) && (driver_output_binary(d->port, NULL, 0, dbin, 0, dlen) < 0)) {
-        res = Z_ERRNO;
-    }
-    driver_free_binary(dbin);
-    return res;
-#else
-    abort(); /* never called, just to silence 'unresolved symbol'
-                for non-optimizing compiler */
-#endif
-}
-
-static int zlib_inflate(ZLibData* d, int flush)
-{
-    int res = Z_OK;
-
-    if ((d->bin == NULL) && (zlib_output_init(d) < 0)) {
-	errno = ENOMEM;
-	return Z_ERRNO;
-    }
-
-    while ((driver_sizeq(d->port) > 0) && (res != Z_STREAM_END)) {
-	int vlen;
-	SysIOVec* iov = driver_peekq(d->port, &vlen);
-	int len;
-	int possibly_more_output = 0;
-
-	d->s.next_in = iov[0].iov_base;
-	d->s.avail_in = iov[0].iov_len;
-	while((possibly_more_output || (d->s.avail_in > 0)) && (res != Z_STREAM_END)) {
-	    res = inflate(&d->s, Z_NO_FLUSH);
-	    if (res == Z_NEED_DICT) {
-		/* Essential to eat the header bytes that zlib has looked at */
-		len = iov[0].iov_len - d->s.avail_in;
-		driver_deq(d->port, len);
-		return res;
-	    }
-	    if (res == Z_BUF_ERROR) {
-		/* Was possible more output, but actually not */
-		res = Z_OK;
-	    }
-	    else if (res < 0) {
-		return res;
-	    }
-	    if (d->s.avail_out != 0) {
-		possibly_more_output = 0;
-	    } else {
-		if (d->want_crc)
-		    d->crc = crc32(d->crc, (unsigned char*)d->bin->orig_bytes,
-				   d->binsz - d->s.avail_out);
-		zlib_output(d);
-		possibly_more_output = 1;
-	    }
-	}
-	len = iov[0].iov_len - d->s.avail_in;
-	driver_deq(d->port, len);
-    }
-
-    if (d->want_crc) {
-       d->crc = crc32(d->crc, (unsigned char*) d->bin->orig_bytes,
-		      d->binsz - d->s.avail_out);
-    }
-    zlib_output(d);
-    if (res == Z_STREAM_END) {       
-       d->inflate_eos_seen = 1;
-    }
-    return res;
-}
-
-static int zlib_inflate_chunk(ZLibData* d)
-{
-    int res = Z_OK;
-
-    if ((d->bin == NULL) && (zlib_output_init(d) < 0)) {
-	errno = ENOMEM;
-	return Z_ERRNO;
-    }
-
-    while ((driver_sizeq(d->port) > 0) && (d->s.avail_out > 0) &&
-           (res != Z_STREAM_END)) {
-	int vlen;
-	SysIOVec* iov = driver_peekq(d->port, &vlen);
-	int len;
-
-	d->s.next_in = iov[0].iov_base;
-	d->s.avail_in = iov[0].iov_len;
-	while((d->s.avail_in > 0) && (d->s.avail_out > 0) && (res != Z_STREAM_END)) {
-	    res = inflate(&d->s, Z_NO_FLUSH);
-	    if (res == Z_NEED_DICT) {
-		/* Essential to eat the header bytes that zlib has looked at */
-		len = iov[0].iov_len - d->s.avail_in;
-		driver_deq(d->port, len);
-		return res;
-	    }
-	    if (res == Z_BUF_ERROR) {
-		/* Was possible more output, but actually not */
-		res = Z_OK;
-	    }
-	    else if (res < 0) {
-		return res;
-	    }
-	}
-	len = iov[0].iov_len - d->s.avail_in;
-	driver_deq(d->port, len);
-    }
-
-    /* We are here because all input was consumed or EOS reached or output
-     * buffer is full */
-    if (d->want_crc) {
-       d->crc = crc32(d->crc, (unsigned char*) d->bin->orig_bytes,
-		      d->binsz - d->s.avail_out);
-    }
-    zlib_output(d);
-    if ((res == Z_OK) && (d->s.avail_in > 0))
-       res = INFLATE_HAS_MORE;
-    else if (res == Z_STREAM_END) {
-       d->inflate_eos_seen = 1;
-    }
-    return res;
-}
-
-static int zlib_deflate(ZLibData* d, int flush)
-{
-    int res = Z_OK;
-
-    if ((d->bin == NULL) && (zlib_output_init(d) < 0)) {
-	errno = ENOMEM;
-	return Z_ERRNO;
-    }
-
-    while ((driver_sizeq(d->port) > 0) && (res != Z_STREAM_END)) {
-	int vlen;
-	SysIOVec* iov = driver_peekq(d->port, &vlen);
-	int len;
-
-	d->s.next_in = iov[0].iov_base;
-	d->s.avail_in = iov[0].iov_len;
-
-	while((d->s.avail_in > 0) && (res != Z_STREAM_END)) {
-	    if ((res = deflate(&d->s, Z_NO_FLUSH)) < 0) {
-		return res;
-	    }
-	    if (d->s.avail_out == 0) {
-		zlib_output(d);
-	    }
-	}
-	len = iov[0].iov_len - d->s.avail_in;
-	if (d->want_crc) {
-	    d->crc = crc32(d->crc, iov[0].iov_base, len);
-	}
-	driver_deq(d->port, len);
-    }
-
-    if (flush != Z_NO_FLUSH) {
-	if ((res = deflate(&d->s, flush)) < 0) {
-	    return res;
-	}
-	if (flush == Z_FINISH) {
-	    while (d->s.avail_out < d->binsz) {
-		zlib_output(d);
-		if (res == Z_STREAM_END) {
-		    break;
-		}
-		if ((res = deflate(&d->s, flush)) < 0) {
-		    return res;
-		}
-	    }
-	} else {
-	    while (d->s.avail_out == 0) {
-	       zlib_output(d);
-	       if ((res = deflate(&d->s, flush)) < 0) {
-		  return res;
-	       }
-	    }
-	    if (d->s.avail_out < d->binsz) {
-	       zlib_output(d);
-	    }
-	}
-    }
-    return res;
-}
-
-
-
-static void* zlib_alloc(void* data, unsigned int items, unsigned int size)
-{
-    return (void*) driver_alloc(items*size);
-}
-
-static void zlib_free(void* data, void* addr)
-{
-    driver_free(addr);
-}
-
-#if defined(__APPLE__) && defined(__MACH__) && defined(HAVE_ZLIB_INFLATEGETDICTIONARY)
-
-/* Work around broken build system with runtime version test */
-static int have_inflateGetDictionary;
-
-static int zlib_init()
-{
-    unsigned int v[4] = {0, 0, 0, 0};
-    unsigned hexver;
-
-    sscanf(zlibVersion(), "%u.%u.%u.%u", &v[0], &v[1], &v[2], &v[3]);
-
-    hexver = (v[0] << (8*3)) | (v[1] << (8*2)) | (v[2] << (8)) | v[3];
-
-    have_inflateGetDictionary = (hexver >= 0x1020701); /* 1.2.7.1 */
-
-    return 0;
-}
-#else /* trust configure got it right */
-#  ifdef HAVE_ZLIB_INFLATEGETDICTIONARY
-#    define have_inflateGetDictionary 1
-#  else
-#    define have_inflateGetDictionary 0
-#  endif
-static int zlib_init()
-{
-    return 0;
-}
-#endif
-
-static ErlDrvData zlib_start(ErlDrvPort port, char* buf)
-{
-    ZLibData* d;
-
-    if ((d = (ZLibData*) driver_alloc(sizeof(ZLibData))) == NULL)
-        return ERL_DRV_ERROR_GENERAL;
-
-    memset(&d->s, 0, sizeof(z_stream));
-
-    d->s.zalloc = zlib_alloc;
-    d->s.zfree  = zlib_free;
-    d->s.opaque = d;
-    d->s.data_type = Z_BINARY;
-
-    d->port      = port;
-    d->state     = ST_NONE;
-    d->bin       = NULL;
-    d->binsz     = 0;
-    d->binsz_need = DEFAULT_BUFSZ;
-    d->crc       = crc32(0L, Z_NULL, 0);
-    d->inflate_eos_seen = 0;
-    d->want_crc  = 0;
-    return (ErlDrvData)d;
-}
-
-
-static void zlib_stop(ErlDrvData e)
-{
-    ZLibData* d = (ZLibData*)e;
-
-    if (d->state == ST_DEFLATE)
-	deflateEnd(&d->s);
-    else if (d->state == ST_INFLATE)
-	inflateEnd(&d->s);
-
-    if (d->bin != NULL)
-	driver_free_binary(d->bin);
-
-    driver_free(d);
-}
-
-static void zlib_flush(ErlDrvData drv_data)
-{
-    ZLibData* d = (ZLibData*) drv_data;
-
-    driver_deq(d->port, driver_sizeq(d->port));
-}
-
-static ErlDrvSSizeT zlib_ctl(ErlDrvData drv_data, unsigned int command, char *buf,
-			     ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen)
-{
-    ZLibData* d = (ZLibData*)drv_data;
-    int res;
-
-    switch(command) {
-    case DEFLATE_INIT:
-	if (len != 4) goto badarg;
-	if (d->state != ST_NONE) goto badarg;
-	res = deflateInit(&d->s, i32(buf));
-	if (res == Z_OK) {
-	    d->state = ST_DEFLATE;
-	    d->want_crc = 0;
-	    d->crc = crc32(0L, Z_NULL, 0);
-	}
-	return zlib_return(res, rbuf, rlen);
-
-    case DEFLATE_INIT2: {
-	int wbits;
-
-	if (len != 20) goto badarg;
-	if (d->state != ST_NONE) goto badarg;
-	wbits = i32(buf+8);
-	res = deflateInit2(&d->s, i32(buf), i32(buf+4), wbits, 
-			   i32(buf+12), i32(buf+16));
-	if (res == Z_OK) {
-	    d->state = ST_DEFLATE;
-	    d->want_crc = (wbits < 0);
-	    d->crc = crc32(0L, Z_NULL, 0);
-	}
-	return zlib_return(res, rbuf, rlen);
-    }
-	
-    case DEFLATE_SETDICT:
-	if (d->state != ST_DEFLATE) goto badarg;
-	res = deflateSetDictionary(&d->s, (unsigned char*)buf, len);
-	if (res == Z_OK) {
-	    return zlib_value(d->s.adler, rbuf, rlen);
-	} else {
-	    return zlib_return(res, rbuf, rlen);
-	}
-
-    case DEFLATE_RESET:
-	if (len != 0) goto badarg;
-	if (d->state != ST_DEFLATE) goto badarg;
-	driver_deq(d->port, driver_sizeq(d->port));
-	res = deflateReset(&d->s);
-	return zlib_return(res, rbuf, rlen);	
-	
-    case DEFLATE_END:
-	if (len != 0) goto badarg;
-	if (d->state != ST_DEFLATE) goto badarg;
-	driver_deq(d->port, driver_sizeq(d->port));
-	res = deflateEnd(&d->s);
-	d->state = ST_NONE;
-	return zlib_return(res, rbuf, rlen);
-
-    case DEFLATE_PARAMS:
-	if (len != 8) goto badarg;
-	if (d->state != ST_DEFLATE) goto badarg;
-	res = deflateParams(&d->s, i32(buf), i32(buf+4));
-	return zlib_return(res, rbuf, rlen);
-
-    case DEFLATE:
-	if (d->state != ST_DEFLATE) goto badarg;
-	if (len != 4) goto badarg;
-	res = zlib_deflate(d, i32(buf));
-	return zlib_return(res, rbuf, rlen);
-
-    case INFLATE_INIT:
-	if (len != 0) goto badarg;
-	if (d->state != ST_NONE) goto badarg;
-	res = inflateInit(&d->s);
-	if (res == Z_OK) {
-	    d->state = ST_INFLATE;
-	    d->inflate_eos_seen = 0;
-	    d->want_crc = 0;
-	    d->crc = crc32(0L, Z_NULL, 0);
-	}
-	return zlib_return(res, rbuf, rlen);	
-	
-    case INFLATE_INIT2: {
-	int wbits;
-
-	if (len != 4) goto badarg;	
-	if (d->state != ST_NONE) goto badarg;
-	wbits = i32(buf);
-	res = inflateInit2(&d->s, wbits);
-	if (res == Z_OK) {
-	    d->state = ST_INFLATE;
-	    d->inflate_eos_seen = 0;
-	    d->want_crc = (wbits < 0);
-	    d->crc = crc32(0L, Z_NULL, 0);
-	}
-	return zlib_return(res, rbuf, rlen);
-    }
-	
-    case INFLATE_SETDICT:
-	if (d->state != ST_INFLATE) goto badarg;
-	res = inflateSetDictionary(&d->s, (unsigned char*)buf, len);
-	return zlib_return(res, rbuf, rlen);
-
-    case INFLATE_GETDICT:
-        if (have_inflateGetDictionary) {
-            if (d->state != ST_INFLATE) goto badarg;
-            res = zlib_inflate_get_dictionary(d);
-        } else {
-            errno = ENOTSUP;
-            res = Z_ERRNO;
-        }
-        return zlib_return(res, rbuf, rlen);
-
-    case INFLATE_SYNC:
-	if (d->state != ST_INFLATE) goto badarg;
-	if (len != 0) goto badarg;
-	if (driver_sizeq(d->port) == 0) {
-	    res = Z_BUF_ERROR;
-	} else {
-	    int vlen;
-	    SysIOVec* iov = driver_peekq(d->port, &vlen);
-
-	    d->s.next_in = iov[0].iov_base;
-	    d->s.avail_in = iov[0].iov_len;
-	    res = inflateSync(&d->s);
-	}
-	return zlib_return(res, rbuf, rlen);
-
-    case INFLATE_RESET:
-	if (d->state != ST_INFLATE) goto badarg;
-	if (len != 0) goto badarg;
-	driver_deq(d->port, driver_sizeq(d->port));
-	res = inflateReset(&d->s);
-	d->inflate_eos_seen = 0;
-	return zlib_return(res, rbuf, rlen);
-
-    case INFLATE_END:
-	if (d->state != ST_INFLATE) goto badarg;
-	if (len != 0) goto badarg;
-	driver_deq(d->port, driver_sizeq(d->port));
-	res = inflateEnd(&d->s);
-	if (res == Z_OK && d->inflate_eos_seen == 0) {
-	    res = Z_DATA_ERROR;
-	}
-	d->state = ST_NONE;
-	return zlib_return(res, rbuf, rlen);
-
-    case INFLATE:
-	if (d->state != ST_INFLATE) goto badarg;
-	if (len != 4) goto badarg;
-	res = zlib_inflate(d, i32(buf));
-	if (res == Z_NEED_DICT) {
-	    return zlib_value2(3, d->s.adler, rbuf, rlen);
-	} else {
-	    return zlib_return(res, rbuf, rlen);
-	}
-
-    case INFLATE_CHUNK:
-	if (d->state != ST_INFLATE) goto badarg;
-	if (len != 0) goto badarg;
-	res = zlib_inflate_chunk(d);
-	if (res == INFLATE_HAS_MORE) {
-	    return zlib_value2(4, 0, rbuf, rlen);
-	} else if (res == Z_NEED_DICT) {
-	    return zlib_value2(3, d->s.adler, rbuf, rlen);
-	} else {
-	    return zlib_return(res, rbuf, rlen);
-	}
-
-    case GET_QSIZE:
-	return zlib_value(driver_sizeq(d->port), rbuf, rlen);
-
-    case GET_BUFSZ:
-	return zlib_value(d->binsz_need, rbuf, rlen);
-
-    case SET_BUFSZ: {
-	int need;
-	if (len != 4) goto badarg;
-	need = i32(buf);
-	if ((need < 16) || (need > 0x00ffffff))
-	    goto badarg;
-	if (d->binsz_need != need) {
-	    d->binsz_need = need;
-	    if (d->bin != NULL) {
-		if (d->s.avail_out == d->binsz) {
-		    driver_free_binary(d->bin);
-		    d->bin = NULL;
-		    d->binsz = 0;
-		}
-		else
-		    zlib_output(d);
-	    }
-	}
-	return zlib_return(Z_OK, rbuf, rlen);
-    }
-
-    case CRC32_0:
-	return zlib_value(d->crc, rbuf, rlen);
-
-    case CRC32_1: {
-	uLong crc = crc32(0L, Z_NULL, 0);
-	crc = crc32(crc, (unsigned char*) buf, len);
-	return zlib_value(crc, rbuf, rlen);
-    }
-	
-    case CRC32_2: {
-	uLong crc;
-	if (len < 4) goto badarg;
-	crc = (unsigned int) i32(buf);
-	crc = crc32(crc, (unsigned char*) buf+4, len-4);
-	return zlib_value(crc, rbuf, rlen);
-    }
-
-    case ADLER32_1: {
-	uLong adler = adler32(0L, Z_NULL, 0);
-	adler = adler32(adler, (unsigned char*) buf, len);
-	return zlib_value(adler, rbuf, rlen);
-    }
-	
-    case ADLER32_2: {
-       uLong adler;
-       if (len < 4) goto badarg;
-       adler = (unsigned int) i32(buf);
-       adler = adler32(adler, (unsigned char*) buf+4, len-4);
-       return zlib_value(adler, rbuf, rlen);
-    }
-
-    case CRC32_COMBINE: {
-       uLong crc, crc1, crc2, len2;
-       if (len != 12) goto badarg;
-       crc1 = (unsigned int) i32(buf);
-       crc2 = (unsigned int) i32(buf+4);
-       len2 = (unsigned int) i32(buf+8);
-       crc = crc32_combine(crc1, crc2, len2);
-       return zlib_value(crc, rbuf, rlen);
-    }
-
-    case ADLER32_COMBINE: {
-       uLong adler, adler1, adler2, len2;
-       if (len != 12) goto badarg;
-       adler1 = (unsigned int) i32(buf);
-       adler2 = (unsigned int) i32(buf+4);
-       len2   = (unsigned int) i32(buf+8);
-       adler  = adler32_combine(adler1, adler2, len2);
-       return zlib_value(adler, rbuf, rlen);
-    }       
-    }
-
- badarg:
-    errno = EINVAL;
-    return zlib_return(Z_ERRNO, rbuf, rlen);
-}
-
-
-
-static void zlib_outputv(ErlDrvData drv_data, ErlIOVec *ev)
-{
-    ZLibData* d = (ZLibData*) drv_data;
-
-    driver_enqv(d->port, ev, 0);
-}
diff --git a/erts/emulator/nifs/common/zlib_nif.c b/erts/emulator/nifs/common/zlib_nif.c
new file mode 100644
index 0000000000..cffb3f3f63
--- /dev/null
+++ b/erts/emulator/nifs/common/zlib_nif.c
@@ -0,0 +1,998 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson 2017. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * %CopyrightEnd%
+ */
+
+#define STATIC_ERLANG_NIF 1
+
+#include <stdio.h>
+#include <zlib.h>
+
+#include "erl_nif.h"
+#include "config.h"
+#include "sys.h"
+
+#ifdef VALGRIND
+#  include <valgrind/memcheck.h>
+#endif
+
+#define INFL_DICT_SZ    (32768)
+
+#ifndef MAX
+#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
+#endif
+
+#ifndef MIN
+#define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
+#endif
+
+/* NIF interface declarations */
+static int load(ErlNifEnv *env, void** priv_data, ERL_NIF_TERM load_info);
+static int upgrade(ErlNifEnv *env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info);
+static void unload(ErlNifEnv *env, void* priv_data);
+
+static ErlNifResourceType *rtype_zlib;
+
+static ERL_NIF_TERM am_ok;
+static ERL_NIF_TERM am_error;
+static ERL_NIF_TERM am_continue;
+static ERL_NIF_TERM am_finished;
+static ERL_NIF_TERM am_empty;
+static ERL_NIF_TERM am_not_supported;
+static ERL_NIF_TERM am_need_dictionary;
+static ERL_NIF_TERM am_stream_end;
+static ERL_NIF_TERM am_stream_error;
+static ERL_NIF_TERM am_data_error;
+static ERL_NIF_TERM am_mem_error;
+static ERL_NIF_TERM am_buf_error;
+static ERL_NIF_TERM am_version_error;
+static ERL_NIF_TERM am_unknown_error;
+
+typedef enum {
+    ST_NONE    = 0,
+    ST_DEFLATE = 1,
+    ST_INFLATE = 2,
+    ST_CLOSED = 3
+} zlib_state;
+
+typedef struct {
+    z_stream s;
+    zlib_state state;
+
+    /* These refer to the plaintext CRC, and are only needed for zlib:crc32/1
+     * which is deprecated. */
+    uLong input_crc;
+    uLong output_crc;
+    int want_input_crc;
+    int want_output_crc;
+
+    int is_raw_stream;
+
+    int eos_seen;
+
+    /* DEPRECATED */
+    int inflateChunk_buffer_size;
+
+    ErlNifPid controlling_process;
+
+    ErlNifIOQueue *input_queue;
+
+    ErlNifEnv *stash_env;
+    ERL_NIF_TERM stash_term;
+} zlib_data_t;
+
+/* The NIFs: */
+
+static ERL_NIF_TERM zlib_open(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_close(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_deflateInit(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_deflateInit2(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_deflateSetDictionary(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_deflateReset(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_deflateEnd(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_deflateParams(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_deflate(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM zlib_inflateInit(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_inflateInit2(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_inflateSetDictionary(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_inflateGetDictionary(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_inflateReset(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_inflateEnd(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_inflate(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM zlib_crc32(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM zlib_clearStash(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_setStash(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_getStash(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM zlib_getBufSize(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM zlib_setBufSize(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM zlib_enqueue_input(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ErlNifFunc nif_funcs[] = {
+    /* deflate */
+    {"deflateInit_nif", 2, zlib_deflateInit},
+    {"deflateInit_nif", 6, zlib_deflateInit2},
+    {"deflateSetDictionary_nif", 2, zlib_deflateSetDictionary},
+    {"deflateReset_nif", 1, zlib_deflateReset},
+    {"deflateEnd_nif", 1, zlib_deflateEnd},
+    {"deflateParams_nif", 3, zlib_deflateParams},
+    {"deflate_nif", 4, zlib_deflate},
+
+    /* inflate */
+    {"inflateInit_nif", 1, zlib_inflateInit},
+    {"inflateInit_nif", 2, zlib_inflateInit2},
+    {"inflateSetDictionary_nif", 2, zlib_inflateSetDictionary},
+    {"inflateGetDictionary_nif", 1, zlib_inflateGetDictionary},
+    {"inflateReset_nif", 1, zlib_inflateReset},
+    {"inflateEnd_nif", 1, zlib_inflateEnd},
+    {"inflate_nif", 4, zlib_inflate},
+
+    /* running checksum */
+    {"crc32_nif", 1, zlib_crc32},
+
+    /* open & close */
+    {"close_nif", 1, zlib_close},
+    {"open_nif", 0, zlib_open},
+
+    /* The stash keeps a single term alive across calls, and is used in
+     * exception_on_need_dict/1 to retain the old error behavior, and for
+     * saving data flushed through deflateParams/3. */
+    {"getStash_nif", 1, zlib_getStash},
+    {"clearStash_nif", 1, zlib_clearStash},
+    {"setStash_nif", 2, zlib_setStash},
+
+    /* DEPRECATED: buffer size for inflateChunk */
+    {"getBufSize_nif", 1, zlib_getBufSize},
+    {"setBufSize_nif", 2, zlib_setBufSize},
+
+    {"enqueue_nif", 2, zlib_enqueue_input},
+};
+
+ERL_NIF_INIT(zlib, nif_funcs, load, NULL, upgrade, unload)
+
+static void gc_zlib(ErlNifEnv *env, void* data);
+
+static int load(ErlNifEnv *env, void** priv_data, ERL_NIF_TERM load_info)
+{
+    am_ok = enif_make_atom(env, "ok");
+    am_error = enif_make_atom(env, "error");
+    am_empty = enif_make_atom(env, "empty");
+    am_continue = enif_make_atom(env, "continue");
+    am_finished = enif_make_atom(env, "finished");
+    am_need_dictionary = enif_make_atom(env, "need_dictionary");
+    am_not_supported = enif_make_atom(env, "not_supported");
+    am_stream_end = enif_make_atom(env, "stream_end");
+    am_stream_error = enif_make_atom(env, "stream_error");
+    am_data_error = enif_make_atom(env, "data_error");
+    am_mem_error = enif_make_atom(env, "mem_error");
+    am_buf_error = enif_make_atom(env, "buf_error");
+    am_version_error = enif_make_atom(env, "version_error");
+    am_unknown_error = enif_make_atom(env, "unknown_error");
+
+    rtype_zlib = enif_open_resource_type(env, NULL,
+            "gc_zlib", gc_zlib, ERL_NIF_RT_CREATE, NULL);
+    *priv_data = NULL;
+
+    return 0;
+}
+
+static void unload(ErlNifEnv *env, void* priv_data)
+{
+
+}
+
+static int upgrade(ErlNifEnv *env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info)
+{
+    if(*old_priv_data != NULL) {
+        return -1; /* Don't know how to do that */
+    }
+    if(*priv_data != NULL) {
+        return -1; /* Don't know how to do that */
+    }
+    if(load(env, priv_data, load_info)) {
+        return -1;
+    }
+    return 0;
+}
+
+static void* zlib_alloc(void* data, unsigned int items, unsigned int size)
+{
+    return (void*) enif_alloc(items * size);
+}
+
+static void zlib_free(void* data, void* addr)
+{
+    enif_free(addr);
+}
+
+static ERL_NIF_TERM zlib_return(ErlNifEnv *env, int code) {
+    ERL_NIF_TERM reason;
+    switch(code) {
+    case Z_OK:
+        reason = am_ok;
+        break;
+    case Z_STREAM_END:
+        reason = am_stream_end;
+        break;
+    case Z_ERRNO:
+        reason = enif_make_int(env, errno);
+        //enif_make_tuple2(env, enif_make_int(env, err), reason);
+        break;
+    case Z_STREAM_ERROR:
+        //reason = am_stream_error;
+        reason = enif_raise_exception(env, am_stream_error);
+        break;
+    case Z_DATA_ERROR:
+        //reason = am_data_error;
+        reason = enif_raise_exception(env, am_data_error);
+        break;
+    case Z_MEM_ERROR:
+        reason = am_mem_error;
+        break;
+    case Z_BUF_ERROR:
+        reason = am_buf_error;
+        break;
+    case Z_VERSION_ERROR:
+        reason = am_version_error;
+        break;
+    default:
+        reason = am_unknown_error;
+        break;
+    }
+    return reason;
+}
+
+static void gc_zlib(ErlNifEnv *env, void* data) {
+    zlib_data_t *d = (zlib_data_t*)data;
+
+    if(d->state == ST_DEFLATE) {
+        deflateEnd(&d->s);
+    } else if(d->state == ST_INFLATE) {
+        inflateEnd(&d->s);
+    }
+
+    if(d->state != ST_CLOSED) {
+        enif_ioq_destroy(d->input_queue);
+
+        if(d->stash_env != NULL) {
+            enif_free_env(d->stash_env);
+        }
+
+        d->state = ST_CLOSED;
+    }
+}
+
+static void zlib_reset_input(zlib_data_t *d) {
+    enif_ioq_destroy(d->input_queue);
+    d->input_queue = enif_ioq_create(ERL_NIF_IOQ_NORMAL);
+
+    if(d->stash_env != NULL) {
+        enif_free_env(d->stash_env);
+        d->stash_env = NULL;
+        d->stash_term = NIL;
+    }
+}
+
+static int get_zlib_data(ErlNifEnv* env, ERL_NIF_TERM opaque, zlib_data_t **d) {
+    ErlNifPid current_process;
+
+    if(!enif_get_resource(env, opaque, rtype_zlib, (void **)d)) {
+        return 0;
+    }
+
+    enif_self(env, &current_process);
+
+    return enif_is_identical(enif_make_pid(env, &current_process),
+        enif_make_pid(env, &(*d)->controlling_process));
+}
+
+static int zlib_flush_queue(int (*codec)(z_stream*, int), ErlNifEnv *env,
+        zlib_data_t *d, size_t input_limit, ErlNifBinary *output_buffer, int flush,
+        size_t *bytes_produced, size_t *bytes_consumed, size_t *bytes_remaining) {
+
+    int vec_len, vec_idx;
+    SysIOVec *input_vec;
+    int res;
+
+    input_vec = enif_ioq_peek(d->input_queue, &vec_len);
+    vec_idx = 0;
+    res = Z_OK;
+
+    *bytes_produced = 0;
+    *bytes_consumed = 0;
+
+    d->s.avail_out = output_buffer->size;
+    d->s.next_out = output_buffer->data;
+
+    while(res == Z_OK && vec_idx < vec_len && *bytes_consumed < input_limit) {
+        size_t timeslice_percent, block_consumed, block_size;
+
+        block_size = MIN(input_vec[vec_idx].iov_len, input_limit);
+
+        d->s.next_in = input_vec[vec_idx].iov_base;
+        d->s.avail_in = block_size;
+
+        res = codec(&d->s, Z_NO_FLUSH);
+
+        ASSERT(d->s.avail_in == 0 || d->s.avail_out == 0 || res != Z_OK);
+
+        block_consumed = block_size - d->s.avail_in;
+        *bytes_consumed += block_consumed;
+
+        if(d->want_input_crc) {
+            d->input_crc =
+                crc32(d->input_crc, input_vec[vec_idx].iov_base, block_consumed);
+        }
+
+        timeslice_percent = (100 * block_consumed) / input_limit;
+        if(enif_consume_timeslice(env, MAX(1, timeslice_percent))) {
+            break;
+        }
+
+        vec_idx++;
+    }
+
+    if(!enif_ioq_deq(d->input_queue, *bytes_consumed, bytes_remaining)) {
+        *bytes_remaining = 0;
+        res = Z_BUF_ERROR;
+    }
+
+    if(res == Z_OK && flush != Z_NO_FLUSH && (*bytes_remaining == 0)) {
+        d->s.next_in = NULL;
+        d->s.avail_in = 0;
+
+        res = codec(&d->s, flush);
+    }
+
+    *bytes_produced = output_buffer->size - d->s.avail_out;
+
+    return res;
+}
+
+static ERL_NIF_TERM zlib_codec(int (*codec)(z_stream*, int),
+                               ErlNifEnv *env, zlib_data_t *d,
+                               int input_chunk_size,
+                               int output_chunk_size,
+                               int flush) {
+
+    size_t bytes_produced, bytes_consumed, bytes_remaining;
+    ErlNifBinary output_buffer;
+    int res;
+
+    if(!enif_alloc_binary(output_chunk_size, &output_buffer)) {
+        return zlib_return(env, Z_MEM_ERROR);
+    }
+
+    res = zlib_flush_queue(codec, env, d, input_chunk_size, &output_buffer,
+        flush, &bytes_produced, &bytes_consumed, &bytes_remaining);
+
+    if(res < 0 && res != Z_BUF_ERROR) {
+        enif_release_binary(&output_buffer);
+        return zlib_return(env, res);
+    }
+
+    if(res == Z_STREAM_END) {
+        d->eos_seen = 1;
+    }
+
+    if(d->want_output_crc) {
+        d->output_crc =
+            crc32(d->output_crc, output_buffer.data, bytes_produced);
+    }
+
+    if(bytes_consumed == 0 && bytes_produced == 0 && bytes_remaining != 0) {
+        /* Die if we've made zero progress; this should not happen on
+         * well-formed input. */
+
+        enif_release_binary(&output_buffer);
+        return zlib_return(env, Z_DATA_ERROR);
+    } else {
+        ERL_NIF_TERM flushed_output;
+
+        if(bytes_produced > 0) {
+            if(bytes_produced < output_buffer.size) {
+                enif_realloc_binary(&output_buffer, bytes_produced);
+            }
+
+            flushed_output =
+                enif_make_list1(env, enif_make_binary(env, &output_buffer));
+        } else {
+            enif_release_binary(&output_buffer);
+            flushed_output = enif_make_list(env, 0);
+        }
+
+        if(bytes_remaining == 0 && bytes_produced < output_chunk_size) {
+            return enif_make_tuple2(env, am_finished, flushed_output);
+        } else if(res != Z_NEED_DICT) {
+            return enif_make_tuple2(env, am_continue, flushed_output);
+        }
+
+        return enif_make_tuple3(env, am_need_dictionary,
+            enif_make_int(env, d->s.adler), flushed_output);
+    }
+}
+
+/* zlib nifs */
+
+static ERL_NIF_TERM zlib_getStash(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+
+    if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->stash_env == NULL) {
+        return am_empty;
+    }
+
+    return enif_make_tuple2(env, am_ok, enif_make_copy(env, d->stash_term));
+}
+
+static ERL_NIF_TERM zlib_clearStash(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+
+    if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->stash_env == NULL) {
+        return enif_make_badarg(env);
+    }
+
+    enif_free_env(d->stash_env);
+    d->stash_env = NULL;
+    d->stash_term = NIL;
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM zlib_setStash(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+
+    if(argc != 2 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->stash_env != NULL) {
+        return enif_make_badarg(env);
+    }
+
+    d->stash_env = enif_alloc_env();
+    d->stash_term = enif_make_copy(d->stash_env, argv[1]);
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM zlib_open(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    ERL_NIF_TERM result;
+
+    d = (zlib_data_t *) enif_alloc_resource(rtype_zlib, sizeof(zlib_data_t));
+
+    memset(&d->s, 0, sizeof(z_stream));
+
+    enif_self(env, &d->controlling_process);
+
+    d->input_queue = enif_ioq_create(ERL_NIF_IOQ_NORMAL);
+
+    d->s.zalloc = zlib_alloc;
+    d->s.zfree  = zlib_free;
+    d->s.opaque = d;
+    d->s.data_type = Z_BINARY;
+
+    d->state = ST_NONE;
+    d->eos_seen = 0;
+
+    d->want_output_crc = 0;
+    d->want_input_crc = 0;
+    d->is_raw_stream = 0;
+
+    d->output_crc = crc32(0L, Z_NULL, 0);
+    d->input_crc = crc32(0L, Z_NULL, 0);
+
+    d->stash_env = NULL;
+    d->stash_term = NIL;
+
+    d->inflateChunk_buffer_size = 4000;
+
+    result = enif_make_resource(env, d);
+    enif_release_resource(d);
+
+    return result;
+}
+
+static ERL_NIF_TERM zlib_close(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+
+    /* strictly speaking not needed since the gc will handle this */
+    if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state == ST_CLOSED) {
+        return enif_make_badarg(env);
+    }
+
+    gc_zlib(env, d);
+
+    return am_ok;
+}
+
+/* deflate */
+
+static ERL_NIF_TERM zlib_deflateInit(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    int level, res;
+
+    if(argc != 2 || !get_zlib_data(env, argv[0], &d) ||
+                    !enif_get_int(env, argv[1], &level)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_NONE) {
+        return enif_make_badarg(env);
+    }
+
+    res = deflateInit(&d->s, level);
+
+    if(res == Z_OK) {
+        d->state = ST_DEFLATE;
+        d->eos_seen = 0;
+
+        /* FIXME: crc32/1 is documented as returning "the current calculated
+         * checksum," but failed to mention that the old implementation only
+         * calculated it when WindowBits < 0 (See zlib_deflateInit2).
+         *
+         * We could fix this behavior by setting d->want_input_crc to 1 here,
+         * but we've decided to retain this quirk since the performance hit is
+         * quite significant. */
+        d->want_output_crc = 0;
+        d->want_input_crc = 0;
+
+        d->output_crc = crc32(0L, Z_NULL, 0);
+        d->input_crc = crc32(0L, Z_NULL, 0);
+    }
+
+    return zlib_return(env, res);
+}
+
+static ERL_NIF_TERM zlib_deflateInit2(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    int level, method, windowBits, memLevel, strategy, res;
+
+    if(argc != 6 || !get_zlib_data(env, argv[0], &d) 
+                 || !enif_get_int(env, argv[1], &level)
+                 || !enif_get_int(env, argv[2], &method)
+                 || !enif_get_int(env, argv[3], &windowBits)
+                 || !enif_get_int(env, argv[4], &memLevel)
+                 || !enif_get_int(env, argv[5], &strategy)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_NONE) {
+        return enif_make_badarg(env);
+    }
+
+    res = deflateInit2(&d->s, level, method, windowBits, memLevel, strategy);
+
+    if(res == Z_OK) {
+        d->state = ST_DEFLATE;
+        d->eos_seen = 0;
+
+        d->is_raw_stream = (windowBits < 0);
+
+        d->want_output_crc = 0;
+        d->want_input_crc = d->is_raw_stream;
+
+        d->output_crc = crc32(0L, Z_NULL, 0);
+        d->input_crc = crc32(0L, Z_NULL, 0);
+    }
+
+    return zlib_return(env, res);
+}
+
+static ERL_NIF_TERM zlib_deflateSetDictionary(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    ErlNifBinary bin;
+    int res;
+
+    if(argc != 2 || !get_zlib_data(env, argv[0], &d)
+                 || !enif_inspect_iolist_as_binary(env, argv[1], &bin)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_DEFLATE) {
+        return enif_make_badarg(env);
+    }
+
+    if((res = deflateSetDictionary(&d->s, bin.data, bin.size)) == Z_OK) {
+        uLong checksum = d->s.adler;
+
+        /* d->s.adler is not updated in raw deflate mode, so we'll calculate it
+         * ourselves in case the user wants to rely on that behavior. */
+        if(d->is_raw_stream) {
+            checksum = adler32(0, bin.data, bin.size);
+        }
+
+        return enif_make_int(env, checksum);
+    }
+
+    return zlib_return(env, res);
+}
+
+static ERL_NIF_TERM zlib_deflateReset(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    int res;
+
+    if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_DEFLATE) {
+        return enif_make_badarg(env);
+    }
+
+    res = deflateReset(&d->s);
+
+    d->input_crc = crc32(0L, Z_NULL, 0);
+    d->eos_seen = 0;
+
+    zlib_reset_input(d);
+
+    return zlib_return(env, res);
+}
+
+static ERL_NIF_TERM zlib_deflateEnd(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    int res;
+
+    if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_DEFLATE) {
+        return enif_make_badarg(env);
+    }
+
+    res = deflateEnd(&d->s);
+
+    if(res == Z_OK && enif_ioq_size(d->input_queue) > 0) {
+        res = Z_DATA_ERROR;
+    }
+
+    zlib_reset_input(d);
+    d->state = ST_NONE;
+
+    return zlib_return(env, res);
+}
+
+static ERL_NIF_TERM zlib_deflateParams(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    int res, level, strategy;
+
+    if(argc != 3 || !get_zlib_data(env, argv[0], &d)
+                 || !enif_get_int(env, argv[1], &level)
+                 || !enif_get_int(env, argv[2], &strategy)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_DEFLATE) {
+        return enif_make_badarg(env);
+    }
+
+    /* deflateParams will flush everything currently in the stream, corrupting
+     * the heap unless it's empty. We therefore pretend to have a full output
+     * buffer, forcing a Z_BUF_ERROR if there's anything left to be flushed. */
+    d->s.avail_out = 0;
+    res = deflateParams(&d->s, level, strategy);
+
+    return zlib_return(env, res);
+}
+
+static ERL_NIF_TERM zlib_deflate(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+
+    int input_chunk_size, output_chunk_size, flush;
+
+    if(argc != 4 || !get_zlib_data(env, argv[0], &d)
+                 || !enif_get_int(env, argv[1], &input_chunk_size)
+                 || !enif_get_int(env, argv[2], &output_chunk_size)
+                 || !enif_get_int(env, argv[3], &flush)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_DEFLATE) {
+        return enif_make_badarg(env);
+    }
+
+    return zlib_codec(&deflate, env, d, input_chunk_size, output_chunk_size, flush);
+}
+
+/* inflate */
+
+static ERL_NIF_TERM zlib_inflateInit(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    int res;
+
+    if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_NONE) {
+        return enif_make_badarg(env);
+    }
+
+    res = inflateInit(&d->s);
+
+    if(res == Z_OK) {
+        d->state = ST_INFLATE;
+        d->eos_seen = 0;
+
+        d->want_output_crc = 0;
+        d->want_input_crc = 0;
+        d->is_raw_stream = 0;
+
+        d->output_crc = crc32(0L, Z_NULL, 0);
+        d->input_crc = crc32(0L, Z_NULL, 0);
+    }
+
+    return zlib_return(env, res);
+}
+
+static ERL_NIF_TERM zlib_inflateInit2(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    int windowBits, res;
+
+    if(argc != 2 || !get_zlib_data(env, argv[0], &d)
+                 || !enif_get_int(env, argv[1], &windowBits)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_NONE) {
+        return enif_make_badarg(env);
+    }
+
+    res = inflateInit2(&d->s, windowBits);
+
+    if(res == Z_OK) {
+        d->state = ST_INFLATE;
+        d->eos_seen = 0;
+
+        d->is_raw_stream = (windowBits < 0);
+
+        d->want_output_crc = d->is_raw_stream;
+        d->want_input_crc = 0;
+
+        d->output_crc = crc32(0L, Z_NULL, 0);
+        d->input_crc = crc32(0L, Z_NULL, 0);
+    }
+
+    return zlib_return(env, res);
+}
+
+static ERL_NIF_TERM zlib_inflateSetDictionary(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    ErlNifBinary bin;
+    int res;
+
+    if(argc != 2 || !get_zlib_data(env, argv[0], &d)
+                 || !enif_inspect_iolist_as_binary(env, argv[1], &bin)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_INFLATE) {
+        return enif_make_badarg(env);
+    }
+
+    res = inflateSetDictionary(&d->s, bin.data, bin.size);
+
+    return zlib_return(env, res);
+}
+
+#ifdef HAVE_ZLIB_INFLATEGETDICTIONARY
+/* Work around broken build system with runtime version test */
+static int zlib_supports_inflateGetDictionary(void) {
+    static int supportsGetDictionary = -1;
+
+#if defined(__APPLE__) && defined(__MACH__)
+    if(supportsGetDictionary < 0) {
+        unsigned int v[4] = {0, 0, 0, 0};
+        unsigned hexver;
+
+        sscanf(zlibVersion(), "%u.%u.%u.%u", &v[0], &v[1], &v[2], &v[3]);
+
+        hexver = (v[0] << (8*3)) | (v[1] << (8*2)) | (v[2] << (8)) | v[3];
+        supportsGetDictionary = (hexver >= 0x1020701); /* 1.2.7.1 */
+    }
+#endif
+
+    return supportsGetDictionary;
+}
+
+static ERL_NIF_TERM zlib_inflateGetDictionary(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    ErlNifBinary obin;
+    uInt len;
+    int res;
+
+    if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_INFLATE) {
+        return enif_make_badarg(env);
+    }
+
+    if(!zlib_supports_inflateGetDictionary()) {
+        return enif_make_badarg(env);
+    }
+
+    enif_alloc_binary(INFL_DICT_SZ, &obin);
+
+    len = 0;
+    if((res = inflateGetDictionary(&d->s, obin.data, &len)) < 0) {
+        enif_release_binary(&obin);
+        return zlib_return(env, res);
+    }
+
+    enif_realloc_binary(&obin, (size_t)len);
+    return enif_make_binary(env, &obin);
+}
+
+#else /* !HAVE_ZLIB_INFLATEGETDICTIONARY */
+
+static ERL_NIF_TERM zlib_inflateGetDictionary(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    return enif_make_badarg(env);
+}
+
+#endif
+
+static ERL_NIF_TERM zlib_inflateReset(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    int res;
+
+    if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_INFLATE) {
+        return enif_make_badarg(env);
+    }
+
+    res = inflateReset(&d->s);
+
+    d->output_crc = crc32(0L, Z_NULL, 0);
+    d->eos_seen = 0;
+
+    zlib_reset_input(d);
+
+    return zlib_return(env, res);
+}
+
+static ERL_NIF_TERM zlib_inflateEnd(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+    int res;
+
+    if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_INFLATE) {
+        return enif_make_badarg(env);
+    }
+
+    res = inflateEnd(&d->s);
+
+    if(res == Z_OK && (!d->eos_seen || enif_ioq_size(d->input_queue) > 0)) {
+        res = Z_DATA_ERROR;
+    }
+
+    zlib_reset_input(d);
+    d->state = ST_NONE;
+
+    return zlib_return(env, res);
+}
+
+static ERL_NIF_TERM zlib_inflate(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+
+    int input_chunk_size, output_chunk_size, flush;
+
+    if(argc != 4 || !get_zlib_data(env, argv[0], &d)
+                 || !enif_get_int(env, argv[1], &input_chunk_size)
+                 || !enif_get_int(env, argv[2], &output_chunk_size)
+                 || !enif_get_int(env, argv[3], &flush)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_INFLATE) {
+        return enif_make_badarg(env);
+    }
+
+    return zlib_codec(&inflate, env, d, input_chunk_size, output_chunk_size, flush);
+}
+
+static ERL_NIF_TERM zlib_crc32(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+
+    if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state == ST_DEFLATE) {
+        return enif_make_ulong(env, d->input_crc);
+    } else if(d->state == ST_INFLATE) {
+        return enif_make_ulong(env, d->output_crc);
+    }
+
+    return enif_make_badarg(env);
+}
+
+static ERL_NIF_TERM zlib_getBufSize(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+
+    if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    return enif_make_int(env, d->inflateChunk_buffer_size);
+}
+
+static ERL_NIF_TERM zlib_setBufSize(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+
+    if(argc != 2 || !get_zlib_data(env, argv[0], &d)
+                 || !enif_get_int(env, argv[1], &d->inflateChunk_buffer_size)) {
+        return enif_make_badarg(env);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM zlib_enqueue_input(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    zlib_data_t *d;
+
+    ErlNifIOVec prealloc, *iovec = &prealloc;
+    ERL_NIF_TERM tail;
+
+    if(argc != 2 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    if(d->state != ST_DEFLATE && d->state != ST_INFLATE) {
+        return enif_make_badarg(env);
+    }
+
+    if(!enif_inspect_iovec(env, 256, argv[1], &tail, &iovec)) {
+        return enif_make_badarg(env);
+    }
+
+    if(!enif_ioq_enqv(d->input_queue, iovec, 0)) {
+        return enif_make_badarg(env);
+    }
+
+    if(!enif_is_empty_list(env, tail)) {
+        return enif_make_tuple2(env, am_continue, tail);
+    }
+
+    return am_ok;
+}