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