Mix/Src/compress.c

/* Mixmaster version 3.0  --  (C) 1999 - 2004 Anonymizer Inc. and others.

   Mixmaster may be redistributed and modified under certain conditions.
   This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
   ANY KIND, either express or implied. See the file COPYRIGHT for
   details.

   Buffer compression (interface to zlib)
   $Id$ */


#include "mix3.h"
#include <stdio.h>
#include <assert.h>

static byte gz_magic[2] =
{0x1f, 0x8b};                   /* gzip magic header */

/* gzip flag byte */
#define ASCII_FLAG   0x01
#define HEAD_CRC     0x02
#define EXTRA_FIELD  0x04
#define ORIG_NAME    0x08
#define COMMENT      0x10
#define RESERVED     0xE0
#define Z_DEFLATED   8

#ifdef USE_ZLIB
#include "zlib.h"

int buf_unzip(BUFFER *in, int type)
{
  BUFFER *out;
  z_stream s;
  long outstart;
  int err;
  int ret = 0;

  out = buf_new();

  s.zalloc = (alloc_func) 0;
  s.zfree = (free_func) 0;
  s.opaque = (voidpf) 0;

  s.next_in = in->data + in->ptr;
  s.avail_in = in->length + 1 - in->ptr;        /* terminating 0 byte as "dummy" */
  s.next_out = NULL;

  if (type == 1)
    err = inflateInit(&s);    /* zlib */
  else
    err = inflateInit2(&s, -MAX_WBITS);
  if (err != Z_OK) {
    ret = -1;
    goto end;
  }
  outstart = 0;
  buf_append(out, NULL, in->length * 15 / 10);

  for (;;) {
    s.next_out = out->data + s.total_out + outstart;
    s.avail_out = out->length - outstart - s.total_out;
    err = inflate(&s, Z_PARTIAL_FLUSH);
    out->length -= s.avail_out;
    if (err != Z_OK)
      break;
    buf_append(out, NULL, BUFSIZE);
  }
  if (err != Z_STREAM_END)
    errlog(WARNING, "Decompression error %d\n", err);

  err = inflateEnd(&s);
  if (err != Z_OK)
    ret = -1;
end:
  if (ret != 0)
    switch (err) {
    case Z_STREAM_ERROR:
      errlog(ERRORMSG, "Decompression error Z_STREAM_ERROR.\n", err);
      break;
    case Z_MEM_ERROR:
      errlog(ERRORMSG, "Decompression error Z_MEM_ERROR.\n", err);
      break;
    case Z_BUF_ERROR:
      errlog(ERRORMSG, "Decompression error Z_BUF_ERROR.\n", err);
      break;
    case Z_VERSION_ERROR:
      errlog(ERRORMSG, "Decompression error Z_VERSION_ERROR.\n", err);
      break;
    default:
      errlog(ERRORMSG, "Decompression error %d.\n", err);
    }
  buf_move(in, out);
  buf_free(out);
  return (ret);
}

int buf_zip(BUFFER *out, BUFFER *in, int bits)
{
  z_stream s;
  long outstart;
  int err = -1;

  assert(in != out);

  s.zalloc = (alloc_func) 0;
  s.zfree = (free_func) 0;
  s.opaque = (voidpf) 0;
  s.next_in = NULL;

  if (bits == 0)
    bits = MAX_WBITS;

  if (deflateInit2(&s, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -bits, 8, 0) != Z_OK)
    goto end;

  outstart = out->length;
  /* 12 is overhead, 1.01 is maximum expansion, and 1 is there to force a round-up */
  buf_append(out, NULL, (int)13+in->length*1.01); /* fit it in one chunk */

  s.next_in = in->data;
  s.avail_in = in->length;

  for (;;) {
    s.next_out = out->data + s.total_out + outstart;
    s.avail_out = out->length - outstart - s.total_out;
    err = deflate(&s, Z_FINISH);
    out->length -= s.avail_out;
    if (err != Z_OK)
      break;
    errlog(ERRORMSG, "Compressed data did not fit in one chunk.\n");
    buf_append(out, NULL, BUFSIZE);
  }
  if (deflateEnd(&s) != Z_OK || err != Z_STREAM_END)
    err = -1;
  else
    err = 0;
end:
  if (err != 0)
    errlog(ERRORMSG, "Compression error.\n");
  return (err);
}

#else /* end of USE_ZLIB */
int buf_zip(BUFFER *out, BUFFER *in, int bits)
{
  return (-1);
}

int buf_unzip(BUFFER *b, int type)
{
  errlog(ERRORMSG, "Can't uncompress: no zlib\n");
  return (-1);
}
#endif /* else not USE_ZLIB */

int compressed(BUFFER *b)
{
  return (b->length >= 10 && b->data[0] == gz_magic[0] &&
          b->data[1] == gz_magic[1]);
}

int buf_uncompress(BUFFER *in)
{
  int type;
  int err = -1;
  unsigned int len;

  if (!compressed(in))
    return (0);
  type = in->data[3];
  if (in->data[2] != Z_DEFLATED || (type & RESERVED) == 0) {
    in->ptr = 10;
    if ((type & EXTRA_FIELD) != 0) {
      len = buf_geti(in);
      in->ptr += len;
    }
    if ((type & ORIG_NAME) != 0)
      while (buf_getc(in) > 0) ;
    if ((type & COMMENT) != 0)
      while (buf_getc(in) > 0) ;
    if ((type & HEAD_CRC) != 0)
      buf_geti(in);
    err = buf_unzip(in, 0);
  }
  return (err);
}

int buf_compress(BUFFER *in)
{
  BUFFER *out;
  int err;

  if (compressed(in))
    return (0);

  out = buf_new();
  buf_appendc(out, gz_magic[0]);
  buf_appendc(out, gz_magic[1]);
  buf_appendc(out, Z_DEFLATED);
  buf_appendc(out, 0);          /* flags */
  buf_appendl(out, 0);          /* time */
  buf_appendc(out, 0);          /* xflags */
  buf_appendc(out, 3);          /* Unix */
  err = buf_zip(out, in, 0);
  if (err == 0)
    buf_move(in, out);
  buf_free(out);
  return (err);
}
1	/* Mixmaster version 3.0 -- (C) 1999 - 2004 Anonymizer Inc. and others.
2
3	Mixmaster may be redistributed and modified under certain conditions.
4	This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
5	ANY KIND, either express or implied. See the file COPYRIGHT for
6	details.
7
8	Buffer compression (interface to zlib)
9	$Id$ */
10
11
12	#include "mix3.h"
13	#include <stdio.h>
14	#include <assert.h>
15
16	static byte gz_magic[2] =
17	{0x1f, 0x8b}; /* gzip magic header */
18
19	/* gzip flag byte */
20	#define ASCII_FLAG 0x01
21	#define HEAD_CRC 0x02
22	#define EXTRA_FIELD 0x04
23	#define ORIG_NAME 0x08
24	#define COMMENT 0x10
25	#define RESERVED 0xE0
26	#define Z_DEFLATED 8
27
28	#ifdef USE_ZLIB
29	#include "zlib.h"
30
31	int buf_unzip(BUFFER *in, int type)
32	{
33	BUFFER *out;
34	z_stream s;
35	long outstart;
36	int err;
37	int ret = 0;
38
39	out = buf_new();
40
41	s.zalloc = (alloc_func) 0;
42	s.zfree = (free_func) 0;
43	s.opaque = (voidpf) 0;
44
45	s.next_in = in->data + in->ptr;
46	s.avail_in = in->length + 1 - in->ptr; /* terminating 0 byte as "dummy" */
47	s.next_out = NULL;
48
49	if (type == 1)
50	err = inflateInit(&s); /* zlib */
51	else
52	err = inflateInit2(&s, -MAX_WBITS);
53	if (err != Z_OK) {
54	ret = -1;
55	goto end;
56	}
57	outstart = 0;
58	buf_append(out, NULL, in->length * 15 / 10);
59
60	for (;;) {
61	s.next_out = out->data + s.total_out + outstart;
62	s.avail_out = out->length - outstart - s.total_out;
63	err = inflate(&s, Z_PARTIAL_FLUSH);
64	out->length -= s.avail_out;
65	if (err != Z_OK)
66	break;
67	buf_append(out, NULL, BUFSIZE);
68	}
69	if (err != Z_STREAM_END)
70	errlog(WARNING, "Decompression error %d\n", err);
71
72	err = inflateEnd(&s);
73	if (err != Z_OK)
74	ret = -1;
75	end:
76	if (ret != 0)
77	switch (err) {
78	case Z_STREAM_ERROR:
79	errlog(ERRORMSG, "Decompression error Z_STREAM_ERROR.\n", err);
80	break;
81	case Z_MEM_ERROR:
82	errlog(ERRORMSG, "Decompression error Z_MEM_ERROR.\n", err);
83	break;
84	case Z_BUF_ERROR:
85	errlog(ERRORMSG, "Decompression error Z_BUF_ERROR.\n", err);
86	break;
87	case Z_VERSION_ERROR:
88	errlog(ERRORMSG, "Decompression error Z_VERSION_ERROR.\n", err);
89	break;
90	default:
91	errlog(ERRORMSG, "Decompression error %d.\n", err);
92	}
93	buf_move(in, out);
94	buf_free(out);
95	return (ret);
96	}
97
98	int buf_zip(BUFFER out, BUFFER in, int bits)
99	{
100	z_stream s;
101	long outstart;
102	int err = -1;
103
104	assert(in != out);
105
106	s.zalloc = (alloc_func) 0;
107	s.zfree = (free_func) 0;
108	s.opaque = (voidpf) 0;
109	s.next_in = NULL;
110
111	if (bits == 0)
112	bits = MAX_WBITS;
113
114	if (deflateInit2(&s, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -bits, 8, 0) != Z_OK)
115	goto end;
116
117	outstart = out->length;
118	/* 12 is overhead, 1.01 is maximum expansion, and 1 is there to force a round-up */
119	buf_append(out, NULL, (int)13+in->length1.01); / fit it in one chunk */
120
121	s.next_in = in->data;
122	s.avail_in = in->length;
123
124	for (;;) {
125	s.next_out = out->data + s.total_out + outstart;
126	s.avail_out = out->length - outstart - s.total_out;
127	err = deflate(&s, Z_FINISH);
128	out->length -= s.avail_out;
129	if (err != Z_OK)
130	break;
131	errlog(ERRORMSG, "Compressed data did not fit in one chunk.\n");
132	buf_append(out, NULL, BUFSIZE);
133	}
134	if (deflateEnd(&s) != Z_OK \|\| err != Z_STREAM_END)
135	err = -1;
136	else
137	err = 0;
138	end:
139	if (err != 0)
140	errlog(ERRORMSG, "Compression error.\n");
141	return (err);
142	}
143
144	#else /* end of USE_ZLIB */
145	int buf_zip(BUFFER out, BUFFER in, int bits)
146	{
147	return (-1);
148	}
149
150	int buf_unzip(BUFFER *b, int type)
151	{
152	errlog(ERRORMSG, "Can't uncompress: no zlib\n");
153	return (-1);
154	}
155	#endif /* else not USE_ZLIB */
156
157	int compressed(BUFFER *b)
158	{
159	return (b->length >= 10 && b->data[0] == gz_magic[0] &&
160	b->data[1] == gz_magic[1]);
161	}
162
163	int buf_uncompress(BUFFER *in)
164	{
165	int type;
166	int err = -1;
167	unsigned int len;
168
169	if (!compressed(in))
170	return (0);
171	type = in->data[3];
172	if (in->data[2] != Z_DEFLATED \|\| (type & RESERVED) == 0) {
173	in->ptr = 10;
174	if ((type & EXTRA_FIELD) != 0) {
175	len = buf_geti(in);
176	in->ptr += len;
177	}
178	if ((type & ORIG_NAME) != 0)
179	while (buf_getc(in) > 0) ;
180	if ((type & COMMENT) != 0)
181	while (buf_getc(in) > 0) ;
182	if ((type & HEAD_CRC) != 0)
183	buf_geti(in);
184	err = buf_unzip(in, 0);
185	}
186	return (err);
187	}
188
189	int buf_compress(BUFFER *in)
190	{
191	BUFFER *out;
192	int err;
193
194	if (compressed(in))
195	return (0);
196
197	out = buf_new();
198	buf_appendc(out, gz_magic[0]);
199	buf_appendc(out, gz_magic[1]);
200	buf_appendc(out, Z_DEFLATED);
201	buf_appendc(out, 0); /* flags */
202	buf_appendl(out, 0); /* time */
203	buf_appendc(out, 0); /* xflags */
204	buf_appendc(out, 3); /* Unix */
205	err = buf_zip(out, in, 0);
206	if (err == 0)
207	buf_move(in, out);
208	buf_free(out);
209	return (err);
210	}