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 */
 122static u32 arp_hash(const void *pkey, const struct net_device *dev, __u32 *hash_rnd);
 123static bool arp_key_eq(const struct neighbour *n, const void *pkey);
 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);
 128static int arp_is_multicast(const void *pkey);
 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
 152struct 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};
 185EXPORT_SYMBOL(arp_tbl);
 186
 187int 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
 211static 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
 218static bool arp_key_eq(const struct neighbour *neigh, const void *pkey)
 219{
 220	return neigh_key_eq32(neigh, pkey);
 221}
 222
 223static 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
 294static 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. */
 301static 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
 323void 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}
 331EXPORT_SYMBOL(arp_send);
 332
 333static 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
 396static 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
 432static 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
 452static 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 */
 474static 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 */
 519static 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 */
 545struct 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
 646out:
 647	kfree_skb(skb);
 648	return NULL;
 649}
 650EXPORT_SYMBOL(arp_create);
 651
 652static 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 */
 660void arp_xmit(struct sk_buff *skb)
 661{
 662	rcu_read_lock();
 663	/* Send it off, maybe filter it using firewalling first.  */
 664	NF_HOOK(NFPROTO_ARP, NF_ARP_OUT,
 665		dev_net_rcu(skb->dev), NULL, skb, NULL, skb->dev,
 666		arp_xmit_finish);
 667	rcu_read_unlock();
 668}
 669EXPORT_SYMBOL(arp_xmit);
 670
 671static bool arp_is_garp(struct net *net, struct net_device *dev,
 672			int *addr_type, __be16 ar_op,
 673			__be32 sip, __be32 tip,
 674			unsigned char *sha, unsigned char *tha)
 675{
 676	bool is_garp = tip == sip;
 677
 678	/* Gratuitous ARP _replies_ also require target hwaddr to be
 679	 * the same as source.
 680	 */
 681	if (is_garp && ar_op == htons(ARPOP_REPLY))
 682		is_garp =
 683			/* IPv4 over IEEE 1394 doesn't provide target
 684			 * hardware address field in its ARP payload.
 685			 */
 686			tha &&
 687			!memcmp(tha, sha, dev->addr_len);
 688
 689	if (is_garp) {
 690		*addr_type = inet_addr_type_dev_table(net, dev, sip);
 691		if (*addr_type != RTN_UNICAST)
 692			is_garp = false;
 693	}
 694	return is_garp;
 695}
 696
 697/*
 698 *	Process an arp request.
 699 */
 700
 701static int arp_process(struct net *net, struct sock *sk, struct sk_buff *skb)
 702{
 703	struct net_device *dev = skb->dev;
 704	struct in_device *in_dev = __in_dev_get_rcu(dev);
 705	struct arphdr *arp;
 706	unsigned char *arp_ptr;
 707	struct rtable *rt;
 708	unsigned char *sha;
 709	unsigned char *tha = NULL;
 710	__be32 sip, tip;
 711	u16 dev_type = dev->type;
 712	int addr_type;
 713	struct neighbour *n;
 714	struct dst_entry *reply_dst = NULL;
 715	bool is_garp = false;
 716
 717	/* arp_rcv below verifies the ARP header and verifies the device
 718	 * is ARP'able.
 719	 */
 720
 721	if (!in_dev)
 722		goto out_free_skb;
 723
 724	arp = arp_hdr(skb);
 725
 726	switch (dev_type) {
 727	default:
 728		if (arp->ar_pro != htons(ETH_P_IP) ||
 729		    htons(dev_type) != arp->ar_hrd)
 730			goto out_free_skb;
 731		break;
 732	case ARPHRD_ETHER:
 733	case ARPHRD_FDDI:
 734	case ARPHRD_IEEE802:
 735		/*
 736		 * ETHERNET, and Fibre Channel (which are IEEE 802
 737		 * devices, according to RFC 2625) devices will accept ARP
 738		 * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
 739		 * This is the case also of FDDI, where the RFC 1390 says that
 740		 * FDDI devices should accept ARP hardware of (1) Ethernet,
 741		 * however, to be more robust, we'll accept both 1 (Ethernet)
 742		 * or 6 (IEEE 802.2)
 743		 */
 744		if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
 745		     arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
 746		    arp->ar_pro != htons(ETH_P_IP))
 747			goto out_free_skb;
 748		break;
 749	case ARPHRD_AX25:
 750		if (arp->ar_pro != htons(AX25_P_IP) ||
 751		    arp->ar_hrd != htons(ARPHRD_AX25))
 752			goto out_free_skb;
 753		break;
 754	case ARPHRD_NETROM:
 755		if (arp->ar_pro != htons(AX25_P_IP) ||
 756		    arp->ar_hrd != htons(ARPHRD_NETROM))
 757			goto out_free_skb;
 758		break;
 759	}
 760
 761	/* Understand only these message types */
 762
 763	if (arp->ar_op != htons(ARPOP_REPLY) &&
 764	    arp->ar_op != htons(ARPOP_REQUEST))
 765		goto out_free_skb;
 766
 767/*
 768 *	Extract fields
 769 */
 770	arp_ptr = (unsigned char *)(arp + 1);
 771	sha	= arp_ptr;
 772	arp_ptr += dev->addr_len;
 773	memcpy(&sip, arp_ptr, 4);
 774	arp_ptr += 4;
 775	switch (dev_type) {
 776#if IS_ENABLED(CONFIG_FIREWIRE_NET)
 777	case ARPHRD_IEEE1394:
 778		break;
 779#endif
 780	default:
 781		tha = arp_ptr;
 782		arp_ptr += dev->addr_len;
 783	}
 784	memcpy(&tip, arp_ptr, 4);
 785/*
 786 *	Check for bad requests for 127.x.x.x and requests for multicast
 787 *	addresses.  If this is one such, delete it.
 788 */
 789	if (ipv4_is_multicast(tip) ||
 790	    (!IN_DEV_ROUTE_LOCALNET(in_dev) && ipv4_is_loopback(tip)))
 791		goto out_free_skb;
 792
 793 /*
 794  *	For some 802.11 wireless deployments (and possibly other networks),
 795  *	there will be an ARP proxy and gratuitous ARP frames are attacks
 796  *	and thus should not be accepted.
 797  */
 798	if (sip == tip && IN_DEV_ORCONF(in_dev, DROP_GRATUITOUS_ARP))
 799		goto out_free_skb;
 800
 801/*
 802 *     Special case: We must set Frame Relay source Q.922 address
 803 */
 804	if (dev_type == ARPHRD_DLCI)
 805		sha = dev->broadcast;
 806
 807/*
 808 *  Process entry.  The idea here is we want to send a reply if it is a
 809 *  request for us or if it is a request for someone else that we hold
 810 *  a proxy for.  We want to add an entry to our cache if it is a reply
 811 *  to us or if it is a request for our address.
 812 *  (The assumption for this last is that if someone is requesting our
 813 *  address, they are probably intending to talk to us, so it saves time
 814 *  if we cache their address.  Their address is also probably not in
 815 *  our cache, since ours is not in their cache.)
 816 *
 817 *  Putting this another way, we only care about replies if they are to
 818 *  us, in which case we add them to the cache.  For requests, we care
 819 *  about those for us and those for our proxies.  We reply to both,
 820 *  and in the case of requests for us we add the requester to the arp
 821 *  cache.
 822 */
 823
 824	if (arp->ar_op == htons(ARPOP_REQUEST) && skb_metadata_dst(skb))
 825		reply_dst = (struct dst_entry *)
 826			    iptunnel_metadata_reply(skb_metadata_dst(skb),
 827						    GFP_ATOMIC);
 828
 829	/* Special case: IPv4 duplicate address detection packet (RFC2131) */
 830	if (sip == 0) {
 831		if (arp->ar_op == htons(ARPOP_REQUEST) &&
 832		    inet_addr_type_dev_table(net, dev, tip) == RTN_LOCAL &&
 833		    !arp_ignore(in_dev, sip, tip))
 834			arp_send_dst(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip,
 835				     sha, dev->dev_addr, sha, reply_dst);
 836		goto out_consume_skb;
 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_dst(ARPOP_REPLY, ETH_P_ARP,
 855						     sip, dev, tip, sha,
 856						     dev->dev_addr, sha,
 857						     reply_dst);
 858					neigh_release(n);
 859				}
 860			}
 861			goto out_consume_skb;
 862		} else if (IN_DEV_FORWARD(in_dev)) {
 863			if (addr_type == RTN_UNICAST  &&
 864			    (arp_fwd_proxy(in_dev, dev, rt) ||
 865			     arp_fwd_pvlan(in_dev, dev, rt, sip, tip) ||
 866			     (rt->dst.dev != dev &&
 867			      pneigh_lookup(&arp_tbl, net, &tip, dev, 0)))) {
 868				n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
 869				if (n)
 870					neigh_release(n);
 871
 872				if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
 873				    skb->pkt_type == PACKET_HOST ||
 874				    NEIGH_VAR(in_dev->arp_parms, PROXY_DELAY) == 0) {
 875					arp_send_dst(ARPOP_REPLY, ETH_P_ARP,
 876						     sip, dev, tip, sha,
 877						     dev->dev_addr, sha,
 878						     reply_dst);
 879				} else {
 880					pneigh_enqueue(&arp_tbl,
 881						       in_dev->arp_parms, skb);
 882					goto out_free_dst;
 883				}
 884				goto out_consume_skb;
 885			}
 886		}
 887	}
 888
 889	/* Update our ARP tables */
 890
 891	n = __neigh_lookup(&arp_tbl, &sip, dev, 0);
 892
 893	addr_type = -1;
 894	if (n || arp_accept(in_dev, sip)) {
 895		is_garp = arp_is_garp(net, dev, &addr_type, arp->ar_op,
 896				      sip, tip, sha, tha);
 897	}
 898
 899	if (arp_accept(in_dev, sip)) {
 900		/* Unsolicited ARP is not accepted by default.
 901		   It is possible, that this option should be enabled for some
 902		   devices (strip is candidate)
 903		 */
 904		if (!n &&
 905		    (is_garp ||
 906		     (arp->ar_op == htons(ARPOP_REPLY) &&
 907		      (addr_type == RTN_UNICAST ||
 908		       (addr_type < 0 &&
 909			/* postpone calculation to as late as possible */
 910			inet_addr_type_dev_table(net, dev, sip) ==
 911				RTN_UNICAST)))))
 912			n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
 913	}
 914
 915	if (n) {
 916		int state = NUD_REACHABLE;
 917		int override;
 918
 919		/* If several different ARP replies follows back-to-back,
 920		   use the FIRST one. It is possible, if several proxy
 921		   agents are active. Taking the first reply prevents
 922		   arp trashing and chooses the fastest router.
 923		 */
 924		override = time_after(jiffies,
 925				      n->updated +
 926				      NEIGH_VAR(n->parms, LOCKTIME)) ||
 927			   is_garp;
 928
 929		/* Broadcast replies and request packets
 930		   do not assert neighbour reachability.
 931		 */
 932		if (arp->ar_op != htons(ARPOP_REPLY) ||
 933		    skb->pkt_type != PACKET_HOST)
 934			state = NUD_STALE;
 935		neigh_update(n, sha, state,
 936			     override ? NEIGH_UPDATE_F_OVERRIDE : 0, 0);
 937		neigh_release(n);
 938	}
 939
 940out_consume_skb:
 941	consume_skb(skb);
 942
 943out_free_dst:
 944	dst_release(reply_dst);
 945	return NET_RX_SUCCESS;
 946
 947out_free_skb:
 948	kfree_skb(skb);
 949	return NET_RX_DROP;
 950}
 951
 952static void parp_redo(struct sk_buff *skb)
 953{
 954	arp_process(dev_net(skb->dev), NULL, skb);
 955}
 956
 957static int arp_is_multicast(const void *pkey)
 958{
 959	return ipv4_is_multicast(*((__be32 *)pkey));
 960}
 961
 962/*
 963 *	Receive an arp request from the device layer.
 964 */
 965
 966static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
 967		   struct packet_type *pt, struct net_device *orig_dev)
 968{
 969	const struct arphdr *arp;
 970
 971	/* do not tweak dropwatch on an ARP we will ignore */
 972	if (dev->flags & IFF_NOARP ||
 973	    skb->pkt_type == PACKET_OTHERHOST ||
 974	    skb->pkt_type == PACKET_LOOPBACK)
 975		goto consumeskb;
 976
 977	skb = skb_share_check(skb, GFP_ATOMIC);
 978	if (!skb)
 979		goto out_of_mem;
 980
 981	/* ARP header, plus 2 device addresses, plus 2 IP addresses.  */
 982	if (!pskb_may_pull(skb, arp_hdr_len(dev)))
 983		goto freeskb;
 984
 985	arp = arp_hdr(skb);
 986	if (arp->ar_hln != dev->addr_len || arp->ar_pln != 4)
 987		goto freeskb;
 988
 989	memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
 990
 991	return NF_HOOK(NFPROTO_ARP, NF_ARP_IN,
 992		       dev_net(dev), NULL, skb, dev, NULL,
 993		       arp_process);
 994
 995consumeskb:
 996	consume_skb(skb);
 997	return NET_RX_SUCCESS;
 998freeskb:
 999	kfree_skb(skb);
1000out_of_mem:
1001	return NET_RX_DROP;
1002}
1003
1004/*
1005 *	User level interface (ioctl)
1006 */
1007
1008static struct net_device *arp_req_dev_by_name(struct net *net, struct arpreq *r,
1009					      bool getarp)
1010{
1011	struct net_device *dev;
1012
1013	if (getarp)
1014		dev = dev_get_by_name_rcu(net, r->arp_dev);
1015	else
1016		dev = __dev_get_by_name(net, r->arp_dev);
1017	if (!dev)
1018		return ERR_PTR(-ENODEV);
1019
1020	/* Mmmm... It is wrong... ARPHRD_NETROM == 0 */
1021	if (!r->arp_ha.sa_family)
1022		r->arp_ha.sa_family = dev->type;
1023
1024	if ((r->arp_flags & ATF_COM) && r->arp_ha.sa_family != dev->type)
1025		return ERR_PTR(-EINVAL);
1026
1027	return dev;
1028}
1029
1030static struct net_device *arp_req_dev(struct net *net, struct arpreq *r)
1031{
1032	struct net_device *dev;
1033	struct rtable *rt;
1034	__be32 ip;
1035
1036	if (r->arp_dev[0])
1037		return arp_req_dev_by_name(net, r, false);
1038
1039	if (r->arp_flags & ATF_PUBL)
1040		return NULL;
1041
1042	ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1043
1044	rt = ip_route_output(net, ip, 0, 0, 0, RT_SCOPE_LINK);
1045	if (IS_ERR(rt))
1046		return ERR_CAST(rt);
1047
1048	dev = rt->dst.dev;
1049	ip_rt_put(rt);
1050
1051	if (!dev)
1052		return ERR_PTR(-EINVAL);
1053
1054	return dev;
1055}
1056
1057/*
1058 *	Set (create) an ARP cache entry.
1059 */
1060
1061static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on)
1062{
1063	if (!dev) {
1064		IPV4_DEVCONF_ALL(net, PROXY_ARP) = on;
1065		return 0;
1066	}
1067	if (__in_dev_get_rtnl(dev)) {
1068		IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, on);
1069		return 0;
1070	}
1071	return -ENXIO;
1072}
1073
1074static int arp_req_set_public(struct net *net, struct arpreq *r,
1075		struct net_device *dev)
1076{
 
1077	__be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1078
 
 
1079	if (!dev && (r->arp_flags & ATF_COM)) {
1080		dev = dev_getbyhwaddr(net, r->arp_ha.sa_family,
1081				      r->arp_ha.sa_data);
1082		if (!dev)
1083			return -ENODEV;
1084	}
1085	if (mask) {
1086		__be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1087
1088		if (!pneigh_lookup(&arp_tbl, net, &ip, dev, 1))
1089			return -ENOBUFS;
1090		return 0;
1091	}
1092
1093	return arp_req_set_proxy(net, dev, 1);
1094}
1095
1096static int arp_req_set(struct net *net, struct arpreq *r)
 
1097{
1098	struct neighbour *neigh;
1099	struct net_device *dev;
1100	__be32 ip;
 
1101	int err;
1102
1103	dev = arp_req_dev(net, r);
1104	if (IS_ERR(dev))
1105		return PTR_ERR(dev);
1106
1107	if (r->arp_flags & ATF_PUBL)
1108		return arp_req_set_public(net, r, dev);
1109
 
 
 
 
 
 
 
 
 
 
 
 
 
1110	switch (dev->type) {
1111#if IS_ENABLED(CONFIG_FDDI)
1112	case ARPHRD_FDDI:
1113		/*
1114		 * According to RFC 1390, FDDI devices should accept ARP
1115		 * hardware types of 1 (Ethernet).  However, to be more
1116		 * robust, we'll accept hardware types of either 1 (Ethernet)
1117		 * or 6 (IEEE 802.2).
1118		 */
1119		if (r->arp_ha.sa_family != ARPHRD_FDDI &&
1120		    r->arp_ha.sa_family != ARPHRD_ETHER &&
1121		    r->arp_ha.sa_family != ARPHRD_IEEE802)
1122			return -EINVAL;
1123		break;
1124#endif
1125	default:
1126		if (r->arp_ha.sa_family != dev->type)
1127			return -EINVAL;
1128		break;
1129	}
1130
1131	ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1132
1133	neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev);
1134	err = PTR_ERR(neigh);
1135	if (!IS_ERR(neigh)) {
1136		unsigned int state = NUD_STALE;
1137
1138		if (r->arp_flags & ATF_PERM) {
1139			r->arp_flags |= ATF_COM;
1140			state = NUD_PERMANENT;
1141		}
1142
1143		err = neigh_update(neigh, (r->arp_flags & ATF_COM) ?
1144				   r->arp_ha.sa_data : NULL, state,
1145				   NEIGH_UPDATE_F_OVERRIDE |
1146				   NEIGH_UPDATE_F_ADMIN, 0);
1147		neigh_release(neigh);
1148	}
1149	return err;
1150}
1151
1152static unsigned int arp_state_to_flags(struct neighbour *neigh)
1153{
1154	if (neigh->nud_state&NUD_PERMANENT)
1155		return ATF_PERM | ATF_COM;
1156	else if (neigh->nud_state&NUD_VALID)
1157		return ATF_COM;
1158	else
1159		return 0;
1160}
1161
1162/*
1163 *	Get an ARP cache entry.
1164 */
1165
1166static int arp_req_get(struct net *net, struct arpreq *r)
1167{
1168	__be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1169	struct neighbour *neigh;
1170	struct net_device *dev;
1171
1172	if (!r->arp_dev[0])
1173		return -ENODEV;
1174
1175	dev = arp_req_dev_by_name(net, r, true);
1176	if (IS_ERR(dev))
1177		return PTR_ERR(dev);
1178
1179	neigh = neigh_lookup(&arp_tbl, &ip, dev);
1180	if (!neigh)
1181		return -ENXIO;
1182
1183	if (READ_ONCE(neigh->nud_state) & NUD_NOARP) {
 
 
 
 
 
 
 
1184		neigh_release(neigh);
1185		return -ENXIO;
1186	}
1187
1188	read_lock_bh(&neigh->lock);
1189	memcpy(r->arp_ha.sa_data, neigh->ha,
1190	       min(dev->addr_len, sizeof(r->arp_ha.sa_data_min)));
1191	r->arp_flags = arp_state_to_flags(neigh);
1192	read_unlock_bh(&neigh->lock);
1193
1194	neigh_release(neigh);
1195
1196	r->arp_ha.sa_family = dev->type;
1197	netdev_copy_name(dev, r->arp_dev);
1198
1199	return 0;
1200}
1201
1202int arp_invalidate(struct net_device *dev, __be32 ip, bool force)
1203{
1204	struct neighbour *neigh = neigh_lookup(&arp_tbl, &ip, dev);
1205	int err = -ENXIO;
1206	struct neigh_table *tbl = &arp_tbl;
1207
1208	if (neigh) {
1209		if ((READ_ONCE(neigh->nud_state) & NUD_VALID) && !force) {
1210			neigh_release(neigh);
1211			return 0;
1212		}
1213
1214		if (READ_ONCE(neigh->nud_state) & ~NUD_NOARP)
1215			err = neigh_update(neigh, NULL, NUD_FAILED,
1216					   NEIGH_UPDATE_F_OVERRIDE|
1217					   NEIGH_UPDATE_F_ADMIN, 0);
1218		write_lock_bh(&tbl->lock);
1219		neigh_release(neigh);
1220		neigh_remove_one(neigh);
1221		write_unlock_bh(&tbl->lock);
1222	}
1223
1224	return err;
1225}
1226
1227static int arp_req_delete_public(struct net *net, struct arpreq *r,
1228		struct net_device *dev)
1229{
 
1230	__be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1231
1232	if (mask) {
1233		__be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1234
1235		return pneigh_delete(&arp_tbl, net, &ip, dev);
1236	}
 
 
1237
1238	return arp_req_set_proxy(net, dev, 0);
1239}
1240
1241static int arp_req_delete(struct net *net, struct arpreq *r)
 
1242{
1243	struct net_device *dev;
1244	__be32 ip;
1245
1246	dev = arp_req_dev(net, r);
1247	if (IS_ERR(dev))
1248		return PTR_ERR(dev);
1249
1250	if (r->arp_flags & ATF_PUBL)
1251		return arp_req_delete_public(net, r, dev);
1252
1253	ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1254
 
 
 
 
 
 
 
 
1255	return arp_invalidate(dev, ip, true);
1256}
1257
1258/*
1259 *	Handle an ARP layer I/O control request.
1260 */
1261
1262int arp_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1263{
1264	struct arpreq r;
1265	__be32 *netmask;
1266	int err;
 
 
1267
1268	switch (cmd) {
1269	case SIOCDARP:
1270	case SIOCSARP:
1271		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1272			return -EPERM;
1273		fallthrough;
1274	case SIOCGARP:
1275		err = copy_from_user(&r, arg, sizeof(struct arpreq));
1276		if (err)
1277			return -EFAULT;
1278		break;
1279	default:
1280		return -EINVAL;
1281	}
1282
1283	if (r.arp_pa.sa_family != AF_INET)
1284		return -EPFNOSUPPORT;
1285
1286	if (!(r.arp_flags & ATF_PUBL) &&
1287	    (r.arp_flags & (ATF_NETMASK | ATF_DONTPUB)))
1288		return -EINVAL;
1289
1290	netmask = &((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr;
1291	if (!(r.arp_flags & ATF_NETMASK))
1292		*netmask = htonl(0xFFFFFFFFUL);
1293	else if (*netmask && *netmask != htonl(0xFFFFFFFFUL))
1294		return -EINVAL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1295
1296	switch (cmd) {
1297	case SIOCDARP:
1298		rtnl_lock();
1299		err = arp_req_delete(net, &r);
1300		rtnl_unlock();
1301		break;
1302	case SIOCSARP:
1303		rtnl_lock();
1304		err = arp_req_set(net, &r);
1305		rtnl_unlock();
1306		break;
1307	case SIOCGARP:
1308		rcu_read_lock();
1309		err = arp_req_get(net, &r);
1310		rcu_read_unlock();
1311
1312		if (!err && copy_to_user(arg, &r, sizeof(r)))
1313			err = -EFAULT;
1314		break;
1315	}
1316
 
 
 
1317	return err;
1318}
1319
1320static int arp_netdev_event(struct notifier_block *this, unsigned long event,
1321			    void *ptr)
1322{
1323	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1324	struct netdev_notifier_change_info *change_info;
1325	struct in_device *in_dev;
1326	bool evict_nocarrier;
1327
1328	switch (event) {
1329	case NETDEV_CHANGEADDR:
1330		neigh_changeaddr(&arp_tbl, dev);
1331		rt_cache_flush(dev_net(dev));
1332		break;
1333	case NETDEV_CHANGE:
1334		change_info = ptr;
1335		if (change_info->flags_changed & IFF_NOARP)
1336			neigh_changeaddr(&arp_tbl, dev);
1337
1338		in_dev = __in_dev_get_rtnl(dev);
1339		if (!in_dev)
1340			evict_nocarrier = true;
1341		else
1342			evict_nocarrier = IN_DEV_ARP_EVICT_NOCARRIER(in_dev);
1343
1344		if (evict_nocarrier && !netif_carrier_ok(dev))
1345			neigh_carrier_down(&arp_tbl, dev);
1346		break;
1347	default:
1348		break;
1349	}
1350
1351	return NOTIFY_DONE;
1352}
1353
1354static struct notifier_block arp_netdev_notifier = {
1355	.notifier_call = arp_netdev_event,
1356};
1357
1358/* Note, that it is not on notifier chain.
1359   It is necessary, that this routine was called after route cache will be
1360   flushed.
1361 */
1362void arp_ifdown(struct net_device *dev)
1363{
1364	neigh_ifdown(&arp_tbl, dev);
1365}
1366
1367
1368/*
1369 *	Called once on startup.
1370 */
1371
1372static struct packet_type arp_packet_type __read_mostly = {
1373	.type =	cpu_to_be16(ETH_P_ARP),
1374	.func =	arp_rcv,
1375};
1376
1377#ifdef CONFIG_PROC_FS
1378#if IS_ENABLED(CONFIG_AX25)
1379
1380/*
1381 *	ax25 -> ASCII conversion
1382 */
1383static void ax2asc2(ax25_address *a, char *buf)
1384{
1385	char c, *s;
1386	int n;
1387
1388	for (n = 0, s = buf; n < 6; n++) {
1389		c = (a->ax25_call[n] >> 1) & 0x7F;
1390
1391		if (c != ' ')
1392			*s++ = c;
1393	}
1394
1395	*s++ = '-';
1396	n = (a->ax25_call[6] >> 1) & 0x0F;
1397	if (n > 9) {
1398		*s++ = '1';
1399		n -= 10;
1400	}
1401
1402	*s++ = n + '0';
1403	*s++ = '\0';
1404
1405	if (*buf == '\0' || *buf == '-') {
1406		buf[0] = '*';
1407		buf[1] = '\0';
1408	}
1409}
1410#endif /* CONFIG_AX25 */
1411
1412#define HBUFFERLEN 30
1413
1414static void arp_format_neigh_entry(struct seq_file *seq,
1415				   struct neighbour *n)
1416{
1417	char hbuffer[HBUFFERLEN];
1418	int k, j;
1419	char tbuf[16];
1420	struct net_device *dev = n->dev;
1421	int hatype = dev->type;
1422
1423	read_lock(&n->lock);
1424	/* Convert hardware address to XX:XX:XX:XX ... form. */
1425#if IS_ENABLED(CONFIG_AX25)
1426	if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM)
1427		ax2asc2((ax25_address *)n->ha, hbuffer);
1428	else {
1429#endif
1430	for (k = 0, j = 0; k < HBUFFERLEN - 3 && j < dev->addr_len; j++) {
1431		hbuffer[k++] = hex_asc_hi(n->ha[j]);
1432		hbuffer[k++] = hex_asc_lo(n->ha[j]);
1433		hbuffer[k++] = ':';
1434	}
1435	if (k != 0)
1436		--k;
1437	hbuffer[k] = 0;
1438#if IS_ENABLED(CONFIG_AX25)
1439	}
1440#endif
1441	sprintf(tbuf, "%pI4", n->primary_key);
1442	seq_printf(seq, "%-16s 0x%-10x0x%-10x%-17s     *        %s\n",
1443		   tbuf, hatype, arp_state_to_flags(n), hbuffer, dev->name);
1444	read_unlock(&n->lock);
1445}
1446
1447static void arp_format_pneigh_entry(struct seq_file *seq,
1448				    struct pneigh_entry *n)
1449{
1450	struct net_device *dev = n->dev;
1451	int hatype = dev ? dev->type : 0;
1452	char tbuf[16];
1453
1454	sprintf(tbuf, "%pI4", n->key);
1455	seq_printf(seq, "%-16s 0x%-10x0x%-10x%s     *        %s\n",
1456		   tbuf, hatype, ATF_PUBL | ATF_PERM, "00:00:00:00:00:00",
1457		   dev ? dev->name : "*");
1458}
1459
1460static int arp_seq_show(struct seq_file *seq, void *v)
1461{
1462	if (v == SEQ_START_TOKEN) {
1463		seq_puts(seq, "IP address       HW type     Flags       "
1464			      "HW address            Mask     Device\n");
1465	} else {
1466		struct neigh_seq_state *state = seq->private;
1467
1468		if (state->flags & NEIGH_SEQ_IS_PNEIGH)
1469			arp_format_pneigh_entry(seq, v);
1470		else
1471			arp_format_neigh_entry(seq, v);
1472	}
1473
1474	return 0;
1475}
1476
1477static void *arp_seq_start(struct seq_file *seq, loff_t *pos)
1478{
1479	/* Don't want to confuse "arp -a" w/ magic entries,
1480	 * so we tell the generic iterator to skip NUD_NOARP.
1481	 */
1482	return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_SKIP_NOARP);
1483}
1484
1485static const struct seq_operations arp_seq_ops = {
1486	.start	= arp_seq_start,
1487	.next	= neigh_seq_next,
1488	.stop	= neigh_seq_stop,
1489	.show	= arp_seq_show,
1490};
1491#endif /* CONFIG_PROC_FS */
1492
1493static int __net_init arp_net_init(struct net *net)
1494{
1495	if (!proc_create_net("arp", 0444, net->proc_net, &arp_seq_ops,
1496			sizeof(struct neigh_seq_state)))
1497		return -ENOMEM;
1498	return 0;
1499}
1500
1501static void __net_exit arp_net_exit(struct net *net)
1502{
1503	remove_proc_entry("arp", net->proc_net);
1504}
1505
1506static struct pernet_operations arp_net_ops = {
1507	.init = arp_net_init,
1508	.exit = arp_net_exit,
1509};
1510
1511void __init arp_init(void)
1512{
1513	neigh_table_init(NEIGH_ARP_TABLE, &arp_tbl);
1514
1515	dev_add_pack(&arp_packet_type);
1516	register_pernet_subsys(&arp_net_ops);
1517#ifdef CONFIG_SYSCTL
1518	neigh_sysctl_register(NULL, &arp_tbl.parms, NULL);
1519#endif
1520	register_netdevice_notifier(&arp_netdev_notifier);
1521}