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