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