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