From 3fca15005a3eb1adb1ac4f94ec3eb6439e2dc865 Mon Sep 17 00:00:00 2001 From: Paul Mackerras Date: Mon, 1 Jul 1996 01:00:31 +0000 Subject: [PATCH] updated for 2.3 from netbsd stuff --- freebsd-2.0/files-2.2.patch | 13 + freebsd-2.0/files.patch | 4 +- freebsd-2.0/if_ppp.c | 264 ++++++++------- freebsd-2.0/if_pppvar.h | 16 +- freebsd-2.0/kinstall.sh | 17 +- freebsd-2.0/ppp-deflate.c | 653 ++++++++++++++++++++++++++++++++++++ freebsd-2.0/ppp_tty.c | 208 +++++++----- 7 files changed, 941 insertions(+), 234 deletions(-) create mode 100644 freebsd-2.0/files-2.2.patch create mode 100644 freebsd-2.0/ppp-deflate.c diff --git a/freebsd-2.0/files-2.2.patch b/freebsd-2.0/files-2.2.patch new file mode 100644 index 0000000..4ce538b --- /dev/null +++ b/freebsd-2.0/files-2.2.patch @@ -0,0 +1,13 @@ +*** files.orig Wed Dec 14 13:11:12 1994 +--- files Wed Dec 14 13:13:56 1994 +*************** +*** 141,146 **** +--- 141,148 ---- + net/if_ppp.c optional ppp + net/ppp_tty.c optional ppp + net/bsd-comp.c optional ppp ++ net/ppp-deflate.c optional ppp ++ net/zlib.c optional ppp + net/if_sl.c optional sl + net/pppcompress.c optional ppp + net/radix.c standard diff --git a/freebsd-2.0/files.patch b/freebsd-2.0/files.patch index 56fb2b7..b9e9f68 100644 --- a/freebsd-2.0/files.patch +++ b/freebsd-2.0/files.patch @@ -2,12 +2,14 @@ --- files Wed Dec 14 13:13:56 1994 *************** *** 139,144 **** ---- 139,146 ---- +--- 139,148 ---- net/if_ethersubr.c optional ether net/if_loop.c optional loop net/if_ppp.c optional ppp + net/ppp_tty.c optional ppp + net/bsd-comp.c optional ppp ++ net/ppp-deflate.c optional ppp ++ net/zlib.c optional ppp net/if_sl.c optional sl net/pppcompress.c optional ppp net/radix.c standard diff --git a/freebsd-2.0/if_ppp.c b/freebsd-2.0/if_ppp.c index 702bcca..23a95b4 100644 --- a/freebsd-2.0/if_ppp.c +++ b/freebsd-2.0/if_ppp.c @@ -69,8 +69,9 @@ * Paul Mackerras (paulus@cs.anu.edu.au). */ -/* $Id: if_ppp.c,v 1.6 1995/10/27 03:34:42 paulus Exp $ */ +/* $Id: if_ppp.c,v 1.7 1996/07/01 01:00:27 paulus Exp $ */ /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */ +/* from NetBSD: if_ppp.c,v 1.15.2.2 1994/07/28 05:17:58 cgd Exp */ #include "ppp.h" #if NPPP > 0 @@ -85,6 +86,8 @@ #include #include #include +#include +#include #include #include @@ -100,7 +103,6 @@ #include "bpfilter.h" #if NBPFILTER > 0 -#include #include #endif @@ -123,17 +125,9 @@ #include #endif -void pppattach __P((void)); -int pppioctl __P((struct ppp_softc *sc, u_long cmd, caddr_t data, int flag, - struct proc *)); -int pppoutput __P((struct ifnet *ifp, struct mbuf *m0, - struct sockaddr *dst, struct rtentry *rtp)); -int pppsioctl __P((struct ifnet *ifp, u_long cmd, caddr_t data)); -void pppintr __P((void)); - static void ppp_requeue __P((struct ppp_softc *)); static void ppp_outpkt __P((struct ppp_softc *)); -static int ppp_ccp __P((struct ppp_softc *, struct mbuf *m, int rcvd)); +static void ppp_ccp __P((struct ppp_softc *, struct mbuf *m, int rcvd)); static void ppp_ccp_closed __P((struct ppp_softc *)); static void ppp_inproc __P((struct ppp_softc *, struct mbuf *)); static void pppdumpm __P((struct mbuf *m0)); @@ -166,10 +160,14 @@ static void pppdumpm __P((struct mbuf *m0)); */ extern struct compressor ppp_bsd_compress; +extern struct compressor ppp_deflate; struct compressor *ppp_compressors[8] = { #if DO_BSD_COMPRESS &ppp_bsd_compress, +#endif +#if DO_DEFLATE + &ppp_deflate, #endif NULL }; @@ -232,8 +230,12 @@ pppalloc(pid) sc->sc_flags = 0; sc->sc_mru = PPP_MRU; sc->sc_relinq = NULL; + bzero((char *)&sc->sc_stats, sizeof(sc->sc_stats)); #ifdef VJC - vj_compress_init(&sc->sc_comp, -1); + MALLOC(sc->sc_comp, struct slcompress *, sizeof(struct slcompress), + M_DEVBUF, M_NOWAIT); + if (sc->sc_comp) + vj_compress_init(sc->sc_comp, -1); #endif #ifdef PPP_COMPRESS sc->sc_xc_state = NULL; @@ -292,6 +294,12 @@ pppdealloc(sc) sc->sc_xc_state = NULL; sc->sc_rc_state = NULL; #endif /* PPP_COMPRESS */ +#ifdef VJC + if (sc->sc_comp != 0) { + FREE(sc->sc_comp, M_DEVBUF); + sc->sc_comp = 0; + } +#endif } /* @@ -328,7 +336,7 @@ pppioctl(sc, cmd, data, flag, p) break; case PPPIOCSFLAGS: - if (error = suser(p->p_ucred, &p->p_acflag)) + if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) return (error); flags = *(int *)data & SC_MASK; s = splnet(); @@ -342,7 +350,7 @@ pppioctl(sc, cmd, data, flag, p) break; case PPPIOCSMRU: - if (error = suser(p->p_ucred, &p->p_acflag)) + if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) return (error); mru = *(int *)data; if (mru >= PPP_MRU && mru <= PPP_MAXMRU) @@ -355,29 +363,31 @@ pppioctl(sc, cmd, data, flag, p) #ifdef VJC case PPPIOCSMAXCID: - if (error = suser(p->p_ucred, &p->p_acflag)) + if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) return (error); - s = splnet(); - vj_compress_init(&sc->sc_comp, *(int *)data); - splx(s); + if (sc->sc_comp) { + s = splnet(); + vj_compress_init(sc->sc_comp, *(int *)data); + splx(s); + } break; #endif case PPPIOCXFERUNIT: - if (error = suser(p->p_ucred, &p->p_acflag)) + if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) return (error); sc->sc_xfer = p->p_pid; break; #ifdef PPP_COMPRESS case PPPIOCSCOMPRESS: - if (error = suser(p->p_ucred, &p->p_acflag)) + if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) return (error); odp = (struct ppp_option_data *) data; nb = odp->length; if (nb > sizeof(ccp_option)) nb = sizeof(ccp_option); - if (error = copyin(odp->ptr, ccp_option, nb)) + if ((error = copyin(odp->ptr, ccp_option, nb)) != 0) return (error); if (ccp_option[1] < 2) /* preliminary check on the length byte */ return (EINVAL); @@ -441,7 +451,7 @@ pppioctl(sc, cmd, data, flag, p) if (cmd == PPPIOCGNPMODE) { npi->mode = sc->sc_npmode[npx]; } else { - if (error = suser(p->p_ucred, &p->p_acflag)) + if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) return (error); if (npi->mode != sc->sc_npmode[npx]) { s = splnet(); @@ -505,7 +515,7 @@ pppsioctl(ifp, cmd, data) break; case SIOCSIFMTU: - if (error = suser(p->p_ucred, &p->p_acflag)) + if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) break; sc->sc_if.if_mtu = ifr->ifr_mtu; break; @@ -516,6 +526,10 @@ pppsioctl(ifp, cmd, data) case SIOCADDMULTI: case SIOCDELMULTI: + if (ifr == 0) { + error = EAFNOSUPPORT; + break; + } switch(ifr->ifr_addr.sa_family) { #ifdef INET case AF_INET: @@ -530,21 +544,18 @@ pppsioctl(ifp, cmd, data) case SIOCGPPPSTATS: psp = &((struct ifpppstatsreq *) data)->stats; bzero(psp, sizeof(*psp)); - psp->p.ppp_ibytes = sc->sc_bytesrcvd; - psp->p.ppp_ipackets = ifp->if_ipackets; - psp->p.ppp_ierrors = ifp->if_ierrors; - psp->p.ppp_obytes = sc->sc_bytessent; - psp->p.ppp_opackets = ifp->if_opackets; - psp->p.ppp_oerrors = ifp->if_oerrors; -#ifdef VJC - psp->vj.vjs_packets = sc->sc_comp.sls_packets; - psp->vj.vjs_compressed = sc->sc_comp.sls_compressed; - psp->vj.vjs_searches = sc->sc_comp.sls_searches; - psp->vj.vjs_misses = sc->sc_comp.sls_misses; - psp->vj.vjs_uncompressedin = sc->sc_comp.sls_uncompressedin; - psp->vj.vjs_compressedin = sc->sc_comp.sls_compressedin; - psp->vj.vjs_errorin = sc->sc_comp.sls_errorin; - psp->vj.vjs_tossed = sc->sc_comp.sls_tossed; + psp->p = sc->sc_stats; +#if defined(VJC) && !defined(SL_NO_STATS) + if (sc->sc_comp) { + psp->vj.vjs_packets = sc->sc_comp->sls_packets; + psp->vj.vjs_compressed = sc->sc_comp->sls_compressed; + psp->vj.vjs_searches = sc->sc_comp->sls_searches; + psp->vj.vjs_misses = sc->sc_comp->sls_misses; + psp->vj.vjs_uncompressedin = sc->sc_comp->sls_uncompressedin; + psp->vj.vjs_compressedin = sc->sc_comp->sls_compressedin; + psp->vj.vjs_errorin = sc->sc_comp->sls_errorin; + psp->vj.vjs_tossed = sc->sc_comp->sls_tossed; + } #endif /* VJC */ break; @@ -578,7 +589,6 @@ pppoutput(ifp, m0, dst, rtp) struct rtentry *rtp; { register struct ppp_softc *sc = &ppp_softc[ifp->if_unit]; - struct ppp_header *ph; int protocol, address, control; u_char *cp; int s, error; @@ -587,7 +597,7 @@ pppoutput(ifp, m0, dst, rtp) enum NPmode mode; if (sc->sc_devp == NULL || (ifp->if_flags & IFF_RUNNING) == 0 - || (ifp->if_flags & IFF_UP) == 0 && dst->sa_family != AF_UNSPEC) { + || ((ifp->if_flags & IFF_UP) == 0 && dst->sa_family != AF_UNSPEC)) { error = ENETDOWN; /* sort of */ goto bad; } @@ -663,6 +673,13 @@ pppoutput(ifp, m0, dst, rtp) pppdumpm(m0); } + if ((protocol & 0x8000) == 0) { + /* + * Update the time we sent the most recent data packet. + */ + sc->sc_last_sent = time.tv_sec; + } + #if NBPFILTER > 0 /* * See if bpf wants to look at the packet. @@ -686,12 +703,16 @@ pppoutput(ifp, m0, dst, rtp) IF_DROP(ifq); splx(s); sc->sc_if.if_oerrors++; + sc->sc_stats.ppp_oerrors++; error = ENOBUFS; goto bad; } IF_ENQUEUE(ifq, m0); (*sc->sc_start)(sc); } + ifp->if_lastchange = time; + ifp->if_opackets++; + ifp->if_obytes += len; splx(s); return (0); @@ -734,6 +755,7 @@ ppp_requeue(sc) if (IF_QFULL(ifq)) { IF_DROP(ifq); sc->sc_if.if_oerrors++; + sc->sc_stats.ppp_oerrors++; } else IF_ENQUEUE(ifq, m); break; @@ -753,80 +775,34 @@ ppp_requeue(sc) } /* - * Get a packet to send. This procedure is intended to be called at - * spltty or splimp, so it takes little time. If there isn't a packet - * waiting to go out, it schedules a software interrupt to prepare a - * new packet; the device start routine gets called again when a - * packet is ready. + * Transmitter has finished outputting some stuff; + * remember to call sc->sc_start later at splnet. */ -struct mbuf * -ppp_dequeue(sc) +void +ppp_restart(sc) struct ppp_softc *sc; { - struct mbuf *m; int s = splimp(); - m = sc->sc_togo; - if (m) { - /* - * Had a packet waiting - send it. - */ - sc->sc_togo = NULL; - sc->sc_flags |= SC_TBUSY; - splx(s); - return m; - } - /* - * Remember we wanted a packet and schedule a software interrupt. - */ sc->sc_flags &= ~SC_TBUSY; schednetisr(NETISR_PPP); splx(s); - return NULL; } /* - * Software interrupt routine, called at splnet(). - */ -void -pppintr() -{ - struct ppp_softc *sc; - int i, s; - struct mbuf *m; - - s = splnet(); - sc = ppp_softc; - for (i = 0; i < NPPP; ++i, ++sc) { - if (!(sc->sc_flags & SC_TBUSY) && sc->sc_togo == NULL - && (sc->sc_if.if_snd.ifq_head || sc->sc_fastq.ifq_head)) - ppp_outpkt(sc); - for (;;) { - s = splimp(); - IF_DEQUEUE(&sc->sc_rawq, m); - splx(s); - if (m == NULL) - break; - ppp_inproc(sc, m); - } - } - splx(s); -} - -/* - * Grab another packet off a queue and apply VJ compression, - * packet compression, address/control and/or protocol compression - * if enabled. Should be called at splnet. + * Get a packet to send. This procedure is intended to be called at + * splnet, since it may involve time-consuming operations such as + * applying VJ compression, packet compression, address/control and/or + * protocol field compression to the packet. */ -static void -ppp_outpkt(sc) +struct mbuf * +ppp_dequeue(sc) struct ppp_softc *sc; { - int s; struct mbuf *m, *mp; u_char *cp; int address, control, protocol; - enum NPmode mode; + int s; /* * Grab a packet to send: first try the fast queue, then the @@ -836,7 +812,9 @@ ppp_outpkt(sc) if (m == NULL) IF_DEQUEUE(&sc->sc_if.if_snd, m); if (m == NULL) - return; + return NULL; + + ++sc->sc_stats.ppp_opackets; /* * Extract the ppp header of the new packet. @@ -849,16 +827,11 @@ ppp_outpkt(sc) switch (protocol) { case PPP_IP: - /* - * Update the time we sent the most recent packet. - */ - sc->sc_last_sent = time.tv_sec; - #ifdef VJC /* * If the packet is a TCP/IP packet, see if we can compress it. */ - if (sc->sc_flags & SC_COMP_TCP) { + if ((sc->sc_flags & SC_COMP_TCP) && sc->sc_comp != NULL) { struct ip *ip; int type; @@ -872,7 +845,7 @@ ppp_outpkt(sc) } /* this code assumes the IP/TCP header is in one non-shared mbuf */ if (ip->ip_p == IPPROTO_TCP) { - type = vj_compress_tcp(mp, ip, &sc->sc_comp, + type = vj_compress_tcp(mp, ip, sc->sc_comp, !(sc->sc_flags & SC_NO_TCP_CCID)); switch (type) { case TYPE_UNCOMPRESSED_TCP: @@ -940,8 +913,39 @@ ppp_outpkt(sc) --m->m_len; } - sc->sc_togo = m; - (*sc->sc_start)(sc); + return m; +} + +/* + * Software interrupt routine, called at splnet. + */ +void +pppintr() +{ + struct ppp_softc *sc; + int i, s, s2; + struct mbuf *m; + + sc = ppp_softc; + s = splnet(); + for (i = 0; i < NPPP; ++i, ++sc) { + if (!(sc->sc_flags & SC_TBUSY) + && (sc->sc_if.if_snd.ifq_head || sc->sc_fastq.ifq_head)) { + s2 = splimp(); + sc->sc_flags |= SC_TBUSY; + splx(s2); + (*sc->sc_start)(sc); + } + for (;;) { + s2 = splimp(); + IF_DEQUEUE(&sc->sc_rawq, m); + splx(s2); + if (m == NULL) + break; + ppp_inproc(sc, m); + } + } + splx(s); } #ifdef PPP_COMPRESS @@ -949,7 +953,7 @@ ppp_outpkt(sc) * Handle a CCP packet. `rcvd' is 1 if the packet was received, * 0 if it is about to be transmitted. */ -static int +static void ppp_ccp(sc, m, rcvd) struct ppp_softc *sc; struct mbuf *m; @@ -978,7 +982,7 @@ ppp_ccp(sc, m, rcvd) slen = CCP_LENGTH(dp); if (dp + slen > ep) { if (sc->sc_flags & SC_DEBUG) - printf("if_ppp/ccp: not enough data in mbuf (%x+%x > %x+%x)\n", + printf("if_ppp/ccp: not enough data in mbuf (%p+%x > %p+%x)\n", dp, slen, mtod(mp, u_char *), mp->m_len); return; } @@ -1094,6 +1098,7 @@ ppp_inproc(sc, m) struct ppp_softc *sc; struct mbuf *m; { + struct ifnet *ifp = &sc->sc_if; struct ifqueue *inq; int s, ilen, xlen, proto, rv; u_char *cp, adrs, ctrl; @@ -1101,13 +1106,13 @@ ppp_inproc(sc, m) u_char *iphdr; u_int hlen; - sc->sc_if.if_ipackets++; + sc->sc_stats.ppp_ipackets++; if (sc->sc_flags & SC_LOG_INPKT) { ilen = 0; for (mp = m; mp != NULL; mp = mp->m_next) ilen += mp->m_len; - printf("ppp%d: got %d bytes\n", sc->sc_if.if_unit, ilen); + printf("ppp%d: got %d bytes\n", ifp->if_unit, ilen); pppdumpm(m); } @@ -1149,7 +1154,7 @@ ppp_inproc(sc, m) * CCP down or issue a Reset-Req. */ if (sc->sc_flags & SC_DEBUG) - printf("ppp%d: decompress failed %d\n", sc->sc_if.if_unit, rv); + printf("ppp%d: decompress failed %d\n", ifp->if_unit, rv); s = splimp(); sc->sc_flags |= SC_VJ_RESET; if (rv == DECOMP_ERROR) @@ -1179,7 +1184,8 @@ ppp_inproc(sc, m) * If we've missed a packet, we must toss subsequent compressed * packets which don't have an explicit connection ID. */ - vj_uncompress_tcp(NULL, 0, TYPE_ERROR, &sc->sc_comp); + if (sc->sc_comp) + vj_uncompress_tcp(NULL, 0, TYPE_ERROR, sc->sc_comp); s = splimp(); sc->sc_flags &= ~SC_VJ_RESET; splx(s); @@ -1189,17 +1195,17 @@ ppp_inproc(sc, m) * See if we have a VJ-compressed packet to uncompress. */ if (proto == PPP_VJC_COMP) { - if (sc->sc_flags & SC_REJ_COMP_TCP) + if ((sc->sc_flags & SC_REJ_COMP_TCP) || sc->sc_comp == 0) goto bad; xlen = vj_uncompress_tcp_core(cp + PPP_HDRLEN, m->m_len - PPP_HDRLEN, ilen - PPP_HDRLEN, TYPE_COMPRESSED_TCP, - &sc->sc_comp, &iphdr, &hlen); + sc->sc_comp, &iphdr, &hlen); if (xlen <= 0) { if (sc->sc_flags & SC_DEBUG) printf("ppp%d: VJ uncompress failed on type comp\n", - sc->sc_if.if_unit); + ifp->if_unit); goto bad; } @@ -1241,17 +1247,17 @@ ppp_inproc(sc, m) ilen += hlen - xlen; } else if (proto == PPP_VJC_UNCOMP) { - if (sc->sc_flags & SC_REJ_COMP_TCP) + if ((sc->sc_flags & SC_REJ_COMP_TCP) || sc->sc_comp == 0) goto bad; xlen = vj_uncompress_tcp_core(cp + PPP_HDRLEN, m->m_len - PPP_HDRLEN, ilen - PPP_HDRLEN, TYPE_UNCOMPRESSED_TCP, - &sc->sc_comp, &iphdr, &hlen); + sc->sc_comp, &iphdr, &hlen); if (xlen < 0) { if (sc->sc_flags & SC_DEBUG) printf("ppp%d: VJ uncompress failed on type uncomp\n", - sc->sc_if.if_unit); + ifp->if_unit); goto bad; } @@ -1274,7 +1280,14 @@ ppp_inproc(sc, m) } } m->m_pkthdr.len = ilen; - m->m_pkthdr.rcvif = &sc->sc_if; + m->m_pkthdr.rcvif = ifp; + + /* + * Record the time that we received this packet. + */ + if ((proto & 0x8000) == 0) { + sc->sc_last_recv = time.tv_sec; + } #if NBPFILTER > 0 /* See if bpf wants to look at the packet. */ @@ -1289,7 +1302,7 @@ ppp_inproc(sc, m) /* * IP packet - take off the ppp header and pass it up to IP. */ - if ((sc->sc_if.if_flags & IFF_UP) == 0 + if ((ifp->if_flags & IFF_UP) == 0 || sc->sc_npmode[NP_IP] != NPMODE_PASS) { /* interface is down - drop the packet. */ m_freem(m); @@ -1300,7 +1313,6 @@ ppp_inproc(sc, m) m->m_len -= PPP_HDRLEN; schednetisr(NETISR_IP); inq = &ipintrq; - sc->sc_last_recv = time.tv_sec; /* update time of last pkt rcvd */ break; #endif @@ -1321,12 +1333,15 @@ ppp_inproc(sc, m) IF_DROP(inq); splx(s); if (sc->sc_flags & SC_DEBUG) - printf("ppp%d: input queue full\n", sc->sc_if.if_unit); - sc->sc_if.if_iqdrops++; + printf("ppp%d: input queue full\n", ifp->if_unit); + ifp->if_iqdrops++; goto bad; } IF_ENQUEUE(inq, m); splx(s); + ifp->if_ipackets++; + ifp->if_ibytes += ilen; + ifp->if_lastchange = time; if (rv) (*sc->sc_ctlp)(sc); @@ -1336,6 +1351,7 @@ ppp_inproc(sc, m) bad: m_freem(m); sc->sc_if.if_ierrors++; + sc->sc_stats.ppp_ierrors++; } #define MAX_DUMP_BYTES 128 diff --git a/freebsd-2.0/if_pppvar.h b/freebsd-2.0/if_pppvar.h index 196e54b..4673334 100644 --- a/freebsd-2.0/if_pppvar.h +++ b/freebsd-2.0/if_pppvar.h @@ -1,4 +1,4 @@ -/* $Id: if_pppvar.h,v 1.1 1994/12/15 22:28:09 paulus Exp $ */ +/* $Id: if_pppvar.h,v 1.2 1996/07/01 01:00:28 paulus Exp $ */ /* * if_pppvar.h - private structures and declarations for PPP. * @@ -66,11 +66,7 @@ struct ppp_softc { struct mbuf *sc_togo; /* output packet ready to go */ struct mbuf *sc_npqueue; /* output packets not to be sent yet */ struct mbuf **sc_npqtail; /* ptr to last next ptr in npqueue */ -#ifdef VJC - struct vjcompress sc_comp; /* vjc control buffer */ -#endif - u_int sc_bytessent; /* count of octets sent */ - u_int sc_bytesrcvd; /* count of octets received */ + struct pppstat sc_stats; /* count of bytes/pkts sent/rcvd */ caddr_t sc_bpf; /* hook for BPF */ enum NPmode sc_npmode[NUM_NP]; /* what to do with each NP */ struct compressor *sc_xcomp; /* transmit compressor */ @@ -79,7 +75,10 @@ struct ppp_softc { void *sc_rc_state; /* receive decompressor state */ time_t sc_last_sent; /* time (secs) last NP pkt sent */ time_t sc_last_recv; /* time (secs) last NP pkt rcvd */ - +#ifdef VJC + struct slcompress *sc_comp; /* vjc control buffer */ +#endif + /* Device-dependent part for async lines. */ ext_accm sc_asyncmap; /* async control character map */ u_long sc_rasyncmap; /* receive async control char map */ @@ -98,7 +97,8 @@ struct ppp_softc ppp_softc[NPPP]; struct ppp_softc *pppalloc __P((pid_t pid)); void pppdealloc __P((struct ppp_softc *sc)); -int pppioctl __P((struct ppp_softc *sc, int cmd, caddr_t data, +int pppioctl __P((struct ppp_softc *sc, u_long cmd, caddr_t data, int flag, struct proc *p)); +void ppp_restart __P((struct ppp_softc *sc)); void ppppktin __P((struct ppp_softc *sc, struct mbuf *m, int lost)); struct mbuf *ppp_dequeue __P((struct ppp_softc *sc)); diff --git a/freebsd-2.0/kinstall.sh b/freebsd-2.0/kinstall.sh index 7273902..bb0d88a 100755 --- a/freebsd-2.0/kinstall.sh +++ b/freebsd-2.0/kinstall.sh @@ -1,7 +1,7 @@ #!/bin/sh # This script modifies the kernel sources in /sys to install -# ppp-2.2. It is intended to be run in the ppp-2.2 directory. +# ppp-2.3. It is intended to be run in the ppp-2.3 directory. # # Paul Mackerras 17-Mar-95 @@ -17,14 +17,13 @@ CONFIG=config # Copy new versions of files into /sys/net for f in net/if_ppp.h net/ppp-comp.h net/ppp_defs.h $SRC/bsd-comp.c \ - $SRC/if_ppp.c $SRC/if_pppvar.h $SRC/ppp_tty.c \ - $SRC/pppcompress.c $SRC/pppcompress.h; do + $SRC/ppp-deflate.c $SRC/if_ppp.c $SRC/if_pppvar.h $SRC/ppp_tty.c \ + $SRC/pppcompress.c $SRC/pppcompress.h common/zlib.c common/zlib.h; do dest=$SYS/net/$(basename $f) if [ -f $dest ]; then if ! cmp -s $f $dest; then echo "Copying $f to $dest" - mv -f $dest $dest.orig - echo " (old version saved in $dest.orig)" + mv -f $dest $dest.orig && echo " (old version saved in $dest.orig)" cp $f $dest DOMAKE=yes fi @@ -41,9 +40,11 @@ if [ -f $SYS/conf/files ]; then if ! grep -q ppp_tty $SYS/conf/files; then echo "Patching $SYS/conf/files" patch -p -N -d $SYS/conf <$SRC/files.patch - if [ $CONFIG = config ]; then - DOCONF=yes - fi + DOCONF=yes + elif ! grep -q ppp-deflate $SYS/conf/files; then + echo "Patching $SYS/conf/files" + patch -N $SYS/conf/$OLDFILES <$SRC/files-2.2.patch + DOCONF=yes fi fi diff --git a/freebsd-2.0/ppp-deflate.c b/freebsd-2.0/ppp-deflate.c new file mode 100644 index 0000000..2ba1c35 --- /dev/null +++ b/freebsd-2.0/ppp-deflate.c @@ -0,0 +1,653 @@ +/* $Id: ppp-deflate.c,v 1.1 1996/07/01 01:00:30 paulus Exp $ */ + +/* + * ppp_deflate.c - interface the zlib procedures for Deflate compression + * and decompression (as used by gzip) to the PPP code. + * This version is for use with mbufs on BSD-derived systems. + * + * Copyright (c) 1994 The Australian National University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation is hereby granted, provided that the above copyright + * notice appears in all copies. This software is provided without any + * warranty, express or implied. The Australian National University + * makes no representations about the suitability of this software for + * any purpose. + * + * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY + * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF + * THE AUSTRALIAN NATIONAL UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO + * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, + * OR MODIFICATIONS. + */ + +#include +#include +#include +#include +#include +#include + +#define PACKETPTR struct mbuf * +#include + +#if DO_DEFLATE + +/* + * State for a Deflate (de)compressor. + */ +struct deflate_state { + int seqno; + int w_size; + int unit; + int hdrlen; + int mru; + int debug; + z_stream strm; + struct compstat stats; +}; + +#define DEFLATE_OVHD 2 /* Deflate overhead/packet */ + +static void *zalloc __P((void *, u_int items, u_int size)); +static void zfree __P((void *, void *ptr, u_int nb)); +static void *z_comp_alloc __P((u_char *options, int opt_len)); +static void *z_decomp_alloc __P((u_char *options, int opt_len)); +static void z_comp_free __P((void *state)); +static void z_decomp_free __P((void *state)); +static int z_comp_init __P((void *state, u_char *options, int opt_len, + int unit, int hdrlen, int debug)); +static int z_decomp_init __P((void *state, u_char *options, int opt_len, + int unit, int hdrlen, int mru, int debug)); +static int z_compress __P((void *state, struct mbuf **mret, + struct mbuf *mp, int slen, int maxolen)); +static void z_incomp __P((void *state, struct mbuf *dmsg)); +static int z_decompress __P((void *state, struct mbuf *cmp, + struct mbuf **dmpp)); +static void z_comp_reset __P((void *state)); +static void z_decomp_reset __P((void *state)); +static void z_comp_stats __P((void *state, struct compstat *stats)); + +/* + * Procedures exported to if_ppp.c. + */ +struct compressor ppp_deflate = { + CI_DEFLATE, /* compress_proto */ + z_comp_alloc, /* comp_alloc */ + z_comp_free, /* comp_free */ + z_comp_init, /* comp_init */ + z_comp_reset, /* comp_reset */ + z_compress, /* compress */ + z_comp_stats, /* comp_stat */ + z_decomp_alloc, /* decomp_alloc */ + z_decomp_free, /* decomp_free */ + z_decomp_init, /* decomp_init */ + z_decomp_reset, /* decomp_reset */ + z_decompress, /* decompress */ + z_incomp, /* incomp */ + z_comp_stats, /* decomp_stat */ +}; + +/* + * Space allocation and freeing routines for use by zlib routines. + */ +void * +zalloc(notused, items, size) + void *notused; + u_int items, size; +{ + void *ptr; + + MALLOC(ptr, void *, items * size, M_DEVBUF, M_NOWAIT); + return ptr; +} + +void +zfree(notused, ptr, nbytes) + void *notused; + void *ptr; + u_int nbytes; +{ + FREE(ptr, M_DEVBUF); +} + +/* + * Allocate space for a compressor. + */ +static void * +z_comp_alloc(options, opt_len) + u_char *options; + int opt_len; +{ + struct deflate_state *state; + int w_size; + + if (opt_len != CILEN_DEFLATE || options[0] != CI_DEFLATE + || options[1] != CILEN_DEFLATE + || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL + || options[3] != DEFLATE_CHK_SEQUENCE) + return NULL; + w_size = DEFLATE_SIZE(options[2]); + if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE) + return NULL; + + MALLOC(state, struct deflate_state *, sizeof(struct deflate_state), + M_DEVBUF, M_NOWAIT); + if (state == NULL) + return NULL; + + state->strm.next_in = NULL; + state->strm.zalloc = zalloc; + state->strm.zfree = zfree; + if (deflateInit2(&state->strm, Z_DEFAULT_COMPRESSION, DEFLATE_METHOD_VAL, + -w_size, 8, Z_DEFAULT_STRATEGY, DEFLATE_OVHD+2) != Z_OK) { + FREE(state, M_DEVBUF); + return NULL; + } + + state->w_size = w_size; + bzero(&state->stats, sizeof(state->stats)); + return (void *) state; +} + +static void +z_comp_free(arg) + void *arg; +{ + struct deflate_state *state = (struct deflate_state *) arg; + + deflateEnd(&state->strm); + FREE(state, M_DEVBUF); +} + +static int +z_comp_init(arg, options, opt_len, unit, hdrlen, debug) + void *arg; + u_char *options; + int opt_len, unit, hdrlen, debug; +{ + struct deflate_state *state = (struct deflate_state *) arg; + + if (opt_len < CILEN_DEFLATE || options[0] != CI_DEFLATE + || options[1] != CILEN_DEFLATE + || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL + || DEFLATE_SIZE(options[2]) != state->w_size + || options[3] != DEFLATE_CHK_SEQUENCE) + return 0; + + state->seqno = 0; + state->unit = unit; + state->hdrlen = hdrlen; + state->debug = debug; + + deflateReset(&state->strm); + + return 1; +} + +static void +z_comp_reset(arg) + void *arg; +{ + struct deflate_state *state = (struct deflate_state *) arg; + + state->seqno = 0; + deflateReset(&state->strm); +} + +int +z_compress(arg, mret, mp, orig_len, maxolen) + void *arg; + struct mbuf **mret; /* compressed packet (out) */ + struct mbuf *mp; /* uncompressed packet (in) */ + int orig_len, maxolen; +{ + struct deflate_state *state = (struct deflate_state *) arg; + u_char *rptr, *wptr; + int proto, olen, wspace, r, flush; + struct mbuf *m; + + /* + * Check that the protocol is in the range we handle. + */ + rptr = mtod(mp, u_char *); + proto = PPP_PROTOCOL(rptr); + if (proto > 0x3fff || proto == 0xfd || proto == 0xfb) { + *mret = NULL; + return orig_len; + } + + /* Allocate one mbuf initially. */ + if (maxolen > orig_len) + maxolen = orig_len; + MGET(m, M_DONTWAIT, MT_DATA); + *mret = m; + if (m != NULL) { + m->m_len = 0; + if (maxolen + state->hdrlen > MLEN) + MCLGET(m, M_DONTWAIT); + wspace = M_TRAILINGSPACE(m); + if (state->hdrlen + PPP_HDRLEN + 2 < wspace) { + m->m_data += state->hdrlen; + wspace -= state->hdrlen; + } + wptr = mtod(m, u_char *); + + /* + * Copy over the PPP header and store the 2-byte sequence number. + */ + wptr[0] = PPP_ADDRESS(rptr); + wptr[1] = PPP_CONTROL(rptr); + wptr[2] = PPP_COMP >> 8; + wptr[3] = PPP_COMP; + wptr += PPP_HDRLEN; + wptr[0] = state->seqno >> 8; + wptr[1] = state->seqno; + wptr += 2; + state->strm.next_out = wptr; + state->strm.avail_out = wspace - (PPP_HDRLEN + 2); + } else { + state->strm.next_out = NULL; + state->strm.avail_out = 1000000; + wptr = NULL; + wspace = 0; + } + ++state->seqno; + + rptr += (proto > 0xff)? 2: 3; /* skip 1st proto byte if 0 */ + state->strm.next_in = rptr; + state->strm.avail_in = mtod(mp, u_char *) + mp->m_len - rptr; + mp = mp->m_next; + flush = (mp == NULL)? Z_PACKET_FLUSH: Z_NO_FLUSH; + olen = 0; + for (;;) { + r = deflate(&state->strm, flush); + if (r != Z_OK) { + printf("z_compress: deflate returned %d (%s)\n", + r, (state->strm.msg? state->strm.msg: "")); + break; + } + if (flush != Z_NO_FLUSH && state->strm.avail_out != 0) + break; /* all done */ + if (state->strm.avail_in == 0 && mp != NULL) { + state->strm.next_in = mtod(mp, u_char *); + state->strm.avail_in = mp->m_len; + mp = mp->m_next; + if (mp == NULL) + flush = Z_PACKET_FLUSH; + } + if (state->strm.avail_out == 0) { + if (m != NULL) { + m->m_len = wspace; + olen += wspace; + MGET(m->m_next, M_DONTWAIT, MT_DATA); + m = m->m_next; + if (m != NULL) { + m->m_len = 0; + if (maxolen - olen > MLEN) + MCLGET(m, M_DONTWAIT); + state->strm.next_out = mtod(m, u_char *); + state->strm.avail_out = wspace = M_TRAILINGSPACE(m); + } + } + if (m == NULL) { + state->strm.next_out = NULL; + state->strm.avail_out = 1000000; + } + } + } + if (m != NULL) + olen += (m->m_len = wspace - state->strm.avail_out); + + /* + * See if we managed to reduce the size of the packet. + * If the compressor just gave us a single zero byte, it means + * the packet was incompressible. + */ + if (m != NULL && olen < orig_len + && !(olen == PPP_HDRLEN + 3 && *wptr == 0)) { + state->stats.comp_bytes += olen; + state->stats.comp_packets++; + } else { + if (*mret != NULL) { + m_freem(*mret); + *mret = NULL; + } + state->stats.inc_bytes += orig_len; + state->stats.inc_packets++; + olen = orig_len; + } + state->stats.unc_bytes += orig_len; + state->stats.unc_packets++; + + return olen; +} + +static void +z_comp_stats(arg, stats) + void *arg; + struct compstat *stats; +{ + struct deflate_state *state = (struct deflate_state *) arg; + u_int out; + + *stats = state->stats; + stats->ratio = stats->unc_bytes; + out = stats->comp_bytes + stats->inc_bytes; + if (stats->ratio <= 0x7ffffff) + stats->ratio <<= 8; + else + out >>= 8; + if (out != 0) + stats->ratio /= out; +} + +/* + * Allocate space for a decompressor. + */ +static void * +z_decomp_alloc(options, opt_len) + u_char *options; + int opt_len; +{ + struct deflate_state *state; + int w_size; + + if (opt_len != CILEN_DEFLATE || options[0] != CI_DEFLATE + || options[1] != CILEN_DEFLATE + || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL + || options[3] != DEFLATE_CHK_SEQUENCE) + return NULL; + w_size = DEFLATE_SIZE(options[2]); + if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE) + return NULL; + + MALLOC(state, struct deflate_state *, sizeof(struct deflate_state), + M_DEVBUF, M_NOWAIT); + if (state == NULL) + return NULL; + + state->strm.next_out = NULL; + state->strm.zalloc = zalloc; + state->strm.zfree = zfree; + if (inflateInit2(&state->strm, -w_size) != Z_OK) { + FREE(state, M_DEVBUF); + return NULL; + } + + state->w_size = w_size; + bzero(&state->stats, sizeof(state->stats)); + return (void *) state; +} + +static void +z_decomp_free(arg) + void *arg; +{ + struct deflate_state *state = (struct deflate_state *) arg; + + inflateEnd(&state->strm); + FREE(state, M_DEVBUF); +} + +static int +z_decomp_init(arg, options, opt_len, unit, hdrlen, mru, debug) + void *arg; + u_char *options; + int opt_len, unit, hdrlen, mru, debug; +{ + struct deflate_state *state = (struct deflate_state *) arg; + + if (opt_len < CILEN_DEFLATE || options[0] != CI_DEFLATE + || options[1] != CILEN_DEFLATE + || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL + || DEFLATE_SIZE(options[2]) != state->w_size + || options[3] != DEFLATE_CHK_SEQUENCE) + return 0; + + state->seqno = 0; + state->unit = unit; + state->hdrlen = hdrlen; + state->debug = debug; + state->mru = mru; + + inflateReset(&state->strm); + + return 1; +} + +static void +z_decomp_reset(arg) + void *arg; +{ + struct deflate_state *state = (struct deflate_state *) arg; + + state->seqno = 0; + inflateReset(&state->strm); +} + +/* + * Decompress a Deflate-compressed packet. + * + * Because of patent problems, we return DECOMP_ERROR for errors + * found by inspecting the input data and for system problems, but + * DECOMP_FATALERROR for any errors which could possibly be said to + * be being detected "after" decompression. For DECOMP_ERROR, + * we can issue a CCP reset-request; for DECOMP_FATALERROR, we may be + * infringing a patent of Motorola's if we do, so we take CCP down + * instead. + * + * Given that the frame has the correct sequence number and a good FCS, + * errors such as invalid codes in the input most likely indicate a + * bug, so we return DECOMP_FATALERROR for them in order to turn off + * compression, even though they are detected by inspecting the input. + */ +int +z_decompress(arg, mi, mop) + void *arg; + struct mbuf *mi, **mop; +{ + struct deflate_state *state = (struct deflate_state *) arg; + struct mbuf *mo, *mo_head; + u_char *rptr, *wptr; + int rlen, olen, ospace; + int seq, i, flush, r, decode_proto; + u_char hdr[PPP_HDRLEN + DEFLATE_OVHD]; + + *mop = NULL; + rptr = mtod(mi, u_char *); + rlen = mi->m_len; + for (i = 0; i < PPP_HDRLEN + DEFLATE_OVHD; ++i) { + while (rlen <= 0) { + mi = mi->m_next; + if (mi == NULL) + return DECOMP_ERROR; + rptr = mtod(mi, u_char *); + rlen = mi->m_len; + } + hdr[i] = *rptr++; + --rlen; + } + + /* Check the sequence number. */ + seq = (hdr[PPP_HDRLEN] << 8) + hdr[PPP_HDRLEN+1]; + if (seq != state->seqno) { + if (state->debug) + printf("z_decompress%d: bad seq # %d, expected %d\n", + state->unit, seq, state->seqno); + return DECOMP_ERROR; + } + ++state->seqno; + + /* Allocate an output mbuf. */ + MGETHDR(mo, M_DONTWAIT, MT_DATA); + if (mo == NULL) + return DECOMP_ERROR; + mo_head = mo; + mo->m_len = 0; + mo->m_next = NULL; + MCLGET(mo, M_DONTWAIT); + ospace = M_TRAILINGSPACE(mo); + if (state->hdrlen + PPP_HDRLEN < ospace) { + mo->m_data += state->hdrlen; + ospace -= state->hdrlen; + } + + /* + * Fill in the first part of the PPP header. The protocol field + * comes from the decompressed data. + */ + wptr = mtod(mo, u_char *); + wptr[0] = PPP_ADDRESS(hdr); + wptr[1] = PPP_CONTROL(hdr); + wptr[2] = 0; + + /* + * Set up to call inflate. We set avail_out to 1 initially so we can + * look at the first byte of the output and decide whether we have + * a 1-byte or 2-byte protocol field. + */ + state->strm.next_in = rptr; + state->strm.avail_in = rlen; + mi = mi->m_next; + flush = (mi == NULL)? Z_PACKET_FLUSH: Z_NO_FLUSH; + rlen += PPP_HDRLEN + DEFLATE_OVHD; + state->strm.next_out = wptr + 3; + state->strm.avail_out = 1; + decode_proto = 1; + olen = PPP_HDRLEN; + + /* + * Call inflate, supplying more input or output as needed. + */ + for (;;) { + r = inflate(&state->strm, flush); + if (r != Z_OK) { + if (state->debug) + printf("z_decompress%d: inflate returned %d (%s)\n", + state->unit, r, (state->strm.msg? state->strm.msg: "")); + m_freem(mo_head); + return DECOMP_FATALERROR; + } + if (flush != Z_NO_FLUSH && state->strm.avail_out != 0) + break; /* all done */ + if (state->strm.avail_in == 0 && mi != NULL) { + state->strm.next_in = mtod(mi, u_char *); + state->strm.avail_in = mi->m_len; + rlen += mi->m_len; + mi = mi->m_next; + if (mi == NULL) + flush = Z_PACKET_FLUSH; + } + if (state->strm.avail_out == 0) { + if (decode_proto) { + state->strm.avail_out = ospace - PPP_HDRLEN; + if ((wptr[3] & 1) == 0) { + /* 2-byte protocol field */ + wptr[2] = wptr[3]; + --state->strm.next_out; + ++state->strm.avail_out; + --olen; + } + decode_proto = 0; + } else { + mo->m_len = ospace; + olen += ospace; + MGET(mo->m_next, M_DONTWAIT, MT_DATA); + mo = mo->m_next; + if (mo == NULL) { + m_freem(mo_head); + return DECOMP_ERROR; + } + MCLGET(mo, M_DONTWAIT); + state->strm.next_out = mtod(mo, u_char *); + state->strm.avail_out = ospace = M_TRAILINGSPACE(mo); + } + } + } + if (decode_proto) { + m_freem(mo_head); + return DECOMP_ERROR; + } + olen += (mo->m_len = ospace - state->strm.avail_out); + + state->stats.unc_bytes += olen; + state->stats.unc_packets++; + state->stats.comp_bytes += rlen; + state->stats.comp_packets++; + + *mop = mo_head; + return DECOMP_OK; +} + +/* + * Incompressible data has arrived - add it to the history. + */ +static void +z_incomp(arg, mi) + void *arg; + struct mbuf *mi; +{ + struct deflate_state *state = (struct deflate_state *) arg; + u_char *rptr; + int rlen, proto, r; + + /* + * Check that the protocol is one we handle. + */ + rptr = mtod(mi, u_char *); + proto = PPP_PROTOCOL(rptr); + if (proto > 0x3fff || proto == 0xfd || proto == 0xfb) + return; + + ++state->seqno; + + /* + * Iterate through the mbufs, adding the characters in them + * to the decompressor's history. For the first mbuf, we start + * at the either the 1st or 2nd byte of the protocol field, + * depending on whether the protocol value is compressible. + */ + rlen = mi->m_len; + state->strm.next_in = rptr + 3; + state->strm.avail_in = rlen - 3; + if (proto > 0xff) { + --state->strm.next_in; + ++state->strm.avail_in; + } + for (;;) { + r = inflateIncomp(&state->strm); + if (r != Z_OK) { + /* gak! */ + if (state->debug) { + printf("z_incomp%d: inflateIncomp returned %d (%s)\n", + state->unit, r, (state->strm.msg? state->strm.msg: "")); + } + return; + } + mi = mi->m_next; + if (mi == NULL) + break; + state->strm.next_in = mtod(mi, u_char *); + state->strm.avail_in = mi->m_len; + rlen += mi->m_len; + } + + /* + * Update stats. + */ + state->stats.inc_bytes += rlen; + state->stats.inc_packets++; + state->stats.unc_bytes += rlen; + state->stats.unc_packets++; +} + +#endif /* DO_DEFLATE */ diff --git a/freebsd-2.0/ppp_tty.c b/freebsd-2.0/ppp_tty.c index 81ffe92..01040de 100644 --- a/freebsd-2.0/ppp_tty.c +++ b/freebsd-2.0/ppp_tty.c @@ -62,7 +62,7 @@ * 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 + * 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 @@ -70,8 +70,9 @@ * Paul Mackerras (paulus@cs.anu.edu.au). */ -/* $Id: ppp_tty.c,v 1.4 1995/10/27 03:34:44 paulus Exp $ */ +/* $Id: ppp_tty.c,v 1.5 1996/07/01 01:00:31 paulus Exp $ */ /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */ +/* from NetBSD: if_ppp.c,v 1.15.2.2 1994/07/28 05:17:58 cgd Exp */ #include "ppp.h" #if NPPP > 0 @@ -149,6 +150,7 @@ static void ppplogchar __P((struct ppp_softc *, int)); /* This is a FreeBSD-2.0 kernel. */ #define CCOUNT(q) ((q)->c_cc) +#define PPP_LOWAT 100 /* Process more output when < LOWAT on queue */ #define PPP_HIWAT 400 /* Don't start a new packet if HIWAT on que */ /* @@ -181,9 +183,9 @@ pppopen(dev, tp) { struct proc *p = curproc; /* XXX */ register struct ppp_softc *sc; - int error, s, i; + int error, s; - if (error = suser(p->p_ucred, &p->p_acflag)) + if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) return (error); s = spltty(); @@ -217,6 +219,7 @@ pppopen(dev, tp) sc->sc_outm = NULL; pppgetm(sc); sc->sc_if.if_flags |= IFF_RUNNING; + sc->sc_if.if_baudrate = tp->t_ospeed; tp->t_sc = (caddr_t) sc; ttyflush(tp, FREAD | FWRITE); @@ -237,7 +240,6 @@ pppclose(tp, flag) int flag; { register struct ppp_softc *sc; - struct mbuf *m; int s; s = spltty(); @@ -332,7 +334,7 @@ pppread(tp, uio, flag) splx(s); for (m = m0; m && uio->uio_resid; m = m->m_next) - if (error = uiomove(mtod(m, u_char *), m->m_len, uio)) + if ((error = uiomove(mtod(m, u_char *), m->m_len, uio)) != 0) break; m_freem(m0); return (error); @@ -373,7 +375,7 @@ pppwrite(tp, uio, flag) len = M_TRAILINGSPACE(m); if (len > uio->uio_resid) len = uio->uio_resid; - if (error = uiomove(mtod(m, u_char *), len, uio)) { + if ((error = uiomove(mtod(m, u_char *), len, uio)) != 0) { m_freem(m0); return (error); } @@ -409,7 +411,7 @@ ppptioctl(tp, cmd, data, flag, p) error = 0; switch (cmd) { case PPPIOCSASYNCMAP: - if (error = suser(p->p_ucred, &p->p_acflag)) + if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) break; sc->sc_asyncmap[0] = *(u_int *)data; break; @@ -419,7 +421,7 @@ ppptioctl(tp, cmd, data, flag, p) break; case PPPIOCSRASYNCMAP: - if (error = suser(p->p_ucred, &p->p_acflag)) + if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) break; sc->sc_rasyncmap = *(u_int *)data; break; @@ -429,7 +431,7 @@ ppptioctl(tp, cmd, data, flag, p) break; case PPPIOCSXASYNCMAP: - if (error = suser(p->p_ucred, &p->p_acflag)) + if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) break; s = spltty(); bcopy(data, sc->sc_asyncmap, sizeof(sc->sc_asyncmap)); @@ -505,62 +507,20 @@ pppfcs(fcs, cp, len) } /* - * This gets called from pppoutput when a new packet is - * put on a queue, at splnet. + * This gets called at splnet from if_ppp.c at various times + * when there is data ready to be sent. */ static void pppasyncstart(sc) register struct ppp_softc *sc; { register struct tty *tp = (struct tty *) sc->sc_devp; - int s; - - s = spltty(); - pppstart(tp); - splx(s); -} - -/* - * This gets called when a received packet is placed on - * the inq, at splnet. - */ -static void -pppasyncctlp(sc) - struct ppp_softc *sc; -{ - struct tty *tp; - int s; - - /* Put a placeholder byte in canq for ttselect()/ttnread(). */ - s = spltty(); - tp = (struct tty *) sc->sc_devp; - putc(0, &tp->t_canq); - ttwakeup(tp); - splx(s); -} - -/* - * Start output on async tty interface. Get another datagram - * to send from the interface queue and start sending it. - * Called at spltty or higher. - */ -int -pppstart(tp) - register struct tty *tp; -{ - register struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc; register struct mbuf *m; register int len; register u_char *start, *stop, *cp; - int n, s, ndone, done, idle; + int n, ndone, done, idle; struct mbuf *m2; - - if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0 - || sc == NULL || tp != (struct tty *) sc->sc_devp) { - if (tp->t_oproc != NULL) - (*tp->t_oproc)(tp); - return 0; - } + int s; idle = 0; while (CCOUNT(&tp->t_outq) < PPP_HIWAT) { @@ -585,12 +545,13 @@ pppstart(tp) * the line may have been idle for some time. */ if (CCOUNT(&tp->t_outq) == 0) { - ++sc->sc_bytessent; + ++sc->sc_stats.ppp_obytes; (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); + sc->sc_if.if_lastchange = time; } for (;;) { @@ -611,24 +572,27 @@ pppstart(tp) ndone = n - b_to_q(start, n, &tp->t_outq); len -= ndone; start += ndone; - sc->sc_bytessent += ndone; + sc->sc_stats.ppp_obytes += ndone; if (ndone < n) break; /* packet doesn't fit */ } /* * If there are characters left in the mbuf, - * the first one must be special.. + * the first one must be special. * Put it out in a different form. */ if (len) { + s = spltty(); if (putc(PPP_ESCAPE, &tp->t_outq)) break; if (putc(*start ^ PPP_TRANS, &tp->t_outq)) { (void) unputc(&tp->t_outq); + splx(s); break; } - sc->sc_bytessent += 2; + splx(s); + sc->sc_stats.ppp_obytes += 2; start++; len--; } @@ -668,6 +632,7 @@ pppstart(tp) * Try to output the FCS and flag. If the bytes * don't all fit, back out. */ + s = spltty(); for (q = endseq; q < p; ++q) if (putc(*q, &tp->t_outq)) { done = 0; @@ -675,7 +640,9 @@ pppstart(tp) unputc(&tp->t_outq); break; } - sc->sc_bytessent += q - endseq; + splx(s); + if (done) + sc->sc_stats.ppp_obytes += q - endseq; } if (!done) { @@ -690,28 +657,24 @@ pppstart(tp) m = m2; if (m == NULL) { /* Finished a packet */ - sc->sc_if.if_opackets++; - sc->sc_if.if_obytes = sc->sc_bytessent; break; } sc->sc_outfcs = pppfcs(sc->sc_outfcs, mtod(m, u_char *), m->m_len); } /* - * Here we have either finished a packet (m == NULL) - * or filled up the output queue (m != NULL). + * If m == NULL, we have finished a packet. + * If m != NULL, we've either done as much work this time + * as we need to, or else we've filled up the output queue. */ sc->sc_outm = m; if (m) break; } - /* - * Send anything that may be in the output queue. - * We are being called in lieu of ttstart and must do what it would. - */ - if (tp->t_oproc != NULL) - (*tp->t_oproc)(tp); + /* Call pppstart to start output again if necessary. */ + s = spltty(); + pppstart(tp); /* * This timeout is needed for operation on a pseudo-tty, @@ -723,6 +686,58 @@ pppstart(tp) sc->sc_flags |= SC_TIMEOUT; } + splx(s); +} + +/* + * This gets called when a received packet is placed on + * the inq, at splnet. + */ +static void +pppasyncctlp(sc) + struct ppp_softc *sc; +{ + struct tty *tp; + int s; + + /* Put a placeholder byte in canq for ttselect()/ttnread(). */ + s = spltty(); + tp = (struct tty *) sc->sc_devp; + putc(0, &tp->t_canq); + ttwakeup(tp); + splx(s); +} + +/* + * Start output on async tty interface. If the transmit queue + * has drained sufficiently, arrange for pppasyncstart to be + * called later at splnet. + * Called at spltty or higher. + */ +int +pppstart(tp) + register struct tty *tp; +{ + register struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc; + + /* + * If there is stuff in the output queue, send it now. + * We are being called in lieu of ttstart and must do what it would. + */ + if (tp->t_oproc != NULL) + (*tp->t_oproc)(tp); + + /* + * If the transmit queue has drained and the tty has not hung up + * or been disconnected from the ppp unit, then tell if_ppp.c that + * we need more output. + */ + if (CCOUNT(&tp->t_outq) < PPP_LOWAT + && !((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) + && sc != NULL && tp == (struct tty *) sc->sc_devp) { + ppp_restart(sc); + } + return 0; } @@ -752,9 +767,7 @@ pppgetm(sc) { struct mbuf *m, **mp; int len; - int s; - s = spltty(); mp = &sc->sc_m; for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){ if ((m = *mp) == NULL) { @@ -767,7 +780,6 @@ pppgetm(sc) len -= M_DATASIZE(m); mp = &m->m_next; } - splx(s); } /* @@ -791,9 +803,8 @@ pppinput(c, tp) if (sc == NULL || tp != (struct tty *) sc->sc_devp) return 0; - s = spltty(); /* should be unnecessary */ ++tk_nin; - ++sc->sc_bytesrcvd; + ++sc->sc_stats.ppp_ibytes; if (c & TTY_FE) { /* framing error or overrun on this char - abort packet */ @@ -804,15 +815,18 @@ pppinput(c, tp) c &= 0xff; - if (sc->sc_flags & SC_XONXOFF) { - if (c == XOFF) { + /* + * Handle software flow control of output. + */ + if (tp->t_iflag & IXON) { + if (c == tp->t_cc[VSTOP] && tp->t_cc[VSTOP] != _POSIX_VDISABLE) { if ((tp->t_state & TS_TTSTOP) == 0) { tp->t_state |= TS_TTSTOP; (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0); } return 0; } - if (c == XON) { + if (c == tp->t_cc[VSTART] && tp->t_cc[VSTART] != _POSIX_VDISABLE) { tp->t_state &= ~TS_TTSTOP; if (tp->t_oproc != NULL) (*tp->t_oproc)(tp); @@ -820,6 +834,7 @@ pppinput(c, tp) } } + s = spltty(); if (c & 0x80) sc->sc_flags |= SC_RCV_B7_1; else @@ -828,6 +843,7 @@ pppinput(c, tp) sc->sc_flags |= SC_RCV_ODDP; else sc->sc_flags |= SC_RCV_EVNP; + splx(s); if (sc->sc_flags & SC_LOG_RAWIN) ppplogchar(sc, c); @@ -835,7 +851,6 @@ pppinput(c, tp) if (c == PPP_FLAG) { ilen = sc->sc_ilen; sc->sc_ilen = 0; - sc->sc_if.if_ibytes = sc->sc_bytesrcvd; if (sc->sc_rawin_count > 0) ppplogchar(sc, -1); @@ -845,13 +860,15 @@ pppinput(c, tp) * abort sequence "}~". */ if (sc->sc_flags & (SC_FLUSH | SC_ESCAPED) - || ilen > 0 && sc->sc_fcs != PPP_GOODFCS) { + || (ilen > 0 && sc->sc_fcs != PPP_GOODFCS)) { + s = spltty(); sc->sc_flags |= SC_PKTLOST; /* note the dropped packet */ if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){ if (sc->sc_flags & SC_DEBUG) - printf("ppp%d: bad fcs %x\n", sc->sc_if.if_unit, - sc->sc_fcs); + printf("ppp%d: bad fcs %x, pkt len %d\n", + sc->sc_if.if_unit, sc->sc_fcs, ilen); sc->sc_if.if_ierrors++; + sc->sc_stats.ppp_ierrors++; } else sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED); splx(s); @@ -862,10 +879,12 @@ pppinput(c, tp) if (ilen) { if (sc->sc_flags & SC_DEBUG) printf("ppp%d: too short (%d)\n", sc->sc_if.if_unit, ilen); + s = spltty(); sc->sc_if.if_ierrors++; + sc->sc_stats.ppp_ierrors++; sc->sc_flags |= SC_PKTLOST; + splx(s); } - splx(s); return 0; } @@ -886,25 +905,26 @@ pppinput(c, tp) sc->sc_mc->m_next = NULL; ppppktin(sc, m, sc->sc_flags & SC_PKTLOST); - sc->sc_flags &= ~SC_PKTLOST; + if (sc->sc_flags & SC_PKTLOST) { + s = spltty(); + sc->sc_flags &= ~SC_PKTLOST; + splx(s); + } pppgetm(sc); - splx(s); return 0; } if (sc->sc_flags & SC_FLUSH) { if (sc->sc_flags & SC_LOG_FLUSH) ppplogchar(sc, c); - splx(s); return 0; } - if (c < 0x20 && (sc->sc_rasyncmap & (1 << c))) { - splx(s); + if (c < 0x20 && (sc->sc_rasyncmap & (1 << c))) return 0; - } + s = spltty(); if (sc->sc_flags & SC_ESCAPED) { sc->sc_flags &= ~SC_ESCAPED; c ^= PPP_TRANS; @@ -913,6 +933,7 @@ pppinput(c, tp) splx(s); return 0; } + splx(s); /* * Initialize buffer on first octet received. @@ -998,17 +1019,18 @@ pppinput(c, tp) ++m->m_len; *sc->sc_mp++ = c; sc->sc_fcs = PPP_FCS(sc->sc_fcs, c); - splx(s); return 0; flush: if (!(sc->sc_flags & SC_FLUSH)) { + s = spltty(); sc->sc_if.if_ierrors++; + sc->sc_stats.ppp_ierrors++; sc->sc_flags |= SC_FLUSH; + splx(s); if (sc->sc_flags & SC_LOG_FLUSH) ppplogchar(sc, c); } - splx(s); return 0; } @@ -1022,7 +1044,7 @@ ppplogchar(sc, c) if (c >= 0) sc->sc_rawin[sc->sc_rawin_count++] = c; if (sc->sc_rawin_count >= sizeof(sc->sc_rawin) - || c < 0 && sc->sc_rawin_count > 0) { + || (c < 0 && sc->sc_rawin_count > 0)) { printf("ppp%d input: ", sc->sc_if.if_unit); pppdumpb(sc->sc_rawin, sc->sc_rawin_count); sc->sc_rawin_count = 0; -- 2.39.2