blob: 6bab84503cd9bb9622a3f269e7cde67aafc9b6aa [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;
Nikola ForrĂ³0315e382015-09-17 16:01:32 +02002039 int err = -ENETUNREACH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040
David S. Miller85b91b02012-07-13 08:21:29 -07002041 res.tclassid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 res.fi = NULL;
David S. Miller8b96d222012-06-11 02:01:56 -07002043 res.table = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044
David S. Miller813b3b52011-04-28 14:48:42 -07002045 orig_oif = fl4->flowi4_oif;
2046
Pavel Emelyanov1fb94892012-08-08 21:53:36 +00002047 fl4->flowi4_iif = LOOPBACK_IFINDEX;
David S. Miller813b3b52011-04-28 14:48:42 -07002048 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
2049 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
2050 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
David S. Miller44713b62011-03-04 21:24:47 -08002051
David S. Miller010c2702011-02-17 15:37:09 -08002052 rcu_read_lock();
David S. Miller813b3b52011-04-28 14:48:42 -07002053 if (fl4->saddr) {
David S. Millerb23dd4f2011-03-02 14:31:35 -08002054 rth = ERR_PTR(-EINVAL);
David S. Miller813b3b52011-04-28 14:48:42 -07002055 if (ipv4_is_multicast(fl4->saddr) ||
2056 ipv4_is_lbcast(fl4->saddr) ||
2057 ipv4_is_zeronet(fl4->saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 goto out;
2059
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 /* I removed check for oif == dev_out->oif here.
2061 It was wrong for two reasons:
Denis V. Lunev1ab35272008-01-22 22:04:30 -08002062 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2063 is assigned to multiple interfaces.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 2. Moreover, we are allowed to send packets with saddr
2065 of another iface. --ANK
2066 */
2067
David S. Miller813b3b52011-04-28 14:48:42 -07002068 if (fl4->flowi4_oif == 0 &&
2069 (ipv4_is_multicast(fl4->daddr) ||
2070 ipv4_is_lbcast(fl4->daddr))) {
Julian Anastasova210d012008-10-01 07:28:28 -07002071 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
David S. Miller813b3b52011-04-28 14:48:42 -07002072 dev_out = __ip_dev_find(net, fl4->saddr, false);
Ian Morris51456b22015-04-03 09:17:26 +01002073 if (!dev_out)
Julian Anastasova210d012008-10-01 07:28:28 -07002074 goto out;
2075
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 /* Special hack: user can direct multicasts
2077 and limited broadcast via necessary interface
2078 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2079 This hack is not just for fun, it allows
2080 vic,vat and friends to work.
2081 They bind socket to loopback, set ttl to zero
2082 and expect that it will work.
2083 From the viewpoint of routing cache they are broken,
2084 because we are not allowed to build multicast path
2085 with loopback source addr (look, routing cache
2086 cannot know, that ttl is zero, so that packet
2087 will not leave this host and route is valid).
2088 Luckily, this hack is good workaround.
2089 */
2090
David S. Miller813b3b52011-04-28 14:48:42 -07002091 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 goto make_route;
2093 }
Julian Anastasova210d012008-10-01 07:28:28 -07002094
David S. Miller813b3b52011-04-28 14:48:42 -07002095 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
Julian Anastasova210d012008-10-01 07:28:28 -07002096 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
David S. Miller813b3b52011-04-28 14:48:42 -07002097 if (!__ip_dev_find(net, fl4->saddr, false))
Julian Anastasova210d012008-10-01 07:28:28 -07002098 goto out;
Julian Anastasova210d012008-10-01 07:28:28 -07002099 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 }
2101
2102
David S. Miller813b3b52011-04-28 14:48:42 -07002103 if (fl4->flowi4_oif) {
2104 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
David S. Millerb23dd4f2011-03-02 14:31:35 -08002105 rth = ERR_PTR(-ENODEV);
Ian Morris51456b22015-04-03 09:17:26 +01002106 if (!dev_out)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 goto out;
Herbert Xue5ed6392005-10-03 14:35:55 -07002108
2109 /* RACE: Check return value of inet_select_addr instead. */
Eric Dumazetfc75fc82010-12-22 04:39:39 +00002110 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
David S. Millerb23dd4f2011-03-02 14:31:35 -08002111 rth = ERR_PTR(-ENETUNREACH);
Eric Dumazetfc75fc82010-12-22 04:39:39 +00002112 goto out;
2113 }
David S. Miller813b3b52011-04-28 14:48:42 -07002114 if (ipv4_is_local_multicast(fl4->daddr) ||
Andrew Lunn6a211652015-05-01 16:39:54 +02002115 ipv4_is_lbcast(fl4->daddr) ||
2116 fl4->flowi4_proto == IPPROTO_IGMP) {
David S. Miller813b3b52011-04-28 14:48:42 -07002117 if (!fl4->saddr)
2118 fl4->saddr = inet_select_addr(dev_out, 0,
2119 RT_SCOPE_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 goto make_route;
2121 }
Jiri Benc0a7e2262013-10-04 17:04:48 +02002122 if (!fl4->saddr) {
David S. Miller813b3b52011-04-28 14:48:42 -07002123 if (ipv4_is_multicast(fl4->daddr))
2124 fl4->saddr = inet_select_addr(dev_out, 0,
2125 fl4->flowi4_scope);
2126 else if (!fl4->daddr)
2127 fl4->saddr = inet_select_addr(dev_out, 0,
2128 RT_SCOPE_HOST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 }
David Ahern613d09b2015-08-13 14:59:02 -06002130 if (netif_is_vrf(dev_out) &&
2131 !(fl4->flowi4_flags & FLOWI_FLAG_VRFSRC)) {
2132 rth = vrf_dev_get_rth(dev_out);
2133 goto out;
2134 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 }
2136
David S. Miller813b3b52011-04-28 14:48:42 -07002137 if (!fl4->daddr) {
2138 fl4->daddr = fl4->saddr;
2139 if (!fl4->daddr)
2140 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002141 dev_out = net->loopback_dev;
Pavel Emelyanov1fb94892012-08-08 21:53:36 +00002142 fl4->flowi4_oif = LOOPBACK_IFINDEX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143 res.type = RTN_LOCAL;
2144 flags |= RTCF_LOCAL;
2145 goto make_route;
2146 }
2147
Nikola ForrĂ³0315e382015-09-17 16:01:32 +02002148 err = fib_lookup(net, fl4, &res, 0);
2149 if (err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 res.fi = NULL;
David S. Miller8b96d222012-06-11 02:01:56 -07002151 res.table = NULL;
David S. Miller813b3b52011-04-28 14:48:42 -07002152 if (fl4->flowi4_oif) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 /* Apparently, routing tables are wrong. Assume,
2154 that the destination is on link.
2155
2156 WHY? DW.
2157 Because we are allowed to send to iface
2158 even if it has NO routes and NO assigned
2159 addresses. When oif is specified, routing
2160 tables are looked up with only one purpose:
2161 to catch if destination is gatewayed, rather than
2162 direct. Moreover, if MSG_DONTROUTE is set,
2163 we send packet, ignoring both routing tables
2164 and ifaddr state. --ANK
2165
2166
2167 We could make it even if oif is unknown,
2168 likely IPv6, but we do not.
2169 */
2170
David S. Miller813b3b52011-04-28 14:48:42 -07002171 if (fl4->saddr == 0)
2172 fl4->saddr = inet_select_addr(dev_out, 0,
2173 RT_SCOPE_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 res.type = RTN_UNICAST;
2175 goto make_route;
2176 }
Nikola ForrĂ³0315e382015-09-17 16:01:32 +02002177 rth = ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178 goto out;
2179 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180
2181 if (res.type == RTN_LOCAL) {
David S. Miller813b3b52011-04-28 14:48:42 -07002182 if (!fl4->saddr) {
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002183 if (res.fi->fib_prefsrc)
David S. Miller813b3b52011-04-28 14:48:42 -07002184 fl4->saddr = res.fi->fib_prefsrc;
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002185 else
David S. Miller813b3b52011-04-28 14:48:42 -07002186 fl4->saddr = fl4->daddr;
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002187 }
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002188 dev_out = net->loopback_dev;
David S. Miller813b3b52011-04-28 14:48:42 -07002189 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190 flags |= RTCF_LOCAL;
2191 goto make_route;
2192 }
2193
2194#ifdef CONFIG_IP_ROUTE_MULTIPATH
David S. Miller813b3b52011-04-28 14:48:42 -07002195 if (res.fi->fib_nhs > 1 && fl4->flowi4_oif == 0)
David S. Miller1b7fe5932011-03-10 17:01:16 -08002196 fib_select_multipath(&res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 else
2198#endif
David S. Miller21d8c492011-04-14 14:49:37 -07002199 if (!res.prefixlen &&
2200 res.table->tb_num_default > 1 &&
David S. Miller813b3b52011-04-28 14:48:42 -07002201 res.type == RTN_UNICAST && !fl4->flowi4_oif)
Julian Anastasov2392deb2015-07-22 10:43:23 +03002202 fib_select_default(fl4, &res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203
David S. Miller813b3b52011-04-28 14:48:42 -07002204 if (!fl4->saddr)
2205 fl4->saddr = FIB_RES_PREFSRC(net, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207 dev_out = FIB_RES_DEV(res);
David S. Miller813b3b52011-04-28 14:48:42 -07002208 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209
2210
2211make_route:
David Miller1a00fee2012-07-01 02:02:56 +00002212 rth = __mkroute_output(&res, fl4, orig_oif, dev_out, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213
David S. Miller010c2702011-02-17 15:37:09 -08002214out:
2215 rcu_read_unlock();
David S. Millerb23dd4f2011-03-02 14:31:35 -08002216 return rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217}
Arnaldo Carvalho de Melod8c97a92005-08-09 20:12:12 -07002218EXPORT_SYMBOL_GPL(__ip_route_output_key);
2219
Jianzhao Wangae2688d2010-09-08 14:35:43 -07002220static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2221{
2222 return NULL;
2223}
2224
Steffen Klassertebb762f2011-11-23 02:12:51 +00002225static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
Roland Dreierec831ea2011-01-31 13:16:00 -08002226{
Steffen Klassert618f9bc2011-11-23 02:13:31 +00002227 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2228
2229 return mtu ? : dst->dev->mtu;
Roland Dreierec831ea2011-01-31 13:16:00 -08002230}
2231
David S. Miller6700c272012-07-17 03:29:28 -07002232static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2233 struct sk_buff *skb, u32 mtu)
David S. Miller14e50e52007-05-24 18:17:54 -07002234{
2235}
2236
David S. Miller6700c272012-07-17 03:29:28 -07002237static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2238 struct sk_buff *skb)
David S. Millerb587ee32012-07-12 00:39:24 -07002239{
2240}
2241
Held Bernhard0972ddb2011-04-24 22:07:32 +00002242static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2243 unsigned long old)
2244{
2245 return NULL;
2246}
2247
David S. Miller14e50e52007-05-24 18:17:54 -07002248static struct dst_ops ipv4_dst_blackhole_ops = {
2249 .family = AF_INET,
Jianzhao Wangae2688d2010-09-08 14:35:43 -07002250 .check = ipv4_blackhole_dst_check,
Steffen Klassertebb762f2011-11-23 02:12:51 +00002251 .mtu = ipv4_blackhole_mtu,
Eric Dumazet214f45c2011-02-18 11:39:01 -08002252 .default_advmss = ipv4_default_advmss,
David S. Miller14e50e52007-05-24 18:17:54 -07002253 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
David S. Millerb587ee32012-07-12 00:39:24 -07002254 .redirect = ipv4_rt_blackhole_redirect,
Held Bernhard0972ddb2011-04-24 22:07:32 +00002255 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
David S. Millerd3aaeb32011-07-18 00:40:17 -07002256 .neigh_lookup = ipv4_neigh_lookup,
David S. Miller14e50e52007-05-24 18:17:54 -07002257};
2258
David S. Miller2774c132011-03-01 14:59:04 -08002259struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
David S. Miller14e50e52007-05-24 18:17:54 -07002260{
David S. Miller2774c132011-03-01 14:59:04 -08002261 struct rtable *ort = (struct rtable *) dst_orig;
David S. Millerf5b0a872012-07-19 12:31:33 -07002262 struct rtable *rt;
David S. Miller14e50e52007-05-24 18:17:54 -07002263
David S. Millerf5b0a872012-07-19 12:31:33 -07002264 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE, 0);
David S. Miller14e50e52007-05-24 18:17:54 -07002265 if (rt) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002266 struct dst_entry *new = &rt->dst;
David S. Miller14e50e52007-05-24 18:17:54 -07002267
David S. Miller14e50e52007-05-24 18:17:54 -07002268 new->__use = 1;
Herbert Xu352e5122007-11-13 21:34:06 -08002269 new->input = dst_discard;
Eric Dumazetaad88722014-04-15 13:47:15 -04002270 new->output = dst_discard_sk;
David S. Miller14e50e52007-05-24 18:17:54 -07002271
Changli Gaod8d1f302010-06-10 23:31:35 -07002272 new->dev = ort->dst.dev;
David S. Miller14e50e52007-05-24 18:17:54 -07002273 if (new->dev)
2274 dev_hold(new->dev);
2275
David S. Miller9917e1e82012-07-17 14:44:26 -07002276 rt->rt_is_input = ort->rt_is_input;
David S. Miller5e2b61f2011-03-04 21:47:09 -08002277 rt->rt_iif = ort->rt_iif;
David S. Miller59436342012-07-10 06:58:42 -07002278 rt->rt_pmtu = ort->rt_pmtu;
David S. Miller14e50e52007-05-24 18:17:54 -07002279
fan.duca4c3fc2013-07-30 08:33:53 +08002280 rt->rt_genid = rt_genid_ipv4(net);
David S. Miller14e50e52007-05-24 18:17:54 -07002281 rt->rt_flags = ort->rt_flags;
2282 rt->rt_type = ort->rt_type;
David S. Miller14e50e52007-05-24 18:17:54 -07002283 rt->rt_gateway = ort->rt_gateway;
Julian Anastasov155e8332012-10-08 11:41:18 +00002284 rt->rt_uses_gateway = ort->rt_uses_gateway;
David S. Miller14e50e52007-05-24 18:17:54 -07002285
David S. Millercaacf052012-07-31 15:06:50 -07002286 INIT_LIST_HEAD(&rt->rt_uncached);
David S. Miller14e50e52007-05-24 18:17:54 -07002287 dst_free(new);
2288 }
2289
David S. Miller2774c132011-03-01 14:59:04 -08002290 dst_release(dst_orig);
2291
2292 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
David S. Miller14e50e52007-05-24 18:17:54 -07002293}
2294
David S. Miller9d6ec932011-03-12 01:12:47 -05002295struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
Eric Dumazet6f9c9612015-09-25 07:39:10 -07002296 const struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297{
David S. Miller9d6ec932011-03-12 01:12:47 -05002298 struct rtable *rt = __ip_route_output_key(net, flp4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299
David S. Millerb23dd4f2011-03-02 14:31:35 -08002300 if (IS_ERR(rt))
2301 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302
David S. Miller56157872011-05-02 14:37:45 -07002303 if (flp4->flowi4_proto)
Steffen Klassertf92ee612014-09-16 10:08:40 +02002304 rt = (struct rtable *)xfrm_lookup_route(net, &rt->dst,
2305 flowi4_to_flowi(flp4),
2306 sk, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307
David S. Millerb23dd4f2011-03-02 14:31:35 -08002308 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309}
Arnaldo Carvalho de Melod8c97a92005-08-09 20:12:12 -07002310EXPORT_SYMBOL_GPL(ip_route_output_flow);
2311
David Ahernc36ba662015-09-02 13:58:36 -07002312static int rt_fill_info(struct net *net, __be32 dst, __be32 src, u32 table_id,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002313 struct flowi4 *fl4, struct sk_buff *skb, u32 portid,
David S. Millerf1ce3062012-07-12 10:10:17 -07002314 u32 seq, int event, int nowait, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315{
Eric Dumazet511c3f92009-06-02 05:14:27 +00002316 struct rtable *rt = skb_rtable(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317 struct rtmsg *r;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002318 struct nlmsghdr *nlh;
Steffen Klassert2bc8ca42011-10-11 01:12:02 +00002319 unsigned long expires = 0;
David S. Millerf1850712012-07-10 07:26:01 -07002320 u32 error;
Julian Anastasov521f5492012-07-20 12:02:08 +03002321 u32 metrics[RTAX_MAX];
Thomas Grafbe403ea2006-08-17 18:15:17 -07002322
Eric W. Biederman15e47302012-09-07 20:12:54 +00002323 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*r), flags);
Ian Morris51456b22015-04-03 09:17:26 +01002324 if (!nlh)
Patrick McHardy26932562007-01-31 23:16:40 -08002325 return -EMSGSIZE;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002326
2327 r = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328 r->rtm_family = AF_INET;
2329 r->rtm_dst_len = 32;
2330 r->rtm_src_len = 0;
David Millerd6c0a4f2012-07-01 02:02:59 +00002331 r->rtm_tos = fl4->flowi4_tos;
David Ahernc36ba662015-09-02 13:58:36 -07002332 r->rtm_table = table_id;
2333 if (nla_put_u32(skb, RTA_TABLE, table_id))
David S. Millerf3756b72012-04-01 20:39:02 -04002334 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 r->rtm_type = rt->rt_type;
2336 r->rtm_scope = RT_SCOPE_UNIVERSE;
2337 r->rtm_protocol = RTPROT_UNSPEC;
2338 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2339 if (rt->rt_flags & RTCF_NOTIFY)
2340 r->rtm_flags |= RTM_F_NOTIFY;
Hannes Frederic Sowadf4d9252015-01-23 12:01:26 +01002341 if (IPCB(skb)->flags & IPSKB_DOREDIRECT)
2342 r->rtm_flags |= RTCF_DOREDIRECT;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002343
Jiri Benc930345e2015-03-29 16:59:25 +02002344 if (nla_put_in_addr(skb, RTA_DST, dst))
David S. Millerf3756b72012-04-01 20:39:02 -04002345 goto nla_put_failure;
David Miller1a00fee2012-07-01 02:02:56 +00002346 if (src) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 r->rtm_src_len = 32;
Jiri Benc930345e2015-03-29 16:59:25 +02002348 if (nla_put_in_addr(skb, RTA_SRC, src))
David S. Millerf3756b72012-04-01 20:39:02 -04002349 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350 }
David S. Millerf3756b72012-04-01 20:39:02 -04002351 if (rt->dst.dev &&
2352 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2353 goto nla_put_failure;
Patrick McHardyc7066f72011-01-14 13:36:42 +01002354#ifdef CONFIG_IP_ROUTE_CLASSID
David S. Millerf3756b72012-04-01 20:39:02 -04002355 if (rt->dst.tclassid &&
2356 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2357 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358#endif
David S. Miller41347dc2012-06-28 04:05:27 -07002359 if (!rt_is_input_route(rt) &&
David Millerd6c0a4f2012-07-01 02:02:59 +00002360 fl4->saddr != src) {
Jiri Benc930345e2015-03-29 16:59:25 +02002361 if (nla_put_in_addr(skb, RTA_PREFSRC, fl4->saddr))
David S. Millerf3756b72012-04-01 20:39:02 -04002362 goto nla_put_failure;
2363 }
Julian Anastasov155e8332012-10-08 11:41:18 +00002364 if (rt->rt_uses_gateway &&
Jiri Benc930345e2015-03-29 16:59:25 +02002365 nla_put_in_addr(skb, RTA_GATEWAY, rt->rt_gateway))
David S. Millerf3756b72012-04-01 20:39:02 -04002366 goto nla_put_failure;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002367
Steffen Klassertee9a8f72012-10-08 00:56:54 +00002368 expires = rt->dst.expires;
2369 if (expires) {
2370 unsigned long now = jiffies;
2371
2372 if (time_before(now, expires))
2373 expires -= now;
2374 else
2375 expires = 0;
2376 }
2377
Julian Anastasov521f5492012-07-20 12:02:08 +03002378 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
Steffen Klassertee9a8f72012-10-08 00:56:54 +00002379 if (rt->rt_pmtu && expires)
Julian Anastasov521f5492012-07-20 12:02:08 +03002380 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2381 if (rtnetlink_put_metrics(skb, metrics) < 0)
Thomas Grafbe403ea2006-08-17 18:15:17 -07002382 goto nla_put_failure;
2383
David Millerb4869882012-07-01 02:03:01 +00002384 if (fl4->flowi4_mark &&
stephen hemminger68aaed52012-10-10 08:27:25 +00002385 nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
David S. Millerf3756b72012-04-01 20:39:02 -04002386 goto nla_put_failure;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002387
Changli Gaod8d1f302010-06-10 23:31:35 -07002388 error = rt->dst.error;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002389
David S. Millerc7537962010-11-11 17:07:48 -08002390 if (rt_is_input_route(rt)) {
Nicolas Dichtel8caaf7b2012-12-04 01:03:07 +00002391#ifdef CONFIG_IP_MROUTE
2392 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2393 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2394 int err = ipmr_get_route(net, skb,
2395 fl4->saddr, fl4->daddr,
2396 r, nowait);
2397 if (err <= 0) {
2398 if (!nowait) {
2399 if (err == 0)
2400 return 0;
2401 goto nla_put_failure;
2402 } else {
2403 if (err == -EMSGSIZE)
2404 goto nla_put_failure;
2405 error = err;
2406 }
2407 }
2408 } else
2409#endif
Julian Anastasov91146152014-04-13 18:08:02 +03002410 if (nla_put_u32(skb, RTA_IIF, skb->dev->ifindex))
Nicolas Dichtel8caaf7b2012-12-04 01:03:07 +00002411 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412 }
2413
David S. Millerf1850712012-07-10 07:26:01 -07002414 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
Thomas Grafe3703b32006-11-27 09:27:07 -08002415 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416
Johannes Berg053c0952015-01-16 22:09:00 +01002417 nlmsg_end(skb, nlh);
2418 return 0;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002419
2420nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002421 nlmsg_cancel(skb, nlh);
2422 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423}
2424
Thomas Graf661d2962013-03-21 07:45:29 +00002425static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002427 struct net *net = sock_net(in_skb->sk);
Thomas Grafd889ce32006-08-17 18:15:44 -07002428 struct rtmsg *rtm;
2429 struct nlattr *tb[RTA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430 struct rtable *rt = NULL;
David Millerd6c0a4f2012-07-01 02:02:59 +00002431 struct flowi4 fl4;
Al Viro9e12bb22006-09-26 21:25:20 -07002432 __be32 dst = 0;
2433 __be32 src = 0;
2434 u32 iif;
Thomas Grafd889ce32006-08-17 18:15:44 -07002435 int err;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002436 int mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002437 struct sk_buff *skb;
David Ahernc36ba662015-09-02 13:58:36 -07002438 u32 table_id = RT_TABLE_MAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439
Thomas Grafd889ce32006-08-17 18:15:44 -07002440 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2441 if (err < 0)
2442 goto errout;
2443
2444 rtm = nlmsg_data(nlh);
2445
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01002447 if (!skb) {
Thomas Grafd889ce32006-08-17 18:15:44 -07002448 err = -ENOBUFS;
2449 goto errout;
2450 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451
2452 /* Reserve room for dummy headers, this skb can pass
2453 through good chunk of routing engine.
2454 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07002455 skb_reset_mac_header(skb);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07002456 skb_reset_network_header(skb);
Stephen Hemmingerd2c962b2006-04-17 17:27:11 -07002457
2458 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07002459 ip_hdr(skb)->protocol = IPPROTO_ICMP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2461
Jiri Benc67b61f62015-03-29 16:59:26 +02002462 src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0;
2463 dst = tb[RTA_DST] ? nla_get_in_addr(tb[RTA_DST]) : 0;
Thomas Grafd889ce32006-08-17 18:15:44 -07002464 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002465 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466
David Millerd6c0a4f2012-07-01 02:02:59 +00002467 memset(&fl4, 0, sizeof(fl4));
2468 fl4.daddr = dst;
2469 fl4.saddr = src;
2470 fl4.flowi4_tos = rtm->rtm_tos;
2471 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2472 fl4.flowi4_mark = mark;
2473
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474 if (iif) {
Thomas Grafd889ce32006-08-17 18:15:44 -07002475 struct net_device *dev;
2476
Denis V. Lunev19375042008-02-28 20:52:04 -08002477 dev = __dev_get_by_index(net, iif);
Ian Morris51456b22015-04-03 09:17:26 +01002478 if (!dev) {
Thomas Grafd889ce32006-08-17 18:15:44 -07002479 err = -ENODEV;
2480 goto errout_free;
2481 }
2482
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 skb->protocol = htons(ETH_P_IP);
2484 skb->dev = dev;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002485 skb->mark = mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002486 local_bh_disable();
2487 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2488 local_bh_enable();
Thomas Grafd889ce32006-08-17 18:15:44 -07002489
Eric Dumazet511c3f92009-06-02 05:14:27 +00002490 rt = skb_rtable(skb);
Changli Gaod8d1f302010-06-10 23:31:35 -07002491 if (err == 0 && rt->dst.error)
2492 err = -rt->dst.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 } else {
David S. Miller9d6ec932011-03-12 01:12:47 -05002494 rt = ip_route_output_key(net, &fl4);
David S. Millerb23dd4f2011-03-02 14:31:35 -08002495
2496 err = 0;
2497 if (IS_ERR(rt))
2498 err = PTR_ERR(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499 }
Thomas Grafd889ce32006-08-17 18:15:44 -07002500
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501 if (err)
Thomas Grafd889ce32006-08-17 18:15:44 -07002502 goto errout_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503
Changli Gaod8d1f302010-06-10 23:31:35 -07002504 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002505 if (rtm->rtm_flags & RTM_F_NOTIFY)
2506 rt->rt_flags |= RTCF_NOTIFY;
2507
David Ahernc36ba662015-09-02 13:58:36 -07002508 if (rtm->rtm_flags & RTM_F_LOOKUP_TABLE)
2509 table_id = rt->rt_table_id;
2510
2511 err = rt_fill_info(net, dst, src, table_id, &fl4, skb,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002512 NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
Denis V. Lunev19375042008-02-28 20:52:04 -08002513 RTM_NEWROUTE, 0, 0);
David S. Miller7b46a642015-01-18 23:36:08 -05002514 if (err < 0)
Thomas Grafd889ce32006-08-17 18:15:44 -07002515 goto errout_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516
Eric W. Biederman15e47302012-09-07 20:12:54 +00002517 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
Thomas Grafd889ce32006-08-17 18:15:44 -07002518errout:
Thomas Graf2942e902006-08-15 00:30:25 -07002519 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520
Thomas Grafd889ce32006-08-17 18:15:44 -07002521errout_free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522 kfree_skb(skb);
Thomas Grafd889ce32006-08-17 18:15:44 -07002523 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524}
2525
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526void ip_rt_multicast_event(struct in_device *in_dev)
2527{
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002528 rt_cache_flush(dev_net(in_dev->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529}
2530
2531#ifdef CONFIG_SYSCTL
Gao feng082c7ca2013-02-19 00:43:12 +00002532static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
2533static int ip_rt_gc_interval __read_mostly = 60 * HZ;
2534static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
2535static int ip_rt_gc_elasticity __read_mostly = 8;
2536
Joe Perchesfe2c6332013-06-11 23:04:25 -07002537static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002538 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539 size_t *lenp, loff_t *ppos)
2540{
Timo Teräs5aad1de2013-05-27 20:46:33 +00002541 struct net *net = (struct net *)__ctl->extra1;
2542
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543 if (write) {
Timo Teräs5aad1de2013-05-27 20:46:33 +00002544 rt_cache_flush(net);
2545 fnhe_genid_bump(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546 return 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002547 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548
2549 return -EINVAL;
2550}
2551
Joe Perchesfe2c6332013-06-11 23:04:25 -07002552static struct ctl_table ipv4_route_table[] = {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002553 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554 .procname = "gc_thresh",
2555 .data = &ipv4_dst_ops.gc_thresh,
2556 .maxlen = sizeof(int),
2557 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002558 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559 },
2560 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561 .procname = "max_size",
2562 .data = &ip_rt_max_size,
2563 .maxlen = sizeof(int),
2564 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002565 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566 },
2567 {
2568 /* Deprecated. Use gc_min_interval_ms */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002569
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570 .procname = "gc_min_interval",
2571 .data = &ip_rt_gc_min_interval,
2572 .maxlen = sizeof(int),
2573 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002574 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575 },
2576 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 .procname = "gc_min_interval_ms",
2578 .data = &ip_rt_gc_min_interval,
2579 .maxlen = sizeof(int),
2580 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002581 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 },
2583 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584 .procname = "gc_timeout",
2585 .data = &ip_rt_gc_timeout,
2586 .maxlen = sizeof(int),
2587 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002588 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589 },
2590 {
Eric Dumazet9f28a2f2011-12-21 15:47:16 -05002591 .procname = "gc_interval",
2592 .data = &ip_rt_gc_interval,
2593 .maxlen = sizeof(int),
2594 .mode = 0644,
2595 .proc_handler = proc_dointvec_jiffies,
2596 },
2597 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598 .procname = "redirect_load",
2599 .data = &ip_rt_redirect_load,
2600 .maxlen = sizeof(int),
2601 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002602 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603 },
2604 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605 .procname = "redirect_number",
2606 .data = &ip_rt_redirect_number,
2607 .maxlen = sizeof(int),
2608 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002609 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610 },
2611 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612 .procname = "redirect_silence",
2613 .data = &ip_rt_redirect_silence,
2614 .maxlen = sizeof(int),
2615 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002616 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617 },
2618 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619 .procname = "error_cost",
2620 .data = &ip_rt_error_cost,
2621 .maxlen = sizeof(int),
2622 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002623 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624 },
2625 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626 .procname = "error_burst",
2627 .data = &ip_rt_error_burst,
2628 .maxlen = sizeof(int),
2629 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002630 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631 },
2632 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002633 .procname = "gc_elasticity",
2634 .data = &ip_rt_gc_elasticity,
2635 .maxlen = sizeof(int),
2636 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002637 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638 },
2639 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 .procname = "mtu_expires",
2641 .data = &ip_rt_mtu_expires,
2642 .maxlen = sizeof(int),
2643 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002644 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 },
2646 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647 .procname = "min_pmtu",
2648 .data = &ip_rt_min_pmtu,
2649 .maxlen = sizeof(int),
2650 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002651 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 },
2653 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654 .procname = "min_adv_mss",
2655 .data = &ip_rt_min_advmss,
2656 .maxlen = sizeof(int),
2657 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002658 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002660 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661};
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002662
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002663static struct ctl_table ipv4_route_flush_table[] = {
2664 {
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002665 .procname = "flush",
2666 .maxlen = sizeof(int),
2667 .mode = 0200,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002668 .proc_handler = ipv4_sysctl_rtcache_flush,
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002669 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002670 { },
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002671};
2672
2673static __net_init int sysctl_route_net_init(struct net *net)
2674{
2675 struct ctl_table *tbl;
2676
2677 tbl = ipv4_route_flush_table;
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08002678 if (!net_eq(net, &init_net)) {
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002679 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01002680 if (!tbl)
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002681 goto err_dup;
Eric W. Biederman464dc802012-11-16 03:02:59 +00002682
2683 /* Don't export sysctls to unprivileged users */
2684 if (net->user_ns != &init_user_ns)
2685 tbl[0].procname = NULL;
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002686 }
2687 tbl[0].extra1 = net;
2688
Eric W. Biedermanec8f23c2012-04-19 13:44:49 +00002689 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
Ian Morris51456b22015-04-03 09:17:26 +01002690 if (!net->ipv4.route_hdr)
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002691 goto err_reg;
2692 return 0;
2693
2694err_reg:
2695 if (tbl != ipv4_route_flush_table)
2696 kfree(tbl);
2697err_dup:
2698 return -ENOMEM;
2699}
2700
2701static __net_exit void sysctl_route_net_exit(struct net *net)
2702{
2703 struct ctl_table *tbl;
2704
2705 tbl = net->ipv4.route_hdr->ctl_table_arg;
2706 unregister_net_sysctl_table(net->ipv4.route_hdr);
2707 BUG_ON(tbl == ipv4_route_flush_table);
2708 kfree(tbl);
2709}
2710
2711static __net_initdata struct pernet_operations sysctl_route_ops = {
2712 .init = sysctl_route_net_init,
2713 .exit = sysctl_route_net_exit,
2714};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715#endif
2716
Neil Horman3ee94372010-05-08 01:57:52 -07002717static __net_init int rt_genid_init(struct net *net)
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002718{
fan.duca4c3fc2013-07-30 08:33:53 +08002719 atomic_set(&net->ipv4.rt_genid, 0);
Timo Teräs5aad1de2013-05-27 20:46:33 +00002720 atomic_set(&net->fnhe_genid, 0);
David S. Miller436c3b62011-03-24 17:42:21 -07002721 get_random_bytes(&net->ipv4.dev_addr_genid,
2722 sizeof(net->ipv4.dev_addr_genid));
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002723 return 0;
2724}
2725
Neil Horman3ee94372010-05-08 01:57:52 -07002726static __net_initdata struct pernet_operations rt_genid_ops = {
2727 .init = rt_genid_init,
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002728};
2729
David S. Millerc3426b42012-06-09 16:27:05 -07002730static int __net_init ipv4_inetpeer_init(struct net *net)
2731{
2732 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2733
2734 if (!bp)
2735 return -ENOMEM;
2736 inet_peer_base_init(bp);
2737 net->ipv4.peers = bp;
2738 return 0;
2739}
2740
2741static void __net_exit ipv4_inetpeer_exit(struct net *net)
2742{
2743 struct inet_peer_base *bp = net->ipv4.peers;
2744
2745 net->ipv4.peers = NULL;
David S. Miller56a6b242012-06-09 16:32:41 -07002746 inetpeer_invalidate_tree(bp);
David S. Millerc3426b42012-06-09 16:27:05 -07002747 kfree(bp);
2748}
2749
2750static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
2751 .init = ipv4_inetpeer_init,
2752 .exit = ipv4_inetpeer_exit,
2753};
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002754
Patrick McHardyc7066f72011-01-14 13:36:42 +01002755#ifdef CONFIG_IP_ROUTE_CLASSID
Tejun Heo7d720c32010-02-16 15:20:26 +00002756struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
Patrick McHardyc7066f72011-01-14 13:36:42 +01002757#endif /* CONFIG_IP_ROUTE_CLASSID */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759int __init ip_rt_init(void)
2760{
Eric Dumazet424c4b72005-07-05 14:58:19 -07002761 int rc = 0;
Eric Dumazet5055c372015-01-14 15:17:06 -08002762 int cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763
Eric Dumazet73f156a2014-06-02 05:26:03 -07002764 ip_idents = kmalloc(IP_IDENTS_SZ * sizeof(*ip_idents), GFP_KERNEL);
2765 if (!ip_idents)
2766 panic("IP: failed to allocate ip_idents\n");
2767
2768 prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));
2769
Eric Dumazet355b590c2015-05-01 10:37:49 -07002770 ip_tstamps = kcalloc(IP_IDENTS_SZ, sizeof(*ip_tstamps), GFP_KERNEL);
2771 if (!ip_tstamps)
2772 panic("IP: failed to allocate ip_tstamps\n");
2773
Eric Dumazet5055c372015-01-14 15:17:06 -08002774 for_each_possible_cpu(cpu) {
2775 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
2776
2777 INIT_LIST_HEAD(&ul->head);
2778 spin_lock_init(&ul->lock);
2779 }
Patrick McHardyc7066f72011-01-14 13:36:42 +01002780#ifdef CONFIG_IP_ROUTE_CLASSID
Ingo Molnar0dcec8c2009-02-25 14:07:33 +01002781 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 if (!ip_rt_acct)
2783 panic("IP: failed to allocate ip_rt_acct\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002784#endif
2785
Alexey Dobriyane5d679f332006-08-26 19:25:52 -07002786 ipv4_dst_ops.kmem_cachep =
2787 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09002788 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789
David S. Miller14e50e52007-05-24 18:17:54 -07002790 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
2791
Eric Dumazetfc66f952010-10-08 06:37:34 +00002792 if (dst_entries_init(&ipv4_dst_ops) < 0)
2793 panic("IP: failed to allocate ipv4_dst_ops counter\n");
2794
2795 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
2796 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
2797
David S. Miller89aef892012-07-17 11:00:09 -07002798 ipv4_dst_ops.gc_thresh = ~0;
2799 ip_rt_max_size = INT_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801 devinet_init();
2802 ip_fib_init();
2803
Denis V. Lunev73b38712008-02-28 20:51:18 -08002804 if (ip_rt_proc_init())
Joe Perches058bd4d2012-03-11 18:36:11 +00002805 pr_err("Unable to create route proc files\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806#ifdef CONFIG_XFRM
2807 xfrm_init();
Steffen Klassert703fb942012-11-13 08:52:24 +01002808 xfrm4_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002809#endif
Greg Rosec7ac8672011-06-10 01:27:09 +00002810 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL, NULL);
Thomas Graf63f34442007-03-22 11:55:17 -07002811
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002812#ifdef CONFIG_SYSCTL
2813 register_pernet_subsys(&sysctl_route_ops);
2814#endif
Neil Horman3ee94372010-05-08 01:57:52 -07002815 register_pernet_subsys(&rt_genid_ops);
David S. Millerc3426b42012-06-09 16:27:05 -07002816 register_pernet_subsys(&ipv4_inetpeer_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002817 return rc;
2818}
2819
Al Viroa1bc6eb2008-07-30 06:32:52 -04002820#ifdef CONFIG_SYSCTL
Al Viroeeb61f72008-07-27 08:59:33 +01002821/*
2822 * We really need to sanitize the damn ipv4 init order, then all
2823 * this nonsense will go away.
2824 */
2825void __init ip_static_sysctl_init(void)
2826{
Eric W. Biederman4e5ca782012-04-19 13:32:39 +00002827 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);
Al Viroeeb61f72008-07-27 08:59:33 +01002828}
Al Viroa1bc6eb2008-07-30 06:32:52 -04002829#endif