route.c 87.6 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
L
Linus Torvalds 已提交
2 3 4 5 6 7 8
/*
 * INET		An implementation of the TCP/IP protocol suite for the LINUX
 *		operating system.  INET is implemented using the  BSD Socket
 *		interface as the means of communication with the user level.
 *
 *		ROUTE - implementation of the IP router.
 *
9
 * Authors:	Ross Biro
L
Linus Torvalds 已提交
10 11 12 13 14 15 16 17 18 19 20 21
 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 *		Alan Cox, <gw4pts@gw4pts.ampr.org>
 *		Linus Torvalds, <Linus.Torvalds@helsinki.fi>
 *		Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 *
 * Fixes:
 *		Alan Cox	:	Verify area fixes.
 *		Alan Cox	:	cli() protects routing changes
 *		Rui Oliveira	:	ICMP routing table updates
 *		(rco@di.uminho.pt)	Routing table insertion and update
 *		Linus Torvalds	:	Rewrote bits to be sensible
 *		Alan Cox	:	Added BSD route gw semantics
22
 *		Alan Cox	:	Super /proc >4K
L
Linus Torvalds 已提交
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
 *		Alan Cox	:	MTU in route table
 *		Alan Cox	: 	MSS actually. Also added the window
 *					clamper.
 *		Sam Lantinga	:	Fixed route matching in rt_del()
 *		Alan Cox	:	Routing cache support.
 *		Alan Cox	:	Removed compatibility cruft.
 *		Alan Cox	:	RTF_REJECT support.
 *		Alan Cox	:	TCP irtt support.
 *		Jonathan Naylor	:	Added Metric support.
 *	Miquel van Smoorenburg	:	BSD API fixes.
 *	Miquel van Smoorenburg	:	Metrics.
 *		Alan Cox	:	Use __u32 properly
 *		Alan Cox	:	Aligned routing errors more closely with BSD
 *					our system is still very different.
 *		Alan Cox	:	Faster /proc handling
 *	Alexey Kuznetsov	:	Massive rework to support tree based routing,
 *					routing caches and better behaviour.
40
 *
L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
 *		Olaf Erb	:	irtt wasn't being copied right.
 *		Bjorn Ekwall	:	Kerneld route support.
 *		Alan Cox	:	Multicast fixed (I hope)
 * 		Pavel Krauz	:	Limited broadcast fixed
 *		Mike McLagan	:	Routing by source
 *	Alexey Kuznetsov	:	End of old history. Split to fib.c and
 *					route.c and rewritten from scratch.
 *		Andi Kleen	:	Load-limit warning messages.
 *	Vitaly E. Lavrov	:	Transparent proxy revived after year coma.
 *	Vitaly E. Lavrov	:	Race condition in ip_route_input_slow.
 *	Tobias Ringstrom	:	Uninitialized res.type in ip_route_output_slow.
 *	Vladimir V. Ivanov	:	IP rule info (flowid) is really useful.
 *		Marc Boucher	:	routing by fwmark
 *	Robert Olsson		:	Added rt_cache statistics
 *	Arnaldo C. Melo		:	Convert proc stuff to seq_file
56
 *	Eric Dumazet		:	hashed spinlocks and rt_check_expire() fixes.
57 58
 * 	Ilia Sotnikov		:	Ignore TOS on PMTUD and Redirect
 * 	Ilia Sotnikov		:	Removed TOS from hash calculations
L
Linus Torvalds 已提交
59 60
 */

61 62
#define pr_fmt(fmt) "IPv4: " fmt

L
Linus Torvalds 已提交
63
#include <linux/module.h>
64
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
#include <linux/bitops.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/errno.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/proc_fs.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/inetdevice.h>
#include <linux/igmp.h>
#include <linux/pkt_sched.h>
#include <linux/mroute.h>
#include <linux/netfilter_ipv4.h>
#include <linux/random.h>
#include <linux/rcupdate.h>
#include <linux/times.h>
87
#include <linux/slab.h>
88
#include <linux/jhash.h>
89
#include <net/dst.h>
90
#include <net/dst_metadata.h>
91
#include <net/net_namespace.h>
L
Linus Torvalds 已提交
92 93 94 95 96 97
#include <net/protocol.h>
#include <net/ip.h>
#include <net/route.h>
#include <net/inetpeer.h>
#include <net/sock.h>
#include <net/ip_fib.h>
98
#include <net/nexthop.h>
L
Linus Torvalds 已提交
99 100 101 102
#include <net/arp.h>
#include <net/tcp.h>
#include <net/icmp.h>
#include <net/xfrm.h>
103
#include <net/lwtunnel.h>
104
#include <net/netevent.h>
105
#include <net/rtnetlink.h>
L
Linus Torvalds 已提交
106 107 108
#ifdef CONFIG_SYSCTL
#include <linux/sysctl.h>
#endif
109
#include <net/secure_seq.h>
110
#include <net/ip_tunnels.h>
111
#include <net/l3mdev.h>
L
Linus Torvalds 已提交
112

113 114
#include "fib_lookup.h"

115
#define RT_FL_TOS(oldflp4) \
116
	((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
L
Linus Torvalds 已提交
117 118 119 120

#define RT_GC_TIMEOUT (300*HZ)

static int ip_rt_max_size;
121 122 123 124 125 126
static int ip_rt_redirect_number __read_mostly	= 9;
static int ip_rt_redirect_load __read_mostly	= HZ / 50;
static int ip_rt_redirect_silence __read_mostly	= ((HZ / 50) << (9 + 1));
static int ip_rt_error_cost __read_mostly	= HZ;
static int ip_rt_error_burst __read_mostly	= 5 * HZ;
static int ip_rt_mtu_expires __read_mostly	= 10 * 60 * HZ;
127
static u32 ip_rt_min_pmtu __read_mostly		= 512 + 20 + 20;
128
static int ip_rt_min_advmss __read_mostly	= 256;
129

130
static int ip_rt_gc_timeout __read_mostly	= RT_GC_TIMEOUT;
131

L
Linus Torvalds 已提交
132 133 134 135 136
/*
 *	Interface to generic destination cache.
 */

static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
137
static unsigned int	 ipv4_default_advmss(const struct dst_entry *dst);
138
static unsigned int	 ipv4_mtu(const struct dst_entry *dst);
L
Linus Torvalds 已提交
139 140
static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
static void		 ipv4_link_failure(struct sk_buff *skb);
141
static void		 ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
142 143
					   struct sk_buff *skb, u32 mtu,
					   bool confirm_neigh);
144 145
static void		 ip_do_redirect(struct dst_entry *dst, struct sock *sk,
					struct sk_buff *skb);
146
static void		ipv4_dst_destroy(struct dst_entry *dst);
L
Linus Torvalds 已提交
147

148 149
static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
{
150 151
	WARN_ON(1);
	return NULL;
152 153
}

154 155 156
static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
					   struct sk_buff *skb,
					   const void *daddr);
157
static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr);
158

L
Linus Torvalds 已提交
159 160 161
static struct dst_ops ipv4_dst_ops = {
	.family =		AF_INET,
	.check =		ipv4_dst_check,
162
	.default_advmss =	ipv4_default_advmss,
163
	.mtu =			ipv4_mtu,
164
	.cow_metrics =		ipv4_cow_metrics,
165
	.destroy =		ipv4_dst_destroy,
L
Linus Torvalds 已提交
166 167 168
	.negative_advice =	ipv4_negative_advice,
	.link_failure =		ipv4_link_failure,
	.update_pmtu =		ip_rt_update_pmtu,
169
	.redirect =		ip_do_redirect,
170
	.local_out =		__ip_local_out,
171
	.neigh_lookup =		ipv4_neigh_lookup,
172
	.confirm_neigh =	ipv4_confirm_neigh,
L
Linus Torvalds 已提交
173 174 175 176
};

#define ECN_OR_COST(class)	TC_PRIO_##class

177
const __u8 ip_tos2prio[16] = {
L
Linus Torvalds 已提交
178
	TC_PRIO_BESTEFFORT,
D
Dan Siemon 已提交
179
	ECN_OR_COST(BESTEFFORT),
L
Linus Torvalds 已提交
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
	TC_PRIO_BESTEFFORT,
	ECN_OR_COST(BESTEFFORT),
	TC_PRIO_BULK,
	ECN_OR_COST(BULK),
	TC_PRIO_BULK,
	ECN_OR_COST(BULK),
	TC_PRIO_INTERACTIVE,
	ECN_OR_COST(INTERACTIVE),
	TC_PRIO_INTERACTIVE,
	ECN_OR_COST(INTERACTIVE),
	TC_PRIO_INTERACTIVE_BULK,
	ECN_OR_COST(INTERACTIVE_BULK),
	TC_PRIO_INTERACTIVE_BULK,
	ECN_OR_COST(INTERACTIVE_BULK)
};
195
EXPORT_SYMBOL(ip_tos2prio);
L
Linus Torvalds 已提交
196

197
static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
198
#define RT_CACHE_STAT_INC(field) raw_cpu_inc(rt_cache_stat.field)
L
Linus Torvalds 已提交
199 200 201 202

#ifdef CONFIG_PROC_FS
static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
{
203
	if (*pos)
204
		return NULL;
205
	return SEQ_START_TOKEN;
L
Linus Torvalds 已提交
206 207 208 209 210
}

static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	++*pos;
211
	return NULL;
L
Linus Torvalds 已提交
212 213 214 215 216 217 218 219 220 221 222 223 224
}

static void rt_cache_seq_stop(struct seq_file *seq, void *v)
{
}

static int rt_cache_seq_show(struct seq_file *seq, void *v)
{
	if (v == SEQ_START_TOKEN)
		seq_printf(seq, "%-127s\n",
			   "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
			   "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
			   "HHUptod\tSpecDst");
225
	return 0;
L
Linus Torvalds 已提交
226 227
}

228
static const struct seq_operations rt_cache_seq_ops = {
L
Linus Torvalds 已提交
229 230 231 232 233 234 235 236
	.start  = rt_cache_seq_start,
	.next   = rt_cache_seq_next,
	.stop   = rt_cache_seq_stop,
	.show   = rt_cache_seq_show,
};

static int rt_cache_seq_open(struct inode *inode, struct file *file)
{
237
	return seq_open(file, &rt_cache_seq_ops);
L
Linus Torvalds 已提交
238 239
}

240
static const struct file_operations rt_cache_seq_fops = {
L
Linus Torvalds 已提交
241 242 243
	.open	 = rt_cache_seq_open,
	.read	 = seq_read,
	.llseek	 = seq_lseek,
244
	.release = seq_release,
L
Linus Torvalds 已提交
245 246 247 248 249 250 251 252 253 254
};


static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
{
	int cpu;

	if (*pos == 0)
		return SEQ_START_TOKEN;

255
	for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
L
Linus Torvalds 已提交
256 257 258
		if (!cpu_possible(cpu))
			continue;
		*pos = cpu+1;
259
		return &per_cpu(rt_cache_stat, cpu);
L
Linus Torvalds 已提交
260 261 262 263 264 265 266 267
	}
	return NULL;
}

static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	int cpu;

268
	for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
L
Linus Torvalds 已提交
269 270 271
		if (!cpu_possible(cpu))
			continue;
		*pos = cpu+1;
272
		return &per_cpu(rt_cache_stat, cpu);
L
Linus Torvalds 已提交
273 274
	}
	return NULL;
275

L
Linus Torvalds 已提交
276 277 278 279 280 281 282 283 284 285 286 287
}

static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
{

}

static int rt_cpu_seq_show(struct seq_file *seq, void *v)
{
	struct rt_cache_stat *st = v;

	if (v == SEQ_START_TOKEN) {
288
		seq_printf(seq, "entries  in_hit in_slow_tot in_slow_mc in_no_route in_brd in_martian_dst in_martian_src  out_hit out_slow_tot out_slow_mc  gc_total gc_ignored gc_goal_miss gc_dst_overflow in_hlist_search out_hlist_search\n");
L
Linus Torvalds 已提交
289 290
		return 0;
	}
291

L
Linus Torvalds 已提交
292 293
	seq_printf(seq,"%08x  %08x %08x %08x %08x %08x %08x %08x "
		   " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
294
		   dst_entries_get_slow(&ipv4_dst_ops),
E
Eric Dumazet 已提交
295
		   0, /* st->in_hit */
L
Linus Torvalds 已提交
296 297 298 299 300 301 302
		   st->in_slow_tot,
		   st->in_slow_mc,
		   st->in_no_route,
		   st->in_brd,
		   st->in_martian_dst,
		   st->in_martian_src,

E
Eric Dumazet 已提交
303
		   0, /* st->out_hit */
L
Linus Torvalds 已提交
304
		   st->out_slow_tot,
305
		   st->out_slow_mc,
L
Linus Torvalds 已提交
306

E
Eric Dumazet 已提交
307 308 309 310 311 312
		   0, /* st->gc_total */
		   0, /* st->gc_ignored */
		   0, /* st->gc_goal_miss */
		   0, /* st->gc_dst_overflow */
		   0, /* st->in_hlist_search */
		   0  /* st->out_hlist_search */
L
Linus Torvalds 已提交
313 314 315 316
		);
	return 0;
}

317
static const struct seq_operations rt_cpu_seq_ops = {
L
Linus Torvalds 已提交
318 319 320 321 322 323 324 325 326 327 328 329
	.start  = rt_cpu_seq_start,
	.next   = rt_cpu_seq_next,
	.stop   = rt_cpu_seq_stop,
	.show   = rt_cpu_seq_show,
};


static int rt_cpu_seq_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &rt_cpu_seq_ops);
}

330
static const struct file_operations rt_cpu_seq_fops = {
L
Linus Torvalds 已提交
331 332 333 334 335 336
	.open	 = rt_cpu_seq_open,
	.read	 = seq_read,
	.llseek	 = seq_lseek,
	.release = seq_release,
};

337
#ifdef CONFIG_IP_ROUTE_CLASSID
338
static int rt_acct_proc_show(struct seq_file *m, void *v)
339
{
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
	struct ip_rt_acct *dst, *src;
	unsigned int i, j;

	dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
	if (!dst)
		return -ENOMEM;

	for_each_possible_cpu(i) {
		src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
		for (j = 0; j < 256; j++) {
			dst[j].o_bytes   += src[j].o_bytes;
			dst[j].o_packets += src[j].o_packets;
			dst[j].i_bytes   += src[j].i_bytes;
			dst[j].i_packets += src[j].i_packets;
		}
355 356
	}

357 358 359 360
	seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
	kfree(dst);
	return 0;
}
361
#endif
362

363
static int __net_init ip_rt_do_proc_init(struct net *net)
364 365 366
{
	struct proc_dir_entry *pde;

367
	pde = proc_create("rt_cache", 0444, net->proc_net,
368
			  &rt_cache_seq_fops);
369 370 371
	if (!pde)
		goto err1;

372
	pde = proc_create("rt_cache", 0444,
373
			  net->proc_net_stat, &rt_cpu_seq_fops);
374 375 376
	if (!pde)
		goto err2;

377
#ifdef CONFIG_IP_ROUTE_CLASSID
378 379
	pde = proc_create_single("rt_acct", 0, net->proc_net,
			rt_acct_proc_show);
380 381 382 383 384
	if (!pde)
		goto err3;
#endif
	return 0;

385
#ifdef CONFIG_IP_ROUTE_CLASSID
386 387 388 389 390 391 392 393
err3:
	remove_proc_entry("rt_cache", net->proc_net_stat);
#endif
err2:
	remove_proc_entry("rt_cache", net->proc_net);
err1:
	return -ENOMEM;
}
394 395 396 397 398

static void __net_exit ip_rt_do_proc_exit(struct net *net)
{
	remove_proc_entry("rt_cache", net->proc_net_stat);
	remove_proc_entry("rt_cache", net->proc_net);
399
#ifdef CONFIG_IP_ROUTE_CLASSID
400
	remove_proc_entry("rt_acct", net->proc_net);
401
#endif
402 403 404 405 406 407 408 409 410 411 412 413
}

static struct pernet_operations ip_rt_proc_ops __net_initdata =  {
	.init = ip_rt_do_proc_init,
	.exit = ip_rt_do_proc_exit,
};

static int __init ip_rt_proc_init(void)
{
	return register_pernet_subsys(&ip_rt_proc_ops);
}

414
#else
415
static inline int ip_rt_proc_init(void)
416 417 418
{
	return 0;
}
L
Linus Torvalds 已提交
419
#endif /* CONFIG_PROC_FS */
420

421
static inline bool rt_is_expired(const struct rtable *rth)
422
{
423
	return rth->rt_genid != rt_genid_ipv4(dev_net(rth->dst.dev));
424 425
}

426
void rt_cache_flush(struct net *net)
L
Linus Torvalds 已提交
427
{
428
	rt_genid_bump_ipv4(net);
429 430
}

431 432 433
static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
					   struct sk_buff *skb,
					   const void *daddr)
434
{
435
	const struct rtable *rt = container_of(dst, struct rtable, dst);
436
	struct net_device *dev = dst->dev;
437 438
	struct neighbour *n;

439 440 441 442 443 444 445 446 447 448 449 450 451
	rcu_read_lock_bh();

	if (likely(rt->rt_gw_family == AF_INET)) {
		n = ip_neigh_gw4(dev, rt->rt_gw4);
	} else if (rt->rt_gw_family == AF_INET6) {
		n = ip_neigh_gw6(dev, &rt->rt_gw6);
        } else {
		__be32 pkey;

		pkey = skb ? ip_hdr(skb)->daddr : *((__be32 *) daddr);
		n = ip_neigh_gw4(dev, pkey);
	}

452
	if (!IS_ERR(n) && !refcount_inc_not_zero(&n->refcnt))
453 454 455 456 457
		n = NULL;

	rcu_read_unlock_bh();

	return n;
458 459
}

460 461
static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr)
{
462
	const struct rtable *rt = container_of(dst, struct rtable, dst);
463 464 465
	struct net_device *dev = dst->dev;
	const __be32 *pkey = daddr;

466
	if (rt->rt_gw_family == AF_INET) {
467
		pkey = (const __be32 *)&rt->rt_gw4;
468 469 470
	} else if (rt->rt_gw_family == AF_INET6) {
		return __ipv6_confirm_neigh_stub(dev, &rt->rt_gw6);
	} else if (!daddr ||
471
		 (rt->rt_flags &
472
		  (RTCF_MULTICAST | RTCF_BROADCAST | RTCF_LOCAL))) {
473
		return;
474
	}
475 476 477
	__ipv4_confirm_neigh(dev, *(__force u32 *)pkey);
}

478 479
#define IP_IDENTS_SZ 2048u

480 481
static atomic_t *ip_idents __read_mostly;
static u32 *ip_tstamps __read_mostly;
482 483 484 485 486 487 488

/* In order to protect privacy, we add a perturbation to identifiers
 * if one generator is seldom used. This makes hard for an attacker
 * to infer how many packets were sent between two points in time.
 */
u32 ip_idents_reserve(u32 hash, int segs)
{
489 490
	u32 *p_tstamp = ip_tstamps + hash % IP_IDENTS_SZ;
	atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ;
491
	u32 old = READ_ONCE(*p_tstamp);
492
	u32 now = (u32)jiffies;
493
	u32 new, delta = 0;
494

495
	if (old != now && cmpxchg(p_tstamp, old, now) == old)
496 497
		delta = prandom_u32_max(now - old);

498 499 500 501 502 503 504
	/* Do not use atomic_add_return() as it makes UBSAN unhappy */
	do {
		old = (u32)atomic_read(p_id);
		new = old + delta + segs;
	} while (atomic_cmpxchg(p_id, old, new) != old);

	return new - segs;
505 506
}
EXPORT_SYMBOL(ip_idents_reserve);
L
Linus Torvalds 已提交
507

508
void __ip_select_ident(struct net *net, struct iphdr *iph, int segs)
L
Linus Torvalds 已提交
509
{
510
	u32 hash, id;
L
Linus Torvalds 已提交
511

512 513 514 515
	/* Note the following code is not safe, but this is okay. */
	if (unlikely(siphash_key_is_zero(&net->ipv4.ip_id_key)))
		get_random_bytes(&net->ipv4.ip_id_key,
				 sizeof(net->ipv4.ip_id_key));
L
Linus Torvalds 已提交
516

517
	hash = siphash_3u32((__force u32)iph->daddr,
518
			    (__force u32)iph->saddr,
519 520
			    iph->protocol,
			    &net->ipv4.ip_id_key);
521 522
	id = ip_idents_reserve(hash, segs);
	iph->id = htons(id);
L
Linus Torvalds 已提交
523
}
524
EXPORT_SYMBOL(__ip_select_ident);
L
Linus Torvalds 已提交
525

526 527
static void __build_flow_key(const struct net *net, struct flowi4 *fl4,
			     const struct sock *sk,
528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
			     const struct iphdr *iph,
			     int oif, u8 tos,
			     u8 prot, u32 mark, int flow_flags)
{
	if (sk) {
		const struct inet_sock *inet = inet_sk(sk);

		oif = sk->sk_bound_dev_if;
		mark = sk->sk_mark;
		tos = RT_CONN_FLAGS(sk);
		prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
	}
	flowi4_init_output(fl4, oif, mark, tos,
			   RT_SCOPE_UNIVERSE, prot,
			   flow_flags,
543 544
			   iph->daddr, iph->saddr, 0, 0,
			   sock_net_uid(net, sk));
545 546
}

E
Eric Dumazet 已提交
547 548
static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
			       const struct sock *sk)
549
{
550
	const struct net *net = dev_net(skb->dev);
551 552 553 554 555 556
	const struct iphdr *iph = ip_hdr(skb);
	int oif = skb->dev->ifindex;
	u8 tos = RT_TOS(iph->tos);
	u8 prot = iph->protocol;
	u32 mark = skb->mark;

557
	__build_flow_key(net, fl4, sk, iph, oif, tos, prot, mark, 0);
558 559
}

E
Eric Dumazet 已提交
560
static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
561 562
{
	const struct inet_sock *inet = inet_sk(sk);
E
Eric Dumazet 已提交
563
	const struct ip_options_rcu *inet_opt;
564 565 566 567 568 569 570 571 572 573
	__be32 daddr = inet->inet_daddr;

	rcu_read_lock();
	inet_opt = rcu_dereference(inet->inet_opt);
	if (inet_opt && inet_opt->opt.srr)
		daddr = inet_opt->opt.faddr;
	flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
			   RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
			   inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
			   inet_sk_flowi_flags(sk),
574
			   daddr, inet->inet_saddr, 0, 0, sk->sk_uid);
575 576 577
	rcu_read_unlock();
}

E
Eric Dumazet 已提交
578 579
static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
				 const struct sk_buff *skb)
580 581 582 583 584 585 586
{
	if (skb)
		build_skb_flow_key(fl4, skb, sk);
	else
		build_sk_flow_key(fl4, sk);
}

587
static DEFINE_SPINLOCK(fnhe_lock);
588

589 590 591 592 593 594 595
static void fnhe_flush_routes(struct fib_nh_exception *fnhe)
{
	struct rtable *rt;

	rt = rcu_dereference(fnhe->fnhe_rth_input);
	if (rt) {
		RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL);
596
		dst_dev_put(&rt->dst);
597
		dst_release(&rt->dst);
598 599 600 601
	}
	rt = rcu_dereference(fnhe->fnhe_rth_output);
	if (rt) {
		RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL);
602
		dst_dev_put(&rt->dst);
603
		dst_release(&rt->dst);
604 605 606
	}
}

607
static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
608 609 610 611 612 613 614 615 616
{
	struct fib_nh_exception *fnhe, *oldest;

	oldest = rcu_dereference(hash->chain);
	for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
	     fnhe = rcu_dereference(fnhe->fnhe_next)) {
		if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
			oldest = fnhe;
	}
617
	fnhe_flush_routes(oldest);
618 619 620
	return oldest;
}

621 622
static inline u32 fnhe_hashfun(__be32 daddr)
{
623
	static u32 fnhe_hashrnd __read_mostly;
624 625
	u32 hval;

626 627 628
	net_get_random_once(&fnhe_hashrnd, sizeof(fnhe_hashrnd));
	hval = jhash_1word((__force u32) daddr, fnhe_hashrnd);
	return hash_32(hval, FNHE_HASH_SHIFT);
629 630
}

631 632 633
static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnhe)
{
	rt->rt_pmtu = fnhe->fnhe_pmtu;
634
	rt->rt_mtu_locked = fnhe->fnhe_mtu_locked;
635 636 637 638
	rt->dst.expires = fnhe->fnhe_expires;

	if (fnhe->fnhe_gw) {
		rt->rt_flags |= RTCF_REDIRECTED;
639
		rt->rt_uses_gateway = 1;
640 641
		rt->rt_gw_family = AF_INET;
		rt->rt_gw4 = fnhe->fnhe_gw;
642 643 644
	}
}

645 646 647
static void update_or_create_fnhe(struct fib_nh_common *nhc, __be32 daddr,
				  __be32 gw, u32 pmtu, bool lock,
				  unsigned long expires)
648
{
649
	struct fnhe_hash_bucket *hash;
650
	struct fib_nh_exception *fnhe;
651
	struct rtable *rt;
652
	u32 genid, hval;
653
	unsigned int i;
654
	int depth;
655

656
	genid = fnhe_genid(dev_net(nhc->nhc_dev));
657
	hval = fnhe_hashfun(daddr);
658

659
	spin_lock_bh(&fnhe_lock);
660

661
	hash = rcu_dereference(nhc->nhc_exceptions);
662
	if (!hash) {
663
		hash = kcalloc(FNHE_HASH_SIZE, sizeof(*hash), GFP_ATOMIC);
664
		if (!hash)
665
			goto out_unlock;
666
		rcu_assign_pointer(nhc->nhc_exceptions, hash);
667 668 669 670 671 672 673 674
	}

	hash += hval;

	depth = 0;
	for (fnhe = rcu_dereference(hash->chain); fnhe;
	     fnhe = rcu_dereference(fnhe->fnhe_next)) {
		if (fnhe->fnhe_daddr == daddr)
675
			break;
676 677 678
		depth++;
	}

679
	if (fnhe) {
680 681
		if (fnhe->fnhe_genid != genid)
			fnhe->fnhe_genid = genid;
682 683
		if (gw)
			fnhe->fnhe_gw = gw;
684
		if (pmtu) {
685
			fnhe->fnhe_pmtu = pmtu;
686 687
			fnhe->fnhe_mtu_locked = lock;
		}
688
		fnhe->fnhe_expires = max(1UL, expires);
689
		/* Update all cached dsts too */
690 691 692 693
		rt = rcu_dereference(fnhe->fnhe_rth_input);
		if (rt)
			fill_route_from_fnhe(rt, fnhe);
		rt = rcu_dereference(fnhe->fnhe_rth_output);
694 695
		if (rt)
			fill_route_from_fnhe(rt, fnhe);
696 697 698 699 700 701 702 703 704 705 706
	} else {
		if (depth > FNHE_RECLAIM_DEPTH)
			fnhe = fnhe_oldest(hash);
		else {
			fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
			if (!fnhe)
				goto out_unlock;

			fnhe->fnhe_next = hash->chain;
			rcu_assign_pointer(hash->chain, fnhe);
		}
707
		fnhe->fnhe_genid = genid;
708 709 710
		fnhe->fnhe_daddr = daddr;
		fnhe->fnhe_gw = gw;
		fnhe->fnhe_pmtu = pmtu;
711
		fnhe->fnhe_mtu_locked = lock;
712
		fnhe->fnhe_expires = max(1UL, expires);
713 714 715 716 717

		/* Exception created; mark the cached routes for the nexthop
		 * stale, so anyone caching it rechecks if this exception
		 * applies to them.
		 */
718
		rt = rcu_dereference(nhc->nhc_rth_input);
719 720 721
		if (rt)
			rt->dst.obsolete = DST_OBSOLETE_KILL;

722 723
		for_each_possible_cpu(i) {
			struct rtable __rcu **prt;
724
			prt = per_cpu_ptr(nhc->nhc_pcpu_rth_output, i);
725 726 727 728
			rt = rcu_dereference(*prt);
			if (rt)
				rt->dst.obsolete = DST_OBSOLETE_KILL;
		}
729 730 731
	}

	fnhe->fnhe_stamp = jiffies;
732 733

out_unlock:
734
	spin_unlock_bh(&fnhe_lock);
735 736
}

737 738
static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
			     bool kill_route)
L
Linus Torvalds 已提交
739
{
740
	__be32 new_gw = icmp_hdr(skb)->un.gateway;
741
	__be32 old_gw = ip_hdr(skb)->saddr;
742 743
	struct net_device *dev = skb->dev;
	struct in_device *in_dev;
744
	struct fib_result res;
745
	struct neighbour *n;
746
	struct net *net;
L
Linus Torvalds 已提交
747

748 749 750 751 752 753 754 755 756 757 758
	switch (icmp_hdr(skb)->code & 7) {
	case ICMP_REDIR_NET:
	case ICMP_REDIR_NETTOS:
	case ICMP_REDIR_HOST:
	case ICMP_REDIR_HOSTTOS:
		break;

	default:
		return;
	}

759
	if (rt->rt_gw_family != AF_INET || rt->rt_gw4 != old_gw)
760 761 762 763 764 765
		return;

	in_dev = __in_dev_get_rcu(dev);
	if (!in_dev)
		return;

766
	net = dev_net(dev);
767 768 769
	if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
	    ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
	    ipv4_is_zeronet(new_gw))
L
Linus Torvalds 已提交
770 771 772 773 774 775 776 777
		goto reject_redirect;

	if (!IN_DEV_SHARED_MEDIA(in_dev)) {
		if (!inet_addr_onlink(in_dev, new_gw, old_gw))
			goto reject_redirect;
		if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
			goto reject_redirect;
	} else {
778
		if (inet_addr_type(net, new_gw) != RTN_UNICAST)
L
Linus Torvalds 已提交
779 780 781
			goto reject_redirect;
	}

782 783 784
	n = __ipv4_neigh_lookup(rt->dst.dev, new_gw);
	if (!n)
		n = neigh_create(&arp_tbl, &new_gw, rt->dst.dev);
785
	if (!IS_ERR(n)) {
786 787 788
		if (!(n->nud_state & NUD_VALID)) {
			neigh_event_send(n, NULL);
		} else {
789
			if (fib_lookup(net, fl4, &res, 0) == 0) {
790
				struct fib_nh_common *nhc = FIB_RES_NHC(res);
791

792
				update_or_create_fnhe(nhc, fl4->daddr, new_gw,
793 794
						0, false,
						jiffies + ip_rt_gc_timeout);
795
			}
796 797
			if (kill_route)
				rt->dst.obsolete = DST_OBSOLETE_KILL;
798 799 800 801 802 803 804 805
			call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
		}
		neigh_release(n);
	}
	return;

reject_redirect:
#ifdef CONFIG_IP_ROUTE_VERBOSE
806 807 808 809 810
	if (IN_DEV_LOG_MARTIANS(in_dev)) {
		const struct iphdr *iph = (const struct iphdr *) skb->data;
		__be32 daddr = iph->daddr;
		__be32 saddr = iph->saddr;

811 812 813 814
		net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
				     "  Advised path = %pI4 -> %pI4\n",
				     &old_gw, dev->name, &new_gw,
				     &saddr, &daddr);
815
	}
816 817 818 819
#endif
	;
}

820 821 822 823
static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
{
	struct rtable *rt;
	struct flowi4 fl4;
824
	const struct iphdr *iph = (const struct iphdr *) skb->data;
825
	struct net *net = dev_net(skb->dev);
826 827 828 829
	int oif = skb->dev->ifindex;
	u8 tos = RT_TOS(iph->tos);
	u8 prot = iph->protocol;
	u32 mark = skb->mark;
830 831 832

	rt = (struct rtable *) dst;

833
	__build_flow_key(net, &fl4, sk, iph, oif, tos, prot, mark, 0);
834
	__ip_do_redirect(rt, skb, &fl4, true);
835 836
}

L
Linus Torvalds 已提交
837 838
static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
{
839
	struct rtable *rt = (struct rtable *)dst;
L
Linus Torvalds 已提交
840 841 842
	struct dst_entry *ret = dst;

	if (rt) {
843
		if (dst->obsolete > 0) {
L
Linus Torvalds 已提交
844 845
			ip_rt_put(rt);
			ret = NULL;
846 847
		} else if ((rt->rt_flags & RTCF_REDIRECTED) ||
			   rt->dst.expires) {
848
			ip_rt_put(rt);
L
Linus Torvalds 已提交
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872
			ret = NULL;
		}
	}
	return ret;
}

/*
 * Algorithm:
 *	1. The first ip_rt_redirect_number redirects are sent
 *	   with exponential backoff, then we stop sending them at all,
 *	   assuming that the host ignores our redirects.
 *	2. If we did not see packets requiring redirects
 *	   during ip_rt_redirect_silence, we assume that the host
 *	   forgot redirected route and start to send redirects again.
 *
 * This algorithm is much cheaper and more intelligent than dumb load limiting
 * in icmp.c.
 *
 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
 * and "frag. need" (breaks PMTU discovery) in icmp.c.
 */

void ip_rt_send_redirect(struct sk_buff *skb)
{
E
Eric Dumazet 已提交
873
	struct rtable *rt = skb_rtable(skb);
874
	struct in_device *in_dev;
875
	struct inet_peer *peer;
876
	struct net *net;
877
	int log_martians;
878
	int vif;
L
Linus Torvalds 已提交
879

880
	rcu_read_lock();
881
	in_dev = __in_dev_get_rcu(rt->dst.dev);
882 883
	if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
		rcu_read_unlock();
L
Linus Torvalds 已提交
884
		return;
885 886
	}
	log_martians = IN_DEV_LOG_MARTIANS(in_dev);
887
	vif = l3mdev_master_ifindex_rcu(rt->dst.dev);
888
	rcu_read_unlock();
L
Linus Torvalds 已提交
889

890
	net = dev_net(rt->dst.dev);
891
	peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, vif, 1);
892
	if (!peer) {
893 894
		icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
			  rt_nexthop(rt, ip_hdr(skb)->daddr));
895 896 897
		return;
	}

L
Linus Torvalds 已提交
898 899 900
	/* No redirected packets during ip_rt_redirect_silence;
	 * reset the algorithm.
	 */
901
	if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence)) {
902
		peer->rate_tokens = 0;
903 904
		peer->n_redirects = 0;
	}
L
Linus Torvalds 已提交
905 906

	/* Too many ignored redirects; do not send anything
907
	 * set dst.rate_last to the last seen redirected packet.
L
Linus Torvalds 已提交
908
	 */
909
	if (peer->n_redirects >= ip_rt_redirect_number) {
910
		peer->rate_last = jiffies;
911
		goto out_put_peer;
L
Linus Torvalds 已提交
912 913 914 915 916
	}

	/* Check for load limit; set rate_last to the latest sent
	 * redirect.
	 */
917
	if (peer->rate_tokens == 0 ||
918
	    time_after(jiffies,
919
		       (peer->rate_last +
920
			(ip_rt_redirect_load << peer->n_redirects)))) {
921 922 923
		__be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);

		icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
924
		peer->rate_last = jiffies;
925
		++peer->n_redirects;
L
Linus Torvalds 已提交
926
#ifdef CONFIG_IP_ROUTE_VERBOSE
927
		if (log_martians &&
928
		    peer->n_redirects == ip_rt_redirect_number)
929
			net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
930
					     &ip_hdr(skb)->saddr, inet_iif(skb),
931
					     &ip_hdr(skb)->daddr, &gw);
L
Linus Torvalds 已提交
932 933
#endif
	}
934 935
out_put_peer:
	inet_putpeer(peer);
L
Linus Torvalds 已提交
936 937 938 939
}

static int ip_error(struct sk_buff *skb)
{
E
Eric Dumazet 已提交
940
	struct rtable *rt = skb_rtable(skb);
941 942
	struct net_device *dev = skb->dev;
	struct in_device *in_dev;
943
	struct inet_peer *peer;
L
Linus Torvalds 已提交
944
	unsigned long now;
945
	struct net *net;
946
	bool send;
L
Linus Torvalds 已提交
947 948
	int code;

949 950 951 952 953 954 955 956
	if (netif_is_l3_master(skb->dev)) {
		dev = __dev_get_by_index(dev_net(skb->dev), IPCB(skb)->iif);
		if (!dev)
			goto out;
	}

	in_dev = __in_dev_get_rcu(dev);

957 958 959 960
	/* IP on this device is disabled. */
	if (!in_dev)
		goto out;

961 962 963 964
	net = dev_net(rt->dst.dev);
	if (!IN_DEV_FORWARD(in_dev)) {
		switch (rt->dst.error) {
		case EHOSTUNREACH:
965
			__IP_INC_STATS(net, IPSTATS_MIB_INADDRERRORS);
966 967 968
			break;

		case ENETUNREACH:
969
			__IP_INC_STATS(net, IPSTATS_MIB_INNOROUTES);
970 971 972 973 974
			break;
		}
		goto out;
	}

975
	switch (rt->dst.error) {
976 977 978 979 980 981 982 983
	case EINVAL:
	default:
		goto out;
	case EHOSTUNREACH:
		code = ICMP_HOST_UNREACH;
		break;
	case ENETUNREACH:
		code = ICMP_NET_UNREACH;
984
		__IP_INC_STATS(net, IPSTATS_MIB_INNOROUTES);
985 986 987 988
		break;
	case EACCES:
		code = ICMP_PKT_FILTERED;
		break;
L
Linus Torvalds 已提交
989 990
	}

991
	peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr,
992
			       l3mdev_master_ifindex(skb->dev), 1);
993 994 995 996 997 998 999 1000 1001 1002 1003 1004

	send = true;
	if (peer) {
		now = jiffies;
		peer->rate_tokens += now - peer->rate_last;
		if (peer->rate_tokens > ip_rt_error_burst)
			peer->rate_tokens = ip_rt_error_burst;
		peer->rate_last = now;
		if (peer->rate_tokens >= ip_rt_error_cost)
			peer->rate_tokens -= ip_rt_error_cost;
		else
			send = false;
1005
		inet_putpeer(peer);
L
Linus Torvalds 已提交
1006
	}
1007 1008
	if (send)
		icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
L
Linus Torvalds 已提交
1009 1010 1011

out:	kfree_skb(skb);
	return 0;
1012
}
L
Linus Torvalds 已提交
1013

1014
static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
L
Linus Torvalds 已提交
1015
{
1016
	struct dst_entry *dst = &rt->dst;
1017
	u32 old_mtu = ipv4_mtu(dst);
1018
	struct fib_result res;
1019
	bool lock = false;
1020

1021
	if (ip_mtu_locked(dst))
1022 1023
		return;

1024
	if (old_mtu < mtu)
1025 1026
		return;

1027 1028
	if (mtu < ip_rt_min_pmtu) {
		lock = true;
1029
		mtu = min(old_mtu, ip_rt_min_pmtu);
1030
	}
1031

1032
	if (rt->rt_pmtu == mtu && !lock &&
1033 1034 1035
	    time_before(jiffies, dst->expires - ip_rt_mtu_expires / 2))
		return;

1036
	rcu_read_lock();
1037
	if (fib_lookup(dev_net(dst->dev), fl4, &res, 0) == 0) {
1038
		struct fib_nh_common *nhc = FIB_RES_NHC(res);
1039

1040
		update_or_create_fnhe(nhc, fl4->daddr, 0, mtu, lock,
1041
				      jiffies + ip_rt_mtu_expires);
1042
	}
1043
	rcu_read_unlock();
L
Linus Torvalds 已提交
1044 1045
}

1046
static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1047 1048
			      struct sk_buff *skb, u32 mtu,
			      bool confirm_neigh)
1049 1050 1051 1052 1053
{
	struct rtable *rt = (struct rtable *) dst;
	struct flowi4 fl4;

	ip_rt_build_flow_key(&fl4, sk, skb);
1054
	__ip_rt_update_pmtu(rt, &fl4, mtu);
1055 1056
}

1057
void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
1058
		      int oif, u8 protocol)
1059
{
1060
	const struct iphdr *iph = (const struct iphdr *) skb->data;
1061 1062
	struct flowi4 fl4;
	struct rtable *rt;
1063
	u32 mark = IP4_REPLY_MARK(net, skb->mark);
1064

1065
	__build_flow_key(net, &fl4, NULL, iph, oif,
1066
			 RT_TOS(iph->tos), protocol, mark, 0);
1067 1068
	rt = __ip_route_output_key(net, &fl4);
	if (!IS_ERR(rt)) {
1069
		__ip_rt_update_pmtu(rt, &fl4, mtu);
1070 1071 1072 1073 1074
		ip_rt_put(rt);
	}
}
EXPORT_SYMBOL_GPL(ipv4_update_pmtu);

1075
static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1076
{
1077 1078 1079
	const struct iphdr *iph = (const struct iphdr *) skb->data;
	struct flowi4 fl4;
	struct rtable *rt;
1080

1081
	__build_flow_key(sock_net(sk), &fl4, sk, iph, 0, 0, 0, 0, 0);
1082 1083 1084 1085

	if (!fl4.flowi4_mark)
		fl4.flowi4_mark = IP4_REPLY_MARK(sock_net(sk), skb->mark);

1086 1087 1088 1089 1090
	rt = __ip_route_output_key(sock_net(sk), &fl4);
	if (!IS_ERR(rt)) {
		__ip_rt_update_pmtu(rt, &fl4, mtu);
		ip_rt_put(rt);
	}
1091
}
1092 1093 1094 1095 1096 1097

void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
{
	const struct iphdr *iph = (const struct iphdr *) skb->data;
	struct flowi4 fl4;
	struct rtable *rt;
1098
	struct dst_entry *odst = NULL;
1099
	bool new = false;
1100
	struct net *net = sock_net(sk);
1101 1102

	bh_lock_sock(sk);
1103 1104 1105 1106

	if (!ip_sk_accept_pmtu(sk))
		goto out;

1107
	odst = sk_dst_get(sk);
1108

1109
	if (sock_owned_by_user(sk) || !odst) {
1110 1111 1112 1113
		__ipv4_sk_update_pmtu(skb, sk, mtu);
		goto out;
	}

1114
	__build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);
1115

1116
	rt = (struct rtable *)odst;
1117
	if (odst->obsolete && !odst->ops->check(odst, 0)) {
1118 1119 1120
		rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
		if (IS_ERR(rt))
			goto out;
1121 1122

		new = true;
1123 1124
	}

1125
	__ip_rt_update_pmtu((struct rtable *) xfrm_dst_path(&rt->dst), &fl4, mtu);
1126

1127
	if (!dst_check(&rt->dst, 0)) {
1128 1129 1130
		if (new)
			dst_release(&rt->dst);

1131 1132 1133 1134
		rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
		if (IS_ERR(rt))
			goto out;

1135
		new = true;
1136 1137
	}

1138
	if (new)
1139
		sk_dst_set(sk, &rt->dst);
1140 1141 1142

out:
	bh_unlock_sock(sk);
1143
	dst_release(odst);
1144
}
1145
EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
1146

1147
void ipv4_redirect(struct sk_buff *skb, struct net *net,
1148
		   int oif, u8 protocol)
1149
{
1150
	const struct iphdr *iph = (const struct iphdr *) skb->data;
1151 1152 1153
	struct flowi4 fl4;
	struct rtable *rt;

1154
	__build_flow_key(net, &fl4, NULL, iph, oif,
1155
			 RT_TOS(iph->tos), protocol, 0, 0);
1156 1157
	rt = __ip_route_output_key(net, &fl4);
	if (!IS_ERR(rt)) {
1158
		__ip_do_redirect(rt, skb, &fl4, false);
1159 1160 1161 1162 1163 1164 1165
		ip_rt_put(rt);
	}
}
EXPORT_SYMBOL_GPL(ipv4_redirect);

void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
{
1166 1167 1168
	const struct iphdr *iph = (const struct iphdr *) skb->data;
	struct flowi4 fl4;
	struct rtable *rt;
1169
	struct net *net = sock_net(sk);
1170

1171 1172
	__build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);
	rt = __ip_route_output_key(net, &fl4);
1173
	if (!IS_ERR(rt)) {
1174
		__ip_do_redirect(rt, skb, &fl4, false);
1175 1176
		ip_rt_put(rt);
	}
1177 1178 1179
}
EXPORT_SYMBOL_GPL(ipv4_sk_redirect);

1180 1181 1182 1183
static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
{
	struct rtable *rt = (struct rtable *) dst;

1184 1185 1186 1187
	/* All IPV4 dsts are created with ->obsolete set to the value
	 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
	 * into this function always.
	 *
1188 1189
	 * When a PMTU/redirect information update invalidates a route,
	 * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
1190
	 * DST_OBSOLETE_DEAD.
1191
	 */
1192
	if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
1193
		return NULL;
1194
	return dst;
L
Linus Torvalds 已提交
1195 1196
}

1197
static void ipv4_send_dest_unreach(struct sk_buff *skb)
L
Linus Torvalds 已提交
1198
{
1199
	struct ip_options opt;
1200
	int res;
L
Linus Torvalds 已提交
1201

1202
	/* Recompile ip options since IPCB may not be valid anymore.
1203
	 * Also check we have a reasonable ipv4 header.
1204
	 */
1205 1206 1207
	if (!pskb_network_may_pull(skb, sizeof(struct iphdr)) ||
	    ip_hdr(skb)->version != 4 || ip_hdr(skb)->ihl < 5)
		return;
1208

1209 1210 1211 1212 1213
	memset(&opt, 0, sizeof(opt));
	if (ip_hdr(skb)->ihl > 5) {
		if (!pskb_network_may_pull(skb, ip_hdr(skb)->ihl * 4))
			return;
		opt.optlen = ip_hdr(skb)->ihl * 4 - sizeof(struct iphdr);
1214

1215 1216 1217
		rcu_read_lock();
		res = __ip_options_compile(dev_net(skb->dev), &opt, skb, NULL);
		rcu_read_unlock();
1218

1219 1220 1221
		if (res)
			return;
	}
1222
	__icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0, &opt);
1223 1224 1225 1226 1227 1228 1229
}

static void ipv4_link_failure(struct sk_buff *skb)
{
	struct rtable *rt;

	ipv4_send_dest_unreach(skb);
L
Linus Torvalds 已提交
1230

E
Eric Dumazet 已提交
1231
	rt = skb_rtable(skb);
1232 1233
	if (rt)
		dst_set_expires(&rt->dst, 0);
L
Linus Torvalds 已提交
1234 1235
}

1236
static int ip_rt_bug(struct net *net, struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
1237
{
1238 1239 1240
	pr_debug("%s: %pI4 -> %pI4, %s\n",
		 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
		 skb->dev ? skb->dev->name : "?");
L
Linus Torvalds 已提交
1241
	kfree_skb(skb);
1242
	WARN_ON(1);
L
Linus Torvalds 已提交
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
	return 0;
}

/*
   We do not cache source address of outgoing interface,
   because it is used only by IP RR, TS and SRR options,
   so that it out of fast path.

   BTW remember: "addr" is allowed to be not aligned
   in IP options!
 */

1255
void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
L
Linus Torvalds 已提交
1256
{
1257
	__be32 src;
L
Linus Torvalds 已提交
1258

1259
	if (rt_is_output_route(rt))
1260
		src = ip_hdr(skb)->saddr;
1261
	else {
1262
		struct fib_result res;
1263 1264 1265 1266 1267 1268 1269 1270 1271
		struct iphdr *iph = ip_hdr(skb);
		struct flowi4 fl4 = {
			.daddr = iph->daddr,
			.saddr = iph->saddr,
			.flowi4_tos = RT_TOS(iph->tos),
			.flowi4_oif = rt->dst.dev->ifindex,
			.flowi4_iif = skb->dev->ifindex,
			.flowi4_mark = skb->mark,
		};
1272

1273
		rcu_read_lock();
1274
		if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res, 0) == 0)
1275
			src = fib_result_prefsrc(dev_net(rt->dst.dev), &res);
1276
		else
1277 1278 1279
			src = inet_select_addr(rt->dst.dev,
					       rt_nexthop(rt, iph->daddr),
					       RT_SCOPE_UNIVERSE);
1280 1281
		rcu_read_unlock();
	}
L
Linus Torvalds 已提交
1282 1283 1284
	memcpy(addr, &src, 4);
}

1285
#ifdef CONFIG_IP_ROUTE_CLASSID
L
Linus Torvalds 已提交
1286 1287
static void set_class_tag(struct rtable *rt, u32 tag)
{
1288 1289 1290 1291
	if (!(rt->dst.tclassid & 0xFFFF))
		rt->dst.tclassid |= tag & 0xFFFF;
	if (!(rt->dst.tclassid & 0xFFFF0000))
		rt->dst.tclassid |= tag & 0xFFFF0000;
L
Linus Torvalds 已提交
1292 1293 1294
}
#endif

1295 1296
static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
{
1297
	unsigned int header_size = sizeof(struct tcphdr) + sizeof(struct iphdr);
1298
	unsigned int advmss = max_t(unsigned int, ipv4_mtu(dst) - header_size,
1299
				    ip_rt_min_advmss);
1300

1301
	return min(advmss, IPV4_MAX_PMTU - header_size);
1302 1303
}

1304
static unsigned int ipv4_mtu(const struct dst_entry *dst)
1305
{
1306
	const struct rtable *rt = (const struct rtable *) dst;
1307 1308
	unsigned int mtu = rt->rt_pmtu;

1309
	if (!mtu || time_after_eq(jiffies, rt->dst.expires))
1310
		mtu = dst_metric_raw(dst, RTAX_MTU);
1311

1312
	if (mtu)
1313 1314
		return mtu;

1315
	mtu = READ_ONCE(dst->dev->mtu);
1316

1317
	if (unlikely(ip_mtu_locked(dst))) {
1318
		if (rt->rt_uses_gateway && mtu > 576)
1319 1320 1321
			mtu = 576;
	}

1322 1323 1324
	mtu = min_t(unsigned int, mtu, IP_MAX_MTU);

	return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
1325 1326
}

1327
static void ip_del_fnhe(struct fib_nh_common *nhc, __be32 daddr)
1328 1329 1330 1331 1332 1333 1334
{
	struct fnhe_hash_bucket *hash;
	struct fib_nh_exception *fnhe, __rcu **fnhe_p;
	u32 hval = fnhe_hashfun(daddr);

	spin_lock_bh(&fnhe_lock);

1335
	hash = rcu_dereference_protected(nhc->nhc_exceptions,
1336 1337 1338 1339 1340 1341 1342 1343 1344
					 lockdep_is_held(&fnhe_lock));
	hash += hval;

	fnhe_p = &hash->chain;
	fnhe = rcu_dereference_protected(*fnhe_p, lockdep_is_held(&fnhe_lock));
	while (fnhe) {
		if (fnhe->fnhe_daddr == daddr) {
			rcu_assign_pointer(*fnhe_p, rcu_dereference_protected(
				fnhe->fnhe_next, lockdep_is_held(&fnhe_lock)));
1345 1346 1347 1348
			/* set fnhe_daddr to 0 to ensure it won't bind with
			 * new dsts in rt_bind_exception().
			 */
			fnhe->fnhe_daddr = 0;
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360
			fnhe_flush_routes(fnhe);
			kfree_rcu(fnhe, rcu);
			break;
		}
		fnhe_p = &fnhe->fnhe_next;
		fnhe = rcu_dereference_protected(fnhe->fnhe_next,
						 lockdep_is_held(&fnhe_lock));
	}

	spin_unlock_bh(&fnhe_lock);
}

1361 1362
static struct fib_nh_exception *find_exception(struct fib_nh_common *nhc,
					       __be32 daddr)
1363
{
1364
	struct fnhe_hash_bucket *hash = rcu_dereference(nhc->nhc_exceptions);
1365 1366 1367
	struct fib_nh_exception *fnhe;
	u32 hval;

1368 1369 1370
	if (!hash)
		return NULL;

1371
	hval = fnhe_hashfun(daddr);
1372 1373 1374

	for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
	     fnhe = rcu_dereference(fnhe->fnhe_next)) {
1375 1376 1377
		if (fnhe->fnhe_daddr == daddr) {
			if (fnhe->fnhe_expires &&
			    time_after(jiffies, fnhe->fnhe_expires)) {
1378
				ip_del_fnhe(nhc, daddr);
1379 1380
				break;
			}
1381
			return fnhe;
1382
		}
1383 1384 1385
	}
	return NULL;
}
1386

1387 1388 1389 1390 1391 1392 1393 1394
/* MTU selection:
 * 1. mtu on route is locked - use it
 * 2. mtu from nexthop exception
 * 3. mtu from egress device
 */

u32 ip_mtu_from_fib_result(struct fib_result *res, __be32 daddr)
{
1395 1396
	struct fib_nh_common *nhc = res->nhc;
	struct net_device *dev = nhc->nhc_dev;
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
	struct fib_info *fi = res->fi;
	u32 mtu = 0;

	if (dev_net(dev)->ipv4.sysctl_ip_fwd_use_pmtu ||
	    fi->fib_metrics->metrics[RTAX_LOCK - 1] & (1 << RTAX_MTU))
		mtu = fi->fib_mtu;

	if (likely(!mtu)) {
		struct fib_nh_exception *fnhe;

1407
		fnhe = find_exception(nhc, daddr);
1408 1409 1410 1411 1412 1413 1414
		if (fnhe && !time_after_eq(jiffies, fnhe->fnhe_expires))
			mtu = fnhe->fnhe_pmtu;
	}

	if (likely(!mtu))
		mtu = min(READ_ONCE(dev->mtu), IP_MAX_MTU);

1415
	return mtu - lwtunnel_headroom(nhc->nhc_lwtstate, mtu);
1416 1417
}

1418
static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
W
Wei Wang 已提交
1419
			      __be32 daddr, const bool do_cache)
1420
{
1421 1422
	bool ret = false;

1423
	spin_lock_bh(&fnhe_lock);
1424

1425
	if (daddr == fnhe->fnhe_daddr) {
1426 1427
		struct rtable __rcu **porig;
		struct rtable *orig;
1428
		int genid = fnhe_genid(dev_net(rt->dst.dev));
1429 1430 1431 1432 1433 1434

		if (rt_is_input_route(rt))
			porig = &fnhe->fnhe_rth_input;
		else
			porig = &fnhe->fnhe_rth_output;
		orig = rcu_dereference(*porig);
1435 1436 1437

		if (fnhe->fnhe_genid != genid) {
			fnhe->fnhe_genid = genid;
1438 1439 1440
			fnhe->fnhe_gw = 0;
			fnhe->fnhe_pmtu = 0;
			fnhe->fnhe_expires = 0;
1441
			fnhe->fnhe_mtu_locked = false;
1442 1443
			fnhe_flush_routes(fnhe);
			orig = NULL;
1444
		}
1445
		fill_route_from_fnhe(rt, fnhe);
1446 1447 1448 1449
		if (!rt->rt_gw4) {
			rt->rt_gw4 = daddr;
			rt->rt_gw_family = AF_INET;
		}
1450

W
Wei Wang 已提交
1451
		if (do_cache) {
1452
			dst_hold(&rt->dst);
1453
			rcu_assign_pointer(*porig, rt);
1454
			if (orig) {
1455
				dst_dev_put(&orig->dst);
1456 1457
				dst_release(&orig->dst);
			}
1458 1459
			ret = true;
		}
1460 1461 1462 1463

		fnhe->fnhe_stamp = jiffies;
	}
	spin_unlock_bh(&fnhe_lock);
1464 1465

	return ret;
1466 1467
}

1468
static bool rt_cache_route(struct fib_nh_common *nhc, struct rtable *rt)
1469
{
1470
	struct rtable *orig, *prev, **p;
1471
	bool ret = true;
1472

1473
	if (rt_is_input_route(rt)) {
1474
		p = (struct rtable **)&nhc->nhc_rth_input;
1475
	} else {
1476
		p = (struct rtable **)raw_cpu_ptr(nhc->nhc_pcpu_rth_output);
1477
	}
1478 1479
	orig = *p;

1480 1481 1482 1483
	/* hold dst before doing cmpxchg() to avoid race condition
	 * on this dst
	 */
	dst_hold(&rt->dst);
1484 1485
	prev = cmpxchg(p, orig, rt);
	if (prev == orig) {
1486
		if (orig) {
1487
			rt_add_uncached_list(orig);
1488 1489 1490 1491
			dst_release(&orig->dst);
		}
	} else {
		dst_release(&rt->dst);
1492
		ret = false;
1493
	}
1494 1495 1496 1497

	return ret;
}

1498 1499 1500 1501 1502 1503
struct uncached_list {
	spinlock_t		lock;
	struct list_head	head;
};

static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt_uncached_list);
1504

1505
void rt_add_uncached_list(struct rtable *rt)
1506
{
1507 1508 1509 1510 1511 1512 1513
	struct uncached_list *ul = raw_cpu_ptr(&rt_uncached_list);

	rt->rt_uncached_list = ul;

	spin_lock_bh(&ul->lock);
	list_add_tail(&rt->rt_uncached, &ul->head);
	spin_unlock_bh(&ul->lock);
1514 1515
}

1516
void rt_del_uncached_list(struct rtable *rt)
1517
{
1518
	if (!list_empty(&rt->rt_uncached)) {
1519 1520 1521
		struct uncached_list *ul = rt->rt_uncached_list;

		spin_lock_bh(&ul->lock);
1522
		list_del(&rt->rt_uncached);
1523
		spin_unlock_bh(&ul->lock);
1524 1525 1526
	}
}

1527 1528 1529 1530
static void ipv4_dst_destroy(struct dst_entry *dst)
{
	struct rtable *rt = (struct rtable *)dst;

1531
	ip_dst_metrics_put(dst);
1532 1533 1534
	rt_del_uncached_list(rt);
}

1535 1536
void rt_flush_dev(struct net_device *dev)
{
1537 1538 1539 1540 1541
	struct rtable *rt;
	int cpu;

	for_each_possible_cpu(cpu) {
		struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
1542

1543 1544
		spin_lock_bh(&ul->lock);
		list_for_each_entry(rt, &ul->head, rt_uncached) {
1545 1546
			if (rt->dst.dev != dev)
				continue;
1547
			rt->dst.dev = blackhole_netdev;
1548 1549 1550
			dev_hold(rt->dst.dev);
			dev_put(dev);
		}
1551
		spin_unlock_bh(&ul->lock);
1552 1553 1554
	}
}

1555
static bool rt_cache_valid(const struct rtable *rt)
1556
{
1557 1558 1559
	return	rt &&
		rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
		!rt_is_expired(rt);
1560 1561
}

1562
static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
1563
			   const struct fib_result *res,
1564
			   struct fib_nh_exception *fnhe,
W
Wei Wang 已提交
1565 1566
			   struct fib_info *fi, u16 type, u32 itag,
			   const bool do_cache)
L
Linus Torvalds 已提交
1567
{
1568 1569
	bool cached = false;

L
Linus Torvalds 已提交
1570
	if (fi) {
1571
		struct fib_nh_common *nhc = FIB_RES_NHC(*res);
1572

1573
		if (nhc->nhc_gw_family && nhc->nhc_scope == RT_SCOPE_LINK) {
1574
			rt->rt_uses_gateway = 1;
1575 1576 1577 1578 1579 1580
			rt->rt_gw_family = nhc->nhc_gw_family;
			/* only INET and INET6 are supported */
			if (likely(nhc->nhc_gw_family == AF_INET))
				rt->rt_gw4 = nhc->nhc_gw.ipv4;
			else
				rt->rt_gw6 = nhc->nhc_gw.ipv6;
1581
		}
1582

1583 1584
		ip_dst_init_metrics(&rt->dst, fi->fib_metrics);

1585
#ifdef CONFIG_IP_ROUTE_CLASSID
1586
		if (nhc->nhc_family == AF_INET) {
1587 1588 1589 1590 1591
			struct fib_nh *nh;

			nh = container_of(nhc, struct fib_nh, nh_common);
			rt->dst.tclassid = nh->nh_tclassid;
		}
L
Linus Torvalds 已提交
1592
#endif
1593
		rt->dst.lwtstate = lwtstate_get(nhc->nhc_lwtstate);
1594
		if (unlikely(fnhe))
W
Wei Wang 已提交
1595 1596
			cached = rt_bind_exception(rt, fnhe, daddr, do_cache);
		else if (do_cache)
1597
			cached = rt_cache_route(nhc, rt);
1598 1599 1600 1601 1602 1603
		if (unlikely(!cached)) {
			/* Routes we intend to cache in nexthop exception or
			 * FIB nexthop have the DST_NOCACHE bit clear.
			 * However, if we are unsuccessful at storing this
			 * route into the cache we really need to set it.
			 */
1604 1605 1606 1607
			if (!rt->rt_gw4) {
				rt->rt_gw_family = AF_INET;
				rt->rt_gw4 = daddr;
			}
1608 1609 1610
			rt_add_uncached_list(rt);
		}
	} else
1611
		rt_add_uncached_list(rt);
1612

1613
#ifdef CONFIG_IP_ROUTE_CLASSID
L
Linus Torvalds 已提交
1614
#ifdef CONFIG_IP_MULTIPLE_TABLES
1615
	set_class_tag(rt, res->tclassid);
L
Linus Torvalds 已提交
1616 1617 1618 1619 1620
#endif
	set_class_tag(rt, itag);
#endif
}

1621 1622 1623
struct rtable *rt_dst_alloc(struct net_device *dev,
			    unsigned int flags, u16 type,
			    bool nopolicy, bool noxfrm, bool will_cache)
1624
{
1625 1626 1627
	struct rtable *rt;

	rt = dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
W
Wei Wang 已提交
1628
		       (will_cache ? 0 : DST_HOST) |
1629
		       (nopolicy ? DST_NOPOLICY : 0) |
W
Wei Wang 已提交
1630
		       (noxfrm ? DST_NOXFRM : 0));
1631 1632 1633 1634 1635 1636 1637 1638

	if (rt) {
		rt->rt_genid = rt_genid_ipv4(dev_net(dev));
		rt->rt_flags = flags;
		rt->rt_type = type;
		rt->rt_is_input = 0;
		rt->rt_iif = 0;
		rt->rt_pmtu = 0;
1639
		rt->rt_mtu_locked = 0;
1640
		rt->rt_uses_gateway = 0;
1641 1642
		rt->rt_gw_family = 0;
		rt->rt_gw4 = 0;
1643 1644 1645 1646 1647 1648 1649 1650
		INIT_LIST_HEAD(&rt->rt_uncached);

		rt->dst.output = ip_output;
		if (flags & RTCF_LOCAL)
			rt->dst.input = ip_local_deliver;
	}

	return rt;
1651
}
1652
EXPORT_SYMBOL(rt_dst_alloc);
1653

1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686
struct rtable *rt_dst_clone(struct net_device *dev, struct rtable *rt)
{
	struct rtable *new_rt;

	new_rt = dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
			   rt->dst.flags);

	if (new_rt) {
		new_rt->rt_genid = rt_genid_ipv4(dev_net(dev));
		new_rt->rt_flags = rt->rt_flags;
		new_rt->rt_type = rt->rt_type;
		new_rt->rt_is_input = rt->rt_is_input;
		new_rt->rt_iif = rt->rt_iif;
		new_rt->rt_pmtu = rt->rt_pmtu;
		new_rt->rt_mtu_locked = rt->rt_mtu_locked;
		new_rt->rt_gw_family = rt->rt_gw_family;
		if (rt->rt_gw_family == AF_INET)
			new_rt->rt_gw4 = rt->rt_gw4;
		else if (rt->rt_gw_family == AF_INET6)
			new_rt->rt_gw6 = rt->rt_gw6;
		INIT_LIST_HEAD(&new_rt->rt_uncached);

		new_rt->dst.flags |= DST_HOST;
		new_rt->dst.input = rt->dst.input;
		new_rt->dst.output = rt->dst.output;
		new_rt->dst.error = rt->dst.error;
		new_rt->dst.lastuse = jiffies;
		new_rt->dst.lwtstate = lwtstate_get(rt->dst.lwtstate);
	}
	return new_rt;
}
EXPORT_SYMBOL(rt_dst_clone);

1687
/* called in rcu_read_lock() section */
1688 1689 1690
int ip_mc_validate_source(struct sk_buff *skb, __be32 daddr, __be32 saddr,
			  u8 tos, struct net_device *dev,
			  struct in_device *in_dev, u32 *itag)
L
Linus Torvalds 已提交
1691
{
1692
	int err;
L
Linus Torvalds 已提交
1693 1694

	/* Primary sanity checks. */
1695
	if (!in_dev)
L
Linus Torvalds 已提交
1696 1697
		return -EINVAL;

1698
	if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
1699
	    skb->protocol != htons(ETH_P_IP))
1700
		return -EINVAL;
L
Linus Torvalds 已提交
1701

1702
	if (ipv4_is_loopback(saddr) && !IN_DEV_ROUTE_LOCALNET(in_dev))
1703
		return -EINVAL;
1704

1705
	if (ipv4_is_zeronet(saddr)) {
1706 1707
		if (!ipv4_is_local_multicast(daddr) &&
		    ip_hdr(skb)->protocol != IPPROTO_IGMP)
1708
			return -EINVAL;
1709
	} else {
1710
		err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1711
					  in_dev, itag);
1712
		if (err < 0)
1713
			return err;
1714
	}
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731
	return 0;
}

/* called in rcu_read_lock() section */
static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
			     u8 tos, struct net_device *dev, int our)
{
	struct in_device *in_dev = __in_dev_get_rcu(dev);
	unsigned int flags = RTCF_MULTICAST;
	struct rtable *rth;
	u32 itag = 0;
	int err;

	err = ip_mc_validate_source(skb, daddr, saddr, tos, dev, in_dev, &itag);
	if (err)
		return err;

1732 1733 1734 1735
	if (our)
		flags |= RTCF_LOCAL;

	rth = rt_dst_alloc(dev_net(dev)->loopback_dev, flags, RTN_MULTICAST,
1736
			   IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
L
Linus Torvalds 已提交
1737
	if (!rth)
1738
		return -ENOBUFS;
L
Linus Torvalds 已提交
1739

1740 1741 1742
#ifdef CONFIG_IP_ROUTE_CLASSID
	rth->dst.tclassid = itag;
#endif
1743
	rth->dst.output = ip_rt_bug;
1744
	rth->rt_is_input= 1;
L
Linus Torvalds 已提交
1745 1746

#ifdef CONFIG_IP_MROUTE
1747
	if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
1748
		rth->dst.input = ip_mr_input;
L
Linus Torvalds 已提交
1749 1750 1751
#endif
	RT_CACHE_STAT_INC(in_slow_mc);

1752 1753
	skb_dst_set(skb, &rth->dst);
	return 0;
L
Linus Torvalds 已提交
1754 1755 1756 1757 1758 1759
}


static void ip_handle_martian_source(struct net_device *dev,
				     struct in_device *in_dev,
				     struct sk_buff *skb,
1760 1761
				     __be32 daddr,
				     __be32 saddr)
L
Linus Torvalds 已提交
1762 1763 1764 1765 1766 1767 1768 1769
{
	RT_CACHE_STAT_INC(in_martian_src);
#ifdef CONFIG_IP_ROUTE_VERBOSE
	if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
		/*
		 *	RFC1812 recommendation, if source is martian,
		 *	the only hint is MAC header.
		 */
1770
		pr_warn("martian source %pI4 from %pI4, on dev %s\n",
1771
			&daddr, &saddr, dev->name);
1772
		if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
1773 1774 1775
			print_hex_dump(KERN_WARNING, "ll header: ",
				       DUMP_PREFIX_OFFSET, 16, 1,
				       skb_mac_header(skb),
1776
				       dev->hard_header_len, false);
L
Linus Torvalds 已提交
1777 1778 1779 1780 1781
		}
	}
#endif
}

1782
/* called in rcu_read_lock() section */
1783
static int __mkroute_input(struct sk_buff *skb,
1784
			   const struct fib_result *res,
1785
			   struct in_device *in_dev,
1786
			   __be32 daddr, __be32 saddr, u32 tos)
L
Linus Torvalds 已提交
1787
{
1788 1789
	struct fib_nh_common *nhc = FIB_RES_NHC(*res);
	struct net_device *dev = nhc->nhc_dev;
1790
	struct fib_nh_exception *fnhe;
L
Linus Torvalds 已提交
1791 1792 1793
	struct rtable *rth;
	int err;
	struct in_device *out_dev;
1794
	bool do_cache;
1795
	u32 itag = 0;
L
Linus Torvalds 已提交
1796 1797

	/* get a working reference to the output device */
1798
	out_dev = __in_dev_get_rcu(dev);
1799
	if (!out_dev) {
1800
		net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
L
Linus Torvalds 已提交
1801 1802 1803
		return -EINVAL;
	}

1804
	err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
1805
				  in_dev->dev, in_dev, &itag);
L
Linus Torvalds 已提交
1806
	if (err < 0) {
1807
		ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
L
Linus Torvalds 已提交
1808
					 saddr);
1809

L
Linus Torvalds 已提交
1810 1811 1812
		goto cleanup;
	}

1813 1814
	do_cache = res->fi && !itag;
	if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
1815
	    skb->protocol == htons(ETH_P_IP)) {
1816
		__be32 gw;
1817

1818
		gw = nhc->nhc_gw_family == AF_INET ? nhc->nhc_gw.ipv4 : 0;
1819 1820 1821 1822
		if (IN_DEV_SHARED_MEDIA(out_dev) ||
		    inet_addr_onlink(out_dev, saddr, gw))
			IPCB(skb)->flags |= IPSKB_DOREDIRECT;
	}
L
Linus Torvalds 已提交
1823 1824 1825 1826

	if (skb->protocol != htons(ETH_P_IP)) {
		/* Not IP (i.e. ARP). Do not create route, if it is
		 * invalid for proxy arp. DNAT routes are always valid.
1827 1828 1829 1830
		 *
		 * Proxy arp feature have been extended to allow, ARP
		 * replies back to the same interface, to support
		 * Private VLAN switch technologies. See arp.c.
L
Linus Torvalds 已提交
1831
		 */
1832 1833
		if (out_dev == in_dev &&
		    IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
L
Linus Torvalds 已提交
1834 1835 1836 1837 1838
			err = -EINVAL;
			goto cleanup;
		}
	}

1839
	fnhe = find_exception(nhc, daddr);
1840
	if (do_cache) {
1841
		if (fnhe)
1842
			rth = rcu_dereference(fnhe->fnhe_rth_input);
1843
		else
1844
			rth = rcu_dereference(nhc->nhc_rth_input);
1845 1846 1847
		if (rt_cache_valid(rth)) {
			skb_dst_set_noref(skb, &rth->dst);
			goto out;
1848 1849
		}
	}
1850

1851
	rth = rt_dst_alloc(out_dev->dev, 0, res->type,
1852
			   IN_DEV_CONF_GET(in_dev, NOPOLICY),
1853
			   IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
L
Linus Torvalds 已提交
1854 1855 1856 1857 1858
	if (!rth) {
		err = -ENOBUFS;
		goto cleanup;
	}

1859
	rth->rt_is_input = 1;
1860
	RT_CACHE_STAT_INC(in_slow_tot);
L
Linus Torvalds 已提交
1861

1862
	rth->dst.input = ip_forward;
L
Linus Torvalds 已提交
1863

W
Wei Wang 已提交
1864 1865
	rt_set_nexthop(rth, daddr, res, fnhe, res->fi, res->type, itag,
		       do_cache);
1866
	lwtunnel_set_redirect(&rth->dst);
1867
	skb_dst_set(skb, &rth->dst);
1868
out:
L
Linus Torvalds 已提交
1869 1870 1871
	err = 0;
 cleanup:
	return err;
1872
}
L
Linus Torvalds 已提交
1873

1874 1875
#ifdef CONFIG_IP_ROUTE_MULTIPATH
/* To make ICMP packets follow the right flow, the multipath hash is
1876
 * calculated from the inner IP addresses.
1877
 */
1878 1879
static void ip_multipath_l3_keys(const struct sk_buff *skb,
				 struct flow_keys *hash_keys)
1880 1881
{
	const struct iphdr *outer_iph = ip_hdr(skb);
1882
	const struct iphdr *key_iph = outer_iph;
1883
	const struct iphdr *inner_iph;
1884 1885
	const struct icmphdr *icmph;
	struct iphdr _inner_iph;
1886 1887 1888
	struct icmphdr _icmph;

	if (likely(outer_iph->protocol != IPPROTO_ICMP))
1889
		goto out;
1890 1891

	if (unlikely((outer_iph->frag_off & htons(IP_OFFSET)) != 0))
1892
		goto out;
1893 1894 1895 1896

	icmph = skb_header_pointer(skb, outer_iph->ihl * 4, sizeof(_icmph),
				   &_icmph);
	if (!icmph)
1897
		goto out;
1898

1899
	if (!icmp_is_err(icmph->type))
1900
		goto out;
1901 1902 1903 1904 1905

	inner_iph = skb_header_pointer(skb,
				       outer_iph->ihl * 4 + sizeof(_icmph),
				       sizeof(_inner_iph), &_inner_iph);
	if (!inner_iph)
1906 1907 1908 1909 1910 1911
		goto out;

	key_iph = inner_iph;
out:
	hash_keys->addrs.v4addrs.src = key_iph->saddr;
	hash_keys->addrs.v4addrs.dst = key_iph->daddr;
1912
}
1913

1914
/* if skb is set it will be used and fl4 can be NULL */
1915
int fib_multipath_hash(const struct net *net, const struct flowi4 *fl4,
1916
		       const struct sk_buff *skb, struct flow_keys *flkeys)
1917
{
1918
	u32 multipath_hash = fl4 ? fl4->flowi4_multipath_hash : 0;
1919 1920
	struct flow_keys hash_keys;
	u32 mhash;
1921

1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941
	switch (net->ipv4.sysctl_fib_multipath_hash_policy) {
	case 0:
		memset(&hash_keys, 0, sizeof(hash_keys));
		hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
		if (skb) {
			ip_multipath_l3_keys(skb, &hash_keys);
		} else {
			hash_keys.addrs.v4addrs.src = fl4->saddr;
			hash_keys.addrs.v4addrs.dst = fl4->daddr;
		}
		break;
	case 1:
		/* skb is currently provided only when forwarding */
		if (skb) {
			unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP;
			struct flow_keys keys;

			/* short-circuit if we already have L4 hash present */
			if (skb->l4_hash)
				return skb_get_hash_raw(skb) >> 1;
1942

1943
			memset(&hash_keys, 0, sizeof(hash_keys));
1944

1945
			if (!flkeys) {
1946
				skb_flow_dissect_flow_keys(skb, &keys, flag);
1947
				flkeys = &keys;
1948
			}
1949 1950 1951 1952 1953 1954 1955

			hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
			hash_keys.addrs.v4addrs.src = flkeys->addrs.v4addrs.src;
			hash_keys.addrs.v4addrs.dst = flkeys->addrs.v4addrs.dst;
			hash_keys.ports.src = flkeys->ports.src;
			hash_keys.ports.dst = flkeys->ports.dst;
			hash_keys.basic.ip_proto = flkeys->basic.ip_proto;
1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
		} else {
			memset(&hash_keys, 0, sizeof(hash_keys));
			hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
			hash_keys.addrs.v4addrs.src = fl4->saddr;
			hash_keys.addrs.v4addrs.dst = fl4->daddr;
			hash_keys.ports.src = fl4->fl4_sport;
			hash_keys.ports.dst = fl4->fl4_dport;
			hash_keys.basic.ip_proto = fl4->flowi4_proto;
		}
		break;
1966 1967 1968 1969 1970 1971 1972
	case 2:
		memset(&hash_keys, 0, sizeof(hash_keys));
		/* skb is currently provided only when forwarding */
		if (skb) {
			struct flow_keys keys;

			skb_flow_dissect_flow_keys(skb, &keys, 0);
1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
			/* Inner can be v4 or v6 */
			if (keys.control.addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) {
				hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
				hash_keys.addrs.v4addrs.src = keys.addrs.v4addrs.src;
				hash_keys.addrs.v4addrs.dst = keys.addrs.v4addrs.dst;
			} else if (keys.control.addr_type == FLOW_DISSECTOR_KEY_IPV6_ADDRS) {
				hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
				hash_keys.addrs.v6addrs.src = keys.addrs.v6addrs.src;
				hash_keys.addrs.v6addrs.dst = keys.addrs.v6addrs.dst;
				hash_keys.tags.flow_label = keys.tags.flow_label;
				hash_keys.basic.ip_proto = keys.basic.ip_proto;
			} else {
				/* Same as case 0 */
				hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
				ip_multipath_l3_keys(skb, &hash_keys);
			}
1989 1990
		} else {
			/* Same as case 0 */
1991
			hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
1992 1993 1994 1995
			hash_keys.addrs.v4addrs.src = fl4->saddr;
			hash_keys.addrs.v4addrs.dst = fl4->daddr;
		}
		break;
1996 1997
	}
	mhash = flow_hash_from_keys(&hash_keys);
1998

1999 2000 2001
	if (multipath_hash)
		mhash = jhash_2words(mhash, multipath_hash, 0);

2002 2003
	return mhash >> 1;
}
2004 2005
#endif /* CONFIG_IP_ROUTE_MULTIPATH */

2006 2007 2008
static int ip_mkroute_input(struct sk_buff *skb,
			    struct fib_result *res,
			    struct in_device *in_dev,
2009 2010
			    __be32 daddr, __be32 saddr, u32 tos,
			    struct flow_keys *hkeys)
L
Linus Torvalds 已提交
2011 2012
{
#ifdef CONFIG_IP_ROUTE_MULTIPATH
2013
	if (res->fi && fib_info_num_path(res->fi) > 1) {
2014
		int h = fib_multipath_hash(res->fi->fib_net, NULL, skb, hkeys);
2015 2016 2017

		fib_select_multipath(res, h);
	}
L
Linus Torvalds 已提交
2018 2019 2020
#endif

	/* create a routing cache entry */
2021
	return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
L
Linus Torvalds 已提交
2022 2023
}

2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063
/* Implements all the saddr-related checks as ip_route_input_slow(),
 * assuming daddr is valid and the destination is not a local broadcast one.
 * Uses the provided hint instead of performing a route lookup.
 */
int ip_route_use_hint(struct sk_buff *skb, __be32 daddr, __be32 saddr,
		      u8 tos, struct net_device *dev,
		      const struct sk_buff *hint)
{
	struct in_device *in_dev = __in_dev_get_rcu(dev);
	struct rtable *rt = (struct rtable *)hint;
	struct net *net = dev_net(dev);
	int err = -EINVAL;
	u32 tag = 0;

	if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
		goto martian_source;

	if (ipv4_is_zeronet(saddr))
		goto martian_source;

	if (ipv4_is_loopback(saddr) && !IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
		goto martian_source;

	if (rt->rt_type != RTN_LOCAL)
		goto skip_validate_source;

	tos &= IPTOS_RT_MASK;
	err = fib_validate_source(skb, saddr, daddr, tos, 0, dev, in_dev, &tag);
	if (err < 0)
		goto martian_source;

skip_validate_source:
	skb_dst_copy(skb, hint);
	return 0;

martian_source:
	ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
	return err;
}

L
Linus Torvalds 已提交
2064 2065 2066 2067
/*
 *	NOTE. We drop all the packets that has local source
 *	addresses, because every properly looped back packet
 *	must have correct destination already attached by output routine.
2068 2069
 *	Changes in the enforced policies must be applied also to
 *	ip_route_use_hint().
L
Linus Torvalds 已提交
2070 2071 2072 2073
 *
 *	Such approach solves two big problems:
 *	1. Not simplex devices are handled properly.
 *	2. IP spoofing attempts are filtered with 100% of guarantee.
2074
 *	called with rcu_read_lock()
L
Linus Torvalds 已提交
2075 2076
 */

2077
static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2078 2079
			       u8 tos, struct net_device *dev,
			       struct fib_result *res)
L
Linus Torvalds 已提交
2080
{
2081
	struct in_device *in_dev = __in_dev_get_rcu(dev);
2082 2083
	struct flow_keys *flkeys = NULL, _flkeys;
	struct net    *net = dev_net(dev);
2084
	struct ip_tunnel_info *tun_info;
2085
	int		err = -EINVAL;
2086
	unsigned int	flags = 0;
L
Linus Torvalds 已提交
2087
	u32		itag = 0;
2088
	struct rtable	*rth;
2089
	struct flowi4	fl4;
2090
	bool do_cache = true;
L
Linus Torvalds 已提交
2091 2092 2093 2094 2095 2096 2097 2098 2099 2100

	/* IP on this device is disabled. */

	if (!in_dev)
		goto out;

	/* Check for the most weird martians, which can be not detected
	   by fib_lookup.
	 */

2101
	tun_info = skb_tunnel_info(skb);
2102
	if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
2103 2104 2105
		fl4.flowi4_tun_key.tun_id = tun_info->key.tun_id;
	else
		fl4.flowi4_tun_key.tun_id = 0;
2106 2107
	skb_dst_drop(skb);

2108
	if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
L
Linus Torvalds 已提交
2109 2110
		goto martian_source;

2111 2112
	res->fi = NULL;
	res->table = NULL;
2113
	if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
L
Linus Torvalds 已提交
2114 2115 2116 2117 2118
		goto brd_input;

	/* Accept zero addresses only to limited broadcast;
	 * I even do not know to fix it or not. Waiting for complains :-)
	 */
2119
	if (ipv4_is_zeronet(saddr))
L
Linus Torvalds 已提交
2120 2121
		goto martian_source;

2122
	if (ipv4_is_zeronet(daddr))
L
Linus Torvalds 已提交
2123 2124
		goto martian_destination;

2125 2126 2127 2128 2129
	/* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
	 * and call it once if daddr or/and saddr are loopback addresses
	 */
	if (ipv4_is_loopback(daddr)) {
		if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
2130
			goto martian_destination;
2131 2132
	} else if (ipv4_is_loopback(saddr)) {
		if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
2133 2134 2135
			goto martian_source;
	}

L
Linus Torvalds 已提交
2136 2137 2138
	/*
	 *	Now we are ready to route packet.
	 */
2139
	fl4.flowi4_oif = 0;
2140
	fl4.flowi4_iif = dev->ifindex;
2141 2142 2143
	fl4.flowi4_mark = skb->mark;
	fl4.flowi4_tos = tos;
	fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
2144
	fl4.flowi4_flags = 0;
2145 2146
	fl4.daddr = daddr;
	fl4.saddr = saddr;
2147
	fl4.flowi4_uid = sock_net_uid(net, NULL);
2148

2149
	if (fib4_rules_early_flow_dissect(net, skb, &fl4, &_flkeys)) {
2150
		flkeys = &_flkeys;
2151 2152 2153 2154 2155
	} else {
		fl4.flowi4_proto = 0;
		fl4.fl4_sport = 0;
		fl4.fl4_dport = 0;
	}
2156

2157
	err = fib_lookup(net, &fl4, res, 0);
2158 2159 2160
	if (err != 0) {
		if (!IN_DEV_FORWARD(in_dev))
			err = -EHOSTUNREACH;
L
Linus Torvalds 已提交
2161
		goto no_route;
2162
	}
L
Linus Torvalds 已提交
2163

2164 2165 2166
	if (res->type == RTN_BROADCAST) {
		if (IN_DEV_BFORWARD(in_dev))
			goto make_route;
2167 2168 2169
		/* not do cache if bc_forwarding is enabled */
		if (IPV4_DEVCONF_ALL(net, BC_FORWARDING))
			do_cache = false;
L
Linus Torvalds 已提交
2170
		goto brd_input;
2171
	}
L
Linus Torvalds 已提交
2172

2173
	if (res->type == RTN_LOCAL) {
2174
		err = fib_validate_source(skb, saddr, daddr, tos,
2175
					  0, dev, in_dev, &itag);
2176
		if (err < 0)
2177
			goto martian_source;
L
Linus Torvalds 已提交
2178 2179 2180
		goto local_input;
	}

2181 2182
	if (!IN_DEV_FORWARD(in_dev)) {
		err = -EHOSTUNREACH;
2183
		goto no_route;
2184
	}
2185
	if (res->type != RTN_UNICAST)
L
Linus Torvalds 已提交
2186 2187
		goto martian_destination;

2188
make_route:
2189
	err = ip_mkroute_input(skb, res, in_dev, daddr, saddr, tos, flkeys);
L
Linus Torvalds 已提交
2190 2191 2192 2193 2194 2195
out:	return err;

brd_input:
	if (skb->protocol != htons(ETH_P_IP))
		goto e_inval;

2196
	if (!ipv4_is_zeronet(saddr)) {
2197 2198
		err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
					  in_dev, &itag);
L
Linus Torvalds 已提交
2199
		if (err < 0)
2200
			goto martian_source;
L
Linus Torvalds 已提交
2201 2202
	}
	flags |= RTCF_BROADCAST;
2203
	res->type = RTN_BROADCAST;
L
Linus Torvalds 已提交
2204 2205 2206
	RT_CACHE_STAT_INC(in_brd);

local_input:
2207 2208 2209
	do_cache &= res->fi && !itag;
	if (do_cache) {
		struct fib_nh_common *nhc = FIB_RES_NHC(*res);
2210

2211 2212 2213 2214 2215
		rth = rcu_dereference(nhc->nhc_rth_input);
		if (rt_cache_valid(rth)) {
			skb_dst_set_noref(skb, &rth->dst);
			err = 0;
			goto out;
2216 2217 2218
		}
	}

2219
	rth = rt_dst_alloc(l3mdev_master_dev_rcu(dev) ? : net->loopback_dev,
2220
			   flags | RTCF_LOCAL, res->type,
2221
			   IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
L
Linus Torvalds 已提交
2222 2223 2224
	if (!rth)
		goto e_nobufs;

2225
	rth->dst.output= ip_rt_bug;
2226 2227 2228
#ifdef CONFIG_IP_ROUTE_CLASSID
	rth->dst.tclassid = itag;
#endif
2229
	rth->rt_is_input = 1;
2230

2231
	RT_CACHE_STAT_INC(in_slow_tot);
2232
	if (res->type == RTN_UNREACHABLE) {
2233 2234
		rth->dst.input= ip_error;
		rth->dst.error= -err;
L
Linus Torvalds 已提交
2235 2236
		rth->rt_flags 	&= ~RTCF_LOCAL;
	}
2237

2238
	if (do_cache) {
2239
		struct fib_nh_common *nhc = FIB_RES_NHC(*res);
2240

2241
		rth->dst.lwtstate = lwtstate_get(nhc->nhc_lwtstate);
2242 2243 2244 2245 2246 2247
		if (lwtunnel_input_redirect(rth->dst.lwtstate)) {
			WARN_ON(rth->dst.input == lwtunnel_input);
			rth->dst.lwtstate->orig_input = rth->dst.input;
			rth->dst.input = lwtunnel_input;
		}

2248
		if (unlikely(!rt_cache_route(nhc, rth)))
2249 2250
			rt_add_uncached_list(rth);
	}
2251
	skb_dst_set(skb, &rth->dst);
2252
	err = 0;
2253
	goto out;
L
Linus Torvalds 已提交
2254 2255 2256

no_route:
	RT_CACHE_STAT_INC(in_no_route);
2257 2258 2259
	res->type = RTN_UNREACHABLE;
	res->fi = NULL;
	res->table = NULL;
L
Linus Torvalds 已提交
2260 2261 2262 2263 2264 2265 2266 2267
	goto local_input;

	/*
	 *	Do not cache martian addresses: they should be logged (RFC1812)
	 */
martian_destination:
	RT_CACHE_STAT_INC(in_martian_dst);
#ifdef CONFIG_IP_ROUTE_VERBOSE
2268 2269 2270
	if (IN_DEV_LOG_MARTIANS(in_dev))
		net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
				     &daddr, &saddr, dev->name);
L
Linus Torvalds 已提交
2271
#endif
2272

L
Linus Torvalds 已提交
2273 2274
e_inval:
	err = -EINVAL;
2275
	goto out;
L
Linus Torvalds 已提交
2276 2277 2278

e_nobufs:
	err = -ENOBUFS;
2279
	goto out;
L
Linus Torvalds 已提交
2280 2281 2282

martian_source:
	ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
2283
	goto out;
L
Linus Torvalds 已提交
2284 2285
}

2286 2287
int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
			 u8 tos, struct net_device *dev)
L
Linus Torvalds 已提交
2288
{
2289 2290
	struct fib_result res;
	int err;
L
Linus Torvalds 已提交
2291

2292
	tos &= IPTOS_RT_MASK;
2293
	rcu_read_lock();
2294 2295
	err = ip_route_input_rcu(skb, daddr, saddr, tos, dev, &res);
	rcu_read_unlock();
2296

2297 2298 2299 2300 2301 2302 2303 2304
	return err;
}
EXPORT_SYMBOL(ip_route_input_noref);

/* called with rcu_read_lock held */
int ip_route_input_rcu(struct sk_buff *skb, __be32 daddr, __be32 saddr,
		       u8 tos, struct net_device *dev, struct fib_result *res)
{
L
Linus Torvalds 已提交
2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315
	/* Multicast recognition logic is moved from route cache to here.
	   The problem was that too many Ethernet cards have broken/missing
	   hardware multicast filters :-( As result the host on multicasting
	   network acquires a lot of useless route cache entries, sort of
	   SDR messages from all the world. Now we try to get rid of them.
	   Really, provided software IP multicast filter is organized
	   reasonably (at least, hashed), it does not result in a slowdown
	   comparing with route cache reject entries.
	   Note, that multicast routers are not affected, because
	   route cache entry is created eventually.
	 */
2316
	if (ipv4_is_multicast(daddr)) {
2317
		struct in_device *in_dev = __in_dev_get_rcu(dev);
2318
		int our = 0;
2319
		int err = -EINVAL;
L
Linus Torvalds 已提交
2320

2321 2322 2323 2324
		if (!in_dev)
			return err;
		our = ip_check_mc_rcu(in_dev, daddr, saddr,
				      ip_hdr(skb)->protocol);
2325 2326

		/* check l3 master if no match yet */
2327
		if (!our && netif_is_l3_slave(dev)) {
2328 2329 2330 2331 2332 2333 2334 2335 2336
			struct in_device *l3_in_dev;

			l3_in_dev = __in_dev_get_rcu(skb->dev);
			if (l3_in_dev)
				our = ip_check_mc_rcu(l3_in_dev, daddr, saddr,
						      ip_hdr(skb)->protocol);
		}

		if (our
L
Linus Torvalds 已提交
2337
#ifdef CONFIG_IP_MROUTE
2338 2339 2340
			||
		    (!ipv4_is_local_multicast(daddr) &&
		     IN_DEV_MFORWARD(in_dev))
L
Linus Torvalds 已提交
2341
#endif
2342
		   ) {
2343
			err = ip_route_input_mc(skb, daddr, saddr,
2344
						tos, dev, our);
L
Linus Torvalds 已提交
2345
		}
2346
		return err;
L
Linus Torvalds 已提交
2347
	}
2348 2349

	return ip_route_input_slow(skb, daddr, saddr, tos, dev, res);
L
Linus Torvalds 已提交
2350 2351
}

2352
/* called with rcu_read_lock() */
2353
static struct rtable *__mkroute_output(const struct fib_result *res,
2354
				       const struct flowi4 *fl4, int orig_oif,
2355
				       struct net_device *dev_out,
2356
				       unsigned int flags)
L
Linus Torvalds 已提交
2357
{
2358
	struct fib_info *fi = res->fi;
2359
	struct fib_nh_exception *fnhe;
2360
	struct in_device *in_dev;
2361
	u16 type = res->type;
2362
	struct rtable *rth;
2363
	bool do_cache;
L
Linus Torvalds 已提交
2364

2365 2366
	in_dev = __in_dev_get_rcu(dev_out);
	if (!in_dev)
2367
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
2368

2369
	if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
2370 2371 2372
		if (ipv4_is_loopback(fl4->saddr) &&
		    !(dev_out->flags & IFF_LOOPBACK) &&
		    !netif_is_l3_master(dev_out))
2373 2374
			return ERR_PTR(-EINVAL);

2375
	if (ipv4_is_lbcast(fl4->daddr))
2376
		type = RTN_BROADCAST;
2377
	else if (ipv4_is_multicast(fl4->daddr))
2378
		type = RTN_MULTICAST;
2379
	else if (ipv4_is_zeronet(fl4->daddr))
2380
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
2381 2382 2383 2384

	if (dev_out->flags & IFF_LOOPBACK)
		flags |= RTCF_LOCAL;

2385
	do_cache = true;
2386
	if (type == RTN_BROADCAST) {
L
Linus Torvalds 已提交
2387
		flags |= RTCF_BROADCAST | RTCF_LOCAL;
2388 2389
		fi = NULL;
	} else if (type == RTN_MULTICAST) {
2390
		flags |= RTCF_MULTICAST | RTCF_LOCAL;
2391 2392
		if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
				     fl4->flowi4_proto))
L
Linus Torvalds 已提交
2393
			flags &= ~RTCF_LOCAL;
2394 2395
		else
			do_cache = false;
L
Linus Torvalds 已提交
2396
		/* If multicast route do not exist use
2397 2398
		 * default one, but do not gateway in this case.
		 * Yes, it is hack.
L
Linus Torvalds 已提交
2399
		 */
2400 2401
		if (fi && res->prefixlen < 4)
			fi = NULL;
2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412
	} else if ((type == RTN_LOCAL) && (orig_oif != 0) &&
		   (orig_oif != dev_out->ifindex)) {
		/* For local routes that require a particular output interface
		 * we do not want to cache the result.  Caching the result
		 * causes incorrect behaviour when there are multiple source
		 * addresses on the interface, the end result being that if the
		 * intended recipient is waiting on that interface for the
		 * packet he won't receive it because it will be delivered on
		 * the loopback interface and the IP_PKTINFO ipi_ifindex will
		 * be set to the loopback interface as well.
		 */
2413
		do_cache = false;
L
Linus Torvalds 已提交
2414 2415
	}

2416
	fnhe = NULL;
2417
	do_cache &= fi != NULL;
2418
	if (fi) {
2419
		struct fib_nh_common *nhc = FIB_RES_NHC(*res);
2420
		struct rtable __rcu **prth;
2421

2422
		fnhe = find_exception(nhc, fl4->daddr);
2423 2424
		if (!do_cache)
			goto add;
2425
		if (fnhe) {
2426
			prth = &fnhe->fnhe_rth_output;
2427 2428 2429
		} else {
			if (unlikely(fl4->flowi4_flags &
				     FLOWI_FLAG_KNOWN_NH &&
2430
				     !(nhc->nhc_gw_family &&
2431
				       nhc->nhc_scope == RT_SCOPE_LINK))) {
2432 2433
				do_cache = false;
				goto add;
2434
			}
2435
			prth = raw_cpu_ptr(nhc->nhc_pcpu_rth_output);
2436
		}
2437
		rth = rcu_dereference(*prth);
2438
		if (rt_cache_valid(rth) && dst_hold_safe(&rth->dst))
2439
			return rth;
2440
	}
2441 2442

add:
2443
	rth = rt_dst_alloc(dev_out, flags, type,
2444
			   IN_DEV_CONF_GET(in_dev, NOPOLICY),
2445
			   IN_DEV_CONF_GET(in_dev, NOXFRM),
2446
			   do_cache);
2447
	if (!rth)
2448
		return ERR_PTR(-ENOBUFS);
2449

2450
	rth->rt_iif = orig_oif;
2451

L
Linus Torvalds 已提交
2452 2453 2454
	RT_CACHE_STAT_INC(out_slow_tot);

	if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
2455
		if (flags & RTCF_LOCAL &&
L
Linus Torvalds 已提交
2456
		    !(dev_out->flags & IFF_LOOPBACK)) {
2457
			rth->dst.output = ip_mc_output;
L
Linus Torvalds 已提交
2458 2459 2460
			RT_CACHE_STAT_INC(out_slow_mc);
		}
#ifdef CONFIG_IP_MROUTE
2461
		if (type == RTN_MULTICAST) {
L
Linus Torvalds 已提交
2462
			if (IN_DEV_MFORWARD(in_dev) &&
2463
			    !ipv4_is_local_multicast(fl4->daddr)) {
2464 2465
				rth->dst.input = ip_mr_input;
				rth->dst.output = ip_mc_output;
L
Linus Torvalds 已提交
2466 2467 2468 2469 2470
			}
		}
#endif
	}

W
Wei Wang 已提交
2471
	rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0, do_cache);
2472
	lwtunnel_set_redirect(&rth->dst);
L
Linus Torvalds 已提交
2473

2474
	return rth;
L
Linus Torvalds 已提交
2475 2476 2477 2478 2479 2480
}

/*
 * Major route resolver routine.
 */

2481 2482
struct rtable *ip_route_output_key_hash(struct net *net, struct flowi4 *fl4,
					const struct sk_buff *skb)
L
Linus Torvalds 已提交
2483
{
2484
	__u8 tos = RT_FL_TOS(fl4);
2485 2486 2487 2488 2489 2490
	struct fib_result res = {
		.type		= RTN_UNSPEC,
		.fi		= NULL,
		.table		= NULL,
		.tclassid	= 0,
	};
2491
	struct rtable *rth;
L
Linus Torvalds 已提交
2492

2493
	fl4->flowi4_iif = LOOPBACK_IFINDEX;
2494 2495 2496
	fl4->flowi4_tos = tos & IPTOS_RT_MASK;
	fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
			 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
2497

2498
	rcu_read_lock();
2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513
	rth = ip_route_output_key_hash_rcu(net, fl4, &res, skb);
	rcu_read_unlock();

	return rth;
}
EXPORT_SYMBOL_GPL(ip_route_output_key_hash);

struct rtable *ip_route_output_key_hash_rcu(struct net *net, struct flowi4 *fl4,
					    struct fib_result *res,
					    const struct sk_buff *skb)
{
	struct net_device *dev_out = NULL;
	int orig_oif = fl4->flowi4_oif;
	unsigned int flags = 0;
	struct rtable *rth;
2514
	int err;
2515

2516 2517 2518
	if (fl4->saddr) {
		if (ipv4_is_multicast(fl4->saddr) ||
		    ipv4_is_lbcast(fl4->saddr) ||
2519 2520
		    ipv4_is_zeronet(fl4->saddr)) {
			rth = ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
2521
			goto out;
2522 2523 2524
		}

		rth = ERR_PTR(-ENETUNREACH);
L
Linus Torvalds 已提交
2525 2526 2527

		/* I removed check for oif == dev_out->oif here.
		   It was wrong for two reasons:
2528 2529
		   1. ip_dev_find(net, saddr) can return wrong iface, if saddr
		      is assigned to multiple interfaces.
L
Linus Torvalds 已提交
2530 2531 2532 2533
		   2. Moreover, we are allowed to send packets with saddr
		      of another iface. --ANK
		 */

2534 2535 2536
		if (fl4->flowi4_oif == 0 &&
		    (ipv4_is_multicast(fl4->daddr) ||
		     ipv4_is_lbcast(fl4->daddr))) {
2537
			/* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2538
			dev_out = __ip_dev_find(net, fl4->saddr, false);
2539
			if (!dev_out)
2540 2541
				goto out;

L
Linus Torvalds 已提交
2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556
			/* Special hack: user can direct multicasts
			   and limited broadcast via necessary interface
			   without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
			   This hack is not just for fun, it allows
			   vic,vat and friends to work.
			   They bind socket to loopback, set ttl to zero
			   and expect that it will work.
			   From the viewpoint of routing cache they are broken,
			   because we are not allowed to build multicast path
			   with loopback source addr (look, routing cache
			   cannot know, that ttl is zero, so that packet
			   will not leave this host and route is valid).
			   Luckily, this hack is good workaround.
			 */

2557
			fl4->flowi4_oif = dev_out->ifindex;
L
Linus Torvalds 已提交
2558 2559
			goto make_route;
		}
2560

2561
		if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
2562
			/* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2563
			if (!__ip_dev_find(net, fl4->saddr, false))
2564 2565
				goto out;
		}
L
Linus Torvalds 已提交
2566 2567 2568
	}


2569 2570
	if (fl4->flowi4_oif) {
		dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
2571
		rth = ERR_PTR(-ENODEV);
2572
		if (!dev_out)
L
Linus Torvalds 已提交
2573
			goto out;
2574 2575

		/* RACE: Check return value of inet_select_addr instead. */
2576
		if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
2577
			rth = ERR_PTR(-ENETUNREACH);
2578 2579
			goto out;
		}
2580
		if (ipv4_is_local_multicast(fl4->daddr) ||
2581 2582
		    ipv4_is_lbcast(fl4->daddr) ||
		    fl4->flowi4_proto == IPPROTO_IGMP) {
2583 2584 2585
			if (!fl4->saddr)
				fl4->saddr = inet_select_addr(dev_out, 0,
							      RT_SCOPE_LINK);
L
Linus Torvalds 已提交
2586 2587
			goto make_route;
		}
2588
		if (!fl4->saddr) {
2589 2590 2591 2592 2593 2594
			if (ipv4_is_multicast(fl4->daddr))
				fl4->saddr = inet_select_addr(dev_out, 0,
							      fl4->flowi4_scope);
			else if (!fl4->daddr)
				fl4->saddr = inet_select_addr(dev_out, 0,
							      RT_SCOPE_HOST);
L
Linus Torvalds 已提交
2595 2596 2597
		}
	}

2598 2599 2600 2601
	if (!fl4->daddr) {
		fl4->daddr = fl4->saddr;
		if (!fl4->daddr)
			fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
2602
		dev_out = net->loopback_dev;
2603
		fl4->flowi4_oif = LOOPBACK_IFINDEX;
2604
		res->type = RTN_LOCAL;
L
Linus Torvalds 已提交
2605 2606 2607 2608
		flags |= RTCF_LOCAL;
		goto make_route;
	}

2609
	err = fib_lookup(net, fl4, res, 0);
2610
	if (err) {
2611 2612
		res->fi = NULL;
		res->table = NULL;
2613
		if (fl4->flowi4_oif &&
2614 2615
		    (ipv4_is_multicast(fl4->daddr) ||
		    !netif_index_is_l3_master(net, fl4->flowi4_oif))) {
L
Linus Torvalds 已提交
2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633
			/* Apparently, routing tables are wrong. Assume,
			   that the destination is on link.

			   WHY? DW.
			   Because we are allowed to send to iface
			   even if it has NO routes and NO assigned
			   addresses. When oif is specified, routing
			   tables are looked up with only one purpose:
			   to catch if destination is gatewayed, rather than
			   direct. Moreover, if MSG_DONTROUTE is set,
			   we send packet, ignoring both routing tables
			   and ifaddr state. --ANK


			   We could make it even if oif is unknown,
			   likely IPv6, but we do not.
			 */

2634 2635 2636
			if (fl4->saddr == 0)
				fl4->saddr = inet_select_addr(dev_out, 0,
							      RT_SCOPE_LINK);
2637
			res->type = RTN_UNICAST;
L
Linus Torvalds 已提交
2638 2639
			goto make_route;
		}
2640
		rth = ERR_PTR(err);
L
Linus Torvalds 已提交
2641 2642 2643
		goto out;
	}

2644
	if (res->type == RTN_LOCAL) {
2645
		if (!fl4->saddr) {
2646 2647
			if (res->fi->fib_prefsrc)
				fl4->saddr = res->fi->fib_prefsrc;
2648
			else
2649
				fl4->saddr = fl4->daddr;
2650
		}
2651 2652

		/* L3 master device is the loopback for that domain */
2653
		dev_out = l3mdev_master_dev_rcu(FIB_RES_DEV(*res)) ? :
2654
			net->loopback_dev;
2655 2656 2657 2658 2659 2660

		/* make sure orig_oif points to fib result device even
		 * though packet rx/tx happens over loopback or l3mdev
		 */
		orig_oif = FIB_RES_OIF(*res);

2661
		fl4->flowi4_oif = dev_out->ifindex;
L
Linus Torvalds 已提交
2662 2663 2664 2665
		flags |= RTCF_LOCAL;
		goto make_route;
	}

2666
	fib_select_path(net, res, fl4, skb);
L
Linus Torvalds 已提交
2667

2668
	dev_out = FIB_RES_DEV(*res);
2669
	fl4->flowi4_oif = dev_out->ifindex;
L
Linus Torvalds 已提交
2670 2671 2672


make_route:
2673
	rth = __mkroute_output(res, fl4, orig_oif, dev_out, flags);
L
Linus Torvalds 已提交
2674

2675
out:
2676
	return rth;
L
Linus Torvalds 已提交
2677
}
2678

2679 2680 2681 2682 2683
static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
{
	return NULL;
}

2684
static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
2685
{
2686 2687 2688
	unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);

	return mtu ? : dst->dev->mtu;
2689 2690
}

2691
static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2692 2693
					  struct sk_buff *skb, u32 mtu,
					  bool confirm_neigh)
2694 2695 2696
{
}

2697 2698
static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
				       struct sk_buff *skb)
2699 2700 2701
{
}

2702 2703 2704 2705 2706 2707
static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
					  unsigned long old)
{
	return NULL;
}

2708 2709
static struct dst_ops ipv4_dst_blackhole_ops = {
	.family			=	AF_INET,
2710
	.check			=	ipv4_blackhole_dst_check,
2711
	.mtu			=	ipv4_blackhole_mtu,
2712
	.default_advmss		=	ipv4_default_advmss,
2713
	.update_pmtu		=	ipv4_rt_blackhole_update_pmtu,
2714
	.redirect		=	ipv4_rt_blackhole_redirect,
2715
	.cow_metrics		=	ipv4_rt_blackhole_cow_metrics,
2716
	.neigh_lookup		=	ipv4_neigh_lookup,
2717 2718
};

2719
struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
2720
{
2721
	struct rtable *ort = (struct rtable *) dst_orig;
2722
	struct rtable *rt;
2723

2724
	rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_DEAD, 0);
2725
	if (rt) {
2726
		struct dst_entry *new = &rt->dst;
2727 2728

		new->__use = 1;
2729
		new->input = dst_discard;
2730
		new->output = dst_discard_out;
2731

2732
		new->dev = net->loopback_dev;
2733 2734 2735
		if (new->dev)
			dev_hold(new->dev);

2736
		rt->rt_is_input = ort->rt_is_input;
2737
		rt->rt_iif = ort->rt_iif;
2738
		rt->rt_pmtu = ort->rt_pmtu;
2739
		rt->rt_mtu_locked = ort->rt_mtu_locked;
2740

2741
		rt->rt_genid = rt_genid_ipv4(net);
2742 2743
		rt->rt_flags = ort->rt_flags;
		rt->rt_type = ort->rt_type;
2744
		rt->rt_uses_gateway = ort->rt_uses_gateway;
2745 2746 2747
		rt->rt_gw_family = ort->rt_gw_family;
		if (rt->rt_gw_family == AF_INET)
			rt->rt_gw4 = ort->rt_gw4;
2748 2749
		else if (rt->rt_gw_family == AF_INET6)
			rt->rt_gw6 = ort->rt_gw6;
2750

2751
		INIT_LIST_HEAD(&rt->rt_uncached);
2752 2753
	}

2754 2755 2756
	dst_release(dst_orig);

	return rt ? &rt->dst : ERR_PTR(-ENOMEM);
2757 2758
}

2759
struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
2760
				    const struct sock *sk)
L
Linus Torvalds 已提交
2761
{
2762
	struct rtable *rt = __ip_route_output_key(net, flp4);
L
Linus Torvalds 已提交
2763

2764 2765
	if (IS_ERR(rt))
		return rt;
L
Linus Torvalds 已提交
2766

2767
	if (flp4->flowi4_proto)
2768 2769 2770
		rt = (struct rtable *)xfrm_lookup_route(net, &rt->dst,
							flowi4_to_flowi(flp4),
							sk, 0);
L
Linus Torvalds 已提交
2771

2772
	return rt;
L
Linus Torvalds 已提交
2773
}
2774 2775
EXPORT_SYMBOL_GPL(ip_route_output_flow);

2776
/* called with rcu_read_lock held */
2777 2778
static int rt_fill_info(struct net *net, __be32 dst, __be32 src,
			struct rtable *rt, u32 table_id, struct flowi4 *fl4,
2779 2780
			struct sk_buff *skb, u32 portid, u32 seq,
			unsigned int flags)
L
Linus Torvalds 已提交
2781 2782
{
	struct rtmsg *r;
2783
	struct nlmsghdr *nlh;
2784
	unsigned long expires = 0;
2785
	u32 error;
2786
	u32 metrics[RTAX_MAX];
2787

2788
	nlh = nlmsg_put(skb, portid, seq, RTM_NEWROUTE, sizeof(*r), flags);
2789
	if (!nlh)
2790
		return -EMSGSIZE;
2791 2792

	r = nlmsg_data(nlh);
L
Linus Torvalds 已提交
2793 2794 2795
	r->rtm_family	 = AF_INET;
	r->rtm_dst_len	= 32;
	r->rtm_src_len	= 0;
2796
	r->rtm_tos	= fl4 ? fl4->flowi4_tos : 0;
2797
	r->rtm_table	= table_id < 256 ? table_id : RT_TABLE_COMPAT;
2798
	if (nla_put_u32(skb, RTA_TABLE, table_id))
2799
		goto nla_put_failure;
L
Linus Torvalds 已提交
2800 2801 2802 2803 2804 2805
	r->rtm_type	= rt->rt_type;
	r->rtm_scope	= RT_SCOPE_UNIVERSE;
	r->rtm_protocol = RTPROT_UNSPEC;
	r->rtm_flags	= (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
	if (rt->rt_flags & RTCF_NOTIFY)
		r->rtm_flags |= RTM_F_NOTIFY;
2806 2807
	if (IPCB(skb)->flags & IPSKB_DOREDIRECT)
		r->rtm_flags |= RTCF_DOREDIRECT;
2808

2809
	if (nla_put_in_addr(skb, RTA_DST, dst))
2810
		goto nla_put_failure;
2811
	if (src) {
L
Linus Torvalds 已提交
2812
		r->rtm_src_len = 32;
2813
		if (nla_put_in_addr(skb, RTA_SRC, src))
2814
			goto nla_put_failure;
L
Linus Torvalds 已提交
2815
	}
2816 2817 2818
	if (rt->dst.dev &&
	    nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
		goto nla_put_failure;
2819
#ifdef CONFIG_IP_ROUTE_CLASSID
2820 2821 2822
	if (rt->dst.tclassid &&
	    nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
		goto nla_put_failure;
L
Linus Torvalds 已提交
2823
#endif
2824
	if (fl4 && !rt_is_input_route(rt) &&
2825
	    fl4->saddr != src) {
2826
		if (nla_put_in_addr(skb, RTA_PREFSRC, fl4->saddr))
2827 2828
			goto nla_put_failure;
	}
2829 2830 2831
	if (rt->rt_uses_gateway) {
		if (rt->rt_gw_family == AF_INET &&
		    nla_put_in_addr(skb, RTA_GATEWAY, rt->rt_gw4)) {
2832
			goto nla_put_failure;
2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845
		} else if (rt->rt_gw_family == AF_INET6) {
			int alen = sizeof(struct in6_addr);
			struct nlattr *nla;
			struct rtvia *via;

			nla = nla_reserve(skb, RTA_VIA, alen + 2);
			if (!nla)
				goto nla_put_failure;

			via = nla_data(nla);
			via->rtvia_family = AF_INET6;
			memcpy(via->rtvia_addr, &rt->rt_gw6, alen);
		}
2846
	}
2847

2848 2849 2850 2851 2852 2853 2854 2855 2856 2857
	expires = rt->dst.expires;
	if (expires) {
		unsigned long now = jiffies;

		if (time_before(now, expires))
			expires -= now;
		else
			expires = 0;
	}

2858
	memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
2859
	if (rt->rt_pmtu && expires)
2860
		metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2861 2862
	if (rt->rt_mtu_locked && expires)
		metrics[RTAX_LOCK - 1] |= BIT(RTAX_MTU);
2863
	if (rtnetlink_put_metrics(skb, metrics) < 0)
2864 2865
		goto nla_put_failure;

2866 2867 2868 2869
	if (fl4) {
		if (fl4->flowi4_mark &&
		    nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
			goto nla_put_failure;
2870

2871 2872 2873 2874 2875
		if (!uid_eq(fl4->flowi4_uid, INVALID_UID) &&
		    nla_put_u32(skb, RTA_UID,
				from_kuid_munged(current_user_ns(),
						 fl4->flowi4_uid)))
			goto nla_put_failure;
2876

2877
		if (rt_is_input_route(rt)) {
2878
#ifdef CONFIG_IP_MROUTE
2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891
			if (ipv4_is_multicast(dst) &&
			    !ipv4_is_local_multicast(dst) &&
			    IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
				int err = ipmr_get_route(net, skb,
							 fl4->saddr, fl4->daddr,
							 r, portid);

				if (err <= 0) {
					if (err == 0)
						return 0;
					goto nla_put_failure;
				}
			} else
2892
#endif
2893 2894 2895
				if (nla_put_u32(skb, RTA_IIF, fl4->flowi4_iif))
					goto nla_put_failure;
		}
L
Linus Torvalds 已提交
2896 2897
	}

2898 2899
	error = rt->dst.error;

2900
	if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
2901
		goto nla_put_failure;
2902

2903 2904
	nlmsg_end(skb, nlh);
	return 0;
L
Linus Torvalds 已提交
2905

2906
nla_put_failure:
2907 2908
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
2909 2910
}

2911 2912 2913
static int fnhe_dump_bucket(struct net *net, struct sk_buff *skb,
			    struct netlink_callback *cb, u32 table_id,
			    struct fnhe_hash_bucket *bucket, int genid,
2914
			    int *fa_index, int fa_start, unsigned int flags)
2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944
{
	int i;

	for (i = 0; i < FNHE_HASH_SIZE; i++) {
		struct fib_nh_exception *fnhe;

		for (fnhe = rcu_dereference(bucket[i].chain); fnhe;
		     fnhe = rcu_dereference(fnhe->fnhe_next)) {
			struct rtable *rt;
			int err;

			if (*fa_index < fa_start)
				goto next;

			if (fnhe->fnhe_genid != genid)
				goto next;

			if (fnhe->fnhe_expires &&
			    time_after(jiffies, fnhe->fnhe_expires))
				goto next;

			rt = rcu_dereference(fnhe->fnhe_rth_input);
			if (!rt)
				rt = rcu_dereference(fnhe->fnhe_rth_output);
			if (!rt)
				goto next;

			err = rt_fill_info(net, fnhe->fnhe_daddr, 0, rt,
					   table_id, NULL, skb,
					   NETLINK_CB(cb->skb).portid,
2945
					   cb->nlh->nlmsg_seq, flags);
2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957
			if (err)
				return err;
next:
			(*fa_index)++;
		}
	}

	return 0;
}

int fib_dump_info_fnhe(struct sk_buff *skb, struct netlink_callback *cb,
		       u32 table_id, struct fib_info *fi,
2958
		       int *fa_index, int fa_start, unsigned int flags)
2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970
{
	struct net *net = sock_net(cb->skb->sk);
	int nhsel, genid = fnhe_genid(net);

	for (nhsel = 0; nhsel < fib_info_num_path(fi); nhsel++) {
		struct fib_nh_common *nhc = fib_info_nhc(fi, nhsel);
		struct fnhe_hash_bucket *bucket;
		int err;

		if (nhc->nhc_flags & RTNH_F_DEAD)
			continue;

2971
		rcu_read_lock();
2972
		bucket = rcu_dereference(nhc->nhc_exceptions);
2973 2974 2975
		err = 0;
		if (bucket)
			err = fnhe_dump_bucket(net, skb, cb, table_id, bucket,
2976 2977
					       genid, fa_index, fa_start,
					       flags);
2978
		rcu_read_unlock();
2979 2980 2981 2982 2983 2984 2985
		if (err)
			return err;
	}

	return 0;
}

2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046
static struct sk_buff *inet_rtm_getroute_build_skb(__be32 src, __be32 dst,
						   u8 ip_proto, __be16 sport,
						   __be16 dport)
{
	struct sk_buff *skb;
	struct iphdr *iph;

	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!skb)
		return NULL;

	/* Reserve room for dummy headers, this skb can pass
	 * through good chunk of routing engine.
	 */
	skb_reset_mac_header(skb);
	skb_reset_network_header(skb);
	skb->protocol = htons(ETH_P_IP);
	iph = skb_put(skb, sizeof(struct iphdr));
	iph->protocol = ip_proto;
	iph->saddr = src;
	iph->daddr = dst;
	iph->version = 0x4;
	iph->frag_off = 0;
	iph->ihl = 0x5;
	skb_set_transport_header(skb, skb->len);

	switch (iph->protocol) {
	case IPPROTO_UDP: {
		struct udphdr *udph;

		udph = skb_put_zero(skb, sizeof(struct udphdr));
		udph->source = sport;
		udph->dest = dport;
		udph->len = sizeof(struct udphdr);
		udph->check = 0;
		break;
	}
	case IPPROTO_TCP: {
		struct tcphdr *tcph;

		tcph = skb_put_zero(skb, sizeof(struct tcphdr));
		tcph->source	= sport;
		tcph->dest	= dport;
		tcph->doff	= sizeof(struct tcphdr) / 4;
		tcph->rst = 1;
		tcph->check = ~tcp_v4_check(sizeof(struct tcphdr),
					    src, dst, 0);
		break;
	}
	case IPPROTO_ICMP: {
		struct icmphdr *icmph;

		icmph = skb_put_zero(skb, sizeof(struct icmphdr));
		icmph->type = ICMP_ECHO;
		icmph->code = 0;
	}
	}

	return skb;
}

3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061
static int inet_rtm_valid_getroute_req(struct sk_buff *skb,
				       const struct nlmsghdr *nlh,
				       struct nlattr **tb,
				       struct netlink_ext_ack *extack)
{
	struct rtmsg *rtm;
	int i, err;

	if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*rtm))) {
		NL_SET_ERR_MSG(extack,
			       "ipv4: Invalid header for route get request");
		return -EINVAL;
	}

	if (!netlink_strict_get_check(skb))
3062 3063
		return nlmsg_parse_deprecated(nlh, sizeof(*rtm), tb, RTA_MAX,
					      rtm_ipv4_policy, extack);
3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080

	rtm = nlmsg_data(nlh);
	if ((rtm->rtm_src_len && rtm->rtm_src_len != 32) ||
	    (rtm->rtm_dst_len && rtm->rtm_dst_len != 32) ||
	    rtm->rtm_table || rtm->rtm_protocol ||
	    rtm->rtm_scope || rtm->rtm_type) {
		NL_SET_ERR_MSG(extack, "ipv4: Invalid values in header for route get request");
		return -EINVAL;
	}

	if (rtm->rtm_flags & ~(RTM_F_NOTIFY |
			       RTM_F_LOOKUP_TABLE |
			       RTM_F_FIB_MATCH)) {
		NL_SET_ERR_MSG(extack, "ipv4: Unsupported rtm_flags for route get request");
		return -EINVAL;
	}

3081 3082
	err = nlmsg_parse_deprecated_strict(nlh, sizeof(*rtm), tb, RTA_MAX,
					    rtm_ipv4_policy, extack);
3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115
	if (err)
		return err;

	if ((tb[RTA_SRC] && !rtm->rtm_src_len) ||
	    (tb[RTA_DST] && !rtm->rtm_dst_len)) {
		NL_SET_ERR_MSG(extack, "ipv4: rtm_src_len and rtm_dst_len must be 32 for IPv4");
		return -EINVAL;
	}

	for (i = 0; i <= RTA_MAX; i++) {
		if (!tb[i])
			continue;

		switch (i) {
		case RTA_IIF:
		case RTA_OIF:
		case RTA_SRC:
		case RTA_DST:
		case RTA_IP_PROTO:
		case RTA_SPORT:
		case RTA_DPORT:
		case RTA_MARK:
		case RTA_UID:
			break;
		default:
			NL_SET_ERR_MSG(extack, "ipv4: Unsupported attribute in route get request");
			return -EINVAL;
		}
	}

	return 0;
}

3116 3117
static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
			     struct netlink_ext_ack *extack)
L
Linus Torvalds 已提交
3118
{
3119
	struct net *net = sock_net(in_skb->sk);
3120
	struct nlattr *tb[RTA_MAX+1];
3121 3122
	u32 table_id = RT_TABLE_MAIN;
	__be16 sport = 0, dport = 0;
3123
	struct fib_result res = {};
3124
	u8 ip_proto = IPPROTO_UDP;
L
Linus Torvalds 已提交
3125
	struct rtable *rt = NULL;
3126 3127
	struct sk_buff *skb;
	struct rtmsg *rtm;
3128
	struct flowi4 fl4 = {};
3129 3130
	__be32 dst = 0;
	__be32 src = 0;
3131
	kuid_t uid;
3132
	u32 iif;
3133
	int err;
E
Eric Dumazet 已提交
3134
	int mark;
L
Linus Torvalds 已提交
3135

3136
	err = inet_rtm_valid_getroute_req(in_skb, nlh, tb, extack);
3137
	if (err < 0)
3138
		return err;
3139 3140

	rtm = nlmsg_data(nlh);
3141 3142
	src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0;
	dst = tb[RTA_DST] ? nla_get_in_addr(tb[RTA_DST]) : 0;
3143
	iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
E
Eric Dumazet 已提交
3144
	mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
3145 3146 3147 3148
	if (tb[RTA_UID])
		uid = make_kuid(current_user_ns(), nla_get_u32(tb[RTA_UID]));
	else
		uid = (iif ? INVALID_UID : current_uid());
L
Linus Torvalds 已提交
3149

3150 3151
	if (tb[RTA_IP_PROTO]) {
		err = rtm_getroute_parse_ip_proto(tb[RTA_IP_PROTO],
3152
						  &ip_proto, AF_INET, extack);
3153 3154 3155
		if (err)
			return err;
	}
3156

3157 3158
	if (tb[RTA_SPORT])
		sport = nla_get_be16(tb[RTA_SPORT]);
3159

3160 3161 3162 3163 3164 3165
	if (tb[RTA_DPORT])
		dport = nla_get_be16(tb[RTA_DPORT]);

	skb = inet_rtm_getroute_build_skb(src, dst, ip_proto, sport, dport);
	if (!skb)
		return -ENOBUFS;
3166

3167 3168 3169 3170 3171
	fl4.daddr = dst;
	fl4.saddr = src;
	fl4.flowi4_tos = rtm->rtm_tos;
	fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
	fl4.flowi4_mark = mark;
3172
	fl4.flowi4_uid = uid;
3173 3174 3175 3176 3177
	if (sport)
		fl4.fl4_sport = sport;
	if (dport)
		fl4.fl4_dport = dport;
	fl4.flowi4_proto = ip_proto;
3178

3179 3180
	rcu_read_lock();

L
Linus Torvalds 已提交
3181
	if (iif) {
3182 3183
		struct net_device *dev;

3184
		dev = dev_get_by_index_rcu(net, iif);
3185
		if (!dev) {
3186
			err = -ENODEV;
3187
			goto errout_rcu;
3188 3189
		}

3190
		fl4.flowi4_iif = iif; /* for rt_fill_info */
L
Linus Torvalds 已提交
3191
		skb->dev	= dev;
E
Eric Dumazet 已提交
3192
		skb->mark	= mark;
3193 3194
		err = ip_route_input_rcu(skb, dst, src, rtm->rtm_tos,
					 dev, &res);
3195

E
Eric Dumazet 已提交
3196
		rt = skb_rtable(skb);
3197 3198
		if (err == 0 && rt->dst.error)
			err = -rt->dst.error;
L
Linus Torvalds 已提交
3199
	} else {
3200
		fl4.flowi4_iif = LOOPBACK_IFINDEX;
3201
		skb->dev = net->loopback_dev;
3202
		rt = ip_route_output_key_hash_rcu(net, &fl4, &res, skb);
3203 3204 3205
		err = 0;
		if (IS_ERR(rt))
			err = PTR_ERR(rt);
3206 3207
		else
			skb_dst_set(skb, &rt->dst);
L
Linus Torvalds 已提交
3208
	}
3209

L
Linus Torvalds 已提交
3210
	if (err)
3211
		goto errout_rcu;
L
Linus Torvalds 已提交
3212 3213 3214 3215

	if (rtm->rtm_flags & RTM_F_NOTIFY)
		rt->rt_flags |= RTCF_NOTIFY;

3216
	if (rtm->rtm_flags & RTM_F_LOOKUP_TABLE)
3217
		table_id = res.table ? res.table->tb_id : 0;
3218

3219 3220 3221 3222 3223 3224
	/* reset skb for netlink reply msg */
	skb_trim(skb, 0);
	skb_reset_network_header(skb);
	skb_reset_transport_header(skb);
	skb_reset_mac_header(skb);

3225 3226 3227 3228 3229
	if (rtm->rtm_flags & RTM_F_FIB_MATCH) {
		if (!res.fi) {
			err = fib_props[res.type].error;
			if (!err)
				err = -EHOSTUNREACH;
3230
			goto errout_rcu;
3231
		}
3232 3233 3234 3235
		err = fib_dump_info(skb, NETLINK_CB(in_skb).portid,
				    nlh->nlmsg_seq, RTM_NEWROUTE, table_id,
				    rt->rt_type, res.prefix, res.prefixlen,
				    fl4.flowi4_tos, res.fi, 0);
3236
	} else {
3237
		err = rt_fill_info(net, dst, src, rt, table_id, &fl4, skb,
3238 3239
				   NETLINK_CB(in_skb).portid,
				   nlh->nlmsg_seq, 0);
3240
	}
3241
	if (err < 0)
3242
		goto errout_rcu;
L
Linus Torvalds 已提交
3243

3244 3245
	rcu_read_unlock();

3246
	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
L
Linus Torvalds 已提交
3247

3248
errout_free:
3249 3250
	return err;
errout_rcu:
3251
	rcu_read_unlock();
L
Linus Torvalds 已提交
3252
	kfree_skb(skb);
3253
	goto errout_free;
L
Linus Torvalds 已提交
3254 3255 3256 3257
}

void ip_rt_multicast_event(struct in_device *in_dev)
{
3258
	rt_cache_flush(dev_net(in_dev->dev));
L
Linus Torvalds 已提交
3259 3260 3261
}

#ifdef CONFIG_SYSCTL
3262 3263 3264
static int ip_rt_gc_interval __read_mostly  = 60 * HZ;
static int ip_rt_gc_min_interval __read_mostly	= HZ / 2;
static int ip_rt_gc_elasticity __read_mostly	= 8;
3265
static int ip_min_valid_pmtu __read_mostly	= IPV4_MIN_MTU;
3266

3267
static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write,
3268
					void __user *buffer,
L
Linus Torvalds 已提交
3269 3270
					size_t *lenp, loff_t *ppos)
{
3271 3272
	struct net *net = (struct net *)__ctl->extra1;

L
Linus Torvalds 已提交
3273
	if (write) {
3274 3275
		rt_cache_flush(net);
		fnhe_genid_bump(net);
L
Linus Torvalds 已提交
3276
		return 0;
3277
	}
L
Linus Torvalds 已提交
3278 3279 3280 3281

	return -EINVAL;
}

3282
static struct ctl_table ipv4_route_table[] = {
L
Linus Torvalds 已提交
3283 3284 3285 3286 3287
	{
		.procname	= "gc_thresh",
		.data		= &ipv4_dst_ops.gc_thresh,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3288
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3289 3290 3291 3292 3293 3294
	},
	{
		.procname	= "max_size",
		.data		= &ip_rt_max_size,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3295
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3296 3297 3298
	},
	{
		/*  Deprecated. Use gc_min_interval_ms */
3299

L
Linus Torvalds 已提交
3300 3301 3302 3303
		.procname	= "gc_min_interval",
		.data		= &ip_rt_gc_min_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3304
		.proc_handler	= proc_dointvec_jiffies,
L
Linus Torvalds 已提交
3305 3306 3307 3308 3309 3310
	},
	{
		.procname	= "gc_min_interval_ms",
		.data		= &ip_rt_gc_min_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3311
		.proc_handler	= proc_dointvec_ms_jiffies,
L
Linus Torvalds 已提交
3312 3313 3314 3315 3316 3317
	},
	{
		.procname	= "gc_timeout",
		.data		= &ip_rt_gc_timeout,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3318
		.proc_handler	= proc_dointvec_jiffies,
L
Linus Torvalds 已提交
3319
	},
3320 3321 3322 3323 3324 3325 3326
	{
		.procname	= "gc_interval",
		.data		= &ip_rt_gc_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_jiffies,
	},
L
Linus Torvalds 已提交
3327 3328 3329 3330 3331
	{
		.procname	= "redirect_load",
		.data		= &ip_rt_redirect_load,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3332
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3333 3334 3335 3336 3337 3338
	},
	{
		.procname	= "redirect_number",
		.data		= &ip_rt_redirect_number,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3339
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3340 3341 3342 3343 3344 3345
	},
	{
		.procname	= "redirect_silence",
		.data		= &ip_rt_redirect_silence,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3346
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3347 3348 3349 3350 3351 3352
	},
	{
		.procname	= "error_cost",
		.data		= &ip_rt_error_cost,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3353
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3354 3355 3356 3357 3358 3359
	},
	{
		.procname	= "error_burst",
		.data		= &ip_rt_error_burst,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3360
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3361 3362 3363 3364 3365 3366
	},
	{
		.procname	= "gc_elasticity",
		.data		= &ip_rt_gc_elasticity,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3367
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3368 3369 3370 3371 3372 3373
	},
	{
		.procname	= "mtu_expires",
		.data		= &ip_rt_mtu_expires,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3374
		.proc_handler	= proc_dointvec_jiffies,
L
Linus Torvalds 已提交
3375 3376 3377 3378 3379 3380
	},
	{
		.procname	= "min_pmtu",
		.data		= &ip_rt_min_pmtu,
		.maxlen		= sizeof(int),
		.mode		= 0644,
3381 3382
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &ip_min_valid_pmtu,
L
Linus Torvalds 已提交
3383 3384 3385 3386 3387 3388
	},
	{
		.procname	= "min_adv_mss",
		.data		= &ip_rt_min_advmss,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3389
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3390
	},
3391
	{ }
L
Linus Torvalds 已提交
3392
};
3393

3394 3395
static const char ipv4_route_flush_procname[] = "flush";

3396 3397
static struct ctl_table ipv4_route_flush_table[] = {
	{
3398
		.procname	= ipv4_route_flush_procname,
3399 3400
		.maxlen		= sizeof(int),
		.mode		= 0200,
A
Alexey Dobriyan 已提交
3401
		.proc_handler	= ipv4_sysctl_rtcache_flush,
3402
	},
3403
	{ },
3404 3405 3406 3407 3408 3409 3410
};

static __net_init int sysctl_route_net_init(struct net *net)
{
	struct ctl_table *tbl;

	tbl = ipv4_route_flush_table;
3411
	if (!net_eq(net, &init_net)) {
3412
		tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
3413
		if (!tbl)
3414
			goto err_dup;
3415

3416 3417 3418 3419 3420
		/* Don't export non-whitelisted sysctls to unprivileged users */
		if (net->user_ns != &init_user_ns) {
			if (tbl[0].procname != ipv4_route_flush_procname)
				tbl[0].procname = NULL;
		}
3421 3422 3423
	}
	tbl[0].extra1 = net;

3424
	net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
3425
	if (!net->ipv4.route_hdr)
3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449
		goto err_reg;
	return 0;

err_reg:
	if (tbl != ipv4_route_flush_table)
		kfree(tbl);
err_dup:
	return -ENOMEM;
}

static __net_exit void sysctl_route_net_exit(struct net *net)
{
	struct ctl_table *tbl;

	tbl = net->ipv4.route_hdr->ctl_table_arg;
	unregister_net_sysctl_table(net->ipv4.route_hdr);
	BUG_ON(tbl == ipv4_route_flush_table);
	kfree(tbl);
}

static __net_initdata struct pernet_operations sysctl_route_ops = {
	.init = sysctl_route_net_init,
	.exit = sysctl_route_net_exit,
};
L
Linus Torvalds 已提交
3450 3451
#endif

3452
static __net_init int rt_genid_init(struct net *net)
3453
{
3454
	atomic_set(&net->ipv4.rt_genid, 0);
3455
	atomic_set(&net->fnhe_genid, 0);
3456
	atomic_set(&net->ipv4.dev_addr_genid, get_random_int());
3457 3458 3459
	return 0;
}

3460 3461
static __net_initdata struct pernet_operations rt_genid_ops = {
	.init = rt_genid_init,
3462 3463
};

3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479
static int __net_init ipv4_inetpeer_init(struct net *net)
{
	struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);

	if (!bp)
		return -ENOMEM;
	inet_peer_base_init(bp);
	net->ipv4.peers = bp;
	return 0;
}

static void __net_exit ipv4_inetpeer_exit(struct net *net)
{
	struct inet_peer_base *bp = net->ipv4.peers;

	net->ipv4.peers = NULL;
3480
	inetpeer_invalidate_tree(bp);
3481 3482 3483 3484 3485 3486 3487
	kfree(bp);
}

static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
	.init	=	ipv4_inetpeer_init,
	.exit	=	ipv4_inetpeer_exit,
};
3488

3489
#ifdef CONFIG_IP_ROUTE_CLASSID
3490
struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
3491
#endif /* CONFIG_IP_ROUTE_CLASSID */
L
Linus Torvalds 已提交
3492 3493 3494

int __init ip_rt_init(void)
{
3495
	int cpu;
L
Linus Torvalds 已提交
3496

3497 3498
	ip_idents = kmalloc_array(IP_IDENTS_SZ, sizeof(*ip_idents),
				  GFP_KERNEL);
3499 3500 3501 3502 3503
	if (!ip_idents)
		panic("IP: failed to allocate ip_idents\n");

	prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));

3504 3505 3506 3507
	ip_tstamps = kcalloc(IP_IDENTS_SZ, sizeof(*ip_tstamps), GFP_KERNEL);
	if (!ip_tstamps)
		panic("IP: failed to allocate ip_tstamps\n");

3508 3509 3510 3511 3512 3513
	for_each_possible_cpu(cpu) {
		struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);

		INIT_LIST_HEAD(&ul->head);
		spin_lock_init(&ul->lock);
	}
3514
#ifdef CONFIG_IP_ROUTE_CLASSID
3515
	ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
L
Linus Torvalds 已提交
3516 3517 3518 3519
	if (!ip_rt_acct)
		panic("IP: failed to allocate ip_rt_acct\n");
#endif

A
Alexey Dobriyan 已提交
3520 3521
	ipv4_dst_ops.kmem_cachep =
		kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
3522
				  SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
L
Linus Torvalds 已提交
3523

3524 3525
	ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;

3526 3527 3528 3529 3530 3531
	if (dst_entries_init(&ipv4_dst_ops) < 0)
		panic("IP: failed to allocate ipv4_dst_ops counter\n");

	if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
		panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");

3532 3533
	ipv4_dst_ops.gc_thresh = ~0;
	ip_rt_max_size = INT_MAX;
L
Linus Torvalds 已提交
3534 3535 3536 3537

	devinet_init();
	ip_fib_init();

3538
	if (ip_rt_proc_init())
3539
		pr_err("Unable to create route proc files\n");
L
Linus Torvalds 已提交
3540 3541
#ifdef CONFIG_XFRM
	xfrm_init();
3542
	xfrm4_init();
L
Linus Torvalds 已提交
3543
#endif
3544 3545
	rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL,
		      RTNL_FLAG_DOIT_UNLOCKED);
3546

3547 3548 3549
#ifdef CONFIG_SYSCTL
	register_pernet_subsys(&sysctl_route_ops);
#endif
3550
	register_pernet_subsys(&rt_genid_ops);
3551
	register_pernet_subsys(&ipv4_inetpeer_ops);
3552
	return 0;
L
Linus Torvalds 已提交
3553 3554
}

3555
#ifdef CONFIG_SYSCTL
3556 3557 3558 3559 3560 3561
/*
 * We really need to sanitize the damn ipv4 init order, then all
 * this nonsense will go away.
 */
void __init ip_static_sysctl_init(void)
{
3562
	register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);
3563
}
3564
#endif
新手
引导
客服 返回
顶部