blob: fd9ecb52c66bf8815c09e678c452017e9a7e2122 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * ROUTE - implementation of the IP router.
7 *
Jesper Juhl02c30a82005-05-05 16:16:16 -07008 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10 * Alan Cox, <gw4pts@gw4pts.ampr.org>
11 * Linus Torvalds, <Linus.Torvalds@helsinki.fi>
12 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
13 *
14 * Fixes:
15 * Alan Cox : Verify area fixes.
16 * Alan Cox : cli() protects routing changes
17 * Rui Oliveira : ICMP routing table updates
18 * (rco@di.uminho.pt) Routing table insertion and update
19 * Linus Torvalds : Rewrote bits to be sensible
20 * Alan Cox : Added BSD route gw semantics
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090021 * Alan Cox : Super /proc >4K
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 * Alan Cox : MTU in route table
23 * Alan Cox : MSS actually. Also added the window
24 * clamper.
25 * Sam Lantinga : Fixed route matching in rt_del()
26 * Alan Cox : Routing cache support.
27 * Alan Cox : Removed compatibility cruft.
28 * Alan Cox : RTF_REJECT support.
29 * Alan Cox : TCP irtt support.
30 * Jonathan Naylor : Added Metric support.
31 * Miquel van Smoorenburg : BSD API fixes.
32 * Miquel van Smoorenburg : Metrics.
33 * Alan Cox : Use __u32 properly
34 * Alan Cox : Aligned routing errors more closely with BSD
35 * our system is still very different.
36 * Alan Cox : Faster /proc handling
37 * Alexey Kuznetsov : Massive rework to support tree based routing,
38 * routing caches and better behaviour.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090039 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 * Olaf Erb : irtt wasn't being copied right.
41 * Bjorn Ekwall : Kerneld route support.
42 * Alan Cox : Multicast fixed (I hope)
43 * Pavel Krauz : Limited broadcast fixed
44 * Mike McLagan : Routing by source
45 * Alexey Kuznetsov : End of old history. Split to fib.c and
46 * route.c and rewritten from scratch.
47 * Andi Kleen : Load-limit warning messages.
48 * Vitaly E. Lavrov : Transparent proxy revived after year coma.
49 * Vitaly E. Lavrov : Race condition in ip_route_input_slow.
50 * Tobias Ringstrom : Uninitialized res.type in ip_route_output_slow.
51 * Vladimir V. Ivanov : IP rule info (flowid) is really useful.
52 * Marc Boucher : routing by fwmark
53 * Robert Olsson : Added rt_cache statistics
54 * Arnaldo C. Melo : Convert proc stuff to seq_file
Eric Dumazetbb1d23b2005-07-05 15:00:32 -070055 * Eric Dumazet : hashed spinlocks and rt_check_expire() fixes.
Ilia Sotnikovcef26852006-03-25 01:38:55 -080056 * Ilia Sotnikov : Ignore TOS on PMTUD and Redirect
57 * Ilia Sotnikov : Removed TOS from hash calculations
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 *
59 * This program is free software; you can redistribute it and/or
60 * modify it under the terms of the GNU General Public License
61 * as published by the Free Software Foundation; either version
62 * 2 of the License, or (at your option) any later version.
63 */
64
Joe Perchesafd465032012-03-12 07:03:32 +000065#define pr_fmt(fmt) "IPv4: " fmt
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <linux/module.h>
68#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <linux/bitops.h>
70#include <linux/types.h>
71#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#include <linux/mm.h>
73#include <linux/string.h>
74#include <linux/socket.h>
75#include <linux/sockios.h>
76#include <linux/errno.h>
77#include <linux/in.h>
78#include <linux/inet.h>
79#include <linux/netdevice.h>
80#include <linux/proc_fs.h>
81#include <linux/init.h>
82#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070083#include <linux/inetdevice.h>
84#include <linux/igmp.h>
85#include <linux/pkt_sched.h>
86#include <linux/mroute.h>
87#include <linux/netfilter_ipv4.h>
88#include <linux/random.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070089#include <linux/rcupdate.h>
90#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090091#include <linux/slab.h>
Herbert Xu352e5122007-11-13 21:34:06 -080092#include <net/dst.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020093#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070094#include <net/protocol.h>
95#include <net/ip.h>
96#include <net/route.h>
97#include <net/inetpeer.h>
98#include <net/sock.h>
99#include <net/ip_fib.h>
100#include <net/arp.h>
101#include <net/tcp.h>
102#include <net/icmp.h>
103#include <net/xfrm.h>
Tom Tucker8d717402006-07-30 20:43:36 -0700104#include <net/netevent.h>
Thomas Graf63f34442007-03-22 11:55:17 -0700105#include <net/rtnetlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106#ifdef CONFIG_SYSCTL
107#include <linux/sysctl.h>
Shan Wei7426a562012-04-18 18:05:46 +0000108#include <linux/kmemleak.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109#endif
David S. Miller6e5714e2011-08-03 20:50:44 -0700110#include <net/secure_seq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
David S. Miller68a5e3d2011-03-11 20:07:33 -0500112#define RT_FL_TOS(oldflp4) \
Julian Anastasovf61759e2011-12-02 11:39:42 +0000113 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
115#define IP_MAX_MTU 0xFFF0
116
117#define RT_GC_TIMEOUT (300*HZ)
118
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119static int ip_rt_max_size;
Stephen Hemminger817bc4d2008-03-22 17:43:59 -0700120static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
Eric Dumazet9f28a2f2011-12-21 15:47:16 -0500121static int ip_rt_gc_interval __read_mostly = 60 * HZ;
Stephen Hemminger817bc4d2008-03-22 17:43:59 -0700122static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
123static int ip_rt_redirect_number __read_mostly = 9;
124static int ip_rt_redirect_load __read_mostly = HZ / 50;
125static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
126static int ip_rt_error_cost __read_mostly = HZ;
127static int ip_rt_error_burst __read_mostly = 5 * HZ;
128static int ip_rt_gc_elasticity __read_mostly = 8;
129static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
130static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
131static int ip_rt_min_advmss __read_mostly = 256;
Eric Dumazet9f28a2f2011-12-21 15:47:16 -0500132
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133/*
134 * Interface to generic destination cache.
135 */
136
137static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
David S. Miller0dbaee32010-12-13 12:52:14 -0800138static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
Steffen Klassertebb762f2011-11-23 02:12:51 +0000139static unsigned int ipv4_mtu(const struct dst_entry *dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
141static void ipv4_link_failure(struct sk_buff *skb);
David S. Miller6700c272012-07-17 03:29:28 -0700142static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
143 struct sk_buff *skb, u32 mtu);
144static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,
145 struct sk_buff *skb);
David S. Millercaacf052012-07-31 15:06:50 -0700146static void ipv4_dst_destroy(struct dst_entry *dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
Eric Dumazet72cdd1d2010-11-11 07:14:07 +0000148static void ipv4_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
149 int how)
150{
151}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
David S. Miller62fa8a82011-01-26 20:51:05 -0800153static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
154{
David S. Miller31248732012-07-10 07:08:18 -0700155 WARN_ON(1);
156 return NULL;
David S. Miller62fa8a82011-01-26 20:51:05 -0800157}
158
David S. Millerf894cbf2012-07-02 21:52:24 -0700159static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
160 struct sk_buff *skb,
161 const void *daddr);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163static struct dst_ops ipv4_dst_ops = {
164 .family = AF_INET,
Harvey Harrison09640e62009-02-01 00:45:17 -0800165 .protocol = cpu_to_be16(ETH_P_IP),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 .check = ipv4_dst_check,
David S. Miller0dbaee32010-12-13 12:52:14 -0800167 .default_advmss = ipv4_default_advmss,
Steffen Klassertebb762f2011-11-23 02:12:51 +0000168 .mtu = ipv4_mtu,
David S. Miller62fa8a82011-01-26 20:51:05 -0800169 .cow_metrics = ipv4_cow_metrics,
David S. Millercaacf052012-07-31 15:06:50 -0700170 .destroy = ipv4_dst_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 .ifdown = ipv4_dst_ifdown,
172 .negative_advice = ipv4_negative_advice,
173 .link_failure = ipv4_link_failure,
174 .update_pmtu = ip_rt_update_pmtu,
David S. Millere47a1852012-07-11 20:55:47 -0700175 .redirect = ip_do_redirect,
Herbert Xu1ac06e02008-05-20 14:32:14 -0700176 .local_out = __ip_local_out,
David S. Millerd3aaeb32011-07-18 00:40:17 -0700177 .neigh_lookup = ipv4_neigh_lookup,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178};
179
180#define ECN_OR_COST(class) TC_PRIO_##class
181
Philippe De Muyter4839c522007-07-09 15:32:57 -0700182const __u8 ip_tos2prio[16] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 TC_PRIO_BESTEFFORT,
Dan Siemon4a2b9c32011-03-15 13:56:07 +0000184 ECN_OR_COST(BESTEFFORT),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 TC_PRIO_BESTEFFORT,
186 ECN_OR_COST(BESTEFFORT),
187 TC_PRIO_BULK,
188 ECN_OR_COST(BULK),
189 TC_PRIO_BULK,
190 ECN_OR_COST(BULK),
191 TC_PRIO_INTERACTIVE,
192 ECN_OR_COST(INTERACTIVE),
193 TC_PRIO_INTERACTIVE,
194 ECN_OR_COST(INTERACTIVE),
195 TC_PRIO_INTERACTIVE_BULK,
196 ECN_OR_COST(INTERACTIVE_BULK),
197 TC_PRIO_INTERACTIVE_BULK,
198 ECN_OR_COST(INTERACTIVE_BULK)
199};
Amir Vadaid4a96862012-04-04 21:33:28 +0000200EXPORT_SYMBOL(ip_tos2prio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Eric Dumazet2f970d82006-01-17 02:54:36 -0800202static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
Eric Dumazet27f39c73e2010-05-19 22:07:23 +0000203#define RT_CACHE_STAT_INC(field) __this_cpu_inc(rt_cache_stat.field)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700205static inline int rt_genid(struct net *net)
206{
207 return atomic_read(&net->ipv4.rt_genid);
208}
209
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
212{
Eric Dumazet29e75252008-01-31 17:05:09 -0800213 if (*pos)
David S. Miller89aef892012-07-17 11:00:09 -0700214 return NULL;
Eric Dumazet29e75252008-01-31 17:05:09 -0800215 return SEQ_START_TOKEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216}
217
218static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
219{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 ++*pos;
David S. Miller89aef892012-07-17 11:00:09 -0700221 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222}
223
224static void rt_cache_seq_stop(struct seq_file *seq, void *v)
225{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226}
227
228static int rt_cache_seq_show(struct seq_file *seq, void *v)
229{
230 if (v == SEQ_START_TOKEN)
231 seq_printf(seq, "%-127s\n",
232 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
233 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
234 "HHUptod\tSpecDst");
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900235 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236}
237
Stephen Hemmingerf6908082007-03-12 14:34:29 -0700238static const struct seq_operations rt_cache_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 .start = rt_cache_seq_start,
240 .next = rt_cache_seq_next,
241 .stop = rt_cache_seq_stop,
242 .show = rt_cache_seq_show,
243};
244
245static int rt_cache_seq_open(struct inode *inode, struct file *file)
246{
David S. Miller89aef892012-07-17 11:00:09 -0700247 return seq_open(file, &rt_cache_seq_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248}
249
Arjan van de Ven9a321442007-02-12 00:55:35 -0800250static const struct file_operations rt_cache_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 .owner = THIS_MODULE,
252 .open = rt_cache_seq_open,
253 .read = seq_read,
254 .llseek = seq_lseek,
David S. Miller89aef892012-07-17 11:00:09 -0700255 .release = seq_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256};
257
258
259static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
260{
261 int cpu;
262
263 if (*pos == 0)
264 return SEQ_START_TOKEN;
265
Rusty Russell0f23174a2008-12-29 12:23:42 +0000266 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 if (!cpu_possible(cpu))
268 continue;
269 *pos = cpu+1;
Eric Dumazet2f970d82006-01-17 02:54:36 -0800270 return &per_cpu(rt_cache_stat, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 }
272 return NULL;
273}
274
275static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
276{
277 int cpu;
278
Rusty Russell0f23174a2008-12-29 12:23:42 +0000279 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 if (!cpu_possible(cpu))
281 continue;
282 *pos = cpu+1;
Eric Dumazet2f970d82006-01-17 02:54:36 -0800283 return &per_cpu(rt_cache_stat, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 }
285 return NULL;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287}
288
289static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
290{
291
292}
293
294static int rt_cpu_seq_show(struct seq_file *seq, void *v)
295{
296 struct rt_cache_stat *st = v;
297
298 if (v == SEQ_START_TOKEN) {
Olaf Rempel5bec0032005-04-28 12:16:08 -0700299 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 -0700300 return 0;
301 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
304 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
Eric Dumazetfc66f952010-10-08 06:37:34 +0000305 dst_entries_get_slow(&ipv4_dst_ops),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 st->in_hit,
307 st->in_slow_tot,
308 st->in_slow_mc,
309 st->in_no_route,
310 st->in_brd,
311 st->in_martian_dst,
312 st->in_martian_src,
313
314 st->out_hit,
315 st->out_slow_tot,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900316 st->out_slow_mc,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
318 st->gc_total,
319 st->gc_ignored,
320 st->gc_goal_miss,
321 st->gc_dst_overflow,
322 st->in_hlist_search,
323 st->out_hlist_search
324 );
325 return 0;
326}
327
Stephen Hemmingerf6908082007-03-12 14:34:29 -0700328static const struct seq_operations rt_cpu_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 .start = rt_cpu_seq_start,
330 .next = rt_cpu_seq_next,
331 .stop = rt_cpu_seq_stop,
332 .show = rt_cpu_seq_show,
333};
334
335
336static int rt_cpu_seq_open(struct inode *inode, struct file *file)
337{
338 return seq_open(file, &rt_cpu_seq_ops);
339}
340
Arjan van de Ven9a321442007-02-12 00:55:35 -0800341static const struct file_operations rt_cpu_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 .owner = THIS_MODULE,
343 .open = rt_cpu_seq_open,
344 .read = seq_read,
345 .llseek = seq_lseek,
346 .release = seq_release,
347};
348
Patrick McHardyc7066f72011-01-14 13:36:42 +0100349#ifdef CONFIG_IP_ROUTE_CLASSID
Alexey Dobriyana661c412009-11-25 15:40:35 -0800350static int rt_acct_proc_show(struct seq_file *m, void *v)
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800351{
Alexey Dobriyana661c412009-11-25 15:40:35 -0800352 struct ip_rt_acct *dst, *src;
353 unsigned int i, j;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800354
Alexey Dobriyana661c412009-11-25 15:40:35 -0800355 dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
356 if (!dst)
357 return -ENOMEM;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800358
Alexey Dobriyana661c412009-11-25 15:40:35 -0800359 for_each_possible_cpu(i) {
360 src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
361 for (j = 0; j < 256; j++) {
362 dst[j].o_bytes += src[j].o_bytes;
363 dst[j].o_packets += src[j].o_packets;
364 dst[j].i_bytes += src[j].i_bytes;
365 dst[j].i_packets += src[j].i_packets;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800366 }
367 }
Alexey Dobriyana661c412009-11-25 15:40:35 -0800368
369 seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
370 kfree(dst);
371 return 0;
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800372}
Alexey Dobriyana661c412009-11-25 15:40:35 -0800373
374static int rt_acct_proc_open(struct inode *inode, struct file *file)
375{
376 return single_open(file, rt_acct_proc_show, NULL);
377}
378
379static const struct file_operations rt_acct_proc_fops = {
380 .owner = THIS_MODULE,
381 .open = rt_acct_proc_open,
382 .read = seq_read,
383 .llseek = seq_lseek,
384 .release = single_release,
385};
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800386#endif
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800387
Denis V. Lunev73b38712008-02-28 20:51:18 -0800388static int __net_init ip_rt_do_proc_init(struct net *net)
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800389{
390 struct proc_dir_entry *pde;
391
392 pde = proc_net_fops_create(net, "rt_cache", S_IRUGO,
393 &rt_cache_seq_fops);
394 if (!pde)
395 goto err1;
396
Wang Chen77020722008-02-28 14:14:25 -0800397 pde = proc_create("rt_cache", S_IRUGO,
398 net->proc_net_stat, &rt_cpu_seq_fops);
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800399 if (!pde)
400 goto err2;
401
Patrick McHardyc7066f72011-01-14 13:36:42 +0100402#ifdef CONFIG_IP_ROUTE_CLASSID
Alexey Dobriyana661c412009-11-25 15:40:35 -0800403 pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800404 if (!pde)
405 goto err3;
406#endif
407 return 0;
408
Patrick McHardyc7066f72011-01-14 13:36:42 +0100409#ifdef CONFIG_IP_ROUTE_CLASSID
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800410err3:
411 remove_proc_entry("rt_cache", net->proc_net_stat);
412#endif
413err2:
414 remove_proc_entry("rt_cache", net->proc_net);
415err1:
416 return -ENOMEM;
417}
Denis V. Lunev73b38712008-02-28 20:51:18 -0800418
419static void __net_exit ip_rt_do_proc_exit(struct net *net)
420{
421 remove_proc_entry("rt_cache", net->proc_net_stat);
422 remove_proc_entry("rt_cache", net->proc_net);
Patrick McHardyc7066f72011-01-14 13:36:42 +0100423#ifdef CONFIG_IP_ROUTE_CLASSID
Denis V. Lunev73b38712008-02-28 20:51:18 -0800424 remove_proc_entry("rt_acct", net->proc_net);
Alexey Dobriyan0a931ac2010-01-17 03:32:50 +0000425#endif
Denis V. Lunev73b38712008-02-28 20:51:18 -0800426}
427
428static struct pernet_operations ip_rt_proc_ops __net_initdata = {
429 .init = ip_rt_do_proc_init,
430 .exit = ip_rt_do_proc_exit,
431};
432
433static int __init ip_rt_proc_init(void)
434{
435 return register_pernet_subsys(&ip_rt_proc_ops);
436}
437
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800438#else
Denis V. Lunev73b38712008-02-28 20:51:18 -0800439static inline int ip_rt_proc_init(void)
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800440{
441 return 0;
442}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443#endif /* CONFIG_PROC_FS */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900444
Eric Dumazet4331deb2012-07-25 05:11:23 +0000445static inline bool rt_is_expired(const struct rtable *rth)
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700446{
Changli Gaod8d1f302010-06-10 23:31:35 -0700447 return rth->rt_genid != rt_genid(dev_net(rth->dst.dev));
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700448}
449
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800450/*
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300451 * Perturbation of rt_genid by a small quantity [1..256]
Eric Dumazet29e75252008-01-31 17:05:09 -0800452 * Using 8 bits of shuffling ensure we can call rt_cache_invalidate()
453 * many times (2^24) without giving recent rt_genid.
454 * Jenkins hash is strong enough that litle changes of rt_genid are OK.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 */
Denis V. Lunev86c657f2008-07-05 19:03:31 -0700456static void rt_cache_invalidate(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457{
Eric Dumazet29e75252008-01-31 17:05:09 -0800458 unsigned char shuffle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
Eric Dumazet29e75252008-01-31 17:05:09 -0800460 get_random_bytes(&shuffle, sizeof(shuffle));
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700461 atomic_add(shuffle + 1U, &net->ipv4.rt_genid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462}
463
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800464/*
Eric Dumazet29e75252008-01-31 17:05:09 -0800465 * delay < 0 : invalidate cache (fast : entries will be deleted later)
466 * delay >= 0 : invalidate & flush cache (can be long)
467 */
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -0700468void rt_cache_flush(struct net *net, int delay)
Eric Dumazet29e75252008-01-31 17:05:09 -0800469{
Denis V. Lunev86c657f2008-07-05 19:03:31 -0700470 rt_cache_invalidate(net);
Eric Dumazet98376382010-03-08 03:20:00 +0000471}
472
David S. Millerf894cbf2012-07-02 21:52:24 -0700473static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
474 struct sk_buff *skb,
475 const void *daddr)
David Miller3769cff2011-07-11 22:44:24 +0000476{
David S. Millerd3aaeb32011-07-18 00:40:17 -0700477 struct net_device *dev = dst->dev;
478 const __be32 *pkey = daddr;
David S. Miller39232972012-01-26 15:22:32 -0500479 const struct rtable *rt;
David Miller3769cff2011-07-11 22:44:24 +0000480 struct neighbour *n;
481
David S. Miller39232972012-01-26 15:22:32 -0500482 rt = (const struct rtable *) dst;
David S. Millera263b302012-07-02 02:02:15 -0700483 if (rt->rt_gateway)
David S. Miller39232972012-01-26 15:22:32 -0500484 pkey = (const __be32 *) &rt->rt_gateway;
David S. Millerf894cbf2012-07-02 21:52:24 -0700485 else if (skb)
486 pkey = &ip_hdr(skb)->daddr;
David S. Millerd3aaeb32011-07-18 00:40:17 -0700487
David S. Miller80703d22012-02-15 17:48:35 -0500488 n = __ipv4_neigh_lookup(dev, *(__force u32 *)pkey);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700489 if (n)
490 return n;
David Miller32092ec2011-07-25 00:01:41 +0000491 return neigh_create(&arp_tbl, pkey, dev);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700492}
493
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494/*
495 * Peer allocation may fail only in serious out-of-memory conditions. However
496 * we still can generate some output.
497 * Random ID selection looks a bit dangerous because we have no chances to
498 * select ID being unique in a reasonable period of time.
499 * But broken packet identifier may be better than no packet at all.
500 */
501static void ip_select_fb_ident(struct iphdr *iph)
502{
503 static DEFINE_SPINLOCK(ip_fb_id_lock);
504 static u32 ip_fallback_id;
505 u32 salt;
506
507 spin_lock_bh(&ip_fb_id_lock);
Al Viroe4485152006-09-26 22:15:01 -0700508 salt = secure_ip_id((__force __be32)ip_fallback_id ^ iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 iph->id = htons(salt & 0xFFFF);
510 ip_fallback_id = salt;
511 spin_unlock_bh(&ip_fb_id_lock);
512}
513
514void __ip_select_ident(struct iphdr *iph, struct dst_entry *dst, int more)
515{
David S. Miller1d861aa2012-07-10 03:58:16 -0700516 struct net *net = dev_net(dst->dev);
517 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
David S. Miller1d861aa2012-07-10 03:58:16 -0700519 peer = inet_getpeer_v4(net->ipv4.peers, iph->daddr, 1);
520 if (peer) {
521 iph->id = htons(inet_getid(peer, more));
522 inet_putpeer(peer);
523 return;
524 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
526 ip_select_fb_ident(iph);
527}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000528EXPORT_SYMBOL(__ip_select_ident);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200530static void __build_flow_key(struct flowi4 *fl4, const struct sock *sk,
David S. Miller4895c772012-07-17 04:19:00 -0700531 const struct iphdr *iph,
532 int oif, u8 tos,
533 u8 prot, u32 mark, int flow_flags)
534{
535 if (sk) {
536 const struct inet_sock *inet = inet_sk(sk);
537
538 oif = sk->sk_bound_dev_if;
539 mark = sk->sk_mark;
540 tos = RT_CONN_FLAGS(sk);
541 prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
542 }
543 flowi4_init_output(fl4, oif, mark, tos,
544 RT_SCOPE_UNIVERSE, prot,
545 flow_flags,
546 iph->daddr, iph->saddr, 0, 0);
547}
548
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200549static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
550 const struct sock *sk)
David S. Miller4895c772012-07-17 04:19:00 -0700551{
552 const struct iphdr *iph = ip_hdr(skb);
553 int oif = skb->dev->ifindex;
554 u8 tos = RT_TOS(iph->tos);
555 u8 prot = iph->protocol;
556 u32 mark = skb->mark;
557
558 __build_flow_key(fl4, sk, iph, oif, tos, prot, mark, 0);
559}
560
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200561static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
David S. Miller4895c772012-07-17 04:19:00 -0700562{
563 const struct inet_sock *inet = inet_sk(sk);
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200564 const struct ip_options_rcu *inet_opt;
David S. Miller4895c772012-07-17 04:19:00 -0700565 __be32 daddr = inet->inet_daddr;
566
567 rcu_read_lock();
568 inet_opt = rcu_dereference(inet->inet_opt);
569 if (inet_opt && inet_opt->opt.srr)
570 daddr = inet_opt->opt.faddr;
571 flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
572 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
573 inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
574 inet_sk_flowi_flags(sk),
575 daddr, inet->inet_saddr, 0, 0);
576 rcu_read_unlock();
577}
578
Eric Dumazet5abf7f72012-07-17 22:42:13 +0200579static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
580 const struct sk_buff *skb)
David S. Miller4895c772012-07-17 04:19:00 -0700581{
582 if (skb)
583 build_skb_flow_key(fl4, skb, sk);
584 else
585 build_sk_flow_key(fl4, sk);
586}
587
David S. Millerc5038a82012-07-31 15:02:02 -0700588static inline void rt_free(struct rtable *rt)
589{
590 call_rcu(&rt->dst.rcu_head, dst_rcu_free);
591}
592
593static DEFINE_SPINLOCK(fnhe_lock);
David S. Miller4895c772012-07-17 04:19:00 -0700594
Julian Anastasovaee06da2012-07-18 10:15:35 +0000595static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
David S. Miller4895c772012-07-17 04:19:00 -0700596{
597 struct fib_nh_exception *fnhe, *oldest;
David S. Millerc5038a82012-07-31 15:02:02 -0700598 struct rtable *orig;
David S. Miller4895c772012-07-17 04:19:00 -0700599
600 oldest = rcu_dereference(hash->chain);
601 for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
602 fnhe = rcu_dereference(fnhe->fnhe_next)) {
603 if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
604 oldest = fnhe;
605 }
David S. Millerc5038a82012-07-31 15:02:02 -0700606 orig = rcu_dereference(oldest->fnhe_rth);
607 if (orig) {
608 RCU_INIT_POINTER(oldest->fnhe_rth, NULL);
609 rt_free(orig);
610 }
David S. Miller4895c772012-07-17 04:19:00 -0700611 return oldest;
612}
613
David S. Millerd3a25c92012-07-17 13:23:08 -0700614static inline u32 fnhe_hashfun(__be32 daddr)
615{
616 u32 hval;
617
618 hval = (__force u32) daddr;
619 hval ^= (hval >> 11) ^ (hval >> 22);
620
621 return hval & (FNHE_HASH_SIZE - 1);
622}
623
Julian Anastasovaee06da2012-07-18 10:15:35 +0000624static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
625 u32 pmtu, unsigned long expires)
David S. Miller4895c772012-07-17 04:19:00 -0700626{
Julian Anastasovaee06da2012-07-18 10:15:35 +0000627 struct fnhe_hash_bucket *hash;
David S. Miller4895c772012-07-17 04:19:00 -0700628 struct fib_nh_exception *fnhe;
629 int depth;
Julian Anastasovaee06da2012-07-18 10:15:35 +0000630 u32 hval = fnhe_hashfun(daddr);
David S. Miller4895c772012-07-17 04:19:00 -0700631
David S. Millerc5038a82012-07-31 15:02:02 -0700632 spin_lock_bh(&fnhe_lock);
Julian Anastasovaee06da2012-07-18 10:15:35 +0000633
634 hash = nh->nh_exceptions;
David S. Miller4895c772012-07-17 04:19:00 -0700635 if (!hash) {
Julian Anastasovaee06da2012-07-18 10:15:35 +0000636 hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC);
David S. Miller4895c772012-07-17 04:19:00 -0700637 if (!hash)
Julian Anastasovaee06da2012-07-18 10:15:35 +0000638 goto out_unlock;
639 nh->nh_exceptions = hash;
David S. Miller4895c772012-07-17 04:19:00 -0700640 }
641
David S. Miller4895c772012-07-17 04:19:00 -0700642 hash += hval;
643
644 depth = 0;
645 for (fnhe = rcu_dereference(hash->chain); fnhe;
646 fnhe = rcu_dereference(fnhe->fnhe_next)) {
647 if (fnhe->fnhe_daddr == daddr)
Julian Anastasovaee06da2012-07-18 10:15:35 +0000648 break;
David S. Miller4895c772012-07-17 04:19:00 -0700649 depth++;
650 }
651
Julian Anastasovaee06da2012-07-18 10:15:35 +0000652 if (fnhe) {
653 if (gw)
654 fnhe->fnhe_gw = gw;
655 if (pmtu) {
656 fnhe->fnhe_pmtu = pmtu;
657 fnhe->fnhe_expires = expires;
658 }
659 } else {
660 if (depth > FNHE_RECLAIM_DEPTH)
661 fnhe = fnhe_oldest(hash);
662 else {
663 fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
664 if (!fnhe)
665 goto out_unlock;
666
667 fnhe->fnhe_next = hash->chain;
668 rcu_assign_pointer(hash->chain, fnhe);
669 }
670 fnhe->fnhe_daddr = daddr;
671 fnhe->fnhe_gw = gw;
672 fnhe->fnhe_pmtu = pmtu;
673 fnhe->fnhe_expires = expires;
David S. Miller4895c772012-07-17 04:19:00 -0700674 }
David S. Miller4895c772012-07-17 04:19:00 -0700675
David S. Miller4895c772012-07-17 04:19:00 -0700676 fnhe->fnhe_stamp = jiffies;
Julian Anastasovaee06da2012-07-18 10:15:35 +0000677
678out_unlock:
David S. Millerc5038a82012-07-31 15:02:02 -0700679 spin_unlock_bh(&fnhe_lock);
Julian Anastasovaee06da2012-07-18 10:15:35 +0000680 return;
David S. Miller4895c772012-07-17 04:19:00 -0700681}
682
David S. Millerceb33202012-07-17 11:31:28 -0700683static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
684 bool kill_route)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685{
David S. Millere47a1852012-07-11 20:55:47 -0700686 __be32 new_gw = icmp_hdr(skb)->un.gateway;
David S. Miller94206122012-07-11 20:38:08 -0700687 __be32 old_gw = ip_hdr(skb)->saddr;
David S. Millere47a1852012-07-11 20:55:47 -0700688 struct net_device *dev = skb->dev;
David S. Millere47a1852012-07-11 20:55:47 -0700689 struct in_device *in_dev;
David S. Miller4895c772012-07-17 04:19:00 -0700690 struct fib_result res;
David S. Millere47a1852012-07-11 20:55:47 -0700691 struct neighbour *n;
Denis V. Lunev317805b2008-02-28 20:50:06 -0800692 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
David S. Miller94206122012-07-11 20:38:08 -0700694 switch (icmp_hdr(skb)->code & 7) {
695 case ICMP_REDIR_NET:
696 case ICMP_REDIR_NETTOS:
697 case ICMP_REDIR_HOST:
698 case ICMP_REDIR_HOSTTOS:
699 break;
700
701 default:
702 return;
703 }
704
David S. Millere47a1852012-07-11 20:55:47 -0700705 if (rt->rt_gateway != old_gw)
706 return;
707
708 in_dev = __in_dev_get_rcu(dev);
709 if (!in_dev)
710 return;
711
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900712 net = dev_net(dev);
Joe Perches9d4fb272009-11-23 10:41:23 -0800713 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
714 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
715 ipv4_is_zeronet(new_gw))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 goto reject_redirect;
717
718 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
719 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
720 goto reject_redirect;
721 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
722 goto reject_redirect;
723 } else {
Denis V. Lunev317805b2008-02-28 20:50:06 -0800724 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 goto reject_redirect;
726 }
727
David S. Miller4895c772012-07-17 04:19:00 -0700728 n = ipv4_neigh_lookup(&rt->dst, NULL, &new_gw);
David S. Millere47a1852012-07-11 20:55:47 -0700729 if (n) {
730 if (!(n->nud_state & NUD_VALID)) {
731 neigh_event_send(n, NULL);
732 } else {
David S. Miller4895c772012-07-17 04:19:00 -0700733 if (fib_lookup(net, fl4, &res) == 0) {
734 struct fib_nh *nh = &FIB_RES_NH(res);
David S. Miller4895c772012-07-17 04:19:00 -0700735
Julian Anastasovaee06da2012-07-18 10:15:35 +0000736 update_or_create_fnhe(nh, fl4->daddr, new_gw,
737 0, 0);
David S. Miller4895c772012-07-17 04:19:00 -0700738 }
David S. Millerceb33202012-07-17 11:31:28 -0700739 if (kill_route)
740 rt->dst.obsolete = DST_OBSOLETE_KILL;
David S. Millere47a1852012-07-11 20:55:47 -0700741 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
742 }
743 neigh_release(n);
744 }
745 return;
746
747reject_redirect:
748#ifdef CONFIG_IP_ROUTE_VERBOSE
David S. Miller99ee0382012-07-12 07:40:05 -0700749 if (IN_DEV_LOG_MARTIANS(in_dev)) {
750 const struct iphdr *iph = (const struct iphdr *) skb->data;
751 __be32 daddr = iph->daddr;
752 __be32 saddr = iph->saddr;
753
David S. Millere47a1852012-07-11 20:55:47 -0700754 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
755 " Advised path = %pI4 -> %pI4\n",
756 &old_gw, dev->name, &new_gw,
757 &saddr, &daddr);
David S. Miller99ee0382012-07-12 07:40:05 -0700758 }
David S. Millere47a1852012-07-11 20:55:47 -0700759#endif
760 ;
761}
762
David S. Miller4895c772012-07-17 04:19:00 -0700763static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
764{
765 struct rtable *rt;
766 struct flowi4 fl4;
767
768 rt = (struct rtable *) dst;
769
770 ip_rt_build_flow_key(&fl4, sk, skb);
David S. Millerceb33202012-07-17 11:31:28 -0700771 __ip_do_redirect(rt, skb, &fl4, true);
David S. Miller4895c772012-07-17 04:19:00 -0700772}
773
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
775{
Eric Dumazetee6b9672008-03-05 18:30:47 -0800776 struct rtable *rt = (struct rtable *)dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 struct dst_entry *ret = dst;
778
779 if (rt) {
Timo Teräsd11a4dc2010-03-18 23:20:20 +0000780 if (dst->obsolete > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 ip_rt_put(rt);
782 ret = NULL;
David S. Miller59436342012-07-10 06:58:42 -0700783 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
784 rt->dst.expires) {
David S. Miller89aef892012-07-17 11:00:09 -0700785 ip_rt_put(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 ret = NULL;
787 }
788 }
789 return ret;
790}
791
792/*
793 * Algorithm:
794 * 1. The first ip_rt_redirect_number redirects are sent
795 * with exponential backoff, then we stop sending them at all,
796 * assuming that the host ignores our redirects.
797 * 2. If we did not see packets requiring redirects
798 * during ip_rt_redirect_silence, we assume that the host
799 * forgot redirected route and start to send redirects again.
800 *
801 * This algorithm is much cheaper and more intelligent than dumb load limiting
802 * in icmp.c.
803 *
804 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
805 * and "frag. need" (breaks PMTU discovery) in icmp.c.
806 */
807
808void ip_rt_send_redirect(struct sk_buff *skb)
809{
Eric Dumazet511c3f92009-06-02 05:14:27 +0000810 struct rtable *rt = skb_rtable(skb);
Eric Dumazet30038fc2009-08-28 23:52:01 -0700811 struct in_device *in_dev;
David S. Miller92d86822011-02-04 15:55:25 -0800812 struct inet_peer *peer;
David S. Miller1d861aa2012-07-10 03:58:16 -0700813 struct net *net;
Eric Dumazet30038fc2009-08-28 23:52:01 -0700814 int log_martians;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
Eric Dumazet30038fc2009-08-28 23:52:01 -0700816 rcu_read_lock();
Changli Gaod8d1f302010-06-10 23:31:35 -0700817 in_dev = __in_dev_get_rcu(rt->dst.dev);
Eric Dumazet30038fc2009-08-28 23:52:01 -0700818 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
819 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 return;
Eric Dumazet30038fc2009-08-28 23:52:01 -0700821 }
822 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
823 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
David S. Miller1d861aa2012-07-10 03:58:16 -0700825 net = dev_net(rt->dst.dev);
826 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
David S. Miller92d86822011-02-04 15:55:25 -0800827 if (!peer) {
828 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, rt->rt_gateway);
829 return;
830 }
831
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 /* No redirected packets during ip_rt_redirect_silence;
833 * reset the algorithm.
834 */
David S. Miller92d86822011-02-04 15:55:25 -0800835 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
836 peer->rate_tokens = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
838 /* Too many ignored redirects; do not send anything
Changli Gaod8d1f302010-06-10 23:31:35 -0700839 * set dst.rate_last to the last seen redirected packet.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 */
David S. Miller92d86822011-02-04 15:55:25 -0800841 if (peer->rate_tokens >= ip_rt_redirect_number) {
842 peer->rate_last = jiffies;
David S. Miller1d861aa2012-07-10 03:58:16 -0700843 goto out_put_peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 }
845
846 /* Check for load limit; set rate_last to the latest sent
847 * redirect.
848 */
David S. Miller92d86822011-02-04 15:55:25 -0800849 if (peer->rate_tokens == 0 ||
Li Yewang14fb8a72006-12-18 00:26:35 -0800850 time_after(jiffies,
David S. Miller92d86822011-02-04 15:55:25 -0800851 (peer->rate_last +
852 (ip_rt_redirect_load << peer->rate_tokens)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, rt->rt_gateway);
David S. Miller92d86822011-02-04 15:55:25 -0800854 peer->rate_last = jiffies;
855 ++peer->rate_tokens;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856#ifdef CONFIG_IP_ROUTE_VERBOSE
Eric Dumazet30038fc2009-08-28 23:52:01 -0700857 if (log_martians &&
Joe Perchese87cc472012-05-13 21:56:26 +0000858 peer->rate_tokens == ip_rt_redirect_number)
859 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
David S. Miller92101b32012-07-23 16:29:00 -0700860 &ip_hdr(skb)->saddr, inet_iif(skb),
David S. Millerf1ce3062012-07-12 10:10:17 -0700861 &ip_hdr(skb)->daddr, &rt->rt_gateway);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862#endif
863 }
David S. Miller1d861aa2012-07-10 03:58:16 -0700864out_put_peer:
865 inet_putpeer(peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866}
867
868static int ip_error(struct sk_buff *skb)
869{
David S. Miller251da412012-06-26 16:27:09 -0700870 struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
Eric Dumazet511c3f92009-06-02 05:14:27 +0000871 struct rtable *rt = skb_rtable(skb);
David S. Miller92d86822011-02-04 15:55:25 -0800872 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 unsigned long now;
David S. Miller251da412012-06-26 16:27:09 -0700874 struct net *net;
David S. Miller92d86822011-02-04 15:55:25 -0800875 bool send;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 int code;
877
David S. Miller251da412012-06-26 16:27:09 -0700878 net = dev_net(rt->dst.dev);
879 if (!IN_DEV_FORWARD(in_dev)) {
880 switch (rt->dst.error) {
881 case EHOSTUNREACH:
882 IP_INC_STATS_BH(net, IPSTATS_MIB_INADDRERRORS);
883 break;
884
885 case ENETUNREACH:
886 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
887 break;
888 }
889 goto out;
890 }
891
Changli Gaod8d1f302010-06-10 23:31:35 -0700892 switch (rt->dst.error) {
Joe Perches4500ebf2011-07-01 09:43:07 +0000893 case EINVAL:
894 default:
895 goto out;
896 case EHOSTUNREACH:
897 code = ICMP_HOST_UNREACH;
898 break;
899 case ENETUNREACH:
900 code = ICMP_NET_UNREACH;
David S. Miller251da412012-06-26 16:27:09 -0700901 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
Joe Perches4500ebf2011-07-01 09:43:07 +0000902 break;
903 case EACCES:
904 code = ICMP_PKT_FILTERED;
905 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 }
907
David S. Miller1d861aa2012-07-10 03:58:16 -0700908 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
David S. Miller92d86822011-02-04 15:55:25 -0800909
910 send = true;
911 if (peer) {
912 now = jiffies;
913 peer->rate_tokens += now - peer->rate_last;
914 if (peer->rate_tokens > ip_rt_error_burst)
915 peer->rate_tokens = ip_rt_error_burst;
916 peer->rate_last = now;
917 if (peer->rate_tokens >= ip_rt_error_cost)
918 peer->rate_tokens -= ip_rt_error_cost;
919 else
920 send = false;
David S. Miller1d861aa2012-07-10 03:58:16 -0700921 inet_putpeer(peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 }
David S. Miller92d86822011-02-04 15:55:25 -0800923 if (send)
924 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
926out: kfree_skb(skb);
927 return 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900928}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
David S. Millerceb33202012-07-17 11:31:28 -0700930static u32 __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931{
David S. Miller4895c772012-07-17 04:19:00 -0700932 struct fib_result res;
David S. Miller2c8cec52011-02-09 20:42:07 -0800933
David S. Miller59436342012-07-10 06:58:42 -0700934 if (mtu < ip_rt_min_pmtu)
935 mtu = ip_rt_min_pmtu;
Eric Dumazetfe6fe792011-06-08 06:07:07 +0000936
David S. Miller4895c772012-07-17 04:19:00 -0700937 if (fib_lookup(dev_net(rt->dst.dev), fl4, &res) == 0) {
938 struct fib_nh *nh = &FIB_RES_NH(res);
David S. Miller4895c772012-07-17 04:19:00 -0700939
Julian Anastasovaee06da2012-07-18 10:15:35 +0000940 update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
941 jiffies + ip_rt_mtu_expires);
David S. Miller4895c772012-07-17 04:19:00 -0700942 }
David S. Millerceb33202012-07-17 11:31:28 -0700943 return mtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944}
945
David S. Miller4895c772012-07-17 04:19:00 -0700946static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
947 struct sk_buff *skb, u32 mtu)
948{
949 struct rtable *rt = (struct rtable *) dst;
950 struct flowi4 fl4;
951
952 ip_rt_build_flow_key(&fl4, sk, skb);
David S. Millerceb33202012-07-17 11:31:28 -0700953 mtu = __ip_rt_update_pmtu(rt, &fl4, mtu);
954
955 if (!rt->rt_pmtu) {
956 dst->obsolete = DST_OBSOLETE_KILL;
957 } else {
958 rt->rt_pmtu = mtu;
959 dst_set_expires(&rt->dst, ip_rt_mtu_expires);
960 }
David S. Miller4895c772012-07-17 04:19:00 -0700961}
962
David S. Miller36393392012-06-14 22:21:46 -0700963void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
964 int oif, u32 mark, u8 protocol, int flow_flags)
965{
David S. Miller4895c772012-07-17 04:19:00 -0700966 const struct iphdr *iph = (const struct iphdr *) skb->data;
David S. Miller36393392012-06-14 22:21:46 -0700967 struct flowi4 fl4;
968 struct rtable *rt;
969
David S. Miller4895c772012-07-17 04:19:00 -0700970 __build_flow_key(&fl4, NULL, iph, oif,
971 RT_TOS(iph->tos), protocol, mark, flow_flags);
David S. Miller36393392012-06-14 22:21:46 -0700972 rt = __ip_route_output_key(net, &fl4);
973 if (!IS_ERR(rt)) {
David S. Miller4895c772012-07-17 04:19:00 -0700974 __ip_rt_update_pmtu(rt, &fl4, mtu);
David S. Miller36393392012-06-14 22:21:46 -0700975 ip_rt_put(rt);
976 }
977}
978EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
979
980void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
981{
David S. Miller4895c772012-07-17 04:19:00 -0700982 const struct iphdr *iph = (const struct iphdr *) skb->data;
983 struct flowi4 fl4;
984 struct rtable *rt;
David S. Miller36393392012-06-14 22:21:46 -0700985
David S. Miller4895c772012-07-17 04:19:00 -0700986 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
987 rt = __ip_route_output_key(sock_net(sk), &fl4);
988 if (!IS_ERR(rt)) {
989 __ip_rt_update_pmtu(rt, &fl4, mtu);
990 ip_rt_put(rt);
991 }
David S. Miller36393392012-06-14 22:21:46 -0700992}
993EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
David S. Millerf39925d2011-02-09 22:00:16 -0800994
David S. Millerb42597e2012-07-11 21:25:45 -0700995void ipv4_redirect(struct sk_buff *skb, struct net *net,
996 int oif, u32 mark, u8 protocol, int flow_flags)
997{
David S. Miller4895c772012-07-17 04:19:00 -0700998 const struct iphdr *iph = (const struct iphdr *) skb->data;
David S. Millerb42597e2012-07-11 21:25:45 -0700999 struct flowi4 fl4;
1000 struct rtable *rt;
1001
David S. Miller4895c772012-07-17 04:19:00 -07001002 __build_flow_key(&fl4, NULL, iph, oif,
1003 RT_TOS(iph->tos), protocol, mark, flow_flags);
David S. Millerb42597e2012-07-11 21:25:45 -07001004 rt = __ip_route_output_key(net, &fl4);
1005 if (!IS_ERR(rt)) {
David S. Millerceb33202012-07-17 11:31:28 -07001006 __ip_do_redirect(rt, skb, &fl4, false);
David S. Millerb42597e2012-07-11 21:25:45 -07001007 ip_rt_put(rt);
1008 }
1009}
1010EXPORT_SYMBOL_GPL(ipv4_redirect);
1011
1012void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1013{
David S. Miller4895c772012-07-17 04:19:00 -07001014 const struct iphdr *iph = (const struct iphdr *) skb->data;
1015 struct flowi4 fl4;
1016 struct rtable *rt;
David S. Millerb42597e2012-07-11 21:25:45 -07001017
David S. Miller4895c772012-07-17 04:19:00 -07001018 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1019 rt = __ip_route_output_key(sock_net(sk), &fl4);
1020 if (!IS_ERR(rt)) {
David S. Millerceb33202012-07-17 11:31:28 -07001021 __ip_do_redirect(rt, skb, &fl4, false);
David S. Miller4895c772012-07-17 04:19:00 -07001022 ip_rt_put(rt);
1023 }
David S. Millerb42597e2012-07-11 21:25:45 -07001024}
1025EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1026
David S. Millerefbc3682011-12-01 13:38:59 -05001027static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1028{
1029 struct rtable *rt = (struct rtable *) dst;
1030
David S. Millerceb33202012-07-17 11:31:28 -07001031 /* All IPV4 dsts are created with ->obsolete set to the value
1032 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1033 * into this function always.
1034 *
1035 * When a PMTU/redirect information update invalidates a
1036 * route, this is indicated by setting obsolete to
1037 * DST_OBSOLETE_KILL.
1038 */
1039 if (dst->obsolete == DST_OBSOLETE_KILL || rt_is_expired(rt))
David S. Millerefbc3682011-12-01 13:38:59 -05001040 return NULL;
Timo Teräsd11a4dc2010-03-18 23:20:20 +00001041 return dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042}
1043
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044static void ipv4_link_failure(struct sk_buff *skb)
1045{
1046 struct rtable *rt;
1047
1048 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1049
Eric Dumazet511c3f92009-06-02 05:14:27 +00001050 rt = skb_rtable(skb);
David S. Miller59436342012-07-10 06:58:42 -07001051 if (rt)
1052 dst_set_expires(&rt->dst, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053}
1054
1055static int ip_rt_bug(struct sk_buff *skb)
1056{
Joe Perches91df42b2012-05-15 14:11:54 +00001057 pr_debug("%s: %pI4 -> %pI4, %s\n",
1058 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1059 skb->dev ? skb->dev->name : "?");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 kfree_skb(skb);
Dave Jonesc378a9c2011-05-21 07:16:42 +00001061 WARN_ON(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 return 0;
1063}
1064
1065/*
1066 We do not cache source address of outgoing interface,
1067 because it is used only by IP RR, TS and SRR options,
1068 so that it out of fast path.
1069
1070 BTW remember: "addr" is allowed to be not aligned
1071 in IP options!
1072 */
1073
David S. Miller8e363602011-05-13 17:29:41 -04001074void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075{
Al Viroa61ced52006-09-26 21:27:54 -07001076 __be32 src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077
David S. Millerc7537962010-11-11 17:07:48 -08001078 if (rt_is_output_route(rt))
David S. Millerc5be24f2011-05-13 18:01:21 -04001079 src = ip_hdr(skb)->saddr;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001080 else {
David S. Miller8e363602011-05-13 17:29:41 -04001081 struct fib_result res;
1082 struct flowi4 fl4;
1083 struct iphdr *iph;
1084
1085 iph = ip_hdr(skb);
1086
1087 memset(&fl4, 0, sizeof(fl4));
1088 fl4.daddr = iph->daddr;
1089 fl4.saddr = iph->saddr;
Julian Anastasovb0fe4a32011-07-23 02:00:41 +00001090 fl4.flowi4_tos = RT_TOS(iph->tos);
David S. Miller8e363602011-05-13 17:29:41 -04001091 fl4.flowi4_oif = rt->dst.dev->ifindex;
1092 fl4.flowi4_iif = skb->dev->ifindex;
1093 fl4.flowi4_mark = skb->mark;
David S. Miller5e2b61f2011-03-04 21:47:09 -08001094
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001095 rcu_read_lock();
David S. Miller68a5e3d2011-03-11 20:07:33 -05001096 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res) == 0)
David S. Miller436c3b62011-03-24 17:42:21 -07001097 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001098 else
David S. Millerf8126f12012-07-13 05:03:45 -07001099 src = inet_select_addr(rt->dst.dev,
1100 rt_nexthop(rt, iph->daddr),
1101 RT_SCOPE_UNIVERSE);
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001102 rcu_read_unlock();
1103 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 memcpy(addr, &src, 4);
1105}
1106
Patrick McHardyc7066f72011-01-14 13:36:42 +01001107#ifdef CONFIG_IP_ROUTE_CLASSID
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108static void set_class_tag(struct rtable *rt, u32 tag)
1109{
Changli Gaod8d1f302010-06-10 23:31:35 -07001110 if (!(rt->dst.tclassid & 0xFFFF))
1111 rt->dst.tclassid |= tag & 0xFFFF;
1112 if (!(rt->dst.tclassid & 0xFFFF0000))
1113 rt->dst.tclassid |= tag & 0xFFFF0000;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114}
1115#endif
1116
David S. Miller0dbaee32010-12-13 12:52:14 -08001117static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1118{
1119 unsigned int advmss = dst_metric_raw(dst, RTAX_ADVMSS);
1120
1121 if (advmss == 0) {
1122 advmss = max_t(unsigned int, dst->dev->mtu - 40,
1123 ip_rt_min_advmss);
1124 if (advmss > 65535 - 40)
1125 advmss = 65535 - 40;
1126 }
1127 return advmss;
1128}
1129
Steffen Klassertebb762f2011-11-23 02:12:51 +00001130static unsigned int ipv4_mtu(const struct dst_entry *dst)
David S. Millerd33e4552010-12-14 13:01:14 -08001131{
Steffen Klassert261663b2011-11-23 02:14:50 +00001132 const struct rtable *rt = (const struct rtable *) dst;
David S. Miller59436342012-07-10 06:58:42 -07001133 unsigned int mtu = rt->rt_pmtu;
1134
1135 if (mtu && time_after_eq(jiffies, rt->dst.expires))
1136 mtu = 0;
1137
1138 if (!mtu)
1139 mtu = dst_metric_raw(dst, RTAX_MTU);
Steffen Klassert618f9bc2011-11-23 02:13:31 +00001140
Steffen Klassert261663b2011-11-23 02:14:50 +00001141 if (mtu && rt_is_output_route(rt))
Steffen Klassert618f9bc2011-11-23 02:13:31 +00001142 return mtu;
1143
1144 mtu = dst->dev->mtu;
David S. Millerd33e4552010-12-14 13:01:14 -08001145
1146 if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
David S. Millerf8126f12012-07-13 05:03:45 -07001147 if (rt->rt_gateway && mtu > 576)
David S. Millerd33e4552010-12-14 13:01:14 -08001148 mtu = 576;
1149 }
1150
1151 if (mtu > IP_MAX_MTU)
1152 mtu = IP_MAX_MTU;
1153
1154 return mtu;
1155}
1156
David S. Millerf2bb4be2012-07-17 12:20:47 -07001157static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
David S. Miller4895c772012-07-17 04:19:00 -07001158{
1159 struct fnhe_hash_bucket *hash = nh->nh_exceptions;
1160 struct fib_nh_exception *fnhe;
1161 u32 hval;
1162
David S. Millerf2bb4be2012-07-17 12:20:47 -07001163 if (!hash)
1164 return NULL;
1165
David S. Millerd3a25c92012-07-17 13:23:08 -07001166 hval = fnhe_hashfun(daddr);
David S. Miller4895c772012-07-17 04:19:00 -07001167
1168 for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1169 fnhe = rcu_dereference(fnhe->fnhe_next)) {
David S. Millerf2bb4be2012-07-17 12:20:47 -07001170 if (fnhe->fnhe_daddr == daddr)
1171 return fnhe;
1172 }
1173 return NULL;
1174}
David S. Miller4895c772012-07-17 04:19:00 -07001175
David S. Millercaacf052012-07-31 15:06:50 -07001176static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001177 __be32 daddr)
1178{
David S. Millercaacf052012-07-31 15:06:50 -07001179 bool ret = false;
1180
David S. Millerc5038a82012-07-31 15:02:02 -07001181 spin_lock_bh(&fnhe_lock);
Julian Anastasovaee06da2012-07-18 10:15:35 +00001182
David S. Millerc5038a82012-07-31 15:02:02 -07001183 if (daddr == fnhe->fnhe_daddr) {
1184 struct rtable *orig;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001185
David S. Millerc5038a82012-07-31 15:02:02 -07001186 if (fnhe->fnhe_pmtu) {
1187 unsigned long expires = fnhe->fnhe_expires;
1188 unsigned long diff = expires - jiffies;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001189
David S. Millerc5038a82012-07-31 15:02:02 -07001190 if (time_before(jiffies, expires)) {
1191 rt->rt_pmtu = fnhe->fnhe_pmtu;
1192 dst_set_expires(&rt->dst, diff);
1193 }
David S. Miller4895c772012-07-17 04:19:00 -07001194 }
David S. Millerc5038a82012-07-31 15:02:02 -07001195 if (fnhe->fnhe_gw) {
1196 rt->rt_flags |= RTCF_REDIRECTED;
1197 rt->rt_gateway = fnhe->fnhe_gw;
1198 }
David S. Millerf2bb4be2012-07-17 12:20:47 -07001199
David S. Millerc5038a82012-07-31 15:02:02 -07001200 orig = rcu_dereference(fnhe->fnhe_rth);
1201 rcu_assign_pointer(fnhe->fnhe_rth, rt);
1202 if (orig)
1203 rt_free(orig);
1204
1205 fnhe->fnhe_stamp = jiffies;
David S. Millercaacf052012-07-31 15:06:50 -07001206 ret = true;
David S. Millerc5038a82012-07-31 15:02:02 -07001207 } else {
1208 /* Routes we intend to cache in nexthop exception have
1209 * the DST_NOCACHE bit clear. However, if we are
1210 * unsuccessful at storing this route into the cache
1211 * we really need to set it.
1212 */
1213 rt->dst.flags |= DST_NOCACHE;
1214 }
1215 spin_unlock_bh(&fnhe_lock);
David S. Millercaacf052012-07-31 15:06:50 -07001216
1217 return ret;
Eric Dumazet54764bb2012-07-31 01:08:23 +00001218}
1219
David S. Millercaacf052012-07-31 15:06:50 -07001220static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
David S. Millerf2bb4be2012-07-17 12:20:47 -07001221{
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001222 struct rtable *orig, *prev, **p;
David S. Millercaacf052012-07-31 15:06:50 -07001223 bool ret = true;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001224
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001225 if (rt_is_input_route(rt)) {
Eric Dumazet54764bb2012-07-31 01:08:23 +00001226 p = (struct rtable **)&nh->nh_rth_input;
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001227 } else {
1228 if (!nh->nh_pcpu_rth_output)
1229 goto nocache;
1230 p = (struct rtable **)__this_cpu_ptr(nh->nh_pcpu_rth_output);
1231 }
David S. Millerf2bb4be2012-07-17 12:20:47 -07001232 orig = *p;
1233
1234 prev = cmpxchg(p, orig, rt);
1235 if (prev == orig) {
David S. Millerf2bb4be2012-07-17 12:20:47 -07001236 if (orig)
Eric Dumazet54764bb2012-07-31 01:08:23 +00001237 rt_free(orig);
David S. Millerc6cffba2012-07-26 11:14:38 +00001238 } else {
Eric Dumazet54764bb2012-07-31 01:08:23 +00001239 /* Routes we intend to cache in the FIB nexthop have
1240 * the DST_NOCACHE bit clear. However, if we are
1241 * unsuccessful at storing this route into the cache
1242 * we really need to set it.
1243 */
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001244nocache:
Eric Dumazet54764bb2012-07-31 01:08:23 +00001245 rt->dst.flags |= DST_NOCACHE;
David S. Millercaacf052012-07-31 15:06:50 -07001246 ret = false;
1247 }
1248
1249 return ret;
1250}
1251
1252static DEFINE_SPINLOCK(rt_uncached_lock);
1253static LIST_HEAD(rt_uncached_list);
1254
1255static void rt_add_uncached_list(struct rtable *rt)
1256{
1257 spin_lock_bh(&rt_uncached_lock);
1258 list_add_tail(&rt->rt_uncached, &rt_uncached_list);
1259 spin_unlock_bh(&rt_uncached_lock);
1260}
1261
1262static void ipv4_dst_destroy(struct dst_entry *dst)
1263{
1264 struct rtable *rt = (struct rtable *) dst;
1265
1266 if (dst->flags & DST_NOCACHE) {
1267 spin_lock_bh(&rt_uncached_lock);
1268 list_del(&rt->rt_uncached);
1269 spin_unlock_bh(&rt_uncached_lock);
1270 }
1271}
1272
1273void rt_flush_dev(struct net_device *dev)
1274{
1275 if (!list_empty(&rt_uncached_list)) {
1276 struct net *net = dev_net(dev);
1277 struct rtable *rt;
1278
1279 spin_lock_bh(&rt_uncached_lock);
1280 list_for_each_entry(rt, &rt_uncached_list, rt_uncached) {
1281 if (rt->dst.dev != dev)
1282 continue;
1283 rt->dst.dev = net->loopback_dev;
1284 dev_hold(rt->dst.dev);
1285 dev_put(dev);
1286 }
1287 spin_unlock_bh(&rt_uncached_lock);
David S. Miller4895c772012-07-17 04:19:00 -07001288 }
1289}
1290
Eric Dumazet4331deb2012-07-25 05:11:23 +00001291static bool rt_cache_valid(const struct rtable *rt)
David S. Millerd2d68ba2012-07-17 12:58:50 -07001292{
Eric Dumazet4331deb2012-07-25 05:11:23 +00001293 return rt &&
1294 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1295 !rt_is_expired(rt);
David S. Millerd2d68ba2012-07-17 12:58:50 -07001296}
1297
David S. Millerf2bb4be2012-07-17 12:20:47 -07001298static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
David S. Miller5e2b61f2011-03-04 21:47:09 -08001299 const struct fib_result *res,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001300 struct fib_nh_exception *fnhe,
David S. Miller982721f2011-02-16 21:44:24 -08001301 struct fib_info *fi, u16 type, u32 itag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302{
David S. Millercaacf052012-07-31 15:06:50 -07001303 bool cached = false;
1304
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 if (fi) {
David S. Miller4895c772012-07-17 04:19:00 -07001306 struct fib_nh *nh = &FIB_RES_NH(*res);
1307
1308 if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK)
1309 rt->rt_gateway = nh->nh_gw;
David S. Miller28605832012-07-17 14:55:59 -07001310 dst_init_metrics(&rt->dst, fi->fib_metrics, true);
Patrick McHardyc7066f72011-01-14 13:36:42 +01001311#ifdef CONFIG_IP_ROUTE_CLASSID
David S. Millerf2bb4be2012-07-17 12:20:47 -07001312 rt->dst.tclassid = nh->nh_tclassid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313#endif
David S. Millerc5038a82012-07-31 15:02:02 -07001314 if (unlikely(fnhe))
David S. Millercaacf052012-07-31 15:06:50 -07001315 cached = rt_bind_exception(rt, fnhe, daddr);
David S. Millerc5038a82012-07-31 15:02:02 -07001316 else if (!(rt->dst.flags & DST_NOCACHE))
David S. Millercaacf052012-07-31 15:06:50 -07001317 cached = rt_cache_route(nh, rt);
David S. Millerd33e4552010-12-14 13:01:14 -08001318 }
David S. Millercaacf052012-07-31 15:06:50 -07001319 if (unlikely(!cached))
1320 rt_add_uncached_list(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321
Patrick McHardyc7066f72011-01-14 13:36:42 +01001322#ifdef CONFIG_IP_ROUTE_CLASSID
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323#ifdef CONFIG_IP_MULTIPLE_TABLES
David S. Miller85b91b02012-07-13 08:21:29 -07001324 set_class_tag(rt, res->tclassid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325#endif
1326 set_class_tag(rt, itag);
1327#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328}
1329
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001330static struct rtable *rt_dst_alloc(struct net_device *dev,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001331 bool nopolicy, bool noxfrm, bool will_cache)
David S. Miller0c4dcd52011-02-17 15:42:37 -08001332{
David S. Millerf5b0a872012-07-19 12:31:33 -07001333 return dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
David S. Millerc6cffba2012-07-26 11:14:38 +00001334 (will_cache ? 0 : (DST_HOST | DST_NOCACHE)) |
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001335 (nopolicy ? DST_NOPOLICY : 0) |
1336 (noxfrm ? DST_NOXFRM : 0));
David S. Miller0c4dcd52011-02-17 15:42:37 -08001337}
1338
Eric Dumazet96d36222010-06-02 19:21:31 +00001339/* called in rcu_read_lock() section */
Al Viro9e12bb22006-09-26 21:25:20 -07001340static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 u8 tos, struct net_device *dev, int our)
1342{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 struct rtable *rth;
Eric Dumazet96d36222010-06-02 19:21:31 +00001344 struct in_device *in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 u32 itag = 0;
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001346 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347
1348 /* Primary sanity checks. */
1349
1350 if (in_dev == NULL)
1351 return -EINVAL;
1352
Jan Engelhardt1e637c72008-01-21 03:18:08 -08001353 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
Thomas Grafd0daebc32012-06-12 00:44:01 +00001354 skb->protocol != htons(ETH_P_IP))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 goto e_inval;
1356
Thomas Grafd0daebc32012-06-12 00:44:01 +00001357 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1358 if (ipv4_is_loopback(saddr))
1359 goto e_inval;
1360
Joe Perchesf97c1e02007-12-16 13:45:43 -08001361 if (ipv4_is_zeronet(saddr)) {
1362 if (!ipv4_is_local_multicast(daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 goto e_inval;
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001364 } else {
David S. Miller9e56e382012-06-28 18:54:02 -07001365 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1366 in_dev, &itag);
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001367 if (err < 0)
1368 goto e_err;
1369 }
Benjamin LaHaise4e7b2f12012-03-27 15:55:32 +00001370 rth = rt_dst_alloc(dev_net(dev)->loopback_dev,
David S. Millerf2bb4be2012-07-17 12:20:47 -07001371 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 if (!rth)
1373 goto e_nobufs;
1374
Patrick McHardyc7066f72011-01-14 13:36:42 +01001375#ifdef CONFIG_IP_ROUTE_CLASSID
Changli Gaod8d1f302010-06-10 23:31:35 -07001376 rth->dst.tclassid = itag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377#endif
David S. Millercf911662011-04-28 14:31:47 -07001378 rth->dst.output = ip_rt_bug;
1379
Denis V. Luneve84f84f2008-07-05 19:04:32 -07001380 rth->rt_genid = rt_genid(dev_net(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 rth->rt_flags = RTCF_MULTICAST;
Eric Dumazet29e75252008-01-31 17:05:09 -08001382 rth->rt_type = RTN_MULTICAST;
David S. Miller9917e1e82012-07-17 14:44:26 -07001383 rth->rt_is_input= 1;
David S. Miller13378ca2012-07-23 13:57:45 -07001384 rth->rt_iif = 0;
David S. Miller59436342012-07-10 06:58:42 -07001385 rth->rt_pmtu = 0;
David S. Millerf8126f12012-07-13 05:03:45 -07001386 rth->rt_gateway = 0;
David S. Millercaacf052012-07-31 15:06:50 -07001387 INIT_LIST_HEAD(&rth->rt_uncached);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 if (our) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001389 rth->dst.input= ip_local_deliver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 rth->rt_flags |= RTCF_LOCAL;
1391 }
1392
1393#ifdef CONFIG_IP_MROUTE
Joe Perchesf97c1e02007-12-16 13:45:43 -08001394 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
Changli Gaod8d1f302010-06-10 23:31:35 -07001395 rth->dst.input = ip_mr_input;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396#endif
1397 RT_CACHE_STAT_INC(in_slow_mc);
1398
David S. Miller89aef892012-07-17 11:00:09 -07001399 skb_dst_set(skb, &rth->dst);
1400 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401
1402e_nobufs:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404e_inval:
Eric Dumazet96d36222010-06-02 19:21:31 +00001405 return -EINVAL;
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001406e_err:
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001407 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408}
1409
1410
1411static void ip_handle_martian_source(struct net_device *dev,
1412 struct in_device *in_dev,
1413 struct sk_buff *skb,
Al Viro9e12bb22006-09-26 21:25:20 -07001414 __be32 daddr,
1415 __be32 saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416{
1417 RT_CACHE_STAT_INC(in_martian_src);
1418#ifdef CONFIG_IP_ROUTE_VERBOSE
1419 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1420 /*
1421 * RFC1812 recommendation, if source is martian,
1422 * the only hint is MAC header.
1423 */
Joe Perches058bd4d2012-03-11 18:36:11 +00001424 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
Harvey Harrison673d57e2008-10-31 00:53:57 -07001425 &daddr, &saddr, dev->name);
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001426 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
Joe Perches058bd4d2012-03-11 18:36:11 +00001427 print_hex_dump(KERN_WARNING, "ll header: ",
1428 DUMP_PREFIX_OFFSET, 16, 1,
1429 skb_mac_header(skb),
1430 dev->hard_header_len, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 }
1432 }
1433#endif
1434}
1435
Eric Dumazet47360222010-06-03 04:13:21 +00001436/* called in rcu_read_lock() section */
Stephen Hemminger5969f712008-04-10 01:52:09 -07001437static int __mkroute_input(struct sk_buff *skb,
David S. Miller982721f2011-02-16 21:44:24 -08001438 const struct fib_result *res,
Stephen Hemminger5969f712008-04-10 01:52:09 -07001439 struct in_device *in_dev,
David S. Millerc6cffba2012-07-26 11:14:38 +00001440 __be32 daddr, __be32 saddr, u32 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 struct rtable *rth;
1443 int err;
1444 struct in_device *out_dev;
Eric Dumazet47360222010-06-03 04:13:21 +00001445 unsigned int flags = 0;
David S. Millerd2d68ba2012-07-17 12:58:50 -07001446 bool do_cache;
Al Virod9c9df82006-09-26 21:28:14 -07001447 u32 itag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448
1449 /* get a working reference to the output device */
Eric Dumazet47360222010-06-03 04:13:21 +00001450 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 if (out_dev == NULL) {
Joe Perchese87cc472012-05-13 21:56:26 +00001452 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 return -EINVAL;
1454 }
1455
1456
Michael Smith5c04c812011-04-07 04:51:50 +00001457 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
David S. Miller9e56e382012-06-28 18:54:02 -07001458 in_dev->dev, in_dev, &itag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 if (err < 0) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001460 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 saddr);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001462
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 goto cleanup;
1464 }
1465
Thomas Graf51b77ca2008-06-03 16:36:01 -07001466 if (out_dev == in_dev && err &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 (IN_DEV_SHARED_MEDIA(out_dev) ||
1468 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1469 flags |= RTCF_DOREDIRECT;
1470
1471 if (skb->protocol != htons(ETH_P_IP)) {
1472 /* Not IP (i.e. ARP). Do not create route, if it is
1473 * invalid for proxy arp. DNAT routes are always valid.
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00001474 *
1475 * Proxy arp feature have been extended to allow, ARP
1476 * replies back to the same interface, to support
1477 * Private VLAN switch technologies. See arp.c.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 */
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00001479 if (out_dev == in_dev &&
1480 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 err = -EINVAL;
1482 goto cleanup;
1483 }
1484 }
1485
David S. Millerd2d68ba2012-07-17 12:58:50 -07001486 do_cache = false;
1487 if (res->fi) {
David S. Millerfe3edf42012-07-23 13:22:20 -07001488 if (!itag) {
Eric Dumazet54764bb2012-07-31 01:08:23 +00001489 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
David S. Millerd2d68ba2012-07-17 12:58:50 -07001490 if (rt_cache_valid(rth)) {
David S. Millerc6cffba2012-07-26 11:14:38 +00001491 skb_dst_set_noref(skb, &rth->dst);
David S. Millerd2d68ba2012-07-17 12:58:50 -07001492 goto out;
1493 }
1494 do_cache = true;
1495 }
1496 }
David S. Millerf2bb4be2012-07-17 12:20:47 -07001497
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001498 rth = rt_dst_alloc(out_dev->dev,
1499 IN_DEV_CONF_GET(in_dev, NOPOLICY),
David S. Millerd2d68ba2012-07-17 12:58:50 -07001500 IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 if (!rth) {
1502 err = -ENOBUFS;
1503 goto cleanup;
1504 }
1505
David S. Millercf911662011-04-28 14:31:47 -07001506 rth->rt_genid = rt_genid(dev_net(rth->dst.dev));
1507 rth->rt_flags = flags;
1508 rth->rt_type = res->type;
David S. Miller9917e1e82012-07-17 14:44:26 -07001509 rth->rt_is_input = 1;
David S. Miller13378ca2012-07-23 13:57:45 -07001510 rth->rt_iif = 0;
David S. Miller59436342012-07-10 06:58:42 -07001511 rth->rt_pmtu = 0;
David S. Millerf8126f12012-07-13 05:03:45 -07001512 rth->rt_gateway = 0;
David S. Millercaacf052012-07-31 15:06:50 -07001513 INIT_LIST_HEAD(&rth->rt_uncached);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514
Changli Gaod8d1f302010-06-10 23:31:35 -07001515 rth->dst.input = ip_forward;
1516 rth->dst.output = ip_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517
David S. Millerd2d68ba2012-07-17 12:58:50 -07001518 rt_set_nexthop(rth, daddr, res, NULL, res->fi, res->type, itag);
David S. Millerc6cffba2012-07-26 11:14:38 +00001519 skb_dst_set(skb, &rth->dst);
David S. Millerd2d68ba2012-07-17 12:58:50 -07001520out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 err = 0;
1522 cleanup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 return err;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001524}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525
Stephen Hemminger5969f712008-04-10 01:52:09 -07001526static int ip_mkroute_input(struct sk_buff *skb,
1527 struct fib_result *res,
David S. Miller68a5e3d2011-03-11 20:07:33 -05001528 const struct flowi4 *fl4,
Stephen Hemminger5969f712008-04-10 01:52:09 -07001529 struct in_device *in_dev,
1530 __be32 daddr, __be32 saddr, u32 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532#ifdef CONFIG_IP_ROUTE_MULTIPATH
David S. Millerff3fccb2011-03-10 16:23:24 -08001533 if (res->fi && res->fi->fib_nhs > 1)
David S. Miller1b7fe5932011-03-10 17:01:16 -08001534 fib_select_multipath(res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535#endif
1536
1537 /* create a routing cache entry */
David S. Millerc6cffba2012-07-26 11:14:38 +00001538 return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539}
1540
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541/*
1542 * NOTE. We drop all the packets that has local source
1543 * addresses, because every properly looped back packet
1544 * must have correct destination already attached by output routine.
1545 *
1546 * Such approach solves two big problems:
1547 * 1. Not simplex devices are handled properly.
1548 * 2. IP spoofing attempts are filtered with 100% of guarantee.
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001549 * called with rcu_read_lock()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 */
1551
Al Viro9e12bb22006-09-26 21:25:20 -07001552static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
David S. Millerc10237e2012-06-27 17:05:06 -07001553 u8 tos, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554{
1555 struct fib_result res;
Eric Dumazet96d36222010-06-02 19:21:31 +00001556 struct in_device *in_dev = __in_dev_get_rcu(dev);
David S. Miller68a5e3d2011-03-11 20:07:33 -05001557 struct flowi4 fl4;
Eric Dumazet95c96172012-04-15 05:58:06 +00001558 unsigned int flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 u32 itag = 0;
Eric Dumazet95c96172012-04-15 05:58:06 +00001560 struct rtable *rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 int err = -EINVAL;
Daniel Baluta5e73ea12012-04-15 01:34:41 +00001562 struct net *net = dev_net(dev);
David S. Millerd2d68ba2012-07-17 12:58:50 -07001563 bool do_cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564
1565 /* IP on this device is disabled. */
1566
1567 if (!in_dev)
1568 goto out;
1569
1570 /* Check for the most weird martians, which can be not detected
1571 by fib_lookup.
1572 */
1573
Thomas Grafd0daebc32012-06-12 00:44:01 +00001574 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 goto martian_source;
1576
David S. Millerd2d68ba2012-07-17 12:58:50 -07001577 res.fi = NULL;
Andy Walls27a954b2010-10-17 15:11:22 +00001578 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 goto brd_input;
1580
1581 /* Accept zero addresses only to limited broadcast;
1582 * I even do not know to fix it or not. Waiting for complains :-)
1583 */
Joe Perchesf97c1e02007-12-16 13:45:43 -08001584 if (ipv4_is_zeronet(saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 goto martian_source;
1586
Thomas Grafd0daebc32012-06-12 00:44:01 +00001587 if (ipv4_is_zeronet(daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 goto martian_destination;
1589
Thomas Grafd0daebc32012-06-12 00:44:01 +00001590 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev))) {
1591 if (ipv4_is_loopback(daddr))
1592 goto martian_destination;
1593
1594 if (ipv4_is_loopback(saddr))
1595 goto martian_source;
1596 }
1597
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 /*
1599 * Now we are ready to route packet.
1600 */
David S. Miller68a5e3d2011-03-11 20:07:33 -05001601 fl4.flowi4_oif = 0;
1602 fl4.flowi4_iif = dev->ifindex;
1603 fl4.flowi4_mark = skb->mark;
1604 fl4.flowi4_tos = tos;
1605 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
1606 fl4.daddr = daddr;
1607 fl4.saddr = saddr;
1608 err = fib_lookup(net, &fl4, &res);
David S. Miller251da412012-06-26 16:27:09 -07001609 if (err != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 goto no_route;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611
1612 RT_CACHE_STAT_INC(in_slow_tot);
1613
1614 if (res.type == RTN_BROADCAST)
1615 goto brd_input;
1616
1617 if (res.type == RTN_LOCAL) {
Michael Smith5c04c812011-04-07 04:51:50 +00001618 err = fib_validate_source(skb, saddr, daddr, tos,
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001619 net->loopback_dev->ifindex,
David S. Miller9e56e382012-06-28 18:54:02 -07001620 dev, in_dev, &itag);
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001621 if (err < 0)
1622 goto martian_source_keep_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 goto local_input;
1624 }
1625
1626 if (!IN_DEV_FORWARD(in_dev))
David S. Miller251da412012-06-26 16:27:09 -07001627 goto no_route;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 if (res.type != RTN_UNICAST)
1629 goto martian_destination;
1630
David S. Miller68a5e3d2011-03-11 20:07:33 -05001631 err = ip_mkroute_input(skb, &res, &fl4, in_dev, daddr, saddr, tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632out: return err;
1633
1634brd_input:
1635 if (skb->protocol != htons(ETH_P_IP))
1636 goto e_inval;
1637
David S. Miller41347dc2012-06-28 04:05:27 -07001638 if (!ipv4_is_zeronet(saddr)) {
David S. Miller9e56e382012-06-28 18:54:02 -07001639 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1640 in_dev, &itag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 if (err < 0)
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001642 goto martian_source_keep_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 }
1644 flags |= RTCF_BROADCAST;
1645 res.type = RTN_BROADCAST;
1646 RT_CACHE_STAT_INC(in_brd);
1647
1648local_input:
David S. Millerd2d68ba2012-07-17 12:58:50 -07001649 do_cache = false;
1650 if (res.fi) {
David S. Millerfe3edf42012-07-23 13:22:20 -07001651 if (!itag) {
Eric Dumazet54764bb2012-07-31 01:08:23 +00001652 rth = rcu_dereference(FIB_RES_NH(res).nh_rth_input);
David S. Millerd2d68ba2012-07-17 12:58:50 -07001653 if (rt_cache_valid(rth)) {
David S. Millerc6cffba2012-07-26 11:14:38 +00001654 skb_dst_set_noref(skb, &rth->dst);
1655 err = 0;
1656 goto out;
David S. Millerd2d68ba2012-07-17 12:58:50 -07001657 }
1658 do_cache = true;
1659 }
1660 }
1661
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001662 rth = rt_dst_alloc(net->loopback_dev,
David S. Millerd2d68ba2012-07-17 12:58:50 -07001663 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 if (!rth)
1665 goto e_nobufs;
1666
David S. Millercf911662011-04-28 14:31:47 -07001667 rth->dst.input= ip_local_deliver;
Changli Gaod8d1f302010-06-10 23:31:35 -07001668 rth->dst.output= ip_rt_bug;
David S. Millercf911662011-04-28 14:31:47 -07001669#ifdef CONFIG_IP_ROUTE_CLASSID
1670 rth->dst.tclassid = itag;
1671#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672
David S. Millercf911662011-04-28 14:31:47 -07001673 rth->rt_genid = rt_genid(net);
1674 rth->rt_flags = flags|RTCF_LOCAL;
1675 rth->rt_type = res.type;
David S. Miller9917e1e82012-07-17 14:44:26 -07001676 rth->rt_is_input = 1;
David S. Miller13378ca2012-07-23 13:57:45 -07001677 rth->rt_iif = 0;
David S. Miller59436342012-07-10 06:58:42 -07001678 rth->rt_pmtu = 0;
David S. Millerf8126f12012-07-13 05:03:45 -07001679 rth->rt_gateway = 0;
David S. Millercaacf052012-07-31 15:06:50 -07001680 INIT_LIST_HEAD(&rth->rt_uncached);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 if (res.type == RTN_UNREACHABLE) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001682 rth->dst.input= ip_error;
1683 rth->dst.error= -err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 rth->rt_flags &= ~RTCF_LOCAL;
1685 }
David S. Millerd2d68ba2012-07-17 12:58:50 -07001686 if (do_cache)
1687 rt_cache_route(&FIB_RES_NH(res), rth);
David S. Miller89aef892012-07-17 11:00:09 -07001688 skb_dst_set(skb, &rth->dst);
David S. Millerb23dd4f2011-03-02 14:31:35 -08001689 err = 0;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001690 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691
1692no_route:
1693 RT_CACHE_STAT_INC(in_no_route);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 res.type = RTN_UNREACHABLE;
Mitsuru Chinen7f538782007-12-07 01:07:24 -08001695 if (err == -ESRCH)
1696 err = -ENETUNREACH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 goto local_input;
1698
1699 /*
1700 * Do not cache martian addresses: they should be logged (RFC1812)
1701 */
1702martian_destination:
1703 RT_CACHE_STAT_INC(in_martian_dst);
1704#ifdef CONFIG_IP_ROUTE_VERBOSE
Joe Perchese87cc472012-05-13 21:56:26 +00001705 if (IN_DEV_LOG_MARTIANS(in_dev))
1706 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
1707 &daddr, &saddr, dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708#endif
Dietmar Eggemann2c2910a2005-06-28 13:06:23 -07001709
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710e_inval:
1711 err = -EINVAL;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001712 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713
1714e_nobufs:
1715 err = -ENOBUFS;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001716 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717
1718martian_source:
Eric Dumazetb5f7e752010-06-02 12:05:27 +00001719 err = -EINVAL;
1720martian_source_keep_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001722 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723}
1724
David S. Millerc6cffba2012-07-26 11:14:38 +00001725int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1726 u8 tos, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727{
Eric Dumazet96d36222010-06-02 19:21:31 +00001728 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729
Eric Dumazet96d36222010-06-02 19:21:31 +00001730 rcu_read_lock();
1731
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 /* Multicast recognition logic is moved from route cache to here.
1733 The problem was that too many Ethernet cards have broken/missing
1734 hardware multicast filters :-( As result the host on multicasting
1735 network acquires a lot of useless route cache entries, sort of
1736 SDR messages from all the world. Now we try to get rid of them.
1737 Really, provided software IP multicast filter is organized
1738 reasonably (at least, hashed), it does not result in a slowdown
1739 comparing with route cache reject entries.
1740 Note, that multicast routers are not affected, because
1741 route cache entry is created eventually.
1742 */
Joe Perchesf97c1e02007-12-16 13:45:43 -08001743 if (ipv4_is_multicast(daddr)) {
Eric Dumazet96d36222010-06-02 19:21:31 +00001744 struct in_device *in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745
Eric Dumazet96d36222010-06-02 19:21:31 +00001746 if (in_dev) {
David S. Millerdbdd9a52011-03-10 16:34:38 -08001747 int our = ip_check_mc_rcu(in_dev, daddr, saddr,
1748 ip_hdr(skb)->protocol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 if (our
1750#ifdef CONFIG_IP_MROUTE
Joe Perches9d4fb272009-11-23 10:41:23 -08001751 ||
1752 (!ipv4_is_local_multicast(daddr) &&
1753 IN_DEV_MFORWARD(in_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754#endif
Joe Perches9d4fb272009-11-23 10:41:23 -08001755 ) {
Eric Dumazet96d36222010-06-02 19:21:31 +00001756 int res = ip_route_input_mc(skb, daddr, saddr,
1757 tos, dev, our);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 rcu_read_unlock();
Eric Dumazet96d36222010-06-02 19:21:31 +00001759 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 }
1761 }
1762 rcu_read_unlock();
1763 return -EINVAL;
1764 }
David S. Millerc10237e2012-06-27 17:05:06 -07001765 res = ip_route_input_slow(skb, daddr, saddr, tos, dev);
Eric Dumazet96d36222010-06-02 19:21:31 +00001766 rcu_read_unlock();
1767 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768}
David S. Millerc6cffba2012-07-26 11:14:38 +00001769EXPORT_SYMBOL(ip_route_input_noref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770
Eric Dumazetebc0ffa2010-10-05 10:41:36 +00001771/* called with rcu_read_lock() */
David S. Miller982721f2011-02-16 21:44:24 -08001772static struct rtable *__mkroute_output(const struct fib_result *res,
David Miller1a00fee2012-07-01 02:02:56 +00001773 const struct flowi4 *fl4, int orig_oif,
Julian Anastasovf61759e2011-12-02 11:39:42 +00001774 struct net_device *dev_out,
David S. Miller5ada5522011-02-17 15:29:00 -08001775 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776{
David S. Miller982721f2011-02-16 21:44:24 -08001777 struct fib_info *fi = res->fi;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001778 struct fib_nh_exception *fnhe;
David S. Miller5ada5522011-02-17 15:29:00 -08001779 struct in_device *in_dev;
David S. Miller982721f2011-02-16 21:44:24 -08001780 u16 type = res->type;
David S. Miller5ada5522011-02-17 15:29:00 -08001781 struct rtable *rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782
Thomas Grafd0daebc32012-06-12 00:44:01 +00001783 in_dev = __in_dev_get_rcu(dev_out);
1784 if (!in_dev)
David S. Miller5ada5522011-02-17 15:29:00 -08001785 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786
Thomas Grafd0daebc32012-06-12 00:44:01 +00001787 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1788 if (ipv4_is_loopback(fl4->saddr) && !(dev_out->flags & IFF_LOOPBACK))
1789 return ERR_PTR(-EINVAL);
1790
David S. Miller68a5e3d2011-03-11 20:07:33 -05001791 if (ipv4_is_lbcast(fl4->daddr))
David S. Miller982721f2011-02-16 21:44:24 -08001792 type = RTN_BROADCAST;
David S. Miller68a5e3d2011-03-11 20:07:33 -05001793 else if (ipv4_is_multicast(fl4->daddr))
David S. Miller982721f2011-02-16 21:44:24 -08001794 type = RTN_MULTICAST;
David S. Miller68a5e3d2011-03-11 20:07:33 -05001795 else if (ipv4_is_zeronet(fl4->daddr))
David S. Miller5ada5522011-02-17 15:29:00 -08001796 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797
1798 if (dev_out->flags & IFF_LOOPBACK)
1799 flags |= RTCF_LOCAL;
1800
David S. Miller982721f2011-02-16 21:44:24 -08001801 if (type == RTN_BROADCAST) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 flags |= RTCF_BROADCAST | RTCF_LOCAL;
David S. Miller982721f2011-02-16 21:44:24 -08001803 fi = NULL;
1804 } else if (type == RTN_MULTICAST) {
Eric Dumazetdd28d1a2010-09-29 11:53:50 +00001805 flags |= RTCF_MULTICAST | RTCF_LOCAL;
David S. Miller813b3b52011-04-28 14:48:42 -07001806 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
1807 fl4->flowi4_proto))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 flags &= ~RTCF_LOCAL;
1809 /* If multicast route do not exist use
Eric Dumazetdd28d1a2010-09-29 11:53:50 +00001810 * default one, but do not gateway in this case.
1811 * Yes, it is hack.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 */
David S. Miller982721f2011-02-16 21:44:24 -08001813 if (fi && res->prefixlen < 4)
1814 fi = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 }
1816
David S. Millerf2bb4be2012-07-17 12:20:47 -07001817 fnhe = NULL;
1818 if (fi) {
David S. Millerc5038a82012-07-31 15:02:02 -07001819 struct rtable __rcu **prth;
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001820
David S. Millerc5038a82012-07-31 15:02:02 -07001821 fnhe = find_exception(&FIB_RES_NH(*res), fl4->daddr);
1822 if (fnhe)
1823 prth = &fnhe->fnhe_rth;
1824 else
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001825 prth = __this_cpu_ptr(FIB_RES_NH(*res).nh_pcpu_rth_output);
David S. Millerc5038a82012-07-31 15:02:02 -07001826 rth = rcu_dereference(*prth);
1827 if (rt_cache_valid(rth)) {
1828 dst_hold(&rth->dst);
1829 return rth;
David S. Millerf2bb4be2012-07-17 12:20:47 -07001830 }
1831 }
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001832 rth = rt_dst_alloc(dev_out,
1833 IN_DEV_CONF_GET(in_dev, NOPOLICY),
David S. Millerf2bb4be2012-07-17 12:20:47 -07001834 IN_DEV_CONF_GET(in_dev, NOXFRM),
David S. Millerc5038a82012-07-31 15:02:02 -07001835 fi);
Dimitris Michailidis8391d072010-10-07 14:48:38 +00001836 if (!rth)
David S. Miller5ada5522011-02-17 15:29:00 -08001837 return ERR_PTR(-ENOBUFS);
Dimitris Michailidis8391d072010-10-07 14:48:38 +00001838
David S. Millercf911662011-04-28 14:31:47 -07001839 rth->dst.output = ip_output;
1840
David S. Millercf911662011-04-28 14:31:47 -07001841 rth->rt_genid = rt_genid(dev_net(dev_out));
1842 rth->rt_flags = flags;
1843 rth->rt_type = type;
David S. Miller9917e1e82012-07-17 14:44:26 -07001844 rth->rt_is_input = 0;
David S. Miller13378ca2012-07-23 13:57:45 -07001845 rth->rt_iif = orig_oif ? : 0;
David S. Miller59436342012-07-10 06:58:42 -07001846 rth->rt_pmtu = 0;
David S. Millerf8126f12012-07-13 05:03:45 -07001847 rth->rt_gateway = 0;
David S. Millercaacf052012-07-31 15:06:50 -07001848 INIT_LIST_HEAD(&rth->rt_uncached);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849
1850 RT_CACHE_STAT_INC(out_slow_tot);
1851
David S. Miller41347dc2012-06-28 04:05:27 -07001852 if (flags & RTCF_LOCAL)
Changli Gaod8d1f302010-06-10 23:31:35 -07001853 rth->dst.input = ip_local_deliver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001855 if (flags & RTCF_LOCAL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 !(dev_out->flags & IFF_LOOPBACK)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001857 rth->dst.output = ip_mc_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858 RT_CACHE_STAT_INC(out_slow_mc);
1859 }
1860#ifdef CONFIG_IP_MROUTE
David S. Miller982721f2011-02-16 21:44:24 -08001861 if (type == RTN_MULTICAST) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 if (IN_DEV_MFORWARD(in_dev) &&
David S. Miller813b3b52011-04-28 14:48:42 -07001863 !ipv4_is_local_multicast(fl4->daddr)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001864 rth->dst.input = ip_mr_input;
1865 rth->dst.output = ip_mc_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 }
1867 }
1868#endif
1869 }
1870
David S. Millerf2bb4be2012-07-17 12:20:47 -07001871 rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872
David S. Miller5ada5522011-02-17 15:29:00 -08001873 return rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874}
1875
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876/*
1877 * Major route resolver routine.
1878 */
1879
David S. Miller89aef892012-07-17 11:00:09 -07001880struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *fl4)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 struct net_device *dev_out = NULL;
Julian Anastasovf61759e2011-12-02 11:39:42 +00001883 __u8 tos = RT_FL_TOS(fl4);
David S. Miller813b3b52011-04-28 14:48:42 -07001884 unsigned int flags = 0;
1885 struct fib_result res;
David S. Miller5ada5522011-02-17 15:29:00 -08001886 struct rtable *rth;
David S. Miller813b3b52011-04-28 14:48:42 -07001887 int orig_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888
David S. Miller85b91b02012-07-13 08:21:29 -07001889 res.tclassid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 res.fi = NULL;
David S. Miller8b96d222012-06-11 02:01:56 -07001891 res.table = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892
David S. Miller813b3b52011-04-28 14:48:42 -07001893 orig_oif = fl4->flowi4_oif;
1894
1895 fl4->flowi4_iif = net->loopback_dev->ifindex;
1896 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
1897 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
1898 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
David S. Miller44713b62011-03-04 21:24:47 -08001899
David S. Miller010c2702011-02-17 15:37:09 -08001900 rcu_read_lock();
David S. Miller813b3b52011-04-28 14:48:42 -07001901 if (fl4->saddr) {
David S. Millerb23dd4f2011-03-02 14:31:35 -08001902 rth = ERR_PTR(-EINVAL);
David S. Miller813b3b52011-04-28 14:48:42 -07001903 if (ipv4_is_multicast(fl4->saddr) ||
1904 ipv4_is_lbcast(fl4->saddr) ||
1905 ipv4_is_zeronet(fl4->saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 goto out;
1907
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 /* I removed check for oif == dev_out->oif here.
1909 It was wrong for two reasons:
Denis V. Lunev1ab35272008-01-22 22:04:30 -08001910 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
1911 is assigned to multiple interfaces.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 2. Moreover, we are allowed to send packets with saddr
1913 of another iface. --ANK
1914 */
1915
David S. Miller813b3b52011-04-28 14:48:42 -07001916 if (fl4->flowi4_oif == 0 &&
1917 (ipv4_is_multicast(fl4->daddr) ||
1918 ipv4_is_lbcast(fl4->daddr))) {
Julian Anastasova210d012008-10-01 07:28:28 -07001919 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
David S. Miller813b3b52011-04-28 14:48:42 -07001920 dev_out = __ip_dev_find(net, fl4->saddr, false);
Julian Anastasova210d012008-10-01 07:28:28 -07001921 if (dev_out == NULL)
1922 goto out;
1923
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 /* Special hack: user can direct multicasts
1925 and limited broadcast via necessary interface
1926 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
1927 This hack is not just for fun, it allows
1928 vic,vat and friends to work.
1929 They bind socket to loopback, set ttl to zero
1930 and expect that it will work.
1931 From the viewpoint of routing cache they are broken,
1932 because we are not allowed to build multicast path
1933 with loopback source addr (look, routing cache
1934 cannot know, that ttl is zero, so that packet
1935 will not leave this host and route is valid).
1936 Luckily, this hack is good workaround.
1937 */
1938
David S. Miller813b3b52011-04-28 14:48:42 -07001939 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 goto make_route;
1941 }
Julian Anastasova210d012008-10-01 07:28:28 -07001942
David S. Miller813b3b52011-04-28 14:48:42 -07001943 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
Julian Anastasova210d012008-10-01 07:28:28 -07001944 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
David S. Miller813b3b52011-04-28 14:48:42 -07001945 if (!__ip_dev_find(net, fl4->saddr, false))
Julian Anastasova210d012008-10-01 07:28:28 -07001946 goto out;
Julian Anastasova210d012008-10-01 07:28:28 -07001947 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 }
1949
1950
David S. Miller813b3b52011-04-28 14:48:42 -07001951 if (fl4->flowi4_oif) {
1952 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
David S. Millerb23dd4f2011-03-02 14:31:35 -08001953 rth = ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 if (dev_out == NULL)
1955 goto out;
Herbert Xue5ed6392005-10-03 14:35:55 -07001956
1957 /* RACE: Check return value of inet_select_addr instead. */
Eric Dumazetfc75fc82010-12-22 04:39:39 +00001958 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
David S. Millerb23dd4f2011-03-02 14:31:35 -08001959 rth = ERR_PTR(-ENETUNREACH);
Eric Dumazetfc75fc82010-12-22 04:39:39 +00001960 goto out;
1961 }
David S. Miller813b3b52011-04-28 14:48:42 -07001962 if (ipv4_is_local_multicast(fl4->daddr) ||
1963 ipv4_is_lbcast(fl4->daddr)) {
1964 if (!fl4->saddr)
1965 fl4->saddr = inet_select_addr(dev_out, 0,
1966 RT_SCOPE_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 goto make_route;
1968 }
David S. Miller813b3b52011-04-28 14:48:42 -07001969 if (fl4->saddr) {
1970 if (ipv4_is_multicast(fl4->daddr))
1971 fl4->saddr = inet_select_addr(dev_out, 0,
1972 fl4->flowi4_scope);
1973 else if (!fl4->daddr)
1974 fl4->saddr = inet_select_addr(dev_out, 0,
1975 RT_SCOPE_HOST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 }
1977 }
1978
David S. Miller813b3b52011-04-28 14:48:42 -07001979 if (!fl4->daddr) {
1980 fl4->daddr = fl4->saddr;
1981 if (!fl4->daddr)
1982 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
Denis V. Lunevb40afd02008-01-22 22:06:19 -08001983 dev_out = net->loopback_dev;
David S. Miller813b3b52011-04-28 14:48:42 -07001984 fl4->flowi4_oif = net->loopback_dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 res.type = RTN_LOCAL;
1986 flags |= RTCF_LOCAL;
1987 goto make_route;
1988 }
1989
David S. Miller813b3b52011-04-28 14:48:42 -07001990 if (fib_lookup(net, fl4, &res)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 res.fi = NULL;
David S. Miller8b96d222012-06-11 02:01:56 -07001992 res.table = NULL;
David S. Miller813b3b52011-04-28 14:48:42 -07001993 if (fl4->flowi4_oif) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 /* Apparently, routing tables are wrong. Assume,
1995 that the destination is on link.
1996
1997 WHY? DW.
1998 Because we are allowed to send to iface
1999 even if it has NO routes and NO assigned
2000 addresses. When oif is specified, routing
2001 tables are looked up with only one purpose:
2002 to catch if destination is gatewayed, rather than
2003 direct. Moreover, if MSG_DONTROUTE is set,
2004 we send packet, ignoring both routing tables
2005 and ifaddr state. --ANK
2006
2007
2008 We could make it even if oif is unknown,
2009 likely IPv6, but we do not.
2010 */
2011
David S. Miller813b3b52011-04-28 14:48:42 -07002012 if (fl4->saddr == 0)
2013 fl4->saddr = inet_select_addr(dev_out, 0,
2014 RT_SCOPE_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 res.type = RTN_UNICAST;
2016 goto make_route;
2017 }
David S. Millerb23dd4f2011-03-02 14:31:35 -08002018 rth = ERR_PTR(-ENETUNREACH);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 goto out;
2020 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021
2022 if (res.type == RTN_LOCAL) {
David S. Miller813b3b52011-04-28 14:48:42 -07002023 if (!fl4->saddr) {
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002024 if (res.fi->fib_prefsrc)
David S. Miller813b3b52011-04-28 14:48:42 -07002025 fl4->saddr = res.fi->fib_prefsrc;
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002026 else
David S. Miller813b3b52011-04-28 14:48:42 -07002027 fl4->saddr = fl4->daddr;
Joel Sing9fc3bbb2011-01-03 20:24:20 +00002028 }
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002029 dev_out = net->loopback_dev;
David S. Miller813b3b52011-04-28 14:48:42 -07002030 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 flags |= RTCF_LOCAL;
2032 goto make_route;
2033 }
2034
2035#ifdef CONFIG_IP_ROUTE_MULTIPATH
David S. Miller813b3b52011-04-28 14:48:42 -07002036 if (res.fi->fib_nhs > 1 && fl4->flowi4_oif == 0)
David S. Miller1b7fe5932011-03-10 17:01:16 -08002037 fib_select_multipath(&res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 else
2039#endif
David S. Miller21d8c492011-04-14 14:49:37 -07002040 if (!res.prefixlen &&
2041 res.table->tb_num_default > 1 &&
David S. Miller813b3b52011-04-28 14:48:42 -07002042 res.type == RTN_UNICAST && !fl4->flowi4_oif)
David S. Miller0c838ff2011-01-31 16:16:50 -08002043 fib_select_default(&res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044
David S. Miller813b3b52011-04-28 14:48:42 -07002045 if (!fl4->saddr)
2046 fl4->saddr = FIB_RES_PREFSRC(net, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 dev_out = FIB_RES_DEV(res);
David S. Miller813b3b52011-04-28 14:48:42 -07002049 fl4->flowi4_oif = dev_out->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050
2051
2052make_route:
David Miller1a00fee2012-07-01 02:02:56 +00002053 rth = __mkroute_output(&res, fl4, orig_oif, dev_out, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054
David S. Miller010c2702011-02-17 15:37:09 -08002055out:
2056 rcu_read_unlock();
David S. Millerb23dd4f2011-03-02 14:31:35 -08002057 return rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058}
Arnaldo Carvalho de Melod8c97a92005-08-09 20:12:12 -07002059EXPORT_SYMBOL_GPL(__ip_route_output_key);
2060
Jianzhao Wangae2688d2010-09-08 14:35:43 -07002061static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2062{
2063 return NULL;
2064}
2065
Steffen Klassertebb762f2011-11-23 02:12:51 +00002066static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
Roland Dreierec831ea2011-01-31 13:16:00 -08002067{
Steffen Klassert618f9bc2011-11-23 02:13:31 +00002068 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2069
2070 return mtu ? : dst->dev->mtu;
Roland Dreierec831ea2011-01-31 13:16:00 -08002071}
2072
David S. Miller6700c272012-07-17 03:29:28 -07002073static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2074 struct sk_buff *skb, u32 mtu)
David S. Miller14e50e52007-05-24 18:17:54 -07002075{
2076}
2077
David S. Miller6700c272012-07-17 03:29:28 -07002078static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2079 struct sk_buff *skb)
David S. Millerb587ee32012-07-12 00:39:24 -07002080{
2081}
2082
Held Bernhard0972ddb2011-04-24 22:07:32 +00002083static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2084 unsigned long old)
2085{
2086 return NULL;
2087}
2088
David S. Miller14e50e52007-05-24 18:17:54 -07002089static struct dst_ops ipv4_dst_blackhole_ops = {
2090 .family = AF_INET,
Harvey Harrison09640e62009-02-01 00:45:17 -08002091 .protocol = cpu_to_be16(ETH_P_IP),
Jianzhao Wangae2688d2010-09-08 14:35:43 -07002092 .check = ipv4_blackhole_dst_check,
Steffen Klassertebb762f2011-11-23 02:12:51 +00002093 .mtu = ipv4_blackhole_mtu,
Eric Dumazet214f45c2011-02-18 11:39:01 -08002094 .default_advmss = ipv4_default_advmss,
David S. Miller14e50e52007-05-24 18:17:54 -07002095 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
David S. Millerb587ee32012-07-12 00:39:24 -07002096 .redirect = ipv4_rt_blackhole_redirect,
Held Bernhard0972ddb2011-04-24 22:07:32 +00002097 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
David S. Millerd3aaeb32011-07-18 00:40:17 -07002098 .neigh_lookup = ipv4_neigh_lookup,
David S. Miller14e50e52007-05-24 18:17:54 -07002099};
2100
David S. Miller2774c132011-03-01 14:59:04 -08002101struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
David S. Miller14e50e52007-05-24 18:17:54 -07002102{
David S. Miller2774c132011-03-01 14:59:04 -08002103 struct rtable *ort = (struct rtable *) dst_orig;
David S. Millerf5b0a872012-07-19 12:31:33 -07002104 struct rtable *rt;
David S. Miller14e50e52007-05-24 18:17:54 -07002105
David S. Millerf5b0a872012-07-19 12:31:33 -07002106 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE, 0);
David S. Miller14e50e52007-05-24 18:17:54 -07002107 if (rt) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002108 struct dst_entry *new = &rt->dst;
David S. Miller14e50e52007-05-24 18:17:54 -07002109
David S. Miller14e50e52007-05-24 18:17:54 -07002110 new->__use = 1;
Herbert Xu352e5122007-11-13 21:34:06 -08002111 new->input = dst_discard;
2112 new->output = dst_discard;
David S. Miller14e50e52007-05-24 18:17:54 -07002113
Changli Gaod8d1f302010-06-10 23:31:35 -07002114 new->dev = ort->dst.dev;
David S. Miller14e50e52007-05-24 18:17:54 -07002115 if (new->dev)
2116 dev_hold(new->dev);
2117
David S. Miller9917e1e82012-07-17 14:44:26 -07002118 rt->rt_is_input = ort->rt_is_input;
David S. Miller5e2b61f2011-03-04 21:47:09 -08002119 rt->rt_iif = ort->rt_iif;
David S. Miller59436342012-07-10 06:58:42 -07002120 rt->rt_pmtu = ort->rt_pmtu;
David S. Miller14e50e52007-05-24 18:17:54 -07002121
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002122 rt->rt_genid = rt_genid(net);
David S. Miller14e50e52007-05-24 18:17:54 -07002123 rt->rt_flags = ort->rt_flags;
2124 rt->rt_type = ort->rt_type;
David S. Miller14e50e52007-05-24 18:17:54 -07002125 rt->rt_gateway = ort->rt_gateway;
David S. Miller14e50e52007-05-24 18:17:54 -07002126
David S. Millercaacf052012-07-31 15:06:50 -07002127 INIT_LIST_HEAD(&rt->rt_uncached);
2128
David S. Miller14e50e52007-05-24 18:17:54 -07002129 dst_free(new);
2130 }
2131
David S. Miller2774c132011-03-01 14:59:04 -08002132 dst_release(dst_orig);
2133
2134 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
David S. Miller14e50e52007-05-24 18:17:54 -07002135}
2136
David S. Miller9d6ec932011-03-12 01:12:47 -05002137struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
David S. Millerb23dd4f2011-03-02 14:31:35 -08002138 struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139{
David S. Miller9d6ec932011-03-12 01:12:47 -05002140 struct rtable *rt = __ip_route_output_key(net, flp4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141
David S. Millerb23dd4f2011-03-02 14:31:35 -08002142 if (IS_ERR(rt))
2143 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144
David S. Miller56157872011-05-02 14:37:45 -07002145 if (flp4->flowi4_proto)
David S. Miller9d6ec932011-03-12 01:12:47 -05002146 rt = (struct rtable *) xfrm_lookup(net, &rt->dst,
2147 flowi4_to_flowi(flp4),
2148 sk, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149
David S. Millerb23dd4f2011-03-02 14:31:35 -08002150 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151}
Arnaldo Carvalho de Melod8c97a92005-08-09 20:12:12 -07002152EXPORT_SYMBOL_GPL(ip_route_output_flow);
2153
David S. Millerf1ce3062012-07-12 10:10:17 -07002154static int rt_fill_info(struct net *net, __be32 dst, __be32 src,
2155 struct flowi4 *fl4, struct sk_buff *skb, u32 pid,
2156 u32 seq, int event, int nowait, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157{
Eric Dumazet511c3f92009-06-02 05:14:27 +00002158 struct rtable *rt = skb_rtable(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 struct rtmsg *r;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002160 struct nlmsghdr *nlh;
Steffen Klassert2bc8ca42011-10-11 01:12:02 +00002161 unsigned long expires = 0;
David S. Millerf1850712012-07-10 07:26:01 -07002162 u32 error;
Julian Anastasov521f5492012-07-20 12:02:08 +03002163 u32 metrics[RTAX_MAX];
Thomas Grafbe403ea2006-08-17 18:15:17 -07002164
2165 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*r), flags);
2166 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08002167 return -EMSGSIZE;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002168
2169 r = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170 r->rtm_family = AF_INET;
2171 r->rtm_dst_len = 32;
2172 r->rtm_src_len = 0;
David Millerd6c0a4f2012-07-01 02:02:59 +00002173 r->rtm_tos = fl4->flowi4_tos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 r->rtm_table = RT_TABLE_MAIN;
David S. Millerf3756b72012-04-01 20:39:02 -04002175 if (nla_put_u32(skb, RTA_TABLE, RT_TABLE_MAIN))
2176 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 r->rtm_type = rt->rt_type;
2178 r->rtm_scope = RT_SCOPE_UNIVERSE;
2179 r->rtm_protocol = RTPROT_UNSPEC;
2180 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2181 if (rt->rt_flags & RTCF_NOTIFY)
2182 r->rtm_flags |= RTM_F_NOTIFY;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002183
David S. Millerf1ce3062012-07-12 10:10:17 -07002184 if (nla_put_be32(skb, RTA_DST, dst))
David S. Millerf3756b72012-04-01 20:39:02 -04002185 goto nla_put_failure;
David Miller1a00fee2012-07-01 02:02:56 +00002186 if (src) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187 r->rtm_src_len = 32;
David Miller1a00fee2012-07-01 02:02:56 +00002188 if (nla_put_be32(skb, RTA_SRC, src))
David S. Millerf3756b72012-04-01 20:39:02 -04002189 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190 }
David S. Millerf3756b72012-04-01 20:39:02 -04002191 if (rt->dst.dev &&
2192 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2193 goto nla_put_failure;
Patrick McHardyc7066f72011-01-14 13:36:42 +01002194#ifdef CONFIG_IP_ROUTE_CLASSID
David S. Millerf3756b72012-04-01 20:39:02 -04002195 if (rt->dst.tclassid &&
2196 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2197 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198#endif
David S. Miller41347dc2012-06-28 04:05:27 -07002199 if (!rt_is_input_route(rt) &&
David Millerd6c0a4f2012-07-01 02:02:59 +00002200 fl4->saddr != src) {
2201 if (nla_put_be32(skb, RTA_PREFSRC, fl4->saddr))
David S. Millerf3756b72012-04-01 20:39:02 -04002202 goto nla_put_failure;
2203 }
David S. Millerf8126f12012-07-13 05:03:45 -07002204 if (rt->rt_gateway &&
David S. Millerf3756b72012-04-01 20:39:02 -04002205 nla_put_be32(skb, RTA_GATEWAY, rt->rt_gateway))
2206 goto nla_put_failure;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002207
Julian Anastasov521f5492012-07-20 12:02:08 +03002208 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
2209 if (rt->rt_pmtu)
2210 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2211 if (rtnetlink_put_metrics(skb, metrics) < 0)
Thomas Grafbe403ea2006-08-17 18:15:17 -07002212 goto nla_put_failure;
2213
David Millerb4869882012-07-01 02:03:01 +00002214 if (fl4->flowi4_mark &&
2215 nla_put_be32(skb, RTA_MARK, fl4->flowi4_mark))
David S. Millerf3756b72012-04-01 20:39:02 -04002216 goto nla_put_failure;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002217
Changli Gaod8d1f302010-06-10 23:31:35 -07002218 error = rt->dst.error;
David S. Miller59436342012-07-10 06:58:42 -07002219 expires = rt->dst.expires;
2220 if (expires) {
2221 if (time_before(jiffies, expires))
2222 expires -= jiffies;
2223 else
2224 expires = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 }
Thomas Grafbe403ea2006-08-17 18:15:17 -07002226
David S. Millerc7537962010-11-11 17:07:48 -08002227 if (rt_is_input_route(rt)) {
David S. Millerf1ce3062012-07-12 10:10:17 -07002228 if (nla_put_u32(skb, RTA_IIF, rt->rt_iif))
2229 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 }
2231
David S. Millerf1850712012-07-10 07:26:01 -07002232 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
Thomas Grafe3703b32006-11-27 09:27:07 -08002233 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234
Thomas Grafbe403ea2006-08-17 18:15:17 -07002235 return nlmsg_end(skb, nlh);
2236
2237nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002238 nlmsg_cancel(skb, nlh);
2239 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240}
2241
Daniel Baluta5e73ea12012-04-15 01:34:41 +00002242static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002244 struct net *net = sock_net(in_skb->sk);
Thomas Grafd889ce32006-08-17 18:15:44 -07002245 struct rtmsg *rtm;
2246 struct nlattr *tb[RTA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 struct rtable *rt = NULL;
David Millerd6c0a4f2012-07-01 02:02:59 +00002248 struct flowi4 fl4;
Al Viro9e12bb22006-09-26 21:25:20 -07002249 __be32 dst = 0;
2250 __be32 src = 0;
2251 u32 iif;
Thomas Grafd889ce32006-08-17 18:15:44 -07002252 int err;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002253 int mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 struct sk_buff *skb;
2255
Thomas Grafd889ce32006-08-17 18:15:44 -07002256 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2257 if (err < 0)
2258 goto errout;
2259
2260 rtm = nlmsg_data(nlh);
2261
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
Thomas Grafd889ce32006-08-17 18:15:44 -07002263 if (skb == NULL) {
2264 err = -ENOBUFS;
2265 goto errout;
2266 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267
2268 /* Reserve room for dummy headers, this skb can pass
2269 through good chunk of routing engine.
2270 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07002271 skb_reset_mac_header(skb);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07002272 skb_reset_network_header(skb);
Stephen Hemmingerd2c962b2006-04-17 17:27:11 -07002273
2274 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07002275 ip_hdr(skb)->protocol = IPPROTO_ICMP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2277
Al Viro17fb2c62006-09-26 22:15:25 -07002278 src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
2279 dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
Thomas Grafd889ce32006-08-17 18:15:44 -07002280 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002281 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282
David Millerd6c0a4f2012-07-01 02:02:59 +00002283 memset(&fl4, 0, sizeof(fl4));
2284 fl4.daddr = dst;
2285 fl4.saddr = src;
2286 fl4.flowi4_tos = rtm->rtm_tos;
2287 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2288 fl4.flowi4_mark = mark;
2289
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290 if (iif) {
Thomas Grafd889ce32006-08-17 18:15:44 -07002291 struct net_device *dev;
2292
Denis V. Lunev19375042008-02-28 20:52:04 -08002293 dev = __dev_get_by_index(net, iif);
Thomas Grafd889ce32006-08-17 18:15:44 -07002294 if (dev == NULL) {
2295 err = -ENODEV;
2296 goto errout_free;
2297 }
2298
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299 skb->protocol = htons(ETH_P_IP);
2300 skb->dev = dev;
Eric Dumazet963bfee2010-07-20 22:03:14 +00002301 skb->mark = mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 local_bh_disable();
2303 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2304 local_bh_enable();
Thomas Grafd889ce32006-08-17 18:15:44 -07002305
Eric Dumazet511c3f92009-06-02 05:14:27 +00002306 rt = skb_rtable(skb);
Changli Gaod8d1f302010-06-10 23:31:35 -07002307 if (err == 0 && rt->dst.error)
2308 err = -rt->dst.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 } else {
David S. Miller9d6ec932011-03-12 01:12:47 -05002310 rt = ip_route_output_key(net, &fl4);
David S. Millerb23dd4f2011-03-02 14:31:35 -08002311
2312 err = 0;
2313 if (IS_ERR(rt))
2314 err = PTR_ERR(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 }
Thomas Grafd889ce32006-08-17 18:15:44 -07002316
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317 if (err)
Thomas Grafd889ce32006-08-17 18:15:44 -07002318 goto errout_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319
Changli Gaod8d1f302010-06-10 23:31:35 -07002320 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321 if (rtm->rtm_flags & RTM_F_NOTIFY)
2322 rt->rt_flags |= RTCF_NOTIFY;
2323
David S. Millerf1ce3062012-07-12 10:10:17 -07002324 err = rt_fill_info(net, dst, src, &fl4, skb,
David Miller1a00fee2012-07-01 02:02:56 +00002325 NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
Denis V. Lunev19375042008-02-28 20:52:04 -08002326 RTM_NEWROUTE, 0, 0);
Thomas Grafd889ce32006-08-17 18:15:44 -07002327 if (err <= 0)
2328 goto errout_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329
Denis V. Lunev19375042008-02-28 20:52:04 -08002330 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
Thomas Grafd889ce32006-08-17 18:15:44 -07002331errout:
Thomas Graf2942e902006-08-15 00:30:25 -07002332 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333
Thomas Grafd889ce32006-08-17 18:15:44 -07002334errout_free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 kfree_skb(skb);
Thomas Grafd889ce32006-08-17 18:15:44 -07002336 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337}
2338
2339int ip_rt_dump(struct sk_buff *skb, struct netlink_callback *cb)
2340{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 return skb->len;
2342}
2343
2344void ip_rt_multicast_event(struct in_device *in_dev)
2345{
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07002346 rt_cache_flush(dev_net(in_dev->dev), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347}
2348
2349#ifdef CONFIG_SYSCTL
Denis V. Lunev81c684d2008-07-08 03:05:28 -07002350static int ipv4_sysctl_rtcache_flush(ctl_table *__ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002351 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352 size_t *lenp, loff_t *ppos)
2353{
2354 if (write) {
Denis V. Lunev639e1042008-07-05 19:02:06 -07002355 int flush_delay;
Denis V. Lunev81c684d2008-07-08 03:05:28 -07002356 ctl_table ctl;
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002357 struct net *net;
Denis V. Lunev639e1042008-07-05 19:02:06 -07002358
Denis V. Lunev81c684d2008-07-08 03:05:28 -07002359 memcpy(&ctl, __ctl, sizeof(ctl));
2360 ctl.data = &flush_delay;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002361 proc_dointvec(&ctl, write, buffer, lenp, ppos);
Denis V. Lunev639e1042008-07-05 19:02:06 -07002362
Denis V. Lunev81c684d2008-07-08 03:05:28 -07002363 net = (struct net *)__ctl->extra1;
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002364 rt_cache_flush(net, flush_delay);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365 return 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002366 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367
2368 return -EINVAL;
2369}
2370
Al Viroeeb61f72008-07-27 08:59:33 +01002371static ctl_table ipv4_route_table[] = {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002372 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373 .procname = "gc_thresh",
2374 .data = &ipv4_dst_ops.gc_thresh,
2375 .maxlen = sizeof(int),
2376 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002377 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378 },
2379 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 .procname = "max_size",
2381 .data = &ip_rt_max_size,
2382 .maxlen = sizeof(int),
2383 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002384 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385 },
2386 {
2387 /* Deprecated. Use gc_min_interval_ms */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002388
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389 .procname = "gc_min_interval",
2390 .data = &ip_rt_gc_min_interval,
2391 .maxlen = sizeof(int),
2392 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002393 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394 },
2395 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396 .procname = "gc_min_interval_ms",
2397 .data = &ip_rt_gc_min_interval,
2398 .maxlen = sizeof(int),
2399 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002400 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 },
2402 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 .procname = "gc_timeout",
2404 .data = &ip_rt_gc_timeout,
2405 .maxlen = sizeof(int),
2406 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002407 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408 },
2409 {
Eric Dumazet9f28a2f2011-12-21 15:47:16 -05002410 .procname = "gc_interval",
2411 .data = &ip_rt_gc_interval,
2412 .maxlen = sizeof(int),
2413 .mode = 0644,
2414 .proc_handler = proc_dointvec_jiffies,
2415 },
2416 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 .procname = "redirect_load",
2418 .data = &ip_rt_redirect_load,
2419 .maxlen = sizeof(int),
2420 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002421 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422 },
2423 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424 .procname = "redirect_number",
2425 .data = &ip_rt_redirect_number,
2426 .maxlen = sizeof(int),
2427 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002428 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 },
2430 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 .procname = "redirect_silence",
2432 .data = &ip_rt_redirect_silence,
2433 .maxlen = sizeof(int),
2434 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002435 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436 },
2437 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438 .procname = "error_cost",
2439 .data = &ip_rt_error_cost,
2440 .maxlen = sizeof(int),
2441 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002442 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443 },
2444 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 .procname = "error_burst",
2446 .data = &ip_rt_error_burst,
2447 .maxlen = sizeof(int),
2448 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002449 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450 },
2451 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452 .procname = "gc_elasticity",
2453 .data = &ip_rt_gc_elasticity,
2454 .maxlen = sizeof(int),
2455 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002456 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002457 },
2458 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459 .procname = "mtu_expires",
2460 .data = &ip_rt_mtu_expires,
2461 .maxlen = sizeof(int),
2462 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002463 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464 },
2465 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 .procname = "min_pmtu",
2467 .data = &ip_rt_min_pmtu,
2468 .maxlen = sizeof(int),
2469 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002470 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 },
2472 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473 .procname = "min_adv_mss",
2474 .data = &ip_rt_min_advmss,
2475 .maxlen = sizeof(int),
2476 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002477 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002479 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480};
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002481
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002482static struct ctl_table ipv4_route_flush_table[] = {
2483 {
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002484 .procname = "flush",
2485 .maxlen = sizeof(int),
2486 .mode = 0200,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002487 .proc_handler = ipv4_sysctl_rtcache_flush,
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002488 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002489 { },
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002490};
2491
2492static __net_init int sysctl_route_net_init(struct net *net)
2493{
2494 struct ctl_table *tbl;
2495
2496 tbl = ipv4_route_flush_table;
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08002497 if (!net_eq(net, &init_net)) {
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002498 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
2499 if (tbl == NULL)
2500 goto err_dup;
2501 }
2502 tbl[0].extra1 = net;
2503
Eric W. Biedermanec8f23c2012-04-19 13:44:49 +00002504 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002505 if (net->ipv4.route_hdr == NULL)
2506 goto err_reg;
2507 return 0;
2508
2509err_reg:
2510 if (tbl != ipv4_route_flush_table)
2511 kfree(tbl);
2512err_dup:
2513 return -ENOMEM;
2514}
2515
2516static __net_exit void sysctl_route_net_exit(struct net *net)
2517{
2518 struct ctl_table *tbl;
2519
2520 tbl = net->ipv4.route_hdr->ctl_table_arg;
2521 unregister_net_sysctl_table(net->ipv4.route_hdr);
2522 BUG_ON(tbl == ipv4_route_flush_table);
2523 kfree(tbl);
2524}
2525
2526static __net_initdata struct pernet_operations sysctl_route_ops = {
2527 .init = sysctl_route_net_init,
2528 .exit = sysctl_route_net_exit,
2529};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002530#endif
2531
Neil Horman3ee94372010-05-08 01:57:52 -07002532static __net_init int rt_genid_init(struct net *net)
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002533{
Neil Horman3ee94372010-05-08 01:57:52 -07002534 get_random_bytes(&net->ipv4.rt_genid,
2535 sizeof(net->ipv4.rt_genid));
David S. Miller436c3b62011-03-24 17:42:21 -07002536 get_random_bytes(&net->ipv4.dev_addr_genid,
2537 sizeof(net->ipv4.dev_addr_genid));
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002538 return 0;
2539}
2540
Neil Horman3ee94372010-05-08 01:57:52 -07002541static __net_initdata struct pernet_operations rt_genid_ops = {
2542 .init = rt_genid_init,
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002543};
2544
David S. Millerc3426b42012-06-09 16:27:05 -07002545static int __net_init ipv4_inetpeer_init(struct net *net)
2546{
2547 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2548
2549 if (!bp)
2550 return -ENOMEM;
2551 inet_peer_base_init(bp);
2552 net->ipv4.peers = bp;
2553 return 0;
2554}
2555
2556static void __net_exit ipv4_inetpeer_exit(struct net *net)
2557{
2558 struct inet_peer_base *bp = net->ipv4.peers;
2559
2560 net->ipv4.peers = NULL;
David S. Miller56a6b242012-06-09 16:32:41 -07002561 inetpeer_invalidate_tree(bp);
David S. Millerc3426b42012-06-09 16:27:05 -07002562 kfree(bp);
2563}
2564
2565static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
2566 .init = ipv4_inetpeer_init,
2567 .exit = ipv4_inetpeer_exit,
2568};
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07002569
Patrick McHardyc7066f72011-01-14 13:36:42 +01002570#ifdef CONFIG_IP_ROUTE_CLASSID
Tejun Heo7d720c32010-02-16 15:20:26 +00002571struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
Patrick McHardyc7066f72011-01-14 13:36:42 +01002572#endif /* CONFIG_IP_ROUTE_CLASSID */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574int __init ip_rt_init(void)
2575{
Eric Dumazet424c4b72005-07-05 14:58:19 -07002576 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577
Patrick McHardyc7066f72011-01-14 13:36:42 +01002578#ifdef CONFIG_IP_ROUTE_CLASSID
Ingo Molnar0dcec8c2009-02-25 14:07:33 +01002579 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 if (!ip_rt_acct)
2581 panic("IP: failed to allocate ip_rt_acct\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582#endif
2583
Alexey Dobriyane5d679f332006-08-26 19:25:52 -07002584 ipv4_dst_ops.kmem_cachep =
2585 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09002586 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002587
David S. Miller14e50e52007-05-24 18:17:54 -07002588 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
2589
Eric Dumazetfc66f952010-10-08 06:37:34 +00002590 if (dst_entries_init(&ipv4_dst_ops) < 0)
2591 panic("IP: failed to allocate ipv4_dst_ops counter\n");
2592
2593 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
2594 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
2595
David S. Miller89aef892012-07-17 11:00:09 -07002596 ipv4_dst_ops.gc_thresh = ~0;
2597 ip_rt_max_size = INT_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599 devinet_init();
2600 ip_fib_init();
2601
Denis V. Lunev73b38712008-02-28 20:51:18 -08002602 if (ip_rt_proc_init())
Joe Perches058bd4d2012-03-11 18:36:11 +00002603 pr_err("Unable to create route proc files\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604#ifdef CONFIG_XFRM
2605 xfrm_init();
Neil Hormana33bc5c2009-07-30 18:52:15 -07002606 xfrm4_init(ip_rt_max_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607#endif
Greg Rosec7ac8672011-06-10 01:27:09 +00002608 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL, NULL);
Thomas Graf63f34442007-03-22 11:55:17 -07002609
Denis V. Lunev39a23e72008-07-05 19:02:33 -07002610#ifdef CONFIG_SYSCTL
2611 register_pernet_subsys(&sysctl_route_ops);
2612#endif
Neil Horman3ee94372010-05-08 01:57:52 -07002613 register_pernet_subsys(&rt_genid_ops);
David S. Millerc3426b42012-06-09 16:27:05 -07002614 register_pernet_subsys(&ipv4_inetpeer_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615 return rc;
2616}
2617
Al Viroa1bc6eb2008-07-30 06:32:52 -04002618#ifdef CONFIG_SYSCTL
Al Viroeeb61f72008-07-27 08:59:33 +01002619/*
2620 * We really need to sanitize the damn ipv4 init order, then all
2621 * this nonsense will go away.
2622 */
2623void __init ip_static_sysctl_init(void)
2624{
Eric W. Biederman4e5ca782012-04-19 13:32:39 +00002625 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);
Al Viroeeb61f72008-07-27 08:59:33 +01002626}
Al Viroa1bc6eb2008-07-30 06:32:52 -04002627#endif