separate actual inflate/deflate from wrappers

src/zlib-helpers.c

@@ -31,6 +31,114 @@
 #define CHUNK 16384
 #define UNKNOWN_ERR 42
 
+static int _def(FILE *source, FILE *dest, const int level) {
+    int flush;
+    unsigned have;
+    z_stream strm;
+    unsigned char in[CHUNK];
+    unsigned char out[CHUNK];
+
+    /* allocate deflate state */
+    strm.zalloc = Z_NULL;
+    strm.zfree = Z_NULL;
+    strm.opaque = Z_NULL;
+    int ret = deflateInit(&strm, level);
+    if (ret != Z_OK) {
+        return ret;
+    }
+
+    /* compress until end of file */
+    do {
+        strm.avail_in = fread(in, 1, CHUNK, source);
+        if (ferror(source)) {
+            (void)deflateEnd(&strm);
+            return Z_ERRNO;
+        }
+        flush = feof(source) ? Z_FINISH : Z_NO_FLUSH;
+        strm.next_in = in;
+
+        /* run deflate() on input until output buffer not full, finish
+           compression if all of source has been read in */
+        do {
+            strm.avail_out = CHUNK;
+            strm.next_out = out;
+            ret = deflate(&strm, flush);    /* no bad return value */
+            assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
+            have = CHUNK - strm.avail_out;
+            if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
+                (void)deflateEnd(&strm);
+                return Z_ERRNO;
+            }
+        } while (strm.avail_out == 0);
+        assert(strm.avail_in == 0);     /* all input will be used */
+
+        /* done when last data in file processed */
+    } while (flush != Z_FINISH);
+    assert(ret == Z_STREAM_END);        /* stream will be complete */
+
+    (void)deflateEnd(&strm);
+    return Z_OK;
+}
+
+static int const _inf(FILE *source, FILE *dest) {
+    unsigned have;
+    z_stream strm;
+    unsigned char in[CHUNK];
+    unsigned char out[CHUNK];
+
+    /* allocate inflate state */
+    strm.zalloc = Z_NULL;
+    strm.zfree = Z_NULL;
+    strm.opaque = Z_NULL;
+    strm.avail_in = 0;
+    strm.next_in = Z_NULL;
+    int ret = inflateInit(&strm);
+    if (ret != Z_OK) {
+        return ret;
+    }
+
+    /* decompress until deflate stream ends or end of file */
+    do {
+        strm.avail_in = fread(in, 1, CHUNK, source);
+        if (ferror(source)) {
+            (void)inflateEnd(&strm);
+            return Z_ERRNO;
+        }
+        if (strm.avail_in == 0)
+        {
+            return UNKNOWN_ERR;
+        }
+        strm.next_in = in;
+
+        /* run inflate() on input until output buffer not full */
+        do {
+            strm.avail_out = CHUNK;
+            strm.next_out = out;
+            ret = inflate(&strm, Z_NO_FLUSH);
+            assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
+            switch (ret) {
+            case Z_NEED_DICT:
+                ret = Z_DATA_ERROR;     /* and fall through */
+            case Z_DATA_ERROR:
+            case Z_MEM_ERROR:
+                (void)inflateEnd(&strm);
+                return ret;
+            }
+            have = CHUNK - strm.avail_out;
+            if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
+                (void)inflateEnd(&strm);
+                return Z_ERRNO;
+            }
+        } while (strm.avail_out == 0);
+
+        /* done when inflate() says it's done */
+    } while (ret != Z_STREAM_END);
+
+    /* clean up and return */
+    (void)inflateEnd(&strm);
+    return Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
+}
+
 /* report a zlib or i/o error */
 static const char* const zerr(int ret, FILE *in, FILE *out)
 {
@@ -101,54 +209,7 @@ const char* const def(const char* const src, const int level)
             break;
         }
 
-        int flush;
+        ret = _def(source, dest, level);
-        unsigned have;
-        z_stream strm;
-        unsigned char in[CHUNK];
-        unsigned char out[CHUNK];
-
-        /* allocate deflate state */
-        strm.zalloc = Z_NULL;
-        strm.zfree = Z_NULL;
-        strm.opaque = Z_NULL;
-        ret = deflateInit(&strm, level);
-        if (ret != Z_OK) {
-            break;
-        }
-
-        /* compress until end of file */
-        do {
-            strm.avail_in = fread(in, 1, CHUNK, source);
-            if (ferror(source)) {
-                (void)deflateEnd(&strm);
-                ret = Z_ERRNO;
-                break;
-            }
-            flush = feof(source) ? Z_FINISH : Z_NO_FLUSH;
-            strm.next_in = in;
-
-            /* run deflate() on input until output buffer not full, finish
-               compression if all of source has been read in */
-            do {
-                strm.avail_out = CHUNK;
-                strm.next_out = out;
-                ret = deflate(&strm, flush);    /* no bad return value */
-                assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
-                have = CHUNK - strm.avail_out;
-                if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
-                    (void)deflateEnd(&strm);
-                    ret = Z_ERRNO;
-                    break;
-                }
-            } while (strm.avail_out == 0);
-            assert(strm.avail_in == 0);     /* all input will be used */
-
-            /* done when last data in file processed */
-        } while (flush != Z_FINISH);
-        assert(ret == Z_STREAM_END);        /* stream will be complete */
-
-        (void)deflateEnd(&strm);
-        ret = Z_OK;
     } while (0);
 
     const char* const err = zerr(ret, source, dest);
@@ -207,64 +268,8 @@ const char* const inf(const char* const src)
             break;
         }
 
-        unsigned have;
+        ret = _inf(source, dest);
-        z_stream strm;
-        unsigned char in[CHUNK];
-        unsigned char out[CHUNK];
 
-        /* allocate inflate state */
-        strm.zalloc = Z_NULL;
-        strm.zfree = Z_NULL;
-        strm.opaque = Z_NULL;
-        strm.avail_in = 0;
-        strm.next_in = Z_NULL;
-        ret = inflateInit(&strm);
-        if (ret != Z_OK) {
-            break;
-        }
-
-        /* decompress until deflate stream ends or end of file */
-        do {
-            strm.avail_in = fread(in, 1, CHUNK, source);
-            if (ferror(source)) {
-                (void)inflateEnd(&strm);
-                ret = Z_ERRNO;
-                break;
-            }
-            if (strm.avail_in == 0)
-            {
-                break;
-            }
-            strm.next_in = in;
-
-            /* run inflate() on input until output buffer not full */
-            do {
-                strm.avail_out = CHUNK;
-                strm.next_out = out;
-                ret = inflate(&strm, Z_NO_FLUSH);
-                assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
-                switch (ret) {
-                case Z_NEED_DICT:
-                    ret = Z_DATA_ERROR;     /* and fall through */
-                case Z_DATA_ERROR:
-                case Z_MEM_ERROR:
-                    (void)inflateEnd(&strm);
-                    break;
-                }
-                have = CHUNK - strm.avail_out;
-                if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
-                    (void)inflateEnd(&strm);
-                    ret = Z_ERRNO;
-                    break;
-                }
-            } while (strm.avail_out == 0);
-
-            /* done when inflate() says it's done */
-        } while (ret != Z_STREAM_END);
-
-        /* clean up and return */
-        (void)inflateEnd(&strm);
-        ret = Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
     } while (0);
 
     const char* const err = zerr(ret, source, dest);