svr4/ppp_comp.c

   1 /*
   2  * ppp_comp.c - STREAMS module for kernel-level compression and CCP support.
   3  *
   4  * Copyright (c) 1994 The Australian National University.
   5  * All rights reserved.
   6  *
   7  * Permission to use, copy, modify, and distribute this software and its
   8  * documentation is hereby granted, provided that the above copyright
   9  * notice appears in all copies.  This software is provided without any
  10  * warranty, express or implied. The Australian National University
  11  * makes no representations about the suitability of this software for
  12  * any purpose.
  13  *
  14  * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
  15  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  16  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
  17  * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY
  18  * OF SUCH DAMAGE.
  19  *
  20  * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  21  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  22  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  23  * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
  24  * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
  25  * OR MODIFICATIONS.
  26  *
  27  * $Id: ppp_comp.c,v 1.5 1995/10/27 03:56:19 paulus Exp $
  28  */
  29
  30 /*
  31  * This file is used under SVR4 and Solaris 2.
  32  */
  33
  34 #include <sys/types.h>
  35 #include <sys/param.h>
  36 #include <sys/errno.h>
  37 #include <sys/stream.h>
  38 #include <sys/conf.h>
  39 #include <sys/kmem.h>
  40 #include <sys/cmn_err.h>
  41 #include <sys/ddi.h>
  42 #ifdef sun
  43 #include <sys/modctl.h>
  44 #include <sys/sunddi.h>
  45 #endif
  46 #include <net/ppp_defs.h>
  47 #include <net/pppio.h>
  48 #include <netinet/in.h>
  49 #include <netinet/in_systm.h>
  50 #include <netinet/ip.h>
  51 #include <net/vjcompress.h>
  52
  53 #define PACKETPTR       mblk_t *
  54 #include <net/ppp-comp.h>
  55
  56 static int ppp_comp_open __P((queue_t *, dev_t *, int, int, cred_t *));
  57 static int ppp_comp_close __P((queue_t *, int, cred_t *));
  58 static int ppp_comp_rput __P((queue_t *, mblk_t *));
  59 static int ppp_comp_rsrv __P((queue_t *));
  60 static int ppp_comp_wput __P((queue_t *, mblk_t *));
  61 static int ppp_comp_wsrv __P((queue_t *));
  62 static void ppp_comp_ccp __P((queue_t *, mblk_t *, int));
  63
  64 static struct module_info minfo = {
  65     0xbadf, "ppp_comp", 0, INFPSZ, 16384, 4096,
  66 };
  67
  68 static struct qinit r_init = {
  69     ppp_comp_rput, ppp_comp_rsrv, ppp_comp_open, ppp_comp_close,
  70     NULL, &minfo, NULL
  71 };
  72
  73 static struct qinit w_init = {
  74     ppp_comp_wput, ppp_comp_wsrv, NULL, NULL, NULL, &minfo, NULL
  75 };
  76
  77 static struct streamtab ppp_compinfo = {
  78     &r_init, &w_init, NULL, NULL
  79 };
  80
  81 #if defined(sun) && defined(svr4)               /* Solaris 2 */
  82 static struct fmodsw fsw = {
  83     "ppp_comp",
  84     &ppp_compinfo,
  85     D_NEW | D_MP | D_MTQPAIR
  86 };
  87
  88 extern struct mod_ops mod_strmodops;
  89
  90 static struct modlstrmod modlstrmod = {
  91     &mod_strmodops,
  92     "PPP compression module",
  93     &fsw
  94 };
  95
  96 static struct modlinkage modlinkage = {
  97     MODREV_1,
  98     (void *) &modlstrmod,
  99     NULL
 100 };
 101 #endif
 102
 103 typedef struct comp_state {
 104     int         flags;
 105     int         mru;
 106     int         mtu;
 107     int         unit;
 108     struct compressor *xcomp;
 109     void        *xstate;
 110     struct compressor *rcomp;
 111     void        *rstate;
 112     struct vjcompress vj_comp;
 113     int         vj_last_ierrors;
 114     struct pppstat stats;
 115 } comp_state_t;
 116
 117 /* Bits in flags are as defined in pppio.h. */
 118 #define CCP_ERR         (CCP_ERROR | CCP_FATALERROR)
 119 #define LAST_MOD        0x1000000       /* no ppp modules below us */
 120
 121 #define MAX_IPHDR       128     /* max TCP/IP header size */
 122 #define MAX_VJHDR       20      /* max VJ compressed header size (?) */
 123
 124 #undef MIN              /* just in case */
 125 #define MIN(a, b)       ((a) < (b)? (a): (b))
 126
 127 #ifdef D_MP
 128 /* Use msgpullup if we have other multithreading support. */
 129 #define PULLUP(mp, len)                         \
 130     do {                                        \
 131         mblk_t *np = msgpullup((mp), (len));    \
 132         freemsg(mp);                            \
 133         mp = np;                                \
 134     } while (0)
 135
 136 #else
 137 /* Use pullupmsg if we don't have any multithreading support. */
 138 #define PULLUP(mp, len)                 \
 139     do {                                \
 140         if (!pullupmsg((mp), (len))) {  \
 141             freemsg(mp);                \
 142             mp = 0;                     \
 143         }                               \
 144     } while (0)
 145
 146 #endif
 147
 148
 149 /*
 150  * List of compressors we know about.
 151  */
 152
 153 extern struct compressor ppp_bsd_compress;
 154
 155 struct compressor *ppp_compressors[] = {
 156 #if DO_BSD_COMPRESS
 157     &ppp_bsd_compress,
 158 #endif
 159     NULL
 160 };
 161
 162 #ifdef sun
 163 /*
 164  * Entry points for modloading.
 165  */
 166 int
 167 _init(void)
 168 {
 169     return mod_install(&modlinkage);
 170 }
 171
 172 int
 173 _fini(void)
 174 {
 175     return mod_remove(&modlinkage);
 176 }
 177
 178 int
 179 _info(mip)
 180     struct modinfo *mip;
 181 {
 182     return mod_info(&modlinkage, mip);
 183 }
 184 #endif
 185
 186 #ifndef sun
 187 # define qprocson(q)
 188 # define qprocsoff(q)
 189 #define canputnext(q)   canput((q)->q_next)
 190 #endif
 191
 192 /*
 193  * STREAMS module entry points.
 194  */
 195 static int
 196 ppp_comp_open(q, devp, flag, sflag, credp)
 197     queue_t *q;
 198     dev_t *devp;
 199     int flag, sflag;
 200     cred_t *credp;
 201 {
 202     comp_state_t *cp;
 203
 204     if (q->q_ptr == NULL) {
 205         cp = (comp_state_t *) kmem_zalloc(sizeof(comp_state_t), KM_SLEEP);
 206         if (cp == NULL)
 207             return ENOSR;
 208         WR(q)->q_ptr = q->q_ptr = cp;
 209         bzero((caddr_t)cp, sizeof(comp_state_t));
 210         cp->mru = PPP_MRU;
 211         cp->mtu = PPP_MRU;
 212         cp->xstate = NULL;
 213         cp->rstate = NULL;
 214         vj_compress_init(&cp->vj_comp, -1);
 215         qprocson(q);
 216     }
 217     return 0;
 218 }
 219
 220 static int
 221 ppp_comp_close(q, flag, credp)
 222     queue_t *q;
 223     int flag;
 224     cred_t *credp;
 225 {
 226     comp_state_t *cp;
 227
 228     qprocsoff(q);
 229     cp = (comp_state_t *) q->q_ptr;
 230     if (cp != NULL) {
 231         if (cp->xstate != NULL)
 232             (*cp->xcomp->comp_free)(cp->xstate);
 233         if (cp->rstate != NULL)
 234             (*cp->rcomp->decomp_free)(cp->rstate);
 235         kmem_free(cp, sizeof(comp_state_t));
 236         q->q_ptr = NULL;
 237         OTHERQ(q)->q_ptr = NULL;
 238     }
 239     return 0;
 240 }
 241
 242 static int
 243 ppp_comp_wput(q, mp)
 244     queue_t *q;
 245     mblk_t *mp;
 246 {
 247     struct iocblk *iop;
 248     comp_state_t *cp;
 249     int error, len;
 250     int flags, mask;
 251     mblk_t *np;
 252     struct compressor **comp;
 253     struct ppp_stats *psp;
 254     struct ppp_comp_stats *csp;
 255     unsigned char *opt_data;
 256     int nxslots, nrslots;
 257
 258     cp = (comp_state_t *) q->q_ptr;
 259     switch (mp->b_datap->db_type) {
 260
 261     case M_DATA:
 262         putq(q, mp);
 263         break;
 264
 265     case M_IOCTL:
 266         iop = (struct iocblk *) mp->b_rptr;
 267         error = EINVAL;
 268         switch (iop->ioc_cmd) {
 269
 270         case PPPIO_CFLAGS:
 271             /* set/get CCP state */
 272             if (iop->ioc_count != 2 * sizeof(int))
 273                 break;
 274             flags = ((int *) mp->b_cont->b_rptr)[0];
 275             mask = ((int *) mp->b_cont->b_rptr)[1];
 276             cp->flags = (cp->flags & ~mask) | (flags & mask);
 277             if ((mask & CCP_ISOPEN) && (flags & CCP_ISOPEN) == 0) {
 278                 if (cp->xstate != NULL) {
 279                     (*cp->xcomp->comp_free)(cp->xstate);
 280                     cp->xstate = NULL;
 281                 }
 282                 if (cp->rstate != NULL) {
 283                     (*cp->rcomp->decomp_free)(cp->rstate);
 284                     cp->rstate = NULL;
 285                 }
 286                 cp->flags &= ~CCP_ISUP;
 287             }
 288             error = 0;
 289             iop->ioc_count = sizeof(int);
 290             ((int *) mp->b_cont->b_rptr)[0] = cp->flags;
 291             mp->b_cont->b_wptr = mp->b_cont->b_rptr + sizeof(int);
 292             break;
 293
 294         case PPPIO_VJINIT:
 295             /*
 296              * Initialize VJ compressor/decompressor
 297              */
 298             if (iop->ioc_count != 2)
 299                 break;
 300             nxslots = mp->b_cont->b_rptr[0] + 1;
 301             nrslots = mp->b_cont->b_rptr[1] + 1;
 302             if (nxslots > MAX_STATES || nrslots > MAX_STATES)
 303                 break;
 304             vj_compress_init(&cp->vj_comp, nxslots);
 305             cp->vj_last_ierrors = cp->stats.ppp_ierrors;
 306             error = 0;
 307             iop->ioc_count = 0;
 308             break;
 309
 310         case PPPIO_XCOMP:
 311         case PPPIO_RCOMP:
 312             if (iop->ioc_count <= 0)
 313                 break;
 314             opt_data = mp->b_cont->b_rptr;
 315             len = mp->b_cont->b_wptr - opt_data;
 316             if (len > iop->ioc_count)
 317                 len = iop->ioc_count;
 318             if (opt_data[1] < 2 || opt_data[1] > len)
 319                 break;
 320             for (comp = ppp_compressors; *comp != NULL; ++comp)
 321                 if ((*comp)->compress_proto == opt_data[0]) {
 322                     /* here's the handler! */
 323                     error = 0;
 324                     if (iop->ioc_cmd == PPPIO_XCOMP) {
 325                         if (cp->xstate != NULL)
 326                             (*cp->xcomp->comp_free)(cp->xstate);
 327                         cp->xcomp = *comp;
 328                         cp->xstate = (*comp)->comp_alloc(opt_data, len);
 329                         if (cp->xstate == NULL)
 330                             error = ENOSR;
 331                     } else {
 332                         if (cp->rstate != NULL)
 333                             (*cp->rcomp->decomp_free)(cp->rstate);
 334                         cp->rcomp = *comp;
 335                         cp->rstate = (*comp)->decomp_alloc(opt_data, len);
 336                         if (cp->rstate == NULL)
 337                             error = ENOSR;
 338                     }
 339                     break;
 340                 }
 341             iop->ioc_count = 0;
 342             break;
 343
 344         case PPPIO_GETSTAT:
 345             if ((cp->flags & LAST_MOD) == 0) {
 346                 error = -1;     /* let the ppp_ahdl module handle it */
 347                 break;
 348             }
 349             np = allocb(sizeof(struct ppp_stats), BPRI_HI);
 350             if (np == 0) {
 351                 error = ENOSR;
 352                 break;
 353             }
 354             if (mp->b_cont != 0)
 355                 freemsg(mp->b_cont);
 356             mp->b_cont = np;
 357             psp = (struct ppp_stats *) np->b_wptr;
 358             np->b_wptr += sizeof(struct ppp_stats);
 359             iop->ioc_count = sizeof(struct ppp_stats);
 360             psp->p = cp->stats;
 361             psp->vj = cp->vj_comp.stats;
 362             error = 0;
 363             break;
 364
 365         case PPPIO_GETCSTAT:
 366             np = allocb(sizeof(struct ppp_comp_stats), BPRI_HI);
 367             if (np == 0) {
 368                 error = ENOSR;
 369                 break;
 370             }
 371             if (mp->b_cont != 0)
 372                 freemsg(mp->b_cont);
 373             mp->b_cont = np;
 374             csp = (struct ppp_comp_stats *) np->b_wptr;
 375             np->b_wptr += sizeof(struct ppp_comp_stats);
 376             iop->ioc_count = sizeof(struct ppp_comp_stats);
 377             bzero((caddr_t)csp, sizeof(struct ppp_comp_stats));
 378             if (cp->xstate != 0)
 379                 (*cp->xcomp->comp_stat)(cp->xstate, &csp->c);
 380             if (cp->rstate != 0)
 381                 (*cp->rcomp->decomp_stat)(cp->rstate, &csp->d);
 382             error = 0;
 383             break;
 384
 385         case PPPIO_LASTMOD:
 386             cp->flags |= LAST_MOD;
 387             error = 0;
 388             break;
 389
 390         default:
 391             error = -1;
 392             break;
 393         }
 394
 395         if (error < 0)
 396             putnext(q, mp);
 397         else if (error == 0) {
 398             mp->b_datap->db_type = M_IOCACK;
 399             qreply(q, mp);
 400         } else {
 401             mp->b_datap->db_type = M_IOCNAK;
 402             iop->ioc_error = error;
 403             iop->ioc_count = 0;
 404             qreply(q, mp);
 405         }
 406         break;
 407
 408     case M_CTL:
 409         switch (*mp->b_rptr) {
 410         case PPPCTL_MTU:
 411             cp->mtu = ((unsigned short *)mp->b_rptr)[1];
 412             break;
 413         case PPPCTL_MRU:
 414             cp->mru = ((unsigned short *)mp->b_rptr)[1];
 415             break;
 416         case PPPCTL_UNIT:
 417             cp->unit = mp->b_rptr[1];
 418             break;
 419         }
 420         putnext(q, mp);
 421         break;
 422
 423     default:
 424         putnext(q, mp);
 425     }
 426 }
 427
 428 static int
 429 ppp_comp_wsrv(q)
 430     queue_t *q;
 431 {
 432     mblk_t *mp, *cmp = NULL, *np;
 433     comp_state_t *cp;
 434     int len, proto, type;
 435     struct ip *ip;
 436     unsigned char *vjhdr, *dp;
 437
 438     cp = (comp_state_t *) q->q_ptr;
 439     while ((mp = getq(q)) != 0) {
 440         /* assert(mp->b_datap->db_type == M_DATA) */
 441         if (!canputnext(q)) {
 442             putbq(q, mp);
 443             return;
 444         }
 445
 446         /*
 447          * Make sure we've got a reasonable amount in the first
 448          * mblk and that we are its only user.
 449          * Then find out what the protocol is.
 450          */
 451         len = msgdsize(mp);
 452         if (len > PPP_HDRLEN + MAX_IPHDR)
 453             len = PPP_HDRLEN + MAX_IPHDR;
 454         if (mp->b_wptr < mp->b_rptr + len || mp->b_datap->db_ref > 1) {
 455             PULLUP(mp, len);
 456             if (mp == 0) {
 457 #if DEBUG
 458                 cmn_err(CE_CONT, "ppp_comp_wsrv: pullup failed\n");
 459 #endif
 460                 cp->stats.ppp_oerrors++;
 461                 putctl1(RD(q)->q_next, M_CTL, PPPCTL_OERROR);
 462                 continue;
 463             }
 464         }
 465         proto = PPP_PROTOCOL(mp->b_rptr);
 466
 467         /*
 468          * Do VJ compression if requested.
 469          */
 470         if (proto == PPP_IP && (cp->flags & COMP_VJC)) {
 471             ip = (struct ip *) (mp->b_rptr + PPP_HDRLEN);
 472             if (ip->ip_p == IPPROTO_TCP) {
 473                 type = vj_compress_tcp(ip, len - PPP_HDRLEN, &cp->vj_comp,
 474                                        (cp->flags & COMP_VJCCID), &vjhdr);
 475                 switch (type) {
 476                 case TYPE_UNCOMPRESSED_TCP:
 477                     mp->b_rptr[3] = proto = PPP_VJC_UNCOMP;
 478                     break;
 479                 case TYPE_COMPRESSED_TCP:
 480                     dp = vjhdr - PPP_HDRLEN;
 481                     dp[1] = mp->b_rptr[1]; /* copy control field */
 482                     dp[0] = mp->b_rptr[0]; /* copy address field */
 483                     dp[2] = 0;             /* set protocol field */
 484                     dp[3] = proto = PPP_VJC_COMP;
 485                     mp->b_rptr = dp;
 486                     break;
 487                 }
 488             }
 489         }
 490
 491         /*
 492          * Do packet compression if enabled.
 493          */
 494         if (proto == PPP_CCP)
 495             ppp_comp_ccp(q, mp, 0);
 496         else if (proto != PPP_LCP && (cp->flags & CCP_COMP_RUN)
 497                  && cp->xstate != NULL) {
 498             len = msgdsize(mp);
 499             (*cp->xcomp->compress)(cp->xstate, &cmp, mp, len,
 500                                    (cp->flags & CCP_ISUP? cp->mtu: 0));
 501             if (cmp != NULL) {
 502                 freemsg(mp);
 503                 mp = cmp;
 504             }
 505         }
 506
 507         /*
 508          * Do address/control and protocol compression if enabled.
 509          */
 510         if (proto != PPP_LCP && (cp->flags & COMP_AC)) {
 511             mp->b_rptr += 2;    /* drop the address & ctrl fields */
 512             if (proto < 0x100 && (cp->flags & COMP_PROT))
 513                 ++mp->b_rptr;   /* drop the high protocol byte */
 514         } else if (proto < 0x100 && (cp->flags & COMP_PROT)) {
 515             /* shuffle up the address & ctrl fields */
 516             mp->b_rptr[2] = mp->b_rptr[1];
 517             mp->b_rptr[1] = mp->b_rptr[0];
 518             ++mp->b_rptr;
 519         }
 520
 521         cp->stats.ppp_opackets++;
 522         cp->stats.ppp_obytes += msgdsize(mp);
 523         putnext(q, mp);
 524     }
 525 }
 526
 527 static int
 528 ppp_comp_rput(q, mp)
 529     queue_t *q;
 530     mblk_t *mp;
 531 {
 532     comp_state_t *cp;
 533     struct iocblk *iop;
 534     struct ppp_stats *psp;
 535
 536     cp = (comp_state_t *) q->q_ptr;
 537     switch (mp->b_datap->db_type) {
 538
 539     case M_DATA:
 540         putq(q, mp);
 541         break;
 542
 543     case M_IOCACK:
 544         iop = (struct iocblk *) mp->b_rptr;
 545         switch (iop->ioc_cmd) {
 546         case PPPIO_GETSTAT:
 547             /*
 548              * Catch this on the way back from the ppp_ahdl module
 549              * so we can fill in the VJ stats.
 550              */
 551             if (mp->b_cont == 0 || iop->ioc_count != sizeof(struct ppp_stats))
 552                 break;
 553             psp = (struct ppp_stats *) mp->b_cont->b_rptr;
 554             psp->vj = cp->vj_comp.stats;
 555             break;
 556         }
 557         putnext(q, mp);
 558         break;
 559
 560     case M_CTL:
 561         switch (mp->b_rptr[0]) {
 562         case PPPCTL_IERROR:
 563             ++cp->stats.ppp_ierrors;
 564             break;
 565         case PPPCTL_OERROR:
 566             ++cp->stats.ppp_oerrors;
 567             break;
 568         }
 569         putnext(q, mp);
 570         break;
 571
 572     default:
 573         putnext(q, mp);
 574     }
 575 }
 576
 577 static int
 578 ppp_comp_rsrv(q)
 579     queue_t *q;
 580 {
 581     int proto, rv, i;
 582     mblk_t *mp, *dmp = NULL, *np;
 583     uchar_t *dp, *iphdr;
 584     comp_state_t *cp;
 585     int len, hlen, vjlen, iphlen;
 586
 587     cp = (comp_state_t *) q->q_ptr;
 588     while ((mp = getq(q)) != 0) {
 589         /* assert(mp->b_datap->db_type == M_DATA) */
 590         if (!canputnext(q)) {
 591             putbq(q, mp);
 592             return;
 593         }
 594
 595         len = msgdsize(mp);
 596         cp->stats.ppp_ibytes += len;
 597         cp->stats.ppp_ipackets++;
 598
 599         /*
 600          * First do address/control and protocol "decompression".
 601          */
 602         hlen = MIN(len, PPP_HDRLEN);
 603         if (mp->b_wptr < mp->b_rptr + hlen) {
 604             PULLUP(mp, hlen);
 605             if (mp == 0)
 606                 goto bad;
 607         }
 608         dp = mp->b_rptr;
 609         if (PPP_ADDRESS(dp) == PPP_ALLSTATIONS
 610             && PPP_CONTROL(dp) == PPP_UI)
 611             dp += 2;                    /* skip address/control */
 612         else if ((cp->flags & DECOMP_AC) == 0) {
 613             /* count these? */
 614             goto bad;
 615         }
 616         proto = 0;
 617         if ((*dp & 1) == 0)
 618             proto = *dp++ << 8;         /* grab high byte of protocol */
 619         else if ((cp->flags & DECOMP_PROT) == 0) {
 620             /* count these? */
 621             goto bad;
 622         }
 623         proto += *dp++;                 /* grab low byte of protocol */
 624         if (dp > mp->b_wptr)
 625             goto bad;                   /* short/bogus packet */
 626         dp -= PPP_HDRLEN;
 627         if (dp != mp->b_rptr) {
 628             /*
 629              * We need to put some bytes on the front of the packet
 630              * to make a full-length PPP header.
 631              * If we can put them in *mp, we do, otherwise we
 632              * tack another mblk on the front.
 633              * XXX we really shouldn't need to carry around
 634              * the address and control at this stage.
 635              */
 636             if (dp < mp->b_datap->db_base || mp->b_datap->db_ref > 1) {
 637                 np = allocb(PPP_HDRLEN, BPRI_MED);
 638                 if (np == 0)
 639                     goto bad;
 640                 np->b_cont = mp;
 641                 mp->b_rptr = dp + PPP_HDRLEN;
 642                 mp = np;
 643                 dp = mp->b_wptr;
 644                 mp->b_wptr += PPP_HDRLEN;
 645             } else
 646                 mp->b_rptr = dp;
 647
 648             dp[0] = PPP_ALLSTATIONS;
 649             dp[1] = PPP_UI;
 650             dp[2] = proto >> 8;
 651             dp[3] = proto;
 652         }
 653
 654         /*
 655          * Now see if we have a compressed packet to decompress,
 656          * or a CCP packet to take notice of.
 657          */
 658         proto = PPP_PROTOCOL(mp->b_rptr);
 659         if (proto == PPP_CCP)
 660             ppp_comp_ccp(q, mp, 1);
 661         else if (proto == PPP_COMP) {
 662             if ((cp->flags & CCP_ISUP)
 663                 && (cp->flags & CCP_DECOMP_RUN) && cp->rstate
 664                 && (cp->flags & CCP_ERR) == 0) {
 665                 rv = (*cp->rcomp->decompress)(cp->rstate, mp, &dmp);
 666                 switch (rv) {
 667                 case DECOMP_OK:
 668                     freemsg(mp);
 669                     mp = dmp;
 670                     if (mp == NULL) {
 671                         /* no error, but no packet returned either. */
 672                         continue;
 673                     }
 674                     break;
 675                 case DECOMP_ERROR:
 676                     cp->flags |= CCP_ERROR;
 677                     ++cp->stats.ppp_ierrors;
 678                     putctl1(q->q_next, M_CTL, PPPCTL_IERROR);
 679                     break;
 680                 case DECOMP_FATALERROR:
 681                     cp->flags |= CCP_FATALERROR;
 682                     ++cp->stats.ppp_ierrors;
 683                     putctl1(q->q_next, M_CTL, PPPCTL_IERROR);
 684                     break;
 685                 }
 686             }
 687         } else if (cp->rstate && (cp->flags & CCP_DECOMP_RUN)) {
 688             (*cp->rcomp->incomp)(cp->rstate, mp);
 689         }
 690
 691         /*
 692          * Now do VJ decompression.
 693          */
 694         proto = PPP_PROTOCOL(mp->b_rptr);
 695         if (proto == PPP_VJC_COMP || proto == PPP_VJC_UNCOMP) {
 696             len = msgdsize(mp) - PPP_HDRLEN;
 697             if ((cp->flags & DECOMP_VJC) == 0 || len <= 0)
 698                 goto bad;
 699
 700             /*
 701              * Advance past the ppp header.
 702              * Here we assume that the whole PPP header is in the first mblk.
 703              */
 704             np = mp;
 705             dp = np->b_rptr + PPP_HDRLEN;
 706             if (dp >= mp->b_wptr) {
 707                 np = np->b_cont;
 708                 dp = np->b_rptr;
 709             }
 710
 711             if (proto == PPP_VJC_COMP) {
 712                 hlen = MIN(len, MAX_VJHDR);
 713                 if (np->b_wptr < dp + hlen) {
 714                     PULLUP(mp, hlen + PPP_HDRLEN);
 715                     if (mp == 0)
 716                         goto bad;
 717                     np = mp;
 718                     dp = np->b_rptr + PPP_HDRLEN;
 719                 }
 720
 721                 if (cp->stats.ppp_ierrors != cp->vj_last_ierrors) {
 722                     vj_uncompress_err(&cp->vj_comp);
 723                     cp->vj_last_ierrors = cp->stats.ppp_ierrors;
 724                 }
 725
 726                 vjlen = vj_uncompress_tcp(dp, np->b_wptr - dp, len,
 727                                           &cp->vj_comp, &iphdr, &iphlen);
 728                 if (vjlen < 0)
 729                     goto bad;
 730
 731                 /* drop ppp and vj headers off */
 732                 if (mp != np) {
 733                     freeb(mp);
 734                     mp = np;
 735                 }
 736                 mp->b_rptr = dp + vjlen;
 737
 738                 /* allocate a new mblk for the ppp and ip headers */
 739                 if ((np = allocb(iphlen + PPP_HDRLEN + 4, BPRI_MED)) == 0)
 740                     goto bad;
 741                 dp = np->b_rptr;        /* prepend mblk with TCP/IP hdr */
 742                 dp[0] = PPP_ALLSTATIONS; /* reconstruct PPP header */
 743                 dp[1] = PPP_UI;
 744                 dp[2] = PPP_IP >> 8;
 745                 dp[3] = PPP_IP;
 746                 bcopy(iphdr, dp + PPP_HDRLEN, iphlen);
 747                 np->b_wptr = dp + iphlen + PPP_HDRLEN;
 748                 np->b_cont = mp;
 749
 750                 /* XXX there seems to be a bug which causes panics in strread
 751                    if we make an mbuf with only the IP header in it :-( */
 752                 if (mp->b_wptr - mp->b_rptr > 4) {
 753                     bcopy(mp->b_rptr, np->b_wptr, 4);
 754                     mp->b_rptr += 4;
 755                     np->b_wptr += 4;
 756                 } else {
 757                     bcopy(mp->b_rptr, np->b_wptr, mp->b_wptr - mp->b_rptr);
 758                     np->b_wptr += mp->b_wptr - mp->b_rptr;
 759                     np->b_cont = mp->b_cont;
 760                     freeb(mp);
 761                 }
 762
 763                 mp = np;
 764
 765             } else {
 766                 hlen = MIN(len, MAX_IPHDR);
 767                 if (np->b_wptr < dp + hlen || np->b_datap->db_ref > 1
 768                     || mp->b_datap->db_ref > 1) {
 769                     PULLUP(mp, hlen + PPP_HDRLEN);
 770                     if (mp == 0)
 771                         goto bad;
 772                     np = mp;
 773                     dp = np->b_rptr + PPP_HDRLEN;
 774                 }
 775
 776                 if (!vj_uncompress_uncomp(dp, &cp->vj_comp))
 777                     goto bad;
 778                 mp->b_rptr[3] = PPP_IP; /* fix up the PPP protocol field */
 779             }
 780         }
 781
 782         putnext(q, mp);
 783         continue;
 784
 785     bad:
 786         if (mp != 0)
 787             freemsg(mp);
 788         cp->stats.ppp_ierrors++;
 789         putctl1(q->q_next, M_CTL, PPPCTL_IERROR);
 790     }
 791 }
 792
 793 /*
 794  * Handle a CCP packet being sent or received.
 795  */
 796 static void
 797 ppp_comp_ccp(q, mp, rcvd)
 798     queue_t *q;
 799     mblk_t *mp;
 800     int rcvd;
 801 {
 802     int len, clen;
 803     comp_state_t *cp;
 804     unsigned char *dp;
 805     mblk_t *np;
 806
 807     len = msgdsize(mp);
 808     if (len < PPP_HDRLEN + CCP_HDRLEN)
 809         return;
 810     if (mp->b_wptr < mp->b_rptr + len) {
 811         /* XXX this isn't right, because it may free mp */
 812         PULLUP(mp, len);
 813         if (mp == 0) {
 814             cmn_err(CE_CONT, "ppp_comp_ccp: pullup failed\n");
 815             return;
 816         }
 817     }
 818     np = mp;
 819
 820     cp = (comp_state_t *) q->q_ptr;
 821     dp = mp->b_rptr + PPP_HDRLEN;
 822     len -= PPP_HDRLEN;
 823     clen = CCP_LENGTH(dp);
 824     if (clen > len)
 825         goto bad;
 826
 827     switch (CCP_CODE(dp)) {
 828     case CCP_CONFREQ:
 829     case CCP_TERMREQ:
 830     case CCP_TERMACK:
 831         cp->flags &= ~CCP_ISUP;
 832         break;
 833
 834     case CCP_CONFACK:
 835         if ((cp->flags & (CCP_ISOPEN | CCP_ISUP)) == CCP_ISOPEN
 836             && clen >= CCP_HDRLEN + CCP_OPT_MINLEN
 837             && clen >= CCP_HDRLEN + CCP_OPT_LENGTH(dp + CCP_HDRLEN)) {
 838             if (!rcvd) {
 839                 if (cp->xstate != NULL
 840                     && (*cp->xcomp->comp_init)
 841                         (cp->xstate, dp + CCP_HDRLEN, clen - CCP_HDRLEN,
 842                          cp->unit, 0, 0))
 843                     cp->flags |= CCP_COMP_RUN;
 844             } else {
 845                 if (cp->rstate != NULL
 846                     && (*cp->rcomp->decomp_init)
 847                         (cp->rstate, dp + CCP_HDRLEN, clen - CCP_HDRLEN,
 848                          cp->unit, 0, cp->mru, 0))
 849                     cp->flags = (cp->flags & ~CCP_ERR)
 850                         | CCP_DECOMP_RUN;
 851             }
 852         }
 853         break;
 854
 855     case CCP_RESETACK:
 856         if (cp->flags & CCP_ISUP) {
 857             if (!rcvd) {
 858                 if (cp->xstate && (cp->flags & CCP_COMP_RUN))
 859                     (*cp->xcomp->comp_reset)(cp->xstate);
 860             } else {
 861                 if (cp->rstate && (cp->flags & CCP_DECOMP_RUN)) {
 862                     (*cp->rcomp->decomp_reset)(cp->rstate);
 863                     cp->flags &= ~CCP_ERROR;
 864                 }
 865             }
 866         }
 867         break;
 868     }
 869
 870  bad:
 871     if (np != mp)
 872         freemsg(np);
 873 }
 874
 875 #if DEBUG
 876 dump_msg(mp)
 877     mblk_t *mp;
 878 {
 879     dblk_t *db;
 880
 881     while (mp != 0) {
 882         db = mp->b_datap;
 883         cmn_err(CE_CONT, "mp=%x cont=%x rptr=%x wptr=%x datap=%x\n",
 884                 mp, mp->b_cont, mp->b_rptr, mp->b_wptr, db);
 885         cmn_err(CE_CONT, "  base=%x lim=%x ref=%d type=%d struioflag=%d\n",
 886                 db->db_base, db->db_lim, db->db_ref, db->db_type,
 887                 db->db_struioflag);
 888         mp = mp->b_cont;
 889     }
 890 }
 891 #endif