arp.c 34.9 KB
Newer Older
1
/* linux/net/ipv4/arp.c
Linus Torvalds's avatar
Linus Torvalds committed
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 *
 * Copyright (C) 1994 by Florian  La Roche
 *
 * This module implements the Address Resolution Protocol ARP (RFC 826),
 * which is used to convert IP addresses (or in the future maybe other
 * high-level addresses) into a low-level hardware address (like an Ethernet
 * address).
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 *
 * Fixes:
16
 *		Alan Cox	:	Removed the Ethernet assumptions in
Linus Torvalds's avatar
Linus Torvalds committed
17
 *					Florian's code
18
 *		Alan Cox	:	Fixed some small errors in the ARP
Linus Torvalds's avatar
Linus Torvalds committed
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 *					logic
 *		Alan Cox	:	Allow >4K in /proc
 *		Alan Cox	:	Make ARP add its own protocol entry
 *		Ross Martin     :       Rewrote arp_rcv() and arp_get_info()
 *		Stephen Henson	:	Add AX25 support to arp_get_info()
 *		Alan Cox	:	Drop data when a device is downed.
 *		Alan Cox	:	Use init_timer().
 *		Alan Cox	:	Double lock fixes.
 *		Martin Seine	:	Move the arphdr structure
 *					to if_arp.h for compatibility.
 *					with BSD based programs.
 *		Andrew Tridgell :       Added ARP netmask code and
 *					re-arranged proxy handling.
 *		Alan Cox	:	Changed to use notifiers.
 *		Niibe Yutaka	:	Reply for this device or proxies only.
 *		Alan Cox	:	Don't proxy across hardware types!
 *		Jonathan Naylor :	Added support for NET/ROM.
 *		Mike Shaver     :       RFC1122 checks.
 *		Jonathan Naylor :	Only lookup the hardware address for
 *					the correct hardware type.
 *		Germano Caronni	:	Assorted subtle races.
40
 *		Craig Schlenter :	Don't modify permanent entry
Linus Torvalds's avatar
Linus Torvalds committed
41
42
43
 *					during arp_rcv.
 *		Russ Nelson	:	Tidied up a few bits.
 *		Alexey Kuznetsov:	Major changes to caching and behaviour,
44
 *					eg intelligent arp probing and
Linus Torvalds's avatar
Linus Torvalds committed
45
46
47
48
49
50
 *					generation
 *					of host down events.
 *		Alan Cox	:	Missing unlock in device events.
 *		Eckes		:	ARP ioctl control errors.
 *		Alexey Kuznetsov:	Arp free fix.
 *		Manuel Rodriguez:	Gratuitous ARP.
51
 *              Jonathan Layes  :       Added arpd support through kerneld
Linus Torvalds's avatar
Linus Torvalds committed
52
53
54
55
56
57
 *                                      message queue (960314)
 *		Mike Shaver	:	/proc/sys/net/ipv4/arp_* support
 *		Mike McLagan    :	Routing by source
 *		Stuart Cheshire	:	Metricom and grat arp fixes
 *					*** FOR 2.1 clean this up ***
 *		Lawrence V. Stefani: (08/12/96) Added FDDI support.
Changli Gao's avatar
Changli Gao committed
58
 *		Alan Cox	:	Took the AP1000 nasty FDDI hack and
Linus Torvalds's avatar
Linus Torvalds committed
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 *					folded into the mainstream FDDI code.
 *					Ack spit, Linus how did you allow that
 *					one in...
 *		Jes Sorensen	:	Make FDDI work again in 2.1.x and
 *					clean up the APFDDI & gen. FDDI bits.
 *		Alexey Kuznetsov:	new arp state machine;
 *					now it is in net/core/neighbour.c.
 *		Krzysztof Halasa:	Added Frame Relay ARP support.
 *		Arnaldo C. Melo :	convert /proc/net/arp to seq_file
 *		Shmulik Hen:		Split arp_send to arp_create and
 *					arp_xmit so intermediate drivers like
 *					bonding can change the skb before
 *					sending (e.g. insert 8021q tag).
 *		Harald Welte	:	convert to make use of jenkins hash
73
 *		Jesper D. Brouer:       Proxy ARP PVLAN RFC 3069 support.
Linus Torvalds's avatar
Linus Torvalds committed
74
75
 */

76
77
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

Linus Torvalds's avatar
Linus Torvalds committed
78
79
80
81
#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/kernel.h>
82
#include <linux/capability.h>
Linus Torvalds's avatar
Linus Torvalds committed
83
84
85
86
87
88
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/errno.h>
#include <linux/in.h>
#include <linux/mm.h>
#include <linux/inet.h>
89
#include <linux/inetdevice.h>
Linus Torvalds's avatar
Linus Torvalds committed
90
91
92
93
94
95
96
97
98
99
100
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/fddidevice.h>
#include <linux/if_arp.h>
#include <linux/skbuff.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/net.h>
#include <linux/rcupdate.h>
101
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
102
103
104
105
#ifdef CONFIG_SYSCTL
#include <linux/sysctl.h>
#endif

106
#include <net/net_namespace.h>
Linus Torvalds's avatar
Linus Torvalds committed
107
108
109
110
111
112
113
114
115
#include <net/ip.h>
#include <net/icmp.h>
#include <net/route.h>
#include <net/protocol.h>
#include <net/tcp.h>
#include <net/sock.h>
#include <net/arp.h>
#include <net/ax25.h>
#include <net/netrom.h>
116
117
#include <net/dst_metadata.h>
#include <net/ip_tunnels.h>
Linus Torvalds's avatar
Linus Torvalds committed
118

Changli Gao's avatar
Changli Gao committed
119
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
120
121
122
123
124
125

#include <linux/netfilter_arp.h>

/*
 *	Interface to generic neighbour cache.
 */
126
static u32 arp_hash(const void *pkey, const struct net_device *dev, __u32 *hash_rnd);
127
static bool arp_key_eq(const struct neighbour *n, const void *pkey);
Linus Torvalds's avatar
Linus Torvalds committed
128
129
130
131
132
static int arp_constructor(struct neighbour *neigh);
static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
static void parp_redo(struct sk_buff *skb);

133
static const struct neigh_ops arp_generic_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
134
135
136
137
138
139
140
	.family =		AF_INET,
	.solicit =		arp_solicit,
	.error_report =		arp_error_report,
	.output =		neigh_resolve_output,
	.connected_output =	neigh_connected_output,
};

141
static const struct neigh_ops arp_hh_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
142
143
144
145
146
147
148
	.family =		AF_INET,
	.solicit =		arp_solicit,
	.error_report =		arp_error_report,
	.output =		neigh_resolve_output,
	.connected_output =	neigh_resolve_output,
};

149
static const struct neigh_ops arp_direct_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
150
	.family =		AF_INET,
151
152
	.output =		neigh_direct_output,
	.connected_output =	neigh_direct_output,
Linus Torvalds's avatar
Linus Torvalds committed
153
154
155
};

struct neigh_table arp_tbl = {
Changli Gao's avatar
Changli Gao committed
156
157
	.family		= AF_INET,
	.key_len	= 4,
158
	.protocol	= cpu_to_be16(ETH_P_IP),
Changli Gao's avatar
Changli Gao committed
159
	.hash		= arp_hash,
160
	.key_eq		= arp_key_eq,
Changli Gao's avatar
Changli Gao committed
161
162
163
164
165
166
	.constructor	= arp_constructor,
	.proxy_redo	= parp_redo,
	.id		= "arp_cache",
	.parms		= {
		.tbl			= &arp_tbl,
		.reachable_time		= 30 * HZ,
Jiri Pirko's avatar
Jiri Pirko committed
167
168
169
170
171
172
173
174
175
176
177
178
179
		.data	= {
			[NEIGH_VAR_MCAST_PROBES] = 3,
			[NEIGH_VAR_UCAST_PROBES] = 3,
			[NEIGH_VAR_RETRANS_TIME] = 1 * HZ,
			[NEIGH_VAR_BASE_REACHABLE_TIME] = 30 * HZ,
			[NEIGH_VAR_DELAY_PROBE_TIME] = 5 * HZ,
			[NEIGH_VAR_GC_STALETIME] = 60 * HZ,
			[NEIGH_VAR_QUEUE_LEN_BYTES] = 64 * 1024,
			[NEIGH_VAR_PROXY_QLEN] = 64,
			[NEIGH_VAR_ANYCAST_DELAY] = 1 * HZ,
			[NEIGH_VAR_PROXY_DELAY]	= (8 * HZ) / 10,
			[NEIGH_VAR_LOCKTIME] = 1 * HZ,
		},
Linus Torvalds's avatar
Linus Torvalds committed
180
	},
Changli Gao's avatar
Changli Gao committed
181
182
183
184
	.gc_interval	= 30 * HZ,
	.gc_thresh1	= 128,
	.gc_thresh2	= 512,
	.gc_thresh3	= 1024,
Linus Torvalds's avatar
Linus Torvalds committed
185
};
186
EXPORT_SYMBOL(arp_tbl);
Linus Torvalds's avatar
Linus Torvalds committed
187

188
int arp_mc_map(__be32 addr, u8 *haddr, struct net_device *dev, int dir)
Linus Torvalds's avatar
Linus Torvalds committed
189
190
191
192
193
194
{
	switch (dev->type) {
	case ARPHRD_ETHER:
	case ARPHRD_FDDI:
	case ARPHRD_IEEE802:
		ip_eth_mc_map(addr, haddr);
195
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
196
	case ARPHRD_INFINIBAND:
197
		ip_ib_mc_map(addr, dev->broadcast, haddr);
Linus Torvalds's avatar
Linus Torvalds committed
198
		return 0;
199
200
201
	case ARPHRD_IPGRE:
		ip_ipgre_mc_map(addr, dev->broadcast, haddr);
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
202
203
204
205
206
207
208
209
210
211
	default:
		if (dir) {
			memcpy(haddr, dev->broadcast, dev->addr_len);
			return 0;
		}
	}
	return -EINVAL;
}


212
213
static u32 arp_hash(const void *pkey,
		    const struct net_device *dev,
214
		    __u32 *hash_rnd)
Linus Torvalds's avatar
Linus Torvalds committed
215
{
216
217
218
219
220
221
	return arp_hashfn(pkey, dev, hash_rnd);
}

static bool arp_key_eq(const struct neighbour *neigh, const void *pkey)
{
	return neigh_key_eq32(neigh, pkey);
Linus Torvalds's avatar
Linus Torvalds committed
222
223
224
225
}

static int arp_constructor(struct neighbour *neigh)
{
Changli Gao's avatar
Changli Gao committed
226
	__be32 addr = *(__be32 *)neigh->primary_key;
Linus Torvalds's avatar
Linus Torvalds committed
227
228
229
230
231
	struct net_device *dev = neigh->dev;
	struct in_device *in_dev;
	struct neigh_parms *parms;

	rcu_read_lock();
232
	in_dev = __in_dev_get_rcu(dev);
233
	if (!in_dev) {
Linus Torvalds's avatar
Linus Torvalds committed
234
235
236
237
		rcu_read_unlock();
		return -EINVAL;
	}

238
	neigh->type = inet_addr_type_dev_table(dev_net(dev), dev, addr);
239

Linus Torvalds's avatar
Linus Torvalds committed
240
241
242
243
244
	parms = in_dev->arp_parms;
	__neigh_parms_put(neigh->parms);
	neigh->parms = neigh_parms_clone(parms);
	rcu_read_unlock();

245
	if (!dev->header_ops) {
Linus Torvalds's avatar
Linus Torvalds committed
246
247
		neigh->nud_state = NUD_NOARP;
		neigh->ops = &arp_direct_ops;
248
		neigh->output = neigh_direct_output;
Linus Torvalds's avatar
Linus Torvalds committed
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
	} else {
		/* Good devices (checked by reading texts, but only Ethernet is
		   tested)

		   ARPHRD_ETHER: (ethernet, apfddi)
		   ARPHRD_FDDI: (fddi)
		   ARPHRD_IEEE802: (tr)
		   ARPHRD_METRICOM: (strip)
		   ARPHRD_ARCNET:
		   etc. etc. etc.

		   ARPHRD_IPDDP will also work, if author repairs it.
		   I did not it, because this driver does not work even
		   in old paradigm.
		 */

		if (neigh->type == RTN_MULTICAST) {
			neigh->nud_state = NUD_NOARP;
			arp_mc_map(addr, neigh->ha, dev, 1);
Changli Gao's avatar
Changli Gao committed
268
		} else if (dev->flags & (IFF_NOARP | IFF_LOOPBACK)) {
Linus Torvalds's avatar
Linus Torvalds committed
269
270
			neigh->nud_state = NUD_NOARP;
			memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
Changli Gao's avatar
Changli Gao committed
271
272
		} else if (neigh->type == RTN_BROADCAST ||
			   (dev->flags & IFF_POINTOPOINT)) {
Linus Torvalds's avatar
Linus Torvalds committed
273
274
275
			neigh->nud_state = NUD_NOARP;
			memcpy(neigh->ha, dev->broadcast, dev->addr_len);
		}
276
277

		if (dev->header_ops->cache)
Linus Torvalds's avatar
Linus Torvalds committed
278
279
280
			neigh->ops = &arp_hh_ops;
		else
			neigh->ops = &arp_generic_ops;
281

Changli Gao's avatar
Changli Gao committed
282
		if (neigh->nud_state & NUD_VALID)
Linus Torvalds's avatar
Linus Torvalds committed
283
284
285
286
287
288
289
290
291
292
293
294
295
			neigh->output = neigh->ops->connected_output;
		else
			neigh->output = neigh->ops->output;
	}
	return 0;
}

static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
{
	dst_link_failure(skb);
	kfree_skb(skb);
}

296
297
298
299
300
/* Create and send an arp packet. */
static void 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,
301
302
			 const unsigned char *target_hw,
			 struct dst_entry *dst)
303
304
305
306
307
308
309
310
311
312
313
314
{
	struct sk_buff *skb;

	/* arp on this interface. */
	if (dev->flags & IFF_NOARP)
		return;

	skb = arp_create(type, ptype, dest_ip, dev, src_ip,
			 dest_hw, src_hw, target_hw);
	if (!skb)
		return;

315
	skb_dst_set(skb, dst_clone(dst));
316
317
318
319
320
321
322
323
324
325
326
327
328
	arp_xmit(skb);
}

void 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)
{
	arp_send_dst(type, ptype, dest_ip, dev, src_ip, dest_hw, src_hw,
		     target_hw, NULL);
}
EXPORT_SYMBOL(arp_send);

Linus Torvalds's avatar
Linus Torvalds committed
329
330
static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
{
331
	__be32 saddr = 0;
332
	u8 dst_ha[MAX_ADDR_LEN], *dst_hw = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
333
	struct net_device *dev = neigh->dev;
Changli Gao's avatar
Changli Gao committed
334
	__be32 target = *(__be32 *)neigh->primary_key;
Linus Torvalds's avatar
Linus Torvalds committed
335
	int probes = atomic_read(&neigh->probes);
336
	struct in_device *in_dev;
337
	struct dst_entry *dst = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
338

339
340
341
342
	rcu_read_lock();
	in_dev = __in_dev_get_rcu(dev);
	if (!in_dev) {
		rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
343
		return;
344
	}
Linus Torvalds's avatar
Linus Torvalds committed
345
346
347
	switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {
	default:
	case 0:		/* By default announce any local IP */
348
		if (skb && inet_addr_type_dev_table(dev_net(dev), dev,
Changli Gao's avatar
Changli Gao committed
349
					  ip_hdr(skb)->saddr) == RTN_LOCAL)
350
			saddr = ip_hdr(skb)->saddr;
Linus Torvalds's avatar
Linus Torvalds committed
351
352
353
354
		break;
	case 1:		/* Restrict announcements of saddr in same subnet */
		if (!skb)
			break;
355
		saddr = ip_hdr(skb)->saddr;
356
357
		if (inet_addr_type_dev_table(dev_net(dev), dev,
					     saddr) == RTN_LOCAL) {
Linus Torvalds's avatar
Linus Torvalds committed
358
359
360
361
362
363
364
365
366
			/* saddr should be known to target */
			if (inet_addr_onlink(in_dev, target, saddr))
				break;
		}
		saddr = 0;
		break;
	case 2:		/* Avoid secondary IPs, get a primary/preferred one */
		break;
	}
367
	rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
368
369
370
371

	if (!saddr)
		saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);

Jiri Pirko's avatar
Jiri Pirko committed
372
	probes -= NEIGH_VAR(neigh->parms, UCAST_PROBES);
Changli Gao's avatar
Changli Gao committed
373
374
	if (probes < 0) {
		if (!(neigh->nud_state & NUD_VALID))
375
			pr_debug("trying to ucast probe in NUD_INVALID\n");
376
		neigh_ha_snapshot(dst_ha, neigh, dev);
377
		dst_hw = dst_ha;
Changli Gao's avatar
Changli Gao committed
378
	} else {
Jiri Pirko's avatar
Jiri Pirko committed
379
		probes -= NEIGH_VAR(neigh->parms, APP_PROBES);
Changli Gao's avatar
Changli Gao committed
380
381
382
383
		if (probes < 0) {
			neigh_app_ns(neigh);
			return;
		}
Linus Torvalds's avatar
Linus Torvalds committed
384
385
	}

386
	if (skb && !(dev->priv_flags & IFF_XMIT_DST_RELEASE))
387
		dst = skb_dst(skb);
388
	arp_send_dst(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
389
		     dst_hw, dev->dev_addr, NULL, dst);
Linus Torvalds's avatar
Linus Torvalds committed
390
391
}

392
static int arp_ignore(struct in_device *in_dev, __be32 sip, __be32 tip)
Linus Torvalds's avatar
Linus Torvalds committed
393
{
394
	struct net *net = dev_net(in_dev->dev);
Linus Torvalds's avatar
Linus Torvalds committed
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
	int scope;

	switch (IN_DEV_ARP_IGNORE(in_dev)) {
	case 0:	/* Reply, the tip is already validated */
		return 0;
	case 1:	/* Reply only if tip is configured on the incoming interface */
		sip = 0;
		scope = RT_SCOPE_HOST;
		break;
	case 2:	/*
		 * Reply only if tip is configured on the incoming interface
		 * and is in same subnet as sip
		 */
		scope = RT_SCOPE_HOST;
		break;
	case 3:	/* Do not reply for scope host addresses */
		sip = 0;
		scope = RT_SCOPE_LINK;
413
		in_dev = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
414
415
416
417
418
419
420
421
422
423
424
		break;
	case 4:	/* Reserved */
	case 5:
	case 6:
	case 7:
		return 0;
	case 8:	/* Do not reply */
		return 1;
	default:
		return 0;
	}
425
	return !inet_confirm_addr(net, in_dev, sip, tip, scope);
Linus Torvalds's avatar
Linus Torvalds committed
426
427
}

428
static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
429
430
{
	struct rtable *rt;
431
	int flag = 0;
Linus Torvalds's avatar
Linus Torvalds committed
432
	/*unsigned long now; */
433
	struct net *net = dev_net(dev);
Linus Torvalds's avatar
Linus Torvalds committed
434

435
	rt = ip_route_output(net, sip, tip, 0, 0);
436
	if (IS_ERR(rt))
Linus Torvalds's avatar
Linus Torvalds committed
437
		return 1;
438
	if (rt->dst.dev != dev) {
439
		__NET_INC_STATS(net, LINUX_MIB_ARPFILTER);
Linus Torvalds's avatar
Linus Torvalds committed
440
		flag = 1;
441
442
443
444
	}
	ip_rt_put(rt);
	return flag;
}
Linus Torvalds's avatar
Linus Torvalds committed
445
446
447
448

/*
 * Check if we can use proxy ARP for this path
 */
449
450
static inline int arp_fwd_proxy(struct in_device *in_dev,
				struct net_device *dev,	struct rtable *rt)
Linus Torvalds's avatar
Linus Torvalds committed
451
452
453
454
{
	struct in_device *out_dev;
	int imi, omi = -1;

455
	if (rt->dst.dev == dev)
456
457
		return 0;

Linus Torvalds's avatar
Linus Torvalds committed
458
459
	if (!IN_DEV_PROXY_ARP(in_dev))
		return 0;
Changli Gao's avatar
Changli Gao committed
460
461
	imi = IN_DEV_MEDIUM_ID(in_dev);
	if (imi == 0)
Linus Torvalds's avatar
Linus Torvalds committed
462
463
464
465
466
467
		return 1;
	if (imi == -1)
		return 0;

	/* place to check for proxy_arp for routes */

468
	out_dev = __in_dev_get_rcu(rt->dst.dev);
Eric Dumazet's avatar
Eric Dumazet committed
469
	if (out_dev)
Linus Torvalds's avatar
Linus Torvalds committed
470
		omi = IN_DEV_MEDIUM_ID(out_dev);
Eric Dumazet's avatar
Eric Dumazet committed
471

Eric Dumazet's avatar
Eric Dumazet committed
472
	return omi != imi && omi != -1;
Linus Torvalds's avatar
Linus Torvalds committed
473
474
}

475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
/*
 * Check for RFC3069 proxy arp private VLAN (allow to send back to same dev)
 *
 * RFC3069 supports proxy arp replies back to the same interface.  This
 * is done to support (ethernet) switch features, like RFC 3069, where
 * the individual ports are not allowed to communicate with each
 * other, BUT they are allowed to talk to the upstream router.  As
 * described in RFC 3069, it is possible to allow these hosts to
 * communicate through the upstream router, by proxy_arp'ing.
 *
 * RFC 3069: "VLAN Aggregation for Efficient IP Address Allocation"
 *
 *  This technology is known by different names:
 *    In RFC 3069 it is called VLAN Aggregation.
 *    Cisco and Allied Telesyn call it Private VLAN.
 *    Hewlett-Packard call it Source-Port filtering or port-isolation.
 *    Ericsson call it MAC-Forced Forwarding (RFC Draft).
 *
 */
static inline int arp_fwd_pvlan(struct in_device *in_dev,
				struct net_device *dev,	struct rtable *rt,
				__be32 sip, __be32 tip)
{
	/* Private VLAN is only concerned about the same ethernet segment */
499
	if (rt->dst.dev != dev)
500
501
502
503
504
505
506
507
508
509
510
511
		return 0;

	/* Don't reply on self probes (often done by windowz boxes)*/
	if (sip == tip)
		return 0;

	if (IN_DEV_PROXY_ARP_PVLAN(in_dev))
		return 1;
	else
		return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
512
513
514
515
516
/*
 *	Interface to link layer: send routine and receive handler.
 */

/*
517
 *	Create an arp packet. If dest_hw is not set, we create a broadcast
Linus Torvalds's avatar
Linus Torvalds committed
518
519
 *	message.
 */
520
521
struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
			   struct net_device *dev, __be32 src_ip,
522
523
524
			   const unsigned char *dest_hw,
			   const unsigned char *src_hw,
			   const unsigned char *target_hw)
Linus Torvalds's avatar
Linus Torvalds committed
525
526
527
528
{
	struct sk_buff *skb;
	struct arphdr *arp;
	unsigned char *arp_ptr;
529
530
	int hlen = LL_RESERVED_SPACE(dev);
	int tlen = dev->needed_tailroom;
Linus Torvalds's avatar
Linus Torvalds committed
531
532
533
534

	/*
	 *	Allocate a buffer
	 */
535

536
537
538
539
540
541
	int skb_sz = arp_hdr_len(dev) + hlen + tlen;

	if (dev->features & NETIF_F_PRIV_DATA_POOL)
		skb_sz |= SKB_DATA_PRIV_POOL;

	skb = alloc_skb(skb_sz, GFP_ATOMIC);
542
	if (!skb)
Linus Torvalds's avatar
Linus Torvalds committed
543
544
		return NULL;

545
	skb_reserve(skb, hlen);
546
	skb_reset_network_header(skb);
547
	arp = (struct arphdr *) skb_put(skb, arp_hdr_len(dev));
Linus Torvalds's avatar
Linus Torvalds committed
548
549
	skb->dev = dev;
	skb->protocol = htons(ETH_P_ARP);
550
	if (!src_hw)
Linus Torvalds's avatar
Linus Torvalds committed
551
		src_hw = dev->dev_addr;
552
	if (!dest_hw)
Linus Torvalds's avatar
Linus Torvalds committed
553
554
555
556
557
		dest_hw = dev->broadcast;

	/*
	 *	Fill the device header for the ARP frame
	 */
558
	if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)
Linus Torvalds's avatar
Linus Torvalds committed
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
		goto out;

	/*
	 * Fill out the arp protocol part.
	 *
	 * The arp hardware type should match the device type, except for FDDI,
	 * which (according to RFC 1390) should always equal 1 (Ethernet).
	 */
	/*
	 *	Exceptions everywhere. AX.25 uses the AX.25 PID value not the
	 *	DIX code for the protocol. Make these device structure fields.
	 */
	switch (dev->type) {
	default:
		arp->ar_hrd = htons(dev->type);
		arp->ar_pro = htons(ETH_P_IP);
		break;

Igor Maravic's avatar
Igor Maravic committed
577
#if IS_ENABLED(CONFIG_AX25)
Linus Torvalds's avatar
Linus Torvalds committed
578
579
580
581
582
	case ARPHRD_AX25:
		arp->ar_hrd = htons(ARPHRD_AX25);
		arp->ar_pro = htons(AX25_P_IP);
		break;

Igor Maravic's avatar
Igor Maravic committed
583
#if IS_ENABLED(CONFIG_NETROM)
Linus Torvalds's avatar
Linus Torvalds committed
584
585
586
587
588
589
590
	case ARPHRD_NETROM:
		arp->ar_hrd = htons(ARPHRD_NETROM);
		arp->ar_pro = htons(AX25_P_IP);
		break;
#endif
#endif

Igor Maravic's avatar
Igor Maravic committed
591
#if IS_ENABLED(CONFIG_FDDI)
Linus Torvalds's avatar
Linus Torvalds committed
592
593
594
595
596
597
598
599
600
601
602
	case ARPHRD_FDDI:
		arp->ar_hrd = htons(ARPHRD_ETHER);
		arp->ar_pro = htons(ETH_P_IP);
		break;
#endif
	}

	arp->ar_hln = dev->addr_len;
	arp->ar_pln = 4;
	arp->ar_op = htons(type);

Changli Gao's avatar
Changli Gao committed
603
	arp_ptr = (unsigned char *)(arp + 1);
Linus Torvalds's avatar
Linus Torvalds committed
604
605

	memcpy(arp_ptr, src_hw, dev->addr_len);
Jianjun Kong's avatar
Jianjun Kong committed
606
607
608
	arp_ptr += dev->addr_len;
	memcpy(arp_ptr, &src_ip, 4);
	arp_ptr += 4;
609
610
611
612
613
614
615

	switch (dev->type) {
#if IS_ENABLED(CONFIG_FIREWIRE_NET)
	case ARPHRD_IEEE1394:
		break;
#endif
	default:
616
		if (target_hw)
617
618
619
620
621
			memcpy(arp_ptr, target_hw, dev->addr_len);
		else
			memset(arp_ptr, 0, dev->addr_len);
		arp_ptr += dev->addr_len;
	}
Linus Torvalds's avatar
Linus Torvalds committed
622
623
624
625
626
627
628
629
	memcpy(arp_ptr, &dest_ip, 4);

	return skb;

out:
	kfree_skb(skb);
	return NULL;
}
630
EXPORT_SYMBOL(arp_create);
Linus Torvalds's avatar
Linus Torvalds committed
631

632
static int arp_xmit_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
633
634
635
636
{
	return dev_queue_xmit(skb);
}

Linus Torvalds's avatar
Linus Torvalds committed
637
638
639
640
641
642
/*
 *	Send an arp packet.
 */
void arp_xmit(struct sk_buff *skb)
{
	/* Send it off, maybe filter it using firewalling first.  */
643
644
645
	NF_HOOK(NFPROTO_ARP, NF_ARP_OUT,
		dev_net(skb->dev), NULL, skb, NULL, skb->dev,
		arp_xmit_finish);
Linus Torvalds's avatar
Linus Torvalds committed
646
}
647
EXPORT_SYMBOL(arp_xmit);
Linus Torvalds's avatar
Linus Torvalds committed
648
649
650
651
652

/*
 *	Process an arp request.
 */

653
static int arp_process(struct net *net, struct sock *sk, struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
654
655
{
	struct net_device *dev = skb->dev;
Eric Dumazet's avatar
Eric Dumazet committed
656
	struct in_device *in_dev = __in_dev_get_rcu(dev);
Linus Torvalds's avatar
Linus Torvalds committed
657
658
659
	struct arphdr *arp;
	unsigned char *arp_ptr;
	struct rtable *rt;
Mark Ryden's avatar
Mark Ryden committed
660
	unsigned char *sha;
Al Viro's avatar
Al Viro committed
661
	__be32 sip, tip;
Linus Torvalds's avatar
Linus Torvalds committed
662
663
664
	u16 dev_type = dev->type;
	int addr_type;
	struct neighbour *n;
665
	struct dst_entry *reply_dst = NULL;
666
	bool is_garp = false;
Linus Torvalds's avatar
Linus Torvalds committed
667
668
669
670
671

	/* arp_rcv below verifies the ARP header and verifies the device
	 * is ARP'able.
	 */

672
	if (!in_dev)
673
		goto out_free_skb;
Linus Torvalds's avatar
Linus Torvalds committed
674

675
	arp = arp_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
676
677

	switch (dev_type) {
678
	default:
Linus Torvalds's avatar
Linus Torvalds committed
679
680
		if (arp->ar_pro != htons(ETH_P_IP) ||
		    htons(dev_type) != arp->ar_hrd)
681
			goto out_free_skb;
Linus Torvalds's avatar
Linus Torvalds committed
682
683
684
685
686
		break;
	case ARPHRD_ETHER:
	case ARPHRD_FDDI:
	case ARPHRD_IEEE802:
		/*
687
		 * ETHERNET, and Fibre Channel (which are IEEE 802
Linus Torvalds's avatar
Linus Torvalds committed
688
689
690
691
692
693
694
695
696
697
		 * devices, according to RFC 2625) devices will accept ARP
		 * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
		 * This is the case also of FDDI, where the RFC 1390 says that
		 * FDDI devices should accept ARP hardware of (1) Ethernet,
		 * however, to be more robust, we'll accept both 1 (Ethernet)
		 * or 6 (IEEE 802.2)
		 */
		if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
		     arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
		    arp->ar_pro != htons(ETH_P_IP))
698
			goto out_free_skb;
Linus Torvalds's avatar
Linus Torvalds committed
699
700
701
702
		break;
	case ARPHRD_AX25:
		if (arp->ar_pro != htons(AX25_P_IP) ||
		    arp->ar_hrd != htons(ARPHRD_AX25))
703
			goto out_free_skb;
Linus Torvalds's avatar
Linus Torvalds committed
704
705
706
707
		break;
	case ARPHRD_NETROM:
		if (arp->ar_pro != htons(AX25_P_IP) ||
		    arp->ar_hrd != htons(ARPHRD_NETROM))
708
			goto out_free_skb;
Linus Torvalds's avatar
Linus Torvalds committed
709
710
711
712
713
714
715
		break;
	}

	/* Understand only these message types */

	if (arp->ar_op != htons(ARPOP_REPLY) &&
	    arp->ar_op != htons(ARPOP_REQUEST))
716
		goto out_free_skb;
Linus Torvalds's avatar
Linus Torvalds committed
717
718
719
720

/*
 *	Extract fields
 */
Changli Gao's avatar
Changli Gao committed
721
	arp_ptr = (unsigned char *)(arp + 1);
Linus Torvalds's avatar
Linus Torvalds committed
722
723
724
725
	sha	= arp_ptr;
	arp_ptr += dev->addr_len;
	memcpy(&sip, arp_ptr, 4);
	arp_ptr += 4;
726
727
728
729
730
731
732
733
	switch (dev_type) {
#if IS_ENABLED(CONFIG_FIREWIRE_NET)
	case ARPHRD_IEEE1394:
		break;
#endif
	default:
		arp_ptr += dev->addr_len;
	}
Linus Torvalds's avatar
Linus Torvalds committed
734
	memcpy(&tip, arp_ptr, 4);
735
/*
Linus Torvalds's avatar
Linus Torvalds committed
736
737
738
 *	Check for bad requests for 127.x.x.x and requests for multicast
 *	addresses.  If this is one such, delete it.
 */
739
740
	if (ipv4_is_multicast(tip) ||
	    (!IN_DEV_ROUTE_LOCALNET(in_dev) && ipv4_is_loopback(tip)))
741
		goto out_free_skb;
Linus Torvalds's avatar
Linus Torvalds committed
742

743
744
745
746
747
748
 /*
  *	For some 802.11 wireless deployments (and possibly other networks),
  *	there will be an ARP proxy and gratuitous ARP frames are attacks
  *	and thus should not be accepted.
  */
	if (sip == tip && IN_DEV_ORCONF(in_dev, DROP_GRATUITOUS_ARP))
749
		goto out_free_skb;
750

Linus Torvalds's avatar
Linus Torvalds committed
751
752
753
754
755
756
757
758
759
760
/*
 *     Special case: We must set Frame Relay source Q.922 address
 */
	if (dev_type == ARPHRD_DLCI)
		sha = dev->broadcast;

/*
 *  Process entry.  The idea here is we want to send a reply if it is a
 *  request for us or if it is a request for someone else that we hold
 *  a proxy for.  We want to add an entry to our cache if it is a reply
761
762
763
764
 *  to us or if it is a request for our address.
 *  (The assumption for this last is that if someone is requesting our
 *  address, they are probably intending to talk to us, so it saves time
 *  if we cache their address.  Their address is also probably not in
Linus Torvalds's avatar
Linus Torvalds committed
765
 *  our cache, since ours is not in their cache.)
766
 *
Linus Torvalds's avatar
Linus Torvalds committed
767
768
769
 *  Putting this another way, we only care about replies if they are to
 *  us, in which case we add them to the cache.  For requests, we care
 *  about those for us and those for our proxies.  We reply to both,
770
 *  and in the case of requests for us we add the requester to the arp
Linus Torvalds's avatar
Linus Torvalds committed
771
772
773
 *  cache.
 */

774
775
776
777
778
	if (arp->ar_op == htons(ARPOP_REQUEST) && skb_metadata_dst(skb))
		reply_dst = (struct dst_entry *)
			    iptunnel_metadata_reply(skb_metadata_dst(skb),
						    GFP_ATOMIC);

779
780
	/* Special case: IPv4 duplicate address detection packet (RFC2131) */
	if (sip == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
781
		if (arp->ar_op == htons(ARPOP_REQUEST) &&
782
		    inet_addr_type_dev_table(net, dev, tip) == RTN_LOCAL &&
783
		    !arp_ignore(in_dev, sip, tip))
784
785
			arp_send_dst(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip,
				     sha, dev->dev_addr, sha, reply_dst);
786
		goto out_consume_skb;
Linus Torvalds's avatar
Linus Torvalds committed
787
788
789
	}

	if (arp->ar_op == htons(ARPOP_REQUEST) &&
790
	    ip_route_input_noref(skb, tip, sip, 0, dev) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
791

Eric Dumazet's avatar
Eric Dumazet committed
792
		rt = skb_rtable(skb);
Linus Torvalds's avatar
Linus Torvalds committed
793
794
795
		addr_type = rt->rt_type;

		if (addr_type == RTN_LOCAL) {
Changli Gao's avatar
Changli Gao committed
796
			int dont_send;
797

Changli Gao's avatar
Changli Gao committed
798
			dont_send = arp_ignore(in_dev, sip, tip);
799
			if (!dont_send && IN_DEV_ARPFILTER(in_dev))
Changli Gao's avatar
Changli Gao committed
800
				dont_send = arp_filter(sip, tip, dev);
801
802
803
			if (!dont_send) {
				n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
				if (n) {
804
805
806
807
					arp_send_dst(ARPOP_REPLY, ETH_P_ARP,
						     sip, dev, tip, sha,
						     dev->dev_addr, sha,
						     reply_dst);
808
809
					neigh_release(n);
				}
Linus Torvalds's avatar
Linus Torvalds committed
810
			}
811
			goto out_consume_skb;
Linus Torvalds's avatar
Linus Torvalds committed
812
		} else if (IN_DEV_FORWARD(in_dev)) {
813
814
815
			if (addr_type == RTN_UNICAST  &&
			    (arp_fwd_proxy(in_dev, dev, rt) ||
			     arp_fwd_pvlan(in_dev, dev, rt, sip, tip) ||
816
817
			     (rt->dst.dev != dev &&
			      pneigh_lookup(&arp_tbl, net, &tip, dev, 0)))) {
Linus Torvalds's avatar
Linus Torvalds committed
818
819
820
821
				n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
				if (n)
					neigh_release(n);

822
				if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
Linus Torvalds's avatar
Linus Torvalds committed
823
				    skb->pkt_type == PACKET_HOST ||
Jiri Pirko's avatar
Jiri Pirko committed
824
				    NEIGH_VAR(in_dev->arp_parms, PROXY_DELAY) == 0) {
825
826
827
828
					arp_send_dst(ARPOP_REPLY, ETH_P_ARP,
						     sip, dev, tip, sha,
						     dev->dev_addr, sha,
						     reply_dst);
Linus Torvalds's avatar
Linus Torvalds committed
829
				} else {
Changli Gao's avatar
Changli Gao committed
830
831
					pneigh_enqueue(&arp_tbl,
						       in_dev->arp_parms, skb);
832
					goto out_free_dst;
Linus Torvalds's avatar
Linus Torvalds committed
833
				}
834
				goto out_consume_skb;
Linus Torvalds's avatar
Linus Torvalds committed
835
836
837
838
839
840
841
842
			}
		}
	}

	/* Update our ARP tables */

	n = __neigh_lookup(&arp_tbl, &sip, dev, 0);

843
	if (IN_DEV_ARP_ACCEPT(in_dev)) {
844
845
		unsigned int addr_type = inet_addr_type_dev_table(net, dev, sip);

846
847
848
849
		/* Unsolicited ARP is not accepted by default.
		   It is possible, that this option should be enabled for some
		   devices (strip is candidate)
		 */
850
		is_garp = arp->ar_op == htons(ARPOP_REQUEST) && tip == sip &&
851
			  addr_type == RTN_UNICAST;
852

853
		if (!n &&
854
		    ((arp->ar_op == htons(ARPOP_REPLY)  &&
855
				addr_type == RTN_UNICAST) || is_garp))
856
			n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
857
	}
Linus Torvalds's avatar
Linus Torvalds committed
858
859
860
861
862
863
864
865
866
867

	if (n) {
		int state = NUD_REACHABLE;
		int override;

		/* If several different ARP replies follows back-to-back,
		   use the FIRST one. It is possible, if several proxy
		   agents are active. Taking the first reply prevents
		   arp trashing and chooses the fastest router.
		 */
868
869
870
871
		override = time_after(jiffies,
				      n->updated +
				      NEIGH_VAR(n->parms, LOCKTIME)) ||
			   is_garp;
Linus Torvalds's avatar
Linus Torvalds committed
872
873
874
875
876
877
878

		/* Broadcast replies and request packets
		   do not assert neighbour reachability.
		 */
		if (arp->ar_op != htons(ARPOP_REPLY) ||
		    skb->pkt_type != PACKET_HOST)
			state = NUD_STALE;
Changli Gao's avatar
Changli Gao committed
879
880
		neigh_update(n, sha, state,
			     override ? NEIGH_UPDATE_F_OVERRIDE : 0);
Linus Torvalds's avatar
Linus Torvalds committed
881
882
883
		neigh_release(n);
	}

884
out_consume_skb:
885
	consume_skb(skb);
886

887
888
out_free_dst:
	dst_release(reply_dst);
889
890
891
892
893
	return NET_RX_SUCCESS;

out_free_skb:
	kfree_skb(skb);
	return NET_RX_DROP;
Linus Torvalds's avatar
Linus Torvalds committed
894
895
}

896
897
static void parp_redo(struct sk_buff *skb)
{
898
	arp_process(dev_net(skb->dev), NULL, skb);
899
900
}

Linus Torvalds's avatar
Linus Torvalds committed
901
902
903
904
905

/*
 *	Receive an arp request from the device layer.
 */

Adrian Bunk's avatar
Adrian Bunk committed
906
907
static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
		   struct packet_type *pt, struct net_device *orig_dev)
Linus Torvalds's avatar
Linus Torvalds committed
908
{
909
910
	const struct arphdr *arp;

911
	/* do not tweak dropwatch on an ARP we will ignore */
912
913
914
	if (dev->flags & IFF_NOARP ||
	    skb->pkt_type == PACKET_OTHERHOST ||
	    skb->pkt_type == PACKET_LOOPBACK)
915
		goto consumeskb;
916
917
918
919

	skb = skb_share_check(skb, GFP_ATOMIC);
	if (!skb)
		goto out_of_mem;
Linus Torvalds's avatar
Linus Torvalds committed
920
921

	/* ARP header, plus 2 device addresses, plus 2 IP addresses.  */
922
	if (!pskb_may_pull(skb, arp_hdr_len(dev)))
Linus Torvalds's avatar
Linus Torvalds committed
923
924
		goto freeskb;

925
	arp = arp_hdr(skb);
926
	if (arp->ar_hln != dev->addr_len || arp->ar_pln != 4)
Linus Torvalds's avatar
Linus Torvalds committed
927
928
		goto freeskb;

929
930
	memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));

931
932
933
	return NF_HOOK(NFPROTO_ARP, NF_ARP_IN,
		       dev_net(dev), NULL, skb, dev, NULL,
		       arp_process);
Linus Torvalds's avatar
Linus Torvalds committed
934

935
936
consumeskb:
	consume_skb(skb);
937
	return NET_RX_SUCCESS;
Linus Torvalds's avatar
Linus Torvalds committed
938
939
940
freeskb:
	kfree_skb(skb);
out_of_mem:
941
	return NET_RX_DROP;
Linus Torvalds's avatar
Linus Torvalds committed
942
943
944
945
946
947
948
949
950
951
}

/*
 *	User level interface (ioctl)
 */

/*
 *	Set (create) an ARP cache entry.
 */

952
static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on)
953
{
954
	if (!dev) {
955
		IPV4_DEVCONF_ALL(net, PROXY_ARP) = on;
956
957
		return 0;
	}
Eric Dumazet's avatar
Eric Dumazet committed
958
959
	if (__in_dev_get_rtnl(dev)) {
		IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, on);
960
961
962
963
964
		return 0;
	}
	return -ENXIO;
}

965
966
static int arp_req_set_public(struct net *net, struct arpreq *r,
		struct net_device *dev)
967
968
969
970
971
972
973
{
	__be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
	__be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;

	if (mask && mask != htonl(0xFFFFFFFF))
		return -EINVAL;
	if (!dev && (r->arp_flags & ATF_COM)) {
974
		dev = dev_getbyhwaddr_rcu(net, r->arp_ha.sa_family,
Changli Gao's avatar
Changli Gao committed
975
				      r->arp_ha.sa_data);
976
977
978
979
		if (!dev)
			return -ENODEV;
	}
	if (mask) {
980
		if (!pneigh_lookup(&arp_tbl, net, &ip, dev, 1))
981
982
983
			return -ENOBUFS;
		return 0;
	}
984

985
	return arp_req_set_proxy(net, dev, 1);
986
987
}

988
static int arp_req_set(struct net *net, struct arpreq *r,
Changli Gao's avatar
Changli Gao committed
989
		       struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
990
{
991
	__be32 ip;
Linus Torvalds's avatar
Linus Torvalds committed
992
993
994
	struct neighbour *neigh;
	int err;

995
	if (r->arp_flags & ATF_PUBL)
996
		return arp_req_set_public(net, r, dev);
Linus Torvalds's avatar
Linus Torvalds committed
997

998
	ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
Linus Torvalds's avatar
Linus Torvalds committed
999
1000
	if (r->arp_flags & ATF_PERM)
		r->arp_flags |= ATF_COM;
For faster browsing, not all history is shown. View entire blame