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