modules/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 HAS 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 1996/08/28 06:36:30 paulus Exp $
  28  */
  29
  30 /*
  31  * This file is used under SVR4, Solaris 2, SunOS 4, and Digital UNIX.
  32  */
  33
  34 #include <sys/types.h>
  35 #include <sys/param.h>
  36 #include <sys/errno.h>
  37 #include <sys/stream.h>
  38
  39 #ifdef SVR4
  40 #include <sys/conf.h>
  41 #include <sys/cmn_err.h>
  42 #include <sys/ddi.h>
  43 #else
  44 #include <sys/user.h>
  45 #endif /* SVR4 */
  46
  47 #include <net/ppp_defs.h>
  48 #include <net/pppio.h>
  49 #include "ppp_mod.h"
  50
  51 #ifdef __osf__
  52 #include <sys/mbuf.h>
  53 #include <sys/protosw.h>
  54 #endif
  55
  56 #include <netinet/in.h>
  57 #include <netinet/in_systm.h>
  58 #include <netinet/ip.h>
  59 #include <net/vjcompress.h>
  60
  61 #define PACKETPTR       mblk_t *
  62 #include <net/ppp-comp.h>
  63
  64 MOD_OPEN_DECL(ppp_comp_open);
  65 MOD_CLOSE_DECL(ppp_comp_close);
  66 static int ppp_comp_rput __P((queue_t *, mblk_t *));
  67 static int ppp_comp_rsrv __P((queue_t *));
  68 static int ppp_comp_wput __P((queue_t *, mblk_t *));
  69 static int ppp_comp_wsrv __P((queue_t *));
  70 static void ppp_comp_ccp __P((queue_t *, mblk_t *, int));
  71 static int msg_byte __P((mblk_t *, unsigned int));
  72
  73 /* Extract byte i of message mp. */
  74 #define MSG_BYTE(mp, i) ((i) < (mp)->b_wptr - (mp)->b_rptr? (mp)->b_rptr[i]: \
  75                          msg_byte((mp), (i)))
  76
  77 /* Is this LCP packet one we have to transmit using LCP defaults? */
  78 #define LCP_USE_DFLT(mp)        (1 <= (code = MSG_BYTE((mp), 4)) && code <= 7)
  79
  80 #define PPP_COMP_ID 0xbadf
  81 static struct module_info minfo = {
  82     PPP_COMP_ID, "ppp_comp", 0, INFPSZ, 16384, 4096,
  83 };
  84
  85 static struct qinit r_init = {
  86     ppp_comp_rput, ppp_comp_rsrv, ppp_comp_open, ppp_comp_close,
  87     NULL, &minfo, NULL
  88 };
  89
  90 static struct qinit w_init = {
  91     ppp_comp_wput, ppp_comp_wsrv, NULL, NULL, NULL, &minfo, NULL
  92 };
  93
  94 struct streamtab ppp_compinfo = {
  95     &r_init, &w_init, NULL, NULL
  96 };
  97
  98 int ppp_comp_count;             /* number of module instances in use */
  99
 100 #ifdef __osf__
 101
 102 static void ppp_comp_alloc __P((comp_state_t *));
 103 typedef struct memreq {
 104     unsigned char *comp;
 105     void *mem;
 106     int len;
 107     int cmd;
 108     int ret;
 109 } memreq_t;
 110
 111 #endif
 112
 113 typedef struct comp_state {
 114     int         flags;
 115     int         mru;
 116     int         mtu;
 117     int         unit;
 118     struct compressor *xcomp;
 119     void        *xstate;
 120     struct compressor *rcomp;
 121     void        *rstate;
 122     struct vjcompress vj_comp;
 123     int         vj_last_ierrors;
 124     struct pppstat stats;
 125 #ifdef __osf__
 126     memreq_t    memreq;
 127     thread_t    thread;
 128 #endif
 129 } comp_state_t;
 130
 131
 132 #ifdef __osf__
 133 extern task_t first_task;
 134 #endif
 135
 136 /* Bits in flags are as defined in pppio.h. */
 137 #define CCP_ERR         (CCP_ERROR | CCP_FATALERROR)
 138 #define LAST_MOD        0x1000000       /* no ppp modules below us */
 139 #define DBGLOG          0x2000000       /* log debugging stuff */
 140
 141 #define MAX_IPHDR       128     /* max TCP/IP header size */
 142 #define MAX_VJHDR       20      /* max VJ compressed header size (?) */
 143
 144 #undef MIN              /* just in case */
 145 #define MIN(a, b)       ((a) < (b)? (a): (b))
 146
 147 /*
 148  * List of compressors we know about.
 149  */
 150
 151 extern struct compressor ppp_bsd_compress;
 152 extern struct compressor ppp_deflate;
 153
 154 struct compressor *ppp_compressors[] = {
 155 #if DO_BSD_COMPRESS
 156     &ppp_bsd_compress,
 157 #endif
 158 #if DO_DEFLATE
 159     &ppp_deflate,
 160 #endif
 161     NULL
 162 };
 163
 164 /*
 165  * STREAMS module entry points.
 166  */
 167 MOD_OPEN(ppp_comp_open)
 168 {
 169     comp_state_t *cp;
 170 #ifdef __osf__
 171     thread_t thread;
 172 #endif
 173
 174     if (q->q_ptr == NULL) {
 175         cp = (comp_state_t *) ALLOC_SLEEP(sizeof(comp_state_t));
 176         if (cp == NULL)
 177             OPEN_ERROR(ENOSR);
 178         WR(q)->q_ptr = q->q_ptr = (caddr_t) cp;
 179         bzero((caddr_t)cp, sizeof(comp_state_t));
 180         cp->mru = PPP_MRU;
 181         cp->mtu = PPP_MRU;
 182         cp->xstate = NULL;
 183         cp->rstate = NULL;
 184         vj_compress_init(&cp->vj_comp, -1);
 185         ++ppp_comp_count;
 186         qprocson(q);
 187 #ifdef __osf__
 188         if (!(thread = kernel_thread_w_arg(first_task, ppp_comp_alloc, (void *)cp)))
 189                 OPEN_ERROR(ENOSR);
 190         cp->thread = thread;
 191 #endif
 192     }
 193     return 0;
 194 }
 195
 196 MOD_CLOSE(ppp_comp_close)
 197 {
 198     comp_state_t *cp;
 199
 200     qprocsoff(q);
 201     cp = (comp_state_t *) q->q_ptr;
 202     if (cp != NULL) {
 203         if (cp->xstate != NULL)
 204             (*cp->xcomp->comp_free)(cp->xstate);
 205         if (cp->rstate != NULL)
 206             (*cp->rcomp->decomp_free)(cp->rstate);
 207 #ifdef __osf__
 208         if (!cp->thread)
 209             printf("ppp_comp_close: NULL thread!\n");
 210         else
 211             thread_deallocate(cp->thread);
 212 #endif
 213         FREE(cp, sizeof(comp_state_t));
 214         q->q_ptr = NULL;
 215         OTHERQ(q)->q_ptr = NULL;
 216         --ppp_comp_count;
 217     }
 218     return 0;
 219 }
 220
 221 #ifdef __osf__
 222
 223 /* thread for calling back to a compressor's memory allocator
 224  * Needed for Digital UNIX since it's VM can't handle requests
 225  * for large amounts of memory without blocking.  The thread
 226  * provides a context in which we can call a memory allocator
 227  * that may block.
 228  */
 229 static void
 230 ppp_comp_alloc(comp_state_t *cp)
 231 {
 232     unsigned char *opt_data;
 233     int len, cmd;
 234     struct compressor *comp;
 235     thread_t thread;
 236
 237 #if (MAJOR_VERSION <= 2)
 238
 239     /* In 2.x and earlier the argument gets passed
 240      * in the thread structure itself.  Yuck.
 241      */
 242     thread = current_thread();
 243     cp = thread->reply_port;
 244     thread->reply_port = PORT_NULL;
 245
 246 #endif
 247
 248     for (;;) {
 249         assert_wait((vm_offset_t)&cp->memreq.comp, TRUE);
 250         thread_block();
 251         opt_data = cp->memreq.comp;
 252         len = cp->memreq.len;
 253         cmd = cp->memreq.cmd;
 254
 255         if (cmd == PPPIO_XCOMP) {
 256             comp = cp->xcomp;
 257             cp->memreq.mem = (*comp->comp_alloc)(opt_data, len);
 258         } else {
 259             comp = cp->rcomp;
 260             cp->memreq.mem = (*comp->decomp_alloc)(opt_data, len);
 261         }
 262         if (!cp->memreq.mem)
 263             cp->memreq.ret = ENOSR;
 264         else
 265             bcopy(opt_data, cp->memreq.mem, len);
 266
 267         /* have to free thunk here, since there's
 268          * no guarantee that the user will call the ioctl
 269          * again if we've taken a long time to complete
 270          */
 271         FREE(opt_data, len);
 272         cp->memreq.ret = 0;
 273     }
 274 }
 275
 276 #endif /* __osf__ */
 277
 278 /* here's the deal with memory allocation under Digital UNIX.
 279  * Some other may also benefit from this...
 280  * We can't ask for huge chunks of memory in a context where
 281  * the caller can't be put to sleep (like, here.)  The alloc
 282  * is likely to fail.  Instead we do this: the first time we
 283  * get called, kick off a thread to do the allocation.  Return
 284  * immediately to the caller with EAGAIN, as an indication that
 285  * they should send down the ioctl again.  By the time the
 286  * second call comes in it's likely that the memory allocation
 287  * thread will have returned with the requested memory.  We will
 288  * continue to return EAGAIN however until the thread has completed.
 289  * When it has, we return zero (and the memory) if the allocator
 290  * was successful and ENOSR otherwise.
 291  *
 292  * Callers of the RCOMP and XCOMP ioctls are encouraged (but not
 293  * required) to loop for some number of iterations with a small
 294  * delay in the loop body (for instance a 1/10-th second "sleep"
 295  * via select.)
 296  */
 297 static int
 298 ppp_comp_wput(q, mp)
 299     queue_t *q;
 300     mblk_t *mp;
 301 {
 302     struct iocblk *iop;
 303     comp_state_t *cp;
 304     int error, len, n;
 305     int flags, mask;
 306     mblk_t *np;
 307     struct compressor **comp;
 308     struct ppp_stats *psp;
 309     struct ppp_comp_stats *csp;
 310     unsigned char *opt_data;
 311     int nxslots, nrslots;
 312
 313     cp = (comp_state_t *) q->q_ptr;
 314     switch (mp->b_datap->db_type) {
 315
 316     case M_DATA:
 317         putq(q, mp);
 318         break;
 319
 320     case M_IOCTL:
 321         iop = (struct iocblk *) mp->b_rptr;
 322         error = EINVAL;
 323         switch (iop->ioc_cmd) {
 324
 325         case PPPIO_CFLAGS:
 326             /* set/get CCP state */
 327             if (iop->ioc_count != 2 * sizeof(int))
 328                 break;
 329             flags = ((int *) mp->b_cont->b_rptr)[0];
 330             mask = ((int *) mp->b_cont->b_rptr)[1];
 331             cp->flags = (cp->flags & ~mask) | (flags & mask);
 332             if ((mask & CCP_ISOPEN) && (flags & CCP_ISOPEN) == 0) {
 333                 if (cp->xstate != NULL) {
 334                     (*cp->xcomp->comp_free)(cp->xstate);
 335                     cp->xstate = NULL;
 336                 }
 337                 if (cp->rstate != NULL) {
 338                     (*cp->rcomp->decomp_free)(cp->rstate);
 339                     cp->rstate = NULL;
 340                 }
 341                 cp->flags &= ~CCP_ISUP;
 342             }
 343             error = 0;
 344             iop->ioc_count = sizeof(int);
 345             ((int *) mp->b_cont->b_rptr)[0] = cp->flags;
 346             mp->b_cont->b_wptr = mp->b_cont->b_rptr + sizeof(int);
 347             break;
 348
 349         case PPPIO_VJINIT:
 350             /*
 351              * Initialize VJ compressor/decompressor
 352              */
 353             if (iop->ioc_count != 2)
 354                 break;
 355             nxslots = mp->b_cont->b_rptr[0] + 1;
 356             nrslots = mp->b_cont->b_rptr[1] + 1;
 357             if (nxslots > MAX_STATES || nrslots > MAX_STATES)
 358                 break;
 359             vj_compress_init(&cp->vj_comp, nxslots);
 360             cp->vj_last_ierrors = cp->stats.ppp_ierrors;
 361             error = 0;
 362             iop->ioc_count = 0;
 363             break;
 364
 365         case PPPIO_XCOMP:
 366         case PPPIO_RCOMP:
 367             if (iop->ioc_count <= 0)
 368                 break;
 369             opt_data = mp->b_cont->b_rptr;
 370             len = mp->b_cont->b_wptr - opt_data;
 371             if (len > iop->ioc_count)
 372                 len = iop->ioc_count;
 373             if (opt_data[1] < 2 || opt_data[1] > len)
 374                 break;
 375             for (comp = ppp_compressors; *comp != NULL; ++comp)
 376                 if ((*comp)->compress_proto == opt_data[0]) {
 377                     /* here's the handler! */
 378                     error = 0;
 379                     if (iop->ioc_cmd == PPPIO_XCOMP) {
 380
 381                         /* A previous call may have fetched memory for a compressor
 382                          * that's now being retired or reset.  Free it using it's
 383                          * mechanism for freeing stuff.
 384                          */
 385                         if (cp->xstate != NULL) {
 386                             (*cp->xcomp->comp_free)(cp->xstate);
 387                             cp->xstate = NULL;
 388                         }
 389
 390 #ifdef __osf__
 391                         /* Account for an orpahned call to get memory.
 392                          * Free that memory up and go on.
 393                          *
 394                          * The trick is that we need to be able to tell
 395                          * the difference between an old call that kicked
 396                          * off a thread where the memory was subsequently
 397                          * orphaned, and the memory we're really interested
 398                          * in.  The thread helps by stamping the memory it
 399                          * allocated with the parameters for the compressor
 400                          * it belongs to.  If the parameters match then this
 401                          * is the memory we want (whether it was an actual
 402                          * orphan or not we don't care.)  If the parameters
 403                          * don't match then this is an orphan.
 404                          *
 405                          * Note that cp->memreq.ret is the synchronization
 406                          * point: we set it to EAGAIN in this function, then
 407                          * wait for the thread to set it to something other
 408                          * than EAGAIN before we fool with the data structure
 409                          * again.  Basically, if ret != EAGAIN then the thread
 410                          * is working and it owns the memreq struture.
 411                          */
 412                         if (cp->memreq.ret == 0 && cp->memreq.mem != NULL &&
 413                             bcmp(cp->memreq.mem, opt_data, len)) {
 414                             (*cp->xcomp->comp_free)(cp->memreq.mem);
 415                             cp->memreq.mem = 0;
 416                         }
 417
 418                         /* First time through, prime the pump and kick
 419                          * off the thread.  Subsequent times though, the thread
 420                          * is either busy (ret == EAGAIN) or finsihed (mem != NULL)
 421                          * || (ret != 0)
 422                          */
 423                         if (cp->memreq.ret == 0 && cp->memreq.mem == NULL) {
 424                             cp->memreq.comp = ALLOC_NOSLEEP(len);
 425                             if (!cp->memreq.comp) {
 426                                 printf("gack! can't get memory for thunk\n");
 427                                 return ENOSR;
 428                             }
 429                             bcopy(opt_data, cp->memreq.comp, len);
 430                             cp->memreq.len = len;
 431                             cp->memreq.cmd = PPPIO_XCOMP;
 432                             cp->xcomp = *comp;
 433                             cp->memreq.ret = EAGAIN;
 434                             thread_wakeup((vm_offset_t)&cp->memreq.comp);
 435                         }
 436
 437                         /* Collect results from the thread, and reset the
 438                          * mechanism for the next attempt to allocate memory
 439                          * If the thread isn't finished (ret == EAGAIN) then
 440                          * don't reset and just return.
 441                          */
 442                         if ((error = cp->memreq.ret) != EAGAIN) {
 443                             cp->xstate = cp->memreq.mem;
 444                             cp->memreq.mem = 0;
 445                             cp->memreq.ret = 0;
 446                         }
 447 #else
 448                         cp->xcomp = *comp;
 449                         cp->xstate = (*comp)->comp_alloc(opt_data, len);
 450                         if (cp->xstate == NULL)
 451                             error = ENOSR;
 452 #endif
 453                     } else {
 454                         if (cp->rstate != NULL) {
 455                             (*cp->rcomp->decomp_free)(cp->rstate);
 456                             cp->rstate = NULL;
 457                         }
 458 #ifdef __osf__
 459                         if (cp->memreq.ret == 0 && cp->memreq.mem != NULL &&
 460                             bcmp(cp->memreq.mem, opt_data, len)) {
 461                             (*cp->rcomp->comp_free)(cp->memreq.mem);
 462                             cp->memreq.mem = 0;
 463                         }
 464                         if (cp->memreq.ret == 0 && cp->memreq.mem == NULL) {
 465                             cp->memreq.comp = ALLOC_NOSLEEP(len);
 466                             if (!cp->memreq.comp) {
 467                                 printf("gack! can't get memory for thunk\n");
 468                                 return ENOSR;
 469                             }
 470                             bcopy(opt_data, cp->memreq.comp, len);
 471                             cp->memreq.len = len;
 472                             cp->memreq.cmd = PPPIO_RCOMP;
 473                             cp->rcomp = *comp;
 474                             cp->memreq.ret = EAGAIN;
 475                             thread_wakeup((vm_offset_t)&cp->memreq.comp);
 476                         }
 477                         if ((error = cp->memreq.ret) != EAGAIN) {
 478                             cp->rstate = cp->memreq.mem;
 479                             cp->memreq.mem = 0;
 480                             cp->memreq.ret = 0;
 481                         }
 482 #else
 483                         cp->rcomp = *comp;
 484                         cp->rstate = (*comp)->decomp_alloc(opt_data, len);
 485                         if (cp->rstate == NULL)
 486                             error = ENOSR;
 487 #endif
 488                     }
 489                     break;
 490                 }
 491             iop->ioc_count = 0;
 492             break;
 493
 494         case PPPIO_GETSTAT:
 495             if ((cp->flags & LAST_MOD) == 0) {
 496                 error = -1;     /* let the ppp_ahdl module handle it */
 497                 break;
 498             }
 499             np = allocb(sizeof(struct ppp_stats), BPRI_HI);
 500             if (np == 0) {
 501                 error = ENOSR;
 502                 break;
 503             }
 504             if (mp->b_cont != 0)
 505                 freemsg(mp->b_cont);
 506             mp->b_cont = np;
 507             psp = (struct ppp_stats *) np->b_wptr;
 508             np->b_wptr += sizeof(struct ppp_stats);
 509             iop->ioc_count = sizeof(struct ppp_stats);
 510             psp->p = cp->stats;
 511             psp->vj = cp->vj_comp.stats;
 512             error = 0;
 513             break;
 514
 515         case PPPIO_GETCSTAT:
 516             np = allocb(sizeof(struct ppp_comp_stats), BPRI_HI);
 517             if (np == 0) {
 518                 error = ENOSR;
 519                 break;
 520             }
 521             if (mp->b_cont != 0)
 522                 freemsg(mp->b_cont);
 523             mp->b_cont = np;
 524             csp = (struct ppp_comp_stats *) np->b_wptr;
 525             np->b_wptr += sizeof(struct ppp_comp_stats);
 526             iop->ioc_count = sizeof(struct ppp_comp_stats);
 527             bzero((caddr_t)csp, sizeof(struct ppp_comp_stats));
 528             if (cp->xstate != 0)
 529                 (*cp->xcomp->comp_stat)(cp->xstate, &csp->c);
 530             if (cp->rstate != 0)
 531                 (*cp->rcomp->decomp_stat)(cp->rstate, &csp->d);
 532             error = 0;
 533             break;
 534
 535         case PPPIO_DEBUG:
 536             if (iop->ioc_count != sizeof(int))
 537                 break;
 538             n = *(int *)mp->b_cont->b_rptr;
 539             if (n == PPPDBG_LOG + PPPDBG_COMP) {
 540                 DPRINT1("ppp_comp%d: debug log enabled\n", cp->unit);
 541                 cp->flags |= DBGLOG;
 542                 error = 0;
 543                 iop->ioc_count = 0;
 544             } else {
 545                 error = -1;
 546             }
 547             break;
 548
 549         case PPPIO_LASTMOD:
 550             cp->flags |= LAST_MOD;
 551             error = 0;
 552             break;
 553
 554         default:
 555             error = -1;
 556             break;
 557         }
 558
 559         if (error < 0)
 560             putnext(q, mp);
 561         else if (error == 0) {
 562             mp->b_datap->db_type = M_IOCACK;
 563             qreply(q, mp);
 564         } else {
 565             mp->b_datap->db_type = M_IOCNAK;
 566             iop->ioc_error = error;
 567             iop->ioc_count = 0;
 568             qreply(q, mp);
 569         }
 570         break;
 571
 572     case M_CTL:
 573         switch (*mp->b_rptr) {
 574         case PPPCTL_MTU:
 575             cp->mtu = ((unsigned short *)mp->b_rptr)[1];
 576             break;
 577         case PPPCTL_MRU:
 578             cp->mru = ((unsigned short *)mp->b_rptr)[1];
 579             break;
 580         case PPPCTL_UNIT:
 581             cp->unit = mp->b_rptr[1];
 582             break;
 583         }
 584         putnext(q, mp);
 585         break;
 586
 587     default:
 588         putnext(q, mp);
 589     }
 590 }
 591
 592 static int
 593 ppp_comp_wsrv(q)
 594     queue_t *q;
 595 {
 596     mblk_t *mp, *cmp = NULL, *np;
 597     comp_state_t *cp;
 598     int len, proto, type, hlen, code;
 599     struct ip *ip;
 600     unsigned char *vjhdr, *dp;
 601
 602     cp = (comp_state_t *) q->q_ptr;
 603     while ((mp = getq(q)) != 0) {
 604         /* assert(mp->b_datap->db_type == M_DATA) */
 605         if (!canputnext(q)) {
 606             putbq(q, mp);
 607             return;
 608         }
 609
 610         /*
 611          * First check the packet length and work out what the protocol is.
 612          */
 613         len = msgdsize(mp);
 614         if (len < PPP_HDRLEN) {
 615             DPRINT1("ppp_comp_wsrv: bogus short packet (%d)\n", len);
 616             freemsg(mp);
 617             cp->stats.ppp_oerrors++;
 618             putctl1(RD(q)->q_next, M_CTL, PPPCTL_OERROR);
 619             continue;
 620         }
 621         proto = (MSG_BYTE(mp, 2) << 8) + MSG_BYTE(mp, 3);
 622
 623         /*
 624          * Make sure we've got enough data in the first mblk
 625          * and that we are its only user.
 626          */
 627         if (proto == PPP_CCP)
 628             hlen = len;
 629         else if (proto == PPP_IP)
 630             hlen = PPP_HDRLEN + MAX_IPHDR;
 631         else
 632             hlen = PPP_HDRLEN;
 633         if (hlen > len)
 634             hlen = len;
 635         if (mp->b_wptr < mp->b_rptr + hlen || mp->b_datap->db_ref > 1) {
 636             PULLUP(mp, hlen);
 637             if (mp == 0) {
 638                 DPRINT1("ppp_comp_wsrv: pullup failed (%d)\n", hlen);
 639                 cp->stats.ppp_oerrors++;
 640                 putctl1(RD(q)->q_next, M_CTL, PPPCTL_OERROR);
 641                 continue;
 642             }
 643         }
 644
 645         /*
 646          * Do VJ compression if requested.
 647          */
 648         if (proto == PPP_IP && (cp->flags & COMP_VJC)) {
 649             ip = (struct ip *) (mp->b_rptr + PPP_HDRLEN);
 650             if (ip->ip_p == IPPROTO_TCP) {
 651                 type = vj_compress_tcp(ip, len - PPP_HDRLEN, &cp->vj_comp,
 652                                        (cp->flags & COMP_VJCCID), &vjhdr);
 653                 switch (type) {
 654                 case TYPE_UNCOMPRESSED_TCP:
 655                     mp->b_rptr[3] = proto = PPP_VJC_UNCOMP;
 656                     break;
 657                 case TYPE_COMPRESSED_TCP:
 658                     dp = vjhdr - PPP_HDRLEN;
 659                     dp[1] = mp->b_rptr[1]; /* copy control field */
 660                     dp[0] = mp->b_rptr[0]; /* copy address field */
 661                     dp[2] = 0;             /* set protocol field */
 662                     dp[3] = proto = PPP_VJC_COMP;
 663                     mp->b_rptr = dp;
 664                     break;
 665                 }
 666             }
 667         }
 668
 669         /*
 670          * Do packet compression if enabled.
 671          */
 672         if (proto == PPP_CCP)
 673             ppp_comp_ccp(q, mp, 0);
 674         else if (proto != PPP_LCP && (cp->flags & CCP_COMP_RUN)
 675                  && cp->xstate != NULL) {
 676             len = msgdsize(mp);
 677             (*cp->xcomp->compress)(cp->xstate, &cmp, mp, len,
 678                                    (cp->flags & CCP_ISUP? cp->mtu: 0));
 679             if (cmp != NULL) {
 680                 freemsg(mp);
 681                 mp = cmp;
 682             }
 683         }
 684
 685         /*
 686          * Do address/control and protocol compression if enabled.
 687          */
 688         if ((cp->flags & COMP_AC)
 689             && !(proto == PPP_LCP && LCP_USE_DFLT(mp))) {
 690             mp->b_rptr += 2;    /* drop the address & ctrl fields */
 691             if (proto < 0x100 && (cp->flags & COMP_PROT))
 692                 ++mp->b_rptr;   /* drop the high protocol byte */
 693         } else if (proto < 0x100 && (cp->flags & COMP_PROT)) {
 694             /* shuffle up the address & ctrl fields */
 695             mp->b_rptr[2] = mp->b_rptr[1];
 696             mp->b_rptr[1] = mp->b_rptr[0];
 697             ++mp->b_rptr;
 698         }
 699
 700         cp->stats.ppp_opackets++;
 701         cp->stats.ppp_obytes += msgdsize(mp);
 702         putnext(q, mp);
 703     }
 704 }
 705
 706 static int
 707 ppp_comp_rput(q, mp)
 708     queue_t *q;
 709     mblk_t *mp;
 710 {
 711     comp_state_t *cp;
 712     struct iocblk *iop;
 713     struct ppp_stats *psp;
 714
 715     cp = (comp_state_t *) q->q_ptr;
 716     switch (mp->b_datap->db_type) {
 717
 718     case M_DATA:
 719         putq(q, mp);
 720         break;
 721
 722     case M_IOCACK:
 723         iop = (struct iocblk *) mp->b_rptr;
 724         switch (iop->ioc_cmd) {
 725         case PPPIO_GETSTAT:
 726             /*
 727              * Catch this on the way back from the ppp_ahdl module
 728              * so we can fill in the VJ stats.
 729              */
 730             if (mp->b_cont == 0 || iop->ioc_count != sizeof(struct ppp_stats))
 731                 break;
 732             psp = (struct ppp_stats *) mp->b_cont->b_rptr;
 733             psp->vj = cp->vj_comp.stats;
 734             break;
 735         }
 736         putnext(q, mp);
 737         break;
 738
 739     case M_CTL:
 740         switch (mp->b_rptr[0]) {
 741         case PPPCTL_IERROR:
 742             ++cp->stats.ppp_ierrors;
 743             break;
 744         case PPPCTL_OERROR:
 745             ++cp->stats.ppp_oerrors;
 746             break;
 747         }
 748         putnext(q, mp);
 749         break;
 750
 751     default:
 752         putnext(q, mp);
 753     }
 754 }
 755
 756 static int
 757 ppp_comp_rsrv(q)
 758     queue_t *q;
 759 {
 760     int proto, rv, i;
 761     mblk_t *mp, *dmp = NULL, *np;
 762     uchar_t *dp, *iphdr;
 763     comp_state_t *cp;
 764     int len, hlen, vjlen;
 765     u_int iphlen;
 766
 767     cp = (comp_state_t *) q->q_ptr;
 768     while ((mp = getq(q)) != 0) {
 769         /* assert(mp->b_datap->db_type == M_DATA) */
 770         if (!canputnext(q)) {
 771             putbq(q, mp);
 772             return;
 773         }
 774
 775         len = msgdsize(mp);
 776         cp->stats.ppp_ibytes += len;
 777         cp->stats.ppp_ipackets++;
 778
 779         /*
 780          * First work out the protocol and where the PPP header ends.
 781          */
 782         i = 0;
 783         proto = MSG_BYTE(mp, 0);
 784         if (proto == PPP_ALLSTATIONS) {
 785             i = 2;
 786             proto = MSG_BYTE(mp, 2);
 787         }
 788         if ((proto & 1) == 0) {
 789             ++i;
 790             proto = (proto << 8) + MSG_BYTE(mp, i);
 791         }
 792         hlen = i + 1;
 793
 794         /*
 795          * Now reconstruct a complete, contiguous PPP header at the
 796          * start of the packet.
 797          */
 798         if (hlen < ((cp->flags & DECOMP_AC)? 0: 2)
 799                    + ((cp->flags & DECOMP_PROT)? 1: 2)) {
 800             /* count these? */
 801             goto bad;
 802         }
 803         if (mp->b_rptr + hlen > mp->b_wptr) {
 804             adjmsg(mp, hlen);   /* XXX check this call */
 805             hlen = 0;
 806         }
 807         if (hlen != PPP_HDRLEN) {
 808             /*
 809              * We need to put some bytes on the front of the packet
 810              * to make a full-length PPP header.
 811              * If we can put them in *mp, we do, otherwise we
 812              * tack another mblk on the front.
 813              * XXX we really shouldn't need to carry around
 814              * the address and control at this stage.
 815              */
 816             dp = mp->b_rptr + hlen - PPP_HDRLEN;
 817             if (dp < mp->b_datap->db_base || mp->b_datap->db_ref > 1) {
 818                 np = allocb(PPP_HDRLEN, BPRI_MED);
 819                 if (np == 0)
 820                     goto bad;
 821                 np->b_cont = mp;
 822                 mp->b_rptr += hlen;
 823                 mp = np;
 824                 dp = mp->b_wptr;
 825                 mp->b_wptr += PPP_HDRLEN;
 826             } else
 827                 mp->b_rptr = dp;
 828
 829             dp[0] = PPP_ALLSTATIONS;
 830             dp[1] = PPP_UI;
 831             dp[2] = proto >> 8;
 832             dp[3] = proto;
 833         }
 834
 835         /*
 836          * Now see if we have a compressed packet to decompress,
 837          * or a CCP packet to take notice of.
 838          */
 839         proto = PPP_PROTOCOL(mp->b_rptr);
 840         if (proto == PPP_CCP) {
 841             len = msgdsize(mp);
 842             if (mp->b_wptr < mp->b_rptr + len) {
 843                 PULLUP(mp, len);
 844                 if (mp == 0)
 845                     goto bad;
 846             }
 847             ppp_comp_ccp(q, mp, 1);
 848         } else if (proto == PPP_COMP) {
 849             if ((cp->flags & CCP_ISUP)
 850                 && (cp->flags & CCP_DECOMP_RUN) && cp->rstate
 851                 && (cp->flags & CCP_ERR) == 0) {
 852                 rv = (*cp->rcomp->decompress)(cp->rstate, mp, &dmp);
 853                 switch (rv) {
 854                 case DECOMP_OK:
 855                     freemsg(mp);
 856                     mp = dmp;
 857                     if (mp == NULL) {
 858                         /* no error, but no packet returned either. */
 859                         continue;
 860                     }
 861                     break;
 862                 case DECOMP_ERROR:
 863                     cp->flags |= CCP_ERROR;
 864                     ++cp->stats.ppp_ierrors;
 865                     putctl1(q->q_next, M_CTL, PPPCTL_IERROR);
 866                     break;
 867                 case DECOMP_FATALERROR:
 868                     cp->flags |= CCP_FATALERROR;
 869                     ++cp->stats.ppp_ierrors;
 870                     putctl1(q->q_next, M_CTL, PPPCTL_IERROR);
 871                     break;
 872                 }
 873             }
 874         } else if (cp->rstate && (cp->flags & CCP_DECOMP_RUN)) {
 875             (*cp->rcomp->incomp)(cp->rstate, mp);
 876         }
 877
 878         /*
 879          * Now do VJ decompression.
 880          */
 881         proto = PPP_PROTOCOL(mp->b_rptr);
 882         if (proto == PPP_VJC_COMP || proto == PPP_VJC_UNCOMP) {
 883             len = msgdsize(mp) - PPP_HDRLEN;
 884             if ((cp->flags & DECOMP_VJC) == 0 || len <= 0)
 885                 goto bad;
 886
 887             /*
 888              * Advance past the ppp header.
 889              * Here we assume that the whole PPP header is in the first mblk.
 890              */
 891             np = mp;
 892             dp = np->b_rptr + PPP_HDRLEN;
 893             if (dp >= mp->b_wptr) {
 894                 np = np->b_cont;
 895                 dp = np->b_rptr;
 896             }
 897
 898             /*
 899              * Make sure we have sufficient contiguous data at this point.
 900              */
 901             hlen = (proto == PPP_VJC_COMP)? MAX_VJHDR: MAX_IPHDR;
 902             if (hlen > len)
 903                 hlen = len;
 904             if (np->b_wptr < dp + hlen || np->b_datap->db_ref > 1) {
 905                 PULLUP(mp, hlen + PPP_HDRLEN);
 906                 if (mp == 0)
 907                     goto bad;
 908                 np = mp;
 909                 dp = np->b_rptr + PPP_HDRLEN;
 910             }
 911
 912             if (proto == PPP_VJC_COMP) {
 913                 /*
 914                  * Decompress VJ-compressed packet.
 915                  * First reset compressor if an input error has occurred.
 916                  */
 917                 if (cp->stats.ppp_ierrors != cp->vj_last_ierrors) {
 918                     if (cp->flags & DBGLOG)
 919                         DPRINT1("ppp%d: resetting VJ\n", cp->unit);
 920                     vj_uncompress_err(&cp->vj_comp);
 921                     cp->vj_last_ierrors = cp->stats.ppp_ierrors;
 922                 }
 923
 924                 vjlen = vj_uncompress_tcp(dp, np->b_wptr - dp, len,
 925                                           &cp->vj_comp, &iphdr, &iphlen);
 926                 if (vjlen < 0) {
 927                     if (cp->flags & DBGLOG)
 928                         DPRINT2("ppp%d: vj_uncomp_tcp failed, pkt len %d\n",
 929                                 cp->unit, len);
 930                     ++cp->vj_last_ierrors;  /* so we don't reset next time */
 931                     goto bad;
 932                 }
 933
 934                 /* drop ppp and vj headers off */
 935                 if (mp != np) {
 936                     freeb(mp);
 937                     mp = np;
 938                 }
 939                 mp->b_rptr = dp + vjlen;
 940
 941                 /* allocate a new mblk for the ppp and ip headers */
 942                 if ((np = allocb(iphlen + PPP_HDRLEN + 4, BPRI_MED)) == 0)
 943                     goto bad;
 944                 dp = np->b_rptr;        /* prepend mblk with TCP/IP hdr */
 945                 dp[0] = PPP_ALLSTATIONS; /* reconstruct PPP header */
 946                 dp[1] = PPP_UI;
 947                 dp[2] = PPP_IP >> 8;
 948                 dp[3] = PPP_IP;
 949                 bcopy((caddr_t)iphdr, (caddr_t)dp + PPP_HDRLEN, iphlen);
 950                 np->b_wptr = dp + iphlen + PPP_HDRLEN;
 951                 np->b_cont = mp;
 952
 953                 /* XXX there seems to be a bug which causes panics in strread
 954                    if we make an mbuf with only the IP header in it :-( */
 955                 if (mp->b_wptr - mp->b_rptr > 4) {
 956                     bcopy((caddr_t)mp->b_rptr, (caddr_t)np->b_wptr, 4);
 957                     mp->b_rptr += 4;
 958                     np->b_wptr += 4;
 959                 } else {
 960                     bcopy((caddr_t)mp->b_rptr, (caddr_t)np->b_wptr,
 961                           mp->b_wptr - mp->b_rptr);
 962                     np->b_wptr += mp->b_wptr - mp->b_rptr;
 963                     np->b_cont = mp->b_cont;
 964                     freeb(mp);
 965                 }
 966
 967                 mp = np;
 968
 969             } else {
 970                 /*
 971                  * "Decompress" a VJ-uncompressed packet.
 972                  */
 973                 cp->vj_last_ierrors = cp->stats.ppp_ierrors;
 974                 if (!vj_uncompress_uncomp(dp, hlen, &cp->vj_comp)) {
 975                     if (cp->flags & DBGLOG)
 976                         DPRINT2("ppp%d: vj_uncomp_uncomp failed, pkt len %d\n",
 977                                 cp->unit, len);
 978                     ++cp->vj_last_ierrors;  /* don't need to reset next time */
 979                     goto bad;
 980                 }
 981                 mp->b_rptr[3] = PPP_IP; /* fix up the PPP protocol field */
 982             }
 983         }
 984
 985         putnext(q, mp);
 986         continue;
 987
 988     bad:
 989         if (mp != 0)
 990             freemsg(mp);
 991         cp->stats.ppp_ierrors++;
 992         putctl1(q->q_next, M_CTL, PPPCTL_IERROR);
 993     }
 994 }
 995
 996 /*
 997  * Handle a CCP packet being sent or received.
 998  * Here all the data in the packet is in a single mbuf.
 999  */
1000 static void
1001 ppp_comp_ccp(q, mp, rcvd)
1002     queue_t *q;
1003     mblk_t *mp;
1004     int rcvd;
1005 {
1006     int len, clen;
1007     comp_state_t *cp;
1008     unsigned char *dp;
1009
1010     len = msgdsize(mp);
1011     if (len < PPP_HDRLEN + CCP_HDRLEN)
1012         return;
1013
1014     cp = (comp_state_t *) q->q_ptr;
1015     dp = mp->b_rptr + PPP_HDRLEN;
1016     len -= PPP_HDRLEN;
1017     clen = CCP_LENGTH(dp);
1018     if (clen > len)
1019         return;
1020
1021     switch (CCP_CODE(dp)) {
1022     case CCP_CONFREQ:
1023     case CCP_TERMREQ:
1024     case CCP_TERMACK:
1025         cp->flags &= ~CCP_ISUP;
1026         break;
1027
1028     case CCP_CONFACK:
1029         if ((cp->flags & (CCP_ISOPEN | CCP_ISUP)) == CCP_ISOPEN
1030             && clen >= CCP_HDRLEN + CCP_OPT_MINLEN
1031             && clen >= CCP_HDRLEN + CCP_OPT_LENGTH(dp + CCP_HDRLEN)) {
1032             if (!rcvd) {
1033                 if (cp->xstate != NULL
1034                     && (*cp->xcomp->comp_init)
1035                         (cp->xstate, dp + CCP_HDRLEN, clen - CCP_HDRLEN,
1036                          cp->unit, 0, ((cp->flags & DBGLOG) != 0)))
1037                     cp->flags |= CCP_COMP_RUN;
1038             } else {
1039                 if (cp->rstate != NULL
1040                     && (*cp->rcomp->decomp_init)
1041                         (cp->rstate, dp + CCP_HDRLEN, clen - CCP_HDRLEN,
1042                          cp->unit, 0, cp->mru, ((cp->flags & DBGLOG) != 0)))
1043                     cp->flags = (cp->flags & ~CCP_ERR) | CCP_DECOMP_RUN;
1044             }
1045         }
1046         break;
1047
1048     case CCP_RESETACK:
1049         if (cp->flags & CCP_ISUP) {
1050             if (!rcvd) {
1051                 if (cp->xstate && (cp->flags & CCP_COMP_RUN))
1052                     (*cp->xcomp->comp_reset)(cp->xstate);
1053             } else {
1054                 if (cp->rstate && (cp->flags & CCP_DECOMP_RUN)) {
1055                     (*cp->rcomp->decomp_reset)(cp->rstate);
1056                     cp->flags &= ~CCP_ERROR;
1057                 }
1058             }
1059         }
1060         break;
1061     }
1062 }
1063
1064 #if 0
1065 dump_msg(mp)
1066     mblk_t *mp;
1067 {
1068     dblk_t *db;
1069
1070     while (mp != 0) {
1071         db = mp->b_datap;
1072         DPRINT2("mp=%x cont=%x ", mp, mp->b_cont);
1073         DPRINT3("rptr=%x wptr=%x datap=%x\n", mp->b_rptr, mp->b_wptr, db);
1074         DPRINT2("  base=%x lim=%x", db->db_base, db->db_lim);
1075         DPRINT2(" ref=%d type=%d\n", db->db_ref, db->db_type);
1076         mp = mp->b_cont;
1077     }
1078 }
1079 #endif
1080
1081 static int
1082 msg_byte(mp, i)
1083     mblk_t *mp;
1084     unsigned int i;
1085 {
1086     while (mp != 0 && i >= mp->b_wptr - mp->b_rptr)
1087         mp = mp->b_cont;
1088     if (mp == 0)
1089         return -1;
1090     return mp->b_rptr[i];
1091 }