blob: b678466da451c994b7baec77f96c482afe62da4b [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>
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080068#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <linux/bitops.h>
70#include <linux/types.h>
71#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#include <linux/mm.h>
73#include <linux/string.h>
74#include <linux/socket.h>
75#include <linux/sockios.h>
76#include <linux/errno.h>
77#include <linux/in.h>
78#include <linux/inet.h>
79#include <linux/netdevice.h>
80#include <linux/proc_fs.h>
81#include <linux/init.h>
82#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070083#include <linux/inetdevice.h>
84#include <linux/igmp.h>
85#include <linux/pkt_sched.h>
86#include <linux/mroute.h>
87#include <linux/netfilter_ipv4.h>
88#include <linux/random.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070089#include <linux/rcupdate.h>
90#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090091#include <linux/slab.h>
Eric Dumazet73f156a2014-06-02 05:26:03 -070092#include <linux/jhash.h>
Herbert Xu352e5122007-11-13 21:34:06 -080093#include <net/dst.h>
Thomas Graf1b7179d2015-07-21 10:43:59 +020094#include <net/dst_metadata.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020095#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070096#include <net/protocol.h>
97#include <net/ip.h>
98#include <net/route.h>
99#include <net/inetpeer.h>
100#include <net/sock.h>
101#include <net/ip_fib.h>
102#include <net/arp.h>
103#include <net/tcp.h>
104#include <net/icmp.h>
105#include <net/xfrm.h>
Roopa Prabhu571e7222015-07-21 10:43:47 +0200106#include <net/lwtunnel.h>
Tom Tucker8d717402006-07-30 20:43:36 -0700107#include <net/netevent.h>
Thomas Graf63f34442007-03-22 11:55:17 -0700108#include <net/rtnetlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109#ifdef CONFIG_SYSCTL
110#include <linux/sysctl.h>
111#endif
David S. Miller6e5714e2011-08-03 20:50:44 -0700112#include <net/secure_seq.h>
Thomas Graf1b7179d2015-07-21 10:43:59 +0200113#include <net/ip_tunnels.h>
David Ahern385add92015-09-29 20:07:13 -0700114#include <net/l3mdev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
Roopa Prabhub6179812017-05-25 10:42:39 -0700116#include "fib_lookup.h"
117
David S. Miller68a5e3d2011-03-11 20:07:33 -0500118#define RT_FL_TOS(oldflp4) \
Julian Anastasovf61759e2011-12-02 11:39:42 +0000119 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121#define RT_GC_TIMEOUT (300*HZ)
122
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123static int ip_rt_max_size;
Stephen Hemminger817bc4d2008-03-22 17:43:59 -0700124static int ip_rt_redirect_number __read_mostly = 9;
125static int ip_rt_redirect_load __read_mostly = HZ / 50;
126static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
127static int ip_rt_error_cost __read_mostly = HZ;
128static int ip_rt_error_burst __read_mostly = 5 * HZ;
Stephen Hemminger817bc4d2008-03-22 17:43:59 -0700129static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
Sabrina Dubrocac7272c22018-02-26 16:13:43 +0100130static u32 ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
Stephen Hemminger817bc4d2008-03-22 17:43:59 -0700131static int ip_rt_min_advmss __read_mostly = 256;
Eric Dumazet9f28a2f2011-12-21 15:47:16 -0500132
Xin Longdeed49d2016-02-18 21:21:19 +0800133static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
Sabrina Dubrocac7272c22018-02-26 16:13:43 +0100134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135/*
136 * Interface to generic destination cache.
137 */
138
139static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
David S. Miller0dbaee32010-12-13 12:52:14 -0800140static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
Steffen Klassertebb762f2011-11-23 02:12:51 +0000141static unsigned int ipv4_mtu(const struct dst_entry *dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
143static void ipv4_link_failure(struct sk_buff *skb);
David S. Miller6700c272012-07-17 03:29:28 -0700144static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
145 struct sk_buff *skb, u32 mtu);
146static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,
147 struct sk_buff *skb);
David S. Millercaacf052012-07-31 15:06:50 -0700148static void ipv4_dst_destroy(struct dst_entry *dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
David S. Miller62fa8a82011-01-26 20:51:05 -0800150static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
151{
David S. Miller31248732012-07-10 07:08:18 -0700152 WARN_ON(1);
153 return NULL;
David S. Miller62fa8a82011-01-26 20:51:05 -0800154}
155
David S. Millerf894cbf2012-07-02 21:52:24 -0700156static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
157 struct sk_buff *skb,
158 const void *daddr);
Julian Anastasov63fca652017-02-06 23:14:15 +0200159static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700160
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161static struct dst_ops ipv4_dst_ops = {
162 .family = AF_INET,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 .check = ipv4_dst_check,
David S. Miller0dbaee32010-12-13 12:52:14 -0800164 .default_advmss = ipv4_default_advmss,
Steffen Klassertebb762f2011-11-23 02:12:51 +0000165 .mtu = ipv4_mtu,
David S. Miller62fa8a82011-01-26 20:51:05 -0800166 .cow_metrics = ipv4_cow_metrics,
David S. Millercaacf052012-07-31 15:06:50 -0700167 .destroy = ipv4_dst_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 .negative_advice = ipv4_negative_advice,
169 .link_failure = ipv4_link_failure,
170 .update_pmtu = ip_rt_update_pmtu,
David S. Millere47a1852012-07-11 20:55:47 -0700171 .redirect = ip_do_redirect,
Eric W. Biedermanb92dacd2015-10-07 16:48:37 -0500172 .local_out = __ip_local_out,
David S. Millerd3aaeb32011-07-18 00:40:17 -0700173 .neigh_lookup = ipv4_neigh_lookup,
Julian Anastasov63fca652017-02-06 23:14:15 +0200174 .confirm_neigh = ipv4_confirm_neigh,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175};
176
177#define ECN_OR_COST(class) TC_PRIO_##class
178
Philippe De Muyter4839c522007-07-09 15:32:57 -0700179const __u8 ip_tos2prio[16] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 TC_PRIO_BESTEFFORT,
Dan Siemon4a2b9c32011-03-15 13:56:07 +0000181 ECN_OR_COST(BESTEFFORT),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 TC_PRIO_BESTEFFORT,
183 ECN_OR_COST(BESTEFFORT),
184 TC_PRIO_BULK,
185 ECN_OR_COST(BULK),
186 TC_PRIO_BULK,
187 ECN_OR_COST(BULK),
188 TC_PRIO_INTERACTIVE,
189 ECN_OR_COST(INTERACTIVE),
190 TC_PRIO_INTERACTIVE,
191 ECN_OR_COST(INTERACTIVE),
192 TC_PRIO_INTERACTIVE_BULK,
193 ECN_OR_COST(INTERACTIVE_BULK),
194 TC_PRIO_INTERACTIVE_BULK,
195 ECN_OR_COST(INTERACTIVE_BULK)
196};
Amir Vadaid4a96862012-04-04 21:33:28 +0000197EXPORT_SYMBOL(ip_tos2prio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Eric Dumazet2f970d82006-01-17 02:54:36 -0800199static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
Christoph Lameter3ed66e92014-04-07 15:39:40 -0700200#define RT_CACHE_STAT_INC(field) raw_cpu_inc(rt_cache_stat.field)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
204{
Eric Dumazet29e75252008-01-31 17:05:09 -0800205 if (*pos)
David S. Miller89aef892012-07-17 11:00:09 -0700206 return NULL;
Eric Dumazet29e75252008-01-31 17:05:09 -0800207 return SEQ_START_TOKEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208}
209
210static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
211{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 ++*pos;
David S. Miller89aef892012-07-17 11:00:09 -0700213 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214}
215
216static void rt_cache_seq_stop(struct seq_file *seq, void *v)
217{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218}
219
220static int rt_cache_seq_show(struct seq_file *seq, void *v)
221{
222 if (v == SEQ_START_TOKEN)
223 seq_printf(seq, "%-127s\n",
224 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
225 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
226 "HHUptod\tSpecDst");
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900227 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228}
229
Stephen Hemmingerf6908082007-03-12 14:34:29 -0700230static const struct seq_operations rt_cache_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 .start = rt_cache_seq_start,
232 .next = rt_cache_seq_next,
233 .stop = rt_cache_seq_stop,
234 .show = rt_cache_seq_show,
235};
236
237static int rt_cache_seq_open(struct inode *inode, struct file *file)
238{
David S. Miller89aef892012-07-17 11:00:09 -0700239 return seq_open(file, &rt_cache_seq_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240}
241
Arjan van de Ven9a321442007-02-12 00:55:35 -0800242static const struct file_operations rt_cache_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 .open = rt_cache_seq_open,
244 .read = seq_read,
245 .llseek = seq_lseek,
David S. Miller89aef892012-07-17 11:00:09 -0700246 .release = seq_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247};
248
249
250static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
251{
252 int cpu;
253
254 if (*pos == 0)
255 return SEQ_START_TOKEN;
256
Rusty Russell0f23174a2008-12-29 12:23:42 +0000257 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 if (!cpu_possible(cpu))
259 continue;
260 *pos = cpu+1;
Eric Dumazet2f970d82006-01-17 02:54:36 -0800261 return &per_cpu(rt_cache_stat, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 }
263 return NULL;
264}
265
266static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
267{
268 int cpu;
269
Rusty Russell0f23174a2008-12-29 12:23:42 +0000270 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 if (!cpu_possible(cpu))
272 continue;
273 *pos = cpu+1;
Eric Dumazet2f970d82006-01-17 02:54:36 -0800274 return &per_cpu(rt_cache_stat, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 }
276 return NULL;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278}
279
280static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
281{
282
283}
284
285static int rt_cpu_seq_show(struct seq_file *seq, void *v)
286{
287 struct rt_cache_stat *st = v;
288
289 if (v == SEQ_START_TOKEN) {
Olaf Rempel5bec0032005-04-28 12:16:08 -0700290 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 -0700291 return 0;
292 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
295 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
Eric Dumazetfc66f952010-10-08 06:37:34 +0000296 dst_entries_get_slow(&ipv4_dst_ops),
Eric Dumazet0baf2b32013-10-16 02:49:04 -0700297 0, /* st->in_hit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 st->in_slow_tot,
299 st->in_slow_mc,
300 st->in_no_route,
301 st->in_brd,
302 st->in_martian_dst,
303 st->in_martian_src,
304
Eric Dumazet0baf2b32013-10-16 02:49:04 -0700305 0, /* st->out_hit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 st->out_slow_tot,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900307 st->out_slow_mc,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308
Eric Dumazet0baf2b32013-10-16 02:49:04 -0700309 0, /* st->gc_total */
310 0, /* st->gc_ignored */
311 0, /* st->gc_goal_miss */
312 0, /* st->gc_dst_overflow */
313 0, /* st->in_hlist_search */
314 0 /* st->out_hlist_search */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 );
316 return 0;
317}
318
Stephen Hemmingerf6908082007-03-12 14:34:29 -0700319static const struct seq_operations rt_cpu_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 .start = rt_cpu_seq_start,
321 .next = rt_cpu_seq_next,
322 .stop = rt_cpu_seq_stop,
323 .show = rt_cpu_seq_show,
324};
325
326
327static int rt_cpu_seq_open(struct inode *inode, struct file *file)
328{
329 return seq_open(file, &rt_cpu_seq_ops);
330}
331
Arjan van de Ven9a321442007-02-12 00:55:35 -0800332static const struct file_operations rt_cpu_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 .open = rt_cpu_seq_open,
334 .read = seq_read,
335 .llseek = seq_lseek,
336 .release = seq_release,
337};
338
Patrick McHardyc7066f72011-01-14 13:36:42 +0100339#ifdef CONFIG_IP_ROUTE_CLASSID
Alexey Dobriyana661c412009-11-25 15:40:35 -0800340static int rt_acct_proc_show(struct seq_file *m, void *v)
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800341{
Alexey Dobriyana661c412009-11-25 15:40:35 -0800342 struct ip_rt_acct *dst, *src;
343 unsigned int i, j;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800344
Alexey Dobriyana661c412009-11-25 15:40:35 -0800345 dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
346 if (!dst)
347 return -ENOMEM;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800348
Alexey Dobriyana661c412009-11-25 15:40:35 -0800349 for_each_possible_cpu(i) {
350 src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
351 for (j = 0; j < 256; j++) {
352 dst[j].o_bytes += src[j].o_bytes;
353 dst[j].o_packets += src[j].o_packets;
354 dst[j].i_bytes += src[j].i_bytes;
355 dst[j].i_packets += src[j].i_packets;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800356 }
357 }
Alexey Dobriyana661c412009-11-25 15:40:35 -0800358
359 seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
360 kfree(dst);
361 return 0;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800362}
363#endif
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800364
Denis V. Lunev73b38712008-02-28 20:51:18 -0800365static int __net_init ip_rt_do_proc_init(struct net *net)
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800366{
367 struct proc_dir_entry *pde;
368
Joe Perchesd6444062018-03-23 15:54:38 -0700369 pde = proc_create("rt_cache", 0444, net->proc_net,
Gao fengd4beaa62013-02-18 01:34:54 +0000370 &rt_cache_seq_fops);
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800371 if (!pde)
372 goto err1;
373
Joe Perchesd6444062018-03-23 15:54:38 -0700374 pde = proc_create("rt_cache", 0444,
Wang Chen77020722008-02-28 14:14:25 -0800375 net->proc_net_stat, &rt_cpu_seq_fops);
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800376 if (!pde)
377 goto err2;
378
Patrick McHardyc7066f72011-01-14 13:36:42 +0100379#ifdef CONFIG_IP_ROUTE_CLASSID
Christoph Hellwig3f3942a2018-05-15 15:57:23 +0200380 pde = proc_create_single("rt_acct", 0, net->proc_net,
381 rt_acct_proc_show);
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800382 if (!pde)
383 goto err3;
384#endif
385 return 0;
386
Patrick McHardyc7066f72011-01-14 13:36:42 +0100387#ifdef CONFIG_IP_ROUTE_CLASSID
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800388err3:
389 remove_proc_entry("rt_cache", net->proc_net_stat);
390#endif
391err2:
392 remove_proc_entry("rt_cache", net->proc_net);
393err1:
394 return -ENOMEM;
395}
Denis V. Lunev73b38712008-02-28 20:51:18 -0800396
397static void __net_exit ip_rt_do_proc_exit(struct net *net)
398{
399 remove_proc_entry("rt_cache", net->proc_net_stat);
400 remove_proc_entry("rt_cache", net->proc_net);
Patrick McHardyc7066f72011-01-14 13:36:42 +0100401#ifdef CONFIG_IP_ROUTE_CLASSID
Denis V. Lunev73b38712008-02-28 20:51:18 -0800402 remove_proc_entry("rt_acct", net->proc_net);
Alexey Dobriyan0a931ac2010-01-17 03:32:50 +0000403#endif
Denis V. Lunev73b38712008-02-28 20:51:18 -0800404}
405
406static struct pernet_operations ip_rt_proc_ops __net_initdata = {
407 .init = ip_rt_do_proc_init,
408 .exit = ip_rt_do_proc_exit,
409};
410
411static int __init ip_rt_proc_init(void)
412{
413 return register_pernet_subsys(&ip_rt_proc_ops);
414}
415
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800416#else
Denis V. Lunev73b38712008-02-28 20:51:18 -0800417static inline int ip_rt_proc_init(void)
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800418{
419 return 0;
420}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421#endif /* CONFIG_PROC_FS */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900422
Eric Dumazet4331deb2012-07-25 05:11:23 +0000423static inline bool rt_is_expired(const struct rtable *rth)
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700424{
fan.duca4c3fc2013-07-30 08:33:53 +0800425 return rth->rt_genid != rt_genid_ipv4(dev_net(rth->dst.dev));
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700426}
427
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +0000428void rt_cache_flush(struct net *net)
Eric Dumazet29e75252008-01-31 17:05:09 -0800429{
fan.duca4c3fc2013-07-30 08:33:53 +0800430 rt_genid_bump_ipv4(net);
Eric Dumazet98376382010-03-08 03:20:00 +0000431}
432
David S. Millerf894cbf2012-07-02 21:52:24 -0700433static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
434 struct sk_buff *skb,
435 const void *daddr)
David Miller3769cff2011-07-11 22:44:24 +0000436{
David S. Millerd3aaeb32011-07-18 00:40:17 -0700437 struct net_device *dev = dst->dev;
438 const __be32 *pkey = daddr;
David S. Miller39232972012-01-26 15:22:32 -0500439 const struct rtable *rt;
David Miller3769cff2011-07-11 22:44:24 +0000440 struct neighbour *n;
441
David S. Miller39232972012-01-26 15:22:32 -0500442 rt = (const struct rtable *) dst;
David S. Millera263b302012-07-02 02:02:15 -0700443 if (rt->rt_gateway)
David S. Miller39232972012-01-26 15:22:32 -0500444 pkey = (const __be32 *) &rt->rt_gateway;
David S. Millerf894cbf2012-07-02 21:52:24 -0700445 else if (skb)
446 pkey = &ip_hdr(skb)->daddr;
David S. Millerd3aaeb32011-07-18 00:40:17 -0700447
David S. Miller80703d22012-02-15 17:48:35 -0500448 n = __ipv4_neigh_lookup(dev, *(__force u32 *)pkey);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700449 if (n)
450 return n;
David Miller32092ec2011-07-25 00:01:41 +0000451 return neigh_create(&arp_tbl, pkey, dev);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700452}
453
Julian Anastasov63fca652017-02-06 23:14:15 +0200454static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr)
455{
456 struct net_device *dev = dst->dev;
457 const __be32 *pkey = daddr;
458 const struct rtable *rt;
459
460 rt = (const struct rtable *)dst;
461 if (rt->rt_gateway)
462 pkey = (const __be32 *)&rt->rt_gateway;
463 else if (!daddr ||
464 (rt->rt_flags &
465 (RTCF_MULTICAST | RTCF_BROADCAST | RTCF_LOCAL)))
466 return;
467
468 __ipv4_confirm_neigh(dev, *(__force u32 *)pkey);
469}
470
Eric Dumazet04ca6972014-07-26 08:58:10 +0200471#define IP_IDENTS_SZ 2048u
Eric Dumazet04ca6972014-07-26 08:58:10 +0200472
Eric Dumazet355b590c2015-05-01 10:37:49 -0700473static atomic_t *ip_idents __read_mostly;
474static u32 *ip_tstamps __read_mostly;
Eric Dumazet04ca6972014-07-26 08:58:10 +0200475
476/* In order to protect privacy, we add a perturbation to identifiers
477 * if one generator is seldom used. This makes hard for an attacker
478 * to infer how many packets were sent between two points in time.
479 */
480u32 ip_idents_reserve(u32 hash, int segs)
481{
Eric Dumazet355b590c2015-05-01 10:37:49 -0700482 u32 *p_tstamp = ip_tstamps + hash % IP_IDENTS_SZ;
483 atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ;
Mark Rutland6aa7de02017-10-23 14:07:29 -0700484 u32 old = READ_ONCE(*p_tstamp);
Eric Dumazet04ca6972014-07-26 08:58:10 +0200485 u32 now = (u32)jiffies;
Eric Dumazetadb03112016-09-20 18:06:17 -0700486 u32 new, delta = 0;
Eric Dumazet04ca6972014-07-26 08:58:10 +0200487
Eric Dumazet355b590c2015-05-01 10:37:49 -0700488 if (old != now && cmpxchg(p_tstamp, old, now) == old)
Eric Dumazet04ca6972014-07-26 08:58:10 +0200489 delta = prandom_u32_max(now - old);
490
Eric Dumazetadb03112016-09-20 18:06:17 -0700491 /* Do not use atomic_add_return() as it makes UBSAN unhappy */
492 do {
493 old = (u32)atomic_read(p_id);
494 new = old + delta + segs;
495 } while (atomic_cmpxchg(p_id, old, new) != old);
496
497 return new - segs;
Eric Dumazet04ca6972014-07-26 08:58:10 +0200498}
499EXPORT_SYMBOL(ip_idents_reserve);
Eric Dumazet73f156a2014-06-02 05:26:03 -0700500
Hannes Frederic Sowab6a77192015-03-25 17:07:44 +0100501void __ip_select_ident(struct net *net, struct iphdr *iph, int segs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502{
Eric Dumazet73f156a2014-06-02 05:26:03 -0700503 static u32 ip_idents_hashrnd __read_mostly;
504 u32 hash, id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
Eric Dumazet73f156a2014-06-02 05:26:03 -0700506 net_get_random_once(&ip_idents_hashrnd, sizeof(ip_idents_hashrnd));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
Eric Dumazet04ca6972014-07-26 08:58:10 +0200508 hash = jhash_3words((__force u32)iph->daddr,
509 (__force u32)iph->saddr,
Hannes Frederic Sowab6a77192015-03-25 17:07:44 +0100510 iph->protocol ^ net_hash_mix(net),
Eric Dumazet04ca6972014-07-26 08:58:10 +0200511 ip_idents_hashrnd);
Eric Dumazet73f156a2014-06-02 05:26:03 -0700512 id = ip_idents_reserve(hash, segs);
513 iph->id = htons(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000515EXPORT_SYMBOL(__ip_select_ident);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
Lorenzo Colittie2d118a2016-11-04 02:23:43 +0900517static void __build_flow_key(const struct net *net, struct flowi4 *fl4,
518 const struct sock *sk,
David S. Miller4895c772012-07-17 04:19:00 -0700519 const struct iphdr *iph,
520 int oif, u8 tos,
521 u8 prot, u32 mark, int flow_flags)
522{
523 if (sk) {
524 const struct inet_sock *inet = inet_sk(sk);
525
526 oif = sk->sk_bound_dev_if;
527 mark = sk->sk_mark;
528 tos = RT_CONN_FLAGS(sk);
529 prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
530 }
531 flowi4_init_output(fl4, oif, mark, tos,
532 RT_SCOPE_UNIVERSE, prot,
533 flow_flags,
Lorenzo Colittie2d118a2016-11-04 02:23:43 +0900534 iph->daddr, iph->saddr, 0, 0,
535 sock_net_uid(net, sk));
David S. Miller4895c772012-07-17 04:19:00 -0700536}
537
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200538static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
539 const struct sock *sk)
David S. Miller4895c772012-07-17 04:19:00 -0700540{
Lorenzo Colittid109e612016-11-30 02:56:47 +0900541 const struct net *net = dev_net(skb->dev);
David S. Miller4895c772012-07-17 04:19:00 -0700542 const struct iphdr *iph = ip_hdr(skb);
543 int oif = skb->dev->ifindex;
544 u8 tos = RT_TOS(iph->tos);
545 u8 prot = iph->protocol;
546 u32 mark = skb->mark;
547
Lorenzo Colittid109e612016-11-30 02:56:47 +0900548 __build_flow_key(net, fl4, sk, iph, oif, tos, prot, mark, 0);
David S. Miller4895c772012-07-17 04:19:00 -0700549}
550
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200551static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
David S. Miller4895c772012-07-17 04:19:00 -0700552{
553 const struct inet_sock *inet = inet_sk(sk);
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200554 const struct ip_options_rcu *inet_opt;
David S. Miller4895c772012-07-17 04:19:00 -0700555 __be32 daddr = inet->inet_daddr;
556
557 rcu_read_lock();
558 inet_opt = rcu_dereference(inet->inet_opt);
559 if (inet_opt && inet_opt->opt.srr)
560 daddr = inet_opt->opt.faddr;
561 flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
562 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
563 inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
564 inet_sk_flowi_flags(sk),
Lorenzo Colittie2d118a2016-11-04 02:23:43 +0900565 daddr, inet->inet_saddr, 0, 0, sk->sk_uid);
David S. Miller4895c772012-07-17 04:19:00 -0700566 rcu_read_unlock();
567}
568
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200569static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
570 const struct sk_buff *skb)
David S. Miller4895c772012-07-17 04:19:00 -0700571{
572 if (skb)
573 build_skb_flow_key(fl4, skb, sk);
574 else
575 build_sk_flow_key(fl4, sk);
576}
577
David S. Millerc5038a82012-07-31 15:02:02 -0700578static DEFINE_SPINLOCK(fnhe_lock);
David S. Miller4895c772012-07-17 04:19:00 -0700579
Timo Teräs2ffae992013-06-27 10:27:05 +0300580static void fnhe_flush_routes(struct fib_nh_exception *fnhe)
581{
582 struct rtable *rt;
583
584 rt = rcu_dereference(fnhe->fnhe_rth_input);
585 if (rt) {
586 RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL);
Wei Wang95c47f92017-06-17 10:42:30 -0700587 dst_dev_put(&rt->dst);
Wei Wang08301062017-06-17 10:42:29 -0700588 dst_release(&rt->dst);
Timo Teräs2ffae992013-06-27 10:27:05 +0300589 }
590 rt = rcu_dereference(fnhe->fnhe_rth_output);
591 if (rt) {
592 RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL);
Wei Wang95c47f92017-06-17 10:42:30 -0700593 dst_dev_put(&rt->dst);
Wei Wang08301062017-06-17 10:42:29 -0700594 dst_release(&rt->dst);
Timo Teräs2ffae992013-06-27 10:27:05 +0300595 }
596}
597
Julian Anastasovaee06da2012-07-18 10:15:35 +0000598static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
David S. Miller4895c772012-07-17 04:19:00 -0700599{
600 struct fib_nh_exception *fnhe, *oldest;
601
602 oldest = rcu_dereference(hash->chain);
603 for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
604 fnhe = rcu_dereference(fnhe->fnhe_next)) {
605 if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
606 oldest = fnhe;
607 }
Timo Teräs2ffae992013-06-27 10:27:05 +0300608 fnhe_flush_routes(oldest);
David S. Miller4895c772012-07-17 04:19:00 -0700609 return oldest;
610}
611
David S. Millerd3a25c92012-07-17 13:23:08 -0700612static inline u32 fnhe_hashfun(__be32 daddr)
613{
Eric Dumazetd546c622014-09-04 08:21:31 -0700614 static u32 fnhe_hashrnd __read_mostly;
David S. Millerd3a25c92012-07-17 13:23:08 -0700615 u32 hval;
616
Eric Dumazetd546c622014-09-04 08:21:31 -0700617 net_get_random_once(&fnhe_hashrnd, sizeof(fnhe_hashrnd));
618 hval = jhash_1word((__force u32) daddr, fnhe_hashrnd);
619 return hash_32(hval, FNHE_HASH_SHIFT);
David S. Millerd3a25c92012-07-17 13:23:08 -0700620}
621
Timo Teräs387aa652013-05-27 20:46:31 +0000622static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnhe)
623{
624 rt->rt_pmtu = fnhe->fnhe_pmtu;
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +0100625 rt->rt_mtu_locked = fnhe->fnhe_mtu_locked;
Timo Teräs387aa652013-05-27 20:46:31 +0000626 rt->dst.expires = fnhe->fnhe_expires;
627
628 if (fnhe->fnhe_gw) {
629 rt->rt_flags |= RTCF_REDIRECTED;
630 rt->rt_gateway = fnhe->fnhe_gw;
631 rt->rt_uses_gateway = 1;
632 }
633}
634
Julian Anastasovaee06da2012-07-18 10:15:35 +0000635static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +0100636 u32 pmtu, bool lock, unsigned long expires)
David S. Miller4895c772012-07-17 04:19:00 -0700637{
Julian Anastasovaee06da2012-07-18 10:15:35 +0000638 struct fnhe_hash_bucket *hash;
David S. Miller4895c772012-07-17 04:19:00 -0700639 struct fib_nh_exception *fnhe;
Timo Teräs387aa652013-05-27 20:46:31 +0000640 struct rtable *rt;
Xin Longcebe84c2017-11-17 14:27:18 +0800641 u32 genid, hval;
Timo Teräs387aa652013-05-27 20:46:31 +0000642 unsigned int i;
David S. Miller4895c772012-07-17 04:19:00 -0700643 int depth;
Xin Longcebe84c2017-11-17 14:27:18 +0800644
645 genid = fnhe_genid(dev_net(nh->nh_dev));
646 hval = fnhe_hashfun(daddr);
David S. Miller4895c772012-07-17 04:19:00 -0700647
David S. Millerc5038a82012-07-31 15:02:02 -0700648 spin_lock_bh(&fnhe_lock);
Julian Anastasovaee06da2012-07-18 10:15:35 +0000649
Eric Dumazetcaa41522014-09-03 22:21:56 -0700650 hash = rcu_dereference(nh->nh_exceptions);
David S. Miller4895c772012-07-17 04:19:00 -0700651 if (!hash) {
Kees Cook6396bb22018-06-12 14:03:40 -0700652 hash = kcalloc(FNHE_HASH_SIZE, sizeof(*hash), GFP_ATOMIC);
David S. Miller4895c772012-07-17 04:19:00 -0700653 if (!hash)
Julian Anastasovaee06da2012-07-18 10:15:35 +0000654 goto out_unlock;
Eric Dumazetcaa41522014-09-03 22:21:56 -0700655 rcu_assign_pointer(nh->nh_exceptions, hash);
David S. Miller4895c772012-07-17 04:19:00 -0700656 }
657
David S. Miller4895c772012-07-17 04:19:00 -0700658 hash += hval;
659
660 depth = 0;
661 for (fnhe = rcu_dereference(hash->chain); fnhe;
662 fnhe = rcu_dereference(fnhe->fnhe_next)) {
663 if (fnhe->fnhe_daddr == daddr)
Julian Anastasovaee06da2012-07-18 10:15:35 +0000664 break;
David S. Miller4895c772012-07-17 04:19:00 -0700665 depth++;
666 }
667
Julian Anastasovaee06da2012-07-18 10:15:35 +0000668 if (fnhe) {
Xin Longcebe84c2017-11-17 14:27:18 +0800669 if (fnhe->fnhe_genid != genid)
670 fnhe->fnhe_genid = genid;
Julian Anastasovaee06da2012-07-18 10:15:35 +0000671 if (gw)
672 fnhe->fnhe_gw = gw;
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +0100673 if (pmtu) {
Julian Anastasovaee06da2012-07-18 10:15:35 +0000674 fnhe->fnhe_pmtu = pmtu;
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +0100675 fnhe->fnhe_mtu_locked = lock;
676 }
Xin Longe39d5242017-11-17 14:27:06 +0800677 fnhe->fnhe_expires = max(1UL, expires);
Timo Teräs387aa652013-05-27 20:46:31 +0000678 /* Update all cached dsts too */
Timo Teräs2ffae992013-06-27 10:27:05 +0300679 rt = rcu_dereference(fnhe->fnhe_rth_input);
680 if (rt)
681 fill_route_from_fnhe(rt, fnhe);
682 rt = rcu_dereference(fnhe->fnhe_rth_output);
Timo Teräs387aa652013-05-27 20:46:31 +0000683 if (rt)
684 fill_route_from_fnhe(rt, fnhe);
Julian Anastasovaee06da2012-07-18 10:15:35 +0000685 } else {
686 if (depth > FNHE_RECLAIM_DEPTH)
687 fnhe = fnhe_oldest(hash);
688 else {
689 fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
690 if (!fnhe)
691 goto out_unlock;
692
693 fnhe->fnhe_next = hash->chain;
694 rcu_assign_pointer(hash->chain, fnhe);
695 }
Xin Longcebe84c2017-11-17 14:27:18 +0800696 fnhe->fnhe_genid = genid;
Julian Anastasovaee06da2012-07-18 10:15:35 +0000697 fnhe->fnhe_daddr = daddr;
698 fnhe->fnhe_gw = gw;
699 fnhe->fnhe_pmtu = pmtu;
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +0100700 fnhe->fnhe_mtu_locked = lock;
Julian Anastasov94720e32018-05-02 09:41:19 +0300701 fnhe->fnhe_expires = max(1UL, expires);
Timo Teräs387aa652013-05-27 20:46:31 +0000702
703 /* Exception created; mark the cached routes for the nexthop
704 * stale, so anyone caching it rechecks if this exception
705 * applies to them.
706 */
Timo Teräs2ffae992013-06-27 10:27:05 +0300707 rt = rcu_dereference(nh->nh_rth_input);
708 if (rt)
709 rt->dst.obsolete = DST_OBSOLETE_KILL;
710
Timo Teräs387aa652013-05-27 20:46:31 +0000711 for_each_possible_cpu(i) {
712 struct rtable __rcu **prt;
713 prt = per_cpu_ptr(nh->nh_pcpu_rth_output, i);
714 rt = rcu_dereference(*prt);
715 if (rt)
716 rt->dst.obsolete = DST_OBSOLETE_KILL;
717 }
David S. Miller4895c772012-07-17 04:19:00 -0700718 }
David S. Miller4895c772012-07-17 04:19:00 -0700719
David S. Miller4895c772012-07-17 04:19:00 -0700720 fnhe->fnhe_stamp = jiffies;
Julian Anastasovaee06da2012-07-18 10:15:35 +0000721
722out_unlock:
David S. Millerc5038a82012-07-31 15:02:02 -0700723 spin_unlock_bh(&fnhe_lock);
David S. Miller4895c772012-07-17 04:19:00 -0700724}
725
David S. Millerceb33202012-07-17 11:31:28 -0700726static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
727 bool kill_route)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728{
David S. Millere47a1852012-07-11 20:55:47 -0700729 __be32 new_gw = icmp_hdr(skb)->un.gateway;
David S. Miller94206122012-07-11 20:38:08 -0700730 __be32 old_gw = ip_hdr(skb)->saddr;
David S. Millere47a1852012-07-11 20:55:47 -0700731 struct net_device *dev = skb->dev;
David S. Millere47a1852012-07-11 20:55:47 -0700732 struct in_device *in_dev;
David S. Miller4895c772012-07-17 04:19:00 -0700733 struct fib_result res;
David S. Millere47a1852012-07-11 20:55:47 -0700734 struct neighbour *n;
Denis V. Lunev317805b2008-02-28 20:50:06 -0800735 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
David S. Miller94206122012-07-11 20:38:08 -0700737 switch (icmp_hdr(skb)->code & 7) {
738 case ICMP_REDIR_NET:
739 case ICMP_REDIR_NETTOS:
740 case ICMP_REDIR_HOST:
741 case ICMP_REDIR_HOSTTOS:
742 break;
743
744 default:
745 return;
746 }
747
David S. Millere47a1852012-07-11 20:55:47 -0700748 if (rt->rt_gateway != old_gw)
749 return;
750
751 in_dev = __in_dev_get_rcu(dev);
752 if (!in_dev)
753 return;
754
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900755 net = dev_net(dev);
Joe Perches9d4fb272009-11-23 10:41:23 -0800756 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
757 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
758 ipv4_is_zeronet(new_gw))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 goto reject_redirect;
760
761 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
762 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
763 goto reject_redirect;
764 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
765 goto reject_redirect;
766 } else {
Denis V. Lunev317805b2008-02-28 20:50:06 -0800767 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 goto reject_redirect;
769 }
770
Stephen Suryaputra Lin969447f2016-11-10 11:16:15 -0500771 n = __ipv4_neigh_lookup(rt->dst.dev, new_gw);
772 if (!n)
773 n = neigh_create(&arp_tbl, &new_gw, rt->dst.dev);
WANG Cong2c1a4312014-09-24 17:07:53 -0700774 if (!IS_ERR(n)) {
David S. Millere47a1852012-07-11 20:55:47 -0700775 if (!(n->nud_state & NUD_VALID)) {
776 neigh_event_send(n, NULL);
777 } else {
Andy Gospodarek0eeb0752015-06-23 13:45:37 -0400778 if (fib_lookup(net, fl4, &res, 0) == 0) {
David S. Miller4895c772012-07-17 04:19:00 -0700779 struct fib_nh *nh = &FIB_RES_NH(res);
David S. Miller4895c772012-07-17 04:19:00 -0700780
Julian Anastasovaee06da2012-07-18 10:15:35 +0000781 update_or_create_fnhe(nh, fl4->daddr, new_gw,
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +0100782 0, false,
783 jiffies + ip_rt_gc_timeout);
David S. Miller4895c772012-07-17 04:19:00 -0700784 }
David S. Millerceb33202012-07-17 11:31:28 -0700785 if (kill_route)
786 rt->dst.obsolete = DST_OBSOLETE_KILL;
David S. Millere47a1852012-07-11 20:55:47 -0700787 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
788 }
789 neigh_release(n);
790 }
791 return;
792
793reject_redirect:
794#ifdef CONFIG_IP_ROUTE_VERBOSE
David S. Miller99ee0382012-07-12 07:40:05 -0700795 if (IN_DEV_LOG_MARTIANS(in_dev)) {
796 const struct iphdr *iph = (const struct iphdr *) skb->data;
797 __be32 daddr = iph->daddr;
798 __be32 saddr = iph->saddr;
799
David S. Millere47a1852012-07-11 20:55:47 -0700800 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
801 " Advised path = %pI4 -> %pI4\n",
802 &old_gw, dev->name, &new_gw,
803 &saddr, &daddr);
David S. Miller99ee0382012-07-12 07:40:05 -0700804 }
David S. Millere47a1852012-07-11 20:55:47 -0700805#endif
806 ;
807}
808
David S. Miller4895c772012-07-17 04:19:00 -0700809static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
810{
811 struct rtable *rt;
812 struct flowi4 fl4;
Michal Kubecekf96ef982013-05-28 08:26:49 +0200813 const struct iphdr *iph = (const struct iphdr *) skb->data;
Lorenzo Colitti7d995692016-12-23 00:33:57 +0900814 struct net *net = dev_net(skb->dev);
Michal Kubecekf96ef982013-05-28 08:26:49 +0200815 int oif = skb->dev->ifindex;
816 u8 tos = RT_TOS(iph->tos);
817 u8 prot = iph->protocol;
818 u32 mark = skb->mark;
David S. Miller4895c772012-07-17 04:19:00 -0700819
820 rt = (struct rtable *) dst;
821
Lorenzo Colitti7d995692016-12-23 00:33:57 +0900822 __build_flow_key(net, &fl4, sk, iph, oif, tos, prot, mark, 0);
David S. Millerceb33202012-07-17 11:31:28 -0700823 __ip_do_redirect(rt, skb, &fl4, true);
David S. Miller4895c772012-07-17 04:19:00 -0700824}
825
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
827{
Eric Dumazetee6b9672008-03-05 18:30:47 -0800828 struct rtable *rt = (struct rtable *)dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 struct dst_entry *ret = dst;
830
831 if (rt) {
Timo Teräsd11a4dc2010-03-18 23:20:20 +0000832 if (dst->obsolete > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 ip_rt_put(rt);
834 ret = NULL;
David S. Miller59436342012-07-10 06:58:42 -0700835 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
836 rt->dst.expires) {
David S. Miller89aef892012-07-17 11:00:09 -0700837 ip_rt_put(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 ret = NULL;
839 }
840 }
841 return ret;
842}
843
844/*
845 * Algorithm:
846 * 1. The first ip_rt_redirect_number redirects are sent
847 * with exponential backoff, then we stop sending them at all,
848 * assuming that the host ignores our redirects.
849 * 2. If we did not see packets requiring redirects
850 * during ip_rt_redirect_silence, we assume that the host
851 * forgot redirected route and start to send redirects again.
852 *
853 * This algorithm is much cheaper and more intelligent than dumb load limiting
854 * in icmp.c.
855 *
856 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
857 * and "frag. need" (breaks PMTU discovery) in icmp.c.
858 */
859
860void ip_rt_send_redirect(struct sk_buff *skb)
861{
Eric Dumazet511c3f92009-06-02 05:14:27 +0000862 struct rtable *rt = skb_rtable(skb);
Eric Dumazet30038fc2009-08-28 23:52:01 -0700863 struct in_device *in_dev;
David S. Miller92d86822011-02-04 15:55:25 -0800864 struct inet_peer *peer;
David S. Miller1d861aa2012-07-10 03:58:16 -0700865 struct net *net;
Eric Dumazet30038fc2009-08-28 23:52:01 -0700866 int log_martians;
David Ahern192132b2015-08-27 16:07:03 -0700867 int vif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868
Eric Dumazet30038fc2009-08-28 23:52:01 -0700869 rcu_read_lock();
Changli Gaod8d1f302010-06-10 23:31:35 -0700870 in_dev = __in_dev_get_rcu(rt->dst.dev);
Eric Dumazet30038fc2009-08-28 23:52:01 -0700871 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
872 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 return;
Eric Dumazet30038fc2009-08-28 23:52:01 -0700874 }
875 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
David Ahern385add92015-09-29 20:07:13 -0700876 vif = l3mdev_master_ifindex_rcu(rt->dst.dev);
Eric Dumazet30038fc2009-08-28 23:52:01 -0700877 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
David S. Miller1d861aa2012-07-10 03:58:16 -0700879 net = dev_net(rt->dst.dev);
David Ahern192132b2015-08-27 16:07:03 -0700880 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, vif, 1);
David S. Miller92d86822011-02-04 15:55:25 -0800881 if (!peer) {
Julian Anastasove81da0e2012-10-08 11:41:15 +0000882 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
883 rt_nexthop(rt, ip_hdr(skb)->daddr));
David S. Miller92d86822011-02-04 15:55:25 -0800884 return;
885 }
886
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 /* No redirected packets during ip_rt_redirect_silence;
888 * reset the algorithm.
889 */
David S. Miller92d86822011-02-04 15:55:25 -0800890 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
891 peer->rate_tokens = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
893 /* Too many ignored redirects; do not send anything
Changli Gaod8d1f302010-06-10 23:31:35 -0700894 * set dst.rate_last to the last seen redirected packet.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 */
David S. Miller92d86822011-02-04 15:55:25 -0800896 if (peer->rate_tokens >= ip_rt_redirect_number) {
897 peer->rate_last = jiffies;
David S. Miller1d861aa2012-07-10 03:58:16 -0700898 goto out_put_peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 }
900
901 /* Check for load limit; set rate_last to the latest sent
902 * redirect.
903 */
David S. Miller92d86822011-02-04 15:55:25 -0800904 if (peer->rate_tokens == 0 ||
Li Yewang14fb8a72006-12-18 00:26:35 -0800905 time_after(jiffies,
David S. Miller92d86822011-02-04 15:55:25 -0800906 (peer->rate_last +
907 (ip_rt_redirect_load << peer->rate_tokens)))) {
Julian Anastasove81da0e2012-10-08 11:41:15 +0000908 __be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);
909
910 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
David S. Miller92d86822011-02-04 15:55:25 -0800911 peer->rate_last = jiffies;
912 ++peer->rate_tokens;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913#ifdef CONFIG_IP_ROUTE_VERBOSE
Eric Dumazet30038fc2009-08-28 23:52:01 -0700914 if (log_martians &&
Joe Perchese87cc472012-05-13 21:56:26 +0000915 peer->rate_tokens == ip_rt_redirect_number)
916 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
David S. Miller92101b32012-07-23 16:29:00 -0700917 &ip_hdr(skb)->saddr, inet_iif(skb),
Julian Anastasove81da0e2012-10-08 11:41:15 +0000918 &ip_hdr(skb)->daddr, &gw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919#endif
920 }
David S. Miller1d861aa2012-07-10 03:58:16 -0700921out_put_peer:
922 inet_putpeer(peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923}
924
925static int ip_error(struct sk_buff *skb)
926{
Eric Dumazet511c3f92009-06-02 05:14:27 +0000927 struct rtable *rt = skb_rtable(skb);
Stephen Suryaputrae2c0dc12018-02-28 12:20:44 -0500928 struct net_device *dev = skb->dev;
929 struct in_device *in_dev;
David S. Miller92d86822011-02-04 15:55:25 -0800930 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 unsigned long now;
David S. Miller251da412012-06-26 16:27:09 -0700932 struct net *net;
David S. Miller92d86822011-02-04 15:55:25 -0800933 bool send;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 int code;
935
Stephen Suryaputrae2c0dc12018-02-28 12:20:44 -0500936 if (netif_is_l3_master(skb->dev)) {
937 dev = __dev_get_by_index(dev_net(skb->dev), IPCB(skb)->iif);
938 if (!dev)
939 goto out;
940 }
941
942 in_dev = __in_dev_get_rcu(dev);
943
Eric W. Biederman381c7592015-05-22 04:58:12 -0500944 /* IP on this device is disabled. */
945 if (!in_dev)
946 goto out;
947
David S. Miller251da412012-06-26 16:27:09 -0700948 net = dev_net(rt->dst.dev);
949 if (!IN_DEV_FORWARD(in_dev)) {
950 switch (rt->dst.error) {
951 case EHOSTUNREACH:
Eric Dumazetb45386e2016-04-27 16:44:35 -0700952 __IP_INC_STATS(net, IPSTATS_MIB_INADDRERRORS);
David S. Miller251da412012-06-26 16:27:09 -0700953 break;
954
955 case ENETUNREACH:
Eric Dumazetb45386e2016-04-27 16:44:35 -0700956 __IP_INC_STATS(net, IPSTATS_MIB_INNOROUTES);
David S. Miller251da412012-06-26 16:27:09 -0700957 break;
958 }
959 goto out;
960 }
961
Changli Gaod8d1f302010-06-10 23:31:35 -0700962 switch (rt->dst.error) {
Joe Perches4500ebf2011-07-01 09:43:07 +0000963 case EINVAL:
964 default:
965 goto out;
966 case EHOSTUNREACH:
967 code = ICMP_HOST_UNREACH;
968 break;
969 case ENETUNREACH:
970 code = ICMP_NET_UNREACH;
Eric Dumazetb45386e2016-04-27 16:44:35 -0700971 __IP_INC_STATS(net, IPSTATS_MIB_INNOROUTES);
Joe Perches4500ebf2011-07-01 09:43:07 +0000972 break;
973 case EACCES:
974 code = ICMP_PKT_FILTERED;
975 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 }
977
David Ahern192132b2015-08-27 16:07:03 -0700978 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr,
David Ahern385add92015-09-29 20:07:13 -0700979 l3mdev_master_ifindex(skb->dev), 1);
David S. Miller92d86822011-02-04 15:55:25 -0800980
981 send = true;
982 if (peer) {
983 now = jiffies;
984 peer->rate_tokens += now - peer->rate_last;
985 if (peer->rate_tokens > ip_rt_error_burst)
986 peer->rate_tokens = ip_rt_error_burst;
987 peer->rate_last = now;
988 if (peer->rate_tokens >= ip_rt_error_cost)
989 peer->rate_tokens -= ip_rt_error_cost;
990 else
991 send = false;
David S. Miller1d861aa2012-07-10 03:58:16 -0700992 inet_putpeer(peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 }
David S. Miller92d86822011-02-04 15:55:25 -0800994 if (send)
995 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996
997out: kfree_skb(skb);
998 return 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900999}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
Steffen Klassertd851c122012-10-07 22:47:25 +00001001static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002{
Steffen Klassertd851c122012-10-07 22:47:25 +00001003 struct dst_entry *dst = &rt->dst;
David S. Miller4895c772012-07-17 04:19:00 -07001004 struct fib_result res;
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +01001005 bool lock = false;
David S. Miller2c8cec52011-02-09 20:42:07 -08001006
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +01001007 if (ip_mtu_locked(dst))
Steffen Klassertfa1e4922013-01-16 20:58:10 +00001008 return;
1009
Herbert Xucb6ccf02015-04-28 11:43:15 +08001010 if (ipv4_mtu(dst) < mtu)
Li Wei3cdaa5b2015-01-29 16:09:03 +08001011 return;
1012
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +01001013 if (mtu < ip_rt_min_pmtu) {
1014 lock = true;
David S. Miller59436342012-07-10 06:58:42 -07001015 mtu = ip_rt_min_pmtu;
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +01001016 }
Eric Dumazetfe6fe792011-06-08 06:07:07 +00001017
Timo Teräsf0162292013-05-27 20:46:32 +00001018 if (rt->rt_pmtu == mtu &&
1019 time_before(jiffies, dst->expires - ip_rt_mtu_expires / 2))
1020 return;
1021
Eric Dumazetc5ae7d42012-08-28 12:33:07 +00001022 rcu_read_lock();
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04001023 if (fib_lookup(dev_net(dst->dev), fl4, &res, 0) == 0) {
David S. Miller4895c772012-07-17 04:19:00 -07001024 struct fib_nh *nh = &FIB_RES_NH(res);
David S. Miller4895c772012-07-17 04:19:00 -07001025
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +01001026 update_or_create_fnhe(nh, fl4->daddr, 0, mtu, lock,
Julian Anastasovaee06da2012-07-18 10:15:35 +00001027 jiffies + ip_rt_mtu_expires);
David S. Miller4895c772012-07-17 04:19:00 -07001028 }
Eric Dumazetc5ae7d42012-08-28 12:33:07 +00001029 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030}
1031
David S. Miller4895c772012-07-17 04:19:00 -07001032static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1033 struct sk_buff *skb, u32 mtu)
1034{
1035 struct rtable *rt = (struct rtable *) dst;
1036 struct flowi4 fl4;
1037
1038 ip_rt_build_flow_key(&fl4, sk, skb);
Steffen Klassertd851c122012-10-07 22:47:25 +00001039 __ip_rt_update_pmtu(rt, &fl4, mtu);
David S. Miller4895c772012-07-17 04:19:00 -07001040}
1041
David S. Miller36393392012-06-14 22:21:46 -07001042void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
1043 int oif, u32 mark, u8 protocol, int flow_flags)
1044{
David S. Miller4895c772012-07-17 04:19:00 -07001045 const struct iphdr *iph = (const struct iphdr *) skb->data;
David S. Miller36393392012-06-14 22:21:46 -07001046 struct flowi4 fl4;
1047 struct rtable *rt;
1048
Lorenzo Colitti1b3c61d2014-05-13 10:17:34 -07001049 if (!mark)
1050 mark = IP4_REPLY_MARK(net, skb->mark);
1051
Lorenzo Colittie2d118a2016-11-04 02:23:43 +09001052 __build_flow_key(net, &fl4, NULL, iph, oif,
David S. Miller4895c772012-07-17 04:19:00 -07001053 RT_TOS(iph->tos), protocol, mark, flow_flags);
David S. Miller36393392012-06-14 22:21:46 -07001054 rt = __ip_route_output_key(net, &fl4);
1055 if (!IS_ERR(rt)) {
David S. Miller4895c772012-07-17 04:19:00 -07001056 __ip_rt_update_pmtu(rt, &fl4, mtu);
David S. Miller36393392012-06-14 22:21:46 -07001057 ip_rt_put(rt);
1058 }
1059}
1060EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
1061
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001062static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
David S. Miller36393392012-06-14 22:21:46 -07001063{
David S. Miller4895c772012-07-17 04:19:00 -07001064 const struct iphdr *iph = (const struct iphdr *) skb->data;
1065 struct flowi4 fl4;
1066 struct rtable *rt;
David S. Miller36393392012-06-14 22:21:46 -07001067
Lorenzo Colittie2d118a2016-11-04 02:23:43 +09001068 __build_flow_key(sock_net(sk), &fl4, sk, iph, 0, 0, 0, 0, 0);
Lorenzo Colitti1b3c61d2014-05-13 10:17:34 -07001069
1070 if (!fl4.flowi4_mark)
1071 fl4.flowi4_mark = IP4_REPLY_MARK(sock_net(sk), skb->mark);
1072
David S. Miller4895c772012-07-17 04:19:00 -07001073 rt = __ip_route_output_key(sock_net(sk), &fl4);
1074 if (!IS_ERR(rt)) {
1075 __ip_rt_update_pmtu(rt, &fl4, mtu);
1076 ip_rt_put(rt);
1077 }
David S. Miller36393392012-06-14 22:21:46 -07001078}
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001079
1080void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1081{
1082 const struct iphdr *iph = (const struct iphdr *) skb->data;
1083 struct flowi4 fl4;
1084 struct rtable *rt;
Eric Dumazet7f502362014-06-30 01:26:23 -07001085 struct dst_entry *odst = NULL;
Steffen Klassertb44108d2013-01-22 00:01:28 +00001086 bool new = false;
Lorenzo Colittie2d118a2016-11-04 02:23:43 +09001087 struct net *net = sock_net(sk);
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001088
1089 bh_lock_sock(sk);
Hannes Frederic Sowa482fc602013-11-05 02:24:17 +01001090
1091 if (!ip_sk_accept_pmtu(sk))
1092 goto out;
1093
Eric Dumazet7f502362014-06-30 01:26:23 -07001094 odst = sk_dst_get(sk);
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001095
Eric Dumazet7f502362014-06-30 01:26:23 -07001096 if (sock_owned_by_user(sk) || !odst) {
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001097 __ipv4_sk_update_pmtu(skb, sk, mtu);
1098 goto out;
1099 }
1100
Lorenzo Colittie2d118a2016-11-04 02:23:43 +09001101 __build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001102
Eric Dumazet7f502362014-06-30 01:26:23 -07001103 rt = (struct rtable *)odst;
Ian Morris51456b22015-04-03 09:17:26 +01001104 if (odst->obsolete && !odst->ops->check(odst, 0)) {
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001105 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1106 if (IS_ERR(rt))
1107 goto out;
Steffen Klassertb44108d2013-01-22 00:01:28 +00001108
1109 new = true;
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001110 }
1111
David Miller0f6c4802017-11-28 15:40:46 -05001112 __ip_rt_update_pmtu((struct rtable *) xfrm_dst_path(&rt->dst), &fl4, mtu);
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001113
Eric Dumazet7f502362014-06-30 01:26:23 -07001114 if (!dst_check(&rt->dst, 0)) {
Steffen Klassertb44108d2013-01-22 00:01:28 +00001115 if (new)
1116 dst_release(&rt->dst);
1117
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001118 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1119 if (IS_ERR(rt))
1120 goto out;
1121
Steffen Klassertb44108d2013-01-22 00:01:28 +00001122 new = true;
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001123 }
1124
Steffen Klassertb44108d2013-01-22 00:01:28 +00001125 if (new)
Eric Dumazet7f502362014-06-30 01:26:23 -07001126 sk_dst_set(sk, &rt->dst);
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001127
1128out:
1129 bh_unlock_sock(sk);
Eric Dumazet7f502362014-06-30 01:26:23 -07001130 dst_release(odst);
Steffen Klassert9cb3a502013-01-21 01:59:11 +00001131}
David S. Miller36393392012-06-14 22:21:46 -07001132EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
David S. Millerf39925d2011-02-09 22:00:16 -08001133
David S. Millerb42597e2012-07-11 21:25:45 -07001134void ipv4_redirect(struct sk_buff *skb, struct net *net,
1135 int oif, u32 mark, u8 protocol, int flow_flags)
1136{
David S. Miller4895c772012-07-17 04:19:00 -07001137 const struct iphdr *iph = (const struct iphdr *) skb->data;
David S. Millerb42597e2012-07-11 21:25:45 -07001138 struct flowi4 fl4;
1139 struct rtable *rt;
1140
Lorenzo Colittie2d118a2016-11-04 02:23:43 +09001141 __build_flow_key(net, &fl4, NULL, iph, oif,
David S. Miller4895c772012-07-17 04:19:00 -07001142 RT_TOS(iph->tos), protocol, mark, flow_flags);
David S. Millerb42597e2012-07-11 21:25:45 -07001143 rt = __ip_route_output_key(net, &fl4);
1144 if (!IS_ERR(rt)) {
David S. Millerceb33202012-07-17 11:31:28 -07001145 __ip_do_redirect(rt, skb, &fl4, false);
David S. Millerb42597e2012-07-11 21:25:45 -07001146 ip_rt_put(rt);
1147 }
1148}
1149EXPORT_SYMBOL_GPL(ipv4_redirect);
1150
1151void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1152{
David S. Miller4895c772012-07-17 04:19:00 -07001153 const struct iphdr *iph = (const struct iphdr *) skb->data;
1154 struct flowi4 fl4;
1155 struct rtable *rt;
Lorenzo Colittie2d118a2016-11-04 02:23:43 +09001156 struct net *net = sock_net(sk);
David S. Millerb42597e2012-07-11 21:25:45 -07001157
Lorenzo Colittie2d118a2016-11-04 02:23:43 +09001158 __build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);
1159 rt = __ip_route_output_key(net, &fl4);
David S. Miller4895c772012-07-17 04:19:00 -07001160 if (!IS_ERR(rt)) {
David S. Millerceb33202012-07-17 11:31:28 -07001161 __ip_do_redirect(rt, skb, &fl4, false);
David S. Miller4895c772012-07-17 04:19:00 -07001162 ip_rt_put(rt);
1163 }
David S. Millerb42597e2012-07-11 21:25:45 -07001164}
1165EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1166
David S. Millerefbc368d2011-12-01 13:38:59 -05001167static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1168{
1169 struct rtable *rt = (struct rtable *) dst;
1170
David S. Millerceb33202012-07-17 11:31:28 -07001171 /* All IPV4 dsts are created with ->obsolete set to the value
1172 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1173 * into this function always.
1174 *
Timo Teräs387aa652013-05-27 20:46:31 +00001175 * When a PMTU/redirect information update invalidates a route,
1176 * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
1177 * DST_OBSOLETE_DEAD by dst_free().
David S. Millerceb33202012-07-17 11:31:28 -07001178 */
Timo Teräs387aa652013-05-27 20:46:31 +00001179 if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
David S. Millerefbc368d2011-12-01 13:38:59 -05001180 return NULL;
Timo Teräsd11a4dc2010-03-18 23:20:20 +00001181 return dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182}
1183
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184static void ipv4_link_failure(struct sk_buff *skb)
1185{
1186 struct rtable *rt;
1187
1188 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1189
Eric Dumazet511c3f92009-06-02 05:14:27 +00001190 rt = skb_rtable(skb);
David S. Miller59436342012-07-10 06:58:42 -07001191 if (rt)
1192 dst_set_expires(&rt->dst, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193}
1194
Eric W. Biedermanede20592015-10-07 16:48:47 -05001195static int ip_rt_bug(struct net *net, struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196{
Joe Perches91df42b2012-05-15 14:11:54 +00001197 pr_debug("%s: %pI4 -> %pI4, %s\n",
1198 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1199 skb->dev ? skb->dev->name : "?");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 kfree_skb(skb);
Dave Jonesc378a9c2011-05-21 07:16:42 +00001201 WARN_ON(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 return 0;
1203}
1204
1205/*
1206 We do not cache source address of outgoing interface,
1207 because it is used only by IP RR, TS and SRR options,
1208 so that it out of fast path.
1209
1210 BTW remember: "addr" is allowed to be not aligned
1211 in IP options!
1212 */
1213
David S. Miller8e363602011-05-13 17:29:41 -04001214void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215{
Al Viroa61ced52006-09-26 21:27:54 -07001216 __be32 src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217
David S. Millerc7537962010-11-11 17:07:48 -08001218 if (rt_is_output_route(rt))
David S. Millerc5be24f2011-05-13 18:01:21 -04001219 src = ip_hdr(skb)->saddr;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001220 else {
David S. Miller8e363602011-05-13 17:29:41 -04001221 struct fib_result res;
1222 struct flowi4 fl4;
1223 struct iphdr *iph;
1224
1225 iph = ip_hdr(skb);
1226
1227 memset(&fl4, 0, sizeof(fl4));
1228 fl4.daddr = iph->daddr;
1229 fl4.saddr = iph->saddr;
Julian Anastasovb0fe4a32011-07-23 02:00:41 +00001230 fl4.flowi4_tos = RT_TOS(iph->tos);
David S. Miller8e363602011-05-13 17:29:41 -04001231 fl4.flowi4_oif = rt->dst.dev->ifindex;
1232 fl4.flowi4_iif = skb->dev->ifindex;
1233 fl4.flowi4_mark = skb->mark;
David S. Miller5e2b61f2011-03-04 21:47:09 -08001234
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001235 rcu_read_lock();
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04001236 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res, 0) == 0)
David S. Miller436c3b62011-03-24 17:42:21 -07001237 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001238 else
David S. Millerf8126f12012-07-13 05:03:45 -07001239 src = inet_select_addr(rt->dst.dev,
1240 rt_nexthop(rt, iph->daddr),
1241 RT_SCOPE_UNIVERSE);
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001242 rcu_read_unlock();
1243 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 memcpy(addr, &src, 4);
1245}
1246
Patrick McHardyc7066f72011-01-14 13:36:42 +01001247#ifdef CONFIG_IP_ROUTE_CLASSID
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248static void set_class_tag(struct rtable *rt, u32 tag)
1249{
Changli Gaod8d1f302010-06-10 23:31:35 -07001250 if (!(rt->dst.tclassid & 0xFFFF))
1251 rt->dst.tclassid |= tag & 0xFFFF;
1252 if (!(rt->dst.tclassid & 0xFFFF0000))
1253 rt->dst.tclassid |= tag & 0xFFFF0000;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254}
1255#endif
1256
David S. Miller0dbaee32010-12-13 12:52:14 -08001257static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1258{
Gao Feng7ed14d92017-04-12 12:34:03 +08001259 unsigned int header_size = sizeof(struct tcphdr) + sizeof(struct iphdr);
Eric Dumazet164a5e72017-10-18 17:02:03 -07001260 unsigned int advmss = max_t(unsigned int, ipv4_mtu(dst) - header_size,
Gao Feng7ed14d92017-04-12 12:34:03 +08001261 ip_rt_min_advmss);
David S. Miller0dbaee32010-12-13 12:52:14 -08001262
Gao Feng7ed14d92017-04-12 12:34:03 +08001263 return min(advmss, IPV4_MAX_PMTU - header_size);
David S. Miller0dbaee32010-12-13 12:52:14 -08001264}
1265
Steffen Klassertebb762f2011-11-23 02:12:51 +00001266static unsigned int ipv4_mtu(const struct dst_entry *dst)
David S. Millerd33e4552010-12-14 13:01:14 -08001267{
Steffen Klassert261663b2011-11-23 02:14:50 +00001268 const struct rtable *rt = (const struct rtable *) dst;
David S. Miller59436342012-07-10 06:58:42 -07001269 unsigned int mtu = rt->rt_pmtu;
1270
Alexander Duyck98d75c32012-08-27 06:30:01 +00001271 if (!mtu || time_after_eq(jiffies, rt->dst.expires))
David S. Miller59436342012-07-10 06:58:42 -07001272 mtu = dst_metric_raw(dst, RTAX_MTU);
Steffen Klassert618f9bc2011-11-23 02:13:31 +00001273
Steffen Klassert38d523e2013-01-16 20:55:01 +00001274 if (mtu)
Steffen Klassert618f9bc2011-11-23 02:13:31 +00001275 return mtu;
1276
Eric Dumazetc780a042017-08-16 11:09:12 -07001277 mtu = READ_ONCE(dst->dev->mtu);
David S. Millerd33e4552010-12-14 13:01:14 -08001278
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +01001279 if (unlikely(ip_mtu_locked(dst))) {
Julian Anastasov155e8332012-10-08 11:41:18 +00001280 if (rt->rt_uses_gateway && mtu > 576)
David S. Millerd33e4552010-12-14 13:01:14 -08001281 mtu = 576;
1282 }
1283
Roopa Prabhu14972cb2016-08-24 20:10:43 -07001284 mtu = min_t(unsigned int, mtu, IP_MAX_MTU);
1285
1286 return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
David S. Millerd33e4552010-12-14 13:01:14 -08001287}
1288
Julian Anastasov94720e32018-05-02 09:41:19 +03001289static void ip_del_fnhe(struct fib_nh *nh, __be32 daddr)
1290{
1291 struct fnhe_hash_bucket *hash;
1292 struct fib_nh_exception *fnhe, __rcu **fnhe_p;
1293 u32 hval = fnhe_hashfun(daddr);
1294
1295 spin_lock_bh(&fnhe_lock);
1296
1297 hash = rcu_dereference_protected(nh->nh_exceptions,
1298 lockdep_is_held(&fnhe_lock));
1299 hash += hval;
1300
1301 fnhe_p = &hash->chain;
1302 fnhe = rcu_dereference_protected(*fnhe_p, lockdep_is_held(&fnhe_lock));
1303 while (fnhe) {
1304 if (fnhe->fnhe_daddr == daddr) {
1305 rcu_assign_pointer(*fnhe_p, rcu_dereference_protected(
1306 fnhe->fnhe_next, lockdep_is_held(&fnhe_lock)));
1307 fnhe_flush_routes(fnhe);
1308 kfree_rcu(fnhe, rcu);
1309 break;
1310 }
1311 fnhe_p = &fnhe->fnhe_next;
1312 fnhe = rcu_dereference_protected(fnhe->fnhe_next,
1313 lockdep_is_held(&fnhe_lock));
1314 }
1315
1316 spin_unlock_bh(&fnhe_lock);
1317}
1318
David S. Millerf2bb4be2012-07-17 12:20:47 -07001319static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
David S. Miller4895c772012-07-17 04:19:00 -07001320{
Eric Dumazetcaa41522014-09-03 22:21:56 -07001321 struct fnhe_hash_bucket *hash = rcu_dereference(nh->nh_exceptions);
David S. Miller4895c772012-07-17 04:19:00 -07001322 struct fib_nh_exception *fnhe;
1323 u32 hval;
1324
David S. Millerf2bb4be2012-07-17 12:20:47 -07001325 if (!hash)
1326 return NULL;
1327
David S. Millerd3a25c92012-07-17 13:23:08 -07001328 hval = fnhe_hashfun(daddr);
David S. Miller4895c772012-07-17 04:19:00 -07001329
1330 for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1331 fnhe = rcu_dereference(fnhe->fnhe_next)) {
Julian Anastasov94720e32018-05-02 09:41:19 +03001332 if (fnhe->fnhe_daddr == daddr) {
1333 if (fnhe->fnhe_expires &&
1334 time_after(jiffies, fnhe->fnhe_expires)) {
1335 ip_del_fnhe(nh, daddr);
1336 break;
1337 }
David S. Millerf2bb4be2012-07-17 12:20:47 -07001338 return fnhe;
Julian Anastasov94720e32018-05-02 09:41:19 +03001339 }
David S. Millerf2bb4be2012-07-17 12:20:47 -07001340 }
1341 return NULL;
1342}
David S. Miller4895c772012-07-17 04:19:00 -07001343
David Ahern50d889b2018-05-21 09:08:13 -07001344/* MTU selection:
1345 * 1. mtu on route is locked - use it
1346 * 2. mtu from nexthop exception
1347 * 3. mtu from egress device
1348 */
1349
1350u32 ip_mtu_from_fib_result(struct fib_result *res, __be32 daddr)
1351{
1352 struct fib_info *fi = res->fi;
1353 struct fib_nh *nh = &fi->fib_nh[res->nh_sel];
1354 struct net_device *dev = nh->nh_dev;
1355 u32 mtu = 0;
1356
1357 if (dev_net(dev)->ipv4.sysctl_ip_fwd_use_pmtu ||
1358 fi->fib_metrics->metrics[RTAX_LOCK - 1] & (1 << RTAX_MTU))
1359 mtu = fi->fib_mtu;
1360
1361 if (likely(!mtu)) {
1362 struct fib_nh_exception *fnhe;
1363
1364 fnhe = find_exception(nh, daddr);
1365 if (fnhe && !time_after_eq(jiffies, fnhe->fnhe_expires))
1366 mtu = fnhe->fnhe_pmtu;
1367 }
1368
1369 if (likely(!mtu))
1370 mtu = min(READ_ONCE(dev->mtu), IP_MAX_MTU);
1371
1372 return mtu - lwtunnel_headroom(nh->nh_lwtstate, mtu);
1373}
1374
David S. Millercaacf052012-07-31 15:06:50 -07001375static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
Wei Wanga4c2fd72017-06-17 10:42:42 -07001376 __be32 daddr, const bool do_cache)
David S. Millerf2bb4be2012-07-17 12:20:47 -07001377{
David S. Millercaacf052012-07-31 15:06:50 -07001378 bool ret = false;
1379
David S. Millerc5038a82012-07-31 15:02:02 -07001380 spin_lock_bh(&fnhe_lock);
Julian Anastasovaee06da2012-07-18 10:15:35 +00001381
David S. Millerc5038a82012-07-31 15:02:02 -07001382 if (daddr == fnhe->fnhe_daddr) {
Timo Teräs2ffae992013-06-27 10:27:05 +03001383 struct rtable __rcu **porig;
1384 struct rtable *orig;
Timo Teräs5aad1de2013-05-27 20:46:33 +00001385 int genid = fnhe_genid(dev_net(rt->dst.dev));
Timo Teräs2ffae992013-06-27 10:27:05 +03001386
1387 if (rt_is_input_route(rt))
1388 porig = &fnhe->fnhe_rth_input;
1389 else
1390 porig = &fnhe->fnhe_rth_output;
1391 orig = rcu_dereference(*porig);
Timo Teräs5aad1de2013-05-27 20:46:33 +00001392
1393 if (fnhe->fnhe_genid != genid) {
1394 fnhe->fnhe_genid = genid;
Steffen Klassert13d82bf2012-10-17 21:17:44 +00001395 fnhe->fnhe_gw = 0;
1396 fnhe->fnhe_pmtu = 0;
1397 fnhe->fnhe_expires = 0;
Hangbin Liu0e8411e42018-05-09 18:06:44 +08001398 fnhe->fnhe_mtu_locked = false;
Timo Teräs2ffae992013-06-27 10:27:05 +03001399 fnhe_flush_routes(fnhe);
1400 orig = NULL;
Steffen Klassert13d82bf2012-10-17 21:17:44 +00001401 }
Timo Teräs387aa652013-05-27 20:46:31 +00001402 fill_route_from_fnhe(rt, fnhe);
1403 if (!rt->rt_gateway)
Julian Anastasov155e8332012-10-08 11:41:18 +00001404 rt->rt_gateway = daddr;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001405
Wei Wanga4c2fd72017-06-17 10:42:42 -07001406 if (do_cache) {
Wei Wang08301062017-06-17 10:42:29 -07001407 dst_hold(&rt->dst);
Timo Teräs2ffae992013-06-27 10:27:05 +03001408 rcu_assign_pointer(*porig, rt);
Wei Wang08301062017-06-17 10:42:29 -07001409 if (orig) {
Wei Wang95c47f92017-06-17 10:42:30 -07001410 dst_dev_put(&orig->dst);
Wei Wang08301062017-06-17 10:42:29 -07001411 dst_release(&orig->dst);
Wei Wang08301062017-06-17 10:42:29 -07001412 }
Timo Teräs2ffae992013-06-27 10:27:05 +03001413 ret = true;
1414 }
David S. Millerc5038a82012-07-31 15:02:02 -07001415
1416 fnhe->fnhe_stamp = jiffies;
David S. Millerc5038a82012-07-31 15:02:02 -07001417 }
1418 spin_unlock_bh(&fnhe_lock);
David S. Millercaacf052012-07-31 15:06:50 -07001419
1420 return ret;
Eric Dumazet54764bb2012-07-31 01:08:23 +00001421}
1422
David S. Millercaacf052012-07-31 15:06:50 -07001423static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
David S. Millerf2bb4be2012-07-17 12:20:47 -07001424{
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001425 struct rtable *orig, *prev, **p;
David S. Millercaacf052012-07-31 15:06:50 -07001426 bool ret = true;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001427
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001428 if (rt_is_input_route(rt)) {
Eric Dumazet54764bb2012-07-31 01:08:23 +00001429 p = (struct rtable **)&nh->nh_rth_input;
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001430 } else {
Christoph Lameter903ceff2014-08-17 12:30:35 -05001431 p = (struct rtable **)raw_cpu_ptr(nh->nh_pcpu_rth_output);
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001432 }
David S. Millerf2bb4be2012-07-17 12:20:47 -07001433 orig = *p;
1434
Wei Wang08301062017-06-17 10:42:29 -07001435 /* hold dst before doing cmpxchg() to avoid race condition
1436 * on this dst
1437 */
1438 dst_hold(&rt->dst);
David S. Millerf2bb4be2012-07-17 12:20:47 -07001439 prev = cmpxchg(p, orig, rt);
1440 if (prev == orig) {
Wei Wang08301062017-06-17 10:42:29 -07001441 if (orig) {
Wei Wang95c47f92017-06-17 10:42:30 -07001442 dst_dev_put(&orig->dst);
Wei Wang08301062017-06-17 10:42:29 -07001443 dst_release(&orig->dst);
Wei Wang08301062017-06-17 10:42:29 -07001444 }
1445 } else {
1446 dst_release(&rt->dst);
David S. Millercaacf052012-07-31 15:06:50 -07001447 ret = false;
Wei Wang08301062017-06-17 10:42:29 -07001448 }
David S. Millercaacf052012-07-31 15:06:50 -07001449
1450 return ret;
1451}
1452
Eric Dumazet5055c372015-01-14 15:17:06 -08001453struct uncached_list {
1454 spinlock_t lock;
1455 struct list_head head;
1456};
1457
1458static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt_uncached_list);
David S. Millercaacf052012-07-31 15:06:50 -07001459
Xin Long510c3212018-02-14 19:06:02 +08001460void rt_add_uncached_list(struct rtable *rt)
David S. Millercaacf052012-07-31 15:06:50 -07001461{
Eric Dumazet5055c372015-01-14 15:17:06 -08001462 struct uncached_list *ul = raw_cpu_ptr(&rt_uncached_list);
1463
1464 rt->rt_uncached_list = ul;
1465
1466 spin_lock_bh(&ul->lock);
1467 list_add_tail(&rt->rt_uncached, &ul->head);
1468 spin_unlock_bh(&ul->lock);
David S. Millercaacf052012-07-31 15:06:50 -07001469}
1470
Xin Long510c3212018-02-14 19:06:02 +08001471void rt_del_uncached_list(struct rtable *rt)
David S. Millercaacf052012-07-31 15:06:50 -07001472{
Eric Dumazet78df76a2012-08-24 05:40:47 +00001473 if (!list_empty(&rt->rt_uncached)) {
Eric Dumazet5055c372015-01-14 15:17:06 -08001474 struct uncached_list *ul = rt->rt_uncached_list;
1475
1476 spin_lock_bh(&ul->lock);
David S. Millercaacf052012-07-31 15:06:50 -07001477 list_del(&rt->rt_uncached);
Eric Dumazet5055c372015-01-14 15:17:06 -08001478 spin_unlock_bh(&ul->lock);
David S. Millercaacf052012-07-31 15:06:50 -07001479 }
1480}
1481
Xin Long510c3212018-02-14 19:06:02 +08001482static void ipv4_dst_destroy(struct dst_entry *dst)
1483{
1484 struct dst_metrics *p = (struct dst_metrics *)DST_METRICS_PTR(dst);
1485 struct rtable *rt = (struct rtable *)dst;
1486
1487 if (p != &dst_default_metrics && refcount_dec_and_test(&p->refcnt))
1488 kfree(p);
1489
1490 rt_del_uncached_list(rt);
1491}
1492
David S. Millercaacf052012-07-31 15:06:50 -07001493void rt_flush_dev(struct net_device *dev)
1494{
Eric Dumazet5055c372015-01-14 15:17:06 -08001495 struct net *net = dev_net(dev);
1496 struct rtable *rt;
1497 int cpu;
David S. Millercaacf052012-07-31 15:06:50 -07001498
Eric Dumazet5055c372015-01-14 15:17:06 -08001499 for_each_possible_cpu(cpu) {
1500 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
1501
1502 spin_lock_bh(&ul->lock);
1503 list_for_each_entry(rt, &ul->head, rt_uncached) {
David S. Millercaacf052012-07-31 15:06:50 -07001504 if (rt->dst.dev != dev)
1505 continue;
1506 rt->dst.dev = net->loopback_dev;
1507 dev_hold(rt->dst.dev);
1508 dev_put(dev);
1509 }
Eric Dumazet5055c372015-01-14 15:17:06 -08001510 spin_unlock_bh(&ul->lock);
David S. Miller4895c772012-07-17 04:19:00 -07001511 }
1512}
1513
Eric Dumazet4331deb2012-07-25 05:11:23 +00001514static bool rt_cache_valid(const struct rtable *rt)
David S. Millerd2d68ba92012-07-17 12:58:50 -07001515{
Eric Dumazet4331deb2012-07-25 05:11:23 +00001516 return rt &&
1517 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1518 !rt_is_expired(rt);
David S. Millerd2d68ba92012-07-17 12:58:50 -07001519}
1520
David S. Millerf2bb4be2012-07-17 12:20:47 -07001521static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
David S. Miller5e2b61f2011-03-04 21:47:09 -08001522 const struct fib_result *res,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001523 struct fib_nh_exception *fnhe,
Wei Wanga4c2fd72017-06-17 10:42:42 -07001524 struct fib_info *fi, u16 type, u32 itag,
1525 const bool do_cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526{
David S. Millercaacf052012-07-31 15:06:50 -07001527 bool cached = false;
1528
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 if (fi) {
David S. Miller4895c772012-07-17 04:19:00 -07001530 struct fib_nh *nh = &FIB_RES_NH(*res);
1531
Julian Anastasov155e8332012-10-08 11:41:18 +00001532 if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK) {
David S. Miller4895c772012-07-17 04:19:00 -07001533 rt->rt_gateway = nh->nh_gw;
Julian Anastasov155e8332012-10-08 11:41:18 +00001534 rt->rt_uses_gateway = 1;
1535 }
Eric Dumazet3fb07da2017-05-25 14:27:35 -07001536 dst_init_metrics(&rt->dst, fi->fib_metrics->metrics, true);
1537 if (fi->fib_metrics != &dst_default_metrics) {
1538 rt->dst._metrics |= DST_METRICS_REFCOUNTED;
Eric Dumazet9620fef2017-08-18 12:08:07 -07001539 refcount_inc(&fi->fib_metrics->refcnt);
Eric Dumazet3fb07da2017-05-25 14:27:35 -07001540 }
Patrick McHardyc7066f72011-01-14 13:36:42 +01001541#ifdef CONFIG_IP_ROUTE_CLASSID
David S. Millerf2bb4be2012-07-17 12:20:47 -07001542 rt->dst.tclassid = nh->nh_tclassid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543#endif
Jiri Benc61adedf2015-08-20 13:56:25 +02001544 rt->dst.lwtstate = lwtstate_get(nh->nh_lwtstate);
David S. Millerc5038a82012-07-31 15:02:02 -07001545 if (unlikely(fnhe))
Wei Wanga4c2fd72017-06-17 10:42:42 -07001546 cached = rt_bind_exception(rt, fnhe, daddr, do_cache);
1547 else if (do_cache)
David S. Millercaacf052012-07-31 15:06:50 -07001548 cached = rt_cache_route(nh, rt);
Julian Anastasov155e8332012-10-08 11:41:18 +00001549 if (unlikely(!cached)) {
1550 /* Routes we intend to cache in nexthop exception or
1551 * FIB nexthop have the DST_NOCACHE bit clear.
1552 * However, if we are unsuccessful at storing this
1553 * route into the cache we really need to set it.
1554 */
Julian Anastasov155e8332012-10-08 11:41:18 +00001555 if (!rt->rt_gateway)
1556 rt->rt_gateway = daddr;
1557 rt_add_uncached_list(rt);
1558 }
1559 } else
David S. Millercaacf052012-07-31 15:06:50 -07001560 rt_add_uncached_list(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
Patrick McHardyc7066f72011-01-14 13:36:42 +01001562#ifdef CONFIG_IP_ROUTE_CLASSID
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563#ifdef CONFIG_IP_MULTIPLE_TABLES
David S. Miller85b91b02012-07-13 08:21:29 -07001564 set_class_tag(rt, res->tclassid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565#endif
1566 set_class_tag(rt, itag);
1567#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568}
1569
David Ahern9ab179d2016-04-07 11:10:06 -07001570struct rtable *rt_dst_alloc(struct net_device *dev,
1571 unsigned int flags, u16 type,
1572 bool nopolicy, bool noxfrm, bool will_cache)
David S. Miller0c4dcd52011-02-17 15:42:37 -08001573{
David Ahernd08c4f32015-09-02 13:58:34 -07001574 struct rtable *rt;
1575
1576 rt = dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
Wei Wanga4c2fd72017-06-17 10:42:42 -07001577 (will_cache ? 0 : DST_HOST) |
David Ahernd08c4f32015-09-02 13:58:34 -07001578 (nopolicy ? DST_NOPOLICY : 0) |
Wei Wangb2a9c0e2017-06-17 10:42:41 -07001579 (noxfrm ? DST_NOXFRM : 0));
David Ahernd08c4f32015-09-02 13:58:34 -07001580
1581 if (rt) {
1582 rt->rt_genid = rt_genid_ipv4(dev_net(dev));
1583 rt->rt_flags = flags;
1584 rt->rt_type = type;
1585 rt->rt_is_input = 0;
1586 rt->rt_iif = 0;
1587 rt->rt_pmtu = 0;
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +01001588 rt->rt_mtu_locked = 0;
David Ahernd08c4f32015-09-02 13:58:34 -07001589 rt->rt_gateway = 0;
1590 rt->rt_uses_gateway = 0;
1591 INIT_LIST_HEAD(&rt->rt_uncached);
1592
1593 rt->dst.output = ip_output;
1594 if (flags & RTCF_LOCAL)
1595 rt->dst.input = ip_local_deliver;
1596 }
1597
1598 return rt;
David S. Miller0c4dcd52011-02-17 15:42:37 -08001599}
David Ahern9ab179d2016-04-07 11:10:06 -07001600EXPORT_SYMBOL(rt_dst_alloc);
David S. Miller0c4dcd52011-02-17 15:42:37 -08001601
Eric Dumazet96d36222010-06-02 19:21:31 +00001602/* called in rcu_read_lock() section */
Paolo Abenibc044e82017-09-28 15:51:37 +02001603int ip_mc_validate_source(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1604 u8 tos, struct net_device *dev,
1605 struct in_device *in_dev, u32 *itag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606{
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001607 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608
1609 /* Primary sanity checks. */
Ian Morris51456b22015-04-03 09:17:26 +01001610 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 return -EINVAL;
1612
Jan Engelhardt1e637c72008-01-21 03:18:08 -08001613 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
Thomas Grafd0daebc32012-06-12 00:44:01 +00001614 skb->protocol != htons(ETH_P_IP))
Paolo Abenibc044e82017-09-28 15:51:37 +02001615 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616
Alexander Duyck75fea732015-09-28 11:10:38 -07001617 if (ipv4_is_loopback(saddr) && !IN_DEV_ROUTE_LOCALNET(in_dev))
Paolo Abenibc044e82017-09-28 15:51:37 +02001618 return -EINVAL;
Thomas Grafd0daebc32012-06-12 00:44:01 +00001619
Joe Perchesf97c1e02007-12-16 13:45:43 -08001620 if (ipv4_is_zeronet(saddr)) {
1621 if (!ipv4_is_local_multicast(daddr))
Paolo Abenibc044e82017-09-28 15:51:37 +02001622 return -EINVAL;
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001623 } else {
David S. Miller9e56e382012-06-28 18:54:02 -07001624 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
Paolo Abenibc044e82017-09-28 15:51:37 +02001625 in_dev, itag);
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001626 if (err < 0)
Paolo Abenibc044e82017-09-28 15:51:37 +02001627 return err;
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001628 }
Paolo Abenibc044e82017-09-28 15:51:37 +02001629 return 0;
1630}
1631
1632/* called in rcu_read_lock() section */
1633static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1634 u8 tos, struct net_device *dev, int our)
1635{
1636 struct in_device *in_dev = __in_dev_get_rcu(dev);
1637 unsigned int flags = RTCF_MULTICAST;
1638 struct rtable *rth;
1639 u32 itag = 0;
1640 int err;
1641
1642 err = ip_mc_validate_source(skb, daddr, saddr, tos, dev, in_dev, &itag);
1643 if (err)
1644 return err;
1645
David Ahernd08c4f32015-09-02 13:58:34 -07001646 if (our)
1647 flags |= RTCF_LOCAL;
1648
1649 rth = rt_dst_alloc(dev_net(dev)->loopback_dev, flags, RTN_MULTICAST,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001650 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 if (!rth)
Paolo Abenibc044e82017-09-28 15:51:37 +02001652 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
Patrick McHardyc7066f72011-01-14 13:36:42 +01001654#ifdef CONFIG_IP_ROUTE_CLASSID
Changli Gaod8d1f302010-06-10 23:31:35 -07001655 rth->dst.tclassid = itag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656#endif
David S. Millercf911662011-04-28 14:31:47 -07001657 rth->dst.output = ip_rt_bug;
David S. Miller9917e1e82012-07-17 14:44:26 -07001658 rth->rt_is_input= 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659
1660#ifdef CONFIG_IP_MROUTE
Joe Perchesf97c1e02007-12-16 13:45:43 -08001661 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
Changli Gaod8d1f302010-06-10 23:31:35 -07001662 rth->dst.input = ip_mr_input;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663#endif
1664 RT_CACHE_STAT_INC(in_slow_mc);
1665
David S. Miller89aef892012-07-17 11:00:09 -07001666 skb_dst_set(skb, &rth->dst);
1667 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668}
1669
1670
1671static void ip_handle_martian_source(struct net_device *dev,
1672 struct in_device *in_dev,
1673 struct sk_buff *skb,
Al Viro9e12bb22006-09-26 21:25:20 -07001674 __be32 daddr,
1675 __be32 saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676{
1677 RT_CACHE_STAT_INC(in_martian_src);
1678#ifdef CONFIG_IP_ROUTE_VERBOSE
1679 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1680 /*
1681 * RFC1812 recommendation, if source is martian,
1682 * the only hint is MAC header.
1683 */
Joe Perches058bd4d2012-03-11 18:36:11 +00001684 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
Harvey Harrison673d57e2008-10-31 00:53:57 -07001685 &daddr, &saddr, dev->name);
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001686 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
Joe Perches058bd4d2012-03-11 18:36:11 +00001687 print_hex_dump(KERN_WARNING, "ll header: ",
1688 DUMP_PREFIX_OFFSET, 16, 1,
1689 skb_mac_header(skb),
1690 dev->hard_header_len, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 }
1692 }
1693#endif
1694}
1695
Eric Dumazet47360222010-06-03 04:13:21 +00001696/* called in rcu_read_lock() section */
Stephen Hemminger5969f712008-04-10 01:52:09 -07001697static int __mkroute_input(struct sk_buff *skb,
David S. Miller982721f2011-02-16 21:44:24 -08001698 const struct fib_result *res,
Stephen Hemminger5969f712008-04-10 01:52:09 -07001699 struct in_device *in_dev,
David S. Millerc6cffba2012-07-26 11:14:38 +00001700 __be32 daddr, __be32 saddr, u32 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701{
Timo Teräs2ffae992013-06-27 10:27:05 +03001702 struct fib_nh_exception *fnhe;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 struct rtable *rth;
1704 int err;
1705 struct in_device *out_dev;
David S. Millerd2d68ba92012-07-17 12:58:50 -07001706 bool do_cache;
Li RongQingfbdc0ad2014-05-22 16:36:55 +08001707 u32 itag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708
1709 /* get a working reference to the output device */
Eric Dumazet47360222010-06-03 04:13:21 +00001710 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
Ian Morris51456b22015-04-03 09:17:26 +01001711 if (!out_dev) {
Joe Perchese87cc472012-05-13 21:56:26 +00001712 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 return -EINVAL;
1714 }
1715
Michael Smith5c04c812011-04-07 04:51:50 +00001716 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
David S. Miller9e56e382012-06-28 18:54:02 -07001717 in_dev->dev, in_dev, &itag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 if (err < 0) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001719 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 saddr);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001721
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 goto cleanup;
1723 }
1724
Julian Anastasove81da0e2012-10-08 11:41:15 +00001725 do_cache = res->fi && !itag;
1726 if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
Hannes Frederic Sowadf4d9252015-01-23 12:01:26 +01001727 skb->protocol == htons(ETH_P_IP) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 (IN_DEV_SHARED_MEDIA(out_dev) ||
Hannes Frederic Sowadf4d9252015-01-23 12:01:26 +01001729 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1730 IPCB(skb)->flags |= IPSKB_DOREDIRECT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731
1732 if (skb->protocol != htons(ETH_P_IP)) {
1733 /* Not IP (i.e. ARP). Do not create route, if it is
1734 * invalid for proxy arp. DNAT routes are always valid.
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00001735 *
1736 * Proxy arp feature have been extended to allow, ARP
1737 * replies back to the same interface, to support
1738 * Private VLAN switch technologies. See arp.c.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 */
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00001740 if (out_dev == in_dev &&
1741 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 err = -EINVAL;
1743 goto cleanup;
1744 }
1745 }
1746
Timo Teräs2ffae992013-06-27 10:27:05 +03001747 fnhe = find_exception(&FIB_RES_NH(*res), daddr);
Julian Anastasove81da0e2012-10-08 11:41:15 +00001748 if (do_cache) {
Julian Anastasov94720e32018-05-02 09:41:19 +03001749 if (fnhe)
Timo Teräs2ffae992013-06-27 10:27:05 +03001750 rth = rcu_dereference(fnhe->fnhe_rth_input);
Julian Anastasov94720e32018-05-02 09:41:19 +03001751 else
1752 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
Julian Anastasove81da0e2012-10-08 11:41:15 +00001753 if (rt_cache_valid(rth)) {
1754 skb_dst_set_noref(skb, &rth->dst);
1755 goto out;
David S. Millerd2d68ba92012-07-17 12:58:50 -07001756 }
1757 }
David S. Millerf2bb4be2012-07-17 12:20:47 -07001758
David Ahernd08c4f32015-09-02 13:58:34 -07001759 rth = rt_dst_alloc(out_dev->dev, 0, res->type,
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001760 IN_DEV_CONF_GET(in_dev, NOPOLICY),
David S. Millerd2d68ba92012-07-17 12:58:50 -07001761 IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 if (!rth) {
1763 err = -ENOBUFS;
1764 goto cleanup;
1765 }
1766
David S. Miller9917e1e82012-07-17 14:44:26 -07001767 rth->rt_is_input = 1;
Duan Jionga6254862014-02-17 15:23:43 +08001768 RT_CACHE_STAT_INC(in_slow_tot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769
Changli Gaod8d1f302010-06-10 23:31:35 -07001770 rth->dst.input = ip_forward;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771
Wei Wanga4c2fd72017-06-17 10:42:42 -07001772 rt_set_nexthop(rth, daddr, res, fnhe, res->fi, res->type, itag,
1773 do_cache);
David Ahern99428952018-02-13 20:32:04 -08001774 lwtunnel_set_redirect(&rth->dst);
David S. Millerc6cffba2012-07-26 11:14:38 +00001775 skb_dst_set(skb, &rth->dst);
David S. Millerd2d68ba92012-07-17 12:58:50 -07001776out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 err = 0;
1778 cleanup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 return err;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001780}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781
Peter Nørlund79a13152015-09-30 10:12:22 +02001782#ifdef CONFIG_IP_ROUTE_MULTIPATH
Peter Nørlund79a13152015-09-30 10:12:22 +02001783/* To make ICMP packets follow the right flow, the multipath hash is
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001784 * calculated from the inner IP addresses.
Peter Nørlund79a13152015-09-30 10:12:22 +02001785 */
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001786static void ip_multipath_l3_keys(const struct sk_buff *skb,
1787 struct flow_keys *hash_keys)
Peter Nørlund79a13152015-09-30 10:12:22 +02001788{
1789 const struct iphdr *outer_iph = ip_hdr(skb);
David Ahern6f74b6c2018-03-02 08:32:13 -08001790 const struct iphdr *key_iph = outer_iph;
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001791 const struct iphdr *inner_iph;
Peter Nørlund79a13152015-09-30 10:12:22 +02001792 const struct icmphdr *icmph;
1793 struct iphdr _inner_iph;
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001794 struct icmphdr _icmph;
1795
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001796 if (likely(outer_iph->protocol != IPPROTO_ICMP))
David Ahern6f74b6c2018-03-02 08:32:13 -08001797 goto out;
Peter Nørlund79a13152015-09-30 10:12:22 +02001798
1799 if (unlikely((outer_iph->frag_off & htons(IP_OFFSET)) != 0))
David Ahern6f74b6c2018-03-02 08:32:13 -08001800 goto out;
Peter Nørlund79a13152015-09-30 10:12:22 +02001801
1802 icmph = skb_header_pointer(skb, outer_iph->ihl * 4, sizeof(_icmph),
1803 &_icmph);
1804 if (!icmph)
David Ahern6f74b6c2018-03-02 08:32:13 -08001805 goto out;
Peter Nørlund79a13152015-09-30 10:12:22 +02001806
1807 if (icmph->type != ICMP_DEST_UNREACH &&
1808 icmph->type != ICMP_REDIRECT &&
1809 icmph->type != ICMP_TIME_EXCEEDED &&
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001810 icmph->type != ICMP_PARAMETERPROB)
David Ahern6f74b6c2018-03-02 08:32:13 -08001811 goto out;
Peter Nørlund79a13152015-09-30 10:12:22 +02001812
1813 inner_iph = skb_header_pointer(skb,
1814 outer_iph->ihl * 4 + sizeof(_icmph),
1815 sizeof(_inner_iph), &_inner_iph);
1816 if (!inner_iph)
David Ahern6f74b6c2018-03-02 08:32:13 -08001817 goto out;
1818
1819 key_iph = inner_iph;
1820out:
1821 hash_keys->addrs.v4addrs.src = key_iph->saddr;
1822 hash_keys->addrs.v4addrs.dst = key_iph->daddr;
Peter Nørlund79a13152015-09-30 10:12:22 +02001823}
1824
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001825/* if skb is set it will be used and fl4 can be NULL */
David Ahern7efc0b62018-03-02 08:32:12 -08001826int fib_multipath_hash(const struct net *net, const struct flowi4 *fl4,
Roopa Prabhue37b1e92018-02-28 22:42:41 -05001827 const struct sk_buff *skb, struct flow_keys *flkeys)
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001828{
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001829 struct flow_keys hash_keys;
1830 u32 mhash;
1831
1832 switch (net->ipv4.sysctl_fib_multipath_hash_policy) {
1833 case 0:
1834 memset(&hash_keys, 0, sizeof(hash_keys));
1835 hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
1836 if (skb) {
1837 ip_multipath_l3_keys(skb, &hash_keys);
1838 } else {
1839 hash_keys.addrs.v4addrs.src = fl4->saddr;
1840 hash_keys.addrs.v4addrs.dst = fl4->daddr;
1841 }
1842 break;
1843 case 1:
1844 /* skb is currently provided only when forwarding */
1845 if (skb) {
1846 unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP;
1847 struct flow_keys keys;
1848
1849 /* short-circuit if we already have L4 hash present */
1850 if (skb->l4_hash)
1851 return skb_get_hash_raw(skb) >> 1;
David Ahernec7127a2018-03-02 08:32:14 -08001852
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001853 memset(&hash_keys, 0, sizeof(hash_keys));
David Ahern1fe4b112018-02-21 11:00:54 -08001854
David Ahernec7127a2018-03-02 08:32:14 -08001855 if (!flkeys) {
Roopa Prabhue37b1e92018-02-28 22:42:41 -05001856 skb_flow_dissect_flow_keys(skb, &keys, flag);
David Ahernec7127a2018-03-02 08:32:14 -08001857 flkeys = &keys;
Roopa Prabhue37b1e92018-02-28 22:42:41 -05001858 }
David Ahernec7127a2018-03-02 08:32:14 -08001859
1860 hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
1861 hash_keys.addrs.v4addrs.src = flkeys->addrs.v4addrs.src;
1862 hash_keys.addrs.v4addrs.dst = flkeys->addrs.v4addrs.dst;
1863 hash_keys.ports.src = flkeys->ports.src;
1864 hash_keys.ports.dst = flkeys->ports.dst;
1865 hash_keys.basic.ip_proto = flkeys->basic.ip_proto;
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001866 } else {
1867 memset(&hash_keys, 0, sizeof(hash_keys));
1868 hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
1869 hash_keys.addrs.v4addrs.src = fl4->saddr;
1870 hash_keys.addrs.v4addrs.dst = fl4->daddr;
1871 hash_keys.ports.src = fl4->fl4_sport;
1872 hash_keys.ports.dst = fl4->fl4_dport;
1873 hash_keys.basic.ip_proto = fl4->flowi4_proto;
1874 }
1875 break;
1876 }
1877 mhash = flow_hash_from_keys(&hash_keys);
1878
1879 return mhash >> 1;
1880}
Peter Nørlund79a13152015-09-30 10:12:22 +02001881#endif /* CONFIG_IP_ROUTE_MULTIPATH */
1882
Stephen Hemminger5969f712008-04-10 01:52:09 -07001883static int ip_mkroute_input(struct sk_buff *skb,
1884 struct fib_result *res,
Stephen Hemminger5969f712008-04-10 01:52:09 -07001885 struct in_device *in_dev,
Roopa Prabhue37b1e92018-02-28 22:42:41 -05001886 __be32 daddr, __be32 saddr, u32 tos,
1887 struct flow_keys *hkeys)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889#ifdef CONFIG_IP_ROUTE_MULTIPATH
Peter Nørlund0e884c72015-09-30 10:12:21 +02001890 if (res->fi && res->fi->fib_nhs > 1) {
David Ahern7efc0b62018-03-02 08:32:12 -08001891 int h = fib_multipath_hash(res->fi->fib_net, NULL, skb, hkeys);
Peter Nørlund0e884c72015-09-30 10:12:21 +02001892
Peter Nørlund0e884c72015-09-30 10:12:21 +02001893 fib_select_multipath(res, h);
1894 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895#endif
1896
1897 /* create a routing cache entry */
David S. Millerc6cffba2012-07-26 11:14:38 +00001898 return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899}
1900
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901/*
1902 * NOTE. We drop all the packets that has local source
1903 * addresses, because every properly looped back packet
1904 * must have correct destination already attached by output routine.
1905 *
1906 * Such approach solves two big problems:
1907 * 1. Not simplex devices are handled properly.
1908 * 2. IP spoofing attempts are filtered with 100% of guarantee.
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001909 * called with rcu_read_lock()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 */
1911
Al Viro9e12bb22006-09-26 21:25:20 -07001912static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
David Ahern5510cdf2017-05-25 10:42:34 -07001913 u8 tos, struct net_device *dev,
1914 struct fib_result *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915{
Eric Dumazet96d36222010-06-02 19:21:31 +00001916 struct in_device *in_dev = __in_dev_get_rcu(dev);
Roopa Prabhue37b1e92018-02-28 22:42:41 -05001917 struct flow_keys *flkeys = NULL, _flkeys;
1918 struct net *net = dev_net(dev);
Thomas Graf1b7179d2015-07-21 10:43:59 +02001919 struct ip_tunnel_info *tun_info;
Roopa Prabhue37b1e92018-02-28 22:42:41 -05001920 int err = -EINVAL;
Eric Dumazet95c96172012-04-15 05:58:06 +00001921 unsigned int flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 u32 itag = 0;
Eric Dumazet95c96172012-04-15 05:58:06 +00001923 struct rtable *rth;
Roopa Prabhue37b1e92018-02-28 22:42:41 -05001924 struct flowi4 fl4;
David S. Millerd2d68ba92012-07-17 12:58:50 -07001925 bool do_cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926
1927 /* IP on this device is disabled. */
1928
1929 if (!in_dev)
1930 goto out;
1931
1932 /* Check for the most weird martians, which can be not detected
1933 by fib_lookup.
1934 */
1935
Jiri Benc61adedf2015-08-20 13:56:25 +02001936 tun_info = skb_tunnel_info(skb);
Jiri Benc46fa0622015-08-28 20:48:19 +02001937 if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
Thomas Graf1b7179d2015-07-21 10:43:59 +02001938 fl4.flowi4_tun_key.tun_id = tun_info->key.tun_id;
1939 else
1940 fl4.flowi4_tun_key.tun_id = 0;
Thomas Graff38a9eb2015-07-21 10:43:56 +02001941 skb_dst_drop(skb);
1942
Thomas Grafd0daebc32012-06-12 00:44:01 +00001943 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 goto martian_source;
1945
David Ahern5510cdf2017-05-25 10:42:34 -07001946 res->fi = NULL;
1947 res->table = NULL;
Andy Walls27a954b2010-10-17 15:11:22 +00001948 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 goto brd_input;
1950
1951 /* Accept zero addresses only to limited broadcast;
1952 * I even do not know to fix it or not. Waiting for complains :-)
1953 */
Joe Perchesf97c1e02007-12-16 13:45:43 -08001954 if (ipv4_is_zeronet(saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 goto martian_source;
1956
Thomas Grafd0daebc32012-06-12 00:44:01 +00001957 if (ipv4_is_zeronet(daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 goto martian_destination;
1959
Eric Dumazet9eb43e72012-08-03 21:27:25 +00001960 /* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
1961 * and call it once if daddr or/and saddr are loopback addresses
1962 */
1963 if (ipv4_is_loopback(daddr)) {
1964 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
Thomas Grafd0daebc32012-06-12 00:44:01 +00001965 goto martian_destination;
Eric Dumazet9eb43e72012-08-03 21:27:25 +00001966 } else if (ipv4_is_loopback(saddr)) {
1967 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
Thomas Grafd0daebc32012-06-12 00:44:01 +00001968 goto martian_source;
1969 }
1970
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 /*
1972 * Now we are ready to route packet.
1973 */
David S. Miller68a5e3d2011-03-11 20:07:33 -05001974 fl4.flowi4_oif = 0;
David Aherne0d56fd2016-09-10 12:09:57 -07001975 fl4.flowi4_iif = dev->ifindex;
David S. Miller68a5e3d2011-03-11 20:07:33 -05001976 fl4.flowi4_mark = skb->mark;
1977 fl4.flowi4_tos = tos;
1978 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
David Ahernb84f7872015-09-29 19:07:07 -07001979 fl4.flowi4_flags = 0;
David S. Miller68a5e3d2011-03-11 20:07:33 -05001980 fl4.daddr = daddr;
1981 fl4.saddr = saddr;
Julian Anastasov8bcfd092017-02-26 15:50:52 +02001982 fl4.flowi4_uid = sock_net_uid(net, NULL);
Roopa Prabhue37b1e92018-02-28 22:42:41 -05001983
David Ahern5a847a62018-05-16 13:36:40 -07001984 if (fib4_rules_early_flow_dissect(net, skb, &fl4, &_flkeys)) {
Roopa Prabhue37b1e92018-02-28 22:42:41 -05001985 flkeys = &_flkeys;
David Ahern5a847a62018-05-16 13:36:40 -07001986 } else {
1987 fl4.flowi4_proto = 0;
1988 fl4.fl4_sport = 0;
1989 fl4.fl4_dport = 0;
1990 }
Roopa Prabhue37b1e92018-02-28 22:42:41 -05001991
David Ahern5510cdf2017-05-25 10:42:34 -07001992 err = fib_lookup(net, &fl4, res, 0);
Duan Jiongcd0f0b92014-02-14 18:26:22 +08001993 if (err != 0) {
1994 if (!IN_DEV_FORWARD(in_dev))
1995 err = -EHOSTUNREACH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 goto no_route;
Duan Jiongcd0f0b92014-02-14 18:26:22 +08001997 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998
Xin Long5cbf7772018-07-27 16:37:28 +08001999 if (res->type == RTN_BROADCAST) {
2000 if (IN_DEV_BFORWARD(in_dev))
2001 goto make_route;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 goto brd_input;
Xin Long5cbf7772018-07-27 16:37:28 +08002003 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004
David Ahern5510cdf2017-05-25 10:42:34 -07002005 if (res->type == RTN_LOCAL) {
Michael Smith5c04c812011-04-07 04:51:50 +00002006 err = fib_validate_source(skb, saddr, daddr, tos,
Cong Wang0d5edc62014-04-15 16:25:35 -07002007 0, dev, in_dev, &itag);
Eric Dumazetb5f7e752010-06-02 12:05:27 +00002008 if (err < 0)
David Ahern0d753962015-09-28 11:10:44 -07002009 goto martian_source;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 goto local_input;
2011 }
2012
Duan Jiongcd0f0b92014-02-14 18:26:22 +08002013 if (!IN_DEV_FORWARD(in_dev)) {
2014 err = -EHOSTUNREACH;
David S. Miller251da412012-06-26 16:27:09 -07002015 goto no_route;
Duan Jiongcd0f0b92014-02-14 18:26:22 +08002016 }
David Ahern5510cdf2017-05-25 10:42:34 -07002017 if (res->type != RTN_UNICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018 goto martian_destination;
2019
Xin Long5cbf7772018-07-27 16:37:28 +08002020make_route:
Roopa Prabhue37b1e92018-02-28 22:42:41 -05002021 err = ip_mkroute_input(skb, res, in_dev, daddr, saddr, tos, flkeys);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022out: return err;
2023
2024brd_input:
2025 if (skb->protocol != htons(ETH_P_IP))
2026 goto e_inval;
2027
David S. Miller41347dc2012-06-28 04:05:27 -07002028 if (!ipv4_is_zeronet(saddr)) {
David S. Miller9e56e382012-06-28 18:54:02 -07002029 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
2030 in_dev, &itag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 if (err < 0)
David Ahern0d753962015-09-28 11:10:44 -07002032 goto martian_source;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 }
2034 flags |= RTCF_BROADCAST;
David Ahern5510cdf2017-05-25 10:42:34 -07002035 res->type = RTN_BROADCAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 RT_CACHE_STAT_INC(in_brd);
2037
2038local_input:
David S. Millerd2d68ba92012-07-17 12:58:50 -07002039 do_cache = false;
David Ahern5510cdf2017-05-25 10:42:34 -07002040 if (res->fi) {
David S. Millerfe3edf42012-07-23 13:22:20 -07002041 if (!itag) {
David Ahern5510cdf2017-05-25 10:42:34 -07002042 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
David S. Millerd2d68ba92012-07-17 12:58:50 -07002043 if (rt_cache_valid(rth)) {
David S. Millerc6cffba2012-07-26 11:14:38 +00002044 skb_dst_set_noref(skb, &rth->dst);
2045 err = 0;
2046 goto out;
David S. Millerd2d68ba92012-07-17 12:58:50 -07002047 }
2048 do_cache = true;
2049 }
2050 }
2051
David Ahernf5a0aab2016-12-29 15:29:03 -08002052 rth = rt_dst_alloc(l3mdev_master_dev_rcu(dev) ? : net->loopback_dev,
David Ahern5510cdf2017-05-25 10:42:34 -07002053 flags | RTCF_LOCAL, res->type,
David S. Millerd2d68ba92012-07-17 12:58:50 -07002054 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 if (!rth)
2056 goto e_nobufs;
2057
Changli Gaod8d1f302010-06-10 23:31:35 -07002058 rth->dst.output= ip_rt_bug;
David S. Millercf911662011-04-28 14:31:47 -07002059#ifdef CONFIG_IP_ROUTE_CLASSID
2060 rth->dst.tclassid = itag;
2061#endif
David S. Miller9917e1e82012-07-17 14:44:26 -07002062 rth->rt_is_input = 1;
Roopa Prabhu571e7222015-07-21 10:43:47 +02002063
Duan Jionga6254862014-02-17 15:23:43 +08002064 RT_CACHE_STAT_INC(in_slow_tot);
David Ahern5510cdf2017-05-25 10:42:34 -07002065 if (res->type == RTN_UNREACHABLE) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002066 rth->dst.input= ip_error;
2067 rth->dst.error= -err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068 rth->rt_flags &= ~RTCF_LOCAL;
2069 }
Thomas Grafefd85702016-11-30 17:10:09 +01002070
Alexei Starovoitovdcdfdf52013-11-19 19:12:34 -08002071 if (do_cache) {
David Ahern5510cdf2017-05-25 10:42:34 -07002072 struct fib_nh *nh = &FIB_RES_NH(*res);
Thomas Grafefd85702016-11-30 17:10:09 +01002073
2074 rth->dst.lwtstate = lwtstate_get(nh->nh_lwtstate);
2075 if (lwtunnel_input_redirect(rth->dst.lwtstate)) {
2076 WARN_ON(rth->dst.input == lwtunnel_input);
2077 rth->dst.lwtstate->orig_input = rth->dst.input;
2078 rth->dst.input = lwtunnel_input;
2079 }
2080
Wei Wanga4c2fd72017-06-17 10:42:42 -07002081 if (unlikely(!rt_cache_route(nh, rth)))
Alexei Starovoitovdcdfdf52013-11-19 19:12:34 -08002082 rt_add_uncached_list(rth);
Alexei Starovoitovdcdfdf52013-11-19 19:12:34 -08002083 }
David S. Miller89aef892012-07-17 11:00:09 -07002084 skb_dst_set(skb, &rth->dst);
David S. Millerb23dd4f2011-03-02 14:31:35 -08002085 err = 0;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00002086 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087
2088no_route:
2089 RT_CACHE_STAT_INC(in_no_route);
David Ahern5510cdf2017-05-25 10:42:34 -07002090 res->type = RTN_UNREACHABLE;
2091 res->fi = NULL;
2092 res->table = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093 goto local_input;
2094
2095 /*
2096 * Do not cache martian addresses: they should be logged (RFC1812)
2097 */
2098martian_destination:
2099 RT_CACHE_STAT_INC(in_martian_dst);
2100#ifdef CONFIG_IP_ROUTE_VERBOSE
Joe Perchese87cc472012-05-13 21:56:26 +00002101 if (IN_DEV_LOG_MARTIANS(in_dev))
2102 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
2103 &daddr, &saddr, dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104#endif
Dietmar Eggemann2c2910a2005-06-28 13:06:23 -07002105
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106e_inval:
2107 err = -EINVAL;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00002108 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109
2110e_nobufs:
2111 err = -ENOBUFS;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00002112 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113
2114martian_source:
2115 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00002116 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117}
2118
David S. Millerc6cffba2012-07-26 11:14:38 +00002119int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2120 u8 tos, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121{
David Ahern5510cdf2017-05-25 10:42:34 -07002122 struct fib_result res;
2123 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124
Julian Anastasov6e280992017-02-26 17:14:35 +02002125 tos &= IPTOS_RT_MASK;
Eric Dumazet96d36222010-06-02 19:21:31 +00002126 rcu_read_lock();
David Ahern5510cdf2017-05-25 10:42:34 -07002127 err = ip_route_input_rcu(skb, daddr, saddr, tos, dev, &res);
2128 rcu_read_unlock();
Eric Dumazet96d36222010-06-02 19:21:31 +00002129
David Ahern5510cdf2017-05-25 10:42:34 -07002130 return err;
2131}
2132EXPORT_SYMBOL(ip_route_input_noref);
2133
2134/* called with rcu_read_lock held */
2135int ip_route_input_rcu(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2136 u8 tos, struct net_device *dev, struct fib_result *res)
2137{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 /* Multicast recognition logic is moved from route cache to here.
2139 The problem was that too many Ethernet cards have broken/missing
2140 hardware multicast filters :-( As result the host on multicasting
2141 network acquires a lot of useless route cache entries, sort of
2142 SDR messages from all the world. Now we try to get rid of them.
2143 Really, provided software IP multicast filter is organized
2144 reasonably (at least, hashed), it does not result in a slowdown
2145 comparing with route cache reject entries.
2146 Note, that multicast routers are not affected, because
2147 route cache entry is created eventually.
2148 */
Joe Perchesf97c1e02007-12-16 13:45:43 -08002149 if (ipv4_is_multicast(daddr)) {
Eric Dumazet96d36222010-06-02 19:21:31 +00002150 struct in_device *in_dev = __in_dev_get_rcu(dev);
David Aherne58e4152016-10-31 15:54:00 -07002151 int our = 0;
David Ahern5510cdf2017-05-25 10:42:34 -07002152 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153
David Aherne58e4152016-10-31 15:54:00 -07002154 if (in_dev)
2155 our = ip_check_mc_rcu(in_dev, daddr, saddr,
2156 ip_hdr(skb)->protocol);
2157
2158 /* check l3 master if no match yet */
2159 if ((!in_dev || !our) && netif_is_l3_slave(dev)) {
2160 struct in_device *l3_in_dev;
2161
2162 l3_in_dev = __in_dev_get_rcu(skb->dev);
2163 if (l3_in_dev)
2164 our = ip_check_mc_rcu(l3_in_dev, daddr, saddr,
2165 ip_hdr(skb)->protocol);
2166 }
2167
David Aherne58e4152016-10-31 15:54:00 -07002168 if (our
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169#ifdef CONFIG_IP_MROUTE
David Aherne58e4152016-10-31 15:54:00 -07002170 ||
2171 (!ipv4_is_local_multicast(daddr) &&
2172 IN_DEV_MFORWARD(in_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173#endif
David Aherne58e4152016-10-31 15:54:00 -07002174 ) {
David Ahern5510cdf2017-05-25 10:42:34 -07002175 err = ip_route_input_mc(skb, daddr, saddr,
David Aherne58e4152016-10-31 15:54:00 -07002176 tos, dev, our);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 }
David Ahern5510cdf2017-05-25 10:42:34 -07002178 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 }
David Ahern5510cdf2017-05-25 10:42:34 -07002180
2181 return ip_route_input_slow(skb, daddr, saddr, tos, dev, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182}
2183
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00002184/* called with rcu_read_lock() */
David S. Miller982721f2011-02-16 21:44:24 -08002185static struct rtable *__mkroute_output(const struct fib_result *res,
David Miller1a00fee2012-07-01 02:02:56 +00002186 const struct flowi4 *fl4, int orig_oif,
Julian Anastasovf61759e2011-12-02 11:39:42 +00002187 struct net_device *dev_out,
David S. Miller5ada5522011-02-17 15:29:00 -08002188 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189{
David S. Miller982721f2011-02-16 21:44:24 -08002190 struct fib_info *fi = res->fi;
David S. Millerf2bb4be2012-07-17 12:20:47 -07002191 struct fib_nh_exception *fnhe;
David S. Miller5ada5522011-02-17 15:29:00 -08002192 struct in_device *in_dev;
David S. Miller982721f2011-02-16 21:44:24 -08002193 u16 type = res->type;
David S. Miller5ada5522011-02-17 15:29:00 -08002194 struct rtable *rth;
Julian Anastasovc92b9652012-10-08 11:41:19 +00002195 bool do_cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196
Thomas Grafd0daebc32012-06-12 00:44:01 +00002197 in_dev = __in_dev_get_rcu(dev_out);
2198 if (!in_dev)
David S. Miller5ada5522011-02-17 15:29:00 -08002199 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200
Thomas Grafd0daebc32012-06-12 00:44:01 +00002201 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
David Ahern5f02ce242016-09-10 12:09:54 -07002202 if (ipv4_is_loopback(fl4->saddr) &&
2203 !(dev_out->flags & IFF_LOOPBACK) &&
2204 !netif_is_l3_master(dev_out))
Thomas Grafd0daebc32012-06-12 00:44:01 +00002205 return ERR_PTR(-EINVAL);
2206
David S. Miller68a5e3d2011-03-11 20:07:33 -05002207 if (ipv4_is_lbcast(fl4->daddr))
David S. Miller982721f2011-02-16 21:44:24 -08002208 type = RTN_BROADCAST;
David S. Miller68a5e3d2011-03-11 20:07:33 -05002209 else if (ipv4_is_multicast(fl4->daddr))
David S. Miller982721f2011-02-16 21:44:24 -08002210 type = RTN_MULTICAST;
David S. Miller68a5e3d2011-03-11 20:07:33 -05002211 else if (ipv4_is_zeronet(fl4->daddr))
David S. Miller5ada5522011-02-17 15:29:00 -08002212 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213
2214 if (dev_out->flags & IFF_LOOPBACK)
2215 flags |= RTCF_LOCAL;
2216
Julian Anastasov63617422012-11-22 23:04:14 +02002217 do_cache = true;
David S. Miller982721f2011-02-16 21:44:24 -08002218 if (type == RTN_BROADCAST) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219 flags |= RTCF_BROADCAST | RTCF_LOCAL;
David S. Miller982721f2011-02-16 21:44:24 -08002220 fi = NULL;
2221 } else if (type == RTN_MULTICAST) {
Eric Dumazetdd28d1a2010-09-29 11:53:50 +00002222 flags |= RTCF_MULTICAST | RTCF_LOCAL;
David S. Miller813b3b52011-04-28 14:48:42 -07002223 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
2224 fl4->flowi4_proto))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 flags &= ~RTCF_LOCAL;
Julian Anastasov63617422012-11-22 23:04:14 +02002226 else
2227 do_cache = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 /* If multicast route do not exist use
Eric Dumazetdd28d1a2010-09-29 11:53:50 +00002229 * default one, but do not gateway in this case.
2230 * Yes, it is hack.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231 */
David S. Miller982721f2011-02-16 21:44:24 -08002232 if (fi && res->prefixlen < 4)
2233 fi = NULL;
Chris Friesend6d5e992016-04-08 15:21:30 -06002234 } else if ((type == RTN_LOCAL) && (orig_oif != 0) &&
2235 (orig_oif != dev_out->ifindex)) {
2236 /* For local routes that require a particular output interface
2237 * we do not want to cache the result. Caching the result
2238 * causes incorrect behaviour when there are multiple source
2239 * addresses on the interface, the end result being that if the
2240 * intended recipient is waiting on that interface for the
2241 * packet he won't receive it because it will be delivered on
2242 * the loopback interface and the IP_PKTINFO ipi_ifindex will
2243 * be set to the loopback interface as well.
2244 */
Julian Anastasov94720e32018-05-02 09:41:19 +03002245 do_cache = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 }
2247
David S. Millerf2bb4be2012-07-17 12:20:47 -07002248 fnhe = NULL;
Julian Anastasov63617422012-11-22 23:04:14 +02002249 do_cache &= fi != NULL;
Julian Anastasov94720e32018-05-02 09:41:19 +03002250 if (fi) {
David S. Millerc5038a82012-07-31 15:02:02 -07002251 struct rtable __rcu **prth;
Julian Anastasovc92b9652012-10-08 11:41:19 +00002252 struct fib_nh *nh = &FIB_RES_NH(*res);
Eric Dumazetd26b3a72012-07-31 05:45:30 +00002253
Julian Anastasovc92b9652012-10-08 11:41:19 +00002254 fnhe = find_exception(nh, fl4->daddr);
Julian Anastasov94720e32018-05-02 09:41:19 +03002255 if (!do_cache)
2256 goto add;
Xin Longdeed49d2016-02-18 21:21:19 +08002257 if (fnhe) {
Timo Teräs2ffae992013-06-27 10:27:05 +03002258 prth = &fnhe->fnhe_rth_output;
Julian Anastasov94720e32018-05-02 09:41:19 +03002259 } else {
2260 if (unlikely(fl4->flowi4_flags &
2261 FLOWI_FLAG_KNOWN_NH &&
2262 !(nh->nh_gw &&
2263 nh->nh_scope == RT_SCOPE_LINK))) {
2264 do_cache = false;
2265 goto add;
Julian Anastasovc92b9652012-10-08 11:41:19 +00002266 }
Julian Anastasov94720e32018-05-02 09:41:19 +03002267 prth = raw_cpu_ptr(nh->nh_pcpu_rth_output);
Julian Anastasovc92b9652012-10-08 11:41:19 +00002268 }
David S. Millerc5038a82012-07-31 15:02:02 -07002269 rth = rcu_dereference(*prth);
Wei Wang9df16ef2017-06-17 10:42:31 -07002270 if (rt_cache_valid(rth) && dst_hold_safe(&rth->dst))
David S. Millerc5038a82012-07-31 15:02:02 -07002271 return rth;
David S. Millerf2bb4be2012-07-17 12:20:47 -07002272 }
Julian Anastasovc92b9652012-10-08 11:41:19 +00002273
2274add:
David Ahernd08c4f32015-09-02 13:58:34 -07002275 rth = rt_dst_alloc(dev_out, flags, type,
David S. Miller5c1e6aa2011-04-28 14:13:38 -07002276 IN_DEV_CONF_GET(in_dev, NOPOLICY),
David S. Millerf2bb4be2012-07-17 12:20:47 -07002277 IN_DEV_CONF_GET(in_dev, NOXFRM),
Julian Anastasovc92b9652012-10-08 11:41:19 +00002278 do_cache);
Dimitris Michailidis8391d072010-10-07 14:48:38 +00002279 if (!rth)
David S. Miller5ada5522011-02-17 15:29:00 -08002280 return ERR_PTR(-ENOBUFS);
Dimitris Michailidis8391d072010-10-07 14:48:38 +00002281
David Ahern9438c872017-08-11 17:02:02 -07002282 rth->rt_iif = orig_oif;
David Ahernb7503e02015-09-02 13:58:35 -07002283
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284 RT_CACHE_STAT_INC(out_slow_tot);
2285
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002287 if (flags & RTCF_LOCAL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288 !(dev_out->flags & IFF_LOOPBACK)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002289 rth->dst.output = ip_mc_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290 RT_CACHE_STAT_INC(out_slow_mc);
2291 }
2292#ifdef CONFIG_IP_MROUTE
David S. Miller982721f2011-02-16 21:44:24 -08002293 if (type == RTN_MULTICAST) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 if (IN_DEV_MFORWARD(in_dev) &&
David S. Miller813b3b52011-04-28 14:48:42 -07002295 !ipv4_is_local_multicast(fl4->daddr)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002296 rth->dst.input = ip_mr_input;
2297 rth->dst.output = ip_mc_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 }
2299 }
2300#endif
2301 }
2302
Wei Wanga4c2fd72017-06-17 10:42:42 -07002303 rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0, do_cache);
David Ahern99428952018-02-13 20:32:04 -08002304 lwtunnel_set_redirect(&rth->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305
David S. Miller5ada5522011-02-17 15:29:00 -08002306 return rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307}
2308
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309/*
2310 * Major route resolver routine.
2311 */
2312
David Ahern3abd1ade2017-05-25 10:42:33 -07002313struct rtable *ip_route_output_key_hash(struct net *net, struct flowi4 *fl4,
2314 const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315{
Julian Anastasovf61759e2011-12-02 11:39:42 +00002316 __u8 tos = RT_FL_TOS(fl4);
Eric Dumazetd0ea2b12018-04-07 13:42:42 -07002317 struct fib_result res = {
2318 .type = RTN_UNSPEC,
2319 .fi = NULL,
2320 .table = NULL,
2321 .tclassid = 0,
2322 };
David S. Miller5ada5522011-02-17 15:29:00 -08002323 struct rtable *rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324
Pavel Emelyanov1fb94892012-08-08 21:53:36 +00002325 fl4->flowi4_iif = LOOPBACK_IFINDEX;
David S. Miller813b3b52011-04-28 14:48:42 -07002326 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
2327 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
2328 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
David S. Miller44713b62011-03-04 21:24:47 -08002329
David S. Miller010c2702011-02-17 15:37:09 -08002330 rcu_read_lock();
David Ahern3abd1ade2017-05-25 10:42:33 -07002331 rth = ip_route_output_key_hash_rcu(net, fl4, &res, skb);
2332 rcu_read_unlock();
2333
2334 return rth;
2335}
2336EXPORT_SYMBOL_GPL(ip_route_output_key_hash);
2337
2338struct rtable *ip_route_output_key_hash_rcu(struct net *net, struct flowi4 *fl4,
2339 struct fib_result *res,
2340 const struct sk_buff *skb)
2341{
2342 struct net_device *dev_out = NULL;
2343 int orig_oif = fl4->flowi4_oif;
2344 unsigned int flags = 0;
2345 struct rtable *rth;
2346 int err = -ENETUNREACH;
2347
David S. Miller813b3b52011-04-28 14:48:42 -07002348 if (fl4->saddr) {
David S. Millerb23dd4f2011-03-02 14:31:35 -08002349 rth = ERR_PTR(-EINVAL);
David S. Miller813b3b52011-04-28 14:48:42 -07002350 if (ipv4_is_multicast(fl4->saddr) ||
2351 ipv4_is_lbcast(fl4->saddr) ||
2352 ipv4_is_zeronet(fl4->saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353 goto out;
2354
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355 /* I removed check for oif == dev_out->oif here.
2356 It was wrong for two reasons:
Denis V. Lunev1ab35272008-01-22 22:04:30 -08002357 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2358 is assigned to multiple interfaces.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359 2. Moreover, we are allowed to send packets with saddr
2360 of another iface. --ANK
2361 */
2362
David S. Miller813b3b52011-04-28 14:48:42 -07002363 if (fl4->flowi4_oif == 0 &&
2364 (ipv4_is_multicast(fl4->daddr) ||
2365 ipv4_is_lbcast(fl4->daddr))) {
Julian Anastasova210d012008-10-01 07:28:28 -07002366 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
David S. Miller813b3b52011-04-28 14:48:42 -07002367 dev_out = __ip_dev_find(net, fl4->saddr, false);
Ian Morris51456b22015-04-03 09:17:26 +01002368 if (!dev_out)
Julian Anastasova210d012008-10-01 07:28:28 -07002369 goto out;
2370
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 /* Special hack: user can direct multicasts
2372 and limited broadcast via necessary interface
2373 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2374 This hack is not just for fun, it allows
2375 vic,vat and friends to work.
2376 They bind socket to loopback, set ttl to zero
2377 and expect that it will work.
2378 From the viewpoint of routing cache they are broken,
2379 because we are not allowed to build multicast path
2380 with loopback source addr (look, routing cache
2381 cannot know, that ttl is zero, so that packet
2382 will not leave this host and route is valid).
2383 Luckily, this hack is good workaround.
2384 */
2385
David S. Miller813b3b52011-04-28 14:48:42 -07002386 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 goto make_route;
2388 }
Julian Anastasova210d012008-10-01 07:28:28 -07002389
David S. Miller813b3b52011-04-28 14:48:42 -07002390 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
Julian Anastasova210d012008-10-01 07:28:28 -07002391 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
David S. Miller813b3b52011-04-28 14:48:42 -07002392 if (!__ip_dev_find(net, fl4->saddr, false))
Julian Anastasova210d012008-10-01 07:28:28 -07002393 goto out;
Julian Anastasova210d012008-10-01 07:28:28 -07002394 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395 }
2396
2397
David S. Miller813b3b52011-04-28 14:48:42 -07002398 if (fl4->flowi4_oif) {
2399 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
David S. Millerb23dd4f2011-03-02 14:31:35 -08002400 rth = ERR_PTR(-ENODEV);
Ian Morris51456b22015-04-03 09:17:26 +01002401 if (!dev_out)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402 goto out;
Herbert Xue5ed6392005-10-03 14:35:55 -07002403
2404 /* RACE: Check return value of inet_select_addr instead. */
Eric Dumazetfc75fc82010-12-22 04:39:39 +00002405 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
David S. Millerb23dd4f2011-03-02 14:31:35 -08002406 rth = ERR_PTR(-ENETUNREACH);
Eric Dumazetfc75fc82010-12-22 04:39:39 +00002407 goto out;
2408 }
David S. Miller813b3b52011-04-28 14:48:42 -07002409 if (ipv4_is_local_multicast(fl4->daddr) ||
Andrew Lunn6a211652015-05-01 16:39:54 +02002410 ipv4_is_lbcast(fl4->daddr) ||
2411 fl4->flowi4_proto == IPPROTO_IGMP) {
David S. Miller813b3b52011-04-28 14:48:42 -07002412 if (!fl4->saddr)
2413 fl4->saddr = inet_select_addr(dev_out, 0,
2414 RT_SCOPE_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415 goto make_route;
2416 }
Jiri Benc0a7e2262013-10-04 17:04:48 +02002417 if (!fl4->saddr) {
David S. Miller813b3b52011-04-28 14:48:42 -07002418 if (ipv4_is_multicast(fl4->daddr))
2419 fl4->saddr = inet_select_addr(dev_out, 0,
2420 fl4->flowi4_scope);
2421 else if (!fl4->daddr)
2422 fl4->saddr = inet_select_addr(dev_out, 0,
2423 RT_SCOPE_HOST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424 }
2425 }
2426
David S. Miller813b3b52011-04-28 14:48:42 -07002427 if (!fl4->daddr) {
2428 fl4->daddr = fl4->saddr;
2429 if (!fl4->daddr)
2430 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002431 dev_out = net->loopback_dev;
Pavel Emelyanov1fb94892012-08-08 21:53:36 +00002432 fl4->flowi4_oif = LOOPBACK_IFINDEX;
David Ahern3abd1ade2017-05-25 10:42:33 -07002433 res->type = RTN_LOCAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434 flags |= RTCF_LOCAL;
2435 goto make_route;
2436 }
2437
David Ahern3abd1ade2017-05-25 10:42:33 -07002438 err = fib_lookup(net, fl4, res, 0);
Nikola Forró0315e382015-09-17 16:01:32 +02002439 if (err) {
David Ahern3abd1ade2017-05-25 10:42:33 -07002440 res->fi = NULL;
2441 res->table = NULL;
David Ahern6104e112016-10-12 13:20:11 -07002442 if (fl4->flowi4_oif &&
David Aherne58e4152016-10-31 15:54:00 -07002443 (ipv4_is_multicast(fl4->daddr) ||
2444 !netif_index_is_l3_master(net, fl4->flowi4_oif))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 /* Apparently, routing tables are wrong. Assume,
2446 that the destination is on link.
2447
2448 WHY? DW.
2449 Because we are allowed to send to iface
2450 even if it has NO routes and NO assigned
2451 addresses. When oif is specified, routing
2452 tables are looked up with only one purpose:
2453 to catch if destination is gatewayed, rather than
2454 direct. Moreover, if MSG_DONTROUTE is set,
2455 we send packet, ignoring both routing tables
2456 and ifaddr state. --ANK
2457
2458
2459 We could make it even if oif is unknown,
2460 likely IPv6, but we do not.
2461 */
2462
David S. Miller813b3b52011-04-28 14:48:42 -07002463 if (fl4->saddr == 0)
2464 fl4->saddr = inet_select_addr(dev_out, 0,
2465 RT_SCOPE_LINK);
David Ahern3abd1ade2017-05-25 10:42:33 -07002466 res->type = RTN_UNICAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467 goto make_route;
2468 }
Nikola Forró0315e382015-09-17 16:01:32 +02002469 rth = ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470 goto out;
2471 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472
David Ahern3abd1ade2017-05-25 10:42:33 -07002473 if (res->type == RTN_LOCAL) {
David S. Miller813b3b52011-04-28 14:48:42 -07002474 if (!fl4->saddr) {
David Ahern3abd1ade2017-05-25 10:42:33 -07002475 if (res->fi->fib_prefsrc)
2476 fl4->saddr = res->fi->fib_prefsrc;
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002477 else
David S. Miller813b3b52011-04-28 14:48:42 -07002478 fl4->saddr = fl4->daddr;
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002479 }
David Ahern5f02ce242016-09-10 12:09:54 -07002480
2481 /* L3 master device is the loopback for that domain */
David Ahern3abd1ade2017-05-25 10:42:33 -07002482 dev_out = l3mdev_master_dev_rcu(FIB_RES_DEV(*res)) ? :
Robert Shearmanb7c84872017-04-21 21:34:59 +01002483 net->loopback_dev;
David Ahern839da4d2017-08-10 13:49:10 -07002484
2485 /* make sure orig_oif points to fib result device even
2486 * though packet rx/tx happens over loopback or l3mdev
2487 */
2488 orig_oif = FIB_RES_OIF(*res);
2489
David S. Miller813b3b52011-04-28 14:48:42 -07002490 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 flags |= RTCF_LOCAL;
2492 goto make_route;
2493 }
2494
David Ahern3abd1ade2017-05-25 10:42:33 -07002495 fib_select_path(net, res, fl4, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496
David Ahern3abd1ade2017-05-25 10:42:33 -07002497 dev_out = FIB_RES_DEV(*res);
David S. Miller813b3b52011-04-28 14:48:42 -07002498 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499
2500
2501make_route:
David Ahern3abd1ade2017-05-25 10:42:33 -07002502 rth = __mkroute_output(res, fl4, orig_oif, dev_out, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503
David S. Miller010c2702011-02-17 15:37:09 -08002504out:
David S. Millerb23dd4f2011-03-02 14:31:35 -08002505 return rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002506}
Arnaldo Carvalho de Melod8c97a92005-08-09 20:12:12 -07002507
Jianzhao Wangae2688d2010-09-08 14:35:43 -07002508static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2509{
2510 return NULL;
2511}
2512
Steffen Klassertebb762f2011-11-23 02:12:51 +00002513static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
Roland Dreierec831ea2011-01-31 13:16:00 -08002514{
Steffen Klassert618f9bc2011-11-23 02:13:31 +00002515 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2516
2517 return mtu ? : dst->dev->mtu;
Roland Dreierec831ea2011-01-31 13:16:00 -08002518}
2519
David S. Miller6700c272012-07-17 03:29:28 -07002520static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2521 struct sk_buff *skb, u32 mtu)
David S. Miller14e50e52007-05-24 18:17:54 -07002522{
2523}
2524
David S. Miller6700c272012-07-17 03:29:28 -07002525static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2526 struct sk_buff *skb)
David S. Millerb587ee32012-07-12 00:39:24 -07002527{
2528}
2529
Held Bernhard0972ddb2011-04-24 22:07:32 +00002530static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2531 unsigned long old)
2532{
2533 return NULL;
2534}
2535
David S. Miller14e50e52007-05-24 18:17:54 -07002536static struct dst_ops ipv4_dst_blackhole_ops = {
2537 .family = AF_INET,
Jianzhao Wangae2688d2010-09-08 14:35:43 -07002538 .check = ipv4_blackhole_dst_check,
Steffen Klassertebb762f2011-11-23 02:12:51 +00002539 .mtu = ipv4_blackhole_mtu,
Eric Dumazet214f45c2011-02-18 11:39:01 -08002540 .default_advmss = ipv4_default_advmss,
David S. Miller14e50e52007-05-24 18:17:54 -07002541 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
David S. Millerb587ee32012-07-12 00:39:24 -07002542 .redirect = ipv4_rt_blackhole_redirect,
Held Bernhard0972ddb2011-04-24 22:07:32 +00002543 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
David S. Millerd3aaeb32011-07-18 00:40:17 -07002544 .neigh_lookup = ipv4_neigh_lookup,
David S. Miller14e50e52007-05-24 18:17:54 -07002545};
2546
David S. Miller2774c132011-03-01 14:59:04 -08002547struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
David S. Miller14e50e52007-05-24 18:17:54 -07002548{
David S. Miller2774c132011-03-01 14:59:04 -08002549 struct rtable *ort = (struct rtable *) dst_orig;
David S. Millerf5b0a872012-07-19 12:31:33 -07002550 struct rtable *rt;
David S. Miller14e50e52007-05-24 18:17:54 -07002551
Steffen Klassert6c0e7282017-10-09 08:43:55 +02002552 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_DEAD, 0);
David S. Miller14e50e52007-05-24 18:17:54 -07002553 if (rt) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002554 struct dst_entry *new = &rt->dst;
David S. Miller14e50e52007-05-24 18:17:54 -07002555
David S. Miller14e50e52007-05-24 18:17:54 -07002556 new->__use = 1;
Herbert Xu352e5122007-11-13 21:34:06 -08002557 new->input = dst_discard;
Eric W. Biedermanede20592015-10-07 16:48:47 -05002558 new->output = dst_discard_out;
David S. Miller14e50e52007-05-24 18:17:54 -07002559
Wei Wang1dbe32522017-06-17 10:42:26 -07002560 new->dev = net->loopback_dev;
David S. Miller14e50e52007-05-24 18:17:54 -07002561 if (new->dev)
2562 dev_hold(new->dev);
2563
David S. Miller9917e1e82012-07-17 14:44:26 -07002564 rt->rt_is_input = ort->rt_is_input;
David S. Miller5e2b61f2011-03-04 21:47:09 -08002565 rt->rt_iif = ort->rt_iif;
David S. Miller59436342012-07-10 06:58:42 -07002566 rt->rt_pmtu = ort->rt_pmtu;
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +01002567 rt->rt_mtu_locked = ort->rt_mtu_locked;
David S. Miller14e50e52007-05-24 18:17:54 -07002568
fan.duca4c3fc2013-07-30 08:33:53 +08002569 rt->rt_genid = rt_genid_ipv4(net);
David S. Miller14e50e52007-05-24 18:17:54 -07002570 rt->rt_flags = ort->rt_flags;
2571 rt->rt_type = ort->rt_type;
David S. Miller14e50e52007-05-24 18:17:54 -07002572 rt->rt_gateway = ort->rt_gateway;
Julian Anastasov155e8332012-10-08 11:41:18 +00002573 rt->rt_uses_gateway = ort->rt_uses_gateway;
David S. Miller14e50e52007-05-24 18:17:54 -07002574
David S. Millercaacf052012-07-31 15:06:50 -07002575 INIT_LIST_HEAD(&rt->rt_uncached);
David S. Miller14e50e52007-05-24 18:17:54 -07002576 }
2577
David S. Miller2774c132011-03-01 14:59:04 -08002578 dst_release(dst_orig);
2579
2580 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
David S. Miller14e50e52007-05-24 18:17:54 -07002581}
2582
David S. Miller9d6ec932011-03-12 01:12:47 -05002583struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
Eric Dumazet6f9c9612015-09-25 07:39:10 -07002584 const struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002585{
David S. Miller9d6ec932011-03-12 01:12:47 -05002586 struct rtable *rt = __ip_route_output_key(net, flp4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002587
David S. Millerb23dd4f2011-03-02 14:31:35 -08002588 if (IS_ERR(rt))
2589 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590
David S. Miller56157872011-05-02 14:37:45 -07002591 if (flp4->flowi4_proto)
Steffen Klassertf92ee612014-09-16 10:08:40 +02002592 rt = (struct rtable *)xfrm_lookup_route(net, &rt->dst,
2593 flowi4_to_flowi(flp4),
2594 sk, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595
David S. Millerb23dd4f2011-03-02 14:31:35 -08002596 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597}
Arnaldo Carvalho de Melod8c97a92005-08-09 20:12:12 -07002598EXPORT_SYMBOL_GPL(ip_route_output_flow);
2599
David Ahern3765d352017-05-25 10:42:36 -07002600/* called with rcu_read_lock held */
Roopa Prabhu404eb772018-05-22 14:03:27 -07002601static int rt_fill_info(struct net *net, __be32 dst, __be32 src,
2602 struct rtable *rt, u32 table_id, struct flowi4 *fl4,
2603 struct sk_buff *skb, u32 portid, u32 seq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605 struct rtmsg *r;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002606 struct nlmsghdr *nlh;
Steffen Klassert2bc8ca42011-10-11 01:12:02 +00002607 unsigned long expires = 0;
David S. Millerf1850712012-07-10 07:26:01 -07002608 u32 error;
Julian Anastasov521f5492012-07-20 12:02:08 +03002609 u32 metrics[RTAX_MAX];
Thomas Grafbe403ea2006-08-17 18:15:17 -07002610
David Ahernd3166e02017-05-25 10:42:35 -07002611 nlh = nlmsg_put(skb, portid, seq, RTM_NEWROUTE, sizeof(*r), 0);
Ian Morris51456b22015-04-03 09:17:26 +01002612 if (!nlh)
Patrick McHardy26932562007-01-31 23:16:40 -08002613 return -EMSGSIZE;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002614
2615 r = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002616 r->rtm_family = AF_INET;
2617 r->rtm_dst_len = 32;
2618 r->rtm_src_len = 0;
David Millerd6c0a4f2012-07-01 02:02:59 +00002619 r->rtm_tos = fl4->flowi4_tos;
David Ahern8a430ed2017-01-11 15:42:17 -08002620 r->rtm_table = table_id < 256 ? table_id : RT_TABLE_COMPAT;
David Ahernc36ba662015-09-02 13:58:36 -07002621 if (nla_put_u32(skb, RTA_TABLE, table_id))
David S. Millerf3756b72012-04-01 20:39:02 -04002622 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623 r->rtm_type = rt->rt_type;
2624 r->rtm_scope = RT_SCOPE_UNIVERSE;
2625 r->rtm_protocol = RTPROT_UNSPEC;
2626 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2627 if (rt->rt_flags & RTCF_NOTIFY)
2628 r->rtm_flags |= RTM_F_NOTIFY;
Hannes Frederic Sowadf4d9252015-01-23 12:01:26 +01002629 if (IPCB(skb)->flags & IPSKB_DOREDIRECT)
2630 r->rtm_flags |= RTCF_DOREDIRECT;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002631
Jiri Benc930345e2015-03-29 16:59:25 +02002632 if (nla_put_in_addr(skb, RTA_DST, dst))
David S. Millerf3756b72012-04-01 20:39:02 -04002633 goto nla_put_failure;
David Miller1a00fee2012-07-01 02:02:56 +00002634 if (src) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635 r->rtm_src_len = 32;
Jiri Benc930345e2015-03-29 16:59:25 +02002636 if (nla_put_in_addr(skb, RTA_SRC, src))
David S. Millerf3756b72012-04-01 20:39:02 -04002637 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638 }
David S. Millerf3756b72012-04-01 20:39:02 -04002639 if (rt->dst.dev &&
2640 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2641 goto nla_put_failure;
Patrick McHardyc7066f72011-01-14 13:36:42 +01002642#ifdef CONFIG_IP_ROUTE_CLASSID
David S. Millerf3756b72012-04-01 20:39:02 -04002643 if (rt->dst.tclassid &&
2644 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2645 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646#endif
David S. Miller41347dc2012-06-28 04:05:27 -07002647 if (!rt_is_input_route(rt) &&
David Millerd6c0a4f2012-07-01 02:02:59 +00002648 fl4->saddr != src) {
Jiri Benc930345e2015-03-29 16:59:25 +02002649 if (nla_put_in_addr(skb, RTA_PREFSRC, fl4->saddr))
David S. Millerf3756b72012-04-01 20:39:02 -04002650 goto nla_put_failure;
2651 }
Julian Anastasov155e8332012-10-08 11:41:18 +00002652 if (rt->rt_uses_gateway &&
Jiri Benc930345e2015-03-29 16:59:25 +02002653 nla_put_in_addr(skb, RTA_GATEWAY, rt->rt_gateway))
David S. Millerf3756b72012-04-01 20:39:02 -04002654 goto nla_put_failure;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002655
Steffen Klassertee9a8f72012-10-08 00:56:54 +00002656 expires = rt->dst.expires;
2657 if (expires) {
2658 unsigned long now = jiffies;
2659
2660 if (time_before(now, expires))
2661 expires -= now;
2662 else
2663 expires = 0;
2664 }
2665
Julian Anastasov521f5492012-07-20 12:02:08 +03002666 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
Steffen Klassertee9a8f72012-10-08 00:56:54 +00002667 if (rt->rt_pmtu && expires)
Julian Anastasov521f5492012-07-20 12:02:08 +03002668 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
Sabrina Dubrocad52e5a72018-03-14 10:21:14 +01002669 if (rt->rt_mtu_locked && expires)
2670 metrics[RTAX_LOCK - 1] |= BIT(RTAX_MTU);
Julian Anastasov521f5492012-07-20 12:02:08 +03002671 if (rtnetlink_put_metrics(skb, metrics) < 0)
Thomas Grafbe403ea2006-08-17 18:15:17 -07002672 goto nla_put_failure;
2673
David Millerb4869882012-07-01 02:03:01 +00002674 if (fl4->flowi4_mark &&
stephen hemminger68aaed52012-10-10 08:27:25 +00002675 nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
David S. Millerf3756b72012-04-01 20:39:02 -04002676 goto nla_put_failure;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002677
Lorenzo Colitti622ec2c2016-11-04 02:23:42 +09002678 if (!uid_eq(fl4->flowi4_uid, INVALID_UID) &&
2679 nla_put_u32(skb, RTA_UID,
2680 from_kuid_munged(current_user_ns(), fl4->flowi4_uid)))
2681 goto nla_put_failure;
2682
Changli Gaod8d1f302010-06-10 23:31:35 -07002683 error = rt->dst.error;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002684
David S. Millerc7537962010-11-11 17:07:48 -08002685 if (rt_is_input_route(rt)) {
Nicolas Dichtel8caaf7b2012-12-04 01:03:07 +00002686#ifdef CONFIG_IP_MROUTE
2687 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2688 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2689 int err = ipmr_get_route(net, skb,
2690 fl4->saddr, fl4->daddr,
David Ahern9f09eae2017-01-06 17:39:06 -08002691 r, portid);
Nikolay Aleksandrov2cf75072016-09-25 23:08:31 +02002692
Nicolas Dichtel8caaf7b2012-12-04 01:03:07 +00002693 if (err <= 0) {
David Ahern0c8d8032017-01-05 19:32:46 -08002694 if (err == 0)
2695 return 0;
2696 goto nla_put_failure;
Nicolas Dichtel8caaf7b2012-12-04 01:03:07 +00002697 }
2698 } else
2699#endif
Roopa Prabhu404eb772018-05-22 14:03:27 -07002700 if (nla_put_u32(skb, RTA_IIF, fl4->flowi4_iif))
Nicolas Dichtel8caaf7b2012-12-04 01:03:07 +00002701 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002702 }
2703
David S. Millerf1850712012-07-10 07:26:01 -07002704 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
Thomas Grafe3703b32006-11-27 09:27:07 -08002705 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706
Johannes Berg053c0952015-01-16 22:09:00 +01002707 nlmsg_end(skb, nlh);
2708 return 0;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002709
2710nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002711 nlmsg_cancel(skb, nlh);
2712 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713}
2714
Roopa Prabhu404eb772018-05-22 14:03:27 -07002715static struct sk_buff *inet_rtm_getroute_build_skb(__be32 src, __be32 dst,
2716 u8 ip_proto, __be16 sport,
2717 __be16 dport)
2718{
2719 struct sk_buff *skb;
2720 struct iphdr *iph;
2721
2722 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2723 if (!skb)
2724 return NULL;
2725
2726 /* Reserve room for dummy headers, this skb can pass
2727 * through good chunk of routing engine.
2728 */
2729 skb_reset_mac_header(skb);
2730 skb_reset_network_header(skb);
2731 skb->protocol = htons(ETH_P_IP);
2732 iph = skb_put(skb, sizeof(struct iphdr));
2733 iph->protocol = ip_proto;
2734 iph->saddr = src;
2735 iph->daddr = dst;
2736 iph->version = 0x4;
2737 iph->frag_off = 0;
2738 iph->ihl = 0x5;
2739 skb_set_transport_header(skb, skb->len);
2740
2741 switch (iph->protocol) {
2742 case IPPROTO_UDP: {
2743 struct udphdr *udph;
2744
2745 udph = skb_put_zero(skb, sizeof(struct udphdr));
2746 udph->source = sport;
2747 udph->dest = dport;
2748 udph->len = sizeof(struct udphdr);
2749 udph->check = 0;
2750 break;
2751 }
2752 case IPPROTO_TCP: {
2753 struct tcphdr *tcph;
2754
2755 tcph = skb_put_zero(skb, sizeof(struct tcphdr));
2756 tcph->source = sport;
2757 tcph->dest = dport;
2758 tcph->doff = sizeof(struct tcphdr) / 4;
2759 tcph->rst = 1;
2760 tcph->check = ~tcp_v4_check(sizeof(struct tcphdr),
2761 src, dst, 0);
2762 break;
2763 }
2764 case IPPROTO_ICMP: {
2765 struct icmphdr *icmph;
2766
2767 icmph = skb_put_zero(skb, sizeof(struct icmphdr));
2768 icmph->type = ICMP_ECHO;
2769 icmph->code = 0;
2770 }
2771 }
2772
2773 return skb;
2774}
2775
David Ahernc21ef3e2017-04-16 09:48:24 -07002776static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
2777 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002779 struct net *net = sock_net(in_skb->sk);
Thomas Grafd889ce32006-08-17 18:15:44 -07002780 struct nlattr *tb[RTA_MAX+1];
Roopa Prabhu404eb772018-05-22 14:03:27 -07002781 u32 table_id = RT_TABLE_MAIN;
2782 __be16 sport = 0, dport = 0;
David Ahern3765d352017-05-25 10:42:36 -07002783 struct fib_result res = {};
Roopa Prabhu404eb772018-05-22 14:03:27 -07002784 u8 ip_proto = IPPROTO_UDP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785 struct rtable *rt = NULL;
Roopa Prabhu404eb772018-05-22 14:03:27 -07002786 struct sk_buff *skb;
2787 struct rtmsg *rtm;
David Millerd6c0a4f2012-07-01 02:02:59 +00002788 struct flowi4 fl4;
Al Viro9e12bb22006-09-26 21:25:20 -07002789 __be32 dst = 0;
2790 __be32 src = 0;
Roopa Prabhu404eb772018-05-22 14:03:27 -07002791 kuid_t uid;
Al Viro9e12bb22006-09-26 21:25:20 -07002792 u32 iif;
Thomas Grafd889ce32006-08-17 18:15:44 -07002793 int err;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002794 int mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795
Johannes Bergfceb6432017-04-12 14:34:07 +02002796 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy,
David Ahernc21ef3e2017-04-16 09:48:24 -07002797 extack);
Thomas Grafd889ce32006-08-17 18:15:44 -07002798 if (err < 0)
Roopa Prabhu404eb772018-05-22 14:03:27 -07002799 return err;
Thomas Grafd889ce32006-08-17 18:15:44 -07002800
2801 rtm = nlmsg_data(nlh);
Jiri Benc67b61f62015-03-29 16:59:26 +02002802 src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0;
2803 dst = tb[RTA_DST] ? nla_get_in_addr(tb[RTA_DST]) : 0;
Thomas Grafd889ce32006-08-17 18:15:44 -07002804 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002805 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
Lorenzo Colitti622ec2c2016-11-04 02:23:42 +09002806 if (tb[RTA_UID])
2807 uid = make_kuid(current_user_ns(), nla_get_u32(tb[RTA_UID]));
2808 else
2809 uid = (iif ? INVALID_UID : current_uid());
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810
Roopa Prabhu404eb772018-05-22 14:03:27 -07002811 if (tb[RTA_IP_PROTO]) {
2812 err = rtm_getroute_parse_ip_proto(tb[RTA_IP_PROTO],
2813 &ip_proto, extack);
2814 if (err)
2815 return err;
2816 }
Florian Laryschbbadb9a2017-04-07 14:42:20 +02002817
Roopa Prabhu404eb772018-05-22 14:03:27 -07002818 if (tb[RTA_SPORT])
2819 sport = nla_get_be16(tb[RTA_SPORT]);
2820
2821 if (tb[RTA_DPORT])
2822 dport = nla_get_be16(tb[RTA_DPORT]);
2823
2824 skb = inet_rtm_getroute_build_skb(src, dst, ip_proto, sport, dport);
2825 if (!skb)
2826 return -ENOBUFS;
Florian Laryschbbadb9a2017-04-07 14:42:20 +02002827
David Millerd6c0a4f2012-07-01 02:02:59 +00002828 memset(&fl4, 0, sizeof(fl4));
2829 fl4.daddr = dst;
2830 fl4.saddr = src;
2831 fl4.flowi4_tos = rtm->rtm_tos;
2832 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2833 fl4.flowi4_mark = mark;
Lorenzo Colitti622ec2c2016-11-04 02:23:42 +09002834 fl4.flowi4_uid = uid;
Roopa Prabhu404eb772018-05-22 14:03:27 -07002835 if (sport)
2836 fl4.fl4_sport = sport;
2837 if (dport)
2838 fl4.fl4_dport = dport;
2839 fl4.flowi4_proto = ip_proto;
David Millerd6c0a4f2012-07-01 02:02:59 +00002840
David Ahern3765d352017-05-25 10:42:36 -07002841 rcu_read_lock();
2842
Linus Torvalds1da177e2005-04-16 15:20:36 -07002843 if (iif) {
Thomas Grafd889ce32006-08-17 18:15:44 -07002844 struct net_device *dev;
2845
David Ahern3765d352017-05-25 10:42:36 -07002846 dev = dev_get_by_index_rcu(net, iif);
Ian Morris51456b22015-04-03 09:17:26 +01002847 if (!dev) {
Thomas Grafd889ce32006-08-17 18:15:44 -07002848 err = -ENODEV;
Roopa Prabhu404eb772018-05-22 14:03:27 -07002849 goto errout_rcu;
Thomas Grafd889ce32006-08-17 18:15:44 -07002850 }
2851
Roopa Prabhu404eb772018-05-22 14:03:27 -07002852 fl4.flowi4_iif = iif; /* for rt_fill_info */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853 skb->dev = dev;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002854 skb->mark = mark;
David Ahern3765d352017-05-25 10:42:36 -07002855 err = ip_route_input_rcu(skb, dst, src, rtm->rtm_tos,
2856 dev, &res);
Thomas Grafd889ce32006-08-17 18:15:44 -07002857
Eric Dumazet511c3f92009-06-02 05:14:27 +00002858 rt = skb_rtable(skb);
Changli Gaod8d1f302010-06-10 23:31:35 -07002859 if (err == 0 && rt->dst.error)
2860 err = -rt->dst.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861 } else {
Lorenzo Colitti6503a302018-01-11 18:36:26 +09002862 fl4.flowi4_iif = LOOPBACK_IFINDEX;
David Ahern3765d352017-05-25 10:42:36 -07002863 rt = ip_route_output_key_hash_rcu(net, &fl4, &res, skb);
David S. Millerb23dd4f2011-03-02 14:31:35 -08002864 err = 0;
2865 if (IS_ERR(rt))
2866 err = PTR_ERR(rt);
Florian Westphal2c87d632017-08-14 00:52:58 +02002867 else
2868 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002869 }
Thomas Grafd889ce32006-08-17 18:15:44 -07002870
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871 if (err)
Roopa Prabhu404eb772018-05-22 14:03:27 -07002872 goto errout_rcu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 if (rtm->rtm_flags & RTM_F_NOTIFY)
2875 rt->rt_flags |= RTCF_NOTIFY;
2876
David Ahernc36ba662015-09-02 13:58:36 -07002877 if (rtm->rtm_flags & RTM_F_LOOKUP_TABLE)
David Ahern68e813a2018-02-14 14:24:28 -08002878 table_id = res.table ? res.table->tb_id : 0;
David Ahernc36ba662015-09-02 13:58:36 -07002879
Roopa Prabhu404eb772018-05-22 14:03:27 -07002880 /* reset skb for netlink reply msg */
2881 skb_trim(skb, 0);
2882 skb_reset_network_header(skb);
2883 skb_reset_transport_header(skb);
2884 skb_reset_mac_header(skb);
2885
Roopa Prabhubc3aae22017-08-16 12:38:52 -07002886 if (rtm->rtm_flags & RTM_F_FIB_MATCH) {
2887 if (!res.fi) {
2888 err = fib_props[res.type].error;
2889 if (!err)
2890 err = -EHOSTUNREACH;
Roopa Prabhu404eb772018-05-22 14:03:27 -07002891 goto errout_rcu;
Roopa Prabhubc3aae22017-08-16 12:38:52 -07002892 }
Roopa Prabhub6179812017-05-25 10:42:39 -07002893 err = fib_dump_info(skb, NETLINK_CB(in_skb).portid,
2894 nlh->nlmsg_seq, RTM_NEWROUTE, table_id,
2895 rt->rt_type, res.prefix, res.prefixlen,
2896 fl4.flowi4_tos, res.fi, 0);
Roopa Prabhubc3aae22017-08-16 12:38:52 -07002897 } else {
Roopa Prabhu404eb772018-05-22 14:03:27 -07002898 err = rt_fill_info(net, dst, src, rt, table_id, &fl4, skb,
Roopa Prabhuba52d612017-05-31 22:53:25 -07002899 NETLINK_CB(in_skb).portid, nlh->nlmsg_seq);
Roopa Prabhubc3aae22017-08-16 12:38:52 -07002900 }
David S. Miller7b46a642015-01-18 23:36:08 -05002901 if (err < 0)
Roopa Prabhu404eb772018-05-22 14:03:27 -07002902 goto errout_rcu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002903
David Ahern3765d352017-05-25 10:42:36 -07002904 rcu_read_unlock();
2905
Eric W. Biederman15e47302012-09-07 20:12:54 +00002906 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002907
Thomas Grafd889ce32006-08-17 18:15:44 -07002908errout_free:
Roopa Prabhu404eb772018-05-22 14:03:27 -07002909 return err;
2910errout_rcu:
David Ahern3765d352017-05-25 10:42:36 -07002911 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912 kfree_skb(skb);
Roopa Prabhu404eb772018-05-22 14:03:27 -07002913 goto errout_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002914}
2915
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916void ip_rt_multicast_event(struct in_device *in_dev)
2917{
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002918 rt_cache_flush(dev_net(in_dev->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919}
2920
2921#ifdef CONFIG_SYSCTL
Gao feng082c7ca2013-02-19 00:43:12 +00002922static int ip_rt_gc_interval __read_mostly = 60 * HZ;
2923static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
2924static int ip_rt_gc_elasticity __read_mostly = 8;
Arnd Bergmann773daa32018-02-28 14:32:48 +01002925static int ip_min_valid_pmtu __read_mostly = IPV4_MIN_MTU;
Gao feng082c7ca2013-02-19 00:43:12 +00002926
Joe Perchesfe2c6332013-06-11 23:04:25 -07002927static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002928 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929 size_t *lenp, loff_t *ppos)
2930{
Timo Teräs5aad1de2013-05-27 20:46:33 +00002931 struct net *net = (struct net *)__ctl->extra1;
2932
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933 if (write) {
Timo Teräs5aad1de2013-05-27 20:46:33 +00002934 rt_cache_flush(net);
2935 fnhe_genid_bump(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002936 return 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002937 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002938
2939 return -EINVAL;
2940}
2941
Joe Perchesfe2c6332013-06-11 23:04:25 -07002942static struct ctl_table ipv4_route_table[] = {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002943 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944 .procname = "gc_thresh",
2945 .data = &ipv4_dst_ops.gc_thresh,
2946 .maxlen = sizeof(int),
2947 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002948 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 },
2950 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951 .procname = "max_size",
2952 .data = &ip_rt_max_size,
2953 .maxlen = sizeof(int),
2954 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002955 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 },
2957 {
2958 /* Deprecated. Use gc_min_interval_ms */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002959
Linus Torvalds1da177e2005-04-16 15:20:36 -07002960 .procname = "gc_min_interval",
2961 .data = &ip_rt_gc_min_interval,
2962 .maxlen = sizeof(int),
2963 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002964 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002965 },
2966 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002967 .procname = "gc_min_interval_ms",
2968 .data = &ip_rt_gc_min_interval,
2969 .maxlen = sizeof(int),
2970 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002971 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972 },
2973 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002974 .procname = "gc_timeout",
2975 .data = &ip_rt_gc_timeout,
2976 .maxlen = sizeof(int),
2977 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002978 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979 },
2980 {
Eric Dumazet9f28a2f2011-12-21 15:47:16 -05002981 .procname = "gc_interval",
2982 .data = &ip_rt_gc_interval,
2983 .maxlen = sizeof(int),
2984 .mode = 0644,
2985 .proc_handler = proc_dointvec_jiffies,
2986 },
2987 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988 .procname = "redirect_load",
2989 .data = &ip_rt_redirect_load,
2990 .maxlen = sizeof(int),
2991 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002992 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993 },
2994 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995 .procname = "redirect_number",
2996 .data = &ip_rt_redirect_number,
2997 .maxlen = sizeof(int),
2998 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002999 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003000 },
3001 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003002 .procname = "redirect_silence",
3003 .data = &ip_rt_redirect_silence,
3004 .maxlen = sizeof(int),
3005 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003006 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007 },
3008 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003009 .procname = "error_cost",
3010 .data = &ip_rt_error_cost,
3011 .maxlen = sizeof(int),
3012 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003013 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014 },
3015 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003016 .procname = "error_burst",
3017 .data = &ip_rt_error_burst,
3018 .maxlen = sizeof(int),
3019 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003020 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021 },
3022 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023 .procname = "gc_elasticity",
3024 .data = &ip_rt_gc_elasticity,
3025 .maxlen = sizeof(int),
3026 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003027 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028 },
3029 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030 .procname = "mtu_expires",
3031 .data = &ip_rt_mtu_expires,
3032 .maxlen = sizeof(int),
3033 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003034 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035 },
3036 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037 .procname = "min_pmtu",
3038 .data = &ip_rt_min_pmtu,
3039 .maxlen = sizeof(int),
3040 .mode = 0644,
Sabrina Dubrocac7272c22018-02-26 16:13:43 +01003041 .proc_handler = proc_dointvec_minmax,
3042 .extra1 = &ip_min_valid_pmtu,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003043 },
3044 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045 .procname = "min_adv_mss",
3046 .data = &ip_rt_min_advmss,
3047 .maxlen = sizeof(int),
3048 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003049 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003050 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08003051 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052};
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003053
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003054static struct ctl_table ipv4_route_flush_table[] = {
3055 {
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003056 .procname = "flush",
3057 .maxlen = sizeof(int),
3058 .mode = 0200,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003059 .proc_handler = ipv4_sysctl_rtcache_flush,
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003060 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08003061 { },
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003062};
3063
3064static __net_init int sysctl_route_net_init(struct net *net)
3065{
3066 struct ctl_table *tbl;
3067
3068 tbl = ipv4_route_flush_table;
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08003069 if (!net_eq(net, &init_net)) {
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003070 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01003071 if (!tbl)
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003072 goto err_dup;
Eric W. Biederman464dc802012-11-16 03:02:59 +00003073
3074 /* Don't export sysctls to unprivileged users */
3075 if (net->user_ns != &init_user_ns)
3076 tbl[0].procname = NULL;
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003077 }
3078 tbl[0].extra1 = net;
3079
Eric W. Biedermanec8f23c2012-04-19 13:44:49 +00003080 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
Ian Morris51456b22015-04-03 09:17:26 +01003081 if (!net->ipv4.route_hdr)
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003082 goto err_reg;
3083 return 0;
3084
3085err_reg:
3086 if (tbl != ipv4_route_flush_table)
3087 kfree(tbl);
3088err_dup:
3089 return -ENOMEM;
3090}
3091
3092static __net_exit void sysctl_route_net_exit(struct net *net)
3093{
3094 struct ctl_table *tbl;
3095
3096 tbl = net->ipv4.route_hdr->ctl_table_arg;
3097 unregister_net_sysctl_table(net->ipv4.route_hdr);
3098 BUG_ON(tbl == ipv4_route_flush_table);
3099 kfree(tbl);
3100}
3101
3102static __net_initdata struct pernet_operations sysctl_route_ops = {
3103 .init = sysctl_route_net_init,
3104 .exit = sysctl_route_net_exit,
3105};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003106#endif
3107
Neil Horman3ee94372010-05-08 01:57:52 -07003108static __net_init int rt_genid_init(struct net *net)
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07003109{
fan.duca4c3fc2013-07-30 08:33:53 +08003110 atomic_set(&net->ipv4.rt_genid, 0);
Timo Teräs5aad1de2013-05-27 20:46:33 +00003111 atomic_set(&net->fnhe_genid, 0);
Jason A. Donenfeld7aed9f72017-06-07 23:01:20 -04003112 atomic_set(&net->ipv4.dev_addr_genid, get_random_int());
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07003113 return 0;
3114}
3115
Neil Horman3ee94372010-05-08 01:57:52 -07003116static __net_initdata struct pernet_operations rt_genid_ops = {
3117 .init = rt_genid_init,
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07003118};
3119
David S. Millerc3426b42012-06-09 16:27:05 -07003120static int __net_init ipv4_inetpeer_init(struct net *net)
3121{
3122 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3123
3124 if (!bp)
3125 return -ENOMEM;
3126 inet_peer_base_init(bp);
3127 net->ipv4.peers = bp;
3128 return 0;
3129}
3130
3131static void __net_exit ipv4_inetpeer_exit(struct net *net)
3132{
3133 struct inet_peer_base *bp = net->ipv4.peers;
3134
3135 net->ipv4.peers = NULL;
David S. Miller56a6b242012-06-09 16:32:41 -07003136 inetpeer_invalidate_tree(bp);
David S. Millerc3426b42012-06-09 16:27:05 -07003137 kfree(bp);
3138}
3139
3140static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
3141 .init = ipv4_inetpeer_init,
3142 .exit = ipv4_inetpeer_exit,
3143};
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07003144
Patrick McHardyc7066f72011-01-14 13:36:42 +01003145#ifdef CONFIG_IP_ROUTE_CLASSID
Tejun Heo7d720c32010-02-16 15:20:26 +00003146struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
Patrick McHardyc7066f72011-01-14 13:36:42 +01003147#endif /* CONFIG_IP_ROUTE_CLASSID */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003148
Linus Torvalds1da177e2005-04-16 15:20:36 -07003149int __init ip_rt_init(void)
3150{
Eric Dumazet5055c372015-01-14 15:17:06 -08003151 int cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152
Kees Cook6da2ec52018-06-12 13:55:00 -07003153 ip_idents = kmalloc_array(IP_IDENTS_SZ, sizeof(*ip_idents),
3154 GFP_KERNEL);
Eric Dumazet73f156a2014-06-02 05:26:03 -07003155 if (!ip_idents)
3156 panic("IP: failed to allocate ip_idents\n");
3157
3158 prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));
3159
Eric Dumazet355b590c2015-05-01 10:37:49 -07003160 ip_tstamps = kcalloc(IP_IDENTS_SZ, sizeof(*ip_tstamps), GFP_KERNEL);
3161 if (!ip_tstamps)
3162 panic("IP: failed to allocate ip_tstamps\n");
3163
Eric Dumazet5055c372015-01-14 15:17:06 -08003164 for_each_possible_cpu(cpu) {
3165 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
3166
3167 INIT_LIST_HEAD(&ul->head);
3168 spin_lock_init(&ul->lock);
3169 }
Patrick McHardyc7066f72011-01-14 13:36:42 +01003170#ifdef CONFIG_IP_ROUTE_CLASSID
Ingo Molnar0dcec8c2009-02-25 14:07:33 +01003171 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003172 if (!ip_rt_acct)
3173 panic("IP: failed to allocate ip_rt_acct\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003174#endif
3175
Alexey Dobriyane5d679f332006-08-26 19:25:52 -07003176 ipv4_dst_ops.kmem_cachep =
3177 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09003178 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003179
David S. Miller14e50e52007-05-24 18:17:54 -07003180 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
3181
Eric Dumazetfc66f952010-10-08 06:37:34 +00003182 if (dst_entries_init(&ipv4_dst_ops) < 0)
3183 panic("IP: failed to allocate ipv4_dst_ops counter\n");
3184
3185 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
3186 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
3187
David S. Miller89aef892012-07-17 11:00:09 -07003188 ipv4_dst_ops.gc_thresh = ~0;
3189 ip_rt_max_size = INT_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003190
Linus Torvalds1da177e2005-04-16 15:20:36 -07003191 devinet_init();
3192 ip_fib_init();
3193
Denis V. Lunev73b38712008-02-28 20:51:18 -08003194 if (ip_rt_proc_init())
Joe Perches058bd4d2012-03-11 18:36:11 +00003195 pr_err("Unable to create route proc files\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003196#ifdef CONFIG_XFRM
3197 xfrm_init();
Steffen Klassert703fb942012-11-13 08:52:24 +01003198 xfrm4_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003199#endif
Florian Westphal394f51a2017-08-15 16:34:44 +02003200 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL,
3201 RTNL_FLAG_DOIT_UNLOCKED);
Thomas Graf63f34442007-03-22 11:55:17 -07003202
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003203#ifdef CONFIG_SYSCTL
3204 register_pernet_subsys(&sysctl_route_ops);
3205#endif
Neil Horman3ee94372010-05-08 01:57:52 -07003206 register_pernet_subsys(&rt_genid_ops);
David S. Millerc3426b42012-06-09 16:27:05 -07003207 register_pernet_subsys(&ipv4_inetpeer_ops);
Tim Hansen1bcdca32017-10-04 15:59:49 -04003208 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003209}
3210
Al Viroa1bc6eb2008-07-30 06:32:52 -04003211#ifdef CONFIG_SYSCTL
Al Viroeeb61f72008-07-27 08:59:33 +01003212/*
3213 * We really need to sanitize the damn ipv4 init order, then all
3214 * this nonsense will go away.
3215 */
3216void __init ip_static_sysctl_init(void)
3217{
Eric W. Biederman4e5ca782012-04-19 13:32:39 +00003218 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);
Al Viroeeb61f72008-07-27 08:59:33 +01003219}
Al Viroa1bc6eb2008-07-30 06:32:52 -04003220#endif