use kmalloc not mempool stuff; handle mru-length packets properly
[ppp.git] / linux / ppp_deflate.c
1 /*
2  *  ==FILEVERSION 960926==
3  *
4  * ppp_deflate.c - interface the zlib procedures for Deflate compression
5  * and decompression (as used by gzip) to the PPP code.
6  * This version is for use with Linux kernel 1.3.X.
7  *
8  * Copyright (c) 1994 The Australian National University.
9  * All rights reserved.
10  *
11  * Permission to use, copy, modify, and distribute this software and its
12  * documentation is hereby granted, provided that the above copyright
13  * notice appears in all copies.  This software is provided without any
14  * warranty, express or implied. The Australian National University
15  * makes no representations about the suitability of this software for
16  * any purpose.
17  *
18  * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
19  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
20  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
21  * THE AUSTRALIAN NATIONAL UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY
22  * OF SUCH DAMAGE.
23  *
24  * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
25  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
26  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
27  * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
28  * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
29  * OR MODIFICATIONS.
30  *
31  * From: deflate.c,v 1.1 1996/01/18 03:17:48 paulus Exp
32  */
33
34 #include <linux/module.h>
35
36 #include <endian.h>
37 #include <linux/kernel.h>
38 #include <linux/sched.h>
39 #include <linux/types.h>
40 #include <linux/fcntl.h>
41 #include <linux/interrupt.h>
42 #include <linux/ptrace.h>
43 #include <linux/ioport.h>
44 #include <linux/in.h>
45 #include <linux/malloc.h>
46 #include <linux/tty.h>
47 #include <linux/errno.h>
48 #include <linux/sched.h>        /* to get the struct task_struct */
49 #include <linux/string.h>       /* used in new tty drivers */
50 #include <linux/signal.h>       /* used in new tty drivers */
51
52 #include <asm/system.h>
53 #include <asm/bitops.h>
54 #include <asm/segment.h>
55
56 #include <net/if.h>
57
58 #include <linux/if_ether.h>
59 #include <linux/netdevice.h>
60 #include <linux/skbuff.h>
61 #include <linux/inet.h>
62 #include <linux/ioctl.h>
63
64 #include <linux/ppp_defs.h>
65
66 #ifdef NEW_SKBUFF
67 #include <linux/netprotocol.h>
68 #endif
69
70 #include <netinet/ip.h>
71 #include <netinet/tcp.h>
72 #include <net/if_arp.h>
73 #include <linux/ppp-comp.h>
74
75 #include "zlib.c"
76
77 #define USEMEMPOOL      0       /* use kmalloc, not memPool routines */
78
79 /*
80  * State for a Deflate (de)compressor.
81  */
82 struct ppp_deflate_state {
83     int         seqno;
84     int         w_size;
85     int         unit;
86     int         mru;
87     int         debug;
88     int         in_alloc;       /* set when we're in [de]comp_alloc */
89     z_stream    strm;
90     struct compstat stats;
91 };
92
93 #define DEFLATE_OVHD    2               /* Deflate overhead/packet */
94
95 static void     *zalloc __P((void *, unsigned int items, unsigned int size));
96 static void     zfree __P((void *, void *ptr, unsigned int nb));
97 static void     *z_comp_alloc __P((unsigned char *options, int opt_len));
98 static void     *z_decomp_alloc __P((unsigned char *options, int opt_len));
99 static void     z_comp_free __P((void *state));
100 static void     z_decomp_free __P((void *state));
101 static int      z_comp_init __P((void *state, unsigned char *options,
102                                  int opt_len,
103                                  int unit, int hdrlen, int debug));
104 static int      z_decomp_init __P((void *state, unsigned char *options,
105                                    int opt_len,
106                                    int unit, int hdrlen, int mru, int debug));
107 static int      z_compress __P((void *state, unsigned char *rptr,
108                                 unsigned char *obuf,
109                                 int isize, int osize));
110 static void     z_incomp __P((void *state, unsigned char *ibuf, int icnt));
111 static int      z_decompress __P((void *state, unsigned char *ibuf,
112                                 int isize, unsigned char *obuf, int osize));
113 static void     z_comp_reset __P((void *state));
114 static void     z_decomp_reset __P((void *state));
115 static void     z_comp_stats __P((void *state, struct compstat *stats));
116
117 #if USEMEMPOOL
118 /*
119  * This is a small set of memory allocation routines.  I created them so
120  * that all memory allocation from the kernel takes place at the
121  * z_(de)comp_alloc and z_(de)comp_free routines.  This eliminates worry
122  * about calling valloc() from within an interrupt.
123  *
124  * The free list is a single linked list sorted by memory address.
125  * The zfree() function re-combines any segments it can.
126  */
127 typedef struct memchunk {
128     unsigned int m_size;
129     struct memchunk *m_next;
130 } MemChunk;
131
132 typedef struct {
133     void *memHead;
134     MemChunk *freePool;
135 } MemPool;
136
137 static int     memPoolAlloc __P((void *arg, unsigned int size));
138 static void    memPoolFree __P((void *arg));
139
140 static int
141 memPoolAlloc(arg, size)
142 void *arg;
143 unsigned int size;
144 {
145     MemPool **memPool = arg;
146     MemChunk *freePool;
147
148     if ((*memPool = kmalloc(sizeof(MemPool), GFP_KERNEL)) == NULL) {
149         printk(KERN_DEBUG "Unable to allocate Memory Head\n");
150         return 0;
151     }
152
153     if (((*memPool)->memHead = (void *)vmalloc(size)) == NULL) {
154         printk(KERN_DEBUG "Unable to allocate Memory Pool\n");
155         kfree(*memPool);
156         return 0;
157     }
158     freePool = (*memPool)->freePool = (*memPool)->memHead;
159     freePool->m_size = size;
160     freePool->m_next = 0;
161
162     return 1;
163 }
164
165 static void
166 memPoolFree(arg)
167 void *arg;
168 {
169     MemPool **memPool = arg;
170
171     if (*memPool) {
172         vfree((*memPool)->memHead);
173         kfree(*memPool);
174         *memPool = NULL;
175     }
176 }
177
178 #ifdef POOLDGB
179 static void    showFreeList __P((MemChunk *));
180
181 static void
182 showFreeList(freePool)
183 MemChunk *freePool;
184 {
185     MemChunk *node;
186     
187     for (node = freePool; node; node = node->m_next)
188         printk(KERN_DEBUG "{%x,%d}->", node, node->m_size);
189     printk(KERN_DEBUG "\n");
190 }
191 #endif
192 #endif /* USEMEMPOOL */
193
194 /*
195  * Space allocation and freeing routines for use by zlib routines.
196  */
197 void
198 zfree(arg, ptr, nbytes)
199     void *arg;
200     void *ptr;
201     unsigned int nbytes;
202 {
203 #if !USEMEMPOOL
204     kfree(ptr);
205 #else
206     MemPool *memPool = (MemPool *)arg;
207     MemChunk *mprev = 0, *node;
208     MemChunk *new = (void *)(((unsigned char *)ptr) - sizeof(MemChunk));
209
210     if (!memPool->freePool) {
211         new->m_next = 0;
212         memPool->freePool = new;
213     } else {
214         /*
215          * Find where this new chunk fits in the free list.
216          */
217         for (node = memPool->freePool; node && new > node; node = node->m_next)
218             mprev = node;
219         /*
220          * Re-combine with the following free chunk if possible.
221          */
222         if ((((unsigned char *)new) + new->m_size) == (unsigned char *)node) {
223             new->m_size += node->m_size;
224             new->m_next = node->m_next;
225             if (mprev) {
226                 if ((((unsigned char *)mprev) + mprev->m_size) == (unsigned char *)new) {
227                     mprev->m_size += new->m_size;
228                     mprev->m_next = new->m_next;
229                 } else
230                     mprev->m_next = new;
231             } else
232                 memPool->freePool = new;
233         /*
234          * Re-combine with the previous free chunk if possible.
235          */
236         } else if (mprev && (((unsigned char *)mprev) + mprev->m_size) ==
237           (unsigned char *)new) {
238             mprev->m_size += new->m_size;
239             if ((((unsigned char *)mprev) + mprev->m_size) == (unsigned char *)node) {
240                 mprev->m_size += node->m_size;
241                 mprev->m_next = node->m_next;
242             } else
243                 mprev->m_next = node;
244         /*
245          * No luck re-combining, just insert the new chunk into the list.
246          */
247         } else {
248             if (mprev)
249                 mprev->m_next = new;
250             else
251                 memPool->freePool = new;
252             new->m_next = node;
253         }
254     }
255 #endif /* USEMEMPOOL */
256 }
257
258 void *
259 zalloc(arg, items, size)
260     void *arg;
261     unsigned int items, size;
262 {
263 #if !USEMEMPOOL
264     struct ppp_deflate_state *state = arg;
265
266     return kmalloc(items * size, state->in_alloc? GFP_KERNEL: GFP_ATOMIC);
267 #else
268     MemPool *memPool = (MemPool *)arg;
269     MemChunk *mprev = 0, *node;
270
271     size *= items;
272     size += sizeof(MemChunk);
273     if (size & 0x3)
274         size = (size + 7) & ~3; 
275     for (node = memPool->freePool; node; node = node->m_next) {
276         if (size == node->m_size) {
277             if (mprev)
278                 mprev->m_next = node->m_next;
279             else
280                 memPool->freePool = node->m_next;
281             return (void *)(((unsigned char *)node)+sizeof(MemChunk));
282         } else if (node->m_size > (size + sizeof(MemChunk) + 7)) {
283             MemChunk *new;
284
285             new = (void *)(((unsigned char *)node) + size);
286             new->m_size = node->m_size - size;
287             new->m_next = node->m_next;
288             if (mprev)
289                 mprev->m_next = new;
290             else
291                 memPool->freePool = new;
292
293             node->m_size = size;
294
295             return (void *)(((unsigned char *)node)+sizeof(MemChunk));
296             break;
297         }
298         mprev = node;
299     }
300     printk(KERN_DEBUG
301            "zalloc(%d)... Out of memory in Pool!\n", size - sizeof(MemChunk)); 
302     return NULL;
303 #endif /* USEMEMPOOL */
304 }
305
306 static void
307 z_comp_free(arg)
308     void *arg;
309 {
310     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
311
312     if (state) {
313             deflateEnd(&state->strm);
314 #if USEMEMPOOL
315             memPoolFree(&state->strm.opaque);
316 #endif
317             kfree(state);
318             MOD_DEC_USE_COUNT;
319     }
320 }
321
322 /*
323  * Allocate space for a compressor.
324  */
325 static void *
326 z_comp_alloc(options, opt_len)
327     unsigned char *options;
328     int opt_len;
329 {
330     struct ppp_deflate_state *state;
331     int w_size;
332
333     if (opt_len != CILEN_DEFLATE || options[0] != CI_DEFLATE
334         || options[1] != CILEN_DEFLATE
335         || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
336         || options[3] != DEFLATE_CHK_SEQUENCE)
337         return NULL;
338     w_size = DEFLATE_SIZE(options[2]);
339     if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
340         return NULL;
341
342     state = (struct ppp_deflate_state *) kmalloc(sizeof(*state), GFP_KERNEL);
343     if (state == NULL)
344         return NULL;
345
346     MOD_INC_USE_COUNT;
347     memset (state, 0, sizeof (struct ppp_deflate_state));
348     state->strm.next_in = NULL;
349     state->strm.zalloc  = zalloc;
350     state->strm.zfree   = zfree;
351     state->w_size       = w_size;
352     state->in_alloc = 1;
353
354 #if USEMEMPOOL
355     if (!memPoolAlloc(&state->strm.opaque, 0x50000)) {
356         z_comp_free(state);
357         return NULL;
358     }
359 #else
360     state->strm.opaque = state;
361 #endif
362
363     if (deflateInit2(&state->strm, Z_DEFAULT_COMPRESSION, DEFLATE_METHOD_VAL,
364                      -w_size, 8, Z_DEFAULT_STRATEGY, DEFLATE_OVHD+2) != Z_OK) {
365         z_comp_free(state);
366         return NULL;
367     }
368     state->in_alloc = 0;
369     return (void *) state;
370 }
371
372 static int
373 z_comp_init(arg, options, opt_len, unit, hdrlen, debug)
374     void *arg;
375     unsigned char *options;
376     int opt_len, unit, hdrlen, debug;
377 {
378     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
379
380     if (opt_len < CILEN_DEFLATE || options[0] != CI_DEFLATE
381         || options[1] != CILEN_DEFLATE
382         || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
383         || DEFLATE_SIZE(options[2]) != state->w_size
384         || options[3] != DEFLATE_CHK_SEQUENCE)
385         return 0;
386
387     state->seqno = 0;
388     state->unit  = unit;
389     state->debug = debug;
390
391     deflateReset(&state->strm);
392
393     return 1;
394 }
395
396 static void
397 z_comp_reset(arg)
398     void *arg;
399 {
400     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
401
402     state->seqno = 0;
403     deflateReset(&state->strm);
404 }
405
406 int
407 z_compress(arg, rptr, obuf, isize, osize)
408     void *arg;
409     unsigned char *rptr;        /* uncompressed packet (in) */
410     unsigned char *obuf;        /* compressed packet (out) */
411     int isize, osize;
412 {
413     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
414     int r, proto, off, olen;
415     unsigned char *wptr;
416
417     /*
418      * Check that the protocol is in the range we handle.
419      */
420     proto = PPP_PROTOCOL(rptr);
421     if (proto > 0x3fff || proto == 0xfd || proto == 0xfb)
422         return 0;
423
424     /* Don't generate compressed packets which are larger than
425        the uncompressed packet. */
426     if (osize > isize)
427         osize = isize;
428
429     wptr = obuf;
430
431     /*
432      * Copy over the PPP header and store the 2-byte sequence number.
433      */
434     wptr[0] = PPP_ADDRESS(rptr);
435     wptr[1] = PPP_CONTROL(rptr);
436     wptr[2] = PPP_COMP >> 8;
437     wptr[3] = PPP_COMP;
438     wptr += PPP_HDRLEN;
439     wptr[0] = state->seqno >> 8;
440     wptr[1] = state->seqno;
441     wptr += 2;
442     state->strm.next_out = wptr;
443     state->strm.avail_out = osize - (PPP_HDRLEN + 2);
444     ++state->seqno;
445
446     off = (proto > 0xff) ? 2 : 3;       /* skip 1st proto byte if 0 */
447     rptr += off;
448     state->strm.next_in = rptr;
449     state->strm.avail_in = (isize - off);
450
451     olen = 0;
452     for (;;) {
453         r = deflate(&state->strm, Z_PACKET_FLUSH);
454         if (r != Z_OK) {
455             if (state->debug)
456                 printk(KERN_DEBUG "z_compress: deflate returned %d (%s)\n",
457                        r, (state->strm.msg? state->strm.msg: ""));
458             break;
459         }
460         if (state->strm.avail_out == 0) {
461             olen += osize;
462             state->strm.next_out = NULL;
463             state->strm.avail_out = 1000000;
464         } else {
465             break;              /* all done */
466         }
467     }
468     if (olen < osize)
469         olen += osize - state->strm.avail_out;
470
471     /*
472      * See if we managed to reduce the size of the packet.
473      * If the compressor just gave us a single zero byte, it means
474      * the packet was incompressible.
475      */
476     if (olen < isize && !(olen == PPP_HDRLEN + 3 && *wptr == 0)) {
477         state->stats.comp_bytes += olen;
478         state->stats.comp_packets++;
479     } else {
480         state->stats.inc_bytes += isize;
481         state->stats.inc_packets++;
482         olen = 0;
483     }
484     state->stats.unc_bytes += isize;
485     state->stats.unc_packets++;
486
487     return olen;
488 }
489
490 static void
491 z_comp_stats(arg, stats)
492     void *arg;
493     struct compstat *stats;
494 {
495     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
496
497     *stats = state->stats;
498 }
499
500 static void
501 z_decomp_free(arg)
502     void *arg;
503 {
504     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
505
506     if (state) {
507             inflateEnd(&state->strm);
508 #if USEMEMPOOL
509             memPoolFree(&state->strm.opaque);
510 #endif
511             kfree(state);
512             MOD_DEC_USE_COUNT;
513     }
514 }
515
516 /*
517  * Allocate space for a decompressor.
518  */
519 static void *
520 z_decomp_alloc(options, opt_len)
521     unsigned char *options;
522     int opt_len;
523 {
524     struct ppp_deflate_state *state;
525     int w_size;
526
527     if (opt_len != CILEN_DEFLATE || options[0] != CI_DEFLATE
528         || options[1] != CILEN_DEFLATE
529         || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
530         || options[3] != DEFLATE_CHK_SEQUENCE)
531         return NULL;
532     w_size = DEFLATE_SIZE(options[2]);
533     if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
534         return NULL;
535
536     state = (struct ppp_deflate_state *) kmalloc(sizeof(*state), GFP_KERNEL);
537     if (state == NULL)
538         return NULL;
539
540     MOD_INC_USE_COUNT;
541     memset (state, 0, sizeof (struct ppp_deflate_state));
542     state->w_size        = w_size;
543     state->strm.next_out = NULL;
544     state->strm.zalloc   = zalloc;
545     state->strm.zfree    = zfree;
546     state->in_alloc = 1;
547
548 #if USEMEMPOOL
549     if (!memPoolAlloc(&state->strm.opaque, 0x10000)) {
550         z_decomp_free(state);
551         return NULL;
552     }
553 #else
554     state->strm.opaque = state;
555 #endif
556
557     if (inflateInit2(&state->strm, -w_size) != Z_OK) {
558         z_decomp_free(state);
559         return NULL;
560     }
561     state->in_alloc = 0;
562     return (void *) state;
563 }
564
565 static int
566 z_decomp_init(arg, options, opt_len, unit, hdrlen, mru, debug)
567     void *arg;
568     unsigned char *options;
569     int opt_len, unit, hdrlen, mru, debug;
570 {
571     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
572
573     if (opt_len < CILEN_DEFLATE || options[0] != CI_DEFLATE
574         || options[1] != CILEN_DEFLATE
575         || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
576         || DEFLATE_SIZE(options[2]) != state->w_size
577         || options[3] != DEFLATE_CHK_SEQUENCE)
578         return 0;
579
580     state->seqno = 0;
581     state->unit  = unit;
582     state->debug = debug;
583     state->mru   = mru;
584
585     inflateReset(&state->strm);
586
587     return 1;
588 }
589
590 static void
591 z_decomp_reset(arg)
592     void *arg;
593 {
594     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
595
596     state->seqno = 0;
597     inflateReset(&state->strm);
598 }
599
600 /*
601  * Decompress a Deflate-compressed packet.
602  *
603  * Because of patent problems, we return DECOMP_ERROR for errors
604  * found by inspecting the input data and for system problems, but
605  * DECOMP_FATALERROR for any errors which could possibly be said to
606  * be being detected "after" decompression.  For DECOMP_ERROR,
607  * we can issue a CCP reset-request; for DECOMP_FATALERROR, we may be
608  * infringing a patent of Motorola's if we do, so we take CCP down
609  * instead.
610  *
611  * Given that the frame has the correct sequence number and a good FCS,
612  * errors such as invalid codes in the input most likely indicate a
613  * bug, so we return DECOMP_FATALERROR for them in order to turn off
614  * compression, even though they are detected by inspecting the input.
615  */
616 int
617 z_decompress(arg, ibuf, isize, obuf, osize)
618     void *arg;
619     unsigned char *ibuf;
620     int isize;
621     unsigned char *obuf;
622     int osize;
623 {
624     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
625     int olen, seq, r;
626     int decode_proto, overflow;
627     unsigned char overflow_buf[1];
628
629     if (isize <= PPP_HDRLEN + DEFLATE_OVHD) {
630         if (state->debug)
631             printk(KERN_DEBUG "z_decompress%d: short packet (len=%d)\n",
632                    state->unit, isize);
633         return DECOMP_ERROR;
634     }
635
636     /* Check the sequence number. */
637     seq = (ibuf[PPP_HDRLEN] << 8) + ibuf[PPP_HDRLEN+1];
638     if (seq != state->seqno) {
639         if (state->debug)
640             printk(KERN_DEBUG "z_decompress%d: bad seq # %d, expected %d\n",
641                    state->unit, seq, state->seqno);
642         return DECOMP_ERROR;
643     }
644     ++state->seqno;
645
646     /*
647      * Fill in the first part of the PPP header.  The protocol field
648      * comes from the decompressed data.
649      */
650     obuf[0] = PPP_ADDRESS(ibuf);
651     obuf[1] = PPP_CONTROL(ibuf);
652     obuf[2] = 0;
653
654     /*
655      * Set up to call inflate.  We set avail_out to 1 initially so we can
656      * look at the first byte of the output and decide whether we have
657      * a 1-byte or 2-byte protocol field.
658      */
659     state->strm.next_in = ibuf + PPP_HDRLEN + DEFLATE_OVHD;
660     state->strm.avail_in = isize - (PPP_HDRLEN + DEFLATE_OVHD);
661     state->strm.next_out = obuf + 3;
662     state->strm.avail_out = 1;
663     decode_proto = 1;
664     overflow = 0;
665
666     /*
667      * Call inflate, supplying more input or output as needed.
668      */
669     for (;;) {
670         r = inflate(&state->strm, Z_PACKET_FLUSH);
671         if (r != Z_OK) {
672             if (state->debug)
673                 printk(KERN_DEBUG "z_decompress%d: inflate returned %d (%s)\n",
674                        state->unit, r, (state->strm.msg? state->strm.msg: ""));
675             return DECOMP_FATALERROR;
676         }
677         if (state->strm.avail_out != 0)
678             break;              /* all done */
679         if (decode_proto) {
680             state->strm.avail_out = osize - PPP_HDRLEN;
681             if ((obuf[3] & 1) == 0) {
682                 /* 2-byte protocol field */
683                 obuf[2] = obuf[3];
684                 --state->strm.next_out;
685                 ++state->strm.avail_out;
686             }
687             decode_proto = 0;
688         } else if (!overflow) {
689             /*
690              * We've filled up the output buffer; the only way to
691              * find out whether inflate has any more characters left
692              * is to give it another byte of output space.
693              */
694             state->strm.next_out = overflow_buf;
695             state->strm.avail_out = 1;
696             overflow = 1;
697         } else {
698             if (state->debug)
699                 printk(KERN_DEBUG "z_decompress%d: ran out of mru\n",
700                        state->unit);
701             return DECOMP_FATALERROR;
702         }
703     }
704
705     if (decode_proto)
706         return DECOMP_ERROR;
707
708     olen = osize - state->strm.avail_out;
709     state->stats.unc_bytes += olen;
710     state->stats.unc_packets++;
711     state->stats.comp_bytes += isize;
712     state->stats.comp_packets++;
713
714     return olen;
715 }
716
717 /*
718  * Incompressible data has arrived - add it to the history.
719  */
720 static void
721 z_incomp(arg, ibuf, icnt)
722     void *arg;
723     unsigned char *ibuf;
724     int icnt;
725 {
726     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
727     int proto, r;
728
729     /*
730      * Check that the protocol is one we handle.
731      */
732     proto = PPP_PROTOCOL(ibuf);
733     if (proto > 0x3fff || proto == 0xfd || proto == 0xfb)
734         return;
735
736     ++state->seqno;
737
738     /*
739      * Iterate through the message blocks, adding the characters in them
740      * to the decompressor's history.  For the first block, we start
741      * at the either the 1st or 2nd byte of the protocol field,
742      * depending on whether the protocol value is compressible.
743      */
744     state->strm.next_in = ibuf + 3;
745     state->strm.avail_in = icnt - 3;
746     if (proto > 0xff) {
747         --state->strm.next_in;
748         ++state->strm.avail_in;
749     }
750
751     r = inflateIncomp(&state->strm);
752     if (r != Z_OK) {
753         /* gak! */
754         if (state->debug) {
755             printk(KERN_DEBUG "z_incomp%d: inflateIncomp returned %d (%s)\n",
756                    state->unit, r, (state->strm.msg? state->strm.msg: ""));
757         }
758         return;
759     }
760
761     /*
762      * Update stats.
763      */
764     state->stats.inc_bytes += icnt;
765     state->stats.inc_packets++;
766     state->stats.unc_bytes += icnt;
767     state->stats.unc_packets++;
768 }
769
770 /*************************************************************
771  * Module interface table
772  *************************************************************/
773
774 /* These are in ppp.c */
775 extern int  ppp_register_compressor   (struct compressor *cp);
776 extern void ppp_unregister_compressor (struct compressor *cp);
777
778 /*
779  * Procedures exported to if_ppp.c.
780  */
781 struct compressor ppp_deflate = {
782     CI_DEFLATE,                 /* compress_proto */
783     z_comp_alloc,               /* comp_alloc */
784     z_comp_free,                /* comp_free */
785     z_comp_init,                /* comp_init */
786     z_comp_reset,               /* comp_reset */
787     z_compress,                 /* compress */
788     z_comp_stats,               /* comp_stat */
789     z_decomp_alloc,             /* decomp_alloc */
790     z_decomp_free,              /* decomp_free */
791     z_decomp_init,              /* decomp_init */
792     z_decomp_reset,             /* decomp_reset */
793     z_decompress,               /* decompress */
794     z_incomp,                   /* incomp */
795     z_comp_stats,               /* decomp_stat */
796 };
797
798 #ifdef MODULE
799 /*************************************************************
800  * Module support routines
801  *************************************************************/
802
803 int
804 init_module(void)
805 {  
806         int answer = ppp_register_compressor (&ppp_deflate);
807         if (answer == 0)
808                 printk (KERN_INFO
809                         "PPP Deflate Compression module registered\n");
810         return answer;
811 }
812      
813 void
814 cleanup_module(void)
815 {
816         if (MOD_IN_USE)
817                 printk (KERN_INFO
818                         "Deflate Compression module busy, remove delayed\n");
819         else
820                 ppp_unregister_compressor (&ppp_deflate);
821 }
822 #endif