2 * if_ppp.c - Point-to-Point Protocol (PPP) Asynchronous driver.
4 * Copyright (c) 1989 Carnegie Mellon University.
7 * Redistribution and use in source and binary forms are permitted
8 * provided that the above copyright notice and this paragraph are
9 * duplicated in all such forms and that any documentation,
10 * advertising materials, and other materials related to such
11 * distribution and use acknowledge that the software was developed
12 * by Carnegie Mellon University. The name of the
13 * University may not be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
20 * Carnegie Mellon University
22 * Pittsburgh, PA 15213
27 * @(#)if_sl.c 7.6.1.2 (Berkeley) 2/15/89
29 * Copyright (c) 1987 Regents of the University of California.
30 * All rights reserved.
32 * Redistribution and use in source and binary forms are permitted
33 * provided that the above copyright notice and this paragraph are
34 * duplicated in all such forms and that any documentation,
35 * advertising materials, and other materials related to such
36 * distribution and use acknowledge that the software was developed
37 * by the University of California, Berkeley. The name of the
38 * University may not be used to endorse or promote products derived
39 * from this software without specific prior written permission.
40 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
41 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
42 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
44 * Serial Line interface
47 * Center for Seismic Studies
48 * 1300 N 17th Street, Suite 1450
49 * Arlington, Virginia 22209
54 * Pounded on heavily by Chris Torek (chris@mimsy.umd.edu, umcp-cs!chris).
55 * Converted to 4.3BSD Beta by Chris Torek.
56 * Other changes made at Berkeley, based in part on code by Kirk Smith.
58 * Converted to 4.3BSD+ 386BSD by Brad Parker (brad@cayman.com)
59 * Added VJ tcp header compression; more unified ioctls
61 * Extensively modified by Paul Mackerras (paulus@cs.anu.edu.au).
62 * Cleaned up a lot of the mbuf-related code to fix bugs that
63 * caused system crashes and packet corruption. Changed pppstart
64 * so that it doesn't just give up with a collision if the whole
65 * packet doesn't fit in the output ring buffer.
67 * Added priority queueing for interactive IP packets, following
68 * the model of if_sl.c, plus hooks for bpf.
69 * Paul Mackerras (paulus@cs.anu.edu.au).
72 /* $FreeBSD: src/sys/net/if_ppp.c,v 1.67.2.4 2002/04/14 21:41:48 luigi Exp $ */
73 /* $DragonFly: src/sys/net/ppp/if_ppp.c,v 1.36 2007/08/24 16:00:52 dillon Exp $ */
74 /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */
75 /* from NetBSD: if_ppp.c,v 1.15.2.2 1994/07/28 05:17:58 cgd Exp */
88 #include <sys/param.h>
89 #include <sys/systm.h>
92 #include <sys/socket.h>
93 #include <sys/filio.h>
94 #include <sys/sockio.h>
95 #include <sys/kernel.h>
97 #include <sys/malloc.h>
99 #include <sys/msgport2.h>
102 #include <net/if_types.h>
103 #include <net/ifq_var.h>
104 #include <net/netisr.h>
108 #include <netinet/in.h>
109 #include <netinet/in_systm.h>
110 #include <netinet/in_var.h>
111 #include <netinet/ip.h>
115 #include <netproto/ipx/ipx.h>
116 #include <netproto/ipx/ipx_if.h>
120 #include <net/slcompress.h>
124 #include "if_pppvar.h"
128 #define splsoftnet splnet
132 #define PACKETPTR struct mbuf *
133 #include <net/ppp_layer/ppp_comp.h>
136 struct ppp_softc ppp_softc
[NPPP
];
138 /* XXX layering violation */
139 extern void pppasyncattach (void *);
141 static void pppattach (void *);
142 PSEUDO_SET(pppattach
, if_ppp
);
144 static int pppsioctl (struct ifnet
*ifp
, u_long cmd
, caddr_t data
,
147 static void ppp_requeue (struct ppp_softc
*);
148 static void ppp_ccp (struct ppp_softc
*, struct mbuf
*m
, int rcvd
);
149 static void ppp_ccp_closed (struct ppp_softc
*);
150 static void ppp_inproc (struct ppp_softc
*, struct mbuf
*);
151 static void pppdumpm (struct mbuf
*m0
);
152 static void ppp_ifstart(struct ifnet
*ifp
);
155 * Some useful mbuf macros not in mbuf.h.
157 #define M_IS_CLUSTER(m) ((m)->m_flags & M_EXT)
159 #define M_DATASTART(m) \
160 (M_IS_CLUSTER(m) ? (m)->m_ext.ext_buf : \
161 (m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat)
163 #define M_DATASIZE(m) \
164 (M_IS_CLUSTER(m) ? (m)->m_ext.ext_size : \
165 (m)->m_flags & M_PKTHDR ? MHLEN: MLEN)
168 * We steal two bits in the mbuf m_flags, to mark high-priority packets
169 * for output, and received packets following lost/corrupted packets.
171 #define M_HIGHPRI M_PROTO2 /* output packet for sc_fastq */
172 #define M_ERRMARK M_PROTO3 /* steal a bit in mbuf m_flags */
177 * List of compressors we know about.
178 * We leave some space so maybe we can modload compressors.
181 extern struct compressor ppp_bsd_compress
;
182 extern struct compressor ppp_deflate
, ppp_deflate_draft
;
184 static struct compressor
*ppp_compressors
[8] = {
185 #if DO_BSD_COMPRESS && defined(PPP_BSDCOMP)
188 #if DO_DEFLATE && defined(PPP_DEFLATE)
194 #endif /* PPP_COMPRESS */
197 * Software interrupt routine, called at spl[soft]net.
200 pppintr(struct netmsg
*msg
)
203 struct ppp_softc
*sc
;
207 * Packets are never sent to this netisr so the message must always
208 * be replied. Interlock processing and notification by replying
211 lwkt_replymsg(&msg
->nm_lmsg
, 0);
214 for (i
= 0; i
< NPPP
; ++i
, ++sc
) {
215 lwkt_serialize_enter(sc
->sc_if
.if_serializer
);
216 if (!(sc
->sc_flags
& SC_TBUSY
)
217 && (!ifq_is_empty(&sc
->sc_if
.if_snd
) || !IF_QEMPTY(&sc
->sc_fastq
))) {
218 sc
->sc_flags
|= SC_TBUSY
;
222 IF_DEQUEUE(&sc
->sc_rawq
, m
);
227 lwkt_serialize_exit(sc
->sc_if
.if_serializer
);
232 * Called from boot code to establish ppp interfaces.
235 pppattach(void *dummy
)
237 struct ppp_softc
*sc
;
240 for (sc
= ppp_softc
; i
< NPPP
; sc
++) {
241 if_initname(&(sc
->sc_if
), "ppp", i
++);
242 sc
->sc_if
.if_softc
= sc
;
243 sc
->sc_if
.if_mtu
= PPP_MTU
;
244 sc
->sc_if
.if_flags
= IFF_POINTOPOINT
| IFF_MULTICAST
;
245 sc
->sc_if
.if_type
= IFT_PPP
;
246 sc
->sc_if
.if_hdrlen
= PPP_HDRLEN
;
247 sc
->sc_if
.if_ioctl
= pppsioctl
;
248 sc
->sc_if
.if_output
= pppoutput
;
249 sc
->sc_if
.if_start
= ppp_ifstart
;
250 ifq_set_maxlen(&sc
->sc_if
.if_snd
, IFQ_MAXLEN
);
251 ifq_set_ready(&sc
->sc_if
.if_snd
);
252 sc
->sc_inq
.ifq_maxlen
= IFQ_MAXLEN
;
253 sc
->sc_fastq
.ifq_maxlen
= IFQ_MAXLEN
;
254 sc
->sc_rawq
.ifq_maxlen
= IFQ_MAXLEN
;
255 callout_init(&sc
->sc_timeout
);
256 if_attach(&sc
->sc_if
, NULL
);
257 bpfattach(&sc
->sc_if
, DLT_PPP
, PPP_HDRLEN
);
259 netisr_register(NETISR_PPP
, cpu0_portfn
, pppintr
);
261 * XXX layering violation - if_ppp can work over any lower level
262 * transport that cares to attach to it.
264 pppasyncattach(dummy
);
268 * Allocate a ppp interface unit and initialize it.
271 pppalloc(struct thread
*td
)
274 struct ppp_softc
*sc
;
276 for (nppp
= 0, sc
= ppp_softc
; nppp
< NPPP
; nppp
++, sc
++)
277 if (sc
->sc_xfer
== td
) {
281 for (nppp
= 0, sc
= ppp_softc
; nppp
< NPPP
; nppp
++, sc
++)
282 if (sc
->sc_devp
== NULL
)
288 sc
->sc_mru
= PPP_MRU
;
289 sc
->sc_relinq
= NULL
;
290 bzero((char *)&sc
->sc_stats
, sizeof(sc
->sc_stats
));
292 MALLOC(sc
->sc_comp
, struct slcompress
*, sizeof(struct slcompress
),
294 sl_compress_init(sc
->sc_comp
, -1);
297 sc
->sc_xc_state
= NULL
;
298 sc
->sc_rc_state
= NULL
;
299 #endif /* PPP_COMPRESS */
300 for (i
= 0; i
< NUM_NP
; ++i
)
301 sc
->sc_npmode
[i
] = NPMODE_ERROR
;
302 sc
->sc_npqueue
= NULL
;
303 sc
->sc_npqtail
= &sc
->sc_npqueue
;
304 sc
->sc_last_sent
= sc
->sc_last_recv
= time_second
;
310 * Deallocate a ppp unit. Must be called at splsoftnet or higher.
313 pppdealloc(struct ppp_softc
*sc
)
318 sc
->sc_if
.if_flags
&= ~(IFF_UP
|IFF_RUNNING
);
319 getmicrotime(&sc
->sc_if
.if_lastchange
);
323 IF_DEQUEUE(&sc
->sc_rawq
, m
);
329 IF_DEQUEUE(&sc
->sc_inq
, m
);
335 IF_DEQUEUE(&sc
->sc_fastq
, m
);
340 while ((m
= sc
->sc_npqueue
) != NULL
) {
341 sc
->sc_npqueue
= m
->m_nextpkt
;
346 sc
->sc_xc_state
= NULL
;
347 sc
->sc_rc_state
= NULL
;
348 #endif /* PPP_COMPRESS */
350 if (sc
->sc_pass_filt
.bf_insns
!= 0) {
351 kfree(sc
->sc_pass_filt
.bf_insns
, M_DEVBUF
);
352 sc
->sc_pass_filt
.bf_insns
= 0;
353 sc
->sc_pass_filt
.bf_len
= 0;
355 if (sc
->sc_active_filt
.bf_insns
!= 0) {
356 kfree(sc
->sc_active_filt
.bf_insns
, M_DEVBUF
);
357 sc
->sc_active_filt
.bf_insns
= 0;
358 sc
->sc_active_filt
.bf_len
= 0;
360 #endif /* PPP_FILTER */
362 if (sc
->sc_comp
!= 0) {
363 kfree(sc
->sc_comp
, M_DEVBUF
);
370 * Ioctl routine for generic ppp devices.
373 pppioctl(struct ppp_softc
*sc
, u_long cmd
, caddr_t data
,
374 int flag
, struct ucred
*cred
)
376 int error
, flags
, mru
, npx
;
378 struct ppp_option_data
*odp
;
379 struct compressor
**cp
;
383 struct bpf_program
*bp
, *nbp
;
384 struct bpf_insn
*newcode
, *oldcode
;
386 #endif /* PPP_FILTER */
388 u_char ccp_option
[CCP_MAX_OPTION_LENGTH
];
393 *(int *)data
= sc
->sc_inq
.ifq_len
;
397 *(int *)data
= sc
->sc_if
.if_dunit
;
401 *(u_int
*)data
= sc
->sc_flags
;
405 if ((error
= suser_cred(cred
, 0)) != 0)
407 flags
= *(int *)data
& SC_MASK
;
410 if (sc
->sc_flags
& SC_CCP_OPEN
&& !(flags
& SC_CCP_OPEN
))
413 sc
->sc_flags
= (sc
->sc_flags
& ~SC_MASK
) | flags
;
418 if ((error
= suser_cred(cred
, 0)) != 0)
421 if (mru
>= PPP_MRU
&& mru
<= PPP_MAXMRU
)
426 *(int *)data
= sc
->sc_mru
;
431 if ((error
= suser_cred(cred
, 0)) != 0)
435 sl_compress_init(sc
->sc_comp
, *(int *)data
);
442 if ((error
= suser_cred(cred
, 0)) != 0)
444 sc
->sc_xfer
= curthread
;
448 case PPPIOCSCOMPRESS
:
449 if ((error
= suser_cred(cred
, 0)) != 0)
451 odp
= (struct ppp_option_data
*) data
;
453 if (nb
> sizeof(ccp_option
))
454 nb
= sizeof(ccp_option
);
455 if ((error
= copyin(odp
->ptr
, ccp_option
, nb
)) != 0)
457 if (ccp_option
[1] < 2) /* preliminary check on the length byte */
459 for (cp
= ppp_compressors
; *cp
!= NULL
; ++cp
)
460 if ((*cp
)->compress_proto
== ccp_option
[0]) {
462 * Found a handler for the protocol - try to allocate
463 * a compressor or decompressor.
468 if (sc
->sc_xc_state
!= NULL
)
469 (*sc
->sc_xcomp
->comp_free
)(sc
->sc_xc_state
);
471 sc
->sc_xc_state
= (*cp
)->comp_alloc(ccp_option
, nb
);
472 if (sc
->sc_xc_state
== NULL
) {
473 if (sc
->sc_flags
& SC_DEBUG
)
474 kprintf("%s: comp_alloc failed\n",
478 sc
->sc_flags
&= ~SC_COMP_RUN
;
482 if (sc
->sc_rc_state
!= NULL
)
483 (*sc
->sc_rcomp
->decomp_free
)(sc
->sc_rc_state
);
485 sc
->sc_rc_state
= (*cp
)->decomp_alloc(ccp_option
, nb
);
486 if (sc
->sc_rc_state
== NULL
) {
487 if (sc
->sc_flags
& SC_DEBUG
)
488 kprintf("%s: decomp_alloc failed\n",
492 sc
->sc_flags
&= ~SC_DECOMP_RUN
;
497 if (sc
->sc_flags
& SC_DEBUG
)
498 kprintf("%s: no compressor for [%x %x %x], %x\n",
499 sc
->sc_if
.if_xname
, ccp_option
[0], ccp_option
[1],
501 return (EINVAL
); /* no handler found */
502 #endif /* PPP_COMPRESS */
506 npi
= (struct npioctl
*) data
;
507 switch (npi
->protocol
) {
514 if (cmd
== PPPIOCGNPMODE
) {
515 npi
->mode
= sc
->sc_npmode
[npx
];
517 if ((error
= suser_cred(cred
, 0)) != 0)
519 if (npi
->mode
!= sc
->sc_npmode
[npx
]) {
521 sc
->sc_npmode
[npx
] = npi
->mode
;
522 if (npi
->mode
!= NPMODE_QUEUE
) {
534 ((struct ppp_idle
*)data
)->xmit_idle
= t
- sc
->sc_last_sent
;
535 ((struct ppp_idle
*)data
)->recv_idle
= t
- sc
->sc_last_recv
;
542 nbp
= (struct bpf_program
*) data
;
543 if ((unsigned) nbp
->bf_len
> BPF_MAXINSNS
)
545 newcodelen
= nbp
->bf_len
* sizeof(struct bpf_insn
);
546 if (newcodelen
!= 0) {
547 MALLOC(newcode
, struct bpf_insn
*, newcodelen
, M_DEVBUF
, M_WAITOK
);
549 return EINVAL
; /* or sumpin */
551 if ((error
= copyin((caddr_t
)nbp
->bf_insns
, (caddr_t
)newcode
,
553 kfree(newcode
, M_DEVBUF
);
556 if (!bpf_validate(newcode
, nbp
->bf_len
)) {
557 kfree(newcode
, M_DEVBUF
);
562 bp
= (cmd
== PPPIOCSPASS
)? &sc
->sc_pass_filt
: &sc
->sc_active_filt
;
563 oldcode
= bp
->bf_insns
;
565 bp
->bf_len
= nbp
->bf_len
;
566 bp
->bf_insns
= newcode
;
569 kfree(oldcode
, M_DEVBUF
);
580 * Process an ioctl request to the ppp network interface.
583 pppsioctl(struct ifnet
*ifp
, u_long cmd
, caddr_t data
, struct ucred
*cr
)
585 struct ppp_softc
*sc
= &ppp_softc
[ifp
->if_dunit
];
586 struct ifaddr
*ifa
= (struct ifaddr
*)data
;
587 struct ifreq
*ifr
= (struct ifreq
*)data
;
588 struct ppp_stats
*psp
;
590 struct ppp_comp_stats
*pcp
;
598 if ((ifp
->if_flags
& IFF_RUNNING
) == 0)
599 ifp
->if_flags
&= ~IFF_UP
;
604 switch(ifa
->ifa_addr
->sa_family
) {
614 error
= EAFNOSUPPORT
;
620 switch(ifa
->ifa_addr
->sa_family
) {
630 error
= EAFNOSUPPORT
;
636 if ((error
= suser_cred(cr
, 0)) != 0)
638 if (ifr
->ifr_mtu
> PPP_MAXMTU
)
641 sc
->sc_if
.if_mtu
= ifr
->ifr_mtu
;
643 (*sc
->sc_setmtu
)(sc
);
648 ifr
->ifr_mtu
= sc
->sc_if
.if_mtu
;
654 error
= EAFNOSUPPORT
;
657 switch(ifr
->ifr_addr
.sa_family
) {
663 error
= EAFNOSUPPORT
;
669 psp
= &((struct ifpppstatsreq
*) data
)->stats
;
670 bzero(psp
, sizeof(*psp
));
671 psp
->p
= sc
->sc_stats
;
672 #if defined(VJC) && !defined(SL_NO_STATS)
674 psp
->vj
.vjs_packets
= sc
->sc_comp
->sls_packets
;
675 psp
->vj
.vjs_compressed
= sc
->sc_comp
->sls_compressed
;
676 psp
->vj
.vjs_searches
= sc
->sc_comp
->sls_searches
;
677 psp
->vj
.vjs_misses
= sc
->sc_comp
->sls_misses
;
678 psp
->vj
.vjs_uncompressedin
= sc
->sc_comp
->sls_uncompressedin
;
679 psp
->vj
.vjs_compressedin
= sc
->sc_comp
->sls_compressedin
;
680 psp
->vj
.vjs_errorin
= sc
->sc_comp
->sls_errorin
;
681 psp
->vj
.vjs_tossed
= sc
->sc_comp
->sls_tossed
;
688 pcp
= &((struct ifpppcstatsreq
*) data
)->stats
;
689 bzero(pcp
, sizeof(*pcp
));
690 if (sc
->sc_xc_state
!= NULL
)
691 (*sc
->sc_xcomp
->comp_stat
)(sc
->sc_xc_state
, &pcp
->c
);
692 if (sc
->sc_rc_state
!= NULL
)
693 (*sc
->sc_rcomp
->decomp_stat
)(sc
->sc_rc_state
, &pcp
->d
);
695 #endif /* PPP_COMPRESS */
705 * Queue a packet. Start transmission if not active.
706 * Packet is placed in Information field of PPP frame.
707 * Called at splnet as the if->if_output handler.
708 * Called at splnet from pppwrite().
711 pppoutput(struct ifnet
*ifp
, struct mbuf
*m0
, struct sockaddr
*dst
,
714 struct ppp_softc
*sc
= &ppp_softc
[ifp
->if_dunit
];
715 int protocol
, address
, control
;
723 struct altq_pktattr pktattr
;
725 if (sc
->sc_devp
== NULL
|| (ifp
->if_flags
& IFF_RUNNING
) == 0
726 || ((ifp
->if_flags
& IFF_UP
) == 0 && dst
->sa_family
!= AF_UNSPEC
)) {
727 error
= ENETDOWN
; /* sort of */
731 ifq_classify(&ifp
->if_snd
, m0
, dst
->sa_family
, &pktattr
);
734 * Compute PPP header.
736 m0
->m_flags
&= ~M_HIGHPRI
;
737 switch (dst
->sa_family
) {
740 address
= PPP_ALLSTATIONS
;
743 mode
= sc
->sc_npmode
[NP_IP
];
746 * If this packet has the "low delay" bit set in the IP header,
747 * put it on the fastq instead.
749 ip
= mtod(m0
, struct ip
*);
750 if (ip
->ip_tos
& IPTOS_LOWDELAY
)
751 m0
->m_flags
|= M_HIGHPRI
;
757 * This is pretty bogus.. We dont have an ipxcp module in pppd
758 * yet to configure the link parameters. Sigh. I guess a
759 * manual ifconfig would do.... -Peter
761 address
= PPP_ALLSTATIONS
;
768 address
= PPP_ADDRESS(dst
->sa_data
);
769 control
= PPP_CONTROL(dst
->sa_data
);
770 protocol
= PPP_PROTOCOL(dst
->sa_data
);
774 kprintf("%s: af%d not supported\n", ifp
->if_xname
, dst
->sa_family
);
775 error
= EAFNOSUPPORT
;
780 * Drop this packet, or return an error, if necessary.
782 if (mode
== NPMODE_ERROR
) {
786 if (mode
== NPMODE_DROP
) {
792 * Add PPP header. If no space in first mbuf, allocate another.
793 * (This assumes M_LEADINGSPACE is always 0 for a cluster mbuf.)
795 if (M_LEADINGSPACE(m0
) < PPP_HDRLEN
) {
796 m0
= m_prepend(m0
, PPP_HDRLEN
, MB_DONTWAIT
);
803 m0
->m_data
-= PPP_HDRLEN
;
805 cp
= mtod(m0
, u_char
*);
808 *cp
++ = protocol
>> 8;
809 *cp
++ = protocol
& 0xff;
810 m0
->m_len
+= PPP_HDRLEN
;
813 for (m
= m0
; m
!= 0; m
= m
->m_next
)
816 if (sc
->sc_flags
& SC_LOG_OUTPKT
) {
817 kprintf("%s output: ", ifp
->if_xname
);
821 if ((protocol
& 0x8000) == 0) {
824 * Apply the pass and active filters to the packet,
825 * but only if it is a data packet.
827 *mtod(m0
, u_char
*) = 1; /* indicates outbound */
828 if (sc
->sc_pass_filt
.bf_insns
!= 0
829 && bpf_filter(sc
->sc_pass_filt
.bf_insns
, (u_char
*) m0
,
831 error
= 0; /* drop this packet */
836 * Update the time we sent the most recent packet.
838 if (sc
->sc_active_filt
.bf_insns
== 0
839 || bpf_filter(sc
->sc_active_filt
.bf_insns
, (u_char
*) m0
, len
, 0))
840 sc
->sc_last_sent
= time_second
;
842 *mtod(m0
, u_char
*) = address
;
845 * Update the time we sent the most recent data packet.
847 sc
->sc_last_sent
= time_second
;
848 #endif /* PPP_FILTER */
854 * Put the packet on the appropriate queue.
857 if (mode
== NPMODE_QUEUE
) {
858 /* XXX we should limit the number of packets on this queue */
859 *sc
->sc_npqtail
= m0
;
860 m0
->m_nextpkt
= NULL
;
861 sc
->sc_npqtail
= &m0
->m_nextpkt
;
863 /* fastq and if_snd are emptied at spl[soft]net now */
864 if ((m0
->m_flags
& M_HIGHPRI
) && !ifq_is_enabled(&sc
->sc_if
.if_snd
)) {
866 if (IF_QFULL(ifq
) && dst
->sa_family
!= AF_UNSPEC
) {
875 ASSERT_SERIALIZED(sc
->sc_if
.if_serializer
);
876 error
= ifq_enqueue(&sc
->sc_if
.if_snd
, m0
, &pktattr
);
880 sc
->sc_if
.if_oerrors
++;
881 sc
->sc_stats
.ppp_oerrors
++;
886 getmicrotime(&ifp
->if_lastchange
);
888 ifp
->if_obytes
+= len
;
899 * After a change in the NPmode for some NP, move packets from the
900 * npqueue to the send queue or the fast queue as appropriate.
901 * Should be called at spl[soft]net.
904 ppp_requeue(struct ppp_softc
*sc
)
906 struct mbuf
*m
, **mpp
;
911 for (mpp
= &sc
->sc_npqueue
; (m
= *mpp
) != NULL
; ) {
912 switch (PPP_PROTOCOL(mtod(m
, u_char
*))) {
914 mode
= sc
->sc_npmode
[NP_IP
];
923 * This packet can now go on one of the queues to be sent.
927 if ((m
->m_flags
& M_HIGHPRI
) && !ifq_is_enabled(&sc
->sc_if
.if_snd
)) {
937 lwkt_serialize_enter(sc
->sc_if
.if_serializer
);
938 error
= ifq_enqueue(&sc
->sc_if
.if_snd
, m
, NULL
);
939 lwkt_serialize_exit(sc
->sc_if
.if_serializer
);
942 sc
->sc_if
.if_oerrors
++;
943 sc
->sc_stats
.ppp_oerrors
++;
958 sc
->sc_npqtail
= mpp
;
962 * Transmitter has finished outputting some stuff;
963 * remember to call sc->sc_start later at splsoftnet.
966 ppp_restart(struct ppp_softc
*sc
)
969 sc
->sc_flags
&= ~SC_TBUSY
;
970 schednetisr(NETISR_PPP
);
976 * Get a packet to send. This procedure is intended to be called at
977 * splsoftnet, since it may involve time-consuming operations such as
978 * applying VJ compression, packet compression, address/control and/or
979 * protocol field compression to the packet.
982 ppp_dequeue(struct ppp_softc
*sc
)
986 int address
, control
, protocol
;
989 * Grab a packet to send: first try the fast queue, then the
992 IF_DEQUEUE(&sc
->sc_fastq
, m
);
994 m
= ifq_dequeue(&sc
->sc_if
.if_snd
, NULL
);
998 ++sc
->sc_stats
.ppp_opackets
;
1001 * Extract the ppp header of the new packet.
1002 * The ppp header will be in one mbuf.
1004 cp
= mtod(m
, u_char
*);
1005 address
= PPP_ADDRESS(cp
);
1006 control
= PPP_CONTROL(cp
);
1007 protocol
= PPP_PROTOCOL(cp
);
1013 * If the packet is a TCP/IP packet, see if we can compress it.
1015 if ((sc
->sc_flags
& SC_COMP_TCP
) && sc
->sc_comp
!= NULL
) {
1020 ip
= (struct ip
*) (cp
+ PPP_HDRLEN
);
1021 if (mp
->m_len
<= PPP_HDRLEN
) {
1025 ip
= mtod(mp
, struct ip
*);
1027 /* this code assumes the IP/TCP header is in one non-shared mbuf */
1028 if (ip
->ip_p
== IPPROTO_TCP
) {
1029 type
= sl_compress_tcp(mp
, ip
, sc
->sc_comp
,
1030 !(sc
->sc_flags
& SC_NO_TCP_CCID
));
1032 case TYPE_UNCOMPRESSED_TCP
:
1033 protocol
= PPP_VJC_UNCOMP
;
1035 case TYPE_COMPRESSED_TCP
:
1036 protocol
= PPP_VJC_COMP
;
1037 cp
= mtod(m
, u_char
*);
1038 cp
[0] = address
; /* header has moved */
1043 cp
[3] = protocol
; /* update protocol in PPP header */
1053 #endif /* PPP_COMPRESS */
1057 if (protocol
!= PPP_LCP
&& protocol
!= PPP_CCP
1058 && sc
->sc_xc_state
&& (sc
->sc_flags
& SC_COMP_RUN
)) {
1059 struct mbuf
*mcomp
= NULL
;
1063 for (mp
= m
; mp
!= NULL
; mp
= mp
->m_next
)
1065 clen
= (*sc
->sc_xcomp
->compress
)
1066 (sc
->sc_xc_state
, &mcomp
, m
, slen
, sc
->sc_if
.if_mtu
+ PPP_HDRLEN
);
1067 if (mcomp
!= NULL
) {
1068 if (sc
->sc_flags
& SC_CCP_UP
) {
1069 /* Send the compressed packet instead of the original. */
1072 cp
= mtod(m
, u_char
*);
1075 /* Can't transmit compressed packets until CCP is up. */
1080 #endif /* PPP_COMPRESS */
1083 * Compress the address/control and protocol, if possible.
1085 if (sc
->sc_flags
& SC_COMP_AC
&& address
== PPP_ALLSTATIONS
&&
1086 control
== PPP_UI
&& protocol
!= PPP_ALLSTATIONS
&&
1087 protocol
!= PPP_LCP
) {
1088 /* can compress address/control */
1092 if (sc
->sc_flags
& SC_COMP_PROT
&& protocol
< 0xFF) {
1093 /* can compress protocol */
1094 if (mtod(m
, u_char
*) == cp
) {
1095 cp
[2] = cp
[1]; /* move address/control up */
1107 * Handle a CCP packet. `rcvd' is 1 if the packet was received,
1108 * 0 if it is about to be transmitted.
1111 ppp_ccp(struct ppp_softc
*sc
, struct mbuf
*m
, int rcvd
)
1118 * Get a pointer to the data after the PPP header.
1120 if (m
->m_len
<= PPP_HDRLEN
) {
1124 dp
= (mp
!= NULL
)? mtod(mp
, u_char
*): NULL
;
1127 dp
= mtod(mp
, u_char
*) + PPP_HDRLEN
;
1130 ep
= mtod(mp
, u_char
*) + mp
->m_len
;
1131 if (dp
+ CCP_HDRLEN
> ep
)
1133 slen
= CCP_LENGTH(dp
);
1134 if (dp
+ slen
> ep
) {
1135 if (sc
->sc_flags
& SC_DEBUG
)
1136 kprintf("if_ppp/ccp: not enough data in mbuf (%p+%x > %p+%x)\n",
1137 dp
, slen
, mtod(mp
, u_char
*), mp
->m_len
);
1141 switch (CCP_CODE(dp
)) {
1145 /* CCP must be going down - disable compression */
1146 if (sc
->sc_flags
& SC_CCP_UP
) {
1148 sc
->sc_flags
&= ~(SC_CCP_UP
| SC_COMP_RUN
| SC_DECOMP_RUN
);
1154 if (sc
->sc_flags
& SC_CCP_OPEN
&& !(sc
->sc_flags
& SC_CCP_UP
)
1155 && slen
>= CCP_HDRLEN
+ CCP_OPT_MINLEN
1156 && slen
>= CCP_OPT_LENGTH(dp
+ CCP_HDRLEN
) + CCP_HDRLEN
) {
1158 /* we're agreeing to send compressed packets. */
1159 if (sc
->sc_xc_state
!= NULL
1160 && (*sc
->sc_xcomp
->comp_init
)
1161 (sc
->sc_xc_state
, dp
+ CCP_HDRLEN
, slen
- CCP_HDRLEN
,
1162 sc
->sc_if
.if_dunit
, 0, sc
->sc_flags
& SC_DEBUG
)) {
1164 sc
->sc_flags
|= SC_COMP_RUN
;
1168 /* peer is agreeing to send compressed packets. */
1169 if (sc
->sc_rc_state
!= NULL
1170 && (*sc
->sc_rcomp
->decomp_init
)
1171 (sc
->sc_rc_state
, dp
+ CCP_HDRLEN
, slen
- CCP_HDRLEN
,
1172 sc
->sc_if
.if_dunit
, 0, sc
->sc_mru
,
1173 sc
->sc_flags
& SC_DEBUG
)) {
1175 sc
->sc_flags
|= SC_DECOMP_RUN
;
1176 sc
->sc_flags
&= ~(SC_DC_ERROR
| SC_DC_FERROR
);
1184 if (sc
->sc_flags
& SC_CCP_UP
) {
1186 if (sc
->sc_xc_state
&& (sc
->sc_flags
& SC_COMP_RUN
))
1187 (*sc
->sc_xcomp
->comp_reset
)(sc
->sc_xc_state
);
1189 if (sc
->sc_rc_state
&& (sc
->sc_flags
& SC_DECOMP_RUN
)) {
1190 (*sc
->sc_rcomp
->decomp_reset
)(sc
->sc_rc_state
);
1192 sc
->sc_flags
&= ~SC_DC_ERROR
;
1202 * CCP is down; free (de)compressor state if necessary.
1205 ppp_ccp_closed(struct ppp_softc
*sc
)
1207 if (sc
->sc_xc_state
) {
1208 (*sc
->sc_xcomp
->comp_free
)(sc
->sc_xc_state
);
1209 sc
->sc_xc_state
= NULL
;
1211 if (sc
->sc_rc_state
) {
1212 (*sc
->sc_rcomp
->decomp_free
)(sc
->sc_rc_state
);
1213 sc
->sc_rc_state
= NULL
;
1216 #endif /* PPP_COMPRESS */
1219 * PPP packet input routine.
1220 * The caller has checked and removed the FCS and has inserted
1221 * the address/control bytes and the protocol high byte if they
1225 ppppktin(struct ppp_softc
*sc
, struct mbuf
*m
, int lost
)
1230 m
->m_flags
|= M_ERRMARK
;
1231 IF_ENQUEUE(&sc
->sc_rawq
, m
);
1232 schednetisr(NETISR_PPP
);
1238 * Process a received PPP packet, doing decompression as necessary.
1239 * Should be called at splsoftnet.
1241 #define COMPTYPE(proto) ((proto) == PPP_VJC_COMP? TYPE_COMPRESSED_TCP: \
1242 TYPE_UNCOMPRESSED_TCP)
1245 ppp_inproc(struct ppp_softc
*sc
, struct mbuf
*m
)
1247 struct ifnet
*ifp
= &sc
->sc_if
;
1249 int ilen
= 0, xlen
, proto
, rv
;
1250 u_char
*cp
, adrs
, ctrl
;
1251 struct mbuf
*mp
, *dmp
= NULL
;
1255 ASSERT_SERIALIZED(ifp
->if_serializer
);
1257 sc
->sc_stats
.ppp_ipackets
++;
1259 if (sc
->sc_flags
& SC_LOG_INPKT
) {
1261 for (mp
= m
; mp
!= NULL
; mp
= mp
->m_next
)
1263 kprintf("%s: got %d bytes\n", ifp
->if_xname
, ilen
);
1267 cp
= mtod(m
, u_char
*);
1268 adrs
= PPP_ADDRESS(cp
);
1269 ctrl
= PPP_CONTROL(cp
);
1270 proto
= PPP_PROTOCOL(cp
);
1272 if (m
->m_flags
& M_ERRMARK
) {
1273 m
->m_flags
&= ~M_ERRMARK
;
1275 sc
->sc_flags
|= SC_VJ_RESET
;
1281 * Decompress this packet if necessary, update the receiver's
1282 * dictionary, or take appropriate action on a CCP packet.
1284 if (proto
== PPP_COMP
&& sc
->sc_rc_state
&& (sc
->sc_flags
& SC_DECOMP_RUN
)
1285 && !(sc
->sc_flags
& SC_DC_ERROR
) && !(sc
->sc_flags
& SC_DC_FERROR
)) {
1286 /* decompress this packet */
1287 rv
= (*sc
->sc_rcomp
->decompress
)(sc
->sc_rc_state
, m
, &dmp
);
1288 if (rv
== DECOMP_OK
) {
1291 /* no error, but no decompressed packet produced */
1295 cp
= mtod(m
, u_char
*);
1296 proto
= PPP_PROTOCOL(cp
);
1300 * An error has occurred in decompression.
1301 * Pass the compressed packet up to pppd, which may take
1302 * CCP down or issue a Reset-Req.
1304 if (sc
->sc_flags
& SC_DEBUG
)
1305 kprintf("%s: decompress failed %d\n", ifp
->if_xname
, rv
);
1307 sc
->sc_flags
|= SC_VJ_RESET
;
1308 if (rv
== DECOMP_ERROR
)
1309 sc
->sc_flags
|= SC_DC_ERROR
;
1311 sc
->sc_flags
|= SC_DC_FERROR
;
1316 if (sc
->sc_rc_state
&& (sc
->sc_flags
& SC_DECOMP_RUN
)) {
1317 (*sc
->sc_rcomp
->incomp
)(sc
->sc_rc_state
, m
);
1319 if (proto
== PPP_CCP
) {
1326 for (mp
= m
; mp
!= NULL
; mp
= mp
->m_next
)
1330 if (sc
->sc_flags
& SC_VJ_RESET
) {
1332 * If we've missed a packet, we must toss subsequent compressed
1333 * packets which don't have an explicit connection ID.
1336 sl_uncompress_tcp(NULL
, 0, TYPE_ERROR
, sc
->sc_comp
);
1338 sc
->sc_flags
&= ~SC_VJ_RESET
;
1343 * See if we have a VJ-compressed packet to uncompress.
1345 if (proto
== PPP_VJC_COMP
) {
1346 if ((sc
->sc_flags
& SC_REJ_COMP_TCP
) || sc
->sc_comp
== 0)
1349 xlen
= sl_uncompress_tcp_core(cp
+ PPP_HDRLEN
, m
->m_len
- PPP_HDRLEN
,
1350 ilen
- PPP_HDRLEN
, TYPE_COMPRESSED_TCP
,
1351 sc
->sc_comp
, &iphdr
, &hlen
);
1354 if (sc
->sc_flags
& SC_DEBUG
)
1355 kprintf("%s: VJ uncompress failed on type comp\n",
1360 /* Copy the PPP and IP headers into a new mbuf. */
1361 MGETHDR(mp
, MB_DONTWAIT
, MT_DATA
);
1366 if (hlen
+ PPP_HDRLEN
> MHLEN
) {
1367 MCLGET(mp
, MB_DONTWAIT
);
1368 if (M_TRAILINGSPACE(mp
) < hlen
+ PPP_HDRLEN
) {
1370 goto bad
; /* lose if big headers and no clusters */
1373 cp
= mtod(mp
, u_char
*);
1379 bcopy(iphdr
, cp
+ PPP_HDRLEN
, hlen
);
1380 mp
->m_len
= hlen
+ PPP_HDRLEN
;
1383 * Trim the PPP and VJ headers off the old mbuf
1384 * and stick the new and old mbufs together.
1386 m
->m_data
+= PPP_HDRLEN
+ xlen
;
1387 m
->m_len
-= PPP_HDRLEN
+ xlen
;
1388 if (m
->m_len
<= M_TRAILINGSPACE(mp
)) {
1389 bcopy(mtod(m
, u_char
*), mtod(mp
, u_char
*) + mp
->m_len
, m
->m_len
);
1390 mp
->m_len
+= m
->m_len
;
1391 mp
->m_next
= m_free(m
);
1396 ilen
+= hlen
- xlen
;
1398 } else if (proto
== PPP_VJC_UNCOMP
) {
1399 if ((sc
->sc_flags
& SC_REJ_COMP_TCP
) || sc
->sc_comp
== 0)
1402 xlen
= sl_uncompress_tcp_core(cp
+ PPP_HDRLEN
, m
->m_len
- PPP_HDRLEN
,
1403 ilen
- PPP_HDRLEN
, TYPE_UNCOMPRESSED_TCP
,
1404 sc
->sc_comp
, &iphdr
, &hlen
);
1407 if (sc
->sc_flags
& SC_DEBUG
)
1408 kprintf("%s: VJ uncompress failed on type uncomp\n",
1419 * If the packet will fit in a header mbuf, don't waste a
1420 * whole cluster on it.
1422 if (ilen
<= MHLEN
&& M_IS_CLUSTER(m
)) {
1423 MGETHDR(mp
, MB_DONTWAIT
, MT_DATA
);
1425 m_copydata(m
, 0, ilen
, mtod(mp
, caddr_t
));
1431 m
->m_pkthdr
.len
= ilen
;
1432 m
->m_pkthdr
.rcvif
= ifp
;
1434 if ((proto
& 0x8000) == 0) {
1437 * See whether we want to pass this packet, and
1438 * if it counts as link activity.
1440 adrs
= *mtod(m
, u_char
*); /* save address field */
1441 *mtod(m
, u_char
*) = 0; /* indicate inbound */
1442 if (sc
->sc_pass_filt
.bf_insns
!= 0
1443 && bpf_filter(sc
->sc_pass_filt
.bf_insns
, (u_char
*) m
,
1445 /* drop this packet */
1449 if (sc
->sc_active_filt
.bf_insns
== 0
1450 || bpf_filter(sc
->sc_active_filt
.bf_insns
, (u_char
*) m
, ilen
, 0))
1451 sc
->sc_last_recv
= time_second
;
1453 *mtod(m
, u_char
*) = adrs
;
1456 * Record the time that we received this packet.
1458 sc
->sc_last_recv
= time_second
;
1459 #endif /* PPP_FILTER */
1462 BPF_MTAP(&sc
->sc_if
, m
);
1469 * IP packet - take off the ppp header and pass it up to IP.
1471 if ((ifp
->if_flags
& IFF_UP
) == 0
1472 || sc
->sc_npmode
[NP_IP
] != NPMODE_PASS
) {
1473 /* interface is down - drop the packet. */
1477 m
->m_pkthdr
.len
-= PPP_HDRLEN
;
1478 m
->m_data
+= PPP_HDRLEN
;
1479 m
->m_len
-= PPP_HDRLEN
;
1480 if (ipflow_fastforward(m
, ifp
->if_serializer
))
1488 * IPX packet - take off the ppp header and pass it up to IPX.
1490 if ((sc
->sc_if
.if_flags
& IFF_UP
) == 0
1491 /* XXX: || sc->sc_npmode[NP_IPX] != NPMODE_PASS*/) {
1492 /* interface is down - drop the packet. */
1496 m
->m_pkthdr
.len
-= PPP_HDRLEN
;
1497 m
->m_data
+= PPP_HDRLEN
;
1498 m
->m_len
-= PPP_HDRLEN
;
1500 sc
->sc_last_recv
= time_second
; /* update time of last pkt rcvd */
1506 * Some other protocol - place on input queue for read().
1512 * If we found a netproto just pass it to the proto. Otherwise queue
1513 * the packet to the tty (e.g. pppd). Note that sc_ctlp() must be
1514 * called EXACTLY once per packet queued.
1517 rv
= IF_HANDOFF(&sc
->sc_inq
, m
, NULL
);
1521 rv
= (netisr_queue(isr
, m
) == 0);
1524 if (sc
->sc_flags
& SC_DEBUG
)
1525 kprintf("%s: input queue full\n", ifp
->if_xname
);
1531 ifp
->if_ibytes
+= ilen
;
1532 getmicrotime(&ifp
->if_lastchange
);
1538 sc
->sc_if
.if_ierrors
++;
1539 sc
->sc_stats
.ppp_ierrors
++;
1542 #define MAX_DUMP_BYTES 128
1545 pppdumpm(struct mbuf
*m0
)
1547 char buf
[3*MAX_DUMP_BYTES
+4];
1551 for (m
= m0
; m
; m
= m
->m_next
) {
1553 u_char
*rptr
= (u_char
*)m
->m_data
;
1556 if (bp
> buf
+ sizeof(buf
) - 4)
1558 *bp
++ = hex2ascii(*rptr
>> 4);
1559 *bp
++ = hex2ascii(*rptr
++ & 0xf);
1563 if (bp
> buf
+ sizeof(buf
) - 3)
1573 kprintf("%s\n", buf
);
1577 * a wrapper to transmit a packet from if_start since ALTQ uses
1578 * if_start to send a packet.
1581 ppp_ifstart(struct ifnet
*ifp
)
1583 struct ppp_softc
*sc
;
1586 (*sc
->sc_start
)(sc
);