mods for other SVR4 systems; don't use ddi_get_soft_state etc.;
[ppp.git] / svr4 / ppp.c
1 /*
2  * ppp.c - STREAMS multiplexing pseudo-device driver for PPP.
3  *
4  * Copyright (c) 1994 The Australian National University.
5  * All rights reserved.
6  *
7  * Permission to use, copy, modify, and distribute this software and its
8  * documentation is hereby granted, provided that the above copyright
9  * notice appears in all copies.  This software is provided without any
10  * warranty, express or implied. The Australian National University
11  * makes no representations about the suitability of this software for
12  * any purpose.
13  *
14  * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
15  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
16  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
17  * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY
18  * OF SUCH DAMAGE.
19  *
20  * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
21  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
22  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
23  * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
24  * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
25  * OR MODIFICATIONS.
26  *
27  * $Id: ppp.c,v 1.3 1995/05/29 06:59:36 paulus Exp $
28  */
29
30 /*
31  * This file is used under Solaris 2.
32  */
33
34 #include <sys/types.h>
35 #include <sys/param.h>
36 #include <sys/stat.h>
37 #include <sys/stream.h>
38 #include <sys/stropts.h>
39 #include <sys/errno.h>
40 #include <sys/cmn_err.h>
41 #include <sys/conf.h>
42 #include <sys/dlpi.h>
43 #include <sys/ioccom.h>
44 #include <sys/kmem.h>
45 #include <sys/ddi.h>
46 #ifdef sun
47 #include <sys/modctl.h>
48 #include <sys/kstat.h>
49 #include <sys/sunddi.h>
50 #endif
51 #include <net/ppp_defs.h>
52 #include <net/pppio.h>
53
54 #ifdef __STDC__
55 #define __P(x)  x
56 #else
57 #define __P(x)  ()
58 #endif
59
60 /*
61  * The IP module uses this SAP value for IP packets.
62  */
63 #ifndef ETHERTYPE_IP
64 #define ETHERTYPE_IP    0x800
65 #endif
66
67 #ifndef PPP_MAXMTU
68 #define PPP_MAXMTU      65535
69 #endif
70
71 /*
72  * Private information; one per upper stream.
73  */
74 typedef struct upperstr {
75     minor_t mn;                 /* minor device number */
76     struct upperstr *nextmn;    /* next minor device */
77     queue_t *q;                 /* read q associated with this upper stream */
78     int flags;                  /* flag bits, see below */
79     int state;                  /* current DLPI state */
80     int sap;                    /* service access point */
81     int req_sap;                /* which SAP the DLPI client requested */
82     struct upperstr *ppa;       /* control stream for our ppa */
83     struct upperstr *next;      /* next stream for this ppa */
84     /*
85      * There is exactly one control stream for each PPA.
86      * The following fields are only used for control streams.
87      */
88     int ppa_id;
89     queue_t *lowerq;            /* write queue attached below this PPA */
90     struct upperstr *nextppa;   /* next control stream */
91     int mru;
92     int mtu;
93     struct pppstat stats;       /* statistics */
94 #ifdef sun
95     kstat_t *kstats;            /* stats for netstat */
96 #endif
97 } upperstr_t;
98
99 /* Values for flags */
100 #define US_PRIV         1       /* stream was opened by superuser */
101 #define US_CONTROL      2       /* stream is a control stream */
102 #define US_BLOCKED      4       /* flow ctrl has blocked lower write stream */
103 #define US_LASTMOD      8       /* no PPP modules below us */
104
105 static upperstr_t *minor_devs = NULL;
106 static upperstr_t *ppas = NULL;
107
108 #ifdef sun
109 static int ppp_identify __P((dev_info_t *));
110 static int ppp_attach __P((dev_info_t *, ddi_attach_cmd_t));
111 static int ppp_detach __P((dev_info_t *, ddi_detach_cmd_t));
112 static int ppp_devinfo __P((dev_info_t *, ddi_info_cmd_t, void *, void **));
113 #endif
114 static int pppopen __P((queue_t *, dev_t *, int, int, cred_t *));
115 static int pppclose __P((queue_t *, int, cred_t *));
116 static int pppuwput __P((queue_t *, mblk_t *));
117 static int pppursrv __P((queue_t *));
118 static int pppuwsrv __P((queue_t *));
119 static int ppplrput __P((queue_t *, mblk_t *));
120 static int ppplwput __P((queue_t *, mblk_t *));
121 static int ppplrsrv __P((queue_t *));
122 static int ppplwsrv __P((queue_t *));
123 static void dlpi_request __P((queue_t *, mblk_t *, upperstr_t *));
124 static void dlpi_error __P((queue_t *, int, int, int));
125 static void dlpi_ok __P((queue_t *, int));
126 static int send_data __P((mblk_t *, upperstr_t *));
127 static void new_ppa __P((queue_t *, mblk_t *));
128 static void attach_ppa __P((queue_t *, mblk_t *));
129 static void detach_ppa __P((queue_t *, mblk_t *));
130 static upperstr_t *find_dest __P((upperstr_t *, int));
131 static int putctl2 __P((queue_t *, int, int, int));
132 static int putctl4 __P((queue_t *, int, int, int));
133
134 static struct module_info ppp_info = {
135     0xb1a6, "ppp", 0, 512, 512, 128
136 };
137
138 static struct qinit pppurint = {
139     NULL, pppursrv, pppopen, pppclose, NULL, &ppp_info, NULL
140 };
141
142 static struct qinit pppuwint = {
143     pppuwput, pppuwsrv, NULL, NULL, NULL, &ppp_info, NULL
144 };
145
146 static struct qinit ppplrint = {
147     ppplrput, ppplrsrv, NULL, NULL, NULL, &ppp_info, NULL
148 };
149
150 static struct qinit ppplwint = {
151     ppplwput, ppplwsrv, NULL, NULL, NULL, &ppp_info, NULL
152 };
153
154 static struct streamtab pppinfo = {
155     &pppurint, &pppuwint,
156     &ppplrint, &ppplwint
157 };
158
159 #ifdef sun
160 static dev_info_t *ppp_dip;
161
162 static struct cb_ops cb_ppp_ops = {
163     nulldev, nulldev, nodev, nodev,     /* cb_open, ... */
164     nodev, nodev, nodev, nodev,         /* cb_dump, ... */
165     nodev, nodev, nodev, nochpoll,      /* cb_devmap, ... */
166     ddi_prop_op,                        /* cb_prop_op */
167     &pppinfo,                           /* cb_stream */
168     D_NEW|D_MP|D_MTQPAIR|D_MTOUTPERIM|D_MTOCEXCL        /* cb_flag */
169 };
170
171 static struct dev_ops ppp_ops = {
172     DEVO_REV,                           /* devo_rev */
173     0,                                  /* devo_refcnt */
174     ppp_devinfo,                        /* devo_getinfo */
175     ppp_identify,                       /* devo_identify */
176     nulldev,                            /* devo_probe */
177     ppp_attach,                         /* devo_attach */
178     ppp_detach,                         /* devo_detach */
179     nodev,                              /* devo_reset */
180     &cb_ppp_ops,                        /* devo_cb_ops */
181     NULL                                /* devo_bus_ops */
182 };
183
184 /*
185  * Module linkage information
186  */
187
188 static struct modldrv modldrv = {
189     &mod_driverops,                     /* says this is a pseudo driver */
190     "PPP-2.2 multiplexing driver",
191     &ppp_ops                            /* driver ops */
192 };
193
194 static struct modlinkage modlinkage = {
195     MODREV_1,
196     (void *) &modldrv,
197     NULL
198 };
199
200 int
201 _init(void)
202 {
203     return mod_install(&modlinkage);
204 }
205
206 int
207 _fini(void)
208 {
209     return mod_remove(&modlinkage);
210 }
211
212 int
213 _info(mip)
214     struct modinfo *mip;
215 {
216     return mod_info(&modlinkage, mip);
217 }
218
219 static int
220 ppp_identify(dip)
221     dev_info_t *dip;
222 {
223     return strcmp(ddi_get_name(dip), "ppp") == 0? DDI_IDENTIFIED:
224         DDI_NOT_IDENTIFIED;
225 }
226
227 static int
228 ppp_attach(dip, cmd)
229     dev_info_t *dip;
230     ddi_attach_cmd_t cmd;
231 {
232
233     if (cmd != DDI_ATTACH)
234         return DDI_FAILURE;
235     if (ddi_create_minor_node(dip, "ppp", S_IFCHR, 0, DDI_PSEUDO, CLONE_DEV)
236         == DDI_FAILURE) {
237         ddi_remove_minor_node(dip, NULL);
238         return DDI_FAILURE;
239     }
240     return DDI_SUCCESS;
241 }
242
243 static int
244 ppp_detach(dip, cmd)
245     dev_info_t *dip;
246     ddi_detach_cmd_t cmd;
247 {
248     ddi_remove_minor_node(dip, NULL);
249     return DDI_SUCCESS;
250 }
251
252 static int
253 ppp_devinfo(dip, cmd, arg, result)
254     dev_info_t *dip;
255     ddi_info_cmd_t cmd;
256     void *arg;
257     void **result;
258 {
259     int error;
260
261     error = DDI_SUCCESS;
262     switch (cmd) {
263     case DDI_INFO_DEVT2DEVINFO:
264         if (ppp_dip == NULL)
265             error = DDI_FAILURE;
266         else
267             *result = (void *) ppp_dip;
268         break;
269     case DDI_INFO_DEVT2INSTANCE:
270         *result = NULL;
271         break;
272     default:
273         error = DDI_FAILURE;
274     }
275     return error;
276 }
277 #endif /* sun */
278
279 #ifndef sun
280 # define qprocson(q)
281 # define qprocsoff(q)
282 # define canputnext(q)  canput((q)->q_next)
283 # define qwriter(q, mp, func, scope)    (func)((q), (mp))
284 #endif
285
286 static int
287 pppopen(q, devp, oflag, sflag, credp)
288     queue_t *q;
289     dev_t *devp;
290     int oflag, sflag;
291     cred_t *credp;
292 {
293     upperstr_t *up;
294     upperstr_t **prevp;
295     minor_t mn;
296
297     if (q->q_ptr)
298         return 0;               /* device is already open */
299
300     if (sflag == CLONEOPEN) {
301         mn = 0;
302         for (prevp = &minor_devs; (up = *prevp) != 0; prevp = &up->nextmn) {
303             if (up->mn != mn)
304                 break;
305             ++mn;
306         }
307     } else {
308         mn = getminor(*devp);
309         for (prevp = &minor_devs; (up = *prevp) != 0; prevp = &up->nextmn) {
310             if (up->mn >= mn)
311                 break;
312         }
313         if (up->mn == mn) {
314             /* this can't happen */
315             q->q_ptr = WR(q)->q_ptr = up;
316             return 0;
317         }
318     }
319
320     /*
321      * Construct a new minor node.
322      */
323     up = (upperstr_t *) kmem_zalloc(sizeof(upperstr_t), KM_SLEEP);
324     if (up == 0) {
325         cmn_err(CE_CONT, "pppopen: out of kernel memory\n");
326         return ENXIO;
327     }
328     up->nextmn = *prevp;
329     *prevp = up;
330     up->mn = mn;
331     *devp = makedevice(getmajor(*devp), mn);
332     up->q = q;
333     if (drv_priv(credp) == 0)
334         up->flags |= US_PRIV;
335     up->state = DL_UNATTACHED;
336     up->sap = -1;
337     q->q_ptr = up;
338     WR(q)->q_ptr = up;
339     noenable(WR(q));
340
341     qprocson(q);
342     return 0;
343 }
344
345 static int
346 pppclose(q, flag, credp)
347     queue_t *q;
348     int flag;
349     cred_t *credp;
350 {
351     upperstr_t *up, **upp;
352     upperstr_t *as, *asnext;
353     upperstr_t **prevp;
354
355     qprocsoff(q);
356
357     up = (upperstr_t *) q->q_ptr;
358     if (up->flags & US_CONTROL) {
359         /*
360          * This stream represents a PPA:
361          * For all streams attached to the PPA, clear their
362          * references to this PPA.
363          * Then remove this PPA from the list of PPAs.
364          */
365         for (as = up->next; as != 0; as = asnext) {
366             asnext = as->next;
367             as->next = 0;
368             as->ppa = 0;
369             if (as->flags & US_BLOCKED) {
370                 as->flags &= ~US_BLOCKED;
371                 flushq(WR(as->q), FLUSHDATA);
372             }
373         }
374         for (upp = &ppas; *upp != 0; upp = &(*upp)->nextppa)
375             if (*upp == up) {
376                 *upp = up->nextppa;
377                 break;
378             }
379
380     } else {
381         /*
382          * If this stream is attached to a PPA,
383          * remove it from the PPA's list.
384          */
385         if ((as = up->ppa) != 0) {
386             for (; as->next != 0; as = as->next)
387                 if (as->next == up) {
388                     as->next = up->next;
389                     break;
390                 }
391         }
392     }
393
394     if (up->kstats)
395         kstat_delete(up->kstats);
396
397     q->q_ptr = NULL;
398     WR(q)->q_ptr = NULL;
399
400     for (prevp = &minor_devs; *prevp != 0; prevp = &up->nextmn) {
401         if (*prevp == up) {
402             *prevp = up->nextmn;
403             break;
404         }
405     }
406     kmem_free(up, sizeof(upperstr_t));
407
408     return 0;
409 }
410
411 /*
412  * A message from on high.  We do one of three things:
413  *      - qreply()
414  *      - put the message on the lower write stream
415  *      - queue it for our service routine
416  */
417 static int
418 pppuwput(q, mp)
419     queue_t *q;
420     mblk_t *mp;
421 {
422     upperstr_t *us, *usnext, *ppa;
423     struct iocblk *iop;
424     struct linkblk *lb;
425     queue_t *lq;
426     int error, n;
427     mblk_t *mq;
428
429     us = (upperstr_t *) q->q_ptr;
430     switch (mp->b_datap->db_type) {
431     case M_PCPROTO:
432     case M_PROTO:
433         dlpi_request(q, mp, us);
434         break;
435
436     case M_DATA:
437         if ((us->flags & US_CONTROL) == 0
438             || msgdsize(mp) > us->mtu + PPP_HDRLEN) {
439 #if DEBUG
440             cmn_err(CE_CONT, "pppuwput: junk data len=%d\n", msgdsize(mp));
441 #endif
442             freemsg(mp);
443             break;
444         }
445         if (!send_data(mp, us))
446             putq(q, mp);
447         break;
448
449     case M_IOCTL:
450         iop = (struct iocblk *) mp->b_rptr;
451         error = EINVAL;
452         switch (iop->ioc_cmd) {
453         case I_LINK:
454             if ((us->flags & US_CONTROL) == 0 || us->lowerq != 0)
455                 break;
456             lb = (struct linkblk *) mp->b_cont->b_rptr;
457             us->lowerq = lq = lb->l_qbot;
458             lq->q_ptr = us;
459             RD(lq)->q_ptr = us;
460             iop->ioc_count = 0;
461             error = 0;
462             us->flags &= ~US_LASTMOD;
463             /* Unblock upper streams which now feed this lower stream. */
464             qenable(lq);
465             /* Send useful information down to the modules which
466                are now linked below us. */
467             putctl2(lq, M_CTL, PPPCTL_UNIT, us->ppa_id);
468             putctl4(lq, M_CTL, PPPCTL_MRU, us->mru);
469             putctl4(lq, M_CTL, PPPCTL_MTU, us->mtu);
470             break;
471
472         case I_UNLINK:
473             lb = (struct linkblk *) mp->b_cont->b_rptr;
474 #if DEBUG
475             if (us->lowerq != lb->l_qbot)
476                 cmn_err(CE_CONT, "ppp unlink: lowerq=%x qbot=%x\n",
477                         us->lowerq, lb->l_qbot);
478 #endif
479             us->lowerq = 0;
480             iop->ioc_count = 0;
481             error = 0;
482             /* Unblock streams which now feed back up the control stream. */
483             qenable(us->q);
484             break;
485
486         case PPPIO_NEWPPA:
487             if (us->flags & US_CONTROL)
488                 break;
489             if ((us->flags & US_PRIV) == 0) {
490                 error = EPERM;
491                 break;
492             }
493             /* Arrange to return an int */
494             if ((mq = mp->b_cont) == 0
495                 || mq->b_datap->db_lim - mq->b_rptr < sizeof(int)) {
496                 mq = allocb(sizeof(int), BPRI_HI);
497                 if (mq == 0) {
498                     error = ENOSR;
499                     break;
500                 }
501                 if (mp->b_cont != 0)
502                     freemsg(mp->b_cont);
503                 mp->b_cont = mq;
504                 mq->b_cont = 0;
505             }
506             iop->ioc_count = sizeof(int);
507             mq->b_wptr = mq->b_rptr + sizeof(int);
508             qwriter(q, mp, new_ppa, PERIM_OUTER);
509             error = -1;
510             break;
511
512         case PPPIO_ATTACH:
513             /* like dlpi_attach, for programs which can't write to
514                the stream (like pppstats) */
515             if (iop->ioc_count != sizeof(int) || us->ppa != 0)
516                 break;
517             n = *(int *)mp->b_cont->b_rptr;
518             for (ppa = ppas; ppa != 0; ppa = ppa->nextppa)
519                 if (ppa->ppa_id == n)
520                     break;
521             if (ppa == 0)
522                 break;
523             us->ppa = ppa;
524             qwriter(q, NULL, attach_ppa, PERIM_OUTER);
525             break;
526
527         case PPPIO_MRU:
528             if (iop->ioc_count != sizeof(int) || (us->flags & US_CONTROL) == 0)
529                 break;
530             n = *(int *)mp->b_cont->b_rptr;
531             if (n <= 0 || n > PPP_MAXMTU)
532                 break;
533             if (n < PPP_MRU)
534                 n = PPP_MRU;
535             us->mru = n;
536             if (us->lowerq)
537                 putctl4(us->lowerq, M_CTL, PPPCTL_MRU, n);
538             error = 0;
539             iop->ioc_count = 0;
540             break;
541
542         case PPPIO_MTU:
543             if (iop->ioc_count != sizeof(int) || (us->flags & US_CONTROL) == 0)
544                 break;
545             n = *(int *)mp->b_cont->b_rptr;
546             if (n <= 0 || n > PPP_MAXMTU)
547                 break;
548             if (n < PPP_MRU)
549                 n = PPP_MRU;
550             us->mtu = n;
551             if (us->lowerq)
552                 putctl4(us->lowerq, M_CTL, PPPCTL_MTU, n);
553             error = 0;
554             iop->ioc_count = 0;
555             break;
556
557         case PPPIO_LASTMOD:
558             us->flags |= US_LASTMOD;
559             error = 0;
560             break;
561
562         default:
563             if (us->ppa == 0 || us->ppa->lowerq == 0)
564                 break;
565             error = -1;
566             switch (iop->ioc_cmd) {
567             case PPPIO_GETSTAT:
568             case PPPIO_GETCSTAT:
569                 if (us->flags & US_LASTMOD) {
570                     error = EINVAL;
571                     break;
572                 }
573                 putnext(us->ppa->lowerq, mp);
574                 break;
575             default:
576                 if (us->flags & US_PRIV)
577                     putnext(us->ppa->lowerq, mp);
578                 else {
579 #if DEBUG
580                     cmn_err(CE_CONT, "ppp ioctl %x rejected\n", iop->ioc_cmd);
581 #endif
582                     error = EPERM;
583                 }
584                 break;
585             }
586             break;
587         }
588
589         if (error > 0) {
590             iop->ioc_error = error;
591             mp->b_datap->db_type = M_IOCNAK;
592             qreply(q, mp);
593         } else if (error == 0) {
594             mp->b_datap->db_type = M_IOCACK;
595             qreply(q, mp);
596         }
597         break;
598
599     case M_FLUSH:
600         if (*mp->b_rptr & FLUSHW)
601             flushq(q, FLUSHDATA);
602         if (*mp->b_rptr & FLUSHR) {
603             *mp->b_rptr &= ~FLUSHW;
604             qreply(q, mp);
605         } else
606             freemsg(mp);
607         break;
608
609     default:
610         freemsg(mp);
611         break;
612     }
613     return 0;
614 }
615
616 static void
617 dlpi_request(q, mp, us)
618     queue_t *q;
619     mblk_t *mp;
620     upperstr_t *us;
621 {
622     union DL_primitives *d = (union DL_primitives *) mp->b_rptr;
623     int size = mp->b_wptr - mp->b_rptr;
624     mblk_t *reply, *np;
625     upperstr_t *ppa, *os;
626     int sap, *ip, len;
627     dl_info_ack_t *info;
628     dl_bind_ack_t *ackp;
629
630     switch (d->dl_primitive) {
631     case DL_INFO_REQ:
632         if (size < sizeof(dl_info_req_t))
633             goto badprim;
634         if ((reply = allocb(sizeof(dl_info_ack_t), BPRI_HI)) == 0)
635             break;              /* should do bufcall */
636         reply->b_datap->db_type = M_PCPROTO;
637         info = (dl_info_ack_t *) reply->b_wptr;
638         reply->b_wptr += sizeof(dl_info_ack_t);
639         bzero((caddr_t) info, sizeof(dl_info_ack_t));
640         info->dl_primitive = DL_INFO_ACK;
641         info->dl_max_sdu = PPP_MAXMTU;
642         info->dl_min_sdu = 1;
643         info->dl_addr_length = sizeof(ulong);
644 #ifdef DL_OTHER
645         info->dl_mac_type = DL_OTHER;
646 #else
647         info->dl_mac_type = DL_HDLC;    /* a lie */
648 #endif
649         info->dl_current_state = us->state;
650         info->dl_service_mode = DL_CLDLS;
651         info->dl_provider_style = DL_STYLE2;
652 #if DL_CURRENT_VERSION >= 2
653         info->dl_sap_length = sizeof(ulong);
654         info->dl_version = DL_CURRENT_VERSION;
655 #endif
656         qreply(q, reply);
657         break;
658
659     case DL_ATTACH_REQ:
660         if (size < sizeof(dl_attach_req_t))
661             goto badprim;
662         if (us->state != DL_UNATTACHED || us->ppa != 0) {
663             dlpi_error(q, DL_ATTACH_REQ, DL_OUTSTATE, 0);
664             break;
665         }
666         for (ppa = ppas; ppa != 0; ppa = ppa->nextppa)
667             if (ppa->ppa_id == d->attach_req.dl_ppa)
668                 break;
669         if (ppa == 0) {
670             dlpi_error(q, DL_ATTACH_REQ, DL_BADPPA, 0);
671             break;
672         }
673         us->ppa = ppa;
674         qwriter(q, mp, attach_ppa, PERIM_OUTER);
675         break;
676
677     case DL_DETACH_REQ:
678         if (size < sizeof(dl_detach_req_t))
679             goto badprim;
680         if (us->state != DL_UNBOUND || us->ppa == 0) {
681             dlpi_error(q, DL_DETACH_REQ, DL_OUTSTATE, 0);
682             break;
683         }
684         qwriter(q, mp, detach_ppa, PERIM_OUTER);
685         break;
686
687     case DL_BIND_REQ:
688         if (size < sizeof(dl_bind_req_t))
689             goto badprim;
690         if (us->state != DL_UNBOUND || us->ppa == 0) {
691             dlpi_error(q, DL_BIND_REQ, DL_OUTSTATE, 0);
692             break;
693         }
694         if (d->bind_req.dl_service_mode != DL_CLDLS) {
695             dlpi_error(q, DL_BIND_REQ, DL_UNSUPPORTED, 0);
696             break;
697         }
698
699         /* saps must be valid PPP network protocol numbers,
700            except that we accept ETHERTYPE_IP in place of PPP_IP. */
701         sap = d->bind_req.dl_sap;
702         us->req_sap = sap;
703 #if DEBUG
704         cmn_err(CE_CONT, "ppp bind %x\n", sap);
705 #endif
706         if (sap == ETHERTYPE_IP)
707             sap = PPP_IP;
708         if (sap < 0x21 || sap > 0x3fff || (sap & 0x101) != 1) {
709             dlpi_error(q, DL_BIND_REQ, DL_BADADDR, 0);
710             break;
711         }
712
713         /* check that no other stream is bound to this sap already. */
714         for (os = us->ppa; os != 0; os = os->next)
715             if (os->sap == sap)
716                 break;
717         if (os != 0) {
718             dlpi_error(q, DL_BIND_REQ, DL_NOADDR, 0);
719             break;
720         }
721
722         us->sap = sap;
723         us->state = DL_IDLE;
724
725         if ((reply = allocb(sizeof(dl_bind_ack_t) + sizeof(ulong),
726                             BPRI_HI)) == 0)
727             break;              /* should do bufcall */
728         ackp = (dl_bind_ack_t *) reply->b_wptr;
729         reply->b_wptr += sizeof(dl_bind_ack_t) + sizeof(ulong);
730         reply->b_datap->db_type = M_PCPROTO;
731         bzero((caddr_t) ackp, sizeof(dl_bind_ack_t));
732         ackp->dl_primitive = DL_BIND_ACK;
733         ackp->dl_sap = sap;
734         ackp->dl_addr_length = sizeof(ulong);
735         ackp->dl_addr_offset = sizeof(dl_bind_ack_t);
736         *(ulong *)(ackp+1) = sap;
737         qreply(q, reply);
738         break;
739
740     case DL_UNBIND_REQ:
741         if (size < sizeof(dl_unbind_req_t))
742             goto badprim;
743         if (us->state != DL_IDLE) {
744             dlpi_error(q, DL_UNBIND_REQ, DL_OUTSTATE, 0);
745             break;
746         }
747         us->sap = -1;
748         us->state = DL_UNBOUND;
749         dlpi_ok(q, DL_UNBIND_REQ);
750         break;
751
752     case DL_UNITDATA_REQ:
753         if (size < sizeof(dl_unitdata_req_t))
754             goto badprim;
755         if (us->state != DL_IDLE) {
756             dlpi_error(q, DL_UNITDATA_REQ, DL_OUTSTATE, 0);
757             break;
758         }
759         if (us->ppa == 0) {
760             cmn_err(CE_CONT, "ppp: in state dl_idle but ppa == 0?\n");
761             break;
762         }
763         len = mp->b_cont == 0? 0: msgdsize(mp->b_cont);
764         if (len > us->ppa->mtu) {
765 #if DEBUG
766             cmn_err(CE_CONT, "dlpi data too large (%d > %d)\n", len, us->mtu);
767 #endif
768             break;
769         }
770         /* this assumes PPP_HDRLEN <= sizeof(dl_unitdata_req_t) */
771         if (mp->b_datap->db_ref > 1) {
772             np = allocb(PPP_HDRLEN, BPRI_HI);
773             if (np == 0)
774                 break;          /* gak! */
775             np->b_cont = mp->b_cont;
776             mp->b_cont = 0;
777             freeb(mp);
778             mp = np;
779         } else
780             mp->b_datap->db_type = M_DATA;
781         /* XXX should use dl_dest_addr_offset/length here,
782            but we would have to translate ETHERTYPE_IP -> PPP_IP */
783         mp->b_wptr = mp->b_rptr + PPP_HDRLEN;
784         mp->b_rptr[0] = PPP_ALLSTATIONS;
785         mp->b_rptr[1] = PPP_UI;
786         mp->b_rptr[2] = us->sap >> 8;
787         mp->b_rptr[3] = us->sap;
788         if (!send_data(mp, us))
789             putq(q, mp);
790         return;
791
792 #if DL_CURRENT_VERSION >= 2
793     case DL_SUBS_BIND_REQ:
794     case DL_SUBS_UNBIND_REQ:
795     case DL_ENABMULTI_REQ:
796     case DL_DISABMULTI_REQ:
797     case DL_PROMISCON_REQ:
798     case DL_PROMISCOFF_REQ:
799     case DL_SET_PHYS_ADDR_REQ:
800     case DL_XID_REQ:
801     case DL_TEST_REQ:
802     case DL_REPLY_UPDATE_REQ:
803     case DL_REPLY_REQ:
804     case DL_DATA_ACK_REQ:
805 #endif
806     case DL_CONNECT_REQ:
807     case DL_TOKEN_REQ:
808         dlpi_error(q, d->dl_primitive, DL_NOTSUPPORTED, 0);
809         break;
810
811     case DL_CONNECT_RES:
812     case DL_DISCONNECT_REQ:
813     case DL_RESET_REQ:
814     case DL_RESET_RES:
815         dlpi_error(q, d->dl_primitive, DL_OUTSTATE, 0);
816         break;
817
818     case DL_UDQOS_REQ:
819         dlpi_error(q, d->dl_primitive, DL_BADQOSTYPE, 0);
820         break;
821
822 #if DL_CURRENT_VERSION >= 2
823     case DL_TEST_RES:
824     case DL_XID_RES:
825         break;
826 #endif
827
828     default:
829         cmn_err(CE_CONT, "ppp: unknown dlpi prim 0x%x\n", d->dl_primitive);
830         /* fall through */
831     badprim:
832         dlpi_error(q, d->dl_primitive, DL_BADPRIM, 0);
833         break;
834     }
835     freemsg(mp);
836 }
837
838 static void
839 dlpi_error(q, prim, err, uerr)
840     queue_t *q;
841     int prim, err, uerr;
842 {
843     mblk_t *reply;
844     dl_error_ack_t *errp;
845
846     reply = allocb(sizeof(dl_error_ack_t), BPRI_HI);
847     if (reply == 0)
848         return;                 /* XXX should do bufcall */
849     reply->b_datap->db_type = M_PCPROTO;
850     errp = (dl_error_ack_t *) reply->b_wptr;
851     reply->b_wptr += sizeof(dl_error_ack_t);
852     errp->dl_primitive = DL_ERROR_ACK;
853     errp->dl_error_primitive = prim;
854     errp->dl_errno = err;
855     errp->dl_unix_errno = uerr;
856     qreply(q, reply);
857 }
858
859 static void
860 dlpi_ok(q, prim)
861     queue_t *q;
862     int prim;
863 {
864     mblk_t *reply;
865     dl_ok_ack_t *okp;
866
867     reply = allocb(sizeof(dl_ok_ack_t), BPRI_HI);
868     if (reply == 0)
869         return;                 /* XXX should do bufcall */
870     reply->b_datap->db_type = M_PCPROTO;
871     okp = (dl_ok_ack_t *) reply->b_wptr;
872     reply->b_wptr += sizeof(dl_ok_ack_t);
873     okp->dl_primitive = DL_OK_ACK;
874     okp->dl_correct_primitive = prim;
875     qreply(q, reply);
876 }
877
878 static int
879 send_data(mp, us)
880     mblk_t *mp;
881     upperstr_t *us;
882 {
883     queue_t *q;
884     upperstr_t *ppa;
885
886     if (us->flags & US_BLOCKED)
887         return 0;
888     ppa = us->ppa;
889     if (ppa == 0) {
890         freemsg(mp);
891         return 1;
892     }
893     if ((q = ppa->lowerq) == 0) {
894         /* try to send it up the control stream */
895         if (canputnext(ppa->q)) {
896             putnext(ppa->q, mp);
897             return 1;
898         }
899     } else {
900         if (canputnext(ppa->lowerq)) {
901             /*
902              * The lower write queue's put procedure just updates counters
903              * and does a putnext.  We call it in order to enter the lower
904              * queues' perimeter so that the counter updates are serialized.
905              */
906             put(ppa->lowerq, mp);
907             return 1;
908         }
909     }
910     us->flags |= US_BLOCKED;
911     return 0;
912 }
913
914 /*
915  * Allocate a new PPA id and link this stream into the list of PPAs.
916  * This procedure is called with an exclusive lock on all queues in
917  * this driver.
918  */
919 static void
920 new_ppa(q, mp)
921     queue_t *q;
922     mblk_t *mp;
923 {
924     upperstr_t *us, **usp;
925     int ppa_id;
926
927     usp = &ppas;
928     ppa_id = 0;
929     while ((us = *usp) != 0 && ppa_id == us->ppa_id) {
930         ++ppa_id;
931         usp = &us->nextppa;
932     }
933     us = (upperstr_t *) q->q_ptr;
934     us->ppa_id = ppa_id;
935     us->ppa = us;
936     us->next = 0;
937     us->nextppa = *usp;
938     *usp = us;
939     us->flags |= US_CONTROL;
940
941     us->mtu = PPP_MRU;
942     us->mru = PPP_MRU;
943
944 #ifdef sun
945     if (us->kstats == 0) {
946         char unit[32];
947
948         sprintf(unit, "ppp%d", us->ppa->ppa_id);
949         us->kstats = kstat_create("ppp", us->ppa->ppa_id, unit,
950                                   "net", KSTAT_TYPE_NAMED, 4, 0);
951         if (us->kstats != 0) {
952             kstat_named_t *kn = KSTAT_NAMED_PTR(us->kstats);
953
954             strcpy(kn[0].name, "ipackets");
955             kn[0].data_type = KSTAT_DATA_ULONG;
956             strcpy(kn[1].name, "ierrors");
957             kn[1].data_type = KSTAT_DATA_ULONG;
958             strcpy(kn[2].name, "opackets");
959             kn[2].data_type = KSTAT_DATA_ULONG;
960             strcpy(kn[3].name, "oerrors");
961             kn[3].data_type = KSTAT_DATA_ULONG;
962             kstat_install(us->kstats);
963         }
964     }
965 #endif
966
967     *(int *)mp->b_cont->b_rptr = ppa_id;
968     mp->b_datap->db_type = M_IOCACK;
969     qreply(q, mp);
970 }
971
972 static void
973 attach_ppa(q, mp)
974     queue_t *q;
975     mblk_t *mp;
976 {
977     upperstr_t *us, *t;
978
979     us = (upperstr_t *) q->q_ptr;
980     us->state = DL_UNBOUND;
981     for (t = us->ppa; t->next != 0; t = t->next)
982         ;
983     t->next = us;
984     us->next = 0;
985     if (mp)
986         dlpi_ok(q, DL_ATTACH_REQ);
987 }
988
989 static void
990 detach_ppa(q, mp)
991     queue_t *q;
992     mblk_t *mp;
993 {
994     upperstr_t *us, *t;
995
996     us = (upperstr_t *) q->q_ptr;
997     for (t = us->ppa; t->next != 0; t = t->next)
998         if (t->next == us) {
999             t->next = us->next;
1000             break;
1001         }
1002     us->next = 0;
1003     us->ppa = 0;
1004     us->state = DL_UNATTACHED;
1005     dlpi_ok(q, DL_DETACH_REQ);
1006 }
1007
1008 static int
1009 pppuwsrv(q)
1010     queue_t *q;
1011 {
1012     upperstr_t *us;
1013     struct lowerstr *ls;
1014     queue_t *lwq;
1015     mblk_t *mp;
1016
1017     us = (upperstr_t *) q->q_ptr;
1018     while ((mp = getq(q)) != 0) {
1019         if (!send_data(mp, us)) {
1020             putbq(q, mp);
1021             break;
1022         }
1023     }
1024     if (mp == 0)
1025         us->flags &= ~US_BLOCKED;
1026     return 0;
1027 }
1028
1029 static int
1030 ppplwput(q, mp)
1031     queue_t *q;
1032     mblk_t *mp;
1033 {
1034     upperstr_t *ppa;
1035
1036     ppa = q->q_ptr;
1037     if (ppa != 0) {             /* why wouldn't it? */
1038         ppa->stats.ppp_opackets++;
1039         ppa->stats.ppp_obytes += msgdsize(mp);
1040         if (ppa->kstats != 0)
1041             KSTAT_NAMED_PTR(ppa->kstats)[2].value.ul++;
1042     }
1043     putnext(q, mp);
1044     return 0;
1045 }
1046
1047 static int
1048 ppplwsrv(q)
1049     queue_t *q;
1050 {
1051     upperstr_t *us;
1052
1053     /*
1054      * Flow control has back-enabled this stream:
1055      * enable the write service procedures of all upper
1056      * streams feeding this lower stream.
1057      */
1058     for (us = (upperstr_t *) q->q_ptr; us != NULL; us = us->next)
1059         if (us->flags & US_BLOCKED)
1060             qenable(WR(us->q));
1061     return 0;
1062 }
1063
1064 static int
1065 pppursrv(q)
1066     queue_t *q;
1067 {
1068     upperstr_t *us, *as;
1069     mblk_t *mp, *hdr;
1070     dl_unitdata_ind_t *ud;
1071     int proto;
1072
1073     /*
1074      * If this is a control stream and we don't have a lower queue attached,
1075      * run the write service routines of other streams attached to this PPA.
1076      */
1077     us = (upperstr_t *) q->q_ptr;
1078     if (us->flags & US_CONTROL) {
1079         /*
1080          * A control stream.
1081          * If there is no lower queue attached, run the write service
1082          * routines of other upper streams attached to this PPA.
1083          */
1084         if (us->lowerq == 0) {
1085             as = us;
1086             do {
1087                 if (as->flags & US_BLOCKED)
1088                     qenable(WR(as->q));
1089                 as = as->next;
1090             } while (as != 0);
1091         }
1092     } else {
1093         /*
1094          * A network protocol stream.  Put a DLPI header on each
1095          * packet and send it on.
1096          */
1097         while ((mp = getq(q)) != 0) {
1098             if (!canputnext(q)) {
1099                 putbq(q, mp);
1100                 break;
1101             }
1102             proto = PPP_PROTOCOL(mp->b_rptr);
1103             mp->b_rptr += PPP_HDRLEN;
1104             hdr = allocb(sizeof(dl_unitdata_ind_t) + 2 * sizeof(ulong),
1105                          BPRI_MED);
1106             if (hdr == 0) {
1107                 /* XXX should put it back and use bufcall */
1108                 freemsg(mp);
1109                 continue;
1110             }
1111             ud = (dl_unitdata_ind_t *) hdr->b_wptr;
1112             hdr->b_wptr += sizeof(dl_unitdata_ind_t) + 2 * sizeof(ulong);
1113             hdr->b_cont = mp;
1114             ud->dl_primitive = DL_UNITDATA_IND;
1115             ud->dl_dest_addr_length = sizeof(ulong);
1116             ud->dl_dest_addr_offset = sizeof(dl_unitdata_ind_t);
1117             ud->dl_src_addr_length = sizeof(ulong);
1118             ud->dl_src_addr_offset = ud->dl_dest_addr_offset + sizeof(ulong);
1119 #if DL_CURRENT_VERSION >= 2
1120             ud->dl_group_address = 0;
1121 #endif
1122             /* Send the DLPI client the data with the SAP they requested,
1123                (e.g. ETHERTYPE_IP) rather than the PPP protocol number
1124                (e.g. PPP_IP) */
1125             ((ulong *)(ud + 1))[0] = us->req_sap;       /* dest SAP */
1126             ((ulong *)(ud + 1))[1] = us->req_sap;       /* src SAP */
1127             putnext(q, mp);
1128         }
1129     }
1130     return 0;
1131 }
1132
1133 static upperstr_t *
1134 find_dest(ppa, proto)
1135     upperstr_t *ppa;
1136     int proto;
1137 {
1138     upperstr_t *us;
1139
1140     for (us = ppa->next; us != 0; us = us->next)
1141         if (proto == us->sap)
1142             break;
1143     return us;
1144 }
1145
1146 static int
1147 ppplrput(q, mp)
1148     queue_t *q;
1149     mblk_t *mp;
1150 {
1151     upperstr_t *ppa, *us;
1152     queue_t *uq;
1153     int proto, len;
1154     mblk_t *np;
1155
1156     ppa = (upperstr_t *) q->q_ptr;
1157     if (ppa == 0) {
1158 #if DEBUG
1159         cmn_err(CE_CONT, "ppplrput: q = %x, ppa = 0??\n", q);
1160 #endif
1161         freemsg(mp);
1162         return 0;
1163     }
1164     switch (mp->b_datap->db_type) {
1165     case M_FLUSH:
1166         if (*mp->b_rptr & FLUSHW) {
1167             *mp->b_rptr &= ~FLUSHR;
1168             qreply(q, mp);
1169         } else
1170             freemsg(mp);
1171         break;
1172
1173     case M_CTL:
1174         switch (*mp->b_rptr) {
1175         case PPPCTL_IERROR:
1176             if (ppa->kstats != 0) {
1177                 KSTAT_NAMED_PTR(ppa->kstats)[1].value.ul++;
1178             }
1179             ppa->stats.ppp_ierrors++;
1180             break;
1181         case PPPCTL_OERROR:
1182             if (ppa->kstats != 0) {
1183                 KSTAT_NAMED_PTR(ppa->kstats)[3].value.ul++;
1184             }
1185             ppa->stats.ppp_oerrors++;
1186             break;
1187         }
1188         freemsg(mp);
1189         break;
1190
1191     default:
1192         if (mp->b_datap->db_type == M_DATA) {
1193             len = msgdsize(mp);
1194             if (mp->b_wptr - mp->b_rptr < PPP_HDRLEN) {
1195                 np = msgpullup(mp, PPP_HDRLEN);
1196                 freemsg(mp);
1197                 if (np == 0) {
1198 #if DEBUG
1199                     cmn_err(CE_CONT, "ppp_lrput: msgpullup failed (len=%d)\n",
1200                             len);
1201 #endif
1202                     break;
1203                 }
1204                 mp = np;
1205             }
1206             ppa->stats.ppp_ipackets++;
1207             ppa->stats.ppp_ibytes += len;
1208             if (ppa->kstats != 0) {
1209                 KSTAT_NAMED_PTR(ppa->kstats)[0].value.ul++;
1210             }
1211             proto = PPP_PROTOCOL(mp->b_rptr);
1212             if (proto < 0x8000 && (us = find_dest(ppa, proto)) != 0) {
1213                 /*
1214                  * A data packet for some network protocol.
1215                  * Queue it on the upper stream for that protocol.
1216                  */
1217                 if (canput(us->q))
1218                     putq(us->q, mp);
1219                 else
1220                     putq(q, mp);
1221                 break;
1222             }
1223         }
1224         /*
1225          * A control frame, a frame for an unknown protocol,
1226          * or some other message type.
1227          * Send it up to pppd via the control stream.
1228          */
1229         if (queclass(mp) == QPCTL || canputnext(ppa->q))
1230             putnext(ppa->q, mp);
1231         else
1232             putq(q, mp);
1233         break;
1234     }
1235
1236     return 0;
1237 }
1238
1239 static int
1240 ppplrsrv(q)
1241     queue_t *q;
1242 {
1243     mblk_t *mp;
1244     upperstr_t *ppa, *us;
1245     int proto;
1246
1247     /*
1248      * Packets only get queued here for flow control reasons.
1249      */
1250     ppa = (upperstr_t *) q->q_ptr;
1251     while ((mp = getq(q)) != 0) {
1252         if (mp->b_datap->db_type == M_DATA
1253             && (proto = PPP_PROTOCOL(mp->b_rptr)) < 0x8000
1254             && (us = find_dest(ppa, proto)) != 0) {
1255             if (canput(us->q))
1256                 putq(us->q, mp);
1257             else {
1258                 putbq(q, mp);
1259                 break;
1260             }
1261         } else {
1262             if (canputnext(ppa->q))
1263                 putnext(ppa->q, mp);
1264             else {
1265                 putbq(q, mp);
1266                 break;
1267             }
1268         }
1269     }
1270     return 0;
1271 }
1272
1273 static int
1274 putctl2(q, type, code, val)
1275     queue_t *q;
1276     int type, code, val;
1277 {
1278     mblk_t *mp;
1279
1280     mp = allocb(2, BPRI_HI);
1281     if (mp == 0)
1282         return 0;
1283     mp->b_datap->db_type = type;
1284     mp->b_wptr[0] = code;
1285     mp->b_wptr[1] = val;
1286     mp->b_wptr += 2;
1287     putnext(q, mp);
1288     return 1;
1289 }
1290
1291 static int
1292 putctl4(q, type, code, val)
1293     queue_t *q;
1294     int type, code, val;
1295 {
1296     mblk_t *mp;
1297
1298     mp = allocb(4, BPRI_HI);
1299     if (mp == 0)
1300         return 0;
1301     mp->b_datap->db_type = type;
1302     mp->b_wptr[0] = code;
1303     ((short *)mp->b_wptr)[1] = val;
1304     mp->b_wptr += 4;
1305     putnext(q, mp);
1306     return 1;
1307 }