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