This source file includes following definitions.
- arp_check_expire
- arp_release_entry
- arp_device_event
- arp_send
- arp_expire_request
- arp_send_q
- arp_destroy
- arp_rcv
- arp_find
- arp_get_info
- arp_lookup
- arp_req_set
- arp_req_get
- arp_ioctl
- arp_init
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42 #include <linux/types.h>
43 #include <linux/string.h>
44 #include <linux/kernel.h>
45 #include <linux/sched.h>
46 #include <linux/config.h>
47 #include <linux/socket.h>
48 #include <linux/sockios.h>
49 #include <linux/errno.h>
50 #include <linux/if_arp.h>
51 #include <linux/in.h>
52 #include <asm/system.h>
53 #include <asm/segment.h>
54 #include <stdarg.h>
55 #include <linux/inet.h>
56 #include <linux/netdevice.h>
57 #include <linux/etherdevice.h>
58 #include "ip.h"
59 #include "route.h"
60 #include "protocol.h"
61 #include "tcp.h"
62 #include <linux/skbuff.h>
63 #include "sock.h"
64 #include "arp.h"
65 #ifdef CONFIG_AX25
66 #include "ax25.h"
67 #endif
68
69
70
71
72
73
74
75
76
77 struct arp_table
78 {
79 struct arp_table *next;
80 unsigned long last_used;
81 unsigned int flags;
82 unsigned long ip;
83 unsigned long mask;
84 unsigned char ha[MAX_ADDR_LEN];
85 unsigned char hlen;
86 unsigned short htype;
87 struct device *dev;
88
89
90
91
92
93 struct timer_list timer;
94 int retries;
95 struct sk_buff_head skb;
96 };
97
98
99
100
101
102
103
104
105
106
107
108 #define ARP_RES_TIME (250*(HZ/10))
109
110
111
112
113
114
115 #define ARP_MAX_TRIES 3
116
117
118
119
120
121 #define ARP_TIMEOUT (600*HZ)
122
123
124
125
126
127
128
129 #define ARP_CHECK_INTERVAL (60 * HZ)
130
131
132 static void arp_check_expire (unsigned long);
133 static struct arp_table *arp_lookup(unsigned long paddr, int exact);
134
135
136 static struct timer_list arp_timer =
137 { NULL, NULL, ARP_CHECK_INTERVAL, 0L, &arp_check_expire };
138
139
140
141
142
143
144
145 #define DEF_ARP_NETMASK (~0)
146
147
148
149
150
151
152
153
154
155 #define ARP_TABLE_SIZE 16
156
157
158
159
160
161
162 #define FULL_ARP_TABLE_SIZE (ARP_TABLE_SIZE+1)
163
164 struct arp_table *arp_tables[FULL_ARP_TABLE_SIZE] =
165 {
166 NULL,
167 };
168
169
170
171
172
173
174
175 #define HASH(paddr) (htonl(paddr) & (ARP_TABLE_SIZE - 1))
176 #define PROXY_HASH ARP_TABLE_SIZE
177
178
179
180
181
182
183
184
185
186 static void arp_check_expire(unsigned long dummy)
187 {
188 int i;
189 unsigned long now = jiffies;
190 unsigned long flags;
191 save_flags(flags);
192 cli();
193
194 for (i = 0; i < FULL_ARP_TABLE_SIZE; i++)
195 {
196 struct arp_table *entry;
197 struct arp_table **pentry = &arp_tables[i];
198
199 while ((entry = *pentry) != NULL)
200 {
201 if ((now - entry->last_used) > ARP_TIMEOUT
202 && !(entry->flags & ATF_PERM))
203 {
204 *pentry = entry->next;
205 del_timer(&entry->timer);
206 kfree_s(entry, sizeof(struct arp_table));
207 }
208 else
209 pentry = &entry->next;
210 }
211 }
212 restore_flags(flags);
213
214
215
216
217
218 del_timer(&arp_timer);
219 arp_timer.expires = ARP_CHECK_INTERVAL;
220 add_timer(&arp_timer);
221 }
222
223
224
225
226
227
228 static void arp_release_entry(struct arp_table *entry)
229 {
230 struct sk_buff *skb;
231 unsigned long flags;
232
233 save_flags(flags);
234 cli();
235
236 while ((skb = skb_dequeue(&entry->skb)) != NULL)
237 {
238 skb_device_lock(skb);
239 restore_flags(flags);
240 dev_kfree_skb(skb, FREE_WRITE);
241 }
242 restore_flags(flags);
243 del_timer(&entry->timer);
244 kfree_s(entry, sizeof(struct arp_table));
245 return;
246 }
247
248
249
250
251
252 int arp_device_event(unsigned long event, void *ptr)
253 {
254 struct device *dev=ptr;
255 int i;
256 unsigned long flags;
257
258 if(event!=NETDEV_DOWN)
259 return NOTIFY_DONE;
260
261
262
263
264 save_flags(flags);
265 cli();
266 for (i = 0; i < FULL_ARP_TABLE_SIZE; i++)
267 {
268 struct arp_table *entry;
269 struct arp_table **pentry = &arp_tables[i];
270
271 while ((entry = *pentry) != NULL)
272 {
273 if(entry->dev==dev)
274 {
275 *pentry = entry->next;
276 del_timer(&entry->timer);
277 kfree_s(entry, sizeof(struct arp_table));
278 }
279 else
280 pentry = &entry->next;
281 }
282 }
283 restore_flags(flags);
284 return NOTIFY_DONE;
285 }
286
287
288
289
290
291
292
293 void arp_send(int type, int ptype, unsigned long dest_ip,
294 struct device *dev, unsigned long src_ip,
295 unsigned char *dest_hw, unsigned char *src_hw)
296 {
297 struct sk_buff *skb;
298 struct arphdr *arp;
299 unsigned char *arp_ptr;
300
301
302
303
304
305 if(dev->flags&IFF_NOARP)
306 return;
307
308
309
310
311
312 skb = alloc_skb(sizeof(struct arphdr)+ 2*(dev->addr_len+4)
313 + dev->hard_header_len, GFP_ATOMIC);
314 if (skb == NULL)
315 {
316 printk("ARP: no memory to send an arp packet\n");
317 return;
318 }
319 skb->len = sizeof(struct arphdr) + dev->hard_header_len + 2*(dev->addr_len+4);
320 skb->arp = 1;
321 skb->dev = dev;
322 skb->free = 1;
323
324
325
326
327
328 dev->hard_header(skb->data,dev,ptype,dest_hw?dest_hw:dev->broadcast,src_hw?src_hw:NULL,skb->len,skb);
329
330
331 arp = (struct arphdr *) (skb->data + dev->hard_header_len);
332 arp->ar_hrd = htons(dev->type);
333 #ifdef CONFIG_AX25
334 arp->ar_pro = (dev->type != ARPHRD_AX25)? htons(ETH_P_IP) : htons(AX25_P_IP);
335 #else
336 arp->ar_pro = htons(ETH_P_IP);
337 #endif
338 arp->ar_hln = dev->addr_len;
339 arp->ar_pln = 4;
340 arp->ar_op = htons(type);
341
342 arp_ptr=(unsigned char *)(arp+1);
343
344 memcpy(arp_ptr, src_hw, dev->addr_len);
345 arp_ptr+=dev->addr_len;
346 memcpy(arp_ptr, &src_ip,4);
347 arp_ptr+=4;
348 if (dest_hw != NULL)
349 memcpy(arp_ptr, dest_hw, dev->addr_len);
350 else
351 memset(arp_ptr, 0, dev->addr_len);
352 arp_ptr+=dev->addr_len;
353 memcpy(arp_ptr, &dest_ip, 4);
354
355 dev_queue_xmit(skb, dev, 0);
356 }
357
358
359
360
361
362
363
364 static void arp_expire_request (unsigned long arg)
365 {
366 struct arp_table *entry = (struct arp_table *) arg;
367 struct arp_table **pentry;
368 unsigned long hash;
369 unsigned long flags;
370
371 save_flags(flags);
372 cli();
373
374
375
376
377
378
379
380 if (entry->flags & ATF_COM)
381 {
382 restore_flags(flags);
383 return;
384 }
385
386 if (--entry->retries > 0)
387 {
388 unsigned long ip = entry->ip;
389 struct device *dev = entry->dev;
390
391
392 del_timer(&entry->timer);
393 entry->timer.expires = ARP_RES_TIME;
394 add_timer(&entry->timer);
395 restore_flags(flags);
396 arp_send(ARPOP_REQUEST, ETH_P_ARP, ip, dev, dev->pa_addr,
397 NULL, dev->dev_addr);
398 return;
399 }
400
401
402
403
404
405
406
407
408 hash = HASH(entry->ip);
409
410
411
412
413 if (entry->flags & ATF_PUBL)
414 pentry = &arp_tables[PROXY_HASH];
415 else
416 pentry = &arp_tables[hash];
417 while (*pentry != NULL)
418 {
419 if (*pentry == entry)
420 {
421 *pentry = entry->next;
422 del_timer(&entry->timer);
423 restore_flags(flags);
424 arp_release_entry(entry);
425 return;
426 }
427 pentry = &(*pentry)->next;
428 }
429 restore_flags(flags);
430 printk("Possible ARP queue corruption.\n");
431
432
433
434 }
435
436
437
438
439
440
441 static void arp_send_q(struct arp_table *entry, unsigned char *hw_dest)
442 {
443 struct sk_buff *skb;
444
445 unsigned long flags;
446
447
448
449
450
451 if(!(entry->flags&ATF_COM))
452 {
453 printk("arp_send_q: incomplete entry for %s\n",
454 in_ntoa(entry->ip));
455 return;
456 }
457
458 save_flags(flags);
459
460 cli();
461 while((skb = skb_dequeue(&entry->skb)) != NULL)
462 {
463 IS_SKB(skb);
464 skb_device_lock(skb);
465 restore_flags(flags);
466 if(!skb->dev->rebuild_header(skb->data,skb->dev,skb->raddr,skb))
467 {
468 skb->arp = 1;
469 if(skb->sk==NULL)
470 dev_queue_xmit(skb, skb->dev, 0);
471 else
472 dev_queue_xmit(skb,skb->dev,skb->sk->priority);
473 }
474 else
475 {
476
477
478 printk("arp_send_q: The impossible occurred. Please notify Alan.\n");
479 printk("arp_send_q: active entity %s\n",in_ntoa(entry->ip));
480 printk("arp_send_q: failed to find %s\n",in_ntoa(skb->raddr));
481 }
482 }
483 restore_flags(flags);
484 }
485
486
487
488
489
490
491 void arp_destroy(unsigned long ip_addr, int force)
492 {
493 int checked_proxies = 0;
494 struct arp_table *entry;
495 struct arp_table **pentry;
496 unsigned long hash = HASH(ip_addr);
497
498 cli();
499 pentry = &arp_tables[hash];
500 if (! *pentry)
501 pentry = &arp_tables[PROXY_HASH];
502
503 while ((entry = *pentry) != NULL)
504 {
505 if (entry->ip == ip_addr)
506 {
507 if ((entry->flags & ATF_PERM) && !force)
508 return;
509 *pentry = entry->next;
510 del_timer(&entry->timer);
511 sti();
512 arp_release_entry(entry);
513 return;
514 }
515 pentry = &entry->next;
516 if (!checked_proxies && ! *pentry)
517 {
518
519 checked_proxies = 1;
520 pentry = &arp_tables[PROXY_HASH];
521 }
522 }
523 sti();
524 }
525
526
527
528
529
530
531
532
533 int arp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
534 {
535
536
537
538
539 struct arphdr *arp = (struct arphdr *)skb->h.raw;
540 unsigned char *arp_ptr= (unsigned char *)(arp+1);
541 struct arp_table *entry;
542 struct arp_table *proxy_entry;
543 int addr_hint,hlen,htype;
544 unsigned long hash;
545 unsigned char ha[MAX_ADDR_LEN];
546 long sip,tip;
547 unsigned char *sha,*tha;
548
549
550
551
552
553
554
555
556 if (arp->ar_hln != dev->addr_len ||
557 dev->type != ntohs(arp->ar_hrd) ||
558 dev->flags & IFF_NOARP ||
559 arp->ar_pln != 4)
560 {
561 kfree_skb(skb, FREE_READ);
562 return 0;
563 }
564
565
566
567
568
569
570
571 switch(dev->type)
572 {
573 #ifdef CONFIG_AX25
574 case ARPHRD_AX25:
575 if(arp->ar_pro != htons(AX25_P_IP))
576 {
577 kfree_skb(skb, FREE_READ);
578 return 0;
579 }
580 break;
581 #endif
582 case ARPHRD_ETHER:
583 #ifdef CONFIG_ARCNET
584 case ARPHRD_ARCNET:
585 #endif
586 if(arp->ar_pro != htons(ETH_P_IP))
587 {
588 kfree_skb(skb, FREE_READ);
589 return 0;
590 }
591 break;
592
593 default:
594 printk("ARP: dev->type mangled!\n");
595 kfree_skb(skb, FREE_READ);
596 return 0;
597 }
598
599
600
601
602
603 hlen = dev->addr_len;
604 htype = dev->type;
605
606 sha=arp_ptr;
607 arp_ptr+=hlen;
608 memcpy(&sip,arp_ptr,4);
609 arp_ptr+=4;
610 tha=arp_ptr;
611 arp_ptr+=hlen;
612 memcpy(&tip,arp_ptr,4);
613
614
615
616
617 if(tip == INADDR_LOOPBACK)
618 {
619 kfree_skb(skb, FREE_READ);
620 return 0;
621 }
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640 addr_hint = ip_chk_addr(tip);
641
642 if(arp->ar_op == htons(ARPOP_REPLY))
643 {
644 if(addr_hint!=IS_MYADDR)
645 {
646
647
648
649 kfree_skb(skb, FREE_READ);
650 return 0;
651 }
652
653
654
655 }
656 else
657 {
658
659
660
661 if(addr_hint != IS_MYADDR)
662 {
663
664
665
666
667
668 cli();
669 for(proxy_entry=arp_tables[PROXY_HASH];
670 proxy_entry;
671 proxy_entry = proxy_entry->next)
672 {
673
674
675
676
677
678
679
680
681 if (proxy_entry->htype == htype &&
682 !((proxy_entry->ip^tip)&proxy_entry->mask))
683 break;
684
685 }
686 if (proxy_entry)
687 {
688 memcpy(ha, proxy_entry->ha, hlen);
689 sti();
690 arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,ha);
691 kfree_skb(skb, FREE_READ);
692 return 0;
693 }
694 else
695 {
696 sti();
697 kfree_skb(skb, FREE_READ);
698 return 0;
699 }
700 }
701 else
702 {
703
704
705
706 if(tip==dev->pa_addr)
707 arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr);
708 }
709 }
710
711
712
713
714
715
716
717
718 hash = HASH(sip);
719 cli();
720 for(entry=arp_tables[hash];entry;entry=entry->next)
721 if(entry->ip==sip && entry->htype==htype)
722 break;
723
724 if(entry)
725 {
726
727
728
729 memcpy(entry->ha, sha, hlen);
730 entry->hlen = hlen;
731 entry->last_used = jiffies;
732 if (!(entry->flags & ATF_COM))
733 {
734
735
736
737
738 del_timer(&entry->timer);
739 entry->flags |= ATF_COM;
740 sti();
741
742
743
744
745
746 arp_send_q(entry, sha);
747 }
748 else
749 {
750 sti();
751 }
752 }
753 else
754 {
755
756
757
758 entry = (struct arp_table *)kmalloc(sizeof(struct arp_table),GFP_ATOMIC);
759 if(entry == NULL)
760 {
761 sti();
762 printk("ARP: no memory for new arp entry\n");
763
764 kfree_skb(skb, FREE_READ);
765 return 0;
766 }
767
768 entry->mask = DEF_ARP_NETMASK;
769 entry->ip = sip;
770 entry->hlen = hlen;
771 entry->htype = htype;
772 entry->flags = ATF_COM;
773 init_timer(&entry->timer);
774 memcpy(entry->ha, sha, hlen);
775 entry->last_used = jiffies;
776 entry->dev = skb->dev;
777 skb_queue_head_init(&entry->skb);
778 entry->next = arp_tables[hash];
779 arp_tables[hash] = entry;
780 sti();
781 }
782
783
784
785
786 kfree_skb(skb, FREE_READ);
787 return 0;
788 }
789
790
791
792
793
794
795 int arp_find(unsigned char *haddr, unsigned long paddr, struct device *dev,
796 unsigned long saddr, struct sk_buff *skb)
797 {
798 struct arp_table *entry;
799 unsigned long hash;
800 #ifdef CONFIG_IP_MULTICAST
801 unsigned long taddr;
802 #endif
803
804 switch (ip_chk_addr(paddr))
805 {
806 case IS_MYADDR:
807 printk("ARP: arp called for own IP address\n");
808 memcpy(haddr, dev->dev_addr, dev->addr_len);
809 skb->arp = 1;
810 return 0;
811 #ifdef CONFIG_IP_MULTICAST
812 case IS_MULTICAST:
813 if(dev->type==ARPHRD_ETHER || dev->type==ARPHRD_IEEE802)
814 {
815 haddr[0]=0x01;
816 haddr[1]=0x00;
817 haddr[2]=0x5e;
818 taddr=ntohl(paddr);
819 haddr[5]=taddr&0xff;
820 taddr=taddr>>8;
821 haddr[4]=taddr&0xff;
822 taddr=taddr>>8;
823 haddr[3]=taddr&0x7f;
824 return 0;
825 }
826
827
828
829 #endif
830
831 case IS_BROADCAST:
832 memcpy(haddr, dev->broadcast, dev->addr_len);
833 skb->arp = 1;
834 return 0;
835 }
836
837 hash = HASH(paddr);
838 cli();
839
840
841
842
843 entry = arp_lookup(paddr, 0);
844
845 if (entry != NULL)
846 {
847 if (!(entry->flags & ATF_COM))
848 {
849
850
851
852
853
854 if (skb != NULL)
855 {
856 skb_queue_tail(&entry->skb, skb);
857 skb_device_unlock(skb);
858 }
859 sti();
860 return 1;
861 }
862
863
864
865
866
867 entry->last_used = jiffies;
868 memcpy(haddr, entry->ha, dev->addr_len);
869 if (skb)
870 skb->arp = 1;
871 sti();
872 return 0;
873 }
874
875
876
877
878
879 entry = (struct arp_table *) kmalloc(sizeof(struct arp_table),
880 GFP_ATOMIC);
881 if (entry != NULL)
882 {
883 entry->mask = DEF_ARP_NETMASK;
884 entry->ip = paddr;
885 entry->hlen = dev->addr_len;
886 entry->htype = dev->type;
887 entry->flags = 0;
888 memset(entry->ha, 0, dev->addr_len);
889 entry->dev = dev;
890 entry->last_used = jiffies;
891 init_timer(&entry->timer);
892 entry->timer.function = arp_expire_request;
893 entry->timer.data = (unsigned long)entry;
894 entry->timer.expires = ARP_RES_TIME;
895 entry->next = arp_tables[hash];
896 arp_tables[hash] = entry;
897 add_timer(&entry->timer);
898 entry->retries = ARP_MAX_TRIES;
899 skb_queue_head_init(&entry->skb);
900 if (skb != NULL)
901 {
902 skb_queue_tail(&entry->skb, skb);
903 skb_device_unlock(skb);
904 }
905 }
906 else
907 {
908 if (skb != NULL && skb->free)
909 kfree_skb(skb, FREE_WRITE);
910 }
911 sti();
912
913
914
915
916
917 arp_send(ARPOP_REQUEST, ETH_P_ARP, paddr, dev, saddr, NULL,
918 dev->dev_addr);
919
920 return 1;
921 }
922
923
924
925
926
927
928 #define HBUFFERLEN 30
929
930 int arp_get_info(char *buffer, char **start, off_t offset, int length)
931 {
932 int len=0;
933 off_t begin=0;
934 off_t pos=0;
935 int size;
936 struct arp_table *entry;
937 char hbuffer[HBUFFERLEN];
938 int i,j,k;
939 const char hexbuf[] = "0123456789ABCDEF";
940
941 size = sprintf(buffer,"IP address HW type Flags HW address Mask\n");
942
943 pos+=size;
944 len+=size;
945
946 cli();
947 for(i=0; i<FULL_ARP_TABLE_SIZE; i++)
948 {
949 for(entry=arp_tables[i]; entry!=NULL; entry=entry->next)
950 {
951
952
953
954 #ifdef CONFIG_AX25
955
956 if(entry->htype==ARPHRD_AX25)
957 strcpy(hbuffer,ax2asc((ax25_address *)entry->ha));
958 else {
959 #endif
960
961 for(k=0,j=0;k<HBUFFERLEN-3 && j<entry->hlen;j++)
962 {
963 hbuffer[k++]=hexbuf[ (entry->ha[j]>>4)&15 ];
964 hbuffer[k++]=hexbuf[ entry->ha[j]&15 ];
965 hbuffer[k++]=':';
966 }
967 hbuffer[--k]=0;
968
969 #ifdef CONFIG_AX25
970 }
971 #endif
972 size = sprintf(buffer+len,
973 "%-17s0x%-10x0x%-10x%s",
974 in_ntoa(entry->ip),
975 (unsigned int)entry->htype,
976 entry->flags,
977 hbuffer);
978 size += sprintf(buffer+len+size,
979 " %-17s\n",
980 entry->mask==DEF_ARP_NETMASK?
981 "*":in_ntoa(entry->mask));
982
983 len+=size;
984 pos=begin+len;
985
986 if(pos<offset)
987 {
988 len=0;
989 begin=pos;
990 }
991 if(pos>offset+length)
992 break;
993 }
994 }
995 sti();
996
997 *start=buffer+(offset-begin);
998 len-=(offset-begin);
999 if(len>length)
1000 len=length;
1001 return len;
1002 }
1003
1004
1005
1006
1007
1008
1009
1010
1011 static struct arp_table *arp_lookup(unsigned long paddr, int exact)
1012 {
1013 struct arp_table *entry;
1014 unsigned long hash = HASH(paddr);
1015
1016 for (entry = arp_tables[hash]; entry != NULL; entry = entry->next)
1017 if (entry->ip == paddr) break;
1018
1019
1020 if (!entry)
1021 for (entry=arp_tables[PROXY_HASH]; entry != NULL; entry = entry->next)
1022 if (exact? (entry->ip==paddr) : !((entry->ip^paddr)&entry->mask))
1023 break;
1024
1025 return entry;
1026 }
1027
1028
1029
1030
1031
1032
1033 static int arp_req_set(struct arpreq *req)
1034 {
1035 struct arpreq r;
1036 struct arp_table *entry;
1037 struct sockaddr_in *si;
1038 int htype, hlen;
1039 unsigned long ip;
1040 struct rtable *rt;
1041
1042 memcpy_fromfs(&r, req, sizeof(r));
1043
1044
1045 if (r.arp_pa.sa_family != AF_INET)
1046 return -EPFNOSUPPORT;
1047
1048
1049
1050
1051
1052
1053
1054 switch (r.arp_ha.sa_family) {
1055 case ARPHRD_ETHER:
1056 htype = ARPHRD_ETHER;
1057 hlen = ETH_ALEN;
1058 break;
1059 #ifdef CONFIG_ARCNET
1060 case ARPHRD_ARCNET:
1061 htype = ARPHRD_ARCNET;
1062 hlen = 1;
1063 break;
1064 #endif
1065 #ifdef CONFIG_AX25
1066 case ARPHRD_AX25:
1067 htype = ARPHRD_AX25;
1068 hlen = 7;
1069 break;
1070 #endif
1071 default:
1072 return -EPFNOSUPPORT;
1073 }
1074
1075 si = (struct sockaddr_in *) &r.arp_pa;
1076 ip = si->sin_addr.s_addr;
1077 if (ip == 0)
1078 {
1079 printk("ARP: SETARP: requested PA is 0.0.0.0 !\n");
1080 return -EINVAL;
1081 }
1082
1083
1084
1085
1086
1087 rt = ip_rt_route(ip, NULL, NULL);
1088 if (rt == NULL)
1089 return -ENETUNREACH;
1090
1091
1092
1093
1094
1095 cli();
1096
1097
1098
1099
1100 entry = arp_lookup(ip, 1);
1101
1102
1103
1104
1105
1106 if (entry == NULL)
1107 {
1108 unsigned long hash = HASH(ip);
1109 if (r.arp_flags & ATF_PUBL)
1110 hash = PROXY_HASH;
1111
1112 entry = (struct arp_table *) kmalloc(sizeof(struct arp_table),
1113 GFP_ATOMIC);
1114 if (entry == NULL)
1115 {
1116 sti();
1117 return -ENOMEM;
1118 }
1119 entry->ip = ip;
1120 entry->hlen = hlen;
1121 entry->htype = htype;
1122 init_timer(&entry->timer);
1123 entry->next = arp_tables[hash];
1124 arp_tables[hash] = entry;
1125 skb_queue_head_init(&entry->skb);
1126 }
1127
1128
1129
1130
1131 memcpy(&entry->ha, &r.arp_ha.sa_data, hlen);
1132 entry->last_used = jiffies;
1133 entry->flags = r.arp_flags | ATF_COM;
1134 if ((entry->flags & ATF_PUBL) && (entry->flags & ATF_NETMASK))
1135 {
1136 si = (struct sockaddr_in *) &r.arp_netmask;
1137 entry->mask = si->sin_addr.s_addr;
1138 }
1139 else
1140 entry->mask = DEF_ARP_NETMASK;
1141 entry->dev = rt->rt_dev;
1142 sti();
1143
1144 return 0;
1145 }
1146
1147
1148
1149
1150
1151
1152 static int arp_req_get(struct arpreq *req)
1153 {
1154 struct arpreq r;
1155 struct arp_table *entry;
1156 struct sockaddr_in *si;
1157
1158
1159
1160
1161
1162 memcpy_fromfs(&r, req, sizeof(r));
1163
1164 if (r.arp_pa.sa_family != AF_INET)
1165 return -EPFNOSUPPORT;
1166
1167
1168
1169
1170
1171 si = (struct sockaddr_in *) &r.arp_pa;
1172 cli();
1173 entry = arp_lookup(si->sin_addr.s_addr,0);
1174
1175 if (entry == NULL)
1176 {
1177 sti();
1178 return -ENXIO;
1179 }
1180
1181
1182
1183
1184
1185 memcpy(r.arp_ha.sa_data, &entry->ha, entry->hlen);
1186 r.arp_ha.sa_family = entry->htype;
1187 r.arp_flags = entry->flags;
1188 sti();
1189
1190
1191
1192
1193
1194 memcpy_tofs(req, &r, sizeof(r));
1195 return 0;
1196 }
1197
1198
1199
1200
1201
1202
1203 int arp_ioctl(unsigned int cmd, void *arg)
1204 {
1205 struct arpreq r;
1206 struct sockaddr_in *si;
1207 int err;
1208
1209 switch(cmd)
1210 {
1211 case SIOCDARP:
1212 if (!suser())
1213 return -EPERM;
1214 err = verify_area(VERIFY_READ, arg, sizeof(struct arpreq));
1215 if(err)
1216 return err;
1217 memcpy_fromfs(&r, arg, sizeof(r));
1218 if (r.arp_pa.sa_family != AF_INET)
1219 return -EPFNOSUPPORT;
1220 si = (struct sockaddr_in *) &r.arp_pa;
1221 arp_destroy(si->sin_addr.s_addr, 1);
1222 return 0;
1223 case SIOCGARP:
1224 err = verify_area(VERIFY_WRITE, arg, sizeof(struct arpreq));
1225 if(err)
1226 return err;
1227 return arp_req_get((struct arpreq *)arg);
1228 case SIOCSARP:
1229 if (!suser())
1230 return -EPERM;
1231 err = verify_area(VERIFY_READ, arg, sizeof(struct arpreq));
1232 if(err)
1233 return err;
1234 return arp_req_set((struct arpreq *)arg);
1235 default:
1236 return -EINVAL;
1237 }
1238
1239 return 0;
1240 }
1241
1242
1243
1244
1245
1246
1247 static struct packet_type arp_packet_type =
1248 {
1249 0,
1250 NULL,
1251 arp_rcv,
1252 NULL,
1253 NULL
1254 };
1255
1256 static struct notifier_block arp_dev_notifier={
1257 arp_device_event,
1258 NULL,
1259 0
1260 };
1261
1262 void arp_init (void)
1263 {
1264
1265 arp_packet_type.type=htons(ETH_P_ARP);
1266 dev_add_pack(&arp_packet_type);
1267
1268 add_timer(&arp_timer);
1269
1270 register_netdevice_notifier(&arp_dev_notifier);
1271 }
1272