linux/ppp_deflate.c

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