src/common/Makefile.nmake

@@ -7,8 +7,8 @@ LIBOR_OBJECTS = address.obj backtrace.obj compat.obj container.obj di_ops.obj \
 	log.obj memarea.obj mempool.obj procmon.obj sandbox.obj util.obj \
 	util_codedigest.obj
 
-LIBOR_CRYPTO_OBJECTS = aes.obj crypto.obj crypto_format.obj torgzip.obj tortls.obj \
-	crypto_curve25519.obj curve25519-donna.obj
+LIBOR_CRYPTO_OBJECTS = aes.obj crypto.obj crypto_format.obj compress.obj compress_zlib.obj \
+	tortls.obj crypto_curve25519.obj curve25519-donna.obj
 
 LIBOR_EVENT_OBJECTS = compat_libevent.obj
 

src/common/compress.c

+/* Copyright (c) 2004, Roger Dingledine.
+ * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
+ * Copyright (c) 2007-2017, The Tor Project, Inc. */
+/* See LICENSE for licensing information */
+
+/**
+ * \file compress.c
+ * \brief Common compression API.
+ **/
+
+#include "orconfig.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+#include "torint.h"
+
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+#include "util.h"
+#include "torlog.h"
+#include "compress.h"
+#include "compress_zlib.h"
+
+/** @{ */
+/* These macros define the maximum allowable compression factor.  Anything of
+ * size greater than CHECK_FOR_COMPRESSION_BOMB_AFTER is not allowed to
+ * have an uncompression factor (uncompressed size:compressed size ratio) of
+ * any greater than MAX_UNCOMPRESSION_FACTOR.
+ *
+ * Picking a value for MAX_UNCOMPRESSION_FACTOR is a trade-off: we want it to
+ * be small to limit the attack multiplier, but we also want it to be large
+ * enough so that no legitimate document --even ones we might invent in the
+ * future -- ever compresses by a factor of greater than
+ * MAX_UNCOMPRESSION_FACTOR. Within those parameters, there's a reasonably
+ * large range of possible values. IMO, anything over 8 is probably safe; IMO
+ * anything under 50 is probably sufficient.
+ */
+#define MAX_UNCOMPRESSION_FACTOR 25
+#define CHECK_FOR_COMPRESSION_BOMB_AFTER (1024*64)
+/** @} */
+
+/** Return true if uncompressing an input of size <b>in_size</b> to an input of
+ * size at least <b>size_out</b> looks like a compression bomb. */
+int
+tor_compress_is_compression_bomb(size_t size_in, size_t size_out)
+{
+  if (size_in == 0 || size_out < CHECK_FOR_COMPRESSION_BOMB_AFTER)
+    return 0;
+
+  return (size_out / size_in > MAX_UNCOMPRESSION_FACTOR);
+}
+
+/** Given <b>level</b> return the memory level.  The memory level is needed for
+ * the various compression backends used in Tor.
+ */
+int
+tor_compress_memory_level(compression_level_t level)
+{
+  switch (level) {
+    default:
+    case HIGH_COMPRESSION: return 8;
+    case MEDIUM_COMPRESSION: return 7;
+    case LOW_COMPRESSION: return 6;
+  }
+}
+
+/** Given <b>in_len</b> bytes at <b>in</b>, compress them into a newly
+ * allocated buffer, using the method described in <b>method</b>.  Store the
+ * compressed string in *<b>out</b>, and its length in *<b>out_len</b>.
+ * Return 0 on success, -1 on failure.
+ */
+int
+tor_compress(char **out, size_t *out_len,
+             const char *in, size_t in_len,
+             compress_method_t method)
+{
+  if (method == GZIP_METHOD || method == ZLIB_METHOD)
+    return tor_zlib_compress(out, out_len, in, in_len, method);
+
+  return -1;
+}
+
+/** Given zero or more zlib-compressed or gzip-compressed strings of
+ * total length
+ * <b>in_len</b> bytes at <b>in</b>, uncompress them into a newly allocated
+ * buffer, using the method described in <b>method</b>.  Store the uncompressed
+ * string in *<b>out</b>, and its length in *<b>out_len</b>.  Return 0 on
+ * success, -1 on failure.
+ *
+ * If <b>complete_only</b> is true, we consider a truncated input as a
+ * failure; otherwise we decompress as much as we can.  Warn about truncated
+ * or corrupt inputs at <b>protocol_warn_level</b>.
+ */
+int
+tor_uncompress(char **out, size_t *out_len,
+               const char *in, size_t in_len,
+               compress_method_t method,
+               int complete_only,
+               int protocol_warn_level)
+{
+  if (method == GZIP_METHOD || method == ZLIB_METHOD)
+    return tor_zlib_uncompress(out, out_len, in, in_len,
+                               method,
+                               complete_only,
+                               protocol_warn_level);
+
+  return -1;
+}
+
+/** Try to tell whether the <b>in_len</b>-byte string in <b>in</b> is likely
+ * to be compressed or not.  If it is, return the likeliest compression method.
+ * Otherwise, return UNKNOWN_METHOD.
+ */
+compress_method_t
+detect_compression_method(const char *in, size_t in_len)
+{
+  if (in_len > 2 && fast_memeq(in, "\x1f\x8b", 2)) {
+    return GZIP_METHOD;
+  } else if (in_len > 2 && (in[0] & 0x0f) == 8 &&
+             (ntohs(get_uint16(in)) % 31) == 0) {
+    return ZLIB_METHOD;
+  } else {
+    return UNKNOWN_METHOD;
+  }
+}
+
+/** Internal state for an incremental compression/decompression.  The body of
+ * this struct is not exposed. */
+struct tor_compress_state_t {
+  compress_method_t method; /**< The compression method. */
+
+  union {
+    tor_zlib_compress_state_t *zlib_state;
+  } u; /**< Compression backend state. */
+};
+
+/** Construct and return a tor_compress_state_t object using <b>method</b>.  If
+ * <b>compress</b>, it's for compression; otherwise it's for decompression. */
+tor_compress_state_t *
+tor_compress_new(int compress, compress_method_t method,
+                 compression_level_t compression_level)
+{
+  tor_compress_state_t *state;
+
+  state = tor_malloc_zero(sizeof(tor_compress_state_t));
+  state->method = method;
+
+  switch (method) {
+    case GZIP_METHOD:
+    case ZLIB_METHOD: {
+      tor_zlib_compress_state_t *zlib_state =
+        tor_zlib_compress_new(compress, method, compression_level);
+
+      if (zlib_state == NULL)
+        goto err;
+
+      state->u.zlib_state = zlib_state;
+      break;
+    }
+
+    case NO_METHOD:
+    case UNKNOWN_METHOD:
+      goto err;
+  }
+
+  return state;
+
+ err:
+  tor_free(state);
+  return NULL;
+}
+
+/** Compress/decompress some bytes using <b>state</b>.  Read up to
+ * *<b>in_len</b> bytes from *<b>in</b>, and write up to *<b>out_len</b> bytes
+ * to *<b>out</b>, adjusting the values as we go.  If <b>finish</b> is true,
+ * we've reached the end of the input.
+ *
+ * Return TOR_COMPRESS_DONE if we've finished the entire
+ * compression/decompression.
+ * Return TOR_COMPRESS_OK if we're processed everything from the input.
+ * Return TOR_COMPRESS_BUFFER_FULL if we're out of space on <b>out</b>.
+ * Return TOR_COMPRESS_ERROR if the stream is corrupt.
+ */
+tor_compress_output_t
+tor_compress_process(tor_compress_state_t *state,
+                     char **out, size_t *out_len,
+                     const char **in, size_t *in_len,
+                     int finish)
+{
+  tor_assert(state != NULL);
+
+  switch (state->method) {
+    case GZIP_METHOD:
+    case ZLIB_METHOD:
+      return tor_zlib_compress_process(state->u.zlib_state,
+                                       out, out_len, in, in_len,
+                                       finish);
+
+    case NO_METHOD:
+    case UNKNOWN_METHOD:
+      goto err;
+  }
+
+ err:
+  return TOR_COMPRESS_ERROR;
+}
+
+/** Deallocate <b>state</b>. */
+void
+tor_compress_free(tor_compress_state_t *state)
+{
+  if (state == NULL)
+    return;
+
+  switch (state->method) {
+    case GZIP_METHOD:
+    case ZLIB_METHOD:
+      tor_zlib_compress_free(state->u.zlib_state);
+      break;
+
+    case NO_METHOD:
+    case UNKNOWN_METHOD:
+      break;
+  }
+
+  tor_free(state);
+}
+
+/** Return the approximate number of bytes allocated for <b>state</b>. */
+size_t
+tor_compress_state_size(const tor_compress_state_t *state)
+{
+  tor_assert(state != NULL);
+
+  switch (state->method) {
+    case GZIP_METHOD:
+    case ZLIB_METHOD:
+      return tor_zlib_compress_state_size(state->u.zlib_state);
+
+    case NO_METHOD:
+    case UNKNOWN_METHOD:
+      goto err;
+  }
+
+ err:
+  return 0;
+}
+

src/common/torgzip.h → src/common/compress.h

@@ -4,12 +4,12 @@
 /* See LICENSE for licensing information */
 
 /**
- * \file torgzip.h
- * \brief Headers for torgzip.h
+ * \file compress.h
+ * \brief Headers for compress.c
  **/
 
-#ifndef TOR_TORGZIP_H
-#define TOR_TORGZIP_H
+#ifndef TOR_COMPRESS_H
+#define TOR_COMPRESS_H
 
 /** Enumeration of what kind of compression to use.  Only ZLIB_METHOD and
  * GZIP_METHOD is guaranteed to be supported by the compress/uncompress
@@ -38,12 +38,6 @@ tor_uncompress(char **out, size_t *out_len,
                int complete_only,
                int protocol_warn_level);
 
-const char *
-tor_zlib_get_version_str(void);
-
-const char *
-tor_zlib_get_header_version_str(void);
-
 compress_method_t detect_compression_method(const char *in, size_t in_len);
 
 int
@@ -60,8 +54,10 @@ typedef enum {
   TOR_COMPRESS_BUFFER_FULL,
   TOR_COMPRESS_ERROR
 } tor_compress_output_t;
-/** Internal state for an incremental zlib compression/decompression. */
+
+/** Internal state for an incremental compression/decompression. */
 typedef struct tor_compress_state_t tor_compress_state_t;
+
 tor_compress_state_t *tor_compress_new(int compress,
                                        compress_method_t method,
                                        compression_level_t level);
@@ -73,7 +69,6 @@ tor_compress_output_t tor_compress_process(tor_compress_state_t *state,
 void tor_compress_free(tor_compress_state_t *state);
 
 size_t tor_compress_state_size(const tor_compress_state_t *state);
-size_t tor_zlib_get_total_allocation(void);
 
-#endif
+#endif // TOR_COMPRESS_H.
 

src/common/torgzip.c → src/common/compress_zlib.c

@@ -4,25 +4,16 @@
 /* See LICENSE for licensing information */
 
 /**
- * \file torgzip.c
- * \brief A simple in-memory gzip implementation.
+ * \file compress_zlib.c
+ * \brief Compression backend for gzip and zlib.
  **/
 
 #include "orconfig.h"
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <assert.h>
-#include <string.h>
-#include "torint.h"
-
-#ifdef HAVE_NETINET_IN_H
-#include <netinet/in.h>
-#endif
-
 #include "util.h"
 #include "torlog.h"
-#include "torgzip.h"
+#include "compress.h"
+#include "compress_zlib.h"
 
 /* zlib 1.2.4 and 1.2.5 do some "clever" things with macros.  Instead of
    saying "(defined(FOO) ? FOO : 0)" they like to say "FOO-0", on the theory
@@ -56,22 +47,6 @@ static size_t tor_zlib_state_size_precalc(int inflate,
 /** Total number of bytes allocated for zlib state */
 static size_t total_zlib_allocation = 0;
 
-/** Return a string representation of the version of the currently running
- * version of zlib. */
-const char *
-tor_zlib_get_version_str(void)
-{
-  return zlibVersion();
-}
-
-/** Return a string representation of the version of the version of zlib
-* used at compilation. */
-const char *
-tor_zlib_get_header_version_str(void)
-{
-  return ZLIB_VERSION;
-}
-
 /** Return the 'bits' value to tell zlib to use <b>method</b>.*/
 static inline int
 method_bits(compress_method_t method, compression_level_t level)
@@ -86,59 +61,26 @@ method_bits(compress_method_t method, compression_level_t level)
   }
 }
 
-
-/** @{ */
-/* These macros define the maximum allowable compression factor.  Anything of
- * size greater than CHECK_FOR_COMPRESSION_BOMB_AFTER is not allowed to
- * have an uncompression factor (uncompressed size:compressed size ratio) of
- * any greater than MAX_UNCOMPRESSION_FACTOR.
- *
- * Picking a value for MAX_UNCOMPRESSION_FACTOR is a trade-off: we want it to
- * be small to limit the attack multiplier, but we also want it to be large
- * enough so that no legitimate document --even ones we might invent in the
- * future -- ever compresses by a factor of greater than
- * MAX_UNCOMPRESSION_FACTOR. Within those parameters, there's a reasonably
- * large range of possible values. IMO, anything over 8 is probably safe; IMO
- * anything under 50 is probably sufficient.
- */
-#define MAX_UNCOMPRESSION_FACTOR 25
-#define CHECK_FOR_COMPRESSION_BOMB_AFTER (1024*64)
-/** @} */
-
-/** Return true if uncompressing an input of size <b>in_size</b> to an input of
- * size at least <b>size_out</b> looks like a compression bomb. */
-int
-tor_compress_is_compression_bomb(size_t size_in, size_t size_out)
+/** Return a string representation of the version of the currently running
+ * version of zlib. */
+const char *
+tor_zlib_get_version_str(void)
 {
-  if (size_in == 0 || size_out < CHECK_FOR_COMPRESSION_BOMB_AFTER)
-    return 0;
-
-  return (size_out / size_in > MAX_UNCOMPRESSION_FACTOR);
+  return zlibVersion();
 }
 
-/** Given <b>level</b> return the memory level.  The memory level is needed for
- * the various compression backends used in Tor.
- */
-int
-tor_compress_memory_level(compression_level_t level)
+/** Return a string representation of the version of the version of zlib
+* used at compilation. */
+const char *
+tor_zlib_get_header_version_str(void)
 {
-  switch (level) {
-    default:
-    case HIGH_COMPRESSION: return 8;
-    case MEDIUM_COMPRESSION: return 7;
-    case LOW_COMPRESSION: return 6;
-  }
+  return ZLIB_VERSION;
 }
 
-/** Given <b>in_len</b> bytes at <b>in</b>, compress them into a newly
- * allocated buffer, using the method described in <b>method</b>.  Store the
- * compressed string in *<b>out</b>, and its length in *<b>out_len</b>.
- * Return 0 on success, -1 on failure.
- */
 int
-tor_compress(char **out, size_t *out_len,
-             const char *in, size_t in_len,
-             compress_method_t method)
+tor_zlib_compress(char **out, size_t *out_len,
+                  const char *in, size_t in_len,
+                  compress_method_t method)
 {
   struct z_stream_s *stream = NULL;
   size_t out_size, old_size;
@@ -160,7 +102,7 @@ tor_compress(char **out, size_t *out_len,
 
   if (deflateInit2(stream, Z_BEST_COMPRESSION, Z_DEFLATED,
                    method_bits(method, HIGH_COMPRESSION),
-                   get_memlevel(HIGH_COMPRESSION),
+                   tor_compress_memory_level(HIGH_COMPRESSION),
                    Z_DEFAULT_STRATEGY) != Z_OK) {
     //LCOV_EXCL_START -- we can only provoke failure by giving junk arguments.
     log_warn(LD_GENERAL, "Error from deflateInit2: %s",
@@ -228,7 +170,7 @@ tor_compress(char **out, size_t *out_len,
   }
   tor_free(stream);
 
-  if (is_compression_bomb(*out_len, in_len)) {
+  if (tor_compress_is_compression_bomb(*out_len, in_len)) {
     log_warn(LD_BUG, "We compressed something and got an insanely high "
           "compression factor; other Tors would think this was a zlib bomb.");
     goto err;
@@ -244,23 +186,12 @@ tor_compress(char **out, size_t *out_len,
   return -1;
 }
 
-/** Given zero or more zlib-compressed or gzip-compressed strings of
- * total length
- * <b>in_len</b> bytes at <b>in</b>, uncompress them into a newly allocated
- * buffer, using the method described in <b>method</b>.  Store the uncompressed
- * string in *<b>out</b>, and its length in *<b>out_len</b>.  Return 0 on
- * success, -1 on failure.
- *
- * If <b>complete_only</b> is true, we consider a truncated input as a
- * failure; otherwise we decompress as much as we can.  Warn about truncated
- * or corrupt inputs at <b>protocol_warn_level</b>.
- */
 int
-tor_uncompress(char **out, size_t *out_len,
-               const char *in, size_t in_len,
-               compress_method_t method,
-               int complete_only,
-               int protocol_warn_level)
+tor_zlib_uncompress(char **out, size_t *out_len,
+                    const char *in, size_t in_len,
+                    compress_method_t method,
+                    int complete_only,
+                    int protocol_warn_level)
 {
   struct z_stream_s *stream = NULL;
   size_t out_size, old_size;
@@ -336,7 +267,7 @@ tor_uncompress(char **out, size_t *out_len,
           log_warn(LD_GENERAL, "Size overflow in uncompression.");
           goto err;
         }
-        if (is_compression_bomb(in_len, out_size)) {
+        if (tor_compress_is_compression_bomb(in_len, out_size)) {
           log_warn(LD_GENERAL, "Input looks like a possible zlib bomb; "
                    "not proceeding.");
           goto err;
@@ -386,26 +317,9 @@ tor_uncompress(char **out, size_t *out_len,
   return -1;
 }
 
-/** Try to tell whether the <b>in_len</b>-byte string in <b>in</b> is likely
- * to be compressed or not.  If it is, return the likeliest compression method.
- * Otherwise, return UNKNOWN_METHOD.
- */
-compress_method_t
-detect_compression_method(const char *in, size_t in_len)
-{
-  if (in_len > 2 && fast_memeq(in, "\x1f\x8b", 2)) {
-    return GZIP_METHOD;
-  } else if (in_len > 2 && (in[0] & 0x0f) == 8 &&
-             (ntohs(get_uint16(in)) % 31) == 0) {
-    return ZLIB_METHOD;
-  } else {
-    return UNKNOWN_METHOD;
-  }
-}
-
-/** Internal state for an incremental compression/decompression.  The body of
- * this struct is not exposed. */
-struct tor_compress_state_t {
+/** Internal zlib state for an incremental compression/decompression.
+ * The body of this struct is not exposed. */
+struct tor_zlib_compress_state_t {
   struct z_stream_s stream; /**< The zlib stream */
   int compress; /**< True if we are compressing; false if we are inflating */
 
@@ -418,66 +332,86 @@ struct tor_compress_state_t {
   size_t allocation;
 };
 
-/** Construct and return a tor_compress_state_t object using <b>method</b>.  If
- * <b>compress</b>, it's for compression; otherwise it's for decompression. */
-tor_compress_state_t *
-tor_compress_new(int compress_, compress_method_t method,
-                 compression_level_t compression_level)
+/** Return an approximate number of bytes used in RAM to hold a state with
+ * window bits <b>windowBits</b> and compression level 'memlevel' */
+static size_t
+tor_zlib_state_size_precalc(int inflate_, int windowbits, int memlevel)
 {
-  tor_compress_state_t *out;
+  windowbits &= 15;
+
+#define A_FEW_KILOBYTES 2048
+
+  if (inflate_) {
+    /* From zconf.h:
+
+       "The memory requirements for inflate are (in bytes) 1 << windowBits
+       that is, 32K for windowBits=15 (default value) plus a few kilobytes
+       for small objects."
+    */
+    return sizeof(tor_zlib_compress_state_t) + sizeof(struct z_stream_s) +
+      (1 << 15) + A_FEW_KILOBYTES;
+  } else {
+    /* Also from zconf.h:
+
+       "The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+        ... plus a few kilobytes for small objects."
+    */
+    return sizeof(tor_zlib_compress_state_t) + sizeof(struct z_stream_s) +
+      (1 << (windowbits + 2)) + (1 << (memlevel + 9)) + A_FEW_KILOBYTES;
+  }
+#undef A_FEW_KILOBYTES
+}
+
+tor_zlib_compress_state_t *
+tor_zlib_compress_new(int compress,
+                      compress_method_t method,
+                      compression_level_t compression_level)
+{
+  tor_zlib_compress_state_t *out;
   int bits, memlevel;
 
- if (! compress_) {
-   /* use this setting for decompression, since we might have the
-    * max number of window bits */
-   compression_level = HIGH_COMPRESSION;
- }
-
- out = tor_malloc_zero(sizeof(tor_compress_state_t));
- out->stream.zalloc = Z_NULL;
- out->stream.zfree = Z_NULL;
- out->stream.opaque = NULL;
- out->compress = compress_;
- bits = method_bits(method, compression_level);
- memlevel = get_memlevel(compression_level);
- if (compress_) {
-   if (deflateInit2(&out->stream, Z_BEST_COMPRESSION, Z_DEFLATED,
-                    bits, memlevel,
-                    Z_DEFAULT_STRATEGY) != Z_OK)
-     goto err; // LCOV_EXCL_LINE
- } else {
-   if (inflateInit2(&out->stream, bits) != Z_OK)
-     goto err; // LCOV_EXCL_LINE
- }
- out->allocation = tor_zlib_state_size_precalc(!compress_, bits, memlevel);
-
- total_zlib_allocation += out->allocation;
-
- return out;
+  if (! compress) {
+    /* use this setting for decompression, since we might have the
+     * max number of window bits */
+    compression_level = HIGH_COMPRESSION;
+  }
+
+  out = tor_malloc_zero(sizeof(tor_zlib_compress_state_t));
+  out->stream.zalloc = Z_NULL;
+  out->stream.zfree = Z_NULL;
+  out->stream.opaque = NULL;
+  out->compress = compress;
+  bits = method_bits(method, compression_level);
+  memlevel = tor_compress_memory_level(compression_level);
+  if (compress) {
+    if (deflateInit2(&out->stream, Z_BEST_COMPRESSION, Z_DEFLATED,
+                     bits, memlevel,
+                     Z_DEFAULT_STRATEGY) != Z_OK)
+    goto err; // LCOV_EXCL_LINE
+  } else {
+    if (inflateInit2(&out->stream, bits) != Z_OK)
+      goto err; // LCOV_EXCL_LINE
+  }
+  out->allocation = tor_zlib_state_size_precalc(!compress, bits, memlevel);
+
+  total_zlib_allocation += out->allocation;
+
+  return out;
 
  err:
- tor_free(out);
- return NULL;
+  tor_free(out);
+  return NULL;
 }
 
-/** Compress/decompress some bytes using <b>state</b>.  Read up to
- * *<b>in_len</b> bytes from *<b>in</b>, and write up to *<b>out_len</b> bytes
- * to *<b>out</b>, adjusting the values as we go.  If <b>finish</b> is true,
- * we've reached the end of the input.
- *
- * Return TOR_COMPRESS_DONE if we've finished the entire
- * compression/decompression.
- * Return TOR_COMPRESS_OK if we're processed everything from the input.
- * Return TOR_COMPRESS_BUFFER_FULL if we're out of space on <b>out</b>.
- * Return TOR_COMPRESS_ERROR if the stream is corrupt.
- */
 tor_compress_output_t
-tor_compress_process(tor_compress_state_t *state,
-                     char **out, size_t *out_len,
-                     const char **in, size_t *in_len,
-                     int finish)
+tor_zlib_compress_process(tor_zlib_compress_state_t *state,
+                          char **out, size_t *out_len,
+                          const char **in, size_t *in_len,
+                          int finish)
 {
   int err;
+  tor_assert(state != NULL);
   tor_assert(*in_len <= UINT_MAX);
   tor_assert(*out_len <= UINT_MAX);
   state->stream.next_in = (unsigned char*) *in;
@@ -500,7 +434,8 @@ tor_compress_process(tor_compress_state_t *state,
   *in_len = state->stream.avail_in;
 
   if (! state->compress &&
-      is_compression_bomb(state->input_so_far, state->output_so_far)) {
+      tor_compress_is_compression_bomb(state->input_so_far,
+                                       state->output_so_far)) {
     log_warn(LD_DIR, "Possible zlib bomb; abandoning stream.");
     return TOR_COMPRESS_ERROR;
   }
@@ -524,14 +459,13 @@ tor_compress_process(tor_compress_state_t *state,
     }
 }
 
-/** Deallocate <b>state</b>. */
 void
-tor_compress_free(tor_compress_state_t *state)
+tor_zlib_compress_free(tor_zlib_compress_state_t *state)
 {
-  if (!state)
+  if (state == NULL)
     return;
 
- total_zlib_allocation -= state->allocation;
+  total_zlib_allocation -= state->allocation;
 
   if (state->compress)
     deflateEnd(&state->stream);
@@ -541,41 +475,10 @@ tor_compress_free(tor_compress_state_t *state)
   tor_free(state);
 }
 
-/** Return an approximate number of bytes used in RAM to hold a state with
- * window bits <b>windowBits</b> and compression level 'memlevel' */
-static size_t
-tor_zlib_state_size_precalc(int inflate_, int windowbits, int memlevel)
-{
-  windowbits &= 15;
-
-#define A_FEW_KILOBYTES 2048
-
-  if (inflate_) {
-    /* From zconf.h:
-
-       "The memory requirements for inflate are (in bytes) 1 << windowBits
-       that is, 32K for windowBits=15 (default value) plus a few kilobytes
-       for small objects."
-    */
-    return sizeof(tor_compress_state_t) + sizeof(struct z_stream_s) +
-      (1 << 15) + A_FEW_KILOBYTES;
-  } else {
-    /* Also from zconf.h:
-
-       "The memory requirements for deflate are (in bytes):
-            (1 << (windowBits+2)) +  (1 << (memLevel+9))
-        ... plus a few kilobytes for small objects."
-    */
-    return sizeof(tor_compress_state_t) + sizeof(struct z_stream_s) +
-      (1 << (windowbits + 2)) + (1 << (memlevel + 9)) + A_FEW_KILOBYTES;
-  }
-#undef A_FEW_KILOBYTES
-}
-
-/** Return the approximate number of bytes allocated for <b>state</b>. */
 size_t
-tor_compress_state_size(const tor_compress_state_t *state)
+tor_zlib_compress_state_size(const tor_zlib_compress_state_t *state)
 {
+  tor_assert(state != NULL);
   return state->allocation;
 }
 

src/common/compress_zlib.h

+/* Copyright (c) 2003, Roger Dingledine
+ * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
+ * Copyright (c) 2007-2017, The Tor Project, Inc. */
+/* See LICENSE for licensing information */
+
+/**
+ * \file compress_zlib.h
+ * \brief Header for compress_zlib.c
+ **/
+
+#ifndef TOR_COMPRESS_ZLIB_H
+#define TOR_COMPRESS_ZLIB_H
+
+const char *
+tor_zlib_get_version_str(void);
+
+const char *
+tor_zlib_get_header_version_str(void);
+
+int
+tor_zlib_compress(char **out, size_t *out_len,
+                  const char *in, size_t in_len,
+                  compress_method_t method);
+
+int
+tor_zlib_uncompress(char **out, size_t *out_len,
+                    const char *in, size_t in_len,
+                    compress_method_t method,
+                    int complete_only,
+                    int protocol_warn_level);
+
+/** Internal state for an incremental zlib/gzip compression/decompression. */
+typedef struct tor_zlib_compress_state_t tor_zlib_compress_state_t;
+
+tor_zlib_compress_state_t *
+tor_zlib_compress_new(int compress,
+                      compress_method_t method,
+                      compression_level_t compression_level);
+
+tor_compress_output_t
+tor_zlib_compress_process(tor_zlib_compress_state_t *state,
+                          char **out, size_t *out_len,
+                          const char **in, size_t *in_len,
+                          int finish);
+
+void
+tor_zlib_compress_free(tor_zlib_compress_state_t *state);
+
+size_t
+tor_zlib_compress_state_size(const tor_zlib_compress_state_t *state);
+
+size_t
+tor_zlib_get_total_allocation(void);
+
+#endif // TOR_COMPRESS_ZLIB_H.
+

src/common/include.am

@@ -105,11 +105,12 @@ src/common/src_common_libor_testing_a-log.$(OBJEXT) \
 
 LIBOR_CRYPTO_A_SRC = \
   src/common/aes.c		\
+  src/common/compress.c	\
+  src/common/compress_zlib.c	\
   src/common/crypto.c		\
   src/common/crypto_pwbox.c     \
   src/common/crypto_s2k.c	\
   src/common/crypto_format.c	\
-  src/common/torgzip.c		\
   src/common/tortls.c		\
   src/common/crypto_curve25519.c \
   src/common/crypto_ed25519.c
@@ -145,6 +146,8 @@ COMMONHEADERS = \
   src/common/compat_openssl.h			\
   src/common/compat_threads.h			\
   src/common/compat_time.h			\
+  src/common/compress.h			\
+  src/common/compress_zlib.h			\
   src/common/confline.h				\
   src/common/container.h			\
   src/common/crypto.h				\
@@ -163,7 +166,6 @@ COMMONHEADERS = \
   src/common/storagedir.h			\
   src/common/testsupport.h			\
   src/common/timers.h				\
-  src/common/torgzip.h				\
   src/common/torint.h				\
   src/common/torlog.h				\
   src/common/tortls.h				\

src/or/config.c

@@ -69,6 +69,8 @@
 #include "circuitmux.h"
 #include "circuitmux_ewma.h"
 #include "circuitstats.h"
+#include "compress.h"
+#include "compress_zlib.h"
 #include "config.h"
 #include "connection.h"
 #include "connection_edge.h"
@@ -99,7 +101,6 @@
 #include "statefile.h"
 #include "transports.h"
 #include "ext_orport.h"
-#include "torgzip.h"
 #ifdef _WIN32
 #include <shlobj.h>
 #endif

src/or/main.c

@@ -58,6 +58,7 @@
 #include "circuitlist.h"
 #include "circuituse.h"
 #include "command.h"
+#include "compress_zlib.h"
 #include "config.h"
 #include "confparse.h"
 #include "connection.h"

src/or/or.h

@@ -71,7 +71,7 @@
 #include "tortls.h"
 #include "torlog.h"
 #include "container.h"
-#include "torgzip.h"
+#include "compress.h"
 #include "address.h"
 #include "compat_libevent.h"
 #include "ht.h"

src/or/relay.c

@@ -54,6 +54,7 @@
 #include "circuitbuild.h"
 #include "circuitlist.h"
 #include "circuituse.h"
+#include "compress_zlib.h"
 #include "config.h"
 #include "connection.h"
 #include "connection_edge.h"

src/test/test.c

@@ -44,13 +44,13 @@ double fabs(double x);
 #include "buffers.h"
 #include "circuitlist.h"
 #include "circuitstats.h"
+#include "compress.h"
 #include "config.h"
 #include "connection_edge.h"
 #include "geoip.h"
 #include "rendcommon.h"
 #include "rendcache.h"
 #include "test.h"
-#include "torgzip.h"
 #include "main.h"
 #include "memarea.h"
 #include "onion.h"

src/test/test_dir_handle_get.c

@@ -14,6 +14,7 @@
 #include "connection.h"
 #include "directory.h"
 #include "test.h"
+#include "compress.h"
 #include "connection.h"
 #include "rendcommon.h"
 #include "rendcache.h"
@@ -28,7 +29,6 @@
 #include "networkstatus.h"
 #include "geoip.h"
 #include "dirserv.h"
-#include "torgzip.h"
 #include "dirvote.h"
 #include "log_test_helpers.h"