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