## diffname port/stip.c 1991/0424
## diff -e /dev/null /n/bootesdump/1991/0424/sys/src/9/port/stip.c
0a
/*
* ethernet specific multiplexor for ip
*
* this line discipline gets pushed onto an ethernet channel
* to demultiplex/multiplex ip conversations.
*/
#include "u.h"
#include "lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"
#include "errno.h"
#include "arp.h"
#include "ipdat.h"
#define DPRINT if(pip)print
int pip = 0;
int ipcksum = 1;
extern Ipifc *ipifc;
int Id = 1;
Fragq *flisthead;
Fragq *fragfree;
QLock fraglock;
Queue *Etherq;
Ipaddr Myip;
Ipaddr Mymask;
/* Predeclaration */
static void ipetherclose(Queue*);
static void ipetheriput(Queue*, Block*);
static void ipetheropen(Queue*, Stream*);
static void ipetheroput(Queue*, Block*);
/*
* the ethernet multiplexor stream module definition
*/
Qinfo ipinfo =
{
ipetheriput,
ipetheroput,
ipetheropen,
ipetherclose,
"internet"
};
void
initfrag(int size)
{
Fragq *fq, *eq;
fragfree = (Fragq*)ialloc(sizeof(Fragq) * size, 0);
eq = &fragfree[size];
for(fq = fragfree; fq < eq; fq++)
fq->next = fq+1;
fragfree[size-1].next = 0;
}
/*
* set up an ether interface
*/
static void
ipetheropen(Queue *q, Stream *s)
{
/* First open is by ipconfig and sets up channel
* to ethernet
*/
if(!Etherq)
Etherq = WR(q);
DPRINT("ipetheropen EQ %lux dev=%d id=%d RD %lux WR %lux\n",
Etherq, s->dev, s->id, RD(q), WR(q));
}
/*
* newipifc - Attach to or Create a new protocol interface
*/
Ipifc *
newipifc(uchar ptcl, void (*recvfun)(Ipconv *, Block *bp),
Ipconv *con, int max, int min, int hdrsize, char *name)
{
Ipifc *ifc, *free;
free = 0;
for(ifc = ipifc; ifc < &ipifc[conf.ipif]; ifc++) {
qlock(ifc);
if(ifc->protocol == ptcl) {
ifc->ref++;
qunlock(ifc);
return(ifc);
}
if(!free && ifc->ref == 0) {
ifc->ref = 1;
free = ifc;
}
else
qunlock(ifc);
}
if(!free)
error(Enoifc);
free->iprcv = recvfun;
/* If media supports large transfer units limit maxmtu
* to max ip size */
if(max > IP_MAX)
max = IP_MAX;
free->maxmtu = max;
free->minmtu = min;
free->hsize = hdrsize;
free->connections = con;
free->protocol = ptcl;
strncpy(free->name, name, NAMELEN);
qunlock(free);
return(free);
}
static void
ipetherclose(Queue *q)
{
if(q == Etherq) {
print("stip: Clearing ether channel\n");
Etherq = 0;
}
DPRINT("ipetherclose RD %lux WR %lux\n", RD(q), WR(q));
}
void
closeipifc(Ipifc *ifc)
{
/* If this is the last reference to the protocol multiplexor
* cancel upcalls from this stream
*/
qlock(ifc);
if(--ifc->ref == 0) {
ifc->protocol = 0;
ifc->name[0] = 0;
}
qunlock(ifc);
}
static void
ipetheroput(Queue *q, Block *bp)
{
Etherhdr *eh, *feh;
int lid, len, seglen, chunk, dlen, blklen, offset;
Ipifc *ifp;
ushort fragoff;
Block *xp, *nb;
uchar *ptr;
if(bp->type != M_DATA){
/* Allow one setting of the ip address */
if(!Myip && streamparse("setip", bp)) {
ptr = bp->rptr;
Myip = ipparse((char *)ptr);
Mymask = classmask[Myip>>30];
while(*ptr != ' ' && *ptr)
ptr++;
if(*ptr)
Mymask = ipparse((char *)ptr);
freeb(bp);
}
else
PUTNEXT(Etherq, bp);
return;
}
ifp = (Ipifc *)(q->ptr);
/* Number of bytes in ip and media header to write */
len = blen(bp);
/* Fill out the ip header */
eh = (Etherhdr *)(bp->rptr);
eh->vihl = IP_VER|IP_HLEN;
eh->tos = 0;
eh->ttl = 255;
/* If we dont need to fragment just send it */
if(len <= ifp->maxmtu) {
hnputs(eh->length, len-ETHER_HDR);
eh->frag[0] = 0;
eh->frag[1] = 0;
eh->cksum[0] = 0;
eh->cksum[1] = 0;
hnputs(eh->cksum, ip_csum(&eh->vihl));
/* Finally put in the ethernet level information */
hnputs(eh->type, ET_IP);
if(!arp_lookup(eh->dst, eh->d)) {
freeb(bp);
return;
}
PUTNEXT(Etherq, bp);
return;
}
if(eh->frag[0] & (IP_DF>>8))
goto drop;
seglen = (ifp->minmtu - (ETHER_HDR+ETHER_IPHDR)) & ~7;
if(seglen < 8)
goto drop;
/* Make prototype output header */
hnputs(eh->type, ET_IP);
if(!arp_lookup(eh->dst, eh->d)) {
freeb(bp);
return;
}
dlen = len - (ETHER_HDR+ETHER_IPHDR);
xp = bp;
lid = Id++;
offset = ETHER_HDR+ETHER_IPHDR;
while(xp && offset && offset >= BLEN(xp)) {
offset -= BLEN(xp);
xp = xp->next;
}
xp->rptr += offset;
for(fragoff = 0; fragoff < dlen; fragoff += seglen) {
nb = allocb(ETHER_HDR+ETHER_IPHDR+seglen);
feh = (Etherhdr *)(nb->rptr);
memmove(nb->wptr, eh, ETHER_HDR+ETHER_IPHDR);
nb->wptr += ETHER_HDR+ETHER_IPHDR;
if((fragoff + seglen) >= dlen) {
seglen = dlen - fragoff;
hnputs(feh->frag, fragoff>>3);
}
else {
hnputs(feh->frag, (fragoff>>3)|IP_MF);
}
hnputs(feh->length, seglen + ETHER_IPHDR);
hnputs(feh->id, lid);
/* Copy up the data area */
chunk = seglen;
while(chunk) {
if(!xp) {
freeb(nb);
goto drop;
}
blklen = MIN(BLEN(xp), chunk);
memmove(nb->wptr, xp->rptr, blklen);
nb->wptr += blklen;
xp->rptr += blklen;
chunk -= blklen;
if(xp->rptr == xp->wptr)
xp = xp->next;
}
feh->cksum[0] = 0;
feh->cksum[1] = 0;
hnputs(feh->cksum, ip_csum(&feh->vihl));
nb->flags |= S_DELIM;
PUTNEXT(Etherq, nb);
}
drop:
freeb(bp);
}
/*
* Input a packet and use the ip protocol to select the correct
* device to pass it to.
*
*/
static void
ipetheriput(Queue *q, Block *bp)
{
Ipifc *ep, *ifp;
Etherhdr *h;
ushort frag;
if(bp->type != M_DATA){
PUTNEXT(q, bp);
return;
}
h = (Etherhdr *)(bp->rptr);
/* Ensure we have enough data to process */
if(BLEN(bp) < (ETHER_HDR+ETHER_IPHDR)) {
bp = pullup(bp, ETHER_HDR+ETHER_IPHDR);
if(!bp)
return;
}
if(ipcksum && ip_csum(&h->vihl)) {
print("ip: checksum error (from %d.%d.%d.%d ?)\n",
h->src[0], h->src[1], h->src[2], h->src[3]);
goto drop;
}
/* Check header length and version */
if(h->vihl != (IP_VER|IP_HLEN))
goto drop;
frag = nhgets(h->frag);
if(frag) {
h->tos = frag & IP_MF ? 1 : 0;
bp = ip_reassemble(frag, bp, h);
if(!bp)
return;
}
/*
* Look for an ip interface attached to this protocol
*/
ep = &ipifc[conf.ipif];
for(ifp = ipifc; ifp < ep; ifp++) {
if(ifp->protocol == h->proto) {
(*ifp->iprcv)(ifp->connections, bp);
return;
}
}
drop:
freeb(bp);
}
Block *
ip_reassemble(int offset, Block *bp, Etherhdr *ip)
{
Fragq *f;
Ipaddr src, dst;
ushort id;
Block *bl, **l, *last, *prev;
int ovlap, len, fragsize;
src = nhgetl(ip->src);
dst = nhgetl(ip->dst);
id = nhgets(ip->id);
for(f = flisthead; f; f = f->next) {
if(f->src == src && f->dst == dst && f->id == id)
break;
}
if(!ip->tos && (offset & ~(IP_MF|IP_DF)) == 0) {
if(f) {
qlock(f);
ipfragfree(f);
}
return(bp);
}
BLKFRAG(bp)->foff = offset<<3;
BLKFRAG(bp)->flen = nhgets(ip->length) - ETHER_IPHDR; /* Ip data length */
bp->flags &= ~S_DELIM;
/* First fragment allocates a reassembly queue */
if(f == 0) {
f = ipfragallo();
if(f == 0) {
freeb(bp);
return 0;
}
qlock(f);
f->id = id;
f->src = src;
f->dst = dst;
f->blist = bp;
/* Check lance has handed us a contiguous buffer */
if(bp->next)
panic("ip: reass ?");
qunlock(f);
return 0;
}
qlock(f);
prev = 0;
l = &f->blist;
for(bl = f->blist; bl && BLKFRAG(bp)->foff > BLKFRAG(bl)->foff; bl = bl->next) {
prev = bl;
l = &bl->next;
}
/* Check overlap of a previous fragment - trim away as necessary */
if(prev) {
ovlap = BLKFRAG(prev)->foff + BLKFRAG(prev)->flen - BLKFRAG(bp)->foff;
if(ovlap > 0) {
if(ovlap > BLKFRAG(bp)->flen) {
freeb(bp);
qunlock(f);
return 0;
}
BLKFRAG(bp)->flen -= ovlap;
}
}
/* Link onto assembly queue */
bp->next = *l;
*l = bp;
/* Check to see if suceeding segments overlap */
if(bp->next) {
l = &bp->next;
end = BLKFRAG(bp)->foff + BLKFRAG(bp)->flen;
/* Take completely covered segements out */
while(*l && (ovlap = (end - BLKFRAG(*l)->foff)) > 0) {
if(ovlap < BLKFRAG(*l)->flen) {
BLKFRAG(*l)->flen -= ovlap;
(*l)->rptr += ovlap;
break;
}
last = *l;
freeb(*l);
*l = last;
}
}
/* Now look for a completed queue */
for(bl = f->blist; bl; bl = bl->next) {
if((BLKIP(bl)->frag[0]&(IP_MF>>8)) == 0)
goto complete;
if(bl->next == 0 ||
BLKFRAG(bl)->foff+BLKFRAG(bl)->flen != BLKFRAG(bl->next)->foff)
break;
}
qunlock(f);
return 0;
complete:
bl = f->blist;
last = bl;
len = nhgets(BLKIP(bl)->length);
bl->wptr = bl->rptr + len + ETHER_HDR;
/* Pullup all the fragment headers and return a complete packet */
for(bl = bl->next; bl; bl = bl->next) {
fragsize = BLKFRAG(bl)->flen;
len += fragsize;
bl->rptr += (ETHER_HDR+ETHER_IPHDR);
bl->wptr = bl->rptr + fragsize;
last = bl;
}
last->flags |= S_DELIM;
bl = f->blist;
f->blist = 0;
ipfragfree(f);
ip = BLKIP(bl);
hnputs(ip->length, len);
return(bl);
}
/*
* ipfragfree - Free a list of fragments, fragment list must be locked
*/
void
ipfragfree(Fragq *frag)
{
Block *f, *next;
Fragq *fl, **l;
for(f = frag->blist; f; f = next) {
next = f->next;
freeb(f);
}
frag->src = 0;
frag->id = 0;
qunlock(frag);
qlock(&fraglock);
l = &flisthead;
for(fl = *l; fl; fl = fl->next) {
if(fl == frag) {
*l = frag->next;
break;
}
l = &fl->next;
}
frag->next = fragfree;
fragfree = frag;
qunlock(&fraglock);
}
/*
* ipfragallo - allocate a reassembly queue
*/
Fragq *
ipfragallo(void)
{
Fragq *f;
qlock(&fraglock);
if(!fragfree) {
qunlock(&fraglock);
print("ipfragallo: no queue\n");
return 0;
}
f = fragfree;
fragfree = f->next;
f->next = flisthead;
flisthead = f;
qunlock(&fraglock);
return f;
}
/*
* ip_csum - Compute internet header checksums
*/
ushort
ip_csum(uchar *addr)
{
int len;
ulong sum = 0;
len = (addr[0]&0xf)<<2;
while(len > 0) {
sum += addr[0]<<8 | addr[1] ;
len -= 2;
addr += 2;
}
sum = (sum & 0xffff) + (sum >> 16);
sum = (sum & 0xffff) + (sum >> 16);
return (sum^0xffff);
}
/*
* ipparse - Parse an ip address out of a string
*/
Ipaddr classmask[4] = {
0xff000000,
0xff000000,
0xffff0000,
0xffffff00
};
Ipaddr
ipparse(char *ipa)
{
Ipaddr address = 0;
int shift;
Ipaddr net;
shift = 24;
while(shift >= 0 && ipa != (char *)1) {
address |= atoi(ipa) << shift;
shift -= 8;
ipa = strchr(ipa, '.')+1;
}
net = address & classmask[address>>30];
shift += 8;
return net | ((address & ~classmask[address>>30])>>shift);
}
/*
* XXX debugging code !
*/
void
ppkt(Block *bp)
{
uchar *x;
int len, cnt = 0;
Block *xp;
uchar ch;
if(bp)
print("ppkt: %lux len %d\n", bp, blen(bp));
else
print("ppkt: Null packet pointer\n");
xp = bp;
while(bp) {
len = BLEN(bp);
x = bp->rptr;
while(len--) {
if(cnt%64 == 0)
print("\n%.04d: ", cnt);
print("%.02x ", *x++);
cnt++;
}
bp = bp->next;
}
bp = xp;
cnt = 0;
while(bp) {
len = BLEN(bp);
x = bp->rptr;
while(len--) {
if(cnt%64 == 0)
print("\n%.04d: ", cnt);
ch = *x++;
print("%c ", ch < ' ' || ch >= 0x7f ? '.' : ch);
cnt++;
}
bp = bp->next;
}
print("\n");
}
.
## diffname port/stip.c 1991/0430
## diff -e /n/bootesdump/1991/0424/sys/src/9/port/stip.c /n/bootesdump/1991/0430/sys/src/9/port/stip.c
130,135d
74a
s->opens++; /* Hold this queue in place */
}
.
73c
if(!Etherq) {
.
## diffname port/stip.c 1991/0504
## diff -e /n/bootesdump/1991/0430/sys/src/9/port/stip.c /n/bootesdump/1991/0504/sys/src/9/port/stip.c
75a
s->inuse++;
.
## diffname port/stip.c 1991/0906
## diff -e /n/bootesdump/1991/0504/sys/src/9/port/stip.c /n/bootesdump/1991/0906/sys/src/9/port/stip.c
582,627d
304a
/* Look to see if its for me before we waste time checksuming it */
if(memcmp(h->dst, Netmyip, sizeof(Netmyip)) != 0)
goto drop;
.
163a
Netmyip[0] = (Myip>>24)&0xff;
Netmyip[1] = (Myip>>16)&0xff;
Netmyip[2] = (Myip>>8)&0xff;
Netmyip[3] = Myip&0xff;
.
30a
uchar Netmyip[4]; /* In Network byte order */
.
## diffname port/stip.c 1991/1023
## diff -e /n/bootesdump/1991/0906/sys/src/9/port/stip.c /n/bootesdump/1991/1023/sys/src/9/port/stip.c
558d
## diffname port/stip.c 1991/1027
## diff -e /n/bootesdump/1991/1023/sys/src/9/port/stip.c /n/bootesdump/1991/1027/sys/src/9/port/stip.c
276c
arpsendpkt(feh->dst, feh->d, Etherq, nb);
.
274d
221,224d
203,208c
arpsendpkt(eh->dst, eh->d, Etherq, bp);
.
## diffname port/stip.c 1991/1029
## diff -e /n/bootesdump/1991/1027/sys/src/9/port/stip.c /n/bootesdump/1991/1029/sys/src/9/port/stip.c
268d
266c
PUTNEXT(Etherq, nb);
.
203c
PUTNEXT(Etherq, bp);
.
201c
/* Finally put in the type and pass down to the arp layer */
.
## diffname port/stip.c 1991/1106
## diff -e /n/bootesdump/1991/1029/sys/src/9/port/stip.c /n/bootesdump/1991/1106/sys/src/9/port/stip.c
330d
325c
for(ifp = ipifc; ifp < ep; ifp++)
.
## diffname port/stip.c 1991/1115
## diff -e /n/bootesdump/1991/1106/sys/src/9/port/stip.c /n/bootesdump/1991/1115/sys/src/9/port/stip.c
133a
USED(q);
.
## diffname port/stip.c 1991/1120
## diff -e /n/bootesdump/1991/1115/sys/src/9/port/stip.c /n/bootesdump/1991/1120/sys/src/9/port/stip.c
134c
Ipconv *ipc;
ipc = (Ipconv *)(q->ptr);
if(ipc)
ipc->ref = 0;
.
77a
} else {
ipc = &ipconv[s->dev][s->id];
RD(q)->ptr = (void *)ipc;
WR(q)->ptr = (void *)ipc;
ipc->ref = 1;
.
70a
Ipconv *ipc;
.
## diffname port/stip.c 1991/1125
## diff -e /n/bootesdump/1991/1120/sys/src/9/port/stip.c /n/bootesdump/1991/1125/sys/src/9/port/stip.c
312c
if(memcmp(h->dst, Netmyip, sizeof(Netmyip)) != 0 &&
memcmp(h->dst, bcast, sizeof(bcast)) != 0)
.
31a
uchar bcast[4] = { 0xff, 0xff, 0xff, 0xff };
.
## diffname port/stip.c 1991/1126
## diff -e /n/bootesdump/1991/1125/sys/src/9/port/stip.c /n/bootesdump/1991/1126/sys/src/9/port/stip.c
348a
int
ipforme(uchar *addr)
{
Ipaddr haddr;
if(memcmp(addr, Netmyip, sizeof(Netmyip)) == 0)
return 1;
haddr = nhgetl(addr);
/* My subnet broadcast */
if((haddr&Mymask) == (Myip&Mymask))
return 1;
/* My network broadcast */
if((haddr&Mynetmask) == (Myip&Mynetmask))
return 1;
/* Real ip broadcast */
if(haddr == 0)
return 1;
/* Old style 255.255.255.255 address */
if(haddr == ~0)
return 1;
return 0;
}
.
316a
.
313,314c
if(ipforme(h->dst) == 0)
.
186a
/*
* Temporary Until we understand real subnets
*/
Mynetmask = Mymask;
.
146a
}
.
145c
if(ipc){
netdisown(ipc->net, ipc->index);
.
30a
Ipaddr Mynetmask;
.
## diffname port/stip.c 1991/1216
## diff -e /n/bootesdump/1991/1126/sys/src/9/port/stip.c /n/bootesdump/1991/1216/sys/src/9/port/stip.c
569a
f->age = TK2MS(MACHP(0)->ticks)/1000 + 600;
.
214a
hnputs(eh->id, Id++);
.
## diffname port/stip.c 1991/1219
## diff -e /n/bootesdump/1991/1216/sys/src/9/port/stip.c /n/bootesdump/1991/1219/sys/src/9/port/stip.c
231c
seglen = (ifp->maxmtu - (ETHER_HDR+ETHER_IPHDR)) & ~7;
.
## diffname port/stip.c 1992/0101
## diff -e /n/bootesdump/1991/1219/sys/src/9/port/stip.c /n/bootesdump/1992/0101/sys/src/9/port/stip.c
575d
571c
f->age = TK2MS(MACHP(0)->ticks) + 30000;
.
562,565c
while(fragfree == 0) {
for(f = flisthead; f; f = f->next)
if(canqlock(f)) {
qunlock(&fraglock);
ipfragfree(f);
break;
}
qlock(&fraglock);
.
549,550d
531a
frag->blist = 0;
.
525,528c
freeb(frag->blist);
.
522d
488c
.
482,484c
pktposn += BLKFRAG(bl)->flen;
.
479a
if(BLKFRAG(bl)->foff != pktposn)
break;
.
478c
pktposn = 0;
.
418,421d
404c
if(f != 0) {
.
401a
qunlock(&fraglock);
.
399c
if(f->src == src)
if(f->dst == dst)
if(f->id == id)
.
397a
qlock(&fraglock);
.
392c
int ovlap, len, fragsize, pktposn;
.
## diffname port/stip.c 1992/0102
## diff -e /n/bootesdump/1992/0101/sys/src/9/port/stip.c /n/bootesdump/1992/0102/sys/src/9/port/stip.c
525c
if(frag->blist)
freeb(frag->blist);
.
## diffname port/stip.c 1992/0107
## diff -e /n/bootesdump/1992/0102/sys/src/9/port/stip.c /n/bootesdump/1992/0107/sys/src/9/port/stip.c
566d
562,563c
ipfragfree(f, 0);
.
547c
if(lockq)
qunlock(&fraglock);
.
533c
if(lockq)
qlock(&fraglock);
.
521c
ipfragfree(Fragq *frag, int lockq)
.
508c
ipfragfree(f, 1);
.
428,430d
410c
ipfragfree(f, 1);
.
393a
/* Check lance has handed us a contiguous buffer */
if(bp->next)
panic("ip: reass ?");
.
316c
if(bp == 0)
.
## diffname port/stip.c 1992/0111
## diff -e /n/bootesdump/1992/0107/sys/src/9/port/stip.c /n/bootesdump/1992/0111/sys/src/9/port/stip.c
13c
#include "../port/error.h"
.
## diffname port/stip.c 1992/0211
## diff -e /n/bootesdump/1992/0111/sys/src/9/port/stip.c /n/bootesdump/1992/0211/sys/src/9/port/stip.c
190,192d
178c
if(streamparse("setip", bp)) {
if(strncmp(eve, u->p->user, sizeof(eve)) != 0)
error(Eperm);
.
## diffname port/stip.c 1992/0213
## diff -e /n/bootesdump/1992/0211/sys/src/9/port/stip.c /n/bootesdump/1992/0213/sys/src/9/port/stip.c
383a
.
374,381d
370,371c
/* if we haven't set an address yet, accept anything we get */
if(Myip[Myself] == 0)
.
366,368c
/* try my address plus all the forms of ip broadcast */
for(p = Myip; p < &Myip[7]; p++)
if(haddr == *p);
return 1;
.
361,363d
359a
Ipaddr *p;
.
355a
void
ipsetaddrs(void)
{
Myip[1] = ~0; /* local broadcast */
Myip[2] = 0; /* local broadcast - old */
Myip[Mysubnet] = Myip[Myself] | ~Mynetmask; /* subnet broadcast */
Myip[Mysubnet+1] = Myip[Myself] & Mynetmask; /* subnet broadcast - old */
Myip[Mynet] = Myip[Myself] | ~Mymask; /* net broadcast */
Myip[Mynet+1] = Myip[Myself] & Mymask; /* net broadcast - old */
}
.
193a
ipsetaddrs();
.
191,192c
Mynetmask = ipparse((char *)ptr);
else
Mynetmask = Mymask;
.
182,187c
Myip[Myself] = ipparse((char *)ptr);
Netmyip[0] = (Myip[Myself]>>24)&0xff;
Netmyip[1] = (Myip[Myself]>>16)&0xff;
Netmyip[2] = (Myip[Myself]>>8)&0xff;
Netmyip[3] = Myip[Myself]&0xff;
Mymask = classmask[Myip[Myself]>>30];
.
81a
ipsetaddrs();
.
39a
static void ipsetaddrs(void);
.
33a
Ipaddr Me[7]; /* possible addresses for me */
.
29c
Ipaddr Myip[4];
.
## diffname port/stip.c 1992/0214
## diff -e /n/bootesdump/1992/0213/sys/src/9/port/stip.c /n/bootesdump/1992/0214/sys/src/9/port/stip.c
364c
Myip[Mybcast] = ~0; /* local broadcast */
.
41d
34d
29c
Ipaddr Myip[7];
.
## diffname port/stip.c 1992/0304
## diff -e /n/bootesdump/1992/0214/sys/src/9/port/stip.c /n/bootesdump/1992/0304/sys/src/9/port/stip.c
478c
last = (*l)->next;
.
## diffname port/stip.c 1992/0307
## diff -e /n/bootesdump/1992/0304/sys/src/9/port/stip.c /n/bootesdump/1992/0307/sys/src/9/port/stip.c
473a
fragstat.succall++;
.
472c
while(*l){
ovlap = end - BLKFRAG(*l)->foff;
if(ovlap <= 0)
break;
fragstat.succ++;
.
454c
fragstat.prev++;
if(ovlap >= BLKFRAG(bp)->flen) {
fragstat.prevall++;
.
389a
typedef struct Fragstat Fragstat;
struct Fragstat
{
ulong prev;
ulong prevall;
ulong succ;
ulong succall;
};
Fragstat fragstat;
.
## diffname port/stip.c 1992/0319
## diff -e /n/bootesdump/1992/0307/sys/src/9/port/stip.c /n/bootesdump/1992/0319/sys/src/9/port/stip.c
494c
}
.
479c
/* Check to see if succeeding segments overlap */
.
407a
int end;
.
## diffname port/stip.c 1992/0321
## diff -e /n/bootesdump/1992/0319/sys/src/9/port/stip.c /n/bootesdump/1992/0321/sys/src/9/port/stip.c
8c
#include "../port/lib.h"
.
## diffname port/stip.c 1992/0326
## diff -e /n/bootesdump/1992/0321/sys/src/9/port/stip.c /n/bootesdump/1992/0326/sys/src/9/port/stip.c
501a
/*
* look for a complete packet. if we get to a fragment
* without IP_MF set, we're done.
*/
.
496a
(*l)->next = 0;
.
492a
BLKFRAG(*l)->foff += ovlap;
.
472c
BLKFRAG(prev)->flen -= ovlap;
.
453a
/*
* find the new fragment's position in the queue
*/
.
426a
/*
* if this isn't a fragmented packet, accept it
* and get rid of any fragments that might go
* with it.
*/
.
417a
/*
* find a reassembly queue for this fragment
*/
.
## diffname port/stip.c 1992/0622
## diff -e /n/bootesdump/1992/0326/sys/src/9/port/stip.c /n/bootesdump/1992/0622/sys/src/9/port/stip.c
58c
fragfree = (Fragq*)xalloc(sizeof(Fragq) * size);
.
## diffname port/stip.c 1992/0623
## diff -e /n/bootesdump/1992/0622/sys/src/9/port/stip.c /n/bootesdump/1992/0623/sys/src/9/port/stip.c
148c
netdisown(ipc);
.
## diffname port/stip.c 1992/0626
## diff -e /n/bootesdump/1992/0623/sys/src/9/port/stip.c /n/bootesdump/1992/0626/sys/src/9/port/stip.c
354c
}
.
348,351c
for(ifp = ipifc; ; ifp++){
ifc = *ifp;
if(ifc == 0)
break;
if(ifc->protocol == h->proto) {
(*ifc->iprcv)(ifc, bp);
.
304c
Ipifc *ifc, **ifp;
.
153,166d
137,138c
qunlock(ifc);
.
134,135c
ifc->protocol = ptcl;
ifc->inited = 1;
.
129,132c
ifc->maxmtu = max;
ifc->minmtu = min;
ifc->hsize = hdrsize;
.
120,124d
102,118c
qlock(ifc);
ifc->iprcv = recvfun;
.
97,100c
void
initipifc(Ipifc *ifc, uchar ptcl, void (*recvfun)(Ipifc*, Block *bp), int max,
int min, int hdrsize, char *name)
.
95c
* initipifc - set parameters of an ip protocol interface
.
84c
ipc = ipcreateconv(ipifc[s->dev], s->id);
.
20d
## diffname port/stip.c 1992/0711
## diff -e /n/bootesdump/1992/0626/sys/src/9/port/stip.c /n/bootesdump/1992/0711/sys/src/9/port/stip.c
98c
int min, int hdrsize)
.
## diffname port/stip.c 1992/0724
## diff -e /n/bootesdump/1992/0711/sys/src/9/port/stip.c /n/bootesdump/1992/0724/sys/src/9/port/stip.c
469a
/* move up ether+ip hdrs */
memmove((*l)->rptr + ovlap, (*l)->rptr,
ETHER_HDR+ETHER_IPHDR);
.
## diffname port/stip.c 1992/0913
## diff -e /n/bootesdump/1992/0724/sys/src/9/port/stip.c /n/bootesdump/1992/0913/sys/src/9/port/stip.c
405c
return bp;
.
392d
387,390c
for(f = flisthead; f; f = f->next)
if(f->src == src && f->dst == dst && f->id == id)
.
375c
/* Check ethrnet has handed us a contiguous buffer */
.
## diffname port/stip.c 1993/0123
## diff -e /n/bootesdump/1992/0913/sys/src/9/port/stip.c /n/bootesdump/1993/0123/sys/src/9/port/stip.c
459c
ovlap = fend - BLKFRAG(*l)->foff;
.
456c
fend = BLKFRAG(bp)->foff + BLKFRAG(bp)->flen;
.
373c
int fend;
.
## diffname port/stip.c 1993/0501
## diff -e /n/bootesdump/1993/0123/sys/src/9/port/stip.c /n/fornaxdump/1993/0501/sys/src/brazil/port/stip.c
459c
ovlap = end - BLKFRAG(*l)->foff;
.
456c
end = BLKFRAG(bp)->foff + BLKFRAG(bp)->flen;
.
373c
int end;
.
142c
if(strncmp(eve, up->user, sizeof(eve)) != 0)
.
## diffname port/stip.c 1993/0804 # deleted
## diff -e /n/fornaxdump/1993/0501/sys/src/brazil/port/stip.c /n/fornaxdump/1993/0804/sys/src/brazil/port/stip.c
1,635d
|
