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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75#include <linux/module.h>
76#include <linux/types.h>
77#include <linux/string.h>
78#include <linux/kernel.h>
79#include <linux/capability.h>
80#include <linux/socket.h>
81#include <linux/sockios.h>
82#include <linux/errno.h>
83#include <linux/in.h>
84#include <linux/mm.h>
85#include <linux/inet.h>
86#include <linux/inetdevice.h>
87#include <linux/netdevice.h>
88#include <linux/etherdevice.h>
89#include <linux/fddidevice.h>
90#include <linux/if_arp.h>
91#include <linux/trdevice.h>
92#include <linux/skbuff.h>
93#include <linux/proc_fs.h>
94#include <linux/seq_file.h>
95#include <linux/stat.h>
96#include <linux/init.h>
97#include <linux/net.h>
98#include <linux/rcupdate.h>
99#include <linux/jhash.h>
100#ifdef CONFIG_SYSCTL
101#include <linux/sysctl.h>
102#endif
103
104#include <net/net_namespace.h>
105#include <net/ip.h>
106#include <net/icmp.h>
107#include <net/route.h>
108#include <net/protocol.h>
109#include <net/tcp.h>
110#include <net/sock.h>
111#include <net/arp.h>
112#include <net/ax25.h>
113#include <net/netrom.h>
114#if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
115#include <net/atmclip.h>
116struct neigh_table *clip_tbl_hook;
117#endif
118
119#include <asm/system.h>
120#include <asm/uaccess.h>
121
122#include <linux/netfilter_arp.h>
123
124
125
126
127static u32 arp_hash(const void *pkey, const struct net_device *dev);
128static int arp_constructor(struct neighbour *neigh);
129static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
130static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
131static void parp_redo(struct sk_buff *skb);
132
133static const struct neigh_ops arp_generic_ops = {
134 .family = AF_INET,
135 .solicit = arp_solicit,
136 .error_report = arp_error_report,
137 .output = neigh_resolve_output,
138 .connected_output = neigh_connected_output,
139 .hh_output = dev_queue_xmit,
140 .queue_xmit = dev_queue_xmit,
141};
142
143static const struct neigh_ops arp_hh_ops = {
144 .family = AF_INET,
145 .solicit = arp_solicit,
146 .error_report = arp_error_report,
147 .output = neigh_resolve_output,
148 .connected_output = neigh_resolve_output,
149 .hh_output = dev_queue_xmit,
150 .queue_xmit = dev_queue_xmit,
151};
152
153static const struct neigh_ops arp_direct_ops = {
154 .family = AF_INET,
155 .output = dev_queue_xmit,
156 .connected_output = dev_queue_xmit,
157 .hh_output = dev_queue_xmit,
158 .queue_xmit = dev_queue_xmit,
159};
160
161const struct neigh_ops arp_broken_ops = {
162 .family = AF_INET,
163 .solicit = arp_solicit,
164 .error_report = arp_error_report,
165 .output = neigh_compat_output,
166 .connected_output = neigh_compat_output,
167 .hh_output = dev_queue_xmit,
168 .queue_xmit = dev_queue_xmit,
169};
170
171struct neigh_table arp_tbl = {
172 .family = AF_INET,
173 .entry_size = sizeof(struct neighbour) + 4,
174 .key_len = 4,
175 .hash = arp_hash,
176 .constructor = arp_constructor,
177 .proxy_redo = parp_redo,
178 .id = "arp_cache",
179 .parms = {
180 .tbl = &arp_tbl,
181 .base_reachable_time = 30 * HZ,
182 .retrans_time = 1 * HZ,
183 .gc_staletime = 60 * HZ,
184 .reachable_time = 30 * HZ,
185 .delay_probe_time = 5 * HZ,
186 .queue_len = 3,
187 .ucast_probes = 3,
188 .mcast_probes = 3,
189 .anycast_delay = 1 * HZ,
190 .proxy_delay = (8 * HZ) / 10,
191 .proxy_qlen = 64,
192 .locktime = 1 * HZ,
193 },
194 .gc_interval = 30 * HZ,
195 .gc_thresh1 = 128,
196 .gc_thresh2 = 512,
197 .gc_thresh3 = 1024,
198};
199
200int arp_mc_map(__be32 addr, u8 *haddr, struct net_device *dev, int dir)
201{
202 switch (dev->type) {
203 case ARPHRD_ETHER:
204 case ARPHRD_FDDI:
205 case ARPHRD_IEEE802:
206 ip_eth_mc_map(addr, haddr);
207 return 0;
208 case ARPHRD_IEEE802_TR:
209 ip_tr_mc_map(addr, haddr);
210 return 0;
211 case ARPHRD_INFINIBAND:
212 ip_ib_mc_map(addr, dev->broadcast, haddr);
213 return 0;
214 default:
215 if (dir) {
216 memcpy(haddr, dev->broadcast, dev->addr_len);
217 return 0;
218 }
219 }
220 return -EINVAL;
221}
222
223
224static u32 arp_hash(const void *pkey, const struct net_device *dev)
225{
226 return jhash_2words(*(u32 *)pkey, dev->ifindex, arp_tbl.hash_rnd);
227}
228
229static int arp_constructor(struct neighbour *neigh)
230{
231 __be32 addr = *(__be32*)neigh->primary_key;
232 struct net_device *dev = neigh->dev;
233 struct in_device *in_dev;
234 struct neigh_parms *parms;
235
236 rcu_read_lock();
237 in_dev = __in_dev_get_rcu(dev);
238 if (in_dev == NULL) {
239 rcu_read_unlock();
240 return -EINVAL;
241 }
242
243 neigh->type = inet_addr_type(dev_net(dev), addr);
244
245 parms = in_dev->arp_parms;
246 __neigh_parms_put(neigh->parms);
247 neigh->parms = neigh_parms_clone(parms);
248 rcu_read_unlock();
249
250 if (!dev->header_ops) {
251 neigh->nud_state = NUD_NOARP;
252 neigh->ops = &arp_direct_ops;
253 neigh->output = neigh->ops->queue_xmit;
254 } else {
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270#if 1
271
272
273
274
275
276
277
278
279
280
281
282 switch (dev->type) {
283 default:
284 break;
285 case ARPHRD_ROSE:
286#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
287 case ARPHRD_AX25:
288#if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
289 case ARPHRD_NETROM:
290#endif
291 neigh->ops = &arp_broken_ops;
292 neigh->output = neigh->ops->output;
293 return 0;
294#endif
295 ;}
296#endif
297 if (neigh->type == RTN_MULTICAST) {
298 neigh->nud_state = NUD_NOARP;
299 arp_mc_map(addr, neigh->ha, dev, 1);
300 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
301 neigh->nud_state = NUD_NOARP;
302 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
303 } else if (neigh->type == RTN_BROADCAST || dev->flags&IFF_POINTOPOINT) {
304 neigh->nud_state = NUD_NOARP;
305 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
306 }
307
308 if (dev->header_ops->cache)
309 neigh->ops = &arp_hh_ops;
310 else
311 neigh->ops = &arp_generic_ops;
312
313 if (neigh->nud_state&NUD_VALID)
314 neigh->output = neigh->ops->connected_output;
315 else
316 neigh->output = neigh->ops->output;
317 }
318 return 0;
319}
320
321static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
322{
323 dst_link_failure(skb);
324 kfree_skb(skb);
325}
326
327static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
328{
329 __be32 saddr = 0;
330 u8 *dst_ha = NULL;
331 struct net_device *dev = neigh->dev;
332 __be32 target = *(__be32*)neigh->primary_key;
333 int probes = atomic_read(&neigh->probes);
334 struct in_device *in_dev = in_dev_get(dev);
335
336 if (!in_dev)
337 return;
338
339 switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {
340 default:
341 case 0:
342 if (skb && inet_addr_type(dev_net(dev), ip_hdr(skb)->saddr) == RTN_LOCAL)
343 saddr = ip_hdr(skb)->saddr;
344 break;
345 case 1:
346 if (!skb)
347 break;
348 saddr = ip_hdr(skb)->saddr;
349 if (inet_addr_type(dev_net(dev), saddr) == RTN_LOCAL) {
350
351 if (inet_addr_onlink(in_dev, target, saddr))
352 break;
353 }
354 saddr = 0;
355 break;
356 case 2:
357 break;
358 }
359
360 if (in_dev)
361 in_dev_put(in_dev);
362 if (!saddr)
363 saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);
364
365 if ((probes -= neigh->parms->ucast_probes) < 0) {
366 if (!(neigh->nud_state&NUD_VALID))
367 printk(KERN_DEBUG "trying to ucast probe in NUD_INVALID\n");
368 dst_ha = neigh->ha;
369 read_lock_bh(&neigh->lock);
370 } else if ((probes -= neigh->parms->app_probes) < 0) {
371#ifdef CONFIG_ARPD
372 neigh_app_ns(neigh);
373#endif
374 return;
375 }
376
377 arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
378 dst_ha, dev->dev_addr, NULL);
379 if (dst_ha)
380 read_unlock_bh(&neigh->lock);
381}
382
383static int arp_ignore(struct in_device *in_dev, __be32 sip, __be32 tip)
384{
385 int scope;
386
387 switch (IN_DEV_ARP_IGNORE(in_dev)) {
388 case 0:
389 return 0;
390 case 1:
391 sip = 0;
392 scope = RT_SCOPE_HOST;
393 break;
394 case 2:
395
396
397
398 scope = RT_SCOPE_HOST;
399 break;
400 case 3:
401 sip = 0;
402 scope = RT_SCOPE_LINK;
403 break;
404 case 4:
405 case 5:
406 case 6:
407 case 7:
408 return 0;
409 case 8:
410 return 1;
411 default:
412 return 0;
413 }
414 return !inet_confirm_addr(in_dev, sip, tip, scope);
415}
416
417static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
418{
419 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = sip,
420 .saddr = tip } } };
421 struct rtable *rt;
422 int flag = 0;
423
424 struct net *net = dev_net(dev);
425
426 if (ip_route_output_key(net, &rt, &fl) < 0)
427 return 1;
428 if (rt->u.dst.dev != dev) {
429 NET_INC_STATS_BH(net, LINUX_MIB_ARPFILTER);
430 flag = 1;
431 }
432 ip_rt_put(rt);
433 return flag;
434}
435
436
437
438
439
440
441
442
443
444
445
446
447static int arp_set_predefined(int addr_hint, unsigned char * haddr, __be32 paddr, struct net_device * dev)
448{
449 switch (addr_hint) {
450 case RTN_LOCAL:
451 printk(KERN_DEBUG "ARP: arp called for own IP address\n");
452 memcpy(haddr, dev->dev_addr, dev->addr_len);
453 return 1;
454 case RTN_MULTICAST:
455 arp_mc_map(paddr, haddr, dev, 1);
456 return 1;
457 case RTN_BROADCAST:
458 memcpy(haddr, dev->broadcast, dev->addr_len);
459 return 1;
460 }
461 return 0;
462}
463
464
465int arp_find(unsigned char *haddr, struct sk_buff *skb)
466{
467 struct net_device *dev = skb->dev;
468 __be32 paddr;
469 struct neighbour *n;
470
471 if (!skb_dst(skb)) {
472 printk(KERN_DEBUG "arp_find is called with dst==NULL\n");
473 kfree_skb(skb);
474 return 1;
475 }
476
477 paddr = skb_rtable(skb)->rt_gateway;
478
479 if (arp_set_predefined(inet_addr_type(dev_net(dev), paddr), haddr, paddr, dev))
480 return 0;
481
482 n = __neigh_lookup(&arp_tbl, &paddr, dev, 1);
483
484 if (n) {
485 n->used = jiffies;
486 if (n->nud_state&NUD_VALID || neigh_event_send(n, skb) == 0) {
487 read_lock_bh(&n->lock);
488 memcpy(haddr, n->ha, dev->addr_len);
489 read_unlock_bh(&n->lock);
490 neigh_release(n);
491 return 0;
492 }
493 neigh_release(n);
494 } else
495 kfree_skb(skb);
496 return 1;
497}
498
499
500
501int arp_bind_neighbour(struct dst_entry *dst)
502{
503 struct net_device *dev = dst->dev;
504 struct neighbour *n = dst->neighbour;
505
506 if (dev == NULL)
507 return -EINVAL;
508 if (n == NULL) {
509 __be32 nexthop = ((struct rtable *)dst)->rt_gateway;
510 if (dev->flags&(IFF_LOOPBACK|IFF_POINTOPOINT))
511 nexthop = 0;
512 n = __neigh_lookup_errno(
513#if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
514 dev->type == ARPHRD_ATM ? clip_tbl_hook :
515#endif
516 &arp_tbl, &nexthop, dev);
517 if (IS_ERR(n))
518 return PTR_ERR(n);
519 dst->neighbour = n;
520 }
521 return 0;
522}
523
524
525
526
527
528static inline int arp_fwd_proxy(struct in_device *in_dev, struct rtable *rt)
529{
530 struct in_device *out_dev;
531 int imi, omi = -1;
532
533 if (!IN_DEV_PROXY_ARP(in_dev))
534 return 0;
535
536 if ((imi = IN_DEV_MEDIUM_ID(in_dev)) == 0)
537 return 1;
538 if (imi == -1)
539 return 0;
540
541
542
543 if ((out_dev = in_dev_get(rt->u.dst.dev)) != NULL) {
544 omi = IN_DEV_MEDIUM_ID(out_dev);
545 in_dev_put(out_dev);
546 }
547 return (omi != imi && omi != -1);
548}
549
550
551
552
553
554
555
556
557
558struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
559 struct net_device *dev, __be32 src_ip,
560 const unsigned char *dest_hw,
561 const unsigned char *src_hw,
562 const unsigned char *target_hw)
563{
564 struct sk_buff *skb;
565 struct arphdr *arp;
566 unsigned char *arp_ptr;
567
568
569
570
571
572 skb = alloc_skb(arp_hdr_len(dev) + LL_ALLOCATED_SPACE(dev), GFP_ATOMIC);
573 if (skb == NULL)
574 return NULL;
575
576 skb_reserve(skb, LL_RESERVED_SPACE(dev));
577 skb_reset_network_header(skb);
578 arp = (struct arphdr *) skb_put(skb, arp_hdr_len(dev));
579 skb->dev = dev;
580 skb->protocol = htons(ETH_P_ARP);
581 if (src_hw == NULL)
582 src_hw = dev->dev_addr;
583 if (dest_hw == NULL)
584 dest_hw = dev->broadcast;
585
586
587
588
589 if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)
590 goto out;
591
592
593
594
595
596
597
598
599
600
601
602 switch (dev->type) {
603 default:
604 arp->ar_hrd = htons(dev->type);
605 arp->ar_pro = htons(ETH_P_IP);
606 break;
607
608#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
609 case ARPHRD_AX25:
610 arp->ar_hrd = htons(ARPHRD_AX25);
611 arp->ar_pro = htons(AX25_P_IP);
612 break;
613
614#if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
615 case ARPHRD_NETROM:
616 arp->ar_hrd = htons(ARPHRD_NETROM);
617 arp->ar_pro = htons(AX25_P_IP);
618 break;
619#endif
620#endif
621
622#ifdef CONFIG_FDDI
623 case ARPHRD_FDDI:
624 arp->ar_hrd = htons(ARPHRD_ETHER);
625 arp->ar_pro = htons(ETH_P_IP);
626 break;
627#endif
628#ifdef CONFIG_TR
629 case ARPHRD_IEEE802_TR:
630 arp->ar_hrd = htons(ARPHRD_IEEE802);
631 arp->ar_pro = htons(ETH_P_IP);
632 break;
633#endif
634 }
635
636 arp->ar_hln = dev->addr_len;
637 arp->ar_pln = 4;
638 arp->ar_op = htons(type);
639
640 arp_ptr=(unsigned char *)(arp+1);
641
642 memcpy(arp_ptr, src_hw, dev->addr_len);
643 arp_ptr += dev->addr_len;
644 memcpy(arp_ptr, &src_ip, 4);
645 arp_ptr += 4;
646 if (target_hw != NULL)
647 memcpy(arp_ptr, target_hw, dev->addr_len);
648 else
649 memset(arp_ptr, 0, dev->addr_len);
650 arp_ptr += dev->addr_len;
651 memcpy(arp_ptr, &dest_ip, 4);
652
653 return skb;
654
655out:
656 kfree_skb(skb);
657 return NULL;
658}
659
660
661
662
663void arp_xmit(struct sk_buff *skb)
664{
665
666 NF_HOOK(NFPROTO_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit);
667}
668
669
670
671
672void arp_send(int type, int ptype, __be32 dest_ip,
673 struct net_device *dev, __be32 src_ip,
674 const unsigned char *dest_hw, const unsigned char *src_hw,
675 const unsigned char *target_hw)
676{
677 struct sk_buff *skb;
678
679
680
681
682
683 if (dev->flags&IFF_NOARP)
684 return;
685
686 skb = arp_create(type, ptype, dest_ip, dev, src_ip,
687 dest_hw, src_hw, target_hw);
688 if (skb == NULL) {
689 return;
690 }
691
692 arp_xmit(skb);
693}
694
695
696
697
698
699static int arp_process(struct sk_buff *skb)
700{
701 struct net_device *dev = skb->dev;
702 struct in_device *in_dev = in_dev_get(dev);
703 struct arphdr *arp;
704 unsigned char *arp_ptr;
705 struct rtable *rt;
706 unsigned char *sha;
707 __be32 sip, tip;
708 u16 dev_type = dev->type;
709 int addr_type;
710 struct neighbour *n;
711 struct net *net = dev_net(dev);
712
713
714
715
716
717 if (in_dev == NULL)
718 goto out;
719
720 arp = arp_hdr(skb);
721
722 switch (dev_type) {
723 default:
724 if (arp->ar_pro != htons(ETH_P_IP) ||
725 htons(dev_type) != arp->ar_hrd)
726 goto out;
727 break;
728 case ARPHRD_ETHER:
729 case ARPHRD_IEEE802_TR:
730 case ARPHRD_FDDI:
731 case ARPHRD_IEEE802:
732
733
734
735
736
737
738
739
740
741 if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
742 arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
743 arp->ar_pro != htons(ETH_P_IP))
744 goto out;
745 break;
746 case ARPHRD_AX25:
747 if (arp->ar_pro != htons(AX25_P_IP) ||
748 arp->ar_hrd != htons(ARPHRD_AX25))
749 goto out;
750 break;
751 case ARPHRD_NETROM:
752 if (arp->ar_pro != htons(AX25_P_IP) ||
753 arp->ar_hrd != htons(ARPHRD_NETROM))
754 goto out;
755 break;
756 }
757
758
759
760 if (arp->ar_op != htons(ARPOP_REPLY) &&
761 arp->ar_op != htons(ARPOP_REQUEST))
762 goto out;
763
764
765
766
767 arp_ptr= (unsigned char *)(arp+1);
768 sha = arp_ptr;
769 arp_ptr += dev->addr_len;
770 memcpy(&sip, arp_ptr, 4);
771 arp_ptr += 4;
772 arp_ptr += dev->addr_len;
773 memcpy(&tip, arp_ptr, 4);
774
775
776
777
778 if (ipv4_is_loopback(tip) || ipv4_is_multicast(tip))
779 goto out;
780
781
782
783
784 if (dev_type == ARPHRD_DLCI)
785 sha = dev->broadcast;
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805 if (sip == 0) {
806 if (arp->ar_op == htons(ARPOP_REQUEST) &&
807 inet_addr_type(net, tip) == RTN_LOCAL &&
808 !arp_ignore(in_dev, sip, tip))
809 arp_send(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
810 dev->dev_addr, sha);
811 goto out;
812 }
813
814 if (arp->ar_op == htons(ARPOP_REQUEST) &&
815 ip_route_input(skb, tip, sip, 0, dev) == 0) {
816
817 rt = skb_rtable(skb);
818 addr_type = rt->rt_type;
819
820 if (addr_type == RTN_LOCAL) {
821 int dont_send = 0;
822
823 if (!dont_send)
824 dont_send |= arp_ignore(in_dev,sip,tip);
825 if (!dont_send && IN_DEV_ARPFILTER(in_dev))
826 dont_send |= arp_filter(sip,tip,dev);
827 if (!dont_send) {
828 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
829 if (n) {
830 arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha);
831 neigh_release(n);
832 }
833 }
834 goto out;
835 } else if (IN_DEV_FORWARD(in_dev)) {
836 if (addr_type == RTN_UNICAST && rt->u.dst.dev != dev &&
837 (arp_fwd_proxy(in_dev, rt) || pneigh_lookup(&arp_tbl, net, &tip, dev, 0))) {
838 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
839 if (n)
840 neigh_release(n);
841
842 if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
843 skb->pkt_type == PACKET_HOST ||
844 in_dev->arp_parms->proxy_delay == 0) {
845 arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha);
846 } else {
847 pneigh_enqueue(&arp_tbl, in_dev->arp_parms, skb);
848 in_dev_put(in_dev);
849 return 0;
850 }
851 goto out;
852 }
853 }
854 }
855
856
857
858 n = __neigh_lookup(&arp_tbl, &sip, dev, 0);
859
860 if (IPV4_DEVCONF_ALL(dev_net(dev), ARP_ACCEPT)) {
861
862
863
864
865 if (n == NULL &&
866 arp->ar_op == htons(ARPOP_REPLY) &&
867 inet_addr_type(net, sip) == RTN_UNICAST)
868 n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
869 }
870
871 if (n) {
872 int state = NUD_REACHABLE;
873 int override;
874
875
876
877
878
879
880 override = time_after(jiffies, n->updated + n->parms->locktime);
881
882
883
884
885 if (arp->ar_op != htons(ARPOP_REPLY) ||
886 skb->pkt_type != PACKET_HOST)
887 state = NUD_STALE;
888 neigh_update(n, sha, state, override ? NEIGH_UPDATE_F_OVERRIDE : 0);
889 neigh_release(n);
890 }
891
892out:
893 if (in_dev)
894 in_dev_put(in_dev);
895 consume_skb(skb);
896 return 0;
897}
898
899static void parp_redo(struct sk_buff *skb)
900{
901 arp_process(skb);
902}
903
904
905
906
907
908
909static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
910 struct packet_type *pt, struct net_device *orig_dev)
911{
912 struct arphdr *arp;
913
914
915 if (!pskb_may_pull(skb, arp_hdr_len(dev)))
916 goto freeskb;
917
918 arp = arp_hdr(skb);
919 if (arp->ar_hln != dev->addr_len ||
920 dev->flags & IFF_NOARP ||
921 skb->pkt_type == PACKET_OTHERHOST ||
922 skb->pkt_type == PACKET_LOOPBACK ||
923 arp->ar_pln != 4)
924 goto freeskb;
925
926 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
927 goto out_of_mem;
928
929 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
930
931 return NF_HOOK(NFPROTO_ARP, NF_ARP_IN, skb, dev, NULL, arp_process);
932
933freeskb:
934 kfree_skb(skb);
935out_of_mem:
936 return 0;
937}
938
939
940
941
942
943
944
945
946
947static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on)
948{
949 if (dev == NULL) {
950 IPV4_DEVCONF_ALL(net, PROXY_ARP) = on;
951 return 0;
952 }
953 if (__in_dev_get_rtnl(dev)) {
954 IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, on);
955 return 0;
956 }
957 return -ENXIO;
958}
959
960static int arp_req_set_public(struct net *net, struct arpreq *r,
961 struct net_device *dev)
962{
963 __be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
964 __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
965
966 if (mask && mask != htonl(0xFFFFFFFF))
967 return -EINVAL;
968 if (!dev && (r->arp_flags & ATF_COM)) {
969 dev = dev_getbyhwaddr(net, r->arp_ha.sa_family,
970 r->arp_ha.sa_data);
971 if (!dev)
972 return -ENODEV;
973 }
974 if (mask) {
975 if (pneigh_lookup(&arp_tbl, net, &ip, dev, 1) == NULL)
976 return -ENOBUFS;
977 return 0;
978 }
979
980 return arp_req_set_proxy(net, dev, 1);
981}
982
983static int arp_req_set(struct net *net, struct arpreq *r,
984 struct net_device * dev)
985{
986 __be32 ip;
987 struct neighbour *neigh;
988 int err;
989
990 if (r->arp_flags & ATF_PUBL)
991 return arp_req_set_public(net, r, dev);
992
993 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
994 if (r->arp_flags & ATF_PERM)
995 r->arp_flags |= ATF_COM;
996 if (dev == NULL) {
997 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip,
998 .tos = RTO_ONLINK } } };
999 struct rtable * rt;
1000 if ((err = ip_route_output_key(net, &rt, &fl)) != 0)
1001 return err;
1002 dev = rt->u.dst.dev;
1003 ip_rt_put(rt);
1004 if (!dev)
1005 return -EINVAL;
1006 }
1007 switch (dev->type) {
1008#ifdef CONFIG_FDDI
1009 case ARPHRD_FDDI:
1010
1011
1012
1013
1014
1015
1016 if (r->arp_ha.sa_family != ARPHRD_FDDI &&
1017 r->arp_ha.sa_family != ARPHRD_ETHER &&
1018 r->arp_ha.sa_family != ARPHRD_IEEE802)
1019 return -EINVAL;
1020 break;
1021#endif
1022 default:
1023 if (r->arp_ha.sa_family != dev->type)
1024 return -EINVAL;
1025 break;
1026 }
1027
1028 neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev);
1029 err = PTR_ERR(neigh);
1030 if (!IS_ERR(neigh)) {
1031 unsigned state = NUD_STALE;
1032 if (r->arp_flags & ATF_PERM)
1033 state = NUD_PERMANENT;
1034 err = neigh_update(neigh, (r->arp_flags&ATF_COM) ?
1035 r->arp_ha.sa_data : NULL, state,
1036 NEIGH_UPDATE_F_OVERRIDE|
1037 NEIGH_UPDATE_F_ADMIN);
1038 neigh_release(neigh);
1039 }
1040 return err;
1041}
1042
1043static unsigned arp_state_to_flags(struct neighbour *neigh)
1044{
1045 unsigned flags = 0;
1046 if (neigh->nud_state&NUD_PERMANENT)
1047 flags = ATF_PERM|ATF_COM;
1048 else if (neigh->nud_state&NUD_VALID)
1049 flags = ATF_COM;
1050 return flags;
1051}
1052
1053
1054
1055
1056
1057static int arp_req_get(struct arpreq *r, struct net_device *dev)
1058{
1059 __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1060 struct neighbour *neigh;
1061 int err = -ENXIO;
1062
1063 neigh = neigh_lookup(&arp_tbl, &ip, dev);
1064 if (neigh) {
1065 read_lock_bh(&neigh->lock);
1066 memcpy(r->arp_ha.sa_data, neigh->ha, dev->addr_len);
1067 r->arp_flags = arp_state_to_flags(neigh);
1068 read_unlock_bh(&neigh->lock);
1069 r->arp_ha.sa_family = dev->type;
1070 strlcpy(r->arp_dev, dev->name, sizeof(r->arp_dev));
1071 neigh_release(neigh);
1072 err = 0;
1073 }
1074 return err;
1075}
1076
1077static int arp_req_delete_public(struct net *net, struct arpreq *r,
1078 struct net_device *dev)
1079{
1080 __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1081 __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1082
1083 if (mask == htonl(0xFFFFFFFF))
1084 return pneigh_delete(&arp_tbl, net, &ip, dev);
1085
1086 if (mask)
1087 return -EINVAL;
1088
1089 return arp_req_set_proxy(net, dev, 0);
1090}
1091
1092static int arp_req_delete(struct net *net, struct arpreq *r,
1093 struct net_device * dev)
1094{
1095 int err;
1096 __be32 ip;
1097 struct neighbour *neigh;
1098
1099 if (r->arp_flags & ATF_PUBL)
1100 return arp_req_delete_public(net, r, dev);
1101
1102 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1103 if (dev == NULL) {
1104 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip,
1105 .tos = RTO_ONLINK } } };
1106 struct rtable * rt;
1107 if ((err = ip_route_output_key(net, &rt, &fl)) != 0)
1108 return err;
1109 dev = rt->u.dst.dev;
1110 ip_rt_put(rt);
1111 if (!dev)
1112 return -EINVAL;
1113 }
1114 err = -ENXIO;
1115 neigh = neigh_lookup(&arp_tbl, &ip, dev);
1116 if (neigh) {
1117 if (neigh->nud_state&~NUD_NOARP)
1118 err = neigh_update(neigh, NULL, NUD_FAILED,
1119 NEIGH_UPDATE_F_OVERRIDE|
1120 NEIGH_UPDATE_F_ADMIN);
1121 neigh_release(neigh);
1122 }
1123 return err;
1124}
1125
1126
1127
1128
1129
1130int arp_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1131{
1132 int err;
1133 struct arpreq r;
1134 struct net_device *dev = NULL;
1135
1136 switch (cmd) {
1137 case SIOCDARP:
1138 case SIOCSARP:
1139 if (!capable(CAP_NET_ADMIN))
1140 return -EPERM;
1141 case SIOCGARP:
1142 err = copy_from_user(&r, arg, sizeof(struct arpreq));
1143 if (err)
1144 return -EFAULT;
1145 break;
1146 default:
1147 return -EINVAL;
1148 }
1149
1150 if (r.arp_pa.sa_family != AF_INET)
1151 return -EPFNOSUPPORT;
1152
1153 if (!(r.arp_flags & ATF_PUBL) &&
1154 (r.arp_flags & (ATF_NETMASK|ATF_DONTPUB)))
1155 return -EINVAL;
1156 if (!(r.arp_flags & ATF_NETMASK))
1157 ((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr =
1158 htonl(0xFFFFFFFFUL);
1159 rtnl_lock();
1160 if (r.arp_dev[0]) {
1161 err = -ENODEV;
1162 if ((dev = __dev_get_by_name(net, r.arp_dev)) == NULL)
1163 goto out;
1164
1165
1166 if (!r.arp_ha.sa_family)
1167 r.arp_ha.sa_family = dev->type;
1168 err = -EINVAL;
1169 if ((r.arp_flags & ATF_COM) && r.arp_ha.sa_family != dev->type)
1170 goto out;
1171 } else if (cmd == SIOCGARP) {
1172 err = -ENODEV;
1173 goto out;
1174 }
1175
1176 switch (cmd) {
1177 case SIOCDARP:
1178 err = arp_req_delete(net, &r, dev);
1179 break;
1180 case SIOCSARP:
1181 err = arp_req_set(net, &r, dev);
1182 break;
1183 case SIOCGARP:
1184 err = arp_req_get(&r, dev);
1185 if (!err && copy_to_user(arg, &r, sizeof(r)))
1186 err = -EFAULT;
1187 break;
1188 }
1189out:
1190 rtnl_unlock();
1191 return err;
1192}
1193
1194static int arp_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1195{
1196 struct net_device *dev = ptr;
1197
1198 switch (event) {
1199 case NETDEV_CHANGEADDR:
1200 neigh_changeaddr(&arp_tbl, dev);
1201 rt_cache_flush(dev_net(dev), 0);
1202 break;
1203 default:
1204 break;
1205 }
1206
1207 return NOTIFY_DONE;
1208}
1209
1210static struct notifier_block arp_netdev_notifier = {
1211 .notifier_call = arp_netdev_event,
1212};
1213
1214
1215
1216
1217
1218void arp_ifdown(struct net_device *dev)
1219{
1220 neigh_ifdown(&arp_tbl, dev);
1221}
1222
1223
1224
1225
1226
1227
1228static struct packet_type arp_packet_type __read_mostly = {
1229 .type = cpu_to_be16(ETH_P_ARP),
1230 .func = arp_rcv,
1231};
1232
1233static int arp_proc_init(void);
1234
1235void __init arp_init(void)
1236{
1237 neigh_table_init(&arp_tbl);
1238
1239 dev_add_pack(&arp_packet_type);
1240 arp_proc_init();
1241#ifdef CONFIG_SYSCTL
1242 neigh_sysctl_register(NULL, &arp_tbl.parms, NET_IPV4,
1243 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1244#endif
1245 register_netdevice_notifier(&arp_netdev_notifier);
1246}
1247
1248#ifdef CONFIG_PROC_FS
1249#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1250
1251
1252
1253
1254
1255static char *ax2asc2(ax25_address *a, char *buf)
1256{
1257 char c, *s;
1258 int n;
1259
1260 for (n = 0, s = buf; n < 6; n++) {
1261 c = (a->ax25_call[n] >> 1) & 0x7F;
1262
1263 if (c != ' ') *s++ = c;
1264 }
1265
1266 *s++ = '-';
1267
1268 if ((n = ((a->ax25_call[6] >> 1) & 0x0F)) > 9) {
1269 *s++ = '1';
1270 n -= 10;
1271 }
1272
1273 *s++ = n + '0';
1274 *s++ = '\0';
1275
1276 if (*buf == '\0' || *buf == '-')
1277 return "*";
1278
1279 return buf;
1280
1281}
1282#endif
1283
1284#define HBUFFERLEN 30
1285
1286static void arp_format_neigh_entry(struct seq_file *seq,
1287 struct neighbour *n)
1288{
1289 char hbuffer[HBUFFERLEN];
1290 int k, j;
1291 char tbuf[16];
1292 struct net_device *dev = n->dev;
1293 int hatype = dev->type;
1294
1295 read_lock(&n->lock);
1296
1297#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1298 if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM)
1299 ax2asc2((ax25_address *)n->ha, hbuffer);
1300 else {
1301#endif
1302 for (k = 0, j = 0; k < HBUFFERLEN - 3 && j < dev->addr_len; j++) {
1303 hbuffer[k++] = hex_asc_hi(n->ha[j]);
1304 hbuffer[k++] = hex_asc_lo(n->ha[j]);
1305 hbuffer[k++] = ':';
1306 }
1307 if (k != 0)
1308 --k;
1309 hbuffer[k] = 0;
1310#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1311 }
1312#endif
1313 sprintf(tbuf, "%pI4", n->primary_key);
1314 seq_printf(seq, "%-16s 0x%-10x0x%-10x%s * %s\n",
1315 tbuf, hatype, arp_state_to_flags(n), hbuffer, dev->name);
1316 read_unlock(&n->lock);
1317}
1318
1319static void arp_format_pneigh_entry(struct seq_file *seq,
1320 struct pneigh_entry *n)
1321{
1322 struct net_device *dev = n->dev;
1323 int hatype = dev ? dev->type : 0;
1324 char tbuf[16];
1325
1326 sprintf(tbuf, "%pI4", n->key);
1327 seq_printf(seq, "%-16s 0x%-10x0x%-10x%s * %s\n",
1328 tbuf, hatype, ATF_PUBL | ATF_PERM, "00:00:00:00:00:00",
1329 dev ? dev->name : "*");
1330}
1331
1332static int arp_seq_show(struct seq_file *seq, void *v)
1333{
1334 if (v == SEQ_START_TOKEN) {
1335 seq_puts(seq, "IP address HW type Flags "
1336 "HW address Mask Device\n");
1337 } else {
1338 struct neigh_seq_state *state = seq->private;
1339
1340 if (state->flags & NEIGH_SEQ_IS_PNEIGH)
1341 arp_format_pneigh_entry(seq, v);
1342 else
1343 arp_format_neigh_entry(seq, v);
1344 }
1345
1346 return 0;
1347}
1348
1349static void *arp_seq_start(struct seq_file *seq, loff_t *pos)
1350{
1351
1352
1353
1354 return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_SKIP_NOARP);
1355}
1356
1357
1358
1359static const struct seq_operations arp_seq_ops = {
1360 .start = arp_seq_start,
1361 .next = neigh_seq_next,
1362 .stop = neigh_seq_stop,
1363 .show = arp_seq_show,
1364};
1365
1366static int arp_seq_open(struct inode *inode, struct file *file)
1367{
1368 return seq_open_net(inode, file, &arp_seq_ops,
1369 sizeof(struct neigh_seq_state));
1370}
1371
1372static const struct file_operations arp_seq_fops = {
1373 .owner = THIS_MODULE,
1374 .open = arp_seq_open,
1375 .read = seq_read,
1376 .llseek = seq_lseek,
1377 .release = seq_release_net,
1378};
1379
1380
1381static int __net_init arp_net_init(struct net *net)
1382{
1383 if (!proc_net_fops_create(net, "arp", S_IRUGO, &arp_seq_fops))
1384 return -ENOMEM;
1385 return 0;
1386}
1387
1388static void __net_exit arp_net_exit(struct net *net)
1389{
1390 proc_net_remove(net, "arp");
1391}
1392
1393static struct pernet_operations arp_net_ops = {
1394 .init = arp_net_init,
1395 .exit = arp_net_exit,
1396};
1397
1398static int __init arp_proc_init(void)
1399{
1400 return register_pernet_subsys(&arp_net_ops);
1401}
1402
1403#else
1404
1405static int __init arp_proc_init(void)
1406{
1407 return 0;
1408}
1409
1410#endif
1411
1412EXPORT_SYMBOL(arp_broken_ops);
1413EXPORT_SYMBOL(arp_find);
1414EXPORT_SYMBOL(arp_create);
1415EXPORT_SYMBOL(arp_xmit);
1416EXPORT_SYMBOL(arp_send);
1417EXPORT_SYMBOL(arp_tbl);
1418
1419#if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
1420EXPORT_SYMBOL(clip_tbl_hook);
1421#endif
1422