![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to devarp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port|
Return to devarp.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port |
1.1 root 1: #include "u.h"
2: #include "../port/lib.h"
3: #include "mem.h"
4: #include "dat.h"
5: #include "fns.h"
6: #include "../port/error.h"
7: #include "arp.h"
8: #include "../port/ipdat.h"
9:
10: #include "devtab.h"
11:
12: #define ARP_FREE 0
13: #define ARP_OK 1
14: #define ARP_ASKED 2
15: #define ARP_TEMP 0
16: #define ARP_PERM 1
17: #define Arphashsize 32
18: #define ARPHASH(p) arphash[((p[2]^p[3])%Arphashsize)]
19:
20: typedef struct Arpcache Arpcache;
21: struct Arpcache
22: {
23: uchar status;
24: uchar type;
25: uchar eip[4];
26: uchar et[6];
27: Arpcache *hash;
28: Arpcache **hashhd;
29: Arpcache *frwd;
30: Arpcache *prev;
31: };
32:
33: Arpstats arpstats;
34: Arpcache *arplruhead, *arplrutail;
35: Arpcache *arp, **arphash;
36: Queue *Servq;
37: Lock larphash;
38:
39: void arpiput(Queue *, Block *);
40: void arpoput(Queue *, Block *);
41: void arpopn(Queue *, Stream *);
42: void arpcls(Queue *);
43: void arpenter(Arpentry*, int);
44: void arpflush(void);
45: int arpperm(char*);
46: int arpdelete(char*);
47: void arplinkhead(Arpcache*);
48: int arplookup(uchar*, uchar*);
49:
50: Qinfo arpinfo = { arpiput, arpoput, arpopn, arpcls, "arp" };
51:
52: #define ARP_ENTRYLEN 50
53: char *padstr = " ";
54:
55: enum{
56: arpdirqid,
57: arpdir2qid,
58: arpstatqid,
59: arpctlqid,
60: arpdataqid,
61: };
62:
63: Dirtab arptab[]={
64: "stats", {arpstatqid}, 0, 0444,
65: "ctl", {arpctlqid}, 0, 0664,
66: "data", {arpdataqid}, 0, 0664,
67: };
68: #define Narptab (sizeof(arptab)/sizeof(Dirtab))
69:
70: enum
71: {
72: Narp= 64, /* size of arp cache */
73: };
74:
75: /*
76: * create a 2-level directory
77: */
78: int
79: arpgen(Chan *c, void *vp, int ntab, int i, Dir *dp)
80: {
81: Qid q;
82:
83: USED(vp);
84: USED(ntab);
85:
86: q.vers = 0;
87:
88: /* top level directory contains the directory arp */
89: if(c->qid.path == CHDIR){
90: if(i)
91: return -1;
92: q.path = CHDIR | arpdir2qid;
93: devdir(c, q, "arp", 0, eve, 0555, dp);
94: return 1;
95: }
96:
97: /* next level uses table */
98: return devgen(c, arptab, Narptab, i, dp);
99: }
100:
101: void
102: arpreset(void)
103: {
104: Arpcache *ap, *ep;
105:
106: arp = xalloc(sizeof(Arpcache) * Narp);
107: arphash = (Arpcache **)xalloc(sizeof(Arpcache *) * Arphashsize);
108:
109: ep = &arp[Narp];
110: for(ap = arp; ap < ep; ap++) {
111: ap->frwd = ap+1;
112: ap->prev = ap-1;
113: ap->type = ARP_FREE;
114: ap->status = ARP_TEMP;
115: }
116:
117: arp[0].prev = 0;
118: arplruhead = arp;
119: ap = &arp[Narp-1];
120: ap->frwd = 0;
121: arplrutail = ap;
122: newqinfo(&arpinfo);
123: }
124:
125: void
126: arpinit(void)
127: {
128: }
129:
130: Chan *
131: arpattach(char *spec)
132: {
133: return devattach('a', spec);
134: }
135:
136: Chan *
137: arpclone(Chan *c, Chan *nc)
138: {
139: return devclone(c, nc);
140: }
141:
142: int
143: arpwalk(Chan *c, char *name)
144: {
145: return devwalk(c, name, 0, 0, arpgen);
146: }
147:
148: void
149: arpstat(Chan *c, char *db)
150: {
151: devstat(c, db, 0, 0, arpgen);
152: }
153:
154: Chan *
155: arpopen(Chan *c, int omode)
156: {
157: if(c->qid.path&CHDIR){
158: if(omode != OREAD)
159: error(Eperm);
160: }
161:
162: switch(STREAMTYPE(c->qid.path)) {
163: case arpdataqid:
164: break;
165: case arpstatqid:
166: if(omode != OREAD)
167: error(Ebadarg);
168: break;
169: case arpctlqid:
170: break;
171: }
172:
173: c->mode = openmode(omode);
174: c->flag |= COPEN;
175: c->offset = 0;
176: return c;
177: }
178:
179: void
180: arpcreate(Chan *c, char *name, int omode, ulong perm)
181: {
182: USED(c, name, omode, perm);
183: error(Eperm);
184: }
185:
186: void
187: arpremove(Chan *c)
188: {
189: USED(c);
190: error(Eperm);
191: }
192:
193: void
194: arpwstat(Chan *c, char *dp)
195: {
196: USED(c, dp);
197: error(Eperm);
198: }
199:
200: void
201: arpclose(Chan *c)
202: {
203: streamclose(c);
204: }
205:
206: long
207: arpread(Chan *c, void *a, long n, ulong offset)
208: {
209: char buf[100];
210: Arpcache *ap;
211: int part, bytes, size;
212: char *ststr;
213:
214: if(c->qid.path&CHDIR)
215: return devdirread(c, a, n, arptab, Narptab, arpgen);
216:
217: switch((int)(c->qid.path&~CHDIR)){
218: case arpdataqid:
219: bytes = c->offset;
220: while(bytes < Narp*ARP_ENTRYLEN && n) {
221: ap = &arp[bytes/ARP_ENTRYLEN];
222: part = bytes%ARP_ENTRYLEN;
223:
224: if(ap->status != ARP_OK)
225: ststr = "invalid";
226: else
227: ststr = (ap->type == ARP_TEMP ? "temp" : "perm");
228:
229: sprint(buf,"%d.%d.%d.%d to %.2x:%.2x:%.2x:%.2x:%.2x:%.2x %s%s",
230: ap->eip[0], ap->eip[1], ap->eip[2], ap->eip[3],
231: ap->et[0], ap->et[1], ap->et[2], ap->et[3],
232: ap->et[4], ap->et[5],
233: ststr, padstr);
234:
235: buf[ARP_ENTRYLEN-1] = '\n';
236:
237: size = ARP_ENTRYLEN - part;
238: size = MIN(n, size);
239: memmove(a, buf+part, size);
240:
241: a = (void *)((int)a + size);
242: n -= size;
243: bytes += size;
244: }
245: return bytes - c->offset;
246: break;
247: case arpstatqid:
248: sprint(buf, "hits: %d miss: %d failed: %d\n",
249: arpstats.hit, arpstats.miss, arpstats.failed);
250:
251: return readstr(offset, a, n, buf);
252: default:
253: n=0;
254: break;
255: }
256: return n;
257: }
258:
259: long
260: arpwrite(Chan *c, char *a, long n, ulong offset)
261: {
262: int m;
263: Arpentry entry;
264: char buf[32], *field[5];
265:
266: USED(offset);
267:
268: switch(STREAMTYPE(c->qid.path)) {
269: case arpctlqid:
270: strncpy(buf, a, sizeof buf);
271: m = getfields(buf, field, 5, " ");
272:
273: if(strncmp(field[0], "flush", 5) == 0)
274: arpflush();
275: else
276: if(strcmp(field[0], "delete") == 0) {
277: if(m != 2)
278: error(Ebadarg);
279:
280: if(arpdelete(field[1]) < 0)
281: error(Enetaddr);
282: }
283: else
284: if(strcmp(field[0], "perm") == 0) {
285: if(m != 2)
286: error(Ebadarg);
287:
288: if(arpperm(field[1]) < 0)
289: error(Enetaddr);
290: }
291: else
292: error(Ebadctl);
293: break;
294:
295: case arpdataqid:
296: if(n != sizeof(Arpentry))
297: error(Emsgsize);
298: memmove(&entry, a, sizeof(Arpentry));
299: arpenter(&entry, ARP_TEMP);
300: break;
301:
302: default:
303: error(Ebadusefd);
304: }
305:
306: return n;
307: }
308:
309: void
310: arpopn(Queue *q, Stream *s)
311: {
312: USED(q, s);
313: }
314:
315: void
316: arpcls(Queue *q)
317: {
318: if(q == Servq)
319: Servq = 0;
320: }
321:
322: void
323: arpiput(Queue *q, Block *bp)
324: {
325: PUTNEXT(q, bp);
326: }
327:
328: void
329: arpoput(Queue *q, Block *bp)
330: {
331: uchar ip[4];
332: Ipaddr addr;
333: Ipdevice *p;
334: Etherhdr *eh;
335: static int dropped;
336:
337:
338: if(bp->type != M_DATA) {
339: if(Servq == 0 && streamparse("arpd", bp)) {
340: Servq = RD(q);
341: freeb(bp);
342: }
343: else
344: PUTNEXT(q, bp);
345: return;
346: }
347:
348: eh = (Etherhdr *)bp->rptr;
349: if(nhgets(eh->type) != ET_IP) {
350: PUTNEXT(q, bp);
351: return;
352: }
353:
354: /*
355: * sleaze - we hid the next hop in the ethernet destination
356: * and the interface in the first byte of the source
357: */
358: memmove(ip, eh->d, sizeof(ip));
359: p = &ipd[eh->s[0]];
360: if(p >= &ipd[Nipd] || p->q == 0)
361: p = ipd;
362:
363: /* if ip broadcast, use ether bcast address */
364: addr = nhgetl(eh->dst);
365: if(p->Myip[Myself] == 0 || addr == p->Myip[Mybcast] || addr == p->Myip[Mynet]
366: || ((addr & p->Mymask) == p->Myip[Mynet+1]
367: && (addr & ~p->Mynetmask) == ~p->Mynetmask)){
368: memset(eh->d, 0xff, sizeof(eh->d));
369: PUTNEXT(q, bp);
370: return;
371: }
372:
373: /* if a known ip addr, send downstream to the ethernet */
374: if(arplookup(ip, eh->d)) {
375: PUTNEXT(q, bp);
376: return;
377: }
378:
379: /* Push the packet up to the arp server for address resolution */
380: if(!Servq) {
381: if((dropped++ % 100) == 99)
382: print("arp: No server, packet dropped %d.%d.%d.%d\n",
383: eh->dst[0], eh->dst[1], eh->dst[2], eh->dst[3]);
384: freeb(bp);
385: return;
386: }
387: memmove(eh->d, ip, sizeof(ip));
388: PUTNEXT(Servq, bp);
389: }
390:
391: int
392: arplookup(uchar *ip, uchar *et)
393: {
394: Arpcache *ap;
395:
396: lock(&larphash);
397: for(ap = ARPHASH(ip); ap; ap = ap->hash) {
398: if(ap->status == ARP_OK && memcmp(ap->eip, ip, sizeof(ap->eip)) == 0) {
399: memmove(et, ap->et, sizeof(ap->et));
400: arplinkhead(ap);
401: arpstats.hit++;
402: unlock(&larphash);
403: return 1;
404: }
405: }
406: arpstats.miss++;
407: unlock(&larphash);
408: return 0;
409: }
410:
411: void
412: arpflush(void)
413: {
414: Arpcache *ap, *ep;
415:
416: ep = &arp[Narp];
417: for(ap = arp; ap < ep; ap++)
418: ap->status = ARP_FREE;
419: }
420:
421: void
422: arpenter(Arpentry *ape, int type)
423: {
424: Arpcache *ap, **l, *d;
425:
426:
427: /* Update an entry if we have one already */
428: l = &ARPHASH(ape->ipaddr);
429: lock(&larphash);
430: for(ap = *l; ap; ap = ap->hash) {
431: if(ap->status == ARP_OK && memcmp(ap->eip, ape->ipaddr, sizeof(ap->eip)) == 0) {
432: if(ap->type != ARP_PERM) {
433: ap->type = type;
434: memmove(ap->et, ape->etaddr, sizeof(ap->et));
435: ap->status = ARP_OK;
436: }
437: unlock(&larphash);
438: return;
439: }
440: }
441:
442: /* Find an entry to replace */
443: ap = arplrutail;
444: while(ap) {
445: if(ap->type != ARP_PERM || ap->type == ARP_FREE)
446: break;
447: ap = ap->prev;
448: }
449: if(!ap) {
450: unlock(&larphash);
451: print("arp: too many permanent entries\n");
452: return;
453: }
454:
455: if(ap->hashhd) {
456: for(d = *ap->hashhd; d; d = d->hash) {
457: if(d == ap) {
458: *(ap->hashhd) = ap->hash;
459: break;
460: }
461: ap->hashhd = &d->hash;
462: }
463: }
464:
465: ap->type = type;
466: ap->status = ARP_OK;
467: memmove(ap->eip, ape->ipaddr, sizeof(ape->ipaddr));
468: memmove(ap->et, ape->etaddr, sizeof(ape->etaddr));
469: ap->hashhd = l;
470: ap->hash = *l;
471: *l = ap;
472: arplinkhead(ap);
473: unlock(&larphash);
474: }
475:
476: int
477: arpperm(char *addr)
478: {
479: Arpcache *ap;
480: uchar ip[4];
481: Ipaddr i;
482: int rv;
483:
484: rv = -1;
485: i = ipparse(addr);
486: hnputl(ip, i);
487: lock(&larphash);
488: for(ap = arplruhead; ap; ap = ap->frwd) {
489: if(memcmp(ap->eip, ip, sizeof(ap->eip)) == 0) {
490: ap->type = ARP_PERM;
491: rv = 0;
492: break;
493: }
494: }
495: unlock(&larphash);
496: return rv;
497: }
498:
499: int
500: arpdelete(char *addr)
501: {
502: Arpcache *ap;
503: uchar ip[4];
504: Ipaddr i;
505: int rv;
506:
507: rv = -1;
508: i = ipparse(addr);
509: hnputl(ip, i);
510: lock(&larphash);
511: for(ap = arplruhead; ap; ap = ap->frwd) {
512: if(memcmp(ap->eip, ip, sizeof(ap->eip)) == 0) {
513: ap->status = ARP_FREE;
514: rv = 0;
515: break;
516: }
517: }
518: unlock(&larphash);
519: return rv;
520: }
521:
522: void
523: arplinkhead(Arpcache *ap)
524: {
525: if(ap == arplruhead)
526: return;
527:
528: if(ap->prev)
529: ap->prev->frwd = ap->frwd;
530: else
531: arplruhead = ap->frwd;
532:
533: if(ap->frwd)
534: ap->frwd->prev = ap->prev;
535: else
536: arplrutail = ap->prev;
537:
538: ap->frwd = arplruhead;
539: ap->prev = 0;
540: arplruhead->prev = ap;
541: arplruhead = ap;
542: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.