Annotation of sys/net/if_ppp.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: if_ppp.c,v 1.49 2007/05/26 17:13:31 jason Exp $ */
2: /* $NetBSD: if_ppp.c,v 1.39 1997/05/17 21:11:59 christos Exp $ */
3:
4: /*
5: * if_ppp.c - Point-to-Point Protocol (PPP) Asynchronous driver.
6: *
7: * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: *
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: *
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in
18: * the documentation and/or other materials provided with the
19: * distribution.
20: *
21: * 3. The name "Carnegie Mellon University" must not be used to
22: * endorse or promote products derived from this software without
23: * prior written permission. For permission or any legal
24: * details, please contact
25: * Office of Technology Transfer
26: * Carnegie Mellon University
27: * 5000 Forbes Avenue
28: * Pittsburgh, PA 15213-3890
29: * (412) 268-4387, fax: (412) 268-7395
30: * tech-transfer@andrew.cmu.edu
31: *
32: * 4. Redistributions of any form whatsoever must retain the following
33: * acknowledgment:
34: * "This product includes software developed by Computing Services
35: * at Carnegie Mellon University (http://www.cmu.edu/computing/)."
36: *
37: * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
38: * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
39: * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
40: * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
41: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
42: * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
43: * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
44: *
45: * Based on:
46: * @(#)if_sl.c 7.6.1.2 (Berkeley) 2/15/89
47: *
48: * Copyright (c) 1987, 1989, 1992, 1993
49: * The Regents of the University of California. All rights reserved.
50: *
51: * Redistribution and use in source and binary forms, with or without
52: * modification, are permitted provided that the following conditions
53: * are met:
54: * 1. Redistributions of source code must retain the above copyright
55: * notice, this list of conditions and the following disclaimer.
56: * 2. Redistributions in binary form must reproduce the above copyright
57: * notice, this list of conditions and the following disclaimer in the
58: * documentation and/or other materials provided with the distribution.
59: * 3. Neither the name of the University nor the names of its contributors
60: * may be used to endorse or promote products derived from this software
61: * without specific prior written permission.
62: *
63: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
64: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
65: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
66: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
67: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
68: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
69: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
70: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
71: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
72: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
73: * SUCH DAMAGE.
74: *
75: * Serial Line interface
76: *
77: * Rick Adams
78: * Center for Seismic Studies
79: * 1300 N 17th Street, Suite 1450
80: * Arlington, Virginia 22209
81: * (703)276-7900
82: * rick@seismo.ARPA
83: * seismo!rick
84: *
85: * Pounded on heavily by Chris Torek (chris@mimsy.umd.edu, umcp-cs!chris).
86: * Converted to 4.3BSD Beta by Chris Torek.
87: * Other changes made at Berkeley, based in part on code by Kirk Smith.
88: *
89: * Converted to 4.3BSD+ 386BSD by Brad Parker (brad@cayman.com)
90: * Added VJ tcp header compression; more unified ioctls
91: *
92: * Extensively modified by Paul Mackerras (paulus@cs.anu.edu.au).
93: * Cleaned up a lot of the mbuf-related code to fix bugs that
94: * caused system crashes and packet corruption. Changed pppstart
95: * so that it doesn't just give up with a collision if the whole
96: * packet doesn't fit in the output ring buffer.
97: *
98: * Added priority queueing for interactive IP packets, following
99: * the model of if_sl.c, plus hooks for bpf.
100: * Paul Mackerras (paulus@cs.anu.edu.au).
101: */
102:
103: /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */
104: /* from NetBSD: if_ppp.c,v 1.15.2.2 1994/07/28 05:17:58 cgd Exp */
105:
106: #include "ppp.h"
107: #if NPPP > 0
108:
109: #define VJC
110: #define PPP_COMPRESS
111:
112: #include <sys/param.h>
113: #include <sys/proc.h>
114: #include <sys/mbuf.h>
115: #include <sys/socket.h>
116: #include <sys/ioctl.h>
117: #include <sys/kernel.h>
118: #include <sys/systm.h>
119: #include <sys/time.h>
120: #include <sys/malloc.h>
121:
122: #include <net/if.h>
123: #include <net/if_types.h>
124: #include <net/netisr.h>
125: #include <net/route.h>
126: #include <net/bpf.h>
127:
128: #if INET
129: #include <netinet/in.h>
130: #include <netinet/in_systm.h>
131: #include <netinet/in_var.h>
132: #include <netinet/ip.h>
133: #else
134: #ifdef _KERNEL
135: #ifdef VJC
136: #error ppp device with VJC assumes INET
137: #endif
138: #endif
139: #endif
140:
141: #include "bpfilter.h"
142: #if NBPFILTER > 0
143: #include <net/bpf.h>
144: #endif
145:
146: #ifdef VJC
147: #include <net/slcompress.h>
148: #endif
149:
150: #include <net/ppp_defs.h>
151: #include <net/if_ppp.h>
152: #include <net/if_pppvar.h>
153: #include <machine/cpu.h>
154:
155: #ifdef PPP_COMPRESS
156: #define PACKETPTR struct mbuf *
157: #include <net/ppp-comp.h>
158: #endif
159:
160: static int pppsioctl(struct ifnet *, u_long, caddr_t);
161: static void ppp_requeue(struct ppp_softc *);
162: static void ppp_ccp(struct ppp_softc *, struct mbuf *m, int rcvd);
163: static void ppp_ccp_closed(struct ppp_softc *);
164: static void ppp_inproc(struct ppp_softc *, struct mbuf *);
165: static void pppdumpm(struct mbuf *m0);
166: #ifdef ALTQ
167: static void ppp_ifstart(struct ifnet *ifp);
168: #endif
169: int ppp_clone_create(struct if_clone *, int);
170: int ppp_clone_destroy(struct ifnet *);
171:
172: /*
173: * Some useful mbuf macros not in mbuf.h.
174: */
175: #define M_IS_CLUSTER(m) ((m)->m_flags & M_EXT)
176:
177: #define M_DATASTART(m) \
178: (M_IS_CLUSTER(m) ? (m)->m_ext.ext_buf : \
179: (m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat)
180:
181: #define M_DATASIZE(m) \
182: (M_IS_CLUSTER(m) ? (m)->m_ext.ext_size : \
183: (m)->m_flags & M_PKTHDR ? MHLEN: MLEN)
184:
185: /*
186: * We steal two bits in the mbuf m_flags, to mark high-priority packets
187: * for output, and received packets following lost/corrupted packets.
188: */
189: #define M_HIGHPRI 0x2000 /* output packet for sc_fastq */
190: #define M_ERRMARK 0x4000 /* steal a bit in mbuf m_flags */
191:
192:
193: #ifdef PPP_COMPRESS
194: /*
195: * List of compressors we know about.
196: * We leave some space so maybe we can modload compressors.
197: */
198:
199: extern struct compressor ppp_bsd_compress;
200: extern struct compressor ppp_deflate, ppp_deflate_draft;
201:
202: struct compressor *ppp_compressors[8] = {
203: #if DO_BSD_COMPRESS && defined(PPP_BSDCOMP)
204: &ppp_bsd_compress,
205: #endif
206: #if DO_DEFLATE && defined(PPP_DEFLATE)
207: &ppp_deflate,
208: &ppp_deflate_draft,
209: #endif
210: NULL
211: };
212: #endif /* PPP_COMPRESS */
213:
214: LIST_HEAD(, ppp_softc) ppp_softc_list;
215: struct if_clone ppp_cloner =
216: IF_CLONE_INITIALIZER("ppp", ppp_clone_create, ppp_clone_destroy);
217:
218: /*
219: * Called from boot code to establish ppp interfaces.
220: */
221: void
222: pppattach()
223: {
224: LIST_INIT(&ppp_softc_list);
225: if_clone_attach(&ppp_cloner);
226: }
227:
228: int
229: ppp_clone_create(ifc, unit)
230: struct if_clone *ifc;
231: int unit;
232: {
233: struct ppp_softc *sc;
234: int s;
235:
236: sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT);
237: if (!sc)
238: return (ENOMEM);
239: bzero(sc, sizeof(*sc));
240:
241: sc->sc_unit = unit;
242: snprintf(sc->sc_if.if_xname, sizeof sc->sc_if.if_xname, "%s%d",
243: ifc->ifc_name, unit);
244: sc->sc_if.if_softc = sc;
245: sc->sc_if.if_mtu = PPP_MTU;
246: sc->sc_if.if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
247: sc->sc_if.if_type = IFT_PPP;
248: sc->sc_if.if_hdrlen = PPP_HDRLEN;
249: sc->sc_if.if_ioctl = pppsioctl;
250: sc->sc_if.if_output = pppoutput;
251: #ifdef ALTQ
252: sc->sc_if.if_start = ppp_ifstart;
253: #endif
254: IFQ_SET_MAXLEN(&sc->sc_if.if_snd, ifqmaxlen);
255: sc->sc_inq.ifq_maxlen = ifqmaxlen;
256: sc->sc_fastq.ifq_maxlen = ifqmaxlen;
257: sc->sc_rawq.ifq_maxlen = ifqmaxlen;
258: IFQ_SET_READY(&sc->sc_if.if_snd);
259: if_attach(&sc->sc_if);
260: if_alloc_sadl(&sc->sc_if);
261: #if NBPFILTER > 0
262: bpfattach(&sc->sc_bpf, &sc->sc_if, DLT_PPP, PPP_HDRLEN);
263: #endif
264: s = splnet();
265: LIST_INSERT_HEAD(&ppp_softc_list, sc, sc_list);
266: splx(s);
267:
268: return (0);
269: }
270:
271: int
272: ppp_clone_destroy(ifp)
273: struct ifnet *ifp;
274: {
275: struct ppp_softc *sc = ifp->if_softc;
276: int s;
277:
278: if (sc->sc_devp != NULL)
279: return (EBUSY);
280:
281: s = splnet();
282: LIST_REMOVE(sc, sc_list);
283: splx(s);
284:
285: if_detach(ifp);
286:
287: free(sc, M_DEVBUF);
288: return (0);
289: }
290:
291: /*
292: * Allocate a ppp interface unit and initialize it.
293: */
294: struct ppp_softc *
295: pppalloc(pid)
296: pid_t pid;
297: {
298: int i;
299: struct ppp_softc *sc;
300:
301: LIST_FOREACH(sc, &ppp_softc_list, sc_list)
302: if (sc->sc_xfer == pid) {
303: sc->sc_xfer = 0;
304: return sc;
305: }
306: LIST_FOREACH(sc, &ppp_softc_list, sc_list)
307: if (sc->sc_devp == NULL)
308: break;
309: if (sc == NULL)
310: return NULL;
311:
312: sc->sc_flags = 0;
313: sc->sc_mru = PPP_MRU;
314: sc->sc_relinq = NULL;
315: bzero((char *)&sc->sc_stats, sizeof(sc->sc_stats));
316: #ifdef VJC
317: MALLOC(sc->sc_comp, struct slcompress *, sizeof(struct slcompress),
318: M_DEVBUF, M_NOWAIT);
319: if (sc->sc_comp)
320: sl_compress_init(sc->sc_comp);
321: #endif
322: #ifdef PPP_COMPRESS
323: sc->sc_xc_state = NULL;
324: sc->sc_rc_state = NULL;
325: #endif /* PPP_COMPRESS */
326: for (i = 0; i < NUM_NP; ++i)
327: sc->sc_npmode[i] = NPMODE_ERROR;
328: sc->sc_npqueue = NULL;
329: sc->sc_npqtail = &sc->sc_npqueue;
330: sc->sc_last_sent = sc->sc_last_recv = time_second;
331:
332: return sc;
333: }
334:
335: /*
336: * Deallocate a ppp unit. Must be called at splsoftnet or higher.
337: */
338: void
339: pppdealloc(sc)
340: struct ppp_softc *sc;
341: {
342: struct mbuf *m;
343:
344: splassert(IPL_SOFTNET);
345:
346: if_down(&sc->sc_if);
347: sc->sc_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
348: sc->sc_devp = NULL;
349: sc->sc_xfer = 0;
350: for (;;) {
351: IF_DEQUEUE(&sc->sc_rawq, m);
352: if (m == NULL)
353: break;
354: m_freem(m);
355: }
356: for (;;) {
357: IF_DEQUEUE(&sc->sc_inq, m);
358: if (m == NULL)
359: break;
360: m_freem(m);
361: }
362: for (;;) {
363: IF_DEQUEUE(&sc->sc_fastq, m);
364: if (m == NULL)
365: break;
366: m_freem(m);
367: }
368: while ((m = sc->sc_npqueue) != NULL) {
369: sc->sc_npqueue = m->m_nextpkt;
370: m_freem(m);
371: }
372: if (sc->sc_togo != NULL) {
373: m_freem(sc->sc_togo);
374: sc->sc_togo = NULL;
375: }
376: #ifdef PPP_COMPRESS
377: ppp_ccp_closed(sc);
378: sc->sc_xc_state = NULL;
379: sc->sc_rc_state = NULL;
380: #endif /* PPP_COMPRESS */
381: #if NBPFILTER > 0
382: if (sc->sc_pass_filt.bf_insns != 0) {
383: FREE(sc->sc_pass_filt.bf_insns, M_DEVBUF);
384: sc->sc_pass_filt.bf_insns = 0;
385: sc->sc_pass_filt.bf_len = 0;
386: }
387: if (sc->sc_active_filt.bf_insns != 0) {
388: FREE(sc->sc_active_filt.bf_insns, M_DEVBUF);
389: sc->sc_active_filt.bf_insns = 0;
390: sc->sc_active_filt.bf_len = 0;
391: }
392: #endif
393: #ifdef VJC
394: if (sc->sc_comp != 0) {
395: FREE(sc->sc_comp, M_DEVBUF);
396: sc->sc_comp = 0;
397: }
398: #endif
399: }
400:
401: /*
402: * Ioctl routine for generic ppp devices.
403: */
404: int
405: pppioctl(sc, cmd, data, flag, p)
406: struct ppp_softc *sc;
407: u_long cmd;
408: caddr_t data;
409: int flag;
410: struct proc *p;
411: {
412: int s, error, flags, mru, npx;
413: u_int nb;
414: struct ppp_option_data *odp;
415: struct compressor **cp;
416: struct npioctl *npi;
417: time_t t;
418: #if NBPFILTER > 0
419: struct bpf_program *bp, *nbp;
420: struct bpf_insn *newcode, *oldcode;
421: int newcodelen;
422: #endif
423: #ifdef PPP_COMPRESS
424: u_char ccp_option[CCP_MAX_OPTION_LENGTH];
425: #endif
426:
427: switch (cmd) {
428: case FIONREAD:
429: *(int *)data = sc->sc_inq.ifq_len;
430: break;
431:
432: case PPPIOCGUNIT:
433: *(int *)data = sc->sc_unit; /* XXX */
434: break;
435:
436: case PPPIOCGFLAGS:
437: *(u_int *)data = sc->sc_flags;
438: break;
439:
440: case PPPIOCSFLAGS:
441: if ((error = suser(p, 0)) != 0)
442: return (error);
443: flags = *(int *)data & SC_MASK;
444: s = splsoftnet();
445: #ifdef PPP_COMPRESS
446: if (sc->sc_flags & SC_CCP_OPEN && !(flags & SC_CCP_OPEN))
447: ppp_ccp_closed(sc);
448: #endif
449: splnet();
450: sc->sc_flags = (sc->sc_flags & ~SC_MASK) | flags;
451: splx(s);
452: break;
453:
454: case PPPIOCSMRU:
455: if ((error = suser(p, 0)) != 0)
456: return (error);
457: mru = *(int *)data;
458: if (mru >= PPP_MRU && mru <= PPP_MAXMRU)
459: sc->sc_mru = mru;
460: break;
461:
462: case PPPIOCGMRU:
463: *(int *)data = sc->sc_mru;
464: break;
465:
466: #ifdef VJC
467: case PPPIOCSMAXCID:
468: if ((error = suser(p, 0)) != 0)
469: return (error);
470: if (sc->sc_comp) {
471: s = splsoftnet();
472: sl_compress_setup(sc->sc_comp, *(int *)data);
473: splx(s);
474: }
475: break;
476: #endif
477:
478: case PPPIOCXFERUNIT:
479: if ((error = suser(p, 0)) != 0)
480: return (error);
481: sc->sc_xfer = p->p_pid;
482: break;
483:
484: #ifdef PPP_COMPRESS
485: case PPPIOCSCOMPRESS:
486: if ((error = suser(p, 0)) != 0)
487: return (error);
488: odp = (struct ppp_option_data *) data;
489: nb = odp->length;
490: if (nb > sizeof(ccp_option))
491: nb = sizeof(ccp_option);
492: if ((error = copyin(odp->ptr, ccp_option, nb)) != 0)
493: return (error);
494: if (ccp_option[1] < 2) /* preliminary check on the length byte */
495: return (EINVAL);
496: for (cp = ppp_compressors; *cp != NULL; ++cp)
497: if ((*cp)->compress_proto == ccp_option[0]) {
498: /*
499: * Found a handler for the protocol - try to allocate
500: * a compressor or decompressor.
501: */
502: error = 0;
503: if (odp->transmit) {
504: s = splsoftnet();
505: if (sc->sc_xc_state != NULL)
506: (*sc->sc_xcomp->comp_free)(sc->sc_xc_state);
507: sc->sc_xcomp = *cp;
508: sc->sc_xc_state = (*cp)->comp_alloc(ccp_option, nb);
509: if (sc->sc_xc_state == NULL) {
510: if (sc->sc_flags & SC_DEBUG)
511: printf("%s: comp_alloc failed\n",
512: sc->sc_if.if_xname);
513: error = ENOBUFS;
514: }
515: splnet();
516: sc->sc_flags &= ~SC_COMP_RUN;
517: splx(s);
518: } else {
519: s = splsoftnet();
520: if (sc->sc_rc_state != NULL)
521: (*sc->sc_rcomp->decomp_free)(sc->sc_rc_state);
522: sc->sc_rcomp = *cp;
523: sc->sc_rc_state = (*cp)->decomp_alloc(ccp_option, nb);
524: if (sc->sc_rc_state == NULL) {
525: if (sc->sc_flags & SC_DEBUG)
526: printf("%s: decomp_alloc failed\n",
527: sc->sc_if.if_xname);
528: error = ENOBUFS;
529: }
530: splnet();
531: sc->sc_flags &= ~SC_DECOMP_RUN;
532: splx(s);
533: }
534: return (error);
535: }
536: if (sc->sc_flags & SC_DEBUG)
537: printf("%s: no compressor for [%x %x %x], %x\n",
538: sc->sc_if.if_xname, ccp_option[0], ccp_option[1],
539: ccp_option[2], nb);
540: return (EINVAL); /* no handler found */
541: #endif /* PPP_COMPRESS */
542:
543: case PPPIOCGNPMODE:
544: case PPPIOCSNPMODE:
545: npi = (struct npioctl *) data;
546: switch (npi->protocol) {
547: case PPP_IP:
548: npx = NP_IP;
549: break;
550: default:
551: return EINVAL;
552: }
553: if (cmd == PPPIOCGNPMODE) {
554: npi->mode = sc->sc_npmode[npx];
555: } else {
556: if ((error = suser(p, 0)) != 0)
557: return (error);
558: if (npi->mode != sc->sc_npmode[npx]) {
559: s = splsoftnet();
560: sc->sc_npmode[npx] = npi->mode;
561: if (npi->mode != NPMODE_QUEUE) {
562: ppp_requeue(sc);
563: (*sc->sc_start)(sc);
564: }
565: splx(s);
566: }
567: }
568: break;
569:
570: case PPPIOCGIDLE:
571: s = splsoftnet();
572: t = time_second;
573: ((struct ppp_idle *)data)->xmit_idle = t - sc->sc_last_sent;
574: ((struct ppp_idle *)data)->recv_idle = t - sc->sc_last_recv;
575: splx(s);
576: break;
577:
578: #if NBPFILTER > 0
579: case PPPIOCSPASS:
580: case PPPIOCSACTIVE:
581: nbp = (struct bpf_program *) data;
582: if ((unsigned) nbp->bf_len > BPF_MAXINSNS)
583: return EINVAL;
584: newcodelen = nbp->bf_len * sizeof(struct bpf_insn);
585: if (newcodelen != 0) {
586: MALLOC(newcode, struct bpf_insn *, newcodelen, M_DEVBUF, M_WAITOK);
587: if ((error = copyin((caddr_t)nbp->bf_insns, (caddr_t)newcode,
588: newcodelen)) != 0) {
589: FREE(newcode, M_DEVBUF);
590: return error;
591: }
592: if (!bpf_validate(newcode, nbp->bf_len)) {
593: FREE(newcode, M_DEVBUF);
594: return EINVAL;
595: }
596: } else
597: newcode = 0;
598: bp = (cmd == PPPIOCSPASS)? &sc->sc_pass_filt: &sc->sc_active_filt;
599: oldcode = bp->bf_insns;
600: s = splnet();
601: bp->bf_len = nbp->bf_len;
602: bp->bf_insns = newcode;
603: splx(s);
604: if (oldcode != 0)
605: FREE(oldcode, M_DEVBUF);
606: break;
607: #endif
608:
609: default:
610: return (-1);
611: }
612: return (0);
613: }
614:
615: /*
616: * Process an ioctl request to the ppp network interface.
617: */
618: static int
619: pppsioctl(ifp, cmd, data)
620: struct ifnet *ifp;
621: u_long cmd;
622: caddr_t data;
623: {
624: struct ppp_softc *sc = ifp->if_softc;
625: struct ifaddr *ifa = (struct ifaddr *)data;
626: struct ifreq *ifr = (struct ifreq *)data;
627: struct ppp_stats *psp;
628: #ifdef PPP_COMPRESS
629: struct ppp_comp_stats *pcp;
630: #endif
631: int s = splnet(), error = 0;
632:
633: switch (cmd) {
634: case SIOCSIFFLAGS:
635: if ((ifp->if_flags & IFF_RUNNING) == 0)
636: ifp->if_flags &= ~IFF_UP;
637: break;
638:
639: case SIOCSIFADDR:
640: if (ifa->ifa_addr->sa_family != AF_INET)
641: error = EAFNOSUPPORT;
642: break;
643:
644: case SIOCSIFDSTADDR:
645: if (ifa->ifa_addr->sa_family != AF_INET)
646: error = EAFNOSUPPORT;
647: break;
648:
649: case SIOCSIFMTU:
650: sc->sc_if.if_mtu = ifr->ifr_mtu;
651: break;
652:
653: case SIOCADDMULTI:
654: case SIOCDELMULTI:
655: if (ifr == 0) {
656: error = EAFNOSUPPORT;
657: break;
658: }
659: switch(ifr->ifr_addr.sa_family) {
660: #ifdef INET
661: case AF_INET:
662: break;
663: #endif
664: default:
665: error = EAFNOSUPPORT;
666: break;
667: }
668: break;
669:
670: case SIOCGPPPSTATS:
671: psp = &((struct ifpppstatsreq *) data)->stats;
672: bzero(psp, sizeof(*psp));
673: psp->p = sc->sc_stats;
674: #if defined(VJC) && !defined(SL_NO_STATS)
675: if (sc->sc_comp) {
676: psp->vj.vjs_packets = sc->sc_comp->sls_packets;
677: psp->vj.vjs_compressed = sc->sc_comp->sls_compressed;
678: psp->vj.vjs_searches = sc->sc_comp->sls_searches;
679: psp->vj.vjs_misses = sc->sc_comp->sls_misses;
680: psp->vj.vjs_uncompressedin = sc->sc_comp->sls_uncompressedin;
681: psp->vj.vjs_compressedin = sc->sc_comp->sls_compressedin;
682: psp->vj.vjs_errorin = sc->sc_comp->sls_errorin;
683: psp->vj.vjs_tossed = sc->sc_comp->sls_tossed;
684: }
685: #endif /* VJC */
686: break;
687:
688: #ifdef PPP_COMPRESS
689: case SIOCGPPPCSTATS:
690: pcp = &((struct ifpppcstatsreq *) data)->stats;
691: bzero(pcp, sizeof(*pcp));
692: if (sc->sc_xc_state != NULL)
693: (*sc->sc_xcomp->comp_stat)(sc->sc_xc_state, &pcp->c);
694: if (sc->sc_rc_state != NULL)
695: (*sc->sc_rcomp->decomp_stat)(sc->sc_rc_state, &pcp->d);
696: break;
697: #endif /* PPP_COMPRESS */
698:
699: default:
700: error = EINVAL;
701: }
702: splx(s);
703: return (error);
704: }
705:
706: /*
707: * Queue a packet. Start transmission if not active.
708: * Packet is placed in Information field of PPP frame.
709: */
710: int
711: pppoutput(ifp, m0, dst, rtp)
712: struct ifnet *ifp;
713: struct mbuf *m0;
714: struct sockaddr *dst;
715: struct rtentry *rtp;
716: {
717: struct ppp_softc *sc = ifp->if_softc;
718: int protocol, address, control;
719: u_char *cp;
720: int s, error;
721: struct ip *ip;
722: struct ifqueue *ifq;
723: enum NPmode mode;
724: int len;
725:
726: if (sc->sc_devp == NULL || (ifp->if_flags & IFF_RUNNING) == 0
727: || ((ifp->if_flags & IFF_UP) == 0 && dst->sa_family != AF_UNSPEC)) {
728: error = ENETDOWN; /* sort of */
729: goto bad;
730: }
731:
732: /*
733: * Compute PPP header.
734: */
735: m0->m_flags &= ~M_HIGHPRI;
736: switch (dst->sa_family) {
737: #ifdef INET
738: case AF_INET:
739: address = PPP_ALLSTATIONS;
740: control = PPP_UI;
741: protocol = PPP_IP;
742: mode = sc->sc_npmode[NP_IP];
743:
744: /*
745: * If this packet has the "low delay" bit set in the IP header,
746: * put it on the fastq instead.
747: */
748: ip = mtod(m0, struct ip *);
749: if (ip->ip_tos & IPTOS_LOWDELAY)
750: m0->m_flags |= M_HIGHPRI;
751: break;
752: #endif
753: case AF_UNSPEC:
754: address = PPP_ADDRESS(dst->sa_data);
755: control = PPP_CONTROL(dst->sa_data);
756: protocol = PPP_PROTOCOL(dst->sa_data);
757: mode = NPMODE_PASS;
758: break;
759: default:
760: printf("%s: af%d not supported\n", ifp->if_xname, dst->sa_family);
761: error = EAFNOSUPPORT;
762: goto bad;
763: }
764:
765: /*
766: * Drop this packet, or return an error, if necessary.
767: */
768: if (mode == NPMODE_ERROR) {
769: error = ENETDOWN;
770: goto bad;
771: }
772: if (mode == NPMODE_DROP) {
773: error = 0;
774: goto bad;
775: }
776:
777: /*
778: * Add PPP header. If no space in first mbuf, allocate another.
779: * (This assumes M_LEADINGSPACE is always 0 for a cluster mbuf.)
780: */
781: M_PREPEND(m0, PPP_HDRLEN, M_DONTWAIT);
782: if (m0 == 0) {
783: error = ENOBUFS;
784: goto bad;
785: }
786:
787: cp = mtod(m0, u_char *);
788: *cp++ = address;
789: *cp++ = control;
790: *cp++ = protocol >> 8;
791: *cp++ = protocol & 0xff;
792:
793: if ((m0->m_flags & M_PKTHDR) == 0)
794: panic("mbuf packet without packet header!");
795: len = m0->m_pkthdr.len;
796:
797: if (sc->sc_flags & SC_LOG_OUTPKT) {
798: printf("%s output: ", ifp->if_xname);
799: pppdumpm(m0);
800: }
801:
802: if ((protocol & 0x8000) == 0) {
803: #if NBPFILTER > 0
804: /*
805: * Apply the pass and active filters to the packet,
806: * but only if it is a data packet.
807: */
808: *mtod(m0, u_char *) = 1; /* indicates outbound */
809: if (sc->sc_pass_filt.bf_insns != 0
810: && bpf_filter(sc->sc_pass_filt.bf_insns, (u_char *) m0,
811: len, 0) == 0) {
812: error = 0; /* drop this packet */
813: goto bad;
814: }
815:
816: /*
817: * Update the time we sent the most recent packet.
818: */
819: if (sc->sc_active_filt.bf_insns == 0
820: || bpf_filter(sc->sc_active_filt.bf_insns, (u_char *) m0, len, 0))
821: sc->sc_last_sent = time_second;
822:
823: *mtod(m0, u_char *) = address;
824: #else
825: /*
826: * Update the time we sent the most recent packet.
827: */
828: sc->sc_last_sent = time_second;
829: #endif
830: }
831:
832: #if NBPFILTER > 0
833: /*
834: * See if bpf wants to look at the packet.
835: */
836: if (sc->sc_bpf)
837: bpf_mtap(sc->sc_bpf, m0, BPF_DIRECTION_OUT);
838: #endif
839:
840: /*
841: * Put the packet on the appropriate queue.
842: */
843: s = splsoftnet();
844: if (mode == NPMODE_QUEUE) {
845: /* XXX we should limit the number of packets on this queue */
846: *sc->sc_npqtail = m0;
847: m0->m_nextpkt = NULL;
848: sc->sc_npqtail = &m0->m_nextpkt;
849: } else {
850: if ((m0->m_flags & M_HIGHPRI)
851: #ifdef ALTQ
852: && ALTQ_IS_ENABLED(&sc->sc_if.if_snd) == 0
853: #endif
854: ) {
855: ifq = &sc->sc_fastq;
856: if (IF_QFULL(ifq) && dst->sa_family != AF_UNSPEC) {
857: IF_DROP(ifq);
858: m_freem(m0);
859: error = ENOBUFS;
860: }
861: else {
862: IF_ENQUEUE(ifq, m0);
863: error = 0;
864: }
865: } else
866: IFQ_ENQUEUE(&sc->sc_if.if_snd, m0, NULL, error);
867: if (error) {
868: splx(s);
869: sc->sc_if.if_oerrors++;
870: sc->sc_stats.ppp_oerrors++;
871: return (error);
872: }
873: (*sc->sc_start)(sc);
874: }
875: ifp->if_opackets++;
876: ifp->if_obytes += len;
877:
878: splx(s);
879: return (0);
880:
881: bad:
882: m_freem(m0);
883: return (error);
884: }
885:
886: /*
887: * After a change in the NPmode for some NP, move packets from the
888: * npqueue to the send queue or the fast queue as appropriate.
889: * Should be called at splsoftnet.
890: */
891: static void
892: ppp_requeue(sc)
893: struct ppp_softc *sc;
894: {
895: struct mbuf *m, **mpp;
896: struct ifqueue *ifq;
897: enum NPmode mode;
898: int error;
899:
900: splassert(IPL_SOFTNET);
901:
902: for (mpp = &sc->sc_npqueue; (m = *mpp) != NULL; ) {
903: switch (PPP_PROTOCOL(mtod(m, u_char *))) {
904: case PPP_IP:
905: mode = sc->sc_npmode[NP_IP];
906: break;
907: default:
908: mode = NPMODE_PASS;
909: }
910:
911: switch (mode) {
912: case NPMODE_PASS:
913: /*
914: * This packet can now go on one of the queues to be sent.
915: */
916: *mpp = m->m_nextpkt;
917: m->m_nextpkt = NULL;
918: if ((m->m_flags & M_HIGHPRI)
919: #ifdef ALTQ
920: && ALTQ_IS_ENABLED(&sc->sc_if.if_snd) == 0
921: #endif
922: ) {
923: ifq = &sc->sc_fastq;
924: if (IF_QFULL(ifq)) {
925: IF_DROP(ifq);
926: m_freem(m);
927: error = ENOBUFS;
928: }
929: else {
930: IF_ENQUEUE(ifq, m);
931: error = 0;
932: }
933: } else
934: IFQ_ENQUEUE(&sc->sc_if.if_snd, m, NULL, error);
935: if (error) {
936: sc->sc_if.if_oerrors++;
937: sc->sc_stats.ppp_oerrors++;
938: }
939: break;
940:
941: case NPMODE_DROP:
942: case NPMODE_ERROR:
943: *mpp = m->m_nextpkt;
944: m_freem(m);
945: break;
946:
947: case NPMODE_QUEUE:
948: mpp = &m->m_nextpkt;
949: break;
950: }
951: }
952: sc->sc_npqtail = mpp;
953: }
954:
955: /*
956: * Transmitter has finished outputting some stuff;
957: * remember to call sc->sc_start later at splsoftnet.
958: */
959: void
960: ppp_restart(sc)
961: struct ppp_softc *sc;
962: {
963: int s = splnet();
964:
965: sc->sc_flags &= ~SC_TBUSY;
966: schednetisr(NETISR_PPP);
967: splx(s);
968: }
969:
970: /*
971: * Get a packet to send. This procedure is intended to be called at
972: * splsoftnet, since it may involve time-consuming operations such as
973: * applying VJ compression, packet compression, address/control and/or
974: * protocol field compression to the packet.
975: */
976: struct mbuf *
977: ppp_dequeue(sc)
978: struct ppp_softc *sc;
979: {
980: struct mbuf *m, *mp;
981: u_char *cp;
982: int address, control, protocol;
983:
984: /*
985: * Grab a packet to send: first try the fast queue, then the
986: * normal queue.
987: */
988: IF_DEQUEUE(&sc->sc_fastq, m);
989: if (m == NULL)
990: IFQ_DEQUEUE(&sc->sc_if.if_snd, m);
991: if (m == NULL)
992: return NULL;
993:
994: ++sc->sc_stats.ppp_opackets;
995:
996: /*
997: * Extract the ppp header of the new packet.
998: * The ppp header will be in one mbuf.
999: */
1000: cp = mtod(m, u_char *);
1001: address = PPP_ADDRESS(cp);
1002: control = PPP_CONTROL(cp);
1003: protocol = PPP_PROTOCOL(cp);
1004:
1005: switch (protocol) {
1006: case PPP_IP:
1007: #ifdef VJC
1008: /*
1009: * If the packet is a TCP/IP packet, see if we can compress it.
1010: */
1011: if ((sc->sc_flags & SC_COMP_TCP) && sc->sc_comp != NULL) {
1012: struct ip *ip;
1013: int type;
1014:
1015: mp = m;
1016: ip = (struct ip *) (cp + PPP_HDRLEN);
1017: if (mp->m_len <= PPP_HDRLEN) {
1018: mp = mp->m_next;
1019: if (mp == NULL)
1020: break;
1021: ip = mtod(mp, struct ip *);
1022: }
1023: /* this code assumes the IP/TCP header is in one non-shared mbuf */
1024: if (ip->ip_p == IPPROTO_TCP) {
1025: type = sl_compress_tcp(mp, ip, sc->sc_comp,
1026: !(sc->sc_flags & SC_NO_TCP_CCID));
1027: switch (type) {
1028: case TYPE_UNCOMPRESSED_TCP:
1029: protocol = PPP_VJC_UNCOMP;
1030: break;
1031: case TYPE_COMPRESSED_TCP:
1032: protocol = PPP_VJC_COMP;
1033: cp = mtod(m, u_char *);
1034: cp[0] = address; /* header has moved */
1035: cp[1] = control;
1036: cp[2] = 0;
1037: break;
1038: }
1039: cp[3] = protocol; /* update protocol in PPP header */
1040: }
1041: }
1042: #endif /* VJC */
1043: break;
1044:
1045: #ifdef PPP_COMPRESS
1046: case PPP_CCP:
1047: ppp_ccp(sc, m, 0);
1048: break;
1049: #endif /* PPP_COMPRESS */
1050: }
1051:
1052: #ifdef PPP_COMPRESS
1053: if (protocol != PPP_LCP && protocol != PPP_CCP
1054: && sc->sc_xc_state && (sc->sc_flags & SC_COMP_RUN)) {
1055: struct mbuf *mcomp = NULL;
1056: int slen, clen;
1057:
1058: slen = 0;
1059: for (mp = m; mp != NULL; mp = mp->m_next)
1060: slen += mp->m_len;
1061: clen = (*sc->sc_xcomp->compress)
1062: (sc->sc_xc_state, &mcomp, m, slen,
1063: (sc->sc_flags & SC_CCP_UP ? sc->sc_if.if_mtu + PPP_HDRLEN : 0));
1064: if (mcomp != NULL) {
1065: if (sc->sc_flags & SC_CCP_UP) {
1066: /* Send the compressed packet instead of the original. */
1067: m_freem(m);
1068: m = mcomp;
1069: cp = mtod(m, u_char *);
1070: protocol = cp[3];
1071: } else {
1072: /* Can't transmit compressed packets until CCP is up. */
1073: m_freem(mcomp);
1074: }
1075: }
1076: }
1077: #endif /* PPP_COMPRESS */
1078:
1079: /*
1080: * Compress the address/control and protocol, if possible.
1081: */
1082: if (sc->sc_flags & SC_COMP_AC && address == PPP_ALLSTATIONS &&
1083: control == PPP_UI && protocol != PPP_ALLSTATIONS &&
1084: protocol != PPP_LCP) {
1085: /* can compress address/control */
1086: m->m_data += 2;
1087: m->m_len -= 2;
1088: }
1089: if (sc->sc_flags & SC_COMP_PROT && protocol < 0xFF) {
1090: /* can compress protocol */
1091: if (mtod(m, u_char *) == cp) {
1092: cp[2] = cp[1]; /* move address/control up */
1093: cp[1] = cp[0];
1094: }
1095: ++m->m_data;
1096: --m->m_len;
1097: }
1098:
1099: return m;
1100: }
1101:
1102: /*
1103: * Software interrupt routine, called at splsoftnet.
1104: */
1105: void
1106: pppintr()
1107: {
1108: struct ppp_softc *sc;
1109: int s, s2;
1110: struct mbuf *m;
1111:
1112: splassert(IPL_SOFTNET);
1113:
1114: s = splsoftnet(); /* XXX - what's the point of this? see comment above */
1115: LIST_FOREACH(sc, &ppp_softc_list, sc_list) {
1116: if (!(sc->sc_flags & SC_TBUSY)
1117: && (IFQ_IS_EMPTY(&sc->sc_if.if_snd) == 0 || sc->sc_fastq.ifq_head)) {
1118: s2 = splnet();
1119: sc->sc_flags |= SC_TBUSY;
1120: splx(s2);
1121: (*sc->sc_start)(sc);
1122: }
1123: while (sc->sc_rawq.ifq_head) {
1124: s2 = splnet();
1125: IF_DEQUEUE(&sc->sc_rawq, m);
1126: splx(s2);
1127: if (m == NULL)
1128: break;
1129: ppp_inproc(sc, m);
1130: }
1131: }
1132: splx(s);
1133: }
1134:
1135: #ifdef PPP_COMPRESS
1136: /*
1137: * Handle a CCP packet. `rcvd' is 1 if the packet was received,
1138: * 0 if it is about to be transmitted.
1139: */
1140: static void
1141: ppp_ccp(sc, m, rcvd)
1142: struct ppp_softc *sc;
1143: struct mbuf *m;
1144: int rcvd;
1145: {
1146: u_char *dp, *ep;
1147: struct mbuf *mp;
1148: int slen, s;
1149:
1150: /*
1151: * Get a pointer to the data after the PPP header.
1152: */
1153: if (m->m_len <= PPP_HDRLEN) {
1154: mp = m->m_next;
1155: if (mp == NULL)
1156: return;
1157: dp = (mp != NULL)? mtod(mp, u_char *): NULL;
1158: } else {
1159: mp = m;
1160: dp = mtod(mp, u_char *) + PPP_HDRLEN;
1161: }
1162:
1163: ep = mtod(mp, u_char *) + mp->m_len;
1164: if (dp + CCP_HDRLEN > ep)
1165: return;
1166: slen = CCP_LENGTH(dp);
1167: if (dp + slen > ep) {
1168: if (sc->sc_flags & SC_DEBUG)
1169: printf("if_ppp/ccp: not enough data in mbuf (%p+%x > %p+%x)\n",
1170: dp, slen, mtod(mp, u_char *), mp->m_len);
1171: return;
1172: }
1173:
1174: switch (CCP_CODE(dp)) {
1175: case CCP_CONFREQ:
1176: case CCP_TERMREQ:
1177: case CCP_TERMACK:
1178: /* CCP must be going down - disable compression */
1179: if (sc->sc_flags & SC_CCP_UP) {
1180: s = splnet();
1181: sc->sc_flags &= ~(SC_CCP_UP | SC_COMP_RUN | SC_DECOMP_RUN);
1182: splx(s);
1183: }
1184: break;
1185:
1186: case CCP_CONFACK:
1187: if (sc->sc_flags & SC_CCP_OPEN && !(sc->sc_flags & SC_CCP_UP)
1188: && slen >= CCP_HDRLEN + CCP_OPT_MINLEN
1189: && slen >= CCP_OPT_LENGTH(dp + CCP_HDRLEN) + CCP_HDRLEN) {
1190: if (!rcvd) {
1191: /* we're agreeing to send compressed packets. */
1192: if (sc->sc_xc_state != NULL
1193: && (*sc->sc_xcomp->comp_init)
1194: (sc->sc_xc_state, dp + CCP_HDRLEN, slen - CCP_HDRLEN,
1195: sc->sc_unit, 0, sc->sc_flags & SC_DEBUG)) {
1196: s = splnet();
1197: sc->sc_flags |= SC_COMP_RUN;
1198: splx(s);
1199: }
1200: } else {
1201: /* peer is agreeing to send compressed packets. */
1202: if (sc->sc_rc_state != NULL
1203: && (*sc->sc_rcomp->decomp_init)
1204: (sc->sc_rc_state, dp + CCP_HDRLEN, slen - CCP_HDRLEN,
1205: sc->sc_unit, 0, sc->sc_mru,
1206: sc->sc_flags & SC_DEBUG)) {
1207: s = splnet();
1208: sc->sc_flags |= SC_DECOMP_RUN;
1209: sc->sc_flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
1210: splx(s);
1211: }
1212: }
1213: }
1214: break;
1215:
1216: case CCP_RESETACK:
1217: if (sc->sc_flags & SC_CCP_UP) {
1218: if (!rcvd) {
1219: if (sc->sc_xc_state && (sc->sc_flags & SC_COMP_RUN))
1220: (*sc->sc_xcomp->comp_reset)(sc->sc_xc_state);
1221: } else {
1222: if (sc->sc_rc_state && (sc->sc_flags & SC_DECOMP_RUN)) {
1223: (*sc->sc_rcomp->decomp_reset)(sc->sc_rc_state);
1224: s = splnet();
1225: sc->sc_flags &= ~SC_DC_ERROR;
1226: splx(s);
1227: }
1228: }
1229: }
1230: break;
1231: }
1232: }
1233:
1234: /*
1235: * CCP is down; free (de)compressor state if necessary.
1236: */
1237: static void
1238: ppp_ccp_closed(sc)
1239: struct ppp_softc *sc;
1240: {
1241: if (sc->sc_xc_state) {
1242: (*sc->sc_xcomp->comp_free)(sc->sc_xc_state);
1243: sc->sc_xc_state = NULL;
1244: }
1245: if (sc->sc_rc_state) {
1246: (*sc->sc_rcomp->decomp_free)(sc->sc_rc_state);
1247: sc->sc_rc_state = NULL;
1248: }
1249: }
1250: #endif /* PPP_COMPRESS */
1251:
1252: /*
1253: * PPP packet input routine.
1254: * The caller has checked and removed the FCS and has inserted
1255: * the address/control bytes and the protocol high byte if they
1256: * were omitted.
1257: */
1258: void
1259: ppppktin(sc, m, lost)
1260: struct ppp_softc *sc;
1261: struct mbuf *m;
1262: int lost;
1263: {
1264: int s = splnet();
1265:
1266: if (lost)
1267: m->m_flags |= M_ERRMARK;
1268: IF_ENQUEUE(&sc->sc_rawq, m);
1269: schednetisr(NETISR_PPP);
1270: splx(s);
1271: }
1272:
1273: /*
1274: * Process a received PPP packet, doing decompression as necessary.
1275: * Should be called at splsoftnet.
1276: */
1277: #define COMPTYPE(proto) ((proto) == PPP_VJC_COMP? TYPE_COMPRESSED_TCP: \
1278: TYPE_UNCOMPRESSED_TCP)
1279:
1280: static void
1281: ppp_inproc(sc, m)
1282: struct ppp_softc *sc;
1283: struct mbuf *m;
1284: {
1285: struct ifnet *ifp = &sc->sc_if;
1286: struct ifqueue *inq;
1287: int s, ilen, xlen, proto, rv;
1288: u_char *cp, adrs, ctrl;
1289: struct mbuf *mp, *dmp = NULL;
1290: u_char *iphdr;
1291: u_int hlen;
1292:
1293: sc->sc_stats.ppp_ipackets++;
1294:
1295: if (sc->sc_flags & SC_LOG_INPKT) {
1296: ilen = 0;
1297: for (mp = m; mp != NULL; mp = mp->m_next)
1298: ilen += mp->m_len;
1299: printf("%s: got %d bytes\n", ifp->if_xname, ilen);
1300: pppdumpm(m);
1301: }
1302:
1303: cp = mtod(m, u_char *);
1304: adrs = PPP_ADDRESS(cp);
1305: ctrl = PPP_CONTROL(cp);
1306: proto = PPP_PROTOCOL(cp);
1307:
1308: if (m->m_flags & M_ERRMARK) {
1309: m->m_flags &= ~M_ERRMARK;
1310: s = splnet();
1311: sc->sc_flags |= SC_VJ_RESET;
1312: splx(s);
1313: }
1314:
1315: #ifdef PPP_COMPRESS
1316: /*
1317: * Decompress this packet if necessary, update the receiver's
1318: * dictionary, or take appropriate action on a CCP packet.
1319: */
1320: if (proto == PPP_COMP && sc->sc_rc_state && (sc->sc_flags & SC_DECOMP_RUN)
1321: && !(sc->sc_flags & SC_DC_ERROR) && !(sc->sc_flags & SC_DC_FERROR)) {
1322: /* decompress this packet */
1323: rv = (*sc->sc_rcomp->decompress)(sc->sc_rc_state, m, &dmp);
1324: if (rv == DECOMP_OK) {
1325: m_freem(m);
1326: if (dmp == NULL) {
1327: /* no error, but no decompressed packet produced */
1328: return;
1329: }
1330: m = dmp;
1331: cp = mtod(m, u_char *);
1332: proto = PPP_PROTOCOL(cp);
1333:
1334: } else {
1335: /*
1336: * An error has occurred in decompression.
1337: * Pass the compressed packet up to pppd, which may take
1338: * CCP down or issue a Reset-Req.
1339: */
1340: if (sc->sc_flags & SC_DEBUG)
1341: printf("%s: decompress failed %d\n", ifp->if_xname, rv);
1342: s = splnet();
1343: sc->sc_flags |= SC_VJ_RESET;
1344: if (rv == DECOMP_ERROR)
1345: sc->sc_flags |= SC_DC_ERROR;
1346: else
1347: sc->sc_flags |= SC_DC_FERROR;
1348: splx(s);
1349: }
1350:
1351: } else {
1352: if (sc->sc_rc_state && (sc->sc_flags & SC_DECOMP_RUN)) {
1353: (*sc->sc_rcomp->incomp)(sc->sc_rc_state, m);
1354: }
1355: if (proto == PPP_CCP) {
1356: ppp_ccp(sc, m, 1);
1357: }
1358: }
1359: #endif
1360:
1361: ilen = 0;
1362: for (mp = m; mp != NULL; mp = mp->m_next)
1363: ilen += mp->m_len;
1364:
1365: #ifdef VJC
1366: if (sc->sc_flags & SC_VJ_RESET) {
1367: /*
1368: * If we've missed a packet, we must toss subsequent compressed
1369: * packets which don't have an explicit connection ID.
1370: */
1371: if (sc->sc_comp)
1372: sl_uncompress_tcp(NULL, 0, TYPE_ERROR, sc->sc_comp);
1373: s = splnet();
1374: sc->sc_flags &= ~SC_VJ_RESET;
1375: splx(s);
1376: }
1377:
1378: /*
1379: * See if we have a VJ-compressed packet to uncompress.
1380: */
1381: if (proto == PPP_VJC_COMP) {
1382: if ((sc->sc_flags & SC_REJ_COMP_TCP) || sc->sc_comp == 0)
1383: goto bad;
1384:
1385: xlen = sl_uncompress_tcp_core(cp + PPP_HDRLEN, m->m_len - PPP_HDRLEN,
1386: ilen - PPP_HDRLEN, TYPE_COMPRESSED_TCP,
1387: sc->sc_comp, &iphdr, &hlen);
1388:
1389: if (xlen <= 0) {
1390: if (sc->sc_flags & SC_DEBUG)
1391: printf("%s: VJ uncompress failed on type comp\n",
1392: ifp->if_xname);
1393: goto bad;
1394: }
1395:
1396: /* Copy the PPP and IP headers into a new mbuf. */
1397: MGETHDR(mp, M_DONTWAIT, MT_DATA);
1398: if (mp == NULL)
1399: goto bad;
1400: mp->m_len = 0;
1401: mp->m_next = NULL;
1402: if (hlen + PPP_HDRLEN > MHLEN) {
1403: MCLGET(mp, M_DONTWAIT);
1404: if (M_TRAILINGSPACE(mp) < hlen + PPP_HDRLEN) {
1405: m_freem(mp);
1406: goto bad; /* lose if big headers and no clusters */
1407: }
1408: }
1409: if (m->m_flags & M_PKTHDR)
1410: M_MOVE_HDR(mp, m);
1411: cp = mtod(mp, u_char *);
1412: cp[0] = adrs;
1413: cp[1] = ctrl;
1414: cp[2] = 0;
1415: cp[3] = PPP_IP;
1416: proto = PPP_IP;
1417: bcopy(iphdr, cp + PPP_HDRLEN, hlen);
1418: mp->m_len = hlen + PPP_HDRLEN;
1419:
1420: /*
1421: * Trim the PPP and VJ headers off the old mbuf
1422: * and stick the new and old mbufs together.
1423: */
1424: m->m_data += PPP_HDRLEN + xlen;
1425: m->m_len -= PPP_HDRLEN + xlen;
1426: if (m->m_len <= M_TRAILINGSPACE(mp)) {
1427: bcopy(mtod(m, u_char *), mtod(mp, u_char *) + mp->m_len, m->m_len);
1428: mp->m_len += m->m_len;
1429: MFREE(m, mp->m_next);
1430: } else
1431: mp->m_next = m;
1432: m = mp;
1433: ilen += hlen - xlen;
1434:
1435: } else if (proto == PPP_VJC_UNCOMP) {
1436: if ((sc->sc_flags & SC_REJ_COMP_TCP) || sc->sc_comp == 0)
1437: goto bad;
1438:
1439: xlen = sl_uncompress_tcp_core(cp + PPP_HDRLEN, m->m_len - PPP_HDRLEN,
1440: ilen - PPP_HDRLEN, TYPE_UNCOMPRESSED_TCP,
1441: sc->sc_comp, &iphdr, &hlen);
1442:
1443: if (xlen < 0) {
1444: if (sc->sc_flags & SC_DEBUG)
1445: printf("%s: VJ uncompress failed on type uncomp\n",
1446: ifp->if_xname);
1447: goto bad;
1448: }
1449:
1450: proto = PPP_IP;
1451: cp[3] = PPP_IP;
1452: }
1453: #endif /* VJC */
1454:
1455: /*
1456: * If the packet will fit in a header mbuf, don't waste a
1457: * whole cluster on it.
1458: */
1459: if (ilen <= MHLEN && M_IS_CLUSTER(m)) {
1460: MGETHDR(mp, M_DONTWAIT, MT_DATA);
1461: if (mp != NULL) {
1462: m_copydata(m, 0, ilen, mtod(mp, caddr_t));
1463: m_freem(m);
1464: m = mp;
1465: m->m_len = ilen;
1466: }
1467: }
1468: m->m_pkthdr.len = ilen;
1469: m->m_pkthdr.rcvif = ifp;
1470:
1471: if ((proto & 0x8000) == 0) {
1472: #if NBPFILTER > 0
1473: /*
1474: * See whether we want to pass this packet, and
1475: * if it counts as link activity.
1476: */
1477: adrs = *mtod(m, u_char *); /* save address field */
1478: *mtod(m, u_char *) = 0; /* indicate inbound */
1479: if (sc->sc_pass_filt.bf_insns != 0
1480: && bpf_filter(sc->sc_pass_filt.bf_insns, (u_char *) m,
1481: ilen, 0) == 0) {
1482: /* drop this packet */
1483: m_freem(m);
1484: return;
1485: }
1486: if (sc->sc_active_filt.bf_insns == 0
1487: || bpf_filter(sc->sc_active_filt.bf_insns, (u_char *) m, ilen, 0))
1488: sc->sc_last_recv = time_second;
1489:
1490: *mtod(m, u_char *) = adrs;
1491: #else
1492: /*
1493: * Record the time that we received this packet.
1494: */
1495: sc->sc_last_recv = time_second;
1496: #endif
1497: }
1498:
1499: #if NBPFILTER > 0
1500: /* See if bpf wants to look at the packet. */
1501: if (sc->sc_bpf)
1502: bpf_mtap(sc->sc_bpf, m, BPF_DIRECTION_IN);
1503: #endif
1504:
1505: rv = 0;
1506: switch (proto) {
1507: #ifdef INET
1508: case PPP_IP:
1509: /*
1510: * IP packet - take off the ppp header and pass it up to IP.
1511: */
1512: if ((ifp->if_flags & IFF_UP) == 0
1513: || sc->sc_npmode[NP_IP] != NPMODE_PASS) {
1514: /* interface is down - drop the packet. */
1515: m_freem(m);
1516: return;
1517: }
1518: m->m_pkthdr.len -= PPP_HDRLEN;
1519: m->m_data += PPP_HDRLEN;
1520: m->m_len -= PPP_HDRLEN;
1521: schednetisr(NETISR_IP);
1522: inq = &ipintrq;
1523: break;
1524: #endif
1525:
1526: default:
1527: /*
1528: * Some other protocol - place on input queue for read().
1529: */
1530: inq = &sc->sc_inq;
1531: rv = 1;
1532: break;
1533: }
1534:
1535: /*
1536: * Put the packet on the appropriate input queue.
1537: */
1538: s = splnet();
1539: if (IF_QFULL(inq)) {
1540: IF_DROP(inq);
1541: splx(s);
1542: if (sc->sc_flags & SC_DEBUG)
1543: printf("%s: input queue full\n", ifp->if_xname);
1544: ifp->if_iqdrops++;
1545: if (!inq->ifq_congestion)
1546: if_congestion(inq);
1547: goto bad;
1548: }
1549: IF_ENQUEUE(inq, m);
1550: splx(s);
1551: ifp->if_ipackets++;
1552: ifp->if_ibytes += ilen;
1553:
1554: if (rv)
1555: (*sc->sc_ctlp)(sc);
1556:
1557: return;
1558:
1559: bad:
1560: m_freem(m);
1561: sc->sc_if.if_ierrors++;
1562: sc->sc_stats.ppp_ierrors++;
1563: }
1564:
1565: #define MAX_DUMP_BYTES 128
1566:
1567: static void
1568: pppdumpm(m0)
1569: struct mbuf *m0;
1570: {
1571: char buf[3*MAX_DUMP_BYTES+4];
1572: char *bp = buf;
1573: struct mbuf *m;
1574: static char digits[] = "0123456789abcdef";
1575:
1576: for (m = m0; m; m = m->m_next) {
1577: int l = m->m_len;
1578: u_char *rptr = (u_char *)m->m_data;
1579:
1580: while (l--) {
1581: if (bp > buf + sizeof(buf) - 4)
1582: goto done;
1583: *bp++ = digits[*rptr >> 4]; /* convert byte to ascii hex */
1584: *bp++ = digits[*rptr++ & 0xf];
1585: }
1586:
1587: if (m->m_next) {
1588: if (bp > buf + sizeof(buf) - 3)
1589: goto done;
1590: *bp++ = '|';
1591: } else
1592: *bp++ = ' ';
1593: }
1594: done:
1595: if (m)
1596: *bp++ = '>';
1597: *bp = 0;
1598: printf("%s\n", buf);
1599: }
1600:
1601: #ifdef ALTQ
1602: /*
1603: * a wrapper to transmit a packet from if_start since ALTQ uses
1604: * if_start to send a packet.
1605: */
1606: static void
1607: ppp_ifstart(ifp)
1608: struct ifnet *ifp;
1609: {
1610: struct ppp_softc *sc;
1611:
1612: sc = ifp->if_softc;
1613: (*sc->sc_start)(sc);
1614: }
1615: #endif
1616:
1617: #endif /* NPPP > 0 */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_ppp.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / net