modules/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 HAS BEEN ADVISED OF THE POSSIBILITY
  18  * OF SUCH DAMAGE.
  19  *
  20  * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  21  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  22  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  23  * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
  24  * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
  25  * OR MODIFICATIONS.
  26  *
  27  * $Id: ppp.c,v 1.5 1996/05/28 00:56:18 paulus Exp $
  28  */
  29
  30 /*
  31  * This file is used under Solaris 2, SVR4, and SunOS 4.
  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/ioccom.h>
  41 #include <sys/time.h>
  42 #ifdef SVR4
  43 #include <sys/cmn_err.h>
  44 #include <sys/conf.h>
  45 #include <sys/dlpi.h>
  46 #include <sys/ddi.h>
  47 #ifdef SOL2
  48 #include <sys/kstat.h>
  49 #include <sys/sunddi.h>
  50 #else
  51 #include <sys/socket.h>
  52 #include <sys/sockio.h>
  53 #include <net/if.h>
  54 #include <netinet/in.h>
  55 #endif /* SOL2 */
  56 #else /* not SVR4 */
  57 #include <sys/user.h>
  58 #endif /* SVR4 */
  59 #include <net/ppp_defs.h>
  60 #include <net/pppio.h>
  61 #include "ppp_mod.h"
  62
  63 #ifdef __STDC__
  64 #define __P(x)  x
  65 #else
  66 #define __P(x)  ()
  67 #endif
  68
  69 /*
  70  * The IP module may use this SAP value for IP packets.
  71  */
  72 #ifndef ETHERTYPE_IP
  73 #define ETHERTYPE_IP    0x800
  74 #endif
  75
  76 #ifndef PPP_MAXMTU
  77 #define PPP_MAXMTU      65535
  78 #endif
  79
  80 extern time_t time;
  81
  82 /*
  83  * Private information; one per upper stream.
  84  */
  85 typedef struct upperstr {
  86     minor_t mn;                 /* minor device number */
  87     struct upperstr *nextmn;    /* next minor device */
  88     queue_t *q;                 /* read q associated with this upper stream */
  89     int flags;                  /* flag bits, see below */
  90     int state;                  /* current DLPI state */
  91     int sap;                    /* service access point */
  92     int req_sap;                /* which SAP the DLPI client requested */
  93     struct upperstr *ppa;       /* control stream for our ppa */
  94     struct upperstr *next;      /* next stream for this ppa */
  95     uint ioc_id;                /* last ioctl ID for this stream */
  96     enum NPmode npmode;         /* what to do with packets on this SAP */
  97     /*
  98      * There is exactly one control stream for each PPA.
  99      * The following fields are only used for control streams.
 100      */
 101     int ppa_id;
 102     queue_t *lowerq;            /* write queue attached below this PPA */
 103     struct upperstr *nextppa;   /* next control stream */
 104     int mru;
 105     int mtu;
 106     struct pppstat stats;       /* statistics */
 107     time_t last_sent;           /* time last NP packet sent */
 108     time_t last_recv;           /* time last NP packet rcvd */
 109 #ifdef SOL2
 110     kstat_t *kstats;            /* stats for netstat */
 111 #endif /* SOL2 */
 112 #ifdef LACHTCP
 113     int ifflags;
 114     char ifname[IFNAMSIZ];
 115     struct ifstats ifstats;
 116 #endif /* LACHTCP */
 117 } upperstr_t;
 118
 119 /* Values for flags */
 120 #define US_PRIV         1       /* stream was opened by superuser */
 121 #define US_CONTROL      2       /* stream is a control stream */
 122 #define US_BLOCKED      4       /* flow ctrl has blocked lower write stream */
 123 #define US_LASTMOD      8       /* no PPP modules below us */
 124 #define US_DBGLOG       0x10    /* log various occurrences */
 125
 126 static upperstr_t *minor_devs = NULL;
 127 static upperstr_t *ppas = NULL;
 128
 129 #ifdef SVR4
 130 static int pppopen __P((queue_t *, dev_t *, int, int, cred_t *));
 131 static int pppclose __P((queue_t *, int, cred_t *));
 132 #else
 133 static int pppopen __P((queue_t *, int, int, int));
 134 static int pppclose __P((queue_t *, int));
 135 #endif /* SVR4 */
 136 static int pppuwput __P((queue_t *, mblk_t *));
 137 static int pppursrv __P((queue_t *));
 138 static int pppuwsrv __P((queue_t *));
 139 static int ppplrput __P((queue_t *, mblk_t *));
 140 static int ppplwput __P((queue_t *, mblk_t *));
 141 static int ppplrsrv __P((queue_t *));
 142 static int ppplwsrv __P((queue_t *));
 143 #ifndef NO_DLPI
 144 static void dlpi_request __P((queue_t *, mblk_t *, upperstr_t *));
 145 static void dlpi_error __P((queue_t *, int, int, int));
 146 static void dlpi_ok __P((queue_t *, int));
 147 #endif
 148 static int send_data __P((mblk_t *, upperstr_t *));
 149 static void new_ppa __P((queue_t *, mblk_t *));
 150 static void attach_ppa __P((queue_t *, mblk_t *));
 151 static void detach_ppa __P((queue_t *, mblk_t *));
 152 static void debug_dump __P((queue_t *, mblk_t *));
 153 static upperstr_t *find_dest __P((upperstr_t *, int));
 154 static int putctl2 __P((queue_t *, int, int, int));
 155 static int putctl4 __P((queue_t *, int, int, int));
 156
 157 static struct module_info ppp_info = {
 158     0xb1a6, "ppp", 0, 512, 512, 128
 159 };
 160
 161 static struct qinit pppurint = {
 162     NULL, pppursrv, pppopen, pppclose, NULL, &ppp_info, NULL
 163 };
 164
 165 static struct qinit pppuwint = {
 166     pppuwput, pppuwsrv, NULL, NULL, NULL, &ppp_info, NULL
 167 };
 168
 169 static struct qinit ppplrint = {
 170     ppplrput, ppplrsrv, NULL, NULL, NULL, &ppp_info, NULL
 171 };
 172
 173 static struct qinit ppplwint = {
 174     ppplwput, ppplwsrv, NULL, NULL, NULL, &ppp_info, NULL
 175 };
 176
 177 #ifdef LACHTCP
 178 extern struct ifstats *ifstats;
 179 int pppdevflag = 0;
 180 #endif
 181
 182 struct streamtab pppinfo = {
 183     &pppurint, &pppuwint,
 184     &ppplrint, &ppplwint
 185 };
 186
 187 int ppp_count;
 188
 189 /*
 190  * How we maintain statistics.
 191  */
 192 #ifdef SOL2
 193 #define INCR_IPACKETS(ppa)                              \
 194         if (ppa->kstats != 0) {                         \
 195             KSTAT_NAMED_PTR(ppa->kstats)[0].value.ul++; \
 196         }
 197 #define INCR_IERRORS(ppa)                               \
 198         if (ppa->kstats != 0) {                         \
 199             KSTAT_NAMED_PTR(ppa->kstats)[1].value.ul++; \
 200         }
 201 #define INCR_OPACKETS(ppa)                              \
 202         if (ppa->kstats != 0) {                         \
 203             KSTAT_NAMED_PTR(ppa->kstats)[2].value.ul++; \
 204         }
 205 #define INCR_OERRORS(ppa)                               \
 206         if (ppa->kstats != 0) {                         \
 207             KSTAT_NAMED_PTR(ppa->kstats)[3].value.ul++; \
 208         }
 209 #endif
 210
 211 #ifdef LACHTCP
 212 #define INCR_IPACKETS(ppa)      ppa->ifstats.ifs_ipackets++;
 213 #define INCR_IERRORS(ppa)       ppa->ifstats.ifs_ierrors++;
 214 #define INCR_OPACKETS(ppa)      ppa->ifstats.ifs_opackets++;
 215 #define INCR_OERRORS(ppa)       ppa->ifstats.ifs_oerrors++;
 216 #endif
 217
 218 /*
 219  * STREAMS driver entry points.
 220  */
 221 static int
 222 #ifdef SVR4
 223 pppopen(q, devp, oflag, sflag, credp)
 224     queue_t *q;
 225     dev_t *devp;
 226     int oflag, sflag;
 227     cred_t *credp;
 228 #else
 229 pppopen(q, dev, oflag, sflag)
 230     queue_t *q;
 231     int dev;                    /* really dev_t */
 232     int oflag, sflag;
 233 #endif
 234 {
 235     upperstr_t *up;
 236     upperstr_t **prevp;
 237     minor_t mn;
 238
 239     if (q->q_ptr)
 240         DRV_OPEN_OK(dev);       /* device is already open */
 241
 242     if (sflag == CLONEOPEN) {
 243         mn = 0;
 244         for (prevp = &minor_devs; (up = *prevp) != 0; prevp = &up->nextmn) {
 245             if (up->mn != mn)
 246                 break;
 247             ++mn;
 248         }
 249     } else {
 250 #ifdef SVR4
 251         mn = getminor(*devp);
 252 #else
 253         mn = minor(dev);
 254 #endif
 255         for (prevp = &minor_devs; (up = *prevp) != 0; prevp = &up->nextmn) {
 256             if (up->mn >= mn)
 257                 break;
 258         }
 259         if (up->mn == mn) {
 260             /* this can't happen */
 261             q->q_ptr = WR(q)->q_ptr = (caddr_t) up;
 262             DRV_OPEN_OK(dev);
 263         }
 264     }
 265
 266     /*
 267      * Construct a new minor node.
 268      */
 269     up = (upperstr_t *) ALLOC_SLEEP(sizeof(upperstr_t));
 270     bzero((caddr_t) up, sizeof(upperstr_t));
 271     if (up == 0) {
 272         DPRINT("pppopen: out of kernel memory\n");
 273         OPEN_ERROR(ENXIO);
 274     }
 275     up->nextmn = *prevp;
 276     *prevp = up;
 277     up->mn = mn;
 278 #ifdef SVR4
 279     *devp = makedevice(getmajor(*devp), mn);
 280 #endif
 281     up->q = q;
 282     if (NOTSUSER() == 0)
 283         up->flags |= US_PRIV;
 284 #ifndef NO_DLPI
 285     up->state = DL_UNATTACHED;
 286 #endif
 287 #ifdef LACHTCP
 288     up->ifflags = IFF_UP | IFF_POINTOPOINT;
 289 #endif
 290     up->sap = -1;
 291     up->last_sent = up->last_recv = time;
 292     up->npmode = NPMODE_DROP;
 293     q->q_ptr = (caddr_t) up;
 294     WR(q)->q_ptr = (caddr_t) up;
 295     noenable(WR(q));
 296     ++ppp_count;
 297
 298     qprocson(q);
 299     DRV_OPEN_OK(makedev(major(dev), mn));
 300 }
 301
 302 static int
 303 #ifdef SVR4
 304 pppclose(q, flag, credp)
 305     queue_t *q;
 306     int flag;
 307     cred_t *credp;
 308 #else
 309 pppclose(q, flag)
 310     queue_t *q;
 311     int flag;
 312 #endif
 313 {
 314     upperstr_t *up, **upp;
 315     upperstr_t *as, *asnext;
 316     upperstr_t **prevp;
 317
 318     qprocsoff(q);
 319
 320     up = (upperstr_t *) q->q_ptr;
 321     if (up->flags & US_DBGLOG)
 322         DPRINT2("ppp/%d: close, flags=%x\n", up->mn, up->flags);
 323     if (up == 0)
 324         return 0;
 325     if (up->flags & US_CONTROL) {
 326 #ifdef LACHTCP
 327         struct ifstats *ifp, *pifp;
 328 #endif
 329         /*
 330          * This stream represents a PPA:
 331          * For all streams attached to the PPA, clear their
 332          * references to this PPA.
 333          * Then remove this PPA from the list of PPAs.
 334          */
 335         for (as = up->next; as != 0; as = asnext) {
 336             asnext = as->next;
 337             as->next = 0;
 338             as->ppa = 0;
 339             if (as->flags & US_BLOCKED) {
 340                 as->flags &= ~US_BLOCKED;
 341                 flushq(WR(as->q), FLUSHDATA);
 342             }
 343         }
 344         for (upp = &ppas; *upp != 0; upp = &(*upp)->nextppa)
 345             if (*upp == up) {
 346                 *upp = up->nextppa;
 347                 break;
 348             }
 349 #ifdef LACHTCP
 350         /* Remove the statistics from the active list.  */
 351         for (ifp = ifstats, pifp = 0; ifp; ifp = ifp->ifs_next) {
 352             if (ifp == &up->ifstats) {
 353                 if (pifp)
 354                     pifp->ifs_next = ifp->ifs_next;
 355                 else
 356                     ifstats = ifp->ifs_next;
 357                 break;
 358             }
 359             pifp = ifp;
 360         }
 361 #endif
 362     } else {
 363         /*
 364          * If this stream is attached to a PPA,
 365          * remove it from the PPA's list.
 366          */
 367         if ((as = up->ppa) != 0) {
 368             for (; as->next != 0; as = as->next)
 369                 if (as->next == up) {
 370                     as->next = up->next;
 371                     break;
 372                 }
 373         }
 374     }
 375
 376 #ifdef SOL2
 377     if (up->kstats)
 378         kstat_delete(up->kstats);
 379 #endif
 380
 381     q->q_ptr = NULL;
 382     WR(q)->q_ptr = NULL;
 383
 384     for (prevp = &minor_devs; *prevp != 0; prevp = &(*prevp)->nextmn) {
 385         if (*prevp == up) {
 386             *prevp = up->nextmn;
 387             break;
 388         }
 389     }
 390     kmem_free(up, sizeof(upperstr_t));
 391     --ppp_count;
 392
 393     return 0;
 394 }
 395
 396 /*
 397  * A message from on high.  We do one of three things:
 398  *      - qreply()
 399  *      - put the message on the lower write stream
 400  *      - queue it for our service routine
 401  */
 402 static int
 403 pppuwput(q, mp)
 404     queue_t *q;
 405     mblk_t *mp;
 406 {
 407     upperstr_t *us, *usnext, *ppa, *os, *nps;
 408     struct iocblk *iop;
 409     struct linkblk *lb;
 410 #ifdef LACHTCP
 411     struct ifreq *ifr;
 412     int i;
 413 #endif
 414     queue_t *lq;
 415     int error, n, sap;
 416     mblk_t *mq;
 417     struct ppp_idle *pip;
 418     int len;
 419
 420     us = (upperstr_t *) q->q_ptr;
 421     switch (mp->b_datap->db_type) {
 422 #ifndef NO_DLPI
 423     case M_PCPROTO:
 424     case M_PROTO:
 425         dlpi_request(q, mp, us);
 426         break;
 427 #endif /* NO_DLPI */
 428
 429     case M_DATA:
 430         if (us->flags & US_DBGLOG)
 431             DPRINT3("ppp/%d: uwput M_DATA len=%d flags=%x\n",
 432                     us->mn, msgdsize(mp), us->flags);
 433         if (us->ppa == 0 || msgdsize(mp) > us->ppa->mtu + PPP_HDRLEN
 434 #ifndef NO_DLPI
 435             || (us->flags & US_CONTROL) == 0
 436 #endif /* NO_DLPI */
 437             ) {
 438             DPRINT1("pppuwput: junk data len=%d\n", msgdsize(mp));
 439             freemsg(mp);
 440             break;
 441         }
 442 #ifdef NO_DLPI
 443         if (!pass_packet(us->ppa, mp, 1)) {
 444             freemsg(mp);
 445             break;
 446         }
 447 #endif
 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         if (us->flags & US_DBGLOG)
 456             DPRINT3("ppp/%d: ioctl %x count=%d\n",
 457                     us->mn, iop->ioc_cmd, iop->ioc_count);
 458         switch (iop->ioc_cmd) {
 459         case I_LINK:
 460             if ((us->flags & US_CONTROL) == 0 || us->lowerq != 0)
 461                 break;
 462             lb = (struct linkblk *) mp->b_cont->b_rptr;
 463             us->lowerq = lq = lb->l_qbot;
 464             lq->q_ptr = (caddr_t) us;
 465             RD(lq)->q_ptr = (caddr_t) us;
 466             noenable(RD(lq));
 467             flushq(RD(lq), FLUSHALL);
 468             iop->ioc_count = 0;
 469             error = 0;
 470             us->flags &= ~US_LASTMOD;
 471             /* Unblock upper streams which now feed this lower stream. */
 472             qenable(lq);
 473             /* Send useful information down to the modules which
 474                are now linked below us. */
 475             putctl2(lq, M_CTL, PPPCTL_UNIT, us->ppa_id);
 476             putctl4(lq, M_CTL, PPPCTL_MRU, us->mru);
 477             putctl4(lq, M_CTL, PPPCTL_MTU, us->mtu);
 478             break;
 479
 480         case I_UNLINK:
 481             lb = (struct linkblk *) mp->b_cont->b_rptr;
 482 #if DEBUG
 483             if (us->lowerq != lb->l_qbot)
 484                 DPRINT2("ppp unlink: lowerq=%x qbot=%x\n",
 485                         us->lowerq, lb->l_qbot);
 486 #endif
 487             us->lowerq = 0;
 488             iop->ioc_count = 0;
 489             error = 0;
 490             /* Unblock streams which now feed back up the control stream. */
 491             qenable(us->q);
 492             break;
 493
 494         case PPPIO_NEWPPA:
 495             if (us->flags & US_CONTROL)
 496                 break;
 497             if ((us->flags & US_PRIV) == 0) {
 498                 error = EPERM;
 499                 break;
 500             }
 501             /* Arrange to return an int */
 502             if ((mq = mp->b_cont) == 0
 503                 || mq->b_datap->db_lim - mq->b_rptr < sizeof(int)) {
 504                 mq = allocb(sizeof(int), BPRI_HI);
 505                 if (mq == 0) {
 506                     error = ENOSR;
 507                     break;
 508                 }
 509                 if (mp->b_cont != 0)
 510                     freemsg(mp->b_cont);
 511                 mp->b_cont = mq;
 512                 mq->b_cont = 0;
 513             }
 514             iop->ioc_count = sizeof(int);
 515             mq->b_wptr = mq->b_rptr + sizeof(int);
 516             qwriter(q, mp, new_ppa, PERIM_OUTER);
 517             error = -1;
 518             break;
 519
 520         case PPPIO_ATTACH:
 521             /* like dlpi_attach, for programs which can't write to
 522                the stream (like pppstats) */
 523             if (iop->ioc_count != sizeof(int) || us->ppa != 0)
 524                 break;
 525             n = *(int *)mp->b_cont->b_rptr;
 526             for (ppa = ppas; ppa != 0; ppa = ppa->nextppa)
 527                 if (ppa->ppa_id == n)
 528                     break;
 529             if (ppa == 0)
 530                 break;
 531             us->ppa = ppa;
 532             iop->ioc_count = 0;
 533             qwriter(q, mp, attach_ppa, PERIM_OUTER);
 534             error = -1;
 535             break;
 536
 537 #ifdef NO_DLPI
 538         case PPPIO_BIND:
 539             /* Attach to a given SAP. */
 540             if (iop->ioc_count != sizeof(int) || us->ppa == 0)
 541                 break;
 542             n = *(int *)mp->b_cont->b_rptr;
 543             /* n must be a valid PPP network protocol number. */
 544             if (n < 0x21 || n > 0x3fff || (n & 0x101) != 1)
 545                 break;
 546             /* check that no other stream is bound to this sap already. */
 547             for (os = us->ppa; os != 0; os = os->next)
 548                 if (os->sap == n)
 549                     break;
 550             if (os != 0)
 551                 break;
 552             us->sap = n;
 553             iop->ioc_count = 0;
 554             error = 0;
 555             break;
 556 #endif /* NO_DLPI */
 557
 558         case PPPIO_MRU:
 559             if (iop->ioc_count != sizeof(int) || (us->flags & US_CONTROL) == 0)
 560                 break;
 561             n = *(int *)mp->b_cont->b_rptr;
 562             if (n <= 0 || n > PPP_MAXMTU)
 563                 break;
 564             if (n < PPP_MRU)
 565                 n = PPP_MRU;
 566             us->mru = n;
 567             if (us->lowerq)
 568                 putctl4(us->lowerq, M_CTL, PPPCTL_MRU, n);
 569             error = 0;
 570             iop->ioc_count = 0;
 571             break;
 572
 573         case PPPIO_MTU:
 574             if (iop->ioc_count != sizeof(int) || (us->flags & US_CONTROL) == 0)
 575                 break;
 576             n = *(int *)mp->b_cont->b_rptr;
 577             if (n <= 0 || n > PPP_MAXMTU)
 578                 break;
 579             if (n < PPP_MRU)
 580                 n = PPP_MRU;
 581             us->mtu = n;
 582 #ifdef LACHTCP
 583             us->ifstats.ifs_mtu = n;
 584 #endif
 585             if (us->lowerq)
 586                 putctl4(us->lowerq, M_CTL, PPPCTL_MTU, n);
 587             error = 0;
 588             iop->ioc_count = 0;
 589             break;
 590
 591         case PPPIO_LASTMOD:
 592             us->flags |= US_LASTMOD;
 593             error = 0;
 594             break;
 595
 596         case PPPIO_DEBUG:
 597             if (iop->ioc_count != sizeof(int))
 598                 break;
 599             n = *(int *)mp->b_cont->b_rptr;
 600             if (n == PPPDBG_DUMP + PPPDBG_DRIVER) {
 601                 qwriter(q, NULL, debug_dump, PERIM_OUTER);
 602                 iop->ioc_count = 0;
 603                 error = 0;
 604             } else if (n == PPPDBG_LOG + PPPDBG_DRIVER) {
 605                 DPRINT1("ppp/%d: debug log enabled\n", us->mn);
 606                 us->flags |= US_DBGLOG;
 607                 iop->ioc_count = 0;
 608                 error = 0;
 609             } else {
 610                 if (us->ppa == 0 || us->ppa->lowerq == 0)
 611                     break;
 612                 putnext(us->ppa->lowerq, mp);
 613                 error = -1;
 614             }
 615             break;
 616
 617         case PPPIO_NPMODE:
 618             if (iop->ioc_count != 2 * sizeof(int))
 619                 break;
 620             if ((us->flags & US_CONTROL) == 0)
 621                 break;
 622             sap = ((int *)mp->b_cont->b_rptr)[0];
 623             for (nps = us->next; nps != 0; nps = nps->next)
 624                 if (nps->sap == sap)
 625                     break;
 626             if (nps == 0) {
 627                 if (us->flags & US_DBGLOG)
 628                     DPRINT2("ppp/%d: no stream for sap %x\n", us->mn, sap);
 629                 break;
 630             }
 631             nps->npmode = (enum NPmode) ((int *)mp->b_cont->b_rptr)[1];
 632             if (nps->npmode == NPMODE_DROP || nps->npmode == NPMODE_ERROR)
 633                 flushq(WR(nps->q), FLUSHDATA);
 634             else if (nps->npmode == NPMODE_PASS && qsize(WR(nps->q)) > 0
 635                      && (nps->flags & US_BLOCKED) == 0)
 636                 qenable(WR(nps->q));
 637             iop->ioc_count = 0;
 638             error = 0;
 639             break;
 640
 641         case PPPIO_GIDLE:
 642             if ((ppa = us->ppa) == 0)
 643                 break;
 644             mq = allocb(sizeof(struct ppp_idle), BPRI_HI);
 645             if (mq == 0) {
 646                 error = ENOSR;
 647                 break;
 648             }
 649             if (mp->b_cont != 0)
 650                 freemsg(mp->b_cont);
 651             mp->b_cont = mq;
 652             mq->b_cont = 0;
 653             pip = (struct ppp_idle *) mq->b_wptr;
 654             pip->xmit_idle = time - ppa->last_sent;
 655             pip->recv_idle = time - ppa->last_recv;
 656             mq->b_wptr += sizeof(struct ppp_idle);
 657             iop->ioc_count = sizeof(struct ppp_idle);
 658             error = 0;
 659             break;
 660
 661 #ifdef LACHTCP
 662         case SIOCSIFNAME:
 663             printf("SIOCSIFNAME\n");
 664             /* Sent from IP down to us.  Attach the ifstats structure.  */
 665             if (iop->ioc_count != sizeof(struct ifreq) || us->ppa == 0)
 666                 break;
 667             ifr = (struct ifreq *)mp->b_cont->b_rptr;
 668             /* Find the unit number in the interface name.  */
 669             for (i = 0; i < IFNAMSIZ; i++) {
 670                 if (ifr->ifr_name[i] == 0 ||
 671                     (ifr->ifr_name[i] >= '0' &&
 672                      ifr->ifr_name[i] <= '9'))
 673                     break;
 674                 else
 675                     us->ifname[i] = ifr->ifr_name[i];
 676             }
 677             us->ifname[i] = 0;
 678
 679             /* Convert the unit number to binary.  */
 680             for (n = 0; i < IFNAMSIZ; i++) {
 681                 if (ifr->ifr_name[i] == 0) {
 682                     break;
 683                 }
 684                 else {
 685                     n = n * 10 + ifr->ifr_name[i] - '0';
 686                 }
 687             }
 688
 689             /* Verify the ppa.  */
 690             if (us->ppa->ppa_id != n)
 691                 break;
 692             ppa = us->ppa;
 693
 694             /* Set up the netstat block.  */
 695             strncpy (ppa->ifname, us->ifname, IFNAMSIZ);
 696
 697             ppa->ifstats.ifs_name = ppa->ifname;
 698             ppa->ifstats.ifs_unit = n;
 699             ppa->ifstats.ifs_active = us->state != DL_UNBOUND;
 700             ppa->ifstats.ifs_mtu = ppa->mtu;
 701
 702             /* Link in statistics used by netstat.  */
 703             ppa->ifstats.ifs_next = ifstats;
 704             ifstats = &ppa->ifstats;
 705
 706             iop->ioc_count = 0;
 707             error = 0;
 708             break;
 709
 710         case SIOCGIFFLAGS:
 711             printf("SIOCGIFFLAGS\n");
 712             if (!(us->flags & US_CONTROL)) {
 713                 if (us->ppa)
 714                     us = us->ppa;
 715                 else
 716                     break;
 717             }
 718             ((struct iocblk_in *)iop)->ioc_ifflags = us->ifflags;
 719             error = 0;
 720             break;
 721
 722         case SIOCSIFFLAGS:
 723             printf("SIOCSIFFLAGS\n");
 724             if (!(us->flags & US_CONTROL)) {
 725                 if (us->ppa)
 726                     us = us->ppa;
 727                 else
 728                     break;
 729             }
 730             us->ifflags = ((struct iocblk_in *)iop)->ioc_ifflags;
 731             error = 0;
 732             break;
 733
 734         case SIOCSIFADDR:
 735             printf("SIOCSIFADDR\n");
 736             if (!(us->flags & US_CONTROL)) {
 737                 if (us->ppa)
 738                     us = us->ppa;
 739                 else
 740                     break;
 741             }
 742             us->ifflags |= IFF_RUNNING;
 743             ((struct iocblk_in *)iop)->ioc_ifflags |= IFF_RUNNING;
 744             error = 0;
 745             break;
 746
 747         case SIOCGIFNETMASK:
 748         case SIOCSIFNETMASK:
 749         case SIOCGIFADDR:
 750         case SIOCGIFDSTADDR:
 751         case SIOCSIFDSTADDR:
 752         case SIOCGIFMETRIC:
 753             error = 0;
 754             break;
 755 #endif /* LACHTCP */
 756
 757         default:
 758             if (us->ppa == 0 || us->ppa->lowerq == 0)
 759                 break;
 760             us->ioc_id = iop->ioc_id;
 761             error = -1;
 762             switch (iop->ioc_cmd) {
 763             case PPPIO_GETSTAT:
 764             case PPPIO_GETCSTAT:
 765                 if (us->flags & US_LASTMOD) {
 766                     error = EINVAL;
 767                     break;
 768                 }
 769                 putnext(us->ppa->lowerq, mp);
 770                 break;
 771             default:
 772                 if (us->flags & US_PRIV)
 773                     putnext(us->ppa->lowerq, mp);
 774                 else {
 775                     DPRINT1("ppp ioctl %x rejected\n", iop->ioc_cmd);
 776                     error = EPERM;
 777                 }
 778                 break;
 779             }
 780             break;
 781         }
 782
 783         if (error > 0) {
 784             iop->ioc_error = error;
 785             mp->b_datap->db_type = M_IOCNAK;
 786             qreply(q, mp);
 787         } else if (error == 0) {
 788             mp->b_datap->db_type = M_IOCACK;
 789             qreply(q, mp);
 790         }
 791         break;
 792
 793     case M_FLUSH:
 794         if (us->flags & US_DBGLOG)
 795             DPRINT2("ppp/%d: flush %x\n", us->mn, *mp->b_rptr);
 796         if (*mp->b_rptr & FLUSHW)
 797             flushq(q, FLUSHDATA);
 798         if (*mp->b_rptr & FLUSHR) {
 799             *mp->b_rptr &= ~FLUSHW;
 800             qreply(q, mp);
 801         } else
 802             freemsg(mp);
 803         break;
 804
 805     default:
 806         freemsg(mp);
 807         break;
 808     }
 809     return 0;
 810 }
 811
 812 #ifndef NO_DLPI
 813 static void
 814 dlpi_request(q, mp, us)
 815     queue_t *q;
 816     mblk_t *mp;
 817     upperstr_t *us;
 818 {
 819     union DL_primitives *d = (union DL_primitives *) mp->b_rptr;
 820     int size = mp->b_wptr - mp->b_rptr;
 821     mblk_t *reply, *np;
 822     upperstr_t *ppa, *os;
 823     int sap, *ip, len;
 824     dl_info_ack_t *info;
 825     dl_bind_ack_t *ackp;
 826
 827     if (us->flags & US_DBGLOG)
 828         DPRINT3("ppp/%d: dlpi prim %x len=%d\n", us->mn,
 829                 d->dl_primitive, size);
 830     switch (d->dl_primitive) {
 831     case DL_INFO_REQ:
 832         if (size < sizeof(dl_info_req_t))
 833             goto badprim;
 834         if ((reply = allocb(sizeof(dl_info_ack_t), BPRI_HI)) == 0)
 835             break;              /* should do bufcall */
 836         reply->b_datap->db_type = M_PCPROTO;
 837         info = (dl_info_ack_t *) reply->b_wptr;
 838         reply->b_wptr += sizeof(dl_info_ack_t);
 839         bzero((caddr_t) info, sizeof(dl_info_ack_t));
 840         info->dl_primitive = DL_INFO_ACK;
 841         info->dl_max_sdu = PPP_MAXMTU;
 842         info->dl_min_sdu = 1;
 843         info->dl_addr_length = sizeof(ulong);
 844 #ifdef DL_OTHER
 845         info->dl_mac_type = DL_OTHER;
 846 #else
 847         info->dl_mac_type = DL_HDLC;    /* a lie */
 848 #endif
 849         info->dl_current_state = us->state;
 850         info->dl_service_mode = DL_CLDLS;
 851         info->dl_provider_style = DL_STYLE2;
 852 #if DL_CURRENT_VERSION >= 2
 853         info->dl_sap_length = sizeof(ulong);
 854         info->dl_version = DL_CURRENT_VERSION;
 855 #endif
 856         qreply(q, reply);
 857         break;
 858
 859     case DL_ATTACH_REQ:
 860         if (size < sizeof(dl_attach_req_t))
 861             goto badprim;
 862         if (us->state != DL_UNATTACHED || us->ppa != 0) {
 863             dlpi_error(q, DL_ATTACH_REQ, DL_OUTSTATE, 0);
 864             break;
 865         }
 866         for (ppa = ppas; ppa != 0; ppa = ppa->nextppa)
 867             if (ppa->ppa_id == d->attach_req.dl_ppa)
 868                 break;
 869         if (ppa == 0) {
 870             dlpi_error(q, DL_ATTACH_REQ, DL_BADPPA, 0);
 871             break;
 872         }
 873         us->ppa = ppa;
 874         qwriter(q, mp, attach_ppa, PERIM_OUTER);
 875         break;
 876
 877     case DL_DETACH_REQ:
 878         if (size < sizeof(dl_detach_req_t))
 879             goto badprim;
 880         if (us->state != DL_UNBOUND || us->ppa == 0) {
 881             dlpi_error(q, DL_DETACH_REQ, DL_OUTSTATE, 0);
 882             break;
 883         }
 884         qwriter(q, mp, detach_ppa, PERIM_OUTER);
 885         break;
 886
 887     case DL_BIND_REQ:
 888         if (size < sizeof(dl_bind_req_t))
 889             goto badprim;
 890         if (us->state != DL_UNBOUND || us->ppa == 0) {
 891             dlpi_error(q, DL_BIND_REQ, DL_OUTSTATE, 0);
 892             break;
 893         }
 894         if (d->bind_req.dl_service_mode != DL_CLDLS) {
 895             dlpi_error(q, DL_BIND_REQ, DL_UNSUPPORTED, 0);
 896             break;
 897         }
 898
 899         /* saps must be valid PPP network protocol numbers,
 900            except that we accept ETHERTYPE_IP in place of PPP_IP. */
 901         sap = d->bind_req.dl_sap;
 902         us->req_sap = sap;
 903         DPRINT1("ppp bind %x\n", sap);
 904         if (sap == ETHERTYPE_IP)
 905             sap = PPP_IP;
 906         if (sap < 0x21 || sap > 0x3fff || (sap & 0x101) != 1) {
 907             dlpi_error(q, DL_BIND_REQ, DL_BADADDR, 0);
 908             break;
 909         }
 910
 911         /* check that no other stream is bound to this sap already. */
 912         for (os = us->ppa; os != 0; os = os->next)
 913             if (os->sap == sap)
 914                 break;
 915         if (os != 0) {
 916             dlpi_error(q, DL_BIND_REQ, DL_NOADDR, 0);
 917             break;
 918         }
 919
 920         us->sap = sap;
 921         us->state = DL_IDLE;
 922
 923         if ((reply = allocb(sizeof(dl_bind_ack_t) + sizeof(ulong),
 924                             BPRI_HI)) == 0)
 925             break;              /* should do bufcall */
 926         ackp = (dl_bind_ack_t *) reply->b_wptr;
 927         reply->b_wptr += sizeof(dl_bind_ack_t) + sizeof(ulong);
 928         reply->b_datap->db_type = M_PCPROTO;
 929         bzero((caddr_t) ackp, sizeof(dl_bind_ack_t));
 930         ackp->dl_primitive = DL_BIND_ACK;
 931         ackp->dl_sap = sap;
 932         ackp->dl_addr_length = sizeof(ulong);
 933         ackp->dl_addr_offset = sizeof(dl_bind_ack_t);
 934         *(ulong *)(ackp+1) = sap;
 935         qreply(q, reply);
 936         break;
 937
 938     case DL_UNBIND_REQ:
 939         if (size < sizeof(dl_unbind_req_t))
 940             goto badprim;
 941         if (us->state != DL_IDLE) {
 942             dlpi_error(q, DL_UNBIND_REQ, DL_OUTSTATE, 0);
 943             break;
 944         }
 945         us->sap = -1;
 946         us->state = DL_UNBOUND;
 947 #ifdef LACHTCP
 948         us->ppa->ifstats.ifs_active = 0;
 949 #endif
 950         dlpi_ok(q, DL_UNBIND_REQ);
 951         break;
 952
 953     case DL_UNITDATA_REQ:
 954         if (size < sizeof(dl_unitdata_req_t))
 955             goto badprim;
 956         if (us->state != DL_IDLE) {
 957             dlpi_error(q, DL_UNITDATA_REQ, DL_OUTSTATE, 0);
 958             break;
 959         }
 960         if ((ppa = us->ppa) == 0) {
 961             cmn_err(CE_CONT, "ppp: in state dl_idle but ppa == 0?\n");
 962             break;
 963         }
 964         len = mp->b_cont == 0? 0: msgdsize(mp->b_cont);
 965         if (len > ppa->mtu) {
 966             DPRINT2("dlpi data too large (%d > %d)\n", len, ppa->mtu);
 967             break;
 968         }
 969         /* this assumes PPP_HDRLEN <= sizeof(dl_unitdata_req_t) */
 970         if (mp->b_datap->db_ref > 1) {
 971             np = allocb(PPP_HDRLEN, BPRI_HI);
 972             if (np == 0)
 973                 break;          /* gak! */
 974             np->b_cont = mp->b_cont;
 975             mp->b_cont = 0;
 976             freeb(mp);
 977             mp = np;
 978         } else
 979             mp->b_datap->db_type = M_DATA;
 980         /* XXX should use dl_dest_addr_offset/length here,
 981            but we would have to translate ETHERTYPE_IP -> PPP_IP */
 982         mp->b_wptr = mp->b_rptr + PPP_HDRLEN;
 983         mp->b_rptr[0] = PPP_ALLSTATIONS;
 984         mp->b_rptr[1] = PPP_UI;
 985         mp->b_rptr[2] = us->sap >> 8;
 986         mp->b_rptr[3] = us->sap;
 987         if (!pass_packet(ppa, mp, 1)) {
 988             freemsg(mp);
 989         } else {
 990             if (!send_data(mp, us))
 991                 putq(q, mp);
 992         }
 993         return;
 994
 995 #if DL_CURRENT_VERSION >= 2
 996     case DL_SUBS_BIND_REQ:
 997     case DL_SUBS_UNBIND_REQ:
 998     case DL_ENABMULTI_REQ:
 999     case DL_DISABMULTI_REQ:
1000     case DL_PROMISCON_REQ:
1001     case DL_PROMISCOFF_REQ:
1002     case DL_PHYS_ADDR_REQ:
1003     case DL_SET_PHYS_ADDR_REQ:
1004     case DL_XID_REQ:
1005     case DL_TEST_REQ:
1006     case DL_REPLY_UPDATE_REQ:
1007     case DL_REPLY_REQ:
1008     case DL_DATA_ACK_REQ:
1009 #endif
1010     case DL_CONNECT_REQ:
1011     case DL_TOKEN_REQ:
1012         dlpi_error(q, d->dl_primitive, DL_NOTSUPPORTED, 0);
1013         break;
1014
1015     case DL_CONNECT_RES:
1016     case DL_DISCONNECT_REQ:
1017     case DL_RESET_REQ:
1018     case DL_RESET_RES:
1019         dlpi_error(q, d->dl_primitive, DL_OUTSTATE, 0);
1020         break;
1021
1022     case DL_UDQOS_REQ:
1023         dlpi_error(q, d->dl_primitive, DL_BADQOSTYPE, 0);
1024         break;
1025
1026 #if DL_CURRENT_VERSION >= 2
1027     case DL_TEST_RES:
1028     case DL_XID_RES:
1029         break;
1030 #endif
1031
1032     default:
1033         cmn_err(CE_CONT, "ppp: unknown dlpi prim 0x%x\n", d->dl_primitive);
1034         /* fall through */
1035     badprim:
1036         dlpi_error(q, d->dl_primitive, DL_BADPRIM, 0);
1037         break;
1038     }
1039     freemsg(mp);
1040 }
1041
1042 static void
1043 dlpi_error(q, prim, err, uerr)
1044     queue_t *q;
1045     int prim, err, uerr;
1046 {
1047     mblk_t *reply;
1048     dl_error_ack_t *errp;
1049
1050     reply = allocb(sizeof(dl_error_ack_t), BPRI_HI);
1051     if (reply == 0)
1052         return;                 /* XXX should do bufcall */
1053     reply->b_datap->db_type = M_PCPROTO;
1054     errp = (dl_error_ack_t *) reply->b_wptr;
1055     reply->b_wptr += sizeof(dl_error_ack_t);
1056     errp->dl_primitive = DL_ERROR_ACK;
1057     errp->dl_error_primitive = prim;
1058     errp->dl_errno = err;
1059     errp->dl_unix_errno = uerr;
1060     qreply(q, reply);
1061 }
1062
1063 static void
1064 dlpi_ok(q, prim)
1065     queue_t *q;
1066     int prim;
1067 {
1068     mblk_t *reply;
1069     dl_ok_ack_t *okp;
1070
1071     reply = allocb(sizeof(dl_ok_ack_t), BPRI_HI);
1072     if (reply == 0)
1073         return;                 /* XXX should do bufcall */
1074     reply->b_datap->db_type = M_PCPROTO;
1075     okp = (dl_ok_ack_t *) reply->b_wptr;
1076     reply->b_wptr += sizeof(dl_ok_ack_t);
1077     okp->dl_primitive = DL_OK_ACK;
1078     okp->dl_correct_primitive = prim;
1079     qreply(q, reply);
1080 }
1081 #endif /* NO_DLPI */
1082
1083 static int
1084 pass_packet(ppa, mp, outbound)
1085     upperstr_t *ppa;
1086     mblk_t *mp;
1087     int outbound;
1088 {
1089     /*
1090      * Here is where we might, in future, decide whether to pass
1091      * or drop the packet, and whether it counts as link activity.
1092      */
1093     if (outbound)
1094         ppa->last_sent = time;
1095     else
1096         ppa->last_recv = time;
1097     return 1;
1098 }
1099
1100 static int
1101 send_data(mp, us)
1102     mblk_t *mp;
1103     upperstr_t *us;
1104 {
1105     queue_t *q;
1106     upperstr_t *ppa;
1107
1108     if ((us->flags & US_BLOCKED) || us->npmode == NPMODE_QUEUE)
1109         return 0;
1110     ppa = us->ppa;
1111     if (ppa == 0 || us->npmode == NPMODE_DROP || us->npmode == NPMODE_ERROR) {
1112         if (us->flags & US_DBGLOG)
1113             DPRINT2("ppp/%d: dropping pkt (npmode=%d)\n", us->mn, us->npmode);
1114         freemsg(mp);
1115         return 1;
1116     }
1117     if ((q = ppa->lowerq) == 0) {
1118         /* try to send it up the control stream */
1119         if (canputnext(ppa->q)) {
1120             putnext(ppa->q, mp);
1121             return 1;
1122         }
1123     } else {
1124         if (canputnext(ppa->lowerq)) {
1125             /*
1126              * The lower write queue's put procedure just updates counters
1127              * and does a putnext.  We call it so that on SMP systems, we
1128              * enter the lower queues' perimeter so that the counter
1129              * updates are serialized.
1130              */
1131             put(ppa->lowerq, mp);
1132             return 1;
1133         }
1134     }
1135     us->flags |= US_BLOCKED;
1136     return 0;
1137 }
1138
1139 /*
1140  * Allocate a new PPA id and link this stream into the list of PPAs.
1141  * This procedure is called with an exclusive lock on all queues in
1142  * this driver.
1143  */
1144 static void
1145 new_ppa(q, mp)
1146     queue_t *q;
1147     mblk_t *mp;
1148 {
1149     upperstr_t *us, **usp;
1150     int ppa_id;
1151
1152     usp = &ppas;
1153     ppa_id = 0;
1154     while ((us = *usp) != 0 && ppa_id == us->ppa_id) {
1155         ++ppa_id;
1156         usp = &us->nextppa;
1157     }
1158     us = (upperstr_t *) q->q_ptr;
1159     us->ppa_id = ppa_id;
1160     us->ppa = us;
1161     us->next = 0;
1162     us->nextppa = *usp;
1163     *usp = us;
1164     us->flags |= US_CONTROL;
1165     us->npmode = NPMODE_PASS;
1166
1167     us->mtu = PPP_MRU;
1168     us->mru = PPP_MRU;
1169
1170 #ifdef SOL2
1171     /*
1172      * Create a kstats record for our statistics, so netstat -i works.
1173      */
1174     if (us->kstats == 0) {
1175         char unit[32];
1176
1177         sprintf(unit, "ppp%d", us->ppa->ppa_id);
1178         us->kstats = kstat_create("ppp", us->ppa->ppa_id, unit,
1179                                   "net", KSTAT_TYPE_NAMED, 4, 0);
1180         if (us->kstats != 0) {
1181             kstat_named_t *kn = KSTAT_NAMED_PTR(us->kstats);
1182
1183             strcpy(kn[0].name, "ipackets");
1184             kn[0].data_type = KSTAT_DATA_ULONG;
1185             strcpy(kn[1].name, "ierrors");
1186             kn[1].data_type = KSTAT_DATA_ULONG;
1187             strcpy(kn[2].name, "opackets");
1188             kn[2].data_type = KSTAT_DATA_ULONG;
1189             strcpy(kn[3].name, "oerrors");
1190             kn[3].data_type = KSTAT_DATA_ULONG;
1191             kstat_install(us->kstats);
1192         }
1193     }
1194 #endif /* SOL2 */
1195
1196     *(int *)mp->b_cont->b_rptr = ppa_id;
1197     mp->b_datap->db_type = M_IOCACK;
1198     qreply(q, mp);
1199 }
1200
1201 static void
1202 attach_ppa(q, mp)
1203     queue_t *q;
1204     mblk_t *mp;
1205 {
1206     upperstr_t *us, *t;
1207
1208     us = (upperstr_t *) q->q_ptr;
1209 #ifndef NO_DLPI
1210     us->state = DL_UNBOUND;
1211 #endif
1212     for (t = us->ppa; t->next != 0; t = t->next)
1213         ;
1214     t->next = us;
1215     us->next = 0;
1216     if (mp->b_datap->db_type == M_IOCTL) {
1217         mp->b_datap->db_type = M_IOCACK;
1218         qreply(q, mp);
1219     } else {
1220 #ifndef NO_DLPI
1221         dlpi_ok(q, DL_ATTACH_REQ);
1222 #endif
1223     }
1224 }
1225
1226 static void
1227 detach_ppa(q, mp)
1228     queue_t *q;
1229     mblk_t *mp;
1230 {
1231     upperstr_t *us, *t;
1232
1233     us = (upperstr_t *) q->q_ptr;
1234     for (t = us->ppa; t->next != 0; t = t->next)
1235         if (t->next == us) {
1236             t->next = us->next;
1237             break;
1238         }
1239     us->next = 0;
1240     us->ppa = 0;
1241 #ifndef NO_DLPI
1242     us->state = DL_UNATTACHED;
1243     dlpi_ok(q, DL_DETACH_REQ);
1244 #endif
1245 }
1246
1247 static int
1248 pppuwsrv(q)
1249     queue_t *q;
1250 {
1251     upperstr_t *us;
1252     struct lowerstr *ls;
1253     queue_t *lwq;
1254     mblk_t *mp;
1255
1256     us = (upperstr_t *) q->q_ptr;
1257     us->flags &= ~US_BLOCKED;
1258     while ((mp = getq(q)) != 0) {
1259         if (!send_data(mp, us)) {
1260             putbq(q, mp);
1261             break;
1262         }
1263     }
1264     return 0;
1265 }
1266
1267 static int
1268 ppplwput(q, mp)
1269     queue_t *q;
1270     mblk_t *mp;
1271 {
1272     upperstr_t *ppa;
1273
1274     ppa = (upperstr_t *) q->q_ptr;
1275     if (ppa != 0) {             /* why wouldn't it? */
1276         ppa->stats.ppp_opackets++;
1277         ppa->stats.ppp_obytes += msgdsize(mp);
1278 #ifdef INCR_OPACKETS
1279         INCR_OPACKETS(ppa);
1280 #endif
1281     }
1282     putnext(q, mp);
1283     return 0;
1284 }
1285
1286 static int
1287 ppplwsrv(q)
1288     queue_t *q;
1289 {
1290     upperstr_t *us;
1291
1292     /*
1293      * Flow control has back-enabled this stream:
1294      * enable the write service procedures of all upper
1295      * streams feeding this lower stream.
1296      */
1297     for (us = (upperstr_t *) q->q_ptr; us != NULL; us = us->next)
1298         if (us->flags & US_BLOCKED)
1299             qenable(WR(us->q));
1300     return 0;
1301 }
1302
1303 static int
1304 pppursrv(q)
1305     queue_t *q;
1306 {
1307     upperstr_t *us, *as;
1308     mblk_t *mp, *hdr;
1309 #ifndef NO_DLPI
1310     dl_unitdata_ind_t *ud;
1311 #endif
1312     int proto;
1313
1314     us = (upperstr_t *) q->q_ptr;
1315     if (us->flags & US_CONTROL) {
1316         /*
1317          * A control stream.
1318          * If there is no lower queue attached, run the write service
1319          * routines of other upper streams attached to this PPA.
1320          */
1321         if (us->lowerq == 0) {
1322             as = us;
1323             do {
1324                 if (as->flags & US_BLOCKED)
1325                     qenable(WR(as->q));
1326                 as = as->next;
1327             } while (as != 0);
1328         }
1329     } else {
1330         /*
1331          * A network protocol stream.  Put a DLPI header on each
1332          * packet and send it on.
1333          * (Actually, it seems that the IP module will happily
1334          * accept M_DATA messages without the DL_UNITDATA_IND header.)
1335          */
1336         while ((mp = getq(q)) != 0) {
1337             if (!canputnext(q)) {
1338                 putbq(q, mp);
1339                 break;
1340             }
1341 #ifndef NO_DLPI
1342             proto = PPP_PROTOCOL(mp->b_rptr);
1343             mp->b_rptr += PPP_HDRLEN;
1344             hdr = allocb(sizeof(dl_unitdata_ind_t) + 2 * sizeof(ulong),
1345                          BPRI_MED);
1346             if (hdr == 0) {
1347                 /* XXX should put it back and use bufcall */
1348                 freemsg(mp);
1349                 continue;
1350             }
1351             hdr->b_datap->db_type = M_PROTO;
1352             ud = (dl_unitdata_ind_t *) hdr->b_wptr;
1353             hdr->b_wptr += sizeof(dl_unitdata_ind_t) + 2 * sizeof(ulong);
1354             hdr->b_cont = mp;
1355             ud->dl_primitive = DL_UNITDATA_IND;
1356             ud->dl_dest_addr_length = sizeof(ulong);
1357             ud->dl_dest_addr_offset = sizeof(dl_unitdata_ind_t);
1358             ud->dl_src_addr_length = sizeof(ulong);
1359             ud->dl_src_addr_offset = ud->dl_dest_addr_offset + sizeof(ulong);
1360 #if DL_CURRENT_VERSION >= 2
1361             ud->dl_group_address = 0;
1362 #endif
1363             /* Send the DLPI client the data with the SAP they requested,
1364                (e.g. ETHERTYPE_IP) rather than the PPP protocol number
1365                (e.g. PPP_IP) */
1366             ((ulong *)(ud + 1))[0] = us->req_sap;       /* dest SAP */
1367             ((ulong *)(ud + 1))[1] = us->req_sap;       /* src SAP */
1368             putnext(q, hdr);
1369 #else /* NO_DLPI */
1370             putnext(q, mp);
1371 #endif /* NO_DLPI */
1372         }
1373     }
1374
1375     /*
1376      * If this stream is attached to a PPA with a lower queue pair,
1377      * enable the read queue's service routine if it has data queued.
1378      * XXX there is a possibility that packets could get out of order
1379      * if ppplrput now runs before ppplrsrv.
1380      */
1381     if (us->ppa != 0 && us->ppa->lowerq != 0)
1382         qenable(RD(us->ppa->lowerq));
1383
1384     return 0;
1385 }
1386
1387 static upperstr_t *
1388 find_dest(ppa, proto)
1389     upperstr_t *ppa;
1390     int proto;
1391 {
1392     upperstr_t *us;
1393
1394     for (us = ppa->next; us != 0; us = us->next)
1395         if (proto == us->sap)
1396             break;
1397     return us;
1398 }
1399
1400 static int
1401 ppplrput(q, mp)
1402     queue_t *q;
1403     mblk_t *mp;
1404 {
1405     upperstr_t *ppa, *us;
1406     queue_t *uq;
1407     int proto, len;
1408     mblk_t *np;
1409     struct iocblk *iop;
1410
1411     ppa = (upperstr_t *) q->q_ptr;
1412     if (ppa == 0) {
1413         DPRINT1("ppplrput: q = %x, ppa = 0??\n", q);
1414         freemsg(mp);
1415         return 0;
1416     }
1417     switch (mp->b_datap->db_type) {
1418     case M_FLUSH:
1419         if (*mp->b_rptr & FLUSHW) {
1420             *mp->b_rptr &= ~FLUSHR;
1421             qreply(q, mp);
1422         } else
1423             freemsg(mp);
1424         break;
1425
1426     case M_CTL:
1427         switch (*mp->b_rptr) {
1428         case PPPCTL_IERROR:
1429 #ifdef INCR_IERRORS
1430             INCR_IERRORS(ppa);
1431 #endif
1432             ppa->stats.ppp_ierrors++;
1433             break;
1434         case PPPCTL_OERROR:
1435 #ifdef INCR_OERRORS
1436             INCR_OERRORS(ppa);
1437 #endif
1438             ppa->stats.ppp_oerrors++;
1439             break;
1440         }
1441         freemsg(mp);
1442         break;
1443
1444     case M_IOCACK:
1445     case M_IOCNAK:
1446         /*
1447          * Attempt to match up the response with the stream
1448          * that the request came from.
1449          */
1450         iop = (struct iocblk *) mp->b_rptr;
1451         for (us = ppa; us != 0; us = us->next)
1452             if (us->ioc_id == iop->ioc_id)
1453                 break;
1454         if (us == 0)
1455             freemsg(mp);
1456         else
1457             putnext(us->q, mp);
1458         break;
1459
1460     default:
1461         if (mp->b_datap->db_type == M_DATA) {
1462             len = msgdsize(mp);
1463             if (mp->b_wptr - mp->b_rptr < PPP_HDRLEN) {
1464                 PULLUP(mp, PPP_HDRLEN);
1465                 if (mp == 0) {
1466                     DPRINT1("ppp_lrput: msgpullup failed (len=%d)\n", len);
1467                     break;
1468                 }
1469             }
1470             ppa->stats.ppp_ipackets++;
1471             ppa->stats.ppp_ibytes += len;
1472 #ifdef INCR_IPACKETS
1473             INCR_IPACKETS(ppa);
1474 #endif
1475             if (!pass_packet(ppa, mp, 0)) {
1476                 freemsg(mp);
1477                 break;
1478             }
1479             proto = PPP_PROTOCOL(mp->b_rptr);
1480             if (proto < 0x8000 && (us = find_dest(ppa, proto)) != 0) {
1481                 /*
1482                  * A data packet for some network protocol.
1483                  * Queue it on the upper stream for that protocol.
1484                  */
1485                 if (canput(us->q))
1486                     putq(us->q, mp);
1487                 else
1488                     putq(q, mp);
1489                 break;
1490             }
1491         }
1492         /*
1493          * A control frame, a frame for an unknown protocol,
1494          * or some other message type.
1495          * Send it up to pppd via the control stream.
1496          */
1497         if (queclass(mp) == QPCTL || canputnext(ppa->q))
1498             putnext(ppa->q, mp);
1499         else
1500             putq(q, mp);
1501         break;
1502     }
1503
1504     return 0;
1505 }
1506
1507 static int
1508 ppplrsrv(q)
1509     queue_t *q;
1510 {
1511     mblk_t *mp;
1512     upperstr_t *ppa, *us;
1513     int proto;
1514
1515     /*
1516      * Packets only get queued here for flow control reasons.
1517      */
1518     ppa = (upperstr_t *) q->q_ptr;
1519     while ((mp = getq(q)) != 0) {
1520         if (mp->b_datap->db_type == M_DATA
1521             && (proto = PPP_PROTOCOL(mp->b_rptr)) < 0x8000
1522             && (us = find_dest(ppa, proto)) != 0) {
1523             if (canput(us->q))
1524                 putq(us->q, mp);
1525             else {
1526                 putbq(q, mp);
1527                 break;
1528             }
1529         } else {
1530             if (canputnext(ppa->q))
1531                 putnext(ppa->q, mp);
1532             else {
1533                 putbq(q, mp);
1534                 break;
1535             }
1536         }
1537     }
1538     return 0;
1539 }
1540
1541 static int
1542 putctl2(q, type, code, val)
1543     queue_t *q;
1544     int type, code, val;
1545 {
1546     mblk_t *mp;
1547
1548     mp = allocb(2, BPRI_HI);
1549     if (mp == 0)
1550         return 0;
1551     mp->b_datap->db_type = type;
1552     mp->b_wptr[0] = code;
1553     mp->b_wptr[1] = val;
1554     mp->b_wptr += 2;
1555     putnext(q, mp);
1556     return 1;
1557 }
1558
1559 static int
1560 putctl4(q, type, code, val)
1561     queue_t *q;
1562     int type, code, val;
1563 {
1564     mblk_t *mp;
1565
1566     mp = allocb(4, BPRI_HI);
1567     if (mp == 0)
1568         return 0;
1569     mp->b_datap->db_type = type;
1570     mp->b_wptr[0] = code;
1571     ((short *)mp->b_wptr)[1] = val;
1572     mp->b_wptr += 4;
1573     putnext(q, mp);
1574     return 1;
1575 }
1576
1577 static void
1578 debug_dump(q, mp)
1579     queue_t *q;                 /* not used */
1580     mblk_t *mp;                 /* not used either */
1581 {
1582     upperstr_t *us;
1583     queue_t *uq, *lq;
1584
1585     DPRINT("ppp upper streams:\n");
1586     for (us = minor_devs; us != 0; us = us->nextmn) {
1587         uq = us->q;
1588         DPRINT3(" %d: q=%x rlev=%d",
1589                 us->mn, uq, (uq? qsize(uq): 0));
1590         DPRINT3(" wlev=%d flags=0x%b", (uq? qsize(WR(uq)): 0),
1591                 us->flags, "\020\1priv\2control\3blocked\4last");
1592         DPRINT3(" state=%x sap=%x req_sap=%x", us->state, us->sap,
1593                 us->req_sap);
1594         if (us->ppa == 0)
1595             DPRINT(" ppa=?\n");
1596         else
1597             DPRINT1(" ppa=%d\n", us->ppa->ppa_id);
1598         if (us->flags & US_CONTROL) {
1599             lq = us->lowerq;
1600             DPRINT3("    control for %d lq=%x rlev=%d",
1601                     us->ppa_id, lq, (lq? qsize(RD(lq)): 0));
1602             DPRINT3(" wlev=%d mru=%d mtu=%d\n",
1603                     (lq? qsize(lq): 0), us->mru, us->mtu);
1604         }
1605     }
1606 }