* if_ppp.c - Point-to-Point Protocol (PPP) Asynchronous driver.
* Copyright (c) 1989 Carnegie Mellon University.
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by Carnegie Mellon University. The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
* Carnegie Mellon University
* @(#)if_sl.c 7.6.1.2 (Berkeley) 2/15/89
* Copyright (c) 1987 Regents of the University of California.
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley. The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
* Center for Seismic Studies
* 1300 N 17th Street, Suite 1450
* Arlington, Virginia 22209
* Pounded on heavily by Chris Torek (chris@mimsy.umd.edu, umcp-cs!chris).
* Converted to 4.3BSD Beta by Chris Torek.
* Other changes made at Berkeley, based in part on code by Kirk Smith.
* Converted to 4.3BSD+ 386BSD by Brad Parker (brad@cayman.com)
* Added VJ tcp header compression; more unified ioctls
* Extensively modified by Paul Mackerras (paulus@cs.anu.edu.au).
* Cleaned up a lot of the mbuf-related code to fix bugs that
* caused system crashes and packet corruption. Changed pppstart
* so that it doesn't just give up with a collision if the whole
* packet doesn't fit in the output ring buffer.
* Added priority queueing for interactive IP packets, following
* the model of if_sl.c, plus hooks for bpf.
* Paul Mackerras (paulus@cs.anu.edu.au).
* $Id: if_ppp.c,v 1.11 1994/03/23 01:58:24 ache Exp $
* From: if_ppp.c,v 1.22 1993/08/31 23:20:40 paulus Exp
* From: if_ppp.c,v 1.21 1993/08/29 11:22:37 paulus Exp
* From: if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp
#include "../netinet/in.h"
#include "../netinet/in_systm.h"
#include "../netinet/in_var.h"
#include "../netinet/ip.h"
* Here we try to tell whether we are in a 386BSD kernel, or
* in a NetBSD/Net-2/4.3-Reno kernel.
/* NetBSD, 4.3-Reno or similar */
#define CCOUNT(q) ((q)->c_cc)
/* 386BSD, Jolitz-style ring buffers */
#define CCOUNT(q) (RB_LEN(q))
/* HDROFF should really be 128, but other parts of the system will
panic on TCP+IP headers bigger than MAX_HDR = MHLEN (100). */
#include "machine/mtpr.h"
struct ppp_softc ppp_softc
[NPPP
];
int ppp_async_out_debug
= 0;
int ppp_async_in_debug
= 0;
int ppp_raw_in_debug
= -1;
void pppattach
__P((void));
int pppopen
__P((dev_t dev
, struct tty
*tp
));
void pppclose
__P((struct tty
*tp
, int flag
));
int pppread
__P((struct tty
*tp
, struct uio
*uio
, int flag
));
int pppwrite
__P((struct tty
*tp
, struct uio
*uio
, int flag
));
int ppptioctl
__P((struct tty
*tp
, int cmd
, caddr_t data
, int flag
));
int pppoutput
__P((struct ifnet
*ifp
, struct mbuf
*m0
,
struct sockaddr
*dst
, struct rtentry
*rt
));
void pppstart
__P((struct tty
*tp
));
void pppinput
__P((int c
, struct tty
*tp
));
int pppioctl
__P((struct ifnet
*ifp
, int cmd
, caddr_t data
));
static u_short pppfcs
__P((u_short fcs
, u_char
*cp
, int len
));
static int pppinit
__P((struct ppp_softc
*sc
));
static struct mbuf
*ppp_btom
__P((struct ppp_softc
*sc
));
static void pppdumpm
__P((struct mbuf
*m0
, int pktlen
));
static void pppdumpb
__P((u_char
*b
, int l
));
* Some useful mbuf macros not in mbuf.h.
((m)->m_flags & M_EXT ? (m)->m_ext.ext_buf : \
(m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat)
((m)->m_flags & M_EXT ? (m)->m_ext.ext_size : \
(m)->m_flags & M_PKTHDR ? MHLEN: MLEN)
* The following disgusting hack gets around the problem that IP TOS
* can't be set yet. We want to put "interactive" traffic on a high
* priority queue. To decide if traffic is interactive, we check that
* a) it is TCP and b) one of its ports is telnet, rlogin or ftp control.
static u_short interactive_ports
[8] = {
#define INTERACTIVE(p) (interactive_ports[(p) & 7] == (p))
* Does c need to be escaped?
#define ESCAPE_P(c) (((c) == PPP_FLAG) || ((c) == PPP_ESCAPE) || \
(c) < 0x20 && (sc->sc_asyncmap & (1 << (c))))
* Called from boot code to establish ppp interfaces.
register struct ppp_softc
*sc
;
for (sc
= ppp_softc
; i
< NPPP
; sc
++) {
sc
->sc_if
.if_name
= "ppp";
sc
->sc_if
.if_mtu
= PPP_MTU
;
sc
->sc_if
.if_flags
= IFF_POINTOPOINT
;
sc
->sc_if
.if_type
= IFT_PPP
;
sc
->sc_if
.if_hdrlen
= PPP_HEADER_LEN
;
sc
->sc_if
.if_ioctl
= pppioctl
;
sc
->sc_if
.if_output
= pppoutput
;
sc
->sc_if
.if_snd
.ifq_maxlen
= IFQ_MAXLEN
;
sc
->sc_inq
.ifq_maxlen
= IFQ_MAXLEN
;
sc
->sc_fastq
.ifq_maxlen
= IFQ_MAXLEN
;
bpfattach(&sc
->sc_bpf
, &sc
->sc_if
, DLT_PPP
, PPP_HEADER_LEN
);
TEXT_SET(pseudo_set
, pppattach
);
* Line specific open routine.
* Attach the given tty to the first available ppp unit.
struct proc
*p
= curproc
; /* XXX */
register struct ppp_softc
*sc
;
if (error
= suser(p
->p_ucred
, &p
->p_acflag
))
if (tp
->t_line
== PPPDISC
)
for (nppp
= 0, sc
= ppp_softc
; nppp
< NPPP
; nppp
++, sc
++)
sl_compress_init(&sc
->sc_comp
);
sc
->sc_if
.if_flags
&= ~(IFF_UP
|IFF_RUNNING
);
ttyflush(tp
, FREAD
| FWRITE
);
sc
->sc_if
.if_flags
|= IFF_RUNNING
;
/* N.B. this code is designed *only* for use in NetBSD */
/* get rid of the default outq clist buffer */
/* and get a new one, without quoting support, much larger */
clalloc(&tp
->t_outq
, PPP_OUTQ_SIZE
, 0);
#endif /* PPP_OUTQ_SIZE */
* Line specific close routine.
* Detach the tty from the ppp unit.
* Mimics part of ttyclose().
register struct ppp_softc
*sc
;
s
= splimp(); /* paranoid; splnet probably ok */
sc
= (struct ppp_softc
*)tp
->t_sc
;
IF_DEQUEUE(&sc
->sc_inq
, m
);
IF_DEQUEUE(&sc
->sc_fastq
, m
);
sc
->sc_if
.if_flags
&= ~(IFF_UP
|IFF_RUNNING
);
/* reinstall default clist-buffer for outq
XXXX should really remember old value and restore that!! */
clalloc(&tp
->t_outq
, 1024, 0);
#endif /* PPP_OUTQ_SIZE */
* Line specific (tty) read routine.
register struct ppp_softc
*sc
= (struct ppp_softc
*)tp
->t_sc
;
while (sc
->sc_inq
.ifq_head
== NULL
&& tp
->t_line
== PPPDISC
) {
if (tp
->t_state
& TS_ASYNC
) {
error
= ttysleep(tp
, (caddr_t
)tp
->t_rawq
, TTIPRI
|PCATCH
, ttyin
, 0);
if (tp
->t_line
!= PPPDISC
) {
/* Pull place-holder byte out of canonical queue */
/* Get the packet from the input queue */
IF_DEQUEUE(&sc
->sc_inq
, m0
);
for (m
= m0
; m
&& uio
->uio_resid
; m
= m
->m_next
)
if (error
= uiomove(mtod(m
, u_char
*), m
->m_len
, uio
))
* Line specific (tty) write routine.
register struct ppp_softc
*sc
= (struct ppp_softc
*)tp
->t_sc
;
struct mbuf
*m
, *m0
, **mp
;
struct ppp_header
*ph1
, *ph2
;
if (tp
->t_line
!= PPPDISC
)
if (uio
->uio_resid
> sc
->sc_if
.if_mtu
+ PPP_HEADER_LEN
||
uio
->uio_resid
< PPP_HEADER_LEN
)
for (mp
= &m0
; uio
->uio_resid
; mp
= &m
->m_next
) {
MGET(m
, M_WAIT
, MT_DATA
);
if (uio
->uio_resid
>= MCLBYTES
/ 2)
len
= MIN(M_TRAILINGSPACE(m
), uio
->uio_resid
);
if (error
= uiomove(mtod(m
, u_char
*), len
, uio
)) {
dst
.sa_family
= AF_UNSPEC
;
ph1
= (struct ppp_header
*) &dst
.sa_data
;
ph2
= mtod(m0
, struct ppp_header
*);
m0
->m_data
+= PPP_HEADER_LEN
;
m0
->m_len
-= PPP_HEADER_LEN
;
return (pppoutput(&sc
->sc_if
, m0
, &dst
, 0));
* Line specific (tty) ioctl routine.
* Provide a way to get the ppp unit number.
* This discipline requires that tty device drivers call
* the line specific l_ioctl routine from their ioctl routines.
ppptioctl(tp
, cmd
, data
, flag
)
register struct ppp_softc
*sc
= (struct ppp_softc
*)tp
->t_sc
;
struct proc
*p
= curproc
; /* XXX */
int s
, error
, flags
, mru
;
#if 0 /* this is handled (properly) by ttioctl */
*(int *)data
= sc
->sc_if
.if_unit
;
*(int *)data
= sc
->sc_inq
.ifq_len
;
*(int *)data
= sc
->sc_if
.if_unit
;
*(u_int
*)data
= sc
->sc_flags
;
if (error
= suser(p
->p_ucred
, &p
->p_acflag
))
flags
= *(int *)data
& SC_MASK
;
sc
->sc_flags
= (sc
->sc_flags
& ~SC_MASK
) | flags
;
if (error
= suser(p
->p_ucred
, &p
->p_acflag
))
sc
->sc_asyncmap
= *(u_int
*)data
;
*(u_int
*)data
= sc
->sc_asyncmap
;
if (error
= suser(p
->p_ucred
, &p
->p_acflag
))
sc
->sc_rasyncmap
= *(u_int
*)data
;
*(u_int
*)data
= sc
->sc_rasyncmap
;
if (error
= suser(p
->p_ucred
, &p
->p_acflag
))
if (mru
>= PPP_MRU
&& mru
<= PPP_MAXMRU
) {
sc
->sc_if
.if_flags
&= ~IFF_UP
;
*(int *)data
= sc
->sc_mru
;
* FCS lookup table as calculated by genfcstab.
static u_short fcstab
[256] = {
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
* Calculate a new FCS given the current FCS and the new data.
fcs
= PPP_FCS(fcs
, *cp
++);
* Queue a packet. Start transmission if not active.
* Packet is placed in Information field of PPP frame.
pppoutput(ifp
, m0
, dst
, rt
)
register struct ppp_softc
*sc
= &ppp_softc
[ifp
->if_unit
];
int protocol
, address
, control
;
if (sc
->sc_ttyp
== NULL
|| (ifp
->if_flags
& IFF_RUNNING
) == 0
|| (ifp
->if_flags
& IFF_UP
) == 0 && dst
->sa_family
!= AF_UNSPEC
) {
error
= ENETDOWN
; /* sort of */
if (!CAN_DO_IO(sc
->sc_ttyp
)) {
address
= PPP_ALLSTATIONS
;
switch (dst
->sa_family
) {
* If this is a TCP packet to or from an "interactive" port,
* put the packet on the fastq instead.
if ((ip
= mtod(m0
, struct ip
*))->ip_p
== IPPROTO_TCP
) {
register int p
= ((int *)ip
)[ip
->ip_hl
];
if (INTERACTIVE(p
& 0xffff) || INTERACTIVE(p
>> 16))
ph
= (struct ppp_header
*) dst
->sa_data
;
address
= ph
->ph_address
;
control
= ph
->ph_control
;
protocol
= ntohs(ph
->ph_protocol
);
printf("ppp%d: af%d not supported\n", ifp
->if_unit
, dst
->sa_family
);
* Add PPP header. If no space in first mbuf, allocate another.
* (This assumes M_LEADINGSPACE is always 0 for a cluster mbuf.)
if (M_LEADINGSPACE(m0
) < PPP_HEADER_LEN
) {
m0
= m_prepend(m0
, PPP_HEADER_LEN
, M_DONTWAIT
);
m0
->m_data
-= PPP_HEADER_LEN
;
m0
->m_len
+= PPP_HEADER_LEN
;
if (ppp_async_out_debug
) {
printf("ppp%d output: ", ifp
->if_unit
);
/* See if bpf wants to look at the packet. */
bpf_mtap(sc
->sc_bpf
, m0
);
* Put the packet on the appropriate queue.
* The next statement used to be subject to:
* if (CCOUNT(&sc->sc_ttyp->t_outq) == 0)
* which was removed so that we don't hang up completely
* if the serial transmitter loses an interrupt.
* Start output on interface. Get another datagram
* to send from the interface queue and map it to
* the interface before starting output.
register struct ppp_softc
*sc
= (struct ppp_softc
*)tp
->t_sc
;
register u_char
*start
, *stop
, *cp
;
int address
, control
, protocol
;
int compac
, compprot
, nb
;
* If there is more in the output queue, just send it now.
* We are being called in lieu of ttstart and must do what
if (CCOUNT(tp
->t_outq
) != 0 && tp
->t_oproc
!= NULL
) {
if (CCOUNT(tp
->t_outq
) > PPP_HIWAT
)
* This happens briefly when the line shuts down.
* See if we have an existing packet partly sent.
* If not, get a new packet and start sending it.
* We take packets on the priority queue ahead of those
IF_DEQUEUE(&sc
->sc_fastq
, m
);
IF_DEQUEUE(&sc
->sc_if
.if_snd
, m
);
* Extract the ppp header of the new packet.
* The ppp header will be in one mbuf.
protocol
= (protocol
<< 8) + *cp
++;
m
->m_data
+= PPP_HEADER_LEN
;
m
->m_len
-= PPP_HEADER_LEN
;
* If the packet is a TCP/IP packet, see if we can compress it.
if (protocol
== PPP_IP
&& sc
->sc_flags
& SC_COMP_TCP
) {
if (ip
->ip_p
== IPPROTO_TCP
) {
type
= sl_compress_tcp(mp
, ip
, &sc
->sc_comp
,
!(sc
->sc_flags
& SC_NO_TCP_CCID
));
case TYPE_UNCOMPRESSED_TCP
:
protocol
= PPP_VJC_UNCOMP
;
case TYPE_COMPRESSED_TCP
:
* Compress the address/control and protocol, if possible.
compac
= sc
->sc_flags
& SC_COMP_AC
&& address
== PPP_ALLSTATIONS
&&
control
== PPP_UI
&& protocol
!= PPP_ALLSTATIONS
&&
compprot
= sc
->sc_flags
& SC_COMP_PROT
&& protocol
< 0x100;
nb
= (compac
? 0 : 2) + (compprot
? 1 : 2);
* The extra PPP_FLAG will start up a new packet, and thus
* will flush any accumulated garbage. We do this whenever
* the line may have been idle for some time.
if (CCOUNT(tp
->t_outq
) == 0) {
(void) putc(PPP_FLAG
, tp
->t_outq
);
/* Calculate the FCS for the first mbuf's worth. */
sc
->sc_outfcs
= pppfcs(PPP_INITFCS
, mtod(m
, u_char
*), m
->m_len
);
start
= mtod(m
, u_char
*);
* Find out how many bytes in the string we can
* handle without doing something special.
for (cp
= start
; cp
< stop
; cp
++)
/* NetBSD (0.9 or later), 4.3-Reno or similar. */
ndone
= n
- b_to_q(start
, n
, tp
->t_outq
);
/* NetBSD with 2-byte ring buffer entries */
ndone
= rb_cwrite(&tp
->t_out
, start
, n
);
for (nleft
= n
; nleft
> 0; nleft
-= cc
) {
if ((cc
= RB_CONTIGPUT(tp
->t_out
)) == 0)
bcopy((char *)start
+ n
- nleft
, tp
->t_out
->rb_tl
, cc
);
tp
->t_out
->rb_tl
= RB_ROLLOVER(tp
->t_out
,
sc
->sc_bytessent
+= ndone
;
break; /* packet doesn't fit */
* If there are characters left in the mbuf,
* the first one must be special..
* Put it out in a different form.
if (putc(PPP_ESCAPE
, tp
->t_outq
))
if (putc(*start
^ PPP_TRANS
, tp
->t_outq
)) {
(void) unputc(tp
->t_outq
);
* If we didn't empty this mbuf, remember where we're up to.
* If we emptied the last mbuf, try to add the FCS and closing
* flag, and if we can't, leave sc_outm pointing to m, but with
* m->m_len == 0, to remind us to output the FCS and flag later.
if (done
&& m
->m_next
== NULL
) {
* We may have to escape the bytes in the FCS.
c
= ~sc
->sc_outfcs
& 0xFF;
c
= (~sc
->sc_outfcs
>> 8) & 0xFF;
* Try to output the FCS and flag. If the bytes
* don't all fit, back out.
for (q
= endseq
; q
< p
; ++q
)
if (putc(*q
, tp
->t_outq
)) {
return; /* can't do any more at the moment */
/* Finished with this mbuf; free it and move on. */
sc
->sc_outfcs
= pppfcs(sc
->sc_outfcs
, mtod(m
, u_char
*), m
->m_len
);
sc
->sc_bytessent
++; /* account for closing flag */
sc
->sc_if
.if_obytes
= sc
->sc_bytessent
;
* Allocate enough mbuf to handle current MRU.
register struct ppp_softc
*sc
;
int len
= HDROFF
+ sc
->sc_mru
+ PPP_HEADER_LEN
+ PPP_FCS_LEN
;
for (mp
= &sc
->sc_m
; (m
= *mp
) != NULL
; mp
= &m
->m_next
)
if ((len
-= M_DATASIZE(m
)) <= 0) {
for (;; mp
= &m
->m_next
) {
MGETHDR(m
, M_DONTWAIT
, MT_DATA
);
printf("ppp%d: can't allocate mbuf\n", sc
->sc_if
.if_unit
);
if ((len
-= M_DATASIZE(m
)) <= 0) {
* Copy mbuf chain. Would like to use m_copy(), but we need a real copy
* of the data, not just copies of pointers to the data.
register struct mbuf
*m
, **mp
;
struct mbuf
*top
= sc
->sc_m
;
* First check current mbuf. If we have more than a small mbuf,
* return the whole cluster and set beginning of buffer to the
* Else, copy the current bytes into a small mbuf, attach the new
* mbuf to the end of the chain and set beginning of buffer to the
if (sc
->sc_mc
->m_len
> MHLEN
) {
sc
->sc_m
= sc
->sc_mc
->m_next
;
sc
->sc_mc
->m_next
= NULL
;
/* rather than waste a whole cluster on <= MHLEN bytes,
alloc a small mbuf and copy to it */
MGETHDR(m
, M_DONTWAIT
, MT_DATA
);
bcopy(mtod(sc
->sc_mc
, caddr_t
), mtod(m
, caddr_t
), sc
->sc_mc
->m_len
);
m
->m_len
= sc
->sc_mc
->m_len
;
for (mp
= &top
; *mp
!= sc
->sc_mc
; mp
= &(*mp
)->m_next
)
* Try to allocate enough extra mbufs to handle the next packet.
sc
->sc_if
.if_flags
&= ~IFF_UP
;
* tty interface receiver interrupt.
#define COMPTYPE(proto) ((proto) == PPP_VJC_COMP? TYPE_COMPRESSED_TCP: \
register struct ppp_softc
*sc
;
int s
, ilen
, xlen
, proto
;
sc
= (struct ppp_softc
*)tp
->t_sc
;
/* framing error or overrun on this char - abort packet */
printf("ppp%d: bad char %x\n", sc
->sc_if
.if_unit
, c
);
if (sc
->sc_if
.if_unit
== ppp_raw_in_debug
) {
ppp_rawin
[ppp_rawin_count
++] = c
;
if (ppp_rawin_count
>= sizeof(ppp_rawin
)) {
printf("raw ppp%d: ", ppp_raw_in_debug
);
pppdumpb(ppp_rawin
, ppp_rawin_count
);
if (sc
->sc_flags
& SC_FLUSH
|| ilen
> 0 && sc
->sc_fcs
!= PPP_GOODFCS
) {
* If we've missed a packet, we must toss subsequent compressed
* packets which don't have an explicit connection ID.
sl_uncompress_tcp(NULL
, 0, TYPE_ERROR
, &sc
->sc_comp
);
if ((sc
->sc_flags
& SC_FLUSH
) == 0){
printf("ppp%d: bad fcs\n", sc
->sc_if
.if_unit
);
sc
->sc_flags
&= ~SC_FLUSH
;
if (ilen
< PPP_HEADER_LEN
+ PPP_FCS_LEN
) {
printf("ppp%d: too short (%d)\n", sc
->sc_if
.if_unit
, ilen
);
* Remove FCS trailer. Somewhat painful...
if (--sc
->sc_mc
->m_len
== 0) {
for (m
= sc
->sc_m
; m
->m_next
!= sc
->sc_mc
; m
= m
->m_next
)
if (ppp_async_in_debug
) {
printf("ppp%d: got %d bytes\n", sc
->sc_if
.if_unit
, ilen
);
hdr
= *mtod(m
, struct ppp_header
*);
proto
= ntohs(hdr
.ph_protocol
);
* See if we have a VJ-compressed packet to uncompress.
if (proto
== PPP_VJC_COMP
|| proto
== PPP_VJC_UNCOMP
) {
char *pkttype
= proto
== PPP_VJC_COMP
? "": "un";
if (sc
->sc_flags
& SC_REJ_COMP_TCP
) {
printf("ppp%d: %scomp pkt w/o compression; flags 0x%x\n",
sc
->sc_if
.if_unit
, pkttype
, sc
->sc_flags
);
m
->m_data
+= PPP_HEADER_LEN
;
m
->m_len
-= PPP_HEADER_LEN
;
xlen
= sl_uncompress_tcp_part((u_char
**)(&m
->m_data
),
COMPTYPE(proto
), &sc
->sc_comp
);
printf("ppp%d: sl_uncompress failed on type %scomp\n",
sc
->sc_if
.if_unit
, pkttype
);
/* adjust the first mbuf by the decompressed amt */
m
->m_data
-= PPP_HEADER_LEN
;
/* put the ppp header back in place */
hdr
.ph_protocol
= htons(PPP_IP
);
*mtod(m
, struct ppp_header
*) = hdr
;
/* get this packet as an mbuf chain */
if ((m
= ppp_btom(sc
)) == NULL
) {
m
->m_pkthdr
.rcvif
= &sc
->sc_if
;
/* See if bpf wants to look at the packet. */
* IP packet - take off the ppp header and pass it up to IP.
if ((sc
->sc_if
.if_flags
& IFF_UP
) == 0) {
/* interface is down - drop the packet. */
m
->m_pkthdr
.len
-= PPP_HEADER_LEN
;
m
->m_data
+= PPP_HEADER_LEN
;
m
->m_len
-= PPP_HEADER_LEN
;
* Some other protocol - place on input queue for read().
* Put a placeholder byte in canq for ttselect()/ttnread().
* Put the packet on the appropriate input queue.
printf("ppp%d: queue full\n", sc
->sc_if
.if_unit
);
if (sc
->sc_flags
& SC_FLUSH
)
sc
->sc_flags
|= SC_ESCAPED
;
if (c
< 0x20 && (sc
->sc_rasyncmap
& (1 << c
)))
if (sc
->sc_flags
& SC_ESCAPED
) {
sc
->sc_flags
&= ~SC_ESCAPED
;
* Initialize buffer on first octet received.
* First octet could be address or protocol (when compressing
* Second octet is control.
* Third octet is first or second (when compressing protocol)
* Fourth octet is second octet of protocol.
/* reset the first input mbuf */
m
->m_data
= M_DATASTART(sc
->sc_m
) + HDROFF
;
sc
->sc_mp
= mtod(m
, char *);
sc
->sc_fcs
= PPP_INITFCS
;
if (c
!= PPP_ALLSTATIONS
) {
if (sc
->sc_flags
& SC_REJ_COMP_AC
) {
printf("ppp%d: missing ALLSTATIONS, got 0x%x; flags %x\n",
sc
->sc_if
.if_unit
, c
, sc
->sc_flags
);
*sc
->sc_mp
++ = PPP_ALLSTATIONS
;
if (sc
->sc_ilen
== 1 && c
!= PPP_UI
) {
printf("ppp%d: missing UI, got 0x%x\n", sc
->sc_if
.if_unit
, c
);
if (sc
->sc_ilen
== 2 && (c
& 1) == 1) {
/* RFC1331 says we have to accept a compressed protocol */
if (sc
->sc_ilen
== 3 && (c
& 1) == 0) {
printf("ppp%d: bad protocol %x\n", sc
->sc_if
.if_unit
,
(sc
->sc_mp
[-1] << 8) + c
);
/* packet beyond configured mru? */
if (++sc
->sc_ilen
> sc
->sc_mru
+ PPP_HEADER_LEN
+ PPP_FCS_LEN
) {
printf("ppp%d: packet too big\n", sc
->sc_if
.if_unit
);
if (M_TRAILINGSPACE(m
) <= 0) {
sc
->sc_mc
= m
= m
->m_next
;
printf("ppp%d: too few input mbufs!\n", sc
->sc_if
.if_unit
);
m
->m_data
= M_DATASTART(m
);
sc
->sc_mp
= mtod(m
, char *);
sc
->sc_fcs
= PPP_FCS(sc
->sc_fcs
, c
);
sc
->sc_flags
|= SC_FLUSH
;
* Process an ioctl request to interface.
register struct ifnet
*ifp
;
struct proc
*p
= curproc
; /* XXX */
register struct ppp_softc
*sc
= &ppp_softc
[ifp
->if_unit
];
register struct ifaddr
*ifa
= (struct ifaddr
*)data
;
register struct ifreq
*ifr
= (struct ifreq
*)data
;
int s
= splimp(), error
= 0;
if ((ifp
->if_flags
& IFF_RUNNING
) == 0)
ifp
->if_flags
&= ~IFF_UP
;
if (ifa
->ifa_addr
->sa_family
!= AF_INET
)
if (ifa
->ifa_addr
->sa_family
!= AF_INET
)
if (error
= suser(p
->p_ucred
, &p
->p_acflag
))
sc
->sc_if
.if_mtu
= ifr
->ifr_mtu
;
ifr
->ifr_mtu
= sc
->sc_if
.if_mtu
;
#define MAX_DUMP_BYTES 128
char buf
[2*MAX_DUMP_BYTES
+4];
static char digits
[] = "0123456789abcdef";
for (m
= m0
; m
&& pktlen
; m
= m
->m_next
) {
u_char
*rptr
= (u_char
*)m
->m_data
;
if (bp
> buf
+ sizeof(buf
) - 4)
*bp
++ = digits
[*rptr
>> 4]; /* convert byte to ascii hex */
*bp
++ = digits
[*rptr
++ & 0xf];
if (bp
> buf
+ sizeof(buf
) - 3)
char buf
[2*MAX_DUMP_BYTES
+4];
static char digits
[] = "0123456789abcdef";
*bp
++ = digits
[*b
>> 4]; /* convert byte to ascii hex */
*bp
++ = digits
[*b
++ & 0xf];
if (bp
>= buf
+ sizeof(buf
) - 2) {