1 /* $FreeBSD: src/sys/net/ppp_deflate.c,v 1.12.2.1 2002/04/14 21:41:48 luigi Exp $ */
2 /* $DragonFly: src/sys/net/ppp_layer/ppp_deflate.c,v 1.9 2006/12/22 23:44:57 swildner Exp $ */
5 * ppp_deflate.c - interface the zlib procedures for Deflate compression
6 * and decompression (as used by gzip) to the PPP code.
7 * This version is for use with mbufs on BSD-derived systems.
9 * Copyright (c) 1994 The Australian National University.
10 * All rights reserved.
12 * Permission to use, copy, modify, and distribute this software and its
13 * documentation is hereby granted, provided that the above copyright
14 * notice appears in all copies. This software is provided without any
15 * warranty, express or implied. The Australian National University
16 * makes no representations about the suitability of this software for
19 * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
20 * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
21 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
22 * THE AUSTRALIAN NATIONAL UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY
25 * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
26 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
27 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
28 * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
29 * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/malloc.h>
40 #define PACKETPTR struct mbuf *
45 #define DEFLATE_DEBUG 1
48 * State for a Deflate (de)compressor.
50 struct deflate_state
{
58 struct compstat stats
;
61 #define DEFLATE_OVHD 2 /* Deflate overhead/packet */
63 static void *z_alloc (void *, u_int items
, u_int size
);
64 static void z_free (void *, void *ptr
);
65 static void *z_comp_alloc (u_char
*options
, int opt_len
);
66 static void *z_decomp_alloc (u_char
*options
, int opt_len
);
67 static void z_comp_free (void *state
);
68 static void z_decomp_free (void *state
);
69 static int z_comp_init (void *state
, u_char
*options
, int opt_len
,
70 int unit
, int hdrlen
, int debug
);
71 static int z_decomp_init (void *state
, u_char
*options
, int opt_len
,
72 int unit
, int hdrlen
, int mru
, int debug
);
73 static int z_compress (void *state
, struct mbuf
**mret
,
74 struct mbuf
*mp
, int slen
, int maxolen
);
75 static void z_incomp (void *state
, struct mbuf
*dmsg
);
76 static int z_decompress (void *state
, struct mbuf
*cmp
,
78 static void z_comp_reset (void *state
);
79 static void z_decomp_reset (void *state
);
80 static void z_comp_stats (void *state
, struct compstat
*stats
);
83 * Procedures exported to if_ppp.c.
85 struct compressor ppp_deflate
= {
86 CI_DEFLATE
, /* compress_proto */
87 z_comp_alloc
, /* comp_alloc */
88 z_comp_free
, /* comp_free */
89 z_comp_init
, /* comp_init */
90 z_comp_reset
, /* comp_reset */
91 z_compress
, /* compress */
92 z_comp_stats
, /* comp_stat */
93 z_decomp_alloc
, /* decomp_alloc */
94 z_decomp_free
, /* decomp_free */
95 z_decomp_init
, /* decomp_init */
96 z_decomp_reset
, /* decomp_reset */
97 z_decompress
, /* decompress */
98 z_incomp
, /* incomp */
99 z_comp_stats
, /* decomp_stat */
102 struct compressor ppp_deflate_draft
= {
103 CI_DEFLATE_DRAFT
, /* compress_proto */
104 z_comp_alloc
, /* comp_alloc */
105 z_comp_free
, /* comp_free */
106 z_comp_init
, /* comp_init */
107 z_comp_reset
, /* comp_reset */
108 z_compress
, /* compress */
109 z_comp_stats
, /* comp_stat */
110 z_decomp_alloc
, /* decomp_alloc */
111 z_decomp_free
, /* decomp_free */
112 z_decomp_init
, /* decomp_init */
113 z_decomp_reset
, /* decomp_reset */
114 z_decompress
, /* decompress */
115 z_incomp
, /* incomp */
116 z_comp_stats
, /* decomp_stat */
120 * Space allocation and freeing routines for use by zlib routines.
123 z_alloc(void *notused
, u_int items
, u_int size
)
127 MALLOC(ptr
, void *, items
* size
, M_DEVBUF
, M_WAITOK
);
132 z_free(void *notused
, void *ptr
)
134 kfree(ptr
, M_DEVBUF
);
138 * Allocate space for a compressor.
141 z_comp_alloc(u_char
*options
, int opt_len
)
143 struct deflate_state
*state
;
146 if (opt_len
!= CILEN_DEFLATE
147 || (options
[0] != CI_DEFLATE
&& options
[0] != CI_DEFLATE_DRAFT
)
148 || options
[1] != CILEN_DEFLATE
149 || DEFLATE_METHOD(options
[2]) != DEFLATE_METHOD_VAL
150 || options
[3] != DEFLATE_CHK_SEQUENCE
)
152 w_size
= DEFLATE_SIZE(options
[2]);
153 if (w_size
< DEFLATE_MIN_SIZE
|| w_size
> DEFLATE_MAX_SIZE
)
156 MALLOC(state
, struct deflate_state
*, sizeof(struct deflate_state
),
159 state
->strm
.next_in
= NULL
;
160 state
->strm
.zalloc
= z_alloc
;
161 state
->strm
.zfree
= z_free
;
162 if (deflateInit2(&state
->strm
, Z_DEFAULT_COMPRESSION
, DEFLATE_METHOD_VAL
,
163 -w_size
, 8, Z_DEFAULT_STRATEGY
) != Z_OK
) {
164 kfree(state
, M_DEVBUF
);
168 state
->w_size
= w_size
;
169 bzero(&state
->stats
, sizeof(state
->stats
));
170 return (void *) state
;
174 z_comp_free(void *arg
)
176 struct deflate_state
*state
= (struct deflate_state
*) arg
;
178 deflateEnd(&state
->strm
);
179 kfree(state
, M_DEVBUF
);
183 z_comp_init(void *arg
, u_char
*options
, int opt_len
, int unit
, int hdrlen
,
186 struct deflate_state
*state
= (struct deflate_state
*) arg
;
188 if (opt_len
< CILEN_DEFLATE
189 || (options
[0] != CI_DEFLATE
&& options
[0] != CI_DEFLATE_DRAFT
)
190 || options
[1] != CILEN_DEFLATE
191 || DEFLATE_METHOD(options
[2]) != DEFLATE_METHOD_VAL
192 || DEFLATE_SIZE(options
[2]) != state
->w_size
193 || options
[3] != DEFLATE_CHK_SEQUENCE
)
198 state
->hdrlen
= hdrlen
;
199 state
->debug
= debug
;
201 deflateReset(&state
->strm
);
207 z_comp_reset(void *arg
)
209 struct deflate_state
*state
= (struct deflate_state
*) arg
;
212 deflateReset(&state
->strm
);
217 * mret: compressed packet (out)
218 * mp: uncompressed packet (in)
221 z_compress(void *arg
, struct mbuf
**mret
, struct mbuf
*mp
, int orig_len
,
224 struct deflate_state
*state
= (struct deflate_state
*) arg
;
226 int proto
, olen
, wspace
, r
, flush
;
230 * Check that the protocol is in the range we handle.
232 rptr
= mtod(mp
, u_char
*);
233 proto
= PPP_PROTOCOL(rptr
);
234 if (proto
> 0x3fff || proto
== 0xfd || proto
== 0xfb) {
239 /* Allocate one mbuf initially. */
240 if (maxolen
> orig_len
)
242 MGET(m
, MB_DONTWAIT
, MT_DATA
);
246 if (maxolen
+ state
->hdrlen
> MLEN
)
247 MCLGET(m
, MB_DONTWAIT
);
248 wspace
= M_TRAILINGSPACE(m
);
249 if (state
->hdrlen
+ PPP_HDRLEN
+ 2 < wspace
) {
250 m
->m_data
+= state
->hdrlen
;
251 wspace
-= state
->hdrlen
;
253 wptr
= mtod(m
, u_char
*);
256 * Copy over the PPP header and store the 2-byte sequence number.
258 wptr
[0] = PPP_ADDRESS(rptr
);
259 wptr
[1] = PPP_CONTROL(rptr
);
260 wptr
[2] = PPP_COMP
>> 8;
263 wptr
[0] = state
->seqno
>> 8;
264 wptr
[1] = state
->seqno
;
266 state
->strm
.next_out
= wptr
;
267 state
->strm
.avail_out
= wspace
- (PPP_HDRLEN
+ 2);
269 state
->strm
.next_out
= NULL
;
270 state
->strm
.avail_out
= 1000000;
276 rptr
+= (proto
> 0xff)? 2: 3; /* skip 1st proto byte if 0 */
277 state
->strm
.next_in
= rptr
;
278 state
->strm
.avail_in
= mtod(mp
, u_char
*) + mp
->m_len
- rptr
;
280 flush
= (mp
== NULL
)? Z_PACKET_FLUSH
: Z_NO_FLUSH
;
283 r
= deflate(&state
->strm
, flush
);
285 kprintf("z_compress: deflate returned %d (%s)\n",
286 r
, (state
->strm
.msg
? state
->strm
.msg
: ""));
289 if (flush
!= Z_NO_FLUSH
&& state
->strm
.avail_out
!= 0)
290 break; /* all done */
291 if (state
->strm
.avail_in
== 0 && mp
!= NULL
) {
292 state
->strm
.next_in
= mtod(mp
, u_char
*);
293 state
->strm
.avail_in
= mp
->m_len
;
296 flush
= Z_PACKET_FLUSH
;
298 if (state
->strm
.avail_out
== 0) {
302 MGET(m
->m_next
, MB_DONTWAIT
, MT_DATA
);
306 if (maxolen
- olen
> MLEN
)
307 MCLGET(m
, MB_DONTWAIT
);
308 state
->strm
.next_out
= mtod(m
, u_char
*);
309 state
->strm
.avail_out
= wspace
= M_TRAILINGSPACE(m
);
313 state
->strm
.next_out
= NULL
;
314 state
->strm
.avail_out
= 1000000;
319 olen
+= (m
->m_len
= wspace
- state
->strm
.avail_out
);
322 * See if we managed to reduce the size of the packet.
324 if (m
!= NULL
&& olen
< orig_len
) {
325 state
->stats
.comp_bytes
+= olen
;
326 state
->stats
.comp_packets
++;
332 state
->stats
.inc_bytes
+= orig_len
;
333 state
->stats
.inc_packets
++;
336 state
->stats
.unc_bytes
+= orig_len
;
337 state
->stats
.unc_packets
++;
343 z_comp_stats(void *arg
, struct compstat
*stats
)
345 struct deflate_state
*state
= (struct deflate_state
*) arg
;
348 *stats
= state
->stats
;
349 stats
->ratio
= stats
->unc_bytes
;
350 out
= stats
->comp_bytes
+ stats
->inc_bytes
;
351 if (stats
->ratio
<= 0x7ffffff)
360 * Allocate space for a decompressor.
363 z_decomp_alloc(u_char
*options
, int opt_len
)
365 struct deflate_state
*state
;
368 if (opt_len
!= CILEN_DEFLATE
369 || (options
[0] != CI_DEFLATE
&& options
[0] != CI_DEFLATE_DRAFT
)
370 || options
[1] != CILEN_DEFLATE
371 || DEFLATE_METHOD(options
[2]) != DEFLATE_METHOD_VAL
372 || options
[3] != DEFLATE_CHK_SEQUENCE
)
374 w_size
= DEFLATE_SIZE(options
[2]);
375 if (w_size
< DEFLATE_MIN_SIZE
|| w_size
> DEFLATE_MAX_SIZE
)
378 MALLOC(state
, struct deflate_state
*, sizeof(struct deflate_state
),
381 state
->strm
.next_out
= NULL
;
382 state
->strm
.zalloc
= z_alloc
;
383 state
->strm
.zfree
= z_free
;
384 if (inflateInit2(&state
->strm
, -w_size
) != Z_OK
) {
385 kfree(state
, M_DEVBUF
);
389 state
->w_size
= w_size
;
390 bzero(&state
->stats
, sizeof(state
->stats
));
391 return (void *) state
;
395 z_decomp_free(void *arg
)
397 struct deflate_state
*state
= (struct deflate_state
*) arg
;
399 inflateEnd(&state
->strm
);
400 kfree(state
, M_DEVBUF
);
404 z_decomp_init(void *arg
, u_char
*options
, int opt_len
, int unit
, int hdrlen
,
407 struct deflate_state
*state
= (struct deflate_state
*) arg
;
409 if (opt_len
< CILEN_DEFLATE
410 || (options
[0] != CI_DEFLATE
&& options
[0] != CI_DEFLATE_DRAFT
)
411 || options
[1] != CILEN_DEFLATE
412 || DEFLATE_METHOD(options
[2]) != DEFLATE_METHOD_VAL
413 || DEFLATE_SIZE(options
[2]) != state
->w_size
414 || options
[3] != DEFLATE_CHK_SEQUENCE
)
419 state
->hdrlen
= hdrlen
;
420 state
->debug
= debug
;
423 inflateReset(&state
->strm
);
429 z_decomp_reset(void *arg
)
431 struct deflate_state
*state
= (struct deflate_state
*) arg
;
434 inflateReset(&state
->strm
);
438 * Decompress a Deflate-compressed packet.
440 * Because of patent problems, we return DECOMP_ERROR for errors
441 * found by inspecting the input data and for system problems, but
442 * DECOMP_FATALERROR for any errors which could possibly be said to
443 * be being detected "after" decompression. For DECOMP_ERROR,
444 * we can issue a CCP reset-request; for DECOMP_FATALERROR, we may be
445 * infringing a patent of Motorola's if we do, so we take CCP down
448 * Given that the frame has the correct sequence number and a good FCS,
449 * errors such as invalid codes in the input most likely indicate a
450 * bug, so we return DECOMP_FATALERROR for them in order to turn off
451 * compression, even though they are detected by inspecting the input.
454 z_decompress(void *arg
, struct mbuf
*mi
, struct mbuf
**mop
)
456 struct deflate_state
*state
= (struct deflate_state
*) arg
;
457 struct mbuf
*mo
, *mo_head
;
459 int rlen
, olen
, ospace
;
460 int seq
, i
, flush
, r
, decode_proto
;
461 u_char hdr
[PPP_HDRLEN
+ DEFLATE_OVHD
];
464 rptr
= mtod(mi
, u_char
*);
466 for (i
= 0; i
< PPP_HDRLEN
+ DEFLATE_OVHD
; ++i
) {
471 rptr
= mtod(mi
, u_char
*);
478 /* Check the sequence number. */
479 seq
= (hdr
[PPP_HDRLEN
] << 8) + hdr
[PPP_HDRLEN
+1];
480 if (seq
!= state
->seqno
) {
482 kprintf("z_decompress%d: bad seq # %d, expected %d\n",
483 state
->unit
, seq
, state
->seqno
);
488 /* Allocate an output mbuf. */
489 MGETHDR(mo
, MB_DONTWAIT
, MT_DATA
);
495 MCLGET(mo
, MB_DONTWAIT
);
496 ospace
= M_TRAILINGSPACE(mo
);
497 if (state
->hdrlen
+ PPP_HDRLEN
< ospace
) {
498 mo
->m_data
+= state
->hdrlen
;
499 ospace
-= state
->hdrlen
;
503 * Fill in the first part of the PPP header. The protocol field
504 * comes from the decompressed data.
506 wptr
= mtod(mo
, u_char
*);
507 wptr
[0] = PPP_ADDRESS(hdr
);
508 wptr
[1] = PPP_CONTROL(hdr
);
512 * Set up to call inflate. We set avail_out to 1 initially so we can
513 * look at the first byte of the output and decide whether we have
514 * a 1-byte or 2-byte protocol field.
516 state
->strm
.next_in
= rptr
;
517 state
->strm
.avail_in
= rlen
;
519 flush
= (mi
== NULL
)? Z_PACKET_FLUSH
: Z_NO_FLUSH
;
520 rlen
+= PPP_HDRLEN
+ DEFLATE_OVHD
;
521 state
->strm
.next_out
= wptr
+ 3;
522 state
->strm
.avail_out
= 1;
527 * Call inflate, supplying more input or output as needed.
530 r
= inflate(&state
->strm
, flush
);
535 kprintf("z_decompress%d: inflate returned %d (%s)\n",
536 state
->unit
, r
, (state
->strm
.msg
? state
->strm
.msg
: ""));
538 return DECOMP_FATALERROR
;
540 if (flush
!= Z_NO_FLUSH
&& state
->strm
.avail_out
!= 0)
541 break; /* all done */
542 if (state
->strm
.avail_in
== 0 && mi
!= NULL
) {
543 state
->strm
.next_in
= mtod(mi
, u_char
*);
544 state
->strm
.avail_in
= mi
->m_len
;
548 flush
= Z_PACKET_FLUSH
;
550 if (state
->strm
.avail_out
== 0) {
552 state
->strm
.avail_out
= ospace
- PPP_HDRLEN
;
553 if ((wptr
[3] & 1) == 0) {
554 /* 2-byte protocol field */
556 --state
->strm
.next_out
;
557 ++state
->strm
.avail_out
;
564 MGET(mo
->m_next
, MB_DONTWAIT
, MT_DATA
);
570 MCLGET(mo
, MB_DONTWAIT
);
571 state
->strm
.next_out
= mtod(mo
, u_char
*);
572 state
->strm
.avail_out
= ospace
= M_TRAILINGSPACE(mo
);
580 olen
+= (mo
->m_len
= ospace
- state
->strm
.avail_out
);
582 if (state
->debug
&& olen
> state
->mru
+ PPP_HDRLEN
)
583 kprintf("ppp_deflate%d: exceeded mru (%d > %d)\n",
584 state
->unit
, olen
, state
->mru
+ PPP_HDRLEN
);
587 state
->stats
.unc_bytes
+= olen
;
588 state
->stats
.unc_packets
++;
589 state
->stats
.comp_bytes
+= rlen
;
590 state
->stats
.comp_packets
++;
597 * Incompressible data has arrived - add it to the history.
600 z_incomp(void *arg
, struct mbuf
*mi
)
602 struct deflate_state
*state
= (struct deflate_state
*) arg
;
607 * Check that the protocol is one we handle.
609 rptr
= mtod(mi
, u_char
*);
610 proto
= PPP_PROTOCOL(rptr
);
611 if (proto
> 0x3fff || proto
== 0xfd || proto
== 0xfb)
617 * Iterate through the mbufs, adding the characters in them
618 * to the decompressor's history. For the first mbuf, we start
619 * at the either the 1st or 2nd byte of the protocol field,
620 * depending on whether the protocol value is compressible.
623 state
->strm
.next_in
= rptr
+ 3;
624 state
->strm
.avail_in
= rlen
- 3;
626 --state
->strm
.next_in
;
627 ++state
->strm
.avail_in
;
630 r
= inflateIncomp(&state
->strm
);
636 kprintf("z_incomp%d: inflateIncomp returned %d (%s)\n",
637 state
->unit
, r
, (state
->strm
.msg
? state
->strm
.msg
: ""));
643 state
->strm
.next_in
= mtod(mi
, u_char
*);
644 state
->strm
.avail_in
= mi
->m_len
;
651 state
->stats
.inc_bytes
+= rlen
;
652 state
->stats
.inc_packets
++;
653 state
->stats
.unc_bytes
+= rlen
;
654 state
->stats
.unc_packets
++;
657 #endif /* DO_DEFLATE */