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