projects / GitHub / LineageOS / android_kernel_motorola_exynos9610.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
vti6: better validate user provided tunnel names
[GitHub/LineageOS/android_kernel_motorola_exynos9610.git] / net / ipv6 / route.c
CommitLineData
1da177e4
LT		 1/*
2 * Linux INET6 implementation
3 * FIB front-end.
4 *
5 * Authors:
1ab1457c 6 * Pedro Roque <roque@di.fc.ul.pt>
1da177e4 7 *
1da177e4
LT		 8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 */
13
14/* Changes:
15 *
16 * YOSHIFUJI Hideaki @USAGI
17 * reworked default router selection.
18 * - respect outgoing interface
19 * - select from (probably) reachable routers (i.e.
20 * routers in REACHABLE, STALE, DELAY or PROBE states).
21 * - always select the same router if it is (probably)
22 * reachable. otherwise, round-robin the list.
c0bece9f
YH		 23 * Ville Nuorvala
24 * Fixed routing subtrees.
1da177e4
LT		 25 */
26
f3213831
JP		 27#define pr_fmt(fmt) "IPv6: " fmt
28
4fc268d2 29#include <linux/capability.h>
1da177e4 30#include <linux/errno.h>
bc3b2d7f 31#include <linux/export.h>
1da177e4
LT		 32#include <linux/types.h>
33#include <linux/times.h>
34#include <linux/socket.h>
35#include <linux/sockios.h>
36#include <linux/net.h>
37#include <linux/route.h>
38#include <linux/netdevice.h>
39#include <linux/in6.h>
7bc570c8 40#include <linux/mroute6.h>
1da177e4 41#include <linux/init.h>
1da177e4 42#include <linux/if_arp.h>
1da177e4
LT		 43#include <linux/proc_fs.h>
44#include <linux/seq_file.h>
5b7c931d 45#include <linux/nsproxy.h>
5a0e3ad6 46#include <linux/slab.h>
457c4cbc 47#include <net/net_namespace.h>
1da177e4
LT		 48#include <net/snmp.h>
49#include <net/ipv6.h>
50#include <net/ip6_fib.h>
51#include <net/ip6_route.h>
52#include <net/ndisc.h>
53#include <net/addrconf.h>
54#include <net/tcp.h>
55#include <linux/rtnetlink.h>
56#include <net/dst.h>
904af04d 57#include <net/dst_metadata.h>
1da177e4 58#include <net/xfrm.h>
8d71740c 59#include <net/netevent.h>
21713ebc 60#include <net/netlink.h>
51ebd318 61#include <net/nexthop.h>
19e42e45 62#include <net/lwtunnel.h>
904af04d 63#include <net/ip_tunnels.h>
ca254490 64#include <net/l3mdev.h>
b811580d 65#include <trace/events/fib6.h>
1da177e4 66
7c0f6ba6 67#include <linux/uaccess.h>
1da177e4
LT		 68
69#ifdef CONFIG_SYSCTL
70#include <linux/sysctl.h>
71#endif
72
afc154e9 73enum rt6_nud_state {
7e980569
JB		 74 RT6_NUD_FAIL_HARD = -3,
75 RT6_NUD_FAIL_PROBE = -2,
76 RT6_NUD_FAIL_DO_RR = -1,
afc154e9
HFS		 77 RT6_NUD_SUCCEED = 1
78};
79
83a09abd 80static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort);
1da177e4 81static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
0dbaee3b 82static unsigned int ip6_default_advmss(const struct dst_entry *dst);
ebb762f2 83static unsigned int ip6_mtu(const struct dst_entry *dst);
1da177e4
LT		 84static struct dst_entry *ip6_negative_advice(struct dst_entry *);
85static void ip6_dst_destroy(struct dst_entry *);
86static void ip6_dst_ifdown(struct dst_entry *,
87 struct net_device *dev, int how);
569d3645 88static int ip6_dst_gc(struct dst_ops *ops);
1da177e4
LT		 89
90static int ip6_pkt_discard(struct sk_buff *skb);
ede2059d 91static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb);
7150aede 92static int ip6_pkt_prohibit(struct sk_buff *skb);
ede2059d 93static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb);
1da177e4 94static void ip6_link_failure(struct sk_buff *skb);
6700c270
DM		 95static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
96 struct sk_buff *skb, u32 mtu);
97static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
98 struct sk_buff *skb);
4b32b5ad 99static void rt6_dst_from_metrics_check(struct rt6_info *rt);
52bd4c0c 100static int rt6_score_route(struct rt6_info *rt, int oif, int strict);
16a16cd3
DA		 101static size_t rt6_nlmsg_size(struct rt6_info *rt);
102static int rt6_fill_node(struct net *net,
103 struct sk_buff *skb, struct rt6_info *rt,
104 struct in6_addr *dst, struct in6_addr *src,
105 int iif, int type, u32 portid, u32 seq,
106 unsigned int flags);
1da177e4 107
70ceb4f5 108#ifdef CONFIG_IPV6_ROUTE_INFO
efa2cea0 109static struct rt6_info *rt6_add_route_info(struct net *net,
b71d1d42 110 const struct in6_addr *prefix, int prefixlen,
830218c1
DA		 111 const struct in6_addr *gwaddr,
112 struct net_device *dev,
95c96174 113 unsigned int pref);
efa2cea0 114static struct rt6_info *rt6_get_route_info(struct net *net,
b71d1d42 115 const struct in6_addr *prefix, int prefixlen,
830218c1
DA		 116 const struct in6_addr *gwaddr,
117 struct net_device *dev);
70ceb4f5
YH		 118#endif
119
8d0b94af
MKL		 120struct uncached_list {
121 spinlock_t lock;
122 struct list_head head;
123};
124
125static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt6_uncached_list);
126
127static void rt6_uncached_list_add(struct rt6_info *rt)
128{
129 struct uncached_list *ul = raw_cpu_ptr(&rt6_uncached_list);
130
8d0b94af
MKL		 131 rt->rt6i_uncached_list = ul;
132
133 spin_lock_bh(&ul->lock);
134 list_add_tail(&rt->rt6i_uncached, &ul->head);
135 spin_unlock_bh(&ul->lock);
136}
137
138static void rt6_uncached_list_del(struct rt6_info *rt)
139{
140 if (!list_empty(&rt->rt6i_uncached)) {
141 struct uncached_list *ul = rt->rt6i_uncached_list;
142
143 spin_lock_bh(&ul->lock);
144 list_del(&rt->rt6i_uncached);
145 spin_unlock_bh(&ul->lock);
146 }
147}
148
149static void rt6_uncached_list_flush_dev(struct net *net, struct net_device *dev)
150{
151 struct net_device *loopback_dev = net->loopback_dev;
152 int cpu;
153
e332bc67
EB		 154 if (dev == loopback_dev)
155 return;
156
8d0b94af
MKL		 157 for_each_possible_cpu(cpu) {
158 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
159 struct rt6_info *rt;
160
161 spin_lock_bh(&ul->lock);
162 list_for_each_entry(rt, &ul->head, rt6i_uncached) {
163 struct inet6_dev *rt_idev = rt->rt6i_idev;
164 struct net_device *rt_dev = rt->dst.dev;
165
e332bc67 166 if (rt_idev->dev == dev) {
8d0b94af
MKL		 167 rt->rt6i_idev = in6_dev_get(loopback_dev);
168 in6_dev_put(rt_idev);
169 }
170
e332bc67 171 if (rt_dev == dev) {
8d0b94af
MKL		 172 rt->dst.dev = loopback_dev;
173 dev_hold(rt->dst.dev);
174 dev_put(rt_dev);
175 }
176 }
177 spin_unlock_bh(&ul->lock);
178 }
179}
180
d52d3997
MKL		 181static u32 *rt6_pcpu_cow_metrics(struct rt6_info *rt)
182{
183 return dst_metrics_write_ptr(rt->dst.from);
184}
185
06582540
DM		 186static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
187{
4b32b5ad 188 struct rt6_info *rt = (struct rt6_info *)dst;
06582540 189
d52d3997
MKL		 190 if (rt->rt6i_flags & RTF_PCPU)
191 return rt6_pcpu_cow_metrics(rt);
192 else if (rt->rt6i_flags & RTF_CACHE)
4b32b5ad
MKL		 193 return NULL;
194 else
3b471175 195 return dst_cow_metrics_generic(dst, old);
06582540
DM		 196}
197
f894cbf8
DM		 198static inline const void *choose_neigh_daddr(struct rt6_info *rt,
199 struct sk_buff *skb,
200 const void *daddr)
39232973
DM		 201{
202 struct in6_addr *p = &rt->rt6i_gateway;
203
a7563f34 204 if (!ipv6_addr_any(p))
39232973 205 return (const void *) p;
f894cbf8
DM		 206 else if (skb)
207 return &ipv6_hdr(skb)->daddr;
39232973
DM		 208 return daddr;
209}
210
f894cbf8
DM		 211static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
212 struct sk_buff *skb,
213 const void *daddr)
d3aaeb38 214{
39232973
DM		 215 struct rt6_info *rt = (struct rt6_info *) dst;
216 struct neighbour *n;
217
f894cbf8 218 daddr = choose_neigh_daddr(rt, skb, daddr);
8e022ee6 219 n = __ipv6_neigh_lookup(dst->dev, daddr);
f83c7790
DM		 220 if (n)
221 return n;
222 return neigh_create(&nd_tbl, daddr, dst->dev);
223}
224
63fca65d
JA		 225static void ip6_confirm_neigh(const struct dst_entry *dst, const void *daddr)
226{
227 struct net_device *dev = dst->dev;
228 struct rt6_info *rt = (struct rt6_info *)dst;
229
230 daddr = choose_neigh_daddr(rt, NULL, daddr);
231 if (!daddr)
232 return;
233 if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
234 return;
235 if (ipv6_addr_is_multicast((const struct in6_addr *)daddr))
236 return;
237 __ipv6_confirm_neigh(dev, daddr);
238}
239
9a7ec3a9 240static struct dst_ops ip6_dst_ops_template = {
1da177e4 241 .family = AF_INET6,
1da177e4
LT		 242 .gc = ip6_dst_gc,
243 .gc_thresh = 1024,
244 .check = ip6_dst_check,
0dbaee3b 245 .default_advmss = ip6_default_advmss,
ebb762f2 246 .mtu = ip6_mtu,
06582540 247 .cow_metrics = ipv6_cow_metrics,
1da177e4
LT		 248 .destroy = ip6_dst_destroy,
249 .ifdown = ip6_dst_ifdown,
250 .negative_advice = ip6_negative_advice,
251 .link_failure = ip6_link_failure,
252 .update_pmtu = ip6_rt_update_pmtu,
6e157b6a 253 .redirect = rt6_do_redirect,
9f8955cc 254 .local_out = __ip6_local_out,
d3aaeb38 255 .neigh_lookup = ip6_neigh_lookup,
63fca65d 256 .confirm_neigh = ip6_confirm_neigh,
1da177e4
LT		 257};
258
ebb762f2 259static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
ec831ea7 260{
618f9bc7
SK		 261 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
262
263 return mtu ? : dst->dev->mtu;
ec831ea7
RD		 264}
265
6700c270
DM		 266static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
267 struct sk_buff *skb, u32 mtu)
14e50e57
DM		 268{
269}
270
6700c270
DM		 271static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
272 struct sk_buff *skb)
b587ee3b
DM		 273{
274}
275
14e50e57
DM		 276static struct dst_ops ip6_dst_blackhole_ops = {
277 .family = AF_INET6,
14e50e57
DM		 278 .destroy = ip6_dst_destroy,
279 .check = ip6_dst_check,
ebb762f2 280 .mtu = ip6_blackhole_mtu,
214f45c9 281 .default_advmss = ip6_default_advmss,
14e50e57 282 .update_pmtu = ip6_rt_blackhole_update_pmtu,
b587ee3b 283 .redirect = ip6_rt_blackhole_redirect,
0a1f5962 284 .cow_metrics = dst_cow_metrics_generic,
d3aaeb38 285 .neigh_lookup = ip6_neigh_lookup,
14e50e57
DM		 286};
287
62fa8a84 288static const u32 ip6_template_metrics[RTAX_MAX] = {
14edd87d 289 [RTAX_HOPLIMIT - 1] = 0,
62fa8a84
DM		 290};
291
fb0af4c7 292static const struct rt6_info ip6_null_entry_template = {
d8d1f30b
CG		 293 .dst = {
294 .__refcnt = ATOMIC_INIT(1),
295 .__use = 1,
2c20cbd7 296 .obsolete = DST_OBSOLETE_FORCE_CHK,
d8d1f30b 297 .error = -ENETUNREACH,
d8d1f30b
CG		 298 .input = ip6_pkt_discard,
299 .output = ip6_pkt_discard_out,
1da177e4
LT		 300 },
301 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
4f724279 302 .rt6i_protocol = RTPROT_KERNEL,
1da177e4
LT		 303 .rt6i_metric = ~(u32) 0,
304 .rt6i_ref = ATOMIC_INIT(1),
305};
306
101367c2
TG		 307#ifdef CONFIG_IPV6_MULTIPLE_TABLES
308
fb0af4c7 309static const struct rt6_info ip6_prohibit_entry_template = {
d8d1f30b
CG		 310 .dst = {
311 .__refcnt = ATOMIC_INIT(1),
312 .__use = 1,
2c20cbd7 313 .obsolete = DST_OBSOLETE_FORCE_CHK,
d8d1f30b 314 .error = -EACCES,
d8d1f30b
CG		 315 .input = ip6_pkt_prohibit,
316 .output = ip6_pkt_prohibit_out,
101367c2
TG		 317 },
318 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
4f724279 319 .rt6i_protocol = RTPROT_KERNEL,
101367c2
TG		 320 .rt6i_metric = ~(u32) 0,
321 .rt6i_ref = ATOMIC_INIT(1),
322};
323
fb0af4c7 324static const struct rt6_info ip6_blk_hole_entry_template = {
d8d1f30b
CG		 325 .dst = {
326 .__refcnt = ATOMIC_INIT(1),
327 .__use = 1,
2c20cbd7 328 .obsolete = DST_OBSOLETE_FORCE_CHK,
d8d1f30b 329 .error = -EINVAL,
d8d1f30b 330 .input = dst_discard,
ede2059d 331 .output = dst_discard_out,
101367c2
TG		 332 },
333 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
4f724279 334 .rt6i_protocol = RTPROT_KERNEL,
101367c2
TG		 335 .rt6i_metric = ~(u32) 0,
336 .rt6i_ref = ATOMIC_INIT(1),
337};
338
339#endif
340
ebfa45f0
MKL		 341static void rt6_info_init(struct rt6_info *rt)
342{
343 struct dst_entry *dst = &rt->dst;
344
345 memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
346 INIT_LIST_HEAD(&rt->rt6i_siblings);
347 INIT_LIST_HEAD(&rt->rt6i_uncached);
348}
349
1da177e4 350/* allocate dst with ip6_dst_ops */
d52d3997
MKL		 351static struct rt6_info *__ip6_dst_alloc(struct net *net,
352 struct net_device *dev,
ad706862 353 int flags)
1da177e4 354{
97bab73f 355 struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
b2a9c0ed 356 1, DST_OBSOLETE_FORCE_CHK, flags);
cf911662 357
ebfa45f0
MKL		 358 if (rt)
359 rt6_info_init(rt);
8104891b 360
cf911662 361 return rt;
1da177e4
LT		 362}
363
9ab179d8
DA		 364struct rt6_info *ip6_dst_alloc(struct net *net,
365 struct net_device *dev,
366 int flags)
d52d3997 367{
ad706862 368 struct rt6_info *rt = __ip6_dst_alloc(net, dev, flags);
d52d3997
MKL		 369
370 if (rt) {
371 rt->rt6i_pcpu = alloc_percpu_gfp(struct rt6_info *, GFP_ATOMIC);
372 if (rt->rt6i_pcpu) {
373 int cpu;
374
375 for_each_possible_cpu(cpu) {
376 struct rt6_info **p;
377
378 p = per_cpu_ptr(rt->rt6i_pcpu, cpu);
379 /* no one shares rt */
380 *p = NULL;
381 }
382 } else {
587fea74 383 dst_release_immediate(&rt->dst);
d52d3997
MKL		 384 return NULL;
385 }
386 }
387
388 return rt;
389}
9ab179d8 390EXPORT_SYMBOL(ip6_dst_alloc);
d52d3997 391
1da177e4
LT		 392static void ip6_dst_destroy(struct dst_entry *dst)
393{
394 struct rt6_info *rt = (struct rt6_info *)dst;
ecd98837 395 struct dst_entry *from = dst->from;
8d0b94af 396 struct inet6_dev *idev;
1da177e4 397
4b32b5ad 398 dst_destroy_metrics_generic(dst);
87775312 399 free_percpu(rt->rt6i_pcpu);
8d0b94af
MKL		 400 rt6_uncached_list_del(rt);
401
402 idev = rt->rt6i_idev;
38308473 403 if (idev) {
1da177e4
LT		 404 rt->rt6i_idev = NULL;
405 in6_dev_put(idev);
1ab1457c 406 }
1716a961 407
ecd98837
YH		 408 dst->from = NULL;
409 dst_release(from);
b3419363
DM		 410}
411
1da177e4
LT		 412static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
413 int how)
414{
415 struct rt6_info *rt = (struct rt6_info *)dst;
416 struct inet6_dev *idev = rt->rt6i_idev;
5a3e55d6 417 struct net_device *loopback_dev =
c346dca1 418 dev_net(dev)->loopback_dev;
1da177e4 419
e5645f51
WW		 420 if (idev && idev->dev != loopback_dev) {
421 struct inet6_dev *loopback_idev = in6_dev_get(loopback_dev);
422 if (loopback_idev) {
423 rt->rt6i_idev = loopback_idev;
424 in6_dev_put(idev);
97cac082 425 }
1da177e4
LT		 426 }
427}
428
5973fb1e
MKL		 429static bool __rt6_check_expired(const struct rt6_info *rt)
430{
431 if (rt->rt6i_flags & RTF_EXPIRES)
432 return time_after(jiffies, rt->dst.expires);
433 else
434 return false;
435}
436
a50feda5 437static bool rt6_check_expired(const struct rt6_info *rt)
1da177e4 438{
1716a961
G		 439 if (rt->rt6i_flags & RTF_EXPIRES) {
440 if (time_after(jiffies, rt->dst.expires))
a50feda5 441 return true;
1716a961 442 } else if (rt->dst.from) {
1e2ea8ad
XL		 443 return rt->dst.obsolete != DST_OBSOLETE_FORCE_CHK ||
444 rt6_check_expired((struct rt6_info *)rt->dst.from);
1716a961 445 }
a50feda5 446 return false;
1da177e4
LT		 447}
448
51ebd318 449static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
52bd4c0c
ND		 450 struct flowi6 *fl6, int oif,
451 int strict)
51ebd318
ND		 452{
453 struct rt6_info *sibling, *next_sibling;
454 int route_choosen;
455
b673d6cc
JS		 456 /* We might have already computed the hash for ICMPv6 errors. In such
457 * case it will always be non-zero. Otherwise now is the time to do it.
458 */
459 if (!fl6->mp_hash)
460 fl6->mp_hash = rt6_multipath_hash(fl6, NULL);
461
462 route_choosen = fl6->mp_hash % (match->rt6i_nsiblings + 1);
51ebd318
ND		 463 /* Don't change the route, if route_choosen == 0
464 * (siblings does not include ourself)
465 */
466 if (route_choosen)
467 list_for_each_entry_safe(sibling, next_sibling,
468 &match->rt6i_siblings, rt6i_siblings) {
469 route_choosen--;
470 if (route_choosen == 0) {
52bd4c0c
ND		 471 if (rt6_score_route(sibling, oif, strict) < 0)
472 break;
51ebd318
ND		 473 match = sibling;
474 break;
475 }
476 }
477 return match;
478}
479
1da177e4 480/*
c71099ac 481 * Route lookup. Any table->tb6_lock is implied.
1da177e4
LT		 482 */
483
8ed67789
DL		 484static inline struct rt6_info *rt6_device_match(struct net *net,
485 struct rt6_info *rt,
b71d1d42 486 const struct in6_addr *saddr,
1da177e4 487 int oif,
d420895e 488 int flags)
1da177e4
LT		 489{
490 struct rt6_info *local = NULL;
491 struct rt6_info *sprt;
492
dd3abc4e
YH		 493 if (!oif && ipv6_addr_any(saddr))
494 goto out;
495
d8d1f30b 496 for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
d1918542 497 struct net_device *dev = sprt->dst.dev;
dd3abc4e
YH		 498
499 if (oif) {
1da177e4
LT		 500 if (dev->ifindex == oif)
501 return sprt;
502 if (dev->flags & IFF_LOOPBACK) {
38308473 503 if (!sprt->rt6i_idev ||
1da177e4 504 sprt->rt6i_idev->dev->ifindex != oif) {
17fb0b2b 505 if (flags & RT6_LOOKUP_F_IFACE)
1da177e4 506 continue;
17fb0b2b
DA		 507 if (local &&
508 local->rt6i_idev->dev->ifindex == oif)
1da177e4
LT		 509 continue;
510 }
511 local = sprt;
512 }
dd3abc4e
YH		 513 } else {
514 if (ipv6_chk_addr(net, saddr, dev,
515 flags & RT6_LOOKUP_F_IFACE))
516 return sprt;
1da177e4 517 }
dd3abc4e 518 }
1da177e4 519
dd3abc4e 520 if (oif) {
1da177e4
LT		 521 if (local)
522 return local;
523
d420895e 524 if (flags & RT6_LOOKUP_F_IFACE)
8ed67789 525 return net->ipv6.ip6_null_entry;
1da177e4 526 }
dd3abc4e 527out:
1da177e4
LT		 528 return rt;
529}
530
27097255 531#ifdef CONFIG_IPV6_ROUTER_PREF
c2f17e82
HFS		 532struct __rt6_probe_work {
533 struct work_struct work;
534 struct in6_addr target;
535 struct net_device *dev;
536};
537
538static void rt6_probe_deferred(struct work_struct *w)
539{
540 struct in6_addr mcaddr;
541 struct __rt6_probe_work *work =
542 container_of(w, struct __rt6_probe_work, work);
543
544 addrconf_addr_solict_mult(&work->target, &mcaddr);
adc176c5 545 ndisc_send_ns(work->dev, &work->target, &mcaddr, NULL, 0);
c2f17e82 546 dev_put(work->dev);
662f5533 547 kfree(work);
c2f17e82
HFS		 548}
549
27097255
YH		 550static void rt6_probe(struct rt6_info *rt)
551{
990edb42 552 struct __rt6_probe_work *work;
f2c31e32 553 struct neighbour *neigh;
27097255
YH		 554 /*
555 * Okay, this does not seem to be appropriate
556 * for now, however, we need to check if it
557 * is really so; aka Router Reachability Probing.
558 *
559 * Router Reachability Probe MUST be rate-limited
560 * to no more than one per minute.
561 */
2152caea 562 if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))
7ff74a59 563 return;
2152caea
YH		 564 rcu_read_lock_bh();
565 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
566 if (neigh) {
8d6c31bf
MKL		 567 if (neigh->nud_state & NUD_VALID)
568 goto out;
569
990edb42 570 work = NULL;
2152caea 571 write_lock(&neigh->lock);
990edb42
MKL		 572 if (!(neigh->nud_state & NUD_VALID) &&
573 time_after(jiffies,
574 neigh->updated +
575 rt->rt6i_idev->cnf.rtr_probe_interval)) {
576 work = kmalloc(sizeof(*work), GFP_ATOMIC);
577 if (work)
578 __neigh_set_probe_once(neigh);
c2f17e82 579 }
2152caea 580 write_unlock(&neigh->lock);
990edb42
MKL		 581 } else {
582 work = kmalloc(sizeof(*work), GFP_ATOMIC);
f2c31e32 583 }
990edb42
MKL		 584
585 if (work) {
586 INIT_WORK(&work->work, rt6_probe_deferred);
587 work->target = rt->rt6i_gateway;
588 dev_hold(rt->dst.dev);
589 work->dev = rt->dst.dev;
590 schedule_work(&work->work);
591 }
592
8d6c31bf 593out:
2152caea 594 rcu_read_unlock_bh();
27097255
YH		 595}
596#else
597static inline void rt6_probe(struct rt6_info *rt)
598{
27097255
YH		 599}
600#endif
601
1da177e4 602/*
554cfb7e 603 * Default Router Selection (RFC 2461 6.3.6)
1da177e4 604 */
b6f99a21 605static inline int rt6_check_dev(struct rt6_info *rt, int oif)
554cfb7e 606{
d1918542 607 struct net_device *dev = rt->dst.dev;
161980f4 608 if (!oif || dev->ifindex == oif)
554cfb7e 609 return 2;
161980f4
DM		 610 if ((dev->flags & IFF_LOOPBACK) &&
611 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
612 return 1;
613 return 0;
554cfb7e 614}
1da177e4 615
afc154e9 616static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)
1da177e4 617{
f2c31e32 618 struct neighbour *neigh;
afc154e9 619 enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
f2c31e32 620
4d0c5911
YH		 621 if (rt->rt6i_flags & RTF_NONEXTHOP ||
622 !(rt->rt6i_flags & RTF_GATEWAY))
afc154e9 623 return RT6_NUD_SUCCEED;
145a3621
YH		 624
625 rcu_read_lock_bh();
626 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
627 if (neigh) {
628 read_lock(&neigh->lock);
554cfb7e 629 if (neigh->nud_state & NUD_VALID)
afc154e9 630 ret = RT6_NUD_SUCCEED;
398bcbeb 631#ifdef CONFIG_IPV6_ROUTER_PREF
a5a81f0b 632 else if (!(neigh->nud_state & NUD_FAILED))
afc154e9 633 ret = RT6_NUD_SUCCEED;
7e980569
JB		 634 else
635 ret = RT6_NUD_FAIL_PROBE;
398bcbeb 636#endif
145a3621 637 read_unlock(&neigh->lock);
afc154e9
HFS		 638 } else {
639 ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
7e980569 640 RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;
a5a81f0b 641 }
145a3621
YH		 642 rcu_read_unlock_bh();
643
a5a81f0b 644 return ret;
1da177e4
LT		 645}
646
554cfb7e
YH		 647static int rt6_score_route(struct rt6_info *rt, int oif,
648 int strict)
1da177e4 649{
a5a81f0b 650 int m;
1ab1457c 651
4d0c5911 652 m = rt6_check_dev(rt, oif);
77d16f45 653 if (!m && (strict & RT6_LOOKUP_F_IFACE))
afc154e9 654 return RT6_NUD_FAIL_HARD;
ebacaaa0
YH		 655#ifdef CONFIG_IPV6_ROUTER_PREF
656 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
657#endif
afc154e9
HFS		 658 if (strict & RT6_LOOKUP_F_REACHABLE) {
659 int n = rt6_check_neigh(rt);
660 if (n < 0)
661 return n;
662 }
554cfb7e
YH		 663 return m;
664}
665
f11e6659 666static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
afc154e9
HFS		 667 int *mpri, struct rt6_info *match,
668 bool *do_rr)
554cfb7e 669{
f11e6659 670 int m;
afc154e9 671 bool match_do_rr = false;
35103d11
AG		 672 struct inet6_dev *idev = rt->rt6i_idev;
673 struct net_device *dev = rt->dst.dev;
674
675 if (dev && !netif_carrier_ok(dev) &&
d5d32e4b
DA		 676 idev->cnf.ignore_routes_with_linkdown &&
677 !(strict & RT6_LOOKUP_F_IGNORE_LINKSTATE))
35103d11 678 goto out;
f11e6659
DM		 679
680 if (rt6_check_expired(rt))
681 goto out;
682
683 m = rt6_score_route(rt, oif, strict);
7e980569 684 if (m == RT6_NUD_FAIL_DO_RR) {
afc154e9
HFS		 685 match_do_rr = true;
686 m = 0; /* lowest valid score */
7e980569 687 } else if (m == RT6_NUD_FAIL_HARD) {
f11e6659 688 goto out;
afc154e9
HFS		 689 }
690
691 if (strict & RT6_LOOKUP_F_REACHABLE)
692 rt6_probe(rt);
f11e6659 693
7e980569 694 /* note that m can be RT6_NUD_FAIL_PROBE at this point */
f11e6659 695 if (m > *mpri) {
afc154e9 696 *do_rr = match_do_rr;
f11e6659
DM		 697 *mpri = m;
698 match = rt;
f11e6659 699 }
f11e6659
DM		 700out:
701 return match;
702}
703
704static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
705 struct rt6_info *rr_head,
afc154e9
HFS		 706 u32 metric, int oif, int strict,
707 bool *do_rr)
f11e6659 708{
9fbdcfaf 709 struct rt6_info *rt, *match, *cont;
554cfb7e 710 int mpri = -1;
1da177e4 711
f11e6659 712 match = NULL;
9fbdcfaf
SK		 713 cont = NULL;
714 for (rt = rr_head; rt; rt = rt->dst.rt6_next) {
715 if (rt->rt6i_metric != metric) {
716 cont = rt;
717 break;
718 }
719
720 match = find_match(rt, oif, strict, &mpri, match, do_rr);
721 }
722
723 for (rt = fn->leaf; rt && rt != rr_head; rt = rt->dst.rt6_next) {
724 if (rt->rt6i_metric != metric) {
725 cont = rt;
726 break;
727 }
728
afc154e9 729 match = find_match(rt, oif, strict, &mpri, match, do_rr);
9fbdcfaf
SK		 730 }
731
732 if (match || !cont)
733 return match;
734
735 for (rt = cont; rt; rt = rt->dst.rt6_next)
afc154e9 736 match = find_match(rt, oif, strict, &mpri, match, do_rr);
1da177e4 737
f11e6659
DM		 738 return match;
739}
1da177e4 740
f11e6659
DM		 741static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
742{
743 struct rt6_info *match, *rt0;
8ed67789 744 struct net *net;
afc154e9 745 bool do_rr = false;
1da177e4 746
f11e6659
DM		 747 rt0 = fn->rr_ptr;
748 if (!rt0)
749 fn->rr_ptr = rt0 = fn->leaf;
1da177e4 750
afc154e9
HFS		 751 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
752 &do_rr);
1da177e4 753
afc154e9 754 if (do_rr) {
d8d1f30b 755 struct rt6_info *next = rt0->dst.rt6_next;
f11e6659 756
554cfb7e 757 /* no entries matched; do round-robin */
f11e6659
DM		 758 if (!next || next->rt6i_metric != rt0->rt6i_metric)
759 next = fn->leaf;
760
761 if (next != rt0)
762 fn->rr_ptr = next;
1da177e4 763 }
1da177e4 764
d1918542 765 net = dev_net(rt0->dst.dev);
a02cec21 766 return match ? match : net->ipv6.ip6_null_entry;
1da177e4
LT		 767}
768
8b9df265
MKL		 769static bool rt6_is_gw_or_nonexthop(const struct rt6_info *rt)
770{
771 return (rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY));
772}
773
70ceb4f5
YH		 774#ifdef CONFIG_IPV6_ROUTE_INFO
775int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
b71d1d42 776 const struct in6_addr *gwaddr)
70ceb4f5 777{
c346dca1 778 struct net *net = dev_net(dev);
70ceb4f5
YH		 779 struct route_info *rinfo = (struct route_info *) opt;
780 struct in6_addr prefix_buf, *prefix;
781 unsigned int pref;
4bed72e4 782 unsigned long lifetime;
70ceb4f5
YH		 783 struct rt6_info *rt;
784
785 if (len < sizeof(struct route_info)) {
786 return -EINVAL;
787 }
788
789 /* Sanity check for prefix_len and length */
790 if (rinfo->length > 3) {
791 return -EINVAL;
792 } else if (rinfo->prefix_len > 128) {
793 return -EINVAL;
794 } else if (rinfo->prefix_len > 64) {
795 if (rinfo->length < 2) {
796 return -EINVAL;
797 }
798 } else if (rinfo->prefix_len > 0) {
799 if (rinfo->length < 1) {
800 return -EINVAL;
801 }
802 }
803
804 pref = rinfo->route_pref;
805 if (pref == ICMPV6_ROUTER_PREF_INVALID)
3933fc95 806 return -EINVAL;
70ceb4f5 807
4bed72e4 808 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
70ceb4f5
YH		 809
810 if (rinfo->length == 3)
811 prefix = (struct in6_addr *)rinfo->prefix;
812 else {
813 /* this function is safe */
814 ipv6_addr_prefix(&prefix_buf,
815 (struct in6_addr *)rinfo->prefix,
816 rinfo->prefix_len);
817 prefix = &prefix_buf;
818 }
819
f104a567
DJ		 820 if (rinfo->prefix_len == 0)
821 rt = rt6_get_dflt_router(gwaddr, dev);
822 else
823 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,
830218c1 824 gwaddr, dev);
70ceb4f5
YH		 825
826 if (rt && !lifetime) {
e0a1ad73 827 ip6_del_rt(rt);
70ceb4f5
YH		 828 rt = NULL;
829 }
830
831 if (!rt && lifetime)
830218c1
DA		 832 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr,
833 dev, pref);
70ceb4f5
YH		 834 else if (rt)
835 rt->rt6i_flags = RTF_ROUTEINFO |
836 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
837
838 if (rt) {
1716a961
G		 839 if (!addrconf_finite_timeout(lifetime))
840 rt6_clean_expires(rt);
841 else
842 rt6_set_expires(rt, jiffies + HZ * lifetime);
843
94e187c0 844 ip6_rt_put(rt);
70ceb4f5
YH		 845 }
846 return 0;
847}
848#endif
849
a3c00e46
MKL		 850static struct fib6_node* fib6_backtrack(struct fib6_node *fn,
851 struct in6_addr *saddr)
852{
853 struct fib6_node *pn;
854 while (1) {
855 if (fn->fn_flags & RTN_TL_ROOT)
856 return NULL;
857 pn = fn->parent;
858 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn)
859 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr);
860 else
861 fn = pn;
862 if (fn->fn_flags & RTN_RTINFO)
863 return fn;
864 }
865}
c71099ac 866
8ed67789
DL		 867static struct rt6_info *ip6_pol_route_lookup(struct net *net,
868 struct fib6_table *table,
4c9483b2 869 struct flowi6 *fl6, int flags)
1da177e4
LT		 870{
871 struct fib6_node *fn;
872 struct rt6_info *rt;
873
d1b820bd
DA		 874 if (fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF)
875 flags &= ~RT6_LOOKUP_F_IFACE;
876
c71099ac 877 read_lock_bh(&table->tb6_lock);
4c9483b2 878 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
c71099ac
TG		 879restart:
880 rt = fn->leaf;
4c9483b2 881 rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
51ebd318 882 if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
52bd4c0c 883 rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);
a3c00e46
MKL		 884 if (rt == net->ipv6.ip6_null_entry) {
885 fn = fib6_backtrack(fn, &fl6->saddr);
886 if (fn)
887 goto restart;
888 }
d8d1f30b 889 dst_use(&rt->dst, jiffies);
c71099ac 890 read_unlock_bh(&table->tb6_lock);
b811580d
DA		 891
892 trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
893
c71099ac
TG		 894 return rt;
895
896}
897
67ba4152 898struct dst_entry *ip6_route_lookup(struct net *net, struct flowi6 *fl6,
ea6e574e
FW		 899 int flags)
900{
901 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
902}
903EXPORT_SYMBOL_GPL(ip6_route_lookup);
904
9acd9f3a
YH		 905struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
906 const struct in6_addr *saddr, int oif, int strict)
c71099ac 907{
4c9483b2
DM		 908 struct flowi6 fl6 = {
909 .flowi6_oif = oif,
910 .daddr = *daddr,
c71099ac
TG		 911 };
912 struct dst_entry *dst;
77d16f45 913 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
c71099ac 914
adaa70bb 915 if (saddr) {
4c9483b2 916 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
adaa70bb
TG		 917 flags |= RT6_LOOKUP_F_HAS_SADDR;
918 }
919
4c9483b2 920 dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
c71099ac
TG		 921 if (dst->error == 0)
922 return (struct rt6_info *) dst;
923
924 dst_release(dst);
925
1da177e4
LT		 926 return NULL;
927}
7159039a
YH		 928EXPORT_SYMBOL(rt6_lookup);
929
c71099ac 930/* ip6_ins_rt is called with FREE table->tb6_lock.
1cfb71ee
WW		 931 * It takes new route entry, the addition fails by any reason the
932 * route is released.
933 * Caller must hold dst before calling it.
1da177e4
LT		 934 */
935
e5fd387a 936static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,
333c4301
DA		 937 struct mx6_config *mxc,
938 struct netlink_ext_ack *extack)
1da177e4
LT		 939{
940 int err;
c71099ac 941 struct fib6_table *table;
1da177e4 942
c71099ac
TG		 943 table = rt->rt6i_table;
944 write_lock_bh(&table->tb6_lock);
333c4301 945 err = fib6_add(&table->tb6_root, rt, info, mxc, extack);
c71099ac 946 write_unlock_bh(&table->tb6_lock);
1da177e4
LT		 947
948 return err;
949}
950
40e22e8f
TG		 951int ip6_ins_rt(struct rt6_info *rt)
952{
e715b6d3
FW		 953 struct nl_info info = { .nl_net = dev_net(rt->dst.dev), };
954 struct mx6_config mxc = { .mx = NULL, };
955
1cfb71ee
WW		 956 /* Hold dst to account for the reference from the fib6 tree */
957 dst_hold(&rt->dst);
333c4301 958 return __ip6_ins_rt(rt, &info, &mxc, NULL);
40e22e8f
TG		 959}
960
4832c30d
DA		 961/* called with rcu_lock held */
962static struct net_device *ip6_rt_get_dev_rcu(struct rt6_info *rt)
963{
964 struct net_device *dev = rt->dst.dev;
965
7afe2e66 966 if (rt->rt6i_flags & (RTF_LOCAL | RTF_ANYCAST)) {
4832c30d
DA		 967 /* for copies of local routes, dst->dev needs to be the
968 * device if it is a master device, the master device if
969 * device is enslaved, and the loopback as the default
970 */
971 if (netif_is_l3_slave(dev) &&
972 !rt6_need_strict(&rt->rt6i_dst.addr))
973 dev = l3mdev_master_dev_rcu(dev);
974 else if (!netif_is_l3_master(dev))
975 dev = dev_net(dev)->loopback_dev;
976 /* last case is netif_is_l3_master(dev) is true in which
977 * case we want dev returned to be dev
978 */
979 }
980
981 return dev;
982}
983
8b9df265
MKL		 984static struct rt6_info *ip6_rt_cache_alloc(struct rt6_info *ort,
985 const struct in6_addr *daddr,
986 const struct in6_addr *saddr)
1da177e4 987{
4832c30d 988 struct net_device *dev;
1da177e4
LT		 989 struct rt6_info *rt;
990
991 /*
992 * Clone the route.
993 */
994
d52d3997 995 if (ort->rt6i_flags & (RTF_CACHE | RTF_PCPU))
83a09abd 996 ort = (struct rt6_info *)ort->dst.from;
1da177e4 997
4832c30d
DA		 998 rcu_read_lock();
999 dev = ip6_rt_get_dev_rcu(ort);
1000 rt = __ip6_dst_alloc(dev_net(dev), dev, 0);
1001 rcu_read_unlock();
83a09abd
MKL		 1002 if (!rt)
1003 return NULL;
1004
1005 ip6_rt_copy_init(rt, ort);
1006 rt->rt6i_flags |= RTF_CACHE;
1007 rt->rt6i_metric = 0;
1008 rt->dst.flags |= DST_HOST;
1009 rt->rt6i_dst.addr = *daddr;
1010 rt->rt6i_dst.plen = 128;
1da177e4 1011
83a09abd
MKL		 1012 if (!rt6_is_gw_or_nonexthop(ort)) {
1013 if (ort->rt6i_dst.plen != 128 &&
1014 ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
1015 rt->rt6i_flags |= RTF_ANYCAST;
1da177e4 1016#ifdef CONFIG_IPV6_SUBTREES
83a09abd
MKL		 1017 if (rt->rt6i_src.plen && saddr) {
1018 rt->rt6i_src.addr = *saddr;
1019 rt->rt6i_src.plen = 128;
8b9df265 1020 }
83a09abd 1021#endif
95a9a5ba 1022 }
1da177e4 1023
95a9a5ba
YH		 1024 return rt;
1025}
1da177e4 1026
d52d3997
MKL		 1027static struct rt6_info *ip6_rt_pcpu_alloc(struct rt6_info *rt)
1028{
4832c30d 1029 struct net_device *dev;
d52d3997
MKL		 1030 struct rt6_info *pcpu_rt;
1031
4832c30d
DA		 1032 rcu_read_lock();
1033 dev = ip6_rt_get_dev_rcu(rt);
1034 pcpu_rt = __ip6_dst_alloc(dev_net(dev), dev, rt->dst.flags);
1035 rcu_read_unlock();
d52d3997
MKL		 1036 if (!pcpu_rt)
1037 return NULL;
1038 ip6_rt_copy_init(pcpu_rt, rt);
1039 pcpu_rt->rt6i_protocol = rt->rt6i_protocol;
1040 pcpu_rt->rt6i_flags |= RTF_PCPU;
1041 return pcpu_rt;
1042}
1043
1044/* It should be called with read_lock_bh(&tb6_lock) acquired */
1045static struct rt6_info *rt6_get_pcpu_route(struct rt6_info *rt)
1046{
a73e4195 1047 struct rt6_info *pcpu_rt, **p;
d52d3997
MKL		 1048
1049 p = this_cpu_ptr(rt->rt6i_pcpu);
1050 pcpu_rt = *p;
1051
a73e4195
MKL		 1052 if (pcpu_rt) {
1053 dst_hold(&pcpu_rt->dst);
1054 rt6_dst_from_metrics_check(pcpu_rt);
1055 }
1056 return pcpu_rt;
1057}
1058
1059static struct rt6_info *rt6_make_pcpu_route(struct rt6_info *rt)
1060{
add9f2a4 1061 struct fib6_table *table = rt->rt6i_table;
a73e4195 1062 struct rt6_info *pcpu_rt, *prev, **p;
d52d3997
MKL		 1063
1064 pcpu_rt = ip6_rt_pcpu_alloc(rt);
1065 if (!pcpu_rt) {
1066 struct net *net = dev_net(rt->dst.dev);
1067
9c7370a1
MKL		 1068 dst_hold(&net->ipv6.ip6_null_entry->dst);
1069 return net->ipv6.ip6_null_entry;
d52d3997
MKL		 1070 }
1071
add9f2a4
GKH		 1072 read_lock_bh(&table->tb6_lock);
1073 if (rt->rt6i_pcpu) {
1074 p = this_cpu_ptr(rt->rt6i_pcpu);
1075 prev = cmpxchg(p, NULL, pcpu_rt);
1076 if (prev) {
1077 /* If someone did it before us, return prev instead */
1078 dst_release_immediate(&pcpu_rt->dst);
1079 pcpu_rt = prev;
1080 }
1081 } else {
1082 /* rt has been removed from the fib6 tree
1083 * before we have a chance to acquire the read_lock.
1084 * In this case, don't brother to create a pcpu rt
1085 * since rt is going away anyway. The next
1086 * dst_check() will trigger a re-lookup.
1087 */
587fea74 1088 dst_release_immediate(&pcpu_rt->dst);
add9f2a4 1089 pcpu_rt = rt;
d52d3997 1090 }
add9f2a4 1091 dst_hold(&pcpu_rt->dst);
d52d3997 1092 rt6_dst_from_metrics_check(pcpu_rt);
add9f2a4 1093 read_unlock_bh(&table->tb6_lock);
d52d3997
MKL		 1094 return pcpu_rt;
1095}
1096
9ff74384
DA		 1097struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table,
1098 int oif, struct flowi6 *fl6, int flags)
1da177e4 1099{
367efcb9 1100 struct fib6_node *fn, *saved_fn;
45e4fd26 1101 struct rt6_info *rt;
c71099ac 1102 int strict = 0;
1da177e4 1103
77d16f45 1104 strict |= flags & RT6_LOOKUP_F_IFACE;
d5d32e4b 1105 strict |= flags & RT6_LOOKUP_F_IGNORE_LINKSTATE;
367efcb9
MKL		 1106 if (net->ipv6.devconf_all->forwarding == 0)
1107 strict |= RT6_LOOKUP_F_REACHABLE;
1da177e4 1108
c71099ac 1109 read_lock_bh(&table->tb6_lock);
1da177e4 1110
4c9483b2 1111 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
367efcb9 1112 saved_fn = fn;
1da177e4 1113
ca254490
DA		 1114 if (fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF)
1115 oif = 0;
1116
a3c00e46 1117redo_rt6_select:
367efcb9 1118 rt = rt6_select(fn, oif, strict);
52bd4c0c 1119 if (rt->rt6i_nsiblings)
367efcb9 1120 rt = rt6_multipath_select(rt, fl6, oif, strict);
a3c00e46
MKL		 1121 if (rt == net->ipv6.ip6_null_entry) {
1122 fn = fib6_backtrack(fn, &fl6->saddr);
1123 if (fn)
1124 goto redo_rt6_select;
367efcb9
MKL		 1125 else if (strict & RT6_LOOKUP_F_REACHABLE) {
1126 /* also consider unreachable route */
1127 strict &= ~RT6_LOOKUP_F_REACHABLE;
1128 fn = saved_fn;
1129 goto redo_rt6_select;
367efcb9 1130 }
a3c00e46
MKL		 1131 }
1132
fb9de91e 1133
3da59bd9 1134 if (rt == net->ipv6.ip6_null_entry || (rt->rt6i_flags & RTF_CACHE)) {
d52d3997
MKL		 1135 dst_use(&rt->dst, jiffies);
1136 read_unlock_bh(&table->tb6_lock);
1137
1138 rt6_dst_from_metrics_check(rt);
b811580d
DA		 1139
1140 trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
d52d3997 1141 return rt;
3da59bd9
MKL		 1142 } else if (unlikely((fl6->flowi6_flags & FLOWI_FLAG_KNOWN_NH) &&
1143 !(rt->rt6i_flags & RTF_GATEWAY))) {
1144 /* Create a RTF_CACHE clone which will not be
1145 * owned by the fib6 tree. It is for the special case where
1146 * the daddr in the skb during the neighbor look-up is different
1147 * from the fl6->daddr used to look-up route here.
1148 */
1149
1150 struct rt6_info *uncached_rt;
1151
d52d3997
MKL		 1152 dst_use(&rt->dst, jiffies);
1153 read_unlock_bh(&table->tb6_lock);
1154
3da59bd9
MKL		 1155 uncached_rt = ip6_rt_cache_alloc(rt, &fl6->daddr, NULL);
1156 dst_release(&rt->dst);
c71099ac 1157
1cfb71ee
WW		 1158 if (uncached_rt) {
1159 /* Uncached_rt's refcnt is taken during ip6_rt_cache_alloc()
1160 * No need for another dst_hold()
1161 */
8d0b94af 1162 rt6_uncached_list_add(uncached_rt);
1cfb71ee 1163 } else {
3da59bd9 1164 uncached_rt = net->ipv6.ip6_null_entry;
1cfb71ee
WW		 1165 dst_hold(&uncached_rt->dst);
1166 }
b811580d
DA		 1167
1168 trace_fib6_table_lookup(net, uncached_rt, table->tb6_id, fl6);
3da59bd9 1169 return uncached_rt;
3da59bd9 1170
d52d3997
MKL		 1171 } else {
1172 /* Get a percpu copy */
1173
1174 struct rt6_info *pcpu_rt;
1175
1176 rt->dst.lastuse = jiffies;
1177 rt->dst.__use++;
1178 pcpu_rt = rt6_get_pcpu_route(rt);
d52d3997 1179
9c7370a1
MKL		 1180 if (pcpu_rt) {
1181 read_unlock_bh(&table->tb6_lock);
1182 } else {
add9f2a4
GKH		 1183 /* We have to do the read_unlock first
1184 * because rt6_make_pcpu_route() may trigger
1185 * ip6_dst_gc() which will take the write_lock.
1186 */
1187 dst_hold(&rt->dst);
1188 read_unlock_bh(&table->tb6_lock);
1189 pcpu_rt = rt6_make_pcpu_route(rt);
1190 dst_release(&rt->dst);
9c7370a1 1191 }
d52d3997 1192
b811580d 1193 trace_fib6_table_lookup(net, pcpu_rt, table->tb6_id, fl6);
d52d3997 1194 return pcpu_rt;
add9f2a4 1195
d52d3997 1196 }
1da177e4 1197}
9ff74384 1198EXPORT_SYMBOL_GPL(ip6_pol_route);
1da177e4 1199
8ed67789 1200static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
4c9483b2 1201 struct flowi6 *fl6, int flags)
4acad72d 1202{
4c9483b2 1203 return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
4acad72d
PE		 1204}
1205
d409b847
MB		 1206struct dst_entry *ip6_route_input_lookup(struct net *net,
1207 struct net_device *dev,
1208 struct flowi6 *fl6, int flags)
72331bc0
SL		 1209{
1210 if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
1211 flags |= RT6_LOOKUP_F_IFACE;
1212
1213 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
1214}
d409b847 1215EXPORT_SYMBOL_GPL(ip6_route_input_lookup);
72331bc0 1216
23aebdac
JS		 1217static void ip6_multipath_l3_keys(const struct sk_buff *skb,
1218 struct flow_keys *keys)
1219{
1220 const struct ipv6hdr *outer_iph = ipv6_hdr(skb);
1221 const struct ipv6hdr *key_iph = outer_iph;
1222 const struct ipv6hdr *inner_iph;
1223 const struct icmp6hdr *icmph;
1224 struct ipv6hdr _inner_iph;
1225
1226 if (likely(outer_iph->nexthdr != IPPROTO_ICMPV6))
1227 goto out;
1228
1229 icmph = icmp6_hdr(skb);
1230 if (icmph->icmp6_type != ICMPV6_DEST_UNREACH &&
1231 icmph->icmp6_type != ICMPV6_PKT_TOOBIG &&
1232 icmph->icmp6_type != ICMPV6_TIME_EXCEED &&
1233 icmph->icmp6_type != ICMPV6_PARAMPROB)
1234 goto out;
1235
1236 inner_iph = skb_header_pointer(skb,
1237 skb_transport_offset(skb) + sizeof(*icmph),
1238 sizeof(_inner_iph), &_inner_iph);
1239 if (!inner_iph)
1240 goto out;
1241
1242 key_iph = inner_iph;
1243out:
1244 memset(keys, 0, sizeof(*keys));
1245 keys->control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
1246 keys->addrs.v6addrs.src = key_iph->saddr;
1247 keys->addrs.v6addrs.dst = key_iph->daddr;
1248 keys->tags.flow_label = ip6_flowinfo(key_iph);
1249 keys->basic.ip_proto = key_iph->nexthdr;
1250}
1251
1252/* if skb is set it will be used and fl6 can be NULL */
1253u32 rt6_multipath_hash(const struct flowi6 *fl6, const struct sk_buff *skb)
1254{
1255 struct flow_keys hash_keys;
1256
1257 if (skb) {
1258 ip6_multipath_l3_keys(skb, &hash_keys);
1259 return flow_hash_from_keys(&hash_keys);
1260 }
1261
1262 return get_hash_from_flowi6(fl6);
1263}
1264
c71099ac
TG		 1265void ip6_route_input(struct sk_buff *skb)
1266{
b71d1d42 1267 const struct ipv6hdr *iph = ipv6_hdr(skb);
c346dca1 1268 struct net *net = dev_net(skb->dev);
adaa70bb 1269 int flags = RT6_LOOKUP_F_HAS_SADDR;
904af04d 1270 struct ip_tunnel_info *tun_info;
4c9483b2 1271 struct flowi6 fl6 = {
e0d56fdd 1272 .flowi6_iif = skb->dev->ifindex,
4c9483b2
DM		 1273 .daddr = iph->daddr,
1274 .saddr = iph->saddr,
6502ca52 1275 .flowlabel = ip6_flowinfo(iph),
4c9483b2
DM		 1276 .flowi6_mark = skb->mark,
1277 .flowi6_proto = iph->nexthdr,
c71099ac 1278 };
adaa70bb 1279
904af04d 1280 tun_info = skb_tunnel_info(skb);
46fa062a 1281 if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
904af04d 1282 fl6.flowi6_tun_key.tun_id = tun_info->key.tun_id;
23aebdac
JS		 1283 if (unlikely(fl6.flowi6_proto == IPPROTO_ICMPV6))
1284 fl6.mp_hash = rt6_multipath_hash(&fl6, skb);
06e9d040 1285 skb_dst_drop(skb);
72331bc0 1286 skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
c71099ac
TG		 1287}
1288
8ed67789 1289static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
4c9483b2 1290 struct flowi6 *fl6, int flags)
1da177e4 1291{
4c9483b2 1292 return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
c71099ac
TG		 1293}
1294
6f21c96a
PA		 1295struct dst_entry *ip6_route_output_flags(struct net *net, const struct sock *sk,
1296 struct flowi6 *fl6, int flags)
c71099ac 1297{
d46a9d67 1298 bool any_src;
c71099ac 1299
4c1feac5
DA		 1300 if (rt6_need_strict(&fl6->daddr)) {
1301 struct dst_entry *dst;
1302
1303 dst = l3mdev_link_scope_lookup(net, fl6);
1304 if (dst)
1305 return dst;
1306 }
ca254490 1307
1fb9489b 1308 fl6->flowi6_iif = LOOPBACK_IFINDEX;
4dc27d1c 1309
d46a9d67 1310 any_src = ipv6_addr_any(&fl6->saddr);
741a11d9 1311 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr) ||
d46a9d67 1312 (fl6->flowi6_oif && any_src))
77d16f45 1313 flags |= RT6_LOOKUP_F_IFACE;
c71099ac 1314
d46a9d67 1315 if (!any_src)
adaa70bb 1316 flags |= RT6_LOOKUP_F_HAS_SADDR;
0c9a2ac1
YH		 1317 else if (sk)
1318 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
adaa70bb 1319
4c9483b2 1320 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
1da177e4 1321}
6f21c96a 1322EXPORT_SYMBOL_GPL(ip6_route_output_flags);
1da177e4 1323
2774c131 1324struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
14e50e57 1325{
5c1e6aa3 1326 struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
1dbe3252 1327 struct net_device *loopback_dev = net->loopback_dev;
14e50e57
DM		 1328 struct dst_entry *new = NULL;
1329
1dbe3252 1330 rt = dst_alloc(&ip6_dst_blackhole_ops, loopback_dev, 1,
62cf27e5 1331 DST_OBSOLETE_DEAD, 0);
14e50e57 1332 if (rt) {
0a1f5962 1333 rt6_info_init(rt);
8104891b 1334
0a1f5962 1335 new = &rt->dst;
14e50e57 1336 new->__use = 1;
352e512c 1337 new->input = dst_discard;
ede2059d 1338 new->output = dst_discard_out;
14e50e57 1339
0a1f5962 1340 dst_copy_metrics(new, &ort->dst);
14e50e57 1341
1dbe3252 1342 rt->rt6i_idev = in6_dev_get(loopback_dev);
4e3fd7a0 1343 rt->rt6i_gateway = ort->rt6i_gateway;
0a1f5962 1344 rt->rt6i_flags = ort->rt6i_flags & ~RTF_PCPU;
14e50e57
DM		 1345 rt->rt6i_metric = 0;
1346
1347 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1348#ifdef CONFIG_IPV6_SUBTREES
1349 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1350#endif
14e50e57
DM		 1351 }
1352
69ead7af
DM		 1353 dst_release(dst_orig);
1354 return new ? new : ERR_PTR(-ENOMEM);
14e50e57 1355}
14e50e57 1356
1da177e4
LT		 1357/*
1358 * Destination cache support functions
1359 */
1360
4b32b5ad
MKL		 1361static void rt6_dst_from_metrics_check(struct rt6_info *rt)
1362{
1363 if (rt->dst.from &&
1364 dst_metrics_ptr(&rt->dst) != dst_metrics_ptr(rt->dst.from))
1365 dst_init_metrics(&rt->dst, dst_metrics_ptr(rt->dst.from), true);
1366}
1367
3da59bd9
MKL		 1368static struct dst_entry *rt6_check(struct rt6_info *rt, u32 cookie)
1369{
36143645 1370 u32 rt_cookie = 0;
c5cff856
WW		 1371
1372 if (!rt6_get_cookie_safe(rt, &rt_cookie) || rt_cookie != cookie)
3da59bd9
MKL		 1373 return NULL;
1374
1375 if (rt6_check_expired(rt))
1376 return NULL;
1377
1378 return &rt->dst;
1379}
1380
1381static struct dst_entry *rt6_dst_from_check(struct rt6_info *rt, u32 cookie)
1382{
5973fb1e
MKL		 1383 if (!__rt6_check_expired(rt) &&
1384 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
3da59bd9
MKL		 1385 rt6_check((struct rt6_info *)(rt->dst.from), cookie))
1386 return &rt->dst;
1387 else
1388 return NULL;
1389}
1390
1da177e4
LT		 1391static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1392{
1393 struct rt6_info *rt;
1394
1395 rt = (struct rt6_info *) dst;
1396
6f3118b5
ND		 1397 /* All IPV6 dsts are created with ->obsolete set to the value
1398 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1399 * into this function always.
1400 */
e3bc10bd 1401
4b32b5ad
MKL		 1402 rt6_dst_from_metrics_check(rt);
1403
02bcf4e0 1404 if (rt->rt6i_flags & RTF_PCPU ||
a4c2fd7f 1405 (unlikely(!list_empty(&rt->rt6i_uncached)) && rt->dst.from))
3da59bd9
MKL		 1406 return rt6_dst_from_check(rt, cookie);
1407 else
1408 return rt6_check(rt, cookie);
1da177e4
LT		 1409}
1410
1411static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1412{
1413 struct rt6_info *rt = (struct rt6_info *) dst;
1414
1415 if (rt) {
54c1a859
YH		 1416 if (rt->rt6i_flags & RTF_CACHE) {
1417 if (rt6_check_expired(rt)) {
1418 ip6_del_rt(rt);
1419 dst = NULL;
1420 }
1421 } else {
1da177e4 1422 dst_release(dst);
54c1a859
YH		 1423 dst = NULL;
1424 }
1da177e4 1425 }
54c1a859 1426 return dst;
1da177e4
LT		 1427}
1428
1429static void ip6_link_failure(struct sk_buff *skb)
1430{
1431 struct rt6_info *rt;
1432
3ffe533c 1433 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1da177e4 1434
adf30907 1435 rt = (struct rt6_info *) skb_dst(skb);
1da177e4 1436 if (rt) {
1eb4f758 1437 if (rt->rt6i_flags & RTF_CACHE) {
ad65a2f0
WW		 1438 if (dst_hold_safe(&rt->dst))
1439 ip6_del_rt(rt);
c5cff856
WW		 1440 } else {
1441 struct fib6_node *fn;
1442
1443 rcu_read_lock();
1444 fn = rcu_dereference(rt->rt6i_node);
1445 if (fn && (rt->rt6i_flags & RTF_DEFAULT))
1446 fn->fn_sernum = -1;
1447 rcu_read_unlock();
1eb4f758 1448 }
1da177e4
LT		 1449 }
1450}
1451
45e4fd26
MKL		 1452static void rt6_do_update_pmtu(struct rt6_info *rt, u32 mtu)
1453{
1454 struct net *net = dev_net(rt->dst.dev);
1455
1456 rt->rt6i_flags |= RTF_MODIFIED;
1457 rt->rt6i_pmtu = mtu;
1458 rt6_update_expires(rt, net->ipv6.sysctl.ip6_rt_mtu_expires);
1459}
1460
0d3f6d29
MKL		 1461static bool rt6_cache_allowed_for_pmtu(const struct rt6_info *rt)
1462{
1463 return !(rt->rt6i_flags & RTF_CACHE) &&
4e587ea7
WW		 1464 (rt->rt6i_flags & RTF_PCPU ||
1465 rcu_access_pointer(rt->rt6i_node));
0d3f6d29
MKL		 1466}
1467
45e4fd26
MKL		 1468static void __ip6_rt_update_pmtu(struct dst_entry *dst, const struct sock *sk,
1469 const struct ipv6hdr *iph, u32 mtu)
1da177e4 1470{
0dec879f 1471 const struct in6_addr *daddr, *saddr;
67ba4152 1472 struct rt6_info *rt6 = (struct rt6_info *)dst;
1da177e4 1473
45e4fd26
MKL		 1474 if (rt6->rt6i_flags & RTF_LOCAL)
1475 return;
81aded24 1476
19bda36c
XL		 1477 if (dst_metric_locked(dst, RTAX_MTU))
1478 return;
1479
0dec879f
JA		 1480 if (iph) {
1481 daddr = &iph->daddr;
1482 saddr = &iph->saddr;
1483 } else if (sk) {
1484 daddr = &sk->sk_v6_daddr;
1485 saddr = &inet6_sk(sk)->saddr;
1486 } else {
1487 daddr = NULL;
1488 saddr = NULL;
1489 }
1490 dst_confirm_neigh(dst, daddr);
45e4fd26
MKL		 1491 mtu = max_t(u32, mtu, IPV6_MIN_MTU);
1492 if (mtu >= dst_mtu(dst))
1493 return;
9d289715 1494
0d3f6d29 1495 if (!rt6_cache_allowed_for_pmtu(rt6)) {
45e4fd26 1496 rt6_do_update_pmtu(rt6, mtu);
0dec879f 1497 } else if (daddr) {
45e4fd26
MKL		 1498 struct rt6_info *nrt6;
1499
45e4fd26
MKL		 1500 nrt6 = ip6_rt_cache_alloc(rt6, daddr, saddr);
1501 if (nrt6) {
1502 rt6_do_update_pmtu(nrt6, mtu);
1503
1504 /* ip6_ins_rt(nrt6) will bump the
1505 * rt6->rt6i_node->fn_sernum
1506 * which will fail the next rt6_check() and
1507 * invalidate the sk->sk_dst_cache.
1508 */
1509 ip6_ins_rt(nrt6);
1cfb71ee
WW		 1510 /* Release the reference taken in
1511 * ip6_rt_cache_alloc()
1512 */
1513 dst_release(&nrt6->dst);
45e4fd26 1514 }
1da177e4
LT		 1515 }
1516}
1517
45e4fd26
MKL		 1518static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1519 struct sk_buff *skb, u32 mtu)
1520{
1521 __ip6_rt_update_pmtu(dst, sk, skb ? ipv6_hdr(skb) : NULL, mtu);
1522}
1523
42ae66c8 1524void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
e2d118a1 1525 int oif, u32 mark, kuid_t uid)
81aded24
DM		 1526{
1527 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1528 struct dst_entry *dst;
1529 struct flowi6 fl6;
1530
1531 memset(&fl6, 0, sizeof(fl6));
1532 fl6.flowi6_oif = oif;
1b3c61dc 1533 fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
81aded24
DM		 1534 fl6.daddr = iph->daddr;
1535 fl6.saddr = iph->saddr;
6502ca52 1536 fl6.flowlabel = ip6_flowinfo(iph);
e2d118a1 1537 fl6.flowi6_uid = uid;
81aded24
DM		 1538
1539 dst = ip6_route_output(net, NULL, &fl6);
1540 if (!dst->error)
45e4fd26 1541 __ip6_rt_update_pmtu(dst, NULL, iph, ntohl(mtu));
81aded24
DM		 1542 dst_release(dst);
1543}
1544EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1545
1546void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1547{
33c162a9
MKL		 1548 struct dst_entry *dst;
1549
81aded24 1550 ip6_update_pmtu(skb, sock_net(sk), mtu,
e2d118a1 1551 sk->sk_bound_dev_if, sk->sk_mark, sk->sk_uid);
33c162a9
MKL		 1552
1553 dst = __sk_dst_get(sk);
1554 if (!dst || !dst->obsolete ||
1555 dst->ops->check(dst, inet6_sk(sk)->dst_cookie))
1556 return;
1557
1558 bh_lock_sock(sk);
1559 if (!sock_owned_by_user(sk) && !ipv6_addr_v4mapped(&sk->sk_v6_daddr))
1560 ip6_datagram_dst_update(sk, false);
1561 bh_unlock_sock(sk);
81aded24
DM		 1562}
1563EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1564
b55b76b2
DJ		 1565/* Handle redirects */
1566struct ip6rd_flowi {
1567 struct flowi6 fl6;
1568 struct in6_addr gateway;
1569};
1570
1571static struct rt6_info *__ip6_route_redirect(struct net *net,
1572 struct fib6_table *table,
1573 struct flowi6 *fl6,
1574 int flags)
1575{
1576 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
1577 struct rt6_info *rt;
1578 struct fib6_node *fn;
1579
1580 /* Get the "current" route for this destination and
67c408cf 1581 * check if the redirect has come from appropriate router.
b55b76b2
DJ		 1582 *
1583 * RFC 4861 specifies that redirects should only be
1584 * accepted if they come from the nexthop to the target.
1585 * Due to the way the routes are chosen, this notion
1586 * is a bit fuzzy and one might need to check all possible
1587 * routes.
1588 */
1589
1590 read_lock_bh(&table->tb6_lock);
1591 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1592restart:
1593 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1594 if (rt6_check_expired(rt))
1595 continue;
1596 if (rt->dst.error)
1597 break;
1598 if (!(rt->rt6i_flags & RTF_GATEWAY))
1599 continue;
1600 if (fl6->flowi6_oif != rt->dst.dev->ifindex)
1601 continue;
1602 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1603 continue;
1604 break;
1605 }
1606
1607 if (!rt)
1608 rt = net->ipv6.ip6_null_entry;
1609 else if (rt->dst.error) {
1610 rt = net->ipv6.ip6_null_entry;
b0a1ba59
MKL		 1611 goto out;
1612 }
1613
1614 if (rt == net->ipv6.ip6_null_entry) {
a3c00e46
MKL		 1615 fn = fib6_backtrack(fn, &fl6->saddr);
1616 if (fn)
1617 goto restart;
b55b76b2 1618 }
a3c00e46 1619
b0a1ba59 1620out:
b55b76b2
DJ		 1621 dst_hold(&rt->dst);
1622
1623 read_unlock_bh(&table->tb6_lock);
1624
b811580d 1625 trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
b55b76b2
DJ		 1626 return rt;
1627};
1628
1629static struct dst_entry *ip6_route_redirect(struct net *net,
1630 const struct flowi6 *fl6,
1631 const struct in6_addr *gateway)
1632{
1633 int flags = RT6_LOOKUP_F_HAS_SADDR;
1634 struct ip6rd_flowi rdfl;
1635
1636 rdfl.fl6 = *fl6;
1637 rdfl.gateway = *gateway;
1638
1639 return fib6_rule_lookup(net, &rdfl.fl6,
1640 flags, __ip6_route_redirect);
1641}
1642
e2d118a1
LC		 1643void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark,
1644 kuid_t uid)
3a5ad2ee
DM		 1645{
1646 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1647 struct dst_entry *dst;
1648 struct flowi6 fl6;
1649
1650 memset(&fl6, 0, sizeof(fl6));
e374c618 1651 fl6.flowi6_iif = LOOPBACK_IFINDEX;
3a5ad2ee
DM		 1652 fl6.flowi6_oif = oif;
1653 fl6.flowi6_mark = mark;
3a5ad2ee
DM		 1654 fl6.daddr = iph->daddr;
1655 fl6.saddr = iph->saddr;
6502ca52 1656 fl6.flowlabel = ip6_flowinfo(iph);
e2d118a1 1657 fl6.flowi6_uid = uid;
3a5ad2ee 1658
b55b76b2
DJ		 1659 dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
1660 rt6_do_redirect(dst, NULL, skb);
3a5ad2ee
DM		 1661 dst_release(dst);
1662}
1663EXPORT_SYMBOL_GPL(ip6_redirect);
1664
c92a59ec
DJ		 1665void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
1666 u32 mark)
1667{
1668 const struct ipv6hdr *iph = ipv6_hdr(skb);
1669 const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
1670 struct dst_entry *dst;
1671 struct flowi6 fl6;
1672
1673 memset(&fl6, 0, sizeof(fl6));
e374c618 1674 fl6.flowi6_iif = LOOPBACK_IFINDEX;
c92a59ec
DJ		 1675 fl6.flowi6_oif = oif;
1676 fl6.flowi6_mark = mark;
c92a59ec
DJ		 1677 fl6.daddr = msg->dest;
1678 fl6.saddr = iph->daddr;
e2d118a1 1679 fl6.flowi6_uid = sock_net_uid(net, NULL);
c92a59ec 1680
b55b76b2
DJ		 1681 dst = ip6_route_redirect(net, &fl6, &iph->saddr);
1682 rt6_do_redirect(dst, NULL, skb);
c92a59ec
DJ		 1683 dst_release(dst);
1684}
1685
3a5ad2ee
DM		 1686void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1687{
e2d118a1
LC		 1688 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark,
1689 sk->sk_uid);
3a5ad2ee
DM		 1690}
1691EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1692
0dbaee3b 1693static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1da177e4 1694{
0dbaee3b
DM		 1695 struct net_device *dev = dst->dev;
1696 unsigned int mtu = dst_mtu(dst);
1697 struct net *net = dev_net(dev);
1698
1da177e4
LT		 1699 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1700
5578689a
DL		 1701 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1702 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1da177e4
LT		 1703
1704 /*
1ab1457c
YH		 1705 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1706 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1707 * IPV6_MAXPLEN is also valid and means: "any MSS,
1da177e4
LT		 1708 * rely only on pmtu discovery"
1709 */
1710 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1711 mtu = IPV6_MAXPLEN;
1712 return mtu;
1713}
1714
ebb762f2 1715static unsigned int ip6_mtu(const struct dst_entry *dst)
d33e4553 1716{
4b32b5ad
MKL		 1717 const struct rt6_info *rt = (const struct rt6_info *)dst;
1718 unsigned int mtu = rt->rt6i_pmtu;
d33e4553 1719 struct inet6_dev *idev;
618f9bc7 1720
4b32b5ad
MKL		 1721 if (mtu)
1722 goto out;
1723
1724 mtu = dst_metric_raw(dst, RTAX_MTU);
618f9bc7 1725 if (mtu)
30f78d8e 1726 goto out;
618f9bc7
SK		 1727
1728 mtu = IPV6_MIN_MTU;
d33e4553
DM		 1729
1730 rcu_read_lock();
1731 idev = __in6_dev_get(dst->dev);
1732 if (idev)
1733 mtu = idev->cnf.mtu6;
1734 rcu_read_unlock();
1735
30f78d8e 1736out:
14972cbd
RP		 1737 mtu = min_t(unsigned int, mtu, IP6_MAX_MTU);
1738
1739 return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
d33e4553
DM		 1740}
1741
3b00944c 1742struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
87a11578 1743 struct flowi6 *fl6)
1da177e4 1744{
87a11578 1745 struct dst_entry *dst;
1da177e4
LT		 1746 struct rt6_info *rt;
1747 struct inet6_dev *idev = in6_dev_get(dev);
c346dca1 1748 struct net *net = dev_net(dev);
1da177e4 1749
38308473 1750 if (unlikely(!idev))
122bdf67 1751 return ERR_PTR(-ENODEV);
1da177e4 1752
ad706862 1753 rt = ip6_dst_alloc(net, dev, 0);
38308473 1754 if (unlikely(!rt)) {
1da177e4 1755 in6_dev_put(idev);
87a11578 1756 dst = ERR_PTR(-ENOMEM);
1da177e4
LT		 1757 goto out;
1758 }
1759
8e2ec639 1760 rt->dst.flags |= DST_HOST;
4b2e0f09 1761 rt->dst.input = ip6_input;
8e2ec639 1762 rt->dst.output = ip6_output;
550bab42 1763 rt->rt6i_gateway = fl6->daddr;
87a11578 1764 rt->rt6i_dst.addr = fl6->daddr;
8e2ec639
YZ		 1765 rt->rt6i_dst.plen = 128;
1766 rt->rt6i_idev = idev;
14edd87d 1767 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1da177e4 1768
587fea74
WW		 1769 /* Add this dst into uncached_list so that rt6_ifdown() can
1770 * do proper release of the net_device
1771 */
1772 rt6_uncached_list_add(rt);
1da177e4 1773
87a11578
DM		 1774 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1775
1da177e4 1776out:
87a11578 1777 return dst;
1da177e4
LT		 1778}
1779
569d3645 1780static int ip6_dst_gc(struct dst_ops *ops)
1da177e4 1781{
86393e52 1782 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
7019b78e
DL		 1783 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1784 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1785 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1786 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1787 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
fc66f95c 1788 int entries;
7019b78e 1789
fc66f95c 1790 entries = dst_entries_get_fast(ops);
49a18d86 1791 if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
fc66f95c 1792 entries <= rt_max_size)
1da177e4
LT		 1793 goto out;
1794
6891a346 1795 net->ipv6.ip6_rt_gc_expire++;
14956643 1796 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
fc66f95c
ED		 1797 entries = dst_entries_get_slow(ops);
1798 if (entries < ops->gc_thresh)
7019b78e 1799 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1da177e4 1800out:
7019b78e 1801 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
fc66f95c 1802 return entries > rt_max_size;
1da177e4
LT		 1803}
1804
e715b6d3
FW		 1805static int ip6_convert_metrics(struct mx6_config *mxc,
1806 const struct fib6_config *cfg)
1807{
c3a8d947 1808 bool ecn_ca = false;
e715b6d3
FW		 1809 struct nlattr *nla;
1810 int remaining;
1811 u32 *mp;
1812
63159f29 1813 if (!cfg->fc_mx)
e715b6d3
FW		 1814 return 0;
1815
1816 mp = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1817 if (unlikely(!mp))
1818 return -ENOMEM;
1819
1820 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1821 int type = nla_type(nla);
1bb14807 1822 u32 val;
e715b6d3 1823
1bb14807
DB		 1824 if (!type)
1825 continue;
1826 if (unlikely(type > RTAX_MAX))
1827 goto err;
ea697639 1828
1bb14807
DB		 1829 if (type == RTAX_CC_ALGO) {
1830 char tmp[TCP_CA_NAME_MAX];
e715b6d3 1831
1bb14807 1832 nla_strlcpy(tmp, nla, sizeof(tmp));
c3a8d947 1833 val = tcp_ca_get_key_by_name(tmp, &ecn_ca);
1bb14807
DB		 1834 if (val == TCP_CA_UNSPEC)
1835 goto err;
1836 } else {
1837 val = nla_get_u32(nla);
e715b6d3 1838 }
626abd59
PA		 1839 if (type == RTAX_HOPLIMIT && val > 255)
1840 val = 255;
b8d3e416
DB		 1841 if (type == RTAX_FEATURES && (val & ~RTAX_FEATURE_MASK))
1842 goto err;
1bb14807
DB		 1843
1844 mp[type - 1] = val;
1845 __set_bit(type - 1, mxc->mx_valid);
e715b6d3
FW		 1846 }
1847
c3a8d947
DB		 1848 if (ecn_ca) {
1849 __set_bit(RTAX_FEATURES - 1, mxc->mx_valid);
1850 mp[RTAX_FEATURES - 1] |= DST_FEATURE_ECN_CA;
1851 }
e715b6d3 1852
c3a8d947 1853 mxc->mx = mp;
e715b6d3
FW		 1854 return 0;
1855 err:
1856 kfree(mp);
1857 return -EINVAL;
1858}
1da177e4 1859
8c14586f
DA		 1860static struct rt6_info *ip6_nh_lookup_table(struct net *net,
1861 struct fib6_config *cfg,
1862 const struct in6_addr *gw_addr)
1863{
1864 struct flowi6 fl6 = {
1865 .flowi6_oif = cfg->fc_ifindex,
1866 .daddr = *gw_addr,
1867 .saddr = cfg->fc_prefsrc,
1868 };
1869 struct fib6_table *table;
1870 struct rt6_info *rt;
d5d32e4b 1871 int flags = RT6_LOOKUP_F_IFACE | RT6_LOOKUP_F_IGNORE_LINKSTATE;
8c14586f
DA		 1872
1873 table = fib6_get_table(net, cfg->fc_table);
1874 if (!table)
1875 return NULL;
1876
1877 if (!ipv6_addr_any(&cfg->fc_prefsrc))
1878 flags |= RT6_LOOKUP_F_HAS_SADDR;
1879
1880 rt = ip6_pol_route(net, table, cfg->fc_ifindex, &fl6, flags);
1881
1882 /* if table lookup failed, fall back to full lookup */
1883 if (rt == net->ipv6.ip6_null_entry) {
1884 ip6_rt_put(rt);
1885 rt = NULL;
1886 }
1887
1888 return rt;
1889}
1890
333c4301
DA		 1891static struct rt6_info *ip6_route_info_create(struct fib6_config *cfg,
1892 struct netlink_ext_ack *extack)
1da177e4 1893{
5578689a 1894 struct net *net = cfg->fc_nlinfo.nl_net;
1da177e4
LT		 1895 struct rt6_info *rt = NULL;
1896 struct net_device *dev = NULL;
1897 struct inet6_dev *idev = NULL;
c71099ac 1898 struct fib6_table *table;
1da177e4 1899 int addr_type;
8c5b83f0 1900 int err = -EINVAL;
1da177e4 1901
557c44be 1902 /* RTF_PCPU is an internal flag; can not be set by userspace */
d5d531cb
DA		 1903 if (cfg->fc_flags & RTF_PCPU) {
1904 NL_SET_ERR_MSG(extack, "Userspace can not set RTF_PCPU");
557c44be 1905 goto out;
d5d531cb 1906 }
557c44be 1907
d5d531cb
DA		 1908 if (cfg->fc_dst_len > 128) {
1909 NL_SET_ERR_MSG(extack, "Invalid prefix length");
1910 goto out;
1911 }
1912 if (cfg->fc_src_len > 128) {
1913 NL_SET_ERR_MSG(extack, "Invalid source address length");
8c5b83f0 1914 goto out;
d5d531cb 1915 }
1da177e4 1916#ifndef CONFIG_IPV6_SUBTREES
d5d531cb
DA		 1917 if (cfg->fc_src_len) {
1918 NL_SET_ERR_MSG(extack,
1919 "Specifying source address requires IPV6_SUBTREES to be enabled");
8c5b83f0 1920 goto out;
d5d531cb 1921 }
1da177e4 1922#endif
86872cb5 1923 if (cfg->fc_ifindex) {
1da177e4 1924 err = -ENODEV;
5578689a 1925 dev = dev_get_by_index(net, cfg->fc_ifindex);
1da177e4
LT		 1926 if (!dev)
1927 goto out;
1928 idev = in6_dev_get(dev);
1929 if (!idev)
1930 goto out;
1931 }
1932
86872cb5
TG		 1933 if (cfg->fc_metric == 0)
1934 cfg->fc_metric = IP6_RT_PRIO_USER;
1da177e4 1935
d71314b4 1936 err = -ENOBUFS;
38308473
DM		 1937 if (cfg->fc_nlinfo.nlh &&
1938 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
d71314b4 1939 table = fib6_get_table(net, cfg->fc_table);
38308473 1940 if (!table) {
f3213831 1941 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
d71314b4
MV		 1942 table = fib6_new_table(net, cfg->fc_table);
1943 }
1944 } else {
1945 table = fib6_new_table(net, cfg->fc_table);
1946 }
38308473
DM		 1947
1948 if (!table)
c71099ac 1949 goto out;
c71099ac 1950
ad706862
MKL		 1951 rt = ip6_dst_alloc(net, NULL,
1952 (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT);
1da177e4 1953
38308473 1954 if (!rt) {
1da177e4
LT		 1955 err = -ENOMEM;
1956 goto out;
1957 }
1958
1716a961
G		 1959 if (cfg->fc_flags & RTF_EXPIRES)
1960 rt6_set_expires(rt, jiffies +
1961 clock_t_to_jiffies(cfg->fc_expires));
1962 else
1963 rt6_clean_expires(rt);
1da177e4 1964
86872cb5
TG		 1965 if (cfg->fc_protocol == RTPROT_UNSPEC)
1966 cfg->fc_protocol = RTPROT_BOOT;
1967 rt->rt6i_protocol = cfg->fc_protocol;
1968
1969 addr_type = ipv6_addr_type(&cfg->fc_dst);
1da177e4
LT		 1970
1971 if (addr_type & IPV6_ADDR_MULTICAST)
d8d1f30b 1972 rt->dst.input = ip6_mc_input;
ab79ad14
MŻ		 1973 else if (cfg->fc_flags & RTF_LOCAL)
1974 rt->dst.input = ip6_input;
1da177e4 1975 else
d8d1f30b 1976 rt->dst.input = ip6_forward;
1da177e4 1977
d8d1f30b 1978 rt->dst.output = ip6_output;
1da177e4 1979
19e42e45
RP		 1980 if (cfg->fc_encap) {
1981 struct lwtunnel_state *lwtstate;
1982
30357d7d 1983 err = lwtunnel_build_state(cfg->fc_encap_type,
127eb7cd 1984 cfg->fc_encap, AF_INET6, cfg,
9ae28727 1985 &lwtstate, extack);
19e42e45
RP		 1986 if (err)
1987 goto out;
61adedf3
JB		 1988 rt->dst.lwtstate = lwtstate_get(lwtstate);
1989 if (lwtunnel_output_redirect(rt->dst.lwtstate)) {
1990 rt->dst.lwtstate->orig_output = rt->dst.output;
1991 rt->dst.output = lwtunnel_output;
25368623 1992 }
61adedf3
JB		 1993 if (lwtunnel_input_redirect(rt->dst.lwtstate)) {
1994 rt->dst.lwtstate->orig_input = rt->dst.input;
1995 rt->dst.input = lwtunnel_input;
25368623 1996 }
19e42e45
RP		 1997 }
1998
86872cb5
TG		 1999 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
2000 rt->rt6i_dst.plen = cfg->fc_dst_len;
afc4eef8 2001 if (rt->rt6i_dst.plen == 128)
e5fd387a 2002 rt->dst.flags |= DST_HOST;
e5fd387a 2003
1da177e4 2004#ifdef CONFIG_IPV6_SUBTREES
86872cb5
TG		 2005 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
2006 rt->rt6i_src.plen = cfg->fc_src_len;
1da177e4
LT		 2007#endif
2008
86872cb5 2009 rt->rt6i_metric = cfg->fc_metric;
1da177e4
LT		 2010
2011 /* We cannot add true routes via loopback here,
2012 they would result in kernel looping; promote them to reject routes
2013 */
86872cb5 2014 if ((cfg->fc_flags & RTF_REJECT) ||
38308473
DM		 2015 (dev && (dev->flags & IFF_LOOPBACK) &&
2016 !(addr_type & IPV6_ADDR_LOOPBACK) &&
2017 !(cfg->fc_flags & RTF_LOCAL))) {
1da177e4 2018 /* hold loopback dev/idev if we haven't done so. */
5578689a 2019 if (dev != net->loopback_dev) {
1da177e4
LT		 2020 if (dev) {
2021 dev_put(dev);
2022 in6_dev_put(idev);
2023 }
5578689a 2024 dev = net->loopback_dev;
1da177e4
LT		 2025 dev_hold(dev);
2026 idev = in6_dev_get(dev);
2027 if (!idev) {
2028 err = -ENODEV;
2029 goto out;
2030 }
2031 }
1da177e4 2032 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
ef2c7d7b
ND		 2033 switch (cfg->fc_type) {
2034 case RTN_BLACKHOLE:
2035 rt->dst.error = -EINVAL;
ede2059d 2036 rt->dst.output = dst_discard_out;
7150aede 2037 rt->dst.input = dst_discard;
ef2c7d7b
ND		 2038 break;
2039 case RTN_PROHIBIT:
2040 rt->dst.error = -EACCES;
7150aede
K		 2041 rt->dst.output = ip6_pkt_prohibit_out;
2042 rt->dst.input = ip6_pkt_prohibit;
ef2c7d7b 2043 break;
b4949ab2 2044 case RTN_THROW:
0315e382 2045 case RTN_UNREACHABLE:
ef2c7d7b 2046 default:
7150aede 2047 rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
0315e382
NF		 2048 : (cfg->fc_type == RTN_UNREACHABLE)
2049 ? -EHOSTUNREACH : -ENETUNREACH;
7150aede
K		 2050 rt->dst.output = ip6_pkt_discard_out;
2051 rt->dst.input = ip6_pkt_discard;
ef2c7d7b
ND		 2052 break;
2053 }
1da177e4
LT		 2054 goto install_route;
2055 }
2056
86872cb5 2057 if (cfg->fc_flags & RTF_GATEWAY) {
b71d1d42 2058 const struct in6_addr *gw_addr;
1da177e4
LT		 2059 int gwa_type;
2060
86872cb5 2061 gw_addr = &cfg->fc_gateway;
330567b7 2062 gwa_type = ipv6_addr_type(gw_addr);
48ed7b26
FW		 2063
2064 /* if gw_addr is local we will fail to detect this in case
2065 * address is still TENTATIVE (DAD in progress). rt6_lookup()
2066 * will return already-added prefix route via interface that
2067 * prefix route was assigned to, which might be non-loopback.
2068 */
2069 err = -EINVAL;
330567b7
FW		 2070 if (ipv6_chk_addr_and_flags(net, gw_addr,
2071 gwa_type & IPV6_ADDR_LINKLOCAL ?
d5d531cb
DA		 2072 dev : NULL, 0, 0)) {
2073 NL_SET_ERR_MSG(extack, "Invalid gateway address");
48ed7b26 2074 goto out;
d5d531cb 2075 }
4e3fd7a0 2076 rt->rt6i_gateway = *gw_addr;
1da177e4
LT		 2077
2078 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
8c14586f 2079 struct rt6_info *grt = NULL;
1da177e4
LT		 2080
2081 /* IPv6 strictly inhibits using not link-local
2082 addresses as nexthop address.
2083 Otherwise, router will not able to send redirects.
2084 It is very good, but in some (rare!) circumstances
2085 (SIT, PtP, NBMA NOARP links) it is handy to allow
2086 some exceptions. --ANK
96d5822c
EN		 2087 We allow IPv4-mapped nexthops to support RFC4798-type
2088 addressing
1da177e4 2089 */
96d5822c 2090 if (!(gwa_type & (IPV6_ADDR_UNICAST |
d5d531cb
DA		 2091 IPV6_ADDR_MAPPED))) {
2092 NL_SET_ERR_MSG(extack,
2093 "Invalid gateway address");
1da177e4 2094 goto out;
d5d531cb 2095 }
1da177e4 2096
a435a07f 2097 if (cfg->fc_table) {
8c14586f
DA		 2098 grt = ip6_nh_lookup_table(net, cfg, gw_addr);
2099
a435a07f
VB		 2100 if (grt) {
2101 if (grt->rt6i_flags & RTF_GATEWAY ||
2102 (dev && dev != grt->dst.dev)) {
2103 ip6_rt_put(grt);
2104 grt = NULL;
2105 }
2106 }
2107 }
2108
8c14586f
DA		 2109 if (!grt)
2110 grt = rt6_lookup(net, gw_addr, NULL,
2111 cfg->fc_ifindex, 1);
1da177e4
LT		 2112
2113 err = -EHOSTUNREACH;
38308473 2114 if (!grt)
1da177e4
LT		 2115 goto out;
2116 if (dev) {
d1918542 2117 if (dev != grt->dst.dev) {
94e187c0 2118 ip6_rt_put(grt);
1da177e4
LT		 2119 goto out;
2120 }
2121 } else {
d1918542 2122 dev = grt->dst.dev;
1da177e4
LT		 2123 idev = grt->rt6i_idev;
2124 dev_hold(dev);
2125 in6_dev_hold(grt->rt6i_idev);
2126 }
38308473 2127 if (!(grt->rt6i_flags & RTF_GATEWAY))
1da177e4 2128 err = 0;
94e187c0 2129 ip6_rt_put(grt);
1da177e4
LT		 2130
2131 if (err)
2132 goto out;
2133 }
2134 err = -EINVAL;
d5d531cb
DA		 2135 if (!dev) {
2136 NL_SET_ERR_MSG(extack, "Egress device not specified");
2137 goto out;
2138 } else if (dev->flags & IFF_LOOPBACK) {
2139 NL_SET_ERR_MSG(extack,
2140 "Egress device can not be loopback device for this route");
1da177e4 2141 goto out;
d5d531cb 2142 }
1da177e4
LT		 2143 }
2144
2145 err = -ENODEV;
38308473 2146 if (!dev)
1da177e4
LT		 2147 goto out;
2148
c3968a85
DW		 2149 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
2150 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
d5d531cb 2151 NL_SET_ERR_MSG(extack, "Invalid source address");
c3968a85
DW		 2152 err = -EINVAL;
2153 goto out;
2154 }
4e3fd7a0 2155 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
c3968a85
DW		 2156 rt->rt6i_prefsrc.plen = 128;
2157 } else
2158 rt->rt6i_prefsrc.plen = 0;
2159
86872cb5 2160 rt->rt6i_flags = cfg->fc_flags;
1da177e4
LT		 2161
2162install_route:
d8d1f30b 2163 rt->dst.dev = dev;
1da177e4 2164 rt->rt6i_idev = idev;
c71099ac 2165 rt->rt6i_table = table;
63152fc0 2166
c346dca1 2167 cfg->fc_nlinfo.nl_net = dev_net(dev);
63152fc0 2168
8c5b83f0 2169 return rt;
6b9ea5a6
RP		 2170out:
2171 if (dev)
2172 dev_put(dev);
2173 if (idev)
2174 in6_dev_put(idev);
587fea74
WW		 2175 if (rt)
2176 dst_release_immediate(&rt->dst);
6b9ea5a6 2177
8c5b83f0 2178 return ERR_PTR(err);
6b9ea5a6
RP		 2179}
2180
333c4301
DA		 2181int ip6_route_add(struct fib6_config *cfg,
2182 struct netlink_ext_ack *extack)
6b9ea5a6
RP		 2183{
2184 struct mx6_config mxc = { .mx = NULL, };
8c5b83f0 2185 struct rt6_info *rt;
6b9ea5a6
RP		 2186 int err;
2187
333c4301 2188 rt = ip6_route_info_create(cfg, extack);
8c5b83f0
RP		 2189 if (IS_ERR(rt)) {
2190 err = PTR_ERR(rt);
2191 rt = NULL;
6b9ea5a6 2192 goto out;
8c5b83f0 2193 }
6b9ea5a6 2194
e715b6d3
FW		 2195 err = ip6_convert_metrics(&mxc, cfg);
2196 if (err)
2197 goto out;
1da177e4 2198
333c4301 2199 err = __ip6_ins_rt(rt, &cfg->fc_nlinfo, &mxc, extack);
e715b6d3
FW		 2200
2201 kfree(mxc.mx);
6b9ea5a6 2202
e715b6d3 2203 return err;
1da177e4 2204out:
587fea74
WW		 2205 if (rt)
2206 dst_release_immediate(&rt->dst);
6b9ea5a6 2207
1da177e4
LT		 2208 return err;
2209}
2210
86872cb5 2211static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 2212{
2213 int err;
c71099ac 2214 struct fib6_table *table;
d1918542 2215 struct net *net = dev_net(rt->dst.dev);
1da177e4 2216
a4c2fd7f 2217 if (rt == net->ipv6.ip6_null_entry) {
6825a26c
G		 2218 err = -ENOENT;
2219 goto out;
2220 }
6c813a72 2221
c71099ac
TG		 2222 table = rt->rt6i_table;
2223 write_lock_bh(&table->tb6_lock);
86872cb5 2224 err = fib6_del(rt, info);
c71099ac 2225 write_unlock_bh(&table->tb6_lock);
1da177e4 2226
6825a26c 2227out:
94e187c0 2228 ip6_rt_put(rt);
1da177e4
LT		 2229 return err;
2230}
2231
e0a1ad73
TG		 2232int ip6_del_rt(struct rt6_info *rt)
2233{
4d1169c1 2234 struct nl_info info = {
d1918542 2235 .nl_net = dev_net(rt->dst.dev),
4d1169c1 2236 };
528c4ceb 2237 return __ip6_del_rt(rt, &info);
e0a1ad73
TG		 2238}
2239
0ae81335
DA		 2240static int __ip6_del_rt_siblings(struct rt6_info *rt, struct fib6_config *cfg)
2241{
2242 struct nl_info *info = &cfg->fc_nlinfo;
e3330039 2243 struct net *net = info->nl_net;
16a16cd3 2244 struct sk_buff *skb = NULL;
0ae81335 2245 struct fib6_table *table;
e3330039 2246 int err = -ENOENT;
0ae81335 2247
e3330039
WC		 2248 if (rt == net->ipv6.ip6_null_entry)
2249 goto out_put;
0ae81335
DA		 2250 table = rt->rt6i_table;
2251 write_lock_bh(&table->tb6_lock);
2252
2253 if (rt->rt6i_nsiblings && cfg->fc_delete_all_nh) {
2254 struct rt6_info *sibling, *next_sibling;
2255
16a16cd3
DA		 2256 /* prefer to send a single notification with all hops */
2257 skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
2258 if (skb) {
2259 u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2260
e3330039 2261 if (rt6_fill_node(net, skb, rt,
16a16cd3
DA		 2262 NULL, NULL, 0, RTM_DELROUTE,
2263 info->portid, seq, 0) < 0) {
2264 kfree_skb(skb);
2265 skb = NULL;
2266 } else
2267 info->skip_notify = 1;
2268 }
2269
0ae81335
DA		 2270 list_for_each_entry_safe(sibling, next_sibling,
2271 &rt->rt6i_siblings,
2272 rt6i_siblings) {
2273 err = fib6_del(sibling, info);
2274 if (err)
e3330039 2275 goto out_unlock;
0ae81335
DA		 2276 }
2277 }
2278
2279 err = fib6_del(rt, info);
e3330039 2280out_unlock:
0ae81335 2281 write_unlock_bh(&table->tb6_lock);
e3330039 2282out_put:
0ae81335 2283 ip6_rt_put(rt);
16a16cd3
DA		 2284
2285 if (skb) {
e3330039 2286 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
16a16cd3
DA		 2287 info->nlh, gfp_any());
2288 }
0ae81335
DA		 2289 return err;
2290}
2291
333c4301
DA		 2292static int ip6_route_del(struct fib6_config *cfg,
2293 struct netlink_ext_ack *extack)
1da177e4 2294{
c71099ac 2295 struct fib6_table *table;
1da177e4
LT		 2296 struct fib6_node *fn;
2297 struct rt6_info *rt;
2298 int err = -ESRCH;
2299
5578689a 2300 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
d5d531cb
DA		 2301 if (!table) {
2302 NL_SET_ERR_MSG(extack, "FIB table does not exist");
c71099ac 2303 return err;
d5d531cb 2304 }
c71099ac
TG		 2305
2306 read_lock_bh(&table->tb6_lock);
1da177e4 2307
c71099ac 2308 fn = fib6_locate(&table->tb6_root,
86872cb5
TG		 2309 &cfg->fc_dst, cfg->fc_dst_len,
2310 &cfg->fc_src, cfg->fc_src_len);
1ab1457c 2311
1da177e4 2312 if (fn) {
d8d1f30b 2313 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1f56a01f
MKL		 2314 if ((rt->rt6i_flags & RTF_CACHE) &&
2315 !(cfg->fc_flags & RTF_CACHE))
2316 continue;
86872cb5 2317 if (cfg->fc_ifindex &&
d1918542
DM		 2318 (!rt->dst.dev ||
2319 rt->dst.dev->ifindex != cfg->fc_ifindex))
1da177e4 2320 continue;
86872cb5
TG		 2321 if (cfg->fc_flags & RTF_GATEWAY &&
2322 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1da177e4 2323 continue;
86872cb5 2324 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1da177e4 2325 continue;
c2ed1880
M		 2326 if (cfg->fc_protocol && cfg->fc_protocol != rt->rt6i_protocol)
2327 continue;
d8d1f30b 2328 dst_hold(&rt->dst);
c71099ac 2329 read_unlock_bh(&table->tb6_lock);
1da177e4 2330
0ae81335
DA		 2331 /* if gateway was specified only delete the one hop */
2332 if (cfg->fc_flags & RTF_GATEWAY)
2333 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
2334
2335 return __ip6_del_rt_siblings(rt, cfg);
1da177e4
LT		 2336 }
2337 }
c71099ac 2338 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 2339
2340 return err;
2341}
2342
6700c270 2343static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
a6279458 2344{
a6279458 2345 struct netevent_redirect netevent;
e8599ff4 2346 struct rt6_info *rt, *nrt = NULL;
e8599ff4
DM		 2347 struct ndisc_options ndopts;
2348 struct inet6_dev *in6_dev;
2349 struct neighbour *neigh;
71bcdba0 2350 struct rd_msg *msg;
6e157b6a
DM		 2351 int optlen, on_link;
2352 u8 *lladdr;
e8599ff4 2353
29a3cad5 2354 optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
71bcdba0 2355 optlen -= sizeof(*msg);
e8599ff4
DM		 2356
2357 if (optlen < 0) {
6e157b6a 2358 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
e8599ff4
DM		 2359 return;
2360 }
2361
71bcdba0 2362 msg = (struct rd_msg *)icmp6_hdr(skb);
e8599ff4 2363
71bcdba0 2364 if (ipv6_addr_is_multicast(&msg->dest)) {
6e157b6a 2365 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
e8599ff4
DM		 2366 return;
2367 }
2368
6e157b6a 2369 on_link = 0;
71bcdba0 2370 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
e8599ff4 2371 on_link = 1;
71bcdba0 2372 } else if (ipv6_addr_type(&msg->target) !=
e8599ff4 2373 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
6e157b6a 2374 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
e8599ff4
DM		 2375 return;
2376 }
2377
2378 in6_dev = __in6_dev_get(skb->dev);
2379 if (!in6_dev)
2380 return;
2381 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
2382 return;
2383
2384 /* RFC2461 8.1:
2385 * The IP source address of the Redirect MUST be the same as the current
2386 * first-hop router for the specified ICMP Destination Address.
2387 */
2388
f997c55c 2389 if (!ndisc_parse_options(skb->dev, msg->opt, optlen, &ndopts)) {
e8599ff4
DM		 2390 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
2391 return;
2392 }
6e157b6a
DM		 2393
2394 lladdr = NULL;
e8599ff4
DM		 2395 if (ndopts.nd_opts_tgt_lladdr) {
2396 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
2397 skb->dev);
2398 if (!lladdr) {
2399 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
2400 return;
2401 }
2402 }
2403
6e157b6a 2404 rt = (struct rt6_info *) dst;
ec13ad1d 2405 if (rt->rt6i_flags & RTF_REJECT) {
6e157b6a 2406 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
e8599ff4 2407 return;
6e157b6a 2408 }
e8599ff4 2409
6e157b6a
DM		 2410 /* Redirect received -> path was valid.
2411 * Look, redirects are sent only in response to data packets,
2412 * so that this nexthop apparently is reachable. --ANK
2413 */
0dec879f 2414 dst_confirm_neigh(&rt->dst, &ipv6_hdr(skb)->saddr);
a6279458 2415
71bcdba0 2416 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
6e157b6a
DM		 2417 if (!neigh)
2418 return;
a6279458 2419
1da177e4
LT		 2420 /*
2421 * We have finally decided to accept it.
2422 */
2423
f997c55c 2424 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
1da177e4
LT		 2425 NEIGH_UPDATE_F_WEAK_OVERRIDE|
2426 NEIGH_UPDATE_F_OVERRIDE|
2427 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
f997c55c
AA		 2428 NEIGH_UPDATE_F_ISROUTER)),
2429 NDISC_REDIRECT, &ndopts);
1da177e4 2430
83a09abd 2431 nrt = ip6_rt_cache_alloc(rt, &msg->dest, NULL);
38308473 2432 if (!nrt)
1da177e4
LT		 2433 goto out;
2434
2435 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
2436 if (on_link)
2437 nrt->rt6i_flags &= ~RTF_GATEWAY;
2438
b91d5329 2439 nrt->rt6i_protocol = RTPROT_REDIRECT;
4e3fd7a0 2440 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1da177e4 2441
40e22e8f 2442 if (ip6_ins_rt(nrt))
1cfb71ee 2443 goto out_release;
1da177e4 2444
d8d1f30b
CG		 2445 netevent.old = &rt->dst;
2446 netevent.new = &nrt->dst;
71bcdba0 2447 netevent.daddr = &msg->dest;
60592833 2448 netevent.neigh = neigh;
8d71740c
TT		 2449 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
2450
38308473 2451 if (rt->rt6i_flags & RTF_CACHE) {
6e157b6a 2452 rt = (struct rt6_info *) dst_clone(&rt->dst);
e0a1ad73 2453 ip6_del_rt(rt);
1da177e4
LT		 2454 }
2455
1cfb71ee
WW		 2456out_release:
2457 /* Release the reference taken in
2458 * ip6_rt_cache_alloc()
2459 */
2460 dst_release(&nrt->dst);
2461
1da177e4 2462out:
e8599ff4 2463 neigh_release(neigh);
6e157b6a
DM		 2464}
2465
1da177e4
LT		 2466/*
2467 * Misc support functions
2468 */
2469
4b32b5ad
MKL		 2470static void rt6_set_from(struct rt6_info *rt, struct rt6_info *from)
2471{
2472 BUG_ON(from->dst.from);
2473
2474 rt->rt6i_flags &= ~RTF_EXPIRES;
2475 dst_hold(&from->dst);
2476 rt->dst.from = &from->dst;
2477 dst_init_metrics(&rt->dst, dst_metrics_ptr(&from->dst), true);
2478}
2479
83a09abd
MKL		 2480static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort)
2481{
2482 rt->dst.input = ort->dst.input;
2483 rt->dst.output = ort->dst.output;
2484 rt->rt6i_dst = ort->rt6i_dst;
2485 rt->dst.error = ort->dst.error;
2486 rt->rt6i_idev = ort->rt6i_idev;
2487 if (rt->rt6i_idev)
2488 in6_dev_hold(rt->rt6i_idev);
2489 rt->dst.lastuse = jiffies;
2490 rt->rt6i_gateway = ort->rt6i_gateway;
2491 rt->rt6i_flags = ort->rt6i_flags;
2492 rt6_set_from(rt, ort);
2493 rt->rt6i_metric = ort->rt6i_metric;
1da177e4 2494#ifdef CONFIG_IPV6_SUBTREES
83a09abd 2495 rt->rt6i_src = ort->rt6i_src;
1da177e4 2496#endif
83a09abd
MKL		 2497 rt->rt6i_prefsrc = ort->rt6i_prefsrc;
2498 rt->rt6i_table = ort->rt6i_table;
61adedf3 2499 rt->dst.lwtstate = lwtstate_get(ort->dst.lwtstate);
1da177e4
LT		 2500}
2501
70ceb4f5 2502#ifdef CONFIG_IPV6_ROUTE_INFO
efa2cea0 2503static struct rt6_info *rt6_get_route_info(struct net *net,
b71d1d42 2504 const struct in6_addr *prefix, int prefixlen,
830218c1
DA		 2505 const struct in6_addr *gwaddr,
2506 struct net_device *dev)
70ceb4f5 2507{
830218c1
DA		 2508 u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO;
2509 int ifindex = dev->ifindex;
70ceb4f5
YH		 2510 struct fib6_node *fn;
2511 struct rt6_info *rt = NULL;
c71099ac
TG		 2512 struct fib6_table *table;
2513
830218c1 2514 table = fib6_get_table(net, tb_id);
38308473 2515 if (!table)
c71099ac 2516 return NULL;
70ceb4f5 2517
5744dd9b 2518 read_lock_bh(&table->tb6_lock);
67ba4152 2519 fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);
70ceb4f5
YH		 2520 if (!fn)
2521 goto out;
2522
d8d1f30b 2523 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
d1918542 2524 if (rt->dst.dev->ifindex != ifindex)
70ceb4f5
YH		 2525 continue;
2526 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
2527 continue;
2528 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
2529 continue;
d8d1f30b 2530 dst_hold(&rt->dst);
70ceb4f5
YH		 2531 break;
2532 }
2533out:
5744dd9b 2534 read_unlock_bh(&table->tb6_lock);
70ceb4f5
YH		 2535 return rt;
2536}
2537
efa2cea0 2538static struct rt6_info *rt6_add_route_info(struct net *net,
b71d1d42 2539 const struct in6_addr *prefix, int prefixlen,
830218c1
DA		 2540 const struct in6_addr *gwaddr,
2541 struct net_device *dev,
95c96174 2542 unsigned int pref)
70ceb4f5 2543{
86872cb5 2544 struct fib6_config cfg = {
238fc7ea 2545 .fc_metric = IP6_RT_PRIO_USER,
830218c1 2546 .fc_ifindex = dev->ifindex,
86872cb5
TG		 2547 .fc_dst_len = prefixlen,
2548 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
2549 RTF_UP | RTF_PREF(pref),
b91d5329 2550 .fc_protocol = RTPROT_RA,
15e47304 2551 .fc_nlinfo.portid = 0,
efa2cea0
DL		 2552 .fc_nlinfo.nlh = NULL,
2553 .fc_nlinfo.nl_net = net,
86872cb5
TG		 2554 };
2555
830218c1 2556 cfg.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO,
4e3fd7a0
AD		 2557 cfg.fc_dst = *prefix;
2558 cfg.fc_gateway = *gwaddr;
70ceb4f5 2559
e317da96
YH		 2560 /* We should treat it as a default route if prefix length is 0. */
2561 if (!prefixlen)
86872cb5 2562 cfg.fc_flags |= RTF_DEFAULT;
70ceb4f5 2563
333c4301 2564 ip6_route_add(&cfg, NULL);
70ceb4f5 2565
830218c1 2566 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, dev);
70ceb4f5
YH		 2567}
2568#endif
2569
b71d1d42 2570struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1ab1457c 2571{
830218c1 2572 u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT;
1da177e4 2573 struct rt6_info *rt;
c71099ac 2574 struct fib6_table *table;
1da177e4 2575
830218c1 2576 table = fib6_get_table(dev_net(dev), tb_id);
38308473 2577 if (!table)
c71099ac 2578 return NULL;
1da177e4 2579
5744dd9b 2580 read_lock_bh(&table->tb6_lock);
67ba4152 2581 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
d1918542 2582 if (dev == rt->dst.dev &&
045927ff 2583 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1da177e4
LT		 2584 ipv6_addr_equal(&rt->rt6i_gateway, addr))
2585 break;
2586 }
2587 if (rt)
d8d1f30b 2588 dst_hold(&rt->dst);
5744dd9b 2589 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 2590 return rt;
2591}
2592
b71d1d42 2593struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
ebacaaa0
YH		 2594 struct net_device *dev,
2595 unsigned int pref)
1da177e4 2596{
86872cb5 2597 struct fib6_config cfg = {
ca254490 2598 .fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT,
238fc7ea 2599 .fc_metric = IP6_RT_PRIO_USER,
86872cb5
TG		 2600 .fc_ifindex = dev->ifindex,
2601 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
2602 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
b91d5329 2603 .fc_protocol = RTPROT_RA,
15e47304 2604 .fc_nlinfo.portid = 0,
5578689a 2605 .fc_nlinfo.nlh = NULL,
c346dca1 2606 .fc_nlinfo.nl_net = dev_net(dev),
86872cb5 2607 };
1da177e4 2608
4e3fd7a0 2609 cfg.fc_gateway = *gwaddr;
1da177e4 2610
333c4301 2611 if (!ip6_route_add(&cfg, NULL)) {
830218c1
DA		 2612 struct fib6_table *table;
2613
2614 table = fib6_get_table(dev_net(dev), cfg.fc_table);
2615 if (table)
2616 table->flags |= RT6_TABLE_HAS_DFLT_ROUTER;
2617 }
1da177e4 2618
1da177e4
LT		 2619 return rt6_get_dflt_router(gwaddr, dev);
2620}
2621
830218c1 2622static void __rt6_purge_dflt_routers(struct fib6_table *table)
1da177e4
LT		 2623{
2624 struct rt6_info *rt;
2625
2626restart:
c71099ac 2627 read_lock_bh(&table->tb6_lock);
d8d1f30b 2628 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
3e8b0ac3
LC		 2629 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2630 (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
d8d1f30b 2631 dst_hold(&rt->dst);
c71099ac 2632 read_unlock_bh(&table->tb6_lock);
e0a1ad73 2633 ip6_del_rt(rt);
1da177e4
LT		 2634 goto restart;
2635 }
2636 }
c71099ac 2637 read_unlock_bh(&table->tb6_lock);
830218c1
DA		 2638
2639 table->flags &= ~RT6_TABLE_HAS_DFLT_ROUTER;
2640}
2641
2642void rt6_purge_dflt_routers(struct net *net)
2643{
2644 struct fib6_table *table;
2645 struct hlist_head *head;
2646 unsigned int h;
2647
2648 rcu_read_lock();
2649
2650 for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
2651 head = &net->ipv6.fib_table_hash[h];
2652 hlist_for_each_entry_rcu(table, head, tb6_hlist) {
2653 if (table->flags & RT6_TABLE_HAS_DFLT_ROUTER)
2654 __rt6_purge_dflt_routers(table);
2655 }
2656 }
2657
2658 rcu_read_unlock();
1da177e4
LT		 2659}
2660
5578689a
DL		 2661static void rtmsg_to_fib6_config(struct net *net,
2662 struct in6_rtmsg *rtmsg,
86872cb5
TG		 2663 struct fib6_config *cfg)
2664{
2665 memset(cfg, 0, sizeof(*cfg));
2666
ca254490
DA		 2667 cfg->fc_table = l3mdev_fib_table_by_index(net, rtmsg->rtmsg_ifindex) ?
2668 : RT6_TABLE_MAIN;
86872cb5
TG		 2669 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2670 cfg->fc_metric = rtmsg->rtmsg_metric;
2671 cfg->fc_expires = rtmsg->rtmsg_info;
2672 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2673 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2674 cfg->fc_flags = rtmsg->rtmsg_flags;
2675
5578689a 2676 cfg->fc_nlinfo.nl_net = net;
f1243c2d 2677
4e3fd7a0
AD		 2678 cfg->fc_dst = rtmsg->rtmsg_dst;
2679 cfg->fc_src = rtmsg->rtmsg_src;
2680 cfg->fc_gateway = rtmsg->rtmsg_gateway;
86872cb5
TG		 2681}
2682
5578689a 2683int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1da177e4 2684{
86872cb5 2685 struct fib6_config cfg;
1da177e4
LT		 2686 struct in6_rtmsg rtmsg;
2687 int err;
2688
67ba4152 2689 switch (cmd) {
1da177e4
LT		 2690 case SIOCADDRT: /* Add a route */
2691 case SIOCDELRT: /* Delete a route */
af31f412 2692 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1da177e4
LT		 2693 return -EPERM;
2694 err = copy_from_user(&rtmsg, arg,
2695 sizeof(struct in6_rtmsg));
2696 if (err)
2697 return -EFAULT;
86872cb5 2698
5578689a 2699 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
86872cb5 2700
1da177e4
LT		 2701 rtnl_lock();
2702 switch (cmd) {
2703 case SIOCADDRT:
333c4301 2704 err = ip6_route_add(&cfg, NULL);
1da177e4
LT		 2705 break;
2706 case SIOCDELRT:
333c4301 2707 err = ip6_route_del(&cfg, NULL);
1da177e4
LT		 2708 break;
2709 default:
2710 err = -EINVAL;
2711 }
2712 rtnl_unlock();
2713
2714 return err;
3ff50b79 2715 }
1da177e4
LT		 2716
2717 return -EINVAL;
2718}
2719
2720/*
2721 * Drop the packet on the floor
2722 */
2723
d5fdd6ba 2724static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
1da177e4 2725{
612f09e8 2726 int type;
adf30907 2727 struct dst_entry *dst = skb_dst(skb);
612f09e8
YH		 2728 switch (ipstats_mib_noroutes) {
2729 case IPSTATS_MIB_INNOROUTES:
0660e03f 2730 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
45bb0060 2731 if (type == IPV6_ADDR_ANY) {
3bd653c8
DL		 2732 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2733 IPSTATS_MIB_INADDRERRORS);
612f09e8
YH		 2734 break;
2735 }
2736 /* FALLTHROUGH */
2737 case IPSTATS_MIB_OUTNOROUTES:
3bd653c8
DL		 2738 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2739 ipstats_mib_noroutes);
612f09e8
YH		 2740 break;
2741 }
3ffe533c 2742 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
1da177e4
LT		 2743 kfree_skb(skb);
2744 return 0;
2745}
2746
9ce8ade0
TG		 2747static int ip6_pkt_discard(struct sk_buff *skb)
2748{
612f09e8 2749 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
9ce8ade0
TG		 2750}
2751
ede2059d 2752static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb)
1da177e4 2753{
adf30907 2754 skb->dev = skb_dst(skb)->dev;
612f09e8 2755 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
1da177e4
LT		 2756}
2757
9ce8ade0
TG		 2758static int ip6_pkt_prohibit(struct sk_buff *skb)
2759{
612f09e8 2760 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
9ce8ade0
TG		 2761}
2762
ede2059d 2763static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb)
9ce8ade0 2764{
adf30907 2765 skb->dev = skb_dst(skb)->dev;
612f09e8 2766 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
9ce8ade0
TG		 2767}
2768
1da177e4
LT		 2769/*
2770 * Allocate a dst for local (unicast / anycast) address.
2771 */
2772
2773struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2774 const struct in6_addr *addr,
8f031519 2775 bool anycast)
1da177e4 2776{
ca254490 2777 u32 tb_id;
c346dca1 2778 struct net *net = dev_net(idev->dev);
4832c30d 2779 struct net_device *dev = idev->dev;
5f02ce24
DA		 2780 struct rt6_info *rt;
2781
5f02ce24 2782 rt = ip6_dst_alloc(net, dev, DST_NOCOUNT);
a3300ef4 2783 if (!rt)
1da177e4
LT		 2784 return ERR_PTR(-ENOMEM);
2785
1da177e4
LT		 2786 in6_dev_hold(idev);
2787
11d53b49 2788 rt->dst.flags |= DST_HOST;
d8d1f30b
CG		 2789 rt->dst.input = ip6_input;
2790 rt->dst.output = ip6_output;
1da177e4 2791 rt->rt6i_idev = idev;
1da177e4 2792
94b5e0f9 2793 rt->rt6i_protocol = RTPROT_KERNEL;
1da177e4 2794 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
58c4fb86
YH		 2795 if (anycast)
2796 rt->rt6i_flags |= RTF_ANYCAST;
2797 else
1da177e4 2798 rt->rt6i_flags |= RTF_LOCAL;
1da177e4 2799
550bab42 2800 rt->rt6i_gateway = *addr;
4e3fd7a0 2801 rt->rt6i_dst.addr = *addr;
1da177e4 2802 rt->rt6i_dst.plen = 128;
ca254490
DA		 2803 tb_id = l3mdev_fib_table(idev->dev) ? : RT6_TABLE_LOCAL;
2804 rt->rt6i_table = fib6_get_table(net, tb_id);
1da177e4 2805
1da177e4
LT		 2806 return rt;
2807}
2808
c3968a85
DW		 2809/* remove deleted ip from prefsrc entries */
2810struct arg_dev_net_ip {
2811 struct net_device *dev;
2812 struct net *net;
2813 struct in6_addr *addr;
2814};
2815
2816static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2817{
2818 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2819 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2820 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2821
d1918542 2822 if (((void *)rt->dst.dev == dev || !dev) &&
c3968a85
DW		 2823 rt != net->ipv6.ip6_null_entry &&
2824 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2825 /* remove prefsrc entry */
2826 rt->rt6i_prefsrc.plen = 0;
2827 }
2828 return 0;
2829}
2830
2831void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2832{
2833 struct net *net = dev_net(ifp->idev->dev);
2834 struct arg_dev_net_ip adni = {
2835 .dev = ifp->idev->dev,
2836 .net = net,
2837 .addr = &ifp->addr,
2838 };
0c3584d5 2839 fib6_clean_all(net, fib6_remove_prefsrc, &adni);
c3968a85
DW		 2840}
2841
be7a010d
DJ		 2842#define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2843#define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)
2844
2845/* Remove routers and update dst entries when gateway turn into host. */
2846static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
2847{
2848 struct in6_addr *gateway = (struct in6_addr *)arg;
2849
2850 if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
2851 ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
2852 ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
2853 return -1;
2854 }
2855 return 0;
2856}
2857
2858void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
2859{
2860 fib6_clean_all(net, fib6_clean_tohost, gateway);
2861}
2862
8ed67789
DL		 2863struct arg_dev_net {
2864 struct net_device *dev;
2865 struct net *net;
2866};
2867
a1a22c12 2868/* called with write lock held for table with rt */
1da177e4
LT		 2869static int fib6_ifdown(struct rt6_info *rt, void *arg)
2870{
bc3ef660 2871 const struct arg_dev_net *adn = arg;
2872 const struct net_device *dev = adn->dev;
8ed67789 2873
d1918542 2874 if ((rt->dst.dev == dev || !dev) &&
a1a22c12
DA		 2875 rt != adn->net->ipv6.ip6_null_entry &&
2876 (rt->rt6i_nsiblings == 0 ||
8397ed36 2877 (dev && netdev_unregistering(dev)) ||
a1a22c12 2878 !rt->rt6i_idev->cnf.ignore_routes_with_linkdown))
1da177e4 2879 return -1;
c159d30c 2880
1da177e4
LT		 2881 return 0;
2882}
2883
f3db4851 2884void rt6_ifdown(struct net *net, struct net_device *dev)
1da177e4 2885{
8ed67789
DL		 2886 struct arg_dev_net adn = {
2887 .dev = dev,
2888 .net = net,
2889 };
2890
0c3584d5 2891 fib6_clean_all(net, fib6_ifdown, &adn);
e332bc67
EB		 2892 if (dev)
2893 rt6_uncached_list_flush_dev(net, dev);
1da177e4
LT		 2894}
2895
95c96174 2896struct rt6_mtu_change_arg {
1da177e4 2897 struct net_device *dev;
95c96174 2898 unsigned int mtu;
1da177e4
LT		 2899};
2900
2901static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2902{
2903 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2904 struct inet6_dev *idev;
2905
2906 /* In IPv6 pmtu discovery is not optional,
2907 so that RTAX_MTU lock cannot disable it.
2908 We still use this lock to block changes
2909 caused by addrconf/ndisc.
2910 */
2911
2912 idev = __in6_dev_get(arg->dev);
38308473 2913 if (!idev)
1da177e4
LT		 2914 return 0;
2915
2916 /* For administrative MTU increase, there is no way to discover
2917 IPv6 PMTU increase, so PMTU increase should be updated here.
2918 Since RFC 1981 doesn't include administrative MTU increase
2919 update PMTU increase is a MUST. (i.e. jumbo frame)
2920 */
2921 /*
2922 If new MTU is less than route PMTU, this new MTU will be the
2923 lowest MTU in the path, update the route PMTU to reflect PMTU
2924 decreases; if new MTU is greater than route PMTU, and the
2925 old MTU is the lowest MTU in the path, update the route PMTU
2926 to reflect the increase. In this case if the other nodes' MTU
2927 also have the lowest MTU, TOO BIG MESSAGE will be lead to
67c408cf 2928 PMTU discovery.
1da177e4 2929 */
d1918542 2930 if (rt->dst.dev == arg->dev &&
fb56be83 2931 dst_metric_raw(&rt->dst, RTAX_MTU) &&
4b32b5ad
MKL		 2932 !dst_metric_locked(&rt->dst, RTAX_MTU)) {
2933 if (rt->rt6i_flags & RTF_CACHE) {
2934 /* For RTF_CACHE with rt6i_pmtu == 0
2935 * (i.e. a redirected route),
2936 * the metrics of its rt->dst.from has already
2937 * been updated.
2938 */
2939 if (rt->rt6i_pmtu && rt->rt6i_pmtu > arg->mtu)
2940 rt->rt6i_pmtu = arg->mtu;
2941 } else if (dst_mtu(&rt->dst) >= arg->mtu ||
2942 (dst_mtu(&rt->dst) < arg->mtu &&
2943 dst_mtu(&rt->dst) == idev->cnf.mtu6)) {
2944 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2945 }
566cfd8f 2946 }
1da177e4
LT		 2947 return 0;
2948}
2949
95c96174 2950void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
1da177e4 2951{
c71099ac
TG		 2952 struct rt6_mtu_change_arg arg = {
2953 .dev = dev,
2954 .mtu = mtu,
2955 };
1da177e4 2956
0c3584d5 2957 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
1da177e4
LT		 2958}
2959
ef7c79ed 2960static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
5176f91e 2961 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
86872cb5 2962 [RTA_OIF] = { .type = NLA_U32 },
ab364a6f 2963 [RTA_IIF] = { .type = NLA_U32 },
86872cb5
TG		 2964 [RTA_PRIORITY] = { .type = NLA_U32 },
2965 [RTA_METRICS] = { .type = NLA_NESTED },
51ebd318 2966 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
c78ba6d6 2967 [RTA_PREF] = { .type = NLA_U8 },
19e42e45
RP		 2968 [RTA_ENCAP_TYPE] = { .type = NLA_U16 },
2969 [RTA_ENCAP] = { .type = NLA_NESTED },
32bc201e 2970 [RTA_EXPIRES] = { .type = NLA_U32 },
622ec2c9 2971 [RTA_UID] = { .type = NLA_U32 },
3b45a410 2972 [RTA_MARK] = { .type = NLA_U32 },
86872cb5
TG		 2973};
2974
2975static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
333c4301
DA		 2976 struct fib6_config *cfg,
2977 struct netlink_ext_ack *extack)
1da177e4 2978{
86872cb5
TG		 2979 struct rtmsg *rtm;
2980 struct nlattr *tb[RTA_MAX+1];
c78ba6d6 2981 unsigned int pref;
86872cb5 2982 int err;
1da177e4 2983
fceb6435
JB		 2984 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy,
2985 NULL);
86872cb5
TG		 2986 if (err < 0)
2987 goto errout;
1da177e4 2988
86872cb5
TG		 2989 err = -EINVAL;
2990 rtm = nlmsg_data(nlh);
2991 memset(cfg, 0, sizeof(*cfg));
2992
2993 cfg->fc_table = rtm->rtm_table;
2994 cfg->fc_dst_len = rtm->rtm_dst_len;
2995 cfg->fc_src_len = rtm->rtm_src_len;
2996 cfg->fc_flags = RTF_UP;
2997 cfg->fc_protocol = rtm->rtm_protocol;
ef2c7d7b 2998 cfg->fc_type = rtm->rtm_type;
86872cb5 2999
ef2c7d7b
ND		 3000 if (rtm->rtm_type == RTN_UNREACHABLE ||
3001 rtm->rtm_type == RTN_BLACKHOLE ||
b4949ab2
ND		 3002 rtm->rtm_type == RTN_PROHIBIT ||
3003 rtm->rtm_type == RTN_THROW)
86872cb5
TG		 3004 cfg->fc_flags |= RTF_REJECT;
3005
ab79ad14
MŻ		 3006 if (rtm->rtm_type == RTN_LOCAL)
3007 cfg->fc_flags |= RTF_LOCAL;
3008
1f56a01f
MKL		 3009 if (rtm->rtm_flags & RTM_F_CLONED)
3010 cfg->fc_flags |= RTF_CACHE;
3011
15e47304 3012 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
86872cb5 3013 cfg->fc_nlinfo.nlh = nlh;
3b1e0a65 3014 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
86872cb5
TG		 3015
3016 if (tb[RTA_GATEWAY]) {
67b61f6c 3017 cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
86872cb5 3018 cfg->fc_flags |= RTF_GATEWAY;
1da177e4 3019 }
86872cb5
TG		 3020
3021 if (tb[RTA_DST]) {
3022 int plen = (rtm->rtm_dst_len + 7) >> 3;
3023
3024 if (nla_len(tb[RTA_DST]) < plen)
3025 goto errout;
3026
3027 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1da177e4 3028 }
86872cb5
TG		 3029
3030 if (tb[RTA_SRC]) {
3031 int plen = (rtm->rtm_src_len + 7) >> 3;
3032
3033 if (nla_len(tb[RTA_SRC]) < plen)
3034 goto errout;
3035
3036 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1da177e4 3037 }
86872cb5 3038
c3968a85 3039 if (tb[RTA_PREFSRC])
67b61f6c 3040 cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);
c3968a85 3041
86872cb5
TG		 3042 if (tb[RTA_OIF])
3043 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
3044
3045 if (tb[RTA_PRIORITY])
3046 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
3047
3048 if (tb[RTA_METRICS]) {
3049 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
3050 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
1da177e4 3051 }
86872cb5
TG		 3052
3053 if (tb[RTA_TABLE])
3054 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
3055
51ebd318
ND		 3056 if (tb[RTA_MULTIPATH]) {
3057 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
3058 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
9ed59592
DA		 3059
3060 err = lwtunnel_valid_encap_type_attr(cfg->fc_mp,
c255bd68 3061 cfg->fc_mp_len, extack);
9ed59592
DA		 3062 if (err < 0)
3063 goto errout;
51ebd318
ND		 3064 }
3065
c78ba6d6
LR		 3066 if (tb[RTA_PREF]) {
3067 pref = nla_get_u8(tb[RTA_PREF]);
3068 if (pref != ICMPV6_ROUTER_PREF_LOW &&
3069 pref != ICMPV6_ROUTER_PREF_HIGH)
3070 pref = ICMPV6_ROUTER_PREF_MEDIUM;
3071 cfg->fc_flags |= RTF_PREF(pref);
3072 }
3073
19e42e45
RP		 3074 if (tb[RTA_ENCAP])
3075 cfg->fc_encap = tb[RTA_ENCAP];
3076
9ed59592 3077 if (tb[RTA_ENCAP_TYPE]) {
19e42e45
RP		 3078 cfg->fc_encap_type = nla_get_u16(tb[RTA_ENCAP_TYPE]);
3079
c255bd68 3080 err = lwtunnel_valid_encap_type(cfg->fc_encap_type, extack);
9ed59592
DA		 3081 if (err < 0)
3082 goto errout;
3083 }
3084
32bc201e
XL		 3085 if (tb[RTA_EXPIRES]) {
3086 unsigned long timeout = addrconf_timeout_fixup(nla_get_u32(tb[RTA_EXPIRES]), HZ);
3087
3088 if (addrconf_finite_timeout(timeout)) {
3089 cfg->fc_expires = jiffies_to_clock_t(timeout * HZ);
3090 cfg->fc_flags |= RTF_EXPIRES;
3091 }
3092 }
3093
86872cb5
TG		 3094 err = 0;
3095errout:
3096 return err;
1da177e4
LT		 3097}
3098
6b9ea5a6
RP		 3099struct rt6_nh {
3100 struct rt6_info *rt6_info;
3101 struct fib6_config r_cfg;
3102 struct mx6_config mxc;
3103 struct list_head next;
3104};
3105
3106static void ip6_print_replace_route_err(struct list_head *rt6_nh_list)
3107{
3108 struct rt6_nh *nh;
3109
3110 list_for_each_entry(nh, rt6_nh_list, next) {
7d4d5065 3111 pr_warn("IPV6: multipath route replace failed (check consistency of installed routes): %pI6c nexthop %pI6c ifi %d\n",
6b9ea5a6
RP		 3112 &nh->r_cfg.fc_dst, &nh->r_cfg.fc_gateway,
3113 nh->r_cfg.fc_ifindex);
3114 }
3115}
3116
3117static int ip6_route_info_append(struct list_head *rt6_nh_list,
3118 struct rt6_info *rt, struct fib6_config *r_cfg)
3119{
3120 struct rt6_nh *nh;
6b9ea5a6
RP		 3121 int err = -EEXIST;
3122
3123 list_for_each_entry(nh, rt6_nh_list, next) {
3124 /* check if rt6_info already exists */
f06b7549 3125 if (rt6_duplicate_nexthop(nh->rt6_info, rt))
6b9ea5a6
RP		 3126 return err;
3127 }
3128
3129 nh = kzalloc(sizeof(*nh), GFP_KERNEL);
3130 if (!nh)
3131 return -ENOMEM;
3132 nh->rt6_info = rt;
3133 err = ip6_convert_metrics(&nh->mxc, r_cfg);
3134 if (err) {
3135 kfree(nh);
3136 return err;
3137 }
3138 memcpy(&nh->r_cfg, r_cfg, sizeof(*r_cfg));
3139 list_add_tail(&nh->next, rt6_nh_list);
3140
3141 return 0;
3142}
3143
3b1137fe
DA		 3144static void ip6_route_mpath_notify(struct rt6_info *rt,
3145 struct rt6_info *rt_last,
3146 struct nl_info *info,
3147 __u16 nlflags)
3148{
3149 /* if this is an APPEND route, then rt points to the first route
3150 * inserted and rt_last points to last route inserted. Userspace
3151 * wants a consistent dump of the route which starts at the first
3152 * nexthop. Since sibling routes are always added at the end of
3153 * the list, find the first sibling of the last route appended
3154 */
3155 if ((nlflags & NLM_F_APPEND) && rt_last && rt_last->rt6i_nsiblings) {
3156 rt = list_first_entry(&rt_last->rt6i_siblings,
3157 struct rt6_info,
3158 rt6i_siblings);
3159 }
3160
3161 if (rt)
3162 inet6_rt_notify(RTM_NEWROUTE, rt, info, nlflags);
3163}
3164
333c4301
DA		 3165static int ip6_route_multipath_add(struct fib6_config *cfg,
3166 struct netlink_ext_ack *extack)
51ebd318 3167{
3b1137fe
DA		 3168 struct rt6_info *rt_notif = NULL, *rt_last = NULL;
3169 struct nl_info *info = &cfg->fc_nlinfo;
51ebd318
ND		 3170 struct fib6_config r_cfg;
3171 struct rtnexthop *rtnh;
6b9ea5a6
RP		 3172 struct rt6_info *rt;
3173 struct rt6_nh *err_nh;
3174 struct rt6_nh *nh, *nh_safe;
3b1137fe 3175 __u16 nlflags;
51ebd318
ND		 3176 int remaining;
3177 int attrlen;
6b9ea5a6
RP		 3178 int err = 1;
3179 int nhn = 0;
3180 int replace = (cfg->fc_nlinfo.nlh &&
3181 (cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_REPLACE));
3182 LIST_HEAD(rt6_nh_list);
51ebd318 3183
3b1137fe
DA		 3184 nlflags = replace ? NLM_F_REPLACE : NLM_F_CREATE;
3185 if (info->nlh && info->nlh->nlmsg_flags & NLM_F_APPEND)
3186 nlflags |= NLM_F_APPEND;
3187
35f1b4e9 3188 remaining = cfg->fc_mp_len;
51ebd318 3189 rtnh = (struct rtnexthop *)cfg->fc_mp;
51ebd318 3190
6b9ea5a6
RP		 3191 /* Parse a Multipath Entry and build a list (rt6_nh_list) of
3192 * rt6_info structs per nexthop
3193 */
51ebd318
ND		 3194 while (rtnh_ok(rtnh, remaining)) {
3195 memcpy(&r_cfg, cfg, sizeof(*cfg));
3196 if (rtnh->rtnh_ifindex)
3197 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
3198
3199 attrlen = rtnh_attrlen(rtnh);
3200 if (attrlen > 0) {
3201 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
3202
3203 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
3204 if (nla) {
67b61f6c 3205 r_cfg.fc_gateway = nla_get_in6_addr(nla);
51ebd318
ND		 3206 r_cfg.fc_flags |= RTF_GATEWAY;
3207 }
19e42e45
RP		 3208 r_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
3209 nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
3210 if (nla)
3211 r_cfg.fc_encap_type = nla_get_u16(nla);
51ebd318 3212 }
6b9ea5a6 3213
333c4301 3214 rt = ip6_route_info_create(&r_cfg, extack);
8c5b83f0
RP		 3215 if (IS_ERR(rt)) {
3216 err = PTR_ERR(rt);
3217 rt = NULL;
6b9ea5a6 3218 goto cleanup;
8c5b83f0 3219 }
6b9ea5a6
RP		 3220
3221 err = ip6_route_info_append(&rt6_nh_list, rt, &r_cfg);
51ebd318 3222 if (err) {
587fea74 3223 dst_release_immediate(&rt->dst);
6b9ea5a6
RP		 3224 goto cleanup;
3225 }
3226
3227 rtnh = rtnh_next(rtnh, &remaining);
3228 }
3229
3b1137fe
DA		 3230 /* for add and replace send one notification with all nexthops.
3231 * Skip the notification in fib6_add_rt2node and send one with
3232 * the full route when done
3233 */
3234 info->skip_notify = 1;
3235
6b9ea5a6
RP		 3236 err_nh = NULL;
3237 list_for_each_entry(nh, &rt6_nh_list, next) {
3b1137fe 3238 rt_last = nh->rt6_info;
333c4301 3239 err = __ip6_ins_rt(nh->rt6_info, info, &nh->mxc, extack);
3b1137fe
DA		 3240 /* save reference to first route for notification */
3241 if (!rt_notif && !err)
3242 rt_notif = nh->rt6_info;
3243
6b9ea5a6
RP		 3244 /* nh->rt6_info is used or freed at this point, reset to NULL*/
3245 nh->rt6_info = NULL;
3246 if (err) {
3247 if (replace && nhn)
3248 ip6_print_replace_route_err(&rt6_nh_list);
3249 err_nh = nh;
3250 goto add_errout;
51ebd318 3251 }
6b9ea5a6 3252
1a72418b 3253 /* Because each route is added like a single route we remove
27596472
MK		 3254 * these flags after the first nexthop: if there is a collision,
3255 * we have already failed to add the first nexthop:
3256 * fib6_add_rt2node() has rejected it; when replacing, old
3257 * nexthops have been replaced by first new, the rest should
3258 * be added to it.
1a72418b 3259 */
27596472
MK		 3260 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
3261 NLM_F_REPLACE);
6b9ea5a6
RP		 3262 nhn++;
3263 }
3264
3b1137fe
DA		 3265 /* success ... tell user about new route */
3266 ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
6b9ea5a6
RP		 3267 goto cleanup;
3268
3269add_errout:
3b1137fe
DA		 3270 /* send notification for routes that were added so that
3271 * the delete notifications sent by ip6_route_del are
3272 * coherent
3273 */
3274 if (rt_notif)
3275 ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
3276
6b9ea5a6
RP		 3277 /* Delete routes that were already added */
3278 list_for_each_entry(nh, &rt6_nh_list, next) {
3279 if (err_nh == nh)
3280 break;
333c4301 3281 ip6_route_del(&nh->r_cfg, extack);
6b9ea5a6
RP		 3282 }
3283
3284cleanup:
3285 list_for_each_entry_safe(nh, nh_safe, &rt6_nh_list, next) {
587fea74
WW		 3286 if (nh->rt6_info)
3287 dst_release_immediate(&nh->rt6_info->dst);
52fe51f8 3288 kfree(nh->mxc.mx);
6b9ea5a6
RP		 3289 list_del(&nh->next);
3290 kfree(nh);
3291 }
3292
3293 return err;
3294}
3295
333c4301
DA		 3296static int ip6_route_multipath_del(struct fib6_config *cfg,
3297 struct netlink_ext_ack *extack)
6b9ea5a6
RP		 3298{
3299 struct fib6_config r_cfg;
3300 struct rtnexthop *rtnh;
3301 int remaining;
3302 int attrlen;
3303 int err = 1, last_err = 0;
3304
3305 remaining = cfg->fc_mp_len;
3306 rtnh = (struct rtnexthop *)cfg->fc_mp;
3307
3308 /* Parse a Multipath Entry */
3309 while (rtnh_ok(rtnh, remaining)) {
3310 memcpy(&r_cfg, cfg, sizeof(*cfg));
3311 if (rtnh->rtnh_ifindex)
3312 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
3313
3314 attrlen = rtnh_attrlen(rtnh);
3315 if (attrlen > 0) {
3316 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
3317
3318 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
3319 if (nla) {
3320 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
3321 r_cfg.fc_flags |= RTF_GATEWAY;
3322 }
3323 }
333c4301 3324 err = ip6_route_del(&r_cfg, extack);
6b9ea5a6
RP		 3325 if (err)
3326 last_err = err;
3327
51ebd318
ND		 3328 rtnh = rtnh_next(rtnh, &remaining);
3329 }
3330
3331 return last_err;
3332}
3333
c21ef3e3
DA		 3334static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh,
3335 struct netlink_ext_ack *extack)
1da177e4 3336{
86872cb5
TG		 3337 struct fib6_config cfg;
3338 int err;
1da177e4 3339
333c4301 3340 err = rtm_to_fib6_config(skb, nlh, &cfg, extack);
86872cb5
TG		 3341 if (err < 0)
3342 return err;
3343
51ebd318 3344 if (cfg.fc_mp)
333c4301 3345 return ip6_route_multipath_del(&cfg, extack);
0ae81335
DA		 3346 else {
3347 cfg.fc_delete_all_nh = 1;
333c4301 3348 return ip6_route_del(&cfg, extack);
0ae81335 3349 }
1da177e4
LT		 3350}
3351
c21ef3e3
DA		 3352static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh,
3353 struct netlink_ext_ack *extack)
1da177e4 3354{
86872cb5
TG		 3355 struct fib6_config cfg;
3356 int err;
1da177e4 3357
333c4301 3358 err = rtm_to_fib6_config(skb, nlh, &cfg, extack);
86872cb5
TG		 3359 if (err < 0)
3360 return err;
3361
51ebd318 3362 if (cfg.fc_mp)
333c4301 3363 return ip6_route_multipath_add(&cfg, extack);
51ebd318 3364 else
333c4301 3365 return ip6_route_add(&cfg, extack);
1da177e4
LT		 3366}
3367
beb1afac 3368static size_t rt6_nlmsg_size(struct rt6_info *rt)
339bf98f 3369{
beb1afac
DA		 3370 int nexthop_len = 0;
3371
3372 if (rt->rt6i_nsiblings) {
3373 nexthop_len = nla_total_size(0) /* RTA_MULTIPATH */
3374 + NLA_ALIGN(sizeof(struct rtnexthop))
3375 + nla_total_size(16) /* RTA_GATEWAY */
beb1afac
DA		 3376 + lwtunnel_get_encap_size(rt->dst.lwtstate);
3377
3378 nexthop_len *= rt->rt6i_nsiblings;
3379 }
3380
339bf98f
TG		 3381 return NLMSG_ALIGN(sizeof(struct rtmsg))
3382 + nla_total_size(16) /* RTA_SRC */
3383 + nla_total_size(16) /* RTA_DST */
3384 + nla_total_size(16) /* RTA_GATEWAY */
3385 + nla_total_size(16) /* RTA_PREFSRC */
3386 + nla_total_size(4) /* RTA_TABLE */
3387 + nla_total_size(4) /* RTA_IIF */
3388 + nla_total_size(4) /* RTA_OIF */
3389 + nla_total_size(4) /* RTA_PRIORITY */
6a2b9ce0 3390 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
ea697639 3391 + nla_total_size(sizeof(struct rta_cacheinfo))
c78ba6d6 3392 + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
19e42e45 3393 + nla_total_size(1) /* RTA_PREF */
beb1afac
DA		 3394 + lwtunnel_get_encap_size(rt->dst.lwtstate)
3395 + nexthop_len;
3396}
3397
3398static int rt6_nexthop_info(struct sk_buff *skb, struct rt6_info *rt,
5be083ce 3399 unsigned int *flags, bool skip_oif)
beb1afac
DA		 3400{
3401 if (!netif_running(rt->dst.dev) || !netif_carrier_ok(rt->dst.dev)) {
3402 *flags |= RTNH_F_LINKDOWN;
3403 if (rt->rt6i_idev->cnf.ignore_routes_with_linkdown)
3404 *flags |= RTNH_F_DEAD;
3405 }
3406
3407 if (rt->rt6i_flags & RTF_GATEWAY) {
3408 if (nla_put_in6_addr(skb, RTA_GATEWAY, &rt->rt6i_gateway) < 0)
3409 goto nla_put_failure;
3410 }
3411
fe400799 3412 if (rt->rt6i_nh_flags & RTNH_F_OFFLOAD)
61e4d01e
IS		 3413 *flags |= RTNH_F_OFFLOAD;
3414
5be083ce
DA		 3415 /* not needed for multipath encoding b/c it has a rtnexthop struct */
3416 if (!skip_oif && rt->dst.dev &&
beb1afac
DA		 3417 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
3418 goto nla_put_failure;
3419
3420 if (rt->dst.lwtstate &&
3421 lwtunnel_fill_encap(skb, rt->dst.lwtstate) < 0)
3422 goto nla_put_failure;
3423
3424 return 0;
3425
3426nla_put_failure:
3427 return -EMSGSIZE;
3428}
3429
5be083ce 3430/* add multipath next hop */
beb1afac
DA		 3431static int rt6_add_nexthop(struct sk_buff *skb, struct rt6_info *rt)
3432{
3433 struct rtnexthop *rtnh;
3434 unsigned int flags = 0;
3435
3436 rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
3437 if (!rtnh)
3438 goto nla_put_failure;
3439
3440 rtnh->rtnh_hops = 0;
3441 rtnh->rtnh_ifindex = rt->dst.dev ? rt->dst.dev->ifindex : 0;
3442
5be083ce 3443 if (rt6_nexthop_info(skb, rt, &flags, true) < 0)
beb1afac
DA		 3444 goto nla_put_failure;
3445
3446 rtnh->rtnh_flags = flags;
3447
3448 /* length of rtnetlink header + attributes */
3449 rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *)rtnh;
3450
3451 return 0;
3452
3453nla_put_failure:
3454 return -EMSGSIZE;
339bf98f
TG		 3455}
3456
191cd582
BH		 3457static int rt6_fill_node(struct net *net,
3458 struct sk_buff *skb, struct rt6_info *rt,
0d51aa80 3459 struct in6_addr *dst, struct in6_addr *src,
15e47304 3460 int iif, int type, u32 portid, u32 seq,
f8cfe2ce 3461 unsigned int flags)
1da177e4 3462{
4b32b5ad 3463 u32 metrics[RTAX_MAX];
1da177e4 3464 struct rtmsg *rtm;
2d7202bf 3465 struct nlmsghdr *nlh;
e3703b3d 3466 long expires;
9e762a4a 3467 u32 table;
1da177e4 3468
15e47304 3469 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
38308473 3470 if (!nlh)
26932566 3471 return -EMSGSIZE;
2d7202bf
TG		 3472
3473 rtm = nlmsg_data(nlh);
1da177e4
LT		 3474 rtm->rtm_family = AF_INET6;
3475 rtm->rtm_dst_len = rt->rt6i_dst.plen;
3476 rtm->rtm_src_len = rt->rt6i_src.plen;
3477 rtm->rtm_tos = 0;
c71099ac 3478 if (rt->rt6i_table)
9e762a4a 3479 table = rt->rt6i_table->tb6_id;
c71099ac 3480 else
9e762a4a
PM		 3481 table = RT6_TABLE_UNSPEC;
3482 rtm->rtm_table = table;
c78679e8
DM		 3483 if (nla_put_u32(skb, RTA_TABLE, table))
3484 goto nla_put_failure;
ef2c7d7b
ND		 3485 if (rt->rt6i_flags & RTF_REJECT) {
3486 switch (rt->dst.error) {
3487 case -EINVAL:
3488 rtm->rtm_type = RTN_BLACKHOLE;
3489 break;
3490 case -EACCES:
3491 rtm->rtm_type = RTN_PROHIBIT;
3492 break;
b4949ab2
ND		 3493 case -EAGAIN:
3494 rtm->rtm_type = RTN_THROW;
3495 break;
ef2c7d7b
ND		 3496 default:
3497 rtm->rtm_type = RTN_UNREACHABLE;
3498 break;
3499 }
3500 }
38308473 3501 else if (rt->rt6i_flags & RTF_LOCAL)
ab79ad14 3502 rtm->rtm_type = RTN_LOCAL;
4ee39733
DA		 3503 else if (rt->rt6i_flags & RTF_ANYCAST)
3504 rtm->rtm_type = RTN_ANYCAST;
d1918542 3505 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
1da177e4
LT		 3506 rtm->rtm_type = RTN_LOCAL;
3507 else
3508 rtm->rtm_type = RTN_UNICAST;
3509 rtm->rtm_flags = 0;
3510 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
3511 rtm->rtm_protocol = rt->rt6i_protocol;
1da177e4 3512
38308473 3513 if (rt->rt6i_flags & RTF_CACHE)
1da177e4
LT		 3514 rtm->rtm_flags |= RTM_F_CLONED;
3515
3516 if (dst) {
930345ea 3517 if (nla_put_in6_addr(skb, RTA_DST, dst))
c78679e8 3518 goto nla_put_failure;
1ab1457c 3519 rtm->rtm_dst_len = 128;
1da177e4 3520 } else if (rtm->rtm_dst_len)
930345ea 3521 if (nla_put_in6_addr(skb, RTA_DST, &rt->rt6i_dst.addr))
c78679e8 3522 goto nla_put_failure;
1da177e4
LT		 3523#ifdef CONFIG_IPV6_SUBTREES
3524 if (src) {
930345ea 3525 if (nla_put_in6_addr(skb, RTA_SRC, src))
c78679e8 3526 goto nla_put_failure;
1ab1457c 3527 rtm->rtm_src_len = 128;
c78679e8 3528 } else if (rtm->rtm_src_len &&
930345ea 3529 nla_put_in6_addr(skb, RTA_SRC, &rt->rt6i_src.addr))
c78679e8 3530 goto nla_put_failure;
1da177e4 3531#endif
7bc570c8
YH		 3532 if (iif) {
3533#ifdef CONFIG_IPV6_MROUTE
3534 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
fd61c6ba
DA		 3535 int err = ip6mr_get_route(net, skb, rtm, portid);
3536
3537 if (err == 0)
3538 return 0;
3539 if (err < 0)
3540 goto nla_put_failure;
7bc570c8
YH		 3541 } else
3542#endif
c78679e8
DM		 3543 if (nla_put_u32(skb, RTA_IIF, iif))
3544 goto nla_put_failure;
7bc570c8 3545 } else if (dst) {
1da177e4 3546 struct in6_addr saddr_buf;
c78679e8 3547 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
930345ea 3548 nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
c78679e8 3549 goto nla_put_failure;
1da177e4 3550 }
2d7202bf 3551
c3968a85
DW		 3552 if (rt->rt6i_prefsrc.plen) {
3553 struct in6_addr saddr_buf;
4e3fd7a0 3554 saddr_buf = rt->rt6i_prefsrc.addr;
930345ea 3555 if (nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
c78679e8 3556 goto nla_put_failure;
c3968a85
DW		 3557 }
3558
4b32b5ad
MKL		 3559 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
3560 if (rt->rt6i_pmtu)
3561 metrics[RTAX_MTU - 1] = rt->rt6i_pmtu;
3562 if (rtnetlink_put_metrics(skb, metrics) < 0)
2d7202bf
TG		 3563 goto nla_put_failure;
3564
c78679e8
DM		 3565 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
3566 goto nla_put_failure;
8253947e 3567
beb1afac
DA		 3568 /* For multipath routes, walk the siblings list and add
3569 * each as a nexthop within RTA_MULTIPATH.
3570 */
3571 if (rt->rt6i_nsiblings) {
3572 struct rt6_info *sibling, *next_sibling;
3573 struct nlattr *mp;
3574
3575 mp = nla_nest_start(skb, RTA_MULTIPATH);
3576 if (!mp)
3577 goto nla_put_failure;
3578
3579 if (rt6_add_nexthop(skb, rt) < 0)
3580 goto nla_put_failure;
3581
3582 list_for_each_entry_safe(sibling, next_sibling,
3583 &rt->rt6i_siblings, rt6i_siblings) {
3584 if (rt6_add_nexthop(skb, sibling) < 0)
3585 goto nla_put_failure;
3586 }
3587
3588 nla_nest_end(skb, mp);
3589 } else {
5be083ce 3590 if (rt6_nexthop_info(skb, rt, &rtm->rtm_flags, false) < 0)
beb1afac
DA		 3591 goto nla_put_failure;
3592 }
3593
8253947e 3594 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
69cdf8f9 3595
87a50699 3596 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
e3703b3d 3597 goto nla_put_failure;
2d7202bf 3598
c78ba6d6
LR		 3599 if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt->rt6i_flags)))
3600 goto nla_put_failure;
3601
19e42e45 3602
053c095a
JB		 3603 nlmsg_end(skb, nlh);
3604 return 0;
2d7202bf
TG		 3605
3606nla_put_failure:
26932566
PM		 3607 nlmsg_cancel(skb, nlh);
3608 return -EMSGSIZE;
1da177e4
LT		 3609}
3610
1b43af54 3611int rt6_dump_route(struct rt6_info *rt, void *p_arg)
1da177e4
LT		 3612{
3613 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
1f17e2f2
DA		 3614 struct net *net = arg->net;
3615
3616 if (rt == net->ipv6.ip6_null_entry)
3617 return 0;
1da177e4 3618
2d7202bf
TG		 3619 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
3620 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
f8cfe2ce
DA		 3621
3622 /* user wants prefix routes only */
3623 if (rtm->rtm_flags & RTM_F_PREFIX &&
3624 !(rt->rt6i_flags & RTF_PREFIX_RT)) {
3625 /* success since this is not a prefix route */
3626 return 1;
3627 }
3628 }
1da177e4 3629
1f17e2f2 3630 return rt6_fill_node(net,
191cd582 3631 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
15e47304 3632 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
f8cfe2ce 3633 NLM_F_MULTI);
1da177e4
LT		 3634}
3635
c21ef3e3
DA		 3636static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
3637 struct netlink_ext_ack *extack)
1da177e4 3638{
3b1e0a65 3639 struct net *net = sock_net(in_skb->sk);
ab364a6f 3640 struct nlattr *tb[RTA_MAX+1];
18c3a61c
RP		 3641 int err, iif = 0, oif = 0;
3642 struct dst_entry *dst;
ab364a6f 3643 struct rt6_info *rt;
1da177e4 3644 struct sk_buff *skb;
ab364a6f 3645 struct rtmsg *rtm;
4c9483b2 3646 struct flowi6 fl6;
18c3a61c 3647 bool fibmatch;
1da177e4 3648
fceb6435 3649 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy,
c21ef3e3 3650 extack);
ab364a6f
TG		 3651 if (err < 0)
3652 goto errout;
1da177e4 3653
ab364a6f 3654 err = -EINVAL;
4c9483b2 3655 memset(&fl6, 0, sizeof(fl6));
38b7097b
HFS		 3656 rtm = nlmsg_data(nlh);
3657 fl6.flowlabel = ip6_make_flowinfo(rtm->rtm_tos, 0);
18c3a61c 3658 fibmatch = !!(rtm->rtm_flags & RTM_F_FIB_MATCH);
1da177e4 3659
ab364a6f
TG		 3660 if (tb[RTA_SRC]) {
3661 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
3662 goto errout;
3663
4e3fd7a0 3664 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
ab364a6f
TG		 3665 }
3666
3667 if (tb[RTA_DST]) {
3668 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
3669 goto errout;
3670
4e3fd7a0 3671 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
ab364a6f
TG		 3672 }
3673
3674 if (tb[RTA_IIF])
3675 iif = nla_get_u32(tb[RTA_IIF]);
3676
3677 if (tb[RTA_OIF])
72331bc0 3678 oif = nla_get_u32(tb[RTA_OIF]);
1da177e4 3679
2e47b291
LC		 3680 if (tb[RTA_MARK])
3681 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
3682
622ec2c9
LC		 3683 if (tb[RTA_UID])
3684 fl6.flowi6_uid = make_kuid(current_user_ns(),
3685 nla_get_u32(tb[RTA_UID]));
3686 else
3687 fl6.flowi6_uid = iif ? INVALID_UID : current_uid();
3688
1da177e4
LT		 3689 if (iif) {
3690 struct net_device *dev;
72331bc0
SL		 3691 int flags = 0;
3692
121622db
FW		 3693 rcu_read_lock();
3694
3695 dev = dev_get_by_index_rcu(net, iif);
1da177e4 3696 if (!dev) {
121622db 3697 rcu_read_unlock();
1da177e4 3698 err = -ENODEV;
ab364a6f 3699 goto errout;
1da177e4 3700 }
72331bc0
SL		 3701
3702 fl6.flowi6_iif = iif;
3703
3704 if (!ipv6_addr_any(&fl6.saddr))
3705 flags |= RT6_LOOKUP_F_HAS_SADDR;
3706
33392196 3707 dst = ip6_route_input_lookup(net, dev, &fl6, flags);
121622db
FW		 3708
3709 rcu_read_unlock();
72331bc0
SL		 3710 } else {
3711 fl6.flowi6_oif = oif;
3712
33392196 3713 dst = ip6_route_output(net, NULL, &fl6);
18c3a61c
RP		 3714 }
3715
18c3a61c
RP		 3716
3717 rt = container_of(dst, struct rt6_info, dst);
3718 if (rt->dst.error) {
3719 err = rt->dst.error;
3720 ip6_rt_put(rt);
3721 goto errout;
1da177e4
LT		 3722 }
3723
9d6acb3b
WC		 3724 if (rt == net->ipv6.ip6_null_entry) {
3725 err = rt->dst.error;
3726 ip6_rt_put(rt);
3727 goto errout;
3728 }
3729
33392196
IS		 3730 if (fibmatch && rt->dst.from) {
3731 struct rt6_info *ort = container_of(rt->dst.from,
3732 struct rt6_info, dst);
3733
3734 dst_hold(&ort->dst);
3735 ip6_rt_put(rt);
3736 rt = ort;
3737 }
3738
ab364a6f 3739 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
38308473 3740 if (!skb) {
94e187c0 3741 ip6_rt_put(rt);
ab364a6f
TG		 3742 err = -ENOBUFS;
3743 goto errout;
3744 }
1da177e4 3745
d8d1f30b 3746 skb_dst_set(skb, &rt->dst);
18c3a61c
RP		 3747 if (fibmatch)
3748 err = rt6_fill_node(net, skb, rt, NULL, NULL, iif,
3749 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
3750 nlh->nlmsg_seq, 0);
3751 else
3752 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
3753 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
3754 nlh->nlmsg_seq, 0);
1da177e4 3755 if (err < 0) {
ab364a6f
TG		 3756 kfree_skb(skb);
3757 goto errout;
1da177e4
LT		 3758 }
3759
15e47304 3760 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
ab364a6f 3761errout:
1da177e4 3762 return err;
1da177e4
LT		 3763}
3764
37a1d361
RP		 3765void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info,
3766 unsigned int nlm_flags)
1da177e4
LT		 3767{
3768 struct sk_buff *skb;
5578689a 3769 struct net *net = info->nl_net;
528c4ceb
DL		 3770 u32 seq;
3771 int err;
3772
3773 err = -ENOBUFS;
38308473 3774 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
86872cb5 3775
19e42e45 3776 skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
38308473 3777 if (!skb)
21713ebc
TG		 3778 goto errout;
3779
191cd582 3780 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
f8cfe2ce 3781 event, info->portid, seq, nlm_flags);
26932566
PM		 3782 if (err < 0) {
3783 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
3784 WARN_ON(err == -EMSGSIZE);
3785 kfree_skb(skb);
3786 goto errout;
3787 }
15e47304 3788 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
1ce85fe4
PNA		 3789 info->nlh, gfp_any());
3790 return;
21713ebc
TG		 3791errout:
3792 if (err < 0)
5578689a 3793 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
1da177e4
LT		 3794}
3795
8ed67789 3796static int ip6_route_dev_notify(struct notifier_block *this,
351638e7 3797 unsigned long event, void *ptr)
8ed67789 3798{
351638e7 3799 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
c346dca1 3800 struct net *net = dev_net(dev);
8ed67789 3801
242d3a49
WC		 3802 if (!(dev->flags & IFF_LOOPBACK))
3803 return NOTIFY_OK;
3804
3805 if (event == NETDEV_REGISTER) {
d8d1f30b 3806 net->ipv6.ip6_null_entry->dst.dev = dev;
8ed67789
DL		 3807 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
3808#ifdef CONFIG_IPV6_MULTIPLE_TABLES
d8d1f30b 3809 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
8ed67789 3810 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
d8d1f30b 3811 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
8ed67789 3812 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
242d3a49 3813#endif
76da0704
WC		 3814 } else if (event == NETDEV_UNREGISTER &&
3815 dev->reg_state != NETREG_UNREGISTERED) {
3816 /* NETDEV_UNREGISTER could be fired for multiple times by
3817 * netdev_wait_allrefs(). Make sure we only call this once.
3818 */
12d94a80 3819 in6_dev_put_clear(&net->ipv6.ip6_null_entry->rt6i_idev);
242d3a49 3820#ifdef CONFIG_IPV6_MULTIPLE_TABLES
12d94a80
ED		 3821 in6_dev_put_clear(&net->ipv6.ip6_prohibit_entry->rt6i_idev);
3822 in6_dev_put_clear(&net->ipv6.ip6_blk_hole_entry->rt6i_idev);
8ed67789
DL		 3823#endif
3824 }
3825
3826 return NOTIFY_OK;
3827}
3828
1da177e4
LT		 3829/*
3830 * /proc
3831 */
3832
3833#ifdef CONFIG_PROC_FS
3834
33120b30
AD		 3835static const struct file_operations ipv6_route_proc_fops = {
3836 .owner = THIS_MODULE,
3837 .open = ipv6_route_open,
3838 .read = seq_read,
3839 .llseek = seq_lseek,
8d2ca1d7 3840 .release = seq_release_net,
33120b30
AD		 3841};
3842
1da177e4
LT		 3843static int rt6_stats_seq_show(struct seq_file *seq, void *v)
3844{
69ddb805 3845 struct net *net = (struct net *)seq->private;
1da177e4 3846 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
69ddb805
DL		 3847 net->ipv6.rt6_stats->fib_nodes,
3848 net->ipv6.rt6_stats->fib_route_nodes,
3849 net->ipv6.rt6_stats->fib_rt_alloc,
3850 net->ipv6.rt6_stats->fib_rt_entries,
3851 net->ipv6.rt6_stats->fib_rt_cache,
fc66f95c 3852 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
69ddb805 3853 net->ipv6.rt6_stats->fib_discarded_routes);
1da177e4
LT		 3854
3855 return 0;
3856}
3857
3858static int rt6_stats_seq_open(struct inode *inode, struct file *file)
3859{
de05c557 3860 return single_open_net(inode, file, rt6_stats_seq_show);
69ddb805
DL		 3861}
3862
9a32144e 3863static const struct file_operations rt6_stats_seq_fops = {
1da177e4
LT		 3864 .owner = THIS_MODULE,
3865 .open = rt6_stats_seq_open,
3866 .read = seq_read,
3867 .llseek = seq_lseek,
b6fcbdb4 3868 .release = single_release_net,
1da177e4
LT		 3869};
3870#endif /* CONFIG_PROC_FS */
3871
3872#ifdef CONFIG_SYSCTL
3873
1da177e4 3874static
fe2c6338 3875int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
1da177e4
LT		 3876 void __user *buffer, size_t *lenp, loff_t *ppos)
3877{
c486da34
LAG		 3878 struct net *net;
3879 int delay;
3880 if (!write)
1da177e4 3881 return -EINVAL;
c486da34
LAG		 3882
3883 net = (struct net *)ctl->extra1;
3884 delay = net->ipv6.sysctl.flush_delay;
3885 proc_dointvec(ctl, write, buffer, lenp, ppos);
2ac3ac8f 3886 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
c486da34 3887 return 0;
1da177e4
LT		 3888}
3889
fe2c6338 3890struct ctl_table ipv6_route_table_template[] = {
1ab1457c 3891 {
1da177e4 3892 .procname = "flush",
4990509f 3893 .data = &init_net.ipv6.sysctl.flush_delay,
1da177e4 3894 .maxlen = sizeof(int),
89c8b3a1 3895 .mode = 0200,
6d9f239a 3896 .proc_handler = ipv6_sysctl_rtcache_flush
1da177e4
LT		 3897 },
3898 {
1da177e4 3899 .procname = "gc_thresh",
9a7ec3a9 3900 .data = &ip6_dst_ops_template.gc_thresh,
1da177e4
LT		 3901 .maxlen = sizeof(int),
3902 .mode = 0644,
6d9f239a 3903 .proc_handler = proc_dointvec,
1da177e4
LT		 3904 },
3905 {
1da177e4 3906 .procname = "max_size",
4990509f 3907 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
1da177e4
LT		 3908 .maxlen = sizeof(int),
3909 .mode = 0644,
6d9f239a 3910 .proc_handler = proc_dointvec,
1da177e4
LT		 3911 },
3912 {
1da177e4 3913 .procname = "gc_min_interval",
4990509f 3914 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 3915 .maxlen = sizeof(int),
3916 .mode = 0644,
6d9f239a 3917 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3918 },
3919 {
1da177e4 3920 .procname = "gc_timeout",
4990509f 3921 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
1da177e4
LT		 3922 .maxlen = sizeof(int),
3923 .mode = 0644,
6d9f239a 3924 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3925 },
3926 {
1da177e4 3927 .procname = "gc_interval",
4990509f 3928 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
1da177e4
LT		 3929 .maxlen = sizeof(int),
3930 .mode = 0644,
6d9f239a 3931 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3932 },
3933 {
1da177e4 3934 .procname = "gc_elasticity",
4990509f 3935 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
1da177e4
LT		 3936 .maxlen = sizeof(int),
3937 .mode = 0644,
f3d3f616 3938 .proc_handler = proc_dointvec,
1da177e4
LT		 3939 },
3940 {
1da177e4 3941 .procname = "mtu_expires",
4990509f 3942 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
1da177e4
LT		 3943 .maxlen = sizeof(int),
3944 .mode = 0644,
6d9f239a 3945 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3946 },
3947 {
1da177e4 3948 .procname = "min_adv_mss",
4990509f 3949 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
1da177e4
LT		 3950 .maxlen = sizeof(int),
3951 .mode = 0644,
f3d3f616 3952 .proc_handler = proc_dointvec,
1da177e4
LT		 3953 },
3954 {
1da177e4 3955 .procname = "gc_min_interval_ms",
4990509f 3956 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 3957 .maxlen = sizeof(int),
3958 .mode = 0644,
6d9f239a 3959 .proc_handler = proc_dointvec_ms_jiffies,
1da177e4 3960 },
f8572d8f 3961 { }
1da177e4
LT		 3962};
3963
2c8c1e72 3964struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
760f2d01
DL		 3965{
3966 struct ctl_table *table;
3967
3968 table = kmemdup(ipv6_route_table_template,
3969 sizeof(ipv6_route_table_template),
3970 GFP_KERNEL);
5ee09105
YH		 3971
3972 if (table) {
3973 table[0].data = &net->ipv6.sysctl.flush_delay;
c486da34 3974 table[0].extra1 = net;
86393e52 3975 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
5ee09105
YH		 3976 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
3977 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3978 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
3979 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
3980 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
3981 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
3982 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
9c69fabe 3983 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
464dc801
EB		 3984
3985 /* Don't export sysctls to unprivileged users */
3986 if (net->user_ns != &init_user_ns)
3987 table[0].procname = NULL;
5ee09105
YH		 3988 }
3989
760f2d01
DL		 3990 return table;
3991}
1da177e4
LT		 3992#endif
3993
2c8c1e72 3994static int __net_init ip6_route_net_init(struct net *net)
cdb18761 3995{
633d424b 3996 int ret = -ENOMEM;
8ed67789 3997
86393e52
AD		 3998 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3999 sizeof(net->ipv6.ip6_dst_ops));
f2fc6a54 4000
fc66f95c
ED		 4001 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
4002 goto out_ip6_dst_ops;
4003
8ed67789
DL		 4004 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
4005 sizeof(*net->ipv6.ip6_null_entry),
4006 GFP_KERNEL);
4007 if (!net->ipv6.ip6_null_entry)
fc66f95c 4008 goto out_ip6_dst_entries;
d8d1f30b 4009 net->ipv6.ip6_null_entry->dst.path =
8ed67789 4010 (struct dst_entry *)net->ipv6.ip6_null_entry;
d8d1f30b 4011 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 4012 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
4013 ip6_template_metrics, true);
8ed67789
DL		 4014
4015#ifdef CONFIG_IPV6_MULTIPLE_TABLES
feca7d8c 4016 net->ipv6.fib6_has_custom_rules = false;
8ed67789
DL		 4017 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
4018 sizeof(*net->ipv6.ip6_prohibit_entry),
4019 GFP_KERNEL);
68fffc67
PZ		 4020 if (!net->ipv6.ip6_prohibit_entry)
4021 goto out_ip6_null_entry;
d8d1f30b 4022 net->ipv6.ip6_prohibit_entry->dst.path =
8ed67789 4023 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
d8d1f30b 4024 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 4025 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
4026 ip6_template_metrics, true);
8ed67789
DL		 4027
4028 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
4029 sizeof(*net->ipv6.ip6_blk_hole_entry),
4030 GFP_KERNEL);
68fffc67
PZ		 4031 if (!net->ipv6.ip6_blk_hole_entry)
4032 goto out_ip6_prohibit_entry;
d8d1f30b 4033 net->ipv6.ip6_blk_hole_entry->dst.path =
8ed67789 4034 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
d8d1f30b 4035 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 4036 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
4037 ip6_template_metrics, true);
8ed67789
DL		 4038#endif
4039
b339a47c
PZ		 4040 net->ipv6.sysctl.flush_delay = 0;
4041 net->ipv6.sysctl.ip6_rt_max_size = 4096;
4042 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
4043 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
4044 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
4045 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
4046 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
4047 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
4048
6891a346
BT		 4049 net->ipv6.ip6_rt_gc_expire = 30*HZ;
4050
8ed67789
DL		 4051 ret = 0;
4052out:
4053 return ret;
f2fc6a54 4054
68fffc67
PZ		 4055#ifdef CONFIG_IPV6_MULTIPLE_TABLES
4056out_ip6_prohibit_entry:
4057 kfree(net->ipv6.ip6_prohibit_entry);
4058out_ip6_null_entry:
4059 kfree(net->ipv6.ip6_null_entry);
4060#endif
fc66f95c
ED		 4061out_ip6_dst_entries:
4062 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
f2fc6a54 4063out_ip6_dst_ops:
f2fc6a54 4064 goto out;
cdb18761
DL		 4065}
4066
2c8c1e72 4067static void __net_exit ip6_route_net_exit(struct net *net)
cdb18761 4068{
8ed67789
DL		 4069 kfree(net->ipv6.ip6_null_entry);
4070#ifdef CONFIG_IPV6_MULTIPLE_TABLES
4071 kfree(net->ipv6.ip6_prohibit_entry);
4072 kfree(net->ipv6.ip6_blk_hole_entry);
4073#endif
41bb78b4 4074 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
cdb18761
DL		 4075}
4076
d189634e
TG		 4077static int __net_init ip6_route_net_init_late(struct net *net)
4078{
4079#ifdef CONFIG_PROC_FS
d4beaa66
G		 4080 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
4081 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
d189634e
TG		 4082#endif
4083 return 0;
4084}
4085
4086static void __net_exit ip6_route_net_exit_late(struct net *net)
4087{
4088#ifdef CONFIG_PROC_FS
ece31ffd
G		 4089 remove_proc_entry("ipv6_route", net->proc_net);
4090 remove_proc_entry("rt6_stats", net->proc_net);
d189634e
TG		 4091#endif
4092}
4093
cdb18761
DL		 4094static struct pernet_operations ip6_route_net_ops = {
4095 .init = ip6_route_net_init,
4096 .exit = ip6_route_net_exit,
4097};
4098
c3426b47
DM		 4099static int __net_init ipv6_inetpeer_init(struct net *net)
4100{
4101 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
4102
4103 if (!bp)
4104 return -ENOMEM;
4105 inet_peer_base_init(bp);
4106 net->ipv6.peers = bp;
4107 return 0;
4108}
4109
4110static void __net_exit ipv6_inetpeer_exit(struct net *net)
4111{
4112 struct inet_peer_base *bp = net->ipv6.peers;
4113
4114 net->ipv6.peers = NULL;
56a6b248 4115 inetpeer_invalidate_tree(bp);
c3426b47
DM		 4116 kfree(bp);
4117}
4118
2b823f72 4119static struct pernet_operations ipv6_inetpeer_ops = {
c3426b47
DM		 4120 .init = ipv6_inetpeer_init,
4121 .exit = ipv6_inetpeer_exit,
4122};
4123
d189634e
TG		 4124static struct pernet_operations ip6_route_net_late_ops = {
4125 .init = ip6_route_net_init_late,
4126 .exit = ip6_route_net_exit_late,
4127};
4128
8ed67789
DL		 4129static struct notifier_block ip6_route_dev_notifier = {
4130 .notifier_call = ip6_route_dev_notify,
242d3a49 4131 .priority = ADDRCONF_NOTIFY_PRIORITY - 10,
8ed67789
DL		 4132};
4133
2f460933
WC		 4134void __init ip6_route_init_special_entries(void)
4135{
4136 /* Registering of the loopback is done before this portion of code,
4137 * the loopback reference in rt6_info will not be taken, do it
4138 * manually for init_net */
4139 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
4140 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
4141 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
4142 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
4143 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
4144 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
4145 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
4146 #endif
4147}
4148
433d49c3 4149int __init ip6_route_init(void)
1da177e4 4150{
433d49c3 4151 int ret;
8d0b94af 4152 int cpu;
433d49c3 4153
9a7ec3a9
DL		 4154 ret = -ENOMEM;
4155 ip6_dst_ops_template.kmem_cachep =
e5d679f3 4156 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
f845ab6b 4157 SLAB_HWCACHE_ALIGN, NULL);
9a7ec3a9 4158 if (!ip6_dst_ops_template.kmem_cachep)
c19a28e1 4159 goto out;
14e50e57 4160
fc66f95c 4161 ret = dst_entries_init(&ip6_dst_blackhole_ops);
8ed67789 4162 if (ret)
bdb3289f 4163 goto out_kmem_cache;
bdb3289f 4164
c3426b47
DM		 4165 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
4166 if (ret)
e8803b6c 4167 goto out_dst_entries;
2a0c451a 4168
7e52b33b
DM		 4169 ret = register_pernet_subsys(&ip6_route_net_ops);
4170 if (ret)
4171 goto out_register_inetpeer;
c3426b47 4172
5dc121e9
AE		 4173 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
4174
e8803b6c 4175 ret = fib6_init();
433d49c3 4176 if (ret)
8ed67789 4177 goto out_register_subsys;
433d49c3 4178
433d49c3
DL		 4179 ret = xfrm6_init();
4180 if (ret)
e8803b6c 4181 goto out_fib6_init;
c35b7e72 4182
433d49c3
DL		 4183 ret = fib6_rules_init();
4184 if (ret)
4185 goto xfrm6_init;
7e5449c2 4186
d189634e
TG		 4187 ret = register_pernet_subsys(&ip6_route_net_late_ops);
4188 if (ret)
4189 goto fib6_rules_init;
4190
433d49c3 4191 ret = -ENOBUFS;
b97bac64
FW		 4192 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, 0) ||
4193 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, 0) ||
e3a22b7f
FW		 4194 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL,
4195 RTNL_FLAG_DOIT_UNLOCKED))
d189634e 4196 goto out_register_late_subsys;
c127ea2c 4197
8ed67789 4198 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
cdb18761 4199 if (ret)
d189634e 4200 goto out_register_late_subsys;
8ed67789 4201
8d0b94af
MKL		 4202 for_each_possible_cpu(cpu) {
4203 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
4204
4205 INIT_LIST_HEAD(&ul->head);
4206 spin_lock_init(&ul->lock);
4207 }
4208
433d49c3
DL		 4209out:
4210 return ret;
4211
d189634e
TG		 4212out_register_late_subsys:
4213 unregister_pernet_subsys(&ip6_route_net_late_ops);
433d49c3 4214fib6_rules_init:
433d49c3
DL		 4215 fib6_rules_cleanup();
4216xfrm6_init:
433d49c3 4217 xfrm6_fini();
2a0c451a
TG		 4218out_fib6_init:
4219 fib6_gc_cleanup();
8ed67789
DL		 4220out_register_subsys:
4221 unregister_pernet_subsys(&ip6_route_net_ops);
7e52b33b
DM		 4222out_register_inetpeer:
4223 unregister_pernet_subsys(&ipv6_inetpeer_ops);
fc66f95c
ED		 4224out_dst_entries:
4225 dst_entries_destroy(&ip6_dst_blackhole_ops);
433d49c3 4226out_kmem_cache:
f2fc6a54 4227 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
433d49c3 4228 goto out;
1da177e4
LT		 4229}
4230
4231void ip6_route_cleanup(void)
4232{
8ed67789 4233 unregister_netdevice_notifier(&ip6_route_dev_notifier);
d189634e 4234 unregister_pernet_subsys(&ip6_route_net_late_ops);
101367c2 4235 fib6_rules_cleanup();
1da177e4 4236 xfrm6_fini();
1da177e4 4237 fib6_gc_cleanup();
c3426b47 4238 unregister_pernet_subsys(&ipv6_inetpeer_ops);
8ed67789 4239 unregister_pernet_subsys(&ip6_route_net_ops);
41bb78b4 4240 dst_entries_destroy(&ip6_dst_blackhole_ops);
f2fc6a54 4241 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
1da177e4 4242}