devbridge.c 23 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195
  1. /*
  2. * IPv4 Ethernet bridge
  3. */
  4. #include "u.h"
  5. #include "../port/lib.h"
  6. #include "mem.h"
  7. #include "dat.h"
  8. #include "fns.h"
  9. #include "../ip/ip.h"
  10. #include "../port/netif.h"
  11. #include "../port/error.h"
  12. typedef struct Bridge Bridge;
  13. typedef struct Port Port;
  14. typedef struct Centry Centry;
  15. typedef struct Iphdr Iphdr;
  16. typedef struct Tcphdr Tcphdr;
  17. enum
  18. {
  19. Qtopdir= 1, /* top level directory */
  20. Qbridgedir, /* bridge* directory */
  21. Qbctl,
  22. Qstats,
  23. Qcache,
  24. Qlog,
  25. Qportdir, /* directory for a protocol */
  26. Qpctl,
  27. Qlocal,
  28. Qstatus,
  29. MaxQ,
  30. Maxbridge= 4,
  31. Maxport= 128, // power of 2
  32. CacheHash= 257, // prime
  33. CacheLook= 5, // how many cache entries to examine
  34. CacheSize= (CacheHash+CacheLook-1),
  35. CacheTimeout= 5*60, // timeout for cache entry in seconds
  36. TcpMssMax = 1300, // max desirable Tcp MSS value
  37. TunnelMtu = 1400,
  38. };
  39. static Dirtab bridgedirtab[]={
  40. "ctl", {Qbctl}, 0, 0666,
  41. "stats", {Qstats}, 0, 0444,
  42. "cache", {Qcache}, 0, 0444,
  43. "log", {Qlog}, 0, 0666,
  44. };
  45. static Dirtab portdirtab[]={
  46. "ctl", {Qpctl}, 0, 0666,
  47. "local", {Qlocal}, 0, 0444,
  48. "status", {Qstatus}, 0, 0444,
  49. };
  50. enum {
  51. Logcache= (1<<0),
  52. Logmcast= (1<<1),
  53. };
  54. // types of interfaces
  55. enum
  56. {
  57. Tether,
  58. Ttun,
  59. };
  60. static Logflag logflags[] =
  61. {
  62. { "cache", Logcache, },
  63. { "multicast", Logmcast, },
  64. { nil, 0, },
  65. };
  66. static Dirtab *dirtab[MaxQ];
  67. #define TYPE(x) (((ulong)(x).path) & 0xff)
  68. #define PORT(x) ((((ulong)(x).path) >> 8)&(Maxport-1))
  69. #define QID(x, y) (((x)<<8) | (y))
  70. struct Centry
  71. {
  72. uchar d[Eaddrlen];
  73. int port;
  74. long expire; // entry expires this many seconds after bootime
  75. long src;
  76. long dst;
  77. };
  78. struct Bridge
  79. {
  80. QLock;
  81. int nport;
  82. Port *port[Maxport];
  83. Centry cache[CacheSize];
  84. ulong hit;
  85. ulong miss;
  86. ulong copy;
  87. long delay0; // constant microsecond delay per packet
  88. long delayn; // microsecond delay per byte
  89. int tcpmss; // modify tcpmss value
  90. Log;
  91. };
  92. struct Port
  93. {
  94. int id;
  95. Bridge *bridge;
  96. int ref;
  97. int closed;
  98. Chan *data[2]; // channel to data
  99. Proc *readp; // read proc
  100. // the following uniquely identifies the port
  101. int type;
  102. char name[KNAMELEN];
  103. // owner hash - avoids bind/unbind races
  104. ulong ownhash;
  105. // various stats
  106. int in; // number of packets read
  107. int inmulti; // multicast or broadcast
  108. int inunknown; // unknown address
  109. int out; // number of packets read
  110. int outmulti; // multicast or broadcast
  111. int outunknown; // unknown address
  112. int outfrag; // fragmented the packet
  113. int nentry; // number of cache entries for this port
  114. };
  115. enum {
  116. IP_TCPPROTO = 6,
  117. EOLOPT = 0,
  118. NOOPOPT = 1,
  119. MSSOPT = 2,
  120. MSS_LENGTH = 4, /* Mean segment size */
  121. SYN = 0x02, /* Pkt. is synchronise */
  122. IPHDR = 20, /* sizeof(Iphdr) */
  123. };
  124. struct Iphdr
  125. {
  126. uchar vihl; /* Version and header length */
  127. uchar tos; /* Type of service */
  128. uchar length[2]; /* packet length */
  129. uchar id[2]; /* ip->identification */
  130. uchar frag[2]; /* Fragment information */
  131. uchar ttl; /* Time to live */
  132. uchar proto; /* Protocol */
  133. uchar cksum[2]; /* Header checksum */
  134. uchar src[4]; /* IP source */
  135. uchar dst[4]; /* IP destination */
  136. };
  137. struct Tcphdr
  138. {
  139. uchar sport[2];
  140. uchar dport[2];
  141. uchar seq[4];
  142. uchar ack[4];
  143. uchar flag[2];
  144. uchar win[2];
  145. uchar cksum[2];
  146. uchar urg[2];
  147. };
  148. static Bridge bridgetab[Maxbridge];
  149. static int m2p[] = {
  150. [OREAD] 4,
  151. [OWRITE] 2,
  152. [ORDWR] 6
  153. };
  154. static int bridgegen(Chan *c, char*, Dirtab*, int, int s, Dir *dp);
  155. static void portbind(Bridge *b, int argc, char *argv[]);
  156. static void portunbind(Bridge *b, int argc, char *argv[]);
  157. static void etherread(void *a);
  158. static char *cachedump(Bridge *b);
  159. static void portfree(Port *port);
  160. static void cacheflushport(Bridge *b, int port);
  161. static void etherwrite(Port *port, Block *bp);
  162. static void
  163. bridgeinit(void)
  164. {
  165. int i;
  166. Dirtab *dt;
  167. // setup dirtab with non directory entries
  168. for(i=0; i<nelem(bridgedirtab); i++) {
  169. dt = bridgedirtab + i;
  170. dirtab[TYPE(dt->qid)] = dt;
  171. }
  172. for(i=0; i<nelem(portdirtab); i++) {
  173. dt = portdirtab + i;
  174. dirtab[TYPE(dt->qid)] = dt;
  175. }
  176. }
  177. static Chan*
  178. bridgeattach(char* spec)
  179. {
  180. Chan *c;
  181. int dev;
  182. dev = atoi(spec);
  183. if(dev<0 || dev >= Maxbridge)
  184. error("bad specification");
  185. c = devattach('B', spec);
  186. mkqid(&c->qid, QID(0, Qtopdir), 0, QTDIR);
  187. c->dev = dev;
  188. return c;
  189. }
  190. static Walkqid*
  191. bridgewalk(Chan *c, Chan *nc, char **name, int nname)
  192. {
  193. return devwalk(c, nc, name, nname, (Dirtab*)0, 0, bridgegen);
  194. }
  195. static int
  196. bridgestat(Chan* c, uchar* db, int n)
  197. {
  198. return devstat(c, db, n, (Dirtab *)0, 0L, bridgegen);
  199. }
  200. static Chan*
  201. bridgeopen(Chan* c, int omode)
  202. {
  203. int perm;
  204. Bridge *b;
  205. omode &= 3;
  206. perm = m2p[omode];
  207. USED(perm);
  208. b = bridgetab + c->dev;
  209. USED(b);
  210. switch(TYPE(c->qid)) {
  211. default:
  212. break;
  213. case Qlog:
  214. logopen(b);
  215. break;
  216. case Qcache:
  217. c->aux = cachedump(b);
  218. break;
  219. }
  220. c->mode = openmode(omode);
  221. c->flag |= COPEN;
  222. c->offset = 0;
  223. return c;
  224. }
  225. static void
  226. bridgeclose(Chan* c)
  227. {
  228. Bridge *b = bridgetab + c->dev;
  229. switch(TYPE(c->qid)) {
  230. case Qcache:
  231. if(c->flag & COPEN)
  232. free(c->aux);
  233. break;
  234. case Qlog:
  235. if(c->flag & COPEN)
  236. logclose(b);
  237. break;
  238. }
  239. }
  240. static long
  241. bridgeread(Chan *c, void *a, long n, vlong off)
  242. {
  243. char buf[256];
  244. Bridge *b = bridgetab + c->dev;
  245. Port *port;
  246. int i, ingood, outgood;
  247. USED(off);
  248. switch(TYPE(c->qid)) {
  249. default:
  250. error(Eperm);
  251. case Qtopdir:
  252. case Qbridgedir:
  253. case Qportdir:
  254. return devdirread(c, a, n, 0, 0, bridgegen);
  255. case Qlog:
  256. return logread(b, a, off, n);
  257. case Qstatus:
  258. qlock(b);
  259. port = b->port[PORT(c->qid)];
  260. if(port == 0)
  261. strcpy(buf, "unbound\n");
  262. else {
  263. i = 0;
  264. switch(port->type) {
  265. default:
  266. panic("bridgeread: unknown port type: %d",
  267. port->type);
  268. case Tether:
  269. i += snprint(buf+i, sizeof(buf)-i, "ether %s: ", port->name);
  270. break;
  271. case Ttun:
  272. i += snprint(buf+i, sizeof(buf)-i, "tunnel %s: ", port->name);
  273. break;
  274. }
  275. ingood = port->in - port->inmulti - port->inunknown;
  276. outgood = port->out - port->outmulti - port->outunknown;
  277. i += snprint(buf+i, sizeof(buf)-i,
  278. "in=%d(%d:%d:%d) out=%d(%d:%d:%d:%d)\n",
  279. port->in, ingood, port->inmulti, port->inunknown,
  280. port->out, outgood, port->outmulti,
  281. port->outunknown, port->outfrag);
  282. USED(i);
  283. }
  284. n = readstr(off, a, n, buf);
  285. qunlock(b);
  286. return n;
  287. case Qbctl:
  288. snprint(buf, sizeof(buf), "%s tcpmss\ndelay %ld %ld\n",
  289. b->tcpmss ? "set" : "clear", b->delay0, b->delayn);
  290. n = readstr(off, a, n, buf);
  291. return n;
  292. case Qcache:
  293. n = readstr(off, a, n, c->aux);
  294. return n;
  295. case Qstats:
  296. snprint(buf, sizeof(buf), "hit=%uld miss=%uld copy=%uld\n",
  297. b->hit, b->miss, b->copy);
  298. n = readstr(off, a, n, buf);
  299. return n;
  300. }
  301. }
  302. static void
  303. bridgeoption(Bridge *b, char *option, int value)
  304. {
  305. if(strcmp(option, "tcpmss") == 0)
  306. b->tcpmss = value;
  307. else
  308. error("unknown bridge option");
  309. }
  310. static long
  311. bridgewrite(Chan *c, void *a, long n, vlong off)
  312. {
  313. Bridge *b = bridgetab + c->dev;
  314. Cmdbuf *cb;
  315. char *arg0, *p;
  316. USED(off);
  317. switch(TYPE(c->qid)) {
  318. default:
  319. error(Eperm);
  320. case Qbctl:
  321. cb = parsecmd(a, n);
  322. qlock(b);
  323. if(waserror()) {
  324. qunlock(b);
  325. free(cb);
  326. nexterror();
  327. }
  328. if(cb->nf == 0)
  329. error("short write");
  330. arg0 = cb->f[0];
  331. if(strcmp(arg0, "bind") == 0) {
  332. portbind(b, cb->nf-1, cb->f+1);
  333. } else if(strcmp(arg0, "unbind") == 0) {
  334. portunbind(b, cb->nf-1, cb->f+1);
  335. } else if(strcmp(arg0, "cacheflush") == 0) {
  336. log(b, Logcache, "cache flush\n");
  337. memset(b->cache, 0, CacheSize*sizeof(Centry));
  338. } else if(strcmp(arg0, "set") == 0) {
  339. if(cb->nf != 2)
  340. error("usage: set option");
  341. bridgeoption(b, cb->f[1], 1);
  342. } else if(strcmp(arg0, "clear") == 0) {
  343. if(cb->nf != 2)
  344. error("usage: clear option");
  345. bridgeoption(b, cb->f[1], 0);
  346. } else if(strcmp(arg0, "delay") == 0) {
  347. if(cb->nf != 3)
  348. error("usage: delay delay0 delayn");
  349. b->delay0 = strtol(cb->f[1], nil, 10);
  350. b->delayn = strtol(cb->f[2], nil, 10);
  351. } else
  352. error("unknown control request");
  353. poperror();
  354. qunlock(b);
  355. free(cb);
  356. return n;
  357. case Qlog:
  358. cb = parsecmd(a, n);
  359. p = logctl(b, cb->nf, cb->f, logflags);
  360. free(cb);
  361. if(p != nil)
  362. error(p);
  363. return n;
  364. }
  365. }
  366. static int
  367. bridgegen(Chan *c, char *, Dirtab*, int, int s, Dir *dp)
  368. {
  369. Bridge *b = bridgetab + c->dev;
  370. int type = TYPE(c->qid);
  371. Dirtab *dt;
  372. Qid qid;
  373. if(s == DEVDOTDOT){
  374. switch(TYPE(c->qid)){
  375. case Qtopdir:
  376. case Qbridgedir:
  377. snprint(up->genbuf, sizeof(up->genbuf), "#B%ld", c->dev);
  378. mkqid(&qid, Qtopdir, 0, QTDIR);
  379. devdir(c, qid, up->genbuf, 0, eve, 0555, dp);
  380. break;
  381. case Qportdir:
  382. snprint(up->genbuf, sizeof(up->genbuf), "bridge%ld", c->dev);
  383. mkqid(&qid, Qbridgedir, 0, QTDIR);
  384. devdir(c, qid, up->genbuf, 0, eve, 0555, dp);
  385. break;
  386. default:
  387. panic("bridgewalk %llux", c->qid.path);
  388. }
  389. return 1;
  390. }
  391. switch(type) {
  392. default:
  393. /* non-directory entries end up here */
  394. if(c->qid.type & QTDIR)
  395. panic("bridgegen: unexpected directory");
  396. if(s != 0)
  397. return -1;
  398. dt = dirtab[TYPE(c->qid)];
  399. if(dt == nil)
  400. panic("bridgegen: unknown type: %lud", TYPE(c->qid));
  401. devdir(c, c->qid, dt->name, dt->length, eve, dt->perm, dp);
  402. return 1;
  403. case Qtopdir:
  404. if(s != 0)
  405. return -1;
  406. snprint(up->genbuf, sizeof(up->genbuf), "bridge%ld", c->dev);
  407. mkqid(&qid, QID(0, Qbridgedir), 0, QTDIR);
  408. devdir(c, qid, up->genbuf, 0, eve, 0555, dp);
  409. return 1;
  410. case Qbridgedir:
  411. if(s<nelem(bridgedirtab)) {
  412. dt = bridgedirtab+s;
  413. devdir(c, dt->qid, dt->name, dt->length, eve, dt->perm, dp);
  414. return 1;
  415. }
  416. s -= nelem(bridgedirtab);
  417. if(s >= b->nport)
  418. return -1;
  419. mkqid(&qid, QID(s, Qportdir), 0, QTDIR);
  420. snprint(up->genbuf, sizeof(up->genbuf), "%d", s);
  421. devdir(c, qid, up->genbuf, 0, eve, 0555, dp);
  422. return 1;
  423. case Qportdir:
  424. if(s>=nelem(portdirtab))
  425. return -1;
  426. dt = portdirtab+s;
  427. mkqid(&qid, QID(PORT(c->qid),TYPE(dt->qid)), 0, QTFILE);
  428. devdir(c, qid, dt->name, dt->length, eve, dt->perm, dp);
  429. return 1;
  430. }
  431. }
  432. // parse mac address; also in netif.c
  433. static int
  434. parseaddr(uchar *to, char *from, int alen)
  435. {
  436. char nip[4];
  437. char *p;
  438. int i;
  439. p = from;
  440. for(i = 0; i < alen; i++){
  441. if(*p == 0)
  442. return -1;
  443. nip[0] = *p++;
  444. if(*p == 0)
  445. return -1;
  446. nip[1] = *p++;
  447. nip[2] = 0;
  448. to[i] = strtoul(nip, 0, 16);
  449. if(*p == ':')
  450. p++;
  451. }
  452. return 0;
  453. }
  454. // assumes b is locked
  455. static void
  456. portbind(Bridge *b, int argc, char *argv[])
  457. {
  458. Port *port;
  459. Chan *ctl;
  460. int type = 0, i, n;
  461. ulong ownhash;
  462. char *dev, *dev2 = nil, *p;
  463. char buf[100], name[KNAMELEN], path[8*KNAMELEN];
  464. static char usage[] = "usage: bind ether|tunnel name ownhash dev [dev2]";
  465. memset(name, 0, KNAMELEN);
  466. if(argc < 4)
  467. error(usage);
  468. if(strcmp(argv[0], "ether") == 0) {
  469. if(argc != 4)
  470. error(usage);
  471. type = Tether;
  472. strncpy(name, argv[1], KNAMELEN);
  473. name[KNAMELEN-1] = 0;
  474. // parseaddr(addr, argv[1], Eaddrlen);
  475. } else if(strcmp(argv[0], "tunnel") == 0) {
  476. if(argc != 5)
  477. error(usage);
  478. type = Ttun;
  479. strncpy(name, argv[1], KNAMELEN);
  480. name[KNAMELEN-1] = 0;
  481. // parseip(addr, argv[1]);
  482. dev2 = argv[4];
  483. } else
  484. error(usage);
  485. ownhash = atoi(argv[2]);
  486. dev = argv[3];
  487. for(i=0; i<b->nport; i++) {
  488. port = b->port[i];
  489. if(port != nil && port->type == type &&
  490. memcmp(port->name, name, KNAMELEN) == 0)
  491. error("port in use");
  492. }
  493. for(i=0; i<Maxport; i++)
  494. if(b->port[i] == nil)
  495. break;
  496. if(i == Maxport)
  497. error("no more ports");
  498. port = smalloc(sizeof(Port));
  499. port->ref = 1;
  500. port->id = i;
  501. port->ownhash = ownhash;
  502. if(waserror()) {
  503. portfree(port);
  504. nexterror();
  505. }
  506. port->type = type;
  507. memmove(port->name, name, KNAMELEN);
  508. switch(port->type) {
  509. default:
  510. panic("portbind: unknown port type: %d", type);
  511. case Tether:
  512. snprint(path, sizeof(path), "%s/clone", dev);
  513. ctl = namec(path, Aopen, ORDWR, 0);
  514. if(waserror()) {
  515. cclose(ctl);
  516. nexterror();
  517. }
  518. // check addr?
  519. // get directory name
  520. n = devtab[ctl->type]->read(ctl, buf, sizeof(buf), 0);
  521. buf[n] = 0;
  522. for(p = buf; *p == ' '; p++)
  523. ;
  524. snprint(path, sizeof(path), "%s/%lud/data", dev, strtoul(p, 0, 0));
  525. // setup connection to be promiscuous
  526. snprint(buf, sizeof(buf), "connect -1");
  527. devtab[ctl->type]->write(ctl, buf, strlen(buf), 0);
  528. snprint(buf, sizeof(buf), "promiscuous");
  529. devtab[ctl->type]->write(ctl, buf, strlen(buf), 0);
  530. snprint(buf, sizeof(buf), "bridge");
  531. devtab[ctl->type]->write(ctl, buf, strlen(buf), 0);
  532. // open data port
  533. port->data[0] = namec(path, Aopen, ORDWR, 0);
  534. // dup it
  535. incref(port->data[0]);
  536. port->data[1] = port->data[0];
  537. poperror();
  538. cclose(ctl);
  539. break;
  540. case Ttun:
  541. port->data[0] = namec(dev, Aopen, OREAD, 0);
  542. port->data[1] = namec(dev2, Aopen, OWRITE, 0);
  543. break;
  544. }
  545. poperror();
  546. /* committed to binding port */
  547. b->port[port->id] = port;
  548. port->bridge = b;
  549. if(b->nport <= port->id)
  550. b->nport = port->id+1;
  551. // assumes kproc always succeeds
  552. kproc("etherread", etherread, port); // poperror must be next
  553. port->ref++;
  554. }
  555. // assumes b is locked
  556. static void
  557. portunbind(Bridge *b, int argc, char *argv[])
  558. {
  559. int type = 0, i;
  560. char name[KNAMELEN];
  561. ulong ownhash;
  562. Port *port = nil;
  563. static char usage[] = "usage: unbind ether|tunnel addr [ownhash]";
  564. memset(name, 0, KNAMELEN);
  565. if(argc < 2 || argc > 3)
  566. error(usage);
  567. if(strcmp(argv[0], "ether") == 0) {
  568. type = Tether;
  569. strncpy(name, argv[1], KNAMELEN);
  570. name[KNAMELEN-1] = 0;
  571. // parseaddr(addr, argv[1], Eaddrlen);
  572. } else if(strcmp(argv[0], "tunnel") == 0) {
  573. type = Ttun;
  574. strncpy(name, argv[1], KNAMELEN);
  575. name[KNAMELEN-1] = 0;
  576. // parseip(addr, argv[1]);
  577. } else
  578. error(usage);
  579. if(argc == 3)
  580. ownhash = atoi(argv[2]);
  581. else
  582. ownhash = 0;
  583. for(i=0; i<b->nport; i++) {
  584. port = b->port[i];
  585. if(port != nil && port->type == type &&
  586. memcmp(port->name, name, KNAMELEN) == 0)
  587. break;
  588. }
  589. if(i == b->nport)
  590. error("port not found");
  591. if(ownhash != 0 && port->ownhash != 0 && ownhash != port->ownhash)
  592. error("bad owner hash");
  593. port->closed = 1;
  594. b->port[i] = nil; // port is now unbound
  595. cacheflushport(b, i);
  596. // try and stop reader
  597. if(port->readp)
  598. postnote(port->readp, 1, "unbind", 0);
  599. portfree(port);
  600. }
  601. // assumes b is locked
  602. static Centry *
  603. cachelookup(Bridge *b, uchar d[Eaddrlen])
  604. {
  605. int i;
  606. uint h;
  607. Centry *p;
  608. long sec;
  609. // dont cache multicast or broadcast
  610. if(d[0] & 1)
  611. return 0;
  612. h = 0;
  613. for(i=0; i<Eaddrlen; i++) {
  614. h *= 7;
  615. h += d[i];
  616. }
  617. h %= CacheHash;
  618. p = b->cache + h;
  619. sec = TK2SEC(m->ticks);
  620. for(i=0; i<CacheLook; i++,p++) {
  621. if(memcmp(d, p->d, Eaddrlen) == 0) {
  622. p->dst++;
  623. if(sec >= p->expire) {
  624. log(b, Logcache, "expired cache entry: %E %d\n",
  625. d, p->port);
  626. return nil;
  627. }
  628. p->expire = sec + CacheTimeout;
  629. return p;
  630. }
  631. }
  632. log(b, Logcache, "cache miss: %E\n", d);
  633. return nil;
  634. }
  635. // assumes b is locked
  636. static void
  637. cacheupdate(Bridge *b, uchar d[Eaddrlen], int port)
  638. {
  639. int i;
  640. uint h;
  641. Centry *p, *pp;
  642. long sec;
  643. // dont cache multicast or broadcast
  644. if(d[0] & 1) {
  645. log(b, Logcache, "bad source address: %E\n", d);
  646. return;
  647. }
  648. h = 0;
  649. for(i=0; i<Eaddrlen; i++) {
  650. h *= 7;
  651. h += d[i];
  652. }
  653. h %= CacheHash;
  654. p = b->cache + h;
  655. pp = p;
  656. sec = p->expire;
  657. // look for oldest entry
  658. for(i=0; i<CacheLook; i++,p++) {
  659. if(memcmp(p->d, d, Eaddrlen) == 0) {
  660. p->expire = TK2SEC(m->ticks) + CacheTimeout;
  661. if(p->port != port) {
  662. log(b, Logcache, "NIC changed port %d->%d: %E\n",
  663. p->port, port, d);
  664. p->port = port;
  665. }
  666. p->src++;
  667. return;
  668. }
  669. if(p->expire < sec) {
  670. sec = p->expire;
  671. pp = p;
  672. }
  673. }
  674. if(pp->expire != 0)
  675. log(b, Logcache, "bumping from cache: %E %d\n", pp->d, pp->port);
  676. pp->expire = TK2SEC(m->ticks) + CacheTimeout;
  677. memmove(pp->d, d, Eaddrlen);
  678. pp->port = port;
  679. pp->src = 1;
  680. pp->dst = 0;
  681. log(b, Logcache, "adding to cache: %E %d\n", pp->d, pp->port);
  682. }
  683. // assumes b is locked
  684. static void
  685. cacheflushport(Bridge *b, int port)
  686. {
  687. Centry *ce;
  688. int i;
  689. ce = b->cache;
  690. for(i=0; i<CacheSize; i++,ce++) {
  691. if(ce->port != port)
  692. continue;
  693. memset(ce, 0, sizeof(Centry));
  694. }
  695. }
  696. static char *
  697. cachedump(Bridge *b)
  698. {
  699. int i, n;
  700. long sec, off;
  701. char *buf, *p, *ep;
  702. Centry *ce;
  703. char c;
  704. qlock(b);
  705. if(waserror()) {
  706. qunlock(b);
  707. nexterror();
  708. }
  709. sec = TK2SEC(m->ticks);
  710. n = 0;
  711. for(i=0; i<CacheSize; i++)
  712. if(b->cache[i].expire != 0)
  713. n++;
  714. n *= 51; // change if print format is changed
  715. n += 10; // some slop at the end
  716. buf = malloc(n);
  717. p = buf;
  718. ep = buf + n;
  719. ce = b->cache;
  720. off = seconds() - sec;
  721. for(i=0; i<CacheSize; i++,ce++) {
  722. if(ce->expire == 0)
  723. continue;
  724. c = (sec < ce->expire)?'v':'e';
  725. p += snprint(p, ep-p, "%E %2d %10ld %10ld %10ld %c\n", ce->d,
  726. ce->port, ce->src, ce->dst, ce->expire+off, c);
  727. }
  728. *p = 0;
  729. poperror();
  730. qunlock(b);
  731. return buf;
  732. }
  733. // assumes b is locked
  734. static void
  735. ethermultiwrite(Bridge *b, Block *bp, Port *port)
  736. {
  737. Port *oport;
  738. Block *bp2;
  739. Etherpkt *ep;
  740. int i, mcast;
  741. if(waserror()) {
  742. if(bp)
  743. freeb(bp);
  744. nexterror();
  745. }
  746. ep = (Etherpkt*)bp->rp;
  747. mcast = ep->d[0] & 1; /* multicast bit of ethernet address */
  748. oport = nil;
  749. for(i=0; i<b->nport; i++) {
  750. if(i == port->id || b->port[i] == nil)
  751. continue;
  752. /*
  753. * we need to forward multicast packets for ipv6,
  754. * so always do it.
  755. */
  756. if(mcast)
  757. b->port[i]->outmulti++;
  758. else
  759. b->port[i]->outunknown++;
  760. // delay one so that the last write does not copy
  761. if(oport != nil) {
  762. b->copy++;
  763. bp2 = copyblock(bp, blocklen(bp));
  764. if(!waserror()) {
  765. etherwrite(oport, bp2);
  766. poperror();
  767. }
  768. }
  769. oport = b->port[i];
  770. }
  771. // last write free block
  772. if(oport) {
  773. bp2 = bp; bp = nil; USED(bp);
  774. if(!waserror()) {
  775. etherwrite(oport, bp2);
  776. poperror();
  777. }
  778. } else
  779. freeb(bp);
  780. poperror();
  781. }
  782. static void
  783. tcpmsshack(Etherpkt *epkt, int n)
  784. {
  785. int hl, optlen;
  786. Iphdr *iphdr;
  787. Tcphdr *tcphdr;
  788. ulong mss, cksum;
  789. uchar *optr;
  790. /* ignore non-ipv4 packets */
  791. if(nhgets(epkt->type) != ETIP4)
  792. return;
  793. iphdr = (Iphdr*)(epkt->data);
  794. n -= ETHERHDRSIZE;
  795. if(n < IPHDR)
  796. return;
  797. /* ignore bad packets */
  798. if(iphdr->vihl != (IP_VER4|IP_HLEN4)) {
  799. hl = (iphdr->vihl&0xF)<<2;
  800. if((iphdr->vihl&0xF0) != IP_VER4 || hl < (IP_HLEN4<<2))
  801. return;
  802. } else
  803. hl = IP_HLEN4<<2;
  804. /* ignore non-tcp packets */
  805. if(iphdr->proto != IP_TCPPROTO)
  806. return;
  807. n -= hl;
  808. if(n < sizeof(Tcphdr))
  809. return;
  810. tcphdr = (Tcphdr*)((uchar*)(iphdr) + hl);
  811. // MSS can only appear in SYN packet
  812. if(!(tcphdr->flag[1] & SYN))
  813. return;
  814. hl = (tcphdr->flag[0] & 0xf0)>>2;
  815. if(n < hl)
  816. return;
  817. // check for MSS option
  818. optr = (uchar*)tcphdr + sizeof(Tcphdr);
  819. n = hl - sizeof(Tcphdr);
  820. for(;;) {
  821. if(n <= 0 || *optr == EOLOPT)
  822. return;
  823. if(*optr == NOOPOPT) {
  824. n--;
  825. optr++;
  826. continue;
  827. }
  828. optlen = optr[1];
  829. if(optlen < 2 || optlen > n)
  830. return;
  831. if(*optr == MSSOPT && optlen == MSS_LENGTH)
  832. break;
  833. n -= optlen;
  834. optr += optlen;
  835. }
  836. mss = nhgets(optr+2);
  837. if(mss <= TcpMssMax)
  838. return;
  839. // fit checksum
  840. cksum = nhgets(tcphdr->cksum);
  841. if(optr-(uchar*)tcphdr & 1) {
  842. print("tcpmsshack: odd alignment!\n");
  843. // odd alignments are a pain
  844. cksum += nhgets(optr+1);
  845. cksum -= (optr[1]<<8)|(TcpMssMax>>8);
  846. cksum += (cksum>>16);
  847. cksum &= 0xffff;
  848. cksum += nhgets(optr+3);
  849. cksum -= ((TcpMssMax&0xff)<<8)|optr[4];
  850. cksum += (cksum>>16);
  851. } else {
  852. cksum += mss;
  853. cksum -= TcpMssMax;
  854. cksum += (cksum>>16);
  855. }
  856. hnputs(tcphdr->cksum, cksum);
  857. hnputs(optr+2, TcpMssMax);
  858. }
  859. /*
  860. * process to read from the ethernet
  861. */
  862. static void
  863. etherread(void *a)
  864. {
  865. Port *port = a;
  866. Bridge *b = port->bridge;
  867. Block *bp, *bp2;
  868. Etherpkt *ep;
  869. Centry *ce;
  870. long md;
  871. qlock(b);
  872. port->readp = up; /* hide identity under a rock for unbind */
  873. while(!port->closed){
  874. // release lock to read - error means it is time to quit
  875. qunlock(b);
  876. if(waserror()) {
  877. print("etherread read error: %s\n", up->errstr);
  878. qlock(b);
  879. break;
  880. }
  881. if(0)
  882. print("devbridge: etherread: reading\n");
  883. bp = devtab[port->data[0]->type]->bread(port->data[0],
  884. ETHERMAXTU, 0);
  885. if(0)
  886. print("devbridge: etherread: blocklen = %d\n",
  887. blocklen(bp));
  888. poperror();
  889. qlock(b);
  890. if(bp == nil || port->closed)
  891. break;
  892. if(waserror()) {
  893. // print("etherread bridge error\n");
  894. if(bp)
  895. freeb(bp);
  896. continue;
  897. }
  898. if(blocklen(bp) < ETHERMINTU)
  899. error("short packet");
  900. port->in++;
  901. ep = (Etherpkt*)bp->rp;
  902. cacheupdate(b, ep->s, port->id);
  903. if(b->tcpmss)
  904. tcpmsshack(ep, BLEN(bp));
  905. /*
  906. * delay packets to simulate a slow link
  907. */
  908. if(b->delay0 || b->delayn){
  909. md = b->delay0 + b->delayn * BLEN(bp);
  910. if(md > 0)
  911. microdelay(md);
  912. }
  913. if(ep->d[0] & 1) {
  914. log(b, Logmcast, "multicast: port=%d src=%E dst=%E type=%#.4ux\n",
  915. port->id, ep->s, ep->d, ep->type[0]<<8|ep->type[1]);
  916. port->inmulti++;
  917. bp2 = bp; bp = nil;
  918. ethermultiwrite(b, bp2, port);
  919. } else {
  920. ce = cachelookup(b, ep->d);
  921. if(ce == nil) {
  922. b->miss++;
  923. port->inunknown++;
  924. bp2 = bp; bp = nil;
  925. ethermultiwrite(b, bp2, port);
  926. }else if(ce->port != port->id){
  927. b->hit++;
  928. bp2 = bp; bp = nil;
  929. etherwrite(b->port[ce->port], bp2);
  930. }
  931. }
  932. poperror();
  933. if(bp)
  934. freeb(bp);
  935. }
  936. // print("etherread: trying to exit\n");
  937. port->readp = nil;
  938. portfree(port);
  939. qunlock(b);
  940. pexit("hangup", 1);
  941. }
  942. static int
  943. fragment(Etherpkt *epkt, int n)
  944. {
  945. Iphdr *iphdr;
  946. if(n <= TunnelMtu)
  947. return 0;
  948. /* ignore non-ipv4 packets */
  949. if(nhgets(epkt->type) != ETIP4)
  950. return 0;
  951. iphdr = (Iphdr*)(epkt->data);
  952. n -= ETHERHDRSIZE;
  953. /*
  954. * ignore: IP runt packets, bad packets (I don't handle IP
  955. * options for the moment), packets with don't-fragment set,
  956. * and short blocks.
  957. */
  958. if(n < IPHDR || iphdr->vihl != (IP_VER4|IP_HLEN4) ||
  959. iphdr->frag[0] & (IP_DF>>8) || nhgets(iphdr->length) > n)
  960. return 0;
  961. return 1;
  962. }
  963. static void
  964. etherwrite(Port *port, Block *bp)
  965. {
  966. Iphdr *eh, *feh;
  967. Etherpkt *epkt;
  968. int n, lid, len, seglen, chunk, dlen, blklen, offset, mf;
  969. Block *xp, *nb;
  970. ushort fragoff, frag;
  971. port->out++;
  972. epkt = (Etherpkt*)bp->rp;
  973. n = blocklen(bp);
  974. if(port->type != Ttun || !fragment(epkt, n)) {
  975. devtab[port->data[1]->type]->bwrite(port->data[1], bp, 0);
  976. return;
  977. }
  978. port->outfrag++;
  979. if(waserror()){
  980. freeblist(bp);
  981. nexterror();
  982. }
  983. seglen = (TunnelMtu - ETHERHDRSIZE - IPHDR) & ~7;
  984. eh = (Iphdr*)(epkt->data);
  985. len = nhgets(eh->length);
  986. frag = nhgets(eh->frag);
  987. mf = frag & IP_MF;
  988. frag <<= 3;
  989. dlen = len - IPHDR;
  990. xp = bp;
  991. lid = nhgets(eh->id);
  992. offset = ETHERHDRSIZE+IPHDR;
  993. while(xp != nil && offset && offset >= BLEN(xp)) {
  994. offset -= BLEN(xp);
  995. xp = xp->next;
  996. }
  997. xp->rp += offset;
  998. if(0)
  999. print("seglen=%d, dlen=%d, mf=%x, frag=%d\n",
  1000. seglen, dlen, mf, frag);
  1001. for(fragoff = 0; fragoff < dlen; fragoff += seglen) {
  1002. nb = allocb(ETHERHDRSIZE+IPHDR+seglen);
  1003. feh = (Iphdr*)(nb->wp+ETHERHDRSIZE);
  1004. memmove(nb->wp, epkt, ETHERHDRSIZE+IPHDR);
  1005. nb->wp += ETHERHDRSIZE+IPHDR;
  1006. if((fragoff + seglen) >= dlen) {
  1007. seglen = dlen - fragoff;
  1008. hnputs(feh->frag, (frag+fragoff)>>3 | mf);
  1009. }
  1010. else
  1011. hnputs(feh->frag, (frag+fragoff>>3) | IP_MF);
  1012. hnputs(feh->length, seglen + IPHDR);
  1013. hnputs(feh->id, lid);
  1014. /* Copy up the data area */
  1015. chunk = seglen;
  1016. while(chunk) {
  1017. blklen = chunk;
  1018. if(BLEN(xp) < chunk)
  1019. blklen = BLEN(xp);
  1020. memmove(nb->wp, xp->rp, blklen);
  1021. nb->wp += blklen;
  1022. xp->rp += blklen;
  1023. chunk -= blklen;
  1024. if(xp->rp == xp->wp)
  1025. xp = xp->next;
  1026. }
  1027. feh->cksum[0] = 0;
  1028. feh->cksum[1] = 0;
  1029. hnputs(feh->cksum, ipcsum(&feh->vihl));
  1030. /* don't generate small packets */
  1031. if(BLEN(nb) < ETHERMINTU)
  1032. nb->wp = nb->rp + ETHERMINTU;
  1033. devtab[port->data[1]->type]->bwrite(port->data[1], nb, 0);
  1034. }
  1035. poperror();
  1036. freeblist(bp);
  1037. }
  1038. // hold b lock
  1039. static void
  1040. portfree(Port *port)
  1041. {
  1042. port->ref--;
  1043. if(port->ref < 0)
  1044. panic("portfree: bad ref");
  1045. if(port->ref > 0)
  1046. return;
  1047. if(port->data[0])
  1048. cclose(port->data[0]);
  1049. if(port->data[1])
  1050. cclose(port->data[1]);
  1051. memset(port, 0, sizeof(Port));
  1052. free(port);
  1053. }
  1054. Dev bridgedevtab = {
  1055. 'B',
  1056. "bridge",
  1057. devreset,
  1058. bridgeinit,
  1059. devshutdown,
  1060. bridgeattach,
  1061. bridgewalk,
  1062. bridgestat,
  1063. bridgeopen,
  1064. devcreate,
  1065. bridgeclose,
  1066. bridgeread,
  1067. devbread,
  1068. bridgewrite,
  1069. devbwrite,
  1070. devremove,
  1071. devwstat,
  1072. };