blob: 0c63b2abd873fb2102cb5cc34dd80e5d3a26db88 [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>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020094#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070095#include <net/protocol.h>
96#include <net/ip.h>
97#include <net/route.h>
98#include <net/inetpeer.h>
99#include <net/sock.h>
100#include <net/ip_fib.h>
101#include <net/arp.h>
102#include <net/tcp.h>
103#include <net/icmp.h>
104#include <net/xfrm.h>
Tom Tucker8d717402006-07-30 20:43:36 -0700105#include <net/netevent.h>
Thomas Graf63f34442007-03-22 11:55:17 -0700106#include <net/rtnetlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107#ifdef CONFIG_SYSCTL
108#include <linux/sysctl.h>
Shan Wei7426a562012-04-18 18:05:46 +0000109#include <linux/kmemleak.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110#endif
David S. Miller6e5714e2011-08-03 20:50:44 -0700111#include <net/secure_seq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
David S. Miller68a5e3d2011-03-11 20:07:33 -0500113#define RT_FL_TOS(oldflp4) \
Julian Anastasovf61759e2011-12-02 11:39:42 +0000114 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116#define RT_GC_TIMEOUT (300*HZ)
117
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118static int ip_rt_max_size;
Stephen Hemminger817bc4d2008-03-22 17:43:59 -0700119static int ip_rt_redirect_number __read_mostly = 9;
120static int ip_rt_redirect_load __read_mostly = HZ / 50;
121static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
122static int ip_rt_error_cost __read_mostly = HZ;
123static int ip_rt_error_burst __read_mostly = 5 * HZ;
Stephen Hemminger817bc4d2008-03-22 17:43:59 -0700124static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
125static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
126static int ip_rt_min_advmss __read_mostly = 256;
Eric Dumazet9f28a2f2011-12-21 15:47:16 -0500127
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128/*
129 * Interface to generic destination cache.
130 */
131
132static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
David S. Miller0dbaee32010-12-13 12:52:14 -0800133static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
Steffen Klassertebb762f2011-11-23 02:12:51 +0000134static unsigned int ipv4_mtu(const struct dst_entry *dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
136static void ipv4_link_failure(struct sk_buff *skb);
David S. Miller6700c272012-07-17 03:29:28 -0700137static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
138 struct sk_buff *skb, u32 mtu);
139static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,
140 struct sk_buff *skb);
David S. Millercaacf052012-07-31 15:06:50 -0700141static void ipv4_dst_destroy(struct dst_entry *dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
David S. Miller62fa8a82011-01-26 20:51:05 -0800143static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
144{
David S. Miller31248732012-07-10 07:08:18 -0700145 WARN_ON(1);
146 return NULL;
David S. Miller62fa8a82011-01-26 20:51:05 -0800147}
148
David S. Millerf894cbf2012-07-02 21:52:24 -0700149static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
150 struct sk_buff *skb,
151 const void *daddr);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153static struct dst_ops ipv4_dst_ops = {
154 .family = AF_INET,
Harvey Harrison09640e62009-02-01 00:45:17 -0800155 .protocol = cpu_to_be16(ETH_P_IP),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 .check = ipv4_dst_check,
David S. Miller0dbaee32010-12-13 12:52:14 -0800157 .default_advmss = ipv4_default_advmss,
Steffen Klassertebb762f2011-11-23 02:12:51 +0000158 .mtu = ipv4_mtu,
David S. Miller62fa8a82011-01-26 20:51:05 -0800159 .cow_metrics = ipv4_cow_metrics,
David S. Millercaacf052012-07-31 15:06:50 -0700160 .destroy = ipv4_dst_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 .negative_advice = ipv4_negative_advice,
162 .link_failure = ipv4_link_failure,
163 .update_pmtu = ip_rt_update_pmtu,
David S. Millere47a1852012-07-11 20:55:47 -0700164 .redirect = ip_do_redirect,
Herbert Xu1ac06e02008-05-20 14:32:14 -0700165 .local_out = __ip_local_out,
David S. Millerd3aaeb32011-07-18 00:40:17 -0700166 .neigh_lookup = ipv4_neigh_lookup,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167};
168
169#define ECN_OR_COST(class) TC_PRIO_##class
170
Philippe De Muyter4839c522007-07-09 15:32:57 -0700171const __u8 ip_tos2prio[16] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 TC_PRIO_BESTEFFORT,
Dan Siemon4a2b9c32011-03-15 13:56:07 +0000173 ECN_OR_COST(BESTEFFORT),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 TC_PRIO_BESTEFFORT,
175 ECN_OR_COST(BESTEFFORT),
176 TC_PRIO_BULK,
177 ECN_OR_COST(BULK),
178 TC_PRIO_BULK,
179 ECN_OR_COST(BULK),
180 TC_PRIO_INTERACTIVE,
181 ECN_OR_COST(INTERACTIVE),
182 TC_PRIO_INTERACTIVE,
183 ECN_OR_COST(INTERACTIVE),
184 TC_PRIO_INTERACTIVE_BULK,
185 ECN_OR_COST(INTERACTIVE_BULK),
186 TC_PRIO_INTERACTIVE_BULK,
187 ECN_OR_COST(INTERACTIVE_BULK)
188};
Amir Vadaid4a96862012-04-04 21:33:28 +0000189EXPORT_SYMBOL(ip_tos2prio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
Eric Dumazet2f970d82006-01-17 02:54:36 -0800191static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
Christoph Lameter3ed66e92014-04-07 15:39:40 -0700192#define RT_CACHE_STAT_INC(field) raw_cpu_inc(rt_cache_stat.field)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
196{
Eric Dumazet29e75252008-01-31 17:05:09 -0800197 if (*pos)
David S. Miller89aef892012-07-17 11:00:09 -0700198 return NULL;
Eric Dumazet29e75252008-01-31 17:05:09 -0800199 return SEQ_START_TOKEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200}
201
202static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
203{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 ++*pos;
David S. Miller89aef892012-07-17 11:00:09 -0700205 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206}
207
208static void rt_cache_seq_stop(struct seq_file *seq, void *v)
209{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210}
211
212static int rt_cache_seq_show(struct seq_file *seq, void *v)
213{
214 if (v == SEQ_START_TOKEN)
215 seq_printf(seq, "%-127s\n",
216 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
217 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
218 "HHUptod\tSpecDst");
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900219 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220}
221
Stephen Hemmingerf6908082007-03-12 14:34:29 -0700222static const struct seq_operations rt_cache_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 .start = rt_cache_seq_start,
224 .next = rt_cache_seq_next,
225 .stop = rt_cache_seq_stop,
226 .show = rt_cache_seq_show,
227};
228
229static int rt_cache_seq_open(struct inode *inode, struct file *file)
230{
David S. Miller89aef892012-07-17 11:00:09 -0700231 return seq_open(file, &rt_cache_seq_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232}
233
Arjan van de Ven9a321442007-02-12 00:55:35 -0800234static const struct file_operations rt_cache_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 .owner = THIS_MODULE,
236 .open = rt_cache_seq_open,
237 .read = seq_read,
238 .llseek = seq_lseek,
David S. Miller89aef892012-07-17 11:00:09 -0700239 .release = seq_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240};
241
242
243static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
244{
245 int cpu;
246
247 if (*pos == 0)
248 return SEQ_START_TOKEN;
249
Rusty Russell0f23174a2008-12-29 12:23:42 +0000250 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 if (!cpu_possible(cpu))
252 continue;
253 *pos = cpu+1;
Eric Dumazet2f970d82006-01-17 02:54:36 -0800254 return &per_cpu(rt_cache_stat, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 }
256 return NULL;
257}
258
259static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
260{
261 int cpu;
262
Rusty Russell0f23174a2008-12-29 12:23:42 +0000263 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 if (!cpu_possible(cpu))
265 continue;
266 *pos = cpu+1;
Eric Dumazet2f970d82006-01-17 02:54:36 -0800267 return &per_cpu(rt_cache_stat, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 }
269 return NULL;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271}
272
273static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
274{
275
276}
277
278static int rt_cpu_seq_show(struct seq_file *seq, void *v)
279{
280 struct rt_cache_stat *st = v;
281
282 if (v == SEQ_START_TOKEN) {
Olaf Rempel5bec0032005-04-28 12:16:08 -0700283 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 -0700284 return 0;
285 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
288 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
Eric Dumazetfc66f952010-10-08 06:37:34 +0000289 dst_entries_get_slow(&ipv4_dst_ops),
Eric Dumazet0baf2b32013-10-16 02:49:04 -0700290 0, /* st->in_hit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 st->in_slow_tot,
292 st->in_slow_mc,
293 st->in_no_route,
294 st->in_brd,
295 st->in_martian_dst,
296 st->in_martian_src,
297
Eric Dumazet0baf2b32013-10-16 02:49:04 -0700298 0, /* st->out_hit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 st->out_slow_tot,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900300 st->out_slow_mc,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Eric Dumazet0baf2b32013-10-16 02:49:04 -0700302 0, /* st->gc_total */
303 0, /* st->gc_ignored */
304 0, /* st->gc_goal_miss */
305 0, /* st->gc_dst_overflow */
306 0, /* st->in_hlist_search */
307 0 /* st->out_hlist_search */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 );
309 return 0;
310}
311
Stephen Hemmingerf6908082007-03-12 14:34:29 -0700312static const struct seq_operations rt_cpu_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 .start = rt_cpu_seq_start,
314 .next = rt_cpu_seq_next,
315 .stop = rt_cpu_seq_stop,
316 .show = rt_cpu_seq_show,
317};
318
319
320static int rt_cpu_seq_open(struct inode *inode, struct file *file)
321{
322 return seq_open(file, &rt_cpu_seq_ops);
323}
324
Arjan van de Ven9a321442007-02-12 00:55:35 -0800325static const struct file_operations rt_cpu_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 .owner = THIS_MODULE,
327 .open = rt_cpu_seq_open,
328 .read = seq_read,
329 .llseek = seq_lseek,
330 .release = seq_release,
331};
332
Patrick McHardyc7066f72011-01-14 13:36:42 +0100333#ifdef CONFIG_IP_ROUTE_CLASSID
Alexey Dobriyana661c412009-11-25 15:40:35 -0800334static int rt_acct_proc_show(struct seq_file *m, void *v)
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800335{
Alexey Dobriyana661c412009-11-25 15:40:35 -0800336 struct ip_rt_acct *dst, *src;
337 unsigned int i, j;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800338
Alexey Dobriyana661c412009-11-25 15:40:35 -0800339 dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
340 if (!dst)
341 return -ENOMEM;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800342
Alexey Dobriyana661c412009-11-25 15:40:35 -0800343 for_each_possible_cpu(i) {
344 src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
345 for (j = 0; j < 256; j++) {
346 dst[j].o_bytes += src[j].o_bytes;
347 dst[j].o_packets += src[j].o_packets;
348 dst[j].i_bytes += src[j].i_bytes;
349 dst[j].i_packets += src[j].i_packets;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800350 }
351 }
Alexey Dobriyana661c412009-11-25 15:40:35 -0800352
353 seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
354 kfree(dst);
355 return 0;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800356}
Alexey Dobriyana661c412009-11-25 15:40:35 -0800357
358static int rt_acct_proc_open(struct inode *inode, struct file *file)
359{
360 return single_open(file, rt_acct_proc_show, NULL);
361}
362
363static const struct file_operations rt_acct_proc_fops = {
364 .owner = THIS_MODULE,
365 .open = rt_acct_proc_open,
366 .read = seq_read,
367 .llseek = seq_lseek,
368 .release = single_release,
369};
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800370#endif
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800371
Denis V. Lunev73b38712008-02-28 20:51:18 -0800372static int __net_init ip_rt_do_proc_init(struct net *net)
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800373{
374 struct proc_dir_entry *pde;
375
Gao fengd4beaa62013-02-18 01:34:54 +0000376 pde = proc_create("rt_cache", S_IRUGO, net->proc_net,
377 &rt_cache_seq_fops);
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800378 if (!pde)
379 goto err1;
380
Wang Chen77020722008-02-28 14:14:25 -0800381 pde = proc_create("rt_cache", S_IRUGO,
382 net->proc_net_stat, &rt_cpu_seq_fops);
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800383 if (!pde)
384 goto err2;
385
Patrick McHardyc7066f72011-01-14 13:36:42 +0100386#ifdef CONFIG_IP_ROUTE_CLASSID
Alexey Dobriyana661c412009-11-25 15:40:35 -0800387 pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800388 if (!pde)
389 goto err3;
390#endif
391 return 0;
392
Patrick McHardyc7066f72011-01-14 13:36:42 +0100393#ifdef CONFIG_IP_ROUTE_CLASSID
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800394err3:
395 remove_proc_entry("rt_cache", net->proc_net_stat);
396#endif
397err2:
398 remove_proc_entry("rt_cache", net->proc_net);
399err1:
400 return -ENOMEM;
401}
Denis V. Lunev73b38712008-02-28 20:51:18 -0800402
403static void __net_exit ip_rt_do_proc_exit(struct net *net)
404{
405 remove_proc_entry("rt_cache", net->proc_net_stat);
406 remove_proc_entry("rt_cache", net->proc_net);
Patrick McHardyc7066f72011-01-14 13:36:42 +0100407#ifdef CONFIG_IP_ROUTE_CLASSID
Denis V. Lunev73b38712008-02-28 20:51:18 -0800408 remove_proc_entry("rt_acct", net->proc_net);
Alexey Dobriyan0a931ac2010-01-17 03:32:50 +0000409#endif
Denis V. Lunev73b38712008-02-28 20:51:18 -0800410}
411
412static struct pernet_operations ip_rt_proc_ops __net_initdata = {
413 .init = ip_rt_do_proc_init,
414 .exit = ip_rt_do_proc_exit,
415};
416
417static int __init ip_rt_proc_init(void)
418{
419 return register_pernet_subsys(&ip_rt_proc_ops);
420}
421
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800422#else
Denis V. Lunev73b38712008-02-28 20:51:18 -0800423static inline int ip_rt_proc_init(void)
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800424{
425 return 0;
426}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427#endif /* CONFIG_PROC_FS */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900428
Eric Dumazet4331deb2012-07-25 05:11:23 +0000429static inline bool rt_is_expired(const struct rtable *rth)
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700430{
fan.duca4c3fc2013-07-30 08:33:53 +0800431 return rth->rt_genid != rt_genid_ipv4(dev_net(rth->dst.dev));
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700432}
433
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +0000434void rt_cache_flush(struct net *net)
Eric Dumazet29e75252008-01-31 17:05:09 -0800435{
fan.duca4c3fc2013-07-30 08:33:53 +0800436 rt_genid_bump_ipv4(net);
Eric Dumazet98376382010-03-08 03:20:00 +0000437}
438
David S. Millerf894cbf2012-07-02 21:52:24 -0700439static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
440 struct sk_buff *skb,
441 const void *daddr)
David Miller3769cff2011-07-11 22:44:24 +0000442{
David S. Millerd3aaeb32011-07-18 00:40:17 -0700443 struct net_device *dev = dst->dev;
444 const __be32 *pkey = daddr;
David S. Miller39232972012-01-26 15:22:32 -0500445 const struct rtable *rt;
David Miller3769cff2011-07-11 22:44:24 +0000446 struct neighbour *n;
447
David S. Miller39232972012-01-26 15:22:32 -0500448 rt = (const struct rtable *) dst;
David S. Millera263b302012-07-02 02:02:15 -0700449 if (rt->rt_gateway)
David S. Miller39232972012-01-26 15:22:32 -0500450 pkey = (const __be32 *) &rt->rt_gateway;
David S. Millerf894cbf2012-07-02 21:52:24 -0700451 else if (skb)
452 pkey = &ip_hdr(skb)->daddr;
David S. Millerd3aaeb32011-07-18 00:40:17 -0700453
David S. Miller80703d22012-02-15 17:48:35 -0500454 n = __ipv4_neigh_lookup(dev, *(__force u32 *)pkey);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700455 if (n)
456 return n;
David Miller32092ec2011-07-25 00:01:41 +0000457 return neigh_create(&arp_tbl, pkey, dev);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700458}
459
Eric Dumazet04ca6972014-07-26 08:58:10 +0200460#define IP_IDENTS_SZ 2048u
461struct ip_ident_bucket {
462 atomic_t id;
463 u32 stamp32;
464};
465
466static struct ip_ident_bucket *ip_idents __read_mostly;
467
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{
474 struct ip_ident_bucket *bucket = ip_idents + hash % IP_IDENTS_SZ;
475 u32 old = ACCESS_ONCE(bucket->stamp32);
476 u32 now = (u32)jiffies;
477 u32 delta = 0;
478
479 if (old != now && cmpxchg(&bucket->stamp32, old, now) == old)
480 delta = prandom_u32_max(now - old);
481
482 return atomic_add_return(segs + delta, &bucket->id) - segs;
483}
484EXPORT_SYMBOL(ip_idents_reserve);
Eric Dumazet73f156a2014-06-02 05:26:03 -0700485
486void __ip_select_ident(struct iphdr *iph, int segs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487{
Eric Dumazet73f156a2014-06-02 05:26:03 -0700488 static u32 ip_idents_hashrnd __read_mostly;
489 u32 hash, id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Eric Dumazet73f156a2014-06-02 05:26:03 -0700491 net_get_random_once(&ip_idents_hashrnd, sizeof(ip_idents_hashrnd));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
Eric Dumazet04ca6972014-07-26 08:58:10 +0200493 hash = jhash_3words((__force u32)iph->daddr,
494 (__force u32)iph->saddr,
495 iph->protocol,
496 ip_idents_hashrnd);
Eric Dumazet73f156a2014-06-02 05:26:03 -0700497 id = ip_idents_reserve(hash, segs);
498 iph->id = htons(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000500EXPORT_SYMBOL(__ip_select_ident);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200502static void __build_flow_key(struct flowi4 *fl4, const struct sock *sk,
David S. Miller4895c772012-07-17 04:19:00 -0700503 const struct iphdr *iph,
504 int oif, u8 tos,
505 u8 prot, u32 mark, int flow_flags)
506{
507 if (sk) {
508 const struct inet_sock *inet = inet_sk(sk);
509
510 oif = sk->sk_bound_dev_if;
511 mark = sk->sk_mark;
512 tos = RT_CONN_FLAGS(sk);
513 prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
514 }
515 flowi4_init_output(fl4, oif, mark, tos,
516 RT_SCOPE_UNIVERSE, prot,
517 flow_flags,
518 iph->daddr, iph->saddr, 0, 0);
519}
520
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200521static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
522 const struct sock *sk)
David S. Miller4895c772012-07-17 04:19:00 -0700523{
524 const struct iphdr *iph = ip_hdr(skb);
525 int oif = skb->dev->ifindex;
526 u8 tos = RT_TOS(iph->tos);
527 u8 prot = iph->protocol;
528 u32 mark = skb->mark;
529
530 __build_flow_key(fl4, sk, iph, oif, tos, prot, mark, 0);
531}
532
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200533static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
David S. Miller4895c772012-07-17 04:19:00 -0700534{
535 const struct inet_sock *inet = inet_sk(sk);
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200536 const struct ip_options_rcu *inet_opt;
David S. Miller4895c772012-07-17 04:19:00 -0700537 __be32 daddr = inet->inet_daddr;
538
539 rcu_read_lock();
540 inet_opt = rcu_dereference(inet->inet_opt);
541 if (inet_opt && inet_opt->opt.srr)
542 daddr = inet_opt->opt.faddr;
543 flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
544 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
545 inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
546 inet_sk_flowi_flags(sk),
547 daddr, inet->inet_saddr, 0, 0);
548 rcu_read_unlock();
549}
550
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200551static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
552 const struct sk_buff *skb)
David S. Miller4895c772012-07-17 04:19:00 -0700553{
554 if (skb)
555 build_skb_flow_key(fl4, skb, sk);
556 else
557 build_sk_flow_key(fl4, sk);
558}
559
David S. Millerc5038a82012-07-31 15:02:02 -0700560static inline void rt_free(struct rtable *rt)
561{
562 call_rcu(&rt->dst.rcu_head, dst_rcu_free);
563}
564
565static DEFINE_SPINLOCK(fnhe_lock);
David S. Miller4895c772012-07-17 04:19:00 -0700566
Timo Teräs2ffae992013-06-27 10:27:05 +0300567static void fnhe_flush_routes(struct fib_nh_exception *fnhe)
568{
569 struct rtable *rt;
570
571 rt = rcu_dereference(fnhe->fnhe_rth_input);
572 if (rt) {
573 RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL);
574 rt_free(rt);
575 }
576 rt = rcu_dereference(fnhe->fnhe_rth_output);
577 if (rt) {
578 RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL);
579 rt_free(rt);
580 }
581}
582
Julian Anastasovaee06da2012-07-18 10:15:35 +0000583static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
David S. Miller4895c772012-07-17 04:19:00 -0700584{
585 struct fib_nh_exception *fnhe, *oldest;
586
587 oldest = rcu_dereference(hash->chain);
588 for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
589 fnhe = rcu_dereference(fnhe->fnhe_next)) {
590 if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
591 oldest = fnhe;
592 }
Timo Teräs2ffae992013-06-27 10:27:05 +0300593 fnhe_flush_routes(oldest);
David S. Miller4895c772012-07-17 04:19:00 -0700594 return oldest;
595}
596
David S. Millerd3a25c92012-07-17 13:23:08 -0700597static inline u32 fnhe_hashfun(__be32 daddr)
598{
Eric Dumazetd546c622014-09-04 08:21:31 -0700599 static u32 fnhe_hashrnd __read_mostly;
David S. Millerd3a25c92012-07-17 13:23:08 -0700600 u32 hval;
601
Eric Dumazetd546c622014-09-04 08:21:31 -0700602 net_get_random_once(&fnhe_hashrnd, sizeof(fnhe_hashrnd));
603 hval = jhash_1word((__force u32) daddr, fnhe_hashrnd);
604 return hash_32(hval, FNHE_HASH_SHIFT);
David S. Millerd3a25c92012-07-17 13:23:08 -0700605}
606
Timo Teräs387aa652013-05-27 20:46:31 +0000607static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnhe)
608{
609 rt->rt_pmtu = fnhe->fnhe_pmtu;
610 rt->dst.expires = fnhe->fnhe_expires;
611
612 if (fnhe->fnhe_gw) {
613 rt->rt_flags |= RTCF_REDIRECTED;
614 rt->rt_gateway = fnhe->fnhe_gw;
615 rt->rt_uses_gateway = 1;
616 }
617}
618
Julian Anastasovaee06da2012-07-18 10:15:35 +0000619static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
620 u32 pmtu, unsigned long expires)
David S. Miller4895c772012-07-17 04:19:00 -0700621{
Julian Anastasovaee06da2012-07-18 10:15:35 +0000622 struct fnhe_hash_bucket *hash;
David S. Miller4895c772012-07-17 04:19:00 -0700623 struct fib_nh_exception *fnhe;
Timo Teräs387aa652013-05-27 20:46:31 +0000624 struct rtable *rt;
625 unsigned int i;
David S. Miller4895c772012-07-17 04:19:00 -0700626 int depth;
Julian Anastasovaee06da2012-07-18 10:15:35 +0000627 u32 hval = fnhe_hashfun(daddr);
David S. Miller4895c772012-07-17 04:19:00 -0700628
David S. Millerc5038a82012-07-31 15:02:02 -0700629 spin_lock_bh(&fnhe_lock);
Julian Anastasovaee06da2012-07-18 10:15:35 +0000630
Eric Dumazetcaa41522014-09-03 22:21:56 -0700631 hash = rcu_dereference(nh->nh_exceptions);
David S. Miller4895c772012-07-17 04:19:00 -0700632 if (!hash) {
Julian Anastasovaee06da2012-07-18 10:15:35 +0000633 hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC);
David S. Miller4895c772012-07-17 04:19:00 -0700634 if (!hash)
Julian Anastasovaee06da2012-07-18 10:15:35 +0000635 goto out_unlock;
Eric Dumazetcaa41522014-09-03 22:21:56 -0700636 rcu_assign_pointer(nh->nh_exceptions, hash);
David S. Miller4895c772012-07-17 04:19:00 -0700637 }
638
David S. Miller4895c772012-07-17 04:19:00 -0700639 hash += hval;
640
641 depth = 0;
642 for (fnhe = rcu_dereference(hash->chain); fnhe;
643 fnhe = rcu_dereference(fnhe->fnhe_next)) {
644 if (fnhe->fnhe_daddr == daddr)
Julian Anastasovaee06da2012-07-18 10:15:35 +0000645 break;
David S. Miller4895c772012-07-17 04:19:00 -0700646 depth++;
647 }
648
Julian Anastasovaee06da2012-07-18 10:15:35 +0000649 if (fnhe) {
650 if (gw)
651 fnhe->fnhe_gw = gw;
652 if (pmtu) {
653 fnhe->fnhe_pmtu = pmtu;
Timo Teräs387aa652013-05-27 20:46:31 +0000654 fnhe->fnhe_expires = max(1UL, expires);
Julian Anastasovaee06da2012-07-18 10:15:35 +0000655 }
Timo Teräs387aa652013-05-27 20:46:31 +0000656 /* Update all cached dsts too */
Timo Teräs2ffae992013-06-27 10:27:05 +0300657 rt = rcu_dereference(fnhe->fnhe_rth_input);
658 if (rt)
659 fill_route_from_fnhe(rt, fnhe);
660 rt = rcu_dereference(fnhe->fnhe_rth_output);
Timo Teräs387aa652013-05-27 20:46:31 +0000661 if (rt)
662 fill_route_from_fnhe(rt, fnhe);
Julian Anastasovaee06da2012-07-18 10:15:35 +0000663 } else {
664 if (depth > FNHE_RECLAIM_DEPTH)
665 fnhe = fnhe_oldest(hash);
666 else {
667 fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
668 if (!fnhe)
669 goto out_unlock;
670
671 fnhe->fnhe_next = hash->chain;
672 rcu_assign_pointer(hash->chain, fnhe);
673 }
Timo Teräs5aad1de2013-05-27 20:46:33 +0000674 fnhe->fnhe_genid = fnhe_genid(dev_net(nh->nh_dev));
Julian Anastasovaee06da2012-07-18 10:15:35 +0000675 fnhe->fnhe_daddr = daddr;
676 fnhe->fnhe_gw = gw;
677 fnhe->fnhe_pmtu = pmtu;
678 fnhe->fnhe_expires = expires;
Timo Teräs387aa652013-05-27 20:46:31 +0000679
680 /* Exception created; mark the cached routes for the nexthop
681 * stale, so anyone caching it rechecks if this exception
682 * applies to them.
683 */
Timo Teräs2ffae992013-06-27 10:27:05 +0300684 rt = rcu_dereference(nh->nh_rth_input);
685 if (rt)
686 rt->dst.obsolete = DST_OBSOLETE_KILL;
687
Timo Teräs387aa652013-05-27 20:46:31 +0000688 for_each_possible_cpu(i) {
689 struct rtable __rcu **prt;
690 prt = per_cpu_ptr(nh->nh_pcpu_rth_output, i);
691 rt = rcu_dereference(*prt);
692 if (rt)
693 rt->dst.obsolete = DST_OBSOLETE_KILL;
694 }
David S. Miller4895c772012-07-17 04:19:00 -0700695 }
David S. Miller4895c772012-07-17 04:19:00 -0700696
David S. Miller4895c772012-07-17 04:19:00 -0700697 fnhe->fnhe_stamp = jiffies;
Julian Anastasovaee06da2012-07-18 10:15:35 +0000698
699out_unlock:
David S. Millerc5038a82012-07-31 15:02:02 -0700700 spin_unlock_bh(&fnhe_lock);
David S. Miller4895c772012-07-17 04:19:00 -0700701}
702
David S. Millerceb33202012-07-17 11:31:28 -0700703static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
704 bool kill_route)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705{
David S. Millere47a1852012-07-11 20:55:47 -0700706 __be32 new_gw = icmp_hdr(skb)->un.gateway;
David S. Miller94206122012-07-11 20:38:08 -0700707 __be32 old_gw = ip_hdr(skb)->saddr;
David S. Millere47a1852012-07-11 20:55:47 -0700708 struct net_device *dev = skb->dev;
David S. Millere47a1852012-07-11 20:55:47 -0700709 struct in_device *in_dev;
David S. Miller4895c772012-07-17 04:19:00 -0700710 struct fib_result res;
David S. Millere47a1852012-07-11 20:55:47 -0700711 struct neighbour *n;
Denis V. Lunev317805b2008-02-28 20:50:06 -0800712 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713
David S. Miller94206122012-07-11 20:38:08 -0700714 switch (icmp_hdr(skb)->code & 7) {
715 case ICMP_REDIR_NET:
716 case ICMP_REDIR_NETTOS:
717 case ICMP_REDIR_HOST:
718 case ICMP_REDIR_HOSTTOS:
719 break;
720
721 default:
722 return;
723 }
724
David S. Millere47a1852012-07-11 20:55:47 -0700725 if (rt->rt_gateway != old_gw)
726 return;
727
728 in_dev = __in_dev_get_rcu(dev);
729 if (!in_dev)
730 return;
731
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900732 net = dev_net(dev);
Joe Perches9d4fb272009-11-23 10:41:23 -0800733 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
734 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
735 ipv4_is_zeronet(new_gw))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 goto reject_redirect;
737
738 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
739 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
740 goto reject_redirect;
741 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
742 goto reject_redirect;
743 } else {
Denis V. Lunev317805b2008-02-28 20:50:06 -0800744 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 goto reject_redirect;
746 }
747
David S. Miller4895c772012-07-17 04:19:00 -0700748 n = ipv4_neigh_lookup(&rt->dst, NULL, &new_gw);
WANG Cong2c1a4312014-09-24 17:07:53 -0700749 if (!IS_ERR(n)) {
David S. Millere47a1852012-07-11 20:55:47 -0700750 if (!(n->nud_state & NUD_VALID)) {
751 neigh_event_send(n, NULL);
752 } else {
David S. Miller4895c772012-07-17 04:19:00 -0700753 if (fib_lookup(net, fl4, &res) == 0) {
754 struct fib_nh *nh = &FIB_RES_NH(res);
David S. Miller4895c772012-07-17 04:19:00 -0700755
Julian Anastasovaee06da2012-07-18 10:15:35 +0000756 update_or_create_fnhe(nh, fl4->daddr, new_gw,
757 0, 0);
David S. Miller4895c772012-07-17 04:19:00 -0700758 }
David S. Millerceb33202012-07-17 11:31:28 -0700759 if (kill_route)
760 rt->dst.obsolete = DST_OBSOLETE_KILL;
David S. Millere47a1852012-07-11 20:55:47 -0700761 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
762 }
763 neigh_release(n);
764 }
765 return;
766
767reject_redirect:
768#ifdef CONFIG_IP_ROUTE_VERBOSE
David S. Miller99ee0382012-07-12 07:40:05 -0700769 if (IN_DEV_LOG_MARTIANS(in_dev)) {
770 const struct iphdr *iph = (const struct iphdr *) skb->data;
771 __be32 daddr = iph->daddr;
772 __be32 saddr = iph->saddr;
773
David S. Millere47a1852012-07-11 20:55:47 -0700774 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
775 " Advised path = %pI4 -> %pI4\n",
776 &old_gw, dev->name, &new_gw,
777 &saddr, &daddr);
David S. Miller99ee0382012-07-12 07:40:05 -0700778 }
David S. Millere47a1852012-07-11 20:55:47 -0700779#endif
780 ;
781}
782
David S. Miller4895c772012-07-17 04:19:00 -0700783static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
784{
785 struct rtable *rt;
786 struct flowi4 fl4;
Michal Kubecekf96ef982013-05-28 08:26:49 +0200787 const struct iphdr *iph = (const struct iphdr *) skb->data;
788 int oif = skb->dev->ifindex;
789 u8 tos = RT_TOS(iph->tos);
790 u8 prot = iph->protocol;
791 u32 mark = skb->mark;
David S. Miller4895c772012-07-17 04:19:00 -0700792
793 rt = (struct rtable *) dst;
794
Michal Kubecekf96ef982013-05-28 08:26:49 +0200795 __build_flow_key(&fl4, sk, iph, oif, tos, prot, mark, 0);
David S. Millerceb33202012-07-17 11:31:28 -0700796 __ip_do_redirect(rt, skb, &fl4, true);
David S. Miller4895c772012-07-17 04:19:00 -0700797}
798
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
800{
Eric Dumazetee6b9672008-03-05 18:30:47 -0800801 struct rtable *rt = (struct rtable *)dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 struct dst_entry *ret = dst;
803
804 if (rt) {
Timo Teräsd11a4dc2010-03-18 23:20:20 +0000805 if (dst->obsolete > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 ip_rt_put(rt);
807 ret = NULL;
David S. Miller59436342012-07-10 06:58:42 -0700808 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
809 rt->dst.expires) {
David S. Miller89aef892012-07-17 11:00:09 -0700810 ip_rt_put(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 ret = NULL;
812 }
813 }
814 return ret;
815}
816
817/*
818 * Algorithm:
819 * 1. The first ip_rt_redirect_number redirects are sent
820 * with exponential backoff, then we stop sending them at all,
821 * assuming that the host ignores our redirects.
822 * 2. If we did not see packets requiring redirects
823 * during ip_rt_redirect_silence, we assume that the host
824 * forgot redirected route and start to send redirects again.
825 *
826 * This algorithm is much cheaper and more intelligent than dumb load limiting
827 * in icmp.c.
828 *
829 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
830 * and "frag. need" (breaks PMTU discovery) in icmp.c.
831 */
832
833void ip_rt_send_redirect(struct sk_buff *skb)
834{
Eric Dumazet511c3f92009-06-02 05:14:27 +0000835 struct rtable *rt = skb_rtable(skb);
Eric Dumazet30038fc2009-08-28 23:52:01 -0700836 struct in_device *in_dev;
David S. Miller92d86822011-02-04 15:55:25 -0800837 struct inet_peer *peer;
David S. Miller1d861aa2012-07-10 03:58:16 -0700838 struct net *net;
Eric Dumazet30038fc2009-08-28 23:52:01 -0700839 int log_martians;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
Eric Dumazet30038fc2009-08-28 23:52:01 -0700841 rcu_read_lock();
Changli Gaod8d1f302010-06-10 23:31:35 -0700842 in_dev = __in_dev_get_rcu(rt->dst.dev);
Eric Dumazet30038fc2009-08-28 23:52:01 -0700843 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
844 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 return;
Eric Dumazet30038fc2009-08-28 23:52:01 -0700846 }
847 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
848 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849
David S. Miller1d861aa2012-07-10 03:58:16 -0700850 net = dev_net(rt->dst.dev);
851 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
David S. Miller92d86822011-02-04 15:55:25 -0800852 if (!peer) {
Julian Anastasove81da0e2012-10-08 11:41:15 +0000853 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
854 rt_nexthop(rt, ip_hdr(skb)->daddr));
David S. Miller92d86822011-02-04 15:55:25 -0800855 return;
856 }
857
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 /* No redirected packets during ip_rt_redirect_silence;
859 * reset the algorithm.
860 */
David S. Miller92d86822011-02-04 15:55:25 -0800861 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
862 peer->rate_tokens = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
864 /* Too many ignored redirects; do not send anything
Changli Gaod8d1f302010-06-10 23:31:35 -0700865 * set dst.rate_last to the last seen redirected packet.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 */
David S. Miller92d86822011-02-04 15:55:25 -0800867 if (peer->rate_tokens >= ip_rt_redirect_number) {
868 peer->rate_last = jiffies;
David S. Miller1d861aa2012-07-10 03:58:16 -0700869 goto out_put_peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 }
871
872 /* Check for load limit; set rate_last to the latest sent
873 * redirect.
874 */
David S. Miller92d86822011-02-04 15:55:25 -0800875 if (peer->rate_tokens == 0 ||
Li Yewang14fb8a72006-12-18 00:26:35 -0800876 time_after(jiffies,
David S. Miller92d86822011-02-04 15:55:25 -0800877 (peer->rate_last +
878 (ip_rt_redirect_load << peer->rate_tokens)))) {
Julian Anastasove81da0e2012-10-08 11:41:15 +0000879 __be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);
880
881 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
David S. Miller92d86822011-02-04 15:55:25 -0800882 peer->rate_last = jiffies;
883 ++peer->rate_tokens;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884#ifdef CONFIG_IP_ROUTE_VERBOSE
Eric Dumazet30038fc2009-08-28 23:52:01 -0700885 if (log_martians &&
Joe Perchese87cc472012-05-13 21:56:26 +0000886 peer->rate_tokens == ip_rt_redirect_number)
887 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
David S. Miller92101b32012-07-23 16:29:00 -0700888 &ip_hdr(skb)->saddr, inet_iif(skb),
Julian Anastasove81da0e2012-10-08 11:41:15 +0000889 &ip_hdr(skb)->daddr, &gw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890#endif
891 }
David S. Miller1d861aa2012-07-10 03:58:16 -0700892out_put_peer:
893 inet_putpeer(peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894}
895
896static int ip_error(struct sk_buff *skb)
897{
David S. Miller251da412012-06-26 16:27:09 -0700898 struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
Eric Dumazet511c3f92009-06-02 05:14:27 +0000899 struct rtable *rt = skb_rtable(skb);
David S. Miller92d86822011-02-04 15:55:25 -0800900 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 unsigned long now;
David S. Miller251da412012-06-26 16:27:09 -0700902 struct net *net;
David S. Miller92d86822011-02-04 15:55:25 -0800903 bool send;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 int code;
905
David S. Miller251da412012-06-26 16:27:09 -0700906 net = dev_net(rt->dst.dev);
907 if (!IN_DEV_FORWARD(in_dev)) {
908 switch (rt->dst.error) {
909 case EHOSTUNREACH:
910 IP_INC_STATS_BH(net, IPSTATS_MIB_INADDRERRORS);
911 break;
912
913 case ENETUNREACH:
914 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
915 break;
916 }
917 goto out;
918 }
919
Changli Gaod8d1f302010-06-10 23:31:35 -0700920 switch (rt->dst.error) {
Joe Perches4500ebf2011-07-01 09:43:07 +0000921 case EINVAL:
922 default:
923 goto out;
924 case EHOSTUNREACH:
925 code = ICMP_HOST_UNREACH;
926 break;
927 case ENETUNREACH:
928 code = ICMP_NET_UNREACH;
David S. Miller251da412012-06-26 16:27:09 -0700929 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
Joe Perches4500ebf2011-07-01 09:43:07 +0000930 break;
931 case EACCES:
932 code = ICMP_PKT_FILTERED;
933 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 }
935
David S. Miller1d861aa2012-07-10 03:58:16 -0700936 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
David S. Miller92d86822011-02-04 15:55:25 -0800937
938 send = true;
939 if (peer) {
940 now = jiffies;
941 peer->rate_tokens += now - peer->rate_last;
942 if (peer->rate_tokens > ip_rt_error_burst)
943 peer->rate_tokens = ip_rt_error_burst;
944 peer->rate_last = now;
945 if (peer->rate_tokens >= ip_rt_error_cost)
946 peer->rate_tokens -= ip_rt_error_cost;
947 else
948 send = false;
David S. Miller1d861aa2012-07-10 03:58:16 -0700949 inet_putpeer(peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 }
David S. Miller92d86822011-02-04 15:55:25 -0800951 if (send)
952 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
954out: kfree_skb(skb);
955 return 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900956}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957
Steffen Klassertd851c122012-10-07 22:47:25 +0000958static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959{
Steffen Klassertd851c122012-10-07 22:47:25 +0000960 struct dst_entry *dst = &rt->dst;
David S. Miller4895c772012-07-17 04:19:00 -0700961 struct fib_result res;
David S. Miller2c8cec52011-02-09 20:42:07 -0800962
Steffen Klassertfa1e4922013-01-16 20:58:10 +0000963 if (dst_metric_locked(dst, RTAX_MTU))
964 return;
965
Steffen Klassert7f92d332012-10-07 22:48:18 +0000966 if (dst->dev->mtu < mtu)
967 return;
968
David S. Miller59436342012-07-10 06:58:42 -0700969 if (mtu < ip_rt_min_pmtu)
970 mtu = ip_rt_min_pmtu;
Eric Dumazetfe6fe792011-06-08 06:07:07 +0000971
Timo Teräsf0162292013-05-27 20:46:32 +0000972 if (rt->rt_pmtu == mtu &&
973 time_before(jiffies, dst->expires - ip_rt_mtu_expires / 2))
974 return;
975
Eric Dumazetc5ae7d42012-08-28 12:33:07 +0000976 rcu_read_lock();
Steffen Klassertd851c122012-10-07 22:47:25 +0000977 if (fib_lookup(dev_net(dst->dev), fl4, &res) == 0) {
David S. Miller4895c772012-07-17 04:19:00 -0700978 struct fib_nh *nh = &FIB_RES_NH(res);
David S. Miller4895c772012-07-17 04:19:00 -0700979
Julian Anastasovaee06da2012-07-18 10:15:35 +0000980 update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
981 jiffies + ip_rt_mtu_expires);
David S. Miller4895c772012-07-17 04:19:00 -0700982 }
Eric Dumazetc5ae7d42012-08-28 12:33:07 +0000983 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984}
985
David S. Miller4895c772012-07-17 04:19:00 -0700986static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
987 struct sk_buff *skb, u32 mtu)
988{
989 struct rtable *rt = (struct rtable *) dst;
990 struct flowi4 fl4;
991
992 ip_rt_build_flow_key(&fl4, sk, skb);
Steffen Klassertd851c122012-10-07 22:47:25 +0000993 __ip_rt_update_pmtu(rt, &fl4, mtu);
David S. Miller4895c772012-07-17 04:19:00 -0700994}
995
David S. Miller36393392012-06-14 22:21:46 -0700996void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
997 int oif, u32 mark, u8 protocol, int flow_flags)
998{
David S. Miller4895c772012-07-17 04:19:00 -0700999 const struct iphdr *iph = (const struct iphdr *) skb->data;
David S. Miller36393392012-06-14 22:21:46 -07001000 struct flowi4 fl4;
1001 struct rtable *rt;
1002
Lorenzo Colitti1b3c61d2014-05-13 10:17:34 -07001003 if (!mark)
1004 mark = IP4_REPLY_MARK(net, skb->mark);
1005
David S. Miller4895c772012-07-17 04:19:00 -07001006 __build_flow_key(&fl4, NULL, iph, oif,
1007 RT_TOS(iph->tos), protocol, mark, flow_flags);
David S. Miller36393392012-06-14 22:21:46 -07001008 rt = __ip_route_output_key(net, &fl4);
1009 if (!IS_ERR(rt)) {
David S. Miller4895c772012-07-17 04:19:00 -07001010 __ip_rt_update_pmtu(rt, &fl4, mtu);
David S. Miller36393392012-06-14 22:21:46 -07001011 ip_rt_put(rt);
1012 }
1013}
1014EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
1015
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001016static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
David S. Miller36393392012-06-14 22:21:46 -07001017{
David S. Miller4895c772012-07-17 04:19:00 -07001018 const struct iphdr *iph = (const struct iphdr *) skb->data;
1019 struct flowi4 fl4;
1020 struct rtable *rt;
David S. Miller36393392012-06-14 22:21:46 -07001021
David S. Miller4895c772012-07-17 04:19:00 -07001022 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
Lorenzo Colitti1b3c61d2014-05-13 10:17:34 -07001023
1024 if (!fl4.flowi4_mark)
1025 fl4.flowi4_mark = IP4_REPLY_MARK(sock_net(sk), skb->mark);
1026
David S. Miller4895c772012-07-17 04:19:00 -07001027 rt = __ip_route_output_key(sock_net(sk), &fl4);
1028 if (!IS_ERR(rt)) {
1029 __ip_rt_update_pmtu(rt, &fl4, mtu);
1030 ip_rt_put(rt);
1031 }
David S. Miller36393392012-06-14 22:21:46 -07001032}
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001033
1034void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1035{
1036 const struct iphdr *iph = (const struct iphdr *) skb->data;
1037 struct flowi4 fl4;
1038 struct rtable *rt;
Eric Dumazet7f502362014-06-30 01:26:23 -07001039 struct dst_entry *odst = NULL;
Steffen Klassertb44108d2013-01-22 00:01:28 +00001040 bool new = false;
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001041
1042 bh_lock_sock(sk);
Hannes Frederic Sowa482fc602013-11-05 02:24:17 +01001043
1044 if (!ip_sk_accept_pmtu(sk))
1045 goto out;
1046
Eric Dumazet7f502362014-06-30 01:26:23 -07001047 odst = sk_dst_get(sk);
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001048
Eric Dumazet7f502362014-06-30 01:26:23 -07001049 if (sock_owned_by_user(sk) || !odst) {
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001050 __ipv4_sk_update_pmtu(skb, sk, mtu);
1051 goto out;
1052 }
1053
1054 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1055
Eric Dumazet7f502362014-06-30 01:26:23 -07001056 rt = (struct rtable *)odst;
1057 if (odst->obsolete && odst->ops->check(odst, 0) == NULL) {
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001058 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1059 if (IS_ERR(rt))
1060 goto out;
Steffen Klassertb44108d2013-01-22 00:01:28 +00001061
1062 new = true;
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001063 }
1064
1065 __ip_rt_update_pmtu((struct rtable *) rt->dst.path, &fl4, mtu);
1066
Eric Dumazet7f502362014-06-30 01:26:23 -07001067 if (!dst_check(&rt->dst, 0)) {
Steffen Klassertb44108d2013-01-22 00:01:28 +00001068 if (new)
1069 dst_release(&rt->dst);
1070
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001071 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1072 if (IS_ERR(rt))
1073 goto out;
1074
Steffen Klassertb44108d2013-01-22 00:01:28 +00001075 new = true;
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001076 }
1077
Steffen Klassertb44108d2013-01-22 00:01:28 +00001078 if (new)
Eric Dumazet7f502362014-06-30 01:26:23 -07001079 sk_dst_set(sk, &rt->dst);
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001080
1081out:
1082 bh_unlock_sock(sk);
Eric Dumazet7f502362014-06-30 01:26:23 -07001083 dst_release(odst);
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001084}
David S. Miller36393392012-06-14 22:21:46 -07001085EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
David S. Millerf39925d2011-02-09 22:00:16 -08001086
David S. Millerb42597e2012-07-11 21:25:45 -07001087void ipv4_redirect(struct sk_buff *skb, struct net *net,
1088 int oif, u32 mark, u8 protocol, int flow_flags)
1089{
David S. Miller4895c772012-07-17 04:19:00 -07001090 const struct iphdr *iph = (const struct iphdr *) skb->data;
David S. Millerb42597e2012-07-11 21:25:45 -07001091 struct flowi4 fl4;
1092 struct rtable *rt;
1093
David S. Miller4895c772012-07-17 04:19:00 -07001094 __build_flow_key(&fl4, NULL, iph, oif,
1095 RT_TOS(iph->tos), protocol, mark, flow_flags);
David S. Millerb42597e2012-07-11 21:25:45 -07001096 rt = __ip_route_output_key(net, &fl4);
1097 if (!IS_ERR(rt)) {
David S. Millerceb33202012-07-17 11:31:28 -07001098 __ip_do_redirect(rt, skb, &fl4, false);
David S. Millerb42597e2012-07-11 21:25:45 -07001099 ip_rt_put(rt);
1100 }
1101}
1102EXPORT_SYMBOL_GPL(ipv4_redirect);
1103
1104void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1105{
David S. Miller4895c772012-07-17 04:19:00 -07001106 const struct iphdr *iph = (const struct iphdr *) skb->data;
1107 struct flowi4 fl4;
1108 struct rtable *rt;
David S. Millerb42597e2012-07-11 21:25:45 -07001109
David S. Miller4895c772012-07-17 04:19:00 -07001110 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1111 rt = __ip_route_output_key(sock_net(sk), &fl4);
1112 if (!IS_ERR(rt)) {
David S. Millerceb33202012-07-17 11:31:28 -07001113 __ip_do_redirect(rt, skb, &fl4, false);
David S. Miller4895c772012-07-17 04:19:00 -07001114 ip_rt_put(rt);
1115 }
David S. Millerb42597e2012-07-11 21:25:45 -07001116}
1117EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1118
David S. Millerefbc3682011-12-01 13:38:59 -05001119static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1120{
1121 struct rtable *rt = (struct rtable *) dst;
1122
David S. Millerceb33202012-07-17 11:31:28 -07001123 /* All IPV4 dsts are created with ->obsolete set to the value
1124 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1125 * into this function always.
1126 *
Timo Teräs387aa652013-05-27 20:46:31 +00001127 * When a PMTU/redirect information update invalidates a route,
1128 * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
1129 * DST_OBSOLETE_DEAD by dst_free().
David S. Millerceb33202012-07-17 11:31:28 -07001130 */
Timo Teräs387aa652013-05-27 20:46:31 +00001131 if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
David S. Millerefbc3682011-12-01 13:38:59 -05001132 return NULL;
Timo Teräsd11a4dc2010-03-18 23:20:20 +00001133 return dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134}
1135
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136static void ipv4_link_failure(struct sk_buff *skb)
1137{
1138 struct rtable *rt;
1139
1140 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1141
Eric Dumazet511c3f92009-06-02 05:14:27 +00001142 rt = skb_rtable(skb);
David S. Miller59436342012-07-10 06:58:42 -07001143 if (rt)
1144 dst_set_expires(&rt->dst, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145}
1146
Eric Dumazetaad88722014-04-15 13:47:15 -04001147static int ip_rt_bug(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148{
Joe Perches91df42b2012-05-15 14:11:54 +00001149 pr_debug("%s: %pI4 -> %pI4, %s\n",
1150 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1151 skb->dev ? skb->dev->name : "?");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 kfree_skb(skb);
Dave Jonesc378a9c2011-05-21 07:16:42 +00001153 WARN_ON(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 return 0;
1155}
1156
1157/*
1158 We do not cache source address of outgoing interface,
1159 because it is used only by IP RR, TS and SRR options,
1160 so that it out of fast path.
1161
1162 BTW remember: "addr" is allowed to be not aligned
1163 in IP options!
1164 */
1165
David S. Miller8e363602011-05-13 17:29:41 -04001166void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167{
Al Viroa61ced52006-09-26 21:27:54 -07001168 __be32 src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169
David S. Millerc7537962010-11-11 17:07:48 -08001170 if (rt_is_output_route(rt))
David S. Millerc5be24f2011-05-13 18:01:21 -04001171 src = ip_hdr(skb)->saddr;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001172 else {
David S. Miller8e363602011-05-13 17:29:41 -04001173 struct fib_result res;
1174 struct flowi4 fl4;
1175 struct iphdr *iph;
1176
1177 iph = ip_hdr(skb);
1178
1179 memset(&fl4, 0, sizeof(fl4));
1180 fl4.daddr = iph->daddr;
1181 fl4.saddr = iph->saddr;
Julian Anastasovb0fe4a32011-07-23 02:00:41 +00001182 fl4.flowi4_tos = RT_TOS(iph->tos);
David S. Miller8e363602011-05-13 17:29:41 -04001183 fl4.flowi4_oif = rt->dst.dev->ifindex;
1184 fl4.flowi4_iif = skb->dev->ifindex;
1185 fl4.flowi4_mark = skb->mark;
David S. Miller5e2b61f2011-03-04 21:47:09 -08001186
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001187 rcu_read_lock();
David S. Miller68a5e3d2011-03-11 20:07:33 -05001188 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res) == 0)
David S. Miller436c3b62011-03-24 17:42:21 -07001189 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001190 else
David S. Millerf8126f12012-07-13 05:03:45 -07001191 src = inet_select_addr(rt->dst.dev,
1192 rt_nexthop(rt, iph->daddr),
1193 RT_SCOPE_UNIVERSE);
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001194 rcu_read_unlock();
1195 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 memcpy(addr, &src, 4);
1197}
1198
Patrick McHardyc7066f72011-01-14 13:36:42 +01001199#ifdef CONFIG_IP_ROUTE_CLASSID
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200static void set_class_tag(struct rtable *rt, u32 tag)
1201{
Changli Gaod8d1f302010-06-10 23:31:35 -07001202 if (!(rt->dst.tclassid & 0xFFFF))
1203 rt->dst.tclassid |= tag & 0xFFFF;
1204 if (!(rt->dst.tclassid & 0xFFFF0000))
1205 rt->dst.tclassid |= tag & 0xFFFF0000;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206}
1207#endif
1208
David S. Miller0dbaee32010-12-13 12:52:14 -08001209static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1210{
1211 unsigned int advmss = dst_metric_raw(dst, RTAX_ADVMSS);
1212
1213 if (advmss == 0) {
1214 advmss = max_t(unsigned int, dst->dev->mtu - 40,
1215 ip_rt_min_advmss);
1216 if (advmss > 65535 - 40)
1217 advmss = 65535 - 40;
1218 }
1219 return advmss;
1220}
1221
Steffen Klassertebb762f2011-11-23 02:12:51 +00001222static unsigned int ipv4_mtu(const struct dst_entry *dst)
David S. Millerd33e4552010-12-14 13:01:14 -08001223{
Steffen Klassert261663b2011-11-23 02:14:50 +00001224 const struct rtable *rt = (const struct rtable *) dst;
David S. Miller59436342012-07-10 06:58:42 -07001225 unsigned int mtu = rt->rt_pmtu;
1226
Alexander Duyck98d75c32012-08-27 06:30:01 +00001227 if (!mtu || time_after_eq(jiffies, rt->dst.expires))
David S. Miller59436342012-07-10 06:58:42 -07001228 mtu = dst_metric_raw(dst, RTAX_MTU);
Steffen Klassert618f9bc2011-11-23 02:13:31 +00001229
Steffen Klassert38d523e2013-01-16 20:55:01 +00001230 if (mtu)
Steffen Klassert618f9bc2011-11-23 02:13:31 +00001231 return mtu;
1232
1233 mtu = dst->dev->mtu;
David S. Millerd33e4552010-12-14 13:01:14 -08001234
1235 if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
Julian Anastasov155e8332012-10-08 11:41:18 +00001236 if (rt->rt_uses_gateway && mtu > 576)
David S. Millerd33e4552010-12-14 13:01:14 -08001237 mtu = 576;
1238 }
1239
Eric Dumazet734d2722013-08-18 19:08:07 -07001240 return min_t(unsigned int, mtu, IP_MAX_MTU);
David S. Millerd33e4552010-12-14 13:01:14 -08001241}
1242
David S. Millerf2bb4be2012-07-17 12:20:47 -07001243static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
David S. Miller4895c772012-07-17 04:19:00 -07001244{
Eric Dumazetcaa41522014-09-03 22:21:56 -07001245 struct fnhe_hash_bucket *hash = rcu_dereference(nh->nh_exceptions);
David S. Miller4895c772012-07-17 04:19:00 -07001246 struct fib_nh_exception *fnhe;
1247 u32 hval;
1248
David S. Millerf2bb4be2012-07-17 12:20:47 -07001249 if (!hash)
1250 return NULL;
1251
David S. Millerd3a25c92012-07-17 13:23:08 -07001252 hval = fnhe_hashfun(daddr);
David S. Miller4895c772012-07-17 04:19:00 -07001253
1254 for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1255 fnhe = rcu_dereference(fnhe->fnhe_next)) {
David S. Millerf2bb4be2012-07-17 12:20:47 -07001256 if (fnhe->fnhe_daddr == daddr)
1257 return fnhe;
1258 }
1259 return NULL;
1260}
David S. Miller4895c772012-07-17 04:19:00 -07001261
David S. Millercaacf052012-07-31 15:06:50 -07001262static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001263 __be32 daddr)
1264{
David S. Millercaacf052012-07-31 15:06:50 -07001265 bool ret = false;
1266
David S. Millerc5038a82012-07-31 15:02:02 -07001267 spin_lock_bh(&fnhe_lock);
Julian Anastasovaee06da2012-07-18 10:15:35 +00001268
David S. Millerc5038a82012-07-31 15:02:02 -07001269 if (daddr == fnhe->fnhe_daddr) {
Timo Teräs2ffae992013-06-27 10:27:05 +03001270 struct rtable __rcu **porig;
1271 struct rtable *orig;
Timo Teräs5aad1de2013-05-27 20:46:33 +00001272 int genid = fnhe_genid(dev_net(rt->dst.dev));
Timo Teräs2ffae992013-06-27 10:27:05 +03001273
1274 if (rt_is_input_route(rt))
1275 porig = &fnhe->fnhe_rth_input;
1276 else
1277 porig = &fnhe->fnhe_rth_output;
1278 orig = rcu_dereference(*porig);
Timo Teräs5aad1de2013-05-27 20:46:33 +00001279
1280 if (fnhe->fnhe_genid != genid) {
1281 fnhe->fnhe_genid = genid;
Steffen Klassert13d82bf2012-10-17 21:17:44 +00001282 fnhe->fnhe_gw = 0;
1283 fnhe->fnhe_pmtu = 0;
1284 fnhe->fnhe_expires = 0;
Timo Teräs2ffae992013-06-27 10:27:05 +03001285 fnhe_flush_routes(fnhe);
1286 orig = NULL;
Steffen Klassert13d82bf2012-10-17 21:17:44 +00001287 }
Timo Teräs387aa652013-05-27 20:46:31 +00001288 fill_route_from_fnhe(rt, fnhe);
1289 if (!rt->rt_gateway)
Julian Anastasov155e8332012-10-08 11:41:18 +00001290 rt->rt_gateway = daddr;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001291
Timo Teräs2ffae992013-06-27 10:27:05 +03001292 if (!(rt->dst.flags & DST_NOCACHE)) {
1293 rcu_assign_pointer(*porig, rt);
1294 if (orig)
1295 rt_free(orig);
1296 ret = true;
1297 }
David S. Millerc5038a82012-07-31 15:02:02 -07001298
1299 fnhe->fnhe_stamp = jiffies;
David S. Millerc5038a82012-07-31 15:02:02 -07001300 }
1301 spin_unlock_bh(&fnhe_lock);
David S. Millercaacf052012-07-31 15:06:50 -07001302
1303 return ret;
Eric Dumazet54764bb2012-07-31 01:08:23 +00001304}
1305
David S. Millercaacf052012-07-31 15:06:50 -07001306static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
David S. Millerf2bb4be2012-07-17 12:20:47 -07001307{
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001308 struct rtable *orig, *prev, **p;
David S. Millercaacf052012-07-31 15:06:50 -07001309 bool ret = true;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001310
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001311 if (rt_is_input_route(rt)) {
Eric Dumazet54764bb2012-07-31 01:08:23 +00001312 p = (struct rtable **)&nh->nh_rth_input;
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001313 } else {
Christoph Lameter903ceff2014-08-17 12:30:35 -05001314 p = (struct rtable **)raw_cpu_ptr(nh->nh_pcpu_rth_output);
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001315 }
David S. Millerf2bb4be2012-07-17 12:20:47 -07001316 orig = *p;
1317
1318 prev = cmpxchg(p, orig, rt);
1319 if (prev == orig) {
David S. Millerf2bb4be2012-07-17 12:20:47 -07001320 if (orig)
Eric Dumazet54764bb2012-07-31 01:08:23 +00001321 rt_free(orig);
Julian Anastasov155e8332012-10-08 11:41:18 +00001322 } else
David S. Millercaacf052012-07-31 15:06:50 -07001323 ret = false;
David S. Millercaacf052012-07-31 15:06:50 -07001324
1325 return ret;
1326}
1327
Eric Dumazet5055c372015-01-14 15:17:06 -08001328struct uncached_list {
1329 spinlock_t lock;
1330 struct list_head head;
1331};
1332
1333static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt_uncached_list);
David S. Millercaacf052012-07-31 15:06:50 -07001334
1335static void rt_add_uncached_list(struct rtable *rt)
1336{
Eric Dumazet5055c372015-01-14 15:17:06 -08001337 struct uncached_list *ul = raw_cpu_ptr(&rt_uncached_list);
1338
1339 rt->rt_uncached_list = ul;
1340
1341 spin_lock_bh(&ul->lock);
1342 list_add_tail(&rt->rt_uncached, &ul->head);
1343 spin_unlock_bh(&ul->lock);
David S. Millercaacf052012-07-31 15:06:50 -07001344}
1345
1346static void ipv4_dst_destroy(struct dst_entry *dst)
1347{
1348 struct rtable *rt = (struct rtable *) dst;
1349
Eric Dumazet78df76a2012-08-24 05:40:47 +00001350 if (!list_empty(&rt->rt_uncached)) {
Eric Dumazet5055c372015-01-14 15:17:06 -08001351 struct uncached_list *ul = rt->rt_uncached_list;
1352
1353 spin_lock_bh(&ul->lock);
David S. Millercaacf052012-07-31 15:06:50 -07001354 list_del(&rt->rt_uncached);
Eric Dumazet5055c372015-01-14 15:17:06 -08001355 spin_unlock_bh(&ul->lock);
David S. Millercaacf052012-07-31 15:06:50 -07001356 }
1357}
1358
1359void rt_flush_dev(struct net_device *dev)
1360{
Eric Dumazet5055c372015-01-14 15:17:06 -08001361 struct net *net = dev_net(dev);
1362 struct rtable *rt;
1363 int cpu;
David S. Millercaacf052012-07-31 15:06:50 -07001364
Eric Dumazet5055c372015-01-14 15:17:06 -08001365 for_each_possible_cpu(cpu) {
1366 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
1367
1368 spin_lock_bh(&ul->lock);
1369 list_for_each_entry(rt, &ul->head, rt_uncached) {
David S. Millercaacf052012-07-31 15:06:50 -07001370 if (rt->dst.dev != dev)
1371 continue;
1372 rt->dst.dev = net->loopback_dev;
1373 dev_hold(rt->dst.dev);
1374 dev_put(dev);
1375 }
Eric Dumazet5055c372015-01-14 15:17:06 -08001376 spin_unlock_bh(&ul->lock);
David S. Miller4895c772012-07-17 04:19:00 -07001377 }
1378}
1379
Eric Dumazet4331deb2012-07-25 05:11:23 +00001380static bool rt_cache_valid(const struct rtable *rt)
David S. Millerd2d68ba2012-07-17 12:58:50 -07001381{
Eric Dumazet4331deb2012-07-25 05:11:23 +00001382 return rt &&
1383 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1384 !rt_is_expired(rt);
David S. Millerd2d68ba2012-07-17 12:58:50 -07001385}
1386
David S. Millerf2bb4be2012-07-17 12:20:47 -07001387static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
David S. Miller5e2b61f2011-03-04 21:47:09 -08001388 const struct fib_result *res,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001389 struct fib_nh_exception *fnhe,
David S. Miller982721f2011-02-16 21:44:24 -08001390 struct fib_info *fi, u16 type, u32 itag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391{
David S. Millercaacf052012-07-31 15:06:50 -07001392 bool cached = false;
1393
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 if (fi) {
David S. Miller4895c772012-07-17 04:19:00 -07001395 struct fib_nh *nh = &FIB_RES_NH(*res);
1396
Julian Anastasov155e8332012-10-08 11:41:18 +00001397 if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK) {
David S. Miller4895c772012-07-17 04:19:00 -07001398 rt->rt_gateway = nh->nh_gw;
Julian Anastasov155e8332012-10-08 11:41:18 +00001399 rt->rt_uses_gateway = 1;
1400 }
David S. Miller28605832012-07-17 14:55:59 -07001401 dst_init_metrics(&rt->dst, fi->fib_metrics, true);
Patrick McHardyc7066f72011-01-14 13:36:42 +01001402#ifdef CONFIG_IP_ROUTE_CLASSID
David S. Millerf2bb4be2012-07-17 12:20:47 -07001403 rt->dst.tclassid = nh->nh_tclassid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404#endif
David S. Millerc5038a82012-07-31 15:02:02 -07001405 if (unlikely(fnhe))
David S. Millercaacf052012-07-31 15:06:50 -07001406 cached = rt_bind_exception(rt, fnhe, daddr);
David S. Millerc5038a82012-07-31 15:02:02 -07001407 else if (!(rt->dst.flags & DST_NOCACHE))
David S. Millercaacf052012-07-31 15:06:50 -07001408 cached = rt_cache_route(nh, rt);
Julian Anastasov155e8332012-10-08 11:41:18 +00001409 if (unlikely(!cached)) {
1410 /* Routes we intend to cache in nexthop exception or
1411 * FIB nexthop have the DST_NOCACHE bit clear.
1412 * However, if we are unsuccessful at storing this
1413 * route into the cache we really need to set it.
1414 */
1415 rt->dst.flags |= DST_NOCACHE;
1416 if (!rt->rt_gateway)
1417 rt->rt_gateway = daddr;
1418 rt_add_uncached_list(rt);
1419 }
1420 } else
David S. Millercaacf052012-07-31 15:06:50 -07001421 rt_add_uncached_list(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422
Patrick McHardyc7066f72011-01-14 13:36:42 +01001423#ifdef CONFIG_IP_ROUTE_CLASSID
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424#ifdef CONFIG_IP_MULTIPLE_TABLES
David S. Miller85b91b02012-07-13 08:21:29 -07001425 set_class_tag(rt, res->tclassid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426#endif
1427 set_class_tag(rt, itag);
1428#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429}
1430
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001431static struct rtable *rt_dst_alloc(struct net_device *dev,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001432 bool nopolicy, bool noxfrm, bool will_cache)
David S. Miller0c4dcd52011-02-17 15:42:37 -08001433{
David S. Millerf5b0a872012-07-19 12:31:33 -07001434 return dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
David S. Millerc6cffba2012-07-26 11:14:38 +00001435 (will_cache ? 0 : (DST_HOST | DST_NOCACHE)) |
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001436 (nopolicy ? DST_NOPOLICY : 0) |
1437 (noxfrm ? DST_NOXFRM : 0));
David S. Miller0c4dcd52011-02-17 15:42:37 -08001438}
1439
Eric Dumazet96d36222010-06-02 19:21:31 +00001440/* called in rcu_read_lock() section */
Al Viro9e12bb22006-09-26 21:25:20 -07001441static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 u8 tos, struct net_device *dev, int our)
1443{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 struct rtable *rth;
Eric Dumazet96d36222010-06-02 19:21:31 +00001445 struct in_device *in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 u32 itag = 0;
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001447 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448
1449 /* Primary sanity checks. */
1450
1451 if (in_dev == NULL)
1452 return -EINVAL;
1453
Jan Engelhardt1e637c72008-01-21 03:18:08 -08001454 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
Thomas Grafd0daebc32012-06-12 00:44:01 +00001455 skb->protocol != htons(ETH_P_IP))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 goto e_inval;
1457
Thomas Grafd0daebc32012-06-12 00:44:01 +00001458 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1459 if (ipv4_is_loopback(saddr))
1460 goto e_inval;
1461
Joe Perchesf97c1e02007-12-16 13:45:43 -08001462 if (ipv4_is_zeronet(saddr)) {
1463 if (!ipv4_is_local_multicast(daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 goto e_inval;
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001465 } else {
David S. Miller9e56e382012-06-28 18:54:02 -07001466 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1467 in_dev, &itag);
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001468 if (err < 0)
1469 goto e_err;
1470 }
Benjamin LaHaise4e7b2f12012-03-27 15:55:32 +00001471 rth = rt_dst_alloc(dev_net(dev)->loopback_dev,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001472 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 if (!rth)
1474 goto e_nobufs;
1475
Patrick McHardyc7066f72011-01-14 13:36:42 +01001476#ifdef CONFIG_IP_ROUTE_CLASSID
Changli Gaod8d1f302010-06-10 23:31:35 -07001477 rth->dst.tclassid = itag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478#endif
David S. Millercf911662011-04-28 14:31:47 -07001479 rth->dst.output = ip_rt_bug;
1480
fan.duca4c3fc2013-07-30 08:33:53 +08001481 rth->rt_genid = rt_genid_ipv4(dev_net(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 rth->rt_flags = RTCF_MULTICAST;
Eric Dumazet29e75252008-01-31 17:05:09 -08001483 rth->rt_type = RTN_MULTICAST;
David S. Miller9917e1e82012-07-17 14:44:26 -07001484 rth->rt_is_input= 1;
David S. Miller13378ca2012-07-23 13:57:45 -07001485 rth->rt_iif = 0;
David S. Miller59436342012-07-10 06:58:42 -07001486 rth->rt_pmtu = 0;
David S. Millerf8126f12012-07-13 05:03:45 -07001487 rth->rt_gateway = 0;
Julian Anastasov155e8332012-10-08 11:41:18 +00001488 rth->rt_uses_gateway = 0;
David S. Millercaacf052012-07-31 15:06:50 -07001489 INIT_LIST_HEAD(&rth->rt_uncached);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 if (our) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001491 rth->dst.input= ip_local_deliver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 rth->rt_flags |= RTCF_LOCAL;
1493 }
1494
1495#ifdef CONFIG_IP_MROUTE
Joe Perchesf97c1e02007-12-16 13:45:43 -08001496 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
Changli Gaod8d1f302010-06-10 23:31:35 -07001497 rth->dst.input = ip_mr_input;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498#endif
1499 RT_CACHE_STAT_INC(in_slow_mc);
1500
David S. Miller89aef892012-07-17 11:00:09 -07001501 skb_dst_set(skb, &rth->dst);
1502 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503
1504e_nobufs:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506e_inval:
Eric Dumazet96d36222010-06-02 19:21:31 +00001507 return -EINVAL;
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001508e_err:
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001509 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510}
1511
1512
1513static void ip_handle_martian_source(struct net_device *dev,
1514 struct in_device *in_dev,
1515 struct sk_buff *skb,
Al Viro9e12bb22006-09-26 21:25:20 -07001516 __be32 daddr,
1517 __be32 saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518{
1519 RT_CACHE_STAT_INC(in_martian_src);
1520#ifdef CONFIG_IP_ROUTE_VERBOSE
1521 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1522 /*
1523 * RFC1812 recommendation, if source is martian,
1524 * the only hint is MAC header.
1525 */
Joe Perches058bd4d2012-03-11 18:36:11 +00001526 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
Harvey Harrison673d57e2008-10-31 00:53:57 -07001527 &daddr, &saddr, dev->name);
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001528 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
Joe Perches058bd4d2012-03-11 18:36:11 +00001529 print_hex_dump(KERN_WARNING, "ll header: ",
1530 DUMP_PREFIX_OFFSET, 16, 1,
1531 skb_mac_header(skb),
1532 dev->hard_header_len, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 }
1534 }
1535#endif
1536}
1537
Eric Dumazet47360222010-06-03 04:13:21 +00001538/* called in rcu_read_lock() section */
Stephen Hemminger5969f712008-04-10 01:52:09 -07001539static int __mkroute_input(struct sk_buff *skb,
David S. Miller982721f2011-02-16 21:44:24 -08001540 const struct fib_result *res,
Stephen Hemminger5969f712008-04-10 01:52:09 -07001541 struct in_device *in_dev,
David S. Millerc6cffba2012-07-26 11:14:38 +00001542 __be32 daddr, __be32 saddr, u32 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543{
Timo Teräs2ffae992013-06-27 10:27:05 +03001544 struct fib_nh_exception *fnhe;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 struct rtable *rth;
1546 int err;
1547 struct in_device *out_dev;
Eric Dumazet47360222010-06-03 04:13:21 +00001548 unsigned int flags = 0;
David S. Millerd2d68ba2012-07-17 12:58:50 -07001549 bool do_cache;
Li RongQingfbdc0ad2014-05-22 16:36:55 +08001550 u32 itag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551
1552 /* get a working reference to the output device */
Eric Dumazet47360222010-06-03 04:13:21 +00001553 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 if (out_dev == NULL) {
Joe Perchese87cc472012-05-13 21:56:26 +00001555 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 return -EINVAL;
1557 }
1558
Michael Smith5c04c812011-04-07 04:51:50 +00001559 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
David S. Miller9e56e382012-06-28 18:54:02 -07001560 in_dev->dev, in_dev, &itag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 if (err < 0) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001562 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 saddr);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001564
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 goto cleanup;
1566 }
1567
Julian Anastasove81da0e2012-10-08 11:41:15 +00001568 do_cache = res->fi && !itag;
1569 if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
Hannes Frederic Sowadf4d9252015-01-23 12:01:26 +01001570 skb->protocol == htons(ETH_P_IP) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 (IN_DEV_SHARED_MEDIA(out_dev) ||
Hannes Frederic Sowadf4d9252015-01-23 12:01:26 +01001572 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1573 IPCB(skb)->flags |= IPSKB_DOREDIRECT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574
1575 if (skb->protocol != htons(ETH_P_IP)) {
1576 /* Not IP (i.e. ARP). Do not create route, if it is
1577 * invalid for proxy arp. DNAT routes are always valid.
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00001578 *
1579 * Proxy arp feature have been extended to allow, ARP
1580 * replies back to the same interface, to support
1581 * Private VLAN switch technologies. See arp.c.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 */
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00001583 if (out_dev == in_dev &&
1584 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 err = -EINVAL;
1586 goto cleanup;
1587 }
1588 }
1589
Timo Teräs2ffae992013-06-27 10:27:05 +03001590 fnhe = find_exception(&FIB_RES_NH(*res), daddr);
Julian Anastasove81da0e2012-10-08 11:41:15 +00001591 if (do_cache) {
Timo Teräs2ffae992013-06-27 10:27:05 +03001592 if (fnhe != NULL)
1593 rth = rcu_dereference(fnhe->fnhe_rth_input);
1594 else
1595 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
1596
Julian Anastasove81da0e2012-10-08 11:41:15 +00001597 if (rt_cache_valid(rth)) {
1598 skb_dst_set_noref(skb, &rth->dst);
1599 goto out;
David S. Millerd2d68ba2012-07-17 12:58:50 -07001600 }
1601 }
David S. Millerf2bb4be2012-07-17 12:20:47 -07001602
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001603 rth = rt_dst_alloc(out_dev->dev,
1604 IN_DEV_CONF_GET(in_dev, NOPOLICY),
David S. Millerd2d68ba2012-07-17 12:58:50 -07001605 IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 if (!rth) {
1607 err = -ENOBUFS;
1608 goto cleanup;
1609 }
1610
fan.duca4c3fc2013-07-30 08:33:53 +08001611 rth->rt_genid = rt_genid_ipv4(dev_net(rth->dst.dev));
David S. Millercf911662011-04-28 14:31:47 -07001612 rth->rt_flags = flags;
1613 rth->rt_type = res->type;
David S. Miller9917e1e82012-07-17 14:44:26 -07001614 rth->rt_is_input = 1;
David S. Miller13378ca2012-07-23 13:57:45 -07001615 rth->rt_iif = 0;
David S. Miller59436342012-07-10 06:58:42 -07001616 rth->rt_pmtu = 0;
David S. Millerf8126f12012-07-13 05:03:45 -07001617 rth->rt_gateway = 0;
Julian Anastasov155e8332012-10-08 11:41:18 +00001618 rth->rt_uses_gateway = 0;
David S. Millercaacf052012-07-31 15:06:50 -07001619 INIT_LIST_HEAD(&rth->rt_uncached);
Duan Jionga6254862014-02-17 15:23:43 +08001620 RT_CACHE_STAT_INC(in_slow_tot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621
Changli Gaod8d1f302010-06-10 23:31:35 -07001622 rth->dst.input = ip_forward;
1623 rth->dst.output = ip_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624
Timo Teräs2ffae992013-06-27 10:27:05 +03001625 rt_set_nexthop(rth, daddr, res, fnhe, res->fi, res->type, itag);
David S. Millerc6cffba2012-07-26 11:14:38 +00001626 skb_dst_set(skb, &rth->dst);
David S. Millerd2d68ba2012-07-17 12:58:50 -07001627out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 err = 0;
1629 cleanup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 return err;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001631}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632
Stephen Hemminger5969f712008-04-10 01:52:09 -07001633static int ip_mkroute_input(struct sk_buff *skb,
1634 struct fib_result *res,
David S. Miller68a5e3d2011-03-11 20:07:33 -05001635 const struct flowi4 *fl4,
Stephen Hemminger5969f712008-04-10 01:52:09 -07001636 struct in_device *in_dev,
1637 __be32 daddr, __be32 saddr, u32 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639#ifdef CONFIG_IP_ROUTE_MULTIPATH
David S. Millerff3fccb2011-03-10 16:23:24 -08001640 if (res->fi && res->fi->fib_nhs > 1)
David S. Miller1b7fe5932011-03-10 17:01:16 -08001641 fib_select_multipath(res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642#endif
1643
1644 /* create a routing cache entry */
David S. Millerc6cffba2012-07-26 11:14:38 +00001645 return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646}
1647
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648/*
1649 * NOTE. We drop all the packets that has local source
1650 * addresses, because every properly looped back packet
1651 * must have correct destination already attached by output routine.
1652 *
1653 * Such approach solves two big problems:
1654 * 1. Not simplex devices are handled properly.
1655 * 2. IP spoofing attempts are filtered with 100% of guarantee.
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001656 * called with rcu_read_lock()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 */
1658
Al Viro9e12bb22006-09-26 21:25:20 -07001659static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
David S. Millerc10237e2012-06-27 17:05:06 -07001660 u8 tos, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661{
1662 struct fib_result res;
Eric Dumazet96d36222010-06-02 19:21:31 +00001663 struct in_device *in_dev = __in_dev_get_rcu(dev);
David S. Miller68a5e3d2011-03-11 20:07:33 -05001664 struct flowi4 fl4;
Eric Dumazet95c96172012-04-15 05:58:06 +00001665 unsigned int flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 u32 itag = 0;
Eric Dumazet95c96172012-04-15 05:58:06 +00001667 struct rtable *rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 int err = -EINVAL;
Daniel Baluta5e73ea12012-04-15 01:34:41 +00001669 struct net *net = dev_net(dev);
David S. Millerd2d68ba2012-07-17 12:58:50 -07001670 bool do_cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671
1672 /* IP on this device is disabled. */
1673
1674 if (!in_dev)
1675 goto out;
1676
1677 /* Check for the most weird martians, which can be not detected
1678 by fib_lookup.
1679 */
1680
Thomas Grafd0daebc32012-06-12 00:44:01 +00001681 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 goto martian_source;
1683
David S. Millerd2d68ba2012-07-17 12:58:50 -07001684 res.fi = NULL;
Andy Walls27a954b2010-10-17 15:11:22 +00001685 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 goto brd_input;
1687
1688 /* Accept zero addresses only to limited broadcast;
1689 * I even do not know to fix it or not. Waiting for complains :-)
1690 */
Joe Perchesf97c1e02007-12-16 13:45:43 -08001691 if (ipv4_is_zeronet(saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 goto martian_source;
1693
Thomas Grafd0daebc32012-06-12 00:44:01 +00001694 if (ipv4_is_zeronet(daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 goto martian_destination;
1696
Eric Dumazet9eb43e72012-08-03 21:27:25 +00001697 /* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
1698 * and call it once if daddr or/and saddr are loopback addresses
1699 */
1700 if (ipv4_is_loopback(daddr)) {
1701 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
Thomas Grafd0daebc32012-06-12 00:44:01 +00001702 goto martian_destination;
Eric Dumazet9eb43e72012-08-03 21:27:25 +00001703 } else if (ipv4_is_loopback(saddr)) {
1704 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
Thomas Grafd0daebc32012-06-12 00:44:01 +00001705 goto martian_source;
1706 }
1707
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 /*
1709 * Now we are ready to route packet.
1710 */
David S. Miller68a5e3d2011-03-11 20:07:33 -05001711 fl4.flowi4_oif = 0;
1712 fl4.flowi4_iif = dev->ifindex;
1713 fl4.flowi4_mark = skb->mark;
1714 fl4.flowi4_tos = tos;
1715 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
1716 fl4.daddr = daddr;
1717 fl4.saddr = saddr;
1718 err = fib_lookup(net, &fl4, &res);
Duan Jiongcd0f0b92014-02-14 18:26:22 +08001719 if (err != 0) {
1720 if (!IN_DEV_FORWARD(in_dev))
1721 err = -EHOSTUNREACH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 goto no_route;
Duan Jiongcd0f0b92014-02-14 18:26:22 +08001723 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724
1725 if (res.type == RTN_BROADCAST)
1726 goto brd_input;
1727
1728 if (res.type == RTN_LOCAL) {
Michael Smith5c04c812011-04-07 04:51:50 +00001729 err = fib_validate_source(skb, saddr, daddr, tos,
Cong Wang0d5edc62014-04-15 16:25:35 -07001730 0, dev, in_dev, &itag);
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001731 if (err < 0)
1732 goto martian_source_keep_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 goto local_input;
1734 }
1735
Duan Jiongcd0f0b92014-02-14 18:26:22 +08001736 if (!IN_DEV_FORWARD(in_dev)) {
1737 err = -EHOSTUNREACH;
David S. Miller251da412012-06-26 16:27:09 -07001738 goto no_route;
Duan Jiongcd0f0b92014-02-14 18:26:22 +08001739 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 if (res.type != RTN_UNICAST)
1741 goto martian_destination;
1742
David S. Miller68a5e3d2011-03-11 20:07:33 -05001743 err = ip_mkroute_input(skb, &res, &fl4, in_dev, daddr, saddr, tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744out: return err;
1745
1746brd_input:
1747 if (skb->protocol != htons(ETH_P_IP))
1748 goto e_inval;
1749
David S. Miller41347dc2012-06-28 04:05:27 -07001750 if (!ipv4_is_zeronet(saddr)) {
David S. Miller9e56e382012-06-28 18:54:02 -07001751 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1752 in_dev, &itag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 if (err < 0)
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001754 goto martian_source_keep_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 }
1756 flags |= RTCF_BROADCAST;
1757 res.type = RTN_BROADCAST;
1758 RT_CACHE_STAT_INC(in_brd);
1759
1760local_input:
David S. Millerd2d68ba2012-07-17 12:58:50 -07001761 do_cache = false;
1762 if (res.fi) {
David S. Millerfe3edf42012-07-23 13:22:20 -07001763 if (!itag) {
Eric Dumazet54764bb2012-07-31 01:08:23 +00001764 rth = rcu_dereference(FIB_RES_NH(res).nh_rth_input);
David S. Millerd2d68ba2012-07-17 12:58:50 -07001765 if (rt_cache_valid(rth)) {
David S. Millerc6cffba2012-07-26 11:14:38 +00001766 skb_dst_set_noref(skb, &rth->dst);
1767 err = 0;
1768 goto out;
David S. Millerd2d68ba2012-07-17 12:58:50 -07001769 }
1770 do_cache = true;
1771 }
1772 }
1773
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001774 rth = rt_dst_alloc(net->loopback_dev,
David S. Millerd2d68ba2012-07-17 12:58:50 -07001775 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 if (!rth)
1777 goto e_nobufs;
1778
David S. Millercf911662011-04-28 14:31:47 -07001779 rth->dst.input= ip_local_deliver;
Changli Gaod8d1f302010-06-10 23:31:35 -07001780 rth->dst.output= ip_rt_bug;
David S. Millercf911662011-04-28 14:31:47 -07001781#ifdef CONFIG_IP_ROUTE_CLASSID
1782 rth->dst.tclassid = itag;
1783#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784
fan.duca4c3fc2013-07-30 08:33:53 +08001785 rth->rt_genid = rt_genid_ipv4(net);
David S. Millercf911662011-04-28 14:31:47 -07001786 rth->rt_flags = flags|RTCF_LOCAL;
1787 rth->rt_type = res.type;
David S. Miller9917e1e82012-07-17 14:44:26 -07001788 rth->rt_is_input = 1;
David S. Miller13378ca2012-07-23 13:57:45 -07001789 rth->rt_iif = 0;
David S. Miller59436342012-07-10 06:58:42 -07001790 rth->rt_pmtu = 0;
David S. Millerf8126f12012-07-13 05:03:45 -07001791 rth->rt_gateway = 0;
Julian Anastasov155e8332012-10-08 11:41:18 +00001792 rth->rt_uses_gateway = 0;
David S. Millercaacf052012-07-31 15:06:50 -07001793 INIT_LIST_HEAD(&rth->rt_uncached);
Duan Jionga6254862014-02-17 15:23:43 +08001794 RT_CACHE_STAT_INC(in_slow_tot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 if (res.type == RTN_UNREACHABLE) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001796 rth->dst.input= ip_error;
1797 rth->dst.error= -err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 rth->rt_flags &= ~RTCF_LOCAL;
1799 }
Alexei Starovoitovdcdfdf52013-11-19 19:12:34 -08001800 if (do_cache) {
1801 if (unlikely(!rt_cache_route(&FIB_RES_NH(res), rth))) {
1802 rth->dst.flags |= DST_NOCACHE;
1803 rt_add_uncached_list(rth);
1804 }
1805 }
David S. Miller89aef892012-07-17 11:00:09 -07001806 skb_dst_set(skb, &rth->dst);
David S. Millerb23dd4f2011-03-02 14:31:35 -08001807 err = 0;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001808 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809
1810no_route:
1811 RT_CACHE_STAT_INC(in_no_route);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 res.type = RTN_UNREACHABLE;
Nicolas Cavallarifa19c2b02014-10-30 10:09:53 +01001813 res.fi = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 goto local_input;
1815
1816 /*
1817 * Do not cache martian addresses: they should be logged (RFC1812)
1818 */
1819martian_destination:
1820 RT_CACHE_STAT_INC(in_martian_dst);
1821#ifdef CONFIG_IP_ROUTE_VERBOSE
Joe Perchese87cc472012-05-13 21:56:26 +00001822 if (IN_DEV_LOG_MARTIANS(in_dev))
1823 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
1824 &daddr, &saddr, dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825#endif
Dietmar Eggemann2c2910a2005-06-28 13:06:23 -07001826
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827e_inval:
1828 err = -EINVAL;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001829 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830
1831e_nobufs:
1832 err = -ENOBUFS;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001833 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834
1835martian_source:
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001836 err = -EINVAL;
1837martian_source_keep_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001839 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840}
1841
David S. Millerc6cffba2012-07-26 11:14:38 +00001842int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1843 u8 tos, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844{
Eric Dumazet96d36222010-06-02 19:21:31 +00001845 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846
Eric Dumazet96d36222010-06-02 19:21:31 +00001847 rcu_read_lock();
1848
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 /* Multicast recognition logic is moved from route cache to here.
1850 The problem was that too many Ethernet cards have broken/missing
1851 hardware multicast filters :-( As result the host on multicasting
1852 network acquires a lot of useless route cache entries, sort of
1853 SDR messages from all the world. Now we try to get rid of them.
1854 Really, provided software IP multicast filter is organized
1855 reasonably (at least, hashed), it does not result in a slowdown
1856 comparing with route cache reject entries.
1857 Note, that multicast routers are not affected, because
1858 route cache entry is created eventually.
1859 */
Joe Perchesf97c1e02007-12-16 13:45:43 -08001860 if (ipv4_is_multicast(daddr)) {
Eric Dumazet96d36222010-06-02 19:21:31 +00001861 struct in_device *in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862
Eric Dumazet96d36222010-06-02 19:21:31 +00001863 if (in_dev) {
David S. Millerdbdd9a52011-03-10 16:34:38 -08001864 int our = ip_check_mc_rcu(in_dev, daddr, saddr,
1865 ip_hdr(skb)->protocol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 if (our
1867#ifdef CONFIG_IP_MROUTE
Joe Perches9d4fb272009-11-23 10:41:23 -08001868 ||
1869 (!ipv4_is_local_multicast(daddr) &&
1870 IN_DEV_MFORWARD(in_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871#endif
Joe Perches9d4fb272009-11-23 10:41:23 -08001872 ) {
Eric Dumazet96d36222010-06-02 19:21:31 +00001873 int res = ip_route_input_mc(skb, daddr, saddr,
1874 tos, dev, our);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 rcu_read_unlock();
Eric Dumazet96d36222010-06-02 19:21:31 +00001876 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 }
1878 }
1879 rcu_read_unlock();
1880 return -EINVAL;
1881 }
David S. Millerc10237e2012-06-27 17:05:06 -07001882 res = ip_route_input_slow(skb, daddr, saddr, tos, dev);
Eric Dumazet96d36222010-06-02 19:21:31 +00001883 rcu_read_unlock();
1884 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885}
David S. Millerc6cffba2012-07-26 11:14:38 +00001886EXPORT_SYMBOL(ip_route_input_noref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001888/* called with rcu_read_lock() */
David S. Miller982721f2011-02-16 21:44:24 -08001889static struct rtable *__mkroute_output(const struct fib_result *res,
David Miller1a00fee2012-07-01 02:02:56 +00001890 const struct flowi4 *fl4, int orig_oif,
Julian Anastasovf61759e2011-12-02 11:39:42 +00001891 struct net_device *dev_out,
David S. Miller5ada5522011-02-17 15:29:00 -08001892 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893{
David S. Miller982721f2011-02-16 21:44:24 -08001894 struct fib_info *fi = res->fi;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001895 struct fib_nh_exception *fnhe;
David S. Miller5ada5522011-02-17 15:29:00 -08001896 struct in_device *in_dev;
David S. Miller982721f2011-02-16 21:44:24 -08001897 u16 type = res->type;
David S. Miller5ada5522011-02-17 15:29:00 -08001898 struct rtable *rth;
Julian Anastasovc92b9652012-10-08 11:41:19 +00001899 bool do_cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900
Thomas Grafd0daebc32012-06-12 00:44:01 +00001901 in_dev = __in_dev_get_rcu(dev_out);
1902 if (!in_dev)
David S. Miller5ada5522011-02-17 15:29:00 -08001903 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904
Thomas Grafd0daebc32012-06-12 00:44:01 +00001905 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1906 if (ipv4_is_loopback(fl4->saddr) && !(dev_out->flags & IFF_LOOPBACK))
1907 return ERR_PTR(-EINVAL);
1908
David S. Miller68a5e3d2011-03-11 20:07:33 -05001909 if (ipv4_is_lbcast(fl4->daddr))
David S. Miller982721f2011-02-16 21:44:24 -08001910 type = RTN_BROADCAST;
David S. Miller68a5e3d2011-03-11 20:07:33 -05001911 else if (ipv4_is_multicast(fl4->daddr))
David S. Miller982721f2011-02-16 21:44:24 -08001912 type = RTN_MULTICAST;
David S. Miller68a5e3d2011-03-11 20:07:33 -05001913 else if (ipv4_is_zeronet(fl4->daddr))
David S. Miller5ada5522011-02-17 15:29:00 -08001914 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915
1916 if (dev_out->flags & IFF_LOOPBACK)
1917 flags |= RTCF_LOCAL;
1918
Julian Anastasov63617422012-11-22 23:04:14 +02001919 do_cache = true;
David S. Miller982721f2011-02-16 21:44:24 -08001920 if (type == RTN_BROADCAST) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 flags |= RTCF_BROADCAST | RTCF_LOCAL;
David S. Miller982721f2011-02-16 21:44:24 -08001922 fi = NULL;
1923 } else if (type == RTN_MULTICAST) {
Eric Dumazetdd28d1a2010-09-29 11:53:50 +00001924 flags |= RTCF_MULTICAST | RTCF_LOCAL;
David S. Miller813b3b52011-04-28 14:48:42 -07001925 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
1926 fl4->flowi4_proto))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 flags &= ~RTCF_LOCAL;
Julian Anastasov63617422012-11-22 23:04:14 +02001928 else
1929 do_cache = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 /* If multicast route do not exist use
Eric Dumazetdd28d1a2010-09-29 11:53:50 +00001931 * default one, but do not gateway in this case.
1932 * Yes, it is hack.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 */
David S. Miller982721f2011-02-16 21:44:24 -08001934 if (fi && res->prefixlen < 4)
1935 fi = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 }
1937
David S. Millerf2bb4be2012-07-17 12:20:47 -07001938 fnhe = NULL;
Julian Anastasov63617422012-11-22 23:04:14 +02001939 do_cache &= fi != NULL;
1940 if (do_cache) {
David S. Millerc5038a82012-07-31 15:02:02 -07001941 struct rtable __rcu **prth;
Julian Anastasovc92b9652012-10-08 11:41:19 +00001942 struct fib_nh *nh = &FIB_RES_NH(*res);
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001943
Julian Anastasovc92b9652012-10-08 11:41:19 +00001944 fnhe = find_exception(nh, fl4->daddr);
David S. Millerc5038a82012-07-31 15:02:02 -07001945 if (fnhe)
Timo Teräs2ffae992013-06-27 10:27:05 +03001946 prth = &fnhe->fnhe_rth_output;
Julian Anastasovc92b9652012-10-08 11:41:19 +00001947 else {
1948 if (unlikely(fl4->flowi4_flags &
1949 FLOWI_FLAG_KNOWN_NH &&
1950 !(nh->nh_gw &&
1951 nh->nh_scope == RT_SCOPE_LINK))) {
1952 do_cache = false;
1953 goto add;
1954 }
Christoph Lameter903ceff2014-08-17 12:30:35 -05001955 prth = raw_cpu_ptr(nh->nh_pcpu_rth_output);
Julian Anastasovc92b9652012-10-08 11:41:19 +00001956 }
David S. Millerc5038a82012-07-31 15:02:02 -07001957 rth = rcu_dereference(*prth);
1958 if (rt_cache_valid(rth)) {
1959 dst_hold(&rth->dst);
1960 return rth;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001961 }
1962 }
Julian Anastasovc92b9652012-10-08 11:41:19 +00001963
1964add:
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001965 rth = rt_dst_alloc(dev_out,
1966 IN_DEV_CONF_GET(in_dev, NOPOLICY),
David S. Millerf2bb4be2012-07-17 12:20:47 -07001967 IN_DEV_CONF_GET(in_dev, NOXFRM),
Julian Anastasovc92b9652012-10-08 11:41:19 +00001968 do_cache);
Dimitris Michailidis8391d072010-10-07 14:48:38 +00001969 if (!rth)
David S. Miller5ada5522011-02-17 15:29:00 -08001970 return ERR_PTR(-ENOBUFS);
Dimitris Michailidis8391d072010-10-07 14:48:38 +00001971
David S. Millercf911662011-04-28 14:31:47 -07001972 rth->dst.output = ip_output;
1973
fan.duca4c3fc2013-07-30 08:33:53 +08001974 rth->rt_genid = rt_genid_ipv4(dev_net(dev_out));
David S. Millercf911662011-04-28 14:31:47 -07001975 rth->rt_flags = flags;
1976 rth->rt_type = type;
David S. Miller9917e1e82012-07-17 14:44:26 -07001977 rth->rt_is_input = 0;
David S. Miller13378ca2012-07-23 13:57:45 -07001978 rth->rt_iif = orig_oif ? : 0;
David S. Miller59436342012-07-10 06:58:42 -07001979 rth->rt_pmtu = 0;
David S. Millerf8126f12012-07-13 05:03:45 -07001980 rth->rt_gateway = 0;
Julian Anastasov155e8332012-10-08 11:41:18 +00001981 rth->rt_uses_gateway = 0;
David S. Millercaacf052012-07-31 15:06:50 -07001982 INIT_LIST_HEAD(&rth->rt_uncached);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983
1984 RT_CACHE_STAT_INC(out_slow_tot);
1985
David S. Miller41347dc2012-06-28 04:05:27 -07001986 if (flags & RTCF_LOCAL)
Changli Gaod8d1f302010-06-10 23:31:35 -07001987 rth->dst.input = ip_local_deliver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001989 if (flags & RTCF_LOCAL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 !(dev_out->flags & IFF_LOOPBACK)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001991 rth->dst.output = ip_mc_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 RT_CACHE_STAT_INC(out_slow_mc);
1993 }
1994#ifdef CONFIG_IP_MROUTE
David S. Miller982721f2011-02-16 21:44:24 -08001995 if (type == RTN_MULTICAST) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 if (IN_DEV_MFORWARD(in_dev) &&
David S. Miller813b3b52011-04-28 14:48:42 -07001997 !ipv4_is_local_multicast(fl4->daddr)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001998 rth->dst.input = ip_mr_input;
1999 rth->dst.output = ip_mc_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 }
2001 }
2002#endif
2003 }
2004
David S. Millerf2bb4be2012-07-17 12:20:47 -07002005 rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006
David S. Miller5ada5522011-02-17 15:29:00 -08002007 return rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008}
2009
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010/*
2011 * Major route resolver routine.
2012 */
2013
David S. Miller89aef892012-07-17 11:00:09 -07002014struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *fl4)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016 struct net_device *dev_out = NULL;
Julian Anastasovf61759e2011-12-02 11:39:42 +00002017 __u8 tos = RT_FL_TOS(fl4);
David S. Miller813b3b52011-04-28 14:48:42 -07002018 unsigned int flags = 0;
2019 struct fib_result res;
David S. Miller5ada5522011-02-17 15:29:00 -08002020 struct rtable *rth;
David S. Miller813b3b52011-04-28 14:48:42 -07002021 int orig_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022
David S. Miller85b91b02012-07-13 08:21:29 -07002023 res.tclassid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 res.fi = NULL;
David S. Miller8b96d222012-06-11 02:01:56 -07002025 res.table = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026
David S. Miller813b3b52011-04-28 14:48:42 -07002027 orig_oif = fl4->flowi4_oif;
2028
Pavel Emelyanov1fb94892012-08-08 21:53:36 +00002029 fl4->flowi4_iif = LOOPBACK_IFINDEX;
David S. Miller813b3b52011-04-28 14:48:42 -07002030 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
2031 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
2032 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
David S. Miller44713b62011-03-04 21:24:47 -08002033
David S. Miller010c2702011-02-17 15:37:09 -08002034 rcu_read_lock();
David S. Miller813b3b52011-04-28 14:48:42 -07002035 if (fl4->saddr) {
David S. Millerb23dd4f2011-03-02 14:31:35 -08002036 rth = ERR_PTR(-EINVAL);
David S. Miller813b3b52011-04-28 14:48:42 -07002037 if (ipv4_is_multicast(fl4->saddr) ||
2038 ipv4_is_lbcast(fl4->saddr) ||
2039 ipv4_is_zeronet(fl4->saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 goto out;
2041
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 /* I removed check for oif == dev_out->oif here.
2043 It was wrong for two reasons:
Denis V. Lunev1ab35272008-01-22 22:04:30 -08002044 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2045 is assigned to multiple interfaces.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046 2. Moreover, we are allowed to send packets with saddr
2047 of another iface. --ANK
2048 */
2049
David S. Miller813b3b52011-04-28 14:48:42 -07002050 if (fl4->flowi4_oif == 0 &&
2051 (ipv4_is_multicast(fl4->daddr) ||
2052 ipv4_is_lbcast(fl4->daddr))) {
Julian Anastasova210d012008-10-01 07:28:28 -07002053 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
David S. Miller813b3b52011-04-28 14:48:42 -07002054 dev_out = __ip_dev_find(net, fl4->saddr, false);
Julian Anastasova210d012008-10-01 07:28:28 -07002055 if (dev_out == NULL)
2056 goto out;
2057
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 /* Special hack: user can direct multicasts
2059 and limited broadcast via necessary interface
2060 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2061 This hack is not just for fun, it allows
2062 vic,vat and friends to work.
2063 They bind socket to loopback, set ttl to zero
2064 and expect that it will work.
2065 From the viewpoint of routing cache they are broken,
2066 because we are not allowed to build multicast path
2067 with loopback source addr (look, routing cache
2068 cannot know, that ttl is zero, so that packet
2069 will not leave this host and route is valid).
2070 Luckily, this hack is good workaround.
2071 */
2072
David S. Miller813b3b52011-04-28 14:48:42 -07002073 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 goto make_route;
2075 }
Julian Anastasova210d012008-10-01 07:28:28 -07002076
David S. Miller813b3b52011-04-28 14:48:42 -07002077 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
Julian Anastasova210d012008-10-01 07:28:28 -07002078 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
David S. Miller813b3b52011-04-28 14:48:42 -07002079 if (!__ip_dev_find(net, fl4->saddr, false))
Julian Anastasova210d012008-10-01 07:28:28 -07002080 goto out;
Julian Anastasova210d012008-10-01 07:28:28 -07002081 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 }
2083
2084
David S. Miller813b3b52011-04-28 14:48:42 -07002085 if (fl4->flowi4_oif) {
2086 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
David S. Millerb23dd4f2011-03-02 14:31:35 -08002087 rth = ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 if (dev_out == NULL)
2089 goto out;
Herbert Xue5ed6392005-10-03 14:35:55 -07002090
2091 /* RACE: Check return value of inet_select_addr instead. */
Eric Dumazetfc75fc82010-12-22 04:39:39 +00002092 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
David S. Millerb23dd4f2011-03-02 14:31:35 -08002093 rth = ERR_PTR(-ENETUNREACH);
Eric Dumazetfc75fc82010-12-22 04:39:39 +00002094 goto out;
2095 }
David S. Miller813b3b52011-04-28 14:48:42 -07002096 if (ipv4_is_local_multicast(fl4->daddr) ||
2097 ipv4_is_lbcast(fl4->daddr)) {
2098 if (!fl4->saddr)
2099 fl4->saddr = inet_select_addr(dev_out, 0,
2100 RT_SCOPE_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101 goto make_route;
2102 }
Jiri Benc0a7e2262013-10-04 17:04:48 +02002103 if (!fl4->saddr) {
David S. Miller813b3b52011-04-28 14:48:42 -07002104 if (ipv4_is_multicast(fl4->daddr))
2105 fl4->saddr = inet_select_addr(dev_out, 0,
2106 fl4->flowi4_scope);
2107 else if (!fl4->daddr)
2108 fl4->saddr = inet_select_addr(dev_out, 0,
2109 RT_SCOPE_HOST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 }
2111 }
2112
David S. Miller813b3b52011-04-28 14:48:42 -07002113 if (!fl4->daddr) {
2114 fl4->daddr = fl4->saddr;
2115 if (!fl4->daddr)
2116 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002117 dev_out = net->loopback_dev;
Pavel Emelyanov1fb94892012-08-08 21:53:36 +00002118 fl4->flowi4_oif = LOOPBACK_IFINDEX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 res.type = RTN_LOCAL;
2120 flags |= RTCF_LOCAL;
2121 goto make_route;
2122 }
2123
David S. Miller813b3b52011-04-28 14:48:42 -07002124 if (fib_lookup(net, fl4, &res)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 res.fi = NULL;
David S. Miller8b96d222012-06-11 02:01:56 -07002126 res.table = NULL;
David S. Miller813b3b52011-04-28 14:48:42 -07002127 if (fl4->flowi4_oif) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 /* Apparently, routing tables are wrong. Assume,
2129 that the destination is on link.
2130
2131 WHY? DW.
2132 Because we are allowed to send to iface
2133 even if it has NO routes and NO assigned
2134 addresses. When oif is specified, routing
2135 tables are looked up with only one purpose:
2136 to catch if destination is gatewayed, rather than
2137 direct. Moreover, if MSG_DONTROUTE is set,
2138 we send packet, ignoring both routing tables
2139 and ifaddr state. --ANK
2140
2141
2142 We could make it even if oif is unknown,
2143 likely IPv6, but we do not.
2144 */
2145
David S. Miller813b3b52011-04-28 14:48:42 -07002146 if (fl4->saddr == 0)
2147 fl4->saddr = inet_select_addr(dev_out, 0,
2148 RT_SCOPE_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 res.type = RTN_UNICAST;
2150 goto make_route;
2151 }
David S. Millerb23dd4f2011-03-02 14:31:35 -08002152 rth = ERR_PTR(-ENETUNREACH);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 goto out;
2154 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155
2156 if (res.type == RTN_LOCAL) {
David S. Miller813b3b52011-04-28 14:48:42 -07002157 if (!fl4->saddr) {
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002158 if (res.fi->fib_prefsrc)
David S. Miller813b3b52011-04-28 14:48:42 -07002159 fl4->saddr = res.fi->fib_prefsrc;
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002160 else
David S. Miller813b3b52011-04-28 14:48:42 -07002161 fl4->saddr = fl4->daddr;
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002162 }
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002163 dev_out = net->loopback_dev;
David S. Miller813b3b52011-04-28 14:48:42 -07002164 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 flags |= RTCF_LOCAL;
2166 goto make_route;
2167 }
2168
2169#ifdef CONFIG_IP_ROUTE_MULTIPATH
David S. Miller813b3b52011-04-28 14:48:42 -07002170 if (res.fi->fib_nhs > 1 && fl4->flowi4_oif == 0)
David S. Miller1b7fe5932011-03-10 17:01:16 -08002171 fib_select_multipath(&res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 else
2173#endif
David S. Miller21d8c492011-04-14 14:49:37 -07002174 if (!res.prefixlen &&
2175 res.table->tb_num_default > 1 &&
David S. Miller813b3b52011-04-28 14:48:42 -07002176 res.type == RTN_UNICAST && !fl4->flowi4_oif)
David S. Miller0c838ff2011-01-31 16:16:50 -08002177 fib_select_default(&res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178
David S. Miller813b3b52011-04-28 14:48:42 -07002179 if (!fl4->saddr)
2180 fl4->saddr = FIB_RES_PREFSRC(net, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 dev_out = FIB_RES_DEV(res);
David S. Miller813b3b52011-04-28 14:48:42 -07002183 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184
2185
2186make_route:
David Miller1a00fee2012-07-01 02:02:56 +00002187 rth = __mkroute_output(&res, fl4, orig_oif, dev_out, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188
David S. Miller010c2702011-02-17 15:37:09 -08002189out:
2190 rcu_read_unlock();
David S. Millerb23dd4f2011-03-02 14:31:35 -08002191 return rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192}
Arnaldo Carvalho de Melod8c97a92005-08-09 20:12:12 -07002193EXPORT_SYMBOL_GPL(__ip_route_output_key);
2194
Jianzhao Wangae2688d2010-09-08 14:35:43 -07002195static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2196{
2197 return NULL;
2198}
2199
Steffen Klassertebb762f2011-11-23 02:12:51 +00002200static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
Roland Dreierec831ea2011-01-31 13:16:00 -08002201{
Steffen Klassert618f9bc2011-11-23 02:13:31 +00002202 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2203
2204 return mtu ? : dst->dev->mtu;
Roland Dreierec831ea2011-01-31 13:16:00 -08002205}
2206
David S. Miller6700c272012-07-17 03:29:28 -07002207static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2208 struct sk_buff *skb, u32 mtu)
David S. Miller14e50e52007-05-24 18:17:54 -07002209{
2210}
2211
David S. Miller6700c272012-07-17 03:29:28 -07002212static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2213 struct sk_buff *skb)
David S. Millerb587ee32012-07-12 00:39:24 -07002214{
2215}
2216
Held Bernhard0972ddb2011-04-24 22:07:32 +00002217static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2218 unsigned long old)
2219{
2220 return NULL;
2221}
2222
David S. Miller14e50e52007-05-24 18:17:54 -07002223static struct dst_ops ipv4_dst_blackhole_ops = {
2224 .family = AF_INET,
Harvey Harrison09640e62009-02-01 00:45:17 -08002225 .protocol = cpu_to_be16(ETH_P_IP),
Jianzhao Wangae2688d2010-09-08 14:35:43 -07002226 .check = ipv4_blackhole_dst_check,
Steffen Klassertebb762f2011-11-23 02:12:51 +00002227 .mtu = ipv4_blackhole_mtu,
Eric Dumazet214f45c2011-02-18 11:39:01 -08002228 .default_advmss = ipv4_default_advmss,
David S. Miller14e50e52007-05-24 18:17:54 -07002229 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
David S. Millerb587ee32012-07-12 00:39:24 -07002230 .redirect = ipv4_rt_blackhole_redirect,
Held Bernhard0972ddb2011-04-24 22:07:32 +00002231 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
David S. Millerd3aaeb32011-07-18 00:40:17 -07002232 .neigh_lookup = ipv4_neigh_lookup,
David S. Miller14e50e52007-05-24 18:17:54 -07002233};
2234
David S. Miller2774c132011-03-01 14:59:04 -08002235struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
David S. Miller14e50e52007-05-24 18:17:54 -07002236{
David S. Miller2774c132011-03-01 14:59:04 -08002237 struct rtable *ort = (struct rtable *) dst_orig;
David S. Millerf5b0a872012-07-19 12:31:33 -07002238 struct rtable *rt;
David S. Miller14e50e52007-05-24 18:17:54 -07002239
David S. Millerf5b0a872012-07-19 12:31:33 -07002240 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE, 0);
David S. Miller14e50e52007-05-24 18:17:54 -07002241 if (rt) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002242 struct dst_entry *new = &rt->dst;
David S. Miller14e50e52007-05-24 18:17:54 -07002243
David S. Miller14e50e52007-05-24 18:17:54 -07002244 new->__use = 1;
Herbert Xu352e5122007-11-13 21:34:06 -08002245 new->input = dst_discard;
Eric Dumazetaad88722014-04-15 13:47:15 -04002246 new->output = dst_discard_sk;
David S. Miller14e50e52007-05-24 18:17:54 -07002247
Changli Gaod8d1f302010-06-10 23:31:35 -07002248 new->dev = ort->dst.dev;
David S. Miller14e50e52007-05-24 18:17:54 -07002249 if (new->dev)
2250 dev_hold(new->dev);
2251
David S. Miller9917e1e82012-07-17 14:44:26 -07002252 rt->rt_is_input = ort->rt_is_input;
David S. Miller5e2b61f2011-03-04 21:47:09 -08002253 rt->rt_iif = ort->rt_iif;
David S. Miller59436342012-07-10 06:58:42 -07002254 rt->rt_pmtu = ort->rt_pmtu;
David S. Miller14e50e52007-05-24 18:17:54 -07002255
fan.duca4c3fc2013-07-30 08:33:53 +08002256 rt->rt_genid = rt_genid_ipv4(net);
David S. Miller14e50e52007-05-24 18:17:54 -07002257 rt->rt_flags = ort->rt_flags;
2258 rt->rt_type = ort->rt_type;
David S. Miller14e50e52007-05-24 18:17:54 -07002259 rt->rt_gateway = ort->rt_gateway;
Julian Anastasov155e8332012-10-08 11:41:18 +00002260 rt->rt_uses_gateway = ort->rt_uses_gateway;
David S. Miller14e50e52007-05-24 18:17:54 -07002261
David S. Millercaacf052012-07-31 15:06:50 -07002262 INIT_LIST_HEAD(&rt->rt_uncached);
2263
David S. Miller14e50e52007-05-24 18:17:54 -07002264 dst_free(new);
2265 }
2266
David S. Miller2774c132011-03-01 14:59:04 -08002267 dst_release(dst_orig);
2268
2269 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
David S. Miller14e50e52007-05-24 18:17:54 -07002270}
2271
David S. Miller9d6ec932011-03-12 01:12:47 -05002272struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
David S. Millerb23dd4f2011-03-02 14:31:35 -08002273 struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274{
David S. Miller9d6ec932011-03-12 01:12:47 -05002275 struct rtable *rt = __ip_route_output_key(net, flp4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276
David S. Millerb23dd4f2011-03-02 14:31:35 -08002277 if (IS_ERR(rt))
2278 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279
David S. Miller56157872011-05-02 14:37:45 -07002280 if (flp4->flowi4_proto)
Steffen Klassertf92ee612014-09-16 10:08:40 +02002281 rt = (struct rtable *)xfrm_lookup_route(net, &rt->dst,
2282 flowi4_to_flowi(flp4),
2283 sk, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284
David S. Millerb23dd4f2011-03-02 14:31:35 -08002285 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286}
Arnaldo Carvalho de Melod8c97a92005-08-09 20:12:12 -07002287EXPORT_SYMBOL_GPL(ip_route_output_flow);
2288
David S. Millerf1ce3062012-07-12 10:10:17 -07002289static int rt_fill_info(struct net *net, __be32 dst, __be32 src,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002290 struct flowi4 *fl4, struct sk_buff *skb, u32 portid,
David S. Millerf1ce3062012-07-12 10:10:17 -07002291 u32 seq, int event, int nowait, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292{
Eric Dumazet511c3f92009-06-02 05:14:27 +00002293 struct rtable *rt = skb_rtable(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 struct rtmsg *r;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002295 struct nlmsghdr *nlh;
Steffen Klassert2bc8ca42011-10-11 01:12:02 +00002296 unsigned long expires = 0;
David S. Millerf1850712012-07-10 07:26:01 -07002297 u32 error;
Julian Anastasov521f5492012-07-20 12:02:08 +03002298 u32 metrics[RTAX_MAX];
Thomas Grafbe403ea2006-08-17 18:15:17 -07002299
Eric W. Biederman15e47302012-09-07 20:12:54 +00002300 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*r), flags);
Thomas Grafbe403ea2006-08-17 18:15:17 -07002301 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08002302 return -EMSGSIZE;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002303
2304 r = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305 r->rtm_family = AF_INET;
2306 r->rtm_dst_len = 32;
2307 r->rtm_src_len = 0;
David Millerd6c0a4f2012-07-01 02:02:59 +00002308 r->rtm_tos = fl4->flowi4_tos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 r->rtm_table = RT_TABLE_MAIN;
David S. Millerf3756b72012-04-01 20:39:02 -04002310 if (nla_put_u32(skb, RTA_TABLE, RT_TABLE_MAIN))
2311 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312 r->rtm_type = rt->rt_type;
2313 r->rtm_scope = RT_SCOPE_UNIVERSE;
2314 r->rtm_protocol = RTPROT_UNSPEC;
2315 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2316 if (rt->rt_flags & RTCF_NOTIFY)
2317 r->rtm_flags |= RTM_F_NOTIFY;
Hannes Frederic Sowadf4d9252015-01-23 12:01:26 +01002318 if (IPCB(skb)->flags & IPSKB_DOREDIRECT)
2319 r->rtm_flags |= RTCF_DOREDIRECT;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002320
David S. Millerf1ce3062012-07-12 10:10:17 -07002321 if (nla_put_be32(skb, RTA_DST, dst))
David S. Millerf3756b72012-04-01 20:39:02 -04002322 goto nla_put_failure;
David Miller1a00fee2012-07-01 02:02:56 +00002323 if (src) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 r->rtm_src_len = 32;
David Miller1a00fee2012-07-01 02:02:56 +00002325 if (nla_put_be32(skb, RTA_SRC, src))
David S. Millerf3756b72012-04-01 20:39:02 -04002326 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 }
David S. Millerf3756b72012-04-01 20:39:02 -04002328 if (rt->dst.dev &&
2329 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2330 goto nla_put_failure;
Patrick McHardyc7066f72011-01-14 13:36:42 +01002331#ifdef CONFIG_IP_ROUTE_CLASSID
David S. Millerf3756b72012-04-01 20:39:02 -04002332 if (rt->dst.tclassid &&
2333 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2334 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335#endif
David S. Miller41347dc2012-06-28 04:05:27 -07002336 if (!rt_is_input_route(rt) &&
David Millerd6c0a4f2012-07-01 02:02:59 +00002337 fl4->saddr != src) {
2338 if (nla_put_be32(skb, RTA_PREFSRC, fl4->saddr))
David S. Millerf3756b72012-04-01 20:39:02 -04002339 goto nla_put_failure;
2340 }
Julian Anastasov155e8332012-10-08 11:41:18 +00002341 if (rt->rt_uses_gateway &&
David S. Millerf3756b72012-04-01 20:39:02 -04002342 nla_put_be32(skb, RTA_GATEWAY, rt->rt_gateway))
2343 goto nla_put_failure;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002344
Steffen Klassertee9a8f72012-10-08 00:56:54 +00002345 expires = rt->dst.expires;
2346 if (expires) {
2347 unsigned long now = jiffies;
2348
2349 if (time_before(now, expires))
2350 expires -= now;
2351 else
2352 expires = 0;
2353 }
2354
Julian Anastasov521f5492012-07-20 12:02:08 +03002355 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
Steffen Klassertee9a8f72012-10-08 00:56:54 +00002356 if (rt->rt_pmtu && expires)
Julian Anastasov521f5492012-07-20 12:02:08 +03002357 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2358 if (rtnetlink_put_metrics(skb, metrics) < 0)
Thomas Grafbe403ea2006-08-17 18:15:17 -07002359 goto nla_put_failure;
2360
David Millerb4869882012-07-01 02:03:01 +00002361 if (fl4->flowi4_mark &&
stephen hemminger68aaed52012-10-10 08:27:25 +00002362 nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
David S. Millerf3756b72012-04-01 20:39:02 -04002363 goto nla_put_failure;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002364
Changli Gaod8d1f302010-06-10 23:31:35 -07002365 error = rt->dst.error;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002366
David S. Millerc7537962010-11-11 17:07:48 -08002367 if (rt_is_input_route(rt)) {
Nicolas Dichtel8caaf7b2012-12-04 01:03:07 +00002368#ifdef CONFIG_IP_MROUTE
2369 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2370 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2371 int err = ipmr_get_route(net, skb,
2372 fl4->saddr, fl4->daddr,
2373 r, nowait);
2374 if (err <= 0) {
2375 if (!nowait) {
2376 if (err == 0)
2377 return 0;
2378 goto nla_put_failure;
2379 } else {
2380 if (err == -EMSGSIZE)
2381 goto nla_put_failure;
2382 error = err;
2383 }
2384 }
2385 } else
2386#endif
Julian Anastasov91146152014-04-13 18:08:02 +03002387 if (nla_put_u32(skb, RTA_IIF, skb->dev->ifindex))
Nicolas Dichtel8caaf7b2012-12-04 01:03:07 +00002388 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389 }
2390
David S. Millerf1850712012-07-10 07:26:01 -07002391 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
Thomas Grafe3703b32006-11-27 09:27:07 -08002392 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393
Johannes Berg053c0952015-01-16 22:09:00 +01002394 nlmsg_end(skb, nlh);
2395 return 0;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002396
2397nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002398 nlmsg_cancel(skb, nlh);
2399 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400}
2401
Thomas Graf661d2962013-03-21 07:45:29 +00002402static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002404 struct net *net = sock_net(in_skb->sk);
Thomas Grafd889ce32006-08-17 18:15:44 -07002405 struct rtmsg *rtm;
2406 struct nlattr *tb[RTA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 struct rtable *rt = NULL;
David Millerd6c0a4f2012-07-01 02:02:59 +00002408 struct flowi4 fl4;
Al Viro9e12bb22006-09-26 21:25:20 -07002409 __be32 dst = 0;
2410 __be32 src = 0;
2411 u32 iif;
Thomas Grafd889ce32006-08-17 18:15:44 -07002412 int err;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002413 int mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414 struct sk_buff *skb;
2415
Thomas Grafd889ce32006-08-17 18:15:44 -07002416 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2417 if (err < 0)
2418 goto errout;
2419
2420 rtm = nlmsg_data(nlh);
2421
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
Thomas Grafd889ce32006-08-17 18:15:44 -07002423 if (skb == NULL) {
2424 err = -ENOBUFS;
2425 goto errout;
2426 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427
2428 /* Reserve room for dummy headers, this skb can pass
2429 through good chunk of routing engine.
2430 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07002431 skb_reset_mac_header(skb);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07002432 skb_reset_network_header(skb);
Stephen Hemmingerd2c962b2006-04-17 17:27:11 -07002433
2434 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07002435 ip_hdr(skb)->protocol = IPPROTO_ICMP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2437
Al Viro17fb2c62006-09-26 22:15:25 -07002438 src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
2439 dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
Thomas Grafd889ce32006-08-17 18:15:44 -07002440 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002441 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442
David Millerd6c0a4f2012-07-01 02:02:59 +00002443 memset(&fl4, 0, sizeof(fl4));
2444 fl4.daddr = dst;
2445 fl4.saddr = src;
2446 fl4.flowi4_tos = rtm->rtm_tos;
2447 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2448 fl4.flowi4_mark = mark;
2449
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450 if (iif) {
Thomas Grafd889ce32006-08-17 18:15:44 -07002451 struct net_device *dev;
2452
Denis V. Lunev19375042008-02-28 20:52:04 -08002453 dev = __dev_get_by_index(net, iif);
Thomas Grafd889ce32006-08-17 18:15:44 -07002454 if (dev == NULL) {
2455 err = -ENODEV;
2456 goto errout_free;
2457 }
2458
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459 skb->protocol = htons(ETH_P_IP);
2460 skb->dev = dev;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002461 skb->mark = mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462 local_bh_disable();
2463 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2464 local_bh_enable();
Thomas Grafd889ce32006-08-17 18:15:44 -07002465
Eric Dumazet511c3f92009-06-02 05:14:27 +00002466 rt = skb_rtable(skb);
Changli Gaod8d1f302010-06-10 23:31:35 -07002467 if (err == 0 && rt->dst.error)
2468 err = -rt->dst.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469 } else {
David S. Miller9d6ec932011-03-12 01:12:47 -05002470 rt = ip_route_output_key(net, &fl4);
David S. Millerb23dd4f2011-03-02 14:31:35 -08002471
2472 err = 0;
2473 if (IS_ERR(rt))
2474 err = PTR_ERR(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 }
Thomas Grafd889ce32006-08-17 18:15:44 -07002476
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 if (err)
Thomas Grafd889ce32006-08-17 18:15:44 -07002478 goto errout_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479
Changli Gaod8d1f302010-06-10 23:31:35 -07002480 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481 if (rtm->rtm_flags & RTM_F_NOTIFY)
2482 rt->rt_flags |= RTCF_NOTIFY;
2483
David S. Millerf1ce3062012-07-12 10:10:17 -07002484 err = rt_fill_info(net, dst, src, &fl4, skb,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002485 NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
Denis V. Lunev19375042008-02-28 20:52:04 -08002486 RTM_NEWROUTE, 0, 0);
David S. Miller7b46a642015-01-18 23:36:08 -05002487 if (err < 0)
Thomas Grafd889ce32006-08-17 18:15:44 -07002488 goto errout_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489
Eric W. Biederman15e47302012-09-07 20:12:54 +00002490 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
Thomas Grafd889ce32006-08-17 18:15:44 -07002491errout:
Thomas Graf2942e902006-08-15 00:30:25 -07002492 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493
Thomas Grafd889ce32006-08-17 18:15:44 -07002494errout_free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495 kfree_skb(skb);
Thomas Grafd889ce32006-08-17 18:15:44 -07002496 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497}
2498
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499void ip_rt_multicast_event(struct in_device *in_dev)
2500{
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002501 rt_cache_flush(dev_net(in_dev->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502}
2503
2504#ifdef CONFIG_SYSCTL
Gao feng082c7ca2013-02-19 00:43:12 +00002505static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
2506static int ip_rt_gc_interval __read_mostly = 60 * HZ;
2507static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
2508static int ip_rt_gc_elasticity __read_mostly = 8;
2509
Joe Perchesfe2c6332013-06-11 23:04:25 -07002510static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002511 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512 size_t *lenp, loff_t *ppos)
2513{
Timo Teräs5aad1de2013-05-27 20:46:33 +00002514 struct net *net = (struct net *)__ctl->extra1;
2515
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516 if (write) {
Timo Teräs5aad1de2013-05-27 20:46:33 +00002517 rt_cache_flush(net);
2518 fnhe_genid_bump(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002519 return 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002520 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002521
2522 return -EINVAL;
2523}
2524
Joe Perchesfe2c6332013-06-11 23:04:25 -07002525static struct ctl_table ipv4_route_table[] = {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002526 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527 .procname = "gc_thresh",
2528 .data = &ipv4_dst_ops.gc_thresh,
2529 .maxlen = sizeof(int),
2530 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002531 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532 },
2533 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534 .procname = "max_size",
2535 .data = &ip_rt_max_size,
2536 .maxlen = sizeof(int),
2537 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002538 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539 },
2540 {
2541 /* Deprecated. Use gc_min_interval_ms */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002542
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543 .procname = "gc_min_interval",
2544 .data = &ip_rt_gc_min_interval,
2545 .maxlen = sizeof(int),
2546 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002547 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 },
2549 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550 .procname = "gc_min_interval_ms",
2551 .data = &ip_rt_gc_min_interval,
2552 .maxlen = sizeof(int),
2553 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002554 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 },
2556 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557 .procname = "gc_timeout",
2558 .data = &ip_rt_gc_timeout,
2559 .maxlen = sizeof(int),
2560 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002561 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 },
2563 {
Eric Dumazet9f28a2f2011-12-21 15:47:16 -05002564 .procname = "gc_interval",
2565 .data = &ip_rt_gc_interval,
2566 .maxlen = sizeof(int),
2567 .mode = 0644,
2568 .proc_handler = proc_dointvec_jiffies,
2569 },
2570 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571 .procname = "redirect_load",
2572 .data = &ip_rt_redirect_load,
2573 .maxlen = sizeof(int),
2574 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002575 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576 },
2577 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002578 .procname = "redirect_number",
2579 .data = &ip_rt_redirect_number,
2580 .maxlen = sizeof(int),
2581 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002582 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583 },
2584 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002585 .procname = "redirect_silence",
2586 .data = &ip_rt_redirect_silence,
2587 .maxlen = sizeof(int),
2588 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002589 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590 },
2591 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002592 .procname = "error_cost",
2593 .data = &ip_rt_error_cost,
2594 .maxlen = sizeof(int),
2595 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002596 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597 },
2598 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599 .procname = "error_burst",
2600 .data = &ip_rt_error_burst,
2601 .maxlen = sizeof(int),
2602 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002603 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604 },
2605 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606 .procname = "gc_elasticity",
2607 .data = &ip_rt_gc_elasticity,
2608 .maxlen = sizeof(int),
2609 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002610 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611 },
2612 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613 .procname = "mtu_expires",
2614 .data = &ip_rt_mtu_expires,
2615 .maxlen = sizeof(int),
2616 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002617 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002618 },
2619 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 .procname = "min_pmtu",
2621 .data = &ip_rt_min_pmtu,
2622 .maxlen = sizeof(int),
2623 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002624 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625 },
2626 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627 .procname = "min_adv_mss",
2628 .data = &ip_rt_min_advmss,
2629 .maxlen = sizeof(int),
2630 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002631 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002633 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002634};
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002635
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002636static struct ctl_table ipv4_route_flush_table[] = {
2637 {
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002638 .procname = "flush",
2639 .maxlen = sizeof(int),
2640 .mode = 0200,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002641 .proc_handler = ipv4_sysctl_rtcache_flush,
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002642 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002643 { },
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002644};
2645
2646static __net_init int sysctl_route_net_init(struct net *net)
2647{
2648 struct ctl_table *tbl;
2649
2650 tbl = ipv4_route_flush_table;
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08002651 if (!net_eq(net, &init_net)) {
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002652 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
2653 if (tbl == NULL)
2654 goto err_dup;
Eric W. Biederman464dc802012-11-16 03:02:59 +00002655
2656 /* Don't export sysctls to unprivileged users */
2657 if (net->user_ns != &init_user_ns)
2658 tbl[0].procname = NULL;
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002659 }
2660 tbl[0].extra1 = net;
2661
Eric W. Biedermanec8f23c2012-04-19 13:44:49 +00002662 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002663 if (net->ipv4.route_hdr == NULL)
2664 goto err_reg;
2665 return 0;
2666
2667err_reg:
2668 if (tbl != ipv4_route_flush_table)
2669 kfree(tbl);
2670err_dup:
2671 return -ENOMEM;
2672}
2673
2674static __net_exit void sysctl_route_net_exit(struct net *net)
2675{
2676 struct ctl_table *tbl;
2677
2678 tbl = net->ipv4.route_hdr->ctl_table_arg;
2679 unregister_net_sysctl_table(net->ipv4.route_hdr);
2680 BUG_ON(tbl == ipv4_route_flush_table);
2681 kfree(tbl);
2682}
2683
2684static __net_initdata struct pernet_operations sysctl_route_ops = {
2685 .init = sysctl_route_net_init,
2686 .exit = sysctl_route_net_exit,
2687};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002688#endif
2689
Neil Horman3ee94372010-05-08 01:57:52 -07002690static __net_init int rt_genid_init(struct net *net)
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002691{
fan.duca4c3fc2013-07-30 08:33:53 +08002692 atomic_set(&net->ipv4.rt_genid, 0);
Timo Teräs5aad1de2013-05-27 20:46:33 +00002693 atomic_set(&net->fnhe_genid, 0);
David S. Miller436c3b62011-03-24 17:42:21 -07002694 get_random_bytes(&net->ipv4.dev_addr_genid,
2695 sizeof(net->ipv4.dev_addr_genid));
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002696 return 0;
2697}
2698
Neil Horman3ee94372010-05-08 01:57:52 -07002699static __net_initdata struct pernet_operations rt_genid_ops = {
2700 .init = rt_genid_init,
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002701};
2702
David S. Millerc3426b42012-06-09 16:27:05 -07002703static int __net_init ipv4_inetpeer_init(struct net *net)
2704{
2705 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2706
2707 if (!bp)
2708 return -ENOMEM;
2709 inet_peer_base_init(bp);
2710 net->ipv4.peers = bp;
2711 return 0;
2712}
2713
2714static void __net_exit ipv4_inetpeer_exit(struct net *net)
2715{
2716 struct inet_peer_base *bp = net->ipv4.peers;
2717
2718 net->ipv4.peers = NULL;
David S. Miller56a6b242012-06-09 16:32:41 -07002719 inetpeer_invalidate_tree(bp);
David S. Millerc3426b42012-06-09 16:27:05 -07002720 kfree(bp);
2721}
2722
2723static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
2724 .init = ipv4_inetpeer_init,
2725 .exit = ipv4_inetpeer_exit,
2726};
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002727
Patrick McHardyc7066f72011-01-14 13:36:42 +01002728#ifdef CONFIG_IP_ROUTE_CLASSID
Tejun Heo7d720c32010-02-16 15:20:26 +00002729struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
Patrick McHardyc7066f72011-01-14 13:36:42 +01002730#endif /* CONFIG_IP_ROUTE_CLASSID */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731
Linus Torvalds1da177e2005-04-16 15:20:36 -07002732int __init ip_rt_init(void)
2733{
Eric Dumazet424c4b72005-07-05 14:58:19 -07002734 int rc = 0;
Eric Dumazet5055c372015-01-14 15:17:06 -08002735 int cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736
Eric Dumazet73f156a2014-06-02 05:26:03 -07002737 ip_idents = kmalloc(IP_IDENTS_SZ * sizeof(*ip_idents), GFP_KERNEL);
2738 if (!ip_idents)
2739 panic("IP: failed to allocate ip_idents\n");
2740
2741 prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));
2742
Eric Dumazet5055c372015-01-14 15:17:06 -08002743 for_each_possible_cpu(cpu) {
2744 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
2745
2746 INIT_LIST_HEAD(&ul->head);
2747 spin_lock_init(&ul->lock);
2748 }
Patrick McHardyc7066f72011-01-14 13:36:42 +01002749#ifdef CONFIG_IP_ROUTE_CLASSID
Ingo Molnar0dcec8c2009-02-25 14:07:33 +01002750 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002751 if (!ip_rt_acct)
2752 panic("IP: failed to allocate ip_rt_acct\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002753#endif
2754
Alexey Dobriyane5d679f332006-08-26 19:25:52 -07002755 ipv4_dst_ops.kmem_cachep =
2756 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09002757 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758
David S. Miller14e50e52007-05-24 18:17:54 -07002759 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
2760
Eric Dumazetfc66f952010-10-08 06:37:34 +00002761 if (dst_entries_init(&ipv4_dst_ops) < 0)
2762 panic("IP: failed to allocate ipv4_dst_ops counter\n");
2763
2764 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
2765 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
2766
David S. Miller89aef892012-07-17 11:00:09 -07002767 ipv4_dst_ops.gc_thresh = ~0;
2768 ip_rt_max_size = INT_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 devinet_init();
2771 ip_fib_init();
2772
Denis V. Lunev73b38712008-02-28 20:51:18 -08002773 if (ip_rt_proc_init())
Joe Perches058bd4d2012-03-11 18:36:11 +00002774 pr_err("Unable to create route proc files\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775#ifdef CONFIG_XFRM
2776 xfrm_init();
Steffen Klassert703fb942012-11-13 08:52:24 +01002777 xfrm4_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778#endif
Greg Rosec7ac8672011-06-10 01:27:09 +00002779 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL, NULL);
Thomas Graf63f34442007-03-22 11:55:17 -07002780
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002781#ifdef CONFIG_SYSCTL
2782 register_pernet_subsys(&sysctl_route_ops);
2783#endif
Neil Horman3ee94372010-05-08 01:57:52 -07002784 register_pernet_subsys(&rt_genid_ops);
David S. Millerc3426b42012-06-09 16:27:05 -07002785 register_pernet_subsys(&ipv4_inetpeer_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786 return rc;
2787}
2788
Al Viroa1bc6eb2008-07-30 06:32:52 -04002789#ifdef CONFIG_SYSCTL
Al Viroeeb61f72008-07-27 08:59:33 +01002790/*
2791 * We really need to sanitize the damn ipv4 init order, then all
2792 * this nonsense will go away.
2793 */
2794void __init ip_static_sysctl_init(void)
2795{
Eric W. Biederman4e5ca782012-04-19 13:32:39 +00002796 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);
Al Viroeeb61f72008-07-27 08:59:33 +01002797}
Al Viroa1bc6eb2008-07-30 06:32:52 -04002798#endif