Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * INET An implementation of the TCP/IP protocol suite for the LINUX
4 : : * operating system. INET is implemented using the BSD Socket
5 : : * interface as the means of communication with the user level.
6 : : *
7 : : * ROUTE - implementation of the IP router.
8 : : *
9 : : * Authors: Ross Biro
10 : : * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
11 : : * Alan Cox, <gw4pts@gw4pts.ampr.org>
12 : : * Linus Torvalds, <Linus.Torvalds@helsinki.fi>
13 : : * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
14 : : *
15 : : * Fixes:
16 : : * Alan Cox : Verify area fixes.
17 : : * Alan Cox : cli() protects routing changes
18 : : * Rui Oliveira : ICMP routing table updates
19 : : * (rco@di.uminho.pt) Routing table insertion and update
20 : : * Linus Torvalds : Rewrote bits to be sensible
21 : : * Alan Cox : Added BSD route gw semantics
22 : : * Alan Cox : Super /proc >4K
23 : : * Alan Cox : MTU in route table
24 : : * Alan Cox : MSS actually. Also added the window
25 : : * clamper.
26 : : * Sam Lantinga : Fixed route matching in rt_del()
27 : : * Alan Cox : Routing cache support.
28 : : * Alan Cox : Removed compatibility cruft.
29 : : * Alan Cox : RTF_REJECT support.
30 : : * Alan Cox : TCP irtt support.
31 : : * Jonathan Naylor : Added Metric support.
32 : : * Miquel van Smoorenburg : BSD API fixes.
33 : : * Miquel van Smoorenburg : Metrics.
34 : : * Alan Cox : Use __u32 properly
35 : : * Alan Cox : Aligned routing errors more closely with BSD
36 : : * our system is still very different.
37 : : * Alan Cox : Faster /proc handling
38 : : * Alexey Kuznetsov : Massive rework to support tree based routing,
39 : : * routing caches and better behaviour.
40 : : *
41 : : * Olaf Erb : irtt wasn't being copied right.
42 : : * Bjorn Ekwall : Kerneld route support.
43 : : * Alan Cox : Multicast fixed (I hope)
44 : : * Pavel Krauz : Limited broadcast fixed
45 : : * Mike McLagan : Routing by source
46 : : * Alexey Kuznetsov : End of old history. Split to fib.c and
47 : : * route.c and rewritten from scratch.
48 : : * Andi Kleen : Load-limit warning messages.
49 : : * Vitaly E. Lavrov : Transparent proxy revived after year coma.
50 : : * Vitaly E. Lavrov : Race condition in ip_route_input_slow.
51 : : * Tobias Ringstrom : Uninitialized res.type in ip_route_output_slow.
52 : : * Vladimir V. Ivanov : IP rule info (flowid) is really useful.
53 : : * Marc Boucher : routing by fwmark
54 : : * Robert Olsson : Added rt_cache statistics
55 : : * Arnaldo C. Melo : Convert proc stuff to seq_file
56 : : * Eric Dumazet : hashed spinlocks and rt_check_expire() fixes.
57 : : * Ilia Sotnikov : Ignore TOS on PMTUD and Redirect
58 : : * Ilia Sotnikov : Removed TOS from hash calculations
59 : : */
60 : :
61 : : #define pr_fmt(fmt) "IPv4: " fmt
62 : :
63 : : #include <linux/module.h>
64 : : #include <linux/uaccess.h>
65 : : #include <linux/bitops.h>
66 : : #include <linux/types.h>
67 : : #include <linux/kernel.h>
68 : : #include <linux/mm.h>
69 : : #include <linux/string.h>
70 : : #include <linux/socket.h>
71 : : #include <linux/sockios.h>
72 : : #include <linux/errno.h>
73 : : #include <linux/in.h>
74 : : #include <linux/inet.h>
75 : : #include <linux/netdevice.h>
76 : : #include <linux/proc_fs.h>
77 : : #include <linux/init.h>
78 : : #include <linux/skbuff.h>
79 : : #include <linux/inetdevice.h>
80 : : #include <linux/igmp.h>
81 : : #include <linux/pkt_sched.h>
82 : : #include <linux/mroute.h>
83 : : #include <linux/netfilter_ipv4.h>
84 : : #include <linux/random.h>
85 : : #include <linux/rcupdate.h>
86 : : #include <linux/times.h>
87 : : #include <linux/slab.h>
88 : : #include <linux/jhash.h>
89 : : #include <net/dst.h>
90 : : #include <net/dst_metadata.h>
91 : : #include <net/net_namespace.h>
92 : : #include <net/protocol.h>
93 : : #include <net/ip.h>
94 : : #include <net/route.h>
95 : : #include <net/inetpeer.h>
96 : : #include <net/sock.h>
97 : : #include <net/ip_fib.h>
98 : : #include <net/nexthop.h>
99 : : #include <net/arp.h>
100 : : #include <net/tcp.h>
101 : : #include <net/icmp.h>
102 : : #include <net/xfrm.h>
103 : : #include <net/lwtunnel.h>
104 : : #include <net/netevent.h>
105 : : #include <net/rtnetlink.h>
106 : : #ifdef CONFIG_SYSCTL
107 : : #include <linux/sysctl.h>
108 : : #endif
109 : : #include <net/secure_seq.h>
110 : : #include <net/ip_tunnels.h>
111 : : #include <net/l3mdev.h>
112 : :
113 : : #include "fib_lookup.h"
114 : :
115 : : #define RT_FL_TOS(oldflp4) \
116 : : ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
117 : :
118 : : #define RT_GC_TIMEOUT (300*HZ)
119 : :
120 : : static int ip_rt_max_size;
121 : : static int ip_rt_redirect_number __read_mostly = 9;
122 : : static int ip_rt_redirect_load __read_mostly = HZ / 50;
123 : : static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
124 : : static int ip_rt_error_cost __read_mostly = HZ;
125 : : static int ip_rt_error_burst __read_mostly = 5 * HZ;
126 : : static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
127 : : static u32 ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
128 : : static int ip_rt_min_advmss __read_mostly = 256;
129 : :
130 : : static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
131 : :
132 : : /*
133 : : * Interface to generic destination cache.
134 : : */
135 : :
136 : : static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
137 : : static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
138 : : static unsigned int ipv4_mtu(const struct dst_entry *dst);
139 : : static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
140 : : static void ipv4_link_failure(struct sk_buff *skb);
141 : : static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
142 : : struct sk_buff *skb, u32 mtu,
143 : : bool confirm_neigh);
144 : : static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,
145 : : struct sk_buff *skb);
146 : : static void ipv4_dst_destroy(struct dst_entry *dst);
147 : :
148 : 0 : static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
149 : : {
150 : 0 : WARN_ON(1);
151 : 0 : return NULL;
152 : : }
153 : :
154 : : static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
155 : : struct sk_buff *skb,
156 : : const void *daddr);
157 : : static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr);
158 : :
159 : : static struct dst_ops ipv4_dst_ops = {
160 : : .family = AF_INET,
161 : : .check = ipv4_dst_check,
162 : : .default_advmss = ipv4_default_advmss,
163 : : .mtu = ipv4_mtu,
164 : : .cow_metrics = ipv4_cow_metrics,
165 : : .destroy = ipv4_dst_destroy,
166 : : .negative_advice = ipv4_negative_advice,
167 : : .link_failure = ipv4_link_failure,
168 : : .update_pmtu = ip_rt_update_pmtu,
169 : : .redirect = ip_do_redirect,
170 : : .local_out = __ip_local_out,
171 : : .neigh_lookup = ipv4_neigh_lookup,
172 : : .confirm_neigh = ipv4_confirm_neigh,
173 : : };
174 : :
175 : : #define ECN_OR_COST(class) TC_PRIO_##class
176 : :
177 : : const __u8 ip_tos2prio[16] = {
178 : : TC_PRIO_BESTEFFORT,
179 : : ECN_OR_COST(BESTEFFORT),
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 : : };
195 : : EXPORT_SYMBOL(ip_tos2prio);
196 : :
197 : : static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
198 : : #define RT_CACHE_STAT_INC(field) raw_cpu_inc(rt_cache_stat.field)
199 : :
200 : : #ifdef CONFIG_PROC_FS
201 : 0 : static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
202 : : {
203 [ # # ]: 0 : if (*pos)
204 : 0 : return NULL;
205 : : return SEQ_START_TOKEN;
206 : : }
207 : :
208 : 0 : static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
209 : : {
210 : 0 : ++*pos;
211 : 0 : return NULL;
212 : : }
213 : :
214 : 0 : static void rt_cache_seq_stop(struct seq_file *seq, void *v)
215 : : {
216 : 0 : }
217 : :
218 : 0 : static int rt_cache_seq_show(struct seq_file *seq, void *v)
219 : : {
220 [ # # ]: 0 : if (v == SEQ_START_TOKEN)
221 : 0 : 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");
225 : 0 : return 0;
226 : : }
227 : :
228 : : static const struct seq_operations rt_cache_seq_ops = {
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 : :
235 : 0 : static int rt_cache_seq_open(struct inode *inode, struct file *file)
236 : : {
237 : 0 : return seq_open(file, &rt_cache_seq_ops);
238 : : }
239 : :
240 : : static const struct proc_ops rt_cache_proc_ops = {
241 : : .proc_open = rt_cache_seq_open,
242 : : .proc_read = seq_read,
243 : : .proc_lseek = seq_lseek,
244 : : .proc_release = seq_release,
245 : : };
246 : :
247 : :
248 : 0 : static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
249 : : {
250 : 0 : int cpu;
251 : :
252 [ # # ]: 0 : if (*pos == 0)
253 : : return SEQ_START_TOKEN;
254 : :
255 [ # # ]: 0 : for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
256 [ # # ]: 0 : if (!cpu_possible(cpu))
257 : 0 : continue;
258 : 0 : *pos = cpu+1;
259 : 0 : return &per_cpu(rt_cache_stat, cpu);
260 : : }
261 : : return NULL;
262 : : }
263 : :
264 : 0 : static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
265 : : {
266 : 0 : int cpu;
267 : :
268 [ # # ]: 0 : for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
269 [ # # ]: 0 : if (!cpu_possible(cpu))
270 : 0 : continue;
271 : 0 : *pos = cpu+1;
272 : 0 : return &per_cpu(rt_cache_stat, cpu);
273 : : }
274 : 0 : (*pos)++;
275 : 0 : return NULL;
276 : :
277 : : }
278 : :
279 : 0 : static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
280 : : {
281 : :
282 : 0 : }
283 : :
284 : 0 : static int rt_cpu_seq_show(struct seq_file *seq, void *v)
285 : : {
286 : 0 : struct rt_cache_stat *st = v;
287 : :
288 [ # # ]: 0 : if (v == SEQ_START_TOKEN) {
289 : 0 : 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");
290 : 0 : return 0;
291 : : }
292 : :
293 : 0 : seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
294 : : " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
295 : : dst_entries_get_slow(&ipv4_dst_ops),
296 : : 0, /* st->in_hit */
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 : :
304 : : 0, /* st->out_hit */
305 : : st->out_slow_tot,
306 : : st->out_slow_mc,
307 : :
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 */
314 : : );
315 : 0 : return 0;
316 : : }
317 : :
318 : : static const struct seq_operations rt_cpu_seq_ops = {
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 : :
326 : 0 : static int rt_cpu_seq_open(struct inode *inode, struct file *file)
327 : : {
328 : 0 : return seq_open(file, &rt_cpu_seq_ops);
329 : : }
330 : :
331 : : static const struct proc_ops rt_cpu_proc_ops = {
332 : : .proc_open = rt_cpu_seq_open,
333 : : .proc_read = seq_read,
334 : : .proc_lseek = seq_lseek,
335 : : .proc_release = seq_release,
336 : : };
337 : :
338 : : #ifdef CONFIG_IP_ROUTE_CLASSID
339 : : static int rt_acct_proc_show(struct seq_file *m, void *v)
340 : : {
341 : : struct ip_rt_acct *dst, *src;
342 : : unsigned int i, j;
343 : :
344 : : dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
345 : : if (!dst)
346 : : return -ENOMEM;
347 : :
348 : : for_each_possible_cpu(i) {
349 : : src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
350 : : for (j = 0; j < 256; j++) {
351 : : dst[j].o_bytes += src[j].o_bytes;
352 : : dst[j].o_packets += src[j].o_packets;
353 : : dst[j].i_bytes += src[j].i_bytes;
354 : : dst[j].i_packets += src[j].i_packets;
355 : : }
356 : : }
357 : :
358 : : seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
359 : : kfree(dst);
360 : : return 0;
361 : : }
362 : : #endif
363 : :
364 : 30 : static int __net_init ip_rt_do_proc_init(struct net *net)
365 : : {
366 : 30 : struct proc_dir_entry *pde;
367 : :
368 : 30 : pde = proc_create("rt_cache", 0444, net->proc_net,
369 : : &rt_cache_proc_ops);
370 [ - + ]: 30 : if (!pde)
371 : 0 : goto err1;
372 : :
373 : 30 : pde = proc_create("rt_cache", 0444,
374 : : net->proc_net_stat, &rt_cpu_proc_ops);
375 [ - + ]: 30 : if (!pde)
376 : 0 : goto err2;
377 : :
378 : : #ifdef CONFIG_IP_ROUTE_CLASSID
379 : : pde = proc_create_single("rt_acct", 0, net->proc_net,
380 : : rt_acct_proc_show);
381 : : if (!pde)
382 : : goto err3;
383 : : #endif
384 : : return 0;
385 : :
386 : : #ifdef CONFIG_IP_ROUTE_CLASSID
387 : : err3:
388 : : remove_proc_entry("rt_cache", net->proc_net_stat);
389 : : #endif
390 : : err2:
391 : 0 : remove_proc_entry("rt_cache", net->proc_net);
392 : : err1:
393 : : return -ENOMEM;
394 : : }
395 : :
396 : 0 : static void __net_exit ip_rt_do_proc_exit(struct net *net)
397 : : {
398 : 0 : remove_proc_entry("rt_cache", net->proc_net_stat);
399 : 0 : remove_proc_entry("rt_cache", net->proc_net);
400 : : #ifdef CONFIG_IP_ROUTE_CLASSID
401 : : remove_proc_entry("rt_acct", net->proc_net);
402 : : #endif
403 : 0 : }
404 : :
405 : : static struct pernet_operations ip_rt_proc_ops __net_initdata = {
406 : : .init = ip_rt_do_proc_init,
407 : : .exit = ip_rt_do_proc_exit,
408 : : };
409 : :
410 : 30 : static int __init ip_rt_proc_init(void)
411 : : {
412 : 30 : return register_pernet_subsys(&ip_rt_proc_ops);
413 : : }
414 : :
415 : : #else
416 : : static inline int ip_rt_proc_init(void)
417 : : {
418 : : return 0;
419 : : }
420 : : #endif /* CONFIG_PROC_FS */
421 : :
422 : 30 : static inline bool rt_is_expired(const struct rtable *rth)
423 : : {
424 : 30 : return rth->rt_genid != rt_genid_ipv4(dev_net(rth->dst.dev));
425 : : }
426 : :
427 : 228 : void rt_cache_flush(struct net *net)
428 : : {
429 : 228 : rt_genid_bump_ipv4(net);
430 : 192 : }
431 : :
432 : 0 : static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
433 : : struct sk_buff *skb,
434 : : const void *daddr)
435 : : {
436 : 0 : const struct rtable *rt = container_of(dst, struct rtable, dst);
437 : 0 : struct net_device *dev = dst->dev;
438 : 0 : struct neighbour *n;
439 : :
440 : 0 : rcu_read_lock_bh();
441 : :
442 [ # # ]: 0 : if (likely(rt->rt_gw_family == AF_INET)) {
443 : 0 : n = ip_neigh_gw4(dev, rt->rt_gw4);
444 [ # # ]: 0 : } else if (rt->rt_gw_family == AF_INET6) {
445 : 0 : n = ip_neigh_gw6(dev, &rt->rt_gw6);
446 : : } else {
447 : 0 : __be32 pkey;
448 : :
449 [ # # ]: 0 : pkey = skb ? ip_hdr(skb)->daddr : *((__be32 *) daddr);
450 : 0 : n = ip_neigh_gw4(dev, pkey);
451 : : }
452 : :
453 [ # # # # ]: 0 : if (!IS_ERR(n) && !refcount_inc_not_zero(&n->refcnt))
454 : 0 : n = NULL;
455 : :
456 : 0 : rcu_read_unlock_bh();
457 : :
458 : 0 : return n;
459 : : }
460 : :
461 : 0 : static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr)
462 : : {
463 : 0 : const struct rtable *rt = container_of(dst, struct rtable, dst);
464 : 0 : struct net_device *dev = dst->dev;
465 : 0 : const __be32 *pkey = daddr;
466 : :
467 [ # # ]: 0 : if (rt->rt_gw_family == AF_INET) {
468 : 0 : pkey = (const __be32 *)&rt->rt_gw4;
469 [ # # ]: 0 : } else if (rt->rt_gw_family == AF_INET6) {
470 : 0 : return __ipv6_confirm_neigh_stub(dev, &rt->rt_gw6);
471 [ # # ]: 0 : } else if (!daddr ||
472 [ # # ]: 0 : (rt->rt_flags &
473 : : (RTCF_MULTICAST | RTCF_BROADCAST | RTCF_LOCAL))) {
474 : : return;
475 : : }
476 : 0 : __ipv4_confirm_neigh(dev, *(__force u32 *)pkey);
477 : : }
478 : :
479 : : #define IP_IDENTS_SZ 2048u
480 : :
481 : : static atomic_t *ip_idents __read_mostly;
482 : : static u32 *ip_tstamps __read_mostly;
483 : :
484 : : /* In order to protect privacy, we add a perturbation to identifiers
485 : : * if one generator is seldom used. This makes hard for an attacker
486 : : * to infer how many packets were sent between two points in time.
487 : : */
488 : 0 : u32 ip_idents_reserve(u32 hash, int segs)
489 : : {
490 : 0 : u32 *p_tstamp = ip_tstamps + hash % IP_IDENTS_SZ;
491 : 0 : atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ;
492 [ # # ]: 0 : u32 old = READ_ONCE(*p_tstamp);
493 : 0 : u32 now = (u32)jiffies;
494 : 0 : u32 new, delta = 0;
495 : :
496 [ # # # # ]: 0 : if (old != now && cmpxchg(p_tstamp, old, now) == old)
497 : 0 : delta = prandom_u32_max(now - old);
498 : :
499 : : /* Do not use atomic_add_return() as it makes UBSAN unhappy */
500 : 0 : do {
501 : 0 : old = (u32)atomic_read(p_id);
502 : 0 : new = old + delta + segs;
503 [ # # ]: 0 : } while (atomic_cmpxchg(p_id, old, new) != old);
504 : :
505 : 0 : return new - segs;
506 : : }
507 : : EXPORT_SYMBOL(ip_idents_reserve);
508 : :
509 : 0 : void __ip_select_ident(struct net *net, struct iphdr *iph, int segs)
510 : : {
511 : 0 : u32 hash, id;
512 : :
513 : : /* Note the following code is not safe, but this is okay. */
514 [ # # ]: 0 : if (unlikely(siphash_key_is_zero(&net->ipv4.ip_id_key)))
515 : 0 : get_random_bytes(&net->ipv4.ip_id_key,
516 : : sizeof(net->ipv4.ip_id_key));
517 : :
518 : 0 : hash = siphash_3u32((__force u32)iph->daddr,
519 : 0 : (__force u32)iph->saddr,
520 : 0 : iph->protocol,
521 : 0 : &net->ipv4.ip_id_key);
522 : 0 : id = ip_idents_reserve(hash, segs);
523 : 0 : iph->id = htons(id);
524 : 0 : }
525 : : EXPORT_SYMBOL(__ip_select_ident);
526 : :
527 : 0 : static void __build_flow_key(const struct net *net, struct flowi4 *fl4,
528 : : const struct sock *sk,
529 : : const struct iphdr *iph,
530 : : int oif, u8 tos,
531 : : u8 prot, u32 mark, int flow_flags)
532 : : {
533 [ # # ]: 0 : if (sk) {
534 : 0 : const struct inet_sock *inet = inet_sk(sk);
535 : :
536 : 0 : oif = sk->sk_bound_dev_if;
537 : 0 : mark = sk->sk_mark;
538 : 0 : tos = RT_CONN_FLAGS(sk);
539 [ # # ]: 0 : prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
540 : : }
541 [ # # ]: 0 : flowi4_init_output(fl4, oif, mark, tos,
542 : : RT_SCOPE_UNIVERSE, prot,
543 : : flow_flags,
544 : : iph->daddr, iph->saddr, 0, 0,
545 : : sock_net_uid(net, sk));
546 : 0 : }
547 : :
548 : 0 : static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
549 : : const struct sock *sk)
550 : : {
551 : 0 : const struct net *net = dev_net(skb->dev);
552 : 0 : const struct iphdr *iph = ip_hdr(skb);
553 : 0 : int oif = skb->dev->ifindex;
554 : 0 : u8 tos = RT_TOS(iph->tos);
555 : 0 : u8 prot = iph->protocol;
556 : 0 : u32 mark = skb->mark;
557 : :
558 : 0 : __build_flow_key(net, fl4, sk, iph, oif, tos, prot, mark, 0);
559 : 0 : }
560 : :
561 : 0 : static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
562 : : {
563 : 0 : const struct inet_sock *inet = inet_sk(sk);
564 : 0 : const struct ip_options_rcu *inet_opt;
565 : 0 : __be32 daddr = inet->inet_daddr;
566 : :
567 : 0 : rcu_read_lock();
568 [ # # ]: 0 : inet_opt = rcu_dereference(inet->inet_opt);
569 [ # # # # ]: 0 : if (inet_opt && inet_opt->opt.srr)
570 : 0 : daddr = inet_opt->opt.faddr;
571 [ # # ]: 0 : flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
572 : 0 : RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
573 [ # # ]: 0 : inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
574 : : inet_sk_flowi_flags(sk),
575 : : daddr, inet->inet_saddr, 0, 0, sk->sk_uid);
576 : 0 : rcu_read_unlock();
577 : 0 : }
578 : :
579 : 0 : static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
580 : : const struct sk_buff *skb)
581 : : {
582 [ # # ]: 0 : if (skb)
583 : 0 : build_skb_flow_key(fl4, skb, sk);
584 : : else
585 : 0 : build_sk_flow_key(fl4, sk);
586 : 0 : }
587 : :
588 : : static DEFINE_SPINLOCK(fnhe_lock);
589 : :
590 : 0 : static void fnhe_flush_routes(struct fib_nh_exception *fnhe)
591 : : {
592 : 0 : struct rtable *rt;
593 : :
594 [ # # ]: 0 : rt = rcu_dereference(fnhe->fnhe_rth_input);
595 [ # # ]: 0 : if (rt) {
596 : 0 : RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL);
597 : 0 : dst_dev_put(&rt->dst);
598 : 0 : dst_release(&rt->dst);
599 : : }
600 [ # # ]: 0 : rt = rcu_dereference(fnhe->fnhe_rth_output);
601 [ # # ]: 0 : if (rt) {
602 : 0 : RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL);
603 : 0 : dst_dev_put(&rt->dst);
604 : 0 : dst_release(&rt->dst);
605 : : }
606 : 0 : }
607 : :
608 : 0 : static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
609 : : {
610 : 0 : struct fib_nh_exception *fnhe, *oldest;
611 : :
612 : 0 : oldest = rcu_dereference(hash->chain);
613 [ # # ]: 0 : for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
614 : 0 : fnhe = rcu_dereference(fnhe->fnhe_next)) {
615 [ # # ]: 0 : if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
616 : 0 : oldest = fnhe;
617 : : }
618 : 0 : fnhe_flush_routes(oldest);
619 : 0 : return oldest;
620 : : }
621 : :
622 : 0 : static inline u32 fnhe_hashfun(__be32 daddr)
623 : : {
624 : 0 : static u32 fnhe_hashrnd __read_mostly;
625 : 0 : u32 hval;
626 : :
627 [ # # # # : 0 : net_get_random_once(&fnhe_hashrnd, sizeof(fnhe_hashrnd));
# # ]
628 : 0 : hval = jhash_1word((__force u32) daddr, fnhe_hashrnd);
629 : 0 : return hash_32(hval, FNHE_HASH_SHIFT);
630 : : }
631 : :
632 : 0 : static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnhe)
633 : : {
634 : 0 : rt->rt_pmtu = fnhe->fnhe_pmtu;
635 : 0 : rt->rt_mtu_locked = fnhe->fnhe_mtu_locked;
636 : 0 : rt->dst.expires = fnhe->fnhe_expires;
637 : :
638 : 0 : if (fnhe->fnhe_gw) {
639 : 0 : rt->rt_flags |= RTCF_REDIRECTED;
640 : 0 : rt->rt_uses_gateway = 1;
641 : 0 : rt->rt_gw_family = AF_INET;
642 : 0 : rt->rt_gw4 = fnhe->fnhe_gw;
643 : : }
644 : : }
645 : :
646 : 0 : static void update_or_create_fnhe(struct fib_nh_common *nhc, __be32 daddr,
647 : : __be32 gw, u32 pmtu, bool lock,
648 : : unsigned long expires)
649 : : {
650 : 0 : struct fnhe_hash_bucket *hash;
651 : 0 : struct fib_nh_exception *fnhe;
652 : 0 : struct rtable *rt;
653 : 0 : u32 genid, hval;
654 : 0 : unsigned int i;
655 : 0 : int depth;
656 : :
657 : 0 : genid = fnhe_genid(dev_net(nhc->nhc_dev));
658 : 0 : hval = fnhe_hashfun(daddr);
659 : :
660 : 0 : spin_lock_bh(&fnhe_lock);
661 : :
662 [ # # ]: 0 : hash = rcu_dereference(nhc->nhc_exceptions);
663 [ # # ]: 0 : if (!hash) {
664 : 0 : hash = kcalloc(FNHE_HASH_SIZE, sizeof(*hash), GFP_ATOMIC);
665 [ # # ]: 0 : if (!hash)
666 : 0 : goto out_unlock;
667 : 0 : rcu_assign_pointer(nhc->nhc_exceptions, hash);
668 : : }
669 : :
670 : 0 : hash += hval;
671 : :
672 : 0 : depth = 0;
673 [ # # ]: 0 : for (fnhe = rcu_dereference(hash->chain); fnhe;
674 : 0 : fnhe = rcu_dereference(fnhe->fnhe_next)) {
675 [ # # ]: 0 : if (fnhe->fnhe_daddr == daddr)
676 : : break;
677 : 0 : depth++;
678 : : }
679 : :
680 [ # # ]: 0 : if (fnhe) {
681 [ # # ]: 0 : if (fnhe->fnhe_genid != genid)
682 : 0 : fnhe->fnhe_genid = genid;
683 [ # # ]: 0 : if (gw)
684 : 0 : fnhe->fnhe_gw = gw;
685 [ # # ]: 0 : if (pmtu) {
686 : 0 : fnhe->fnhe_pmtu = pmtu;
687 : 0 : fnhe->fnhe_mtu_locked = lock;
688 : : }
689 : 0 : fnhe->fnhe_expires = max(1UL, expires);
690 : : /* Update all cached dsts too */
691 [ # # ]: 0 : rt = rcu_dereference(fnhe->fnhe_rth_input);
692 [ # # ]: 0 : if (rt)
693 [ # # ]: 0 : fill_route_from_fnhe(rt, fnhe);
694 [ # # ]: 0 : rt = rcu_dereference(fnhe->fnhe_rth_output);
695 [ # # ]: 0 : if (rt)
696 [ # # ]: 0 : fill_route_from_fnhe(rt, fnhe);
697 : : } else {
698 [ # # ]: 0 : if (depth > FNHE_RECLAIM_DEPTH)
699 : 0 : fnhe = fnhe_oldest(hash);
700 : : else {
701 : 0 : fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
702 [ # # ]: 0 : if (!fnhe)
703 : 0 : goto out_unlock;
704 : :
705 : 0 : fnhe->fnhe_next = hash->chain;
706 : 0 : rcu_assign_pointer(hash->chain, fnhe);
707 : : }
708 : 0 : fnhe->fnhe_genid = genid;
709 : 0 : fnhe->fnhe_daddr = daddr;
710 : 0 : fnhe->fnhe_gw = gw;
711 : 0 : fnhe->fnhe_pmtu = pmtu;
712 : 0 : fnhe->fnhe_mtu_locked = lock;
713 : 0 : fnhe->fnhe_expires = max(1UL, expires);
714 : :
715 : : /* Exception created; mark the cached routes for the nexthop
716 : : * stale, so anyone caching it rechecks if this exception
717 : : * applies to them.
718 : : */
719 [ # # ]: 0 : rt = rcu_dereference(nhc->nhc_rth_input);
720 [ # # ]: 0 : if (rt)
721 : 0 : rt->dst.obsolete = DST_OBSOLETE_KILL;
722 : :
723 [ # # ]: 0 : for_each_possible_cpu(i) {
724 : 0 : struct rtable __rcu **prt;
725 : 0 : prt = per_cpu_ptr(nhc->nhc_pcpu_rth_output, i);
726 [ # # ]: 0 : rt = rcu_dereference(*prt);
727 [ # # ]: 0 : if (rt)
728 : 0 : rt->dst.obsolete = DST_OBSOLETE_KILL;
729 : : }
730 : : }
731 : :
732 : 0 : fnhe->fnhe_stamp = jiffies;
733 : :
734 : 0 : out_unlock:
735 : 0 : spin_unlock_bh(&fnhe_lock);
736 : 0 : }
737 : :
738 : 0 : static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
739 : : bool kill_route)
740 : : {
741 [ # # ]: 0 : __be32 new_gw = icmp_hdr(skb)->un.gateway;
742 [ # # ]: 0 : __be32 old_gw = ip_hdr(skb)->saddr;
743 : 0 : struct net_device *dev = skb->dev;
744 : 0 : struct in_device *in_dev;
745 : 0 : struct fib_result res;
746 : 0 : struct neighbour *n;
747 : 0 : struct net *net;
748 : :
749 [ # # ]: 0 : switch (icmp_hdr(skb)->code & 7) {
750 : : case ICMP_REDIR_NET:
751 : : case ICMP_REDIR_NETTOS:
752 : : case ICMP_REDIR_HOST:
753 : : case ICMP_REDIR_HOSTTOS:
754 : 0 : break;
755 : :
756 : : default:
757 : 0 : return;
758 : : }
759 : :
760 [ # # # # ]: 0 : if (rt->rt_gw_family != AF_INET || rt->rt_gw4 != old_gw)
761 : : return;
762 : :
763 [ # # ]: 0 : in_dev = __in_dev_get_rcu(dev);
764 [ # # ]: 0 : if (!in_dev)
765 : : return;
766 : :
767 [ # # ]: 0 : net = dev_net(dev);
768 [ # # # # : 0 : if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
# # # # #
# # # # #
# # ]
769 [ # # # # ]: 0 : ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
770 : : ipv4_is_zeronet(new_gw))
771 : 0 : goto reject_redirect;
772 : :
773 [ # # # # ]: 0 : if (!IN_DEV_SHARED_MEDIA(in_dev)) {
774 [ # # ]: 0 : if (!inet_addr_onlink(in_dev, new_gw, old_gw))
775 : 0 : goto reject_redirect;
776 [ # # # # : 0 : if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
# # ]
777 : 0 : goto reject_redirect;
778 : : } else {
779 [ # # ]: 0 : if (inet_addr_type(net, new_gw) != RTN_UNICAST)
780 : 0 : goto reject_redirect;
781 : : }
782 : :
783 : 0 : n = __ipv4_neigh_lookup(rt->dst.dev, new_gw);
784 [ # # ]: 0 : if (!n)
785 : 0 : n = neigh_create(&arp_tbl, &new_gw, rt->dst.dev);
786 [ # # ]: 0 : if (!IS_ERR(n)) {
787 [ # # ]: 0 : if (!(n->nud_state & NUD_VALID)) {
788 : 0 : neigh_event_send(n, NULL);
789 : : } else {
790 [ # # ]: 0 : if (fib_lookup(net, fl4, &res, 0) == 0) {
791 : 0 : struct fib_nh_common *nhc = FIB_RES_NHC(res);
792 : :
793 : 0 : update_or_create_fnhe(nhc, fl4->daddr, new_gw,
794 : : 0, false,
795 : : jiffies + ip_rt_gc_timeout);
796 : : }
797 [ # # ]: 0 : if (kill_route)
798 : 0 : rt->dst.obsolete = DST_OBSOLETE_KILL;
799 : 0 : call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
800 : : }
801 : 0 : neigh_release(n);
802 : : }
803 : : return;
804 : :
805 : 0 : reject_redirect:
806 : : #ifdef CONFIG_IP_ROUTE_VERBOSE
807 [ # # # # ]: 0 : if (IN_DEV_LOG_MARTIANS(in_dev)) {
808 : 0 : const struct iphdr *iph = (const struct iphdr *) skb->data;
809 : 0 : __be32 daddr = iph->daddr;
810 : 0 : __be32 saddr = iph->saddr;
811 : :
812 [ # # ]: 0 : net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
813 : : " Advised path = %pI4 -> %pI4\n",
814 : : &old_gw, dev->name, &new_gw,
815 : : &saddr, &daddr);
816 : : }
817 : : #endif
818 : 0 : ;
819 : : }
820 : :
821 : 0 : static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
822 : : {
823 : 0 : struct rtable *rt;
824 : 0 : struct flowi4 fl4;
825 : 0 : const struct iphdr *iph = (const struct iphdr *) skb->data;
826 : 0 : struct net *net = dev_net(skb->dev);
827 : 0 : int oif = skb->dev->ifindex;
828 : 0 : u8 tos = RT_TOS(iph->tos);
829 : 0 : u8 prot = iph->protocol;
830 : 0 : u32 mark = skb->mark;
831 : :
832 : 0 : rt = (struct rtable *) dst;
833 : :
834 : 0 : __build_flow_key(net, &fl4, sk, iph, oif, tos, prot, mark, 0);
835 : 0 : __ip_do_redirect(rt, skb, &fl4, true);
836 : 0 : }
837 : :
838 : 0 : static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
839 : : {
840 : 0 : struct rtable *rt = (struct rtable *)dst;
841 : 0 : struct dst_entry *ret = dst;
842 : :
843 [ # # ]: 0 : if (rt) {
844 [ # # ]: 0 : if (dst->obsolete > 0) {
845 : 0 : ip_rt_put(rt);
846 : 0 : ret = NULL;
847 [ # # ]: 0 : } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
848 [ # # ]: 0 : rt->dst.expires) {
849 : 0 : ip_rt_put(rt);
850 : 0 : ret = NULL;
851 : : }
852 : : }
853 : 0 : return ret;
854 : : }
855 : :
856 : : /*
857 : : * Algorithm:
858 : : * 1. The first ip_rt_redirect_number redirects are sent
859 : : * with exponential backoff, then we stop sending them at all,
860 : : * assuming that the host ignores our redirects.
861 : : * 2. If we did not see packets requiring redirects
862 : : * during ip_rt_redirect_silence, we assume that the host
863 : : * forgot redirected route and start to send redirects again.
864 : : *
865 : : * This algorithm is much cheaper and more intelligent than dumb load limiting
866 : : * in icmp.c.
867 : : *
868 : : * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
869 : : * and "frag. need" (breaks PMTU discovery) in icmp.c.
870 : : */
871 : :
872 : 0 : void ip_rt_send_redirect(struct sk_buff *skb)
873 : : {
874 : 0 : struct rtable *rt = skb_rtable(skb);
875 : 0 : struct in_device *in_dev;
876 : 0 : struct inet_peer *peer;
877 : 0 : struct net *net;
878 : 0 : int log_martians;
879 : 0 : int vif;
880 : :
881 : 0 : rcu_read_lock();
882 [ # # ]: 0 : in_dev = __in_dev_get_rcu(rt->dst.dev);
883 [ # # # # : 0 : if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
# # ]
884 : 0 : rcu_read_unlock();
885 : 0 : return;
886 : : }
887 [ # # # # ]: 0 : log_martians = IN_DEV_LOG_MARTIANS(in_dev);
888 : 0 : vif = l3mdev_master_ifindex_rcu(rt->dst.dev);
889 : 0 : rcu_read_unlock();
890 : :
891 : 0 : net = dev_net(rt->dst.dev);
892 : 0 : peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, vif, 1);
893 [ # # ]: 0 : if (!peer) {
894 [ # # ]: 0 : icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
895 : : rt_nexthop(rt, ip_hdr(skb)->daddr));
896 : 0 : return;
897 : : }
898 : :
899 : : /* No redirected packets during ip_rt_redirect_silence;
900 : : * reset the algorithm.
901 : : */
902 [ # # ]: 0 : if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence)) {
903 : 0 : peer->rate_tokens = 0;
904 : 0 : peer->n_redirects = 0;
905 : : }
906 : :
907 : : /* Too many ignored redirects; do not send anything
908 : : * set dst.rate_last to the last seen redirected packet.
909 : : */
910 [ # # ]: 0 : if (peer->n_redirects >= ip_rt_redirect_number) {
911 : 0 : peer->rate_last = jiffies;
912 : 0 : goto out_put_peer;
913 : : }
914 : :
915 : : /* Check for load limit; set rate_last to the latest sent
916 : : * redirect.
917 : : */
918 [ # # ]: 0 : if (peer->rate_tokens == 0 ||
919 [ # # ]: 0 : time_after(jiffies,
920 : : (peer->rate_last +
921 : : (ip_rt_redirect_load << peer->n_redirects)))) {
922 [ # # ]: 0 : __be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);
923 : :
924 : 0 : icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
925 : 0 : peer->rate_last = jiffies;
926 : 0 : ++peer->n_redirects;
927 : : #ifdef CONFIG_IP_ROUTE_VERBOSE
928 [ # # ]: 0 : if (log_martians &&
929 [ # # ]: 0 : peer->n_redirects == ip_rt_redirect_number)
930 [ # # # # ]: 0 : net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
931 : : &ip_hdr(skb)->saddr, inet_iif(skb),
932 : : &ip_hdr(skb)->daddr, &gw);
933 : : #endif
934 : : }
935 : 0 : out_put_peer:
936 : 0 : inet_putpeer(peer);
937 : : }
938 : :
939 : 0 : static int ip_error(struct sk_buff *skb)
940 : : {
941 [ # # ]: 0 : struct rtable *rt = skb_rtable(skb);
942 : 0 : struct net_device *dev = skb->dev;
943 : 0 : struct in_device *in_dev;
944 : 0 : struct inet_peer *peer;
945 : 0 : unsigned long now;
946 : 0 : struct net *net;
947 : 0 : bool send;
948 : 0 : int code;
949 : :
950 [ # # ]: 0 : if (netif_is_l3_master(skb->dev)) {
951 : 0 : dev = __dev_get_by_index(dev_net(skb->dev), IPCB(skb)->iif);
952 [ # # ]: 0 : if (!dev)
953 : 0 : goto out;
954 : : }
955 : :
956 [ # # ]: 0 : in_dev = __in_dev_get_rcu(dev);
957 : :
958 : : /* IP on this device is disabled. */
959 [ # # ]: 0 : if (!in_dev)
960 : 0 : goto out;
961 : :
962 [ # # ]: 0 : net = dev_net(rt->dst.dev);
963 [ # # ]: 0 : if (!IN_DEV_FORWARD(in_dev)) {
964 [ # # # ]: 0 : switch (rt->dst.error) {
965 : : case EHOSTUNREACH:
966 : 0 : __IP_INC_STATS(net, IPSTATS_MIB_INADDRERRORS);
967 : : break;
968 : :
969 : : case ENETUNREACH:
970 : 0 : __IP_INC_STATS(net, IPSTATS_MIB_INNOROUTES);
971 : : break;
972 : : }
973 : 0 : goto out;
974 : : }
975 : :
976 [ # # # # ]: 0 : switch (rt->dst.error) {
977 : 0 : case EINVAL:
978 : : default:
979 : 0 : goto out;
980 : : case EHOSTUNREACH:
981 : : code = ICMP_HOST_UNREACH;
982 : : break;
983 : 0 : case ENETUNREACH:
984 : 0 : code = ICMP_NET_UNREACH;
985 : 0 : __IP_INC_STATS(net, IPSTATS_MIB_INNOROUTES);
986 : : break;
987 : 0 : case EACCES:
988 : 0 : code = ICMP_PKT_FILTERED;
989 : 0 : break;
990 : : }
991 : :
992 : 0 : peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr,
993 : : l3mdev_master_ifindex(skb->dev), 1);
994 : :
995 : 0 : send = true;
996 [ # # ]: 0 : if (peer) {
997 : 0 : now = jiffies;
998 : 0 : peer->rate_tokens += now - peer->rate_last;
999 [ # # ]: 0 : if (peer->rate_tokens > ip_rt_error_burst)
1000 : 0 : peer->rate_tokens = ip_rt_error_burst;
1001 : 0 : peer->rate_last = now;
1002 [ # # ]: 0 : if (peer->rate_tokens >= ip_rt_error_cost)
1003 : 0 : peer->rate_tokens -= ip_rt_error_cost;
1004 : : else
1005 : : send = false;
1006 : 0 : inet_putpeer(peer);
1007 : : }
1008 [ # # ]: 0 : if (send)
1009 : 0 : icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
1010 : :
1011 : 0 : out: kfree_skb(skb);
1012 : 0 : return 0;
1013 : : }
1014 : :
1015 : 0 : static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
1016 : : {
1017 : 0 : struct dst_entry *dst = &rt->dst;
1018 : 0 : u32 old_mtu = ipv4_mtu(dst);
1019 : 0 : struct fib_result res;
1020 : 0 : bool lock = false;
1021 : :
1022 [ # # ]: 0 : if (ip_mtu_locked(dst))
1023 : 0 : return;
1024 : :
1025 [ # # ]: 0 : if (old_mtu < mtu)
1026 : : return;
1027 : :
1028 [ # # ]: 0 : if (mtu < ip_rt_min_pmtu) {
1029 : 0 : lock = true;
1030 : 0 : mtu = min(old_mtu, ip_rt_min_pmtu);
1031 : : }
1032 : :
1033 [ # # # # ]: 0 : if (rt->rt_pmtu == mtu && !lock &&
1034 [ # # ]: 0 : time_before(jiffies, dst->expires - ip_rt_mtu_expires / 2))
1035 : : return;
1036 : :
1037 : 0 : rcu_read_lock();
1038 [ # # ]: 0 : if (fib_lookup(dev_net(dst->dev), fl4, &res, 0) == 0) {
1039 : 0 : struct fib_nh_common *nhc = FIB_RES_NHC(res);
1040 : :
1041 : 0 : update_or_create_fnhe(nhc, fl4->daddr, 0, mtu, lock,
1042 : : jiffies + ip_rt_mtu_expires);
1043 : : }
1044 : 0 : rcu_read_unlock();
1045 : : }
1046 : :
1047 : 0 : static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1048 : : struct sk_buff *skb, u32 mtu,
1049 : : bool confirm_neigh)
1050 : : {
1051 : 0 : struct rtable *rt = (struct rtable *) dst;
1052 : 0 : struct flowi4 fl4;
1053 : :
1054 : 0 : ip_rt_build_flow_key(&fl4, sk, skb);
1055 : 0 : __ip_rt_update_pmtu(rt, &fl4, mtu);
1056 : 0 : }
1057 : :
1058 : 0 : void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
1059 : : int oif, u8 protocol)
1060 : : {
1061 : 0 : const struct iphdr *iph = (const struct iphdr *) skb->data;
1062 : 0 : struct flowi4 fl4;
1063 : 0 : struct rtable *rt;
1064 [ # # ]: 0 : u32 mark = IP4_REPLY_MARK(net, skb->mark);
1065 : :
1066 : 0 : __build_flow_key(net, &fl4, NULL, iph, oif,
1067 : 0 : RT_TOS(iph->tos), protocol, mark, 0);
1068 : 0 : rt = __ip_route_output_key(net, &fl4);
1069 [ # # ]: 0 : if (!IS_ERR(rt)) {
1070 : 0 : __ip_rt_update_pmtu(rt, &fl4, mtu);
1071 : 0 : ip_rt_put(rt);
1072 : : }
1073 : 0 : }
1074 : : EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
1075 : :
1076 : : static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1077 : : {
1078 : : const struct iphdr *iph = (const struct iphdr *) skb->data;
1079 : : struct flowi4 fl4;
1080 : : struct rtable *rt;
1081 : :
1082 : : __build_flow_key(sock_net(sk), &fl4, sk, iph, 0, 0, 0, 0, 0);
1083 : :
1084 : : if (!fl4.flowi4_mark)
1085 : : fl4.flowi4_mark = IP4_REPLY_MARK(sock_net(sk), skb->mark);
1086 : :
1087 : : rt = __ip_route_output_key(sock_net(sk), &fl4);
1088 : : if (!IS_ERR(rt)) {
1089 : : __ip_rt_update_pmtu(rt, &fl4, mtu);
1090 : : ip_rt_put(rt);
1091 : : }
1092 : : }
1093 : :
1094 : 0 : void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1095 : : {
1096 : 0 : const struct iphdr *iph = (const struct iphdr *) skb->data;
1097 : 0 : struct flowi4 fl4;
1098 : 0 : struct rtable *rt;
1099 : 0 : struct dst_entry *odst = NULL;
1100 : 0 : bool new = false;
1101 : 0 : struct net *net = sock_net(sk);
1102 : :
1103 : 0 : bh_lock_sock(sk);
1104 : :
1105 [ # # # # ]: 0 : if (!ip_sk_accept_pmtu(sk))
1106 : 0 : goto out;
1107 : :
1108 : 0 : odst = sk_dst_get(sk);
1109 : :
1110 [ # # # # ]: 0 : if (sock_owned_by_user(sk) || !odst) {
1111 : 0 : __ipv4_sk_update_pmtu(skb, sk, mtu);
1112 : 0 : goto out;
1113 : : }
1114 : :
1115 : 0 : __build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);
1116 : :
1117 : 0 : rt = (struct rtable *)odst;
1118 [ # # # # ]: 0 : if (odst->obsolete && !odst->ops->check(odst, 0)) {
1119 : 0 : rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1120 [ # # ]: 0 : if (IS_ERR(rt))
1121 : 0 : goto out;
1122 : :
1123 : : new = true;
1124 : : }
1125 : :
1126 [ # # ]: 0 : __ip_rt_update_pmtu((struct rtable *) xfrm_dst_path(&rt->dst), &fl4, mtu);
1127 : :
1128 [ # # # # ]: 0 : if (!dst_check(&rt->dst, 0)) {
1129 [ # # ]: 0 : if (new)
1130 : 0 : dst_release(&rt->dst);
1131 : :
1132 : 0 : rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1133 [ # # ]: 0 : if (IS_ERR(rt))
1134 : 0 : goto out;
1135 : :
1136 : : new = true;
1137 : : }
1138 : :
1139 [ # # ]: 0 : if (new)
1140 : 0 : sk_dst_set(sk, &rt->dst);
1141 : :
1142 : 0 : out:
1143 : 0 : bh_unlock_sock(sk);
1144 : 0 : dst_release(odst);
1145 : 0 : }
1146 : : EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
1147 : :
1148 : 0 : void ipv4_redirect(struct sk_buff *skb, struct net *net,
1149 : : int oif, u8 protocol)
1150 : : {
1151 : 0 : const struct iphdr *iph = (const struct iphdr *) skb->data;
1152 : 0 : struct flowi4 fl4;
1153 : 0 : struct rtable *rt;
1154 : :
1155 : 0 : __build_flow_key(net, &fl4, NULL, iph, oif,
1156 : 0 : RT_TOS(iph->tos), protocol, 0, 0);
1157 : 0 : rt = __ip_route_output_key(net, &fl4);
1158 [ # # ]: 0 : if (!IS_ERR(rt)) {
1159 : 0 : __ip_do_redirect(rt, skb, &fl4, false);
1160 : 0 : ip_rt_put(rt);
1161 : : }
1162 : 0 : }
1163 : : EXPORT_SYMBOL_GPL(ipv4_redirect);
1164 : :
1165 : 0 : void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1166 : : {
1167 : 0 : const struct iphdr *iph = (const struct iphdr *) skb->data;
1168 : 0 : struct flowi4 fl4;
1169 : 0 : struct rtable *rt;
1170 : 0 : struct net *net = sock_net(sk);
1171 : :
1172 : 0 : __build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);
1173 : 0 : rt = __ip_route_output_key(net, &fl4);
1174 [ # # ]: 0 : if (!IS_ERR(rt)) {
1175 : 0 : __ip_do_redirect(rt, skb, &fl4, false);
1176 : 0 : ip_rt_put(rt);
1177 : : }
1178 : 0 : }
1179 : : EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1180 : :
1181 : 0 : static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1182 : : {
1183 : 0 : struct rtable *rt = (struct rtable *) dst;
1184 : :
1185 : : /* All IPV4 dsts are created with ->obsolete set to the value
1186 : : * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1187 : : * into this function always.
1188 : : *
1189 : : * When a PMTU/redirect information update invalidates a route,
1190 : : * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
1191 : : * DST_OBSOLETE_DEAD.
1192 : : */
1193 [ # # # # ]: 0 : if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
1194 : 0 : return NULL;
1195 : : return dst;
1196 : : }
1197 : :
1198 : 0 : static void ipv4_send_dest_unreach(struct sk_buff *skb)
1199 : : {
1200 : 0 : struct ip_options opt;
1201 : 0 : int res;
1202 : :
1203 : : /* Recompile ip options since IPCB may not be valid anymore.
1204 : : * Also check we have a reasonable ipv4 header.
1205 : : */
1206 [ # # ]: 0 : if (!pskb_network_may_pull(skb, sizeof(struct iphdr)) ||
1207 [ # # # # ]: 0 : ip_hdr(skb)->version != 4 || ip_hdr(skb)->ihl < 5)
1208 : 0 : return;
1209 : :
1210 : 0 : memset(&opt, 0, sizeof(opt));
1211 [ # # ]: 0 : if (ip_hdr(skb)->ihl > 5) {
1212 [ # # ]: 0 : if (!pskb_network_may_pull(skb, ip_hdr(skb)->ihl * 4))
1213 : : return;
1214 : 0 : opt.optlen = ip_hdr(skb)->ihl * 4 - sizeof(struct iphdr);
1215 : :
1216 : 0 : rcu_read_lock();
1217 : 0 : res = __ip_options_compile(dev_net(skb->dev), &opt, skb, NULL);
1218 : 0 : rcu_read_unlock();
1219 : :
1220 [ # # ]: 0 : if (res)
1221 : : return;
1222 : : }
1223 : 0 : __icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0, &opt);
1224 : : }
1225 : :
1226 : 0 : static void ipv4_link_failure(struct sk_buff *skb)
1227 : : {
1228 : 0 : struct rtable *rt;
1229 : :
1230 : 0 : ipv4_send_dest_unreach(skb);
1231 : :
1232 [ # # ]: 0 : rt = skb_rtable(skb);
1233 [ # # ]: 0 : if (rt)
1234 [ # # ]: 0 : dst_set_expires(&rt->dst, 0);
1235 : 0 : }
1236 : :
1237 : 0 : static int ip_rt_bug(struct net *net, struct sock *sk, struct sk_buff *skb)
1238 : : {
1239 : 0 : pr_debug("%s: %pI4 -> %pI4, %s\n",
1240 : : __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1241 : : skb->dev ? skb->dev->name : "?");
1242 : 0 : kfree_skb(skb);
1243 : 0 : WARN_ON(1);
1244 : 0 : return 0;
1245 : : }
1246 : :
1247 : : /*
1248 : : We do not cache source address of outgoing interface,
1249 : : because it is used only by IP RR, TS and SRR options,
1250 : : so that it out of fast path.
1251 : :
1252 : : BTW remember: "addr" is allowed to be not aligned
1253 : : in IP options!
1254 : : */
1255 : :
1256 : 0 : void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
1257 : : {
1258 : 0 : __be32 src;
1259 : :
1260 [ # # ]: 0 : if (rt_is_output_route(rt))
1261 : 0 : src = ip_hdr(skb)->saddr;
1262 : : else {
1263 : 0 : struct fib_result res;
1264 : 0 : struct iphdr *iph = ip_hdr(skb);
1265 : 0 : struct flowi4 fl4 = {
1266 : 0 : .daddr = iph->daddr,
1267 : 0 : .saddr = iph->saddr,
1268 : 0 : .flowi4_tos = RT_TOS(iph->tos),
1269 : 0 : .flowi4_oif = rt->dst.dev->ifindex,
1270 : 0 : .flowi4_iif = skb->dev->ifindex,
1271 : 0 : .flowi4_mark = skb->mark,
1272 : : };
1273 : :
1274 : 0 : rcu_read_lock();
1275 [ # # ]: 0 : if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res, 0) == 0)
1276 : 0 : src = fib_result_prefsrc(dev_net(rt->dst.dev), &res);
1277 : : else
1278 [ # # ]: 0 : src = inet_select_addr(rt->dst.dev,
1279 : : rt_nexthop(rt, iph->daddr),
1280 : : RT_SCOPE_UNIVERSE);
1281 : 0 : rcu_read_unlock();
1282 : : }
1283 : 0 : memcpy(addr, &src, 4);
1284 : 0 : }
1285 : :
1286 : : #ifdef CONFIG_IP_ROUTE_CLASSID
1287 : : static void set_class_tag(struct rtable *rt, u32 tag)
1288 : : {
1289 : : if (!(rt->dst.tclassid & 0xFFFF))
1290 : : rt->dst.tclassid |= tag & 0xFFFF;
1291 : : if (!(rt->dst.tclassid & 0xFFFF0000))
1292 : : rt->dst.tclassid |= tag & 0xFFFF0000;
1293 : : }
1294 : : #endif
1295 : :
1296 : 0 : static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1297 : : {
1298 : 0 : unsigned int header_size = sizeof(struct tcphdr) + sizeof(struct iphdr);
1299 : 0 : unsigned int advmss = max_t(unsigned int, ipv4_mtu(dst) - header_size,
1300 : : ip_rt_min_advmss);
1301 : :
1302 : 0 : return min(advmss, IPV4_MAX_PMTU - header_size);
1303 : : }
1304 : :
1305 : 0 : static unsigned int ipv4_mtu(const struct dst_entry *dst)
1306 : : {
1307 : 0 : const struct rtable *rt = (const struct rtable *) dst;
1308 : 0 : unsigned int mtu = rt->rt_pmtu;
1309 : :
1310 [ # # # # ]: 0 : if (!mtu || time_after_eq(jiffies, rt->dst.expires))
1311 : 0 : mtu = dst_metric_raw(dst, RTAX_MTU);
1312 : :
1313 [ # # ]: 0 : if (mtu)
1314 : : return mtu;
1315 : :
1316 [ # # ]: 0 : mtu = READ_ONCE(dst->dev->mtu);
1317 : :
1318 [ # # # # ]: 0 : if (unlikely(ip_mtu_locked(dst))) {
1319 [ # # ]: 0 : if (rt->rt_uses_gateway && mtu > 576)
1320 : : mtu = 576;
1321 : : }
1322 : :
1323 : 0 : mtu = min_t(unsigned int, mtu, IP_MAX_MTU);
1324 : :
1325 : 0 : return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
1326 : : }
1327 : :
1328 : : static void ip_del_fnhe(struct fib_nh_common *nhc, __be32 daddr)
1329 : : {
1330 : : struct fnhe_hash_bucket *hash;
1331 : : struct fib_nh_exception *fnhe, __rcu **fnhe_p;
1332 : : u32 hval = fnhe_hashfun(daddr);
1333 : :
1334 : : spin_lock_bh(&fnhe_lock);
1335 : :
1336 : : hash = rcu_dereference_protected(nhc->nhc_exceptions,
1337 : : lockdep_is_held(&fnhe_lock));
1338 : : hash += hval;
1339 : :
1340 : : fnhe_p = &hash->chain;
1341 : : fnhe = rcu_dereference_protected(*fnhe_p, lockdep_is_held(&fnhe_lock));
1342 : : while (fnhe) {
1343 : : if (fnhe->fnhe_daddr == daddr) {
1344 : : rcu_assign_pointer(*fnhe_p, rcu_dereference_protected(
1345 : : fnhe->fnhe_next, lockdep_is_held(&fnhe_lock)));
1346 : : /* set fnhe_daddr to 0 to ensure it won't bind with
1347 : : * new dsts in rt_bind_exception().
1348 : : */
1349 : : fnhe->fnhe_daddr = 0;
1350 : : fnhe_flush_routes(fnhe);
1351 : : kfree_rcu(fnhe, rcu);
1352 : : break;
1353 : : }
1354 : : fnhe_p = &fnhe->fnhe_next;
1355 : : fnhe = rcu_dereference_protected(fnhe->fnhe_next,
1356 : : lockdep_is_held(&fnhe_lock));
1357 : : }
1358 : :
1359 : : spin_unlock_bh(&fnhe_lock);
1360 : : }
1361 : :
1362 : 60 : static struct fib_nh_exception *find_exception(struct fib_nh_common *nhc,
1363 : : __be32 daddr)
1364 : : {
1365 [ - + ]: 60 : struct fnhe_hash_bucket *hash = rcu_dereference(nhc->nhc_exceptions);
1366 : 60 : struct fib_nh_exception *fnhe;
1367 : 60 : u32 hval;
1368 : :
1369 [ - + ]: 60 : if (!hash)
1370 : : return NULL;
1371 : :
1372 : 0 : hval = fnhe_hashfun(daddr);
1373 : :
1374 [ # # ]: 0 : for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1375 : 0 : fnhe = rcu_dereference(fnhe->fnhe_next)) {
1376 [ # # ]: 0 : if (fnhe->fnhe_daddr == daddr) {
1377 [ # # ]: 0 : if (fnhe->fnhe_expires &&
1378 [ # # ]: 0 : time_after(jiffies, fnhe->fnhe_expires)) {
1379 : 0 : ip_del_fnhe(nhc, daddr);
1380 : 0 : break;
1381 : : }
1382 : : return fnhe;
1383 : : }
1384 : : }
1385 : : return NULL;
1386 : : }
1387 : :
1388 : : /* MTU selection:
1389 : : * 1. mtu on route is locked - use it
1390 : : * 2. mtu from nexthop exception
1391 : : * 3. mtu from egress device
1392 : : */
1393 : :
1394 : 0 : u32 ip_mtu_from_fib_result(struct fib_result *res, __be32 daddr)
1395 : : {
1396 : 0 : struct fib_nh_common *nhc = res->nhc;
1397 : 0 : struct net_device *dev = nhc->nhc_dev;
1398 : 0 : struct fib_info *fi = res->fi;
1399 : 0 : u32 mtu = 0;
1400 : :
1401 [ # # ]: 0 : if (dev_net(dev)->ipv4.sysctl_ip_fwd_use_pmtu ||
1402 [ # # ]: 0 : fi->fib_metrics->metrics[RTAX_LOCK - 1] & (1 << RTAX_MTU))
1403 : 0 : mtu = fi->fib_mtu;
1404 : :
1405 [ # # ]: 0 : if (likely(!mtu)) {
1406 : 0 : struct fib_nh_exception *fnhe;
1407 : :
1408 : 0 : fnhe = find_exception(nhc, daddr);
1409 [ # # # # ]: 0 : if (fnhe && !time_after_eq(jiffies, fnhe->fnhe_expires))
1410 : 0 : mtu = fnhe->fnhe_pmtu;
1411 : : }
1412 : :
1413 [ # # ]: 0 : if (likely(!mtu))
1414 : 0 : mtu = min(READ_ONCE(dev->mtu), IP_MAX_MTU);
1415 : :
1416 : 0 : return mtu - lwtunnel_headroom(nhc->nhc_lwtstate, mtu);
1417 : : }
1418 : :
1419 : 0 : static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
1420 : : __be32 daddr, const bool do_cache)
1421 : : {
1422 : 0 : bool ret = false;
1423 : :
1424 : 0 : spin_lock_bh(&fnhe_lock);
1425 : :
1426 [ # # ]: 0 : if (daddr == fnhe->fnhe_daddr) {
1427 : 0 : struct rtable __rcu **porig;
1428 : 0 : struct rtable *orig;
1429 : 0 : int genid = fnhe_genid(dev_net(rt->dst.dev));
1430 : :
1431 [ # # ]: 0 : if (rt_is_input_route(rt))
1432 : 0 : porig = &fnhe->fnhe_rth_input;
1433 : : else
1434 : 0 : porig = &fnhe->fnhe_rth_output;
1435 [ # # ]: 0 : orig = rcu_dereference(*porig);
1436 : :
1437 [ # # ]: 0 : if (fnhe->fnhe_genid != genid) {
1438 : 0 : fnhe->fnhe_genid = genid;
1439 : 0 : fnhe->fnhe_gw = 0;
1440 : 0 : fnhe->fnhe_pmtu = 0;
1441 : 0 : fnhe->fnhe_expires = 0;
1442 : 0 : fnhe->fnhe_mtu_locked = false;
1443 : 0 : fnhe_flush_routes(fnhe);
1444 : 0 : orig = NULL;
1445 : : }
1446 [ # # ]: 0 : fill_route_from_fnhe(rt, fnhe);
1447 [ # # ]: 0 : if (!rt->rt_gw4) {
1448 : 0 : rt->rt_gw4 = daddr;
1449 : 0 : rt->rt_gw_family = AF_INET;
1450 : : }
1451 : :
1452 [ # # ]: 0 : if (do_cache) {
1453 : 0 : dst_hold(&rt->dst);
1454 [ # # ]: 0 : rcu_assign_pointer(*porig, rt);
1455 [ # # ]: 0 : if (orig) {
1456 : 0 : dst_dev_put(&orig->dst);
1457 : 0 : dst_release(&orig->dst);
1458 : : }
1459 : : ret = true;
1460 : : }
1461 : :
1462 : 0 : fnhe->fnhe_stamp = jiffies;
1463 : : }
1464 : 0 : spin_unlock_bh(&fnhe_lock);
1465 : :
1466 : 0 : return ret;
1467 : : }
1468 : :
1469 : 30 : static bool rt_cache_route(struct fib_nh_common *nhc, struct rtable *rt)
1470 : : {
1471 : 30 : struct rtable *orig, *prev, **p;
1472 : 30 : bool ret = true;
1473 : :
1474 [ - + ]: 30 : if (rt_is_input_route(rt)) {
1475 : 0 : p = (struct rtable **)&nhc->nhc_rth_input;
1476 : : } else {
1477 : 30 : p = (struct rtable **)raw_cpu_ptr(nhc->nhc_pcpu_rth_output);
1478 : : }
1479 : 30 : orig = *p;
1480 : :
1481 : : /* hold dst before doing cmpxchg() to avoid race condition
1482 : : * on this dst
1483 : : */
1484 : 30 : dst_hold(&rt->dst);
1485 : 30 : prev = cmpxchg(p, orig, rt);
1486 [ + - ]: 30 : if (prev == orig) {
1487 [ - + ]: 30 : if (orig) {
1488 : 0 : rt_add_uncached_list(orig);
1489 : 0 : dst_release(&orig->dst);
1490 : : }
1491 : : } else {
1492 : 0 : dst_release(&rt->dst);
1493 : 0 : ret = false;
1494 : : }
1495 : :
1496 : 30 : return ret;
1497 : : }
1498 : :
1499 : : struct uncached_list {
1500 : : spinlock_t lock;
1501 : : struct list_head head;
1502 : : };
1503 : :
1504 : : static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt_uncached_list);
1505 : :
1506 : 60 : void rt_add_uncached_list(struct rtable *rt)
1507 : : {
1508 : 60 : struct uncached_list *ul = raw_cpu_ptr(&rt_uncached_list);
1509 : :
1510 : 60 : rt->rt_uncached_list = ul;
1511 : :
1512 : 60 : spin_lock_bh(&ul->lock);
1513 : 60 : list_add_tail(&rt->rt_uncached, &ul->head);
1514 : 60 : spin_unlock_bh(&ul->lock);
1515 : 60 : }
1516 : :
1517 : 60 : void rt_del_uncached_list(struct rtable *rt)
1518 : : {
1519 [ + - ]: 60 : if (!list_empty(&rt->rt_uncached)) {
1520 : 60 : struct uncached_list *ul = rt->rt_uncached_list;
1521 : :
1522 : 60 : spin_lock_bh(&ul->lock);
1523 : 60 : list_del(&rt->rt_uncached);
1524 : 60 : spin_unlock_bh(&ul->lock);
1525 : : }
1526 : 60 : }
1527 : :
1528 : 60 : static void ipv4_dst_destroy(struct dst_entry *dst)
1529 : : {
1530 : 60 : struct rtable *rt = (struct rtable *)dst;
1531 : :
1532 : 60 : ip_dst_metrics_put(dst);
1533 : 60 : rt_del_uncached_list(rt);
1534 : 60 : }
1535 : :
1536 : 0 : void rt_flush_dev(struct net_device *dev)
1537 : : {
1538 : 0 : struct rtable *rt;
1539 : 0 : int cpu;
1540 : :
1541 [ # # ]: 0 : for_each_possible_cpu(cpu) {
1542 : 0 : struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
1543 : :
1544 : 0 : spin_lock_bh(&ul->lock);
1545 [ # # ]: 0 : list_for_each_entry(rt, &ul->head, rt_uncached) {
1546 [ # # ]: 0 : if (rt->dst.dev != dev)
1547 : 0 : continue;
1548 : 0 : rt->dst.dev = blackhole_netdev;
1549 : 0 : dev_hold(rt->dst.dev);
1550 : 0 : dev_put(dev);
1551 : : }
1552 : 0 : spin_unlock_bh(&ul->lock);
1553 : : }
1554 : 0 : }
1555 : :
1556 : 60 : static bool rt_cache_valid(const struct rtable *rt)
1557 : : {
1558 : 90 : return rt &&
1559 [ + + + - : 90 : rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
- + ]
1560 : 30 : !rt_is_expired(rt);
1561 : : }
1562 : :
1563 : 90 : static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
1564 : : const struct fib_result *res,
1565 : : struct fib_nh_exception *fnhe,
1566 : : struct fib_info *fi, u16 type, u32 itag,
1567 : : const bool do_cache)
1568 : : {
1569 : 90 : bool cached = false;
1570 : :
1571 [ + + ]: 90 : if (fi) {
1572 : 30 : struct fib_nh_common *nhc = FIB_RES_NHC(*res);
1573 : :
1574 [ - + - - ]: 30 : if (nhc->nhc_gw_family && nhc->nhc_scope == RT_SCOPE_LINK) {
1575 : 0 : rt->rt_uses_gateway = 1;
1576 : 0 : rt->rt_gw_family = nhc->nhc_gw_family;
1577 : : /* only INET and INET6 are supported */
1578 [ # # ]: 0 : if (likely(nhc->nhc_gw_family == AF_INET))
1579 : 0 : rt->rt_gw4 = nhc->nhc_gw.ipv4;
1580 : : else
1581 : 0 : rt->rt_gw6 = nhc->nhc_gw.ipv6;
1582 : : }
1583 : :
1584 [ - + ]: 30 : ip_dst_init_metrics(&rt->dst, fi->fib_metrics);
1585 : :
1586 : : #ifdef CONFIG_IP_ROUTE_CLASSID
1587 : : if (nhc->nhc_family == AF_INET) {
1588 : : struct fib_nh *nh;
1589 : :
1590 : : nh = container_of(nhc, struct fib_nh, nh_common);
1591 : : rt->dst.tclassid = nh->nh_tclassid;
1592 : : }
1593 : : #endif
1594 [ - + ]: 30 : rt->dst.lwtstate = lwtstate_get(nhc->nhc_lwtstate);
1595 [ - + ]: 30 : if (unlikely(fnhe))
1596 : 0 : cached = rt_bind_exception(rt, fnhe, daddr, do_cache);
1597 [ + - ]: 30 : else if (do_cache)
1598 : 30 : cached = rt_cache_route(nhc, rt);
1599 [ - + ]: 30 : if (unlikely(!cached)) {
1600 : : /* Routes we intend to cache in nexthop exception or
1601 : : * FIB nexthop have the DST_NOCACHE bit clear.
1602 : : * However, if we are unsuccessful at storing this
1603 : : * route into the cache we really need to set it.
1604 : : */
1605 [ # # ]: 0 : if (!rt->rt_gw4) {
1606 : 0 : rt->rt_gw_family = AF_INET;
1607 : 0 : rt->rt_gw4 = daddr;
1608 : : }
1609 : 0 : rt_add_uncached_list(rt);
1610 : : }
1611 : : } else
1612 : 60 : rt_add_uncached_list(rt);
1613 : :
1614 : : #ifdef CONFIG_IP_ROUTE_CLASSID
1615 : : #ifdef CONFIG_IP_MULTIPLE_TABLES
1616 : : set_class_tag(rt, res->tclassid);
1617 : : #endif
1618 : : set_class_tag(rt, itag);
1619 : : #endif
1620 : 90 : }
1621 : :
1622 : 90 : struct rtable *rt_dst_alloc(struct net_device *dev,
1623 : : unsigned int flags, u16 type,
1624 : : bool nopolicy, bool noxfrm, bool will_cache)
1625 : : {
1626 : 90 : struct rtable *rt;
1627 : :
1628 : 180 : rt = dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
1629 [ - + ]: 90 : (will_cache ? 0 : DST_HOST) |
1630 [ - + ]: 90 : (nopolicy ? DST_NOPOLICY : 0) |
1631 : : (noxfrm ? DST_NOXFRM : 0));
1632 : :
1633 [ + - ]: 90 : if (rt) {
1634 : 90 : rt->rt_genid = rt_genid_ipv4(dev_net(dev));
1635 : 90 : rt->rt_flags = flags;
1636 : 90 : rt->rt_type = type;
1637 : 90 : rt->rt_is_input = 0;
1638 : 90 : rt->rt_iif = 0;
1639 : 90 : rt->rt_pmtu = 0;
1640 : 90 : rt->rt_mtu_locked = 0;
1641 : 90 : rt->rt_uses_gateway = 0;
1642 : 90 : rt->rt_gw_family = 0;
1643 : 90 : rt->rt_gw4 = 0;
1644 [ + - ]: 90 : INIT_LIST_HEAD(&rt->rt_uncached);
1645 : :
1646 : 90 : rt->dst.output = ip_output;
1647 [ + - ]: 90 : if (flags & RTCF_LOCAL)
1648 : 90 : rt->dst.input = ip_local_deliver;
1649 : : }
1650 : :
1651 : 90 : return rt;
1652 : : }
1653 : : EXPORT_SYMBOL(rt_dst_alloc);
1654 : :
1655 : 0 : struct rtable *rt_dst_clone(struct net_device *dev, struct rtable *rt)
1656 : : {
1657 : 0 : struct rtable *new_rt;
1658 : :
1659 : 0 : new_rt = dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
1660 : 0 : rt->dst.flags);
1661 : :
1662 [ # # ]: 0 : if (new_rt) {
1663 : 0 : new_rt->rt_genid = rt_genid_ipv4(dev_net(dev));
1664 : 0 : new_rt->rt_flags = rt->rt_flags;
1665 : 0 : new_rt->rt_type = rt->rt_type;
1666 : 0 : new_rt->rt_is_input = rt->rt_is_input;
1667 : 0 : new_rt->rt_iif = rt->rt_iif;
1668 : 0 : new_rt->rt_pmtu = rt->rt_pmtu;
1669 : 0 : new_rt->rt_mtu_locked = rt->rt_mtu_locked;
1670 : 0 : new_rt->rt_gw_family = rt->rt_gw_family;
1671 [ # # ]: 0 : if (rt->rt_gw_family == AF_INET)
1672 : 0 : new_rt->rt_gw4 = rt->rt_gw4;
1673 [ # # ]: 0 : else if (rt->rt_gw_family == AF_INET6)
1674 : 0 : new_rt->rt_gw6 = rt->rt_gw6;
1675 : 0 : INIT_LIST_HEAD(&new_rt->rt_uncached);
1676 : :
1677 : 0 : new_rt->dst.flags |= DST_HOST;
1678 : 0 : new_rt->dst.input = rt->dst.input;
1679 : 0 : new_rt->dst.output = rt->dst.output;
1680 : 0 : new_rt->dst.error = rt->dst.error;
1681 : 0 : new_rt->dst.lastuse = jiffies;
1682 : 0 : new_rt->dst.lwtstate = lwtstate_get(rt->dst.lwtstate);
1683 : : }
1684 : 0 : return new_rt;
1685 : : }
1686 : : EXPORT_SYMBOL(rt_dst_clone);
1687 : :
1688 : : /* called in rcu_read_lock() section */
1689 : 0 : int ip_mc_validate_source(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1690 : : u8 tos, struct net_device *dev,
1691 : : struct in_device *in_dev, u32 *itag)
1692 : : {
1693 : 0 : int err;
1694 : :
1695 : : /* Primary sanity checks. */
1696 [ # # ]: 0 : if (!in_dev)
1697 : : return -EINVAL;
1698 : :
1699 [ # # # # ]: 0 : if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
1700 [ # # ]: 0 : skb->protocol != htons(ETH_P_IP))
1701 : : return -EINVAL;
1702 : :
1703 [ # # # # : 0 : if (ipv4_is_loopback(saddr) && !IN_DEV_ROUTE_LOCALNET(in_dev))
# # ]
1704 : : return -EINVAL;
1705 : :
1706 [ # # ]: 0 : if (ipv4_is_zeronet(saddr)) {
1707 [ # # ]: 0 : if (!ipv4_is_local_multicast(daddr) &&
1708 [ # # ]: 0 : ip_hdr(skb)->protocol != IPPROTO_IGMP)
1709 : 0 : return -EINVAL;
1710 : : } else {
1711 : 0 : err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1712 : : in_dev, itag);
1713 : 0 : if (err < 0)
1714 : : return err;
1715 : : }
1716 : : return 0;
1717 : : }
1718 : :
1719 : : /* called in rcu_read_lock() section */
1720 : 0 : static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1721 : : u8 tos, struct net_device *dev, int our)
1722 : : {
1723 : 0 : struct in_device *in_dev = __in_dev_get_rcu(dev);
1724 : 0 : unsigned int flags = RTCF_MULTICAST;
1725 : 0 : struct rtable *rth;
1726 : 0 : u32 itag = 0;
1727 : 0 : int err;
1728 : :
1729 : 0 : err = ip_mc_validate_source(skb, daddr, saddr, tos, dev, in_dev, &itag);
1730 [ # # ]: 0 : if (err)
1731 : : return err;
1732 : :
1733 [ # # ]: 0 : if (our)
1734 : 0 : flags |= RTCF_LOCAL;
1735 : :
1736 : 0 : rth = rt_dst_alloc(dev_net(dev)->loopback_dev, flags, RTN_MULTICAST,
1737 : : IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
1738 [ # # ]: 0 : if (!rth)
1739 : : return -ENOBUFS;
1740 : :
1741 : : #ifdef CONFIG_IP_ROUTE_CLASSID
1742 : : rth->dst.tclassid = itag;
1743 : : #endif
1744 : 0 : rth->dst.output = ip_rt_bug;
1745 : 0 : rth->rt_is_input= 1;
1746 : :
1747 : : #ifdef CONFIG_IP_MROUTE
1748 [ # # # # : 0 : if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
# # ]
1749 : 0 : rth->dst.input = ip_mr_input;
1750 : : #endif
1751 : 0 : RT_CACHE_STAT_INC(in_slow_mc);
1752 : :
1753 : 0 : skb_dst_set(skb, &rth->dst);
1754 : 0 : return 0;
1755 : : }
1756 : :
1757 : :
1758 : : static void ip_handle_martian_source(struct net_device *dev,
1759 : : struct in_device *in_dev,
1760 : : struct sk_buff *skb,
1761 : : __be32 daddr,
1762 : : __be32 saddr)
1763 : : {
1764 : : RT_CACHE_STAT_INC(in_martian_src);
1765 : : #ifdef CONFIG_IP_ROUTE_VERBOSE
1766 : : if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1767 : : /*
1768 : : * RFC1812 recommendation, if source is martian,
1769 : : * the only hint is MAC header.
1770 : : */
1771 : : pr_warn("martian source %pI4 from %pI4, on dev %s\n",
1772 : : &daddr, &saddr, dev->name);
1773 : : if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
1774 : : print_hex_dump(KERN_WARNING, "ll header: ",
1775 : : DUMP_PREFIX_OFFSET, 16, 1,
1776 : : skb_mac_header(skb),
1777 : : dev->hard_header_len, false);
1778 : : }
1779 : : }
1780 : : #endif
1781 : : }
1782 : :
1783 : : /* called in rcu_read_lock() section */
1784 : 0 : static int __mkroute_input(struct sk_buff *skb,
1785 : : const struct fib_result *res,
1786 : : struct in_device *in_dev,
1787 : : __be32 daddr, __be32 saddr, u32 tos)
1788 : : {
1789 : 0 : struct fib_nh_common *nhc = FIB_RES_NHC(*res);
1790 : 0 : struct net_device *dev = nhc->nhc_dev;
1791 : 0 : struct fib_nh_exception *fnhe;
1792 : 0 : struct rtable *rth;
1793 : 0 : int err;
1794 : 0 : struct in_device *out_dev;
1795 : 0 : bool do_cache;
1796 : 0 : u32 itag = 0;
1797 : :
1798 : : /* get a working reference to the output device */
1799 [ # # ]: 0 : out_dev = __in_dev_get_rcu(dev);
1800 [ # # ]: 0 : if (!out_dev) {
1801 [ # # ]: 0 : net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
1802 : 0 : return -EINVAL;
1803 : : }
1804 : :
1805 : 0 : err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
1806 : : in_dev->dev, in_dev, &itag);
1807 [ # # ]: 0 : if (err < 0) {
1808 : 0 : ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1809 : : saddr);
1810 : :
1811 : 0 : goto cleanup;
1812 : : }
1813 : :
1814 [ # # # # ]: 0 : do_cache = res->fi && !itag;
1815 [ # # # # : 0 : if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
# # ]
1816 [ # # ]: 0 : skb->protocol == htons(ETH_P_IP)) {
1817 : 0 : __be32 gw;
1818 : :
1819 [ # # ]: 0 : gw = nhc->nhc_gw_family == AF_INET ? nhc->nhc_gw.ipv4 : 0;
1820 [ # # # # : 0 : if (IN_DEV_SHARED_MEDIA(out_dev) ||
# # ]
1821 : 0 : inet_addr_onlink(out_dev, saddr, gw))
1822 : 0 : IPCB(skb)->flags |= IPSKB_DOREDIRECT;
1823 : : }
1824 : :
1825 [ # # ]: 0 : if (skb->protocol != htons(ETH_P_IP)) {
1826 : : /* Not IP (i.e. ARP). Do not create route, if it is
1827 : : * invalid for proxy arp. DNAT routes are always valid.
1828 : : *
1829 : : * Proxy arp feature have been extended to allow, ARP
1830 : : * replies back to the same interface, to support
1831 : : * Private VLAN switch technologies. See arp.c.
1832 : : */
1833 [ # # # # ]: 0 : if (out_dev == in_dev &&
1834 : : IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
1835 : 0 : err = -EINVAL;
1836 : 0 : goto cleanup;
1837 : : }
1838 : : }
1839 : :
1840 : 0 : fnhe = find_exception(nhc, daddr);
1841 [ # # ]: 0 : if (do_cache) {
1842 [ # # ]: 0 : if (fnhe)
1843 : 0 : rth = rcu_dereference(fnhe->fnhe_rth_input);
1844 : : else
1845 : 0 : rth = rcu_dereference(nhc->nhc_rth_input);
1846 [ # # ]: 0 : if (rt_cache_valid(rth)) {
1847 : 0 : skb_dst_set_noref(skb, &rth->dst);
1848 : 0 : goto out;
1849 : : }
1850 : : }
1851 : :
1852 : 0 : rth = rt_dst_alloc(out_dev->dev, 0, res->type,
1853 : : IN_DEV_CONF_GET(in_dev, NOPOLICY),
1854 : : IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
1855 [ # # ]: 0 : if (!rth) {
1856 : 0 : err = -ENOBUFS;
1857 : 0 : goto cleanup;
1858 : : }
1859 : :
1860 : 0 : rth->rt_is_input = 1;
1861 : 0 : RT_CACHE_STAT_INC(in_slow_tot);
1862 : :
1863 : 0 : rth->dst.input = ip_forward;
1864 : :
1865 : 0 : rt_set_nexthop(rth, daddr, res, fnhe, res->fi, res->type, itag,
1866 : : do_cache);
1867 : 0 : lwtunnel_set_redirect(&rth->dst);
1868 : 0 : skb_dst_set(skb, &rth->dst);
1869 : : out:
1870 : : err = 0;
1871 : : cleanup:
1872 : : return err;
1873 : : }
1874 : :
1875 : : #ifdef CONFIG_IP_ROUTE_MULTIPATH
1876 : : /* To make ICMP packets follow the right flow, the multipath hash is
1877 : : * calculated from the inner IP addresses.
1878 : : */
1879 : : static void ip_multipath_l3_keys(const struct sk_buff *skb,
1880 : : struct flow_keys *hash_keys)
1881 : : {
1882 : : const struct iphdr *outer_iph = ip_hdr(skb);
1883 : : const struct iphdr *key_iph = outer_iph;
1884 : : const struct iphdr *inner_iph;
1885 : : const struct icmphdr *icmph;
1886 : : struct iphdr _inner_iph;
1887 : : struct icmphdr _icmph;
1888 : :
1889 : : if (likely(outer_iph->protocol != IPPROTO_ICMP))
1890 : : goto out;
1891 : :
1892 : : if (unlikely((outer_iph->frag_off & htons(IP_OFFSET)) != 0))
1893 : : goto out;
1894 : :
1895 : : icmph = skb_header_pointer(skb, outer_iph->ihl * 4, sizeof(_icmph),
1896 : : &_icmph);
1897 : : if (!icmph)
1898 : : goto out;
1899 : :
1900 : : if (!icmp_is_err(icmph->type))
1901 : : goto out;
1902 : :
1903 : : inner_iph = skb_header_pointer(skb,
1904 : : outer_iph->ihl * 4 + sizeof(_icmph),
1905 : : sizeof(_inner_iph), &_inner_iph);
1906 : : if (!inner_iph)
1907 : : goto out;
1908 : :
1909 : : key_iph = inner_iph;
1910 : : out:
1911 : : hash_keys->addrs.v4addrs.src = key_iph->saddr;
1912 : : hash_keys->addrs.v4addrs.dst = key_iph->daddr;
1913 : : }
1914 : :
1915 : : /* if skb is set it will be used and fl4 can be NULL */
1916 : 0 : int fib_multipath_hash(const struct net *net, const struct flowi4 *fl4,
1917 : : const struct sk_buff *skb, struct flow_keys *flkeys)
1918 : : {
1919 [ # # ]: 0 : u32 multipath_hash = fl4 ? fl4->flowi4_multipath_hash : 0;
1920 : 0 : struct flow_keys hash_keys;
1921 : 0 : u32 mhash;
1922 : :
1923 [ # # # # ]: 0 : switch (net->ipv4.sysctl_fib_multipath_hash_policy) {
1924 : 0 : case 0:
1925 : 0 : memset(&hash_keys, 0, sizeof(hash_keys));
1926 : 0 : hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
1927 [ # # ]: 0 : if (skb) {
1928 : 0 : ip_multipath_l3_keys(skb, &hash_keys);
1929 : : } else {
1930 : 0 : hash_keys.addrs.v4addrs.src = fl4->saddr;
1931 : 0 : hash_keys.addrs.v4addrs.dst = fl4->daddr;
1932 : : }
1933 : : break;
1934 : 0 : case 1:
1935 : : /* skb is currently provided only when forwarding */
1936 [ # # ]: 0 : if (skb) {
1937 : 0 : unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP;
1938 : 0 : struct flow_keys keys;
1939 : :
1940 : : /* short-circuit if we already have L4 hash present */
1941 [ # # ]: 0 : if (skb->l4_hash)
1942 : 0 : return skb_get_hash_raw(skb) >> 1;
1943 : :
1944 : 0 : memset(&hash_keys, 0, sizeof(hash_keys));
1945 : :
1946 [ # # ]: 0 : if (!flkeys) {
1947 : 0 : skb_flow_dissect_flow_keys(skb, &keys, flag);
1948 : 0 : flkeys = &keys;
1949 : : }
1950 : :
1951 : 0 : hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
1952 : 0 : hash_keys.addrs.v4addrs.src = flkeys->addrs.v4addrs.src;
1953 : 0 : hash_keys.addrs.v4addrs.dst = flkeys->addrs.v4addrs.dst;
1954 : 0 : hash_keys.ports.src = flkeys->ports.src;
1955 : 0 : hash_keys.ports.dst = flkeys->ports.dst;
1956 : 0 : hash_keys.basic.ip_proto = flkeys->basic.ip_proto;
1957 : : } else {
1958 : 0 : memset(&hash_keys, 0, sizeof(hash_keys));
1959 : 0 : hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
1960 : 0 : hash_keys.addrs.v4addrs.src = fl4->saddr;
1961 : 0 : hash_keys.addrs.v4addrs.dst = fl4->daddr;
1962 : 0 : hash_keys.ports.src = fl4->fl4_sport;
1963 : 0 : hash_keys.ports.dst = fl4->fl4_dport;
1964 : 0 : hash_keys.basic.ip_proto = fl4->flowi4_proto;
1965 : : }
1966 : : break;
1967 : 0 : case 2:
1968 : 0 : memset(&hash_keys, 0, sizeof(hash_keys));
1969 : : /* skb is currently provided only when forwarding */
1970 [ # # ]: 0 : if (skb) {
1971 : 0 : struct flow_keys keys;
1972 : :
1973 : 0 : skb_flow_dissect_flow_keys(skb, &keys, 0);
1974 : : /* Inner can be v4 or v6 */
1975 [ # # ]: 0 : if (keys.control.addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) {
1976 : 0 : hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
1977 : 0 : hash_keys.addrs.v4addrs.src = keys.addrs.v4addrs.src;
1978 : 0 : hash_keys.addrs.v4addrs.dst = keys.addrs.v4addrs.dst;
1979 [ # # ]: 0 : } else if (keys.control.addr_type == FLOW_DISSECTOR_KEY_IPV6_ADDRS) {
1980 : 0 : hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
1981 : 0 : hash_keys.addrs.v6addrs.src = keys.addrs.v6addrs.src;
1982 : 0 : hash_keys.addrs.v6addrs.dst = keys.addrs.v6addrs.dst;
1983 : 0 : hash_keys.tags.flow_label = keys.tags.flow_label;
1984 : 0 : hash_keys.basic.ip_proto = keys.basic.ip_proto;
1985 : : } else {
1986 : : /* Same as case 0 */
1987 : 0 : hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
1988 : 0 : ip_multipath_l3_keys(skb, &hash_keys);
1989 : : }
1990 : : } else {
1991 : : /* Same as case 0 */
1992 : 0 : hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
1993 : 0 : hash_keys.addrs.v4addrs.src = fl4->saddr;
1994 : 0 : hash_keys.addrs.v4addrs.dst = fl4->daddr;
1995 : : }
1996 : : break;
1997 : : }
1998 : 0 : mhash = flow_hash_from_keys(&hash_keys);
1999 : :
2000 [ # # ]: 0 : if (multipath_hash)
2001 : 0 : mhash = jhash_2words(mhash, multipath_hash, 0);
2002 : :
2003 : 0 : return mhash >> 1;
2004 : : }
2005 : : #endif /* CONFIG_IP_ROUTE_MULTIPATH */
2006 : :
2007 : 0 : static int ip_mkroute_input(struct sk_buff *skb,
2008 : : struct fib_result *res,
2009 : : struct in_device *in_dev,
2010 : : __be32 daddr, __be32 saddr, u32 tos,
2011 : : struct flow_keys *hkeys)
2012 : : {
2013 : : #ifdef CONFIG_IP_ROUTE_MULTIPATH
2014 [ # # # # : 0 : if (res->fi && fib_info_num_path(res->fi) > 1) {
# # ]
2015 : 0 : int h = fib_multipath_hash(res->fi->fib_net, NULL, skb, hkeys);
2016 : :
2017 : 0 : fib_select_multipath(res, h);
2018 : : }
2019 : : #endif
2020 : :
2021 : : /* create a routing cache entry */
2022 : 0 : return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
2023 : : }
2024 : :
2025 : : /* Implements all the saddr-related checks as ip_route_input_slow(),
2026 : : * assuming daddr is valid and the destination is not a local broadcast one.
2027 : : * Uses the provided hint instead of performing a route lookup.
2028 : : */
2029 : 0 : int ip_route_use_hint(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2030 : : u8 tos, struct net_device *dev,
2031 : : const struct sk_buff *hint)
2032 : : {
2033 [ # # ]: 0 : struct in_device *in_dev = __in_dev_get_rcu(dev);
2034 : 0 : struct rtable *rt = (struct rtable *)hint;
2035 [ # # ]: 0 : struct net *net = dev_net(dev);
2036 : 0 : int err = -EINVAL;
2037 : 0 : u32 tag = 0;
2038 : :
2039 [ # # # # ]: 0 : if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
2040 : 0 : goto martian_source;
2041 : :
2042 [ # # ]: 0 : if (ipv4_is_zeronet(saddr))
2043 : 0 : goto martian_source;
2044 : :
2045 [ # # # # : 0 : if (ipv4_is_loopback(saddr) && !IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
# # ]
2046 : 0 : goto martian_source;
2047 : :
2048 [ # # ]: 0 : if (rt->rt_type != RTN_LOCAL)
2049 : 0 : goto skip_validate_source;
2050 : :
2051 : 0 : tos &= IPTOS_RT_MASK;
2052 : 0 : err = fib_validate_source(skb, saddr, daddr, tos, 0, dev, in_dev, &tag);
2053 [ # # ]: 0 : if (err < 0)
2054 : 0 : goto martian_source;
2055 : :
2056 : 0 : skip_validate_source:
2057 [ # # ]: 0 : skb_dst_copy(skb, hint);
2058 : : return 0;
2059 : :
2060 : 0 : martian_source:
2061 : 0 : ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
2062 : 0 : return err;
2063 : : }
2064 : :
2065 : : /*
2066 : : * NOTE. We drop all the packets that has local source
2067 : : * addresses, because every properly looped back packet
2068 : : * must have correct destination already attached by output routine.
2069 : : * Changes in the enforced policies must be applied also to
2070 : : * ip_route_use_hint().
2071 : : *
2072 : : * Such approach solves two big problems:
2073 : : * 1. Not simplex devices are handled properly.
2074 : : * 2. IP spoofing attempts are filtered with 100% of guarantee.
2075 : : * called with rcu_read_lock()
2076 : : */
2077 : :
2078 : 0 : static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2079 : : u8 tos, struct net_device *dev,
2080 : : struct fib_result *res)
2081 : : {
2082 [ # # ]: 0 : struct in_device *in_dev = __in_dev_get_rcu(dev);
2083 : 0 : struct flow_keys *flkeys = NULL, _flkeys;
2084 [ # # ]: 0 : struct net *net = dev_net(dev);
2085 : 0 : struct ip_tunnel_info *tun_info;
2086 : 0 : int err = -EINVAL;
2087 : 0 : unsigned int flags = 0;
2088 : 0 : u32 itag = 0;
2089 : 0 : struct rtable *rth;
2090 : 0 : struct flowi4 fl4;
2091 : 0 : bool do_cache = true;
2092 : :
2093 : : /* IP on this device is disabled. */
2094 : :
2095 [ # # ]: 0 : if (!in_dev)
2096 : 0 : goto out;
2097 : :
2098 : : /* Check for the most weird martians, which can be not detected
2099 : : by fib_lookup.
2100 : : */
2101 : :
2102 [ # # ]: 0 : tun_info = skb_tunnel_info(skb);
2103 [ # # # # ]: 0 : if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
2104 : 0 : fl4.flowi4_tun_key.tun_id = tun_info->key.tun_id;
2105 : : else
2106 : 0 : fl4.flowi4_tun_key.tun_id = 0;
2107 [ # # ]: 0 : skb_dst_drop(skb);
2108 : :
2109 [ # # # # ]: 0 : if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
2110 : 0 : goto martian_source;
2111 : :
2112 : 0 : res->fi = NULL;
2113 : 0 : res->table = NULL;
2114 [ # # # # ]: 0 : if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
2115 : 0 : goto brd_input;
2116 : :
2117 : : /* Accept zero addresses only to limited broadcast;
2118 : : * I even do not know to fix it or not. Waiting for complains :-)
2119 : : */
2120 [ # # ]: 0 : if (ipv4_is_zeronet(saddr))
2121 : 0 : goto martian_source;
2122 : :
2123 [ # # ]: 0 : if (ipv4_is_zeronet(daddr))
2124 : 0 : goto martian_destination;
2125 : :
2126 : : /* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
2127 : : * and call it once if daddr or/and saddr are loopback addresses
2128 : : */
2129 [ # # ]: 0 : if (ipv4_is_loopback(daddr)) {
2130 [ # # # # ]: 0 : if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
2131 : 0 : goto martian_destination;
2132 [ # # ]: 0 : } else if (ipv4_is_loopback(saddr)) {
2133 [ # # # # ]: 0 : if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
2134 : 0 : goto martian_source;
2135 : : }
2136 : :
2137 : : /*
2138 : : * Now we are ready to route packet.
2139 : : */
2140 : 0 : fl4.flowi4_oif = 0;
2141 : 0 : fl4.flowi4_iif = dev->ifindex;
2142 : 0 : fl4.flowi4_mark = skb->mark;
2143 : 0 : fl4.flowi4_tos = tos;
2144 : 0 : fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
2145 : 0 : fl4.flowi4_flags = 0;
2146 : 0 : fl4.daddr = daddr;
2147 : 0 : fl4.saddr = saddr;
2148 [ # # ]: 0 : fl4.flowi4_uid = sock_net_uid(net, NULL);
2149 : :
2150 [ # # ]: 0 : if (fib4_rules_early_flow_dissect(net, skb, &fl4, &_flkeys)) {
2151 : : flkeys = &_flkeys;
2152 : : } else {
2153 : 0 : fl4.flowi4_proto = 0;
2154 : 0 : fl4.fl4_sport = 0;
2155 : 0 : fl4.fl4_dport = 0;
2156 : : }
2157 : :
2158 : 0 : err = fib_lookup(net, &fl4, res, 0);
2159 [ # # ]: 0 : if (err != 0) {
2160 [ # # ]: 0 : if (!IN_DEV_FORWARD(in_dev))
2161 : 0 : err = -EHOSTUNREACH;
2162 : 0 : goto no_route;
2163 : : }
2164 : :
2165 [ # # ]: 0 : if (res->type == RTN_BROADCAST) {
2166 [ # # # # ]: 0 : if (IN_DEV_BFORWARD(in_dev))
2167 : 0 : goto make_route;
2168 : : /* not do cache if bc_forwarding is enabled */
2169 [ # # ]: 0 : if (IPV4_DEVCONF_ALL(net, BC_FORWARDING))
2170 : 0 : do_cache = false;
2171 : 0 : goto brd_input;
2172 : : }
2173 : :
2174 [ # # ]: 0 : if (res->type == RTN_LOCAL) {
2175 : 0 : err = fib_validate_source(skb, saddr, daddr, tos,
2176 : : 0, dev, in_dev, &itag);
2177 [ # # ]: 0 : if (err < 0)
2178 : 0 : goto martian_source;
2179 : 0 : goto local_input;
2180 : : }
2181 : :
2182 [ # # ]: 0 : if (!IN_DEV_FORWARD(in_dev)) {
2183 : 0 : err = -EHOSTUNREACH;
2184 : 0 : goto no_route;
2185 : : }
2186 [ # # ]: 0 : if (res->type != RTN_UNICAST)
2187 : 0 : goto martian_destination;
2188 : :
2189 : 0 : make_route:
2190 : 0 : err = ip_mkroute_input(skb, res, in_dev, daddr, saddr, tos, flkeys);
2191 : 0 : out: return err;
2192 : :
2193 : 0 : brd_input:
2194 [ # # ]: 0 : if (skb->protocol != htons(ETH_P_IP))
2195 : 0 : goto e_inval;
2196 : :
2197 [ # # ]: 0 : if (!ipv4_is_zeronet(saddr)) {
2198 : 0 : err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
2199 : : in_dev, &itag);
2200 [ # # ]: 0 : if (err < 0)
2201 : 0 : goto martian_source;
2202 : : }
2203 : 0 : flags |= RTCF_BROADCAST;
2204 : 0 : res->type = RTN_BROADCAST;
2205 : 0 : RT_CACHE_STAT_INC(in_brd);
2206 : :
2207 : 0 : local_input:
2208 [ # # # # ]: 0 : do_cache &= res->fi && !itag;
2209 [ # # ]: 0 : if (do_cache) {
2210 : 0 : struct fib_nh_common *nhc = FIB_RES_NHC(*res);
2211 : :
2212 : 0 : rth = rcu_dereference(nhc->nhc_rth_input);
2213 [ # # ]: 0 : if (rt_cache_valid(rth)) {
2214 : 0 : skb_dst_set_noref(skb, &rth->dst);
2215 : 0 : err = 0;
2216 : 0 : goto out;
2217 : : }
2218 : : }
2219 : :
2220 : 0 : rth = rt_dst_alloc(l3mdev_master_dev_rcu(dev) ? : net->loopback_dev,
2221 : 0 : flags | RTCF_LOCAL, res->type,
2222 : : IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
2223 [ # # ]: 0 : if (!rth)
2224 : 0 : goto e_nobufs;
2225 : :
2226 : 0 : rth->dst.output= ip_rt_bug;
2227 : : #ifdef CONFIG_IP_ROUTE_CLASSID
2228 : : rth->dst.tclassid = itag;
2229 : : #endif
2230 : 0 : rth->rt_is_input = 1;
2231 : :
2232 : 0 : RT_CACHE_STAT_INC(in_slow_tot);
2233 [ # # ]: 0 : if (res->type == RTN_UNREACHABLE) {
2234 : 0 : rth->dst.input= ip_error;
2235 : 0 : rth->dst.error= -err;
2236 : 0 : rth->rt_flags &= ~RTCF_LOCAL;
2237 : : }
2238 : :
2239 [ # # ]: 0 : if (do_cache) {
2240 : 0 : struct fib_nh_common *nhc = FIB_RES_NHC(*res);
2241 : :
2242 : 0 : rth->dst.lwtstate = lwtstate_get(nhc->nhc_lwtstate);
2243 : 0 : if (lwtunnel_input_redirect(rth->dst.lwtstate)) {
2244 : : WARN_ON(rth->dst.input == lwtunnel_input);
2245 : : rth->dst.lwtstate->orig_input = rth->dst.input;
2246 : : rth->dst.input = lwtunnel_input;
2247 : : }
2248 : :
2249 [ # # ]: 0 : if (unlikely(!rt_cache_route(nhc, rth)))
2250 : 0 : rt_add_uncached_list(rth);
2251 : : }
2252 : 0 : skb_dst_set(skb, &rth->dst);
2253 : 0 : err = 0;
2254 : 0 : goto out;
2255 : :
2256 : 0 : no_route:
2257 : 0 : RT_CACHE_STAT_INC(in_no_route);
2258 : 0 : res->type = RTN_UNREACHABLE;
2259 : 0 : res->fi = NULL;
2260 : 0 : res->table = NULL;
2261 : 0 : goto local_input;
2262 : :
2263 : : /*
2264 : : * Do not cache martian addresses: they should be logged (RFC1812)
2265 : : */
2266 : 0 : martian_destination:
2267 : 0 : RT_CACHE_STAT_INC(in_martian_dst);
2268 : : #ifdef CONFIG_IP_ROUTE_VERBOSE
2269 [ # # # # ]: 0 : if (IN_DEV_LOG_MARTIANS(in_dev))
2270 [ # # ]: 0 : net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
2271 : : &daddr, &saddr, dev->name);
2272 : : #endif
2273 : :
2274 : 0 : e_inval:
2275 : 0 : err = -EINVAL;
2276 : 0 : goto out;
2277 : :
2278 : : e_nobufs:
2279 : 0 : err = -ENOBUFS;
2280 : 0 : goto out;
2281 : :
2282 : 0 : martian_source:
2283 : 0 : ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
2284 : 0 : goto out;
2285 : : }
2286 : :
2287 : 0 : int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2288 : : u8 tos, struct net_device *dev)
2289 : : {
2290 : 0 : struct fib_result res;
2291 : 0 : int err;
2292 : :
2293 : 0 : tos &= IPTOS_RT_MASK;
2294 : 0 : rcu_read_lock();
2295 : 0 : err = ip_route_input_rcu(skb, daddr, saddr, tos, dev, &res);
2296 : 0 : rcu_read_unlock();
2297 : :
2298 : 0 : return err;
2299 : : }
2300 : : EXPORT_SYMBOL(ip_route_input_noref);
2301 : :
2302 : : /* called with rcu_read_lock held */
2303 : 0 : int ip_route_input_rcu(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2304 : : u8 tos, struct net_device *dev, struct fib_result *res)
2305 : : {
2306 : : /* Multicast recognition logic is moved from route cache to here.
2307 : : The problem was that too many Ethernet cards have broken/missing
2308 : : hardware multicast filters :-( As result the host on multicasting
2309 : : network acquires a lot of useless route cache entries, sort of
2310 : : SDR messages from all the world. Now we try to get rid of them.
2311 : : Really, provided software IP multicast filter is organized
2312 : : reasonably (at least, hashed), it does not result in a slowdown
2313 : : comparing with route cache reject entries.
2314 : : Note, that multicast routers are not affected, because
2315 : : route cache entry is created eventually.
2316 : : */
2317 [ # # ]: 0 : if (ipv4_is_multicast(daddr)) {
2318 [ # # ]: 0 : struct in_device *in_dev = __in_dev_get_rcu(dev);
2319 : 0 : int our = 0;
2320 : 0 : int err = -EINVAL;
2321 : :
2322 [ # # ]: 0 : if (!in_dev)
2323 : : return err;
2324 : 0 : our = ip_check_mc_rcu(in_dev, daddr, saddr,
2325 : 0 : ip_hdr(skb)->protocol);
2326 : :
2327 : : /* check l3 master if no match yet */
2328 [ # # # # ]: 0 : if (!our && netif_is_l3_slave(dev)) {
2329 : 0 : struct in_device *l3_in_dev;
2330 : :
2331 [ # # ]: 0 : l3_in_dev = __in_dev_get_rcu(skb->dev);
2332 [ # # ]: 0 : if (l3_in_dev)
2333 : 0 : our = ip_check_mc_rcu(l3_in_dev, daddr, saddr,
2334 : 0 : ip_hdr(skb)->protocol);
2335 : : }
2336 : :
2337 [ # # ]: 0 : if (our
2338 : : #ifdef CONFIG_IP_MROUTE
2339 [ # # ]: 0 : ||
2340 [ # # ]: 0 : (!ipv4_is_local_multicast(daddr) &&
2341 [ # # # # ]: 0 : IN_DEV_MFORWARD(in_dev))
2342 : : #endif
2343 : : ) {
2344 : 0 : err = ip_route_input_mc(skb, daddr, saddr,
2345 : : tos, dev, our);
2346 : : }
2347 : 0 : return err;
2348 : : }
2349 : :
2350 : 0 : return ip_route_input_slow(skb, daddr, saddr, tos, dev, res);
2351 : : }
2352 : :
2353 : : /* called with rcu_read_lock() */
2354 : 120 : static struct rtable *__mkroute_output(const struct fib_result *res,
2355 : : const struct flowi4 *fl4, int orig_oif,
2356 : : struct net_device *dev_out,
2357 : : unsigned int flags)
2358 : : {
2359 : 120 : struct fib_info *fi = res->fi;
2360 : 120 : struct fib_nh_exception *fnhe;
2361 : 120 : struct in_device *in_dev;
2362 : 120 : u16 type = res->type;
2363 : 120 : struct rtable *rth;
2364 : 120 : bool do_cache;
2365 : :
2366 [ + - ]: 120 : in_dev = __in_dev_get_rcu(dev_out);
2367 [ + - ]: 120 : if (!in_dev)
2368 : : return ERR_PTR(-EINVAL);
2369 : :
2370 [ + - + - ]: 120 : if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
2371 [ + - ]: 120 : if (ipv4_is_loopback(fl4->saddr) &&
2372 [ - + - - ]: 120 : !(dev_out->flags & IFF_LOOPBACK) &&
2373 [ # # ]: 0 : !netif_is_l3_master(dev_out))
2374 : : return ERR_PTR(-EINVAL);
2375 : :
2376 [ + - ]: 120 : if (ipv4_is_lbcast(fl4->daddr))
2377 : : type = RTN_BROADCAST;
2378 [ + - ]: 120 : else if (ipv4_is_multicast(fl4->daddr))
2379 : : type = RTN_MULTICAST;
2380 [ + - ]: 120 : else if (ipv4_is_zeronet(fl4->daddr))
2381 : : return ERR_PTR(-EINVAL);
2382 : :
2383 [ + - ]: 120 : if (dev_out->flags & IFF_LOOPBACK)
2384 : 120 : flags |= RTCF_LOCAL;
2385 : :
2386 : 120 : do_cache = true;
2387 [ - + ]: 120 : if (type == RTN_BROADCAST) {
2388 : 0 : flags |= RTCF_BROADCAST | RTCF_LOCAL;
2389 : 0 : fi = NULL;
2390 [ - + ]: 120 : } else if (type == RTN_MULTICAST) {
2391 : 0 : flags |= RTCF_MULTICAST | RTCF_LOCAL;
2392 [ # # ]: 0 : if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
2393 : 0 : fl4->flowi4_proto))
2394 : 0 : flags &= ~RTCF_LOCAL;
2395 : : else
2396 : : do_cache = false;
2397 : : /* If multicast route do not exist use
2398 : : * default one, but do not gateway in this case.
2399 : : * Yes, it is hack.
2400 : : */
2401 [ # # # # ]: 0 : if (fi && res->prefixlen < 4)
2402 : 0 : fi = NULL;
2403 [ + + ]: 120 : } else if ((type == RTN_LOCAL) && (orig_oif != 0) &&
2404 [ - + ]: 60 : (orig_oif != dev_out->ifindex)) {
2405 : : /* For local routes that require a particular output interface
2406 : : * we do not want to cache the result. Caching the result
2407 : : * causes incorrect behaviour when there are multiple source
2408 : : * addresses on the interface, the end result being that if the
2409 : : * intended recipient is waiting on that interface for the
2410 : : * packet he won't receive it because it will be delivered on
2411 : : * the loopback interface and the IP_PKTINFO ipi_ifindex will
2412 : : * be set to the loopback interface as well.
2413 : : */
2414 : 0 : do_cache = false;
2415 : : }
2416 : :
2417 : 120 : fnhe = NULL;
2418 : 120 : do_cache &= fi != NULL;
2419 [ + + ]: 120 : if (fi) {
2420 : 60 : struct fib_nh_common *nhc = FIB_RES_NHC(*res);
2421 : 60 : struct rtable __rcu **prth;
2422 : :
2423 : 60 : fnhe = find_exception(nhc, fl4->daddr);
2424 [ - + ]: 60 : if (!do_cache)
2425 : 0 : goto add;
2426 [ - + ]: 60 : if (fnhe) {
2427 : 0 : prth = &fnhe->fnhe_rth_output;
2428 : : } else {
2429 [ - + - - : 60 : if (unlikely(fl4->flowi4_flags &
- - ]
2430 : : FLOWI_FLAG_KNOWN_NH &&
2431 : : !(nhc->nhc_gw_family &&
2432 : : nhc->nhc_scope == RT_SCOPE_LINK))) {
2433 : 0 : do_cache = false;
2434 : 0 : goto add;
2435 : : }
2436 : 60 : prth = raw_cpu_ptr(nhc->nhc_pcpu_rth_output);
2437 : : }
2438 : 60 : rth = rcu_dereference(*prth);
2439 [ + + - + ]: 90 : if (rt_cache_valid(rth) && dst_hold_safe(&rth->dst))
2440 : : return rth;
2441 : : }
2442 : :
2443 : 90 : add:
2444 : 90 : rth = rt_dst_alloc(dev_out, flags, type,
2445 : : IN_DEV_CONF_GET(in_dev, NOPOLICY),
2446 : : IN_DEV_CONF_GET(in_dev, NOXFRM),
2447 : : do_cache);
2448 [ + - ]: 90 : if (!rth)
2449 : : return ERR_PTR(-ENOBUFS);
2450 : :
2451 : 90 : rth->rt_iif = orig_oif;
2452 : :
2453 : 90 : RT_CACHE_STAT_INC(out_slow_tot);
2454 : :
2455 [ - + ]: 90 : if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
2456 [ # # ]: 0 : if (flags & RTCF_LOCAL &&
2457 [ # # ]: 0 : !(dev_out->flags & IFF_LOOPBACK)) {
2458 : 0 : rth->dst.output = ip_mc_output;
2459 : 0 : RT_CACHE_STAT_INC(out_slow_mc);
2460 : : }
2461 : : #ifdef CONFIG_IP_MROUTE
2462 [ # # ]: 0 : if (type == RTN_MULTICAST) {
2463 [ # # # # : 0 : if (IN_DEV_MFORWARD(in_dev) &&
# # ]
2464 [ # # ]: 0 : !ipv4_is_local_multicast(fl4->daddr)) {
2465 : 0 : rth->dst.input = ip_mr_input;
2466 : 0 : rth->dst.output = ip_mc_output;
2467 : : }
2468 : : }
2469 : : #endif
2470 : : }
2471 : :
2472 : 90 : rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0, do_cache);
2473 : 90 : lwtunnel_set_redirect(&rth->dst);
2474 : :
2475 : 90 : return rth;
2476 : : }
2477 : :
2478 : : /*
2479 : : * Major route resolver routine.
2480 : : */
2481 : :
2482 : 2640 : struct rtable *ip_route_output_key_hash(struct net *net, struct flowi4 *fl4,
2483 : : const struct sk_buff *skb)
2484 : : {
2485 : 2640 : __u8 tos = RT_FL_TOS(fl4);
2486 : 2640 : struct fib_result res = {
2487 : : .type = RTN_UNSPEC,
2488 : : .fi = NULL,
2489 : : .table = NULL,
2490 : : .tclassid = 0,
2491 : : };
2492 : 2640 : struct rtable *rth;
2493 : :
2494 : 2640 : fl4->flowi4_iif = LOOPBACK_IFINDEX;
2495 : 2640 : fl4->flowi4_tos = tos & IPTOS_RT_MASK;
2496 [ + - ]: 2640 : fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
2497 : : RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
2498 : :
2499 : 2640 : rcu_read_lock();
2500 : 2640 : rth = ip_route_output_key_hash_rcu(net, fl4, &res, skb);
2501 : 2640 : rcu_read_unlock();
2502 : :
2503 : 2640 : return rth;
2504 : : }
2505 : : EXPORT_SYMBOL_GPL(ip_route_output_key_hash);
2506 : :
2507 : 2640 : struct rtable *ip_route_output_key_hash_rcu(struct net *net, struct flowi4 *fl4,
2508 : : struct fib_result *res,
2509 : : const struct sk_buff *skb)
2510 : : {
2511 : 2640 : struct net_device *dev_out = NULL;
2512 : 2640 : int orig_oif = fl4->flowi4_oif;
2513 : 2640 : unsigned int flags = 0;
2514 : 2640 : struct rtable *rth;
2515 : 2640 : int err;
2516 : :
2517 [ + + ]: 2640 : if (fl4->saddr) {
2518 [ + - - + ]: 60 : if (ipv4_is_multicast(fl4->saddr) ||
2519 : : ipv4_is_lbcast(fl4->saddr) ||
2520 : : ipv4_is_zeronet(fl4->saddr)) {
2521 : 0 : rth = ERR_PTR(-EINVAL);
2522 : 0 : goto out;
2523 : : }
2524 : :
2525 [ + - ]: 60 : rth = ERR_PTR(-ENETUNREACH);
2526 : :
2527 : : /* I removed check for oif == dev_out->oif here.
2528 : : It was wrong for two reasons:
2529 : : 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2530 : : is assigned to multiple interfaces.
2531 : : 2. Moreover, we are allowed to send packets with saddr
2532 : : of another iface. --ANK
2533 : : */
2534 : :
2535 [ + - + - ]: 60 : if (fl4->flowi4_oif == 0 &&
2536 [ + - - + ]: 60 : (ipv4_is_multicast(fl4->daddr) ||
2537 : : ipv4_is_lbcast(fl4->daddr))) {
2538 : : /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2539 : 0 : dev_out = __ip_dev_find(net, fl4->saddr, false);
2540 [ # # ]: 0 : if (!dev_out)
2541 : 0 : goto out;
2542 : :
2543 : : /* Special hack: user can direct multicasts
2544 : : and limited broadcast via necessary interface
2545 : : without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2546 : : This hack is not just for fun, it allows
2547 : : vic,vat and friends to work.
2548 : : They bind socket to loopback, set ttl to zero
2549 : : and expect that it will work.
2550 : : From the viewpoint of routing cache they are broken,
2551 : : because we are not allowed to build multicast path
2552 : : with loopback source addr (look, routing cache
2553 : : cannot know, that ttl is zero, so that packet
2554 : : will not leave this host and route is valid).
2555 : : Luckily, this hack is good workaround.
2556 : : */
2557 : :
2558 : 0 : fl4->flowi4_oif = dev_out->ifindex;
2559 : 0 : goto make_route;
2560 : : }
2561 : :
2562 [ + - ]: 60 : if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
2563 : : /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2564 [ - + ]: 60 : if (!__ip_dev_find(net, fl4->saddr, false))
2565 : 0 : goto out;
2566 : : }
2567 : : }
2568 : :
2569 : :
2570 [ - + ]: 2640 : if (fl4->flowi4_oif) {
2571 : 0 : dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
2572 [ # # ]: 0 : rth = ERR_PTR(-ENODEV);
2573 [ # # ]: 0 : if (!dev_out)
2574 : 0 : goto out;
2575 : :
2576 : : /* RACE: Check return value of inet_select_addr instead. */
2577 [ # # # # ]: 0 : if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
2578 : 0 : rth = ERR_PTR(-ENETUNREACH);
2579 : 0 : goto out;
2580 : : }
2581 [ # # # # ]: 0 : if (ipv4_is_local_multicast(fl4->daddr) ||
2582 : 0 : ipv4_is_lbcast(fl4->daddr) ||
2583 [ # # ]: 0 : fl4->flowi4_proto == IPPROTO_IGMP) {
2584 [ # # ]: 0 : if (!fl4->saddr)
2585 : 0 : fl4->saddr = inet_select_addr(dev_out, 0,
2586 : : RT_SCOPE_LINK);
2587 : 0 : goto make_route;
2588 : : }
2589 [ # # ]: 0 : if (!fl4->saddr) {
2590 [ # # ]: 0 : if (ipv4_is_multicast(fl4->daddr))
2591 : 0 : fl4->saddr = inet_select_addr(dev_out, 0,
2592 : 0 : fl4->flowi4_scope);
2593 [ # # ]: 0 : else if (!fl4->daddr)
2594 : 0 : fl4->saddr = inet_select_addr(dev_out, 0,
2595 : : RT_SCOPE_HOST);
2596 : : }
2597 : : }
2598 : :
2599 [ + + ]: 2640 : if (!fl4->daddr) {
2600 : 60 : fl4->daddr = fl4->saddr;
2601 [ + - ]: 60 : if (!fl4->daddr)
2602 : 60 : fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
2603 : 60 : dev_out = net->loopback_dev;
2604 : 60 : fl4->flowi4_oif = LOOPBACK_IFINDEX;
2605 : 60 : res->type = RTN_LOCAL;
2606 : 60 : flags |= RTCF_LOCAL;
2607 : 60 : goto make_route;
2608 : : }
2609 : :
2610 : 2580 : err = fib_lookup(net, fl4, res, 0);
2611 [ + + ]: 2580 : if (err) {
2612 : 2520 : res->fi = NULL;
2613 : 2520 : res->table = NULL;
2614 [ - + ]: 2520 : if (fl4->flowi4_oif &&
2615 : : (ipv4_is_multicast(fl4->daddr) ||
2616 : : !netif_index_is_l3_master(net, fl4->flowi4_oif))) {
2617 : : /* Apparently, routing tables are wrong. Assume,
2618 : : that the destination is on link.
2619 : :
2620 : : WHY? DW.
2621 : : Because we are allowed to send to iface
2622 : : even if it has NO routes and NO assigned
2623 : : addresses. When oif is specified, routing
2624 : : tables are looked up with only one purpose:
2625 : : to catch if destination is gatewayed, rather than
2626 : : direct. Moreover, if MSG_DONTROUTE is set,
2627 : : we send packet, ignoring both routing tables
2628 : : and ifaddr state. --ANK
2629 : :
2630 : :
2631 : : We could make it even if oif is unknown,
2632 : : likely IPv6, but we do not.
2633 : : */
2634 : :
2635 [ # # ]: 0 : if (fl4->saddr == 0)
2636 : 0 : fl4->saddr = inet_select_addr(dev_out, 0,
2637 : : RT_SCOPE_LINK);
2638 : 0 : res->type = RTN_UNICAST;
2639 : 0 : goto make_route;
2640 : : }
2641 : 2520 : rth = ERR_PTR(err);
2642 : 2520 : goto out;
2643 : : }
2644 : :
2645 [ + - ]: 60 : if (res->type == RTN_LOCAL) {
2646 [ - + ]: 60 : if (!fl4->saddr) {
2647 [ # # ]: 0 : if (res->fi->fib_prefsrc)
2648 : 0 : fl4->saddr = res->fi->fib_prefsrc;
2649 : : else
2650 : 0 : fl4->saddr = fl4->daddr;
2651 : : }
2652 : :
2653 : : /* L3 master device is the loopback for that domain */
2654 : 60 : dev_out = l3mdev_master_dev_rcu(FIB_RES_DEV(*res)) ? :
2655 : : net->loopback_dev;
2656 : :
2657 : : /* make sure orig_oif points to fib result device even
2658 : : * though packet rx/tx happens over loopback or l3mdev
2659 : : */
2660 : 60 : orig_oif = FIB_RES_OIF(*res);
2661 : :
2662 : 60 : fl4->flowi4_oif = dev_out->ifindex;
2663 : 60 : flags |= RTCF_LOCAL;
2664 : 60 : goto make_route;
2665 : : }
2666 : :
2667 : 0 : fib_select_path(net, res, fl4, skb);
2668 : :
2669 : 0 : dev_out = FIB_RES_DEV(*res);
2670 : 0 : fl4->flowi4_oif = dev_out->ifindex;
2671 : :
2672 : :
2673 : 120 : make_route:
2674 : 120 : rth = __mkroute_output(res, fl4, orig_oif, dev_out, flags);
2675 : :
2676 : 2640 : out:
2677 : 2640 : return rth;
2678 : : }
2679 : :
2680 : 0 : static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2681 : : {
2682 : 0 : return NULL;
2683 : : }
2684 : :
2685 : 0 : static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
2686 : : {
2687 [ # # ]: 0 : unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2688 : :
2689 [ # # ]: 0 : return mtu ? : dst->dev->mtu;
2690 : : }
2691 : :
2692 : 0 : static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2693 : : struct sk_buff *skb, u32 mtu,
2694 : : bool confirm_neigh)
2695 : : {
2696 : 0 : }
2697 : :
2698 : 0 : static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2699 : : struct sk_buff *skb)
2700 : : {
2701 : 0 : }
2702 : :
2703 : 0 : static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2704 : : unsigned long old)
2705 : : {
2706 : 0 : return NULL;
2707 : : }
2708 : :
2709 : : static struct dst_ops ipv4_dst_blackhole_ops = {
2710 : : .family = AF_INET,
2711 : : .check = ipv4_blackhole_dst_check,
2712 : : .mtu = ipv4_blackhole_mtu,
2713 : : .default_advmss = ipv4_default_advmss,
2714 : : .update_pmtu = ipv4_rt_blackhole_update_pmtu,
2715 : : .redirect = ipv4_rt_blackhole_redirect,
2716 : : .cow_metrics = ipv4_rt_blackhole_cow_metrics,
2717 : : .neigh_lookup = ipv4_neigh_lookup,
2718 : : };
2719 : :
2720 : 0 : struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
2721 : : {
2722 : 0 : struct rtable *ort = (struct rtable *) dst_orig;
2723 : 0 : struct rtable *rt;
2724 : :
2725 : 0 : rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_DEAD, 0);
2726 [ # # ]: 0 : if (rt) {
2727 : 0 : struct dst_entry *new = &rt->dst;
2728 : :
2729 : 0 : new->__use = 1;
2730 : 0 : new->input = dst_discard;
2731 : 0 : new->output = dst_discard_out;
2732 : :
2733 : 0 : new->dev = net->loopback_dev;
2734 [ # # ]: 0 : if (new->dev)
2735 : 0 : dev_hold(new->dev);
2736 : :
2737 : 0 : rt->rt_is_input = ort->rt_is_input;
2738 : 0 : rt->rt_iif = ort->rt_iif;
2739 : 0 : rt->rt_pmtu = ort->rt_pmtu;
2740 : 0 : rt->rt_mtu_locked = ort->rt_mtu_locked;
2741 : :
2742 : 0 : rt->rt_genid = rt_genid_ipv4(net);
2743 : 0 : rt->rt_flags = ort->rt_flags;
2744 : 0 : rt->rt_type = ort->rt_type;
2745 : 0 : rt->rt_uses_gateway = ort->rt_uses_gateway;
2746 : 0 : rt->rt_gw_family = ort->rt_gw_family;
2747 [ # # ]: 0 : if (rt->rt_gw_family == AF_INET)
2748 : 0 : rt->rt_gw4 = ort->rt_gw4;
2749 [ # # ]: 0 : else if (rt->rt_gw_family == AF_INET6)
2750 : 0 : rt->rt_gw6 = ort->rt_gw6;
2751 : :
2752 : 0 : INIT_LIST_HEAD(&rt->rt_uncached);
2753 : : }
2754 : :
2755 : 0 : dst_release(dst_orig);
2756 : :
2757 [ # # ]: 0 : return rt ? &rt->dst : ERR_PTR(-ENOMEM);
2758 : : }
2759 : :
2760 : 60 : struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
2761 : : const struct sock *sk)
2762 : : {
2763 : 60 : struct rtable *rt = __ip_route_output_key(net, flp4);
2764 : :
2765 [ + - ]: 60 : if (IS_ERR(rt))
2766 : : return rt;
2767 : :
2768 [ + - ]: 60 : if (flp4->flowi4_proto)
2769 : 60 : rt = (struct rtable *)xfrm_lookup_route(net, &rt->dst,
2770 : : flowi4_to_flowi(flp4),
2771 : : sk, 0);
2772 : :
2773 : : return rt;
2774 : : }
2775 : : EXPORT_SYMBOL_GPL(ip_route_output_flow);
2776 : :
2777 : : /* called with rcu_read_lock held */
2778 : 0 : static int rt_fill_info(struct net *net, __be32 dst, __be32 src,
2779 : : struct rtable *rt, u32 table_id, struct flowi4 *fl4,
2780 : : struct sk_buff *skb, u32 portid, u32 seq,
2781 : : unsigned int flags)
2782 : : {
2783 : 0 : struct rtmsg *r;
2784 : 0 : struct nlmsghdr *nlh;
2785 : 0 : unsigned long expires = 0;
2786 : 0 : u32 error;
2787 : 0 : u32 metrics[RTAX_MAX];
2788 : :
2789 [ # # ]: 0 : nlh = nlmsg_put(skb, portid, seq, RTM_NEWROUTE, sizeof(*r), flags);
2790 [ # # ]: 0 : if (!nlh)
2791 : 0 : return -EMSGSIZE;
2792 : :
2793 [ # # ]: 0 : r = nlmsg_data(nlh);
2794 : 0 : r->rtm_family = AF_INET;
2795 : 0 : r->rtm_dst_len = 32;
2796 : 0 : r->rtm_src_len = 0;
2797 [ # # ]: 0 : r->rtm_tos = fl4 ? fl4->flowi4_tos : 0;
2798 [ # # ]: 0 : r->rtm_table = table_id < 256 ? table_id : RT_TABLE_COMPAT;
2799 [ # # ]: 0 : if (nla_put_u32(skb, RTA_TABLE, table_id))
2800 : 0 : goto nla_put_failure;
2801 : 0 : r->rtm_type = rt->rt_type;
2802 : 0 : r->rtm_scope = RT_SCOPE_UNIVERSE;
2803 : 0 : r->rtm_protocol = RTPROT_UNSPEC;
2804 : 0 : r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2805 [ # # ]: 0 : if (rt->rt_flags & RTCF_NOTIFY)
2806 : 0 : r->rtm_flags |= RTM_F_NOTIFY;
2807 [ # # ]: 0 : if (IPCB(skb)->flags & IPSKB_DOREDIRECT)
2808 : 0 : r->rtm_flags |= RTCF_DOREDIRECT;
2809 : :
2810 [ # # ]: 0 : if (nla_put_in_addr(skb, RTA_DST, dst))
2811 : 0 : goto nla_put_failure;
2812 [ # # ]: 0 : if (src) {
2813 : 0 : r->rtm_src_len = 32;
2814 [ # # ]: 0 : if (nla_put_in_addr(skb, RTA_SRC, src))
2815 : 0 : goto nla_put_failure;
2816 : : }
2817 [ # # # # ]: 0 : if (rt->dst.dev &&
2818 : 0 : nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2819 : 0 : goto nla_put_failure;
2820 : : #ifdef CONFIG_IP_ROUTE_CLASSID
2821 : : if (rt->dst.tclassid &&
2822 : : nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2823 : : goto nla_put_failure;
2824 : : #endif
2825 [ # # # # ]: 0 : if (fl4 && !rt_is_input_route(rt) &&
2826 [ # # ]: 0 : fl4->saddr != src) {
2827 [ # # ]: 0 : if (nla_put_in_addr(skb, RTA_PREFSRC, fl4->saddr))
2828 : 0 : goto nla_put_failure;
2829 : : }
2830 [ # # ]: 0 : if (rt->rt_uses_gateway) {
2831 [ # # # # ]: 0 : if (rt->rt_gw_family == AF_INET &&
2832 : 0 : nla_put_in_addr(skb, RTA_GATEWAY, rt->rt_gw4)) {
2833 : 0 : goto nla_put_failure;
2834 [ # # ]: 0 : } else if (rt->rt_gw_family == AF_INET6) {
2835 : 0 : int alen = sizeof(struct in6_addr);
2836 : 0 : struct nlattr *nla;
2837 : 0 : struct rtvia *via;
2838 : :
2839 : 0 : nla = nla_reserve(skb, RTA_VIA, alen + 2);
2840 [ # # ]: 0 : if (!nla)
2841 : 0 : goto nla_put_failure;
2842 : :
2843 : 0 : via = nla_data(nla);
2844 : 0 : via->rtvia_family = AF_INET6;
2845 : 0 : memcpy(via->rtvia_addr, &rt->rt_gw6, alen);
2846 : : }
2847 : : }
2848 : :
2849 : 0 : expires = rt->dst.expires;
2850 [ # # ]: 0 : if (expires) {
2851 : 0 : unsigned long now = jiffies;
2852 : :
2853 [ # # ]: 0 : if (time_before(now, expires))
2854 : 0 : expires -= now;
2855 : : else
2856 : : expires = 0;
2857 : : }
2858 : :
2859 [ # # ]: 0 : memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
2860 [ # # # # ]: 0 : if (rt->rt_pmtu && expires)
2861 : 0 : metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2862 [ # # # # ]: 0 : if (rt->rt_mtu_locked && expires)
2863 : 0 : metrics[RTAX_LOCK - 1] |= BIT(RTAX_MTU);
2864 [ # # ]: 0 : if (rtnetlink_put_metrics(skb, metrics) < 0)
2865 : 0 : goto nla_put_failure;
2866 : :
2867 [ # # ]: 0 : if (fl4) {
2868 [ # # # # ]: 0 : if (fl4->flowi4_mark &&
2869 : : nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
2870 : 0 : goto nla_put_failure;
2871 : :
2872 [ # # # # ]: 0 : if (!uid_eq(fl4->flowi4_uid, INVALID_UID) &&
2873 : : nla_put_u32(skb, RTA_UID,
2874 : : from_kuid_munged(current_user_ns(),
2875 : : fl4->flowi4_uid)))
2876 : 0 : goto nla_put_failure;
2877 : :
2878 [ # # ]: 0 : if (rt_is_input_route(rt)) {
2879 : : #ifdef CONFIG_IP_MROUTE
2880 [ # # # # ]: 0 : if (ipv4_is_multicast(dst) &&
2881 : 0 : !ipv4_is_local_multicast(dst) &&
2882 [ # # ]: 0 : IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2883 : 0 : int err = ipmr_get_route(net, skb,
2884 : : fl4->saddr, fl4->daddr,
2885 : : r, portid);
2886 : :
2887 [ # # ]: 0 : if (err <= 0) {
2888 [ # # ]: 0 : if (err == 0)
2889 : : return 0;
2890 : 0 : goto nla_put_failure;
2891 : : }
2892 : : } else
2893 : : #endif
2894 [ # # ]: 0 : if (nla_put_u32(skb, RTA_IIF, fl4->flowi4_iif))
2895 : 0 : goto nla_put_failure;
2896 : : }
2897 : : }
2898 : :
2899 : 0 : error = rt->dst.error;
2900 : :
2901 [ # # ]: 0 : if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
2902 : 0 : goto nla_put_failure;
2903 : :
2904 : 0 : nlmsg_end(skb, nlh);
2905 : 0 : return 0;
2906 : :
2907 : 0 : nla_put_failure:
2908 : 0 : nlmsg_cancel(skb, nlh);
2909 : 0 : return -EMSGSIZE;
2910 : : }
2911 : :
2912 : : static int fnhe_dump_bucket(struct net *net, struct sk_buff *skb,
2913 : : struct netlink_callback *cb, u32 table_id,
2914 : : struct fnhe_hash_bucket *bucket, int genid,
2915 : : int *fa_index, int fa_start, unsigned int flags)
2916 : : {
2917 : : int i;
2918 : :
2919 : : for (i = 0; i < FNHE_HASH_SIZE; i++) {
2920 : : struct fib_nh_exception *fnhe;
2921 : :
2922 : : for (fnhe = rcu_dereference(bucket[i].chain); fnhe;
2923 : : fnhe = rcu_dereference(fnhe->fnhe_next)) {
2924 : : struct rtable *rt;
2925 : : int err;
2926 : :
2927 : : if (*fa_index < fa_start)
2928 : : goto next;
2929 : :
2930 : : if (fnhe->fnhe_genid != genid)
2931 : : goto next;
2932 : :
2933 : : if (fnhe->fnhe_expires &&
2934 : : time_after(jiffies, fnhe->fnhe_expires))
2935 : : goto next;
2936 : :
2937 : : rt = rcu_dereference(fnhe->fnhe_rth_input);
2938 : : if (!rt)
2939 : : rt = rcu_dereference(fnhe->fnhe_rth_output);
2940 : : if (!rt)
2941 : : goto next;
2942 : :
2943 : : err = rt_fill_info(net, fnhe->fnhe_daddr, 0, rt,
2944 : : table_id, NULL, skb,
2945 : : NETLINK_CB(cb->skb).portid,
2946 : : cb->nlh->nlmsg_seq, flags);
2947 : : if (err)
2948 : : return err;
2949 : : next:
2950 : : (*fa_index)++;
2951 : : }
2952 : : }
2953 : :
2954 : : return 0;
2955 : : }
2956 : :
2957 : 0 : int fib_dump_info_fnhe(struct sk_buff *skb, struct netlink_callback *cb,
2958 : : u32 table_id, struct fib_info *fi,
2959 : : int *fa_index, int fa_start, unsigned int flags)
2960 : : {
2961 : 0 : struct net *net = sock_net(cb->skb->sk);
2962 : 0 : int nhsel, genid = fnhe_genid(net);
2963 : :
2964 [ # # # # ]: 0 : for (nhsel = 0; nhsel < fib_info_num_path(fi); nhsel++) {
2965 [ # # ]: 0 : struct fib_nh_common *nhc = fib_info_nhc(fi, nhsel);
2966 : 0 : struct fnhe_hash_bucket *bucket;
2967 : 0 : int err;
2968 : :
2969 [ # # ]: 0 : if (nhc->nhc_flags & RTNH_F_DEAD)
2970 : 0 : continue;
2971 : :
2972 : 0 : rcu_read_lock();
2973 [ # # ]: 0 : bucket = rcu_dereference(nhc->nhc_exceptions);
2974 : 0 : err = 0;
2975 [ # # ]: 0 : if (bucket)
2976 : 0 : err = fnhe_dump_bucket(net, skb, cb, table_id, bucket,
2977 : : genid, fa_index, fa_start,
2978 : : flags);
2979 : 0 : rcu_read_unlock();
2980 [ # # ]: 0 : if (err)
2981 : 0 : return err;
2982 : : }
2983 : :
2984 : : return 0;
2985 : : }
2986 : :
2987 : 0 : static struct sk_buff *inet_rtm_getroute_build_skb(__be32 src, __be32 dst,
2988 : : u8 ip_proto, __be16 sport,
2989 : : __be16 dport)
2990 : : {
2991 : 0 : struct sk_buff *skb;
2992 : 0 : struct iphdr *iph;
2993 : :
2994 : 0 : skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2995 [ # # ]: 0 : if (!skb)
2996 : : return NULL;
2997 : :
2998 : : /* Reserve room for dummy headers, this skb can pass
2999 : : * through good chunk of routing engine.
3000 : : */
3001 : 0 : skb_reset_mac_header(skb);
3002 : 0 : skb_reset_network_header(skb);
3003 : 0 : skb->protocol = htons(ETH_P_IP);
3004 : 0 : iph = skb_put(skb, sizeof(struct iphdr));
3005 : 0 : iph->protocol = ip_proto;
3006 : 0 : iph->saddr = src;
3007 : 0 : iph->daddr = dst;
3008 : 0 : iph->version = 0x4;
3009 : 0 : iph->frag_off = 0;
3010 : 0 : iph->ihl = 0x5;
3011 [ # # # # ]: 0 : skb_set_transport_header(skb, skb->len);
3012 : :
3013 [ # # # # ]: 0 : switch (iph->protocol) {
3014 : : case IPPROTO_UDP: {
3015 : 0 : struct udphdr *udph;
3016 : :
3017 : 0 : udph = skb_put_zero(skb, sizeof(struct udphdr));
3018 : 0 : udph->source = sport;
3019 : 0 : udph->dest = dport;
3020 : 0 : udph->len = sizeof(struct udphdr);
3021 : 0 : udph->check = 0;
3022 : 0 : break;
3023 : : }
3024 : : case IPPROTO_TCP: {
3025 : 0 : struct tcphdr *tcph;
3026 : :
3027 : 0 : tcph = skb_put_zero(skb, sizeof(struct tcphdr));
3028 : 0 : tcph->source = sport;
3029 : 0 : tcph->dest = dport;
3030 : 0 : tcph->doff = sizeof(struct tcphdr) / 4;
3031 : 0 : tcph->rst = 1;
3032 : 0 : tcph->check = ~tcp_v4_check(sizeof(struct tcphdr),
3033 : : src, dst, 0);
3034 : 0 : break;
3035 : : }
3036 : : case IPPROTO_ICMP: {
3037 : 0 : struct icmphdr *icmph;
3038 : :
3039 : 0 : icmph = skb_put_zero(skb, sizeof(struct icmphdr));
3040 : 0 : icmph->type = ICMP_ECHO;
3041 : 0 : icmph->code = 0;
3042 : : }
3043 : : }
3044 : :
3045 : : return skb;
3046 : : }
3047 : :
3048 : 0 : static int inet_rtm_valid_getroute_req(struct sk_buff *skb,
3049 : : const struct nlmsghdr *nlh,
3050 : : struct nlattr **tb,
3051 : : struct netlink_ext_ack *extack)
3052 : : {
3053 : 0 : struct rtmsg *rtm;
3054 : 0 : int i, err;
3055 : :
3056 [ # # ]: 0 : if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*rtm))) {
3057 [ # # ]: 0 : NL_SET_ERR_MSG(extack,
3058 : : "ipv4: Invalid header for route get request");
3059 : 0 : return -EINVAL;
3060 : : }
3061 : :
3062 [ # # ]: 0 : if (!netlink_strict_get_check(skb))
3063 : 0 : return nlmsg_parse_deprecated(nlh, sizeof(*rtm), tb, RTA_MAX,
3064 : : rtm_ipv4_policy, extack);
3065 : :
3066 [ # # ]: 0 : rtm = nlmsg_data(nlh);
3067 [ # # ]: 0 : if ((rtm->rtm_src_len && rtm->rtm_src_len != 32) ||
3068 [ # # ]: 0 : (rtm->rtm_dst_len && rtm->rtm_dst_len != 32) ||
3069 : : rtm->rtm_table || rtm->rtm_protocol ||
3070 [ # # ]: 0 : rtm->rtm_scope || rtm->rtm_type) {
3071 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "ipv4: Invalid values in header for route get request");
3072 : 0 : return -EINVAL;
3073 : : }
3074 : :
3075 [ # # ]: 0 : if (rtm->rtm_flags & ~(RTM_F_NOTIFY |
3076 : : RTM_F_LOOKUP_TABLE |
3077 : : RTM_F_FIB_MATCH)) {
3078 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "ipv4: Unsupported rtm_flags for route get request");
3079 : 0 : return -EINVAL;
3080 : : }
3081 : :
3082 : 0 : err = nlmsg_parse_deprecated_strict(nlh, sizeof(*rtm), tb, RTA_MAX,
3083 : : rtm_ipv4_policy, extack);
3084 [ # # ]: 0 : if (err)
3085 : : return err;
3086 : :
3087 [ # # # # ]: 0 : if ((tb[RTA_SRC] && !rtm->rtm_src_len) ||
3088 [ # # # # ]: 0 : (tb[RTA_DST] && !rtm->rtm_dst_len)) {
3089 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "ipv4: rtm_src_len and rtm_dst_len must be 32 for IPv4");
3090 : 0 : return -EINVAL;
3091 : : }
3092 : :
3093 [ # # ]: 0 : for (i = 0; i <= RTA_MAX; i++) {
3094 [ # # ]: 0 : if (!tb[i])
3095 : 0 : continue;
3096 : :
3097 [ # # ]: 0 : switch (i) {
3098 : : case RTA_IIF:
3099 : : case RTA_OIF:
3100 : : case RTA_SRC:
3101 : : case RTA_DST:
3102 : : case RTA_IP_PROTO:
3103 : : case RTA_SPORT:
3104 : : case RTA_DPORT:
3105 : : case RTA_MARK:
3106 : : case RTA_UID:
3107 : : break;
3108 : 0 : default:
3109 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "ipv4: Unsupported attribute in route get request");
3110 : : return -EINVAL;
3111 : : }
3112 : : }
3113 : :
3114 : : return 0;
3115 : : }
3116 : :
3117 : 0 : static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
3118 : : struct netlink_ext_ack *extack)
3119 : : {
3120 : 0 : struct net *net = sock_net(in_skb->sk);
3121 : 0 : struct nlattr *tb[RTA_MAX+1];
3122 : 0 : u32 table_id = RT_TABLE_MAIN;
3123 : 0 : __be16 sport = 0, dport = 0;
3124 : 0 : struct fib_result res = {};
3125 : 0 : u8 ip_proto = IPPROTO_UDP;
3126 : 0 : struct rtable *rt = NULL;
3127 : 0 : struct sk_buff *skb;
3128 : 0 : struct rtmsg *rtm;
3129 : 0 : struct flowi4 fl4 = {};
3130 : 0 : __be32 dst = 0;
3131 : 0 : __be32 src = 0;
3132 : 0 : kuid_t uid;
3133 : 0 : u32 iif;
3134 : 0 : int err;
3135 : 0 : int mark;
3136 : :
3137 : 0 : err = inet_rtm_valid_getroute_req(in_skb, nlh, tb, extack);
3138 [ # # ]: 0 : if (err < 0)
3139 : : return err;
3140 : :
3141 [ # # ]: 0 : rtm = nlmsg_data(nlh);
3142 [ # # ]: 0 : src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0;
3143 [ # # ]: 0 : dst = tb[RTA_DST] ? nla_get_in_addr(tb[RTA_DST]) : 0;
3144 [ # # ]: 0 : iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
3145 [ # # ]: 0 : mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
3146 [ # # ]: 0 : if (tb[RTA_UID])
3147 : 0 : uid = make_kuid(current_user_ns(), nla_get_u32(tb[RTA_UID]));
3148 : : else
3149 [ # # ]: 0 : uid = (iif ? INVALID_UID : current_uid());
3150 : :
3151 [ # # ]: 0 : if (tb[RTA_IP_PROTO]) {
3152 : 0 : err = rtm_getroute_parse_ip_proto(tb[RTA_IP_PROTO],
3153 : : &ip_proto, AF_INET, extack);
3154 [ # # ]: 0 : if (err)
3155 : : return err;
3156 : : }
3157 : :
3158 [ # # ]: 0 : if (tb[RTA_SPORT])
3159 : 0 : sport = nla_get_be16(tb[RTA_SPORT]);
3160 : :
3161 [ # # ]: 0 : if (tb[RTA_DPORT])
3162 : 0 : dport = nla_get_be16(tb[RTA_DPORT]);
3163 : :
3164 : 0 : skb = inet_rtm_getroute_build_skb(src, dst, ip_proto, sport, dport);
3165 [ # # ]: 0 : if (!skb)
3166 : : return -ENOBUFS;
3167 : :
3168 : 0 : fl4.daddr = dst;
3169 : 0 : fl4.saddr = src;
3170 : 0 : fl4.flowi4_tos = rtm->rtm_tos;
3171 [ # # ]: 0 : fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
3172 : 0 : fl4.flowi4_mark = mark;
3173 : 0 : fl4.flowi4_uid = uid;
3174 [ # # ]: 0 : if (sport)
3175 : 0 : fl4.fl4_sport = sport;
3176 [ # # ]: 0 : if (dport)
3177 : 0 : fl4.fl4_dport = dport;
3178 : 0 : fl4.flowi4_proto = ip_proto;
3179 : :
3180 : 0 : rcu_read_lock();
3181 : :
3182 [ # # ]: 0 : if (iif) {
3183 : 0 : struct net_device *dev;
3184 : :
3185 : 0 : dev = dev_get_by_index_rcu(net, iif);
3186 [ # # ]: 0 : if (!dev) {
3187 : 0 : err = -ENODEV;
3188 : 0 : goto errout_rcu;
3189 : : }
3190 : :
3191 : 0 : fl4.flowi4_iif = iif; /* for rt_fill_info */
3192 : 0 : skb->dev = dev;
3193 : 0 : skb->mark = mark;
3194 : 0 : err = ip_route_input_rcu(skb, dst, src, rtm->rtm_tos,
3195 : : dev, &res);
3196 : :
3197 [ # # ]: 0 : rt = skb_rtable(skb);
3198 [ # # # # ]: 0 : if (err == 0 && rt->dst.error)
3199 : 0 : err = -rt->dst.error;
3200 : : } else {
3201 : 0 : fl4.flowi4_iif = LOOPBACK_IFINDEX;
3202 : 0 : skb->dev = net->loopback_dev;
3203 : 0 : rt = ip_route_output_key_hash_rcu(net, &fl4, &res, skb);
3204 : 0 : err = 0;
3205 [ # # ]: 0 : if (IS_ERR(rt))
3206 : 0 : err = PTR_ERR(rt);
3207 : : else
3208 : 0 : skb_dst_set(skb, &rt->dst);
3209 : : }
3210 : :
3211 [ # # ]: 0 : if (err)
3212 : 0 : goto errout_rcu;
3213 : :
3214 [ # # ]: 0 : if (rtm->rtm_flags & RTM_F_NOTIFY)
3215 : 0 : rt->rt_flags |= RTCF_NOTIFY;
3216 : :
3217 [ # # ]: 0 : if (rtm->rtm_flags & RTM_F_LOOKUP_TABLE)
3218 [ # # ]: 0 : table_id = res.table ? res.table->tb_id : 0;
3219 : :
3220 : : /* reset skb for netlink reply msg */
3221 : 0 : skb_trim(skb, 0);
3222 [ # # ]: 0 : skb_reset_network_header(skb);
3223 [ # # ]: 0 : skb_reset_transport_header(skb);
3224 [ # # ]: 0 : skb_reset_mac_header(skb);
3225 : :
3226 [ # # ]: 0 : if (rtm->rtm_flags & RTM_F_FIB_MATCH) {
3227 : 0 : struct fib_rt_info fri;
3228 : :
3229 [ # # ]: 0 : if (!res.fi) {
3230 : 0 : err = fib_props[res.type].error;
3231 [ # # ]: 0 : if (!err)
3232 : 0 : err = -EHOSTUNREACH;
3233 : 0 : goto errout_rcu;
3234 : : }
3235 : 0 : fri.fi = res.fi;
3236 : 0 : fri.tb_id = table_id;
3237 : 0 : fri.dst = res.prefix;
3238 : 0 : fri.dst_len = res.prefixlen;
3239 : 0 : fri.tos = fl4.flowi4_tos;
3240 : 0 : fri.type = rt->rt_type;
3241 : 0 : fri.offload = 0;
3242 : 0 : fri.trap = 0;
3243 [ # # ]: 0 : if (res.fa_head) {
3244 : 0 : struct fib_alias *fa;
3245 : :
3246 [ # # # # : 0 : hlist_for_each_entry_rcu(fa, res.fa_head, fa_list) {
# # ]
3247 : 0 : u8 slen = 32 - fri.dst_len;
3248 : :
3249 [ # # ]: 0 : if (fa->fa_slen == slen &&
3250 [ # # ]: 0 : fa->tb_id == fri.tb_id &&
3251 [ # # ]: 0 : fa->fa_tos == fri.tos &&
3252 [ # # ]: 0 : fa->fa_info == res.fi &&
3253 [ # # ]: 0 : fa->fa_type == fri.type) {
3254 : 0 : fri.offload = fa->offload;
3255 : 0 : fri.trap = fa->trap;
3256 : 0 : break;
3257 : : }
3258 : : }
3259 : : }
3260 : 0 : err = fib_dump_info(skb, NETLINK_CB(in_skb).portid,
3261 : : nlh->nlmsg_seq, RTM_NEWROUTE, &fri, 0);
3262 : : } else {
3263 : 0 : err = rt_fill_info(net, dst, src, rt, table_id, &fl4, skb,
3264 : : NETLINK_CB(in_skb).portid,
3265 : : nlh->nlmsg_seq, 0);
3266 : : }
3267 [ # # ]: 0 : if (err < 0)
3268 : 0 : goto errout_rcu;
3269 : :
3270 : 0 : rcu_read_unlock();
3271 : :
3272 : 0 : err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
3273 : :
3274 : : errout_free:
3275 : : return err;
3276 : 0 : errout_rcu:
3277 : 0 : rcu_read_unlock();
3278 : 0 : kfree_skb(skb);
3279 : 0 : goto errout_free;
3280 : : }
3281 : :
3282 : 36 : void ip_rt_multicast_event(struct in_device *in_dev)
3283 : : {
3284 : 36 : rt_cache_flush(dev_net(in_dev->dev));
3285 : 36 : }
3286 : :
3287 : : #ifdef CONFIG_SYSCTL
3288 : : static int ip_rt_gc_interval __read_mostly = 60 * HZ;
3289 : : static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
3290 : : static int ip_rt_gc_elasticity __read_mostly = 8;
3291 : : static int ip_min_valid_pmtu __read_mostly = IPV4_MIN_MTU;
3292 : :
3293 : 0 : static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write,
3294 : : void __user *buffer,
3295 : : size_t *lenp, loff_t *ppos)
3296 : : {
3297 : 0 : struct net *net = (struct net *)__ctl->extra1;
3298 : :
3299 [ # # ]: 0 : if (write) {
3300 : 0 : rt_cache_flush(net);
3301 : 0 : fnhe_genid_bump(net);
3302 : 0 : return 0;
3303 : : }
3304 : :
3305 : : return -EINVAL;
3306 : : }
3307 : :
3308 : : static struct ctl_table ipv4_route_table[] = {
3309 : : {
3310 : : .procname = "gc_thresh",
3311 : : .data = &ipv4_dst_ops.gc_thresh,
3312 : : .maxlen = sizeof(int),
3313 : : .mode = 0644,
3314 : : .proc_handler = proc_dointvec,
3315 : : },
3316 : : {
3317 : : .procname = "max_size",
3318 : : .data = &ip_rt_max_size,
3319 : : .maxlen = sizeof(int),
3320 : : .mode = 0644,
3321 : : .proc_handler = proc_dointvec,
3322 : : },
3323 : : {
3324 : : /* Deprecated. Use gc_min_interval_ms */
3325 : :
3326 : : .procname = "gc_min_interval",
3327 : : .data = &ip_rt_gc_min_interval,
3328 : : .maxlen = sizeof(int),
3329 : : .mode = 0644,
3330 : : .proc_handler = proc_dointvec_jiffies,
3331 : : },
3332 : : {
3333 : : .procname = "gc_min_interval_ms",
3334 : : .data = &ip_rt_gc_min_interval,
3335 : : .maxlen = sizeof(int),
3336 : : .mode = 0644,
3337 : : .proc_handler = proc_dointvec_ms_jiffies,
3338 : : },
3339 : : {
3340 : : .procname = "gc_timeout",
3341 : : .data = &ip_rt_gc_timeout,
3342 : : .maxlen = sizeof(int),
3343 : : .mode = 0644,
3344 : : .proc_handler = proc_dointvec_jiffies,
3345 : : },
3346 : : {
3347 : : .procname = "gc_interval",
3348 : : .data = &ip_rt_gc_interval,
3349 : : .maxlen = sizeof(int),
3350 : : .mode = 0644,
3351 : : .proc_handler = proc_dointvec_jiffies,
3352 : : },
3353 : : {
3354 : : .procname = "redirect_load",
3355 : : .data = &ip_rt_redirect_load,
3356 : : .maxlen = sizeof(int),
3357 : : .mode = 0644,
3358 : : .proc_handler = proc_dointvec,
3359 : : },
3360 : : {
3361 : : .procname = "redirect_number",
3362 : : .data = &ip_rt_redirect_number,
3363 : : .maxlen = sizeof(int),
3364 : : .mode = 0644,
3365 : : .proc_handler = proc_dointvec,
3366 : : },
3367 : : {
3368 : : .procname = "redirect_silence",
3369 : : .data = &ip_rt_redirect_silence,
3370 : : .maxlen = sizeof(int),
3371 : : .mode = 0644,
3372 : : .proc_handler = proc_dointvec,
3373 : : },
3374 : : {
3375 : : .procname = "error_cost",
3376 : : .data = &ip_rt_error_cost,
3377 : : .maxlen = sizeof(int),
3378 : : .mode = 0644,
3379 : : .proc_handler = proc_dointvec,
3380 : : },
3381 : : {
3382 : : .procname = "error_burst",
3383 : : .data = &ip_rt_error_burst,
3384 : : .maxlen = sizeof(int),
3385 : : .mode = 0644,
3386 : : .proc_handler = proc_dointvec,
3387 : : },
3388 : : {
3389 : : .procname = "gc_elasticity",
3390 : : .data = &ip_rt_gc_elasticity,
3391 : : .maxlen = sizeof(int),
3392 : : .mode = 0644,
3393 : : .proc_handler = proc_dointvec,
3394 : : },
3395 : : {
3396 : : .procname = "mtu_expires",
3397 : : .data = &ip_rt_mtu_expires,
3398 : : .maxlen = sizeof(int),
3399 : : .mode = 0644,
3400 : : .proc_handler = proc_dointvec_jiffies,
3401 : : },
3402 : : {
3403 : : .procname = "min_pmtu",
3404 : : .data = &ip_rt_min_pmtu,
3405 : : .maxlen = sizeof(int),
3406 : : .mode = 0644,
3407 : : .proc_handler = proc_dointvec_minmax,
3408 : : .extra1 = &ip_min_valid_pmtu,
3409 : : },
3410 : : {
3411 : : .procname = "min_adv_mss",
3412 : : .data = &ip_rt_min_advmss,
3413 : : .maxlen = sizeof(int),
3414 : : .mode = 0644,
3415 : : .proc_handler = proc_dointvec,
3416 : : },
3417 : : { }
3418 : : };
3419 : :
3420 : : static const char ipv4_route_flush_procname[] = "flush";
3421 : :
3422 : : static struct ctl_table ipv4_route_flush_table[] = {
3423 : : {
3424 : : .procname = ipv4_route_flush_procname,
3425 : : .maxlen = sizeof(int),
3426 : : .mode = 0200,
3427 : : .proc_handler = ipv4_sysctl_rtcache_flush,
3428 : : },
3429 : : { },
3430 : : };
3431 : :
3432 : 30 : static __net_init int sysctl_route_net_init(struct net *net)
3433 : : {
3434 : 30 : struct ctl_table *tbl;
3435 : :
3436 : 30 : tbl = ipv4_route_flush_table;
3437 [ - + ]: 30 : if (!net_eq(net, &init_net)) {
3438 : 0 : tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
3439 [ # # ]: 0 : if (!tbl)
3440 : 0 : goto err_dup;
3441 : :
3442 : : /* Don't export non-whitelisted sysctls to unprivileged users */
3443 [ # # ]: 0 : if (net->user_ns != &init_user_ns) {
3444 [ # # ]: 0 : if (tbl[0].procname != ipv4_route_flush_procname)
3445 : 0 : tbl[0].procname = NULL;
3446 : : }
3447 : : }
3448 : 30 : tbl[0].extra1 = net;
3449 : :
3450 : 30 : net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
3451 [ - + ]: 30 : if (!net->ipv4.route_hdr)
3452 : 0 : goto err_reg;
3453 : : return 0;
3454 : :
3455 : : err_reg:
3456 [ # # ]: 0 : if (tbl != ipv4_route_flush_table)
3457 : 0 : kfree(tbl);
3458 : 0 : err_dup:
3459 : : return -ENOMEM;
3460 : : }
3461 : :
3462 : 0 : static __net_exit void sysctl_route_net_exit(struct net *net)
3463 : : {
3464 : 0 : struct ctl_table *tbl;
3465 : :
3466 : 0 : tbl = net->ipv4.route_hdr->ctl_table_arg;
3467 : 0 : unregister_net_sysctl_table(net->ipv4.route_hdr);
3468 [ # # ]: 0 : BUG_ON(tbl == ipv4_route_flush_table);
3469 : 0 : kfree(tbl);
3470 : 0 : }
3471 : :
3472 : : static __net_initdata struct pernet_operations sysctl_route_ops = {
3473 : : .init = sysctl_route_net_init,
3474 : : .exit = sysctl_route_net_exit,
3475 : : };
3476 : : #endif
3477 : :
3478 : 30 : static __net_init int rt_genid_init(struct net *net)
3479 : : {
3480 : 30 : atomic_set(&net->ipv4.rt_genid, 0);
3481 : 30 : atomic_set(&net->fnhe_genid, 0);
3482 : 30 : atomic_set(&net->ipv4.dev_addr_genid, get_random_int());
3483 : 30 : return 0;
3484 : : }
3485 : :
3486 : : static __net_initdata struct pernet_operations rt_genid_ops = {
3487 : : .init = rt_genid_init,
3488 : : };
3489 : :
3490 : 30 : static int __net_init ipv4_inetpeer_init(struct net *net)
3491 : : {
3492 : 30 : struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3493 : :
3494 [ + - ]: 30 : if (!bp)
3495 : : return -ENOMEM;
3496 : 30 : inet_peer_base_init(bp);
3497 : 30 : net->ipv4.peers = bp;
3498 : 30 : return 0;
3499 : : }
3500 : :
3501 : 0 : static void __net_exit ipv4_inetpeer_exit(struct net *net)
3502 : : {
3503 : 0 : struct inet_peer_base *bp = net->ipv4.peers;
3504 : :
3505 : 0 : net->ipv4.peers = NULL;
3506 : 0 : inetpeer_invalidate_tree(bp);
3507 : 0 : kfree(bp);
3508 : 0 : }
3509 : :
3510 : : static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
3511 : : .init = ipv4_inetpeer_init,
3512 : : .exit = ipv4_inetpeer_exit,
3513 : : };
3514 : :
3515 : : #ifdef CONFIG_IP_ROUTE_CLASSID
3516 : : struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
3517 : : #endif /* CONFIG_IP_ROUTE_CLASSID */
3518 : :
3519 : 30 : int __init ip_rt_init(void)
3520 : : {
3521 : 30 : int cpu;
3522 : :
3523 : 30 : ip_idents = kmalloc_array(IP_IDENTS_SZ, sizeof(*ip_idents),
3524 : : GFP_KERNEL);
3525 [ - + ]: 30 : if (!ip_idents)
3526 : 0 : panic("IP: failed to allocate ip_idents\n");
3527 : :
3528 : 30 : prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));
3529 : :
3530 : 30 : ip_tstamps = kcalloc(IP_IDENTS_SZ, sizeof(*ip_tstamps), GFP_KERNEL);
3531 [ + - ]: 30 : if (!ip_tstamps)
3532 : 0 : panic("IP: failed to allocate ip_tstamps\n");
3533 : :
3534 [ + + ]: 60 : for_each_possible_cpu(cpu) {
3535 : 30 : struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
3536 : :
3537 : 30 : INIT_LIST_HEAD(&ul->head);
3538 : 60 : spin_lock_init(&ul->lock);
3539 : : }
3540 : : #ifdef CONFIG_IP_ROUTE_CLASSID
3541 : : ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
3542 : : if (!ip_rt_acct)
3543 : : panic("IP: failed to allocate ip_rt_acct\n");
3544 : : #endif
3545 : :
3546 : 60 : ipv4_dst_ops.kmem_cachep =
3547 : 30 : kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
3548 : : SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
3549 : :
3550 : 30 : ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
3551 : :
3552 [ - + ]: 30 : if (dst_entries_init(&ipv4_dst_ops) < 0)
3553 : 0 : panic("IP: failed to allocate ipv4_dst_ops counter\n");
3554 : :
3555 [ - + ]: 30 : if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
3556 : 0 : panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
3557 : :
3558 : 30 : ipv4_dst_ops.gc_thresh = ~0;
3559 : 30 : ip_rt_max_size = INT_MAX;
3560 : :
3561 : 30 : devinet_init();
3562 : 30 : ip_fib_init();
3563 : :
3564 [ - + ]: 30 : if (ip_rt_proc_init())
3565 : 0 : pr_err("Unable to create route proc files\n");
3566 : : #ifdef CONFIG_XFRM
3567 : 30 : xfrm_init();
3568 : 30 : xfrm4_init();
3569 : : #endif
3570 : 30 : rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL,
3571 : : RTNL_FLAG_DOIT_UNLOCKED);
3572 : :
3573 : : #ifdef CONFIG_SYSCTL
3574 : 30 : register_pernet_subsys(&sysctl_route_ops);
3575 : : #endif
3576 : 30 : register_pernet_subsys(&rt_genid_ops);
3577 : 30 : register_pernet_subsys(&ipv4_inetpeer_ops);
3578 : 30 : return 0;
3579 : : }
3580 : :
3581 : : #ifdef CONFIG_SYSCTL
3582 : : /*
3583 : : * We really need to sanitize the damn ipv4 init order, then all
3584 : : * this nonsense will go away.
3585 : : */
3586 : 30 : void __init ip_static_sysctl_init(void)
3587 : : {
3588 : 30 : register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);
3589 : 30 : }
3590 : : #endif
|
