/* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */
#if !defined(lint)
-static char sccsid[] = "$Revision: 1.1 $ ($Date: 1995/12/18 03:30:02 $)";
+static char sccsid[] = "$Revision: 1.6 $ ($Date: 1998/05/04 06:14:18 $)";
#endif /* not lint*/
#define KERNEL 1
#define KERNEL_FEATURES 1
#define INET 1
-/* #include "ppp.h" */
+#if NS_TARGET >= 40
+#if NS_TARGET >= 41
+#include <kernserv/clock_timer.h>
+#include <kernserv/lock.h>
+#else
+#include <kern/lock.h>
+#endif /* NS_TARGET */
+#endif /* NS_TARGET */
#include <sys/param.h>
+#if NS_TARGET >= 41
+typedef simple_lock_data_t lock_data_t; /* XXX */
+#endif /* NS_TARGET */
#include <sys/proc.h>
#include "netbuf.h"
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <sys/errno.h>
+#if !(NS_TARGET >= 40)
#include <kernserv/prototypes.h>
+#endif
#if defined(m68k)
#import "spl.h"
#else
#include <netinet/in_systm.h>
#include <netinet/in_var.h>
#include <netinet/ip.h>
+#include <netinet/tcp.h>
#endif
-
#include <net/ppp_defs.h>
#ifdef VJC
#include <net/vjcompress.h>
#endif
#include <net/if_ppp.h>
+#include "NeXT_Version.h"
#include "if_pppvar.h"
+
struct ppp_softc ppp_softc[NUM_PPP];
+
#ifdef PPP_COMPRESS
-#define PACKETPTR netbuf_t
+#define PACKETPTR NETBUF_T
#include <net/ppp-comp.h>
#endif
-#ifdef NBPFILTER
-#include <bpf/bpf.h>
/*
- * We store the address of necessary BPF functions
- * here.
- */
-struct bpf_fns fnarg;
-#endif
-
-/*
- * The max number of netbuf_ts we wish to compress and cache for
+ * The max number of NETBUF_Ts we wish to compress and cache for
* sending.
*/
-#define COMPRESS_CACHE_LEN 5
+#define COMPRESS_CACHE_LEN 1
#include "inlines.h"
static void ppp_requeue __P((struct ppp_softc *));
static void ppp_outpkt __P((struct ppp_softc *));
-static void ppp_ccp __P((struct ppp_softc *, netbuf_t, int rcvd));
+static void ppp_ccp __P((struct ppp_softc *, NETBUF_T, int rcvd));
static void ppp_ccp_closed __P((struct ppp_softc *));
-static void ppp_inproc __P((struct ppp_softc *, netbuf_t));
-static void pppdumpm __P((netbuf_t));
+static void ppp_inproc __P((struct ppp_softc *, NETBUF_T));
+static void pppdumpm __P((NETBUF_T));
extern int install_ppp_ld __P((void));
extern int tty_ld_remove __P((int));
-
/*
* We steal two bits in the mbuf m_flags, to mark high-priority packets
* for output, and received packets following lost/corrupted packets.
static struct qparms qparms[] = {
{20, 40, 50, "free"}, /* freeq */
- {5, 20, 25, "fast"}, /* rawq */
- {5, 20, 25, "slow"}, /* fastq */
- {5, 20, 25, "in"}, /* slowq */
- {5, 20, 25, "out"}, /* inq */
+ {5, 20, 25, "raw"}, /* rawq */
+ {5, 20, 25, "fast"}, /* fastq */
+ {5, 20, 25, "slow"}, /* slowq */
+ {5, 20, 25, "in"}, /* inq */
{5, 20, 25, "np"}, /* npq */
{0, COMPRESS_CACHE_LEN, COMPRESS_CACHE_LEN, "cache"} /* cache */
};
};
+/*
+ * Returns a new "outgoing" netbuf.
+ *
+ * Must return an actual netbuf_t since other protocols
+ * use this to get our buffers. Before releasing, save
+ * any space we may need when the buffer returns.
+ */
+
netbuf_t
pppgetbuf(netif_t ifp)
{
- netbuf_t nb;
+ NETBUF_T nb;
int len = MAX(if_mtu(ifp), PPP_MTU) + PPP_HDRLEN + PPP_FCSLEN;
- nb = ppp_nb_alloc(len);
+ nb = NB_ALLOC(len);
if (nb != NULL)
{
- ppp_nb_shrink_top(nb, PPP_HDRLEN);
- nb_shrink_bot(nb, PPP_FCSLEN); /* grown by pppstart() */
+ NB_SHRINK_TOP(nb, PPP_HDRLEN);
+ NB_SHRINK_BOT(nb, PPP_FCSLEN); /* grown by pppstart() */
}
- return nb;
+ return NB_TO_nb(nb);
}
/*
* Called from boot code to establish ppp interfaces.
*/
-int
+void
pppattach()
{
register struct ppp_softc *sc;
register int i = 0;
-
- IOLog("\nPPP version 2.2 released for NS 3.2 and 3.3\n");
- IOLog("LKS: %s\n", sccsid);
+
+ IOLog("\nPPP version 2.3.5-%s for NeXTSTEP and OPENSTEP\n", PPPVERSION);
IOLog("by Stephen Perkins, Philip Prindeville, and Pete French\n");
-
- IOLog("Installing PPP on Line Discipline %d\n", PPPDISC);
if (install_ppp_ld() < 0) {
IOLog("ppp: Could not install line discipline\n");
- return 0;
}
-
- IOLog("Installing interfaces:\n");
for (sc = ppp_softc; i < NUM_PPP; sc++, i++) {
sc->sc_if = if_attach(NULL, NULL, pppoutput,
pppgetbuf, pppcontrol, "ppp", i, "Serial line PPP",
PPP_MTU, IFF_POINTOPOINT, NETIFCLASS_VIRTUAL, (void *) sc);
- IOLog(" Initializing ppp%d\n", i);
nbq_init(&sc->sc_freeq, &qparms[QFREE]);
nbq_init(&sc->sc_rawq, &qparms[QRAW]);
nbq_init(&sc->sc_fastq, &qparms[QFAST]);
nbq_init(&sc->sc_npq, &qparms[QNP]);
nbq_init(&sc->sc_compq, &qparms[QCACHE]);
IOLog(" ppp%d successfully attached.\n", i);
-#ifdef NBPFILTER
- bpfattach((caddr_t *) &sc->sc_bpf, sc->sc_if, DLT_PPP, PPP_HDRLEN);
-#endif
}
ipforwarding = 1;
ipsendredirects = 1;
- IOLog("PPP-2.2 Successfully Installed.\n\n");
- return 1;
+
+ IOLog("PPP Successfully Installed.\n\n");
}
int
bzero(sc->sc_if, sizeof(netif_t));
IOLog(" ppp%d successfully detached.\n", i);
}
- IOLog("PPP-2.2 Successfully Removed.\n\n");
+ IOLog("PPP-2.3 Successfully Removed.\n\n");
return 0;
}
{
int nppp, i;
struct ppp_softc *sc;
+#if NS_TARGET >= 40
+ struct timeval tv_time;
+#endif /* NS_TARGET */
for (nppp = 0, sc = ppp_softc; nppp < NUM_PPP; nppp++, sc++)
if (sc->sc_xfer == pid) {
for (i = 0; i < NUM_NP; ++i)
sc->sc_npmode[i] = NPMODE_ERROR;
/* XXX - I'm not sure why the npqueue was zapped here... */
+
+#if NS_TARGET >= 40
+ ns_time_to_timeval(clock_value(System), &tv_time);
+ sc->sc_last_sent = sc->sc_last_recv = tv_time.tv_sec;
+#else
sc->sc_last_sent = sc->sc_last_recv = time.tv_sec;
+#endif
+
sc->sc_compsched = 0;
sc->sc_decompsched = 0;
-#if 0
- /*
- * Clear PPP stats information for the new session
- */
- sc->sc_bytessent = 0;
- sc->sc_bytesrcvd = 0;
- if_opackets_set(sc->sc_if, 0);
- if_ipackets_set(sc->sc_if, 0);
- if_oerrors_set(sc->sc_if, 0);
- if_ierrors_set(sc->sc_if, 0);
-#endif
-
/*
* XXX -- We need to get packets here, and we don't care if we do block...
* We do this after we set the sc_mru.
#ifdef PPP_COMPRESS
u_char ccp_option[CCP_MAX_OPTION_LENGTH];
#endif
- netbuf_t m;
+ NETBUF_T m;
#ifdef HAS_BROKEN_TIOCSPGRP
struct tty *tp = sc->sc_devp;
#endif
+#if NS_TARGET >= 40
+ struct timeval tv_time;
+#endif /* NS_TARGET */
+
switch (cmd) {
case FIONREAD:
s = splimp(); /* paranoid; splnet probably ok */
if ((m = nbq_peek(&sc->sc_inq)) != NULL)
- *(int *)data = nb_size(m);
+ *(int *)data = NB_SIZE(m);
else
*(int *)data = 0;
splx(s);
case PPPIOCGUNIT:
*(int *)data = if_unit(sc->sc_if);
-#if 0
- IOLogDbg("ppp%d: unit gets %d\n", if_unit(sc->sc_if), *(int *)data);
-#endif
break;
case PPPIOCGFLAGS:
*(u_int *)data = sc->sc_flags;
-#if 0
- IOLogDbg("ppp%d: flags gets 0x%x\n", if_unit(sc->sc_if), *(u_int *)data);
-#endif
break;
case PPPIOCSFLAGS:
oldflags = sc->sc_flags;
sc->sc_flags = (sc->sc_flags & ~SC_MASK) | flags;
splx(s);
-#if 0
- IOLogDbg("ppp%d: data 0x%x, flags: old 0x%x new 0x%x\n",
- if_unit(sc->sc_if), flags, oldflags, sc->sc_flags);
-#endif
break;
case PPPIOCSMRU:
if (! suser())
return EPERM;
mru = *(int *)data;
-#if 0
+
IOLogDbg("ppp%d: setting mru %d\n", if_unit(sc->sc_if), mru);
-#endif
+
if (mru >= PPP_MRU && mru <= PPP_MAXMRU) {
/* To make sure we handle the received packet
nbq_flush(&sc->sc_freeq); /* get rid of old buffers */
sc->sc_mru = mru;
if (sc->sc_m){
- nb_free(sc->sc_m);
+ NB_FREE(sc->sc_m);
sc->sc_m = NULL;
if (sc->sc_ilen != 0)
sc->sc_flags |= SC_FLUSH;
case PPPIOCGMRU:
*(int *)data = sc->sc_mru;
-#if 0
- IOLogDbg("ppp%d: mru gets 0x%x\n", if_unit(sc->sc_if), *(int *)data);
-#endif
break;
#ifdef VJC
case PPPIOCSMAXCID:
if (! suser())
return EPERM;
-#if 0
- IOLogDbg("ppp%d: setting max cid %d\n", if_unit(sc->sc_if), *(int *)data);
-#endif
s = splnet();
vj_compress_init(&sc->sc_comp, *(int *)data);
splx(s);
if (! suser())
return EPERM;
sc->sc_xfer = p->p_pid;
-#if 0
- IOLogDbg("ppp%d: setting pid %d\n", if_unit(sc->sc_if), sc->sc_xfer);
-#endif
break;
#ifdef PPP_COMPRESS
if (odp->transmit) {
if (sc->sc_xc_state != NULL)
(*sc->sc_xcomp->comp_free)(sc->sc_xc_state);
- sc->sc_xcomp = *cp;
+ sc->sc_xcomp = *cp; /* entry points for compressor */
sc->sc_xc_state = (*cp)->comp_alloc(ccp_option, nb);
if (sc->sc_xc_state == NULL) {
IOLogDbg("ppp%d: comp_alloc failed", if_unit(sc->sc_if));
} else {
if (sc->sc_rc_state != NULL)
(*sc->sc_rcomp->decomp_free)(sc->sc_rc_state);
- sc->sc_rcomp = *cp;
+ sc->sc_rcomp = *cp; /* entry points for compressor */
sc->sc_rc_state = (*cp)->decomp_alloc(ccp_option, nb);
if (sc->sc_rc_state == NULL) {
IOLogDbg("ppp%d: decomp_alloc failed", if_unit(sc->sc_if));
#ifdef HAS_BROKEN_TIOCSPGRP
case TIOCSPGRP:
-#if 0
- IOLogDbg("ppp%d: pgrp was %d, setting pgrp %d, flags 0x%x, state 0x%x\n",
- if_unit(sc->sc_if), tp->t_pgrp, *(int *)data,
- tp->t_flags, tp->t_state);
-#endif
tp->t_pgrp = *(int *)data;
break;
#endif
} else {
if (! suser())
return EPERM;
-#if 0
- IOLogDbg("ppp%d: setting protocol %d to mode %d\n", if_unit(sc->sc_if), npx, npi->mode);
-#endif
if (npi->mode != sc->sc_npmode[npx]) {
s = splimp();
sc->sc_npmode[npx] = npi->mode;
case PPPIOCGIDLE:
s = splimp();
+#if NS_TARGET >= 40
+ ns_time_to_timeval(clock_value(System), &tv_time);
+ t = tv_time.tv_sec;
+#else
t = time.tv_sec;
+#endif /* NS_TARGET */
((struct ppp_idle *)data)->xmit_idle = t - sc->sc_last_sent;
((struct ppp_idle *)data)->recv_idle = t - sc->sc_last_recv;
splx(s);
const char *cmd;
void *data;
{
-#if 0
- register struct ppp_softc *sc = &ppp_softc[if_unit(ifp)];
-#endif
if (!strcmp(cmd, IFCONTROL_UNIXIOCTL)) {
if_ioctl_t* ctl = (if_ioctl_t*)data;
struct sockaddr_in *sin = (struct sockaddr_in *)data;
if (sin->sin_family != AF_INET)
return EAFNOSUPPORT;
-#if 0
- IOLogDbg("ppp%d: setting address, and bringing up interface\n",
- if_unit(ifp));
-#endif
if_flags_set(ifp, if_flags(ifp) | IFF_UP);
return 0;
}
struct sockaddr_in *sin = (struct sockaddr_in *) data;
if (sin->sin_family != AF_INET)
return EAFNOSUPPORT;
-#if 0
- IOLogDbg("ppp%d: probing for interface address\n", if_unit(ifp));
-#endif
return 0;
} else if (!strcmp(cmd, IFCONTROL_SETFLAGS)) {
register union ifr_ifru *ifr = (union ifr_ifru *)data;
if (!suser())
return EPERM;
-#if 0
- IOLogDbg("ppp%d: old flags 0x%x, new flags 0x%x\n", if_unit(ifp),
- if_flags(ifp), ifr->ifru_flags);
-#endif
if_flags_set(ifp, ifr->ifru_flags);
return 0;
}
switch (cmd) {
case SIOCSIFFLAGS:
IOLog("ppp%d: pppioctl: SIOCSIFFLAGS called!\n", if_unit(ifp));
-#if 0
- if_flags_set(ifp, (if_flags(ifp) & IFF_CANTCHANGE)
- | (ifr->ifr_flags & ~IFF_CANTCHANGE));
-#endif
break;
case SIOCSIFADDR:
/*
* Queue a packet. Start transmission if not active.
* Packet is placed in Information field of PPP frame.
+ *
+ * This procedure MUST take an actual netbuf_t as input
+ * since it may be called by procedures outside of us.
+ * The buffer received must be in the same format as that
+ * returned by pppgetbuf().
*/
int
-pppoutput(ifp, m0, arg)
+pppoutput(ifp, in_nb, arg)
netif_t ifp;
- netbuf_t m0;
+ netbuf_t in_nb;
void *arg;
{
register struct ppp_softc *sc = &ppp_softc[if_unit(ifp)];
struct ip *ip;
struct nb_queue *ifq;
enum NPmode mode;
+ NETBUF_T m0;
+
+ m0 = nb_TO_NB(in_nb);
if (sc->sc_devp == NULL || (if_flags(ifp) & IFF_RUNNING) == 0
|| (if_flags(ifp) & IFF_UP) == 0 && dst->sa_family != AF_UNSPEC) {
goto bad;
}
+
/*
* Compute PPP header.
*/
/*
* Add PPP header.
*/
- ppp_nb_grow_top(m0, PPP_HDRLEN);
+ NB_GROW_TOP(m0, PPP_HDRLEN);
cp = mtod(m0, u_char *);
*cp++ = address;
*cp++ = protocol >> 8;
*cp++ = protocol & 0xff;
+
if (sc->sc_flags & SC_LOG_OUTPKT) {
IOLog("ppp%d: output:\n", if_unit(ifp)); /* XXX */
pppdumpm(m0);
}
-#ifdef NBPFILTER
- /*
- * See if bpf wants to look at the packet.
- */
- if (sc->sc_bpf)
- bpf_tap(sc->sc_bpf, nb_map(m0), nb_size(m0));
-#endif
/*
* Put the packet on the appropriate queue.
*/
s = splimp(); /* splnet should be OK now */
if (mode == NPMODE_QUEUE) {
- nb_set_mark(m0,flags); /* save priority */
+ NB_SET_MARK(m0,flags); /* save priority */
/* XXX we should limit the number of packets on this queue */
nbq_enqueue(&sc->sc_npq, m0); /* XXX is this correct? */
} else {
return (0);
bad:
- nb_free(m0);
+ NB_FREE(m0);
return (error);
}
ppp_requeue(sc)
struct ppp_softc *sc;
{
- netbuf_t m, lm, nm;
+ NETBUF_T m, lm, nm;
struct nb_queue *ifq;
enum NPmode mode;
mark_t flags;
lm = nm = NULL;
for (m = sc->sc_npq.head; m; ) {
- nb_get_next(m,&nm);
+ NB_GET_NEXT(m,&nm);
switch (PPP_PROTOCOL(mtod(m, u_char *))) {
case PPP_IP:
* This packet can now go on one of the queues to be sent.
*/
if(lm)
- nb_set_next(lm,nm);
+ NB_SET_NEXT(lm,nm);
else
sc->sc_npq.head = nm;
- nb_set_next(m,NULL);
- nb_get_mark(m,&flags);
+ NB_SET_NEXT(m,NULL);
+ NB_GET_MARK(m,&flags);
ifq = (flags & M_HIGHPRI)? &sc->sc_fastq: &sc->sc_slowq;
if (nbq_full(ifq)) {
nbq_drop(ifq);
incr_cnt(sc->sc_if, if_oerrors);
- nb_free(m);
+ NB_FREE(m);
} else
nbq_enqueue(ifq, m);
sc->sc_npq.len--;
case NPMODE_DROP:
case NPMODE_ERROR:
sc->sc_npq.len--;
- nb_free(m);
+ NB_FREE(m);
break;
case NPMODE_QUEUE:
* to prepare a new packet; the device start routine gets called
* again when a packet is ready.
*/
-netbuf_t
+NETBUF_T
ppp_dequeue(sc)
struct ppp_softc *sc;
{
- netbuf_t m;
+ NETBUF_T m;
int error;
m = nbq_dequeue(&sc->sc_compq);
{
struct ppp_softc *sc = (struct ppp_softc *)arg;
int s;
- netbuf_t m;
+ NETBUF_T m;
if (nbq_low(&sc->sc_freeq))
pppfillfreeq((void *) sc);
{
struct ppp_softc *sc = (struct ppp_softc *)arg;
int s;
- netbuf_t m;
+ NETBUF_T m;
- if (nbq_low(&sc->sc_freeq))
- pppfillfreeq((void *) sc);
+ if (nbq_low(&sc->sc_freeq))
+ pppfillfreeq((void *) sc);
while (!nbq_full(&sc->sc_compq) && !nbq_empty(&sc->sc_fastq))
ppp_outpkt(sc);
- if (!nbq_full(&sc->sc_compq) && !nbq_empty(&sc->sc_slowq))
- ppp_outpkt(sc);
+ if (!nbq_full(&sc->sc_compq) && !nbq_empty(&sc->sc_slowq))
+ ppp_outpkt(sc);
- sc->sc_compsched = 0;
+ sc->sc_compsched = 0;
}
/*
struct ppp_softc *sc;
{
int s;
- netbuf_t m;
+ NETBUF_T m;
u_char *cp;
int address, control, protocol;
+#if NS_TARGET >= 40
+ struct timeval tv_time;
+#endif
/*
* Grab a packet to send: first try the fast queue, then the
control = PPP_CONTROL(cp);
protocol = PPP_PROTOCOL(cp);
+#if NS_TARGET >= 40
+ ns_time_to_timeval(clock_value(System), &tv_time);
+#endif /* NS_TARGET */
+
switch (protocol) {
case PPP_IP:
/*
* Update the time we sent the most recent packet.
*/
- sc->sc_last_sent = time.tv_sec;
+#if NS_TARGET >= 40
+ sc->sc_last_sent = tv_time.tv_sec;
+#else
+ sc->sc_last_sent = time.tv_sec;
+#endif /* NS_TARGET */
#ifdef VJC
/*
ip = (struct ip *) (cp + PPP_HDRLEN);
/* this code assumes the IP/TCP header is in one netbuf */
if (ip->ip_p == IPPROTO_TCP) {
- type = vj_compress_tcp(ip, nb_size(m) - PPP_HDRLEN,
+ type = vj_compress_tcp(ip, NB_SIZE(m) - PPP_HDRLEN,
&sc->sc_comp,
!(sc->sc_flags & SC_NO_TCP_CCID), &vjhdr);
switch (type) {
protocol = PPP_VJC_UNCOMP;
break;
case TYPE_COMPRESSED_TCP:
- ppp_nb_shrink_top(m, vjhdr - (u_char *) ip);
+ NB_SHRINK_TOP(m, vjhdr - (u_char *) ip);
protocol = PPP_VJC_COMP;
cp = mtod(m, u_char *);
cp[0] = address; /* header has moved */
cp[3] = protocol; /* update protocol in PPP header */
}
}
+
#endif /* VJC */
+
break;
#ifdef PPP_COMPRESS
#endif /* PPP_COMPRESS */
}
+
#ifdef PPP_COMPRESS
if (protocol != PPP_LCP && protocol != PPP_CCP
&& sc->sc_xc_state && (sc->sc_flags & SC_COMP_RUN)) {
- netbuf_t mcomp;
+ NETBUF_T mcomp;
int slen, clen;
- slen = nb_size(m);
+ slen = NB_SIZE(m);
+
clen = (*sc->sc_xcomp->compress)
(sc->sc_xc_state, &mcomp, m, slen,
sc->sc_flags & SC_CCP_UP? if_mtu(sc->sc_if): 0);
+
+
+ if (mcomp && (NB_SIZE(mcomp) >= slen))
+ IOLog("BSD Warning... packet growth: Orig=%d New=%d.\n",
+ slen, NB_SIZE(mcomp));
+
if (mcomp != NULL) {
- nb_free(m);
+
+ NB_FREE(m);
m = mcomp;
cp = mtod(m, u_char *);
protocol = cp[3];
control == PPP_UI && protocol != PPP_ALLSTATIONS &&
protocol != PPP_LCP) {
/* can compress address/control */
- ppp_nb_shrink_top(m, 2);
+ NB_SHRINK_TOP(m, 2);
}
if (sc->sc_flags & SC_COMP_PROT && protocol < 0xFF) {
/* can compress protocol */
cp[2] = cp[1]; /* move address/control up */
cp[1] = cp[0];
}
- ppp_nb_shrink_top(m, 1);
+ NB_SHRINK_TOP(m, 1);
}
+
s = splimp();
nbq_enqueue(&sc->sc_compq, m);
(*sc->sc_start)(sc);
static void
ppp_ccp(sc, m, rcvd)
struct ppp_softc *sc;
- netbuf_t m;
+ NETBUF_T m;
int rcvd;
{
u_char *dp, *ep;
*/
dp = mtod(m, u_char *) + PPP_HDRLEN;
- ep = mtod(m, u_char *) + nb_size(m);
+ ep = mtod(m, u_char *) + NB_SIZE(m);
if (dp + CCP_HDRLEN > ep)
return;
slen = CCP_LENGTH(dp);
if (dp + slen > ep) {
IOLogDbg("ppp%d: ccp: not enough data in netbuf (%x+%x > %x+%x)\n",
- if_unit(sc->sc_if), dp, slen, mtod(m, u_char *), nb_size(m));
+ if_unit(sc->sc_if), dp, slen, mtod(m, u_char *), NB_SIZE(m));
return;
}
void
ppppktin(sc, m, lost)
struct ppp_softc *sc;
- netbuf_t m;
+ NETBUF_T m;
int lost;
{
int error, s = splimp();
- nb_set_mark(m,(lost ? M_ERRMARK : 0));
+ NB_SET_MARK(m,(lost ? M_ERRMARK : 0));
/* XXX - we should check for the raw queue overflowing... */
nbq_enqueue(&sc->sc_rawq, m);
static void
ppp_inproc(sc, m)
struct ppp_softc *sc;
- netbuf_t m;
+ NETBUF_T m;
{
struct nb_queue *inq;
int s, ilen, xlen, proto, rv;
mark_t flags;
u_char *cp, adrs, ctrl;
- netbuf_t dmp;
+ NETBUF_T dmp;
u_char *iphdr;
u_int hlen;
+#if NS_TARGET >= 40
+ struct timeval tv_time;
+#endif /* NS_TARGET */
+
incr_cnt(sc->sc_if, if_ipackets);
- nb_get_mark(m,&flags);
+ NB_GET_MARK(m,&flags);
if (sc->sc_flags & SC_LOG_INPKT) {
- IOLog("ppp%d: got %d bytes\n", if_unit(sc->sc_if), nb_size(m));
+ IOLog("ppp%d: got %d bytes\n", if_unit(sc->sc_if), NB_SIZE(m));
pppdumpm(m);
}
/* decompress this packet */
rv = (*sc->sc_rcomp->decompress)(sc->sc_rc_state, m, &dmp);
if (rv == DECOMP_OK){
- nb_free(m);
- if (dmp == NULL){
- /* No error, but no decompressed packet returned */
- return;
- }
+
+ NB_FREE(m);
+ if (dmp == NULL){
+ /* No error, but no decompressed packet returned */
+ return;
+ }
m = dmp;
cp = mtod(m, u_char *);
proto = PPP_PROTOCOL(cp);
-
} else {
/*
* An error has occurred in decompression.
IOLogDbg("ppp%d: decompress failed %d\n", if_unit(sc->sc_if), rv);
s = splimp();
sc->sc_flags |= SC_VJ_RESET;
+
if (rv == DECOMP_ERROR)
sc->sc_flags |= SC_DC_ERROR;
else
}
} else {
- if (sc->sc_rc_state && (sc->sc_flags & SC_DECOMP_RUN)) {
+ if (sc->sc_rc_state && (sc->sc_flags & SC_DECOMP_RUN))
+ {
+
(*sc->sc_rcomp->incomp)(sc->sc_rc_state, m);
}
if (proto == PPP_CCP) {
}
#endif
- ilen = nb_size(m);
+ ilen = NB_SIZE(m);
#ifdef VJC
if (sc->sc_flags & SC_VJ_RESET) {
* If we've missed a packet, we must toss subsequent compressed
* packets which don't have an explicit connection ID.
*/
+
+/* IOLog("SC_VJ_RESET was set!\n"); */
+
vj_uncompress_err(&sc->sc_comp);
s = splimp();
sc->sc_flags &= ~SC_VJ_RESET;
if (sc->sc_flags & SC_REJ_COMP_TCP)
goto bad;
+
xlen = vj_uncompress_tcp(cp + PPP_HDRLEN, ilen - PPP_HDRLEN,
ilen - PPP_HDRLEN,
&sc->sc_comp, &iphdr, &hlen);
if (xlen <= 0) {
- IOLogDbg("ppp%d: VJ uncompress failed on type comp\n",
+/*
+ IOLogDbg("ppp%d: VJ uncompress failed on type comp\n",
if_unit(sc->sc_if));
+*/
goto bad;
}
- ppp_nb_grow_top(m, hlen - xlen);
- nb_write(m, PPP_HDRLEN, hlen, iphdr);
+ /*
+ * Write the IP/TCP header back into the datagram.
+ * The pointers point to the stored copy in the VJ
+ * compression table.
+ */
+
+ NB_GROW_TOP(m, hlen - xlen);
+ NB_WRITE(m, PPP_HDRLEN, hlen, iphdr);
cp = mtod(m, u_char *);
+
+#ifdef TCP_CHECKSUM
+ {
+#define getip_hl(base) ((base).ip_hl)
+
+ u_short mytcpcksum (struct ip *pip);
+ struct tcphdr *ptcp;
+ struct ip *iphdr;
+ u_short thecksum;
+ u_long hlen;
+
+ iphdr = (struct ip*) (cp + PPP_HDRLEN);
+ hlen = getip_hl(*iphdr) << 2; /* Length is in words */
+ ptcp = (struct tcphdr *)&((u_char *)iphdr)[hlen];
+
+ thecksum = (u_short)mytcpcksum(iphdr);
+
+ if(ptcp->th_sum != thecksum)
+ {
+#ifdef NEWVJ_RESYNC
+ set_newvj_error_mode();
+#endif
+ IOLog("NEWVJ: Warning... TCP checksum failed Received=%u, Calculated=%u)\n",
+ (ptcp->th_sum)&0xffff, thecksum&0xffff);
+ }
+ }
+#endif
+
+
cp[0] = adrs;
cp[1] = ctrl;
cp[2] = 0;
if (sc->sc_flags & SC_REJ_COMP_TCP)
goto bad;
- vj_uncompress_uncomp(cp + PPP_HDRLEN, &sc->sc_comp);
+
+ vj_uncompress_uncomp(cp + PPP_HDRLEN, ilen-PPP_HDRLEN, &sc->sc_comp);
proto = PPP_IP;
cp[3] = PPP_IP;
}
#endif /* VJC */
-#ifdef NBPFILTER
- /* See if bpf wants to look at the packet. */
- if (sc->sc_bpf)
- bpf_tap(sc->sc_bpf, nb_map(m), nb_size(m));
-#endif
rv = 0;
switch (proto) {
if ((if_flags(sc->sc_if) & IFF_UP) == 0
|| sc->sc_npmode[NP_IP] != NPMODE_PASS) {
/* interface is down - drop the packet. */
- nb_free(m);
+ NB_FREE(m);
IOLogDbg("ppp%d: IP packed dropped (NPmode)\n", if_unit(sc->sc_if));
return;
}
- ppp_nb_shrink_top(m, PPP_HDRLEN);
- inet_queue(sc->sc_if, m);
+ NB_SHRINK_TOP(m, PPP_HDRLEN);
+ inet_queue(sc->sc_if, NB_TO_nb(m));
+#if NS_TARGET >= 40
+ /* I am assuming the time is different here than above. */
+ ns_time_to_timeval(clock_value(System), &tv_time);
+ sc->sc_last_recv = tv_time.tv_sec; /* update time of last pkt rcvd */
+#else
sc->sc_last_recv = time.tv_sec; /* update time of last pkt rcvd */
+#endif
return;
#endif
return;
bad:
- nb_free(m);
+ NB_FREE(m);
incr_cnt(sc->sc_if, if_ierrors);
}
static void
pppdumpm(m0)
- netbuf_t m0;
+ NETBUF_T m0;
{
char buf[3*MAX_DUMP_BYTES+4];
char *bp = buf;
static char digits[] = "0123456789abcdef";
- int l = nb_size(m0);
+ int l = NB_SIZE(m0);
u_char *rptr = mtod(m0, u_char *);
while (l--) {
projects / ppp.git / blobdiff