linux/ppp_deflate.c

   1 /*
   2  *  ==FILEVERSION 970428==
   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 <linux/kernel.h>
  37 #include <linux/sched.h>
  38 #include <linux/types.h>
  39 #include <linux/fcntl.h>
  40 #include <linux/interrupt.h>
  41 #include <linux/ptrace.h>
  42 #include <linux/ioport.h>
  43 #include <linux/in.h>
  44 #include <linux/malloc.h>
  45 #include <linux/vmalloc.h>
  46 #include <linux/errno.h>
  47 #include <linux/sched.h>        /* to get the struct task_struct */
  48 #include <linux/string.h>       /* used in new tty drivers */
  49 #include <linux/signal.h>       /* used in new tty drivers */
  50
  51 #include <asm/system.h>
  52
  53 #include <linux/netdevice.h>
  54 #include <linux/skbuff.h>
  55 #include <linux/inet.h>
  56 #include <linux/ioctl.h>
  57
  58 #include <linux/ppp_defs.h>
  59 #include <linux/ppp-comp.h>
  60
  61 #include "zlib.c"
  62
  63 /*
  64  * State for a Deflate (de)compressor.
  65  */
  66 struct ppp_deflate_state {
  67     int         seqno;
  68     int         w_size;
  69     int         unit;
  70     int         mru;
  71     int         debug;
  72     z_stream    strm;
  73     struct compstat stats;
  74 };
  75
  76 #define DEFLATE_OVHD    2               /* Deflate overhead/packet */
  77
  78 static void     *zalloc __P((void *, unsigned int items, unsigned int size));
  79 static void     *zalloc_init __P((void *, unsigned int items,
  80                                   unsigned int size));
  81 static void     zfree __P((void *, void *ptr, unsigned int nb));
  82 static void     *z_comp_alloc __P((unsigned char *options, int opt_len));
  83 static void     *z_decomp_alloc __P((unsigned char *options, int opt_len));
  84 static void     z_comp_free __P((void *state));
  85 static void     z_decomp_free __P((void *state));
  86 static int      z_comp_init __P((void *state, unsigned char *options,
  87                                  int opt_len,
  88                                  int unit, int hdrlen, int debug));
  89 static int      z_decomp_init __P((void *state, unsigned char *options,
  90                                    int opt_len,
  91                                    int unit, int hdrlen, int mru, int debug));
  92 static int      z_compress __P((void *state, unsigned char *rptr,
  93                                 unsigned char *obuf,
  94                                 int isize, int osize));
  95 static void     z_incomp __P((void *state, unsigned char *ibuf, int icnt));
  96 static int      z_decompress __P((void *state, unsigned char *ibuf,
  97                                 int isize, unsigned char *obuf, int osize));
  98 static void     z_comp_reset __P((void *state));
  99 static void     z_decomp_reset __P((void *state));
 100 static void     z_comp_stats __P((void *state, struct compstat *stats));
 101
 102 struct chunk_header {
 103     unsigned size;              /* amount of space following header */
 104     int valloced;               /* allocated with valloc, not kmalloc */
 105 };
 106
 107 #define MIN_VMALLOC     2048    /* use kmalloc for blocks < this */
 108
 109 /*
 110  * Space allocation and freeing routines for use by zlib routines.
 111  */
 112 void
 113 zfree(arg, ptr, nbytes)
 114     void *arg;
 115     void *ptr;
 116     unsigned int nbytes;
 117 {
 118     struct chunk_header *hdr = ((struct chunk_header *)ptr) - 1;
 119
 120     if (hdr->valloced)
 121         vfree(hdr);
 122     else
 123         kfree(hdr);
 124 }
 125
 126 void *
 127 zalloc(arg, items, size)
 128     void *arg;
 129     unsigned int items, size;
 130 {
 131     struct chunk_header *hdr;
 132     unsigned nbytes;
 133
 134     nbytes = items * size + sizeof(*hdr);
 135     hdr = kmalloc(nbytes, GFP_ATOMIC);
 136     if (hdr == 0)
 137         return 0;
 138     hdr->size = nbytes;
 139     hdr->valloced = 0;
 140     return (void *) (hdr + 1);
 141 }
 142
 143 void *
 144 zalloc_init(arg, items, size)
 145     void *arg;
 146     unsigned int items, size;
 147 {
 148     struct chunk_header *hdr;
 149     unsigned nbytes;
 150
 151     nbytes = items * size + sizeof(*hdr);
 152     if (nbytes >= MIN_VMALLOC)
 153         hdr = vmalloc(nbytes);
 154     else
 155         hdr = kmalloc(nbytes, GFP_KERNEL);
 156     if (hdr == 0)
 157         return 0;
 158     hdr->size = nbytes;
 159     hdr->valloced = nbytes >= MIN_VMALLOC;
 160     return (void *) (hdr + 1);
 161 }
 162
 163 static void
 164 z_comp_free(arg)
 165     void *arg;
 166 {
 167     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 168
 169     if (state) {
 170             deflateEnd(&state->strm);
 171             kfree(state);
 172             MOD_DEC_USE_COUNT;
 173     }
 174 }
 175
 176 /*
 177  * Allocate space for a compressor.
 178  */
 179 static void *
 180 z_comp_alloc(options, opt_len)
 181     unsigned char *options;
 182     int opt_len;
 183 {
 184     struct ppp_deflate_state *state;
 185     int w_size;
 186
 187     if (opt_len != CILEN_DEFLATE || options[0] != CI_DEFLATE
 188         || options[1] != CILEN_DEFLATE
 189         || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
 190         || options[3] != DEFLATE_CHK_SEQUENCE)
 191         return NULL;
 192     w_size = DEFLATE_SIZE(options[2]);
 193     if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
 194         return NULL;
 195
 196     state = (struct ppp_deflate_state *) kmalloc(sizeof(*state), GFP_KERNEL);
 197     if (state == NULL)
 198         return NULL;
 199
 200     MOD_INC_USE_COUNT;
 201     memset (state, 0, sizeof (struct ppp_deflate_state));
 202     state->strm.next_in = NULL;
 203     state->strm.zalloc  = zalloc;
 204     state->strm.zalloc_init = zalloc;
 205     state->strm.zfree   = zfree;
 206     state->w_size       = w_size;
 207
 208     if (deflateInit2(&state->strm, Z_DEFAULT_COMPRESSION, DEFLATE_METHOD_VAL,
 209                      -w_size, 8, Z_DEFAULT_STRATEGY, DEFLATE_OVHD+2) != Z_OK) {
 210         z_comp_free(state);
 211         return NULL;
 212     }
 213     return (void *) state;
 214 }
 215
 216 static int
 217 z_comp_init(arg, options, opt_len, unit, hdrlen, debug)
 218     void *arg;
 219     unsigned char *options;
 220     int opt_len, unit, hdrlen, debug;
 221 {
 222     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 223
 224     if (opt_len < CILEN_DEFLATE || options[0] != CI_DEFLATE
 225         || options[1] != CILEN_DEFLATE
 226         || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
 227         || DEFLATE_SIZE(options[2]) != state->w_size
 228         || options[3] != DEFLATE_CHK_SEQUENCE)
 229         return 0;
 230
 231     state->seqno = 0;
 232     state->unit  = unit;
 233     state->debug = debug;
 234
 235     deflateReset(&state->strm);
 236
 237     return 1;
 238 }
 239
 240 static void
 241 z_comp_reset(arg)
 242     void *arg;
 243 {
 244     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 245
 246     state->seqno = 0;
 247     deflateReset(&state->strm);
 248 }
 249
 250 int
 251 z_compress(arg, rptr, obuf, isize, osize)
 252     void *arg;
 253     unsigned char *rptr;        /* uncompressed packet (in) */
 254     unsigned char *obuf;        /* compressed packet (out) */
 255     int isize, osize;
 256 {
 257     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 258     int r, proto, off, olen;
 259     unsigned char *wptr;
 260
 261     /*
 262      * Check that the protocol is in the range we handle.
 263      */
 264     proto = PPP_PROTOCOL(rptr);
 265     if (proto > 0x3fff || proto == 0xfd || proto == 0xfb)
 266         return 0;
 267
 268     /* Don't generate compressed packets which are larger than
 269        the uncompressed packet. */
 270     if (osize > isize)
 271         osize = isize;
 272
 273     wptr = obuf;
 274
 275     /*
 276      * Copy over the PPP header and store the 2-byte sequence number.
 277      */
 278     wptr[0] = PPP_ADDRESS(rptr);
 279     wptr[1] = PPP_CONTROL(rptr);
 280     wptr[2] = PPP_COMP >> 8;
 281     wptr[3] = PPP_COMP;
 282     wptr += PPP_HDRLEN;
 283     wptr[0] = state->seqno >> 8;
 284     wptr[1] = state->seqno;
 285     wptr += 2;
 286     state->strm.next_out = wptr;
 287     state->strm.avail_out = osize - (PPP_HDRLEN + 2);
 288     ++state->seqno;
 289
 290     off = (proto > 0xff) ? 2 : 3;       /* skip 1st proto byte if 0 */
 291     rptr += off;
 292     state->strm.next_in = rptr;
 293     state->strm.avail_in = (isize - off);
 294
 295     olen = 0;
 296     for (;;) {
 297         r = deflate(&state->strm, Z_PACKET_FLUSH);
 298         if (r != Z_OK) {
 299             if (state->debug)
 300                 printk(KERN_DEBUG "z_compress: deflate returned %d (%s)\n",
 301                        r, (state->strm.msg? state->strm.msg: ""));
 302             break;
 303         }
 304         if (state->strm.avail_out == 0) {
 305             olen += osize;
 306             state->strm.next_out = NULL;
 307             state->strm.avail_out = 1000000;
 308         } else {
 309             break;              /* all done */
 310         }
 311     }
 312     if (olen < osize)
 313         olen += osize - state->strm.avail_out;
 314
 315     /*
 316      * See if we managed to reduce the size of the packet.
 317      * If the compressor just gave us a single zero byte, it means
 318      * the packet was incompressible.
 319      */
 320     if (olen < isize && !(olen == PPP_HDRLEN + 3 && *wptr == 0)) {
 321         state->stats.comp_bytes += olen;
 322         state->stats.comp_packets++;
 323     } else {
 324         state->stats.inc_bytes += isize;
 325         state->stats.inc_packets++;
 326         olen = 0;
 327     }
 328     state->stats.unc_bytes += isize;
 329     state->stats.unc_packets++;
 330
 331     return olen;
 332 }
 333
 334 static void
 335 z_comp_stats(arg, stats)
 336     void *arg;
 337     struct compstat *stats;
 338 {
 339     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 340
 341     *stats = state->stats;
 342 }
 343
 344 static void
 345 z_decomp_free(arg)
 346     void *arg;
 347 {
 348     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 349
 350     if (state) {
 351             inflateEnd(&state->strm);
 352 #if USEMEMPOOL
 353             memPoolFree(&state->strm.opaque);
 354 #endif
 355             kfree(state);
 356             MOD_DEC_USE_COUNT;
 357     }
 358 }
 359
 360 /*
 361  * Allocate space for a decompressor.
 362  */
 363 static void *
 364 z_decomp_alloc(options, opt_len)
 365     unsigned char *options;
 366     int opt_len;
 367 {
 368     struct ppp_deflate_state *state;
 369     int w_size;
 370
 371     if (opt_len != CILEN_DEFLATE || options[0] != CI_DEFLATE
 372         || options[1] != CILEN_DEFLATE
 373         || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
 374         || options[3] != DEFLATE_CHK_SEQUENCE)
 375         return NULL;
 376     w_size = DEFLATE_SIZE(options[2]);
 377     if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
 378         return NULL;
 379
 380     state = (struct ppp_deflate_state *) kmalloc(sizeof(*state), GFP_KERNEL);
 381     if (state == NULL)
 382         return NULL;
 383
 384     MOD_INC_USE_COUNT;
 385     memset (state, 0, sizeof (struct ppp_deflate_state));
 386     state->w_size        = w_size;
 387     state->strm.next_out = NULL;
 388     state->strm.zalloc   = zalloc;
 389     state->strm.zfree    = zfree;
 390
 391     if (inflateInit2(&state->strm, -w_size) != Z_OK) {
 392         z_decomp_free(state);
 393         return NULL;
 394     }
 395     return (void *) state;
 396 }
 397
 398 static int
 399 z_decomp_init(arg, options, opt_len, unit, hdrlen, mru, debug)
 400     void *arg;
 401     unsigned char *options;
 402     int opt_len, unit, hdrlen, mru, debug;
 403 {
 404     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 405
 406     if (opt_len < CILEN_DEFLATE || options[0] != CI_DEFLATE
 407         || options[1] != CILEN_DEFLATE
 408         || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
 409         || DEFLATE_SIZE(options[2]) != state->w_size
 410         || options[3] != DEFLATE_CHK_SEQUENCE)
 411         return 0;
 412
 413     state->seqno = 0;
 414     state->unit  = unit;
 415     state->debug = debug;
 416     state->mru   = mru;
 417
 418     inflateReset(&state->strm);
 419
 420     return 1;
 421 }
 422
 423 static void
 424 z_decomp_reset(arg)
 425     void *arg;
 426 {
 427     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 428
 429     state->seqno = 0;
 430     inflateReset(&state->strm);
 431 }
 432
 433 /*
 434  * Decompress a Deflate-compressed packet.
 435  *
 436  * Because of patent problems, we return DECOMP_ERROR for errors
 437  * found by inspecting the input data and for system problems, but
 438  * DECOMP_FATALERROR for any errors which could possibly be said to
 439  * be being detected "after" decompression.  For DECOMP_ERROR,
 440  * we can issue a CCP reset-request; for DECOMP_FATALERROR, we may be
 441  * infringing a patent of Motorola's if we do, so we take CCP down
 442  * instead.
 443  *
 444  * Given that the frame has the correct sequence number and a good FCS,
 445  * errors such as invalid codes in the input most likely indicate a
 446  * bug, so we return DECOMP_FATALERROR for them in order to turn off
 447  * compression, even though they are detected by inspecting the input.
 448  */
 449 int
 450 z_decompress(arg, ibuf, isize, obuf, osize)
 451     void *arg;
 452     unsigned char *ibuf;
 453     int isize;
 454     unsigned char *obuf;
 455     int osize;
 456 {
 457     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 458     int olen, seq, r;
 459     int decode_proto, overflow;
 460     unsigned char overflow_buf[1];
 461
 462     if (isize <= PPP_HDRLEN + DEFLATE_OVHD) {
 463         if (state->debug)
 464             printk(KERN_DEBUG "z_decompress%d: short packet (len=%d)\n",
 465                    state->unit, isize);
 466         return DECOMP_ERROR;
 467     }
 468
 469     /* Check the sequence number. */
 470     seq = (ibuf[PPP_HDRLEN] << 8) + ibuf[PPP_HDRLEN+1];
 471     if (seq != state->seqno) {
 472         if (state->debug)
 473             printk(KERN_DEBUG "z_decompress%d: bad seq # %d, expected %d\n",
 474                    state->unit, seq, state->seqno);
 475         return DECOMP_ERROR;
 476     }
 477     ++state->seqno;
 478
 479     /*
 480      * Fill in the first part of the PPP header.  The protocol field
 481      * comes from the decompressed data.
 482      */
 483     obuf[0] = PPP_ADDRESS(ibuf);
 484     obuf[1] = PPP_CONTROL(ibuf);
 485     obuf[2] = 0;
 486
 487     /*
 488      * Set up to call inflate.  We set avail_out to 1 initially so we can
 489      * look at the first byte of the output and decide whether we have
 490      * a 1-byte or 2-byte protocol field.
 491      */
 492     state->strm.next_in = ibuf + PPP_HDRLEN + DEFLATE_OVHD;
 493     state->strm.avail_in = isize - (PPP_HDRLEN + DEFLATE_OVHD);
 494     state->strm.next_out = obuf + 3;
 495     state->strm.avail_out = 1;
 496     decode_proto = 1;
 497     overflow = 0;
 498
 499     /*
 500      * Call inflate, supplying more input or output as needed.
 501      */
 502     for (;;) {
 503         r = inflate(&state->strm, Z_PACKET_FLUSH);
 504         if (r != Z_OK) {
 505             if (state->debug)
 506                 printk(KERN_DEBUG "z_decompress%d: inflate returned %d (%s)\n",
 507                        state->unit, r, (state->strm.msg? state->strm.msg: ""));
 508             return DECOMP_FATALERROR;
 509         }
 510         if (state->strm.avail_out != 0)
 511             break;              /* all done */
 512         if (decode_proto) {
 513             state->strm.avail_out = osize - PPP_HDRLEN;
 514             if ((obuf[3] & 1) == 0) {
 515                 /* 2-byte protocol field */
 516                 obuf[2] = obuf[3];
 517                 --state->strm.next_out;
 518                 ++state->strm.avail_out;
 519             }
 520             decode_proto = 0;
 521         } else if (!overflow) {
 522             /*
 523              * We've filled up the output buffer; the only way to
 524              * find out whether inflate has any more characters left
 525              * is to give it another byte of output space.
 526              */
 527             state->strm.next_out = overflow_buf;
 528             state->strm.avail_out = 1;
 529             overflow = 1;
 530         } else {
 531             if (state->debug)
 532                 printk(KERN_DEBUG "z_decompress%d: ran out of mru\n",
 533                        state->unit);
 534             return DECOMP_FATALERROR;
 535         }
 536     }
 537
 538     if (decode_proto)
 539         return DECOMP_ERROR;
 540
 541     olen = osize + overflow - state->strm.avail_out;
 542     state->stats.unc_bytes += olen;
 543     state->stats.unc_packets++;
 544     state->stats.comp_bytes += isize;
 545     state->stats.comp_packets++;
 546
 547     return olen;
 548 }
 549
 550 /*
 551  * Incompressible data has arrived - add it to the history.
 552  */
 553 static void
 554 z_incomp(arg, ibuf, icnt)
 555     void *arg;
 556     unsigned char *ibuf;
 557     int icnt;
 558 {
 559     struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 560     int proto, r;
 561
 562     /*
 563      * Check that the protocol is one we handle.
 564      */
 565     proto = PPP_PROTOCOL(ibuf);
 566     if (proto > 0x3fff || proto == 0xfd || proto == 0xfb)
 567         return;
 568
 569     ++state->seqno;
 570
 571     /*
 572      * Iterate through the message blocks, adding the characters in them
 573      * to the decompressor's history.  For the first block, we start
 574      * at the either the 1st or 2nd byte of the protocol field,
 575      * depending on whether the protocol value is compressible.
 576      */
 577     state->strm.next_in = ibuf + 3;
 578     state->strm.avail_in = icnt - 3;
 579     if (proto > 0xff) {
 580         --state->strm.next_in;
 581         ++state->strm.avail_in;
 582     }
 583
 584     r = inflateIncomp(&state->strm);
 585     if (r != Z_OK) {
 586         /* gak! */
 587         if (state->debug) {
 588             printk(KERN_DEBUG "z_incomp%d: inflateIncomp returned %d (%s)\n",
 589                    state->unit, r, (state->strm.msg? state->strm.msg: ""));
 590         }
 591         return;
 592     }
 593
 594     /*
 595      * Update stats.
 596      */
 597     state->stats.inc_bytes += icnt;
 598     state->stats.inc_packets++;
 599     state->stats.unc_bytes += icnt;
 600     state->stats.unc_packets++;
 601 }
 602
 603 /*************************************************************
 604  * Module interface table
 605  *************************************************************/
 606
 607 /* These are in ppp.c */
 608 extern int  ppp_register_compressor   (struct compressor *cp);
 609 extern void ppp_unregister_compressor (struct compressor *cp);
 610
 611 /*
 612  * Procedures exported to if_ppp.c.
 613  */
 614 struct compressor ppp_deflate = {
 615     CI_DEFLATE,                 /* compress_proto */
 616     z_comp_alloc,               /* comp_alloc */
 617     z_comp_free,                /* comp_free */
 618     z_comp_init,                /* comp_init */
 619     z_comp_reset,               /* comp_reset */
 620     z_compress,                 /* compress */
 621     z_comp_stats,               /* comp_stat */
 622     z_decomp_alloc,             /* decomp_alloc */
 623     z_decomp_free,              /* decomp_free */
 624     z_decomp_init,              /* decomp_init */
 625     z_decomp_reset,             /* decomp_reset */
 626     z_decompress,               /* decompress */
 627     z_incomp,                   /* incomp */
 628     z_comp_stats,               /* decomp_stat */
 629 };
 630
 631 #ifdef MODULE
 632 /*************************************************************
 633  * Module support routines
 634  *************************************************************/
 635
 636 int
 637 init_module(void)
 638 {
 639         int answer = ppp_register_compressor (&ppp_deflate);
 640         if (answer == 0)
 641                 printk (KERN_INFO
 642                         "PPP Deflate Compression module registered\n");
 643         return answer;
 644 }
 645
 646 void
 647 cleanup_module(void)
 648 {
 649         if (MOD_IN_USE)
 650                 printk (KERN_INFO
 651                         "Deflate Compression module busy, remove delayed\n");
 652         else
 653                 ppp_unregister_compressor (&ppp_deflate);
 654 }
 655 #endif