1999/0930/port/devbridge.c (diff list | history)

port/devbridge.c on 1999/0316
1999/0316		#include "u.h" #include "../port/lib.h" #include "mem.h" #include "dat.h" #include "fns.h" #include "../port/netif.h" #include "../port/error.h" typedef struct Bridge Bridge; typedef struct Port Port; typedef struct Centry Centry;
1999/0826		typedef struct Iphdr Iphdr; typedef struct Tcphdr Tcphdr;
1999/0316		enum { Qtopdir= 1, /* top level directory */ Qbridgedir, /* bridge* directory */ Qbctl, Qstats, Qcache, Qlog, Qportdir, /* directory for a protocol */ Qpctl, Qlocal, Qstatus, MaxQ, Maxbridge= 4, Maxport= 16, // power of 2 CacheHash= 257, // prime CacheLook= 5, // how many cache entries to examine CacheSize= (CacheHash+CacheLook-1), CacheTimeout= 5*60, // timeout for cache entry in seconds
1999/0826		TcpMssMax = 1400, // max desirable Tcp MSS value
1999/0316		};
1999/0824		static Dirtab bridgedirtab[]={
1999/0316		"ctl", {Qbctl}, 0, 0666, "stats", {Qstats}, 0, 0444, "cache", {Qcache}, 0, 0444, "log", {Qlog}, 0, 0666, };
1999/0824		static Dirtab portdirtab[]={
1999/0316		"ctl", {Qpctl}, 0, 0666, "local", {Qlocal}, 0, 0444, "status", {Qstatus}, 0, 0444, }; enum { Logcache= (1<<0), Logmcast= (1<<1), }; // types of interfaces enum { Tether,
1999/0807		Ttun,
1999/0316		}; static Logflag logflags[] = { { "cache", Logcache, }, { "multicast", Logmcast, }, { nil, 0, }, }; static Dirtab *dirtab[MaxQ]; #define TYPE(x) ((x).path & 0xff) #define PORT(x) (((x).path >> 8)&(Maxport-1)) #define QID(x, y) (((x)<<8) | (y)) struct Centry { uchar d[Eaddrlen]; int port; long expire; // entry expires this number of seconds after bootime long src; long dst; }; struct Bridge { QLock; int nport; Port *port[Maxport]; Centry cache[CacheSize];
1999/0901		ulong hit; ulong miss; ulong copy;
1999/0826		int tcpmss; // modify tcpmss value
1999/0316		Log; }; struct Port { int id; Bridge *bridge; int ref; int closed; Chan *data[2]; // channel to data int mcast; // send multi cast packets
1999/0826
1999/0316		Proc *readp; // read proc // the following uniquely identifies the port int type;
1999/0914		char name[NAMELEN];
1999/0316		// owner hash - avoids bind/unbind races ulong ownhash; // various stats int in; // number of packets read int inmulti; // multicast or broadcast int inunknown; // unknown address int out; // number of packets read int outmulti; // multicast or broadcast int outunknown; // unknown address int nentry; // number of cache entries for this port };
1999/0826		enum { IP_VER = 0x40, /* Using IP version 4 */ IP_HLEN = 0x05, /* Header length in characters */ IP_TCPPROTO = 6,
1999/0827		EOLOPT = 0, NOOPOPT = 1,
1999/0826		MSSOPT = 2, MSS_LENGTH = 4, /* Mean segment size */
1999/0827		SYN = 0x02, /* Pkt. is synchronise */
1999/0826		}; struct Iphdr { uchar vihl; /* Version and header length */ uchar tos; /* Type of service */ uchar length[2]; /* packet length */ uchar id[2]; /* ip->identification */ uchar frag[2]; /* Fragment information */ uchar ttl; /* Time to live */ uchar proto; /* Protocol */ uchar cksum[2]; /* Header checksum */ uchar src[4]; /* IP source */ uchar dst[4]; /* IP destination */ }; struct Tcphdr { uchar sport[2]; uchar dport[2]; uchar seq[4]; uchar ack[4]; uchar flag[2]; uchar win[2]; uchar cksum[2]; uchar urg[2]; };
1999/0316		static Bridge bridgetab[Maxbridge]; static int m2p[] = { [OREAD] 4, [OWRITE] 2, [ORDWR] 6 }; static int bridgegen(Chan *c, Dirtab*, int, int s, Dir *dp); static void portbind(Bridge *b, int argc, char *argv[]); static void portunbind(Bridge *b, int argc, char *argv[]); static void etherread(void *a); static char *cachedump(Bridge *b); static void portfree(Port *port); static void cacheflushport(Bridge *b, int port); extern ulong parseip(uchar*, char*); static void bridgeinit(void) { int i; Dirtab *dt; // setup dirtab with non directory entries for(i=0; i<nelem(bridgedirtab); i++) { dt = bridgedirtab + i; dirtab[TYPE(dt->qid)] = dt; } for(i=0; i<nelem(portdirtab); i++) { dt = portdirtab + i; dirtab[TYPE(dt->qid)] = dt; } } static Chan* bridgeattach(char* spec) { Chan *c; int dev; dev = atoi(spec); if(dev<0 || dev >= Maxbridge) error("bad specification"); c = devattach('B', spec); c->qid = (Qid){QID(0, Qtopdir)|CHDIR, 0}; c->dev = dev; return c; } static int bridgewalk(Chan *c, char *name) { if(strcmp(name, "..") == 0){ switch(TYPE(c->qid)){ case Qtopdir: case Qbridgedir: c->qid = (Qid){CHDIR|Qtopdir, 0}; break; case Qportdir: c->qid = (Qid){CHDIR|Qbridgedir, 0}; break; default: panic("bridgewalk %lux", c->qid.path); } return 1; } return devwalk(c, name, 0, 0, bridgegen); } static void bridgestat(Chan* c, char* db) { devstat(c, db, nil, 0, bridgegen); } static Chan* bridgeopen(Chan* c, int omode) { int perm; Bridge *b; omode &= 3; perm = m2p[omode]; USED(perm); b = bridgetab + c->dev; USED(b); switch(TYPE(c->qid)) { default: break; case Qtopdir: case Qbridgedir: case Qportdir: case Qstatus: case Qlocal: case Qstats: if(omode != OREAD) error(Eperm); break; case Qlog: logopen(b); break; case Qcache: if(omode != OREAD) error(Eperm); c->aux = cachedump(b); break; } c->mode = openmode(omode); c->flag |= COPEN; c->offset = 0; return c; } static void bridgeclose(Chan* c) { Bridge *b = bridgetab + c->dev; switch(TYPE(c->qid)) { case Qcache: if(c->flag & COPEN) free(c->aux); break; case Qlog: if(c->flag & COPEN) logclose(b); break; } } static long bridgeread(Chan *c, void *a, long n, vlong off) { char buf[256]; Bridge *b = bridgetab + c->dev; Port *port;
1999/0731		int i, ingood, outgood;
1999/0316		USED(off); switch(TYPE(c->qid)) { default: error(Eperm); case Qtopdir: case Qbridgedir: case Qportdir: return devdirread(c, a, n, 0, 0, bridgegen); case Qlog: return logread(b, a, off, n); case Qstatus: qlock(b); port = b->port[PORT(c->qid)]; if(port == 0) strcpy(buf, "unbound\n"); else { i = 0; switch(port->type) { default: panic("bridgeread: unknown port type: %d", port->type); case Tether:
1999/0914		i += snprint(buf+i, sizeof(buf)-i, "ether %s: ", port->name);
1999/0316		break;
1999/0807		case Ttun:
1999/0914		i += snprint(buf+i, sizeof(buf)-i, "tunnel %s: ", port->name);
1999/0316		break; }
1999/0731		ingood = port->in-port->inmulti-port->inunknown; outgood = port->out-port->outmulti-port->outunknown; i += snprint(buf+i, sizeof(buf)-i, "in=%d(%d:%d:%d) out=%d(%d:%d:%d)\n", port->in, ingood, port->inmulti, port->inunknown, port->out, outgood, port->outmulti, port->outunknown);
1999/0316		USED(i); } n = readstr(off, a, n, buf); qunlock(b); return n; case Qcache: n = readstr(off, a, n, c->aux); return n;
1999/0901		case Qstats: snprint(buf, sizeof(buf), "hit=%uld miss=%uld copy=%uld\n", b->hit, b->miss, b->copy); n = readstr(off, a, n, buf); return n;
1999/0316		} }
1999/0826		static void bridgeoption(Bridge *b, char *option, int value) { if(strcmp(option, "tcpmss") == 0) b->tcpmss = value; else error("unknown bridge option"); }
1999/0316		static long bridgewrite(Chan *c, void *a, long n, vlong off) { Bridge *b = bridgetab + c->dev; Cmdbuf *cb; char *arg0; char *p; USED(off); switch(TYPE(c->qid)) { default: error(Eperm); case Qbctl: cb = parsecmd(a, n); qlock(b); if(waserror()) { qunlock(b); free(cb); nexterror(); } if(cb->nf == 0) error("short write"); arg0 = cb->f[0];
1999/0826		if(strcmp(arg0, "bind") == 0) {
1999/0316		portbind(b, cb->nf-1, cb->f+1);
1999/0826		} else if(strcmp(arg0, "unbind") == 0) {
1999/0316		portunbind(b, cb->nf-1, cb->f+1);
1999/0826		} else if(strcmp(arg0, "cacheflush") == 0) {
1999/0316		log(b, Logcache, "cache flush\n"); memset(b->cache, 0, CacheSize*sizeof(Centry));
1999/0826		} else if(strcmp(arg0, "set") == 0) { if(cb->nf != 2) error("usage: set option"); bridgeoption(b, cb->f[1], 1); } else if(strcmp(arg0, "clear") == 0) { if(cb->nf != 2) error("usage: clear option"); bridgeoption(b, cb->f[1], 0);
1999/0316		} else error("unknown control request"); poperror(); qunlock(b); free(cb); return n; case Qlog: cb = parsecmd(a, n); p = logctl(b, cb->nf, cb->f, logflags); free(cb); if(p != nil) error(p); return n; } } static int bridgegen(Chan *c, Dirtab*, int, int s, Dir *dp) { Bridge *b = bridgetab + c->dev; int type = TYPE(c->qid); char buf[32]; Dirtab *dt; Qid qid; switch(type) { default: // non directory entries end up here if(c->qid.path & CHDIR) panic("bridgegen: unexpected directory"); if(s != 0) return -1; dt = dirtab[TYPE(c->qid)]; if(dt == nil) panic("bridgegen: unknown type: %d", TYPE(c->qid)); devdir(c, c->qid, dt->name, dt->length, eve, dt->perm, dp); return 1; case Qtopdir: if(s != 0) return -1; sprint(buf, "bridge%ld", c->dev); devdir(c, (Qid){QID(0,Qbridgedir)|CHDIR,0}, buf, 0, eve, 0555, dp); return 1; case Qbridgedir: if(s<nelem(bridgedirtab)) { dt = bridgedirtab+s; devdir(c, dt->qid, dt->name, dt->length, eve, dt->perm, dp); return 1; } s -= nelem(bridgedirtab); if(s >= b->nport) return -1; qid = (Qid){QID(s,Qportdir)|CHDIR, 0}; snprint(buf, sizeof(buf), "%d", s); devdir(c, qid, buf, 0, eve, 0555, dp); return 1; case Qportdir: if(s>=nelem(portdirtab)) return -1; dt = portdirtab+s; qid = (Qid){QID(PORT(c->qid),TYPE(dt->qid)),0}; devdir(c, qid, dt->name, dt->length, eve, dt->perm, dp); return 1; } } // also in netif.c static int parseaddr(uchar *to, char *from, int alen) { char nip[4]; char *p; int i; p = from; for(i = 0; i < alen; i++){ if(*p == 0) return -1; nip[0] = *p++; if(*p == 0) return -1; nip[1] = *p++; nip[2] = 0; to[i] = strtoul(nip, 0, 16); if(*p == ':') p++; } return 0; } // assumes b is locked static void portbind(Bridge *b, int argc, char *argv[]) { Port *port; char path[8*NAMELEN]; char buf[100]; char *dev, *dev2=nil, *p; Chan *ctl; int type=0, i, n;
1999/0914		char *usage = "usage: bind ether|tunnel name ownhash dev [dev2]"; char name[NAMELEN];
1999/0316		ulong ownhash;
1999/0914		memset(name, 0, NAMELEN);
1999/0316		if(argc < 4) error(usage); if(strcmp(argv[0], "ether") == 0) { if(argc != 4) error(usage); type = Tether;
1999/0914		strncpy(name, argv[1], NAMELEN); name[NAMELEN-1] = 0; // parseaddr(addr, argv[1], Eaddrlen);
1999/0316		} else if(strcmp(argv[0], "tunnel") == 0) { if(argc != 5) error(usage);
1999/0807		type = Ttun;
1999/0914		strncpy(name, argv[1], NAMELEN); name[NAMELEN-1] = 0; // parseip(addr, argv[1]);
1999/0316		dev2 = argv[4]; } else error(usage); ownhash = atoi(argv[2]); dev = argv[3]; for(i=0; i<b->nport; i++) { port = b->port[i]; if(port != nil) if(port->type == type)
1999/0914		if(memcmp(port->name, name, NAMELEN) == 0)
1999/0316		error("port in use"); } for(i=0; i<Maxport; i++) if(b->port[i] == nil) break; if(i == Maxport) error("no more ports"); port = smalloc(sizeof(Port)); port->ref = 1; port->id = i; port->ownhash = ownhash; if(waserror()) { portfree(port); nexterror(); } port->type = type;
1999/0914		memmove(port->name, name, NAMELEN);
1999/0316		switch(port->type) { default: panic("portbind: unknown port type: %d", type); case Tether: snprint(path, sizeof(path), "%s/clone", dev); ctl = namec(path, Aopen, ORDWR, 0); if(waserror()) { cclose(ctl); nexterror(); } // check addr? // get directory name n = devtab[ctl->type]->read(ctl, buf, sizeof(buf), 0); buf[n] = 0; for(p = buf; *p == ' '; p++) ; snprint(path, sizeof(path), "%s/%lud/data", dev, strtoul(p, 0, 0)); // setup connection to be promiscuous snprint(buf, sizeof(buf), "connect -1"); devtab[ctl->type]->write(ctl, buf, strlen(buf), 0); snprint(buf, sizeof(buf), "promiscuous"); devtab[ctl->type]->write(ctl, buf, strlen(buf), 0);
1999/0625		snprint(buf, sizeof(buf), "bridge"); devtab[ctl->type]->write(ctl, buf, strlen(buf), 0);
1999/0316		// open data port port->data[0] = namec(path, Aopen, ORDWR, 0); // dup it incref(port->data[0]); port->data[1] = port->data[0]; poperror(); cclose(ctl); break;
1999/0807		case Ttun:
1999/0316		port->data[0] = namec(dev, Aopen, OREAD, 0); port->data[1] = namec(dev2, Aopen, OWRITE, 0); break; } poperror(); // commited to binding port b->port[port->id] = port; port->bridge = b; if(b->nport <= port->id) b->nport = port->id+1; // assumes kproc always succeeds kproc("etherread", etherread, port); // poperror must be next
1999/0915		port->ref++;
1999/0316		} // assumes b is locked static void portunbind(Bridge *b, int argc, char *argv[]) { Port *port=nil; int type=0, i; char *usage = "usage: unbind ether|tunnel addr [ownhash]";
1999/0914		char name[NAMELEN];
1999/0316		ulong ownhash;
1999/0914		memset(name, 0, NAMELEN);
1999/0316		if(argc < 2 || argc > 3) error(usage); if(strcmp(argv[0], "ether") == 0) { type = Tether;
1999/0914		strncpy(name, argv[1], NAMELEN); name[NAMELEN-1] = 0; // parseaddr(addr, argv[1], Eaddrlen);
1999/0316		} else if(strcmp(argv[0], "tunnel") == 0) {
1999/0807		type = Ttun;
1999/0914		strncpy(name, argv[1], NAMELEN); name[NAMELEN-1] = 0; // parseip(addr, argv[1]);
1999/0316		} else error(usage); if(argc == 3) ownhash = atoi(argv[2]); else ownhash = 0; for(i=0; i<b->nport; i++) { port = b->port[i]; if(port != nil) if(port->type == type)
1999/0914		if(memcmp(port->name, name, NAMELEN) == 0)
1999/0316		break; } if(i == b->nport) error("port not found"); if(ownhash != 0 && port->ownhash != 0 && ownhash != port->ownhash) error("bad owner hash"); port->closed = 1; b->port[i] = nil; // port is now unbound cacheflushport(b, i); // try and stop reader if(port->readp) postnote(port->readp, 1, "unbind", 0); portfree(port); } // assumes b is locked static Centry * cachelookup(Bridge *b, uchar d[Eaddrlen]) { int i; uint h; Centry *p; long sec; // dont cache multicast or broadcast if(d[0] & 1) return 0; h = 0; for(i=0; i<Eaddrlen; i++) { h *= 7; h += d[i]; } h %= CacheHash; p = b->cache + h; sec = TK2SEC(m->ticks); for(i=0; i<CacheLook; i++,p++) { if(memcmp(d, p->d, Eaddrlen) == 0) { p->dst++; if(sec >= p->expire) { log(b, Logcache, "expired cache entry: %E %d\n", d, p->port); return nil; } p->expire = sec + CacheTimeout; return p; } } log(b, Logcache, "cache miss: %E\n", d); return nil; } // assumes b is locked static void cacheupdate(Bridge *b, uchar d[Eaddrlen], int port) { int i; uint h; Centry *p, *pp; long sec; // dont cache multicast or broadcast if(d[0] & 1) { log(b, Logcache, "bad source address: %E\n", d); return; } h = 0; for(i=0; i<Eaddrlen; i++) { h *= 7; h += d[i]; } h %= CacheHash; p = b->cache + h; pp = p; sec = p->expire; // look for oldest entry for(i=0; i<CacheLook; i++,p++) { if(memcmp(p->d, d, Eaddrlen) == 0) { p->expire = TK2SEC(m->ticks) + CacheTimeout; if(p->port != port) { log(b, Logcache, "NIC changed port %d->%d: %E\n", p->port, port, d); p->port = port; } p->src++; return; } if(p->expire < sec) { sec = p->expire; pp = p; } } if(pp->expire != 0) log(b, Logcache, "bumping from cache: %E %d\n", pp->d, pp->port); pp->expire = TK2SEC(m->ticks) + CacheTimeout; memmove(pp->d, d, Eaddrlen); pp->port = port; pp->src = 1; pp->dst = 0; log(b, Logcache, "adding to cache: %E %d\n", pp->d, pp->port); } // assumes b is locked static void cacheflushport(Bridge *b, int port) { Centry *ce; int i; ce = b->cache; for(i=0; i<CacheSize; i++,ce++) { if(ce->port != port) continue; memset(ce, 0, sizeof(Centry)); } } static char * cachedump(Bridge *b) { int i, n; long sec, off; char *buf, *p, *ep; Centry *ce; char c; qlock(b); if(waserror()) { qunlock(b); nexterror(); } sec = TK2SEC(m->ticks); n = 0; for(i=0; i<CacheSize; i++) if(b->cache[i].expire != 0) n++; n *= 51; // change if print format is changed n += 10; // some slop at the end buf = malloc(n); p = buf; ep = buf + n; ce = b->cache; off = seconds() - sec; for(i=0; i<CacheSize; i++,ce++) { if(ce->expire == 0) continue; c = (sec < ce->expire)?'v':'e'; p += snprint(p, ep-p, "%E %2d %10ld %10ld %10ld %c\n", ce->d, ce->port, ce->src, ce->dst, ce->expire+off, c); } *p = 0; poperror(); qunlock(b); return buf; } // assumes b is locked static void ethermultiwrite(Bridge *b, Block *bp, Port *port) { Chan *c; Block *bp2; Etherpkt *ep; int i, mcast, bcast; static uchar bcastaddr[Eaddrlen] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; if(waserror()) { if(bp) freeb(bp); nexterror(); } ep = (Etherpkt*)bp->rp; mcast = ep->d[0] & 1; if(mcast) bcast = memcmp(ep->d, bcastaddr, Eaddrlen) == 0; else bcast = 0; c = nil; for(i=0; i<b->nport; i++) { if(i == port->id || b->port[i] == nil) continue; if(mcast && !bcast && !b->port[i]->mcast) continue; b->port[i]->out++; if(mcast) b->port[i]->outmulti++; else b->port[i]->outunknown++; // delay one so that the last write does not copy if(c != nil) {
1999/0901		b->copy++;
1999/0316		bp2 = copyblock(bp, blocklen(bp));
1999/0915		if(!waserror()) { devtab[c->type]->bwrite(c, bp2, 0); poperror(); }
1999/0316		} c = b->port[i]->data[1]; } // last write free block if(c) { bp2 = bp; bp = nil; USED(bp);
1999/0915		if(!waserror()) { devtab[c->type]->bwrite(c, bp2, 0); poperror(); }
1999/0316		} else freeb(bp); poperror(); }
1999/0826		static void
1999/0827		tcpmsshack(Etherpkt *epkt, int n)
1999/0826		{ int hl; Iphdr *iphdr; Tcphdr *tcphdr;
1999/0827		ulong mss; ulong cksum; int optlen; uchar *optr;
1999/0826		// check it is an ip packet if(nhgets(epkt->type) != 0x800) return;
1999/0827		iphdr = (Iphdr*)(epkt->data);
1999/0826		n -= ETHERHDRSIZE; if(n < sizeof(Iphdr)) return; // check it is ok IP packet if(iphdr->vihl != (IP_VER|IP_HLEN)) { hl = (iphdr->vihl&0xF)<<2; if((iphdr->vihl&0xF0) != IP_VER || hl < (IP_HLEN<<2)) return;
1999/0827		} else
1999/0826		hl = IP_HLEN<<2; // check TCP if(iphdr->proto != IP_TCPPROTO) return; n -= hl; if(n < sizeof(Tcphdr)) return;
1999/0827		tcphdr = (Tcphdr*)((uchar*)(iphdr) + hl); // MSS can only appear in SYN packet if(!(tcphdr->flag[1] & SYN)) return;
1999/0826		hl = (tcphdr->flag[0] & 0xf0)>>2;
1999/0827		if(n < hl)
1999/0826		return;
1999/0827
1999/0826		// check for MSS option
1999/0827		optr = (uchar*)(tcphdr) + sizeof(Tcphdr); n = hl - sizeof(Tcphdr); for(;;) { if(n <= 0 || *optr == EOLOPT)
1999/0826		return;
1999/0827		if(*optr == NOOPOPT) { n--; optr++; continue; } optlen = optr[1]; if(optlen < 2 || optlen > n) return; if(*optr == MSSOPT && optlen == MSS_LENGTH) break; n -= optlen; optr += optlen; } mss = nhgets(optr+2); if(mss <= TcpMssMax) return; // fit checksum cksum = nhgets(tcphdr->cksum); if(optr-(uchar*)tcphdr & 1) { print("tcpmsshack: odd alignment!\n"); // odd alignments are a pain cksum += nhgets(optr+1); cksum -= (optr[1]<<8)|(TcpMssMax>>8); cksum += (cksum>>16); cksum &= 0xffff; cksum += nhgets(optr+3); cksum -= ((TcpMssMax&0xff)<<8)|optr[4]; cksum += (cksum>>16); } else { cksum += mss; cksum -= TcpMssMax; cksum += (cksum>>16); } hnputs(tcphdr->cksum, cksum); hnputs(optr+2, TcpMssMax);
1999/0826		}
1999/0316		/* * process to read from the ethernet */ static void etherread(void *a) { Port *port = a, *oport; Bridge *b = port->bridge; Block *bp, *bp2; Etherpkt *ep; Centry *ce; qlock(b); port->readp = up; /* hide identity under a rock for unbind */ while(!port->closed){ // release lock to read - error means it is time to quit qunlock(b); if(waserror()) {
1999/0915		print("etherread read error\n");
1999/0316		qlock(b); break; }
1999/0826		if(0)print("devbridge: etherread: reading\n");
1999/0316		bp = devtab[port->data[0]->type]->bread(port->data[0], ETHERMAXTU, 0);
1999/0826		if(0)print("devbridge: etherread: blocklen = %d\n", blocklen(bp));
1999/0316		poperror(); qlock(b);
1999/0930		if(bp == nil || port->closed)
1999/0316		break; if(waserror()) {
1999/0915		print("etherread bridge error\n");
1999/0316		if(bp) freeb(bp); continue; } if(blocklen(bp) < ETHERMINTU) error("short packet"); port->in++;
1999/0827
1999/0316		ep = (Etherpkt*)bp->rp; cacheupdate(b, ep->s, port->id);
1999/0827		if(b->tcpmss) tcpmsshack(ep, BLEN(bp));
1999/0316		if(ep->d[0] & 1) { log(b, Logmcast, "mulitcast: port=%d src=%E dst=%E type=%#.4ux\n", port->id, ep->s, ep->d, (ep->type[0]<<8)|ep->type[1] ); port->inmulti++; bp2 = bp; bp = nil; ethermultiwrite(b, bp2, port); } else { ce = cachelookup(b, ep->d); if(ce == nil) { b->miss++; port->inunknown++;
1999/0826		bp2 = bp; bp = nil; ethermultiwrite(b, bp2, port);
1999/0316		} else if (ce->port != port->id) { b->hit++; bp2 = bp; bp = nil; oport = b->port[ce->port]; oport->out++; devtab[oport->data[1]->type]->bwrite(oport->data[1], bp2, 0); } } poperror(); if(bp) freeb(bp); } print("etherread: trying to exit\n"); port->readp = nil; portfree(port); qunlock(b); pexit("hangup", 1); } // hold b lock static void portfree(Port *port) { port->ref--; if(port->ref < 0) panic("portfree: bad ref"); if(port->ref > 0) return; if(port->data[0]) cclose(port->data[0]); if(port->data[1]) cclose(port->data[1]); memset(port, 0, sizeof(Port)); free(port); } Dev bridgedevtab = { 'B', "bridge", devreset, bridgeinit, bridgeattach, devclone, bridgewalk, bridgestat, bridgeopen, devcreate, bridgeclose, bridgeread, devbread, bridgewrite, devbwrite, devremove, devwstat, };