2 * ppp_deflate.c - interface the zlib procedures for Deflate compression
3 * and decompression (as used by gzip) to the PPP code.
5 * Copyright (c) 1994 Paul Mackerras. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the
19 * 3. The name(s) of the authors of this software must not be used to
20 * endorse or promote products derived from this software without
21 * prior written permission.
23 * 4. Redistributions of any form whatsoever must retain the following
25 * "This product includes software developed by Paul Mackerras
26 * <paulus@samba.org>".
28 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
29 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
30 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
31 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
32 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
33 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
34 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
36 * $Id: deflate.c,v 1.5 2004/01/17 05:47:55 carlsonj Exp $
39 #include <sys/types.h>
50 #define DEFLATE_DEBUG 1
53 * State for a Deflate (de)compressor.
55 struct deflate_state {
63 struct compstat stats;
66 #define DEFLATE_OVHD 2 /* Deflate overhead/packet */
68 static void *z_alloc(void *, u_int items, u_int size);
69 static void z_free(void *, void *ptr, u_int nb);
70 static void *z_decomp_alloc(u_char *options, int opt_len);
71 static void z_decomp_free(void *state);
72 static int z_decomp_init(void *state, u_char *options, int opt_len,
73 int unit, int hdrlen, int mru, int debug);
74 static void z_incomp(void *state, u_char *dmsg, int len);
75 static int z_decompress(void *state, u_char *cmp, int inlen,
76 u_char *dmp, int *outlenp);
77 static void z_decomp_reset(void *state);
78 static void z_comp_stats(void *state, struct compstat *stats);
81 * Procedures exported to if_ppp.c.
83 struct compressor ppp_deflate = {
84 CI_DEFLATE, /* compress_proto */
85 z_decomp_alloc, /* decomp_alloc */
86 z_decomp_free, /* decomp_free */
87 z_decomp_init, /* decomp_init */
88 z_decomp_reset, /* decomp_reset */
89 z_decompress, /* decompress */
90 z_incomp, /* incomp */
91 z_comp_stats, /* decomp_stat */
95 * Space allocation and freeing routines for use by zlib routines.
98 z_alloc(void *notused, u_int items, u_int size)
100 return malloc(items * size);
104 z_free(void *notused, void *ptr, u_int nbytes)
110 z_comp_stats(void *arg, struct compstat *stats)
112 struct deflate_state *state = (struct deflate_state *) arg;
115 *stats = state->stats;
116 stats->ratio = stats->unc_bytes;
117 out = stats->comp_bytes + stats->unc_bytes;
118 if (stats->ratio <= 0x7ffffff)
127 * Allocate space for a decompressor.
130 z_decomp_alloc(u_char *options, int opt_len)
132 struct deflate_state *state;
135 if (opt_len != CILEN_DEFLATE || options[0] != CI_DEFLATE
136 || options[1] != CILEN_DEFLATE
137 || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
138 || options[3] != DEFLATE_CHK_SEQUENCE)
140 w_size = DEFLATE_SIZE(options[2]);
141 if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
144 state = (struct deflate_state *) malloc(sizeof(*state));
148 state->strm.next_out = NULL;
149 state->strm.zalloc = (alloc_func) z_alloc;
150 state->strm.zfree = (free_func) z_free;
151 if (inflateInit2(&state->strm, -w_size) != Z_OK) {
156 state->w_size = w_size;
157 memset(&state->stats, 0, sizeof(state->stats));
158 return (void *) state;
162 z_decomp_free(void *arg)
164 struct deflate_state *state = (struct deflate_state *) arg;
166 inflateEnd(&state->strm);
171 z_decomp_init(void *arg, u_char *options, int opt_len,
172 int unit, int hdrlen, int mru, int debug)
174 struct deflate_state *state = (struct deflate_state *) arg;
176 if (opt_len < CILEN_DEFLATE || options[0] != CI_DEFLATE
177 || options[1] != CILEN_DEFLATE
178 || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
179 || DEFLATE_SIZE(options[2]) != state->w_size
180 || options[3] != DEFLATE_CHK_SEQUENCE)
185 state->hdrlen = hdrlen;
186 state->debug = debug;
189 inflateReset(&state->strm);
195 z_decomp_reset(void *arg)
197 struct deflate_state *state = (struct deflate_state *) arg;
200 inflateReset(&state->strm);
204 * Decompress a Deflate-compressed packet.
206 * Because of patent problems, we return DECOMP_ERROR for errors
207 * found by inspecting the input data and for system problems, but
208 * DECOMP_FATALERROR for any errors which could possibly be said to
209 * be being detected "after" decompression. For DECOMP_ERROR,
210 * we can issue a CCP reset-request; for DECOMP_FATALERROR, we may be
211 * infringing a patent of Motorola's if we do, so we take CCP down
214 * Given that the frame has the correct sequence number and a good FCS,
215 * errors such as invalid codes in the input most likely indicate a
216 * bug, so we return DECOMP_FATALERROR for them in order to turn off
217 * compression, even though they are detected by inspecting the input.
220 z_decompress(void *arg, u_char *mi, int inlen, u_char *mo, int *outlenp)
222 struct deflate_state *state = (struct deflate_state *) arg;
232 /* Check the sequence number. */
233 seq = (rptr[0] << 8) + rptr[1];
235 if (seq != state->seqno) {
239 printf("z_decompress%d: bad seq # %d, expected %d\n",
240 state->unit, seq, state->seqno);
246 * Set up to call inflate.
249 state->strm.next_in = rptr;
250 state->strm.avail_in = mi + inlen - rptr;
251 rlen = state->strm.avail_in + PPP_HDRLEN + DEFLATE_OVHD;
252 state->strm.next_out = wptr;
253 state->strm.avail_out = state->mru + 2;
255 r = inflate(&state->strm, Z_PACKET_FLUSH);
260 printf("z_decompress%d: inflate returned %d (%s)\n",
261 state->unit, r, (state->strm.msg? state->strm.msg: ""));
262 return DECOMP_FATALERROR;
264 olen = state->mru + 2 - state->strm.avail_out;
267 if ((wptr[0] & 1) != 0)
268 ++olen; /* for suppressed protocol high byte */
269 olen += 2; /* for address, control */
272 if (olen > state->mru + PPP_HDRLEN)
273 printf("ppp_deflate%d: exceeded mru (%d > %d)\n",
274 state->unit, olen, state->mru + PPP_HDRLEN);
277 state->stats.unc_bytes += olen;
278 state->stats.unc_packets++;
279 state->stats.comp_bytes += rlen;
280 state->stats.comp_packets++;
286 * Incompressible data has arrived - add it to the history.
289 z_incomp(void *arg, u_char *mi, int mlen)
291 struct deflate_state *state = (struct deflate_state *) arg;
296 * Check that the protocol is one we handle.
300 if ((proto & 1) == 0)
301 proto = (proto << 8) + rptr[1];
302 if (proto > 0x3fff || proto == 0xfd || proto == 0xfb)
309 rlen = mi + mlen - rptr;
310 state->strm.next_in = rptr;
311 state->strm.avail_in = rlen;
312 r = inflateIncomp(&state->strm);
318 printf("z_incomp%d: inflateIncomp returned %d (%s)\n",
319 state->unit, r, (state->strm.msg? state->strm.msg: ""));
329 state->stats.inc_bytes += rlen;
330 state->stats.inc_packets++;
331 state->stats.unc_bytes += rlen;
332 state->stats.unc_packets++;
335 #endif /* DO_DEFLATE */