osf1/ppp_if.c

   1 /*
   2   ppp_if.c - Streams PPP interface module
   3
   4   top level module handles if_ and packetizing PPP packets.
   5
   6   Copyright (C) 1990  Brad K. Clements, All Rights Reserved
   7   See copyright notice in NOTES
   8
   9   $Id: ppp_if.c,v 1.1 1995/12/18 23:45:11 paulus Exp $
  10 */
  11
  12 /*
  13  * This file is used under SunOS 4.x, and OSF/1 on DEC Alpha.
  14  *
  15  * Beware that under OSF/1, the ioctl constants (SIOC*) end up
  16  * as 64-bit (long) values, so an ioctl constant should be cast to
  17  * int (32 bits) before being compared with the ioc_cmd field of
  18  * an iocblk structure.
  19  */
  20
  21 #define VJC     1
  22 #include <sys/types.h>
  23
  24 #ifndef PPP_VD
  25 #include "ppp.h"
  26 #endif
  27
  28 #if NPPP > 0
  29
  30 #define PPP_STATS       1       /* keep statistics */
  31 #define DEBUGS          1       /* include debug code */
  32
  33 #ifdef __osf__
  34 #include <sys/proc.h>
  35 #define NOTSUSER        (suser(u.u_procp->p_rcred, &u.u_acflag))
  36 #define IFA_ADDR(ifa)   (*(ifa)->ifa_addr)
  37 #define ifr_mtu ifr_metric
  38 #define SIOCSIFMTU SIOCSIPMTU
  39 #define SIOCGIFMTU SIOCRIPMTU
  40 #endif
  41
  42 #ifdef sun
  43 #define PPP_SNIT        1       /* support Streams Network Interface Tap */
  44 #define NOTSUSER        (!suser())
  45 #define MHLEN           MLEN
  46 #define MGETHDR         MGET
  47 #define m_data          m_off   /* well almost */
  48 #define IFA_ADDR(ifa)   ((ifa)->ifa_addr)
  49 #endif
  50
  51 #include <sys/param.h>
  52 #include <sys/stream.h>
  53 #include <sys/stropts.h>
  54
  55 #include <sys/user.h>
  56 #include <sys/systm.h>
  57 #include <sys/mbuf.h>
  58 #include <sys/socket.h>
  59 #include <sys/errno.h>
  60 #include <sys/ioctl.h>
  61 #include <sys/file.h>
  62 #include <sys/uio.h>
  63 #include <net/if.h>
  64 #include <net/route.h>
  65 #include <net/netisr.h>
  66 #include <netinet/in.h>
  67 #include <netinet/in_systm.h>
  68 #include <netinet/in_var.h>
  69 #include <netinet/ip.h>
  70
  71 #include <net/ppp_defs.h>
  72 #include <net/ppp_str.h>
  73
  74 #ifdef  VJC
  75 #include <net/vjcompress.h>
  76 #endif
  77
  78 #ifdef  PPP_STATS
  79 #define INCR(comp)      ++p->pii_stats.comp
  80 #else
  81 #define INCR(comp)
  82 #endif
  83
  84 #define MAX_PKTSIZE     4096    /* max packet size including framing */
  85 #define PPP_FRAMING     6       /* 4-byte header + 2-byte FCS */
  86 #define MAX_IPHDR       128     /* max TCP/IP header size */
  87 #define MAX_VJHDR       20      /* max VJ compressed header size (?) */
  88
  89 /*
  90  * Network protocols we support.
  91  */
  92 #define NP_IP           0
  93 #define NUM_NP          1       /* # protocols supported */
  94
  95 /*
  96  * Structure used within the ppp_if streams module.
  97  */
  98 struct ppp_if_info {
  99     int                 pii_flags;
 100     struct ifnet        pii_ifnet;
 101     queue_t             *pii_writeq;    /* used by ppp_output */
 102     enum NPmode         pii_npmode[NUM_NP];
 103     mblk_t              *pii_npq;       /* list of packets queued up */
 104     mblk_t              **pii_npq_tail;
 105 #ifdef  VJC
 106     struct vjcompress   pii_sc_comp;    /* vjc control buffer */
 107 #endif
 108 #ifdef  PPP_STATS
 109     struct pppstat      pii_stats;
 110 #endif
 111     struct ppp_comp_stats pii_cstats;
 112 };
 113
 114 /*
 115  * Values for pii_flags.
 116  */
 117 #define PII_FLAGS_INUSE         0x1     /* in use by  a stream  */
 118 #define PII_FLAGS_ATTACHED      0x8     /* already if_attached  */
 119 #define PII_FLAGS_VJC_ON        0x10    /* VJ TCP header compression enabled */
 120 #define PII_FLAGS_VJC_NOCCID    0x20    /* VJ: don't compress conn. id */
 121 #define PII_FLAGS_VJC_REJ       0x40    /* receive: reject VJ comp */
 122 #define PII_FLAGS_DEBUG         0x80    /* enable debug printout */
 123
 124 #ifdef  DEBUGS
 125 #include <sys/syslog.h>
 126 #define DLOG(s,a)       if (p->pii_flags&PII_FLAGS_DEBUG) log(LOG_DEBUG, s, a)
 127 #else
 128 #define DLOG(s) {}
 129 #endif
 130
 131 #ifdef PPP_SNIT
 132 #include <net/nit_if.h>
 133 #include <netinet/if_ether.h>
 134 /* Use a fake link level header to make etherfind and tcpdump happy. */
 135 static struct ether_header header = {{1}, {2}, ETHERTYPE_IP};
 136 static struct nit_if nif = {(caddr_t)&header, sizeof(header), 0, 0};
 137 #endif
 138
 139 static  int     ppp_if_open(), ppp_if_close(), ppp_if_rput(), ppp_if_wput(),
 140                 ppp_if_wsrv(), ppp_if_rsrv();
 141
 142 static  struct  module_info     minfo ={
 143         0xbad,"ppp_if",0, INFPSZ, 16384, 4096
 144 };
 145
 146 static  struct  qinit   r_init = {
 147         ppp_if_rput, ppp_if_rsrv, ppp_if_open, ppp_if_close, NULL, &minfo, NULL
 148 };
 149 static  struct  qinit   w_init = {
 150         ppp_if_wput, ppp_if_wsrv, ppp_if_open, ppp_if_close, NULL, &minfo, NULL
 151 };
 152 struct  streamtab       ppp_ifinfo = {
 153         &r_init, &w_init, NULL, NULL,
 154 };
 155
 156 typedef struct ppp_if_info      PII;
 157
 158 PII     pii[NPPP];
 159
 160 int ppp_output(), ppp_ioctl();
 161 static void if_release_addrs(), if_delete_route();
 162
 163 int
 164 ppp_attach()
 165 {
 166     int unit;
 167     register struct ifnet *ifp;
 168
 169     for (unit = 0; unit < NPPP; ++unit) {
 170         if (pii[unit].pii_flags & PII_FLAGS_ATTACHED)
 171             continue;
 172         ifp = &pii[unit].pii_ifnet;
 173
 174         ifp->if_name = "ppp";
 175         ifp->if_mtu  = PPP_MTU;
 176         ifp->if_flags = IFF_POINTOPOINT;
 177         ifp->if_unit  = unit;
 178         ifp->if_ioctl = ppp_ioctl;
 179         ifp->if_output = ppp_output;
 180 #ifdef __osf__
 181         ifp->if_version = "2.2";
 182         ifp->if_mediamtu = PPP_MTU;
 183         ifp->if_start = NULL;
 184         ifp->if_done = NULL;
 185         ifp->if_type = 0x1d;  /* IFT_PPP snagged from BSD -- is this ok? */
 186         ifp->if_hdrlen = PPP_HDRLEN;
 187 #endif
 188         ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
 189         if_attach(ifp);
 190         pii[unit].pii_flags |= PII_FLAGS_ATTACHED;
 191     }
 192 }
 193
 194
 195 int
 196 ppp_unattach()
 197 {
 198     int unit;
 199     register struct ifnet *ifp;
 200     register struct ifnet **p;
 201     int s;
 202
 203     for (unit = 0; unit < NPPP; ++unit) {
 204         if (!(pii[unit].pii_flags & PII_FLAGS_ATTACHED))
 205             continue;
 206         ifp = &pii[unit].pii_ifnet;
 207
 208         /* remove interface from interface list */
 209         s = splimp();
 210         for (p = &ifnet; *p; p = &((*p)->if_next)) {
 211             if (*p == ifp) {
 212                 *p = (*p)->if_next;
 213
 214                 /* mark it down and flush it's que */
 215                 if_down(ifp);
 216
 217                 /* free any addresses hanging off the intf */
 218                 if_release_addrs(ifp);
 219
 220                 pii[unit].pii_flags &= ~PII_FLAGS_ATTACHED;
 221
 222                 break;
 223             }
 224         }
 225         (void)splx(s);
 226     }
 227 }
 228
 229
 230 static void
 231 if_release_addrs(ifp)
 232 register struct ifnet *ifp;
 233 {
 234     register struct in_ifaddr **addr;
 235     register struct ifaddr *ifa, *ifanxt;
 236     register int s;
 237
 238     if_delete_route(ifp);
 239
 240     for (addr = &in_ifaddr; *addr; ) {
 241         if ((*addr)->ia_ifp == ifp)
 242             *addr = (*addr)->ia_next;
 243         else
 244             addr = &((*addr)->ia_next);
 245     }
 246
 247     /*
 248      * Free all mbufs holding down this interface's address(es).
 249      */
 250     for (ifa = ifp->if_addrlist; ifa; ifa = ifanxt) {
 251         ifanxt = ifa->ifa_next;
 252         m_free(dtom(ifa));
 253     }
 254     ifp->if_addrlist = 0;
 255 }
 256
 257 /*
 258  * Delete routes to the specified interface.
 259  * Hacked from rtrequest().
 260  */
 261 static void
 262 if_delete_route(ifp)
 263 struct ifnet *ifp;
 264 {
 265     extern int rttrash;         /* routes not in table but not freed */
 266     register struct mbuf **mprev, *m;
 267     register struct rtentry *route;
 268     register int i;
 269
 270     /* search host rt tbl */
 271     for (i = 0; i < RTHASHSIZ; i++) {
 272         mprev = &rthost[i];
 273         while (m = *mprev) {
 274             route = mtod(m, struct rtentry *);
 275             if (route->rt_ifp == ifp) {
 276                 *mprev = m->m_next;
 277                 if (route->rt_refcnt > 0) {
 278                     route->rt_flags &= ~RTF_UP;
 279                     rttrash++;
 280                     m->m_next = 0;
 281                 } else {
 282                     m_free(m);
 283                 }
 284             } else
 285                 mprev = &m->m_next;
 286         }
 287     }
 288
 289     /* search net rt tbl */
 290     for (i = 0; i < RTHASHSIZ; i++) {
 291         mprev = &rtnet[i];
 292         while (m = *mprev) {
 293             route = mtod(m, struct rtentry *);
 294             if (route->rt_ifp == ifp) {
 295                 *mprev = m->m_next;
 296                 if (route->rt_refcnt > 0) {
 297                     route->rt_flags &= ~RTF_UP;
 298                     rttrash++;
 299                     m->m_next = 0;
 300                 } else {
 301                     m_free(m);
 302                 }
 303             } else
 304                 mprev = &m->m_next;
 305         }
 306     }
 307 }
 308
 309 int
 310 ppp_busy()
 311 {
 312     int x;
 313
 314     for (x = 0; x < NPPP; x++) {
 315         if (pii[x].pii_flags & PII_FLAGS_INUSE)
 316             return 1;
 317     }
 318     return 0;
 319 }
 320
 321 static PII *
 322 ppp_if_alloc()
 323 {
 324     int s, x;
 325     PII *p;
 326
 327     s = splstr();
 328     for (x = 0; x < NPPP; x++)
 329         if (!(pii[x].pii_flags & PII_FLAGS_INUSE))
 330             break;
 331     if (x == NPPP) {            /* all buffers in use */
 332         splx(s);                        /* restore processor state */
 333         return NULL;
 334     }
 335     p = &pii[x];
 336     p->pii_flags |= PII_FLAGS_INUSE;
 337     splx(s);
 338     return p;
 339 }
 340
 341 static void
 342 ppp_if_init(q, p)
 343     queue_t *q;
 344     PII *p;
 345 {
 346     int s, n;
 347
 348     s = splstr();
 349
 350 #ifdef  VJC
 351     vj_compress_init(&p->pii_sc_comp, -1);
 352 #endif
 353 #ifdef  PPP_STATS
 354     bzero(&p->pii_stats, sizeof(p->pii_stats));
 355 #endif
 356     if (!(p->pii_flags & PII_FLAGS_ATTACHED))
 357         ppp_attach();                   /* attach it */
 358     else
 359         p->pii_ifnet.if_mtu = PPP_MTU;
 360     p->pii_writeq = WR(q);
 361     /* set write Q and read Q to point here */
 362     WR(q)->q_ptr = q->q_ptr = (caddr_t) p;
 363     p->pii_ifnet.if_flags |= IFF_RUNNING;
 364     p->pii_flags &= PII_FLAGS_INUSE | PII_FLAGS_ATTACHED | PII_FLAGS_DEBUG;
 365     for (n = 0; n < NUM_NP; ++n)
 366         p->pii_npmode[n] = NPMODE_ERROR;
 367     p->pii_npmode[NP_IP] = NPMODE_PASS; /* for backwards compatibility */
 368     p->pii_npq = NULL;
 369     p->pii_npq_tail = &p->pii_npq;
 370
 371     splx(s);
 372     DLOG("ppp_if%d: init\n", p - pii);
 373 }
 374
 375 static int
 376 ppp_if_open(q, dev, flag, sflag)
 377     queue_t     *q;
 378     dev_t       dev;
 379     int         flag, sflag;
 380
 381 {
 382     if (NOTSUSER) {
 383         u.u_error = EPERM;
 384         return (OPENFAIL);
 385     }
 386
 387     return (0);
 388 }
 389
 390 static int
 391 ppp_if_close(q)
 392     queue_t     *q;                     /* queue info */
 393 {
 394     PII *p = (PII *) q->q_ptr;
 395     int s, n;
 396     mblk_t *mp, *mq;
 397
 398     if (p != NULL) {
 399         s = splimp();
 400         if_down(&p->pii_ifnet);
 401         p->pii_ifnet.if_flags &= ~IFF_RUNNING;
 402         p->pii_flags &= ~PII_FLAGS_INUSE;
 403         q->q_ptr = NULL;
 404         splx(s);
 405         for (mp = p->pii_npq; mp != NULL; mp = mq) {
 406             mq = mp->b_next;
 407             freemsg(mp);
 408         }
 409         p->pii_npq = NULL;
 410         p->pii_npq_tail = &p->pii_npq;
 411         p->pii_writeq = NULL;
 412         DLOG("ppp_if%d: closed\n", p - pii);
 413     }
 414     return(0);                  /* no work to be done */
 415 }
 416
 417
 418 static int
 419 ppp_if_wput(q, mp)
 420     queue_t  *q;
 421     register mblk_t *mp;
 422 {
 423     register struct iocblk *i;
 424     register PII *p;
 425     int bits, flags, error, unit, s;
 426     queue_t *oq;
 427     int npix;
 428     struct npioctl *npi;
 429     mblk_t *mq, **mqnext;
 430     struct ppp_stats *psp;
 431
 432     switch (mp->b_datap->db_type) {
 433
 434     case M_FLUSH:
 435         if (*mp->b_rptr & FLUSHW)
 436             flushq(q, FLUSHDATA);
 437         putnext(q, mp);         /* send it along too */
 438         break;
 439
 440     case M_DATA:
 441         putq(q, mp);    /* queue it for my service routine */
 442         break;
 443
 444     case M_IOCTL:
 445         i = (struct iocblk *) mp->b_rptr;
 446         p = (PII *) q->q_ptr;
 447         switch (i->ioc_cmd) {
 448
 449         case SIOCSIFVJCOMP:     /* enable or disable VJ compression */
 450 #ifdef  VJC
 451             if (i->ioc_count == sizeof(u_char) && p != NULL) {
 452                 bits = *(u_char *) mp->b_cont->b_rptr;
 453                 DLOG("ppp_if: SIFVJCOMP %d\n", bits);
 454                 if (bits & 1)
 455                     p->pii_flags |= PII_FLAGS_VJC_ON;
 456                 else
 457                     p->pii_flags &= ~PII_FLAGS_VJC_ON;
 458                 if (bits & 2)
 459                     p->pii_flags |= PII_FLAGS_VJC_NOCCID;
 460                 else
 461                     p->pii_flags &= ~PII_FLAGS_VJC_NOCCID;
 462                 if (bits & 4)
 463                     p->pii_flags |= PII_FLAGS_VJC_REJ;
 464                 else
 465                     p->pii_flags &= ~PII_FLAGS_VJC_REJ;
 466                 bits >>= 4;             /* now max conn id. */
 467                 if (bits)
 468                     vj_compress_init(&p->pii_sc_comp, bits);
 469                 mp->b_datap->db_type = M_IOCACK;
 470                 i->ioc_count = 0;
 471                 qreply(q, mp);
 472                 break;
 473             }
 474 #endif
 475             putnext(q, mp);
 476             break;
 477
 478         case SIOCGETU:  /* get unit number */
 479             /*
 480              * Allocate a unit if we don't already have one.
 481              */
 482             error = 0;
 483             if (p == NULL) {
 484                 p = ppp_if_alloc();
 485                 if (p == NULL)
 486                     error = ENOBUFS;
 487                 else
 488                     ppp_if_init(RD(q), p);
 489             }
 490             if (error == 0
 491                 && (mp->b_cont = allocb(sizeof(int), BPRI_MED)) == NULL)
 492                 error = ENOSR;
 493             if (error == 0) {
 494                 *(int *) mp->b_cont->b_wptr = p->pii_ifnet.if_unit;
 495                 mp->b_cont->b_wptr += i->ioc_count = sizeof(int);
 496                 mp->b_datap->db_type = M_IOCACK;
 497             } else {
 498                 i->ioc_error = error;
 499                 i->ioc_count = 0;
 500                 mp->b_datap->db_type = M_IOCNAK;
 501             }
 502             qreply(q,mp);
 503             break;
 504
 505         case SIOCSETU:  /* set unit number */
 506             if (i->ioc_count == sizeof(int)) {
 507                 unit = *(int *)mp->b_cont->b_rptr;
 508                 if (p != NULL || (unsigned) unit > NPPP) {
 509                     mp->b_datap->db_type = M_IOCNAK;
 510                     i->ioc_error = EINVAL;
 511                     i->ioc_count = 0;
 512                     error = EINVAL;
 513                 } else {
 514                     p = &pii[unit];
 515                     if (p->pii_flags & PII_FLAGS_INUSE) {
 516                         oq = p->pii_writeq;
 517                         oq->q_ptr = RD(oq)->q_ptr = NULL;
 518                         q->q_ptr = RD(q)->q_ptr = (caddr_t) p;
 519                         p->pii_writeq = q;
 520                     } else {
 521                         ppp_if_init(RD(q), p);
 522                     }
 523                     mp->b_datap->db_type = M_IOCACK;
 524                 }
 525                 qreply(q, mp);
 526                 break;
 527             }
 528             putnext(q, mp);
 529             break;
 530
 531         case SIOCSIFDEBUG :
 532             /* catch it on the way past to set our debug flag as well */
 533             if (i->ioc_count == sizeof(int)) {
 534                 flags = *(int *)mp->b_cont->b_rptr;
 535                 if (flags & 1)
 536                     p->pii_flags |= PII_FLAGS_DEBUG;
 537                 else
 538                     p->pii_flags &= ~PII_FLAGS_DEBUG;
 539             }
 540             putnext(q, mp);
 541             break;
 542
 543         case SIOCGETNPMODE:
 544         case SIOCSETNPMODE:
 545             if (i->ioc_count == sizeof(struct npioctl) && p != NULL) {
 546                 npi = (struct npioctl *) mp->b_cont->b_rptr;
 547                 switch (npi->protocol) {
 548                 case PPP_IP:
 549                     npix = NP_IP;
 550                     break;
 551                 default:
 552                     npix = -1;
 553                 }
 554                 if (npix < 0) {
 555                     i->ioc_error = EAFNOSUPPORT;
 556                     i->ioc_count = 0;
 557                     mp->b_datap->db_type = M_IOCNAK;
 558                     qreply(q, mp);
 559                     break;
 560                 }
 561                 if (i->ioc_cmd == (int) SIOCSETNPMODE) {
 562                     if (p->pii_npmode[npix] == NPMODE_QUEUE
 563                         && npi->mode != NPMODE_QUEUE) {
 564                         for (mqnext = &p->pii_npq; (mq = *mqnext) != NULL; ) {
 565                             if (PPP_PROTOCOL(mq->b_rptr) != npi->protocol){
 566                                 mqnext = &mq->b_next;
 567                                 continue;
 568                             }
 569                             *mqnext = mq->b_next;
 570                             if (npi->mode == NPMODE_PASS) {
 571                                 putq(q, mq); /* q it for service routine */
 572                             } else {
 573                                 freemsg(mq);
 574                             }
 575                         }
 576                         p->pii_npq_tail = mqnext;
 577                     }
 578                     p->pii_npmode[npix] = npi->mode;
 579                     i->ioc_count = 0;
 580                 } else
 581                     npi->mode = p->pii_npmode[npix];
 582                 mp->b_datap->db_type = M_IOCACK;
 583                 qreply(q, mp);
 584                 break;
 585             }
 586             putnext(q, mp);
 587             break;
 588
 589         default:                /* unknown IOCTL call */
 590             putnext(q, mp);     /* pass it along */
 591         }
 592         break;
 593
 594     default:
 595         putnext(q, mp); /* don't know what to do with this, so send it along*/
 596     }
 597 }
 598
 599 static int
 600 ppp_if_wsrv(q)
 601     queue_t     *q;
 602 {
 603     register mblk_t *mp;
 604     register PII *p;
 605
 606     p = (PII *) q->q_ptr;
 607
 608     while ((mp = getq(q)) != NULL) {
 609         /*
 610          * we can only get M_DATA types into our Queue,
 611          * due to our Put function
 612          */
 613         if (!canput(q->q_next)) {
 614             putbq(q, mp);
 615             return;
 616         }
 617
 618         /* increment count of outgoing packets */
 619         if (p != NULL)
 620             INCR(ppp_opackets);
 621
 622         /* just pass it along, nothing to do in this direction */
 623         putnext(q, mp);
 624     }   /* end while */
 625 }
 626
 627
 628 static int
 629 ppp_if_rput(q, mp)
 630     queue_t *q;
 631     register mblk_t *mp;
 632 {
 633     register PII *p;
 634
 635     switch (mp->b_datap->db_type) {
 636
 637     case M_FLUSH:
 638         if (*mp->b_rptr & FLUSHR)
 639             flushq(q, FLUSHDATA);
 640         putnext(q, mp);         /* send it along too */
 641         break;
 642
 643     case M_DATA:
 644         putq(q, mp);            /* queue it for my service routine */
 645         break;
 646
 647     case M_CTL:
 648         p = (PII *) q->q_ptr;
 649         if (p != NULL) {
 650             switch (*(u_char *) mp->b_rptr) {
 651             case IF_INPUT_ERROR:
 652                 p->pii_ifnet.if_ierrors++;
 653                 INCR(ppp_ierrors);
 654                 DLOG("ppp_if: input error inc to %d\n",
 655                      p->pii_ifnet.if_ierrors);
 656                 putnext(q, mp);
 657                 break;
 658             case IF_OUTPUT_ERROR:
 659                 p->pii_ifnet.if_oerrors++;
 660                 INCR(ppp_oerrors);
 661                 DLOG("ppp_if: output error inc to %d\n",
 662                      p->pii_ifnet.if_oerrors);
 663                 putnext(q, mp);
 664                 break;
 665             case IF_CSTATS:
 666                 bcopy(mp->b_rptr + sizeof(u_long), &p->pii_cstats,
 667                       sizeof(struct ppp_comp_stats));
 668                 freemsg(mp);
 669                 break;
 670             default:
 671                 putnext(q, mp);         /* send it up to pppd */
 672                 break;
 673             }
 674         }
 675         break;
 676
 677     default:
 678         putnext(q, mp);         /* send along other message types */
 679     }
 680 }
 681
 682 static int
 683 ppp_if_rsrv(q)
 684     queue_t     *q;
 685 {
 686     register mblk_t *mp,*m0;
 687 #ifdef  VJC
 688     register mblk_t *mvjc;
 689     unsigned char *cp, *iphdr;
 690     u_int hlen;
 691 #endif
 692     register PII *p;
 693     struct mbuf *mb1, *mb2, *mbtail;
 694     int len, xlen, count, s;
 695     u_char *rptr;
 696     int address, control;
 697     int dlen;
 698
 699     p = (PII *) q->q_ptr;
 700
 701     while ((mp = getq(q)) != NULL) {
 702         /*
 703          * we can only get M_DATA types into our Queue,
 704          * due to our Put function
 705          */
 706
 707         if (p == NULL) {
 708             if (!canput(q->q_next)) {
 709                 putbq(q, mp);
 710                 return;
 711             }
 712             putnext(q, mp);
 713             continue;
 714         }
 715
 716         len = msgdsize(mp);
 717         dlen = len - PPP_HDRLEN;
 718 #ifdef  PPP_STATS
 719         p->pii_stats.ppp_ibytes += len;
 720 #endif
 721
 722         /* make sure ppp_header is completely in first block */
 723         if (mp->b_wptr - mp->b_rptr < PPP_HDRLEN
 724             && !pullupmsg(mp, PPP_HDRLEN)) {
 725             DLOG("pullupmsg failed!\n", 0);
 726             freemsg(mp);
 727             p->pii_ifnet.if_ierrors++;
 728             continue;
 729         }
 730         m0 = mp;        /* remember first message block */
 731
 732 #ifdef  VJC
 733         switch (PPP_PROTOCOL(mp->b_rptr)) {
 734         case PPP_VJC_COMP :
 735             if ((p->pii_flags & PII_FLAGS_VJC_REJ)
 736                 || p->pii_npmode[NP_IP] != NPMODE_PASS) {
 737                 DLOG("VJC rejected\n", 0);
 738                 freemsg(mp);
 739                 continue;
 740             }
 741             address = PPP_ADDRESS(mp->b_rptr);
 742             control = PPP_CONTROL(mp->b_rptr);
 743             mp->b_rptr += PPP_HDRLEN;
 744             len -= PPP_HDRLEN;
 745
 746             /*
 747              * Make sure the VJ header is in one message block.
 748              */
 749             xlen = MIN(len, MAX_VJHDR);
 750             if (mp->b_rptr + xlen > mp->b_wptr && !pullupmsg(mp, xlen)) {
 751                 DLOG("pullupmsg vjc %d failed\n", xlen);
 752                 freemsg(mp);
 753                 continue;
 754             }
 755
 756             /*
 757              * Decompress it, then get a buffer and put the
 758              * decompressed header in it.
 759              */
 760             xlen = vj_uncompress_tcp(mp->b_rptr, mp->b_wptr - mp->b_rptr,
 761                                      len, &p->pii_sc_comp, &iphdr, &hlen);
 762             if (xlen < 0) {
 763                 DLOG("ppp: vj_uncompress failed on type Compressed\n", 0);
 764                 freemsg(mp);
 765                 continue;
 766             }
 767             if (!(mvjc = allocb(hlen + PPP_HDRLEN, BPRI_MED))) {
 768                 DLOG("allocb mvjc failed (%d)\n", hlen + PPP_HDRLEN);
 769                 freemsg(mp);
 770                 continue;
 771             }
 772             dlen = len - xlen + hlen;
 773             cp = mvjc->b_rptr;
 774             cp[0] = address;
 775             cp[1] = control;
 776             cp[2] = 0;
 777             cp[3] = PPP_IP;
 778             bcopy(iphdr, cp + PPP_HDRLEN, hlen);
 779             mvjc->b_wptr = cp + PPP_HDRLEN + hlen;
 780             mvjc->b_cont = mp;
 781             mp->b_rptr += xlen;
 782             m0 = mp = mvjc;
 783             break;
 784
 785         case PPP_VJC_UNCOMP :
 786             if ((p->pii_flags & PII_FLAGS_VJC_REJ)
 787                 || p->pii_npmode[NP_IP] != NPMODE_PASS) {
 788                 DLOG("VJU rejected\n", 0);
 789                 freemsg(mp);
 790                 continue;
 791             }
 792
 793             /*
 794              * Make sure the IP header is in one message block.
 795              */
 796             xlen = MIN(len, MAX_IPHDR + PPP_HDRLEN);
 797             if (mp->b_rptr + xlen > mp->b_wptr && !pullupmsg(mp, xlen)) {
 798                 DLOG("pullupmsg vju %d failed\n", xlen);
 799                 freemsg(mp);
 800                 continue;
 801             }
 802
 803             /*
 804              * "Uncompress" it.  Basically this just copies information
 805              * into p->pii_sc_comp and restores the protocol field of
 806              * the IP header.
 807              */
 808             if (!vj_uncompress_uncomp(mp->b_rptr + PPP_HDRLEN,
 809                                       &p->pii_sc_comp)) {
 810                 DLOG("ppp: vj_uncompress failed on type Uncompresed\n", 0);
 811                 freemsg(mp);
 812                 continue;
 813             }
 814             mp->b_rptr[3] = PPP_IP;
 815             break;
 816         }
 817 #endif
 818
 819         switch (PPP_PROTOCOL(mp->b_rptr)) {
 820         default:
 821             if (!canput(q->q_next)) {
 822                 putbq(q, mp);
 823                 return;
 824             }
 825             INCR(ppp_ipackets);
 826             p->pii_ifnet.if_ipackets++;
 827             putnext(q, mp);
 828             continue;
 829
 830         case PPP_IP:
 831             /*
 832              * Don't let packets through until IPCP is up.
 833              */
 834             INCR(ppp_ipackets);
 835             p->pii_ifnet.if_ipackets++;
 836
 837             if (!(p->pii_ifnet.if_flags & IFF_UP)
 838                 || p->pii_npmode[NP_IP] != NPMODE_PASS) {
 839                 DLOG("pkt ignored - IP down\n", 0);
 840                 freemsg(mp);
 841                 continue;
 842             }
 843
 844             /*
 845              * Get the first mbuf and put the struct ifnet * in.
 846              */
 847             MGETHDR(mb1, M_DONTWAIT, MT_DATA);
 848             if (mb1 == NULL) {
 849                 p->pii_ifnet.if_ierrors++;
 850                 freemsg(m0);
 851                 continue;
 852             }
 853 #ifdef __osf__
 854             mb1->m_pkthdr.rcvif = &(p->pii_ifnet);
 855             mb1->m_pkthdr.len = dlen;
 856             len = MHLEN;
 857             mb1->m_len = 0;
 858 #else
 859             *mtod(mb1, struct ifnet **) =  &p->pii_ifnet;
 860             len = MLEN - sizeof(struct ifnet *);
 861             mb1->m_len = sizeof(struct ifnet *);
 862 #endif
 863             mbtail = mb2 = mb1;
 864
 865             rptr = mp->b_rptr + PPP_HDRLEN;
 866             xlen = mp->b_wptr - rptr;
 867             for(;;) {
 868                 if (xlen == 0) {        /* move to the next mblk */
 869                     mp = mp->b_cont;
 870                     if (mp == NULL)
 871                         break;
 872                     xlen = mp->b_wptr - (rptr = mp->b_rptr);
 873                     continue;
 874                 }
 875                 if (len == 0) {
 876                     MGET(mb2, M_DONTWAIT, MT_DATA);
 877                     if (!mb2) {
 878                         /* if we couldn't get a buffer, drop the packet */
 879                         p->pii_ifnet.if_ierrors++;
 880                         m_freem(mb1);   /* discard what we've used already */
 881                         mb1 = NULL;
 882                         break;
 883                     }
 884                     len = MLEN;
 885                     mb2->m_len = 0;
 886                     mbtail->m_next = mb2;
 887                     mbtail = mb2;
 888                 }
 889                 count = MIN(xlen, len);
 890                 bcopy((char *) rptr, mtod(mb2, char *) + mb2->m_len, count);
 891                 rptr += count;
 892                 len -= count;
 893                 xlen -= count;
 894                 mb2->m_len += count;
 895             }
 896
 897             freemsg(m0);
 898             if (mb1 == NULL)
 899                 continue;
 900
 901 #ifdef PPP_SNIT
 902             if (p->pii_ifnet.if_flags & IFF_PROMISC) {
 903                 struct mbuf *m = mb1;
 904
 905                 len = 0;
 906                 do {
 907                     len += m->m_len;
 908                 } while (m = m->m_next);
 909                 nif.nif_bodylen = len - sizeof(struct ifnet *);
 910                 mb1->m_off += sizeof(struct ifnet *);
 911                 snit_intr(&p->pii_ifnet, mb1, &nif);
 912                 mb1->m_off -= sizeof(struct ifnet *);
 913             }
 914 #endif
 915             s = splimp();
 916             if (IF_QFULL(&ipintrq)) {
 917                 IF_DROP(&ipintrq);
 918                 p->pii_ifnet.if_ierrors++;
 919                 m_freem(mb1);
 920             }
 921             else {
 922                 IF_ENQUEUE(&ipintrq, mb1);
 923                 schednetisr(NETISR_IP);
 924             }
 925             splx(s);
 926         }
 927     }   /* end while */
 928 }
 929
 930 /* ifp output procedure */
 931 int
 932 ppp_output(ifp, m0, dst)
 933     struct ifnet *ifp;
 934     struct mbuf *m0;
 935     struct sockaddr *dst;
 936 {
 937     register PII *p = &pii[ifp->if_unit];
 938     struct mbuf *m1;
 939     int error, s, len;
 940     u_short protocol;
 941 #ifdef  VJC
 942     int type;
 943     u_char *vjhdr;
 944 #endif
 945     mblk_t *mp;
 946     enum NPmode npmode;
 947
 948     error = 0;
 949     if (!(ifp->if_flags & IFF_UP)) {
 950         error = ENETDOWN;
 951         goto getout;
 952     }
 953
 954     switch (dst->sa_family) {
 955 #ifdef  INET
 956     case AF_INET:
 957 #ifdef PPP_SNIT
 958         if (ifp->if_flags & IFF_PROMISC) {
 959             struct mbuf *m = m0;
 960
 961             len = 0;
 962             do {
 963                 len += m->m_len;
 964             } while (m = m->m_next);
 965             nif.nif_bodylen = len;
 966             snit_intr(ifp, m0, &nif);
 967         }
 968 #endif
 969         protocol = PPP_IP;
 970         npmode = p->pii_npmode[NP_IP];
 971         break;
 972 #endif
 973
 974     default:
 975         DLOG("ppp: af%d not supported\n", dst->sa_family);
 976         error = EAFNOSUPPORT;
 977         goto getout;
 978     }
 979
 980     if (!p->pii_writeq) {
 981         DLOG("ppp_if%d: no queue\n", p - pii);
 982         error = EHOSTUNREACH;
 983         goto getout;
 984     }
 985
 986     switch (npmode) {
 987     case NPMODE_DROP:
 988         goto getout;
 989     case NPMODE_ERROR:
 990         error = ENETDOWN;
 991         goto getout;
 992     }
 993
 994 #ifdef  VJC
 995     if ((protocol == PPP_IP) && (p->pii_flags & PII_FLAGS_VJC_ON)) {
 996         register struct ip *ip;
 997         ip = mtod(m0, struct ip *);
 998         if (ip->ip_p == IPPROTO_TCP) {
 999             type = vj_compress_tcp(ip, m0->m_len, &p->pii_sc_comp,
1000                                    !(p->pii_flags & PII_FLAGS_VJC_NOCCID),
1001                                    &vjhdr);
1002             switch (type) {
1003             case TYPE_UNCOMPRESSED_TCP :
1004                 protocol = PPP_VJC_UNCOMP;
1005                 break;
1006             case TYPE_COMPRESSED_TCP :
1007                 protocol = PPP_VJC_COMP;
1008                 len = vjhdr - (u_char *) ip;
1009                 m0->m_data += len;
1010                 m0->m_len -= len;
1011                 break;
1012             }
1013         }
1014     }
1015 #endif
1016
1017     len = PPP_HDRLEN;
1018     for (m1 = m0; m1; m1 = m1->m_next)
1019         len += m1->m_len;
1020
1021     if (!(mp = allocb(len, BPRI_MED))) {
1022         DLOG("ppp_if%d: allocb failed\n", p - pii);
1023         error = ENOBUFS;
1024         goto getout;
1025     }
1026
1027 #ifdef  PPP_STATS
1028     p->pii_stats.ppp_obytes += len;
1029 #endif
1030
1031     *mp->b_wptr++ = PPP_ALLSTATIONS;
1032     *mp->b_wptr++ = PPP_UI;
1033     *mp->b_wptr++ = 0;
1034     *mp->b_wptr++ = protocol;
1035     for (m1 = m0; m1; m1 = m1->m_next) {        /* copy all data */
1036         bcopy(mtod(m1, char *), (char *) mp->b_wptr, m1->m_len);
1037         mp->b_wptr += m1->m_len;
1038     }
1039
1040     s = splstr();
1041     p->pii_ifnet.if_opackets++;
1042     if (npmode == NPMODE_PASS) {
1043         putq(p->pii_writeq, mp);
1044     } else {
1045         mp->b_next = NULL;
1046         *p->pii_npq_tail = mp;
1047         p->pii_npq_tail = &mp;
1048     }
1049     splx(s);
1050
1051  getout:
1052     m_freem(m0);
1053     if (error) {
1054         INCR(ppp_oerrors);
1055         p->pii_ifnet.if_oerrors++;
1056     }
1057     return (error);
1058 }
1059
1060 /*
1061  * if_ ioctl requests
1062 */
1063 ppp_ioctl(ifp, cmd, data)
1064     register struct ifnet *ifp;
1065     int cmd;
1066     caddr_t     data;
1067 {
1068     register struct ifaddr *ifa = (struct ifaddr *) data;
1069     register struct ifreq *ifr = (struct ifreq *) data;
1070     struct ppp_stats *psp;
1071     struct ppp_comp_stats *pcp;
1072     PII *p;
1073     queue_t *q;
1074     int s = splimp(), error = 0;
1075
1076     switch (cmd) {
1077     case SIOCSIFFLAGS :
1078         /* This happens every time IFF_PROMISC has been changed. */
1079         if (!ifr)
1080             break;
1081         if (NOTSUSER) {
1082             error = EPERM;
1083             break;
1084         }
1085
1086         /* clear the flags that can be cleared */
1087         ifp->if_flags &= (IFF_CANTCHANGE);
1088         /* or in the flags that can be changed */
1089         ifp->if_flags |= (ifr->ifr_flags & ~IFF_CANTCHANGE);
1090         break;
1091
1092     case SIOCGIFFLAGS :
1093         ifr->ifr_flags = ifp->if_flags;
1094         break;
1095
1096     case SIOCSIFADDR :
1097         if (IFA_ADDR(ifa).sa_family != AF_INET)
1098             error = EAFNOSUPPORT;
1099         break;
1100
1101     case SIOCSIFDSTADDR :
1102         if (IFA_ADDR(ifa).sa_family != AF_INET)
1103             error = EAFNOSUPPORT;
1104         break;
1105
1106     case SIOCSIFMTU :
1107         if (NOTSUSER) {
1108             error = EPERM;
1109             break;
1110         }
1111         if (ifr->ifr_mtu > MAX_PKTSIZE - PPP_FRAMING) {
1112             error = EINVAL;
1113             break;
1114         }
1115         ifp->if_mtu = ifr->ifr_mtu;
1116         break;
1117
1118     case SIOCGIFMTU :
1119         ifr->ifr_mtu = ifp->if_mtu;
1120         break;
1121
1122     case SIOCGPPPSTATS:
1123         p = &pii[ifp->if_unit];
1124         psp = (struct ppp_stats *) &((struct ifpppstatsreq *)data)->stats;
1125         bzero(psp, sizeof(struct ppp_stats));
1126 #ifdef PPP_STATS
1127         psp->p = p->pii_stats;
1128 #endif
1129 #if defined(VJC) && !defined(VJ_NO_STATS)
1130         psp->vj = p->pii_sc_comp.stats;
1131 #endif
1132         break;
1133
1134     case SIOCGPPPCSTATS:
1135         p = &pii[ifp->if_unit];
1136         bzero(&p->pii_cstats, sizeof(struct ppp_comp_stats));
1137
1138         /* Make a message to send on the interface's write stream */
1139         s = splstr();
1140         q = p->pii_writeq;
1141         if (q != NULL) {
1142             putctl1(q, M_CTL, IF_GET_CSTATS);
1143             /*
1144              * We assume the message gets passed along immediately, so
1145              * by the time the putctl1 returns, the request has been
1146              * processed, the values returned and p->pii_cstats has
1147              * been updated.  If not, we just get zeroes.
1148              */
1149         }
1150         splx(s);
1151
1152         pcp = (struct ppp_comp_stats *)&((struct ifpppcstatsreq *)data)->stats;
1153         bcopy(&p->pii_cstats, pcp, sizeof(struct ppp_comp_stats));
1154         break;
1155
1156     default:
1157         error = EINVAL;
1158         break;
1159     }
1160     splx(s);
1161     return(error);
1162 }
1163
1164 #endif