1998/0314/ip/ip.c (diff list | history)

ip/ip.c on 1997/0327
1997/0327		#include "u.h" #include "../port/lib.h" #include "mem.h" #include "dat.h" #include "fns.h" #include "../port/error.h" #include "ip.h" typedef struct Iphdr Iphdr; typedef struct Fragment Fragment; typedef struct Ipfrag Ipfrag; enum { IPHDR = 20, /* sizeof(Iphdr) */ IP_VER = 0x40, /* Using IP version 4 */ IP_HLEN = 0x05, /* Header length in characters */ IP_DF = 0x4000, /* Don't fragment */ IP_MF = 0x2000, /* More fragments */
1998/0306		IP_MAX = (32*1024), /* Maximum Internet packet size */
1997/0327		}; struct Iphdr {
1998/0306		uchar vihl; /* Version and header length */ uchar tos; /* Type of service */ uchar length[2]; /* packet length */
1998/0313		uchar id[2]; /* ip->identification */
1998/0306		uchar frag[2]; /* Fragment information */ uchar ttl; /* Time to live */ uchar proto; /* Protocol */ uchar cksum[2]; /* Header checksum */
1998/0313		uchar src[4]; /* IP source */ uchar dst[4]; /* IP destination */
1997/0327		}; struct Fragment { Block* blist; Fragment* next;
1998/0306		ulong src; ulong dst;
1997/0327		ushort id; ulong age; }; struct Ipfrag { ushort foff; ushort flen; };
1998/0313		/* MIB II counters */ typedef struct Ipstats Ipstats; struct Ipstats { ulong ipForwarding; ulong ipDefaultTTL; ulong ipInReceives; ulong ipInHdrErrors; ulong ipInAddrErrors; ulong ipForwDatagrams; ulong ipInUnknownProtos; ulong ipInDiscards; ulong ipInDelivers; ulong ipOutRequests; ulong ipOutDiscards; ulong ipOutNoRoutes; ulong ipReasmTimeout; ulong ipReasmReqds; ulong ipReasmOKs; ulong ipReasmFails; ulong ipFragOKs; ulong ipFragFails; ulong ipFragCreates; };
1997/0327
1998/0313		/* an instance of IP */ struct IP { Ipstats istats; QLock fraglock; Fragment* flisthead; Fragment* fragfree; ulong id; int iprouting; /* true if we route like a gateway */ void (*ipextprotoiput)(Block*); };
1997/0327		#define BLKIP(xp) ((Iphdr*)((xp)->rp)) /* * This sleazy macro relies on the media header size being * larger than sizeof(Ipfrag). ipreassemble checks this is true */ #define BKFG(xp) ((Ipfrag*)((xp)->base))
1998/0313		ushort ipcsum(uchar*); Block* ipreassemble(IP*, int, Block*, Iphdr*); void ipfragfree(IP*, Fragment*); Fragment* ipfragallo(IP*); void ip_init(Fs *f)
1997/0916		{
1998/0313		IP *ip;
1997/0916
1998/0313		ip = smalloc(sizeof(IP)); initfrag(ip, 100); f->ip = ip; }
1997/0327		void
1998/0314		iprouting(Fs *f, int on) { f->ip->iprouting = on; } void
1998/0313		ipoput(Fs *f, Block *bp, int gating, int ttl)
1997/0327		{
1998/0306		Ipifc *ifc; uchar *gate;
1997/0327		ushort fragoff; Block *xp, *nb; Iphdr *eh, *feh; int lid, len, seglen, chunk, dlen, blklen, offset, medialen;
1998/0313		Route *r, *sr; IP *ip;
1997/0327
1998/0313		ip = f->ip;
1997/0327		/* Fill out the ip header */ eh = (Iphdr *)(bp->rp);
1998/0313		ip->istats.ipOutRequests++;
1998/0306		/* Number of uchars in data and ip header to write */
1997/0327		len = blocklen(bp);
1998/0313
1997/0327		if(gating){ chunk = nhgets(eh->length); if(chunk > len){
1998/0313		ip->istats.ipOutDiscards++; netlog(f, Logip, "short gated packet\n");
1998/0308		goto free;
1997/0327		} if(chunk < len) len = chunk; }
1998/0306		if(len >= IP_MAX){
1998/0313		ip->istats.ipOutDiscards++; netlog(f, Logip, "exceeded ip max size %V\n", eh->dst);
1998/0308		goto free;
1997/0327		}
1998/0313		r = v4lookup(f, eh->dst);
1998/0306		if(r == nil){
1998/0313		ip->istats.ipOutNoRoutes++; netlog(f, Logip, "no interface %V\n", eh->dst);
1998/0308		goto free;
1997/0327		}
1998/0313		ifc = r->ifc; if(r->type & (Rifc|Runi))
1998/0306		gate = eh->dst; else
1998/0313		if(r->type & (Rbcast|Rmulti)) { gate = eh->dst; sr = v4lookup(f, eh->src); if(sr != nil && (sr->type & Runi)) ifc = sr->ifc; } else
1998/0306		gate = r->v4.gate;
1998/0313
1997/0327		if(!gating){ eh->vihl = IP_VER|IP_HLEN; eh->tos = 0; eh->ttl = ttl; }
1998/0307		if(waserror()){ runlock(ifc); nexterror(); } rlock(ifc); if(ifc->m == nil) goto raise;
1997/0327		/* If we dont need to fragment just send it */
1998/0306		medialen = ifc->m->maxmtu - ifc->m->hsize;
1997/0327		if(len <= medialen) { if(!gating)
1998/0313		hnputs(eh->id, ip->id++);
1997/0327		hnputs(eh->length, len); eh->frag[0] = 0; eh->frag[1] = 0; eh->cksum[0] = 0; eh->cksum[1] = 0; hnputs(eh->cksum, ipcsum(&eh->vihl));
1998/0313		/* print("ipoput %V->%V via %V\n", eh->src, eh->dst, gate); /**/
1998/0306		ifc->m->bwrite(ifc, bp, V4, gate);
1998/0307		runlock(ifc); poperror();
1997/0327		return; } if(eh->frag[0] & (IP_DF>>8)){
1998/0313		ip->istats.ipOutDiscards++; netlog(f, Logip, "%V: eh->frag[0] & (IP_DF>>8)\n", eh->dst);
1997/0327		goto raise; } seglen = (medialen - IPHDR) & ~7; if(seglen < 8){
1998/0313		ip->istats.ipOutDiscards++; netlog(f, Logip, "%V seglen < 8\n", eh->dst);
1997/0327		goto raise; } dlen = len - IPHDR; xp = bp; if(gating) lid = nhgets(eh->id); else
1998/0313		lid = ip->id++;
1997/0327		offset = IPHDR; while(xp != nil && offset && offset >= BLEN(xp)) { offset -= BLEN(xp); xp = xp->next; } xp->rp += offset; for(fragoff = 0; fragoff < dlen; fragoff += seglen) { nb = allocb(IPHDR+seglen); feh = (Iphdr*)(nb->rp); memmove(nb->wp, eh, IPHDR); nb->wp += 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 + IPHDR); hnputs(feh->id, lid); /* Copy up the data area */ chunk = seglen; while(chunk) { if(!xp) {
1998/0313		ip->istats.ipOutDiscards++;
1997/0327		freeblist(nb);
1998/0313		netlog(f, Logip, "!xp: chunk %d\n", chunk);
1997/0327		goto raise; } blklen = chunk; if(BLEN(xp) < chunk) blklen = BLEN(xp); memmove(nb->wp, xp->rp, blklen); nb->wp += blklen; xp->rp += blklen; chunk -= blklen; if(xp->rp == xp->wp) xp = xp->next;
1998/0313		}
1997/0327		feh->cksum[0] = 0; feh->cksum[1] = 0; hnputs(feh->cksum, ipcsum(&feh->vihl));
1998/0306		ifc->m->bwrite(ifc, nb, V4, gate);
1998/0313		ip->istats.ipFragCreates++;
1997/0327		} raise:
1998/0307		runlock(ifc); poperror();
1998/0308		free:
1997/0327		freeblist(bp); } void
1998/0313		initfrag(IP *ip, int size)
1997/0327		{ Fragment *fq, *eq;
1998/0313		ip->fragfree = (Fragment*)malloc(sizeof(Fragment) * size); if(ip->fragfree == nil)
1997/0327		panic("initfrag");
1998/0313		eq = &ip->fragfree[size]; for(fq = ip->fragfree; fq < eq; fq++)
1997/0327		fq->next = fq+1;
1998/0313		ip->fragfree[size-1].next = nil;
1997/0327		}
1998/0313		#define DBG(x) if((logmask & Logipmsg) && (iponly == 0 || x == iponly))netlog
1997/0327		void
1998/0313		ipiput(Fs *f, uchar *ia, Block *bp)
1997/0327		{
1998/0313		int hl;
1997/0327		Iphdr *h; Proto *p; ushort frag; int notforme;
1998/0313		uchar *dp, v6dst[IPaddrlen]; IP *ip;
1997/0327
1998/0313		ip = f->ip; ip->istats.ipInReceives++;
1997/0806		// h = (Iphdr *)(bp->rp);
1998/0313		// DBG(nhgetl(h->src))(Logipmsg, "ipiput %V %V len %d proto %d\n", // h->src, h->dst, BLEN(bp), h->proto);
1997/0327		/* Ensure we have enough data to process */ if(BLEN(bp) < IPHDR) { bp = pullupblock(bp, IPHDR); if(bp == nil) return; } h = (Iphdr *)(bp->rp);
1998/0306		/* dump anything that whose header doesn't checksum */
1997/0327		if(ipcsum(&h->vihl)) {
1998/0313		ip->istats.ipInHdrErrors++; netlog(f, Logip, "ip: checksum error %I\n", h->src);
1997/0327		freeblist(bp); return; }
1998/0306		v4tov6(v6dst, h->dst);
1998/0313		notforme = ipforme(f, v6dst) == 0; /* Check header length and version */ if(h->vihl != (IP_VER|IP_HLEN)) { hl = (h->vihl&0xF)<<2; if((h->vihl&0xF0) != IP_VER || hl < (IP_HLEN<<2)) { ip->istats.ipInHdrErrors++; netlog(f, Logip, "ip: %V bad hivl %ux\n", h->src, h->vihl); freeblist(bp); return; } /* If this is not routed strip off the options */ if(notforme == 0) { dp = bp->rp + (hl - (IP_HLEN<<2)); memmove(dp, h, IP_HLEN<<2); bp->rp = dp; h = (Iphdr *)(bp->rp); h->vihl = (IP_VER|IP_HLEN); } } /* route */
1998/0306		if(notforme) {
1998/0313		if(ip->iprouting) {
1998/0306		/* gate */ if(h->ttl <= 1) freeblist(bp);
1998/0313		else { ip->istats.ipForwDatagrams++; ipoput(f, bp, 1, h->ttl - 1); }
1998/0306		} else
1998/0313		useriprouter(f, ia, bp);
1998/0306		return; }
1998/0313
1997/0327		frag = nhgets(h->frag); if(frag) { h->tos = 0; if(frag & IP_MF) h->tos = 1;
1998/0313		bp = ipreassemble(ip, frag, bp, h);
1997/0327		if(bp == nil) return; h = (Iphdr *)(bp->rp); }
1998/0313		p = Fsrcvpcol(f, h->proto); if(p != nil && p->rcv != nil) { ip->istats.ipInDelivers++; (*p->rcv)(p, ia, bp); return; } ip->istats.ipInDiscards++; ip->istats.ipInUnknownProtos++; freeblist(bp);
1997/0327		} int
1998/0313		ipstats(Fs *f, char *buf, int len)
1997/0327		{
1998/0313		IP *ip;
1997/0327
1998/0313		ip = f->ip; return snprint(buf, len, "%d %d %d %d %d %d %d %d %d %d " "%d %d %d %d %d %d %d %d %d", ip->istats.ipForwarding, ip->istats.ipDefaultTTL, ip->istats.ipInReceives, ip->istats.ipInHdrErrors, ip->istats.ipInAddrErrors, ip->istats.ipForwDatagrams, ip->istats.ipInUnknownProtos, ip->istats.ipInDiscards, ip->istats.ipInDelivers, ip->istats.ipOutRequests, ip->istats.ipOutDiscards, ip->istats.ipOutNoRoutes, ip->istats.ipReasmTimeout, ip->istats.ipReasmReqds, ip->istats.ipReasmOKs, ip->istats.ipReasmFails, ip->istats.ipFragOKs, ip->istats.ipFragFails, ip->istats.ipFragCreates);
1997/0327		} Block*
1998/0313		ipreassemble(IP *ip, int offset, Block *bp, Iphdr *ih)
1997/0327		{ int fend; ushort id; Fragment *f, *fnext;
1998/0306		ulong src, dst;
1997/0327		Block *bl, **l, *last, *prev; int ovlap, len, fragsize, pktposn;
1998/0313		src = nhgetl(ih->src); dst = nhgetl(ih->dst); id = nhgets(ih->id);
1997/0327		/* * block lists are too hard, pullupblock into a single block */ if(bp->next){ bp = pullupblock(bp, blocklen(bp));
1998/0313		ih = (Iphdr *)(bp->rp);
1997/0327		}
1998/0313		qlock(&ip->fraglock);
1997/0327		/* * find a reassembly queue for this fragment */
1998/0313		for(f = ip->flisthead; f; f = fnext){
1997/0327		fnext = f->next; /* because ipfragfree changes the list */ if(f->src == src && f->dst == dst && f->id == id) break;
1997/0916		if(f->age < msec){
1998/0313		ip->istats.ipReasmTimeout++; ipfragfree(ip, f);
1997/0916		}
1997/0327		} /* * if this isn't a fragmented packet, accept it * and get rid of any fragments that might go * with it. */
1998/0313		if(!ih->tos && (offset & ~(IP_MF|IP_DF)) == 0) { if(f != nil) { ipfragfree(ip, f); ip->istats.ipReasmFails++; } qunlock(&ip->fraglock);
1997/0327		return bp; }
1997/0504		if(bp->base+sizeof(Ipfrag) >= bp->rp){ bp = padblock(bp, sizeof(Ipfrag)); bp->rp += sizeof(Ipfrag); }
1997/0327		BKFG(bp)->foff = offset<<3;
1998/0313		BKFG(bp)->flen = nhgets(ih->length)-IPHDR;
1997/0327		/* First fragment allocates a reassembly queue */ if(f == nil) {
1998/0313		f = ipfragallo(ip);
1997/0327		f->id = id; f->src = src; f->dst = dst; f->blist = bp;
1998/0313		qunlock(&ip->fraglock); ip->istats.ipReasmReqds++;
1997/0327		return nil; } /* * find the new fragment's position in the queue */ prev = nil; l = &f->blist; bl = f->blist; while(bl != nil && BKFG(bp)->foff > BKFG(bl)->foff) { prev = bl; l = &bl->next; bl = bl->next; } /* Check overlap of a previous fragment - trim away as necessary */ if(prev) { ovlap = BKFG(prev)->foff + BKFG(prev)->flen - BKFG(bp)->foff; if(ovlap > 0) { if(ovlap >= BKFG(bp)->flen) { freeblist(bp);
1998/0313		qunlock(&ip->fraglock);
1997/0327		return nil; } BKFG(prev)->flen -= ovlap; } } /* Link onto assembly queue */ bp->next = *l; *l = bp; /* Check to see if succeeding segments overlap */ if(bp->next) { l = &bp->next; fend = BKFG(bp)->foff + BKFG(bp)->flen; /* Take completely covered segments out */ while(*l) { ovlap = fend - BKFG(*l)->foff; if(ovlap <= 0) break; if(ovlap < BKFG(*l)->flen) { BKFG(*l)->flen -= ovlap; BKFG(*l)->foff += ovlap;
1998/0313		/* move up ih hdrs */
1997/0327		memmove((*l)->rp + ovlap, (*l)->rp, IPHDR); (*l)->rp += ovlap; break; } last = (*l)->next; (*l)->next = nil; freeblist(*l); *l = last; } } /* * look for a complete packet. if we get to a fragment * without IP_MF set, we're done. */ pktposn = 0; for(bl = f->blist; bl; bl = bl->next) { if(BKFG(bl)->foff != pktposn) break; if((BLKIP(bl)->frag[0]&(IP_MF>>8)) == 0) { bl = f->blist; len = nhgets(BLKIP(bl)->length); bl->wp = bl->rp + len; /* Pullup all the fragment headers and * return a complete packet */ for(bl = bl->next; bl; bl = bl->next) { fragsize = BKFG(bl)->flen; len += fragsize; bl->rp += IPHDR; bl->wp = bl->rp + fragsize; } bl = f->blist; f->blist = nil;
1998/0313		ipfragfree(ip, f); ih = BLKIP(bl); hnputs(ih->length, len); qunlock(&ip->fraglock); ip->istats.ipReasmOKs++;
1997/0327		return bl; } pktposn += BKFG(bl)->flen; }
1998/0313		qunlock(&ip->fraglock);
1997/0327		return nil; } /*
1997/0529		* ipfragfree - Free a list of fragments - assume hold fraglock
1997/0327		*/ void
1998/0313		ipfragfree(IP *ip, Fragment *frag)
1997/0327		{ Fragment *fl, **l; if(frag->blist) freeblist(frag->blist); frag->src = 0; frag->id = 0; frag->blist = nil;
1998/0313		l = &ip->flisthead;
1997/0327		for(fl = *l; fl; fl = fl->next) { if(fl == frag) { *l = frag->next; break; } l = &fl->next; }
1998/0313		frag->next = ip->fragfree; ip->fragfree = frag;
1997/0327		} /*
1997/0529		* ipfragallo - allocate a reassembly queue - assume hold fraglock
1997/0327		*/ Fragment *
1998/0313		ipfragallo(IP *ip)
1997/0327		{ Fragment *f;
1998/0313		while(ip->fragfree == nil) {
1997/0529		/* free last entry on fraglist */
1998/0313		for(f = ip->flisthead; f->next; f = f->next)
1997/0529		;
1998/0313		ipfragfree(ip, f);
1997/0327		}
1998/0313		f = ip->fragfree; ip->fragfree = f->next; f->next = ip->flisthead; ip->flisthead = f;
1997/0327		f->age = msec + 30000; return f; } ushort
1998/0306		ipcsum(uchar *addr)
1997/0327		{ int len; ulong sum; 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); }