torgzip.c 11.4 KB
Newer Older
1
2
3
/* Copyright (c) 2004, Roger Dingledine.
 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
 * Copyright (c) 2007, The Tor Project, Inc. */
4
5
/* See LICENSE for licensing information */
/* $Id$ */
6
7
const char torgzip_c_id[] =
  "$Id$";
8
9
10

/**
 * \file torgzip.c
11
 * \brief A simple in-memory gzip implementation.
12
13
14
15
16
17
18
 **/

#include "orconfig.h"

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
19
#ifdef _MSC_VER
Nick Mathewson's avatar
Nick Mathewson committed
20
21
#include "..\..\contrib\zlib\zlib.h"
#else
22
#include <zlib.h>
Nick Mathewson's avatar
Nick Mathewson committed
23
#endif
24
#include <string.h>
25
#ifdef HAVE_NETINET_IN_H
26
#include <netinet/in.h>
27
#endif
28
29
30
31
32

#include "util.h"
#include "log.h"
#include "torgzip.h"

33
34
/** Set to 1 if zlib is a version that supports gzip; set to 0 if it doesn't;
 * set to -1 if we haven't checked yet. */
35
36
static int gzip_is_supported = -1;

37
38
/** Return true iff we support gzip-based compression.  Otherwise, we need to
 * use zlib. */
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
int
is_gzip_supported(void)
{
  if (gzip_is_supported >= 0)
    return gzip_is_supported;

  if (!strcmpstart(ZLIB_VERSION, "0.") ||
      !strcmpstart(ZLIB_VERSION, "1.0") ||
      !strcmpstart(ZLIB_VERSION, "1.1"))
    gzip_is_supported = 0;
  else
    gzip_is_supported = 1;

  return gzip_is_supported;
}

55
/** Return the 'bits' value to tell zlib to use <b>method</b>.*/
56
57
58
59
60
61
62
static INLINE int
method_bits(compress_method_t method)
{
  /* Bits+16 means "use gzip" in zlib >= 1.2 */
  return method == GZIP_METHOD ? 15+16 : 15;
}

63
64
65
66
67
/** 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.
 */
68
69
int
tor_gzip_compress(char **out, size_t *out_len,
Nick Mathewson's avatar
Nick Mathewson committed
70
                  const char *in, size_t in_len,
71
72
73
74
75
76
                  compress_method_t method)
{
  struct z_stream_s *stream = NULL;
  size_t out_size;
  off_t offset;

77
78
79
  tor_assert(out);
  tor_assert(out_len);
  tor_assert(in);
80
81
82

  if (method == GZIP_METHOD && !is_gzip_supported()) {
    /* Old zlib version don't support gzip in deflateInit2 */
83
    log_warn(LD_BUG, "Gzip not supported with zlib %s", ZLIB_VERSION);
84
85
86
87
88
89
90
91
92
93
94
95
96
    return -1;
  }

  *out = NULL;

  stream = tor_malloc_zero(sizeof(struct z_stream_s));
  stream->zalloc = Z_NULL;
  stream->zfree = Z_NULL;
  stream->opaque = NULL;
  stream->next_in = (unsigned char*) in;
  stream->avail_in = in_len;

  if (deflateInit2(stream, Z_BEST_COMPRESSION, Z_DEFLATED,
Nick Mathewson's avatar
Nick Mathewson committed
97
98
                   method_bits(method),
                   8, Z_DEFAULT_STRATEGY) != Z_OK) {
99
100
    log_warn(LD_GENERAL, "Error from deflateInit2: %s",
             stream->msg?stream->msg:"<no message>");
101
102
103
104
105
106
107
    goto err;
  }

  /* Guess 50% compression. */
  out_size = in_len / 2;
  if (out_size < 1024) out_size = 1024;
  *out = tor_malloc(out_size);
108
  stream->next_out = (unsigned char*)*out;
109
110
111
112
113
114
115
116
117
118
119
120
  stream->avail_out = out_size;

  while (1) {
    switch (deflate(stream, Z_FINISH))
      {
      case Z_STREAM_END:
        goto done;
      case Z_OK:
        /* In case zlib doesn't work as I think .... */
        if (stream->avail_out >= stream->avail_in+16)
          break;
      case Z_BUF_ERROR:
Nick Mathewson's avatar
Nick Mathewson committed
121
122
123
        offset = stream->next_out - ((unsigned char*)*out);
        out_size *= 2;
        *out = tor_realloc(*out, out_size);
124
        stream->next_out = (unsigned char*)(*out + offset);
125
126
127
128
129
130
        if (out_size - offset > UINT_MAX) {
          log_warn(LD_BUG,  "Ran over unsigned int limit of zlib while "
                   "uncompressing.");
          goto err;
        }
        stream->avail_out = (unsigned int)(out_size - offset);
Nick Mathewson's avatar
Nick Mathewson committed
131
        break;
132
      default:
133
134
        log_warn(LD_GENERAL, "Gzip compression didn't finish: %s",
                 stream->msg ? stream->msg : "<no message>");
135
136
137
138
139
        goto err;
      }
  }
 done:
  *out_len = stream->total_out;
140
141
142
143
  if (stream->total_out > out_size + 4097) {
    /* If we're wasting more than 4k, don't. */
    tor_realloc(*out, stream->total_out + 1);
  }
144
  if (deflateEnd(stream)!=Z_OK) {
145
    log_warn(LD_BUG, "Error freeing gzip structures");
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
    goto err;
  }
  tor_free(stream);

  return 0;
 err:
  if (stream) {
    deflateEnd(stream);
    tor_free(stream);
  }
  if (*out) {
    tor_free(*out);
  }
  return -1;
}

162
163
/** Given zero or more zlib-compressed or gzip-compressed strings of
 * total length
164
165
166
167
 * <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.
168
169
170
171
 *
 * 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>.
172
 */
173
174
int
tor_gzip_uncompress(char **out, size_t *out_len,
Nick Mathewson's avatar
Nick Mathewson committed
175
                    const char *in, size_t in_len,
176
                    compress_method_t method,
177
178
                    int complete_only,
                    int protocol_warn_level)
179
180
181
182
{
  struct z_stream_s *stream = NULL;
  size_t out_size;
  off_t offset;
183
  int r;
184

185
186
187
  tor_assert(out);
  tor_assert(out_len);
  tor_assert(in);
188
189
190

  if (method == GZIP_METHOD && !is_gzip_supported()) {
    /* Old zlib version don't support gzip in inflateInit2 */
191
    log_warn(LD_BUG, "Gzip not supported with zlib %s", ZLIB_VERSION);
192
193
194
195
196
197
198
199
200
201
202
203
204
205
    return -1;
  }

  *out = NULL;

  stream = tor_malloc_zero(sizeof(struct z_stream_s));
  stream->zalloc = Z_NULL;
  stream->zfree = Z_NULL;
  stream->opaque = NULL;
  stream->next_in = (unsigned char*) in;
  stream->avail_in = in_len;

  if (inflateInit2(stream,
                   method_bits(method)) != Z_OK) {
206
207
    log_warn(LD_GENERAL, "Error from inflateInit2: %s",
             stream->msg?stream->msg:"<no message>");
208
209
210
211
212
213
214
    goto err;
  }

  out_size = in_len * 2;  /* guess 50% compression. */
  if (out_size < 1024) out_size = 1024;

  *out = tor_malloc(out_size);
215
  stream->next_out = (unsigned char*)*out;
216
217
218
  stream->avail_out = out_size;

  while (1) {
219
    switch (inflate(stream, complete_only ? Z_FINISH : Z_SYNC_FLUSH))
220
221
      {
      case Z_STREAM_END:
222
223
        if (stream->avail_in == 0)
          goto done;
224
        /* There may be more compressed data here. */
225
        if ((r = inflateEnd(stream)) != Z_OK) {
226
          log_warn(LD_BUG, "Error freeing gzip structures");
227
228
          goto err;
        }
229
        if (inflateInit2(stream, method_bits(method)) != Z_OK) {
230
          log_warn(LD_GENERAL, "Error from second inflateInit2: %s",
231
                   stream->msg?stream->msg:"<no message>");
232
233
234
          goto err;
        }
        break;
235
      case Z_OK:
236
237
        if (!complete_only && stream->avail_in == 0)
          goto done;
Nick Mathewson's avatar
Nick Mathewson committed
238
239
240
        /* In case zlib doesn't work as I think.... */
        if (stream->avail_out >= stream->avail_in+16)
          break;
241
      case Z_BUF_ERROR:
242
        if (stream->avail_out > 0) {
243
244
          log_fn(protocol_warn_level, LD_PROTOCOL,
                 "possible truncated or corrupt zlib data");
245
246
          goto err;
        }
247
        offset = stream->next_out - (unsigned char*)*out;
Nick Mathewson's avatar
Nick Mathewson committed
248
249
        out_size *= 2;
        *out = tor_realloc(*out, out_size);
250
        stream->next_out = (unsigned char*)(*out + offset);
251
252
253
254
255
256
        if (out_size - offset > UINT_MAX) {
          log_warn(LD_BUG,  "Ran over unsigned int limit of zlib while "
                   "uncompressing.");
          goto err;
        }
        stream->avail_out = (unsigned int)(out_size - offset);
Nick Mathewson's avatar
Nick Mathewson committed
257
        break;
258
      default:
259
260
        log_warn(LD_GENERAL, "Gzip decompression returned an error: %s",
                 stream->msg ? stream->msg : "<no message>");
Nick Mathewson's avatar
Nick Mathewson committed
261
        goto err;
262
263
264
      }
  }
 done:
265
  *out_len = stream->next_out - (unsigned char*)*out;
266
267
268
  r = inflateEnd(stream);
  tor_free(stream);
  if (r != Z_OK) {
269
    log_warn(LD_BUG, "Error freeing gzip structures");
270
    goto err;
271
272
  }

273
274
275
276
277
  /* NUL-terminate output. */
  if (out_size == *out_len)
    *out = tor_realloc(*out, out_size + 1);
  (*out)[*out_len] = '\0';

278
279
280
281
282
283
284
285
286
287
288
289
  return 0;
 err:
  if (stream) {
    inflateEnd(stream);
    tor_free(stream);
  }
  if (*out) {
    tor_free(*out);
  }
  return -1;
}

290
291
/** 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.
292
 * Otherwise, return UNKNOWN_METHOD.
293
 */
294
compress_method_t
295
detect_compression_method(const char *in, size_t in_len)
296
{
297
  if (in_len > 2 && !memcmp(in, "\x1f\x8b", 2)) {
298
299
    return GZIP_METHOD;
  } else if (in_len > 2 && (in[0] & 0x0f) == 8 &&
300
             (ntohs(get_uint16(in)) % 31) == 0) {
301
302
    return ZLIB_METHOD;
  } else {
303
    return UNKNOWN_METHOD;
304
305
  }
}
306

Roger Dingledine's avatar
Roger Dingledine committed
307
308
/** Internal state for an incremental zlib compression/decompression.  The
 * body of this struct is not exposed. */
309
310
311
312
313
struct tor_zlib_state_t {
  struct z_stream_s stream;
  int compress;
};

314
315
/** Construct and return a tor_zlib_state_t object using <b>method</b>.  If
 * <b>compress</b>, it's for compression; otherwise it's for
Roger Dingledine's avatar
Roger Dingledine committed
316
 * decompression. */
317
318
319
320
321
322
323
tor_zlib_state_t *
tor_zlib_new(int compress, compress_method_t method)
{
  tor_zlib_state_t *out;

  if (method == GZIP_METHOD && !is_gzip_supported()) {
    /* Old zlib version don't support gzip in inflateInit2 */
324
    log_warn(LD_BUG, "Gzip not supported with zlib %s", ZLIB_VERSION);
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
    return NULL;
 }

 out = tor_malloc_zero(sizeof(tor_zlib_state_t));
 out->stream.zalloc = Z_NULL;
 out->stream.zfree = Z_NULL;
 out->stream.opaque = NULL;
 out->compress = compress;
 if (compress) {
   if (deflateInit2(&out->stream, Z_BEST_COMPRESSION, Z_DEFLATED,
                    method_bits(method), 8, Z_DEFAULT_STRATEGY) != Z_OK)
     goto err;
 } else {
   if (inflateInit2(&out->stream, method_bits(method)) != Z_OK)
     goto err;
 }
 return out;

 err:
 tor_free(out);
 return NULL;
}

348
349
350
351
352
353
354
355
356
357
/** Compress/decommpress 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_ZLIB_DONE if we've finished the entire compression/decompression.
 * Return TOR_ZLIB_OK if we're processed everything from the input.
 * Return TOR_ZLIB_BUF_FULL if we're out of space on <b>out</b>.
 * Return TOR_ZLIB_ERR if the stream is corrupt.
 */
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
tor_zlib_output_t
tor_zlib_process(tor_zlib_state_t *state,
                 char **out, size_t *out_len,
                 const char **in, size_t *in_len,
                 int finish)
{
  int err;
  state->stream.next_in = (unsigned char*) *in;
  state->stream.avail_in = *in_len;
  state->stream.next_out = (unsigned char*) *out;
  state->stream.avail_out = *out_len;

  if (state->compress) {
    err = deflate(&state->stream, finish ? Z_FINISH : Z_SYNC_FLUSH);
  } else {
    err = inflate(&state->stream, finish ? Z_FINISH : Z_SYNC_FLUSH);
  }

  *out = (char*) state->stream.next_out;
  *out_len = state->stream.avail_out;
  *in = (const char *) state->stream.next_in;
  *in_len = state->stream.avail_in;

  switch (err)
    {
    case Z_STREAM_END:
      return TOR_ZLIB_DONE;
    case Z_BUF_ERROR:
386
      if (state->stream.avail_in == 0)
387
        return TOR_ZLIB_OK;
388
389
      return TOR_ZLIB_BUF_FULL;
    case Z_OK:
390
      if (state->stream.avail_out == 0 || finish)
391
392
393
394
395
396
397
398
399
        return TOR_ZLIB_BUF_FULL;
      return TOR_ZLIB_OK;
    default:
      log_warn(LD_GENERAL, "Gzip returned an error: %s",
               state->stream.msg ? state->stream.msg : "<no message>");
      return TOR_ZLIB_ERR;
    }
}

400
/** Deallocate <b>state</b>. */
401
402
403
404
405
406
407
408
409
410
411
412
413
void
tor_zlib_free(tor_zlib_state_t *state)
{
  tor_assert(state);

  if (state->compress)
    deflateEnd(&state->stream);
  else
    inflateEnd(&state->stream);

  tor_free(state);
}