xref: /linux/net/ipv4/arp.c (revision 621cde16e49b3ecf7d59a8106a20aaebfb4a59a9)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* linux/net/ipv4/arp.c
3  *
4  * Copyright (C) 1994 by Florian  La Roche
5  *
6  * This module implements the Address Resolution Protocol ARP (RFC 826),
7  * which is used to convert IP addresses (or in the future maybe other
8  * high-level addresses) into a low-level hardware address (like an Ethernet
9  * address).
10  *
11  * Fixes:
12  *		Alan Cox	:	Removed the Ethernet assumptions in
13  *					Florian's code
14  *		Alan Cox	:	Fixed some small errors in the ARP
15  *					logic
16  *		Alan Cox	:	Allow >4K in /proc
17  *		Alan Cox	:	Make ARP add its own protocol entry
18  *		Ross Martin     :       Rewrote arp_rcv() and arp_get_info()
19  *		Stephen Henson	:	Add AX25 support to arp_get_info()
20  *		Alan Cox	:	Drop data when a device is downed.
21  *		Alan Cox	:	Use init_timer().
22  *		Alan Cox	:	Double lock fixes.
23  *		Martin Seine	:	Move the arphdr structure
24  *					to if_arp.h for compatibility.
25  *					with BSD based programs.
26  *		Andrew Tridgell :       Added ARP netmask code and
27  *					re-arranged proxy handling.
28  *		Alan Cox	:	Changed to use notifiers.
29  *		Niibe Yutaka	:	Reply for this device or proxies only.
30  *		Alan Cox	:	Don't proxy across hardware types!
31  *		Jonathan Naylor :	Added support for NET/ROM.
32  *		Mike Shaver     :       RFC1122 checks.
33  *		Jonathan Naylor :	Only lookup the hardware address for
34  *					the correct hardware type.
35  *		Germano Caronni	:	Assorted subtle races.
36  *		Craig Schlenter :	Don't modify permanent entry
37  *					during arp_rcv.
38  *		Russ Nelson	:	Tidied up a few bits.
39  *		Alexey Kuznetsov:	Major changes to caching and behaviour,
40  *					eg intelligent arp probing and
41  *					generation
42  *					of host down events.
43  *		Alan Cox	:	Missing unlock in device events.
44  *		Eckes		:	ARP ioctl control errors.
45  *		Alexey Kuznetsov:	Arp free fix.
46  *		Manuel Rodriguez:	Gratuitous ARP.
47  *              Jonathan Layes  :       Added arpd support through kerneld
48  *                                      message queue (960314)
49  *		Mike Shaver	:	/proc/sys/net/ipv4/arp_* support
50  *		Mike McLagan    :	Routing by source
51  *		Stuart Cheshire	:	Metricom and grat arp fixes
52  *					*** FOR 2.1 clean this up ***
53  *		Lawrence V. Stefani: (08/12/96) Added FDDI support.
54  *		Alan Cox	:	Took the AP1000 nasty FDDI hack and
55  *					folded into the mainstream FDDI code.
56  *					Ack spit, Linus how did you allow that
57  *					one in...
58  *		Jes Sorensen	:	Make FDDI work again in 2.1.x and
59  *					clean up the APFDDI & gen. FDDI bits.
60  *		Alexey Kuznetsov:	new arp state machine;
61  *					now it is in net/core/neighbour.c.
62  *		Krzysztof Halasa:	Added Frame Relay ARP support.
63  *		Arnaldo C. Melo :	convert /proc/net/arp to seq_file
64  *		Shmulik Hen:		Split arp_send to arp_create and
65  *					arp_xmit so intermediate drivers like
66  *					bonding can change the skb before
67  *					sending (e.g. insert 8021q tag).
68  *		Harald Welte	:	convert to make use of jenkins hash
69  *		Jesper D. Brouer:       Proxy ARP PVLAN RFC 3069 support.
70  */
71 
72 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
73 
74 #include <linux/module.h>
75 #include <linux/types.h>
76 #include <linux/string.h>
77 #include <linux/kernel.h>
78 #include <linux/capability.h>
79 #include <linux/socket.h>
80 #include <linux/sockios.h>
81 #include <linux/errno.h>
82 #include <linux/in.h>
83 #include <linux/mm.h>
84 #include <linux/inet.h>
85 #include <linux/inetdevice.h>
86 #include <linux/netdevice.h>
87 #include <linux/etherdevice.h>
88 #include <linux/fddidevice.h>
89 #include <linux/if_arp.h>
90 #include <linux/skbuff.h>
91 #include <linux/proc_fs.h>
92 #include <linux/seq_file.h>
93 #include <linux/stat.h>
94 #include <linux/init.h>
95 #include <linux/net.h>
96 #include <linux/rcupdate.h>
97 #include <linux/slab.h>
98 #ifdef CONFIG_SYSCTL
99 #include <linux/sysctl.h>
100 #endif
101 
102 #include <net/net_namespace.h>
103 #include <net/ip.h>
104 #include <net/icmp.h>
105 #include <net/route.h>
106 #include <net/protocol.h>
107 #include <net/tcp.h>
108 #include <net/sock.h>
109 #include <net/arp.h>
110 #include <net/ax25.h>
111 #include <net/netrom.h>
112 #include <net/dst_metadata.h>
113 #include <net/ip_tunnels.h>
114 
115 #include <linux/uaccess.h>
116 
117 #include <linux/netfilter_arp.h>
118 
119 /*
120  *	Interface to generic neighbour cache.
121  */
122 static u32 arp_hash(const void *pkey, const struct net_device *dev, __u32 *hash_rnd);
123 static bool arp_key_eq(const struct neighbour *n, const void *pkey);
124 static int arp_constructor(struct neighbour *neigh);
125 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
126 static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
127 static void parp_redo(struct sk_buff *skb);
128 static int arp_is_multicast(const void *pkey);
129 
130 static 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 
138 static 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 
146 static const struct neigh_ops arp_direct_ops = {
147 	.family =		AF_INET,
148 	.output =		neigh_direct_output,
149 	.connected_output =	neigh_direct_output,
150 };
151 
152 struct neigh_table arp_tbl = {
153 	.family		= AF_INET,
154 	.key_len	= 4,
155 	.protocol	= cpu_to_be16(ETH_P_IP),
156 	.hash		= arp_hash,
157 	.key_eq		= arp_key_eq,
158 	.constructor	= arp_constructor,
159 	.proxy_redo	= parp_redo,
160 	.is_multicast	= arp_is_multicast,
161 	.id		= "arp_cache",
162 	.parms		= {
163 		.tbl			= &arp_tbl,
164 		.reachable_time		= 30 * HZ,
165 		.data	= {
166 			[NEIGH_VAR_MCAST_PROBES] = 3,
167 			[NEIGH_VAR_UCAST_PROBES] = 3,
168 			[NEIGH_VAR_RETRANS_TIME] = 1 * HZ,
169 			[NEIGH_VAR_BASE_REACHABLE_TIME] = 30 * HZ,
170 			[NEIGH_VAR_DELAY_PROBE_TIME] = 5 * HZ,
171 			[NEIGH_VAR_INTERVAL_PROBE_TIME_MS] = 5 * HZ,
172 			[NEIGH_VAR_GC_STALETIME] = 60 * HZ,
173 			[NEIGH_VAR_QUEUE_LEN_BYTES] = SK_WMEM_MAX,
174 			[NEIGH_VAR_PROXY_QLEN] = 64,
175 			[NEIGH_VAR_ANYCAST_DELAY] = 1 * HZ,
176 			[NEIGH_VAR_PROXY_DELAY]	= (8 * HZ) / 10,
177 			[NEIGH_VAR_LOCKTIME] = 1 * HZ,
178 		},
179 	},
180 	.gc_interval	= 30 * HZ,
181 	.gc_thresh1	= 128,
182 	.gc_thresh2	= 512,
183 	.gc_thresh3	= 1024,
184 };
185 EXPORT_SYMBOL(arp_tbl);
186 
arp_mc_map(__be32 addr,u8 * haddr,struct net_device * dev,int dir)187 int arp_mc_map(__be32 addr, u8 *haddr, struct net_device *dev, int dir)
188 {
189 	switch (dev->type) {
190 	case ARPHRD_ETHER:
191 	case ARPHRD_FDDI:
192 	case ARPHRD_IEEE802:
193 		ip_eth_mc_map(addr, haddr);
194 		return 0;
195 	case ARPHRD_INFINIBAND:
196 		ip_ib_mc_map(addr, dev->broadcast, haddr);
197 		return 0;
198 	case ARPHRD_IPGRE:
199 		ip_ipgre_mc_map(addr, dev->broadcast, haddr);
200 		return 0;
201 	default:
202 		if (dir) {
203 			memcpy(haddr, dev->broadcast, dev->addr_len);
204 			return 0;
205 		}
206 	}
207 	return -EINVAL;
208 }
209 
210 
arp_hash(const void * pkey,const struct net_device * dev,__u32 * hash_rnd)211 static u32 arp_hash(const void *pkey,
212 		    const struct net_device *dev,
213 		    __u32 *hash_rnd)
214 {
215 	return arp_hashfn(pkey, dev, hash_rnd);
216 }
217 
arp_key_eq(const struct neighbour * neigh,const void * pkey)218 static bool arp_key_eq(const struct neighbour *neigh, const void *pkey)
219 {
220 	return neigh_key_eq32(neigh, pkey);
221 }
222 
arp_constructor(struct neighbour * neigh)223 static int arp_constructor(struct neighbour *neigh)
224 {
225 	__be32 addr;
226 	struct net_device *dev = neigh->dev;
227 	struct in_device *in_dev;
228 	struct neigh_parms *parms;
229 	u32 inaddr_any = INADDR_ANY;
230 
231 	if (dev->flags & (IFF_LOOPBACK | IFF_POINTOPOINT))
232 		memcpy(neigh->primary_key, &inaddr_any, arp_tbl.key_len);
233 
234 	addr = *(__be32 *)neigh->primary_key;
235 	rcu_read_lock();
236 	in_dev = __in_dev_get_rcu(dev);
237 	if (!in_dev) {
238 		rcu_read_unlock();
239 		return -EINVAL;
240 	}
241 
242 	neigh->type = inet_addr_type_dev_table(dev_net(dev), dev, addr);
243 
244 	parms = in_dev->arp_parms;
245 	__neigh_parms_put(neigh->parms);
246 	neigh->parms = neigh_parms_clone(parms);
247 	rcu_read_unlock();
248 
249 	if (!dev->header_ops) {
250 		neigh->nud_state = NUD_NOARP;
251 		neigh->ops = &arp_direct_ops;
252 		neigh->output = neigh_direct_output;
253 	} else {
254 		/* Good devices (checked by reading texts, but only Ethernet is
255 		   tested)
256 
257 		   ARPHRD_ETHER: (ethernet, apfddi)
258 		   ARPHRD_FDDI: (fddi)
259 		   ARPHRD_IEEE802: (tr)
260 		   ARPHRD_METRICOM: (strip)
261 		   ARPHRD_ARCNET:
262 		   etc. etc. etc.
263 
264 		   ARPHRD_IPDDP will also work, if author repairs it.
265 		   I did not it, because this driver does not work even
266 		   in old paradigm.
267 		 */
268 
269 		if (neigh->type == RTN_MULTICAST) {
270 			neigh->nud_state = NUD_NOARP;
271 			arp_mc_map(addr, neigh->ha, dev, 1);
272 		} else if (dev->flags & (IFF_NOARP | IFF_LOOPBACK)) {
273 			neigh->nud_state = NUD_NOARP;
274 			memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
275 		} else if (neigh->type == RTN_BROADCAST ||
276 			   (dev->flags & IFF_POINTOPOINT)) {
277 			neigh->nud_state = NUD_NOARP;
278 			memcpy(neigh->ha, dev->broadcast, dev->addr_len);
279 		}
280 
281 		if (dev->header_ops->cache)
282 			neigh->ops = &arp_hh_ops;
283 		else
284 			neigh->ops = &arp_generic_ops;
285 
286 		if (neigh->nud_state & NUD_VALID)
287 			neigh->output = neigh->ops->connected_output;
288 		else
289 			neigh->output = neigh->ops->output;
290 	}
291 	return 0;
292 }
293 
arp_error_report(struct neighbour * neigh,struct sk_buff * skb)294 static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
295 {
296 	dst_link_failure(skb);
297 	kfree_skb_reason(skb, SKB_DROP_REASON_NEIGH_FAILED);
298 }
299 
300 /* Create and send an arp packet. */
arp_send_dst(int type,int ptype,__be32 dest_ip,struct net_device * dev,__be32 src_ip,const unsigned char * dest_hw,const unsigned char * src_hw,const unsigned char * target_hw,struct dst_entry * dst)301 static void arp_send_dst(int type, int ptype, __be32 dest_ip,
302 			 struct net_device *dev, __be32 src_ip,
303 			 const unsigned char *dest_hw,
304 			 const unsigned char *src_hw,
305 			 const unsigned char *target_hw,
306 			 struct dst_entry *dst)
307 {
308 	struct sk_buff *skb;
309 
310 	/* arp on this interface. */
311 	if (dev->flags & IFF_NOARP)
312 		return;
313 
314 	skb = arp_create(type, ptype, dest_ip, dev, src_ip,
315 			 dest_hw, src_hw, target_hw);
316 	if (!skb)
317 		return;
318 
319 	skb_dst_set(skb, dst_clone(dst));
320 	arp_xmit(skb);
321 }
322 
arp_send(int type,int ptype,__be32 dest_ip,struct net_device * dev,__be32 src_ip,const unsigned char * dest_hw,const unsigned char * src_hw,const unsigned char * target_hw)323 void arp_send(int type, int ptype, __be32 dest_ip,
324 	      struct net_device *dev, __be32 src_ip,
325 	      const unsigned char *dest_hw, const unsigned char *src_hw,
326 	      const unsigned char *target_hw)
327 {
328 	arp_send_dst(type, ptype, dest_ip, dev, src_ip, dest_hw, src_hw,
329 		     target_hw, NULL);
330 }
331 EXPORT_SYMBOL(arp_send);
332 
arp_solicit(struct neighbour * neigh,struct sk_buff * skb)333 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
334 {
335 	__be32 saddr = 0;
336 	u8 dst_ha[MAX_ADDR_LEN], *dst_hw = NULL;
337 	struct net_device *dev = neigh->dev;
338 	__be32 target = *(__be32 *)neigh->primary_key;
339 	int probes = atomic_read(&neigh->probes);
340 	struct in_device *in_dev;
341 	struct dst_entry *dst = NULL;
342 
343 	rcu_read_lock();
344 	in_dev = __in_dev_get_rcu(dev);
345 	if (!in_dev) {
346 		rcu_read_unlock();
347 		return;
348 	}
349 	switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {
350 	default:
351 	case 0:		/* By default announce any local IP */
352 		if (skb && inet_addr_type_dev_table(dev_net(dev), dev,
353 					  ip_hdr(skb)->saddr) == RTN_LOCAL)
354 			saddr = ip_hdr(skb)->saddr;
355 		break;
356 	case 1:		/* Restrict announcements of saddr in same subnet */
357 		if (!skb)
358 			break;
359 		saddr = ip_hdr(skb)->saddr;
360 		if (inet_addr_type_dev_table(dev_net(dev), dev,
361 					     saddr) == RTN_LOCAL) {
362 			/* saddr should be known to target */
363 			if (inet_addr_onlink(in_dev, target, saddr))
364 				break;
365 		}
366 		saddr = 0;
367 		break;
368 	case 2:		/* Avoid secondary IPs, get a primary/preferred one */
369 		break;
370 	}
371 	rcu_read_unlock();
372 
373 	if (!saddr)
374 		saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);
375 
376 	probes -= NEIGH_VAR(neigh->parms, UCAST_PROBES);
377 	if (probes < 0) {
378 		if (!(READ_ONCE(neigh->nud_state) & NUD_VALID))
379 			pr_debug("trying to ucast probe in NUD_INVALID\n");
380 		neigh_ha_snapshot(dst_ha, neigh, dev);
381 		dst_hw = dst_ha;
382 	} else {
383 		probes -= NEIGH_VAR(neigh->parms, APP_PROBES);
384 		if (probes < 0) {
385 			neigh_app_ns(neigh);
386 			return;
387 		}
388 	}
389 
390 	if (skb && !(dev->priv_flags & IFF_XMIT_DST_RELEASE))
391 		dst = skb_dst(skb);
392 	arp_send_dst(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
393 		     dst_hw, dev->dev_addr, NULL, dst);
394 }
395 
arp_ignore(struct in_device * in_dev,__be32 sip,__be32 tip)396 static int arp_ignore(struct in_device *in_dev, __be32 sip, __be32 tip)
397 {
398 	struct net *net = dev_net(in_dev->dev);
399 	int scope;
400 
401 	switch (IN_DEV_ARP_IGNORE(in_dev)) {
402 	case 0:	/* Reply, the tip is already validated */
403 		return 0;
404 	case 1:	/* Reply only if tip is configured on the incoming interface */
405 		sip = 0;
406 		scope = RT_SCOPE_HOST;
407 		break;
408 	case 2:	/*
409 		 * Reply only if tip is configured on the incoming interface
410 		 * and is in same subnet as sip
411 		 */
412 		scope = RT_SCOPE_HOST;
413 		break;
414 	case 3:	/* Do not reply for scope host addresses */
415 		sip = 0;
416 		scope = RT_SCOPE_LINK;
417 		in_dev = NULL;
418 		break;
419 	case 4:	/* Reserved */
420 	case 5:
421 	case 6:
422 	case 7:
423 		return 0;
424 	case 8:	/* Do not reply */
425 		return 1;
426 	default:
427 		return 0;
428 	}
429 	return !inet_confirm_addr(net, in_dev, sip, tip, scope);
430 }
431 
arp_accept(struct in_device * in_dev,__be32 sip)432 static int arp_accept(struct in_device *in_dev, __be32 sip)
433 {
434 	struct net *net = dev_net(in_dev->dev);
435 	int scope = RT_SCOPE_LINK;
436 
437 	switch (IN_DEV_ARP_ACCEPT(in_dev)) {
438 	case 0: /* Don't create new entries from garp */
439 		return 0;
440 	case 1: /* Create new entries from garp */
441 		return 1;
442 	case 2: /* Create a neighbor in the arp table only if sip
443 		 * is in the same subnet as an address configured
444 		 * on the interface that received the garp message
445 		 */
446 		return !!inet_confirm_addr(net, in_dev, sip, 0, scope);
447 	default:
448 		return 0;
449 	}
450 }
451 
arp_filter(__be32 sip,__be32 tip,struct net_device * dev)452 static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
453 {
454 	struct rtable *rt;
455 	int flag = 0;
456 	/*unsigned long now; */
457 	struct net *net = dev_net(dev);
458 
459 	rt = ip_route_output(net, sip, tip, 0, l3mdev_master_ifindex_rcu(dev),
460 			     RT_SCOPE_UNIVERSE);
461 	if (IS_ERR(rt))
462 		return 1;
463 	if (rt->dst.dev != dev) {
464 		__NET_INC_STATS(net, LINUX_MIB_ARPFILTER);
465 		flag = 1;
466 	}
467 	ip_rt_put(rt);
468 	return flag;
469 }
470 
471 /*
472  * Check if we can use proxy ARP for this path
473  */
arp_fwd_proxy(struct in_device * in_dev,struct net_device * dev,struct rtable * rt)474 static inline int arp_fwd_proxy(struct in_device *in_dev,
475 				struct net_device *dev,	struct rtable *rt)
476 {
477 	struct in_device *out_dev;
478 	int imi, omi = -1;
479 
480 	if (rt->dst.dev == dev)
481 		return 0;
482 
483 	if (!IN_DEV_PROXY_ARP(in_dev))
484 		return 0;
485 	imi = IN_DEV_MEDIUM_ID(in_dev);
486 	if (imi == 0)
487 		return 1;
488 	if (imi == -1)
489 		return 0;
490 
491 	/* place to check for proxy_arp for routes */
492 
493 	out_dev = __in_dev_get_rcu(rt->dst.dev);
494 	if (out_dev)
495 		omi = IN_DEV_MEDIUM_ID(out_dev);
496 
497 	return omi != imi && omi != -1;
498 }
499 
500 /*
501  * Check for RFC3069 proxy arp private VLAN (allow to send back to same dev)
502  *
503  * RFC3069 supports proxy arp replies back to the same interface.  This
504  * is done to support (ethernet) switch features, like RFC 3069, where
505  * the individual ports are not allowed to communicate with each
506  * other, BUT they are allowed to talk to the upstream router.  As
507  * described in RFC 3069, it is possible to allow these hosts to
508  * communicate through the upstream router, by proxy_arp'ing.
509  *
510  * RFC 3069: "VLAN Aggregation for Efficient IP Address Allocation"
511  *
512  *  This technology is known by different names:
513  *    In RFC 3069 it is called VLAN Aggregation.
514  *    Cisco and Allied Telesyn call it Private VLAN.
515  *    Hewlett-Packard call it Source-Port filtering or port-isolation.
516  *    Ericsson call it MAC-Forced Forwarding (RFC Draft).
517  *
518  */
arp_fwd_pvlan(struct in_device * in_dev,struct net_device * dev,struct rtable * rt,__be32 sip,__be32 tip)519 static inline int arp_fwd_pvlan(struct in_device *in_dev,
520 				struct net_device *dev,	struct rtable *rt,
521 				__be32 sip, __be32 tip)
522 {
523 	/* Private VLAN is only concerned about the same ethernet segment */
524 	if (rt->dst.dev != dev)
525 		return 0;
526 
527 	/* Don't reply on self probes (often done by windowz boxes)*/
528 	if (sip == tip)
529 		return 0;
530 
531 	if (IN_DEV_PROXY_ARP_PVLAN(in_dev))
532 		return 1;
533 	else
534 		return 0;
535 }
536 
537 /*
538  *	Interface to link layer: send routine and receive handler.
539  */
540 
541 /*
542  *	Create an arp packet. If dest_hw is not set, we create a broadcast
543  *	message.
544  */
arp_create(int type,int ptype,__be32 dest_ip,struct net_device * dev,__be32 src_ip,const unsigned char * dest_hw,const unsigned char * src_hw,const unsigned char * target_hw)545 struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
546 			   struct net_device *dev, __be32 src_ip,
547 			   const unsigned char *dest_hw,
548 			   const unsigned char *src_hw,
549 			   const unsigned char *target_hw)
550 {
551 	struct sk_buff *skb;
552 	struct arphdr *arp;
553 	unsigned char *arp_ptr;
554 	int hlen = LL_RESERVED_SPACE(dev);
555 	int tlen = dev->needed_tailroom;
556 
557 	/*
558 	 *	Allocate a buffer
559 	 */
560 
561 	skb = alloc_skb(arp_hdr_len(dev) + hlen + tlen, GFP_ATOMIC);
562 	if (!skb)
563 		return NULL;
564 
565 	skb_reserve(skb, hlen);
566 	skb_reset_network_header(skb);
567 	arp = skb_put(skb, arp_hdr_len(dev));
568 	skb->dev = dev;
569 	skb->protocol = htons(ETH_P_ARP);
570 	if (!src_hw)
571 		src_hw = dev->dev_addr;
572 	if (!dest_hw)
573 		dest_hw = dev->broadcast;
574 
575 	/*
576 	 *	Fill the device header for the ARP frame
577 	 */
578 	if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)
579 		goto out;
580 
581 	/*
582 	 * Fill out the arp protocol part.
583 	 *
584 	 * The arp hardware type should match the device type, except for FDDI,
585 	 * which (according to RFC 1390) should always equal 1 (Ethernet).
586 	 */
587 	/*
588 	 *	Exceptions everywhere. AX.25 uses the AX.25 PID value not the
589 	 *	DIX code for the protocol. Make these device structure fields.
590 	 */
591 	switch (dev->type) {
592 	default:
593 		arp->ar_hrd = htons(dev->type);
594 		arp->ar_pro = htons(ETH_P_IP);
595 		break;
596 
597 #if IS_ENABLED(CONFIG_AX25)
598 	case ARPHRD_AX25:
599 		arp->ar_hrd = htons(ARPHRD_AX25);
600 		arp->ar_pro = htons(AX25_P_IP);
601 		break;
602 
603 #if IS_ENABLED(CONFIG_NETROM)
604 	case ARPHRD_NETROM:
605 		arp->ar_hrd = htons(ARPHRD_NETROM);
606 		arp->ar_pro = htons(AX25_P_IP);
607 		break;
608 #endif
609 #endif
610 
611 #if IS_ENABLED(CONFIG_FDDI)
612 	case ARPHRD_FDDI:
613 		arp->ar_hrd = htons(ARPHRD_ETHER);
614 		arp->ar_pro = htons(ETH_P_IP);
615 		break;
616 #endif
617 	}
618 
619 	arp->ar_hln = dev->addr_len;
620 	arp->ar_pln = 4;
621 	arp->ar_op = htons(type);
622 
623 	arp_ptr = (unsigned char *)(arp + 1);
624 
625 	memcpy(arp_ptr, src_hw, dev->addr_len);
626 	arp_ptr += dev->addr_len;
627 	memcpy(arp_ptr, &src_ip, 4);
628 	arp_ptr += 4;
629 
630 	switch (dev->type) {
631 #if IS_ENABLED(CONFIG_FIREWIRE_NET)
632 	case ARPHRD_IEEE1394:
633 		break;
634 #endif
635 	default:
636 		if (target_hw)
637 			memcpy(arp_ptr, target_hw, dev->addr_len);
638 		else
639 			memset(arp_ptr, 0, dev->addr_len);
640 		arp_ptr += dev->addr_len;
641 	}
642 	memcpy(arp_ptr, &dest_ip, 4);
643 
644 	return skb;
645 
646 out:
647 	kfree_skb(skb);
648 	return NULL;
649 }
650 EXPORT_SYMBOL(arp_create);
651 
arp_xmit_finish(struct net * net,struct sock * sk,struct sk_buff * skb)652 static int arp_xmit_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
653 {
654 	return dev_queue_xmit(skb);
655 }
656 
657 /*
658  *	Send an arp packet.
659  */
arp_xmit(struct sk_buff * skb)660 void arp_xmit(struct sk_buff *skb)
661 {
662 	/* Send it off, maybe filter it using firewalling first.  */
663 	NF_HOOK(NFPROTO_ARP, NF_ARP_OUT,
664 		dev_net(skb->dev), NULL, skb, NULL, skb->dev,
665 		arp_xmit_finish);
666 }
667 EXPORT_SYMBOL(arp_xmit);
668 
arp_is_garp(struct net * net,struct net_device * dev,int * addr_type,__be16 ar_op,__be32 sip,__be32 tip,unsigned char * sha,unsigned char * tha)669 static bool arp_is_garp(struct net *net, struct net_device *dev,
670 			int *addr_type, __be16 ar_op,
671 			__be32 sip, __be32 tip,
672 			unsigned char *sha, unsigned char *tha)
673 {
674 	bool is_garp = tip == sip;
675 
676 	/* Gratuitous ARP _replies_ also require target hwaddr to be
677 	 * the same as source.
678 	 */
679 	if (is_garp && ar_op == htons(ARPOP_REPLY))
680 		is_garp =
681 			/* IPv4 over IEEE 1394 doesn't provide target
682 			 * hardware address field in its ARP payload.
683 			 */
684 			tha &&
685 			!memcmp(tha, sha, dev->addr_len);
686 
687 	if (is_garp) {
688 		*addr_type = inet_addr_type_dev_table(net, dev, sip);
689 		if (*addr_type != RTN_UNICAST)
690 			is_garp = false;
691 	}
692 	return is_garp;
693 }
694 
695 /*
696  *	Process an arp request.
697  */
698 
arp_process(struct net * net,struct sock * sk,struct sk_buff * skb)699 static int arp_process(struct net *net, struct sock *sk, struct sk_buff *skb)
700 {
701 	struct net_device *dev = skb->dev;
702 	struct in_device *in_dev = __in_dev_get_rcu(dev);
703 	struct arphdr *arp;
704 	unsigned char *arp_ptr;
705 	struct rtable *rt;
706 	unsigned char *sha;
707 	unsigned char *tha = NULL;
708 	__be32 sip, tip;
709 	u16 dev_type = dev->type;
710 	int addr_type;
711 	struct neighbour *n;
712 	struct dst_entry *reply_dst = NULL;
713 	bool is_garp = false;
714 
715 	/* arp_rcv below verifies the ARP header and verifies the device
716 	 * is ARP'able.
717 	 */
718 
719 	if (!in_dev)
720 		goto out_free_skb;
721 
722 	arp = arp_hdr(skb);
723 
724 	switch (dev_type) {
725 	default:
726 		if (arp->ar_pro != htons(ETH_P_IP) ||
727 		    htons(dev_type) != arp->ar_hrd)
728 			goto out_free_skb;
729 		break;
730 	case ARPHRD_ETHER:
731 	case ARPHRD_FDDI:
732 	case ARPHRD_IEEE802:
733 		/*
734 		 * ETHERNET, and Fibre Channel (which are IEEE 802
735 		 * devices, according to RFC 2625) devices will accept ARP
736 		 * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
737 		 * This is the case also of FDDI, where the RFC 1390 says that
738 		 * FDDI devices should accept ARP hardware of (1) Ethernet,
739 		 * however, to be more robust, we'll accept both 1 (Ethernet)
740 		 * or 6 (IEEE 802.2)
741 		 */
742 		if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
743 		     arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
744 		    arp->ar_pro != htons(ETH_P_IP))
745 			goto out_free_skb;
746 		break;
747 	case ARPHRD_AX25:
748 		if (arp->ar_pro != htons(AX25_P_IP) ||
749 		    arp->ar_hrd != htons(ARPHRD_AX25))
750 			goto out_free_skb;
751 		break;
752 	case ARPHRD_NETROM:
753 		if (arp->ar_pro != htons(AX25_P_IP) ||
754 		    arp->ar_hrd != htons(ARPHRD_NETROM))
755 			goto out_free_skb;
756 		break;
757 	}
758 
759 	/* Understand only these message types */
760 
761 	if (arp->ar_op != htons(ARPOP_REPLY) &&
762 	    arp->ar_op != htons(ARPOP_REQUEST))
763 		goto out_free_skb;
764 
765 /*
766  *	Extract fields
767  */
768 	arp_ptr = (unsigned char *)(arp + 1);
769 	sha	= arp_ptr;
770 	arp_ptr += dev->addr_len;
771 	memcpy(&sip, arp_ptr, 4);
772 	arp_ptr += 4;
773 	switch (dev_type) {
774 #if IS_ENABLED(CONFIG_FIREWIRE_NET)
775 	case ARPHRD_IEEE1394:
776 		break;
777 #endif
778 	default:
779 		tha = arp_ptr;
780 		arp_ptr += dev->addr_len;
781 	}
782 	memcpy(&tip, arp_ptr, 4);
783 /*
784  *	Check for bad requests for 127.x.x.x and requests for multicast
785  *	addresses.  If this is one such, delete it.
786  */
787 	if (ipv4_is_multicast(tip) ||
788 	    (!IN_DEV_ROUTE_LOCALNET(in_dev) && ipv4_is_loopback(tip)))
789 		goto out_free_skb;
790 
791  /*
792   *	For some 802.11 wireless deployments (and possibly other networks),
793   *	there will be an ARP proxy and gratuitous ARP frames are attacks
794   *	and thus should not be accepted.
795   */
796 	if (sip == tip && IN_DEV_ORCONF(in_dev, DROP_GRATUITOUS_ARP))
797 		goto out_free_skb;
798 
799 /*
800  *     Special case: We must set Frame Relay source Q.922 address
801  */
802 	if (dev_type == ARPHRD_DLCI)
803 		sha = dev->broadcast;
804 
805 /*
806  *  Process entry.  The idea here is we want to send a reply if it is a
807  *  request for us or if it is a request for someone else that we hold
808  *  a proxy for.  We want to add an entry to our cache if it is a reply
809  *  to us or if it is a request for our address.
810  *  (The assumption for this last is that if someone is requesting our
811  *  address, they are probably intending to talk to us, so it saves time
812  *  if we cache their address.  Their address is also probably not in
813  *  our cache, since ours is not in their cache.)
814  *
815  *  Putting this another way, we only care about replies if they are to
816  *  us, in which case we add them to the cache.  For requests, we care
817  *  about those for us and those for our proxies.  We reply to both,
818  *  and in the case of requests for us we add the requester to the arp
819  *  cache.
820  */
821 
822 	if (arp->ar_op == htons(ARPOP_REQUEST) && skb_metadata_dst(skb))
823 		reply_dst = (struct dst_entry *)
824 			    iptunnel_metadata_reply(skb_metadata_dst(skb),
825 						    GFP_ATOMIC);
826 
827 	/* Special case: IPv4 duplicate address detection packet (RFC2131) */
828 	if (sip == 0) {
829 		if (arp->ar_op == htons(ARPOP_REQUEST) &&
830 		    inet_addr_type_dev_table(net, dev, tip) == RTN_LOCAL &&
831 		    !arp_ignore(in_dev, sip, tip))
832 			arp_send_dst(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip,
833 				     sha, dev->dev_addr, sha, reply_dst);
834 		goto out_consume_skb;
835 	}
836 
837 	if (arp->ar_op == htons(ARPOP_REQUEST) &&
838 	    ip_route_input_noref(skb, tip, sip, 0, dev) == 0) {
839 
840 		rt = skb_rtable(skb);
841 		addr_type = rt->rt_type;
842 
843 		if (addr_type == RTN_LOCAL) {
844 			int dont_send;
845 
846 			dont_send = arp_ignore(in_dev, sip, tip);
847 			if (!dont_send && IN_DEV_ARPFILTER(in_dev))
848 				dont_send = arp_filter(sip, tip, dev);
849 			if (!dont_send) {
850 				n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
851 				if (n) {
852 					arp_send_dst(ARPOP_REPLY, ETH_P_ARP,
853 						     sip, dev, tip, sha,
854 						     dev->dev_addr, sha,
855 						     reply_dst);
856 					neigh_release(n);
857 				}
858 			}
859 			goto out_consume_skb;
860 		} else if (IN_DEV_FORWARD(in_dev)) {
861 			if (addr_type == RTN_UNICAST  &&
862 			    (arp_fwd_proxy(in_dev, dev, rt) ||
863 			     arp_fwd_pvlan(in_dev, dev, rt, sip, tip) ||
864 			     (rt->dst.dev != dev &&
865 			      pneigh_lookup(&arp_tbl, net, &tip, dev, 0)))) {
866 				n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
867 				if (n)
868 					neigh_release(n);
869 
870 				if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
871 				    skb->pkt_type == PACKET_HOST ||
872 				    NEIGH_VAR(in_dev->arp_parms, PROXY_DELAY) == 0) {
873 					arp_send_dst(ARPOP_REPLY, ETH_P_ARP,
874 						     sip, dev, tip, sha,
875 						     dev->dev_addr, sha,
876 						     reply_dst);
877 				} else {
878 					pneigh_enqueue(&arp_tbl,
879 						       in_dev->arp_parms, skb);
880 					goto out_free_dst;
881 				}
882 				goto out_consume_skb;
883 			}
884 		}
885 	}
886 
887 	/* Update our ARP tables */
888 
889 	n = __neigh_lookup(&arp_tbl, &sip, dev, 0);
890 
891 	addr_type = -1;
892 	if (n || arp_accept(in_dev, sip)) {
893 		is_garp = arp_is_garp(net, dev, &addr_type, arp->ar_op,
894 				      sip, tip, sha, tha);
895 	}
896 
897 	if (arp_accept(in_dev, sip)) {
898 		/* Unsolicited ARP is not accepted by default.
899 		   It is possible, that this option should be enabled for some
900 		   devices (strip is candidate)
901 		 */
902 		if (!n &&
903 		    (is_garp ||
904 		     (arp->ar_op == htons(ARPOP_REPLY) &&
905 		      (addr_type == RTN_UNICAST ||
906 		       (addr_type < 0 &&
907 			/* postpone calculation to as late as possible */
908 			inet_addr_type_dev_table(net, dev, sip) ==
909 				RTN_UNICAST)))))
910 			n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
911 	}
912 
913 	if (n) {
914 		int state = NUD_REACHABLE;
915 		int override;
916 
917 		/* If several different ARP replies follows back-to-back,
918 		   use the FIRST one. It is possible, if several proxy
919 		   agents are active. Taking the first reply prevents
920 		   arp trashing and chooses the fastest router.
921 		 */
922 		override = time_after(jiffies,
923 				      n->updated +
924 				      NEIGH_VAR(n->parms, LOCKTIME)) ||
925 			   is_garp;
926 
927 		/* Broadcast replies and request packets
928 		   do not assert neighbour reachability.
929 		 */
930 		if (arp->ar_op != htons(ARPOP_REPLY) ||
931 		    skb->pkt_type != PACKET_HOST)
932 			state = NUD_STALE;
933 		neigh_update(n, sha, state,
934 			     override ? NEIGH_UPDATE_F_OVERRIDE : 0, 0);
935 		neigh_release(n);
936 	}
937 
938 out_consume_skb:
939 	consume_skb(skb);
940 
941 out_free_dst:
942 	dst_release(reply_dst);
943 	return NET_RX_SUCCESS;
944 
945 out_free_skb:
946 	kfree_skb(skb);
947 	return NET_RX_DROP;
948 }
949 
parp_redo(struct sk_buff * skb)950 static void parp_redo(struct sk_buff *skb)
951 {
952 	arp_process(dev_net(skb->dev), NULL, skb);
953 }
954 
arp_is_multicast(const void * pkey)955 static int arp_is_multicast(const void *pkey)
956 {
957 	return ipv4_is_multicast(*((__be32 *)pkey));
958 }
959 
960 /*
961  *	Receive an arp request from the device layer.
962  */
963 
arp_rcv(struct sk_buff * skb,struct net_device * dev,struct packet_type * pt,struct net_device * orig_dev)964 static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
965 		   struct packet_type *pt, struct net_device *orig_dev)
966 {
967 	const struct arphdr *arp;
968 
969 	/* do not tweak dropwatch on an ARP we will ignore */
970 	if (dev->flags & IFF_NOARP ||
971 	    skb->pkt_type == PACKET_OTHERHOST ||
972 	    skb->pkt_type == PACKET_LOOPBACK)
973 		goto consumeskb;
974 
975 	skb = skb_share_check(skb, GFP_ATOMIC);
976 	if (!skb)
977 		goto out_of_mem;
978 
979 	/* ARP header, plus 2 device addresses, plus 2 IP addresses.  */
980 	if (!pskb_may_pull(skb, arp_hdr_len(dev)))
981 		goto freeskb;
982 
983 	arp = arp_hdr(skb);
984 	if (arp->ar_hln != dev->addr_len || arp->ar_pln != 4)
985 		goto freeskb;
986 
987 	memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
988 
989 	return NF_HOOK(NFPROTO_ARP, NF_ARP_IN,
990 		       dev_net(dev), NULL, skb, dev, NULL,
991 		       arp_process);
992 
993 consumeskb:
994 	consume_skb(skb);
995 	return NET_RX_SUCCESS;
996 freeskb:
997 	kfree_skb(skb);
998 out_of_mem:
999 	return NET_RX_DROP;
1000 }
1001 
1002 /*
1003  *	User level interface (ioctl)
1004  */
1005 
arp_req_dev_by_name(struct net * net,struct arpreq * r,bool getarp)1006 static struct net_device *arp_req_dev_by_name(struct net *net, struct arpreq *r,
1007 					      bool getarp)
1008 {
1009 	struct net_device *dev;
1010 
1011 	if (getarp)
1012 		dev = dev_get_by_name_rcu(net, r->arp_dev);
1013 	else
1014 		dev = __dev_get_by_name(net, r->arp_dev);
1015 	if (!dev)
1016 		return ERR_PTR(-ENODEV);
1017 
1018 	/* Mmmm... It is wrong... ARPHRD_NETROM == 0 */
1019 	if (!r->arp_ha.sa_family)
1020 		r->arp_ha.sa_family = dev->type;
1021 
1022 	if ((r->arp_flags & ATF_COM) && r->arp_ha.sa_family != dev->type)
1023 		return ERR_PTR(-EINVAL);
1024 
1025 	return dev;
1026 }
1027 
arp_req_dev(struct net * net,struct arpreq * r)1028 static struct net_device *arp_req_dev(struct net *net, struct arpreq *r)
1029 {
1030 	struct net_device *dev;
1031 	struct rtable *rt;
1032 	__be32 ip;
1033 
1034 	if (r->arp_dev[0])
1035 		return arp_req_dev_by_name(net, r, false);
1036 
1037 	if (r->arp_flags & ATF_PUBL)
1038 		return NULL;
1039 
1040 	ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1041 
1042 	rt = ip_route_output(net, ip, 0, 0, 0, RT_SCOPE_LINK);
1043 	if (IS_ERR(rt))
1044 		return ERR_CAST(rt);
1045 
1046 	dev = rt->dst.dev;
1047 	ip_rt_put(rt);
1048 
1049 	if (!dev)
1050 		return ERR_PTR(-EINVAL);
1051 
1052 	return dev;
1053 }
1054 
1055 /*
1056  *	Set (create) an ARP cache entry.
1057  */
1058 
arp_req_set_proxy(struct net * net,struct net_device * dev,int on)1059 static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on)
1060 {
1061 	if (!dev) {
1062 		IPV4_DEVCONF_ALL(net, PROXY_ARP) = on;
1063 		return 0;
1064 	}
1065 	if (__in_dev_get_rtnl(dev)) {
1066 		IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, on);
1067 		return 0;
1068 	}
1069 	return -ENXIO;
1070 }
1071 
arp_req_set_public(struct net * net,struct arpreq * r,struct net_device * dev)1072 static int arp_req_set_public(struct net *net, struct arpreq *r,
1073 		struct net_device *dev)
1074 {
1075 	__be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1076 
1077 	if (!dev && (r->arp_flags & ATF_COM)) {
1078 		dev = dev_getbyhwaddr_rcu(net, r->arp_ha.sa_family,
1079 				      r->arp_ha.sa_data);
1080 		if (!dev)
1081 			return -ENODEV;
1082 	}
1083 	if (mask) {
1084 		__be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1085 
1086 		if (!pneigh_lookup(&arp_tbl, net, &ip, dev, 1))
1087 			return -ENOBUFS;
1088 		return 0;
1089 	}
1090 
1091 	return arp_req_set_proxy(net, dev, 1);
1092 }
1093 
arp_req_set(struct net * net,struct arpreq * r)1094 static int arp_req_set(struct net *net, struct arpreq *r)
1095 {
1096 	struct neighbour *neigh;
1097 	struct net_device *dev;
1098 	__be32 ip;
1099 	int err;
1100 
1101 	dev = arp_req_dev(net, r);
1102 	if (IS_ERR(dev))
1103 		return PTR_ERR(dev);
1104 
1105 	if (r->arp_flags & ATF_PUBL)
1106 		return arp_req_set_public(net, r, dev);
1107 
1108 	switch (dev->type) {
1109 #if IS_ENABLED(CONFIG_FDDI)
1110 	case ARPHRD_FDDI:
1111 		/*
1112 		 * According to RFC 1390, FDDI devices should accept ARP
1113 		 * hardware types of 1 (Ethernet).  However, to be more
1114 		 * robust, we'll accept hardware types of either 1 (Ethernet)
1115 		 * or 6 (IEEE 802.2).
1116 		 */
1117 		if (r->arp_ha.sa_family != ARPHRD_FDDI &&
1118 		    r->arp_ha.sa_family != ARPHRD_ETHER &&
1119 		    r->arp_ha.sa_family != ARPHRD_IEEE802)
1120 			return -EINVAL;
1121 		break;
1122 #endif
1123 	default:
1124 		if (r->arp_ha.sa_family != dev->type)
1125 			return -EINVAL;
1126 		break;
1127 	}
1128 
1129 	ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1130 
1131 	neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev);
1132 	err = PTR_ERR(neigh);
1133 	if (!IS_ERR(neigh)) {
1134 		unsigned int state = NUD_STALE;
1135 
1136 		if (r->arp_flags & ATF_PERM) {
1137 			r->arp_flags |= ATF_COM;
1138 			state = NUD_PERMANENT;
1139 		}
1140 
1141 		err = neigh_update(neigh, (r->arp_flags & ATF_COM) ?
1142 				   r->arp_ha.sa_data : NULL, state,
1143 				   NEIGH_UPDATE_F_OVERRIDE |
1144 				   NEIGH_UPDATE_F_ADMIN, 0);
1145 		neigh_release(neigh);
1146 	}
1147 	return err;
1148 }
1149 
arp_state_to_flags(struct neighbour * neigh)1150 static unsigned int arp_state_to_flags(struct neighbour *neigh)
1151 {
1152 	if (neigh->nud_state&NUD_PERMANENT)
1153 		return ATF_PERM | ATF_COM;
1154 	else if (neigh->nud_state&NUD_VALID)
1155 		return ATF_COM;
1156 	else
1157 		return 0;
1158 }
1159 
1160 /*
1161  *	Get an ARP cache entry.
1162  */
1163 
arp_req_get(struct net * net,struct arpreq * r)1164 static int arp_req_get(struct net *net, struct arpreq *r)
1165 {
1166 	__be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1167 	struct neighbour *neigh;
1168 	struct net_device *dev;
1169 
1170 	if (!r->arp_dev[0])
1171 		return -ENODEV;
1172 
1173 	dev = arp_req_dev_by_name(net, r, true);
1174 	if (IS_ERR(dev))
1175 		return PTR_ERR(dev);
1176 
1177 	neigh = neigh_lookup(&arp_tbl, &ip, dev);
1178 	if (!neigh)
1179 		return -ENXIO;
1180 
1181 	if (READ_ONCE(neigh->nud_state) & NUD_NOARP) {
1182 		neigh_release(neigh);
1183 		return -ENXIO;
1184 	}
1185 
1186 	read_lock_bh(&neigh->lock);
1187 	memcpy(r->arp_ha.sa_data, neigh->ha,
1188 	       min(dev->addr_len, sizeof(r->arp_ha.sa_data_min)));
1189 	r->arp_flags = arp_state_to_flags(neigh);
1190 	read_unlock_bh(&neigh->lock);
1191 
1192 	neigh_release(neigh);
1193 
1194 	r->arp_ha.sa_family = dev->type;
1195 	netdev_copy_name(dev, r->arp_dev);
1196 
1197 	return 0;
1198 }
1199 
arp_invalidate(struct net_device * dev,__be32 ip,bool force)1200 int arp_invalidate(struct net_device *dev, __be32 ip, bool force)
1201 {
1202 	struct neighbour *neigh = neigh_lookup(&arp_tbl, &ip, dev);
1203 	int err = -ENXIO;
1204 	struct neigh_table *tbl = &arp_tbl;
1205 
1206 	if (neigh) {
1207 		if ((READ_ONCE(neigh->nud_state) & NUD_VALID) && !force) {
1208 			neigh_release(neigh);
1209 			return 0;
1210 		}
1211 
1212 		if (READ_ONCE(neigh->nud_state) & ~NUD_NOARP)
1213 			err = neigh_update(neigh, NULL, NUD_FAILED,
1214 					   NEIGH_UPDATE_F_OVERRIDE|
1215 					   NEIGH_UPDATE_F_ADMIN, 0);
1216 		write_lock_bh(&tbl->lock);
1217 		neigh_release(neigh);
1218 		neigh_remove_one(neigh, tbl);
1219 		write_unlock_bh(&tbl->lock);
1220 	}
1221 
1222 	return err;
1223 }
1224 
arp_req_delete_public(struct net * net,struct arpreq * r,struct net_device * dev)1225 static int arp_req_delete_public(struct net *net, struct arpreq *r,
1226 		struct net_device *dev)
1227 {
1228 	__be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1229 
1230 	if (mask) {
1231 		__be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1232 
1233 		return pneigh_delete(&arp_tbl, net, &ip, dev);
1234 	}
1235 
1236 	return arp_req_set_proxy(net, dev, 0);
1237 }
1238 
arp_req_delete(struct net * net,struct arpreq * r)1239 static int arp_req_delete(struct net *net, struct arpreq *r)
1240 {
1241 	struct net_device *dev;
1242 	__be32 ip;
1243 
1244 	dev = arp_req_dev(net, r);
1245 	if (IS_ERR(dev))
1246 		return PTR_ERR(dev);
1247 
1248 	if (r->arp_flags & ATF_PUBL)
1249 		return arp_req_delete_public(net, r, dev);
1250 
1251 	ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1252 
1253 	return arp_invalidate(dev, ip, true);
1254 }
1255 
1256 /*
1257  *	Handle an ARP layer I/O control request.
1258  */
1259 
arp_ioctl(struct net * net,unsigned int cmd,void __user * arg)1260 int arp_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1261 {
1262 	struct arpreq r;
1263 	__be32 *netmask;
1264 	int err;
1265 
1266 	switch (cmd) {
1267 	case SIOCDARP:
1268 	case SIOCSARP:
1269 		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1270 			return -EPERM;
1271 		fallthrough;
1272 	case SIOCGARP:
1273 		err = copy_from_user(&r, arg, sizeof(struct arpreq));
1274 		if (err)
1275 			return -EFAULT;
1276 		break;
1277 	default:
1278 		return -EINVAL;
1279 	}
1280 
1281 	if (r.arp_pa.sa_family != AF_INET)
1282 		return -EPFNOSUPPORT;
1283 
1284 	if (!(r.arp_flags & ATF_PUBL) &&
1285 	    (r.arp_flags & (ATF_NETMASK | ATF_DONTPUB)))
1286 		return -EINVAL;
1287 
1288 	netmask = &((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr;
1289 	if (!(r.arp_flags & ATF_NETMASK))
1290 		*netmask = htonl(0xFFFFFFFFUL);
1291 	else if (*netmask && *netmask != htonl(0xFFFFFFFFUL))
1292 		return -EINVAL;
1293 
1294 	switch (cmd) {
1295 	case SIOCDARP:
1296 		rtnl_lock();
1297 		err = arp_req_delete(net, &r);
1298 		rtnl_unlock();
1299 		break;
1300 	case SIOCSARP:
1301 		rtnl_lock();
1302 		err = arp_req_set(net, &r);
1303 		rtnl_unlock();
1304 		break;
1305 	case SIOCGARP:
1306 		rcu_read_lock();
1307 		err = arp_req_get(net, &r);
1308 		rcu_read_unlock();
1309 
1310 		if (!err && copy_to_user(arg, &r, sizeof(r)))
1311 			err = -EFAULT;
1312 		break;
1313 	}
1314 
1315 	return err;
1316 }
1317 
arp_netdev_event(struct notifier_block * this,unsigned long event,void * ptr)1318 static int arp_netdev_event(struct notifier_block *this, unsigned long event,
1319 			    void *ptr)
1320 {
1321 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1322 	struct netdev_notifier_change_info *change_info;
1323 	struct in_device *in_dev;
1324 	bool evict_nocarrier;
1325 
1326 	switch (event) {
1327 	case NETDEV_CHANGEADDR:
1328 		neigh_changeaddr(&arp_tbl, dev);
1329 		rt_cache_flush(dev_net(dev));
1330 		break;
1331 	case NETDEV_CHANGE:
1332 		change_info = ptr;
1333 		if (change_info->flags_changed & IFF_NOARP)
1334 			neigh_changeaddr(&arp_tbl, dev);
1335 
1336 		in_dev = __in_dev_get_rtnl(dev);
1337 		if (!in_dev)
1338 			evict_nocarrier = true;
1339 		else
1340 			evict_nocarrier = IN_DEV_ARP_EVICT_NOCARRIER(in_dev);
1341 
1342 		if (evict_nocarrier && !netif_carrier_ok(dev))
1343 			neigh_carrier_down(&arp_tbl, dev);
1344 		break;
1345 	default:
1346 		break;
1347 	}
1348 
1349 	return NOTIFY_DONE;
1350 }
1351 
1352 static struct notifier_block arp_netdev_notifier = {
1353 	.notifier_call = arp_netdev_event,
1354 };
1355 
1356 /* Note, that it is not on notifier chain.
1357    It is necessary, that this routine was called after route cache will be
1358    flushed.
1359  */
arp_ifdown(struct net_device * dev)1360 void arp_ifdown(struct net_device *dev)
1361 {
1362 	neigh_ifdown(&arp_tbl, dev);
1363 }
1364 
1365 
1366 /*
1367  *	Called once on startup.
1368  */
1369 
1370 static struct packet_type arp_packet_type __read_mostly = {
1371 	.type =	cpu_to_be16(ETH_P_ARP),
1372 	.func =	arp_rcv,
1373 };
1374 
1375 #ifdef CONFIG_PROC_FS
1376 #if IS_ENABLED(CONFIG_AX25)
1377 
1378 /*
1379  *	ax25 -> ASCII conversion
1380  */
ax2asc2(ax25_address * a,char * buf)1381 static void ax2asc2(ax25_address *a, char *buf)
1382 {
1383 	char c, *s;
1384 	int n;
1385 
1386 	for (n = 0, s = buf; n < 6; n++) {
1387 		c = (a->ax25_call[n] >> 1) & 0x7F;
1388 
1389 		if (c != ' ')
1390 			*s++ = c;
1391 	}
1392 
1393 	*s++ = '-';
1394 	n = (a->ax25_call[6] >> 1) & 0x0F;
1395 	if (n > 9) {
1396 		*s++ = '1';
1397 		n -= 10;
1398 	}
1399 
1400 	*s++ = n + '0';
1401 	*s++ = '\0';
1402 
1403 	if (*buf == '\0' || *buf == '-') {
1404 		buf[0] = '*';
1405 		buf[1] = '\0';
1406 	}
1407 }
1408 #endif /* CONFIG_AX25 */
1409 
1410 #define HBUFFERLEN 30
1411 
arp_format_neigh_entry(struct seq_file * seq,struct neighbour * n)1412 static void arp_format_neigh_entry(struct seq_file *seq,
1413 				   struct neighbour *n)
1414 {
1415 	char hbuffer[HBUFFERLEN];
1416 	int k, j;
1417 	char tbuf[16];
1418 	struct net_device *dev = n->dev;
1419 	int hatype = dev->type;
1420 
1421 	read_lock(&n->lock);
1422 	/* Convert hardware address to XX:XX:XX:XX ... form. */
1423 #if IS_ENABLED(CONFIG_AX25)
1424 	if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM)
1425 		ax2asc2((ax25_address *)n->ha, hbuffer);
1426 	else {
1427 #endif
1428 	for (k = 0, j = 0; k < HBUFFERLEN - 3 && j < dev->addr_len; j++) {
1429 		hbuffer[k++] = hex_asc_hi(n->ha[j]);
1430 		hbuffer[k++] = hex_asc_lo(n->ha[j]);
1431 		hbuffer[k++] = ':';
1432 	}
1433 	if (k != 0)
1434 		--k;
1435 	hbuffer[k] = 0;
1436 #if IS_ENABLED(CONFIG_AX25)
1437 	}
1438 #endif
1439 	sprintf(tbuf, "%pI4", n->primary_key);
1440 	seq_printf(seq, "%-16s 0x%-10x0x%-10x%-17s     *        %s\n",
1441 		   tbuf, hatype, arp_state_to_flags(n), hbuffer, dev->name);
1442 	read_unlock(&n->lock);
1443 }
1444 
arp_format_pneigh_entry(struct seq_file * seq,struct pneigh_entry * n)1445 static void arp_format_pneigh_entry(struct seq_file *seq,
1446 				    struct pneigh_entry *n)
1447 {
1448 	struct net_device *dev = n->dev;
1449 	int hatype = dev ? dev->type : 0;
1450 	char tbuf[16];
1451 
1452 	sprintf(tbuf, "%pI4", n->key);
1453 	seq_printf(seq, "%-16s 0x%-10x0x%-10x%s     *        %s\n",
1454 		   tbuf, hatype, ATF_PUBL | ATF_PERM, "00:00:00:00:00:00",
1455 		   dev ? dev->name : "*");
1456 }
1457 
arp_seq_show(struct seq_file * seq,void * v)1458 static int arp_seq_show(struct seq_file *seq, void *v)
1459 {
1460 	if (v == SEQ_START_TOKEN) {
1461 		seq_puts(seq, "IP address       HW type     Flags       "
1462 			      "HW address            Mask     Device\n");
1463 	} else {
1464 		struct neigh_seq_state *state = seq->private;
1465 
1466 		if (state->flags & NEIGH_SEQ_IS_PNEIGH)
1467 			arp_format_pneigh_entry(seq, v);
1468 		else
1469 			arp_format_neigh_entry(seq, v);
1470 	}
1471 
1472 	return 0;
1473 }
1474 
arp_seq_start(struct seq_file * seq,loff_t * pos)1475 static void *arp_seq_start(struct seq_file *seq, loff_t *pos)
1476 {
1477 	/* Don't want to confuse "arp -a" w/ magic entries,
1478 	 * so we tell the generic iterator to skip NUD_NOARP.
1479 	 */
1480 	return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_SKIP_NOARP);
1481 }
1482 
1483 static const struct seq_operations arp_seq_ops = {
1484 	.start	= arp_seq_start,
1485 	.next	= neigh_seq_next,
1486 	.stop	= neigh_seq_stop,
1487 	.show	= arp_seq_show,
1488 };
1489 #endif /* CONFIG_PROC_FS */
1490 
arp_net_init(struct net * net)1491 static int __net_init arp_net_init(struct net *net)
1492 {
1493 	if (!proc_create_net("arp", 0444, net->proc_net, &arp_seq_ops,
1494 			sizeof(struct neigh_seq_state)))
1495 		return -ENOMEM;
1496 	return 0;
1497 }
1498 
arp_net_exit(struct net * net)1499 static void __net_exit arp_net_exit(struct net *net)
1500 {
1501 	remove_proc_entry("arp", net->proc_net);
1502 }
1503 
1504 static struct pernet_operations arp_net_ops = {
1505 	.init = arp_net_init,
1506 	.exit = arp_net_exit,
1507 };
1508 
arp_init(void)1509 void __init arp_init(void)
1510 {
1511 	neigh_table_init(NEIGH_ARP_TABLE, &arp_tbl);
1512 
1513 	dev_add_pack(&arp_packet_type);
1514 	register_pernet_subsys(&arp_net_ops);
1515 #ifdef CONFIG_SYSCTL
1516 	neigh_sysctl_register(NULL, &arp_tbl.parms, NULL);
1517 #endif
1518 	register_netdevice_notifier(&arp_netdev_notifier);
1519 }
1520