solaris/ppp_ahdlc.c

   1 /*
   2  * ppp_ahdlc.c - STREAMS module for doing PPP asynchronous HDLC.
   3  *
   4  * Re-written by Adi Masputra <adi.masputra@sun.com>, based on
   5  * the original ppp_ahdlc.c
   6  *
   7  * Copyright (c) 2000 by Sun Microsystems, Inc.
   8  * All rights reserved.
   9  *
  10  * Permission to use, copy, modify, and distribute this software and its
  11  * documentation is hereby granted, provided that the above copyright
  12  * notice appears in all copies.
  13  *
  14  * SUN MAKES NO REPRESENTATION OR WARRANTIES ABOUT THE SUITABILITY OF
  15  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  16  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  17  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT.  SUN SHALL NOT BE LIABLE FOR
  18  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  19  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES
  20  *
  21  * Copyright (c) 1994 The Australian National University.
  22  * All rights reserved.
  23  *
  24  * Permission to use, copy, modify, and distribute this software and its
  25  * documentation is hereby granted, provided that the above copyright
  26  * notice appears in all copies.  This software is provided without any
  27  * warranty, express or implied. The Australian National University
  28  * makes no representations about the suitability of this software for
  29  * any purpose.
  30  *
  31  * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
  32  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  33  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
  34  * THE AUSTRALIAN NATIONAL UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY
  35  * OF SUCH DAMAGE.
  36  *
  37  * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  38  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  39  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  40  * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
  41  * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
  42  * OR MODIFICATIONS.
  43  *
  44  * $Id: ppp_ahdlc.c,v 1.1 2000/04/18 23:51:28 masputra Exp $
  45  */
  46
  47 /*
  48  * This file is used under Solaris 2, SVR4, SunOS 4, and Digital UNIX.
  49  */
  50 #include <sys/types.h>
  51 #include <sys/param.h>
  52 #include <sys/stream.h>
  53 #include <sys/errno.h>
  54
  55 #ifdef SVR4
  56 #include <sys/conf.h>
  57 #include <sys/kmem.h>
  58 #include <sys/cmn_err.h>
  59 #include <sys/ddi.h>
  60 #else
  61 #include <sys/user.h>
  62 #ifdef __osf__
  63 #include <sys/cmn_err.h>
  64 #endif
  65 #endif /* SVR4 */
  66
  67 #include <net/ppp_defs.h>
  68 #include <net/pppio.h>
  69 #include "ppp_mod.h"
  70
  71 /*
  72  * Right now, mutex is only enabled for Solaris 2.x
  73  */
  74 #if defined(SOL2)
  75 #define USE_MUTEX
  76 #endif /* SOL2 */
  77
  78 /*
  79  * intpointer_t and uintpointer_t are signed and unsigned integer types
  80  * large enough to hold any data pointer; that is, data pointers can be
  81  * assigned into or from these integer types without losing precision.
  82  * On recent Solaris releases, these types are defined in sys/int_types.h,
  83  * but not on SunOS 4.x or the earlier Solaris versions.
  84  */
  85 #if defined(_LP64) || defined(_I32LPx)
  86 typedef long                    intpointer_t;
  87 typedef unsigned long           uintpointer_t;
  88 #else
  89 typedef int                     intpointer_t;
  90 typedef unsigned int            uintpointer_t;
  91 #endif
  92
  93 MOD_OPEN_DECL(ahdlc_open);
  94 MOD_CLOSE_DECL(ahdlc_close);
  95 static int ahdlc_wput __P((queue_t *, mblk_t *));
  96 static int ahdlc_rput __P((queue_t *, mblk_t *));
  97 static void ahdlc_encode __P((queue_t *, mblk_t *));
  98 static void ahdlc_decode __P((queue_t *, mblk_t *));
  99 static int msg_byte __P((mblk_t *, unsigned int));
 100
 101 #if defined(SOL2)
 102 /*
 103  * Don't send HDLC start flag is last transmit is within 1.5 seconds -
 104  * FLAG_TIME is defined is microseconds
 105  */
 106 #define FLAG_TIME   1500
 107 #define ABS(x)      (x >= 0 ? x : (-x))
 108 #endif /* SOL2 */
 109
 110 /*
 111  * Extract byte i of message mp
 112  */
 113 #define MSG_BYTE(mp, i) ((i) < (mp)->b_wptr - (mp)->b_rptr? (mp)->b_rptr[i]: \
 114                          msg_byte((mp), (i)))
 115
 116 /*
 117  * Is this LCP packet one we have to transmit using LCP defaults?
 118  */
 119 #define LCP_USE_DFLT(mp)        (1 <= (code = MSG_BYTE((mp), 4)) && code <= 7)
 120
 121 /*
 122  * Standard STREAMS declarations
 123  */
 124 static struct module_info minfo = {
 125     0x7d23, "ppp_ahdl", 0, INFPSZ, 32768, 512
 126 };
 127
 128 static struct qinit rinit = {
 129     ahdlc_rput, NULL, ahdlc_open, ahdlc_close, NULL, &minfo, NULL
 130 };
 131
 132 static struct qinit winit = {
 133     ahdlc_wput, NULL, NULL, NULL, NULL, &minfo, NULL
 134 };
 135
 136 #if defined(SVR4) && !defined(SOL2)
 137 int phdldevflag = 0;
 138 #define ppp_ahdlcinfo phdlinfo
 139 #endif /* defined(SVR4) && !defined(SOL2) */
 140
 141 struct streamtab ppp_ahdlcinfo = {
 142     &rinit,                         /* ptr to st_rdinit */
 143     &winit,                         /* ptr to st_wrinit */
 144     NULL,                           /* ptr to st_muxrinit */
 145     NULL,                           /* ptr to st_muxwinit */
 146 #if defined(SUNOS4)
 147     NULL                            /* ptr to ptr to st_modlist */
 148 #endif /* SUNOS4 */
 149 };
 150
 151 #if defined(SUNOS4)
 152 int ppp_ahdlc_count = 0;            /* open counter */
 153 #endif /* SUNOS4 */
 154
 155 /*
 156  * Per-stream state structure
 157  */
 158 typedef struct ahdlc_state {
 159 #if defined(USE_MUTEX)
 160     kmutex_t        lock;                   /* lock for this structure */
 161 #endif /* USE_MUTEX */
 162     int             flags;                  /* link flags */
 163     mblk_t          *rx_buf;                /* ptr to receive buffer */
 164     int             rx_buf_size;            /* receive buffer size */
 165     ushort_t        infcs;                  /* calculated rx HDLC FCS */
 166     u_int32_t       xaccm[8];               /* 256-bit xmit ACCM */
 167     u_int32_t       raccm;                  /* 32-bit rcv ACCM */
 168     int             mtu;                    /* interface MTU */
 169     int             mru;                    /* link MRU */
 170     int             unit;                   /* current PPP unit number */
 171     struct pppstat  stats;                  /* statistic structure */
 172 #if defined(SOL2)
 173     clock_t         flag_time;              /* time in usec between flags */
 174     clock_t         lbolt;                  /* last updated lbolt */
 175 #endif /* SOL2 */
 176 } ahdlc_state_t;
 177
 178 /*
 179  * Values for flags
 180  */
 181 #define ESCAPED         0x100   /* last saw escape char on input */
 182 #define IFLUSH          0x200   /* flushing input due to error */
 183
 184 /*
 185  * RCV_B7_1, etc., defined in net/pppio.h, are stored in flags also.
 186  */
 187 #define RCV_FLAGS       (RCV_B7_1|RCV_B7_0|RCV_ODDP|RCV_EVNP)
 188
 189 /*
 190  * FCS lookup table as calculated by genfcstab.
 191  */
 192 static u_short fcstab[256] = {
 193         0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
 194         0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
 195         0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
 196         0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
 197         0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
 198         0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
 199         0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
 200         0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
 201         0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
 202         0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
 203         0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
 204         0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
 205         0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
 206         0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
 207         0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
 208         0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
 209         0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
 210         0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
 211         0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
 212         0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
 213         0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
 214         0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
 215         0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
 216         0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
 217         0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
 218         0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
 219         0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
 220         0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
 221         0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
 222         0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
 223         0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
 224         0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
 225 };
 226
 227 static u_int32_t paritytab[8] =
 228 {
 229         0x96696996, 0x69969669, 0x69969669, 0x96696996,
 230         0x69969669, 0x96696996, 0x96696996, 0x69969669
 231 };
 232
 233 /*
 234  * STREAMS module open (entry) point
 235  */
 236 MOD_OPEN(ahdlc_open)
 237 {
 238     ahdlc_state_t   *state;
 239
 240     /*
 241      * Return if it's already opened
 242      */
 243     if (q->q_ptr) {
 244         return 0;
 245     }
 246
 247     /*
 248      * This can only be opened as a module
 249      */
 250     if (sflag != MODOPEN) {
 251         return 0;
 252     }
 253
 254     state = (ahdlc_state_t *) ALLOC_NOSLEEP(sizeof(ahdlc_state_t));
 255     if (state == 0)
 256         OPEN_ERROR(ENOSR);
 257     bzero((caddr_t) state, sizeof(ahdlc_state_t));
 258
 259     q->q_ptr     = (caddr_t) state;
 260     WR(q)->q_ptr = (caddr_t) state;
 261
 262 #if defined(USE_MUTEX)
 263     mutex_init(&state->lock, NULL, MUTEX_DEFAULT, NULL);
 264     mutex_enter(&state->lock);
 265 #endif /* USE_MUTEX */
 266
 267     state->xaccm[0] = ~0;           /* escape 0x00 through 0x1f */
 268     state->xaccm[3] = 0x60000000;   /* escape 0x7d and 0x7e */
 269     state->mru      = PPP_MRU;      /* default of 1500 bytes */
 270 #if defined(SOL2)
 271     state->flag_time = drv_usectohz(FLAG_TIME);
 272 #endif /* SOL2 */
 273
 274 #if defined(USE_MUTEX)
 275     mutex_exit(&state->lock);
 276 #endif /* USE_MUTEX */
 277
 278 #if defined(SUNOS4)
 279     ppp_ahdlc_count++;
 280 #endif /* SUNOS4 */
 281
 282     qprocson(q);
 283
 284     return 0;
 285 }
 286
 287 /*
 288  * STREAMS module close (exit) point
 289  */
 290 MOD_CLOSE(ahdlc_close)
 291 {
 292     ahdlc_state_t   *state;
 293
 294     qprocsoff(q);
 295
 296     state = (ahdlc_state_t *) q->q_ptr;
 297
 298     if (state == 0) {
 299         DPRINT("state == 0 in ahdlc_close\n");
 300         return 0;
 301     }
 302
 303 #if defined(USE_MUTEX)
 304     mutex_enter(&state->lock);
 305 #endif /* USE_MUTEX */
 306
 307     if (state->rx_buf != 0) {
 308         freemsg(state->rx_buf);
 309         state->rx_buf = 0;
 310     }
 311
 312 #if defined(USE_MUTEX)
 313     mutex_exit(&state->lock);
 314     mutex_destroy(&state->lock);
 315 #endif /* USE_MUTEX */
 316
 317     FREE(q->q_ptr, sizeof(ahdlc_state_t));
 318     q->q_ptr         = NULL;
 319     OTHERQ(q)->q_ptr = NULL;
 320
 321 #if defined(SUNOS4)
 322     if (ppp_ahdlc_count)
 323         ppp_ahdlc_count--;
 324 #endif /* SUNOS4 */
 325
 326     return 0;
 327 }
 328
 329 /*
 330  * Write side put routine
 331  */
 332 static int
 333 ahdlc_wput(q, mp)
 334     queue_t     *q;
 335     mblk_t      *mp;
 336 {
 337     ahdlc_state_t       *state;
 338     struct iocblk       *iop;
 339     int                 error;
 340     mblk_t              *np;
 341     struct ppp_stats    *psp;
 342
 343     state = (ahdlc_state_t *) q->q_ptr;
 344     if (state == 0) {
 345         DPRINT("state == 0 in ahdlc_wput\n");
 346         freemsg(mp);
 347         return 0;
 348     }
 349
 350     switch (mp->b_datap->db_type) {
 351     case M_DATA:
 352         /*
 353          * A data packet - do character-stuffing and FCS, and
 354          * send it onwards.
 355          */
 356         ahdlc_encode(q, mp);
 357         freemsg(mp);
 358         break;
 359
 360     case M_IOCTL:
 361         iop = (struct iocblk *) mp->b_rptr;
 362         error = EINVAL;
 363         switch (iop->ioc_cmd) {
 364         case PPPIO_XACCM:
 365             if ((iop->ioc_count < sizeof(u_int32_t)) ||
 366                 (iop->ioc_count > sizeof(ext_accm))) {
 367                 break;
 368             }
 369             if (mp->b_cont == 0) {
 370                 DPRINT1("ahdlc_wput/%d: PPPIO_XACCM b_cont = 0!\n", state->unit);
 371                 break;
 372             }
 373 #if defined(USE_MUTEX)
 374             mutex_enter(&state->lock);
 375 #endif /* USE_MUTEX */
 376             bcopy((caddr_t)mp->b_cont->b_rptr, (caddr_t)state->xaccm,
 377                   iop->ioc_count);
 378             state->xaccm[2] &= ~0x40000000;     /* don't escape 0x5e */
 379             state->xaccm[3] |= 0x60000000;      /* do escape 0x7d, 0x7e */
 380 #if defined(USE_MUTEX)
 381             mutex_exit(&state->lock);
 382 #endif /* USE_MUTEX */
 383             iop->ioc_count = 0;
 384             error = 0;
 385             break;
 386
 387         case PPPIO_RACCM:
 388             if (iop->ioc_count != sizeof(u_int32_t))
 389                 break;
 390             if (mp->b_cont == 0) {
 391                 DPRINT1("ahdlc_wput/%d: PPPIO_RACCM b_cont = 0!\n", state->unit);
 392                 break;
 393             }
 394 #if defined(USE_MUTEX)
 395             mutex_enter(&state->lock);
 396 #endif /* USE_MUTEX */
 397             bcopy((caddr_t)mp->b_cont->b_rptr, (caddr_t)&state->raccm,
 398                   sizeof(u_int32_t));
 399 #if defined(USE_MUTEX)
 400             mutex_exit(&state->lock);
 401 #endif /* USE_MUTEX */
 402             iop->ioc_count = 0;
 403             error = 0;
 404             break;
 405
 406         case PPPIO_GCLEAN:
 407             np = allocb(sizeof(int), BPRI_HI);
 408             if (np == 0) {
 409                 error = ENOSR;
 410                 break;
 411             }
 412             if (mp->b_cont != 0)
 413                 freemsg(mp->b_cont);
 414             mp->b_cont = np;
 415 #if defined(USE_MUTEX)
 416             mutex_enter(&state->lock);
 417 #endif /* USE_MUTEX */
 418             *(int *)np->b_wptr = state->flags & RCV_FLAGS;
 419 #if defined(USE_MUTEX)
 420             mutex_exit(&state->lock);
 421 #endif /* USE_MUTEX */
 422             np->b_wptr += sizeof(int);
 423             iop->ioc_count = sizeof(int);
 424             error = 0;
 425             break;
 426
 427         case PPPIO_GETSTAT:
 428             np = allocb(sizeof(struct ppp_stats), BPRI_HI);
 429             if (np == 0) {
 430                 error = ENOSR;
 431                 break;
 432             }
 433             if (mp->b_cont != 0)
 434                 freemsg(mp->b_cont);
 435             mp->b_cont = np;
 436             psp = (struct ppp_stats *) np->b_wptr;
 437             np->b_wptr += sizeof(struct ppp_stats);
 438             bzero((caddr_t)psp, sizeof(struct ppp_stats));
 439             psp->p = state->stats;
 440             iop->ioc_count = sizeof(struct ppp_stats);
 441             error = 0;
 442             break;
 443
 444         case PPPIO_LASTMOD:
 445             /* we knew this anyway */
 446             error = 0;
 447             break;
 448
 449         default:
 450             error = -1;
 451             break;
 452         }
 453
 454         if (error < 0)
 455             putnext(q, mp);
 456         else if (error == 0) {
 457             mp->b_datap->db_type = M_IOCACK;
 458             qreply(q, mp);
 459         } else {
 460             mp->b_datap->db_type = M_IOCNAK;
 461             iop->ioc_count = 0;
 462             iop->ioc_error = error;
 463             qreply(q, mp);
 464         }
 465         break;
 466
 467     case M_CTL:
 468         switch (*mp->b_rptr) {
 469         case PPPCTL_MTU:
 470 #if defined(USE_MUTEX)
 471             mutex_enter(&state->lock);
 472 #endif /* USE_MUTEX */
 473             state->mtu = ((unsigned short *)mp->b_rptr)[1];
 474 #if defined(USE_MUTEX)
 475             mutex_exit(&state->lock);
 476 #endif /* USE_MUTEX */
 477             freemsg(mp);
 478             break;
 479         case PPPCTL_MRU:
 480 #if defined(USE_MUTEX)
 481             mutex_enter(&state->lock);
 482 #endif /* USE_MUTEX */
 483             state->mru = ((unsigned short *)mp->b_rptr)[1];
 484 #if defined(USE_MUTEX)
 485             mutex_exit(&state->lock);
 486 #endif /* USE_MUTEX */
 487             freemsg(mp);
 488             break;
 489         case PPPCTL_UNIT:
 490 #if defined(USE_MUTEX)
 491             mutex_enter(&state->lock);
 492 #endif /* USE_MUTEX */
 493             state->unit = mp->b_rptr[1];
 494 #if defined(USE_MUTEX)
 495             mutex_exit(&state->lock);
 496 #endif /* USE_MUTEX */
 497             break;
 498         default:
 499             putnext(q, mp);
 500         }
 501         break;
 502
 503     default:
 504         putnext(q, mp);
 505     }
 506
 507     return 0;
 508 }
 509
 510 /*
 511  * Read side put routine
 512  */
 513 static int
 514 ahdlc_rput(q, mp)
 515     queue_t *q;
 516     mblk_t  *mp;
 517 {
 518     ahdlc_state_t *state;
 519
 520     state = (ahdlc_state_t *) q->q_ptr;
 521     if (state == 0) {
 522         DPRINT("state == 0 in ahdlc_rput\n");
 523         freemsg(mp);
 524         return 0;
 525     }
 526
 527     switch (mp->b_datap->db_type) {
 528     case M_DATA:
 529         ahdlc_decode(q, mp);
 530         freemsg(mp);
 531         break;
 532
 533     case M_HANGUP:
 534 #if defined(USE_MUTEX)
 535         mutex_enter(&state->lock);
 536 #endif /* USE_MUTEX */
 537         if (state->rx_buf != 0) {
 538             /* XXX would like to send this up for debugging */
 539             freemsg(state->rx_buf);
 540             state->rx_buf = 0;
 541         }
 542         state->flags = IFLUSH;
 543 #if defined(USE_MUTEX)
 544         mutex_exit(&state->lock);
 545 #endif /* USE_MUTEX */
 546         putnext(q, mp);
 547         break;
 548
 549     default:
 550         putnext(q, mp);
 551     }
 552     return 0;
 553 }
 554
 555 /*
 556  * Extract bit c from map m, to determine if c needs to be escaped
 557  */
 558 #define IN_TX_MAP(c, m) ((m)[(c) >> 5] & (1 << ((c) & 0x1f)))
 559
 560 static void
 561 ahdlc_encode(q, mp)
 562     queue_t     *q;
 563     mblk_t      *mp;
 564 {
 565     ahdlc_state_t       *state;
 566     u_int32_t           *xaccm, loc_xaccm[8];
 567     ushort_t            fcs;
 568     size_t              outmp_len;
 569     mblk_t              *outmp, *tmp;
 570     uchar_t             *dp, fcs_val;
 571     int                 is_lcp, code;
 572 #if defined(SOL2)
 573     clock_t             lbolt;
 574 #endif /* SOL2 */
 575
 576     if (msgdsize(mp) < 4) {
 577         return;
 578     }
 579
 580     state = (ahdlc_state_t *)q->q_ptr;
 581 #if defined(USE_MUTEX)
 582     mutex_enter(&state->lock);
 583 #endif /* USE_MUTEX */
 584
 585     /*
 586      * Allocate an output buffer large enough to handle a case where all
 587      * characters need to be escaped
 588      */
 589     outmp_len = (msgdsize(mp)    << 1) +                /* input block x 2 */
 590                 (sizeof(fcs)     << 2) +                /* HDLC FCS x 4 */
 591                 (sizeof(uchar_t) << 1);                 /* HDLC flags x 2 */
 592
 593     outmp = allocb(outmp_len, BPRI_MED);
 594     if (outmp == NULL) {
 595         state->stats.ppp_oerrors++;
 596 #if defined(USE_MUTEX)
 597         mutex_exit(&state->lock);
 598 #endif /* USE_MUTEX */
 599         putctl1(RD(q)->q_next, M_CTL, PPPCTL_OERROR);
 600         return;
 601     }
 602
 603 #if defined(SOL2)
 604     /*
 605      * Check if our last transmit happenned within flag_time, using
 606      * the system's LBOLT value in clock ticks
 607      */
 608     if (drv_getparm(LBOLT, &lbolt) != -1) {
 609         if (ABS((clock_t)lbolt - state->lbolt) > state->flag_time) {
 610             *outmp->b_wptr++ = PPP_FLAG;
 611         }
 612         state->lbolt = lbolt;
 613     } else {
 614         *outmp->b_wptr++ = PPP_FLAG;
 615     }
 616 #else
 617     /*
 618      * If the driver below still has a message to process, skip the
 619      * HDLC flag, otherwise, put one in the beginning
 620      */
 621     if (qsize(q->q_next) == 0) {
 622         *outmp->b_wptr++ = PPP_FLAG;
 623     }
 624 #endif
 625
 626     /*
 627      * All control characters must be escaped for LCP packets with code
 628      * values between 1 (Conf-Req) and 7 (Code-Rej).
 629      */
 630     is_lcp = ((MSG_BYTE(mp, 0) == PPP_ALLSTATIONS) &&
 631               (MSG_BYTE(mp, 1) == PPP_UI) &&
 632               (MSG_BYTE(mp, 2) == (PPP_LCP >> 8)) &&
 633               (MSG_BYTE(mp, 3) == (PPP_LCP & 0xff)) &&
 634               LCP_USE_DFLT(mp));
 635
 636     xaccm = state->xaccm;
 637     if (is_lcp) {
 638         bcopy((caddr_t)state->xaccm, (caddr_t)loc_xaccm, sizeof(loc_xaccm));
 639         loc_xaccm[0] = ~0;      /* force escape on 0x00 through 0x1f */
 640         xaccm = loc_xaccm;
 641     }
 642
 643     fcs = PPP_INITFCS;          /* Initial FCS is 0xffff */
 644
 645     /*
 646      * Process this block and the rest (if any) attached to the this one
 647      */
 648     for (tmp = mp; tmp; tmp = tmp->b_cont) {
 649         if (tmp->b_datap->db_type == M_DATA) {
 650             for (dp = tmp->b_rptr; dp < tmp->b_wptr; dp++) {
 651                 fcs = PPP_FCS(fcs, *dp);
 652                 if (IN_TX_MAP(*dp, xaccm)) {
 653                     *outmp->b_wptr++ = PPP_ESCAPE;
 654                     *outmp->b_wptr++ = *dp ^ PPP_TRANS;
 655                 } else {
 656                     *outmp->b_wptr++ = *dp;
 657                 }
 658             }
 659         } else {
 660             continue;   /* skip if db_type is something other than M_DATA */
 661         }
 662     }
 663
 664     /*
 665      * Append the HDLC FCS, making sure that escaping is done on any
 666      * necessary bytes
 667      */
 668     fcs_val = (fcs ^ 0xffff) & 0xff;
 669     if (IN_TX_MAP(fcs_val, xaccm)) {
 670         *outmp->b_wptr++ = PPP_ESCAPE;
 671         *outmp->b_wptr++ = fcs_val ^ PPP_TRANS;
 672     } else {
 673         *outmp->b_wptr++ = fcs_val;
 674     }
 675
 676     fcs_val = ((fcs ^ 0xffff) >> 8) & 0xff;
 677     if (IN_TX_MAP(fcs_val, xaccm)) {
 678         *outmp->b_wptr++ = PPP_ESCAPE;
 679         *outmp->b_wptr++ = fcs_val ^ PPP_TRANS;
 680     } else {
 681         *outmp->b_wptr++ = fcs_val;
 682     }
 683
 684     /*
 685      * And finally, append the HDLC flag, and send it away
 686      */
 687     *outmp->b_wptr++ = PPP_FLAG;
 688
 689     state->stats.ppp_obytes += msgdsize(outmp);
 690     state->stats.ppp_opackets++;
 691
 692 #if defined(USE_MUTEX)
 693     mutex_exit(&state->lock);
 694 #endif /* USE_MUTEX */
 695
 696     putnext(q, outmp);
 697     return;
 698 }
 699
 700 /*
 701  * Checks the 32-bit receive ACCM to see if the byte needs un-escaping
 702  */
 703 #define IN_RX_MAP(c, m) ((((unsigned int) (uchar_t) (c)) < 0x20) && \
 704                         (m) & (1 << (c)))
 705
 706
 707 /*
 708  * Process received characters.
 709  */
 710 static void
 711 ahdlc_decode(q, mp)
 712     queue_t *q;
 713     mblk_t  *mp;
 714 {
 715     ahdlc_state_t   *state;
 716     mblk_t          *om;
 717     uchar_t         *dp;
 718     ushort_t        fcs;
 719 #if defined(SOL2)
 720     mblk_t          *zmp;
 721 #endif /* SOL2 */
 722
 723 #if defined(SOL2)
 724     /*
 725      * In case the driver (or something below) doesn't send
 726      * data upstream in one message block, concatenate everything
 727      */
 728     if (!((mp->b_wptr - mp->b_rptr == msgdsize(mp)) &&
 729          ((intpointer_t)mp->b_rptr % sizeof(intpointer_t) == 0))) {
 730
 731         zmp = msgpullup(mp, -1);
 732         freemsg(mp);
 733         mp = zmp;
 734         if (mp == 0)
 735             return;
 736     }
 737 #endif /* SOL2 */
 738
 739     state = (ahdlc_state_t *) q->q_ptr;
 740
 741 #if defined(USE_MUTEX)
 742     mutex_enter(&state->lock);
 743 #endif /* USE_MUTEX */
 744
 745     state->stats.ppp_ibytes += msgdsize(mp);
 746
 747     for (dp = mp->b_rptr; dp < mp->b_wptr; dp++) {
 748
 749         /*
 750          * This should detect the lack of 8-bit communication channel
 751          * which is necessary for PPP to work. In addition, it also
 752          * checks on the parity.
 753          */
 754         if (*dp & 0x80)
 755             state->flags |= RCV_B7_1;
 756         else
 757             state->flags |= RCV_B7_0;
 758
 759         if (paritytab[*dp >> 5] & (1 << (*dp & 0x1f)))
 760             state->flags |= RCV_ODDP;
 761         else
 762             state->flags |= RCV_EVNP;
 763
 764         /*
 765          * So we have a HDLC flag ...
 766          */
 767         if (*dp == PPP_FLAG) {
 768
 769             /*
 770              * If we think that it marks the beginning of the frame,
 771              * then continue to process the next octects
 772              */
 773             if ((state->flags & IFLUSH) ||
 774                 (state->rx_buf == 0) ||
 775                 (msgdsize(state->rx_buf) == 0)) {
 776
 777                 state->flags &= ~IFLUSH;
 778                 continue;
 779             }
 780
 781             /*
 782              * We get here because the above condition isn't true,
 783              * in which case the HDLC flag was there to mark the end
 784              * of the frame (or so we think)
 785              */
 786             om = state->rx_buf;
 787
 788             if (state->infcs == PPP_GOODFCS) {
 789                 state->stats.ppp_ipackets++;
 790                 adjmsg(om, -PPP_FCSLEN);
 791                 putnext(q, om);
 792             } else {
 793                 DPRINT2("ppp%d: bad fcs (len=%d)\n",
 794                     state->unit, msgdsize(state->rx_buf));
 795                 freemsg(state->rx_buf);
 796                 state->flags &= ~(IFLUSH | ESCAPED);
 797                 state->stats.ppp_ierrors++;
 798                 putctl1(q->q_next, M_CTL, PPPCTL_IERROR);
 799             }
 800
 801             state->rx_buf = 0;
 802             continue;
 803         }
 804
 805         if (state->flags & IFLUSH) {
 806             continue;
 807         }
 808
 809         /*
 810          * Allocate a receive buffer, large enough to store a frame (after
 811          * un-escaping) of at least 1500 octets. If MRU is negotiated to
 812          * be more than the default, then allocate that much. In addition,
 813          * we add an extra 32-bytes for a fudge factor
 814          */
 815         if (state->rx_buf == 0) {
 816             state->rx_buf_size  = (state->mru < PPP_MRU ? PPP_MRU : state->mru);
 817             state->rx_buf_size += (sizeof(u_int32_t) << 3);
 818             state->rx_buf = allocb(state->rx_buf_size, BPRI_MED);
 819
 820             /*
 821              * If allocation fails, try again on the next frame
 822              */
 823             if (state->rx_buf == 0) {
 824                 state->flags |= IFLUSH;
 825                 continue;
 826             }
 827             state->flags &= ~(IFLUSH | ESCAPED);
 828             state->infcs  = PPP_INITFCS;
 829         }
 830
 831         if (*dp == PPP_ESCAPE) {
 832             state->flags |= ESCAPED;
 833             continue;
 834         }
 835
 836         /*
 837          * Make sure we un-escape the necessary characters, as well as the
 838          * ones in our receive async control character map
 839          */
 840         if (state->flags & ESCAPED) {
 841             *dp ^= PPP_TRANS;
 842             state->flags &= ~ESCAPED;
 843         } else if (IN_RX_MAP(*dp, state->raccm))
 844             continue;
 845
 846         /*
 847          * Unless the peer lied to us about the negotiated MRU, we should
 848          * never get a frame which is too long. If it happens, toss it away
 849          * and grab the next incoming one
 850          */
 851         if (msgdsize(state->rx_buf) < state->rx_buf_size) {
 852             state->infcs = PPP_FCS(state->infcs, *dp);
 853             *state->rx_buf->b_wptr++ = *dp;
 854         } else {
 855             DPRINT2("ppp%d: frame too long (%d)\n",
 856                 state->unit, msgdsize(state->rx_buf));
 857             freemsg(state->rx_buf);
 858             state->rx_buf     = 0;
 859             state->flags     |= IFLUSH;
 860         }
 861     }
 862
 863 #if defined(USE_MUTEX)
 864     mutex_exit(&state->lock);
 865 #endif /* USE_MUTEX */
 866 }
 867
 868 static int
 869 msg_byte(mp, i)
 870     mblk_t *mp;
 871     unsigned int i;
 872 {
 873     while (mp != 0 && i >= mp->b_wptr - mp->b_rptr)
 874         mp = mp->b_cont;
 875     if (mp == 0)
 876         return -1;
 877     return mp->b_rptr[i];
 878 }