]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - net/ipv4/route.c
lib: fix spelling mistake: "actualy" -> "actually"
[mirror_ubuntu-artful-kernel.git] / net / ipv4 / route.c
CommitLineData
1da177e4
LT
1/*
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 *
02c30a84 8 * Authors: Ross Biro
1da177e4
LT
9 * 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
e905a9ed 21 * Alan Cox : Super /proc >4K
1da177e4
LT
22 * 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.
e905a9ed 39 *
1da177e4
LT
40 * 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
bb1d23b0 55 * Eric Dumazet : hashed spinlocks and rt_check_expire() fixes.
cef2685e
IS
56 * Ilia Sotnikov : Ignore TOS on PMTUD and Redirect
57 * Ilia Sotnikov : Removed TOS from hash calculations
1da177e4
LT
58 *
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
afd46503
JP
65#define pr_fmt(fmt) "IPv4: " fmt
66
1da177e4 67#include <linux/module.h>
7c0f6ba6 68#include <linux/uaccess.h>
1da177e4
LT
69#include <linux/bitops.h>
70#include <linux/types.h>
71#include <linux/kernel.h>
1da177e4
LT
72#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>
1da177e4
LT
83#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>
1da177e4
LT
89#include <linux/rcupdate.h>
90#include <linux/times.h>
5a0e3ad6 91#include <linux/slab.h>
73f156a6 92#include <linux/jhash.h>
352e512c 93#include <net/dst.h>
1b7179d3 94#include <net/dst_metadata.h>
457c4cbc 95#include <net/net_namespace.h>
1da177e4
LT
96#include <net/protocol.h>
97#include <net/ip.h>
98#include <net/route.h>
99#include <net/inetpeer.h>
100#include <net/sock.h>
101#include <net/ip_fib.h>
102#include <net/arp.h>
103#include <net/tcp.h>
104#include <net/icmp.h>
105#include <net/xfrm.h>
571e7226 106#include <net/lwtunnel.h>
8d71740c 107#include <net/netevent.h>
63f3444f 108#include <net/rtnetlink.h>
1da177e4
LT
109#ifdef CONFIG_SYSCTL
110#include <linux/sysctl.h>
7426a564 111#include <linux/kmemleak.h>
1da177e4 112#endif
6e5714ea 113#include <net/secure_seq.h>
1b7179d3 114#include <net/ip_tunnels.h>
385add90 115#include <net/l3mdev.h>
1da177e4 116
68a5e3dd 117#define RT_FL_TOS(oldflp4) \
f61759e6 118 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
1da177e4 119
1da177e4
LT
120#define RT_GC_TIMEOUT (300*HZ)
121
1da177e4 122static int ip_rt_max_size;
817bc4db
SH
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;
817bc4db
SH
128static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
129static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
130static int ip_rt_min_advmss __read_mostly = 256;
9f28a2fc 131
deed49df 132static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
1da177e4
LT
133/*
134 * Interface to generic destination cache.
135 */
136
137static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
0dbaee3b 138static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
ebb762f2 139static unsigned int ipv4_mtu(const struct dst_entry *dst);
1da177e4
LT
140static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
141static void ipv4_link_failure(struct sk_buff *skb);
6700c270
DM
142static 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);
caacf05e 146static void ipv4_dst_destroy(struct dst_entry *dst);
1da177e4 147
62fa8a84
DM
148static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
149{
31248731
DM
150 WARN_ON(1);
151 return NULL;
62fa8a84
DM
152}
153
f894cbf8
DM
154static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
155 struct sk_buff *skb,
156 const void *daddr);
63fca65d 157static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr);
d3aaeb38 158
1da177e4
LT
159static struct dst_ops ipv4_dst_ops = {
160 .family = AF_INET,
1da177e4 161 .check = ipv4_dst_check,
0dbaee3b 162 .default_advmss = ipv4_default_advmss,
ebb762f2 163 .mtu = ipv4_mtu,
62fa8a84 164 .cow_metrics = ipv4_cow_metrics,
caacf05e 165 .destroy = ipv4_dst_destroy,
1da177e4
LT
166 .negative_advice = ipv4_negative_advice,
167 .link_failure = ipv4_link_failure,
168 .update_pmtu = ip_rt_update_pmtu,
e47a185b 169 .redirect = ip_do_redirect,
b92dacd4 170 .local_out = __ip_local_out,
d3aaeb38 171 .neigh_lookup = ipv4_neigh_lookup,
63fca65d 172 .confirm_neigh = ipv4_confirm_neigh,
1da177e4
LT
173};
174
175#define ECN_OR_COST(class) TC_PRIO_##class
176
4839c52b 177const __u8 ip_tos2prio[16] = {
1da177e4 178 TC_PRIO_BESTEFFORT,
4a2b9c37 179 ECN_OR_COST(BESTEFFORT),
1da177e4
LT
180 TC_PRIO_BESTEFFORT,
181 ECN_OR_COST(BESTEFFORT),
182 TC_PRIO_BULK,
183 ECN_OR_COST(BULK),
184 TC_PRIO_BULK,
185 ECN_OR_COST(BULK),
186 TC_PRIO_INTERACTIVE,
187 ECN_OR_COST(INTERACTIVE),
188 TC_PRIO_INTERACTIVE,
189 ECN_OR_COST(INTERACTIVE),
190 TC_PRIO_INTERACTIVE_BULK,
191 ECN_OR_COST(INTERACTIVE_BULK),
192 TC_PRIO_INTERACTIVE_BULK,
193 ECN_OR_COST(INTERACTIVE_BULK)
194};
d4a96865 195EXPORT_SYMBOL(ip_tos2prio);
1da177e4 196
2f970d83 197static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
3ed66e91 198#define RT_CACHE_STAT_INC(field) raw_cpu_inc(rt_cache_stat.field)
1da177e4 199
1da177e4 200#ifdef CONFIG_PROC_FS
1da177e4
LT
201static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
202{
29e75252 203 if (*pos)
89aef892 204 return NULL;
29e75252 205 return SEQ_START_TOKEN;
1da177e4
LT
206}
207
208static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
209{
1da177e4 210 ++*pos;
89aef892 211 return NULL;
1da177e4
LT
212}
213
214static void rt_cache_seq_stop(struct seq_file *seq, void *v)
215{
1da177e4
LT
216}
217
218static int rt_cache_seq_show(struct seq_file *seq, void *v)
219{
220 if (v == SEQ_START_TOKEN)
221 seq_printf(seq, "%-127s\n",
222 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
223 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
224 "HHUptod\tSpecDst");
e905a9ed 225 return 0;
1da177e4
LT
226}
227
f690808e 228static const struct seq_operations rt_cache_seq_ops = {
1da177e4
LT
229 .start = rt_cache_seq_start,
230 .next = rt_cache_seq_next,
231 .stop = rt_cache_seq_stop,
232 .show = rt_cache_seq_show,
233};
234
235static int rt_cache_seq_open(struct inode *inode, struct file *file)
236{
89aef892 237 return seq_open(file, &rt_cache_seq_ops);
1da177e4
LT
238}
239
9a32144e 240static const struct file_operations rt_cache_seq_fops = {
1da177e4
LT
241 .owner = THIS_MODULE,
242 .open = rt_cache_seq_open,
243 .read = seq_read,
244 .llseek = seq_lseek,
89aef892 245 .release = seq_release,
1da177e4
LT
246};
247
248
249static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
250{
251 int cpu;
252
253 if (*pos == 0)
254 return SEQ_START_TOKEN;
255
0f23174a 256 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
1da177e4
LT
257 if (!cpu_possible(cpu))
258 continue;
259 *pos = cpu+1;
2f970d83 260 return &per_cpu(rt_cache_stat, cpu);
1da177e4
LT
261 }
262 return NULL;
263}
264
265static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
266{
267 int cpu;
268
0f23174a 269 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
1da177e4
LT
270 if (!cpu_possible(cpu))
271 continue;
272 *pos = cpu+1;
2f970d83 273 return &per_cpu(rt_cache_stat, cpu);
1da177e4
LT
274 }
275 return NULL;
e905a9ed 276
1da177e4
LT
277}
278
279static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
280{
281
282}
283
284static int rt_cpu_seq_show(struct seq_file *seq, void *v)
285{
286 struct rt_cache_stat *st = v;
287
288 if (v == SEQ_START_TOKEN) {
5bec0039 289 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");
1da177e4
LT
290 return 0;
291 }
e905a9ed 292
1da177e4
LT
293 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
294 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
fc66f95c 295 dst_entries_get_slow(&ipv4_dst_ops),
0baf2b35 296 0, /* st->in_hit */
1da177e4
LT
297 st->in_slow_tot,
298 st->in_slow_mc,
299 st->in_no_route,
300 st->in_brd,
301 st->in_martian_dst,
302 st->in_martian_src,
303
0baf2b35 304 0, /* st->out_hit */
1da177e4 305 st->out_slow_tot,
e905a9ed 306 st->out_slow_mc,
1da177e4 307
0baf2b35
ED
308 0, /* st->gc_total */
309 0, /* st->gc_ignored */
310 0, /* st->gc_goal_miss */
311 0, /* st->gc_dst_overflow */
312 0, /* st->in_hlist_search */
313 0 /* st->out_hlist_search */
1da177e4
LT
314 );
315 return 0;
316}
317
f690808e 318static const struct seq_operations rt_cpu_seq_ops = {
1da177e4
LT
319 .start = rt_cpu_seq_start,
320 .next = rt_cpu_seq_next,
321 .stop = rt_cpu_seq_stop,
322 .show = rt_cpu_seq_show,
323};
324
325
326static int rt_cpu_seq_open(struct inode *inode, struct file *file)
327{
328 return seq_open(file, &rt_cpu_seq_ops);
329}
330
9a32144e 331static const struct file_operations rt_cpu_seq_fops = {
1da177e4
LT
332 .owner = THIS_MODULE,
333 .open = rt_cpu_seq_open,
334 .read = seq_read,
335 .llseek = seq_lseek,
336 .release = seq_release,
337};
338
c7066f70 339#ifdef CONFIG_IP_ROUTE_CLASSID
a661c419 340static int rt_acct_proc_show(struct seq_file *m, void *v)
78c686e9 341{
a661c419
AD
342 struct ip_rt_acct *dst, *src;
343 unsigned int i, j;
344
345 dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
346 if (!dst)
347 return -ENOMEM;
348
349 for_each_possible_cpu(i) {
350 src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
351 for (j = 0; j < 256; j++) {
352 dst[j].o_bytes += src[j].o_bytes;
353 dst[j].o_packets += src[j].o_packets;
354 dst[j].i_bytes += src[j].i_bytes;
355 dst[j].i_packets += src[j].i_packets;
356 }
78c686e9
PE
357 }
358
a661c419
AD
359 seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
360 kfree(dst);
361 return 0;
362}
78c686e9 363
a661c419
AD
364static int rt_acct_proc_open(struct inode *inode, struct file *file)
365{
366 return single_open(file, rt_acct_proc_show, NULL);
78c686e9 367}
a661c419
AD
368
369static const struct file_operations rt_acct_proc_fops = {
370 .owner = THIS_MODULE,
371 .open = rt_acct_proc_open,
372 .read = seq_read,
373 .llseek = seq_lseek,
374 .release = single_release,
375};
78c686e9 376#endif
107f1634 377
73b38711 378static int __net_init ip_rt_do_proc_init(struct net *net)
107f1634
PE
379{
380 struct proc_dir_entry *pde;
381
d4beaa66
G
382 pde = proc_create("rt_cache", S_IRUGO, net->proc_net,
383 &rt_cache_seq_fops);
107f1634
PE
384 if (!pde)
385 goto err1;
386
77020720
WC
387 pde = proc_create("rt_cache", S_IRUGO,
388 net->proc_net_stat, &rt_cpu_seq_fops);
107f1634
PE
389 if (!pde)
390 goto err2;
391
c7066f70 392#ifdef CONFIG_IP_ROUTE_CLASSID
a661c419 393 pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
107f1634
PE
394 if (!pde)
395 goto err3;
396#endif
397 return 0;
398
c7066f70 399#ifdef CONFIG_IP_ROUTE_CLASSID
107f1634
PE
400err3:
401 remove_proc_entry("rt_cache", net->proc_net_stat);
402#endif
403err2:
404 remove_proc_entry("rt_cache", net->proc_net);
405err1:
406 return -ENOMEM;
407}
73b38711
DL
408
409static void __net_exit ip_rt_do_proc_exit(struct net *net)
410{
411 remove_proc_entry("rt_cache", net->proc_net_stat);
412 remove_proc_entry("rt_cache", net->proc_net);
c7066f70 413#ifdef CONFIG_IP_ROUTE_CLASSID
73b38711 414 remove_proc_entry("rt_acct", net->proc_net);
0a931acf 415#endif
73b38711
DL
416}
417
418static struct pernet_operations ip_rt_proc_ops __net_initdata = {
419 .init = ip_rt_do_proc_init,
420 .exit = ip_rt_do_proc_exit,
421};
422
423static int __init ip_rt_proc_init(void)
424{
425 return register_pernet_subsys(&ip_rt_proc_ops);
426}
427
107f1634 428#else
73b38711 429static inline int ip_rt_proc_init(void)
107f1634
PE
430{
431 return 0;
432}
1da177e4 433#endif /* CONFIG_PROC_FS */
e905a9ed 434
4331debc 435static inline bool rt_is_expired(const struct rtable *rth)
e84f84f2 436{
ca4c3fc2 437 return rth->rt_genid != rt_genid_ipv4(dev_net(rth->dst.dev));
e84f84f2
DL
438}
439
4ccfe6d4 440void rt_cache_flush(struct net *net)
1da177e4 441{
ca4c3fc2 442 rt_genid_bump_ipv4(net);
98376387
ED
443}
444
f894cbf8
DM
445static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
446 struct sk_buff *skb,
447 const void *daddr)
3769cffb 448{
d3aaeb38
DM
449 struct net_device *dev = dst->dev;
450 const __be32 *pkey = daddr;
39232973 451 const struct rtable *rt;
3769cffb
DM
452 struct neighbour *n;
453
39232973 454 rt = (const struct rtable *) dst;
a263b309 455 if (rt->rt_gateway)
39232973 456 pkey = (const __be32 *) &rt->rt_gateway;
f894cbf8
DM
457 else if (skb)
458 pkey = &ip_hdr(skb)->daddr;
d3aaeb38 459
80703d26 460 n = __ipv4_neigh_lookup(dev, *(__force u32 *)pkey);
d3aaeb38
DM
461 if (n)
462 return n;
32092ecf 463 return neigh_create(&arp_tbl, pkey, dev);
d3aaeb38
DM
464}
465
63fca65d
JA
466static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr)
467{
468 struct net_device *dev = dst->dev;
469 const __be32 *pkey = daddr;
470 const struct rtable *rt;
471
472 rt = (const struct rtable *)dst;
473 if (rt->rt_gateway)
474 pkey = (const __be32 *)&rt->rt_gateway;
475 else if (!daddr ||
476 (rt->rt_flags &
477 (RTCF_MULTICAST | RTCF_BROADCAST | RTCF_LOCAL)))
478 return;
479
480 __ipv4_confirm_neigh(dev, *(__force u32 *)pkey);
481}
482
04ca6973 483#define IP_IDENTS_SZ 2048u
04ca6973 484
355b590c
ED
485static atomic_t *ip_idents __read_mostly;
486static u32 *ip_tstamps __read_mostly;
04ca6973
ED
487
488/* In order to protect privacy, we add a perturbation to identifiers
489 * if one generator is seldom used. This makes hard for an attacker
490 * to infer how many packets were sent between two points in time.
491 */
492u32 ip_idents_reserve(u32 hash, int segs)
493{
355b590c
ED
494 u32 *p_tstamp = ip_tstamps + hash % IP_IDENTS_SZ;
495 atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ;
496 u32 old = ACCESS_ONCE(*p_tstamp);
04ca6973 497 u32 now = (u32)jiffies;
adb03115 498 u32 new, delta = 0;
04ca6973 499
355b590c 500 if (old != now && cmpxchg(p_tstamp, old, now) == old)
04ca6973
ED
501 delta = prandom_u32_max(now - old);
502
adb03115
ED
503 /* Do not use atomic_add_return() as it makes UBSAN unhappy */
504 do {
505 old = (u32)atomic_read(p_id);
506 new = old + delta + segs;
507 } while (atomic_cmpxchg(p_id, old, new) != old);
508
509 return new - segs;
04ca6973
ED
510}
511EXPORT_SYMBOL(ip_idents_reserve);
1da177e4 512
b6a7719a 513void __ip_select_ident(struct net *net, struct iphdr *iph, int segs)
1da177e4 514{
73f156a6
ED
515 static u32 ip_idents_hashrnd __read_mostly;
516 u32 hash, id;
1da177e4 517
73f156a6 518 net_get_random_once(&ip_idents_hashrnd, sizeof(ip_idents_hashrnd));
1da177e4 519
04ca6973
ED
520 hash = jhash_3words((__force u32)iph->daddr,
521 (__force u32)iph->saddr,
b6a7719a 522 iph->protocol ^ net_hash_mix(net),
04ca6973 523 ip_idents_hashrnd);
73f156a6
ED
524 id = ip_idents_reserve(hash, segs);
525 iph->id = htons(id);
1da177e4 526}
4bc2f18b 527EXPORT_SYMBOL(__ip_select_ident);
1da177e4 528
e2d118a1
LC
529static void __build_flow_key(const struct net *net, struct flowi4 *fl4,
530 const struct sock *sk,
4895c771
DM
531 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,
e2d118a1
LC
546 iph->daddr, iph->saddr, 0, 0,
547 sock_net_uid(net, sk));
4895c771
DM
548}
549
5abf7f7e
ED
550static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
551 const struct sock *sk)
4895c771 552{
d109e61b 553 const struct net *net = dev_net(skb->dev);
4895c771
DM
554 const struct iphdr *iph = ip_hdr(skb);
555 int oif = skb->dev->ifindex;
556 u8 tos = RT_TOS(iph->tos);
557 u8 prot = iph->protocol;
558 u32 mark = skb->mark;
559
d109e61b 560 __build_flow_key(net, fl4, sk, iph, oif, tos, prot, mark, 0);
4895c771
DM
561}
562
5abf7f7e 563static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
4895c771
DM
564{
565 const struct inet_sock *inet = inet_sk(sk);
5abf7f7e 566 const struct ip_options_rcu *inet_opt;
4895c771
DM
567 __be32 daddr = inet->inet_daddr;
568
569 rcu_read_lock();
570 inet_opt = rcu_dereference(inet->inet_opt);
571 if (inet_opt && inet_opt->opt.srr)
572 daddr = inet_opt->opt.faddr;
573 flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
574 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
575 inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
576 inet_sk_flowi_flags(sk),
e2d118a1 577 daddr, inet->inet_saddr, 0, 0, sk->sk_uid);
4895c771
DM
578 rcu_read_unlock();
579}
580
5abf7f7e
ED
581static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
582 const struct sk_buff *skb)
4895c771
DM
583{
584 if (skb)
585 build_skb_flow_key(fl4, skb, sk);
586 else
587 build_sk_flow_key(fl4, sk);
588}
589
c5038a83
DM
590static inline void rt_free(struct rtable *rt)
591{
592 call_rcu(&rt->dst.rcu_head, dst_rcu_free);
593}
594
595static DEFINE_SPINLOCK(fnhe_lock);
4895c771 596
2ffae99d
TT
597static void fnhe_flush_routes(struct fib_nh_exception *fnhe)
598{
599 struct rtable *rt;
600
601 rt = rcu_dereference(fnhe->fnhe_rth_input);
602 if (rt) {
603 RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL);
604 rt_free(rt);
605 }
606 rt = rcu_dereference(fnhe->fnhe_rth_output);
607 if (rt) {
608 RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL);
609 rt_free(rt);
610 }
611}
612
aee06da6 613static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
4895c771
DM
614{
615 struct fib_nh_exception *fnhe, *oldest;
616
617 oldest = rcu_dereference(hash->chain);
618 for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
619 fnhe = rcu_dereference(fnhe->fnhe_next)) {
620 if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
621 oldest = fnhe;
622 }
2ffae99d 623 fnhe_flush_routes(oldest);
4895c771
DM
624 return oldest;
625}
626
d3a25c98
DM
627static inline u32 fnhe_hashfun(__be32 daddr)
628{
d546c621 629 static u32 fnhe_hashrnd __read_mostly;
d3a25c98
DM
630 u32 hval;
631
d546c621
ED
632 net_get_random_once(&fnhe_hashrnd, sizeof(fnhe_hashrnd));
633 hval = jhash_1word((__force u32) daddr, fnhe_hashrnd);
634 return hash_32(hval, FNHE_HASH_SHIFT);
d3a25c98
DM
635}
636
387aa65a
TT
637static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnhe)
638{
639 rt->rt_pmtu = fnhe->fnhe_pmtu;
640 rt->dst.expires = fnhe->fnhe_expires;
641
642 if (fnhe->fnhe_gw) {
643 rt->rt_flags |= RTCF_REDIRECTED;
644 rt->rt_gateway = fnhe->fnhe_gw;
645 rt->rt_uses_gateway = 1;
646 }
647}
648
aee06da6
JA
649static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
650 u32 pmtu, unsigned long expires)
4895c771 651{
aee06da6 652 struct fnhe_hash_bucket *hash;
4895c771 653 struct fib_nh_exception *fnhe;
387aa65a
TT
654 struct rtable *rt;
655 unsigned int i;
4895c771 656 int depth;
aee06da6
JA
657 u32 hval = fnhe_hashfun(daddr);
658
c5038a83 659 spin_lock_bh(&fnhe_lock);
4895c771 660
caa41527 661 hash = rcu_dereference(nh->nh_exceptions);
4895c771 662 if (!hash) {
aee06da6 663 hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC);
4895c771 664 if (!hash)
aee06da6 665 goto out_unlock;
caa41527 666 rcu_assign_pointer(nh->nh_exceptions, hash);
4895c771
DM
667 }
668
4895c771
DM
669 hash += hval;
670
671 depth = 0;
672 for (fnhe = rcu_dereference(hash->chain); fnhe;
673 fnhe = rcu_dereference(fnhe->fnhe_next)) {
674 if (fnhe->fnhe_daddr == daddr)
aee06da6 675 break;
4895c771
DM
676 depth++;
677 }
678
aee06da6
JA
679 if (fnhe) {
680 if (gw)
681 fnhe->fnhe_gw = gw;
682 if (pmtu) {
683 fnhe->fnhe_pmtu = pmtu;
387aa65a 684 fnhe->fnhe_expires = max(1UL, expires);
aee06da6 685 }
387aa65a 686 /* Update all cached dsts too */
2ffae99d
TT
687 rt = rcu_dereference(fnhe->fnhe_rth_input);
688 if (rt)
689 fill_route_from_fnhe(rt, fnhe);
690 rt = rcu_dereference(fnhe->fnhe_rth_output);
387aa65a
TT
691 if (rt)
692 fill_route_from_fnhe(rt, fnhe);
aee06da6
JA
693 } else {
694 if (depth > FNHE_RECLAIM_DEPTH)
695 fnhe = fnhe_oldest(hash);
696 else {
697 fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
698 if (!fnhe)
699 goto out_unlock;
700
701 fnhe->fnhe_next = hash->chain;
702 rcu_assign_pointer(hash->chain, fnhe);
703 }
5aad1de5 704 fnhe->fnhe_genid = fnhe_genid(dev_net(nh->nh_dev));
aee06da6
JA
705 fnhe->fnhe_daddr = daddr;
706 fnhe->fnhe_gw = gw;
707 fnhe->fnhe_pmtu = pmtu;
708 fnhe->fnhe_expires = expires;
387aa65a
TT
709
710 /* Exception created; mark the cached routes for the nexthop
711 * stale, so anyone caching it rechecks if this exception
712 * applies to them.
713 */
2ffae99d
TT
714 rt = rcu_dereference(nh->nh_rth_input);
715 if (rt)
716 rt->dst.obsolete = DST_OBSOLETE_KILL;
717
387aa65a
TT
718 for_each_possible_cpu(i) {
719 struct rtable __rcu **prt;
720 prt = per_cpu_ptr(nh->nh_pcpu_rth_output, i);
721 rt = rcu_dereference(*prt);
722 if (rt)
723 rt->dst.obsolete = DST_OBSOLETE_KILL;
724 }
4895c771 725 }
4895c771 726
4895c771 727 fnhe->fnhe_stamp = jiffies;
aee06da6
JA
728
729out_unlock:
c5038a83 730 spin_unlock_bh(&fnhe_lock);
4895c771
DM
731}
732
ceb33206
DM
733static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
734 bool kill_route)
1da177e4 735{
e47a185b 736 __be32 new_gw = icmp_hdr(skb)->un.gateway;
94206125 737 __be32 old_gw = ip_hdr(skb)->saddr;
e47a185b 738 struct net_device *dev = skb->dev;
e47a185b 739 struct in_device *in_dev;
4895c771 740 struct fib_result res;
e47a185b 741 struct neighbour *n;
317805b8 742 struct net *net;
1da177e4 743
94206125
DM
744 switch (icmp_hdr(skb)->code & 7) {
745 case ICMP_REDIR_NET:
746 case ICMP_REDIR_NETTOS:
747 case ICMP_REDIR_HOST:
748 case ICMP_REDIR_HOSTTOS:
749 break;
750
751 default:
752 return;
753 }
754
e47a185b
DM
755 if (rt->rt_gateway != old_gw)
756 return;
757
758 in_dev = __in_dev_get_rcu(dev);
759 if (!in_dev)
760 return;
761
c346dca1 762 net = dev_net(dev);
9d4fb27d
JP
763 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
764 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
765 ipv4_is_zeronet(new_gw))
1da177e4
LT
766 goto reject_redirect;
767
768 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
769 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
770 goto reject_redirect;
771 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
772 goto reject_redirect;
773 } else {
317805b8 774 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
1da177e4
LT
775 goto reject_redirect;
776 }
777
969447f2
SSL
778 n = __ipv4_neigh_lookup(rt->dst.dev, new_gw);
779 if (!n)
780 n = neigh_create(&arp_tbl, &new_gw, rt->dst.dev);
2c1a4311 781 if (!IS_ERR(n)) {
e47a185b
DM
782 if (!(n->nud_state & NUD_VALID)) {
783 neigh_event_send(n, NULL);
784 } else {
0eeb075f 785 if (fib_lookup(net, fl4, &res, 0) == 0) {
4895c771 786 struct fib_nh *nh = &FIB_RES_NH(res);
4895c771 787
aee06da6 788 update_or_create_fnhe(nh, fl4->daddr, new_gw,
deed49df 789 0, jiffies + ip_rt_gc_timeout);
4895c771 790 }
ceb33206
DM
791 if (kill_route)
792 rt->dst.obsolete = DST_OBSOLETE_KILL;
e47a185b
DM
793 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
794 }
795 neigh_release(n);
796 }
797 return;
798
799reject_redirect:
800#ifdef CONFIG_IP_ROUTE_VERBOSE
99ee038d
DM
801 if (IN_DEV_LOG_MARTIANS(in_dev)) {
802 const struct iphdr *iph = (const struct iphdr *) skb->data;
803 __be32 daddr = iph->daddr;
804 __be32 saddr = iph->saddr;
805
e47a185b
DM
806 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
807 " Advised path = %pI4 -> %pI4\n",
808 &old_gw, dev->name, &new_gw,
809 &saddr, &daddr);
99ee038d 810 }
e47a185b
DM
811#endif
812 ;
813}
814
4895c771
DM
815static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
816{
817 struct rtable *rt;
818 struct flowi4 fl4;
f96ef988 819 const struct iphdr *iph = (const struct iphdr *) skb->data;
7d995694 820 struct net *net = dev_net(skb->dev);
f96ef988
MK
821 int oif = skb->dev->ifindex;
822 u8 tos = RT_TOS(iph->tos);
823 u8 prot = iph->protocol;
824 u32 mark = skb->mark;
4895c771
DM
825
826 rt = (struct rtable *) dst;
827
7d995694 828 __build_flow_key(net, &fl4, sk, iph, oif, tos, prot, mark, 0);
ceb33206 829 __ip_do_redirect(rt, skb, &fl4, true);
4895c771
DM
830}
831
1da177e4
LT
832static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
833{
ee6b9673 834 struct rtable *rt = (struct rtable *)dst;
1da177e4
LT
835 struct dst_entry *ret = dst;
836
837 if (rt) {
d11a4dc1 838 if (dst->obsolete > 0) {
1da177e4
LT
839 ip_rt_put(rt);
840 ret = NULL;
5943634f
DM
841 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
842 rt->dst.expires) {
89aef892 843 ip_rt_put(rt);
1da177e4
LT
844 ret = NULL;
845 }
846 }
847 return ret;
848}
849
850/*
851 * Algorithm:
852 * 1. The first ip_rt_redirect_number redirects are sent
853 * with exponential backoff, then we stop sending them at all,
854 * assuming that the host ignores our redirects.
855 * 2. If we did not see packets requiring redirects
856 * during ip_rt_redirect_silence, we assume that the host
857 * forgot redirected route and start to send redirects again.
858 *
859 * This algorithm is much cheaper and more intelligent than dumb load limiting
860 * in icmp.c.
861 *
862 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
863 * and "frag. need" (breaks PMTU discovery) in icmp.c.
864 */
865
866void ip_rt_send_redirect(struct sk_buff *skb)
867{
511c3f92 868 struct rtable *rt = skb_rtable(skb);
30038fc6 869 struct in_device *in_dev;
92d86829 870 struct inet_peer *peer;
1d861aa4 871 struct net *net;
30038fc6 872 int log_martians;
192132b9 873 int vif;
1da177e4 874
30038fc6 875 rcu_read_lock();
d8d1f30b 876 in_dev = __in_dev_get_rcu(rt->dst.dev);
30038fc6
ED
877 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
878 rcu_read_unlock();
1da177e4 879 return;
30038fc6
ED
880 }
881 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
385add90 882 vif = l3mdev_master_ifindex_rcu(rt->dst.dev);
30038fc6 883 rcu_read_unlock();
1da177e4 884
1d861aa4 885 net = dev_net(rt->dst.dev);
192132b9 886 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, vif, 1);
92d86829 887 if (!peer) {
e81da0e1
JA
888 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
889 rt_nexthop(rt, ip_hdr(skb)->daddr));
92d86829
DM
890 return;
891 }
892
1da177e4
LT
893 /* No redirected packets during ip_rt_redirect_silence;
894 * reset the algorithm.
895 */
92d86829
DM
896 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
897 peer->rate_tokens = 0;
1da177e4
LT
898
899 /* Too many ignored redirects; do not send anything
d8d1f30b 900 * set dst.rate_last to the last seen redirected packet.
1da177e4 901 */
92d86829
DM
902 if (peer->rate_tokens >= ip_rt_redirect_number) {
903 peer->rate_last = jiffies;
1d861aa4 904 goto out_put_peer;
1da177e4
LT
905 }
906
907 /* Check for load limit; set rate_last to the latest sent
908 * redirect.
909 */
92d86829 910 if (peer->rate_tokens == 0 ||
14fb8a76 911 time_after(jiffies,
92d86829
DM
912 (peer->rate_last +
913 (ip_rt_redirect_load << peer->rate_tokens)))) {
e81da0e1
JA
914 __be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);
915
916 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
92d86829
DM
917 peer->rate_last = jiffies;
918 ++peer->rate_tokens;
1da177e4 919#ifdef CONFIG_IP_ROUTE_VERBOSE
30038fc6 920 if (log_martians &&
e87cc472
JP
921 peer->rate_tokens == ip_rt_redirect_number)
922 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
92101b3b 923 &ip_hdr(skb)->saddr, inet_iif(skb),
e81da0e1 924 &ip_hdr(skb)->daddr, &gw);
1da177e4
LT
925#endif
926 }
1d861aa4
DM
927out_put_peer:
928 inet_putpeer(peer);
1da177e4
LT
929}
930
931static int ip_error(struct sk_buff *skb)
932{
251da413 933 struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
511c3f92 934 struct rtable *rt = skb_rtable(skb);
92d86829 935 struct inet_peer *peer;
1da177e4 936 unsigned long now;
251da413 937 struct net *net;
92d86829 938 bool send;
1da177e4
LT
939 int code;
940
381c759d
EB
941 /* IP on this device is disabled. */
942 if (!in_dev)
943 goto out;
944
251da413
DM
945 net = dev_net(rt->dst.dev);
946 if (!IN_DEV_FORWARD(in_dev)) {
947 switch (rt->dst.error) {
948 case EHOSTUNREACH:
b45386ef 949 __IP_INC_STATS(net, IPSTATS_MIB_INADDRERRORS);
251da413
DM
950 break;
951
952 case ENETUNREACH:
b45386ef 953 __IP_INC_STATS(net, IPSTATS_MIB_INNOROUTES);
251da413
DM
954 break;
955 }
956 goto out;
957 }
958
d8d1f30b 959 switch (rt->dst.error) {
4500ebf8
JP
960 case EINVAL:
961 default:
962 goto out;
963 case EHOSTUNREACH:
964 code = ICMP_HOST_UNREACH;
965 break;
966 case ENETUNREACH:
967 code = ICMP_NET_UNREACH;
b45386ef 968 __IP_INC_STATS(net, IPSTATS_MIB_INNOROUTES);
4500ebf8
JP
969 break;
970 case EACCES:
971 code = ICMP_PKT_FILTERED;
972 break;
1da177e4
LT
973 }
974
192132b9 975 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr,
385add90 976 l3mdev_master_ifindex(skb->dev), 1);
92d86829
DM
977
978 send = true;
979 if (peer) {
980 now = jiffies;
981 peer->rate_tokens += now - peer->rate_last;
982 if (peer->rate_tokens > ip_rt_error_burst)
983 peer->rate_tokens = ip_rt_error_burst;
984 peer->rate_last = now;
985 if (peer->rate_tokens >= ip_rt_error_cost)
986 peer->rate_tokens -= ip_rt_error_cost;
987 else
988 send = false;
1d861aa4 989 inet_putpeer(peer);
1da177e4 990 }
92d86829
DM
991 if (send)
992 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
1da177e4
LT
993
994out: kfree_skb(skb);
995 return 0;
e905a9ed 996}
1da177e4 997
d851c12b 998static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
1da177e4 999{
d851c12b 1000 struct dst_entry *dst = &rt->dst;
4895c771 1001 struct fib_result res;
2c8cec5c 1002
fa1e492a
SK
1003 if (dst_metric_locked(dst, RTAX_MTU))
1004 return;
1005
cb6ccf09 1006 if (ipv4_mtu(dst) < mtu)
3cdaa5be
LW
1007 return;
1008
5943634f
DM
1009 if (mtu < ip_rt_min_pmtu)
1010 mtu = ip_rt_min_pmtu;
2c8cec5c 1011
f016229e
TT
1012 if (rt->rt_pmtu == mtu &&
1013 time_before(jiffies, dst->expires - ip_rt_mtu_expires / 2))
1014 return;
1015
c5ae7d41 1016 rcu_read_lock();
0eeb075f 1017 if (fib_lookup(dev_net(dst->dev), fl4, &res, 0) == 0) {
4895c771 1018 struct fib_nh *nh = &FIB_RES_NH(res);
4895c771 1019
aee06da6
JA
1020 update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
1021 jiffies + ip_rt_mtu_expires);
4895c771 1022 }
c5ae7d41 1023 rcu_read_unlock();
1da177e4
LT
1024}
1025
4895c771
DM
1026static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1027 struct sk_buff *skb, u32 mtu)
1028{
1029 struct rtable *rt = (struct rtable *) dst;
1030 struct flowi4 fl4;
1031
1032 ip_rt_build_flow_key(&fl4, sk, skb);
d851c12b 1033 __ip_rt_update_pmtu(rt, &fl4, mtu);
4895c771
DM
1034}
1035
36393395
DM
1036void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
1037 int oif, u32 mark, u8 protocol, int flow_flags)
1038{
4895c771 1039 const struct iphdr *iph = (const struct iphdr *) skb->data;
36393395
DM
1040 struct flowi4 fl4;
1041 struct rtable *rt;
1042
1b3c61dc
LC
1043 if (!mark)
1044 mark = IP4_REPLY_MARK(net, skb->mark);
1045
e2d118a1 1046 __build_flow_key(net, &fl4, NULL, iph, oif,
4895c771 1047 RT_TOS(iph->tos), protocol, mark, flow_flags);
36393395
DM
1048 rt = __ip_route_output_key(net, &fl4);
1049 if (!IS_ERR(rt)) {
4895c771 1050 __ip_rt_update_pmtu(rt, &fl4, mtu);
36393395
DM
1051 ip_rt_put(rt);
1052 }
1053}
1054EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
1055
9cb3a50c 1056static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
36393395 1057{
4895c771
DM
1058 const struct iphdr *iph = (const struct iphdr *) skb->data;
1059 struct flowi4 fl4;
1060 struct rtable *rt;
36393395 1061
e2d118a1 1062 __build_flow_key(sock_net(sk), &fl4, sk, iph, 0, 0, 0, 0, 0);
1b3c61dc
LC
1063
1064 if (!fl4.flowi4_mark)
1065 fl4.flowi4_mark = IP4_REPLY_MARK(sock_net(sk), skb->mark);
1066
4895c771
DM
1067 rt = __ip_route_output_key(sock_net(sk), &fl4);
1068 if (!IS_ERR(rt)) {
1069 __ip_rt_update_pmtu(rt, &fl4, mtu);
1070 ip_rt_put(rt);
1071 }
36393395 1072}
9cb3a50c
SK
1073
1074void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1075{
1076 const struct iphdr *iph = (const struct iphdr *) skb->data;
1077 struct flowi4 fl4;
1078 struct rtable *rt;
7f502361 1079 struct dst_entry *odst = NULL;
b44108db 1080 bool new = false;
e2d118a1 1081 struct net *net = sock_net(sk);
9cb3a50c
SK
1082
1083 bh_lock_sock(sk);
482fc609
HFS
1084
1085 if (!ip_sk_accept_pmtu(sk))
1086 goto out;
1087
7f502361 1088 odst = sk_dst_get(sk);
9cb3a50c 1089
7f502361 1090 if (sock_owned_by_user(sk) || !odst) {
9cb3a50c
SK
1091 __ipv4_sk_update_pmtu(skb, sk, mtu);
1092 goto out;
1093 }
1094
e2d118a1 1095 __build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);
9cb3a50c 1096
7f502361 1097 rt = (struct rtable *)odst;
51456b29 1098 if (odst->obsolete && !odst->ops->check(odst, 0)) {
9cb3a50c
SK
1099 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1100 if (IS_ERR(rt))
1101 goto out;
b44108db
SK
1102
1103 new = true;
9cb3a50c
SK
1104 }
1105
1106 __ip_rt_update_pmtu((struct rtable *) rt->dst.path, &fl4, mtu);
1107
7f502361 1108 if (!dst_check(&rt->dst, 0)) {
b44108db
SK
1109 if (new)
1110 dst_release(&rt->dst);
1111
9cb3a50c
SK
1112 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1113 if (IS_ERR(rt))
1114 goto out;
1115
b44108db 1116 new = true;
9cb3a50c
SK
1117 }
1118
b44108db 1119 if (new)
7f502361 1120 sk_dst_set(sk, &rt->dst);
9cb3a50c
SK
1121
1122out:
1123 bh_unlock_sock(sk);
7f502361 1124 dst_release(odst);
9cb3a50c 1125}
36393395 1126EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
f39925db 1127
b42597e2
DM
1128void ipv4_redirect(struct sk_buff *skb, struct net *net,
1129 int oif, u32 mark, u8 protocol, int flow_flags)
1130{
4895c771 1131 const struct iphdr *iph = (const struct iphdr *) skb->data;
b42597e2
DM
1132 struct flowi4 fl4;
1133 struct rtable *rt;
1134
e2d118a1 1135 __build_flow_key(net, &fl4, NULL, iph, oif,
4895c771 1136 RT_TOS(iph->tos), protocol, mark, flow_flags);
b42597e2
DM
1137 rt = __ip_route_output_key(net, &fl4);
1138 if (!IS_ERR(rt)) {
ceb33206 1139 __ip_do_redirect(rt, skb, &fl4, false);
b42597e2
DM
1140 ip_rt_put(rt);
1141 }
1142}
1143EXPORT_SYMBOL_GPL(ipv4_redirect);
1144
1145void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1146{
4895c771
DM
1147 const struct iphdr *iph = (const struct iphdr *) skb->data;
1148 struct flowi4 fl4;
1149 struct rtable *rt;
e2d118a1 1150 struct net *net = sock_net(sk);
b42597e2 1151
e2d118a1
LC
1152 __build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);
1153 rt = __ip_route_output_key(net, &fl4);
4895c771 1154 if (!IS_ERR(rt)) {
ceb33206 1155 __ip_do_redirect(rt, skb, &fl4, false);
4895c771
DM
1156 ip_rt_put(rt);
1157 }
b42597e2
DM
1158}
1159EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1160
efbc368d
DM
1161static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1162{
1163 struct rtable *rt = (struct rtable *) dst;
1164
ceb33206
DM
1165 /* All IPV4 dsts are created with ->obsolete set to the value
1166 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1167 * into this function always.
1168 *
387aa65a
TT
1169 * When a PMTU/redirect information update invalidates a route,
1170 * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
1171 * DST_OBSOLETE_DEAD by dst_free().
ceb33206 1172 */
387aa65a 1173 if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
efbc368d 1174 return NULL;
d11a4dc1 1175 return dst;
1da177e4
LT
1176}
1177
1da177e4
LT
1178static void ipv4_link_failure(struct sk_buff *skb)
1179{
1180 struct rtable *rt;
1181
1182 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1183
511c3f92 1184 rt = skb_rtable(skb);
5943634f
DM
1185 if (rt)
1186 dst_set_expires(&rt->dst, 0);
1da177e4
LT
1187}
1188
ede2059d 1189static int ip_rt_bug(struct net *net, struct sock *sk, struct sk_buff *skb)
1da177e4 1190{
91df42be
JP
1191 pr_debug("%s: %pI4 -> %pI4, %s\n",
1192 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1193 skb->dev ? skb->dev->name : "?");
1da177e4 1194 kfree_skb(skb);
c378a9c0 1195 WARN_ON(1);
1da177e4
LT
1196 return 0;
1197}
1198
1199/*
1200 We do not cache source address of outgoing interface,
1201 because it is used only by IP RR, TS and SRR options,
1202 so that it out of fast path.
1203
1204 BTW remember: "addr" is allowed to be not aligned
1205 in IP options!
1206 */
1207
8e36360a 1208void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
1da177e4 1209{
a61ced5d 1210 __be32 src;
1da177e4 1211
c7537967 1212 if (rt_is_output_route(rt))
c5be24ff 1213 src = ip_hdr(skb)->saddr;
ebc0ffae 1214 else {
8e36360a
DM
1215 struct fib_result res;
1216 struct flowi4 fl4;
1217 struct iphdr *iph;
1218
1219 iph = ip_hdr(skb);
1220
1221 memset(&fl4, 0, sizeof(fl4));
1222 fl4.daddr = iph->daddr;
1223 fl4.saddr = iph->saddr;
b0fe4a31 1224 fl4.flowi4_tos = RT_TOS(iph->tos);
8e36360a
DM
1225 fl4.flowi4_oif = rt->dst.dev->ifindex;
1226 fl4.flowi4_iif = skb->dev->ifindex;
1227 fl4.flowi4_mark = skb->mark;
5e2b61f7 1228
ebc0ffae 1229 rcu_read_lock();
0eeb075f 1230 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res, 0) == 0)
436c3b66 1231 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
ebc0ffae 1232 else
f8126f1d
DM
1233 src = inet_select_addr(rt->dst.dev,
1234 rt_nexthop(rt, iph->daddr),
1235 RT_SCOPE_UNIVERSE);
ebc0ffae
ED
1236 rcu_read_unlock();
1237 }
1da177e4
LT
1238 memcpy(addr, &src, 4);
1239}
1240
c7066f70 1241#ifdef CONFIG_IP_ROUTE_CLASSID
1da177e4
LT
1242static void set_class_tag(struct rtable *rt, u32 tag)
1243{
d8d1f30b
CG
1244 if (!(rt->dst.tclassid & 0xFFFF))
1245 rt->dst.tclassid |= tag & 0xFFFF;
1246 if (!(rt->dst.tclassid & 0xFFFF0000))
1247 rt->dst.tclassid |= tag & 0xFFFF0000;
1da177e4
LT
1248}
1249#endif
1250
0dbaee3b
DM
1251static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1252{
1253 unsigned int advmss = dst_metric_raw(dst, RTAX_ADVMSS);
1254
1255 if (advmss == 0) {
1256 advmss = max_t(unsigned int, dst->dev->mtu - 40,
1257 ip_rt_min_advmss);
1258 if (advmss > 65535 - 40)
1259 advmss = 65535 - 40;
1260 }
1261 return advmss;
1262}
1263
ebb762f2 1264static unsigned int ipv4_mtu(const struct dst_entry *dst)
d33e4553 1265{
261663b0 1266 const struct rtable *rt = (const struct rtable *) dst;
5943634f
DM
1267 unsigned int mtu = rt->rt_pmtu;
1268
98d75c37 1269 if (!mtu || time_after_eq(jiffies, rt->dst.expires))
5943634f 1270 mtu = dst_metric_raw(dst, RTAX_MTU);
618f9bc7 1271
38d523e2 1272 if (mtu)
618f9bc7
SK
1273 return mtu;
1274
1275 mtu = dst->dev->mtu;
d33e4553
DM
1276
1277 if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
155e8336 1278 if (rt->rt_uses_gateway && mtu > 576)
d33e4553
DM
1279 mtu = 576;
1280 }
1281
14972cbd
RP
1282 mtu = min_t(unsigned int, mtu, IP_MAX_MTU);
1283
1284 return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
d33e4553
DM
1285}
1286
f2bb4bed 1287static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
4895c771 1288{
caa41527 1289 struct fnhe_hash_bucket *hash = rcu_dereference(nh->nh_exceptions);
4895c771
DM
1290 struct fib_nh_exception *fnhe;
1291 u32 hval;
1292
f2bb4bed
DM
1293 if (!hash)
1294 return NULL;
1295
d3a25c98 1296 hval = fnhe_hashfun(daddr);
4895c771
DM
1297
1298 for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1299 fnhe = rcu_dereference(fnhe->fnhe_next)) {
f2bb4bed
DM
1300 if (fnhe->fnhe_daddr == daddr)
1301 return fnhe;
1302 }
1303 return NULL;
1304}
aee06da6 1305
caacf05e 1306static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
f2bb4bed
DM
1307 __be32 daddr)
1308{
caacf05e
DM
1309 bool ret = false;
1310
c5038a83 1311 spin_lock_bh(&fnhe_lock);
f2bb4bed 1312
c5038a83 1313 if (daddr == fnhe->fnhe_daddr) {
2ffae99d
TT
1314 struct rtable __rcu **porig;
1315 struct rtable *orig;
5aad1de5 1316 int genid = fnhe_genid(dev_net(rt->dst.dev));
2ffae99d
TT
1317
1318 if (rt_is_input_route(rt))
1319 porig = &fnhe->fnhe_rth_input;
1320 else
1321 porig = &fnhe->fnhe_rth_output;
1322 orig = rcu_dereference(*porig);
5aad1de5
TT
1323
1324 if (fnhe->fnhe_genid != genid) {
1325 fnhe->fnhe_genid = genid;
13d82bf5
SK
1326 fnhe->fnhe_gw = 0;
1327 fnhe->fnhe_pmtu = 0;
1328 fnhe->fnhe_expires = 0;
2ffae99d
TT
1329 fnhe_flush_routes(fnhe);
1330 orig = NULL;
13d82bf5 1331 }
387aa65a
TT
1332 fill_route_from_fnhe(rt, fnhe);
1333 if (!rt->rt_gateway)
155e8336 1334 rt->rt_gateway = daddr;
f2bb4bed 1335
2ffae99d
TT
1336 if (!(rt->dst.flags & DST_NOCACHE)) {
1337 rcu_assign_pointer(*porig, rt);
1338 if (orig)
1339 rt_free(orig);
1340 ret = true;
1341 }
c5038a83
DM
1342
1343 fnhe->fnhe_stamp = jiffies;
c5038a83
DM
1344 }
1345 spin_unlock_bh(&fnhe_lock);
caacf05e
DM
1346
1347 return ret;
54764bb6
ED
1348}
1349
caacf05e 1350static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
f2bb4bed 1351{
d26b3a7c 1352 struct rtable *orig, *prev, **p;
caacf05e 1353 bool ret = true;
f2bb4bed 1354
d26b3a7c 1355 if (rt_is_input_route(rt)) {
54764bb6 1356 p = (struct rtable **)&nh->nh_rth_input;
d26b3a7c 1357 } else {
903ceff7 1358 p = (struct rtable **)raw_cpu_ptr(nh->nh_pcpu_rth_output);
d26b3a7c 1359 }
f2bb4bed
DM
1360 orig = *p;
1361
1362 prev = cmpxchg(p, orig, rt);
1363 if (prev == orig) {
f2bb4bed 1364 if (orig)
54764bb6 1365 rt_free(orig);
155e8336 1366 } else
caacf05e 1367 ret = false;
caacf05e
DM
1368
1369 return ret;
1370}
1371
5055c371
ED
1372struct uncached_list {
1373 spinlock_t lock;
1374 struct list_head head;
1375};
1376
1377static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt_uncached_list);
caacf05e
DM
1378
1379static void rt_add_uncached_list(struct rtable *rt)
1380{
5055c371
ED
1381 struct uncached_list *ul = raw_cpu_ptr(&rt_uncached_list);
1382
1383 rt->rt_uncached_list = ul;
1384
1385 spin_lock_bh(&ul->lock);
1386 list_add_tail(&rt->rt_uncached, &ul->head);
1387 spin_unlock_bh(&ul->lock);
caacf05e
DM
1388}
1389
1390static void ipv4_dst_destroy(struct dst_entry *dst)
1391{
1392 struct rtable *rt = (struct rtable *) dst;
1393
78df76a0 1394 if (!list_empty(&rt->rt_uncached)) {
5055c371
ED
1395 struct uncached_list *ul = rt->rt_uncached_list;
1396
1397 spin_lock_bh(&ul->lock);
caacf05e 1398 list_del(&rt->rt_uncached);
5055c371 1399 spin_unlock_bh(&ul->lock);
caacf05e
DM
1400 }
1401}
1402
1403void rt_flush_dev(struct net_device *dev)
1404{
5055c371
ED
1405 struct net *net = dev_net(dev);
1406 struct rtable *rt;
1407 int cpu;
1408
1409 for_each_possible_cpu(cpu) {
1410 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
caacf05e 1411
5055c371
ED
1412 spin_lock_bh(&ul->lock);
1413 list_for_each_entry(rt, &ul->head, rt_uncached) {
caacf05e
DM
1414 if (rt->dst.dev != dev)
1415 continue;
1416 rt->dst.dev = net->loopback_dev;
1417 dev_hold(rt->dst.dev);
1418 dev_put(dev);
1419 }
5055c371 1420 spin_unlock_bh(&ul->lock);
4895c771
DM
1421 }
1422}
1423
4331debc 1424static bool rt_cache_valid(const struct rtable *rt)
d2d68ba9 1425{
4331debc
ED
1426 return rt &&
1427 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1428 !rt_is_expired(rt);
d2d68ba9
DM
1429}
1430
f2bb4bed 1431static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
5e2b61f7 1432 const struct fib_result *res,
f2bb4bed 1433 struct fib_nh_exception *fnhe,
982721f3 1434 struct fib_info *fi, u16 type, u32 itag)
1da177e4 1435{
caacf05e
DM
1436 bool cached = false;
1437
1da177e4 1438 if (fi) {
4895c771
DM
1439 struct fib_nh *nh = &FIB_RES_NH(*res);
1440
155e8336 1441 if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK) {
4895c771 1442 rt->rt_gateway = nh->nh_gw;
155e8336
JA
1443 rt->rt_uses_gateway = 1;
1444 }
2860583f 1445 dst_init_metrics(&rt->dst, fi->fib_metrics, true);
c7066f70 1446#ifdef CONFIG_IP_ROUTE_CLASSID
f2bb4bed 1447 rt->dst.tclassid = nh->nh_tclassid;
1da177e4 1448#endif
61adedf3 1449 rt->dst.lwtstate = lwtstate_get(nh->nh_lwtstate);
c5038a83 1450 if (unlikely(fnhe))
caacf05e 1451 cached = rt_bind_exception(rt, fnhe, daddr);
c5038a83 1452 else if (!(rt->dst.flags & DST_NOCACHE))
caacf05e 1453 cached = rt_cache_route(nh, rt);
155e8336
JA
1454 if (unlikely(!cached)) {
1455 /* Routes we intend to cache in nexthop exception or
1456 * FIB nexthop have the DST_NOCACHE bit clear.
1457 * However, if we are unsuccessful at storing this
1458 * route into the cache we really need to set it.
1459 */
1460 rt->dst.flags |= DST_NOCACHE;
1461 if (!rt->rt_gateway)
1462 rt->rt_gateway = daddr;
1463 rt_add_uncached_list(rt);
1464 }
1465 } else
caacf05e 1466 rt_add_uncached_list(rt);
defb3519 1467
c7066f70 1468#ifdef CONFIG_IP_ROUTE_CLASSID
1da177e4 1469#ifdef CONFIG_IP_MULTIPLE_TABLES
85b91b03 1470 set_class_tag(rt, res->tclassid);
1da177e4
LT
1471#endif
1472 set_class_tag(rt, itag);
1473#endif
1da177e4
LT
1474}
1475
9ab179d8
DA
1476struct rtable *rt_dst_alloc(struct net_device *dev,
1477 unsigned int flags, u16 type,
1478 bool nopolicy, bool noxfrm, bool will_cache)
0c4dcd58 1479{
d08c4f35
DA
1480 struct rtable *rt;
1481
1482 rt = dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
1483 (will_cache ? 0 : (DST_HOST | DST_NOCACHE)) |
1484 (nopolicy ? DST_NOPOLICY : 0) |
1485 (noxfrm ? DST_NOXFRM : 0));
1486
1487 if (rt) {
1488 rt->rt_genid = rt_genid_ipv4(dev_net(dev));
1489 rt->rt_flags = flags;
1490 rt->rt_type = type;
1491 rt->rt_is_input = 0;
1492 rt->rt_iif = 0;
1493 rt->rt_pmtu = 0;
1494 rt->rt_gateway = 0;
1495 rt->rt_uses_gateway = 0;
b7503e0c 1496 rt->rt_table_id = 0;
d08c4f35
DA
1497 INIT_LIST_HEAD(&rt->rt_uncached);
1498
1499 rt->dst.output = ip_output;
1500 if (flags & RTCF_LOCAL)
1501 rt->dst.input = ip_local_deliver;
1502 }
1503
1504 return rt;
0c4dcd58 1505}
9ab179d8 1506EXPORT_SYMBOL(rt_dst_alloc);
0c4dcd58 1507
96d36220 1508/* called in rcu_read_lock() section */
9e12bb22 1509static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1da177e4
LT
1510 u8 tos, struct net_device *dev, int our)
1511{
1da177e4 1512 struct rtable *rth;
96d36220 1513 struct in_device *in_dev = __in_dev_get_rcu(dev);
d08c4f35 1514 unsigned int flags = RTCF_MULTICAST;
1da177e4 1515 u32 itag = 0;
b5f7e755 1516 int err;
1da177e4
LT
1517
1518 /* Primary sanity checks. */
1519
51456b29 1520 if (!in_dev)
1da177e4
LT
1521 return -EINVAL;
1522
1e637c74 1523 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
d0daebc3 1524 skb->protocol != htons(ETH_P_IP))
1da177e4
LT
1525 goto e_inval;
1526
75fea73d
AD
1527 if (ipv4_is_loopback(saddr) && !IN_DEV_ROUTE_LOCALNET(in_dev))
1528 goto e_inval;
d0daebc3 1529
f97c1e0c
JP
1530 if (ipv4_is_zeronet(saddr)) {
1531 if (!ipv4_is_local_multicast(daddr))
1da177e4 1532 goto e_inval;
b5f7e755 1533 } else {
9e56e380
DM
1534 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1535 in_dev, &itag);
b5f7e755
ED
1536 if (err < 0)
1537 goto e_err;
1538 }
d08c4f35
DA
1539 if (our)
1540 flags |= RTCF_LOCAL;
1541
1542 rth = rt_dst_alloc(dev_net(dev)->loopback_dev, flags, RTN_MULTICAST,
f2bb4bed 1543 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
1da177e4
LT
1544 if (!rth)
1545 goto e_nobufs;
1546
cf911662
DM
1547#ifdef CONFIG_IP_ROUTE_CLASSID
1548 rth->dst.tclassid = itag;
1549#endif
d8d1f30b 1550 rth->dst.output = ip_rt_bug;
9917e1e8 1551 rth->rt_is_input= 1;
1da177e4
LT
1552
1553#ifdef CONFIG_IP_MROUTE
f97c1e0c 1554 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
d8d1f30b 1555 rth->dst.input = ip_mr_input;
1da177e4
LT
1556#endif
1557 RT_CACHE_STAT_INC(in_slow_mc);
1558
89aef892
DM
1559 skb_dst_set(skb, &rth->dst);
1560 return 0;
1da177e4
LT
1561
1562e_nobufs:
1da177e4 1563 return -ENOBUFS;
1da177e4 1564e_inval:
96d36220 1565 return -EINVAL;
b5f7e755 1566e_err:
b5f7e755 1567 return err;
1da177e4
LT
1568}
1569
1570
1571static void ip_handle_martian_source(struct net_device *dev,
1572 struct in_device *in_dev,
1573 struct sk_buff *skb,
9e12bb22
AV
1574 __be32 daddr,
1575 __be32 saddr)
1da177e4
LT
1576{
1577 RT_CACHE_STAT_INC(in_martian_src);
1578#ifdef CONFIG_IP_ROUTE_VERBOSE
1579 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1580 /*
1581 * RFC1812 recommendation, if source is martian,
1582 * the only hint is MAC header.
1583 */
058bd4d2 1584 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
673d57e7 1585 &daddr, &saddr, dev->name);
98e399f8 1586 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
058bd4d2
JP
1587 print_hex_dump(KERN_WARNING, "ll header: ",
1588 DUMP_PREFIX_OFFSET, 16, 1,
1589 skb_mac_header(skb),
1590 dev->hard_header_len, true);
1da177e4
LT
1591 }
1592 }
1593#endif
1594}
1595
deed49df
XL
1596static void ip_del_fnhe(struct fib_nh *nh, __be32 daddr)
1597{
1598 struct fnhe_hash_bucket *hash;
1599 struct fib_nh_exception *fnhe, __rcu **fnhe_p;
1600 u32 hval = fnhe_hashfun(daddr);
1601
1602 spin_lock_bh(&fnhe_lock);
1603
1604 hash = rcu_dereference_protected(nh->nh_exceptions,
1605 lockdep_is_held(&fnhe_lock));
1606 hash += hval;
1607
1608 fnhe_p = &hash->chain;
1609 fnhe = rcu_dereference_protected(*fnhe_p, lockdep_is_held(&fnhe_lock));
1610 while (fnhe) {
1611 if (fnhe->fnhe_daddr == daddr) {
1612 rcu_assign_pointer(*fnhe_p, rcu_dereference_protected(
1613 fnhe->fnhe_next, lockdep_is_held(&fnhe_lock)));
1614 fnhe_flush_routes(fnhe);
1615 kfree_rcu(fnhe, rcu);
1616 break;
1617 }
1618 fnhe_p = &fnhe->fnhe_next;
1619 fnhe = rcu_dereference_protected(fnhe->fnhe_next,
1620 lockdep_is_held(&fnhe_lock));
1621 }
1622
1623 spin_unlock_bh(&fnhe_lock);
1624}
1625
efd85700
TG
1626static void set_lwt_redirect(struct rtable *rth)
1627{
1628 if (lwtunnel_output_redirect(rth->dst.lwtstate)) {
1629 rth->dst.lwtstate->orig_output = rth->dst.output;
1630 rth->dst.output = lwtunnel_output;
1631 }
1632
1633 if (lwtunnel_input_redirect(rth->dst.lwtstate)) {
1634 rth->dst.lwtstate->orig_input = rth->dst.input;
1635 rth->dst.input = lwtunnel_input;
1636 }
1637}
1638
47360228 1639/* called in rcu_read_lock() section */
5969f71d 1640static int __mkroute_input(struct sk_buff *skb,
982721f3 1641 const struct fib_result *res,
5969f71d 1642 struct in_device *in_dev,
c6cffba4 1643 __be32 daddr, __be32 saddr, u32 tos)
1da177e4 1644{
2ffae99d 1645 struct fib_nh_exception *fnhe;
1da177e4
LT
1646 struct rtable *rth;
1647 int err;
1648 struct in_device *out_dev;
d2d68ba9 1649 bool do_cache;
fbdc0ad0 1650 u32 itag = 0;
1da177e4
LT
1651
1652 /* get a working reference to the output device */
47360228 1653 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
51456b29 1654 if (!out_dev) {
e87cc472 1655 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
1da177e4
LT
1656 return -EINVAL;
1657 }
1658
5c04c819 1659 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
9e56e380 1660 in_dev->dev, in_dev, &itag);
1da177e4 1661 if (err < 0) {
e905a9ed 1662 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1da177e4 1663 saddr);
e905a9ed 1664
1da177e4
LT
1665 goto cleanup;
1666 }
1667
e81da0e1
JA
1668 do_cache = res->fi && !itag;
1669 if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
df4d9254 1670 skb->protocol == htons(ETH_P_IP) &&
1da177e4 1671 (IN_DEV_SHARED_MEDIA(out_dev) ||
df4d9254
HFS
1672 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1673 IPCB(skb)->flags |= IPSKB_DOREDIRECT;
1da177e4
LT
1674
1675 if (skb->protocol != htons(ETH_P_IP)) {
1676 /* Not IP (i.e. ARP). Do not create route, if it is
1677 * invalid for proxy arp. DNAT routes are always valid.
65324144
JDB
1678 *
1679 * Proxy arp feature have been extended to allow, ARP
1680 * replies back to the same interface, to support
1681 * Private VLAN switch technologies. See arp.c.
1da177e4 1682 */
65324144
JDB
1683 if (out_dev == in_dev &&
1684 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
1da177e4
LT
1685 err = -EINVAL;
1686 goto cleanup;
1687 }
1688 }
1689
2ffae99d 1690 fnhe = find_exception(&FIB_RES_NH(*res), daddr);
e81da0e1 1691 if (do_cache) {
deed49df 1692 if (fnhe) {
2ffae99d 1693 rth = rcu_dereference(fnhe->fnhe_rth_input);
deed49df
XL
1694 if (rth && rth->dst.expires &&
1695 time_after(jiffies, rth->dst.expires)) {
1696 ip_del_fnhe(&FIB_RES_NH(*res), daddr);
1697 fnhe = NULL;
1698 } else {
1699 goto rt_cache;
1700 }
1701 }
1702
1703 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
2ffae99d 1704
deed49df 1705rt_cache:
e81da0e1
JA
1706 if (rt_cache_valid(rth)) {
1707 skb_dst_set_noref(skb, &rth->dst);
1708 goto out;
d2d68ba9
DM
1709 }
1710 }
f2bb4bed 1711
d08c4f35 1712 rth = rt_dst_alloc(out_dev->dev, 0, res->type,
5c1e6aa3 1713 IN_DEV_CONF_GET(in_dev, NOPOLICY),
d2d68ba9 1714 IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
1da177e4
LT
1715 if (!rth) {
1716 err = -ENOBUFS;
1717 goto cleanup;
1718 }
1719
9917e1e8 1720 rth->rt_is_input = 1;
b7503e0c
DA
1721 if (res->table)
1722 rth->rt_table_id = res->table->tb_id;
a6254864 1723 RT_CACHE_STAT_INC(in_slow_tot);
1da177e4 1724
d8d1f30b 1725 rth->dst.input = ip_forward;
1da177e4 1726
2ffae99d 1727 rt_set_nexthop(rth, daddr, res, fnhe, res->fi, res->type, itag);
efd85700 1728 set_lwt_redirect(rth);
c6cffba4 1729 skb_dst_set(skb, &rth->dst);
d2d68ba9 1730out:
1da177e4
LT
1731 err = 0;
1732 cleanup:
1da177e4 1733 return err;
e905a9ed 1734}
1da177e4 1735
79a13159
PN
1736#ifdef CONFIG_IP_ROUTE_MULTIPATH
1737
1738/* To make ICMP packets follow the right flow, the multipath hash is
1739 * calculated from the inner IP addresses in reverse order.
1740 */
1741static int ip_multipath_icmp_hash(struct sk_buff *skb)
1742{
1743 const struct iphdr *outer_iph = ip_hdr(skb);
1744 struct icmphdr _icmph;
1745 const struct icmphdr *icmph;
1746 struct iphdr _inner_iph;
1747 const struct iphdr *inner_iph;
1748
1749 if (unlikely((outer_iph->frag_off & htons(IP_OFFSET)) != 0))
1750 goto standard_hash;
1751
1752 icmph = skb_header_pointer(skb, outer_iph->ihl * 4, sizeof(_icmph),
1753 &_icmph);
1754 if (!icmph)
1755 goto standard_hash;
1756
1757 if (icmph->type != ICMP_DEST_UNREACH &&
1758 icmph->type != ICMP_REDIRECT &&
1759 icmph->type != ICMP_TIME_EXCEEDED &&
1760 icmph->type != ICMP_PARAMETERPROB) {
1761 goto standard_hash;
1762 }
1763
1764 inner_iph = skb_header_pointer(skb,
1765 outer_iph->ihl * 4 + sizeof(_icmph),
1766 sizeof(_inner_iph), &_inner_iph);
1767 if (!inner_iph)
1768 goto standard_hash;
1769
1770 return fib_multipath_hash(inner_iph->daddr, inner_iph->saddr);
1771
1772standard_hash:
1773 return fib_multipath_hash(outer_iph->saddr, outer_iph->daddr);
1774}
1775
1776#endif /* CONFIG_IP_ROUTE_MULTIPATH */
1777
5969f71d
SH
1778static int ip_mkroute_input(struct sk_buff *skb,
1779 struct fib_result *res,
5969f71d
SH
1780 struct in_device *in_dev,
1781 __be32 daddr, __be32 saddr, u32 tos)
1da177e4 1782{
1da177e4 1783#ifdef CONFIG_IP_ROUTE_MULTIPATH
0e884c78
PN
1784 if (res->fi && res->fi->fib_nhs > 1) {
1785 int h;
1786
79a13159
PN
1787 if (unlikely(ip_hdr(skb)->protocol == IPPROTO_ICMP))
1788 h = ip_multipath_icmp_hash(skb);
1789 else
1790 h = fib_multipath_hash(saddr, daddr);
0e884c78
PN
1791 fib_select_multipath(res, h);
1792 }
1da177e4
LT
1793#endif
1794
1795 /* create a routing cache entry */
c6cffba4 1796 return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
1da177e4
LT
1797}
1798
1da177e4
LT
1799/*
1800 * NOTE. We drop all the packets that has local source
1801 * addresses, because every properly looped back packet
1802 * must have correct destination already attached by output routine.
1803 *
1804 * Such approach solves two big problems:
1805 * 1. Not simplex devices are handled properly.
1806 * 2. IP spoofing attempts are filtered with 100% of guarantee.
ebc0ffae 1807 * called with rcu_read_lock()
1da177e4
LT
1808 */
1809
9e12bb22 1810static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
c10237e0 1811 u8 tos, struct net_device *dev)
1da177e4
LT
1812{
1813 struct fib_result res;
96d36220 1814 struct in_device *in_dev = __in_dev_get_rcu(dev);
1b7179d3 1815 struct ip_tunnel_info *tun_info;
68a5e3dd 1816 struct flowi4 fl4;
95c96174 1817 unsigned int flags = 0;
1da177e4 1818 u32 itag = 0;
95c96174 1819 struct rtable *rth;
1da177e4 1820 int err = -EINVAL;
5e73ea1a 1821 struct net *net = dev_net(dev);
d2d68ba9 1822 bool do_cache;
1da177e4
LT
1823
1824 /* IP on this device is disabled. */
1825
1826 if (!in_dev)
1827 goto out;
1828
1829 /* Check for the most weird martians, which can be not detected
1830 by fib_lookup.
1831 */
1832
61adedf3 1833 tun_info = skb_tunnel_info(skb);
46fa062a 1834 if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
1b7179d3
TG
1835 fl4.flowi4_tun_key.tun_id = tun_info->key.tun_id;
1836 else
1837 fl4.flowi4_tun_key.tun_id = 0;
f38a9eb1
TG
1838 skb_dst_drop(skb);
1839
d0daebc3 1840 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
1da177e4
LT
1841 goto martian_source;
1842
d2d68ba9 1843 res.fi = NULL;
bde6f9de 1844 res.table = NULL;
27a954bd 1845 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
1da177e4
LT
1846 goto brd_input;
1847
1848 /* Accept zero addresses only to limited broadcast;
1849 * I even do not know to fix it or not. Waiting for complains :-)
1850 */
f97c1e0c 1851 if (ipv4_is_zeronet(saddr))
1da177e4
LT
1852 goto martian_source;
1853
d0daebc3 1854 if (ipv4_is_zeronet(daddr))
1da177e4
LT
1855 goto martian_destination;
1856
9eb43e76
ED
1857 /* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
1858 * and call it once if daddr or/and saddr are loopback addresses
1859 */
1860 if (ipv4_is_loopback(daddr)) {
1861 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
d0daebc3 1862 goto martian_destination;
9eb43e76
ED
1863 } else if (ipv4_is_loopback(saddr)) {
1864 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
d0daebc3
TG
1865 goto martian_source;
1866 }
1867
1da177e4
LT
1868 /*
1869 * Now we are ready to route packet.
1870 */
68a5e3dd 1871 fl4.flowi4_oif = 0;
e0d56fdd 1872 fl4.flowi4_iif = dev->ifindex;
68a5e3dd
DM
1873 fl4.flowi4_mark = skb->mark;
1874 fl4.flowi4_tos = tos;
1875 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
b84f7878 1876 fl4.flowi4_flags = 0;
68a5e3dd
DM
1877 fl4.daddr = daddr;
1878 fl4.saddr = saddr;
0eeb075f 1879 err = fib_lookup(net, &fl4, &res, 0);
cd0f0b95
DJ
1880 if (err != 0) {
1881 if (!IN_DEV_FORWARD(in_dev))
1882 err = -EHOSTUNREACH;
1da177e4 1883 goto no_route;
cd0f0b95 1884 }
1da177e4
LT
1885
1886 if (res.type == RTN_BROADCAST)
1887 goto brd_input;
1888
1889 if (res.type == RTN_LOCAL) {
5c04c819 1890 err = fib_validate_source(skb, saddr, daddr, tos,
0d5edc68 1891 0, dev, in_dev, &itag);
b5f7e755 1892 if (err < 0)
0d753960 1893 goto martian_source;
1da177e4
LT
1894 goto local_input;
1895 }
1896
cd0f0b95
DJ
1897 if (!IN_DEV_FORWARD(in_dev)) {
1898 err = -EHOSTUNREACH;
251da413 1899 goto no_route;
cd0f0b95 1900 }
1da177e4
LT
1901 if (res.type != RTN_UNICAST)
1902 goto martian_destination;
1903
dc33da59 1904 err = ip_mkroute_input(skb, &res, in_dev, daddr, saddr, tos);
1da177e4
LT
1905out: return err;
1906
1907brd_input:
1908 if (skb->protocol != htons(ETH_P_IP))
1909 goto e_inval;
1910
41347dcd 1911 if (!ipv4_is_zeronet(saddr)) {
9e56e380
DM
1912 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1913 in_dev, &itag);
1da177e4 1914 if (err < 0)
0d753960 1915 goto martian_source;
1da177e4
LT
1916 }
1917 flags |= RTCF_BROADCAST;
1918 res.type = RTN_BROADCAST;
1919 RT_CACHE_STAT_INC(in_brd);
1920
1921local_input:
d2d68ba9
DM
1922 do_cache = false;
1923 if (res.fi) {
fe3edf45 1924 if (!itag) {
54764bb6 1925 rth = rcu_dereference(FIB_RES_NH(res).nh_rth_input);
d2d68ba9 1926 if (rt_cache_valid(rth)) {
c6cffba4
DM
1927 skb_dst_set_noref(skb, &rth->dst);
1928 err = 0;
1929 goto out;
d2d68ba9
DM
1930 }
1931 do_cache = true;
1932 }
1933 }
1934
f5a0aab8
DA
1935 rth = rt_dst_alloc(l3mdev_master_dev_rcu(dev) ? : net->loopback_dev,
1936 flags | RTCF_LOCAL, res.type,
d2d68ba9 1937 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
1da177e4
LT
1938 if (!rth)
1939 goto e_nobufs;
1940
d8d1f30b 1941 rth->dst.output= ip_rt_bug;
cf911662
DM
1942#ifdef CONFIG_IP_ROUTE_CLASSID
1943 rth->dst.tclassid = itag;
1944#endif
9917e1e8 1945 rth->rt_is_input = 1;
b7503e0c
DA
1946 if (res.table)
1947 rth->rt_table_id = res.table->tb_id;
571e7226 1948
a6254864 1949 RT_CACHE_STAT_INC(in_slow_tot);
1da177e4 1950 if (res.type == RTN_UNREACHABLE) {
d8d1f30b
CG
1951 rth->dst.input= ip_error;
1952 rth->dst.error= -err;
1da177e4
LT
1953 rth->rt_flags &= ~RTCF_LOCAL;
1954 }
efd85700 1955
dcdfdf56 1956 if (do_cache) {
efd85700
TG
1957 struct fib_nh *nh = &FIB_RES_NH(res);
1958
1959 rth->dst.lwtstate = lwtstate_get(nh->nh_lwtstate);
1960 if (lwtunnel_input_redirect(rth->dst.lwtstate)) {
1961 WARN_ON(rth->dst.input == lwtunnel_input);
1962 rth->dst.lwtstate->orig_input = rth->dst.input;
1963 rth->dst.input = lwtunnel_input;
1964 }
1965
1966 if (unlikely(!rt_cache_route(nh, rth))) {
dcdfdf56
AS
1967 rth->dst.flags |= DST_NOCACHE;
1968 rt_add_uncached_list(rth);
1969 }
1970 }
89aef892 1971 skb_dst_set(skb, &rth->dst);
b23dd4fe 1972 err = 0;
ebc0ffae 1973 goto out;
1da177e4
LT
1974
1975no_route:
1976 RT_CACHE_STAT_INC(in_no_route);
1da177e4 1977 res.type = RTN_UNREACHABLE;
fa19c2b0 1978 res.fi = NULL;
bde6f9de 1979 res.table = NULL;
1da177e4
LT
1980 goto local_input;
1981
1982 /*
1983 * Do not cache martian addresses: they should be logged (RFC1812)
1984 */
1985martian_destination:
1986 RT_CACHE_STAT_INC(in_martian_dst);
1987#ifdef CONFIG_IP_ROUTE_VERBOSE
e87cc472
JP
1988 if (IN_DEV_LOG_MARTIANS(in_dev))
1989 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
1990 &daddr, &saddr, dev->name);
1da177e4 1991#endif
2c2910a4 1992
1da177e4
LT
1993e_inval:
1994 err = -EINVAL;
ebc0ffae 1995 goto out;
1da177e4
LT
1996
1997e_nobufs:
1998 err = -ENOBUFS;
ebc0ffae 1999 goto out;
1da177e4
LT
2000
2001martian_source:
2002 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
ebc0ffae 2003 goto out;
1da177e4
LT
2004}
2005
c6cffba4
DM
2006int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2007 u8 tos, struct net_device *dev)
1da177e4 2008{
96d36220 2009 int res;
1da177e4 2010
96d36220
ED
2011 rcu_read_lock();
2012
1da177e4
LT
2013 /* Multicast recognition logic is moved from route cache to here.
2014 The problem was that too many Ethernet cards have broken/missing
2015 hardware multicast filters :-( As result the host on multicasting
2016 network acquires a lot of useless route cache entries, sort of
2017 SDR messages from all the world. Now we try to get rid of them.
2018 Really, provided software IP multicast filter is organized
2019 reasonably (at least, hashed), it does not result in a slowdown
2020 comparing with route cache reject entries.
2021 Note, that multicast routers are not affected, because
2022 route cache entry is created eventually.
2023 */
f97c1e0c 2024 if (ipv4_is_multicast(daddr)) {
96d36220 2025 struct in_device *in_dev = __in_dev_get_rcu(dev);
e58e4159 2026 int our = 0;
1da177e4 2027
e58e4159
DA
2028 if (in_dev)
2029 our = ip_check_mc_rcu(in_dev, daddr, saddr,
2030 ip_hdr(skb)->protocol);
2031
2032 /* check l3 master if no match yet */
2033 if ((!in_dev || !our) && netif_is_l3_slave(dev)) {
2034 struct in_device *l3_in_dev;
2035
2036 l3_in_dev = __in_dev_get_rcu(skb->dev);
2037 if (l3_in_dev)
2038 our = ip_check_mc_rcu(l3_in_dev, daddr, saddr,
2039 ip_hdr(skb)->protocol);
2040 }
2041
2042 res = -EINVAL;
2043 if (our
1da177e4 2044#ifdef CONFIG_IP_MROUTE
e58e4159
DA
2045 ||
2046 (!ipv4_is_local_multicast(daddr) &&
2047 IN_DEV_MFORWARD(in_dev))
1da177e4 2048#endif
e58e4159
DA
2049 ) {
2050 res = ip_route_input_mc(skb, daddr, saddr,
2051 tos, dev, our);
1da177e4
LT
2052 }
2053 rcu_read_unlock();
e58e4159 2054 return res;
1da177e4 2055 }
c10237e0 2056 res = ip_route_input_slow(skb, daddr, saddr, tos, dev);
96d36220
ED
2057 rcu_read_unlock();
2058 return res;
1da177e4 2059}
c6cffba4 2060EXPORT_SYMBOL(ip_route_input_noref);
1da177e4 2061
ebc0ffae 2062/* called with rcu_read_lock() */
982721f3 2063static struct rtable *__mkroute_output(const struct fib_result *res,
1a00fee4 2064 const struct flowi4 *fl4, int orig_oif,
f61759e6 2065 struct net_device *dev_out,
5ada5527 2066 unsigned int flags)
1da177e4 2067{
982721f3 2068 struct fib_info *fi = res->fi;
f2bb4bed 2069 struct fib_nh_exception *fnhe;
5ada5527 2070 struct in_device *in_dev;
982721f3 2071 u16 type = res->type;
5ada5527 2072 struct rtable *rth;
c92b9655 2073 bool do_cache;
1da177e4 2074
d0daebc3
TG
2075 in_dev = __in_dev_get_rcu(dev_out);
2076 if (!in_dev)
5ada5527 2077 return ERR_PTR(-EINVAL);
1da177e4 2078
d0daebc3 2079 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
5f02ce24
DA
2080 if (ipv4_is_loopback(fl4->saddr) &&
2081 !(dev_out->flags & IFF_LOOPBACK) &&
2082 !netif_is_l3_master(dev_out))
d0daebc3
TG
2083 return ERR_PTR(-EINVAL);
2084
68a5e3dd 2085 if (ipv4_is_lbcast(fl4->daddr))
982721f3 2086 type = RTN_BROADCAST;
68a5e3dd 2087 else if (ipv4_is_multicast(fl4->daddr))
982721f3 2088 type = RTN_MULTICAST;
68a5e3dd 2089 else if (ipv4_is_zeronet(fl4->daddr))
5ada5527 2090 return ERR_PTR(-EINVAL);
1da177e4
LT
2091
2092 if (dev_out->flags & IFF_LOOPBACK)
2093 flags |= RTCF_LOCAL;
2094
63617421 2095 do_cache = true;
982721f3 2096 if (type == RTN_BROADCAST) {
1da177e4 2097 flags |= RTCF_BROADCAST | RTCF_LOCAL;
982721f3
DM
2098 fi = NULL;
2099 } else if (type == RTN_MULTICAST) {
dd28d1a0 2100 flags |= RTCF_MULTICAST | RTCF_LOCAL;
813b3b5d
DM
2101 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
2102 fl4->flowi4_proto))
1da177e4 2103 flags &= ~RTCF_LOCAL;
63617421
JA
2104 else
2105 do_cache = false;
1da177e4 2106 /* If multicast route do not exist use
dd28d1a0
ED
2107 * default one, but do not gateway in this case.
2108 * Yes, it is hack.
1da177e4 2109 */
982721f3
DM
2110 if (fi && res->prefixlen < 4)
2111 fi = NULL;
d6d5e999
CF
2112 } else if ((type == RTN_LOCAL) && (orig_oif != 0) &&
2113 (orig_oif != dev_out->ifindex)) {
2114 /* For local routes that require a particular output interface
2115 * we do not want to cache the result. Caching the result
2116 * causes incorrect behaviour when there are multiple source
2117 * addresses on the interface, the end result being that if the
2118 * intended recipient is waiting on that interface for the
2119 * packet he won't receive it because it will be delivered on
2120 * the loopback interface and the IP_PKTINFO ipi_ifindex will
2121 * be set to the loopback interface as well.
2122 */
2123 fi = NULL;
1da177e4
LT
2124 }
2125
f2bb4bed 2126 fnhe = NULL;
63617421
JA
2127 do_cache &= fi != NULL;
2128 if (do_cache) {
c5038a83 2129 struct rtable __rcu **prth;
c92b9655 2130 struct fib_nh *nh = &FIB_RES_NH(*res);
d26b3a7c 2131
c92b9655 2132 fnhe = find_exception(nh, fl4->daddr);
deed49df 2133 if (fnhe) {
2ffae99d 2134 prth = &fnhe->fnhe_rth_output;
deed49df
XL
2135 rth = rcu_dereference(*prth);
2136 if (rth && rth->dst.expires &&
2137 time_after(jiffies, rth->dst.expires)) {
2138 ip_del_fnhe(nh, fl4->daddr);
2139 fnhe = NULL;
2140 } else {
2141 goto rt_cache;
c92b9655 2142 }
c92b9655 2143 }
deed49df
XL
2144
2145 if (unlikely(fl4->flowi4_flags &
2146 FLOWI_FLAG_KNOWN_NH &&
2147 !(nh->nh_gw &&
2148 nh->nh_scope == RT_SCOPE_LINK))) {
2149 do_cache = false;
2150 goto add;
2151 }
2152 prth = raw_cpu_ptr(nh->nh_pcpu_rth_output);
c5038a83 2153 rth = rcu_dereference(*prth);
deed49df
XL
2154
2155rt_cache:
c5038a83
DM
2156 if (rt_cache_valid(rth)) {
2157 dst_hold(&rth->dst);
2158 return rth;
f2bb4bed
DM
2159 }
2160 }
c92b9655
JA
2161
2162add:
d08c4f35 2163 rth = rt_dst_alloc(dev_out, flags, type,
5c1e6aa3 2164 IN_DEV_CONF_GET(in_dev, NOPOLICY),
f2bb4bed 2165 IN_DEV_CONF_GET(in_dev, NOXFRM),
c92b9655 2166 do_cache);
8391d07b 2167 if (!rth)
5ada5527 2168 return ERR_PTR(-ENOBUFS);
8391d07b 2169
13378cad 2170 rth->rt_iif = orig_oif ? : 0;
b7503e0c
DA
2171 if (res->table)
2172 rth->rt_table_id = res->table->tb_id;
2173
1da177e4
LT
2174 RT_CACHE_STAT_INC(out_slow_tot);
2175
1da177e4 2176 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
e905a9ed 2177 if (flags & RTCF_LOCAL &&
1da177e4 2178 !(dev_out->flags & IFF_LOOPBACK)) {
d8d1f30b 2179 rth->dst.output = ip_mc_output;
1da177e4
LT
2180 RT_CACHE_STAT_INC(out_slow_mc);
2181 }
2182#ifdef CONFIG_IP_MROUTE
982721f3 2183 if (type == RTN_MULTICAST) {
1da177e4 2184 if (IN_DEV_MFORWARD(in_dev) &&
813b3b5d 2185 !ipv4_is_local_multicast(fl4->daddr)) {
d8d1f30b
CG
2186 rth->dst.input = ip_mr_input;
2187 rth->dst.output = ip_mc_output;
1da177e4
LT
2188 }
2189 }
2190#endif
2191 }
2192
f2bb4bed 2193 rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0);
efd85700 2194 set_lwt_redirect(rth);
1da177e4 2195
5ada5527 2196 return rth;
1da177e4
LT
2197}
2198
1da177e4
LT
2199/*
2200 * Major route resolver routine.
2201 */
2202
79a13159
PN
2203struct rtable *__ip_route_output_key_hash(struct net *net, struct flowi4 *fl4,
2204 int mp_hash)
1da177e4 2205{
1da177e4 2206 struct net_device *dev_out = NULL;
f61759e6 2207 __u8 tos = RT_FL_TOS(fl4);
813b3b5d
DM
2208 unsigned int flags = 0;
2209 struct fib_result res;
5ada5527 2210 struct rtable *rth;
813b3b5d 2211 int orig_oif;
0315e382 2212 int err = -ENETUNREACH;
1da177e4 2213
85b91b03 2214 res.tclassid = 0;
1da177e4 2215 res.fi = NULL;
8b96d22d 2216 res.table = NULL;
1da177e4 2217
813b3b5d
DM
2218 orig_oif = fl4->flowi4_oif;
2219
1fb9489b 2220 fl4->flowi4_iif = LOOPBACK_IFINDEX;
813b3b5d
DM
2221 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
2222 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
2223 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
44713b67 2224
010c2708 2225 rcu_read_lock();
813b3b5d 2226 if (fl4->saddr) {
b23dd4fe 2227 rth = ERR_PTR(-EINVAL);
813b3b5d
DM
2228 if (ipv4_is_multicast(fl4->saddr) ||
2229 ipv4_is_lbcast(fl4->saddr) ||
2230 ipv4_is_zeronet(fl4->saddr))
1da177e4
LT
2231 goto out;
2232
1da177e4
LT
2233 /* I removed check for oif == dev_out->oif here.
2234 It was wrong for two reasons:
1ab35276
DL
2235 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2236 is assigned to multiple interfaces.
1da177e4
LT
2237 2. Moreover, we are allowed to send packets with saddr
2238 of another iface. --ANK
2239 */
2240
813b3b5d
DM
2241 if (fl4->flowi4_oif == 0 &&
2242 (ipv4_is_multicast(fl4->daddr) ||
2243 ipv4_is_lbcast(fl4->daddr))) {
a210d01a 2244 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
813b3b5d 2245 dev_out = __ip_dev_find(net, fl4->saddr, false);
51456b29 2246 if (!dev_out)
a210d01a
JA
2247 goto out;
2248
1da177e4
LT
2249 /* Special hack: user can direct multicasts
2250 and limited broadcast via necessary interface
2251 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2252 This hack is not just for fun, it allows
2253 vic,vat and friends to work.
2254 They bind socket to loopback, set ttl to zero
2255 and expect that it will work.
2256 From the viewpoint of routing cache they are broken,
2257 because we are not allowed to build multicast path
2258 with loopback source addr (look, routing cache
2259 cannot know, that ttl is zero, so that packet
2260 will not leave this host and route is valid).
2261 Luckily, this hack is good workaround.
2262 */
2263
813b3b5d 2264 fl4->flowi4_oif = dev_out->ifindex;
1da177e4
LT
2265 goto make_route;
2266 }
a210d01a 2267
813b3b5d 2268 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
a210d01a 2269 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
813b3b5d 2270 if (!__ip_dev_find(net, fl4->saddr, false))
a210d01a 2271 goto out;
a210d01a 2272 }
1da177e4
LT
2273 }
2274
2275
813b3b5d
DM
2276 if (fl4->flowi4_oif) {
2277 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
b23dd4fe 2278 rth = ERR_PTR(-ENODEV);
51456b29 2279 if (!dev_out)
1da177e4 2280 goto out;
e5ed6399
HX
2281
2282 /* RACE: Check return value of inet_select_addr instead. */
fc75fc83 2283 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
b23dd4fe 2284 rth = ERR_PTR(-ENETUNREACH);
fc75fc83
ED
2285 goto out;
2286 }
813b3b5d 2287 if (ipv4_is_local_multicast(fl4->daddr) ||
6a211654
AL
2288 ipv4_is_lbcast(fl4->daddr) ||
2289 fl4->flowi4_proto == IPPROTO_IGMP) {
813b3b5d
DM
2290 if (!fl4->saddr)
2291 fl4->saddr = inet_select_addr(dev_out, 0,
2292 RT_SCOPE_LINK);
1da177e4
LT
2293 goto make_route;
2294 }
0a7e2260 2295 if (!fl4->saddr) {
813b3b5d
DM
2296 if (ipv4_is_multicast(fl4->daddr))
2297 fl4->saddr = inet_select_addr(dev_out, 0,
2298 fl4->flowi4_scope);
2299 else if (!fl4->daddr)
2300 fl4->saddr = inet_select_addr(dev_out, 0,
2301 RT_SCOPE_HOST);
1da177e4
LT
2302 }
2303 }
2304
813b3b5d
DM
2305 if (!fl4->daddr) {
2306 fl4->daddr = fl4->saddr;
2307 if (!fl4->daddr)
2308 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
b40afd0e 2309 dev_out = net->loopback_dev;
1fb9489b 2310 fl4->flowi4_oif = LOOPBACK_IFINDEX;
1da177e4
LT
2311 res.type = RTN_LOCAL;
2312 flags |= RTCF_LOCAL;
2313 goto make_route;
2314 }
2315
0315e382
NF
2316 err = fib_lookup(net, fl4, &res, 0);
2317 if (err) {
1da177e4 2318 res.fi = NULL;
8b96d22d 2319 res.table = NULL;
6104e112 2320 if (fl4->flowi4_oif &&
e58e4159
DA
2321 (ipv4_is_multicast(fl4->daddr) ||
2322 !netif_index_is_l3_master(net, fl4->flowi4_oif))) {
1da177e4
LT
2323 /* Apparently, routing tables are wrong. Assume,
2324 that the destination is on link.
2325
2326 WHY? DW.
2327 Because we are allowed to send to iface
2328 even if it has NO routes and NO assigned
2329 addresses. When oif is specified, routing
2330 tables are looked up with only one purpose:
2331 to catch if destination is gatewayed, rather than
2332 direct. Moreover, if MSG_DONTROUTE is set,
2333 we send packet, ignoring both routing tables
2334 and ifaddr state. --ANK
2335
2336
2337 We could make it even if oif is unknown,
2338 likely IPv6, but we do not.
2339 */
2340
813b3b5d
DM
2341 if (fl4->saddr == 0)
2342 fl4->saddr = inet_select_addr(dev_out, 0,
2343 RT_SCOPE_LINK);
1da177e4
LT
2344 res.type = RTN_UNICAST;
2345 goto make_route;
2346 }
0315e382 2347 rth = ERR_PTR(err);
1da177e4
LT
2348 goto out;
2349 }
1da177e4
LT
2350
2351 if (res.type == RTN_LOCAL) {
813b3b5d 2352 if (!fl4->saddr) {
9fc3bbb4 2353 if (res.fi->fib_prefsrc)
813b3b5d 2354 fl4->saddr = res.fi->fib_prefsrc;
9fc3bbb4 2355 else
813b3b5d 2356 fl4->saddr = fl4->daddr;
9fc3bbb4 2357 }
5f02ce24
DA
2358
2359 /* L3 master device is the loopback for that domain */
2360 dev_out = l3mdev_master_dev_rcu(dev_out) ? : net->loopback_dev;
813b3b5d 2361 fl4->flowi4_oif = dev_out->ifindex;
1da177e4
LT
2362 flags |= RTCF_LOCAL;
2363 goto make_route;
2364 }
2365
3ce58d84 2366 fib_select_path(net, &res, fl4, mp_hash);
1da177e4 2367
1da177e4 2368 dev_out = FIB_RES_DEV(res);
813b3b5d 2369 fl4->flowi4_oif = dev_out->ifindex;
1da177e4
LT
2370
2371
2372make_route:
1a00fee4 2373 rth = __mkroute_output(&res, fl4, orig_oif, dev_out, flags);
1da177e4 2374
010c2708
DM
2375out:
2376 rcu_read_unlock();
b23dd4fe 2377 return rth;
1da177e4 2378}
79a13159 2379EXPORT_SYMBOL_GPL(__ip_route_output_key_hash);
d8c97a94 2380
ae2688d5
JW
2381static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2382{
2383 return NULL;
2384}
2385
ebb762f2 2386static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
ec831ea7 2387{
618f9bc7
SK
2388 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2389
2390 return mtu ? : dst->dev->mtu;
ec831ea7
RD
2391}
2392
6700c270
DM
2393static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2394 struct sk_buff *skb, u32 mtu)
14e50e57
DM
2395{
2396}
2397
6700c270
DM
2398static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2399 struct sk_buff *skb)
b587ee3b
DM
2400{
2401}
2402
0972ddb2
HB
2403static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2404 unsigned long old)
2405{
2406 return NULL;
2407}
2408
14e50e57
DM
2409static struct dst_ops ipv4_dst_blackhole_ops = {
2410 .family = AF_INET,
ae2688d5 2411 .check = ipv4_blackhole_dst_check,
ebb762f2 2412 .mtu = ipv4_blackhole_mtu,
214f45c9 2413 .default_advmss = ipv4_default_advmss,
14e50e57 2414 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
b587ee3b 2415 .redirect = ipv4_rt_blackhole_redirect,
0972ddb2 2416 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
d3aaeb38 2417 .neigh_lookup = ipv4_neigh_lookup,
14e50e57
DM
2418};
2419
2774c131 2420struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
14e50e57 2421{
2774c131 2422 struct rtable *ort = (struct rtable *) dst_orig;
f5b0a874 2423 struct rtable *rt;
14e50e57 2424
f5b0a874 2425 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE, 0);
14e50e57 2426 if (rt) {
d8d1f30b 2427 struct dst_entry *new = &rt->dst;
14e50e57 2428
14e50e57 2429 new->__use = 1;
352e512c 2430 new->input = dst_discard;
ede2059d 2431 new->output = dst_discard_out;
14e50e57 2432
d8d1f30b 2433 new->dev = ort->dst.dev;
14e50e57
DM
2434 if (new->dev)
2435 dev_hold(new->dev);
2436
9917e1e8 2437 rt->rt_is_input = ort->rt_is_input;
5e2b61f7 2438 rt->rt_iif = ort->rt_iif;
5943634f 2439 rt->rt_pmtu = ort->rt_pmtu;
14e50e57 2440
ca4c3fc2 2441 rt->rt_genid = rt_genid_ipv4(net);
14e50e57
DM
2442 rt->rt_flags = ort->rt_flags;
2443 rt->rt_type = ort->rt_type;
14e50e57 2444 rt->rt_gateway = ort->rt_gateway;
155e8336 2445 rt->rt_uses_gateway = ort->rt_uses_gateway;
14e50e57 2446
caacf05e 2447 INIT_LIST_HEAD(&rt->rt_uncached);
14e50e57
DM
2448 dst_free(new);
2449 }
2450
2774c131
DM
2451 dst_release(dst_orig);
2452
2453 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
14e50e57
DM
2454}
2455
9d6ec938 2456struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
6f9c9615 2457 const struct sock *sk)
1da177e4 2458{
9d6ec938 2459 struct rtable *rt = __ip_route_output_key(net, flp4);
1da177e4 2460
b23dd4fe
DM
2461 if (IS_ERR(rt))
2462 return rt;
1da177e4 2463
56157872 2464 if (flp4->flowi4_proto)
f92ee619
SK
2465 rt = (struct rtable *)xfrm_lookup_route(net, &rt->dst,
2466 flowi4_to_flowi(flp4),
2467 sk, 0);
1da177e4 2468
b23dd4fe 2469 return rt;
1da177e4 2470}
d8c97a94
ACM
2471EXPORT_SYMBOL_GPL(ip_route_output_flow);
2472
c36ba660 2473static int rt_fill_info(struct net *net, __be32 dst, __be32 src, u32 table_id,
15e47304 2474 struct flowi4 *fl4, struct sk_buff *skb, u32 portid,
0c8d803f 2475 u32 seq, int event)
1da177e4 2476{
511c3f92 2477 struct rtable *rt = skb_rtable(skb);
1da177e4 2478 struct rtmsg *r;
be403ea1 2479 struct nlmsghdr *nlh;
2bc8ca40 2480 unsigned long expires = 0;
f185071d 2481 u32 error;
521f5490 2482 u32 metrics[RTAX_MAX];
be403ea1 2483
0c8d803f 2484 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*r), 0);
51456b29 2485 if (!nlh)
26932566 2486 return -EMSGSIZE;
be403ea1
TG
2487
2488 r = nlmsg_data(nlh);
1da177e4
LT
2489 r->rtm_family = AF_INET;
2490 r->rtm_dst_len = 32;
2491 r->rtm_src_len = 0;
d6c0a4f6 2492 r->rtm_tos = fl4->flowi4_tos;
8a430ed5 2493 r->rtm_table = table_id < 256 ? table_id : RT_TABLE_COMPAT;
c36ba660 2494 if (nla_put_u32(skb, RTA_TABLE, table_id))
f3756b79 2495 goto nla_put_failure;
1da177e4
LT
2496 r->rtm_type = rt->rt_type;
2497 r->rtm_scope = RT_SCOPE_UNIVERSE;
2498 r->rtm_protocol = RTPROT_UNSPEC;
2499 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2500 if (rt->rt_flags & RTCF_NOTIFY)
2501 r->rtm_flags |= RTM_F_NOTIFY;
df4d9254
HFS
2502 if (IPCB(skb)->flags & IPSKB_DOREDIRECT)
2503 r->rtm_flags |= RTCF_DOREDIRECT;
be403ea1 2504
930345ea 2505 if (nla_put_in_addr(skb, RTA_DST, dst))
f3756b79 2506 goto nla_put_failure;
1a00fee4 2507 if (src) {
1da177e4 2508 r->rtm_src_len = 32;
930345ea 2509 if (nla_put_in_addr(skb, RTA_SRC, src))
f3756b79 2510 goto nla_put_failure;
1da177e4 2511 }
f3756b79
DM
2512 if (rt->dst.dev &&
2513 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2514 goto nla_put_failure;
c7066f70 2515#ifdef CONFIG_IP_ROUTE_CLASSID
f3756b79
DM
2516 if (rt->dst.tclassid &&
2517 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2518 goto nla_put_failure;
1da177e4 2519#endif
41347dcd 2520 if (!rt_is_input_route(rt) &&
d6c0a4f6 2521 fl4->saddr != src) {
930345ea 2522 if (nla_put_in_addr(skb, RTA_PREFSRC, fl4->saddr))
f3756b79
DM
2523 goto nla_put_failure;
2524 }
155e8336 2525 if (rt->rt_uses_gateway &&
930345ea 2526 nla_put_in_addr(skb, RTA_GATEWAY, rt->rt_gateway))
f3756b79 2527 goto nla_put_failure;
be403ea1 2528
ee9a8f7a
SK
2529 expires = rt->dst.expires;
2530 if (expires) {
2531 unsigned long now = jiffies;
2532
2533 if (time_before(now, expires))
2534 expires -= now;
2535 else
2536 expires = 0;
2537 }
2538
521f5490 2539 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
ee9a8f7a 2540 if (rt->rt_pmtu && expires)
521f5490
JA
2541 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2542 if (rtnetlink_put_metrics(skb, metrics) < 0)
be403ea1
TG
2543 goto nla_put_failure;
2544
b4869889 2545 if (fl4->flowi4_mark &&
68aaed54 2546 nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
f3756b79 2547 goto nla_put_failure;
963bfeee 2548
622ec2c9
LC
2549 if (!uid_eq(fl4->flowi4_uid, INVALID_UID) &&
2550 nla_put_u32(skb, RTA_UID,
2551 from_kuid_munged(current_user_ns(), fl4->flowi4_uid)))
2552 goto nla_put_failure;
2553
d8d1f30b 2554 error = rt->dst.error;
be403ea1 2555
c7537967 2556 if (rt_is_input_route(rt)) {
8caaf7b6
ND
2557#ifdef CONFIG_IP_MROUTE
2558 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2559 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2560 int err = ipmr_get_route(net, skb,
2561 fl4->saddr, fl4->daddr,
9f09eaea 2562 r, portid);
2cf75070 2563
8caaf7b6 2564 if (err <= 0) {
0c8d803f
DA
2565 if (err == 0)
2566 return 0;
2567 goto nla_put_failure;
8caaf7b6
ND
2568 }
2569 } else
2570#endif
91146153 2571 if (nla_put_u32(skb, RTA_IIF, skb->dev->ifindex))
8caaf7b6 2572 goto nla_put_failure;
1da177e4
LT
2573 }
2574
f185071d 2575 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
e3703b3d 2576 goto nla_put_failure;
be403ea1 2577
053c095a
JB
2578 nlmsg_end(skb, nlh);
2579 return 0;
1da177e4 2580
be403ea1 2581nla_put_failure:
26932566
PM
2582 nlmsg_cancel(skb, nlh);
2583 return -EMSGSIZE;
1da177e4
LT
2584}
2585
661d2967 2586static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
1da177e4 2587{
3b1e0a65 2588 struct net *net = sock_net(in_skb->sk);
d889ce3b
TG
2589 struct rtmsg *rtm;
2590 struct nlattr *tb[RTA_MAX+1];
1da177e4 2591 struct rtable *rt = NULL;
d6c0a4f6 2592 struct flowi4 fl4;
9e12bb22
AV
2593 __be32 dst = 0;
2594 __be32 src = 0;
2595 u32 iif;
d889ce3b 2596 int err;
963bfeee 2597 int mark;
1da177e4 2598 struct sk_buff *skb;
c36ba660 2599 u32 table_id = RT_TABLE_MAIN;
622ec2c9 2600 kuid_t uid;
1da177e4 2601
d889ce3b
TG
2602 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2603 if (err < 0)
2604 goto errout;
2605
2606 rtm = nlmsg_data(nlh);
2607
1da177e4 2608 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
51456b29 2609 if (!skb) {
d889ce3b
TG
2610 err = -ENOBUFS;
2611 goto errout;
2612 }
1da177e4
LT
2613
2614 /* Reserve room for dummy headers, this skb can pass
2615 through good chunk of routing engine.
2616 */
459a98ed 2617 skb_reset_mac_header(skb);
c1d2bbe1 2618 skb_reset_network_header(skb);
d2c962b8
SH
2619
2620 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
eddc9ec5 2621 ip_hdr(skb)->protocol = IPPROTO_ICMP;
1da177e4
LT
2622 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2623
67b61f6c
JB
2624 src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0;
2625 dst = tb[RTA_DST] ? nla_get_in_addr(tb[RTA_DST]) : 0;
d889ce3b 2626 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
963bfeee 2627 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
622ec2c9
LC
2628 if (tb[RTA_UID])
2629 uid = make_kuid(current_user_ns(), nla_get_u32(tb[RTA_UID]));
2630 else
2631 uid = (iif ? INVALID_UID : current_uid());
1da177e4 2632
d6c0a4f6
DM
2633 memset(&fl4, 0, sizeof(fl4));
2634 fl4.daddr = dst;
2635 fl4.saddr = src;
2636 fl4.flowi4_tos = rtm->rtm_tos;
2637 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2638 fl4.flowi4_mark = mark;
622ec2c9 2639 fl4.flowi4_uid = uid;
d6c0a4f6 2640
1da177e4 2641 if (iif) {
d889ce3b
TG
2642 struct net_device *dev;
2643
1937504d 2644 dev = __dev_get_by_index(net, iif);
51456b29 2645 if (!dev) {
d889ce3b
TG
2646 err = -ENODEV;
2647 goto errout_free;
2648 }
2649
1da177e4
LT
2650 skb->protocol = htons(ETH_P_IP);
2651 skb->dev = dev;
963bfeee 2652 skb->mark = mark;
1da177e4 2653 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
d889ce3b 2654
511c3f92 2655 rt = skb_rtable(skb);
d8d1f30b
CG
2656 if (err == 0 && rt->dst.error)
2657 err = -rt->dst.error;
1da177e4 2658 } else {
9d6ec938 2659 rt = ip_route_output_key(net, &fl4);
b23dd4fe
DM
2660
2661 err = 0;
2662 if (IS_ERR(rt))
2663 err = PTR_ERR(rt);
1da177e4 2664 }
d889ce3b 2665
1da177e4 2666 if (err)
d889ce3b 2667 goto errout_free;
1da177e4 2668
d8d1f30b 2669 skb_dst_set(skb, &rt->dst);
1da177e4
LT
2670 if (rtm->rtm_flags & RTM_F_NOTIFY)
2671 rt->rt_flags |= RTCF_NOTIFY;
2672
c36ba660
DA
2673 if (rtm->rtm_flags & RTM_F_LOOKUP_TABLE)
2674 table_id = rt->rt_table_id;
2675
2676 err = rt_fill_info(net, dst, src, table_id, &fl4, skb,
15e47304 2677 NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
0c8d803f 2678 RTM_NEWROUTE);
7b46a644 2679 if (err < 0)
d889ce3b 2680 goto errout_free;
1da177e4 2681
15e47304 2682 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
d889ce3b 2683errout:
2942e900 2684 return err;
1da177e4 2685
d889ce3b 2686errout_free:
1da177e4 2687 kfree_skb(skb);
d889ce3b 2688 goto errout;
1da177e4
LT
2689}
2690
1da177e4
LT
2691void ip_rt_multicast_event(struct in_device *in_dev)
2692{
4ccfe6d4 2693 rt_cache_flush(dev_net(in_dev->dev));
1da177e4
LT
2694}
2695
2696#ifdef CONFIG_SYSCTL
082c7ca4
G
2697static int ip_rt_gc_interval __read_mostly = 60 * HZ;
2698static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
2699static int ip_rt_gc_elasticity __read_mostly = 8;
2700
fe2c6338 2701static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write,
8d65af78 2702 void __user *buffer,
1da177e4
LT
2703 size_t *lenp, loff_t *ppos)
2704{
5aad1de5
TT
2705 struct net *net = (struct net *)__ctl->extra1;
2706
1da177e4 2707 if (write) {
5aad1de5
TT
2708 rt_cache_flush(net);
2709 fnhe_genid_bump(net);
1da177e4 2710 return 0;
e905a9ed 2711 }
1da177e4
LT
2712
2713 return -EINVAL;
2714}
2715
fe2c6338 2716static struct ctl_table ipv4_route_table[] = {
1da177e4 2717 {
1da177e4
LT
2718 .procname = "gc_thresh",
2719 .data = &ipv4_dst_ops.gc_thresh,
2720 .maxlen = sizeof(int),
2721 .mode = 0644,
6d9f239a 2722 .proc_handler = proc_dointvec,
1da177e4
LT
2723 },
2724 {
1da177e4
LT
2725 .procname = "max_size",
2726 .data = &ip_rt_max_size,
2727 .maxlen = sizeof(int),
2728 .mode = 0644,
6d9f239a 2729 .proc_handler = proc_dointvec,
1da177e4
LT
2730 },
2731 {
2732 /* Deprecated. Use gc_min_interval_ms */
e905a9ed 2733
1da177e4
LT
2734 .procname = "gc_min_interval",
2735 .data = &ip_rt_gc_min_interval,
2736 .maxlen = sizeof(int),
2737 .mode = 0644,
6d9f239a 2738 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT
2739 },
2740 {
1da177e4
LT
2741 .procname = "gc_min_interval_ms",
2742 .data = &ip_rt_gc_min_interval,
2743 .maxlen = sizeof(int),
2744 .mode = 0644,
6d9f239a 2745 .proc_handler = proc_dointvec_ms_jiffies,
1da177e4
LT
2746 },
2747 {
1da177e4
LT
2748 .procname = "gc_timeout",
2749 .data = &ip_rt_gc_timeout,
2750 .maxlen = sizeof(int),
2751 .mode = 0644,
6d9f239a 2752 .proc_handler = proc_dointvec_jiffies,
1da177e4 2753 },
9f28a2fc
ED
2754 {
2755 .procname = "gc_interval",
2756 .data = &ip_rt_gc_interval,
2757 .maxlen = sizeof(int),
2758 .mode = 0644,
2759 .proc_handler = proc_dointvec_jiffies,
2760 },
1da177e4 2761 {
1da177e4
LT
2762 .procname = "redirect_load",
2763 .data = &ip_rt_redirect_load,
2764 .maxlen = sizeof(int),
2765 .mode = 0644,
6d9f239a 2766 .proc_handler = proc_dointvec,
1da177e4
LT
2767 },
2768 {
1da177e4
LT
2769 .procname = "redirect_number",
2770 .data = &ip_rt_redirect_number,
2771 .maxlen = sizeof(int),
2772 .mode = 0644,
6d9f239a 2773 .proc_handler = proc_dointvec,
1da177e4
LT
2774 },
2775 {
1da177e4
LT
2776 .procname = "redirect_silence",
2777 .data = &ip_rt_redirect_silence,
2778 .maxlen = sizeof(int),
2779 .mode = 0644,
6d9f239a 2780 .proc_handler = proc_dointvec,
1da177e4
LT
2781 },
2782 {
1da177e4
LT
2783 .procname = "error_cost",
2784 .data = &ip_rt_error_cost,
2785 .maxlen = sizeof(int),
2786 .mode = 0644,
6d9f239a 2787 .proc_handler = proc_dointvec,
1da177e4
LT
2788 },
2789 {
1da177e4
LT
2790 .procname = "error_burst",
2791 .data = &ip_rt_error_burst,
2792 .maxlen = sizeof(int),
2793 .mode = 0644,
6d9f239a 2794 .proc_handler = proc_dointvec,
1da177e4
LT
2795 },
2796 {
1da177e4
LT
2797 .procname = "gc_elasticity",
2798 .data = &ip_rt_gc_elasticity,
2799 .maxlen = sizeof(int),
2800 .mode = 0644,
6d9f239a 2801 .proc_handler = proc_dointvec,
1da177e4
LT
2802 },
2803 {
1da177e4
LT
2804 .procname = "mtu_expires",
2805 .data = &ip_rt_mtu_expires,
2806 .maxlen = sizeof(int),
2807 .mode = 0644,
6d9f239a 2808 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT
2809 },
2810 {
1da177e4
LT
2811 .procname = "min_pmtu",
2812 .data = &ip_rt_min_pmtu,
2813 .maxlen = sizeof(int),
2814 .mode = 0644,
6d9f239a 2815 .proc_handler = proc_dointvec,
1da177e4
LT
2816 },
2817 {
1da177e4
LT
2818 .procname = "min_adv_mss",
2819 .data = &ip_rt_min_advmss,
2820 .maxlen = sizeof(int),
2821 .mode = 0644,
6d9f239a 2822 .proc_handler = proc_dointvec,
1da177e4 2823 },
f8572d8f 2824 { }
1da177e4 2825};
39a23e75 2826
39a23e75
DL
2827static struct ctl_table ipv4_route_flush_table[] = {
2828 {
39a23e75
DL
2829 .procname = "flush",
2830 .maxlen = sizeof(int),
2831 .mode = 0200,
6d9f239a 2832 .proc_handler = ipv4_sysctl_rtcache_flush,
39a23e75 2833 },
f8572d8f 2834 { },
39a23e75
DL
2835};
2836
2837static __net_init int sysctl_route_net_init(struct net *net)
2838{
2839 struct ctl_table *tbl;
2840
2841 tbl = ipv4_route_flush_table;
09ad9bc7 2842 if (!net_eq(net, &init_net)) {
39a23e75 2843 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
51456b29 2844 if (!tbl)
39a23e75 2845 goto err_dup;
464dc801
EB
2846
2847 /* Don't export sysctls to unprivileged users */
2848 if (net->user_ns != &init_user_ns)
2849 tbl[0].procname = NULL;
39a23e75
DL
2850 }
2851 tbl[0].extra1 = net;
2852
ec8f23ce 2853 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
51456b29 2854 if (!net->ipv4.route_hdr)
39a23e75
DL
2855 goto err_reg;
2856 return 0;
2857
2858err_reg:
2859 if (tbl != ipv4_route_flush_table)
2860 kfree(tbl);
2861err_dup:
2862 return -ENOMEM;
2863}
2864
2865static __net_exit void sysctl_route_net_exit(struct net *net)
2866{
2867 struct ctl_table *tbl;
2868
2869 tbl = net->ipv4.route_hdr->ctl_table_arg;
2870 unregister_net_sysctl_table(net->ipv4.route_hdr);
2871 BUG_ON(tbl == ipv4_route_flush_table);
2872 kfree(tbl);
2873}
2874
2875static __net_initdata struct pernet_operations sysctl_route_ops = {
2876 .init = sysctl_route_net_init,
2877 .exit = sysctl_route_net_exit,
2878};
1da177e4
LT
2879#endif
2880
3ee94372 2881static __net_init int rt_genid_init(struct net *net)
9f5e97e5 2882{
ca4c3fc2 2883 atomic_set(&net->ipv4.rt_genid, 0);
5aad1de5 2884 atomic_set(&net->fnhe_genid, 0);
436c3b66
DM
2885 get_random_bytes(&net->ipv4.dev_addr_genid,
2886 sizeof(net->ipv4.dev_addr_genid));
9f5e97e5
DL
2887 return 0;
2888}
2889
3ee94372
NH
2890static __net_initdata struct pernet_operations rt_genid_ops = {
2891 .init = rt_genid_init,
9f5e97e5
DL
2892};
2893
c3426b47
DM
2894static int __net_init ipv4_inetpeer_init(struct net *net)
2895{
2896 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2897
2898 if (!bp)
2899 return -ENOMEM;
2900 inet_peer_base_init(bp);
2901 net->ipv4.peers = bp;
2902 return 0;
2903}
2904
2905static void __net_exit ipv4_inetpeer_exit(struct net *net)
2906{
2907 struct inet_peer_base *bp = net->ipv4.peers;
2908
2909 net->ipv4.peers = NULL;
56a6b248 2910 inetpeer_invalidate_tree(bp);
c3426b47
DM
2911 kfree(bp);
2912}
2913
2914static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
2915 .init = ipv4_inetpeer_init,
2916 .exit = ipv4_inetpeer_exit,
2917};
9f5e97e5 2918
c7066f70 2919#ifdef CONFIG_IP_ROUTE_CLASSID
7d720c3e 2920struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
c7066f70 2921#endif /* CONFIG_IP_ROUTE_CLASSID */
1da177e4 2922
1da177e4
LT
2923int __init ip_rt_init(void)
2924{
424c4b70 2925 int rc = 0;
5055c371 2926 int cpu;
1da177e4 2927
73f156a6
ED
2928 ip_idents = kmalloc(IP_IDENTS_SZ * sizeof(*ip_idents), GFP_KERNEL);
2929 if (!ip_idents)
2930 panic("IP: failed to allocate ip_idents\n");
2931
2932 prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));
2933
355b590c
ED
2934 ip_tstamps = kcalloc(IP_IDENTS_SZ, sizeof(*ip_tstamps), GFP_KERNEL);
2935 if (!ip_tstamps)
2936 panic("IP: failed to allocate ip_tstamps\n");
2937
5055c371
ED
2938 for_each_possible_cpu(cpu) {
2939 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
2940
2941 INIT_LIST_HEAD(&ul->head);
2942 spin_lock_init(&ul->lock);
2943 }
c7066f70 2944#ifdef CONFIG_IP_ROUTE_CLASSID
0dcec8c2 2945 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
1da177e4
LT
2946 if (!ip_rt_acct)
2947 panic("IP: failed to allocate ip_rt_acct\n");
1da177e4
LT
2948#endif
2949
e5d679f3
AD
2950 ipv4_dst_ops.kmem_cachep =
2951 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
20c2df83 2952 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1da177e4 2953
14e50e57
DM
2954 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
2955
fc66f95c
ED
2956 if (dst_entries_init(&ipv4_dst_ops) < 0)
2957 panic("IP: failed to allocate ipv4_dst_ops counter\n");
2958
2959 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
2960 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
2961
89aef892
DM
2962 ipv4_dst_ops.gc_thresh = ~0;
2963 ip_rt_max_size = INT_MAX;
1da177e4 2964
1da177e4
LT
2965 devinet_init();
2966 ip_fib_init();
2967
73b38711 2968 if (ip_rt_proc_init())
058bd4d2 2969 pr_err("Unable to create route proc files\n");
1da177e4
LT
2970#ifdef CONFIG_XFRM
2971 xfrm_init();
703fb94e 2972 xfrm4_init();
1da177e4 2973#endif
c7ac8679 2974 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL, NULL);
63f3444f 2975
39a23e75
DL
2976#ifdef CONFIG_SYSCTL
2977 register_pernet_subsys(&sysctl_route_ops);
2978#endif
3ee94372 2979 register_pernet_subsys(&rt_genid_ops);
c3426b47 2980 register_pernet_subsys(&ipv4_inetpeer_ops);
1da177e4
LT
2981 return rc;
2982}
2983
a1bc6eb4 2984#ifdef CONFIG_SYSCTL
eeb61f71
AV
2985/*
2986 * We really need to sanitize the damn ipv4 init order, then all
2987 * this nonsense will go away.
2988 */
2989void __init ip_static_sysctl_init(void)
2990{
4e5ca785 2991 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);
eeb61f71 2992}
a1bc6eb4 2993#endif