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.

8 files changed, 1569 insertions, 1135 deletions

diff --git a/erts/doc/src/zlib.xml b/erts/doc/src/zlib.xml
index 1d272c4c18..9c3e97d814 100644
--- a/erts/doc/src/zlib.xml
+++ b/erts/doc/src/zlib.xml
@@ -90,6 +90,9 @@ list_to_binary([Compressed|Last])</pre>
       <name name="zlevel"/>
     </datatype>
     <datatype>
+      <name name="zflush"/>
+    </datatype>
+    <datatype>
       <name name="zmemlevel"/>
     </datatype>
     <datatype>
@@ -112,6 +115,11 @@ list_to_binary([Compressed|Last])</pre>
       <fsummary>Calculate the Adler checksum.</fsummary>
       <desc>
         <p>Calculates the Adler-32 checksum for <c><anno>Data</anno></c>.</p>
+        <warning>
+          <p>This function is deprecated and will be removed in a future
+             release. Use <seealso marker="erts:erlang#adler32/1">
+             <c>erlang:adler32/1</c></seealso> instead.</p>
+        </warning>
       </desc>
     </func>
 
@@ -127,6 +135,11 @@ list_to_binary([Compressed|Last])</pre>
 Crc = lists:foldl(fun(Data,Crc0) ->
                       zlib:adler32(Z, Crc0, Data),
                   end, zlib:adler32(Z,&lt;&lt; &gt;&gt;), Datas)</pre>
+        <warning>
+          <p>This function is deprecated and will be removed in a future
+             release. Use <seealso marker="erts:erlang#adler32/2">
+             <c>erlang:adler32/2</c></seealso> instead.</p>
+        </warning>
       </desc>
     </func>
 
@@ -141,6 +154,11 @@ Crc = lists:foldl(fun(Data,Crc0) ->
         <p>This function returns the <c><anno>Adler</anno></c> checksum of
           <c>[Data1,Data2]</c>, requiring only <c><anno>Adler1</anno></c>,
           <c><anno>Adler2</anno></c>, and <c><anno>Size2</anno></c>.</p>
+        <warning>
+          <p>This function is deprecated and will be removed in a future
+             release. Use <seealso marker="erts:erlang#adler32_combine/3">
+             <c>erlang:adler32_combine/3</c></seealso> instead.</p>
+        </warning>
       </desc>
     </func>
 
@@ -165,6 +183,12 @@ Crc = lists:foldl(fun(Data,Crc0) ->
       <fsummary>Get current CRC.</fsummary>
       <desc>
         <p>Gets the current calculated CRC checksum.</p>
+        <warning>
+          <p>This function is deprecated and will be removed in a future
+             release. Use <seealso marker="erts:erlang#crc32/1">
+             <c>erlang:crc32/1</c></seealso> on the uncompressed data
+             instead.</p>
+        </warning>
       </desc>
     </func>
 
@@ -173,6 +197,11 @@ Crc = lists:foldl(fun(Data,Crc0) ->
       <fsummary>Calculate CRC.</fsummary>
       <desc>
         <p>Calculates the CRC checksum for <c><anno>Data</anno></c>.</p>
+        <warning>
+          <p>This function is deprecated and will be removed in a future
+             release. Use <seealso marker="erts:erlang#crc32/1">
+             <c>erlang:crc32/1</c></seealso> instead.</p>
+        </warning>
       </desc>
     </func>
 
@@ -188,6 +217,11 @@ Crc = lists:foldl(fun(Data,Crc0) ->
 Crc = lists:foldl(fun(Data,Crc0) ->
                       zlib:crc32(Z, Crc0, Data),
                   end, zlib:crc32(Z,&lt;&lt; &gt;&gt;), Datas)</pre>
+        <warning>
+          <p>This function is deprecated and will be removed in a future
+             release. Use <seealso marker="erts:erlang#crc32/2">
+             <c>erlang:crc32/2</c></seealso> instead.</p>
+        </warning>
       </desc>
     </func>
 
@@ -202,6 +236,11 @@ Crc = lists:foldl(fun(Data,Crc0) ->
         <p>This function returns the <c><anno>CRC</anno></c> checksum of
           <c>[Data1,Data2]</c>, requiring only <c><anno>CRC1</anno></c>,
           <c><anno>CRC2</anno></c>, and <c><anno>Size2</anno></c>.</p>
+        <warning>
+          <p>This function is deprecated and will be removed in a future
+             release. Use <seealso marker="erts:erlang#crc32_combine/3">
+             <c>erlang:crc32_combine/3</c></seealso> instead.</p>
+        </warning>
       </desc>
     </func>
 
@@ -407,8 +446,8 @@ list_to_binary([B1,B2])</pre>
           <seealso marker="#deflateInit/1"><c>deflateInit/1,2,6</c></seealso> or
           <seealso marker="#deflateReset/1"><c>deflateReset/1</c></seealso>,
           before any call of
-          <seealso marker="#deflate/3"><c>deflate/3</c></seealso>.
-          The compressor and decompressor must use the same dictionary (see
+          <seealso marker="#deflate/3"><c>deflate/3</c></seealso>.</p>
+        <p>The compressor and decompressor must use the same dictionary (see
           <seealso marker="#inflateSetDictionary/2">
           <c>inflateSetDictionary/2</c></seealso>).</p>
         <p>The Adler checksum of the dictionary is returned.</p>
@@ -420,6 +459,10 @@ list_to_binary([B1,B2])</pre>
       <fsummary>Get buffer size.</fsummary>
       <desc>
         <p>Gets the size of the intermediate buffer.</p>
+        <warning>
+          <p>This function is deprecated and will be removed in a future
+             release.</p>
+        </warning>
       </desc>
     </func>
 
@@ -443,14 +486,31 @@ list_to_binary([B1,B2])</pre>
       <name name="inflate" arity="2"/>
       <fsummary>Decompress data.</fsummary>
       <desc>
-        <p>Decompresses as much data as possible.
-          It can introduce some output latency (reading
-          input without producing any output).</p>
-        <p>If a preset dictionary is needed at this point (see
-          <seealso marker="#inflateSetDictionary/2">
-          <c>inflateSetDictionary/2</c></seealso>), <c>inflate/2</c> throws a
-          <c>{need_dictionary,Adler}</c> exception, where <c>Adler</c> is
-          the Adler-32 checksum of the dictionary chosen by the compressor.</p>
+        <p>Equivalent to
+           <seealso marker="#inflate/3"><c>inflate(Z, Data, [])</c></seealso>
+           </p>
+      </desc>
+    </func>
+
+    <func>
+      <name name="inflate" arity="3"/>
+      <fsummary>Decompress data.</fsummary>
+      <desc>
+        <p>Decompresses as much data as possible. It can introduce some output
+           latency (reading input without producing any output).</p>
+        <p>Currently the only available option is
+           <c>{exception_on_need_dict,boolean()}</c> which controls whether the
+           function should throw an exception when a preset dictionary is
+           required for decompression. When set to false, a
+           <c>need_dictionary</c> tuple will be returned instead. See
+           <seealso marker="#inflateSetDictionary/2">
+           <c>inflateSetDictionary/2</c></seealso> for details.</p>
+        <warning>
+           <p>This option defaults to <c>true</c> for backwards compatibility
+              but we intend to remove the exception behavior in a future
+              release. New code that needs to handle dictionaries manually
+              should always specify <c>{exception_on_need_dict,false}</c>.</p>
+        </warning>
       </desc>
     </func>
 
@@ -458,6 +518,11 @@ list_to_binary([B1,B2])</pre>
       <name name="inflateChunk" arity="1"/>
       <fsummary>Read next uncompressed chunk.</fsummary>
       <desc>
+        <warning>
+          <p>This function is deprecated and will be removed in a future
+             release. Use <seealso marker="#safeInflate/2"><c>safeInflate/2</c>
+             </seealso> instead.</p>
+        </warning>
         <p>Reads the next chunk of uncompressed data, initialized by
           <seealso marker="#inflateChunk/2"><c>inflateChunk/2</c></seealso>.</p>
         <p>This function is to be repeatedly called, while it returns
@@ -469,23 +534,27 @@ list_to_binary([B1,B2])</pre>
       <name name="inflateChunk" arity="2"/>
       <fsummary>Decompress data with limited output size.</fsummary>
       <desc>
+        <warning>
+          <p>This function is deprecated and will be removed in a future
+             release. Use <seealso marker="#safeInflate/2"><c>safeInflate/2</c>
+             </seealso> instead.</p>
+        </warning>
         <p>Like <seealso marker="#inflate/2"><c>inflate/2</c></seealso>,
-          but decompresses no more data than will fit in the buffer configured
-          through <seealso marker="#setBufSize/2"><c>setBufSize/2</c></seealso>.
-          Is is useful when decompressing a stream with a high compression
-          ratio, such that a small amount of compressed input can expand up to
-          1000 times.</p>
+           but decompresses no more data than will fit in the buffer configured
+           through <seealso marker="#setBufSize/2"><c>setBufSize/2</c>
+           </seealso>. Is is useful when decompressing a stream with a high
+           compression ratio, such that a small amount of compressed input can
+           expand up to 1000 times.</p>
         <p>This function returns <c>{more, Decompressed}</c>, when there is
-          more output available, and
-          <seealso marker="#inflateChunk/1"><c>inflateChunk/1</c></seealso>
-          is to be used to read it.</p>
-        <p>This function can introduce some output latency (reading
-          input without producing any output).</p>
-        <p>If a preset dictionary is needed at this point (see
-          <seealso marker="#inflateSetDictionary/2">
-          <c>inflateSetDictionary/2</c></seealso>), this function throws a
-          <c>{need_dictionary,Adler}</c> exception, where <c>Adler</c> is
-          the Adler-32 checksum of the dictionary chosen by the compressor.</p>
+           more output available, and
+           <seealso marker="#inflateChunk/1"><c>inflateChunk/1</c></seealso>
+           is to be used to read it.</p>
+        <p>This function can introduce some output latency (reading input
+           without producing any output).</p>
+        <p>An exception will be thrown if a preset dictionary is required for
+           further decompression. See
+           <seealso marker="#inflateSetDictionary/2">
+           <c>inflateSetDictionary/2</c></seealso> for details.</p>
         <p>Example:</p>
         <pre>
 walk(Compressed, Handler) ->
@@ -517,6 +586,18 @@ loop(Z, Handler, Uncompressed) ->
     </func>
 
     <func>
+      <name name="inflateGetDictionary" arity="1"/>
+      <fsummary>Return the decompression dictionary.</fsummary>
+      <desc>
+        <p>Returns the decompression dictionary currently in use
+          by the stream. This function must be called between
+          <seealso marker="#inflateInit/1"><c>inflateInit/1,2</c></seealso>
+          and <seealso marker="#inflateEnd/1"><c>inflateEnd</c></seealso>.</p>
+        <p>Only supported if ERTS was compiled with zlib >= 1.2.8.</p>
+      </desc>
+    </func>
+
+    <func>
       <name name="inflateInit" arity="1"/>
       <fsummary>Initialize a session for decompression.</fsummary>
       <desc>
@@ -562,45 +643,83 @@ loop(Z, Handler, Uncompressed) ->
       <fsummary>Initialize the decompression dictionary.</fsummary>
       <desc>
         <p>Initializes the decompression dictionary from the specified
-          uncompressed byte sequence. This function must be called
-          immediately after a call of
-          <seealso marker="#inflate/2"><c>inflate/2</c></seealso>
-          if this call threw a <c>{need_dictionary,Adler}</c> exception.
-          The dictionary chosen by the compressor can be determined from the
-          Adler value thrown by the call to <c>inflate/2</c>.
-          The compressor and decompressor must use the same dictionary (see
-          <seealso marker="#deflateSetDictionary/2">
-          <c>deflateSetDictionary/2</c></seealso>).</p>
+           uncompressed byte sequence. This function must be called as a
+           response to an inflate operation (eg.
+           <seealso marker="#safeInflate/2"><c>safeInflate/2</c></seealso>)
+           returning <c>{need_dictionary,Adler,Output}</c> or in the case of
+           deprecated functions, throwing an
+           <c>{'EXIT',{{need_dictionary,Adler},_StackTrace}}</c> exception.</p>
+        <p>The dictionary chosen by the compressor can be determined from the
+           Adler value returned or thrown by the call to the inflate function.
+           The compressor and decompressor must use the same dictionary (See
+           <seealso marker="#deflateSetDictionary/2">
+           <c>deflateSetDictionary/2</c></seealso>).</p>
+        <p>After setting the dictionary the inflate operation should be
+           retried without new input.</p>
         <p>Example:</p>
         <pre>
-unpack(Z, Compressed, Dict) ->
+deprecated_unpack(Z, Compressed, Dict) ->
      case catch zlib:inflate(Z, Compressed) of
-          {'EXIT',{{need_dictionary,DictID},_}} ->
-                   zlib:inflateSetDictionary(Z, Dict),
+          {'EXIT',{{need_dictionary,_DictID},_}} ->
+                 ok = zlib:inflateSetDictionary(Z, Dict),
                  Uncompressed = zlib:inflate(Z, []);
           Uncompressed ->
                  Uncompressed
-     end.</pre>
+     end.
+
+new_unpack(Z, Compressed, Dict) ->
+    case zlib:inflate(Z, Compressed, [{exception_on_need_dict, false}]) of
+        {need_dictionary, _DictId, Output} ->
+            ok = zlib:inflateSetDictionary(Z, Dict),
+            [Output | zlib:inflate(Z, [])];
+        Uncompressed ->
+            Uncompressed
+    end.</pre>
       </desc>
     </func>
 
     <func>
-      <name name="inflateGetDictionary" arity="1"/>
-      <fsummary>Return the decompression dictionary.</fsummary>
+      <name name="open" arity="0"/>
+      <fsummary>Open a stream and return a stream reference.</fsummary>
       <desc>
-        <p>Returns the decompression dictionary currently in use
-          by the stream. This function must be called between
-          <seealso marker="#inflateInit/1"><c>inflateInit/1,2</c></seealso>
-          and <seealso marker="#inflateEnd/1"><c>inflateEnd</c></seealso>.</p>
-        <p>Only supported if ERTS was compiled with zlib >= 1.2.8.</p>
+        <p>Opens a zlib stream.</p>
       </desc>
     </func>
 
     <func>
-      <name name="open" arity="0"/>
-      <fsummary>Open a stream and return a stream reference.</fsummary>
+      <name name="safeInflate" arity="2"/>
+      <fsummary>Decompress data with limited output size.</fsummary>
       <desc>
-        <p>Opens a zlib stream.</p>
+        <p>Like <seealso marker="#inflate/2"><c>inflate/2</c></seealso>,
+           but returns once it has expanded beyond a small 
+           implementation-defined threshold. It's useful when decompressing
+           untrusted input which could have been maliciously crafted to expand
+           until the system runs out of memory.</p>
+        <p>This function returns <c>{continue | finished, Output}</c>, where
+           <anno>Output</anno> is the data that was decompressed in this call.
+           New input can be queued up on each call if desired, and the function
+           will return <c>{finished, Output}</c> once all queued data has been
+           decompressed.</p>
+        <p>This function can introduce some output latency (reading
+           input without producing any output).</p>
+        <p>If a preset dictionary is required for further decompression, this
+           function returns a <c>need_dictionary</c> tuple. See
+           <seealso marker="#inflateSetDictionary/2">
+           <c>inflateSetDictionary/2</c></seealso>) for details.</p>
+        <p>Example:</p>
+        <pre>
+walk(Compressed, Handler) ->
+    Z = zlib:open(),
+    zlib:inflateInit(Z),
+    loop(Z, Handler, zlib:safeInflate(Z, Compressed)),
+    zlib:inflateEnd(Z),
+    zlib:close(Z).
+
+loop(Z, Handler, {continue, Output}) ->
+    Handler(Output),
+    loop(Z, Handler, zlib:safeInflate(Z, []));
+loop(Z, Handler, {finished, Output}) ->
+    Handler(Output).</pre>
       </desc>
     </func>
 
@@ -609,6 +728,10 @@ unpack(Z, Compressed, Dict) ->
       <fsummary>Set buffer size.</fsummary>
       <desc>
         <p>Sets the intermediate buffer size.</p>
+        <warning>
+          <p>This function is deprecated and will be removed in a future
+             release.</p>
+        </warning>
       </desc>
     </func>
 
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;
+}
diff --git a/erts/preloaded/ebin/init.beam b/erts/preloaded/ebin/init.beam
index 2acb1f1211..1c8d0e626a 100644
--- a/erts/preloaded/ebin/init.beam
+++ b/erts/preloaded/ebin/init.beam
diff --git a/erts/preloaded/ebin/zlib.beam b/erts/preloaded/ebin/zlib.beam
index a959ebaaf2..173020b00d 100644
--- a/erts/preloaded/ebin/zlib.beam
+++ b/erts/preloaded/ebin/zlib.beam
diff --git a/erts/preloaded/src/init.erl b/erts/preloaded/src/init.erl
index 1ccf8d599f..34a9f6b8b9 100644
--- a/erts/preloaded/src/init.erl
+++ b/erts/preloaded/src/init.erl
@@ -200,6 +200,8 @@ boot(BootArgs) ->
     register(init, self()),
     process_flag(trap_exit, true),
 
+    %% Load the zlib nif
+    zlib:on_load(),
     %% Load the tracer nif
     erl_tracer:on_load(),
 
diff --git a/erts/preloaded/src/zlib.erl b/erts/preloaded/src/zlib.erl
index 8cd3e39fd7..2731dddcb5 100644
--- a/erts/preloaded/src/zlib.erl
+++ b/erts/preloaded/src/zlib.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2003-2016. All Rights Reserved.
+%% 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.
@@ -21,19 +21,29 @@
 -module(zlib).
 
 -export([open/0,close/1,deflateInit/1,deflateInit/2,deflateInit/6,
-	 deflateSetDictionary/2,deflateReset/1,deflateParams/3,
-	 deflate/2,deflate/3,deflateEnd/1,
-	 inflateInit/1,inflateInit/2,
-	 inflateSetDictionary/2,inflateGetDictionary/1,
-	 inflateSync/1,inflateReset/1,inflate/2,inflateEnd/1,
-	 inflateChunk/1, inflateChunk/2,
-	 setBufSize/2,getBufSize/1,
-	 crc32/1,crc32/2,crc32/3,adler32/2,adler32/3,getQSize/1,
-	 crc32_combine/4,adler32_combine/4,
-	 compress/1,uncompress/1,zip/1,unzip/1,
-	 gzip/1,gunzip/1]).
-
--export_type([zstream/0, zlevel/0, zwindowbits/0, zmemlevel/0, zstrategy/0]).
+         deflateSetDictionary/2,deflateReset/1,deflateParams/3,
+         deflate/2,deflate/3,deflateEnd/1,
+         inflateInit/1,inflateInit/2,
+         inflateSetDictionary/2,inflateGetDictionary/1, inflateReset/1,
+         inflate/2,inflate/3,inflateEnd/1,
+         inflateChunk/2,inflateChunk/1,
+         safeInflate/2,
+         setBufSize/2,getBufSize/1,
+         crc32/1,crc32/2,crc32/3,adler32/2,adler32/3,
+         crc32_combine/4,adler32_combine/4,
+         compress/1,uncompress/1,zip/1,unzip/1,
+         gzip/1,gunzip/1]).
+
+-export([on_load/0]).
+
+%% These are soft-deprecated until OTP 21.
+% -deprecated([inflateChunk/1, inflateChunk/2,
+%              getBufSize/1, setBufSize/2,
+%              crc32/1,crc32/2,crc32/3,adler32/2,adler32/3,
+%              crc32_combine/4,adler32_combine/4]).
+
+-export_type([zstream/0, zflush/0, zlevel/0, zwindowbits/0, zmemlevel/0,
+              zstrategy/0]).
 
 %% flush argument encoding
 -define(Z_NO_FLUSH,      0).
@@ -56,116 +66,76 @@
 %% deflate compression method
 -define(Z_DEFLATED,  8).
 
--define(Z_NULL, 0).
-
 -define(MAX_WBITS, 15).
 
-%% gzip defs (rfc 1952)
-
--define(ID1, 16#1f).
--define(ID2, 16#8b).
-
--define(FTEXT,     16#01).
--define(FHCRC,     16#02).
--define(FEXTRA,    16#04).
--define(FNAME,     16#08).
--define(FCOMMENT,  16#10).
--define(RESERVED,  16#E0).
-
--define(OS_MDDOS,   0).
--define(OS_AMIGA,   1).
--define(OS_OPENVMS, 2).
--define(OS_UNIX,    3).
--define(OS_VMCMS,   4).
--define(OS_ATARI,   5).
--define(OS_OS2,     6).
--define(OS_MAC,     7).
--define(OS_ZSYS,    8).
--define(OS_CPM,     9).
--define(OS_TOP20,  10).
--define(OS_NTFS,   11).
--define(OS_QDOS,   12).
--define(OS_ACORN,  13).
--define(OS_UNKNOWN,255).
-
--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(INFLATE_CHUNK,   26).
-
--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).
+%% Chunk sizes are hardcoded on account of them screwing with the
+%% predictability of the system. zlib is incapable of trapping so we need to
+%% ensure that it never operates on any significant amount of data.
+-define(DEFLATE_IN_CHUNKSIZE, 8 bsl 10).
+-define(DEFLATE_OUT_CHUNKSIZE, 8 bsl 10).
+-define(INFLATE_IN_CHUNKSIZE, 8 bsl 10).
+-define(INFLATE_OUT_CHUNKSIZE, 16 bsl 10).
 
 %%------------------------------------------------------------------------
 
-%% Main data types of the file
--type zstream()     :: port().
+%% Public data types.
+-type zstream() :: term().
+-type zflush() :: 'none' | 'sync' | 'full' | 'finish'.
 
-%% Auxiliary data types of the file
--type zlevel()      :: 'none' | 'default' | 'best_compression' | 'best_speed' 
-                     | 0..9.
--type zmethod()     :: 'deflated'.
+-type zlevel() ::
+    'none' | 'default' | 'best_compression' | 'best_speed' | 0..9.
+-type zstrategy() :: 'default' | 'filtered' | 'huffman_only' | 'rle'.
+
+-type zmemlevel() :: 1..9.
 -type zwindowbits() :: -15..-8 | 8..47.
--type zmemlevel()   :: 1..9.
--type zstrategy()   :: 'default' | 'filtered' | 'huffman_only' | 'rle'.
+
+%% Private data types.
+
+-type zmethod()     :: 'deflated'.
+
+-record(zlib_opts, {
+        stream :: zstream(),
+        method :: term(),
+        input_chunk_size :: integer(),
+        output_chunk_size :: integer(),
+        flush :: integer()
+    }).
 
 %%------------------------------------------------------------------------
 
-%% open a z_stream
+on_load() ->
+    case erlang:load_nif(atom_to_list(?MODULE), 0) of
+        ok -> ok
+    end.
+
 -spec open() -> zstream().
 open() ->
-    open_port({spawn, "zlib_drv"}, [binary]).
+    open_nif().
+open_nif() ->
+    erlang:nif_error(undef).
 
-%% close and release z_stream
 -spec close(Z) -> 'ok' when
       Z :: zstream().
 close(Z) ->
-    try
-	true = port_close(Z),
-	receive	      %In case the caller is the owner and traps exits
-	    {'EXIT',Z,_} -> ok
-	after 0 -> ok
-	end
-    catch _:_ -> erlang:error(badarg)
-    end.
+    close_nif(Z).
+close_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec deflateInit(Z) -> 'ok' when
       Z :: zstream().
 deflateInit(Z) ->
-    call(Z, ?DEFLATE_INIT, <<?Z_DEFAULT_COMPRESSION:32>>).
+    deflateInit(Z, default).
 
 -spec deflateInit(Z, Level) -> 'ok' when
       Z :: zstream(),
       Level :: zlevel().
 deflateInit(Z, Level) ->
-    call(Z, ?DEFLATE_INIT, <<(arg_level(Level)):32>>).
+    deflateInit_nif(Z, arg_level(Level)).
+
+deflateInit_nif(_Z, _Level) ->
+    erlang:nif_error(undef).
 
--spec deflateInit(Z, Level, Method,
-		  WindowBits, MemLevel, Strategy) -> 'ok' when
+-spec deflateInit(Z, Level, Method, WindowBits, MemLevel, Strategy) -> 'ok' when
       Z :: zstream(),
       Level :: zlevel(),
       Method :: zmethod(),
@@ -173,31 +143,49 @@ deflateInit(Z, Level) ->
       MemLevel :: zmemlevel(),
       Strategy :: zstrategy().
 deflateInit(Z, Level, Method, WindowBits, MemLevel, Strategy) ->
-    call(Z, ?DEFLATE_INIT2, <<(arg_level(Level)):32, 
-			     (arg_method(Method)):32,
-			     (arg_bitsz(WindowBits)):32, 
-			     (arg_mem(MemLevel)):32,
-			     (arg_strategy(Strategy)):32>>).
+    deflateInit_nif(Z,
+                    arg_level(Level),
+                    arg_method(Method),
+                    arg_bitsz(WindowBits),
+                    arg_mem(MemLevel),
+                    arg_strategy(Strategy)).
+deflateInit_nif(_Z, _Level, _Method, _WindowBits, _MemLevel, _Strategy) ->
+    erlang:nif_error(undef).
 
 -spec deflateSetDictionary(Z, Dictionary) -> Adler32 when
       Z :: zstream(),
       Dictionary :: iodata(),
       Adler32 :: integer().
 deflateSetDictionary(Z, Dictionary) ->
-    call(Z, ?DEFLATE_SETDICT, Dictionary).
+    deflateSetDictionary_nif(Z, Dictionary).
+deflateSetDictionary_nif(_Z, _Dictionary) ->
+    erlang:nif_error(undef).
 
 -spec deflateReset(Z) -> 'ok' when
       Z :: zstream().
 deflateReset(Z) ->
-    call(Z, ?DEFLATE_RESET, []).
+    deflateReset_nif(Z).
+deflateReset_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec deflateParams(Z, Level, Strategy) -> ok when
       Z :: zstream(),
       Level :: zlevel(),
       Strategy :: zstrategy().
-deflateParams(Z, Level, Strategy) ->
-    call(Z, ?DEFLATE_PARAMS, <<(arg_level(Level)):32, 
-			      (arg_strategy(Strategy)):32>>).
+deflateParams(Z, Level0, Strategy0) ->
+    Level = arg_level(Level0),
+    Strategy = arg_strategy(Strategy0),
+    case deflateParams_nif(Z, Level, Strategy) of
+        buf_error ->
+            %% We had data left in the pipe; flush everything and stash it away
+            %% for the next deflate call before trying again.
+            Output = deflate(Z, <<>>, full),
+            save_progress(Z, deflate, Output),
+            deflateParams_nif(Z, Level, Strategy);
+        Any -> Any
+    end.
+deflateParams_nif(_Z, _Level, _Strategy) ->
+    erlang:nif_error(undef).
 
 -spec deflate(Z, Data) -> Compressed when
       Z :: zstream(),
@@ -209,170 +197,234 @@ deflate(Z, Data) ->
 -spec deflate(Z, Data, Flush) -> Compressed when
       Z :: zstream(),
       Data :: iodata(),
-      Flush :: none | sync | full | finish,
+      Flush :: zflush(),
       Compressed :: iolist().
 deflate(Z, Data, Flush) ->
-    try port_command(Z, Data) of
-	true ->
-	    _ = call(Z, ?DEFLATE, <<(arg_flush(Flush)):32>>),
-	    collect(Z)
-    catch 
-	error:_Err ->
-	    flush(Z),
-	    erlang:error(badarg) 
-    end.
+    Progress = restore_progress(Z, deflate),
+    enqueue_input(Z, Data),
+    append_iolist(Progress, dequeue_all_chunks(Z, deflate_opts(Flush))).
+
+deflate_opts(Flush) ->
+    #zlib_opts{
+        method = fun deflate_nif/4,
+        input_chunk_size = ?DEFLATE_IN_CHUNKSIZE,
+        output_chunk_size = ?DEFLATE_OUT_CHUNKSIZE,
+        flush = arg_flush(Flush)
+    }.
+
+deflate_nif(_Z, _InputChSize, _OutputChSize, _Flush) ->
+    erlang:nif_error(undef).
 
 -spec deflateEnd(Z) -> 'ok' when
       Z :: zstream().
 deflateEnd(Z) ->
-    call(Z, ?DEFLATE_END, []).    
+    deflateEnd_nif(Z).
+deflateEnd_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec inflateInit(Z) -> 'ok' when
       Z :: zstream().
 inflateInit(Z) ->
-    call(Z, ?INFLATE_INIT, []).
+    inflateInit_nif(Z).
+inflateInit_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec inflateInit(Z, WindowBits) -> 'ok' when
       Z :: zstream(),
       WindowBits :: zwindowbits().
-inflateInit(Z, WindowBits) -> 
-    call(Z, ?INFLATE_INIT2, <<(arg_bitsz(WindowBits)):32>>).
+inflateInit(Z, WindowBits) ->
+    inflateInit_nif(Z, WindowBits).
+inflateInit_nif(_Z, _WindowBits) ->
+    erlang:nif_error(undef).
 
 -spec inflateSetDictionary(Z, Dictionary) -> 'ok' when
       Z :: zstream(),
       Dictionary :: iodata().
-inflateSetDictionary(Z, Dictionary) -> 
-    call(Z, ?INFLATE_SETDICT, Dictionary).
+inflateSetDictionary(Z, Dictionary) ->
+    inflateSetDictionary_nif(Z, Dictionary).
+inflateSetDictionary_nif(_Z, _Dictionary) ->
+    erlang:nif_error(undef).
 
 -spec inflateGetDictionary(Z) -> Dictionary when
       Z :: zstream(),
-      Dictionary :: iolist().
+      Dictionary :: binary().
 inflateGetDictionary(Z) ->
-    _ = call(Z, ?INFLATE_GETDICT, []),
-    collect(Z).
-
--spec inflateSync(zstream()) -> 'ok'.
-inflateSync(Z) -> 
-    call(Z, ?INFLATE_SYNC, []).
+    case inflateGetDictionary_nif(Z) of
+        Dictionary when is_binary(Dictionary) ->
+            Dictionary;
+        not_supported ->
+            erlang:error(enotsup)
+    end.
+inflateGetDictionary_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec inflateReset(Z) -> 'ok' when
       Z :: zstream().
-inflateReset(Z) -> 
-    call(Z, ?INFLATE_RESET, []).
+inflateReset(Z) ->
+    inflateReset_nif(Z).
+inflateReset_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec inflate(Z, Data) -> Decompressed when
       Z :: zstream(),
       Data :: iodata(),
       Decompressed :: iolist().
 inflate(Z, Data) ->
-    try port_command(Z, Data) of
-	true -> 
-	    _ = call(Z, ?INFLATE, <<?Z_NO_FLUSH:32>>),
-	    collect(Z)
-    catch 
-	error:_Err ->
-	    flush(Z),
-	    erlang:error(badarg) 
+    inflate(Z, Data, []).
+
+-spec inflate(Z, Data, Options) -> Decompressed when
+      Z :: zstream(),
+      Data :: iodata(),
+      Options :: list({exception_on_need_dict, boolean()}),
+      Decompressed :: iolist() |
+                      {need_dictionary,
+                       Adler32 :: integer(),
+                       Output :: iolist()}.
+inflate(Z, Data, Options) ->
+    enqueue_input(Z, Data),
+    Result = dequeue_all_chunks(Z, inflate_opts()),
+    case proplist_get_value(Options, exception_on_need_dict, true) of
+        true -> exception_on_need_dict(Z, Result);
+        false -> Result
     end.
 
+inflate_nif(_Z, _InputChSize, _OutputChSize, _Flush) ->
+    erlang:nif_error(undef).
+
+inflate_opts() ->
+    #zlib_opts{
+        method = fun inflate_nif/4,
+        input_chunk_size = ?INFLATE_IN_CHUNKSIZE,
+        output_chunk_size = ?INFLATE_OUT_CHUNKSIZE,
+        flush = arg_flush(none)
+    }.
+
 -spec inflateChunk(Z, Data) -> Decompressed | {more, Decompressed} when
       Z :: zstream(),
       Data :: iodata(),
       Decompressed :: iolist().
 inflateChunk(Z, Data) ->
-    try port_command(Z, Data) of
-	true ->
-        inflateChunk(Z)
-    catch
-	error:_Err ->
-	    flush(Z),
-	    erlang:error(badarg)
-    end.
+    enqueue_input(Z, Data),
+    inflateChunk(Z).
 
 -spec inflateChunk(Z) -> Decompressed | {more, Decompressed} when
       Z :: zstream(),
       Decompressed :: iolist().
 inflateChunk(Z) ->
-    Status = call(Z, ?INFLATE_CHUNK, []),
-    Data = receive
-	{Z, {data, Bin}} ->
-	    Bin
-    after 0 ->
-	    []
-    end,
-
-    case Status of
-        Good when (Good == ok) orelse (Good == stream_end) ->
-            Data;
-        inflate_has_more ->
-            {more, Data}
-    end.
+    Opts0 = inflate_opts(),
+    Opts = Opts0#zlib_opts { output_chunk_size = getBufSize(Z) },
+
+    Result0 = dequeue_next_chunk(Z, Opts),
+    Result1 = exception_on_need_dict(Z, Result0),
+    yield_inflateChunk(Z, Result1).
+
+yield_inflateChunk(_Z, {continue, Output}) ->
+    {more, lists:flatten(Output)};
+yield_inflateChunk(_Z, {finished, Output}) ->
+    lists:flatten(Output).
+
+exception_on_need_dict(Z, {need_dictionary, Adler, Output}) ->
+    Progress = restore_progress(Z, inflate),
+    save_progress(Z, inflate, append_iolist(Progress, Output)),
+    erlang:error({need_dictionary, Adler});
+exception_on_need_dict(Z, {Mark, Output}) ->
+    Progress = restore_progress(Z, inflate),
+    {Mark, append_iolist(Progress, Output)};
+exception_on_need_dict(Z, Output) when is_list(Output); is_binary(Output) ->
+    Progress = restore_progress(Z, inflate),
+    append_iolist(Progress, Output).
+
+-spec safeInflate(Z, Data) -> Result when
+      Z :: zstream(),
+      Data :: iodata(),
+      Result :: {continue, Output :: iolist()} |
+                {finished, Output :: iolist()} |
+                {need_dictionary,
+                 Adler32 :: integer(),
+                 Output :: iolist()}.
+safeInflate(Z, Data) ->
+    enqueue_input(Z, Data),
+    dequeue_next_chunk(Z, inflate_opts()).
 
 -spec inflateEnd(Z) -> 'ok' when
       Z :: zstream().
 inflateEnd(Z) ->
-    call(Z, ?INFLATE_END, []).
+    inflateEnd_nif(Z).
+inflateEnd_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec setBufSize(Z, Size) -> 'ok' when
       Z :: zstream(),
       Size :: non_neg_integer().
-setBufSize(Z, Size) ->
-    call(Z, ?SET_BUFSZ, <<Size:32>>).
+setBufSize(Z, Size) when is_integer(Size), Size > 16, Size < (1 bsl 24) ->
+    setBufSize_nif(Z, Size);
+setBufSize(_Z, _Size) ->
+    erlang:error(badarg).
+setBufSize_nif(_Z, _Size) ->
+    erlang:nif_error(undef).
 
--spec getBufSize(Z) -> Size when
-      Z :: zstream(),
-      Size :: non_neg_integer().
+-spec getBufSize(Z) -> non_neg_integer() when
+      Z :: zstream().
 getBufSize(Z) ->
-    call(Z, ?GET_BUFSZ, []).
+    getBufSize_nif(Z).
+getBufSize_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec crc32(Z) -> CRC when
       Z :: zstream(),
       CRC :: integer().
 crc32(Z) ->
-    call(Z, ?CRC32_0, []).
+    crc32_nif(Z).
+crc32_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec crc32(Z, Data) -> CRC when
       Z :: zstream(),
       Data :: iodata(),
       CRC :: integer().
-crc32(Z, Data) ->
-    call(Z, ?CRC32_1, Data).
+crc32(Z, Data) when is_reference(Z) ->
+    erlang:crc32(Data);
+crc32(_Z, _Data) ->
+    erlang:error(badarg).
 
 -spec crc32(Z, PrevCRC, Data) -> CRC when
       Z :: zstream(),
       PrevCRC :: integer(),
       Data :: iodata(),
       CRC :: integer().
-crc32(Z, CRC, Data) ->
-    call(Z, ?CRC32_2, [<<CRC:32>>, Data]).
+crc32(Z, CRC, Data) when is_reference(Z) ->
+    erlang:crc32(CRC, Data);
+crc32(_Z, _CRC, _Data) ->
+    erlang:error(badarg).
+
+-spec crc32_combine(Z, CRC1, CRC2, Size2) -> CRC when
+      Z :: zstream(),
+      CRC :: integer(),
+      CRC1 :: integer(),
+      CRC2 :: integer(),
+      Size2 :: integer().
+crc32_combine(Z, CRC1, CRC2, Size2) when is_reference(Z) ->
+    erlang:crc32_combine(CRC1, CRC2, Size2);
+crc32_combine(_Z, _CRC1, _CRC2, _Size2) ->
+    erlang:error(badarg).
 
 -spec adler32(Z, Data) -> CheckSum when
       Z :: zstream(),
       Data :: iodata(),
       CheckSum :: integer().
-adler32(Z, Data) ->
-    call(Z, ?ADLER32_1, Data).
+adler32(Z, Data) when is_reference(Z) ->
+    erlang:adler32(Data);
+adler32(_Z, _Data) ->
+    erlang:error(badarg).
 
 -spec adler32(Z, PrevAdler, Data) -> CheckSum when
       Z :: zstream(),
       PrevAdler :: integer(),
       Data :: iodata(),
       CheckSum :: integer().
-adler32(Z, Adler, Data) when is_integer(Adler) ->
-    call(Z, ?ADLER32_2, [<<Adler:32>>, Data]);
-adler32(_Z, _Adler, _Data)  ->
-    erlang:error(badarg).
-
--spec crc32_combine(Z, CRC1, CRC2, Size2) -> CRC when
-      Z :: zstream(),
-      CRC :: integer(),
-      CRC1 :: integer(),
-      CRC2 :: integer(),
-      Size2 :: integer().
-crc32_combine(Z, CRC1, CRC2, Len2) 
-  when is_integer(CRC1), is_integer(CRC2), is_integer(Len2) ->
-    call(Z, ?CRC32_COMBINE, <<CRC1:32, CRC2:32, Len2:32>>);
-crc32_combine(_Z, _CRC1, _CRC2, _Len2) ->
+adler32(Z, Adler, Data) when is_reference(Z) ->
+    erlang:adler32(Adler, Data);
+adler32(_Z, _Adler, _Data) ->
     erlang:error(badarg).
 
 -spec adler32_combine(Z, Adler1, Adler2, Size2) -> Adler when
@@ -381,16 +433,11 @@ crc32_combine(_Z, _CRC1, _CRC2, _Len2) ->
       Adler1 :: integer(),
       Adler2 :: integer(),
       Size2 :: integer().
-adler32_combine(Z, Adler1, Adler2, Len2) 
-  when is_integer(Adler1), is_integer(Adler2), is_integer(Len2) ->
-    call(Z, ?ADLER32_COMBINE, <<Adler1:32, Adler2:32, Len2:32>>);
-adler32_combine(_Z, _Adler1, _Adler2, _Len2) ->
+adler32_combine(Z, Adler1, Adler2, Size2) when is_reference(Z) ->
+    erlang:adler32_combine(Adler1, Adler2, Size2);
+adler32_combine(_Z, _Adler1, _Adler2, _Size2) ->
     erlang:error(badarg).
 
--spec getQSize(zstream()) -> non_neg_integer().
-getQSize(Z) ->
-    call(Z, ?GET_QSIZE, []).
-
 %% compress/uncompress zlib with header
 -spec compress(Data) -> Compressed when
       Data :: iodata(),
@@ -398,13 +445,13 @@ getQSize(Z) ->
 compress(Data) ->
     Z = open(),
     Bs = try
-	     deflateInit(Z, default),
-	     B = deflate(Z, Data, finish),
-	     deflateEnd(Z),
-	     B
-	 after
-	     close(Z)
-	 end,
+             deflateInit(Z, default),
+             B = deflate(Z, Data, finish),
+             deflateEnd(Z),
+             B
+         after
+             close(Z)
+         end,
     iolist_to_binary(Bs).
 
 -spec uncompress(Data) -> Decompressed when
@@ -416,14 +463,14 @@ uncompress(Data) ->
             if
                 Size >= 8 ->
                     Z = open(),
-		    Bs = try
-			     inflateInit(Z),
-			     B = inflate(Z, Data),
-			     inflateEnd(Z),
-			     B
-			 after
-			     close(Z)
-			 end,
+                    Bs = try
+                             inflateInit(Z),
+                             B = inflate(Z, Data),
+                             inflateEnd(Z),
+                             B
+                         after
+                             close(Z)
+                         end,
                     iolist_to_binary(Bs);
                 true ->
                     erlang:error(data_error)
@@ -440,13 +487,13 @@ uncompress(Data) ->
 zip(Data) ->
     Z = open(),
     Bs = try
-	     deflateInit(Z, default, deflated, -?MAX_WBITS, 8, default),
-	     B = deflate(Z, Data, finish),
-	     deflateEnd(Z),
-	     B
-	 after
-	     close(Z)
-	 end,
+             deflateInit(Z, default, deflated, -?MAX_WBITS, 8, default),
+             B = deflate(Z, Data, finish),
+             deflateEnd(Z),
+             B
+         after
+             close(Z)
+         end,
     iolist_to_binary(Bs).
 
 -spec unzip(Data) -> Decompressed when
@@ -455,28 +502,28 @@ zip(Data) ->
 unzip(Data) ->
     Z = open(),
     Bs = try
-	     inflateInit(Z, -?MAX_WBITS),
-	     B = inflate(Z, Data),
-	     inflateEnd(Z),
-	     B
-	 after
-	     close(Z)
-	 end,
+             inflateInit(Z, -?MAX_WBITS),
+             B = inflate(Z, Data),
+             inflateEnd(Z),
+             B
+         after
+             close(Z)
+         end,
     iolist_to_binary(Bs).
-    
+
 -spec gzip(Data) -> Compressed when
       Data :: iodata(),
       Compressed :: binary().
 gzip(Data) ->
     Z = open(),
     Bs = try
-	     deflateInit(Z, default, deflated, 16+?MAX_WBITS, 8, default),
-	     B = deflate(Z, Data, finish),
-	     deflateEnd(Z),
-	     B
-	 after
-	     close(Z)
-	 end,
+             deflateInit(Z, default, deflated, 16+?MAX_WBITS, 8, default),
+             B = deflate(Z, Data, finish),
+             deflateEnd(Z),
+             B
+         after
+             close(Z)
+         end,
     iolist_to_binary(Bs).
 
 -spec gunzip(Data) -> Decompressed when
@@ -485,42 +532,108 @@ gzip(Data) ->
 gunzip(Data) ->
     Z = open(),
     Bs = try
-	     inflateInit(Z, 16+?MAX_WBITS),
-	     B = inflate(Z, Data),
-	     inflateEnd(Z),
-	     B
-	 after
-	     close(Z)
-	 end,
+             inflateInit(Z, 16+?MAX_WBITS),
+             B = inflate(Z, Data),
+             inflateEnd(Z),
+             B
+         after
+             close(Z)
+         end,
     iolist_to_binary(Bs).
 
--spec collect(zstream()) -> iolist().
-collect(Z) -> 
-    collect(Z, []).
-
--spec collect(zstream(), iolist()) -> iolist().
-collect(Z, Acc) ->
-    receive 
-	{Z, {data, Bin}} ->
-	    collect(Z, [Bin|Acc])
-    after 0 ->
-	    reverse(Acc)
+-spec dequeue_all_chunks(Z, Opts) -> Result when
+    Z :: zstream(),
+    Opts :: #zlib_opts{},
+    Result :: {need_dictionary, integer(), iolist()} |
+              iolist().
+dequeue_all_chunks(Z, Opts) ->
+    dequeue_all_chunks_1(Z, Opts, []).
+dequeue_all_chunks_1(Z, Opts, Output) ->
+    case dequeue_next_chunk(Z, Opts) of
+        {need_dictionary, _, _} = NeedDict ->
+            NeedDict;
+        {continue, Chunk} ->
+            dequeue_all_chunks_1(Z, Opts, append_iolist(Output, Chunk));
+        {finished, Chunk} ->
+            append_iolist(Output, Chunk)
     end.
 
--spec flush(zstream()) -> 'ok'.
-flush(Z) ->
-    receive
-	{Z, {data,_}} ->
-	    flush(Z)
-    after 0 ->
-	    ok
+-spec dequeue_next_chunk(Z, Opts) -> Result when
+    Z :: zstream(),
+    Opts :: #zlib_opts{},
+    Result :: {need_dictionary, integer(), iolist()} |
+              {continue, iolist()} |
+              {finished, iolist()}.
+dequeue_next_chunk(Z, Opts) ->
+    Method = Opts#zlib_opts.method,
+    IChSz = Opts#zlib_opts.input_chunk_size,
+    OChSz = Opts#zlib_opts.output_chunk_size,
+    Flush = Opts#zlib_opts.flush,
+    Method(Z, IChSz, OChSz, Flush).
+
+-spec append_iolist(IO, D) -> iolist() when
+    IO :: iodata(),
+    D :: iodata().
+append_iolist([], D) when is_list(D) -> D;
+append_iolist([], D) -> [D];
+append_iolist(IO, []) -> IO;
+append_iolist(IO, [D]) -> [IO, D];
+append_iolist(IO, D) -> [IO, D].
+
+%% inflate/2 and friends are documented as throwing an error on Z_NEED_DICT
+%% rather than simply returning something to that effect, and deflateParams/3
+%% may flush behind the scenes. This requires us to stow away our current
+%% progress in the handle and resume from that point on our next call.
+%%
+%% Generally speaking this is either a refc binary or nothing at all, so it's
+%% pretty cheap.
+
+-spec save_progress(Z, Kind, Output) -> ok when
+      Z :: zstream(),
+      Kind :: inflate | deflate,
+      Output :: iolist().
+save_progress(Z, Kind, Output) ->
+    ok = setStash_nif(Z, {Kind, Output}).
+
+-spec restore_progress(Z, Kind) -> iolist() when
+    Z :: zstream(),
+    Kind :: inflate | deflate.
+restore_progress(Z, Kind) ->
+    case getStash_nif(Z) of
+        {ok, {Kind, Output}} ->
+            ok = clearStash_nif(Z),
+            Output;
+        empty ->
+            []
     end.
-    
-arg_flush(none)    -> ?Z_NO_FLUSH;
+
+-spec clearStash_nif(Z) -> ok when
+      Z :: zstream().
+clearStash_nif(_Z) ->
+    erlang:nif_error(undef).
+
+-spec setStash_nif(Z, Term) -> ok when
+      Z :: zstream(),
+      Term :: term().
+setStash_nif(_Z, _Term) ->
+    erlang:nif_error(undef).
+
+-spec getStash_nif(Z) -> {ok, term()} | empty when
+      Z :: zstream().
+getStash_nif(_Z) ->
+    erlang:nif_error(undef).
+
+%% The 'proplists' module isn't preloaded so we can't rely on its existence.
+proplist_get_value([], _Name, DefVal) -> DefVal;
+proplist_get_value([{Name, Value} | _Opts], Name, _DefVal) -> Value;
+proplist_get_value([_Head | Opts], Name, DefVal) ->
+    proplist_get_value(Opts, Name, DefVal).
+
+arg_flush(none)   -> ?Z_NO_FLUSH;
 %% ?Z_PARTIAL_FLUSH is deprecated in zlib -- deliberately not included.
-arg_flush(sync)    -> ?Z_SYNC_FLUSH;
-arg_flush(full)    -> ?Z_FULL_FLUSH;
-arg_flush(finish)  -> ?Z_FINISH;
+arg_flush(sync)   -> ?Z_SYNC_FLUSH;
+arg_flush(full)   -> ?Z_FULL_FLUSH;
+arg_flush(finish) -> ?Z_FINISH;
 arg_flush(_) -> erlang:error(badarg).
 
 arg_level(none)             -> ?Z_NO_COMPRESSION;
@@ -529,7 +642,7 @@ arg_level(best_compression) -> ?Z_BEST_COMPRESSION;
 arg_level(default)          -> ?Z_DEFAULT_COMPRESSION;
 arg_level(Level) when is_integer(Level), Level >= 0, Level =< 9 -> Level;
 arg_level(_) -> erlang:error(badarg).
-     
+
 arg_strategy(filtered) ->     ?Z_FILTERED;
 arg_strategy(huffman_only) -> ?Z_HUFFMAN_ONLY;
 arg_strategy(rle) -> ?Z_RLE;
@@ -541,8 +654,8 @@ arg_method(_) -> erlang:error(badarg).
 
 -spec arg_bitsz(zwindowbits()) -> zwindowbits().
 arg_bitsz(Bits) when is_integer(Bits) andalso
-		     ((8 =< Bits andalso Bits < 48) orelse
-		      (-15 =< Bits andalso Bits =< -8)) ->
+                     ((8 =< Bits andalso Bits < 48) orelse
+                      (-15 =< Bits andalso Bits =< -8)) ->
     Bits;
 arg_bitsz(_) -> erlang:error(badarg).
 
@@ -550,27 +663,17 @@ arg_bitsz(_) -> erlang:error(badarg).
 arg_mem(Level) when is_integer(Level), 1 =< Level, Level =< 9 -> Level;
 arg_mem(_) -> erlang:error(badarg).
 
-call(Z, Cmd, Arg) ->
-    try port_control(Z, Cmd, Arg) of
-	[0|Res] -> list_to_atom(Res);
-	[1|Res] ->
-	    flush(Z),
-	    erlang:error(list_to_atom(Res));
-	[2,A,B,C,D] ->
-	    (A bsl 24)+(B bsl 16)+(C bsl 8)+D;
-	[3,A,B,C,D] ->
-	    erlang:error({need_dictionary,(A bsl 24)+(B bsl 16)+(C bsl 8)+D});
-	[4, _, _, _, _] ->
-	    inflate_has_more
-    catch 
-	error:badarg -> %% Rethrow loses port_control from stacktrace.
-	    erlang:error(badarg)
+-spec enqueue_input(Z, IOData) -> ok when
+      Z :: zstream(),
+      IOData :: iodata().
+enqueue_input(Z, IOData) ->
+    enqueue_input_1(Z, erlang:iolist_to_iovec(IOData)).
+
+enqueue_input_1(Z, IOVec) ->
+    case enqueue_nif(Z, IOVec) of
+        {continue, Remainder} -> enqueue_input_1(Z, Remainder);
+        ok -> ok
     end.
 
-reverse(X) ->
-    reverse(X, []).
-
-reverse([H|T], Y) ->
-    reverse(T, [H|Y]);
-reverse([], X) -> 
-    X.
+enqueue_nif(_Z, _IOVec) ->
+    erlang:nif_error(undef).
\ No newline at end of file