netbsd-1.2/ppp-deflate.c

   1 /*      $NetBSD: ppp-deflate.c,v 1.3 1996/10/13 02:11:08 christos Exp $ */
   2 /*      Id: ppp-deflate.c,v 1.5 1997/03/04 03:33:28 paulus Exp  */
   3
   4 /*
   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.
   8  *
   9  * Copyright (c) 1994 The Australian National University.
  10  * All rights reserved.
  11  *
  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
  17  * any purpose.
  18  *
  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
  23  * OF SUCH DAMAGE.
  24  *
  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,
  30  * OR MODIFICATIONS.
  31  */
  32
  33 #include <sys/param.h>
  34 #include <sys/types.h>
  35 #include <sys/systm.h>
  36 #include <sys/mbuf.h>
  37 #include <net/ppp_defs.h>
  38 #include <net/zlib.h>
  39
  40 #define PACKETPTR       struct mbuf *
  41 #include <net/ppp-comp.h>
  42
  43 #if DO_DEFLATE
  44
  45 #define DEFLATE_DEBUG   1
  46
  47 /*
  48  * State for a Deflate (de)compressor.
  49  */
  50 struct deflate_state {
  51     int         seqno;
  52     int         w_size;
  53     int         unit;
  54     int         hdrlen;
  55     int         mru;
  56     int         debug;
  57     z_stream    strm;
  58     struct compstat stats;
  59 };
  60
  61 #define DEFLATE_OVHD    2               /* Deflate overhead/packet */
  62
  63 static void     *zalloc __P((void *, u_int items, u_int size));
  64 static void     zfree __P((void *, void *ptr));
  65 static void     *z_comp_alloc __P((u_char *options, int opt_len));
  66 static void     *z_decomp_alloc __P((u_char *options, int opt_len));
  67 static void     z_comp_free __P((void *state));
  68 static void     z_decomp_free __P((void *state));
  69 static int      z_comp_init __P((void *state, u_char *options, int opt_len,
  70                                  int unit, int hdrlen, int debug));
  71 static int      z_decomp_init __P((void *state, u_char *options, int opt_len,
  72                                      int unit, int hdrlen, int mru, int debug));
  73 static int      z_compress __P((void *state, struct mbuf **mret,
  74                                   struct mbuf *mp, int slen, int maxolen));
  75 static void     z_incomp __P((void *state, struct mbuf *dmsg));
  76 static int      z_decompress __P((void *state, struct mbuf *cmp,
  77                                     struct mbuf **dmpp));
  78 static void     z_comp_reset __P((void *state));
  79 static void     z_decomp_reset __P((void *state));
  80 static void     z_comp_stats __P((void *state, struct compstat *stats));
  81
  82 /*
  83  * Procedures exported to if_ppp.c.
  84  */
  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 */
 100 };
 101
 102 struct compressor ppp_deflate = {
 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 */
 117 };
 118
 119 /*
 120  * Space allocation and freeing routines for use by zlib routines.
 121  */
 122 void *
 123 zalloc(notused, items, size)
 124     void *notused;
 125     u_int items, size;
 126 {
 127     void *ptr;
 128
 129     MALLOC(ptr, void *, items * size, M_DEVBUF, M_NOWAIT);
 130     return ptr;
 131 }
 132
 133 void
 134 zfree(notused, ptr)
 135     void *notused;
 136     void *ptr;
 137 {
 138     FREE(ptr, M_DEVBUF);
 139 }
 140
 141 /*
 142  * Allocate space for a compressor.
 143  */
 144 static void *
 145 z_comp_alloc(options, opt_len)
 146     u_char *options;
 147     int opt_len;
 148 {
 149     struct deflate_state *state;
 150     int w_size;
 151
 152     if (opt_len != CILEN_DEFLATE
 153         || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT)
 154         || options[1] != CILEN_DEFLATE
 155         || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
 156         || options[3] != DEFLATE_CHK_SEQUENCE)
 157         return NULL;
 158     w_size = DEFLATE_SIZE(options[2]);
 159     if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
 160         return NULL;
 161
 162     MALLOC(state, struct deflate_state *, sizeof(struct deflate_state),
 163            M_DEVBUF, M_NOWAIT);
 164     if (state == NULL)
 165         return NULL;
 166
 167     state->strm.next_in = NULL;
 168     state->strm.zalloc = zalloc;
 169     state->strm.zfree = zfree;
 170     if (deflateInit2(&state->strm, Z_DEFAULT_COMPRESSION, DEFLATE_METHOD_VAL,
 171                      -w_size, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
 172         FREE(state, M_DEVBUF);
 173         return NULL;
 174     }
 175
 176     state->w_size = w_size;
 177     bzero(&state->stats, sizeof(state->stats));
 178     return (void *) state;
 179 }
 180
 181 static void
 182 z_comp_free(arg)
 183     void *arg;
 184 {
 185     struct deflate_state *state = (struct deflate_state *) arg;
 186
 187     deflateEnd(&state->strm);
 188     FREE(state, M_DEVBUF);
 189 }
 190
 191 static int
 192 z_comp_init(arg, options, opt_len, unit, hdrlen, debug)
 193     void *arg;
 194     u_char *options;
 195     int opt_len, unit, hdrlen, debug;
 196 {
 197     struct deflate_state *state = (struct deflate_state *) arg;
 198
 199     if (opt_len < CILEN_DEFLATE
 200         || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT)
 201         || options[1] != CILEN_DEFLATE
 202         || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
 203         || DEFLATE_SIZE(options[2]) != state->w_size
 204         || options[3] != DEFLATE_CHK_SEQUENCE)
 205         return 0;
 206
 207     state->seqno = 0;
 208     state->unit = unit;
 209     state->hdrlen = hdrlen;
 210     state->debug = debug;
 211
 212     deflateReset(&state->strm);
 213
 214     return 1;
 215 }
 216
 217 static void
 218 z_comp_reset(arg)
 219     void *arg;
 220 {
 221     struct deflate_state *state = (struct deflate_state *) arg;
 222
 223     state->seqno = 0;
 224     deflateReset(&state->strm);
 225 }
 226
 227 int
 228 z_compress(arg, mret, mp, orig_len, maxolen)
 229     void *arg;
 230     struct mbuf **mret;         /* compressed packet (out) */
 231     struct mbuf *mp;            /* uncompressed packet (in) */
 232     int orig_len, maxolen;
 233 {
 234     struct deflate_state *state = (struct deflate_state *) arg;
 235     u_char *rptr, *wptr;
 236     int proto, olen, wspace, r, flush;
 237     struct mbuf *m;
 238
 239     /*
 240      * Check that the protocol is in the range we handle.
 241      */
 242     rptr = mtod(mp, u_char *);
 243     proto = PPP_PROTOCOL(rptr);
 244     if (proto > 0x3fff || proto == 0xfd || proto == 0xfb) {
 245         *mret = NULL;
 246         return orig_len;
 247     }
 248
 249     /* Allocate one mbuf initially. */
 250     if (maxolen > orig_len)
 251         maxolen = orig_len;
 252     MGET(m, M_DONTWAIT, MT_DATA);
 253     *mret = m;
 254     if (m != NULL) {
 255         m->m_len = 0;
 256         if (maxolen + state->hdrlen > MLEN)
 257             MCLGET(m, M_DONTWAIT);
 258         wspace = M_TRAILINGSPACE(m);
 259         if (state->hdrlen + PPP_HDRLEN + 2 < wspace) {
 260             m->m_data += state->hdrlen;
 261             wspace -= state->hdrlen;
 262         }
 263         wptr = mtod(m, u_char *);
 264
 265         /*
 266          * Copy over the PPP header and store the 2-byte sequence number.
 267          */
 268         wptr[0] = PPP_ADDRESS(rptr);
 269         wptr[1] = PPP_CONTROL(rptr);
 270         wptr[2] = PPP_COMP >> 8;
 271         wptr[3] = PPP_COMP;
 272         wptr += PPP_HDRLEN;
 273         wptr[0] = state->seqno >> 8;
 274         wptr[1] = state->seqno;
 275         wptr += 2;
 276         state->strm.next_out = wptr;
 277         state->strm.avail_out = wspace - (PPP_HDRLEN + 2);
 278     } else {
 279         state->strm.next_out = NULL;
 280         state->strm.avail_out = 1000000;
 281         wptr = NULL;
 282         wspace = 0;
 283     }
 284     ++state->seqno;
 285
 286     rptr += (proto > 0xff)? 2: 3;       /* skip 1st proto byte if 0 */
 287     state->strm.next_in = rptr;
 288     state->strm.avail_in = mtod(mp, u_char *) + mp->m_len - rptr;
 289     mp = mp->m_next;
 290     flush = (mp == NULL)? Z_PACKET_FLUSH: Z_NO_FLUSH;
 291     olen = 0;
 292     for (;;) {
 293         r = deflate(&state->strm, flush);
 294         if (r != Z_OK) {
 295             printf("z_compress: deflate returned %d (%s)\n",
 296                    r, (state->strm.msg? state->strm.msg: ""));
 297             break;
 298         }
 299         if (flush != Z_NO_FLUSH && state->strm.avail_out != 0)
 300             break;              /* all done */
 301         if (state->strm.avail_in == 0 && mp != NULL) {
 302             state->strm.next_in = mtod(mp, u_char *);
 303             state->strm.avail_in = mp->m_len;
 304             mp = mp->m_next;
 305             if (mp == NULL)
 306                 flush = Z_PACKET_FLUSH;
 307         }
 308         if (state->strm.avail_out == 0) {
 309             if (m != NULL) {
 310                 m->m_len = wspace;
 311                 olen += wspace;
 312                 MGET(m->m_next, M_DONTWAIT, MT_DATA);
 313                 m = m->m_next;
 314                 if (m != NULL) {
 315                     m->m_len = 0;
 316                     if (maxolen - olen > MLEN)
 317                         MCLGET(m, M_DONTWAIT);
 318                     state->strm.next_out = mtod(m, u_char *);
 319                     state->strm.avail_out = wspace = M_TRAILINGSPACE(m);
 320                 }
 321             }
 322             if (m == NULL) {
 323                 state->strm.next_out = NULL;
 324                 state->strm.avail_out = 1000000;
 325             }
 326         }
 327     }
 328     if (m != NULL)
 329         olen += (m->m_len = wspace - state->strm.avail_out);
 330
 331     /*
 332      * See if we managed to reduce the size of the packet.
 333      */
 334     if (m != NULL && olen < orig_len) {
 335         state->stats.comp_bytes += olen;
 336         state->stats.comp_packets++;
 337     } else {
 338         if (*mret != NULL) {
 339             m_freem(*mret);
 340             *mret = NULL;
 341         }
 342         state->stats.inc_bytes += orig_len;
 343         state->stats.inc_packets++;
 344         olen = orig_len;
 345     }
 346     state->stats.unc_bytes += orig_len;
 347     state->stats.unc_packets++;
 348
 349     return olen;
 350 }
 351
 352 static void
 353 z_comp_stats(arg, stats)
 354     void *arg;
 355     struct compstat *stats;
 356 {
 357     struct deflate_state *state = (struct deflate_state *) arg;
 358     u_int out;
 359
 360     *stats = state->stats;
 361     stats->ratio = stats->unc_bytes;
 362     out = stats->comp_bytes + stats->inc_bytes;
 363     if (stats->ratio <= 0x7ffffff)
 364         stats->ratio <<= 8;
 365     else
 366         out >>= 8;
 367     if (out != 0)
 368         stats->ratio /= out;
 369 }
 370
 371 /*
 372  * Allocate space for a decompressor.
 373  */
 374 static void *
 375 z_decomp_alloc(options, opt_len)
 376     u_char *options;
 377     int opt_len;
 378 {
 379     struct deflate_state *state;
 380     int w_size;
 381
 382     if (opt_len != CILEN_DEFLATE
 383         || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT)
 384         || options[1] != CILEN_DEFLATE
 385         || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
 386         || options[3] != DEFLATE_CHK_SEQUENCE)
 387         return NULL;
 388     w_size = DEFLATE_SIZE(options[2]);
 389     if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
 390         return NULL;
 391
 392     MALLOC(state, struct deflate_state *, sizeof(struct deflate_state),
 393            M_DEVBUF, M_NOWAIT);
 394     if (state == NULL)
 395         return NULL;
 396
 397     state->strm.next_out = NULL;
 398     state->strm.zalloc = zalloc;
 399     state->strm.zfree = zfree;
 400     if (inflateInit2(&state->strm, -w_size) != Z_OK) {
 401         FREE(state, M_DEVBUF);
 402         return NULL;
 403     }
 404
 405     state->w_size = w_size;
 406     bzero(&state->stats, sizeof(state->stats));
 407     return (void *) state;
 408 }
 409
 410 static void
 411 z_decomp_free(arg)
 412     void *arg;
 413 {
 414     struct deflate_state *state = (struct deflate_state *) arg;
 415
 416     inflateEnd(&state->strm);
 417     FREE(state, M_DEVBUF);
 418 }
 419
 420 static int
 421 z_decomp_init(arg, options, opt_len, unit, hdrlen, mru, debug)
 422     void *arg;
 423     u_char *options;
 424     int opt_len, unit, hdrlen, mru, debug;
 425 {
 426     struct deflate_state *state = (struct deflate_state *) arg;
 427
 428     if (opt_len < CILEN_DEFLATE
 429         || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT)
 430         || options[1] != CILEN_DEFLATE
 431         || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
 432         || DEFLATE_SIZE(options[2]) != state->w_size
 433         || options[3] != DEFLATE_CHK_SEQUENCE)
 434         return 0;
 435
 436     state->seqno = 0;
 437     state->unit = unit;
 438     state->hdrlen = hdrlen;
 439     state->debug = debug;
 440     state->mru = mru;
 441
 442     inflateReset(&state->strm);
 443
 444     return 1;
 445 }
 446
 447 static void
 448 z_decomp_reset(arg)
 449     void *arg;
 450 {
 451     struct deflate_state *state = (struct deflate_state *) arg;
 452
 453     state->seqno = 0;
 454     inflateReset(&state->strm);
 455 }
 456
 457 /*
 458  * Decompress a Deflate-compressed packet.
 459  *
 460  * Because of patent problems, we return DECOMP_ERROR for errors
 461  * found by inspecting the input data and for system problems, but
 462  * DECOMP_FATALERROR for any errors which could possibly be said to
 463  * be being detected "after" decompression.  For DECOMP_ERROR,
 464  * we can issue a CCP reset-request; for DECOMP_FATALERROR, we may be
 465  * infringing a patent of Motorola's if we do, so we take CCP down
 466  * instead.
 467  *
 468  * Given that the frame has the correct sequence number and a good FCS,
 469  * errors such as invalid codes in the input most likely indicate a
 470  * bug, so we return DECOMP_FATALERROR for them in order to turn off
 471  * compression, even though they are detected by inspecting the input.
 472  */
 473 int
 474 z_decompress(arg, mi, mop)
 475     void *arg;
 476     struct mbuf *mi, **mop;
 477 {
 478     struct deflate_state *state = (struct deflate_state *) arg;
 479     struct mbuf *mo, *mo_head;
 480     u_char *rptr, *wptr;
 481     int rlen, olen, ospace;
 482     int seq, i, flush, r, decode_proto;
 483     u_char hdr[PPP_HDRLEN + DEFLATE_OVHD];
 484
 485     *mop = NULL;
 486     rptr = mtod(mi, u_char *);
 487     rlen = mi->m_len;
 488     for (i = 0; i < PPP_HDRLEN + DEFLATE_OVHD; ++i) {
 489         while (rlen <= 0) {
 490             mi = mi->m_next;
 491             if (mi == NULL)
 492                 return DECOMP_ERROR;
 493             rptr = mtod(mi, u_char *);
 494             rlen = mi->m_len;
 495         }
 496         hdr[i] = *rptr++;
 497         --rlen;
 498     }
 499
 500     /* Check the sequence number. */
 501     seq = (hdr[PPP_HDRLEN] << 8) + hdr[PPP_HDRLEN+1];
 502     if (seq != state->seqno) {
 503         if (state->debug)
 504             printf("z_decompress%d: bad seq # %d, expected %d\n",
 505                    state->unit, seq, state->seqno);
 506         return DECOMP_ERROR;
 507     }
 508     ++state->seqno;
 509
 510     /* Allocate an output mbuf. */
 511     MGETHDR(mo, M_DONTWAIT, MT_DATA);
 512     if (mo == NULL)
 513         return DECOMP_ERROR;
 514     mo_head = mo;
 515     mo->m_len = 0;
 516     mo->m_next = NULL;
 517     MCLGET(mo, M_DONTWAIT);
 518     ospace = M_TRAILINGSPACE(mo);
 519     if (state->hdrlen + PPP_HDRLEN < ospace) {
 520         mo->m_data += state->hdrlen;
 521         ospace -= state->hdrlen;
 522     }
 523
 524     /*
 525      * Fill in the first part of the PPP header.  The protocol field
 526      * comes from the decompressed data.
 527      */
 528     wptr = mtod(mo, u_char *);
 529     wptr[0] = PPP_ADDRESS(hdr);
 530     wptr[1] = PPP_CONTROL(hdr);
 531     wptr[2] = 0;
 532
 533     /*
 534      * Set up to call inflate.  We set avail_out to 1 initially so we can
 535      * look at the first byte of the output and decide whether we have
 536      * a 1-byte or 2-byte protocol field.
 537      */
 538     state->strm.next_in = rptr;
 539     state->strm.avail_in = rlen;
 540     mi = mi->m_next;
 541     flush = (mi == NULL)? Z_PACKET_FLUSH: Z_NO_FLUSH;
 542     rlen += PPP_HDRLEN + DEFLATE_OVHD;
 543     state->strm.next_out = wptr + 3;
 544     state->strm.avail_out = 1;
 545     decode_proto = 1;
 546     olen = PPP_HDRLEN;
 547
 548     /*
 549      * Call inflate, supplying more input or output as needed.
 550      */
 551     for (;;) {
 552         r = inflate(&state->strm, flush);
 553         if (r != Z_OK) {
 554 #if !DEFLATE_DEBUG
 555             if (state->debug)
 556 #endif
 557                 printf("z_decompress%d: inflate returned %d (%s)\n",
 558                        state->unit, r, (state->strm.msg? state->strm.msg: ""));
 559             m_freem(mo_head);
 560             return DECOMP_FATALERROR;
 561         }
 562         if (flush != Z_NO_FLUSH && state->strm.avail_out != 0)
 563             break;              /* all done */
 564         if (state->strm.avail_in == 0 && mi != NULL) {
 565             state->strm.next_in = mtod(mi, u_char *);
 566             state->strm.avail_in = mi->m_len;
 567             rlen += mi->m_len;
 568             mi = mi->m_next;
 569             if (mi == NULL)
 570                 flush = Z_PACKET_FLUSH;
 571         }
 572         if (state->strm.avail_out == 0) {
 573             if (decode_proto) {
 574                 state->strm.avail_out = ospace - PPP_HDRLEN;
 575                 if ((wptr[3] & 1) == 0) {
 576                     /* 2-byte protocol field */
 577                     wptr[2] = wptr[3];
 578                     --state->strm.next_out;
 579                     ++state->strm.avail_out;
 580                     --olen;
 581                 }
 582                 decode_proto = 0;
 583             } else {
 584                 mo->m_len = ospace;
 585                 olen += ospace;
 586                 MGET(mo->m_next, M_DONTWAIT, MT_DATA);
 587                 mo = mo->m_next;
 588                 if (mo == NULL) {
 589                     m_freem(mo_head);
 590                     return DECOMP_ERROR;
 591                 }
 592                 MCLGET(mo, M_DONTWAIT);
 593                 state->strm.next_out = mtod(mo, u_char *);
 594                 state->strm.avail_out = ospace = M_TRAILINGSPACE(mo);
 595             }
 596         }
 597     }
 598     if (decode_proto) {
 599         m_freem(mo_head);
 600         return DECOMP_ERROR;
 601     }
 602     olen += (mo->m_len = ospace - state->strm.avail_out);
 603 #if DEFLATE_DEBUG
 604     if (olen > state->mru + PPP_HDRLEN)
 605         printf("ppp_deflate%d: exceeded mru (%d > %d)\n",
 606                state->unit, olen, state->mru + PPP_HDRLEN);
 607 #endif
 608
 609     state->stats.unc_bytes += olen;
 610     state->stats.unc_packets++;
 611     state->stats.comp_bytes += rlen;
 612     state->stats.comp_packets++;
 613
 614     *mop = mo_head;
 615     return DECOMP_OK;
 616 }
 617
 618 /*
 619  * Incompressible data has arrived - add it to the history.
 620  */
 621 static void
 622 z_incomp(arg, mi)
 623     void *arg;
 624     struct mbuf *mi;
 625 {
 626     struct deflate_state *state = (struct deflate_state *) arg;
 627     u_char *rptr;
 628     int rlen, proto, r;
 629
 630     /*
 631      * Check that the protocol is one we handle.
 632      */
 633     rptr = mtod(mi, u_char *);
 634     proto = PPP_PROTOCOL(rptr);
 635     if (proto > 0x3fff || proto == 0xfd || proto == 0xfb)
 636         return;
 637
 638     ++state->seqno;
 639
 640     /*
 641      * Iterate through the mbufs, adding the characters in them
 642      * to the decompressor's history.  For the first mbuf, we start
 643      * at the either the 1st or 2nd byte of the protocol field,
 644      * depending on whether the protocol value is compressible.
 645      */
 646     rlen = mi->m_len;
 647     state->strm.next_in = rptr + 3;
 648     state->strm.avail_in = rlen - 3;
 649     if (proto > 0xff) {
 650         --state->strm.next_in;
 651         ++state->strm.avail_in;
 652     }
 653     for (;;) {
 654         r = inflateIncomp(&state->strm);
 655         if (r != Z_OK) {
 656             /* gak! */
 657 #if !DEFLATE_DEBUG
 658             if (state->debug)
 659 #endif
 660                 printf("z_incomp%d: inflateIncomp returned %d (%s)\n",
 661                        state->unit, r, (state->strm.msg? state->strm.msg: ""));
 662             return;
 663         }
 664         mi = mi->m_next;
 665         if (mi == NULL)
 666             break;
 667         state->strm.next_in = mtod(mi, u_char *);
 668         state->strm.avail_in = mi->m_len;
 669         rlen += mi->m_len;
 670     }
 671
 672     /*
 673      * Update stats.
 674      */
 675     state->stats.inc_bytes += rlen;
 676     state->stats.inc_packets++;
 677     state->stats.unc_bytes += rlen;
 678     state->stats.unc_packets++;
 679 }
 680
 681 #endif /* DO_DEFLATE */