blob: f7afcba8b1a14cf2d23e84533430c7e100cc5397 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * ROUTE - implementation of the IP router.
7 *
Jesper Juhl02c30a82005-05-05 16:16:16 -07008 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10 * Alan Cox, <gw4pts@gw4pts.ampr.org>
11 * Linus Torvalds, <Linus.Torvalds@helsinki.fi>
12 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
13 *
14 * Fixes:
15 * Alan Cox : Verify area fixes.
16 * Alan Cox : cli() protects routing changes
17 * Rui Oliveira : ICMP routing table updates
18 * (rco@di.uminho.pt) Routing table insertion and update
19 * Linus Torvalds : Rewrote bits to be sensible
20 * Alan Cox : Added BSD route gw semantics
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090021 * Alan Cox : Super /proc >4K
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 * Alan Cox : MTU in route table
23 * Alan Cox : MSS actually. Also added the window
24 * clamper.
25 * Sam Lantinga : Fixed route matching in rt_del()
26 * Alan Cox : Routing cache support.
27 * Alan Cox : Removed compatibility cruft.
28 * Alan Cox : RTF_REJECT support.
29 * Alan Cox : TCP irtt support.
30 * Jonathan Naylor : Added Metric support.
31 * Miquel van Smoorenburg : BSD API fixes.
32 * Miquel van Smoorenburg : Metrics.
33 * Alan Cox : Use __u32 properly
34 * Alan Cox : Aligned routing errors more closely with BSD
35 * our system is still very different.
36 * Alan Cox : Faster /proc handling
37 * Alexey Kuznetsov : Massive rework to support tree based routing,
38 * routing caches and better behaviour.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090039 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 * Olaf Erb : irtt wasn't being copied right.
41 * Bjorn Ekwall : Kerneld route support.
42 * Alan Cox : Multicast fixed (I hope)
43 * Pavel Krauz : Limited broadcast fixed
44 * Mike McLagan : Routing by source
45 * Alexey Kuznetsov : End of old history. Split to fib.c and
46 * route.c and rewritten from scratch.
47 * Andi Kleen : Load-limit warning messages.
48 * Vitaly E. Lavrov : Transparent proxy revived after year coma.
49 * Vitaly E. Lavrov : Race condition in ip_route_input_slow.
50 * Tobias Ringstrom : Uninitialized res.type in ip_route_output_slow.
51 * Vladimir V. Ivanov : IP rule info (flowid) is really useful.
52 * Marc Boucher : routing by fwmark
53 * Robert Olsson : Added rt_cache statistics
54 * Arnaldo C. Melo : Convert proc stuff to seq_file
Eric Dumazetbb1d23b2005-07-05 15:00:32 -070055 * Eric Dumazet : hashed spinlocks and rt_check_expire() fixes.
Ilia Sotnikovcef26852006-03-25 01:38:55 -080056 * Ilia Sotnikov : Ignore TOS on PMTUD and Redirect
57 * Ilia Sotnikov : Removed TOS from hash calculations
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 *
59 * This program is free software; you can redistribute it and/or
60 * modify it under the terms of the GNU General Public License
61 * as published by the Free Software Foundation; either version
62 * 2 of the License, or (at your option) any later version.
63 */
64
Joe Perchesafd465032012-03-12 07:03:32 +000065#define pr_fmt(fmt) "IPv4: " fmt
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <linux/module.h>
68#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <linux/bitops.h>
70#include <linux/types.h>
71#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#include <linux/mm.h>
73#include <linux/string.h>
74#include <linux/socket.h>
75#include <linux/sockios.h>
76#include <linux/errno.h>
77#include <linux/in.h>
78#include <linux/inet.h>
79#include <linux/netdevice.h>
80#include <linux/proc_fs.h>
81#include <linux/init.h>
82#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070083#include <linux/inetdevice.h>
84#include <linux/igmp.h>
85#include <linux/pkt_sched.h>
86#include <linux/mroute.h>
87#include <linux/netfilter_ipv4.h>
88#include <linux/random.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070089#include <linux/rcupdate.h>
90#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090091#include <linux/slab.h>
Eric Dumazet73f156a2014-06-02 05:26:03 -070092#include <linux/jhash.h>
Herbert Xu352e5122007-11-13 21:34:06 -080093#include <net/dst.h>
Thomas Graf1b7179d2015-07-21 10:43:59 +020094#include <net/dst_metadata.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020095#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070096#include <net/protocol.h>
97#include <net/ip.h>
98#include <net/route.h>
99#include <net/inetpeer.h>
100#include <net/sock.h>
101#include <net/ip_fib.h>
102#include <net/arp.h>
103#include <net/tcp.h>
104#include <net/icmp.h>
105#include <net/xfrm.h>
Roopa Prabhu571e7222015-07-21 10:43:47 +0200106#include <net/lwtunnel.h>
Tom Tucker8d717402006-07-30 20:43:36 -0700107#include <net/netevent.h>
Thomas Graf63f34442007-03-22 11:55:17 -0700108#include <net/rtnetlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109#ifdef CONFIG_SYSCTL
110#include <linux/sysctl.h>
Shan Wei7426a562012-04-18 18:05:46 +0000111#include <linux/kmemleak.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112#endif
David S. Miller6e5714e2011-08-03 20:50:44 -0700113#include <net/secure_seq.h>
Thomas Graf1b7179d2015-07-21 10:43:59 +0200114#include <net/ip_tunnels.h>
David Aherncd2fbe12015-08-13 14:59:01 -0600115#include <net/vrf.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
David S. Miller68a5e3d2011-03-11 20:07:33 -0500117#define RT_FL_TOS(oldflp4) \
Julian Anastasovf61759e2011-12-02 11:39:42 +0000118 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120#define RT_GC_TIMEOUT (300*HZ)
121
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122static int ip_rt_max_size;
Stephen Hemminger817bc4d2008-03-22 17:43:59 -0700123static int ip_rt_redirect_number __read_mostly = 9;
124static int ip_rt_redirect_load __read_mostly = HZ / 50;
125static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
126static int ip_rt_error_cost __read_mostly = HZ;
127static int ip_rt_error_burst __read_mostly = 5 * HZ;
Stephen Hemminger817bc4d2008-03-22 17:43:59 -0700128static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
129static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
130static int ip_rt_min_advmss __read_mostly = 256;
Eric Dumazet9f28a2f2011-12-21 15:47:16 -0500131
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132/*
133 * Interface to generic destination cache.
134 */
135
136static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
David S. Miller0dbaee32010-12-13 12:52:14 -0800137static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
Steffen Klassertebb762f2011-11-23 02:12:51 +0000138static unsigned int ipv4_mtu(const struct dst_entry *dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
140static void ipv4_link_failure(struct sk_buff *skb);
David S. Miller6700c272012-07-17 03:29:28 -0700141static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
142 struct sk_buff *skb, u32 mtu);
143static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,
144 struct sk_buff *skb);
David S. Millercaacf052012-07-31 15:06:50 -0700145static void ipv4_dst_destroy(struct dst_entry *dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
David S. Miller62fa8a82011-01-26 20:51:05 -0800147static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
148{
David S. Miller31248732012-07-10 07:08:18 -0700149 WARN_ON(1);
150 return NULL;
David S. Miller62fa8a82011-01-26 20:51:05 -0800151}
152
David S. Millerf894cbf2012-07-02 21:52:24 -0700153static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
154 struct sk_buff *skb,
155 const void *daddr);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157static struct dst_ops ipv4_dst_ops = {
158 .family = AF_INET,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 .check = ipv4_dst_check,
David S. Miller0dbaee32010-12-13 12:52:14 -0800160 .default_advmss = ipv4_default_advmss,
Steffen Klassertebb762f2011-11-23 02:12:51 +0000161 .mtu = ipv4_mtu,
David S. Miller62fa8a82011-01-26 20:51:05 -0800162 .cow_metrics = ipv4_cow_metrics,
David S. Millercaacf052012-07-31 15:06:50 -0700163 .destroy = ipv4_dst_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 .negative_advice = ipv4_negative_advice,
165 .link_failure = ipv4_link_failure,
166 .update_pmtu = ip_rt_update_pmtu,
David S. Millere47a1852012-07-11 20:55:47 -0700167 .redirect = ip_do_redirect,
Herbert Xu1ac06e02008-05-20 14:32:14 -0700168 .local_out = __ip_local_out,
David S. Millerd3aaeb32011-07-18 00:40:17 -0700169 .neigh_lookup = ipv4_neigh_lookup,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170};
171
172#define ECN_OR_COST(class) TC_PRIO_##class
173
Philippe De Muyter4839c522007-07-09 15:32:57 -0700174const __u8 ip_tos2prio[16] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 TC_PRIO_BESTEFFORT,
Dan Siemon4a2b9c32011-03-15 13:56:07 +0000176 ECN_OR_COST(BESTEFFORT),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 TC_PRIO_BESTEFFORT,
178 ECN_OR_COST(BESTEFFORT),
179 TC_PRIO_BULK,
180 ECN_OR_COST(BULK),
181 TC_PRIO_BULK,
182 ECN_OR_COST(BULK),
183 TC_PRIO_INTERACTIVE,
184 ECN_OR_COST(INTERACTIVE),
185 TC_PRIO_INTERACTIVE,
186 ECN_OR_COST(INTERACTIVE),
187 TC_PRIO_INTERACTIVE_BULK,
188 ECN_OR_COST(INTERACTIVE_BULK),
189 TC_PRIO_INTERACTIVE_BULK,
190 ECN_OR_COST(INTERACTIVE_BULK)
191};
Amir Vadaid4a96862012-04-04 21:33:28 +0000192EXPORT_SYMBOL(ip_tos2prio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Eric Dumazet2f970d82006-01-17 02:54:36 -0800194static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
Christoph Lameter3ed66e92014-04-07 15:39:40 -0700195#define RT_CACHE_STAT_INC(field) raw_cpu_inc(rt_cache_stat.field)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
199{
Eric Dumazet29e75252008-01-31 17:05:09 -0800200 if (*pos)
David S. Miller89aef892012-07-17 11:00:09 -0700201 return NULL;
Eric Dumazet29e75252008-01-31 17:05:09 -0800202 return SEQ_START_TOKEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203}
204
205static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
206{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 ++*pos;
David S. Miller89aef892012-07-17 11:00:09 -0700208 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209}
210
211static void rt_cache_seq_stop(struct seq_file *seq, void *v)
212{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213}
214
215static int rt_cache_seq_show(struct seq_file *seq, void *v)
216{
217 if (v == SEQ_START_TOKEN)
218 seq_printf(seq, "%-127s\n",
219 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
220 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
221 "HHUptod\tSpecDst");
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900222 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223}
224
Stephen Hemmingerf6908082007-03-12 14:34:29 -0700225static const struct seq_operations rt_cache_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 .start = rt_cache_seq_start,
227 .next = rt_cache_seq_next,
228 .stop = rt_cache_seq_stop,
229 .show = rt_cache_seq_show,
230};
231
232static int rt_cache_seq_open(struct inode *inode, struct file *file)
233{
David S. Miller89aef892012-07-17 11:00:09 -0700234 return seq_open(file, &rt_cache_seq_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235}
236
Arjan van de Ven9a321442007-02-12 00:55:35 -0800237static const struct file_operations rt_cache_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 .owner = THIS_MODULE,
239 .open = rt_cache_seq_open,
240 .read = seq_read,
241 .llseek = seq_lseek,
David S. Miller89aef892012-07-17 11:00:09 -0700242 .release = seq_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243};
244
245
246static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
247{
248 int cpu;
249
250 if (*pos == 0)
251 return SEQ_START_TOKEN;
252
Rusty Russell0f23174a2008-12-29 12:23:42 +0000253 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 if (!cpu_possible(cpu))
255 continue;
256 *pos = cpu+1;
Eric Dumazet2f970d82006-01-17 02:54:36 -0800257 return &per_cpu(rt_cache_stat, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 }
259 return NULL;
260}
261
262static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
263{
264 int cpu;
265
Rusty Russell0f23174a2008-12-29 12:23:42 +0000266 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 if (!cpu_possible(cpu))
268 continue;
269 *pos = cpu+1;
Eric Dumazet2f970d82006-01-17 02:54:36 -0800270 return &per_cpu(rt_cache_stat, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 }
272 return NULL;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900273
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274}
275
276static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
277{
278
279}
280
281static int rt_cpu_seq_show(struct seq_file *seq, void *v)
282{
283 struct rt_cache_stat *st = v;
284
285 if (v == SEQ_START_TOKEN) {
Olaf Rempel5bec0032005-04-28 12:16:08 -0700286 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");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 return 0;
288 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
291 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
Eric Dumazetfc66f952010-10-08 06:37:34 +0000292 dst_entries_get_slow(&ipv4_dst_ops),
Eric Dumazet0baf2b32013-10-16 02:49:04 -0700293 0, /* st->in_hit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 st->in_slow_tot,
295 st->in_slow_mc,
296 st->in_no_route,
297 st->in_brd,
298 st->in_martian_dst,
299 st->in_martian_src,
300
Eric Dumazet0baf2b32013-10-16 02:49:04 -0700301 0, /* st->out_hit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 st->out_slow_tot,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900303 st->out_slow_mc,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
Eric Dumazet0baf2b32013-10-16 02:49:04 -0700305 0, /* st->gc_total */
306 0, /* st->gc_ignored */
307 0, /* st->gc_goal_miss */
308 0, /* st->gc_dst_overflow */
309 0, /* st->in_hlist_search */
310 0 /* st->out_hlist_search */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 );
312 return 0;
313}
314
Stephen Hemmingerf6908082007-03-12 14:34:29 -0700315static const struct seq_operations rt_cpu_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 .start = rt_cpu_seq_start,
317 .next = rt_cpu_seq_next,
318 .stop = rt_cpu_seq_stop,
319 .show = rt_cpu_seq_show,
320};
321
322
323static int rt_cpu_seq_open(struct inode *inode, struct file *file)
324{
325 return seq_open(file, &rt_cpu_seq_ops);
326}
327
Arjan van de Ven9a321442007-02-12 00:55:35 -0800328static const struct file_operations rt_cpu_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 .owner = THIS_MODULE,
330 .open = rt_cpu_seq_open,
331 .read = seq_read,
332 .llseek = seq_lseek,
333 .release = seq_release,
334};
335
Patrick McHardyc7066f72011-01-14 13:36:42 +0100336#ifdef CONFIG_IP_ROUTE_CLASSID
Alexey Dobriyana661c412009-11-25 15:40:35 -0800337static int rt_acct_proc_show(struct seq_file *m, void *v)
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800338{
Alexey Dobriyana661c412009-11-25 15:40:35 -0800339 struct ip_rt_acct *dst, *src;
340 unsigned int i, j;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800341
Alexey Dobriyana661c412009-11-25 15:40:35 -0800342 dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
343 if (!dst)
344 return -ENOMEM;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800345
Alexey Dobriyana661c412009-11-25 15:40:35 -0800346 for_each_possible_cpu(i) {
347 src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
348 for (j = 0; j < 256; j++) {
349 dst[j].o_bytes += src[j].o_bytes;
350 dst[j].o_packets += src[j].o_packets;
351 dst[j].i_bytes += src[j].i_bytes;
352 dst[j].i_packets += src[j].i_packets;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800353 }
354 }
Alexey Dobriyana661c412009-11-25 15:40:35 -0800355
356 seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
357 kfree(dst);
358 return 0;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800359}
Alexey Dobriyana661c412009-11-25 15:40:35 -0800360
361static int rt_acct_proc_open(struct inode *inode, struct file *file)
362{
363 return single_open(file, rt_acct_proc_show, NULL);
364}
365
366static const struct file_operations rt_acct_proc_fops = {
367 .owner = THIS_MODULE,
368 .open = rt_acct_proc_open,
369 .read = seq_read,
370 .llseek = seq_lseek,
371 .release = single_release,
372};
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800373#endif
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800374
Denis V. Lunev73b38712008-02-28 20:51:18 -0800375static int __net_init ip_rt_do_proc_init(struct net *net)
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800376{
377 struct proc_dir_entry *pde;
378
Gao fengd4beaa62013-02-18 01:34:54 +0000379 pde = proc_create("rt_cache", S_IRUGO, net->proc_net,
380 &rt_cache_seq_fops);
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800381 if (!pde)
382 goto err1;
383
Wang Chen77020722008-02-28 14:14:25 -0800384 pde = proc_create("rt_cache", S_IRUGO,
385 net->proc_net_stat, &rt_cpu_seq_fops);
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800386 if (!pde)
387 goto err2;
388
Patrick McHardyc7066f72011-01-14 13:36:42 +0100389#ifdef CONFIG_IP_ROUTE_CLASSID
Alexey Dobriyana661c412009-11-25 15:40:35 -0800390 pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800391 if (!pde)
392 goto err3;
393#endif
394 return 0;
395
Patrick McHardyc7066f72011-01-14 13:36:42 +0100396#ifdef CONFIG_IP_ROUTE_CLASSID
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800397err3:
398 remove_proc_entry("rt_cache", net->proc_net_stat);
399#endif
400err2:
401 remove_proc_entry("rt_cache", net->proc_net);
402err1:
403 return -ENOMEM;
404}
Denis V. Lunev73b38712008-02-28 20:51:18 -0800405
406static void __net_exit ip_rt_do_proc_exit(struct net *net)
407{
408 remove_proc_entry("rt_cache", net->proc_net_stat);
409 remove_proc_entry("rt_cache", net->proc_net);
Patrick McHardyc7066f72011-01-14 13:36:42 +0100410#ifdef CONFIG_IP_ROUTE_CLASSID
Denis V. Lunev73b38712008-02-28 20:51:18 -0800411 remove_proc_entry("rt_acct", net->proc_net);
Alexey Dobriyan0a931ac2010-01-17 03:32:50 +0000412#endif
Denis V. Lunev73b38712008-02-28 20:51:18 -0800413}
414
415static struct pernet_operations ip_rt_proc_ops __net_initdata = {
416 .init = ip_rt_do_proc_init,
417 .exit = ip_rt_do_proc_exit,
418};
419
420static int __init ip_rt_proc_init(void)
421{
422 return register_pernet_subsys(&ip_rt_proc_ops);
423}
424
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800425#else
Denis V. Lunev73b38712008-02-28 20:51:18 -0800426static inline int ip_rt_proc_init(void)
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800427{
428 return 0;
429}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430#endif /* CONFIG_PROC_FS */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900431
Eric Dumazet4331deb2012-07-25 05:11:23 +0000432static inline bool rt_is_expired(const struct rtable *rth)
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700433{
fan.duca4c3fc2013-07-30 08:33:53 +0800434 return rth->rt_genid != rt_genid_ipv4(dev_net(rth->dst.dev));
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700435}
436
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +0000437void rt_cache_flush(struct net *net)
Eric Dumazet29e75252008-01-31 17:05:09 -0800438{
fan.duca4c3fc2013-07-30 08:33:53 +0800439 rt_genid_bump_ipv4(net);
Eric Dumazet98376382010-03-08 03:20:00 +0000440}
441
David S. Millerf894cbf2012-07-02 21:52:24 -0700442static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
443 struct sk_buff *skb,
444 const void *daddr)
David Miller3769cff2011-07-11 22:44:24 +0000445{
David S. Millerd3aaeb32011-07-18 00:40:17 -0700446 struct net_device *dev = dst->dev;
447 const __be32 *pkey = daddr;
David S. Miller39232972012-01-26 15:22:32 -0500448 const struct rtable *rt;
David Miller3769cff2011-07-11 22:44:24 +0000449 struct neighbour *n;
450
David S. Miller39232972012-01-26 15:22:32 -0500451 rt = (const struct rtable *) dst;
David S. Millera263b302012-07-02 02:02:15 -0700452 if (rt->rt_gateway)
David S. Miller39232972012-01-26 15:22:32 -0500453 pkey = (const __be32 *) &rt->rt_gateway;
David S. Millerf894cbf2012-07-02 21:52:24 -0700454 else if (skb)
455 pkey = &ip_hdr(skb)->daddr;
David S. Millerd3aaeb32011-07-18 00:40:17 -0700456
David S. Miller80703d22012-02-15 17:48:35 -0500457 n = __ipv4_neigh_lookup(dev, *(__force u32 *)pkey);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700458 if (n)
459 return n;
David Miller32092ec2011-07-25 00:01:41 +0000460 return neigh_create(&arp_tbl, pkey, dev);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700461}
462
Eric Dumazet04ca6972014-07-26 08:58:10 +0200463#define IP_IDENTS_SZ 2048u
Eric Dumazet04ca6972014-07-26 08:58:10 +0200464
Eric Dumazet355b590c2015-05-01 10:37:49 -0700465static atomic_t *ip_idents __read_mostly;
466static u32 *ip_tstamps __read_mostly;
Eric Dumazet04ca6972014-07-26 08:58:10 +0200467
468/* In order to protect privacy, we add a perturbation to identifiers
469 * if one generator is seldom used. This makes hard for an attacker
470 * to infer how many packets were sent between two points in time.
471 */
472u32 ip_idents_reserve(u32 hash, int segs)
473{
Eric Dumazet355b590c2015-05-01 10:37:49 -0700474 u32 *p_tstamp = ip_tstamps + hash % IP_IDENTS_SZ;
475 atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ;
476 u32 old = ACCESS_ONCE(*p_tstamp);
Eric Dumazet04ca6972014-07-26 08:58:10 +0200477 u32 now = (u32)jiffies;
478 u32 delta = 0;
479
Eric Dumazet355b590c2015-05-01 10:37:49 -0700480 if (old != now && cmpxchg(p_tstamp, old, now) == old)
Eric Dumazet04ca6972014-07-26 08:58:10 +0200481 delta = prandom_u32_max(now - old);
482
Eric Dumazet355b590c2015-05-01 10:37:49 -0700483 return atomic_add_return(segs + delta, p_id) - segs;
Eric Dumazet04ca6972014-07-26 08:58:10 +0200484}
485EXPORT_SYMBOL(ip_idents_reserve);
Eric Dumazet73f156a2014-06-02 05:26:03 -0700486
Hannes Frederic Sowab6a77192015-03-25 17:07:44 +0100487void __ip_select_ident(struct net *net, struct iphdr *iph, int segs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488{
Eric Dumazet73f156a2014-06-02 05:26:03 -0700489 static u32 ip_idents_hashrnd __read_mostly;
490 u32 hash, id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Eric Dumazet73f156a2014-06-02 05:26:03 -0700492 net_get_random_once(&ip_idents_hashrnd, sizeof(ip_idents_hashrnd));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
Eric Dumazet04ca6972014-07-26 08:58:10 +0200494 hash = jhash_3words((__force u32)iph->daddr,
495 (__force u32)iph->saddr,
Hannes Frederic Sowab6a77192015-03-25 17:07:44 +0100496 iph->protocol ^ net_hash_mix(net),
Eric Dumazet04ca6972014-07-26 08:58:10 +0200497 ip_idents_hashrnd);
Eric Dumazet73f156a2014-06-02 05:26:03 -0700498 id = ip_idents_reserve(hash, segs);
499 iph->id = htons(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000501EXPORT_SYMBOL(__ip_select_ident);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200503static void __build_flow_key(struct flowi4 *fl4, const struct sock *sk,
David S. Miller4895c772012-07-17 04:19:00 -0700504 const struct iphdr *iph,
505 int oif, u8 tos,
506 u8 prot, u32 mark, int flow_flags)
507{
508 if (sk) {
509 const struct inet_sock *inet = inet_sk(sk);
510
511 oif = sk->sk_bound_dev_if;
512 mark = sk->sk_mark;
513 tos = RT_CONN_FLAGS(sk);
514 prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
515 }
516 flowi4_init_output(fl4, oif, mark, tos,
517 RT_SCOPE_UNIVERSE, prot,
518 flow_flags,
519 iph->daddr, iph->saddr, 0, 0);
520}
521
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200522static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
523 const struct sock *sk)
David S. Miller4895c772012-07-17 04:19:00 -0700524{
525 const struct iphdr *iph = ip_hdr(skb);
526 int oif = skb->dev->ifindex;
527 u8 tos = RT_TOS(iph->tos);
528 u8 prot = iph->protocol;
529 u32 mark = skb->mark;
530
531 __build_flow_key(fl4, sk, iph, oif, tos, prot, mark, 0);
532}
533
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200534static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
David S. Miller4895c772012-07-17 04:19:00 -0700535{
536 const struct inet_sock *inet = inet_sk(sk);
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200537 const struct ip_options_rcu *inet_opt;
David S. Miller4895c772012-07-17 04:19:00 -0700538 __be32 daddr = inet->inet_daddr;
539
540 rcu_read_lock();
541 inet_opt = rcu_dereference(inet->inet_opt);
542 if (inet_opt && inet_opt->opt.srr)
543 daddr = inet_opt->opt.faddr;
544 flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
545 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
546 inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
547 inet_sk_flowi_flags(sk),
548 daddr, inet->inet_saddr, 0, 0);
549 rcu_read_unlock();
550}
551
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200552static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
553 const struct sk_buff *skb)
David S. Miller4895c772012-07-17 04:19:00 -0700554{
555 if (skb)
556 build_skb_flow_key(fl4, skb, sk);
557 else
558 build_sk_flow_key(fl4, sk);
559}
560
David S. Millerc5038a82012-07-31 15:02:02 -0700561static inline void rt_free(struct rtable *rt)
562{
563 call_rcu(&rt->dst.rcu_head, dst_rcu_free);
564}
565
566static DEFINE_SPINLOCK(fnhe_lock);
David S. Miller4895c772012-07-17 04:19:00 -0700567
Timo Teräs2ffae992013-06-27 10:27:05 +0300568static void fnhe_flush_routes(struct fib_nh_exception *fnhe)
569{
570 struct rtable *rt;
571
572 rt = rcu_dereference(fnhe->fnhe_rth_input);
573 if (rt) {
574 RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL);
575 rt_free(rt);
576 }
577 rt = rcu_dereference(fnhe->fnhe_rth_output);
578 if (rt) {
579 RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL);
580 rt_free(rt);
581 }
582}
583
Julian Anastasovaee06da2012-07-18 10:15:35 +0000584static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
David S. Miller4895c772012-07-17 04:19:00 -0700585{
586 struct fib_nh_exception *fnhe, *oldest;
587
588 oldest = rcu_dereference(hash->chain);
589 for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
590 fnhe = rcu_dereference(fnhe->fnhe_next)) {
591 if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
592 oldest = fnhe;
593 }
Timo Teräs2ffae992013-06-27 10:27:05 +0300594 fnhe_flush_routes(oldest);
David S. Miller4895c772012-07-17 04:19:00 -0700595 return oldest;
596}
597
David S. Millerd3a25c92012-07-17 13:23:08 -0700598static inline u32 fnhe_hashfun(__be32 daddr)
599{
Eric Dumazetd546c622014-09-04 08:21:31 -0700600 static u32 fnhe_hashrnd __read_mostly;
David S. Millerd3a25c92012-07-17 13:23:08 -0700601 u32 hval;
602
Eric Dumazetd546c622014-09-04 08:21:31 -0700603 net_get_random_once(&fnhe_hashrnd, sizeof(fnhe_hashrnd));
604 hval = jhash_1word((__force u32) daddr, fnhe_hashrnd);
605 return hash_32(hval, FNHE_HASH_SHIFT);
David S. Millerd3a25c92012-07-17 13:23:08 -0700606}
607
Timo Teräs387aa652013-05-27 20:46:31 +0000608static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnhe)
609{
610 rt->rt_pmtu = fnhe->fnhe_pmtu;
611 rt->dst.expires = fnhe->fnhe_expires;
612
613 if (fnhe->fnhe_gw) {
614 rt->rt_flags |= RTCF_REDIRECTED;
615 rt->rt_gateway = fnhe->fnhe_gw;
616 rt->rt_uses_gateway = 1;
617 }
618}
619
Julian Anastasovaee06da2012-07-18 10:15:35 +0000620static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
621 u32 pmtu, unsigned long expires)
David S. Miller4895c772012-07-17 04:19:00 -0700622{
Julian Anastasovaee06da2012-07-18 10:15:35 +0000623 struct fnhe_hash_bucket *hash;
David S. Miller4895c772012-07-17 04:19:00 -0700624 struct fib_nh_exception *fnhe;
Timo Teräs387aa652013-05-27 20:46:31 +0000625 struct rtable *rt;
626 unsigned int i;
David S. Miller4895c772012-07-17 04:19:00 -0700627 int depth;
Julian Anastasovaee06da2012-07-18 10:15:35 +0000628 u32 hval = fnhe_hashfun(daddr);
David S. Miller4895c772012-07-17 04:19:00 -0700629
David S. Millerc5038a82012-07-31 15:02:02 -0700630 spin_lock_bh(&fnhe_lock);
Julian Anastasovaee06da2012-07-18 10:15:35 +0000631
Eric Dumazetcaa41522014-09-03 22:21:56 -0700632 hash = rcu_dereference(nh->nh_exceptions);
David S. Miller4895c772012-07-17 04:19:00 -0700633 if (!hash) {
Julian Anastasovaee06da2012-07-18 10:15:35 +0000634 hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC);
David S. Miller4895c772012-07-17 04:19:00 -0700635 if (!hash)
Julian Anastasovaee06da2012-07-18 10:15:35 +0000636 goto out_unlock;
Eric Dumazetcaa41522014-09-03 22:21:56 -0700637 rcu_assign_pointer(nh->nh_exceptions, hash);
David S. Miller4895c772012-07-17 04:19:00 -0700638 }
639
David S. Miller4895c772012-07-17 04:19:00 -0700640 hash += hval;
641
642 depth = 0;
643 for (fnhe = rcu_dereference(hash->chain); fnhe;
644 fnhe = rcu_dereference(fnhe->fnhe_next)) {
645 if (fnhe->fnhe_daddr == daddr)
Julian Anastasovaee06da2012-07-18 10:15:35 +0000646 break;
David S. Miller4895c772012-07-17 04:19:00 -0700647 depth++;
648 }
649
Julian Anastasovaee06da2012-07-18 10:15:35 +0000650 if (fnhe) {
651 if (gw)
652 fnhe->fnhe_gw = gw;
653 if (pmtu) {
654 fnhe->fnhe_pmtu = pmtu;
Timo Teräs387aa652013-05-27 20:46:31 +0000655 fnhe->fnhe_expires = max(1UL, expires);
Julian Anastasovaee06da2012-07-18 10:15:35 +0000656 }
Timo Teräs387aa652013-05-27 20:46:31 +0000657 /* Update all cached dsts too */
Timo Teräs2ffae992013-06-27 10:27:05 +0300658 rt = rcu_dereference(fnhe->fnhe_rth_input);
659 if (rt)
660 fill_route_from_fnhe(rt, fnhe);
661 rt = rcu_dereference(fnhe->fnhe_rth_output);
Timo Teräs387aa652013-05-27 20:46:31 +0000662 if (rt)
663 fill_route_from_fnhe(rt, fnhe);
Julian Anastasovaee06da2012-07-18 10:15:35 +0000664 } else {
665 if (depth > FNHE_RECLAIM_DEPTH)
666 fnhe = fnhe_oldest(hash);
667 else {
668 fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
669 if (!fnhe)
670 goto out_unlock;
671
672 fnhe->fnhe_next = hash->chain;
673 rcu_assign_pointer(hash->chain, fnhe);
674 }
Timo Teräs5aad1de2013-05-27 20:46:33 +0000675 fnhe->fnhe_genid = fnhe_genid(dev_net(nh->nh_dev));
Julian Anastasovaee06da2012-07-18 10:15:35 +0000676 fnhe->fnhe_daddr = daddr;
677 fnhe->fnhe_gw = gw;
678 fnhe->fnhe_pmtu = pmtu;
679 fnhe->fnhe_expires = expires;
Timo Teräs387aa652013-05-27 20:46:31 +0000680
681 /* Exception created; mark the cached routes for the nexthop
682 * stale, so anyone caching it rechecks if this exception
683 * applies to them.
684 */
Timo Teräs2ffae992013-06-27 10:27:05 +0300685 rt = rcu_dereference(nh->nh_rth_input);
686 if (rt)
687 rt->dst.obsolete = DST_OBSOLETE_KILL;
688
Timo Teräs387aa652013-05-27 20:46:31 +0000689 for_each_possible_cpu(i) {
690 struct rtable __rcu **prt;
691 prt = per_cpu_ptr(nh->nh_pcpu_rth_output, i);
692 rt = rcu_dereference(*prt);
693 if (rt)
694 rt->dst.obsolete = DST_OBSOLETE_KILL;
695 }
David S. Miller4895c772012-07-17 04:19:00 -0700696 }
David S. Miller4895c772012-07-17 04:19:00 -0700697
David S. Miller4895c772012-07-17 04:19:00 -0700698 fnhe->fnhe_stamp = jiffies;
Julian Anastasovaee06da2012-07-18 10:15:35 +0000699
700out_unlock:
David S. Millerc5038a82012-07-31 15:02:02 -0700701 spin_unlock_bh(&fnhe_lock);
David S. Miller4895c772012-07-17 04:19:00 -0700702}
703
David S. Millerceb33202012-07-17 11:31:28 -0700704static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
705 bool kill_route)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706{
David S. Millere47a1852012-07-11 20:55:47 -0700707 __be32 new_gw = icmp_hdr(skb)->un.gateway;
David S. Miller94206122012-07-11 20:38:08 -0700708 __be32 old_gw = ip_hdr(skb)->saddr;
David S. Millere47a1852012-07-11 20:55:47 -0700709 struct net_device *dev = skb->dev;
David S. Millere47a1852012-07-11 20:55:47 -0700710 struct in_device *in_dev;
David S. Miller4895c772012-07-17 04:19:00 -0700711 struct fib_result res;
David S. Millere47a1852012-07-11 20:55:47 -0700712 struct neighbour *n;
Denis V. Lunev317805b2008-02-28 20:50:06 -0800713 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
David S. Miller94206122012-07-11 20:38:08 -0700715 switch (icmp_hdr(skb)->code & 7) {
716 case ICMP_REDIR_NET:
717 case ICMP_REDIR_NETTOS:
718 case ICMP_REDIR_HOST:
719 case ICMP_REDIR_HOSTTOS:
720 break;
721
722 default:
723 return;
724 }
725
David S. Millere47a1852012-07-11 20:55:47 -0700726 if (rt->rt_gateway != old_gw)
727 return;
728
729 in_dev = __in_dev_get_rcu(dev);
730 if (!in_dev)
731 return;
732
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900733 net = dev_net(dev);
Joe Perches9d4fb272009-11-23 10:41:23 -0800734 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
735 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
736 ipv4_is_zeronet(new_gw))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 goto reject_redirect;
738
739 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
740 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
741 goto reject_redirect;
742 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
743 goto reject_redirect;
744 } else {
Denis V. Lunev317805b2008-02-28 20:50:06 -0800745 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 goto reject_redirect;
747 }
748
David S. Miller4895c772012-07-17 04:19:00 -0700749 n = ipv4_neigh_lookup(&rt->dst, NULL, &new_gw);
WANG Cong2c1a4312014-09-24 17:07:53 -0700750 if (!IS_ERR(n)) {
David S. Millere47a1852012-07-11 20:55:47 -0700751 if (!(n->nud_state & NUD_VALID)) {
752 neigh_event_send(n, NULL);
753 } else {
Andy Gospodarek0eeb0752015-06-23 13:45:37 -0400754 if (fib_lookup(net, fl4, &res, 0) == 0) {
David S. Miller4895c772012-07-17 04:19:00 -0700755 struct fib_nh *nh = &FIB_RES_NH(res);
David S. Miller4895c772012-07-17 04:19:00 -0700756
Julian Anastasovaee06da2012-07-18 10:15:35 +0000757 update_or_create_fnhe(nh, fl4->daddr, new_gw,
758 0, 0);
David S. Miller4895c772012-07-17 04:19:00 -0700759 }
David S. Millerceb33202012-07-17 11:31:28 -0700760 if (kill_route)
761 rt->dst.obsolete = DST_OBSOLETE_KILL;
David S. Millere47a1852012-07-11 20:55:47 -0700762 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
763 }
764 neigh_release(n);
765 }
766 return;
767
768reject_redirect:
769#ifdef CONFIG_IP_ROUTE_VERBOSE
David S. Miller99ee0382012-07-12 07:40:05 -0700770 if (IN_DEV_LOG_MARTIANS(in_dev)) {
771 const struct iphdr *iph = (const struct iphdr *) skb->data;
772 __be32 daddr = iph->daddr;
773 __be32 saddr = iph->saddr;
774
David S. Millere47a1852012-07-11 20:55:47 -0700775 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
776 " Advised path = %pI4 -> %pI4\n",
777 &old_gw, dev->name, &new_gw,
778 &saddr, &daddr);
David S. Miller99ee0382012-07-12 07:40:05 -0700779 }
David S. Millere47a1852012-07-11 20:55:47 -0700780#endif
781 ;
782}
783
David S. Miller4895c772012-07-17 04:19:00 -0700784static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
785{
786 struct rtable *rt;
787 struct flowi4 fl4;
Michal Kubecekf96ef982013-05-28 08:26:49 +0200788 const struct iphdr *iph = (const struct iphdr *) skb->data;
789 int oif = skb->dev->ifindex;
790 u8 tos = RT_TOS(iph->tos);
791 u8 prot = iph->protocol;
792 u32 mark = skb->mark;
David S. Miller4895c772012-07-17 04:19:00 -0700793
794 rt = (struct rtable *) dst;
795
Michal Kubecekf96ef982013-05-28 08:26:49 +0200796 __build_flow_key(&fl4, sk, iph, oif, tos, prot, mark, 0);
David S. Millerceb33202012-07-17 11:31:28 -0700797 __ip_do_redirect(rt, skb, &fl4, true);
David S. Miller4895c772012-07-17 04:19:00 -0700798}
799
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
801{
Eric Dumazetee6b9672008-03-05 18:30:47 -0800802 struct rtable *rt = (struct rtable *)dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 struct dst_entry *ret = dst;
804
805 if (rt) {
Timo Teräsd11a4dc2010-03-18 23:20:20 +0000806 if (dst->obsolete > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 ip_rt_put(rt);
808 ret = NULL;
David S. Miller59436342012-07-10 06:58:42 -0700809 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
810 rt->dst.expires) {
David S. Miller89aef892012-07-17 11:00:09 -0700811 ip_rt_put(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 ret = NULL;
813 }
814 }
815 return ret;
816}
817
818/*
819 * Algorithm:
820 * 1. The first ip_rt_redirect_number redirects are sent
821 * with exponential backoff, then we stop sending them at all,
822 * assuming that the host ignores our redirects.
823 * 2. If we did not see packets requiring redirects
824 * during ip_rt_redirect_silence, we assume that the host
825 * forgot redirected route and start to send redirects again.
826 *
827 * This algorithm is much cheaper and more intelligent than dumb load limiting
828 * in icmp.c.
829 *
830 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
831 * and "frag. need" (breaks PMTU discovery) in icmp.c.
832 */
833
834void ip_rt_send_redirect(struct sk_buff *skb)
835{
Eric Dumazet511c3f92009-06-02 05:14:27 +0000836 struct rtable *rt = skb_rtable(skb);
Eric Dumazet30038fc2009-08-28 23:52:01 -0700837 struct in_device *in_dev;
David S. Miller92d86822011-02-04 15:55:25 -0800838 struct inet_peer *peer;
David S. Miller1d861aa2012-07-10 03:58:16 -0700839 struct net *net;
Eric Dumazet30038fc2009-08-28 23:52:01 -0700840 int log_martians;
David Ahern192132b2015-08-27 16:07:03 -0700841 int vif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
Eric Dumazet30038fc2009-08-28 23:52:01 -0700843 rcu_read_lock();
Changli Gaod8d1f302010-06-10 23:31:35 -0700844 in_dev = __in_dev_get_rcu(rt->dst.dev);
Eric Dumazet30038fc2009-08-28 23:52:01 -0700845 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
846 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 return;
Eric Dumazet30038fc2009-08-28 23:52:01 -0700848 }
849 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
David Ahern192132b2015-08-27 16:07:03 -0700850 vif = vrf_master_ifindex_rcu(rt->dst.dev);
Eric Dumazet30038fc2009-08-28 23:52:01 -0700851 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
David S. Miller1d861aa2012-07-10 03:58:16 -0700853 net = dev_net(rt->dst.dev);
David Ahern192132b2015-08-27 16:07:03 -0700854 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, vif, 1);
David S. Miller92d86822011-02-04 15:55:25 -0800855 if (!peer) {
Julian Anastasove81da0e2012-10-08 11:41:15 +0000856 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
857 rt_nexthop(rt, ip_hdr(skb)->daddr));
David S. Miller92d86822011-02-04 15:55:25 -0800858 return;
859 }
860
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 /* No redirected packets during ip_rt_redirect_silence;
862 * reset the algorithm.
863 */
David S. Miller92d86822011-02-04 15:55:25 -0800864 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
865 peer->rate_tokens = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
867 /* Too many ignored redirects; do not send anything
Changli Gaod8d1f302010-06-10 23:31:35 -0700868 * set dst.rate_last to the last seen redirected packet.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 */
David S. Miller92d86822011-02-04 15:55:25 -0800870 if (peer->rate_tokens >= ip_rt_redirect_number) {
871 peer->rate_last = jiffies;
David S. Miller1d861aa2012-07-10 03:58:16 -0700872 goto out_put_peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 }
874
875 /* Check for load limit; set rate_last to the latest sent
876 * redirect.
877 */
David S. Miller92d86822011-02-04 15:55:25 -0800878 if (peer->rate_tokens == 0 ||
Li Yewang14fb8a72006-12-18 00:26:35 -0800879 time_after(jiffies,
David S. Miller92d86822011-02-04 15:55:25 -0800880 (peer->rate_last +
881 (ip_rt_redirect_load << peer->rate_tokens)))) {
Julian Anastasove81da0e2012-10-08 11:41:15 +0000882 __be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);
883
884 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
David S. Miller92d86822011-02-04 15:55:25 -0800885 peer->rate_last = jiffies;
886 ++peer->rate_tokens;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887#ifdef CONFIG_IP_ROUTE_VERBOSE
Eric Dumazet30038fc2009-08-28 23:52:01 -0700888 if (log_martians &&
Joe Perchese87cc472012-05-13 21:56:26 +0000889 peer->rate_tokens == ip_rt_redirect_number)
890 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
David S. Miller92101b32012-07-23 16:29:00 -0700891 &ip_hdr(skb)->saddr, inet_iif(skb),
Julian Anastasove81da0e2012-10-08 11:41:15 +0000892 &ip_hdr(skb)->daddr, &gw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893#endif
894 }
David S. Miller1d861aa2012-07-10 03:58:16 -0700895out_put_peer:
896 inet_putpeer(peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897}
898
899static int ip_error(struct sk_buff *skb)
900{
David S. Miller251da412012-06-26 16:27:09 -0700901 struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
Eric Dumazet511c3f92009-06-02 05:14:27 +0000902 struct rtable *rt = skb_rtable(skb);
David S. Miller92d86822011-02-04 15:55:25 -0800903 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 unsigned long now;
David S. Miller251da412012-06-26 16:27:09 -0700905 struct net *net;
David S. Miller92d86822011-02-04 15:55:25 -0800906 bool send;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 int code;
908
Eric W. Biederman381c7592015-05-22 04:58:12 -0500909 /* IP on this device is disabled. */
910 if (!in_dev)
911 goto out;
912
David S. Miller251da412012-06-26 16:27:09 -0700913 net = dev_net(rt->dst.dev);
914 if (!IN_DEV_FORWARD(in_dev)) {
915 switch (rt->dst.error) {
916 case EHOSTUNREACH:
917 IP_INC_STATS_BH(net, IPSTATS_MIB_INADDRERRORS);
918 break;
919
920 case ENETUNREACH:
921 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
922 break;
923 }
924 goto out;
925 }
926
Changli Gaod8d1f302010-06-10 23:31:35 -0700927 switch (rt->dst.error) {
Joe Perches4500ebf2011-07-01 09:43:07 +0000928 case EINVAL:
929 default:
930 goto out;
931 case EHOSTUNREACH:
932 code = ICMP_HOST_UNREACH;
933 break;
934 case ENETUNREACH:
935 code = ICMP_NET_UNREACH;
David S. Miller251da412012-06-26 16:27:09 -0700936 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
Joe Perches4500ebf2011-07-01 09:43:07 +0000937 break;
938 case EACCES:
939 code = ICMP_PKT_FILTERED;
940 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 }
942
David Ahern192132b2015-08-27 16:07:03 -0700943 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr,
944 vrf_master_ifindex(skb->dev), 1);
David S. Miller92d86822011-02-04 15:55:25 -0800945
946 send = true;
947 if (peer) {
948 now = jiffies;
949 peer->rate_tokens += now - peer->rate_last;
950 if (peer->rate_tokens > ip_rt_error_burst)
951 peer->rate_tokens = ip_rt_error_burst;
952 peer->rate_last = now;
953 if (peer->rate_tokens >= ip_rt_error_cost)
954 peer->rate_tokens -= ip_rt_error_cost;
955 else
956 send = false;
David S. Miller1d861aa2012-07-10 03:58:16 -0700957 inet_putpeer(peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 }
David S. Miller92d86822011-02-04 15:55:25 -0800959 if (send)
960 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
962out: kfree_skb(skb);
963 return 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900964}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965
Steffen Klassertd851c122012-10-07 22:47:25 +0000966static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967{
Steffen Klassertd851c122012-10-07 22:47:25 +0000968 struct dst_entry *dst = &rt->dst;
David S. Miller4895c772012-07-17 04:19:00 -0700969 struct fib_result res;
David S. Miller2c8cec52011-02-09 20:42:07 -0800970
Steffen Klassertfa1e4922013-01-16 20:58:10 +0000971 if (dst_metric_locked(dst, RTAX_MTU))
972 return;
973
Herbert Xucb6ccf02015-04-28 11:43:15 +0800974 if (ipv4_mtu(dst) < mtu)
Li Wei3cdaa5b2015-01-29 16:09:03 +0800975 return;
976
David S. Miller59436342012-07-10 06:58:42 -0700977 if (mtu < ip_rt_min_pmtu)
978 mtu = ip_rt_min_pmtu;
Eric Dumazetfe6fe792011-06-08 06:07:07 +0000979
Timo Teräsf0162292013-05-27 20:46:32 +0000980 if (rt->rt_pmtu == mtu &&
981 time_before(jiffies, dst->expires - ip_rt_mtu_expires / 2))
982 return;
983
Eric Dumazetc5ae7d42012-08-28 12:33:07 +0000984 rcu_read_lock();
Andy Gospodarek0eeb0752015-06-23 13:45:37 -0400985 if (fib_lookup(dev_net(dst->dev), fl4, &res, 0) == 0) {
David S. Miller4895c772012-07-17 04:19:00 -0700986 struct fib_nh *nh = &FIB_RES_NH(res);
David S. Miller4895c772012-07-17 04:19:00 -0700987
Julian Anastasovaee06da2012-07-18 10:15:35 +0000988 update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
989 jiffies + ip_rt_mtu_expires);
David S. Miller4895c772012-07-17 04:19:00 -0700990 }
Eric Dumazetc5ae7d42012-08-28 12:33:07 +0000991 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992}
993
David S. Miller4895c772012-07-17 04:19:00 -0700994static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
995 struct sk_buff *skb, u32 mtu)
996{
997 struct rtable *rt = (struct rtable *) dst;
998 struct flowi4 fl4;
999
1000 ip_rt_build_flow_key(&fl4, sk, skb);
Steffen Klassertd851c122012-10-07 22:47:25 +00001001 __ip_rt_update_pmtu(rt, &fl4, mtu);
David S. Miller4895c772012-07-17 04:19:00 -07001002}
1003
David S. Miller36393392012-06-14 22:21:46 -07001004void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
1005 int oif, u32 mark, u8 protocol, int flow_flags)
1006{
David S. Miller4895c772012-07-17 04:19:00 -07001007 const struct iphdr *iph = (const struct iphdr *) skb->data;
David S. Miller36393392012-06-14 22:21:46 -07001008 struct flowi4 fl4;
1009 struct rtable *rt;
1010
Lorenzo Colitti1b3c61d2014-05-13 10:17:34 -07001011 if (!mark)
1012 mark = IP4_REPLY_MARK(net, skb->mark);
1013
David S. Miller4895c772012-07-17 04:19:00 -07001014 __build_flow_key(&fl4, NULL, iph, oif,
1015 RT_TOS(iph->tos), protocol, mark, flow_flags);
David S. Miller36393392012-06-14 22:21:46 -07001016 rt = __ip_route_output_key(net, &fl4);
1017 if (!IS_ERR(rt)) {
David S. Miller4895c772012-07-17 04:19:00 -07001018 __ip_rt_update_pmtu(rt, &fl4, mtu);
David S. Miller36393392012-06-14 22:21:46 -07001019 ip_rt_put(rt);
1020 }
1021}
1022EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
1023
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001024static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
David S. Miller36393392012-06-14 22:21:46 -07001025{
David S. Miller4895c772012-07-17 04:19:00 -07001026 const struct iphdr *iph = (const struct iphdr *) skb->data;
1027 struct flowi4 fl4;
1028 struct rtable *rt;
David S. Miller36393392012-06-14 22:21:46 -07001029
David S. Miller4895c772012-07-17 04:19:00 -07001030 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
Lorenzo Colitti1b3c61d2014-05-13 10:17:34 -07001031
1032 if (!fl4.flowi4_mark)
1033 fl4.flowi4_mark = IP4_REPLY_MARK(sock_net(sk), skb->mark);
1034
David S. Miller4895c772012-07-17 04:19:00 -07001035 rt = __ip_route_output_key(sock_net(sk), &fl4);
1036 if (!IS_ERR(rt)) {
1037 __ip_rt_update_pmtu(rt, &fl4, mtu);
1038 ip_rt_put(rt);
1039 }
David S. Miller36393392012-06-14 22:21:46 -07001040}
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001041
1042void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1043{
1044 const struct iphdr *iph = (const struct iphdr *) skb->data;
1045 struct flowi4 fl4;
1046 struct rtable *rt;
Eric Dumazet7f502362014-06-30 01:26:23 -07001047 struct dst_entry *odst = NULL;
Steffen Klassertb44108d2013-01-22 00:01:28 +00001048 bool new = false;
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001049
1050 bh_lock_sock(sk);
Hannes Frederic Sowa482fc602013-11-05 02:24:17 +01001051
1052 if (!ip_sk_accept_pmtu(sk))
1053 goto out;
1054
Eric Dumazet7f502362014-06-30 01:26:23 -07001055 odst = sk_dst_get(sk);
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001056
Eric Dumazet7f502362014-06-30 01:26:23 -07001057 if (sock_owned_by_user(sk) || !odst) {
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001058 __ipv4_sk_update_pmtu(skb, sk, mtu);
1059 goto out;
1060 }
1061
1062 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1063
Eric Dumazet7f502362014-06-30 01:26:23 -07001064 rt = (struct rtable *)odst;
Ian Morris51456b22015-04-03 09:17:26 +01001065 if (odst->obsolete && !odst->ops->check(odst, 0)) {
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001066 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1067 if (IS_ERR(rt))
1068 goto out;
Steffen Klassertb44108d2013-01-22 00:01:28 +00001069
1070 new = true;
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001071 }
1072
1073 __ip_rt_update_pmtu((struct rtable *) rt->dst.path, &fl4, mtu);
1074
Eric Dumazet7f502362014-06-30 01:26:23 -07001075 if (!dst_check(&rt->dst, 0)) {
Steffen Klassertb44108d2013-01-22 00:01:28 +00001076 if (new)
1077 dst_release(&rt->dst);
1078
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001079 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1080 if (IS_ERR(rt))
1081 goto out;
1082
Steffen Klassertb44108d2013-01-22 00:01:28 +00001083 new = true;
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001084 }
1085
Steffen Klassertb44108d2013-01-22 00:01:28 +00001086 if (new)
Eric Dumazet7f502362014-06-30 01:26:23 -07001087 sk_dst_set(sk, &rt->dst);
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001088
1089out:
1090 bh_unlock_sock(sk);
Eric Dumazet7f502362014-06-30 01:26:23 -07001091 dst_release(odst);
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001092}
David S. Miller36393392012-06-14 22:21:46 -07001093EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
David S. Millerf39925d2011-02-09 22:00:16 -08001094
David S. Millerb42597e2012-07-11 21:25:45 -07001095void ipv4_redirect(struct sk_buff *skb, struct net *net,
1096 int oif, u32 mark, u8 protocol, int flow_flags)
1097{
David S. Miller4895c772012-07-17 04:19:00 -07001098 const struct iphdr *iph = (const struct iphdr *) skb->data;
David S. Millerb42597e2012-07-11 21:25:45 -07001099 struct flowi4 fl4;
1100 struct rtable *rt;
1101
David S. Miller4895c772012-07-17 04:19:00 -07001102 __build_flow_key(&fl4, NULL, iph, oif,
1103 RT_TOS(iph->tos), protocol, mark, flow_flags);
David S. Millerb42597e2012-07-11 21:25:45 -07001104 rt = __ip_route_output_key(net, &fl4);
1105 if (!IS_ERR(rt)) {
David S. Millerceb33202012-07-17 11:31:28 -07001106 __ip_do_redirect(rt, skb, &fl4, false);
David S. Millerb42597e2012-07-11 21:25:45 -07001107 ip_rt_put(rt);
1108 }
1109}
1110EXPORT_SYMBOL_GPL(ipv4_redirect);
1111
1112void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1113{
David S. Miller4895c772012-07-17 04:19:00 -07001114 const struct iphdr *iph = (const struct iphdr *) skb->data;
1115 struct flowi4 fl4;
1116 struct rtable *rt;
David S. Millerb42597e2012-07-11 21:25:45 -07001117
David S. Miller4895c772012-07-17 04:19:00 -07001118 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1119 rt = __ip_route_output_key(sock_net(sk), &fl4);
1120 if (!IS_ERR(rt)) {
David S. Millerceb33202012-07-17 11:31:28 -07001121 __ip_do_redirect(rt, skb, &fl4, false);
David S. Miller4895c772012-07-17 04:19:00 -07001122 ip_rt_put(rt);
1123 }
David S. Millerb42597e2012-07-11 21:25:45 -07001124}
1125EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1126
David S. Millerefbc368d2011-12-01 13:38:59 -05001127static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1128{
1129 struct rtable *rt = (struct rtable *) dst;
1130
David S. Millerceb33202012-07-17 11:31:28 -07001131 /* All IPV4 dsts are created with ->obsolete set to the value
1132 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1133 * into this function always.
1134 *
Timo Teräs387aa652013-05-27 20:46:31 +00001135 * When a PMTU/redirect information update invalidates a route,
1136 * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
1137 * DST_OBSOLETE_DEAD by dst_free().
David S. Millerceb33202012-07-17 11:31:28 -07001138 */
Timo Teräs387aa652013-05-27 20:46:31 +00001139 if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
David S. Millerefbc368d2011-12-01 13:38:59 -05001140 return NULL;
Timo Teräsd11a4dc2010-03-18 23:20:20 +00001141 return dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142}
1143
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144static void ipv4_link_failure(struct sk_buff *skb)
1145{
1146 struct rtable *rt;
1147
1148 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1149
Eric Dumazet511c3f92009-06-02 05:14:27 +00001150 rt = skb_rtable(skb);
David S. Miller59436342012-07-10 06:58:42 -07001151 if (rt)
1152 dst_set_expires(&rt->dst, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153}
1154
Eric Dumazetaad88722014-04-15 13:47:15 -04001155static int ip_rt_bug(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156{
Joe Perches91df42b2012-05-15 14:11:54 +00001157 pr_debug("%s: %pI4 -> %pI4, %s\n",
1158 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1159 skb->dev ? skb->dev->name : "?");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 kfree_skb(skb);
Dave Jonesc378a9c2011-05-21 07:16:42 +00001161 WARN_ON(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 return 0;
1163}
1164
1165/*
1166 We do not cache source address of outgoing interface,
1167 because it is used only by IP RR, TS and SRR options,
1168 so that it out of fast path.
1169
1170 BTW remember: "addr" is allowed to be not aligned
1171 in IP options!
1172 */
1173
David S. Miller8e363602011-05-13 17:29:41 -04001174void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175{
Al Viroa61ced52006-09-26 21:27:54 -07001176 __be32 src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177
David S. Millerc7537962010-11-11 17:07:48 -08001178 if (rt_is_output_route(rt))
David S. Millerc5be24f2011-05-13 18:01:21 -04001179 src = ip_hdr(skb)->saddr;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001180 else {
David S. Miller8e363602011-05-13 17:29:41 -04001181 struct fib_result res;
1182 struct flowi4 fl4;
1183 struct iphdr *iph;
1184
1185 iph = ip_hdr(skb);
1186
1187 memset(&fl4, 0, sizeof(fl4));
1188 fl4.daddr = iph->daddr;
1189 fl4.saddr = iph->saddr;
Julian Anastasovb0fe4a32011-07-23 02:00:41 +00001190 fl4.flowi4_tos = RT_TOS(iph->tos);
David S. Miller8e363602011-05-13 17:29:41 -04001191 fl4.flowi4_oif = rt->dst.dev->ifindex;
1192 fl4.flowi4_iif = skb->dev->ifindex;
1193 fl4.flowi4_mark = skb->mark;
David S. Miller5e2b61f2011-03-04 21:47:09 -08001194
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001195 rcu_read_lock();
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04001196 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res, 0) == 0)
David S. Miller436c3b62011-03-24 17:42:21 -07001197 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001198 else
David S. Millerf8126f12012-07-13 05:03:45 -07001199 src = inet_select_addr(rt->dst.dev,
1200 rt_nexthop(rt, iph->daddr),
1201 RT_SCOPE_UNIVERSE);
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001202 rcu_read_unlock();
1203 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 memcpy(addr, &src, 4);
1205}
1206
Patrick McHardyc7066f72011-01-14 13:36:42 +01001207#ifdef CONFIG_IP_ROUTE_CLASSID
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208static void set_class_tag(struct rtable *rt, u32 tag)
1209{
Changli Gaod8d1f302010-06-10 23:31:35 -07001210 if (!(rt->dst.tclassid & 0xFFFF))
1211 rt->dst.tclassid |= tag & 0xFFFF;
1212 if (!(rt->dst.tclassid & 0xFFFF0000))
1213 rt->dst.tclassid |= tag & 0xFFFF0000;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214}
1215#endif
1216
David S. Miller0dbaee32010-12-13 12:52:14 -08001217static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1218{
1219 unsigned int advmss = dst_metric_raw(dst, RTAX_ADVMSS);
1220
1221 if (advmss == 0) {
1222 advmss = max_t(unsigned int, dst->dev->mtu - 40,
1223 ip_rt_min_advmss);
1224 if (advmss > 65535 - 40)
1225 advmss = 65535 - 40;
1226 }
1227 return advmss;
1228}
1229
Steffen Klassertebb762f2011-11-23 02:12:51 +00001230static unsigned int ipv4_mtu(const struct dst_entry *dst)
David S. Millerd33e4552010-12-14 13:01:14 -08001231{
Steffen Klassert261663b2011-11-23 02:14:50 +00001232 const struct rtable *rt = (const struct rtable *) dst;
David S. Miller59436342012-07-10 06:58:42 -07001233 unsigned int mtu = rt->rt_pmtu;
1234
Alexander Duyck98d75c32012-08-27 06:30:01 +00001235 if (!mtu || time_after_eq(jiffies, rt->dst.expires))
David S. Miller59436342012-07-10 06:58:42 -07001236 mtu = dst_metric_raw(dst, RTAX_MTU);
Steffen Klassert618f9bc2011-11-23 02:13:31 +00001237
Steffen Klassert38d523e2013-01-16 20:55:01 +00001238 if (mtu)
Steffen Klassert618f9bc2011-11-23 02:13:31 +00001239 return mtu;
1240
1241 mtu = dst->dev->mtu;
David S. Millerd33e4552010-12-14 13:01:14 -08001242
1243 if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
Julian Anastasov155e8332012-10-08 11:41:18 +00001244 if (rt->rt_uses_gateway && mtu > 576)
David S. Millerd33e4552010-12-14 13:01:14 -08001245 mtu = 576;
1246 }
1247
Eric Dumazet734d2722013-08-18 19:08:07 -07001248 return min_t(unsigned int, mtu, IP_MAX_MTU);
David S. Millerd33e4552010-12-14 13:01:14 -08001249}
1250
David S. Millerf2bb4be2012-07-17 12:20:47 -07001251static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
David S. Miller4895c772012-07-17 04:19:00 -07001252{
Eric Dumazetcaa41522014-09-03 22:21:56 -07001253 struct fnhe_hash_bucket *hash = rcu_dereference(nh->nh_exceptions);
David S. Miller4895c772012-07-17 04:19:00 -07001254 struct fib_nh_exception *fnhe;
1255 u32 hval;
1256
David S. Millerf2bb4be2012-07-17 12:20:47 -07001257 if (!hash)
1258 return NULL;
1259
David S. Millerd3a25c92012-07-17 13:23:08 -07001260 hval = fnhe_hashfun(daddr);
David S. Miller4895c772012-07-17 04:19:00 -07001261
1262 for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1263 fnhe = rcu_dereference(fnhe->fnhe_next)) {
David S. Millerf2bb4be2012-07-17 12:20:47 -07001264 if (fnhe->fnhe_daddr == daddr)
1265 return fnhe;
1266 }
1267 return NULL;
1268}
David S. Miller4895c772012-07-17 04:19:00 -07001269
David S. Millercaacf052012-07-31 15:06:50 -07001270static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001271 __be32 daddr)
1272{
David S. Millercaacf052012-07-31 15:06:50 -07001273 bool ret = false;
1274
David S. Millerc5038a82012-07-31 15:02:02 -07001275 spin_lock_bh(&fnhe_lock);
Julian Anastasovaee06da2012-07-18 10:15:35 +00001276
David S. Millerc5038a82012-07-31 15:02:02 -07001277 if (daddr == fnhe->fnhe_daddr) {
Timo Teräs2ffae992013-06-27 10:27:05 +03001278 struct rtable __rcu **porig;
1279 struct rtable *orig;
Timo Teräs5aad1de2013-05-27 20:46:33 +00001280 int genid = fnhe_genid(dev_net(rt->dst.dev));
Timo Teräs2ffae992013-06-27 10:27:05 +03001281
1282 if (rt_is_input_route(rt))
1283 porig = &fnhe->fnhe_rth_input;
1284 else
1285 porig = &fnhe->fnhe_rth_output;
1286 orig = rcu_dereference(*porig);
Timo Teräs5aad1de2013-05-27 20:46:33 +00001287
1288 if (fnhe->fnhe_genid != genid) {
1289 fnhe->fnhe_genid = genid;
Steffen Klassert13d82bf2012-10-17 21:17:44 +00001290 fnhe->fnhe_gw = 0;
1291 fnhe->fnhe_pmtu = 0;
1292 fnhe->fnhe_expires = 0;
Timo Teräs2ffae992013-06-27 10:27:05 +03001293 fnhe_flush_routes(fnhe);
1294 orig = NULL;
Steffen Klassert13d82bf2012-10-17 21:17:44 +00001295 }
Timo Teräs387aa652013-05-27 20:46:31 +00001296 fill_route_from_fnhe(rt, fnhe);
1297 if (!rt->rt_gateway)
Julian Anastasov155e8332012-10-08 11:41:18 +00001298 rt->rt_gateway = daddr;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001299
Timo Teräs2ffae992013-06-27 10:27:05 +03001300 if (!(rt->dst.flags & DST_NOCACHE)) {
1301 rcu_assign_pointer(*porig, rt);
1302 if (orig)
1303 rt_free(orig);
1304 ret = true;
1305 }
David S. Millerc5038a82012-07-31 15:02:02 -07001306
1307 fnhe->fnhe_stamp = jiffies;
David S. Millerc5038a82012-07-31 15:02:02 -07001308 }
1309 spin_unlock_bh(&fnhe_lock);
David S. Millercaacf052012-07-31 15:06:50 -07001310
1311 return ret;
Eric Dumazet54764bb2012-07-31 01:08:23 +00001312}
1313
David S. Millercaacf052012-07-31 15:06:50 -07001314static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
David S. Millerf2bb4be2012-07-17 12:20:47 -07001315{
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001316 struct rtable *orig, *prev, **p;
David S. Millercaacf052012-07-31 15:06:50 -07001317 bool ret = true;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001318
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001319 if (rt_is_input_route(rt)) {
Eric Dumazet54764bb2012-07-31 01:08:23 +00001320 p = (struct rtable **)&nh->nh_rth_input;
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001321 } else {
Christoph Lameter903ceff2014-08-17 12:30:35 -05001322 p = (struct rtable **)raw_cpu_ptr(nh->nh_pcpu_rth_output);
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001323 }
David S. Millerf2bb4be2012-07-17 12:20:47 -07001324 orig = *p;
1325
1326 prev = cmpxchg(p, orig, rt);
1327 if (prev == orig) {
David S. Millerf2bb4be2012-07-17 12:20:47 -07001328 if (orig)
Eric Dumazet54764bb2012-07-31 01:08:23 +00001329 rt_free(orig);
Julian Anastasov155e8332012-10-08 11:41:18 +00001330 } else
David S. Millercaacf052012-07-31 15:06:50 -07001331 ret = false;
David S. Millercaacf052012-07-31 15:06:50 -07001332
1333 return ret;
1334}
1335
Eric Dumazet5055c372015-01-14 15:17:06 -08001336struct uncached_list {
1337 spinlock_t lock;
1338 struct list_head head;
1339};
1340
1341static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt_uncached_list);
David S. Millercaacf052012-07-31 15:06:50 -07001342
1343static void rt_add_uncached_list(struct rtable *rt)
1344{
Eric Dumazet5055c372015-01-14 15:17:06 -08001345 struct uncached_list *ul = raw_cpu_ptr(&rt_uncached_list);
1346
1347 rt->rt_uncached_list = ul;
1348
1349 spin_lock_bh(&ul->lock);
1350 list_add_tail(&rt->rt_uncached, &ul->head);
1351 spin_unlock_bh(&ul->lock);
David S. Millercaacf052012-07-31 15:06:50 -07001352}
1353
1354static void ipv4_dst_destroy(struct dst_entry *dst)
1355{
1356 struct rtable *rt = (struct rtable *) dst;
1357
Eric Dumazet78df76a2012-08-24 05:40:47 +00001358 if (!list_empty(&rt->rt_uncached)) {
Eric Dumazet5055c372015-01-14 15:17:06 -08001359 struct uncached_list *ul = rt->rt_uncached_list;
1360
1361 spin_lock_bh(&ul->lock);
David S. Millercaacf052012-07-31 15:06:50 -07001362 list_del(&rt->rt_uncached);
Eric Dumazet5055c372015-01-14 15:17:06 -08001363 spin_unlock_bh(&ul->lock);
David S. Millercaacf052012-07-31 15:06:50 -07001364 }
1365}
1366
1367void rt_flush_dev(struct net_device *dev)
1368{
Eric Dumazet5055c372015-01-14 15:17:06 -08001369 struct net *net = dev_net(dev);
1370 struct rtable *rt;
1371 int cpu;
David S. Millercaacf052012-07-31 15:06:50 -07001372
Eric Dumazet5055c372015-01-14 15:17:06 -08001373 for_each_possible_cpu(cpu) {
1374 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
1375
1376 spin_lock_bh(&ul->lock);
1377 list_for_each_entry(rt, &ul->head, rt_uncached) {
David S. Millercaacf052012-07-31 15:06:50 -07001378 if (rt->dst.dev != dev)
1379 continue;
1380 rt->dst.dev = net->loopback_dev;
1381 dev_hold(rt->dst.dev);
1382 dev_put(dev);
1383 }
Eric Dumazet5055c372015-01-14 15:17:06 -08001384 spin_unlock_bh(&ul->lock);
David S. Miller4895c772012-07-17 04:19:00 -07001385 }
1386}
1387
Eric Dumazet4331deb2012-07-25 05:11:23 +00001388static bool rt_cache_valid(const struct rtable *rt)
David S. Millerd2d68ba92012-07-17 12:58:50 -07001389{
Eric Dumazet4331deb2012-07-25 05:11:23 +00001390 return rt &&
1391 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1392 !rt_is_expired(rt);
David S. Millerd2d68ba92012-07-17 12:58:50 -07001393}
1394
David S. Millerf2bb4be2012-07-17 12:20:47 -07001395static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
David S. Miller5e2b61f2011-03-04 21:47:09 -08001396 const struct fib_result *res,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001397 struct fib_nh_exception *fnhe,
David S. Miller982721f2011-02-16 21:44:24 -08001398 struct fib_info *fi, u16 type, u32 itag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399{
David S. Millercaacf052012-07-31 15:06:50 -07001400 bool cached = false;
1401
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 if (fi) {
David S. Miller4895c772012-07-17 04:19:00 -07001403 struct fib_nh *nh = &FIB_RES_NH(*res);
1404
Julian Anastasov155e8332012-10-08 11:41:18 +00001405 if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK) {
David S. Miller4895c772012-07-17 04:19:00 -07001406 rt->rt_gateway = nh->nh_gw;
Julian Anastasov155e8332012-10-08 11:41:18 +00001407 rt->rt_uses_gateway = 1;
1408 }
David S. Miller28605832012-07-17 14:55:59 -07001409 dst_init_metrics(&rt->dst, fi->fib_metrics, true);
Patrick McHardyc7066f72011-01-14 13:36:42 +01001410#ifdef CONFIG_IP_ROUTE_CLASSID
David S. Millerf2bb4be2012-07-17 12:20:47 -07001411 rt->dst.tclassid = nh->nh_tclassid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412#endif
Jiri Benc61adedf2015-08-20 13:56:25 +02001413 rt->dst.lwtstate = lwtstate_get(nh->nh_lwtstate);
David S. Millerc5038a82012-07-31 15:02:02 -07001414 if (unlikely(fnhe))
David S. Millercaacf052012-07-31 15:06:50 -07001415 cached = rt_bind_exception(rt, fnhe, daddr);
David S. Millerc5038a82012-07-31 15:02:02 -07001416 else if (!(rt->dst.flags & DST_NOCACHE))
David S. Millercaacf052012-07-31 15:06:50 -07001417 cached = rt_cache_route(nh, rt);
Julian Anastasov155e8332012-10-08 11:41:18 +00001418 if (unlikely(!cached)) {
1419 /* Routes we intend to cache in nexthop exception or
1420 * FIB nexthop have the DST_NOCACHE bit clear.
1421 * However, if we are unsuccessful at storing this
1422 * route into the cache we really need to set it.
1423 */
1424 rt->dst.flags |= DST_NOCACHE;
1425 if (!rt->rt_gateway)
1426 rt->rt_gateway = daddr;
1427 rt_add_uncached_list(rt);
1428 }
1429 } else
David S. Millercaacf052012-07-31 15:06:50 -07001430 rt_add_uncached_list(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
Patrick McHardyc7066f72011-01-14 13:36:42 +01001432#ifdef CONFIG_IP_ROUTE_CLASSID
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433#ifdef CONFIG_IP_MULTIPLE_TABLES
David S. Miller85b91b02012-07-13 08:21:29 -07001434 set_class_tag(rt, res->tclassid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435#endif
1436 set_class_tag(rt, itag);
1437#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438}
1439
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001440static struct rtable *rt_dst_alloc(struct net_device *dev,
David Ahernd08c4f32015-09-02 13:58:34 -07001441 unsigned int flags, u16 type,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001442 bool nopolicy, bool noxfrm, bool will_cache)
David S. Miller0c4dcd52011-02-17 15:42:37 -08001443{
David Ahernd08c4f32015-09-02 13:58:34 -07001444 struct rtable *rt;
1445
1446 rt = dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
1447 (will_cache ? 0 : (DST_HOST | DST_NOCACHE)) |
1448 (nopolicy ? DST_NOPOLICY : 0) |
1449 (noxfrm ? DST_NOXFRM : 0));
1450
1451 if (rt) {
1452 rt->rt_genid = rt_genid_ipv4(dev_net(dev));
1453 rt->rt_flags = flags;
1454 rt->rt_type = type;
1455 rt->rt_is_input = 0;
1456 rt->rt_iif = 0;
1457 rt->rt_pmtu = 0;
1458 rt->rt_gateway = 0;
1459 rt->rt_uses_gateway = 0;
David Ahernb7503e02015-09-02 13:58:35 -07001460 rt->rt_table_id = 0;
David Ahernd08c4f32015-09-02 13:58:34 -07001461 INIT_LIST_HEAD(&rt->rt_uncached);
1462
1463 rt->dst.output = ip_output;
1464 if (flags & RTCF_LOCAL)
1465 rt->dst.input = ip_local_deliver;
1466 }
1467
1468 return rt;
David S. Miller0c4dcd52011-02-17 15:42:37 -08001469}
1470
Eric Dumazet96d36222010-06-02 19:21:31 +00001471/* called in rcu_read_lock() section */
Al Viro9e12bb22006-09-26 21:25:20 -07001472static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 u8 tos, struct net_device *dev, int our)
1474{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 struct rtable *rth;
Eric Dumazet96d36222010-06-02 19:21:31 +00001476 struct in_device *in_dev = __in_dev_get_rcu(dev);
David Ahernd08c4f32015-09-02 13:58:34 -07001477 unsigned int flags = RTCF_MULTICAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 u32 itag = 0;
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001479 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480
1481 /* Primary sanity checks. */
1482
Ian Morris51456b22015-04-03 09:17:26 +01001483 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 return -EINVAL;
1485
Jan Engelhardt1e637c72008-01-21 03:18:08 -08001486 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
Thomas Grafd0daebc32012-06-12 00:44:01 +00001487 skb->protocol != htons(ETH_P_IP))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 goto e_inval;
1489
Thomas Grafd0daebc32012-06-12 00:44:01 +00001490 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1491 if (ipv4_is_loopback(saddr))
1492 goto e_inval;
1493
Joe Perchesf97c1e02007-12-16 13:45:43 -08001494 if (ipv4_is_zeronet(saddr)) {
1495 if (!ipv4_is_local_multicast(daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 goto e_inval;
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001497 } else {
David S. Miller9e56e382012-06-28 18:54:02 -07001498 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1499 in_dev, &itag);
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001500 if (err < 0)
1501 goto e_err;
1502 }
David Ahernd08c4f32015-09-02 13:58:34 -07001503 if (our)
1504 flags |= RTCF_LOCAL;
1505
1506 rth = rt_dst_alloc(dev_net(dev)->loopback_dev, flags, RTN_MULTICAST,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001507 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 if (!rth)
1509 goto e_nobufs;
1510
Patrick McHardyc7066f72011-01-14 13:36:42 +01001511#ifdef CONFIG_IP_ROUTE_CLASSID
Changli Gaod8d1f302010-06-10 23:31:35 -07001512 rth->dst.tclassid = itag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513#endif
David S. Millercf911662011-04-28 14:31:47 -07001514 rth->dst.output = ip_rt_bug;
David S. Miller9917e1e82012-07-17 14:44:26 -07001515 rth->rt_is_input= 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
1517#ifdef CONFIG_IP_MROUTE
Joe Perchesf97c1e02007-12-16 13:45:43 -08001518 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
Changli Gaod8d1f302010-06-10 23:31:35 -07001519 rth->dst.input = ip_mr_input;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520#endif
1521 RT_CACHE_STAT_INC(in_slow_mc);
1522
David S. Miller89aef892012-07-17 11:00:09 -07001523 skb_dst_set(skb, &rth->dst);
1524 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525
1526e_nobufs:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528e_inval:
Eric Dumazet96d36222010-06-02 19:21:31 +00001529 return -EINVAL;
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001530e_err:
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001531 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532}
1533
1534
1535static void ip_handle_martian_source(struct net_device *dev,
1536 struct in_device *in_dev,
1537 struct sk_buff *skb,
Al Viro9e12bb22006-09-26 21:25:20 -07001538 __be32 daddr,
1539 __be32 saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540{
1541 RT_CACHE_STAT_INC(in_martian_src);
1542#ifdef CONFIG_IP_ROUTE_VERBOSE
1543 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1544 /*
1545 * RFC1812 recommendation, if source is martian,
1546 * the only hint is MAC header.
1547 */
Joe Perches058bd4d2012-03-11 18:36:11 +00001548 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
Harvey Harrison673d57e2008-10-31 00:53:57 -07001549 &daddr, &saddr, dev->name);
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001550 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
Joe Perches058bd4d2012-03-11 18:36:11 +00001551 print_hex_dump(KERN_WARNING, "ll header: ",
1552 DUMP_PREFIX_OFFSET, 16, 1,
1553 skb_mac_header(skb),
1554 dev->hard_header_len, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 }
1556 }
1557#endif
1558}
1559
Eric Dumazet47360222010-06-03 04:13:21 +00001560/* called in rcu_read_lock() section */
Stephen Hemminger5969f712008-04-10 01:52:09 -07001561static int __mkroute_input(struct sk_buff *skb,
David S. Miller982721f2011-02-16 21:44:24 -08001562 const struct fib_result *res,
Stephen Hemminger5969f712008-04-10 01:52:09 -07001563 struct in_device *in_dev,
David S. Millerc6cffba2012-07-26 11:14:38 +00001564 __be32 daddr, __be32 saddr, u32 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565{
Timo Teräs2ffae992013-06-27 10:27:05 +03001566 struct fib_nh_exception *fnhe;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 struct rtable *rth;
1568 int err;
1569 struct in_device *out_dev;
David S. Millerd2d68ba92012-07-17 12:58:50 -07001570 bool do_cache;
Li RongQingfbdc0ad2014-05-22 16:36:55 +08001571 u32 itag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572
1573 /* get a working reference to the output device */
Eric Dumazet47360222010-06-03 04:13:21 +00001574 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
Ian Morris51456b22015-04-03 09:17:26 +01001575 if (!out_dev) {
Joe Perchese87cc472012-05-13 21:56:26 +00001576 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 return -EINVAL;
1578 }
1579
Michael Smith5c04c812011-04-07 04:51:50 +00001580 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
David S. Miller9e56e382012-06-28 18:54:02 -07001581 in_dev->dev, in_dev, &itag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 if (err < 0) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001583 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 saddr);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001585
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 goto cleanup;
1587 }
1588
Julian Anastasove81da0e2012-10-08 11:41:15 +00001589 do_cache = res->fi && !itag;
1590 if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
Hannes Frederic Sowadf4d9252015-01-23 12:01:26 +01001591 skb->protocol == htons(ETH_P_IP) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 (IN_DEV_SHARED_MEDIA(out_dev) ||
Hannes Frederic Sowadf4d9252015-01-23 12:01:26 +01001593 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1594 IPCB(skb)->flags |= IPSKB_DOREDIRECT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
1596 if (skb->protocol != htons(ETH_P_IP)) {
1597 /* Not IP (i.e. ARP). Do not create route, if it is
1598 * invalid for proxy arp. DNAT routes are always valid.
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00001599 *
1600 * Proxy arp feature have been extended to allow, ARP
1601 * replies back to the same interface, to support
1602 * Private VLAN switch technologies. See arp.c.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 */
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00001604 if (out_dev == in_dev &&
1605 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 err = -EINVAL;
1607 goto cleanup;
1608 }
1609 }
1610
Timo Teräs2ffae992013-06-27 10:27:05 +03001611 fnhe = find_exception(&FIB_RES_NH(*res), daddr);
Julian Anastasove81da0e2012-10-08 11:41:15 +00001612 if (do_cache) {
Ian Morris00db4122015-04-03 09:17:27 +01001613 if (fnhe)
Timo Teräs2ffae992013-06-27 10:27:05 +03001614 rth = rcu_dereference(fnhe->fnhe_rth_input);
1615 else
1616 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
1617
Julian Anastasove81da0e2012-10-08 11:41:15 +00001618 if (rt_cache_valid(rth)) {
1619 skb_dst_set_noref(skb, &rth->dst);
1620 goto out;
David S. Millerd2d68ba92012-07-17 12:58:50 -07001621 }
1622 }
David S. Millerf2bb4be2012-07-17 12:20:47 -07001623
David Ahernd08c4f32015-09-02 13:58:34 -07001624 rth = rt_dst_alloc(out_dev->dev, 0, res->type,
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001625 IN_DEV_CONF_GET(in_dev, NOPOLICY),
David S. Millerd2d68ba92012-07-17 12:58:50 -07001626 IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 if (!rth) {
1628 err = -ENOBUFS;
1629 goto cleanup;
1630 }
1631
David S. Miller9917e1e82012-07-17 14:44:26 -07001632 rth->rt_is_input = 1;
David Ahernb7503e02015-09-02 13:58:35 -07001633 if (res->table)
1634 rth->rt_table_id = res->table->tb_id;
Duan Jionga6254862014-02-17 15:23:43 +08001635 RT_CACHE_STAT_INC(in_slow_tot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636
Changli Gaod8d1f302010-06-10 23:31:35 -07001637 rth->dst.input = ip_forward;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638
Timo Teräs2ffae992013-06-27 10:27:05 +03001639 rt_set_nexthop(rth, daddr, res, fnhe, res->fi, res->type, itag);
Jiri Benc61adedf2015-08-20 13:56:25 +02001640 if (lwtunnel_output_redirect(rth->dst.lwtstate)) {
1641 rth->dst.lwtstate->orig_output = rth->dst.output;
Roopa Prabhu8602a622015-07-21 10:43:50 +02001642 rth->dst.output = lwtunnel_output;
Tom Herbert25368622015-08-17 13:42:24 -07001643 }
Jiri Benc61adedf2015-08-20 13:56:25 +02001644 if (lwtunnel_input_redirect(rth->dst.lwtstate)) {
1645 rth->dst.lwtstate->orig_input = rth->dst.input;
Tom Herbert25368622015-08-17 13:42:24 -07001646 rth->dst.input = lwtunnel_input;
1647 }
David S. Millerc6cffba2012-07-26 11:14:38 +00001648 skb_dst_set(skb, &rth->dst);
David S. Millerd2d68ba92012-07-17 12:58:50 -07001649out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 err = 0;
1651 cleanup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 return err;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001653}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654
Stephen Hemminger5969f712008-04-10 01:52:09 -07001655static int ip_mkroute_input(struct sk_buff *skb,
1656 struct fib_result *res,
David S. Miller68a5e3d2011-03-11 20:07:33 -05001657 const struct flowi4 *fl4,
Stephen Hemminger5969f712008-04-10 01:52:09 -07001658 struct in_device *in_dev,
1659 __be32 daddr, __be32 saddr, u32 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661#ifdef CONFIG_IP_ROUTE_MULTIPATH
David S. Millerff3fccb2011-03-10 16:23:24 -08001662 if (res->fi && res->fi->fib_nhs > 1)
David S. Miller1b7fe5932011-03-10 17:01:16 -08001663 fib_select_multipath(res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664#endif
1665
1666 /* create a routing cache entry */
David S. Millerc6cffba2012-07-26 11:14:38 +00001667 return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668}
1669
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670/*
1671 * NOTE. We drop all the packets that has local source
1672 * addresses, because every properly looped back packet
1673 * must have correct destination already attached by output routine.
1674 *
1675 * Such approach solves two big problems:
1676 * 1. Not simplex devices are handled properly.
1677 * 2. IP spoofing attempts are filtered with 100% of guarantee.
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001678 * called with rcu_read_lock()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 */
1680
Al Viro9e12bb22006-09-26 21:25:20 -07001681static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
David S. Millerc10237e2012-06-27 17:05:06 -07001682 u8 tos, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683{
1684 struct fib_result res;
Eric Dumazet96d36222010-06-02 19:21:31 +00001685 struct in_device *in_dev = __in_dev_get_rcu(dev);
Thomas Graf1b7179d2015-07-21 10:43:59 +02001686 struct ip_tunnel_info *tun_info;
David S. Miller68a5e3d2011-03-11 20:07:33 -05001687 struct flowi4 fl4;
Eric Dumazet95c96172012-04-15 05:58:06 +00001688 unsigned int flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 u32 itag = 0;
Eric Dumazet95c96172012-04-15 05:58:06 +00001690 struct rtable *rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 int err = -EINVAL;
Daniel Baluta5e73ea12012-04-15 01:34:41 +00001692 struct net *net = dev_net(dev);
David S. Millerd2d68ba92012-07-17 12:58:50 -07001693 bool do_cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694
1695 /* IP on this device is disabled. */
1696
1697 if (!in_dev)
1698 goto out;
1699
1700 /* Check for the most weird martians, which can be not detected
1701 by fib_lookup.
1702 */
1703
Jiri Benc61adedf2015-08-20 13:56:25 +02001704 tun_info = skb_tunnel_info(skb);
Jiri Benc46fa0622015-08-28 20:48:19 +02001705 if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
Thomas Graf1b7179d2015-07-21 10:43:59 +02001706 fl4.flowi4_tun_key.tun_id = tun_info->key.tun_id;
1707 else
1708 fl4.flowi4_tun_key.tun_id = 0;
Thomas Graff38a9eb2015-07-21 10:43:56 +02001709 skb_dst_drop(skb);
1710
Thomas Grafd0daebc32012-06-12 00:44:01 +00001711 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 goto martian_source;
1713
David S. Millerd2d68ba92012-07-17 12:58:50 -07001714 res.fi = NULL;
David Ahernbde6f9d2015-09-16 10:16:39 -06001715 res.table = NULL;
Andy Walls27a954b2010-10-17 15:11:22 +00001716 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 goto brd_input;
1718
1719 /* Accept zero addresses only to limited broadcast;
1720 * I even do not know to fix it or not. Waiting for complains :-)
1721 */
Joe Perchesf97c1e02007-12-16 13:45:43 -08001722 if (ipv4_is_zeronet(saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 goto martian_source;
1724
Thomas Grafd0daebc32012-06-12 00:44:01 +00001725 if (ipv4_is_zeronet(daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 goto martian_destination;
1727
Eric Dumazet9eb43e72012-08-03 21:27:25 +00001728 /* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
1729 * and call it once if daddr or/and saddr are loopback addresses
1730 */
1731 if (ipv4_is_loopback(daddr)) {
1732 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
Thomas Grafd0daebc32012-06-12 00:44:01 +00001733 goto martian_destination;
Eric Dumazet9eb43e72012-08-03 21:27:25 +00001734 } else if (ipv4_is_loopback(saddr)) {
1735 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
Thomas Grafd0daebc32012-06-12 00:44:01 +00001736 goto martian_source;
1737 }
1738
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 /*
1740 * Now we are ready to route packet.
1741 */
David S. Miller68a5e3d2011-03-11 20:07:33 -05001742 fl4.flowi4_oif = 0;
David Aherncd2fbe12015-08-13 14:59:01 -06001743 fl4.flowi4_iif = vrf_master_ifindex_rcu(dev) ? : dev->ifindex;
David S. Miller68a5e3d2011-03-11 20:07:33 -05001744 fl4.flowi4_mark = skb->mark;
1745 fl4.flowi4_tos = tos;
1746 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
1747 fl4.daddr = daddr;
1748 fl4.saddr = saddr;
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04001749 err = fib_lookup(net, &fl4, &res, 0);
Duan Jiongcd0f0b92014-02-14 18:26:22 +08001750 if (err != 0) {
1751 if (!IN_DEV_FORWARD(in_dev))
1752 err = -EHOSTUNREACH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 goto no_route;
Duan Jiongcd0f0b92014-02-14 18:26:22 +08001754 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755
1756 if (res.type == RTN_BROADCAST)
1757 goto brd_input;
1758
1759 if (res.type == RTN_LOCAL) {
Michael Smith5c04c812011-04-07 04:51:50 +00001760 err = fib_validate_source(skb, saddr, daddr, tos,
Cong Wang0d5edc62014-04-15 16:25:35 -07001761 0, dev, in_dev, &itag);
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001762 if (err < 0)
1763 goto martian_source_keep_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 goto local_input;
1765 }
1766
Duan Jiongcd0f0b92014-02-14 18:26:22 +08001767 if (!IN_DEV_FORWARD(in_dev)) {
1768 err = -EHOSTUNREACH;
David S. Miller251da412012-06-26 16:27:09 -07001769 goto no_route;
Duan Jiongcd0f0b92014-02-14 18:26:22 +08001770 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 if (res.type != RTN_UNICAST)
1772 goto martian_destination;
1773
David S. Miller68a5e3d2011-03-11 20:07:33 -05001774 err = ip_mkroute_input(skb, &res, &fl4, in_dev, daddr, saddr, tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775out: return err;
1776
1777brd_input:
1778 if (skb->protocol != htons(ETH_P_IP))
1779 goto e_inval;
1780
David S. Miller41347dc2012-06-28 04:05:27 -07001781 if (!ipv4_is_zeronet(saddr)) {
David S. Miller9e56e382012-06-28 18:54:02 -07001782 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1783 in_dev, &itag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 if (err < 0)
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001785 goto martian_source_keep_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 }
1787 flags |= RTCF_BROADCAST;
1788 res.type = RTN_BROADCAST;
1789 RT_CACHE_STAT_INC(in_brd);
1790
1791local_input:
David S. Millerd2d68ba92012-07-17 12:58:50 -07001792 do_cache = false;
1793 if (res.fi) {
David S. Millerfe3edf42012-07-23 13:22:20 -07001794 if (!itag) {
Eric Dumazet54764bb2012-07-31 01:08:23 +00001795 rth = rcu_dereference(FIB_RES_NH(res).nh_rth_input);
David S. Millerd2d68ba92012-07-17 12:58:50 -07001796 if (rt_cache_valid(rth)) {
David S. Millerc6cffba2012-07-26 11:14:38 +00001797 skb_dst_set_noref(skb, &rth->dst);
1798 err = 0;
1799 goto out;
David S. Millerd2d68ba92012-07-17 12:58:50 -07001800 }
1801 do_cache = true;
1802 }
1803 }
1804
David Ahernd08c4f32015-09-02 13:58:34 -07001805 rth = rt_dst_alloc(net->loopback_dev, flags | RTCF_LOCAL, res.type,
David S. Millerd2d68ba92012-07-17 12:58:50 -07001806 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 if (!rth)
1808 goto e_nobufs;
1809
Changli Gaod8d1f302010-06-10 23:31:35 -07001810 rth->dst.output= ip_rt_bug;
David S. Millercf911662011-04-28 14:31:47 -07001811#ifdef CONFIG_IP_ROUTE_CLASSID
1812 rth->dst.tclassid = itag;
1813#endif
David S. Miller9917e1e82012-07-17 14:44:26 -07001814 rth->rt_is_input = 1;
David Ahernb7503e02015-09-02 13:58:35 -07001815 if (res.table)
1816 rth->rt_table_id = res.table->tb_id;
Roopa Prabhu571e7222015-07-21 10:43:47 +02001817
Duan Jionga6254862014-02-17 15:23:43 +08001818 RT_CACHE_STAT_INC(in_slow_tot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 if (res.type == RTN_UNREACHABLE) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001820 rth->dst.input= ip_error;
1821 rth->dst.error= -err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 rth->rt_flags &= ~RTCF_LOCAL;
1823 }
Alexei Starovoitovdcdfdf52013-11-19 19:12:34 -08001824 if (do_cache) {
1825 if (unlikely(!rt_cache_route(&FIB_RES_NH(res), rth))) {
1826 rth->dst.flags |= DST_NOCACHE;
1827 rt_add_uncached_list(rth);
1828 }
1829 }
David S. Miller89aef892012-07-17 11:00:09 -07001830 skb_dst_set(skb, &rth->dst);
David S. Millerb23dd4f2011-03-02 14:31:35 -08001831 err = 0;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001832 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833
1834no_route:
1835 RT_CACHE_STAT_INC(in_no_route);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 res.type = RTN_UNREACHABLE;
Nicolas Cavallarifa19c2b02014-10-30 10:09:53 +01001837 res.fi = NULL;
David Ahernbde6f9d2015-09-16 10:16:39 -06001838 res.table = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 goto local_input;
1840
1841 /*
1842 * Do not cache martian addresses: they should be logged (RFC1812)
1843 */
1844martian_destination:
1845 RT_CACHE_STAT_INC(in_martian_dst);
1846#ifdef CONFIG_IP_ROUTE_VERBOSE
Joe Perchese87cc472012-05-13 21:56:26 +00001847 if (IN_DEV_LOG_MARTIANS(in_dev))
1848 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
1849 &daddr, &saddr, dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850#endif
Dietmar Eggemann2c2910a2005-06-28 13:06:23 -07001851
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852e_inval:
1853 err = -EINVAL;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001854 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855
1856e_nobufs:
1857 err = -ENOBUFS;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001858 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859
1860martian_source:
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001861 err = -EINVAL;
1862martian_source_keep_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001864 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865}
1866
David S. Millerc6cffba2012-07-26 11:14:38 +00001867int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1868 u8 tos, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869{
Eric Dumazet96d36222010-06-02 19:21:31 +00001870 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871
Eric Dumazet96d36222010-06-02 19:21:31 +00001872 rcu_read_lock();
1873
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 /* Multicast recognition logic is moved from route cache to here.
1875 The problem was that too many Ethernet cards have broken/missing
1876 hardware multicast filters :-( As result the host on multicasting
1877 network acquires a lot of useless route cache entries, sort of
1878 SDR messages from all the world. Now we try to get rid of them.
1879 Really, provided software IP multicast filter is organized
1880 reasonably (at least, hashed), it does not result in a slowdown
1881 comparing with route cache reject entries.
1882 Note, that multicast routers are not affected, because
1883 route cache entry is created eventually.
1884 */
Joe Perchesf97c1e02007-12-16 13:45:43 -08001885 if (ipv4_is_multicast(daddr)) {
Eric Dumazet96d36222010-06-02 19:21:31 +00001886 struct in_device *in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887
Eric Dumazet96d36222010-06-02 19:21:31 +00001888 if (in_dev) {
David S. Millerdbdd9a52011-03-10 16:34:38 -08001889 int our = ip_check_mc_rcu(in_dev, daddr, saddr,
1890 ip_hdr(skb)->protocol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 if (our
1892#ifdef CONFIG_IP_MROUTE
Joe Perches9d4fb272009-11-23 10:41:23 -08001893 ||
1894 (!ipv4_is_local_multicast(daddr) &&
1895 IN_DEV_MFORWARD(in_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896#endif
Joe Perches9d4fb272009-11-23 10:41:23 -08001897 ) {
Eric Dumazet96d36222010-06-02 19:21:31 +00001898 int res = ip_route_input_mc(skb, daddr, saddr,
1899 tos, dev, our);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 rcu_read_unlock();
Eric Dumazet96d36222010-06-02 19:21:31 +00001901 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 }
1903 }
1904 rcu_read_unlock();
1905 return -EINVAL;
1906 }
David S. Millerc10237e2012-06-27 17:05:06 -07001907 res = ip_route_input_slow(skb, daddr, saddr, tos, dev);
Eric Dumazet96d36222010-06-02 19:21:31 +00001908 rcu_read_unlock();
1909 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910}
David S. Millerc6cffba2012-07-26 11:14:38 +00001911EXPORT_SYMBOL(ip_route_input_noref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001913/* called with rcu_read_lock() */
David S. Miller982721f2011-02-16 21:44:24 -08001914static struct rtable *__mkroute_output(const struct fib_result *res,
David Miller1a00fee2012-07-01 02:02:56 +00001915 const struct flowi4 *fl4, int orig_oif,
Julian Anastasovf61759e2011-12-02 11:39:42 +00001916 struct net_device *dev_out,
David S. Miller5ada5522011-02-17 15:29:00 -08001917 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918{
David S. Miller982721f2011-02-16 21:44:24 -08001919 struct fib_info *fi = res->fi;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001920 struct fib_nh_exception *fnhe;
David S. Miller5ada5522011-02-17 15:29:00 -08001921 struct in_device *in_dev;
David S. Miller982721f2011-02-16 21:44:24 -08001922 u16 type = res->type;
David S. Miller5ada5522011-02-17 15:29:00 -08001923 struct rtable *rth;
Julian Anastasovc92b9652012-10-08 11:41:19 +00001924 bool do_cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925
Thomas Grafd0daebc32012-06-12 00:44:01 +00001926 in_dev = __in_dev_get_rcu(dev_out);
1927 if (!in_dev)
David S. Miller5ada5522011-02-17 15:29:00 -08001928 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929
Thomas Grafd0daebc32012-06-12 00:44:01 +00001930 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1931 if (ipv4_is_loopback(fl4->saddr) && !(dev_out->flags & IFF_LOOPBACK))
1932 return ERR_PTR(-EINVAL);
1933
David S. Miller68a5e3d2011-03-11 20:07:33 -05001934 if (ipv4_is_lbcast(fl4->daddr))
David S. Miller982721f2011-02-16 21:44:24 -08001935 type = RTN_BROADCAST;
David S. Miller68a5e3d2011-03-11 20:07:33 -05001936 else if (ipv4_is_multicast(fl4->daddr))
David S. Miller982721f2011-02-16 21:44:24 -08001937 type = RTN_MULTICAST;
David S. Miller68a5e3d2011-03-11 20:07:33 -05001938 else if (ipv4_is_zeronet(fl4->daddr))
David S. Miller5ada5522011-02-17 15:29:00 -08001939 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940
1941 if (dev_out->flags & IFF_LOOPBACK)
1942 flags |= RTCF_LOCAL;
1943
Julian Anastasov63617422012-11-22 23:04:14 +02001944 do_cache = true;
David S. Miller982721f2011-02-16 21:44:24 -08001945 if (type == RTN_BROADCAST) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 flags |= RTCF_BROADCAST | RTCF_LOCAL;
David S. Miller982721f2011-02-16 21:44:24 -08001947 fi = NULL;
1948 } else if (type == RTN_MULTICAST) {
Eric Dumazetdd28d1a2010-09-29 11:53:50 +00001949 flags |= RTCF_MULTICAST | RTCF_LOCAL;
David S. Miller813b3b52011-04-28 14:48:42 -07001950 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
1951 fl4->flowi4_proto))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 flags &= ~RTCF_LOCAL;
Julian Anastasov63617422012-11-22 23:04:14 +02001953 else
1954 do_cache = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 /* If multicast route do not exist use
Eric Dumazetdd28d1a2010-09-29 11:53:50 +00001956 * default one, but do not gateway in this case.
1957 * Yes, it is hack.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 */
David S. Miller982721f2011-02-16 21:44:24 -08001959 if (fi && res->prefixlen < 4)
1960 fi = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 }
1962
David S. Millerf2bb4be2012-07-17 12:20:47 -07001963 fnhe = NULL;
Julian Anastasov63617422012-11-22 23:04:14 +02001964 do_cache &= fi != NULL;
1965 if (do_cache) {
David S. Millerc5038a82012-07-31 15:02:02 -07001966 struct rtable __rcu **prth;
Julian Anastasovc92b9652012-10-08 11:41:19 +00001967 struct fib_nh *nh = &FIB_RES_NH(*res);
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001968
Julian Anastasovc92b9652012-10-08 11:41:19 +00001969 fnhe = find_exception(nh, fl4->daddr);
David S. Millerc5038a82012-07-31 15:02:02 -07001970 if (fnhe)
Timo Teräs2ffae992013-06-27 10:27:05 +03001971 prth = &fnhe->fnhe_rth_output;
Julian Anastasovc92b9652012-10-08 11:41:19 +00001972 else {
1973 if (unlikely(fl4->flowi4_flags &
1974 FLOWI_FLAG_KNOWN_NH &&
1975 !(nh->nh_gw &&
1976 nh->nh_scope == RT_SCOPE_LINK))) {
1977 do_cache = false;
1978 goto add;
1979 }
Christoph Lameter903ceff2014-08-17 12:30:35 -05001980 prth = raw_cpu_ptr(nh->nh_pcpu_rth_output);
Julian Anastasovc92b9652012-10-08 11:41:19 +00001981 }
David S. Millerc5038a82012-07-31 15:02:02 -07001982 rth = rcu_dereference(*prth);
1983 if (rt_cache_valid(rth)) {
1984 dst_hold(&rth->dst);
1985 return rth;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001986 }
1987 }
Julian Anastasovc92b9652012-10-08 11:41:19 +00001988
1989add:
David Ahernd08c4f32015-09-02 13:58:34 -07001990 rth = rt_dst_alloc(dev_out, flags, type,
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001991 IN_DEV_CONF_GET(in_dev, NOPOLICY),
David S. Millerf2bb4be2012-07-17 12:20:47 -07001992 IN_DEV_CONF_GET(in_dev, NOXFRM),
Julian Anastasovc92b9652012-10-08 11:41:19 +00001993 do_cache);
Dimitris Michailidis8391d072010-10-07 14:48:38 +00001994 if (!rth)
David S. Miller5ada5522011-02-17 15:29:00 -08001995 return ERR_PTR(-ENOBUFS);
Dimitris Michailidis8391d072010-10-07 14:48:38 +00001996
David S. Miller13378ca2012-07-23 13:57:45 -07001997 rth->rt_iif = orig_oif ? : 0;
David Ahernb7503e02015-09-02 13:58:35 -07001998 if (res->table)
1999 rth->rt_table_id = res->table->tb_id;
2000
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 RT_CACHE_STAT_INC(out_slow_tot);
2002
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002004 if (flags & RTCF_LOCAL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 !(dev_out->flags & IFF_LOOPBACK)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002006 rth->dst.output = ip_mc_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 RT_CACHE_STAT_INC(out_slow_mc);
2008 }
2009#ifdef CONFIG_IP_MROUTE
David S. Miller982721f2011-02-16 21:44:24 -08002010 if (type == RTN_MULTICAST) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 if (IN_DEV_MFORWARD(in_dev) &&
David S. Miller813b3b52011-04-28 14:48:42 -07002012 !ipv4_is_local_multicast(fl4->daddr)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002013 rth->dst.input = ip_mr_input;
2014 rth->dst.output = ip_mc_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 }
2016 }
2017#endif
2018 }
2019
David S. Millerf2bb4be2012-07-17 12:20:47 -07002020 rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0);
Jiri Benc61adedf2015-08-20 13:56:25 +02002021 if (lwtunnel_output_redirect(rth->dst.lwtstate))
Robert Shearman0335f5b2015-08-03 17:39:21 +01002022 rth->dst.output = lwtunnel_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023
David S. Miller5ada5522011-02-17 15:29:00 -08002024 return rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025}
2026
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027/*
2028 * Major route resolver routine.
2029 */
2030
David S. Miller89aef892012-07-17 11:00:09 -07002031struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *fl4)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 struct net_device *dev_out = NULL;
Julian Anastasovf61759e2011-12-02 11:39:42 +00002034 __u8 tos = RT_FL_TOS(fl4);
David S. Miller813b3b52011-04-28 14:48:42 -07002035 unsigned int flags = 0;
2036 struct fib_result res;
David S. Miller5ada5522011-02-17 15:29:00 -08002037 struct rtable *rth;
David S. Miller813b3b52011-04-28 14:48:42 -07002038 int orig_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039
David S. Miller85b91b02012-07-13 08:21:29 -07002040 res.tclassid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 res.fi = NULL;
David S. Miller8b96d222012-06-11 02:01:56 -07002042 res.table = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043
David S. Miller813b3b52011-04-28 14:48:42 -07002044 orig_oif = fl4->flowi4_oif;
2045
Pavel Emelyanov1fb94892012-08-08 21:53:36 +00002046 fl4->flowi4_iif = LOOPBACK_IFINDEX;
David S. Miller813b3b52011-04-28 14:48:42 -07002047 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
2048 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
2049 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
David S. Miller44713b62011-03-04 21:24:47 -08002050
David S. Miller010c2702011-02-17 15:37:09 -08002051 rcu_read_lock();
David S. Miller813b3b52011-04-28 14:48:42 -07002052 if (fl4->saddr) {
David S. Millerb23dd4f2011-03-02 14:31:35 -08002053 rth = ERR_PTR(-EINVAL);
David S. Miller813b3b52011-04-28 14:48:42 -07002054 if (ipv4_is_multicast(fl4->saddr) ||
2055 ipv4_is_lbcast(fl4->saddr) ||
2056 ipv4_is_zeronet(fl4->saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 goto out;
2058
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 /* I removed check for oif == dev_out->oif here.
2060 It was wrong for two reasons:
Denis V. Lunev1ab35272008-01-22 22:04:30 -08002061 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2062 is assigned to multiple interfaces.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 2. Moreover, we are allowed to send packets with saddr
2064 of another iface. --ANK
2065 */
2066
David S. Miller813b3b52011-04-28 14:48:42 -07002067 if (fl4->flowi4_oif == 0 &&
2068 (ipv4_is_multicast(fl4->daddr) ||
2069 ipv4_is_lbcast(fl4->daddr))) {
Julian Anastasova210d012008-10-01 07:28:28 -07002070 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
David S. Miller813b3b52011-04-28 14:48:42 -07002071 dev_out = __ip_dev_find(net, fl4->saddr, false);
Ian Morris51456b22015-04-03 09:17:26 +01002072 if (!dev_out)
Julian Anastasova210d012008-10-01 07:28:28 -07002073 goto out;
2074
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075 /* Special hack: user can direct multicasts
2076 and limited broadcast via necessary interface
2077 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2078 This hack is not just for fun, it allows
2079 vic,vat and friends to work.
2080 They bind socket to loopback, set ttl to zero
2081 and expect that it will work.
2082 From the viewpoint of routing cache they are broken,
2083 because we are not allowed to build multicast path
2084 with loopback source addr (look, routing cache
2085 cannot know, that ttl is zero, so that packet
2086 will not leave this host and route is valid).
2087 Luckily, this hack is good workaround.
2088 */
2089
David S. Miller813b3b52011-04-28 14:48:42 -07002090 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 goto make_route;
2092 }
Julian Anastasova210d012008-10-01 07:28:28 -07002093
David S. Miller813b3b52011-04-28 14:48:42 -07002094 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
Julian Anastasova210d012008-10-01 07:28:28 -07002095 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
David S. Miller813b3b52011-04-28 14:48:42 -07002096 if (!__ip_dev_find(net, fl4->saddr, false))
Julian Anastasova210d012008-10-01 07:28:28 -07002097 goto out;
Julian Anastasova210d012008-10-01 07:28:28 -07002098 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 }
2100
2101
David S. Miller813b3b52011-04-28 14:48:42 -07002102 if (fl4->flowi4_oif) {
2103 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
David S. Millerb23dd4f2011-03-02 14:31:35 -08002104 rth = ERR_PTR(-ENODEV);
Ian Morris51456b22015-04-03 09:17:26 +01002105 if (!dev_out)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 goto out;
Herbert Xue5ed6392005-10-03 14:35:55 -07002107
2108 /* RACE: Check return value of inet_select_addr instead. */
Eric Dumazetfc75fc82010-12-22 04:39:39 +00002109 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
David S. Millerb23dd4f2011-03-02 14:31:35 -08002110 rth = ERR_PTR(-ENETUNREACH);
Eric Dumazetfc75fc82010-12-22 04:39:39 +00002111 goto out;
2112 }
David S. Miller813b3b52011-04-28 14:48:42 -07002113 if (ipv4_is_local_multicast(fl4->daddr) ||
Andrew Lunn6a211652015-05-01 16:39:54 +02002114 ipv4_is_lbcast(fl4->daddr) ||
2115 fl4->flowi4_proto == IPPROTO_IGMP) {
David S. Miller813b3b52011-04-28 14:48:42 -07002116 if (!fl4->saddr)
2117 fl4->saddr = inet_select_addr(dev_out, 0,
2118 RT_SCOPE_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 goto make_route;
2120 }
Jiri Benc0a7e2262013-10-04 17:04:48 +02002121 if (!fl4->saddr) {
David S. Miller813b3b52011-04-28 14:48:42 -07002122 if (ipv4_is_multicast(fl4->daddr))
2123 fl4->saddr = inet_select_addr(dev_out, 0,
2124 fl4->flowi4_scope);
2125 else if (!fl4->daddr)
2126 fl4->saddr = inet_select_addr(dev_out, 0,
2127 RT_SCOPE_HOST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 }
David Ahern613d09b2015-08-13 14:59:02 -06002129 if (netif_is_vrf(dev_out) &&
2130 !(fl4->flowi4_flags & FLOWI_FLAG_VRFSRC)) {
2131 rth = vrf_dev_get_rth(dev_out);
2132 goto out;
2133 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 }
2135
David S. Miller813b3b52011-04-28 14:48:42 -07002136 if (!fl4->daddr) {
2137 fl4->daddr = fl4->saddr;
2138 if (!fl4->daddr)
2139 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002140 dev_out = net->loopback_dev;
Pavel Emelyanov1fb94892012-08-08 21:53:36 +00002141 fl4->flowi4_oif = LOOPBACK_IFINDEX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 res.type = RTN_LOCAL;
2143 flags |= RTCF_LOCAL;
2144 goto make_route;
2145 }
2146
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04002147 if (fib_lookup(net, fl4, &res, 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 res.fi = NULL;
David S. Miller8b96d222012-06-11 02:01:56 -07002149 res.table = NULL;
David S. Miller813b3b52011-04-28 14:48:42 -07002150 if (fl4->flowi4_oif) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 /* Apparently, routing tables are wrong. Assume,
2152 that the destination is on link.
2153
2154 WHY? DW.
2155 Because we are allowed to send to iface
2156 even if it has NO routes and NO assigned
2157 addresses. When oif is specified, routing
2158 tables are looked up with only one purpose:
2159 to catch if destination is gatewayed, rather than
2160 direct. Moreover, if MSG_DONTROUTE is set,
2161 we send packet, ignoring both routing tables
2162 and ifaddr state. --ANK
2163
2164
2165 We could make it even if oif is unknown,
2166 likely IPv6, but we do not.
2167 */
2168
David S. Miller813b3b52011-04-28 14:48:42 -07002169 if (fl4->saddr == 0)
2170 fl4->saddr = inet_select_addr(dev_out, 0,
2171 RT_SCOPE_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 res.type = RTN_UNICAST;
2173 goto make_route;
2174 }
David S. Millerb23dd4f2011-03-02 14:31:35 -08002175 rth = ERR_PTR(-ENETUNREACH);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176 goto out;
2177 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178
2179 if (res.type == RTN_LOCAL) {
David S. Miller813b3b52011-04-28 14:48:42 -07002180 if (!fl4->saddr) {
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002181 if (res.fi->fib_prefsrc)
David S. Miller813b3b52011-04-28 14:48:42 -07002182 fl4->saddr = res.fi->fib_prefsrc;
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002183 else
David S. Miller813b3b52011-04-28 14:48:42 -07002184 fl4->saddr = fl4->daddr;
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002185 }
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002186 dev_out = net->loopback_dev;
David S. Miller813b3b52011-04-28 14:48:42 -07002187 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 flags |= RTCF_LOCAL;
2189 goto make_route;
2190 }
2191
2192#ifdef CONFIG_IP_ROUTE_MULTIPATH
David S. Miller813b3b52011-04-28 14:48:42 -07002193 if (res.fi->fib_nhs > 1 && fl4->flowi4_oif == 0)
David S. Miller1b7fe5932011-03-10 17:01:16 -08002194 fib_select_multipath(&res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 else
2196#endif
David S. Miller21d8c492011-04-14 14:49:37 -07002197 if (!res.prefixlen &&
2198 res.table->tb_num_default > 1 &&
David S. Miller813b3b52011-04-28 14:48:42 -07002199 res.type == RTN_UNICAST && !fl4->flowi4_oif)
Julian Anastasov2392deb2015-07-22 10:43:23 +03002200 fib_select_default(fl4, &res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201
David S. Miller813b3b52011-04-28 14:48:42 -07002202 if (!fl4->saddr)
2203 fl4->saddr = FIB_RES_PREFSRC(net, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 dev_out = FIB_RES_DEV(res);
David S. Miller813b3b52011-04-28 14:48:42 -07002206 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207
2208
2209make_route:
David Miller1a00fee2012-07-01 02:02:56 +00002210 rth = __mkroute_output(&res, fl4, orig_oif, dev_out, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211
David S. Miller010c2702011-02-17 15:37:09 -08002212out:
2213 rcu_read_unlock();
David S. Millerb23dd4f2011-03-02 14:31:35 -08002214 return rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215}
Arnaldo Carvalho de Melod8c97a92005-08-09 20:12:12 -07002216EXPORT_SYMBOL_GPL(__ip_route_output_key);
2217
Jianzhao Wangae2688d2010-09-08 14:35:43 -07002218static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2219{
2220 return NULL;
2221}
2222
Steffen Klassertebb762f2011-11-23 02:12:51 +00002223static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
Roland Dreierec831ea2011-01-31 13:16:00 -08002224{
Steffen Klassert618f9bc2011-11-23 02:13:31 +00002225 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2226
2227 return mtu ? : dst->dev->mtu;
Roland Dreierec831ea2011-01-31 13:16:00 -08002228}
2229
David S. Miller6700c272012-07-17 03:29:28 -07002230static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2231 struct sk_buff *skb, u32 mtu)
David S. Miller14e50e52007-05-24 18:17:54 -07002232{
2233}
2234
David S. Miller6700c272012-07-17 03:29:28 -07002235static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2236 struct sk_buff *skb)
David S. Millerb587ee32012-07-12 00:39:24 -07002237{
2238}
2239
Held Bernhard0972ddb2011-04-24 22:07:32 +00002240static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2241 unsigned long old)
2242{
2243 return NULL;
2244}
2245
David S. Miller14e50e52007-05-24 18:17:54 -07002246static struct dst_ops ipv4_dst_blackhole_ops = {
2247 .family = AF_INET,
Jianzhao Wangae2688d2010-09-08 14:35:43 -07002248 .check = ipv4_blackhole_dst_check,
Steffen Klassertebb762f2011-11-23 02:12:51 +00002249 .mtu = ipv4_blackhole_mtu,
Eric Dumazet214f45c2011-02-18 11:39:01 -08002250 .default_advmss = ipv4_default_advmss,
David S. Miller14e50e52007-05-24 18:17:54 -07002251 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
David S. Millerb587ee32012-07-12 00:39:24 -07002252 .redirect = ipv4_rt_blackhole_redirect,
Held Bernhard0972ddb2011-04-24 22:07:32 +00002253 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
David S. Millerd3aaeb32011-07-18 00:40:17 -07002254 .neigh_lookup = ipv4_neigh_lookup,
David S. Miller14e50e52007-05-24 18:17:54 -07002255};
2256
David S. Miller2774c132011-03-01 14:59:04 -08002257struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
David S. Miller14e50e52007-05-24 18:17:54 -07002258{
David S. Miller2774c132011-03-01 14:59:04 -08002259 struct rtable *ort = (struct rtable *) dst_orig;
David S. Millerf5b0a872012-07-19 12:31:33 -07002260 struct rtable *rt;
David S. Miller14e50e52007-05-24 18:17:54 -07002261
David S. Millerf5b0a872012-07-19 12:31:33 -07002262 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE, 0);
David S. Miller14e50e52007-05-24 18:17:54 -07002263 if (rt) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002264 struct dst_entry *new = &rt->dst;
David S. Miller14e50e52007-05-24 18:17:54 -07002265
David S. Miller14e50e52007-05-24 18:17:54 -07002266 new->__use = 1;
Herbert Xu352e5122007-11-13 21:34:06 -08002267 new->input = dst_discard;
Eric Dumazetaad88722014-04-15 13:47:15 -04002268 new->output = dst_discard_sk;
David S. Miller14e50e52007-05-24 18:17:54 -07002269
Changli Gaod8d1f302010-06-10 23:31:35 -07002270 new->dev = ort->dst.dev;
David S. Miller14e50e52007-05-24 18:17:54 -07002271 if (new->dev)
2272 dev_hold(new->dev);
2273
David S. Miller9917e1e82012-07-17 14:44:26 -07002274 rt->rt_is_input = ort->rt_is_input;
David S. Miller5e2b61f2011-03-04 21:47:09 -08002275 rt->rt_iif = ort->rt_iif;
David S. Miller59436342012-07-10 06:58:42 -07002276 rt->rt_pmtu = ort->rt_pmtu;
David S. Miller14e50e52007-05-24 18:17:54 -07002277
fan.duca4c3fc2013-07-30 08:33:53 +08002278 rt->rt_genid = rt_genid_ipv4(net);
David S. Miller14e50e52007-05-24 18:17:54 -07002279 rt->rt_flags = ort->rt_flags;
2280 rt->rt_type = ort->rt_type;
David S. Miller14e50e52007-05-24 18:17:54 -07002281 rt->rt_gateway = ort->rt_gateway;
Julian Anastasov155e8332012-10-08 11:41:18 +00002282 rt->rt_uses_gateway = ort->rt_uses_gateway;
David S. Miller14e50e52007-05-24 18:17:54 -07002283
David S. Millercaacf052012-07-31 15:06:50 -07002284 INIT_LIST_HEAD(&rt->rt_uncached);
David S. Miller14e50e52007-05-24 18:17:54 -07002285 dst_free(new);
2286 }
2287
David S. Miller2774c132011-03-01 14:59:04 -08002288 dst_release(dst_orig);
2289
2290 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
David S. Miller14e50e52007-05-24 18:17:54 -07002291}
2292
David S. Miller9d6ec932011-03-12 01:12:47 -05002293struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
Eric Dumazet6f9c9612015-09-25 07:39:10 -07002294 const struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295{
David S. Miller9d6ec932011-03-12 01:12:47 -05002296 struct rtable *rt = __ip_route_output_key(net, flp4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297
David S. Millerb23dd4f2011-03-02 14:31:35 -08002298 if (IS_ERR(rt))
2299 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300
David S. Miller56157872011-05-02 14:37:45 -07002301 if (flp4->flowi4_proto)
Steffen Klassertf92ee612014-09-16 10:08:40 +02002302 rt = (struct rtable *)xfrm_lookup_route(net, &rt->dst,
2303 flowi4_to_flowi(flp4),
2304 sk, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305
David S. Millerb23dd4f2011-03-02 14:31:35 -08002306 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307}
Arnaldo Carvalho de Melod8c97a92005-08-09 20:12:12 -07002308EXPORT_SYMBOL_GPL(ip_route_output_flow);
2309
David Ahernc36ba662015-09-02 13:58:36 -07002310static int rt_fill_info(struct net *net, __be32 dst, __be32 src, u32 table_id,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002311 struct flowi4 *fl4, struct sk_buff *skb, u32 portid,
David S. Millerf1ce3062012-07-12 10:10:17 -07002312 u32 seq, int event, int nowait, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313{
Eric Dumazet511c3f92009-06-02 05:14:27 +00002314 struct rtable *rt = skb_rtable(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 struct rtmsg *r;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002316 struct nlmsghdr *nlh;
Steffen Klassert2bc8ca42011-10-11 01:12:02 +00002317 unsigned long expires = 0;
David S. Millerf1850712012-07-10 07:26:01 -07002318 u32 error;
Julian Anastasov521f5492012-07-20 12:02:08 +03002319 u32 metrics[RTAX_MAX];
Thomas Grafbe403ea2006-08-17 18:15:17 -07002320
Eric W. Biederman15e47302012-09-07 20:12:54 +00002321 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*r), flags);
Ian Morris51456b22015-04-03 09:17:26 +01002322 if (!nlh)
Patrick McHardy26932562007-01-31 23:16:40 -08002323 return -EMSGSIZE;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002324
2325 r = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 r->rtm_family = AF_INET;
2327 r->rtm_dst_len = 32;
2328 r->rtm_src_len = 0;
David Millerd6c0a4f2012-07-01 02:02:59 +00002329 r->rtm_tos = fl4->flowi4_tos;
David Ahernc36ba662015-09-02 13:58:36 -07002330 r->rtm_table = table_id;
2331 if (nla_put_u32(skb, RTA_TABLE, table_id))
David S. Millerf3756b72012-04-01 20:39:02 -04002332 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 r->rtm_type = rt->rt_type;
2334 r->rtm_scope = RT_SCOPE_UNIVERSE;
2335 r->rtm_protocol = RTPROT_UNSPEC;
2336 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2337 if (rt->rt_flags & RTCF_NOTIFY)
2338 r->rtm_flags |= RTM_F_NOTIFY;
Hannes Frederic Sowadf4d9252015-01-23 12:01:26 +01002339 if (IPCB(skb)->flags & IPSKB_DOREDIRECT)
2340 r->rtm_flags |= RTCF_DOREDIRECT;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002341
Jiri Benc930345e2015-03-29 16:59:25 +02002342 if (nla_put_in_addr(skb, RTA_DST, dst))
David S. Millerf3756b72012-04-01 20:39:02 -04002343 goto nla_put_failure;
David Miller1a00fee2012-07-01 02:02:56 +00002344 if (src) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 r->rtm_src_len = 32;
Jiri Benc930345e2015-03-29 16:59:25 +02002346 if (nla_put_in_addr(skb, RTA_SRC, src))
David S. Millerf3756b72012-04-01 20:39:02 -04002347 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348 }
David S. Millerf3756b72012-04-01 20:39:02 -04002349 if (rt->dst.dev &&
2350 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2351 goto nla_put_failure;
Patrick McHardyc7066f72011-01-14 13:36:42 +01002352#ifdef CONFIG_IP_ROUTE_CLASSID
David S. Millerf3756b72012-04-01 20:39:02 -04002353 if (rt->dst.tclassid &&
2354 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2355 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356#endif
David S. Miller41347dc2012-06-28 04:05:27 -07002357 if (!rt_is_input_route(rt) &&
David Millerd6c0a4f2012-07-01 02:02:59 +00002358 fl4->saddr != src) {
Jiri Benc930345e2015-03-29 16:59:25 +02002359 if (nla_put_in_addr(skb, RTA_PREFSRC, fl4->saddr))
David S. Millerf3756b72012-04-01 20:39:02 -04002360 goto nla_put_failure;
2361 }
Julian Anastasov155e8332012-10-08 11:41:18 +00002362 if (rt->rt_uses_gateway &&
Jiri Benc930345e2015-03-29 16:59:25 +02002363 nla_put_in_addr(skb, RTA_GATEWAY, rt->rt_gateway))
David S. Millerf3756b72012-04-01 20:39:02 -04002364 goto nla_put_failure;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002365
Steffen Klassertee9a8f72012-10-08 00:56:54 +00002366 expires = rt->dst.expires;
2367 if (expires) {
2368 unsigned long now = jiffies;
2369
2370 if (time_before(now, expires))
2371 expires -= now;
2372 else
2373 expires = 0;
2374 }
2375
Julian Anastasov521f5492012-07-20 12:02:08 +03002376 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
Steffen Klassertee9a8f72012-10-08 00:56:54 +00002377 if (rt->rt_pmtu && expires)
Julian Anastasov521f5492012-07-20 12:02:08 +03002378 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2379 if (rtnetlink_put_metrics(skb, metrics) < 0)
Thomas Grafbe403ea2006-08-17 18:15:17 -07002380 goto nla_put_failure;
2381
David Millerb4869882012-07-01 02:03:01 +00002382 if (fl4->flowi4_mark &&
stephen hemminger68aaed52012-10-10 08:27:25 +00002383 nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
David S. Millerf3756b72012-04-01 20:39:02 -04002384 goto nla_put_failure;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002385
Changli Gaod8d1f302010-06-10 23:31:35 -07002386 error = rt->dst.error;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002387
David S. Millerc7537962010-11-11 17:07:48 -08002388 if (rt_is_input_route(rt)) {
Nicolas Dichtel8caaf7b2012-12-04 01:03:07 +00002389#ifdef CONFIG_IP_MROUTE
2390 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2391 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2392 int err = ipmr_get_route(net, skb,
2393 fl4->saddr, fl4->daddr,
2394 r, nowait);
2395 if (err <= 0) {
2396 if (!nowait) {
2397 if (err == 0)
2398 return 0;
2399 goto nla_put_failure;
2400 } else {
2401 if (err == -EMSGSIZE)
2402 goto nla_put_failure;
2403 error = err;
2404 }
2405 }
2406 } else
2407#endif
Julian Anastasov91146152014-04-13 18:08:02 +03002408 if (nla_put_u32(skb, RTA_IIF, skb->dev->ifindex))
Nicolas Dichtel8caaf7b2012-12-04 01:03:07 +00002409 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 }
2411
David S. Millerf1850712012-07-10 07:26:01 -07002412 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
Thomas Grafe3703b32006-11-27 09:27:07 -08002413 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414
Johannes Berg053c0952015-01-16 22:09:00 +01002415 nlmsg_end(skb, nlh);
2416 return 0;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002417
2418nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002419 nlmsg_cancel(skb, nlh);
2420 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421}
2422
Thomas Graf661d2962013-03-21 07:45:29 +00002423static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002425 struct net *net = sock_net(in_skb->sk);
Thomas Grafd889ce32006-08-17 18:15:44 -07002426 struct rtmsg *rtm;
2427 struct nlattr *tb[RTA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428 struct rtable *rt = NULL;
David Millerd6c0a4f2012-07-01 02:02:59 +00002429 struct flowi4 fl4;
Al Viro9e12bb22006-09-26 21:25:20 -07002430 __be32 dst = 0;
2431 __be32 src = 0;
2432 u32 iif;
Thomas Grafd889ce32006-08-17 18:15:44 -07002433 int err;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002434 int mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435 struct sk_buff *skb;
David Ahernc36ba662015-09-02 13:58:36 -07002436 u32 table_id = RT_TABLE_MAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002437
Thomas Grafd889ce32006-08-17 18:15:44 -07002438 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2439 if (err < 0)
2440 goto errout;
2441
2442 rtm = nlmsg_data(nlh);
2443
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01002445 if (!skb) {
Thomas Grafd889ce32006-08-17 18:15:44 -07002446 err = -ENOBUFS;
2447 goto errout;
2448 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449
2450 /* Reserve room for dummy headers, this skb can pass
2451 through good chunk of routing engine.
2452 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07002453 skb_reset_mac_header(skb);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07002454 skb_reset_network_header(skb);
Stephen Hemmingerd2c962b2006-04-17 17:27:11 -07002455
2456 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07002457 ip_hdr(skb)->protocol = IPPROTO_ICMP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2459
Jiri Benc67b61f62015-03-29 16:59:26 +02002460 src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0;
2461 dst = tb[RTA_DST] ? nla_get_in_addr(tb[RTA_DST]) : 0;
Thomas Grafd889ce32006-08-17 18:15:44 -07002462 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002463 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464
David Millerd6c0a4f2012-07-01 02:02:59 +00002465 memset(&fl4, 0, sizeof(fl4));
2466 fl4.daddr = dst;
2467 fl4.saddr = src;
2468 fl4.flowi4_tos = rtm->rtm_tos;
2469 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2470 fl4.flowi4_mark = mark;
2471
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472 if (iif) {
Thomas Grafd889ce32006-08-17 18:15:44 -07002473 struct net_device *dev;
2474
Denis V. Lunev19375042008-02-28 20:52:04 -08002475 dev = __dev_get_by_index(net, iif);
Ian Morris51456b22015-04-03 09:17:26 +01002476 if (!dev) {
Thomas Grafd889ce32006-08-17 18:15:44 -07002477 err = -ENODEV;
2478 goto errout_free;
2479 }
2480
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481 skb->protocol = htons(ETH_P_IP);
2482 skb->dev = dev;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002483 skb->mark = mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484 local_bh_disable();
2485 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2486 local_bh_enable();
Thomas Grafd889ce32006-08-17 18:15:44 -07002487
Eric Dumazet511c3f92009-06-02 05:14:27 +00002488 rt = skb_rtable(skb);
Changli Gaod8d1f302010-06-10 23:31:35 -07002489 if (err == 0 && rt->dst.error)
2490 err = -rt->dst.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 } else {
David S. Miller9d6ec932011-03-12 01:12:47 -05002492 rt = ip_route_output_key(net, &fl4);
David S. Millerb23dd4f2011-03-02 14:31:35 -08002493
2494 err = 0;
2495 if (IS_ERR(rt))
2496 err = PTR_ERR(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497 }
Thomas Grafd889ce32006-08-17 18:15:44 -07002498
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499 if (err)
Thomas Grafd889ce32006-08-17 18:15:44 -07002500 goto errout_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501
Changli Gaod8d1f302010-06-10 23:31:35 -07002502 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503 if (rtm->rtm_flags & RTM_F_NOTIFY)
2504 rt->rt_flags |= RTCF_NOTIFY;
2505
David Ahernc36ba662015-09-02 13:58:36 -07002506 if (rtm->rtm_flags & RTM_F_LOOKUP_TABLE)
2507 table_id = rt->rt_table_id;
2508
2509 err = rt_fill_info(net, dst, src, table_id, &fl4, skb,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002510 NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
Denis V. Lunev19375042008-02-28 20:52:04 -08002511 RTM_NEWROUTE, 0, 0);
David S. Miller7b46a642015-01-18 23:36:08 -05002512 if (err < 0)
Thomas Grafd889ce32006-08-17 18:15:44 -07002513 goto errout_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002514
Eric W. Biederman15e47302012-09-07 20:12:54 +00002515 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
Thomas Grafd889ce32006-08-17 18:15:44 -07002516errout:
Thomas Graf2942e902006-08-15 00:30:25 -07002517 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518
Thomas Grafd889ce32006-08-17 18:15:44 -07002519errout_free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520 kfree_skb(skb);
Thomas Grafd889ce32006-08-17 18:15:44 -07002521 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522}
2523
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524void ip_rt_multicast_event(struct in_device *in_dev)
2525{
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002526 rt_cache_flush(dev_net(in_dev->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527}
2528
2529#ifdef CONFIG_SYSCTL
Gao feng082c7ca2013-02-19 00:43:12 +00002530static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
2531static int ip_rt_gc_interval __read_mostly = 60 * HZ;
2532static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
2533static int ip_rt_gc_elasticity __read_mostly = 8;
2534
Joe Perchesfe2c6332013-06-11 23:04:25 -07002535static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002536 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002537 size_t *lenp, loff_t *ppos)
2538{
Timo Teräs5aad1de2013-05-27 20:46:33 +00002539 struct net *net = (struct net *)__ctl->extra1;
2540
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541 if (write) {
Timo Teräs5aad1de2013-05-27 20:46:33 +00002542 rt_cache_flush(net);
2543 fnhe_genid_bump(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 return 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002545 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546
2547 return -EINVAL;
2548}
2549
Joe Perchesfe2c6332013-06-11 23:04:25 -07002550static struct ctl_table ipv4_route_table[] = {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002551 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552 .procname = "gc_thresh",
2553 .data = &ipv4_dst_ops.gc_thresh,
2554 .maxlen = sizeof(int),
2555 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002556 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557 },
2558 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559 .procname = "max_size",
2560 .data = &ip_rt_max_size,
2561 .maxlen = sizeof(int),
2562 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002563 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564 },
2565 {
2566 /* Deprecated. Use gc_min_interval_ms */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002567
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 .procname = "gc_min_interval",
2569 .data = &ip_rt_gc_min_interval,
2570 .maxlen = sizeof(int),
2571 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002572 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573 },
2574 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575 .procname = "gc_min_interval_ms",
2576 .data = &ip_rt_gc_min_interval,
2577 .maxlen = sizeof(int),
2578 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002579 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 },
2581 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 .procname = "gc_timeout",
2583 .data = &ip_rt_gc_timeout,
2584 .maxlen = sizeof(int),
2585 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002586 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002587 },
2588 {
Eric Dumazet9f28a2f2011-12-21 15:47:16 -05002589 .procname = "gc_interval",
2590 .data = &ip_rt_gc_interval,
2591 .maxlen = sizeof(int),
2592 .mode = 0644,
2593 .proc_handler = proc_dointvec_jiffies,
2594 },
2595 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596 .procname = "redirect_load",
2597 .data = &ip_rt_redirect_load,
2598 .maxlen = sizeof(int),
2599 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002600 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601 },
2602 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603 .procname = "redirect_number",
2604 .data = &ip_rt_redirect_number,
2605 .maxlen = sizeof(int),
2606 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002607 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608 },
2609 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610 .procname = "redirect_silence",
2611 .data = &ip_rt_redirect_silence,
2612 .maxlen = sizeof(int),
2613 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002614 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615 },
2616 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617 .procname = "error_cost",
2618 .data = &ip_rt_error_cost,
2619 .maxlen = sizeof(int),
2620 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002621 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622 },
2623 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624 .procname = "error_burst",
2625 .data = &ip_rt_error_burst,
2626 .maxlen = sizeof(int),
2627 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002628 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629 },
2630 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631 .procname = "gc_elasticity",
2632 .data = &ip_rt_gc_elasticity,
2633 .maxlen = sizeof(int),
2634 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002635 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636 },
2637 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638 .procname = "mtu_expires",
2639 .data = &ip_rt_mtu_expires,
2640 .maxlen = sizeof(int),
2641 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002642 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643 },
2644 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 .procname = "min_pmtu",
2646 .data = &ip_rt_min_pmtu,
2647 .maxlen = sizeof(int),
2648 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002649 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650 },
2651 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 .procname = "min_adv_mss",
2653 .data = &ip_rt_min_advmss,
2654 .maxlen = sizeof(int),
2655 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002656 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002658 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659};
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002660
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002661static struct ctl_table ipv4_route_flush_table[] = {
2662 {
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002663 .procname = "flush",
2664 .maxlen = sizeof(int),
2665 .mode = 0200,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002666 .proc_handler = ipv4_sysctl_rtcache_flush,
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002667 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002668 { },
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002669};
2670
2671static __net_init int sysctl_route_net_init(struct net *net)
2672{
2673 struct ctl_table *tbl;
2674
2675 tbl = ipv4_route_flush_table;
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08002676 if (!net_eq(net, &init_net)) {
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002677 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01002678 if (!tbl)
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002679 goto err_dup;
Eric W. Biederman464dc802012-11-16 03:02:59 +00002680
2681 /* Don't export sysctls to unprivileged users */
2682 if (net->user_ns != &init_user_ns)
2683 tbl[0].procname = NULL;
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002684 }
2685 tbl[0].extra1 = net;
2686
Eric W. Biedermanec8f23c2012-04-19 13:44:49 +00002687 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
Ian Morris51456b22015-04-03 09:17:26 +01002688 if (!net->ipv4.route_hdr)
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002689 goto err_reg;
2690 return 0;
2691
2692err_reg:
2693 if (tbl != ipv4_route_flush_table)
2694 kfree(tbl);
2695err_dup:
2696 return -ENOMEM;
2697}
2698
2699static __net_exit void sysctl_route_net_exit(struct net *net)
2700{
2701 struct ctl_table *tbl;
2702
2703 tbl = net->ipv4.route_hdr->ctl_table_arg;
2704 unregister_net_sysctl_table(net->ipv4.route_hdr);
2705 BUG_ON(tbl == ipv4_route_flush_table);
2706 kfree(tbl);
2707}
2708
2709static __net_initdata struct pernet_operations sysctl_route_ops = {
2710 .init = sysctl_route_net_init,
2711 .exit = sysctl_route_net_exit,
2712};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713#endif
2714
Neil Horman3ee94372010-05-08 01:57:52 -07002715static __net_init int rt_genid_init(struct net *net)
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002716{
fan.duca4c3fc2013-07-30 08:33:53 +08002717 atomic_set(&net->ipv4.rt_genid, 0);
Timo Teräs5aad1de2013-05-27 20:46:33 +00002718 atomic_set(&net->fnhe_genid, 0);
David S. Miller436c3b62011-03-24 17:42:21 -07002719 get_random_bytes(&net->ipv4.dev_addr_genid,
2720 sizeof(net->ipv4.dev_addr_genid));
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002721 return 0;
2722}
2723
Neil Horman3ee94372010-05-08 01:57:52 -07002724static __net_initdata struct pernet_operations rt_genid_ops = {
2725 .init = rt_genid_init,
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002726};
2727
David S. Millerc3426b42012-06-09 16:27:05 -07002728static int __net_init ipv4_inetpeer_init(struct net *net)
2729{
2730 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2731
2732 if (!bp)
2733 return -ENOMEM;
2734 inet_peer_base_init(bp);
2735 net->ipv4.peers = bp;
2736 return 0;
2737}
2738
2739static void __net_exit ipv4_inetpeer_exit(struct net *net)
2740{
2741 struct inet_peer_base *bp = net->ipv4.peers;
2742
2743 net->ipv4.peers = NULL;
David S. Miller56a6b242012-06-09 16:32:41 -07002744 inetpeer_invalidate_tree(bp);
David S. Millerc3426b42012-06-09 16:27:05 -07002745 kfree(bp);
2746}
2747
2748static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
2749 .init = ipv4_inetpeer_init,
2750 .exit = ipv4_inetpeer_exit,
2751};
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002752
Patrick McHardyc7066f72011-01-14 13:36:42 +01002753#ifdef CONFIG_IP_ROUTE_CLASSID
Tejun Heo7d720c32010-02-16 15:20:26 +00002754struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
Patrick McHardyc7066f72011-01-14 13:36:42 +01002755#endif /* CONFIG_IP_ROUTE_CLASSID */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757int __init ip_rt_init(void)
2758{
Eric Dumazet424c4b72005-07-05 14:58:19 -07002759 int rc = 0;
Eric Dumazet5055c372015-01-14 15:17:06 -08002760 int cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002761
Eric Dumazet73f156a2014-06-02 05:26:03 -07002762 ip_idents = kmalloc(IP_IDENTS_SZ * sizeof(*ip_idents), GFP_KERNEL);
2763 if (!ip_idents)
2764 panic("IP: failed to allocate ip_idents\n");
2765
2766 prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));
2767
Eric Dumazet355b590c2015-05-01 10:37:49 -07002768 ip_tstamps = kcalloc(IP_IDENTS_SZ, sizeof(*ip_tstamps), GFP_KERNEL);
2769 if (!ip_tstamps)
2770 panic("IP: failed to allocate ip_tstamps\n");
2771
Eric Dumazet5055c372015-01-14 15:17:06 -08002772 for_each_possible_cpu(cpu) {
2773 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
2774
2775 INIT_LIST_HEAD(&ul->head);
2776 spin_lock_init(&ul->lock);
2777 }
Patrick McHardyc7066f72011-01-14 13:36:42 +01002778#ifdef CONFIG_IP_ROUTE_CLASSID
Ingo Molnar0dcec8c2009-02-25 14:07:33 +01002779 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 if (!ip_rt_acct)
2781 panic("IP: failed to allocate ip_rt_acct\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782#endif
2783
Alexey Dobriyane5d679f332006-08-26 19:25:52 -07002784 ipv4_dst_ops.kmem_cachep =
2785 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09002786 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787
David S. Miller14e50e52007-05-24 18:17:54 -07002788 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
2789
Eric Dumazetfc66f952010-10-08 06:37:34 +00002790 if (dst_entries_init(&ipv4_dst_ops) < 0)
2791 panic("IP: failed to allocate ipv4_dst_ops counter\n");
2792
2793 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
2794 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
2795
David S. Miller89aef892012-07-17 11:00:09 -07002796 ipv4_dst_ops.gc_thresh = ~0;
2797 ip_rt_max_size = INT_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799 devinet_init();
2800 ip_fib_init();
2801
Denis V. Lunev73b38712008-02-28 20:51:18 -08002802 if (ip_rt_proc_init())
Joe Perches058bd4d2012-03-11 18:36:11 +00002803 pr_err("Unable to create route proc files\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804#ifdef CONFIG_XFRM
2805 xfrm_init();
Steffen Klassert703fb942012-11-13 08:52:24 +01002806 xfrm4_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807#endif
Greg Rosec7ac8672011-06-10 01:27:09 +00002808 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL, NULL);
Thomas Graf63f34442007-03-22 11:55:17 -07002809
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002810#ifdef CONFIG_SYSCTL
2811 register_pernet_subsys(&sysctl_route_ops);
2812#endif
Neil Horman3ee94372010-05-08 01:57:52 -07002813 register_pernet_subsys(&rt_genid_ops);
David S. Millerc3426b42012-06-09 16:27:05 -07002814 register_pernet_subsys(&ipv4_inetpeer_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815 return rc;
2816}
2817
Al Viroa1bc6eb2008-07-30 06:32:52 -04002818#ifdef CONFIG_SYSCTL
Al Viroeeb61f72008-07-27 08:59:33 +01002819/*
2820 * We really need to sanitize the damn ipv4 init order, then all
2821 * this nonsense will go away.
2822 */
2823void __init ip_static_sysctl_init(void)
2824{
Eric W. Biederman4e5ca782012-04-19 13:32:39 +00002825 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);
Al Viroeeb61f72008-07-27 08:59:33 +01002826}
Al Viroa1bc6eb2008-07-30 06:32:52 -04002827#endif