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