![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to arp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / net / tcp|
Return to arp.c CVS log | Up to [Early Linux] / linux / net / tcp |
1.1 root 1: /* arp.c */
2: /*
3: Copyright (C) 1992 Ross Biro
4:
5: This program is free software; you can redistribute it and/or modify
6: it under the terms of the GNU General Public License as published by
7: the Free Software Foundation; either version 2, or (at your option)
8: any later version.
9:
10: This program is distributed in the hope that it will be useful,
11: but WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with this program; if not, write to the Free Software
17: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18:
19: The Author may be reached as [email protected] or
20: C/O Department of Mathematics; Stanford University; Stanford, CA 94305
21: */
22:
23: #include <linux/types.h>
24: #include <linux/string.h>
25: #include <linux/kernel.h>
26: #include <linux/sched.h>
27:
28: #include <linux/socket.h>
29: #include <netinet/in.h>
30: #include <asm/system.h>
31:
32: #include "timer.h"
33: #include "ip.h"
34: #include "tcp.h"
35: #include "sock.h"
36: #include "arp.h"
37:
38: #undef ARP_DEBUG
39: #ifdef ARP_DEBUG
40: #define PRINTK printk
41: #else
42: #define PRINTK dummy_routine
43: #endif
44:
45: static struct arp_table *arp_table[ARP_TABLE_SIZE] ={NULL, };
46: static struct sk_buff *arp_q=NULL;
47:
48: /* this will try to retransmit everything on the queue. */
49: static void
50: send_arp_q(void)
51: {
52: struct sk_buff *skb;
53: if (arp_q == NULL) return;
54:
55: skb = arp_q;
56: do {
57: if (!skb->dev->rebuild_header (skb+1, skb->dev))
58: {
59: if (skb->next == skb)
60: {
61: arp_q = NULL;
62: }
63: else
64: {
65: skb->next->prev = skb->prev;
66: skb->prev->next = skb->next;
67: arp_q = skb->next;
68: }
69: skb->next = NULL;
70: skb->prev = NULL;
71: skb->arp = 1;
72: skb->dev->queue_xmit (skb, skb->dev, 0);
73: if (arp_q == NULL) break;
74: skb = arp_q;
75: continue;
76: }
77: skb=skb->next;
78: } while (skb != arp_q);
79:
80: }
81:
82: static void
83: print_arp(struct arp *arp)
84: {
85: int i;
86: unsigned long *lptr;
87: unsigned char *ptr;
88: PRINTK ("arp: \n");
89: PRINTK (" hrd = %d\n",net16(arp->hrd));
90: PRINTK (" pro = %d\n",net16(arp->pro));
91: PRINTK (" hlen = %d plen = %d\n",arp->hlen, arp->plen);
92: PRINTK (" op = %d\n", net16(arp->op));
93: ptr = (unsigned char *)(arp+1);
94: PRINTK (" sender haddr = ");
95: for (i = 0; i < arp->hlen; i++)
96: {
97: PRINTK ("0x%02X ",*ptr++);
98: }
99: lptr = (void *)ptr;
100: PRINTK (" send paddr = %X\n",*lptr);
101: lptr ++;
102: ptr = (void *)lptr;
103: PRINTK (" destination haddr = ");
104: for (i = 0; i < arp->hlen; i++)
105: {
106: PRINTK ("0x%02X ",*ptr++);
107: }
108: lptr = (void *)ptr;
109: PRINTK (" destination paddr = %X\n",*lptr);
110: }
111:
112: static unsigned char *
113: arp_sourceh(struct arp *arp)
114: {
115: unsigned char *ptr;
116: ptr = (unsigned char *)(arp + 1);
117: return (ptr);
118: }
119:
120: static unsigned char *
121: arp_targeth(struct arp *arp)
122: {
123: unsigned char *ptr;
124: ptr = (unsigned char *)(arp + 1);
125: ptr += arp->hlen+4;
126: return (ptr);
127: }
128:
129: static unsigned long *
130: arp_sourcep(struct arp *arp)
131: {
132: unsigned long *lptr;
133: unsigned char *ptr;
134: ptr = (unsigned char *)(arp + 1);
135: ptr += arp->hlen;
136: lptr = (unsigned long *)ptr;
137: return (lptr);
138: }
139:
140:
141: static unsigned long *
142: arp_targetp(struct arp *arp)
143: {
144: unsigned long *lptr;
145: unsigned char *ptr;
146: ptr = (unsigned char *)(arp + 1);
147: ptr += 2*arp->hlen+4;
148: lptr = (unsigned long *)ptr;
149: return (lptr);
150: }
151:
152: static void
153: arp_free (void *ptr, unsigned long len)
154: {
155: free_s(ptr, len);
156: }
157:
158: static void *
159: arp_malloc (unsigned long amount)
160: {
161: return (malloc (amount));
162: }
163:
164: static int
165: arp_response (struct arp *arp1, struct device *dev)
166: {
167: struct arp *arp2;
168: struct sk_buff *skb;
169: int tmp;
170:
171: /* get some mem and initialize it for the return trip. */
172: skb = arp_malloc (sizeof (*skb) + sizeof (*arp2) +
173: 2*arp1->hlen + 2*arp1->plen + dev->hard_header_len);
174: if (skb == NULL) return (1);
175:
176: skb->mem_addr = skb;
177: skb->mem_len = sizeof (*skb) + sizeof (*arp2) + 2*arp1->hlen +
178: 2*arp1->plen + dev->hard_header_len;
179: skb->len = sizeof (*arp2) + 2*arp1->hlen +
180: 2*arp1->plen + dev->hard_header_len;
181:
182: tmp = dev->hard_header((unsigned char *)(skb+1), dev,
183: ETHERTYPE_ARP, *arp_sourcep(arp1),
184: *arp_targetp(arp1),skb->len);
185:
186: if (tmp < 0) return (1);
187:
188: arp2 =(struct arp *) ((unsigned char *)skb+sizeof (*skb) + tmp );
189: memcpy (arp2, arp1, sizeof (*arp2));
190:
191: /* now swap the addresses. */
192: *arp_sourcep(arp2) = *arp_targetp(arp1);
193: memcpy(arp_sourceh(arp2), dev->dev_addr, arp1->hlen);
194:
195: *arp_targetp(arp2) = *arp_sourcep(arp1);
196: memcpy(arp_targeth(arp2), arp_sourceh(arp1), arp1->hlen);
197:
198: arp2->op = NET16(ARP_REPLY);
199: skb->free = 1;
200: skb->arp = 1; /* so the code will know it's not waiting on an arp. */
201: skb->sk = NULL;
202: skb->next = NULL;
203: PRINTK (">>");
204: print_arp(arp2);
205: /* send it. */
206: dev->queue_xmit (skb, dev, 0);
207: return (0);
208: }
209:
210: /* This will find an entry in the arp table by looking at the ip
211: address. */
212: static struct arp_table *
213: arp_lookup (unsigned long paddr)
214: {
215: unsigned long hash;
216: struct arp_table *apt;
217: PRINTK ("arp_lookup(paddr=%X)\n", paddr);
218: /* we don't want to arp ourselves. */
219: if (my_ip_addr(paddr)) return (NULL);
220: hash = net32(paddr) & (ARP_TABLE_SIZE - 1);
221: cli();
222: for (apt = arp_table[hash]; apt != NULL; apt = apt->next)
223: {
224: if (apt->ip == paddr)
225: {
226: sti();
227: return (apt);
228: }
229: }
230: sti();
231: return (NULL);
232: }
233:
234: void
235: arp_destroy(unsigned long paddr)
236: {
237: unsigned long hash;
238: struct arp_table *apt;
239: struct arp_table *lapt;
240: PRINTK ("arp_destroy (paddr=%X)\n",paddr);
241: /* we don't want to destroy are own arp */
242: if (my_ip_addr(paddr)) return;
243: hash = net32(paddr) & (ARP_TABLE_SIZE - 1);
244:
245: cli(); /* can't be interrupted. */
246: /* make sure there is something there. */
247: if (arp_table[hash] == NULL) return;
248:
249: /* check the first one. */
250: if (arp_table[hash]->ip == paddr)
251: {
252: apt = arp_table[hash];
253: arp_table[hash] = arp_table[hash]->next;
254: arp_free (apt, sizeof (*apt));
255: sti();
256: return;
257: }
258:
259: /* now deal with it any where else in the chain. */
260: lapt = arp_table[hash];
261: for (apt = arp_table[hash]->next; apt != NULL; apt = apt->next)
262: {
263: if (apt->ip == paddr)
264: {
265: lapt->next = apt->next;
266: arp_free (apt, sizeof (*apt));
267: sti();
268: return;
269: }
270: }
271: sti();
272: }
273:
274: /* this routine does not check for duplicates. It assumes the caller
275: does. */
276: static struct arp_table *
277: create_arp (unsigned long paddr, unsigned char *addr, int hlen)
278: {
279: struct arp_table *apt;
280: unsigned long hash;
281: apt = arp_malloc (sizeof (*apt));
282: if (apt == NULL) return (NULL);
283:
284: hash = net32(paddr) & (ARP_TABLE_SIZE - 1);
285: apt->ip = paddr;
286: apt->hlen =hlen;
287: memcpy (apt->hard, addr, hlen);
288: apt->last_used=timer_seq;
289: sti();
290: apt->next = arp_table[hash];
291: arp_table[hash]=apt;
292: cli();
293: return (apt);
294: }
295:
296: int
297: arp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
298: {
299: struct arp *arp;
300: struct arp_table *tbl;
301: int ret;
302:
303: PRINTK ("<<\n");
304: arp = skb->h.arp;
305: print_arp(arp);
306:
307: /* if this test doesn't pass, something fishy is going on. */
308: if (arp->hlen != dev->addr_len || dev->type !=NET16( arp->hrd))
309: {
310: free_skb(skb, FREE_READ);
311: return (0);
312: }
313:
314: /* for now we will only deal with ip addresses. */
315: if (arp->pro != NET16(ARP_IP_PROT) || arp->plen != 4)
316: {
317: free_skb (skb, FREE_READ);
318: return (0);
319: }
320:
321: /* now look up the ip address in the table. */
322: tbl = arp_lookup (*arp_sourcep(arp));
323: if (tbl != NULL)
324: {
325: memcpy (tbl->hard, arp+1, arp->hlen);
326: tbl->hlen = arp->hlen;
327: tbl->last_used = timer_seq;
328: }
329:
330: if (!my_ip_addr(*arp_targetp(arp)))
331: {
332: free_skb (skb, FREE_READ);
333: return (0);
334: }
335:
336: if (tbl == NULL)
337: create_arp (*arp_sourcep(arp), arp_sourceh(arp), arp->hlen);
338:
339: /* now see if we can send anything. */
340: send_arp_q();
341:
342: if (arp->op != NET16(ARP_REQUEST))
343: {
344: free_skb (skb, FREE_READ);
345: return (0);
346: }
347:
348: /* now we need to create a new packet. */
349: ret = arp_response(arp, dev);
350: free_skb (skb, FREE_READ);
351: return (ret);
352: }
353:
354: void
355: arp_snd (unsigned long paddr, struct device *dev, unsigned long saddr)
356: {
357: struct sk_buff *skb;
358: struct arp *arp;
359: struct arp_table *apt;
360: int tmp;
361: PRINTK ("arp_snd (paddr=%X, dev=%X, saddr=%X)\n",paddr, dev, saddr);
362:
363: /* first we build a dummy arp table entry. */
364: apt = create_arp (paddr, NULL, 0);
365: if (apt == NULL) return;
366:
367: skb = arp_malloc (sizeof (*arp) + sizeof (*skb) + dev->hard_header_len +
368: 2*dev->addr_len+8);
369: if (skb == NULL) return;
370:
371: skb->sk = NULL;
372: skb->mem_addr = skb;
373: skb->mem_len = sizeof (*arp) + sizeof (*skb) + dev->hard_header_len +
374: 2*dev->addr_len+8;
375: skb->arp = 1;
376: skb->dev = dev;
377: skb->len = sizeof (*arp) + dev->hard_header_len + 2*dev->addr_len+8;
378: skb->next = NULL;
379:
380: tmp = dev->hard_header ((unsigned char *)(skb+1), dev,
381: ETHERTYPE_ARP, 0, saddr, skb->len);
382: if (tmp < 0)
383: {
384: arp_free (skb->mem_addr, skb->mem_len);
385: return;
386: }
387:
388: arp =(struct arp *) ((unsigned char *)skb+sizeof (*skb) + tmp );
389: arp->hrd = net16(dev->type);
390: arp->pro = NET16(ARP_IP_PROT);
391: arp->hlen = dev->addr_len;
392: arp->plen = 4;
393: arp->op = NET16(ARP_REQUEST);
394: *arp_sourcep(arp) = saddr;
395: *arp_targetp(arp) = paddr;
396: memcpy (arp_sourceh(arp), dev->dev_addr, dev->addr_len);
397: memcpy (arp_targeth(arp), dev->broadcast, dev->addr_len);
398: PRINTK(">>\n");
399: print_arp(arp);
400: dev->queue_xmit (skb, dev, 0);
401: }
402:
403: int
404: arp_find(unsigned char *haddr, unsigned long paddr, struct device *dev,
405: unsigned long saddr)
406: {
407: struct arp_table *apt;
408: PRINTK ("arp_find(haddr=%X, paddr=%X, dev=%X, saddr=%X)\n",
409: haddr, paddr, dev, saddr);
410: if (my_ip_addr (paddr))
411: {
412: memcpy (haddr, dev->dev_addr, dev->addr_len);
413: return (0);
414: }
415: apt = arp_lookup (paddr);
416: if (apt != NULL)
417: {
418: /* make sure it's not too old. If it is too old, we will
419: just pretend we did not find it, and then arp_snd
420: will verify the address for us. */
421: if (!before (apt->last_used, timer_seq+ARP_TIMEOUT) &&
422: apt->hlen != 0)
423: {
424: apt->last_used=timer_seq;
425: memcpy (haddr, apt->hard, dev->addr_len);
426: return (0);
427: }
428: }
429:
430: /* if we didn't find an entry, we will try to
431: send an arp packet. */
432: if (apt == NULL || after (timer_seq, apt->last_used+ARP_RES_TIME))
433: arp_snd(paddr,dev,saddr);
434:
435: /* this assume haddr are atleast 4 bytes.
436: If this isn't true we can use a lookup
437: table, one for every dev. */
438: *(unsigned long *)haddr = paddr;
439: return (1);
440: }
441:
442:
443: void
444: arp_add (unsigned long addr, unsigned char *haddr, struct device *dev)
445: {
446: struct arp_table *apt;
447: /* first see if the address is already in the table. */
448: apt = arp_lookup (addr);
449: if (apt != NULL)
450: {
451: apt->last_used = timer_seq;
452: memcpy (apt->hard, haddr , dev->addr_len);
453: return;
454: }
455: create_arp (addr, haddr, dev->addr_len);
456: }
457:
458: void
459: arp_add_broad (unsigned long addr, struct device *dev)
460: {
461: arp_add (addr, dev->broadcast , dev);
462: }
463:
464:
465: void
466: arp_queue(struct sk_buff *skb)
467: {
468: cli();
469: if (arp_q == NULL)
470: {
471: arp_q = skb;
472: skb->next = skb;
473: skb->prev = skb;
474: }
475: else
476: {
477: skb->next = arp_q;
478: skb->prev = arp_q->prev;
479: skb->next->prev = skb;
480: skb->prev->next = skb;
481: }
482: sti();
483:
484: }
485:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.