]> 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
gso: Validate assumption of frag_list segementation
[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{
0dec879f 1384 const struct in6_addr *daddr, *saddr;
67ba4152 1385 struct rt6_info *rt6 = (struct rt6_info *)dst;
1da177e4 1386
45e4fd26
MKL		 1387 if (rt6->rt6i_flags & RTF_LOCAL)
1388 return;
81aded24 1389
19bda36c
XL		 1390 if (dst_metric_locked(dst, RTAX_MTU))
1391 return;
1392
0dec879f
JA		 1393 if (iph) {
1394 daddr = &iph->daddr;
1395 saddr = &iph->saddr;
1396 } else if (sk) {
1397 daddr = &sk->sk_v6_daddr;
1398 saddr = &inet6_sk(sk)->saddr;
1399 } else {
1400 daddr = NULL;
1401 saddr = NULL;
1402 }
1403 dst_confirm_neigh(dst, daddr);
45e4fd26
MKL		 1404 mtu = max_t(u32, mtu, IPV6_MIN_MTU);
1405 if (mtu >= dst_mtu(dst))
1406 return;
9d289715 1407
0d3f6d29 1408 if (!rt6_cache_allowed_for_pmtu(rt6)) {
45e4fd26 1409 rt6_do_update_pmtu(rt6, mtu);
0dec879f 1410 } else if (daddr) {
45e4fd26
MKL		 1411 struct rt6_info *nrt6;
1412
45e4fd26
MKL		 1413 nrt6 = ip6_rt_cache_alloc(rt6, daddr, saddr);
1414 if (nrt6) {
1415 rt6_do_update_pmtu(nrt6, mtu);
1416
1417 /* ip6_ins_rt(nrt6) will bump the
1418 * rt6->rt6i_node->fn_sernum
1419 * which will fail the next rt6_check() and
1420 * invalidate the sk->sk_dst_cache.
1421 */
1422 ip6_ins_rt(nrt6);
1423 }
1da177e4
LT		 1424 }
1425}
1426
45e4fd26
MKL		 1427static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1428 struct sk_buff *skb, u32 mtu)
1429{
1430 __ip6_rt_update_pmtu(dst, sk, skb ? ipv6_hdr(skb) : NULL, mtu);
1431}
1432
42ae66c8 1433void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
e2d118a1 1434 int oif, u32 mark, kuid_t uid)
81aded24
DM		 1435{
1436 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1437 struct dst_entry *dst;
1438 struct flowi6 fl6;
1439
1440 memset(&fl6, 0, sizeof(fl6));
1441 fl6.flowi6_oif = oif;
1b3c61dc 1442 fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
81aded24
DM		 1443 fl6.daddr = iph->daddr;
1444 fl6.saddr = iph->saddr;
6502ca52 1445 fl6.flowlabel = ip6_flowinfo(iph);
e2d118a1 1446 fl6.flowi6_uid = uid;
81aded24
DM		 1447
1448 dst = ip6_route_output(net, NULL, &fl6);
1449 if (!dst->error)
45e4fd26 1450 __ip6_rt_update_pmtu(dst, NULL, iph, ntohl(mtu));
81aded24
DM		 1451 dst_release(dst);
1452}
1453EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1454
1455void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1456{
33c162a9
MKL		 1457 struct dst_entry *dst;
1458
81aded24 1459 ip6_update_pmtu(skb, sock_net(sk), mtu,
e2d118a1 1460 sk->sk_bound_dev_if, sk->sk_mark, sk->sk_uid);
33c162a9
MKL		 1461
1462 dst = __sk_dst_get(sk);
1463 if (!dst || !dst->obsolete ||
1464 dst->ops->check(dst, inet6_sk(sk)->dst_cookie))
1465 return;
1466
1467 bh_lock_sock(sk);
1468 if (!sock_owned_by_user(sk) && !ipv6_addr_v4mapped(&sk->sk_v6_daddr))
1469 ip6_datagram_dst_update(sk, false);
1470 bh_unlock_sock(sk);
81aded24
DM		 1471}
1472EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1473
b55b76b2
DJ		 1474/* Handle redirects */
1475struct ip6rd_flowi {
1476 struct flowi6 fl6;
1477 struct in6_addr gateway;
1478};
1479
1480static struct rt6_info *__ip6_route_redirect(struct net *net,
1481 struct fib6_table *table,
1482 struct flowi6 *fl6,
1483 int flags)
1484{
1485 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
1486 struct rt6_info *rt;
1487 struct fib6_node *fn;
1488
1489 /* Get the "current" route for this destination and
67c408cf 1490 * check if the redirect has come from appropriate router.
b55b76b2
DJ		 1491 *
1492 * RFC 4861 specifies that redirects should only be
1493 * accepted if they come from the nexthop to the target.
1494 * Due to the way the routes are chosen, this notion
1495 * is a bit fuzzy and one might need to check all possible
1496 * routes.
1497 */
1498
1499 read_lock_bh(&table->tb6_lock);
1500 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1501restart:
1502 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1503 if (rt6_check_expired(rt))
1504 continue;
1505 if (rt->dst.error)
1506 break;
1507 if (!(rt->rt6i_flags & RTF_GATEWAY))
1508 continue;
1509 if (fl6->flowi6_oif != rt->dst.dev->ifindex)
1510 continue;
1511 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1512 continue;
1513 break;
1514 }
1515
1516 if (!rt)
1517 rt = net->ipv6.ip6_null_entry;
1518 else if (rt->dst.error) {
1519 rt = net->ipv6.ip6_null_entry;
b0a1ba59
MKL		 1520 goto out;
1521 }
1522
1523 if (rt == net->ipv6.ip6_null_entry) {
a3c00e46
MKL		 1524 fn = fib6_backtrack(fn, &fl6->saddr);
1525 if (fn)
1526 goto restart;
b55b76b2 1527 }
a3c00e46 1528
b0a1ba59 1529out:
b55b76b2
DJ		 1530 dst_hold(&rt->dst);
1531
1532 read_unlock_bh(&table->tb6_lock);
1533
b811580d 1534 trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
b55b76b2
DJ		 1535 return rt;
1536};
1537
1538static struct dst_entry *ip6_route_redirect(struct net *net,
1539 const struct flowi6 *fl6,
1540 const struct in6_addr *gateway)
1541{
1542 int flags = RT6_LOOKUP_F_HAS_SADDR;
1543 struct ip6rd_flowi rdfl;
1544
1545 rdfl.fl6 = *fl6;
1546 rdfl.gateway = *gateway;
1547
1548 return fib6_rule_lookup(net, &rdfl.fl6,
1549 flags, __ip6_route_redirect);
1550}
1551
e2d118a1
LC		 1552void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark,
1553 kuid_t uid)
3a5ad2ee
DM		 1554{
1555 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1556 struct dst_entry *dst;
1557 struct flowi6 fl6;
1558
1559 memset(&fl6, 0, sizeof(fl6));
e374c618 1560 fl6.flowi6_iif = LOOPBACK_IFINDEX;
3a5ad2ee
DM		 1561 fl6.flowi6_oif = oif;
1562 fl6.flowi6_mark = mark;
3a5ad2ee
DM		 1563 fl6.daddr = iph->daddr;
1564 fl6.saddr = iph->saddr;
6502ca52 1565 fl6.flowlabel = ip6_flowinfo(iph);
e2d118a1 1566 fl6.flowi6_uid = uid;
3a5ad2ee 1567
b55b76b2
DJ		 1568 dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
1569 rt6_do_redirect(dst, NULL, skb);
3a5ad2ee
DM		 1570 dst_release(dst);
1571}
1572EXPORT_SYMBOL_GPL(ip6_redirect);
1573
c92a59ec
DJ		 1574void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
1575 u32 mark)
1576{
1577 const struct ipv6hdr *iph = ipv6_hdr(skb);
1578 const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
1579 struct dst_entry *dst;
1580 struct flowi6 fl6;
1581
1582 memset(&fl6, 0, sizeof(fl6));
e374c618 1583 fl6.flowi6_iif = LOOPBACK_IFINDEX;
c92a59ec
DJ		 1584 fl6.flowi6_oif = oif;
1585 fl6.flowi6_mark = mark;
c92a59ec
DJ		 1586 fl6.daddr = msg->dest;
1587 fl6.saddr = iph->daddr;
e2d118a1 1588 fl6.flowi6_uid = sock_net_uid(net, NULL);
c92a59ec 1589
b55b76b2
DJ		 1590 dst = ip6_route_redirect(net, &fl6, &iph->saddr);
1591 rt6_do_redirect(dst, NULL, skb);
c92a59ec
DJ		 1592 dst_release(dst);
1593}
1594
3a5ad2ee
DM		 1595void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1596{
e2d118a1
LC		 1597 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark,
1598 sk->sk_uid);
3a5ad2ee
DM		 1599}
1600EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1601
0dbaee3b 1602static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1da177e4 1603{
0dbaee3b
DM		 1604 struct net_device *dev = dst->dev;
1605 unsigned int mtu = dst_mtu(dst);
1606 struct net *net = dev_net(dev);
1607
1da177e4
LT		 1608 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1609
5578689a
DL		 1610 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1611 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1da177e4
LT		 1612
1613 /*
1ab1457c
YH		 1614 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1615 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1616 * IPV6_MAXPLEN is also valid and means: "any MSS,
1da177e4
LT		 1617 * rely only on pmtu discovery"
1618 */
1619 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1620 mtu = IPV6_MAXPLEN;
1621 return mtu;
1622}
1623
ebb762f2 1624static unsigned int ip6_mtu(const struct dst_entry *dst)
d33e4553 1625{
4b32b5ad
MKL		 1626 const struct rt6_info *rt = (const struct rt6_info *)dst;
1627 unsigned int mtu = rt->rt6i_pmtu;
d33e4553 1628 struct inet6_dev *idev;
618f9bc7 1629
4b32b5ad
MKL		 1630 if (mtu)
1631 goto out;
1632
1633 mtu = dst_metric_raw(dst, RTAX_MTU);
618f9bc7 1634 if (mtu)
30f78d8e 1635 goto out;
618f9bc7
SK		 1636
1637 mtu = IPV6_MIN_MTU;
d33e4553
DM		 1638
1639 rcu_read_lock();
1640 idev = __in6_dev_get(dst->dev);
1641 if (idev)
1642 mtu = idev->cnf.mtu6;
1643 rcu_read_unlock();
1644
30f78d8e 1645out:
14972cbd
RP		 1646 mtu = min_t(unsigned int, mtu, IP6_MAX_MTU);
1647
1648 return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
d33e4553
DM		 1649}
1650
3b00944c
YH		 1651static struct dst_entry *icmp6_dst_gc_list;
1652static DEFINE_SPINLOCK(icmp6_dst_lock);
5d0bbeeb 1653
3b00944c 1654struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
87a11578 1655 struct flowi6 *fl6)
1da177e4 1656{
87a11578 1657 struct dst_entry *dst;
1da177e4
LT		 1658 struct rt6_info *rt;
1659 struct inet6_dev *idev = in6_dev_get(dev);
c346dca1 1660 struct net *net = dev_net(dev);
1da177e4 1661
38308473 1662 if (unlikely(!idev))
122bdf67 1663 return ERR_PTR(-ENODEV);
1da177e4 1664
ad706862 1665 rt = ip6_dst_alloc(net, dev, 0);
38308473 1666 if (unlikely(!rt)) {
1da177e4 1667 in6_dev_put(idev);
87a11578 1668 dst = ERR_PTR(-ENOMEM);
1da177e4
LT		 1669 goto out;
1670 }
1671
8e2ec639
YZ		 1672 rt->dst.flags |= DST_HOST;
1673 rt->dst.output = ip6_output;
d8d1f30b 1674 atomic_set(&rt->dst.__refcnt, 1);
550bab42 1675 rt->rt6i_gateway = fl6->daddr;
87a11578 1676 rt->rt6i_dst.addr = fl6->daddr;
8e2ec639
YZ		 1677 rt->rt6i_dst.plen = 128;
1678 rt->rt6i_idev = idev;
14edd87d 1679 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1da177e4 1680
3b00944c 1681 spin_lock_bh(&icmp6_dst_lock);
d8d1f30b
CG		 1682 rt->dst.next = icmp6_dst_gc_list;
1683 icmp6_dst_gc_list = &rt->dst;
3b00944c 1684 spin_unlock_bh(&icmp6_dst_lock);
1da177e4 1685
5578689a 1686 fib6_force_start_gc(net);
1da177e4 1687
87a11578
DM		 1688 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1689
1da177e4 1690out:
87a11578 1691 return dst;
1da177e4
LT		 1692}
1693
3d0f24a7 1694int icmp6_dst_gc(void)
1da177e4 1695{
e9476e95 1696 struct dst_entry *dst, **pprev;
3d0f24a7 1697 int more = 0;
1da177e4 1698
3b00944c
YH		 1699 spin_lock_bh(&icmp6_dst_lock);
1700 pprev = &icmp6_dst_gc_list;
5d0bbeeb 1701
1da177e4
LT		 1702 while ((dst = *pprev) != NULL) {
1703 if (!atomic_read(&dst->__refcnt)) {
1704 *pprev = dst->next;
1705 dst_free(dst);
1da177e4
LT		 1706 } else {
1707 pprev = &dst->next;
3d0f24a7 1708 ++more;
1da177e4
LT		 1709 }
1710 }
1711
3b00944c 1712 spin_unlock_bh(&icmp6_dst_lock);
5d0bbeeb 1713
3d0f24a7 1714 return more;
1da177e4
LT		 1715}
1716
1e493d19
DM		 1717static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1718 void *arg)
1719{
1720 struct dst_entry *dst, **pprev;
1721
1722 spin_lock_bh(&icmp6_dst_lock);
1723 pprev = &icmp6_dst_gc_list;
1724 while ((dst = *pprev) != NULL) {
1725 struct rt6_info *rt = (struct rt6_info *) dst;
1726 if (func(rt, arg)) {
1727 *pprev = dst->next;
1728 dst_free(dst);
1729 } else {
1730 pprev = &dst->next;
1731 }
1732 }
1733 spin_unlock_bh(&icmp6_dst_lock);
1734}
1735
569d3645 1736static int ip6_dst_gc(struct dst_ops *ops)
1da177e4 1737{
86393e52 1738 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
7019b78e
DL		 1739 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1740 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1741 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1742 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1743 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
fc66f95c 1744 int entries;
7019b78e 1745
fc66f95c 1746 entries = dst_entries_get_fast(ops);
49a18d86 1747 if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
fc66f95c 1748 entries <= rt_max_size)
1da177e4
LT		 1749 goto out;
1750
6891a346 1751 net->ipv6.ip6_rt_gc_expire++;
14956643 1752 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
fc66f95c
ED		 1753 entries = dst_entries_get_slow(ops);
1754 if (entries < ops->gc_thresh)
7019b78e 1755 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1da177e4 1756out:
7019b78e 1757 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
fc66f95c 1758 return entries > rt_max_size;
1da177e4
LT		 1759}
1760
e715b6d3
FW		 1761static int ip6_convert_metrics(struct mx6_config *mxc,
1762 const struct fib6_config *cfg)
1763{
c3a8d947 1764 bool ecn_ca = false;
e715b6d3
FW		 1765 struct nlattr *nla;
1766 int remaining;
1767 u32 *mp;
1768
63159f29 1769 if (!cfg->fc_mx)
e715b6d3
FW		 1770 return 0;
1771
1772 mp = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1773 if (unlikely(!mp))
1774 return -ENOMEM;
1775
1776 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1777 int type = nla_type(nla);
1bb14807 1778 u32 val;
e715b6d3 1779
1bb14807
DB		 1780 if (!type)
1781 continue;
1782 if (unlikely(type > RTAX_MAX))
1783 goto err;
ea697639 1784
1bb14807
DB		 1785 if (type == RTAX_CC_ALGO) {
1786 char tmp[TCP_CA_NAME_MAX];
e715b6d3 1787
1bb14807 1788 nla_strlcpy(tmp, nla, sizeof(tmp));
c3a8d947 1789 val = tcp_ca_get_key_by_name(tmp, &ecn_ca);
1bb14807
DB		 1790 if (val == TCP_CA_UNSPEC)
1791 goto err;
1792 } else {
1793 val = nla_get_u32(nla);
e715b6d3 1794 }
626abd59
PA		 1795 if (type == RTAX_HOPLIMIT && val > 255)
1796 val = 255;
b8d3e416
DB		 1797 if (type == RTAX_FEATURES && (val & ~RTAX_FEATURE_MASK))
1798 goto err;
1bb14807
DB		 1799
1800 mp[type - 1] = val;
1801 __set_bit(type - 1, mxc->mx_valid);
e715b6d3
FW		 1802 }
1803
c3a8d947
DB		 1804 if (ecn_ca) {
1805 __set_bit(RTAX_FEATURES - 1, mxc->mx_valid);
1806 mp[RTAX_FEATURES - 1] |= DST_FEATURE_ECN_CA;
1807 }
e715b6d3 1808
c3a8d947 1809 mxc->mx = mp;
e715b6d3
FW		 1810 return 0;
1811 err:
1812 kfree(mp);
1813 return -EINVAL;
1814}
1da177e4 1815
8c14586f
DA		 1816static struct rt6_info *ip6_nh_lookup_table(struct net *net,
1817 struct fib6_config *cfg,
1818 const struct in6_addr *gw_addr)
1819{
1820 struct flowi6 fl6 = {
1821 .flowi6_oif = cfg->fc_ifindex,
1822 .daddr = *gw_addr,
1823 .saddr = cfg->fc_prefsrc,
1824 };
1825 struct fib6_table *table;
1826 struct rt6_info *rt;
d5d32e4b 1827 int flags = RT6_LOOKUP_F_IFACE | RT6_LOOKUP_F_IGNORE_LINKSTATE;
8c14586f
DA		 1828
1829 table = fib6_get_table(net, cfg->fc_table);
1830 if (!table)
1831 return NULL;
1832
1833 if (!ipv6_addr_any(&cfg->fc_prefsrc))
1834 flags |= RT6_LOOKUP_F_HAS_SADDR;
1835
1836 rt = ip6_pol_route(net, table, cfg->fc_ifindex, &fl6, flags);
1837
1838 /* if table lookup failed, fall back to full lookup */
1839 if (rt == net->ipv6.ip6_null_entry) {
1840 ip6_rt_put(rt);
1841 rt = NULL;
1842 }
1843
1844 return rt;
1845}
1846
8c5b83f0 1847static struct rt6_info *ip6_route_info_create(struct fib6_config *cfg)
1da177e4 1848{
5578689a 1849 struct net *net = cfg->fc_nlinfo.nl_net;
1da177e4
LT		 1850 struct rt6_info *rt = NULL;
1851 struct net_device *dev = NULL;
1852 struct inet6_dev *idev = NULL;
c71099ac 1853 struct fib6_table *table;
1da177e4 1854 int addr_type;
8c5b83f0 1855 int err = -EINVAL;
1da177e4 1856
86872cb5 1857 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
8c5b83f0 1858 goto out;
1da177e4 1859#ifndef CONFIG_IPV6_SUBTREES
86872cb5 1860 if (cfg->fc_src_len)
8c5b83f0 1861 goto out;
1da177e4 1862#endif
86872cb5 1863 if (cfg->fc_ifindex) {
1da177e4 1864 err = -ENODEV;
5578689a 1865 dev = dev_get_by_index(net, cfg->fc_ifindex);
1da177e4
LT		 1866 if (!dev)
1867 goto out;
1868 idev = in6_dev_get(dev);
1869 if (!idev)
1870 goto out;
1871 }
1872
86872cb5
TG		 1873 if (cfg->fc_metric == 0)
1874 cfg->fc_metric = IP6_RT_PRIO_USER;
1da177e4 1875
d71314b4 1876 err = -ENOBUFS;
38308473
DM		 1877 if (cfg->fc_nlinfo.nlh &&
1878 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
d71314b4 1879 table = fib6_get_table(net, cfg->fc_table);
38308473 1880 if (!table) {
f3213831 1881 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
d71314b4
MV		 1882 table = fib6_new_table(net, cfg->fc_table);
1883 }
1884 } else {
1885 table = fib6_new_table(net, cfg->fc_table);
1886 }
38308473
DM		 1887
1888 if (!table)
c71099ac 1889 goto out;
c71099ac 1890
ad706862
MKL		 1891 rt = ip6_dst_alloc(net, NULL,
1892 (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT);
1da177e4 1893
38308473 1894 if (!rt) {
1da177e4
LT		 1895 err = -ENOMEM;
1896 goto out;
1897 }
1898
1716a961
G		 1899 if (cfg->fc_flags & RTF_EXPIRES)
1900 rt6_set_expires(rt, jiffies +
1901 clock_t_to_jiffies(cfg->fc_expires));
1902 else
1903 rt6_clean_expires(rt);
1da177e4 1904
86872cb5
TG		 1905 if (cfg->fc_protocol == RTPROT_UNSPEC)
1906 cfg->fc_protocol = RTPROT_BOOT;
1907 rt->rt6i_protocol = cfg->fc_protocol;
1908
1909 addr_type = ipv6_addr_type(&cfg->fc_dst);
1da177e4
LT		 1910
1911 if (addr_type & IPV6_ADDR_MULTICAST)
d8d1f30b 1912 rt->dst.input = ip6_mc_input;
ab79ad14
MŻ		 1913 else if (cfg->fc_flags & RTF_LOCAL)
1914 rt->dst.input = ip6_input;
1da177e4 1915 else
d8d1f30b 1916 rt->dst.input = ip6_forward;
1da177e4 1917
d8d1f30b 1918 rt->dst.output = ip6_output;
1da177e4 1919
19e42e45
RP		 1920 if (cfg->fc_encap) {
1921 struct lwtunnel_state *lwtstate;
1922
30357d7d 1923 err = lwtunnel_build_state(cfg->fc_encap_type,
127eb7cd
TH		 1924 cfg->fc_encap, AF_INET6, cfg,
1925 &lwtstate);
19e42e45
RP		 1926 if (err)
1927 goto out;
61adedf3
JB		 1928 rt->dst.lwtstate = lwtstate_get(lwtstate);
1929 if (lwtunnel_output_redirect(rt->dst.lwtstate)) {
1930 rt->dst.lwtstate->orig_output = rt->dst.output;
1931 rt->dst.output = lwtunnel_output;
25368623 1932 }
61adedf3
JB		 1933 if (lwtunnel_input_redirect(rt->dst.lwtstate)) {
1934 rt->dst.lwtstate->orig_input = rt->dst.input;
1935 rt->dst.input = lwtunnel_input;
25368623 1936 }
19e42e45
RP		 1937 }
1938
86872cb5
TG		 1939 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1940 rt->rt6i_dst.plen = cfg->fc_dst_len;
afc4eef8 1941 if (rt->rt6i_dst.plen == 128)
e5fd387a 1942 rt->dst.flags |= DST_HOST;
e5fd387a 1943
1da177e4 1944#ifdef CONFIG_IPV6_SUBTREES
86872cb5
TG		 1945 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1946 rt->rt6i_src.plen = cfg->fc_src_len;
1da177e4
LT		 1947#endif
1948
86872cb5 1949 rt->rt6i_metric = cfg->fc_metric;
1da177e4
LT		 1950
1951 /* We cannot add true routes via loopback here,
1952 they would result in kernel looping; promote them to reject routes
1953 */
86872cb5 1954 if ((cfg->fc_flags & RTF_REJECT) ||
38308473
DM		 1955 (dev && (dev->flags & IFF_LOOPBACK) &&
1956 !(addr_type & IPV6_ADDR_LOOPBACK) &&
1957 !(cfg->fc_flags & RTF_LOCAL))) {
1da177e4 1958 /* hold loopback dev/idev if we haven't done so. */
5578689a 1959 if (dev != net->loopback_dev) {
1da177e4
LT		 1960 if (dev) {
1961 dev_put(dev);
1962 in6_dev_put(idev);
1963 }
5578689a 1964 dev = net->loopback_dev;
1da177e4
LT		 1965 dev_hold(dev);
1966 idev = in6_dev_get(dev);
1967 if (!idev) {
1968 err = -ENODEV;
1969 goto out;
1970 }
1971 }
1da177e4 1972 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
ef2c7d7b
ND		 1973 switch (cfg->fc_type) {
1974 case RTN_BLACKHOLE:
1975 rt->dst.error = -EINVAL;
ede2059d 1976 rt->dst.output = dst_discard_out;
7150aede 1977 rt->dst.input = dst_discard;
ef2c7d7b
ND		 1978 break;
1979 case RTN_PROHIBIT:
1980 rt->dst.error = -EACCES;
7150aede
K		 1981 rt->dst.output = ip6_pkt_prohibit_out;
1982 rt->dst.input = ip6_pkt_prohibit;
ef2c7d7b 1983 break;
b4949ab2 1984 case RTN_THROW:
0315e382 1985 case RTN_UNREACHABLE:
ef2c7d7b 1986 default:
7150aede 1987 rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
0315e382
NF		 1988 : (cfg->fc_type == RTN_UNREACHABLE)
1989 ? -EHOSTUNREACH : -ENETUNREACH;
7150aede
K		 1990 rt->dst.output = ip6_pkt_discard_out;
1991 rt->dst.input = ip6_pkt_discard;
ef2c7d7b
ND		 1992 break;
1993 }
1da177e4
LT		 1994 goto install_route;
1995 }
1996
86872cb5 1997 if (cfg->fc_flags & RTF_GATEWAY) {
b71d1d42 1998 const struct in6_addr *gw_addr;
1da177e4
LT		 1999 int gwa_type;
2000
86872cb5 2001 gw_addr = &cfg->fc_gateway;
330567b7 2002 gwa_type = ipv6_addr_type(gw_addr);
48ed7b26
FW		 2003
2004 /* if gw_addr is local we will fail to detect this in case
2005 * address is still TENTATIVE (DAD in progress). rt6_lookup()
2006 * will return already-added prefix route via interface that
2007 * prefix route was assigned to, which might be non-loopback.
2008 */
2009 err = -EINVAL;
330567b7
FW		 2010 if (ipv6_chk_addr_and_flags(net, gw_addr,
2011 gwa_type & IPV6_ADDR_LINKLOCAL ?
2012 dev : NULL, 0, 0))
48ed7b26
FW		 2013 goto out;
2014
4e3fd7a0 2015 rt->rt6i_gateway = *gw_addr;
1da177e4
LT		 2016
2017 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
8c14586f 2018 struct rt6_info *grt = NULL;
1da177e4
LT		 2019
2020 /* IPv6 strictly inhibits using not link-local
2021 addresses as nexthop address.
2022 Otherwise, router will not able to send redirects.
2023 It is very good, but in some (rare!) circumstances
2024 (SIT, PtP, NBMA NOARP links) it is handy to allow
2025 some exceptions. --ANK
96d5822c
EN		 2026 We allow IPv4-mapped nexthops to support RFC4798-type
2027 addressing
1da177e4 2028 */
96d5822c
EN		 2029 if (!(gwa_type & (IPV6_ADDR_UNICAST |
2030 IPV6_ADDR_MAPPED)))
1da177e4
LT		 2031 goto out;
2032
a435a07f 2033 if (cfg->fc_table) {
8c14586f
DA		 2034 grt = ip6_nh_lookup_table(net, cfg, gw_addr);
2035
a435a07f
VB		 2036 if (grt) {
2037 if (grt->rt6i_flags & RTF_GATEWAY ||
2038 (dev && dev != grt->dst.dev)) {
2039 ip6_rt_put(grt);
2040 grt = NULL;
2041 }
2042 }
2043 }
2044
8c14586f
DA		 2045 if (!grt)
2046 grt = rt6_lookup(net, gw_addr, NULL,
2047 cfg->fc_ifindex, 1);
1da177e4
LT		 2048
2049 err = -EHOSTUNREACH;
38308473 2050 if (!grt)
1da177e4
LT		 2051 goto out;
2052 if (dev) {
d1918542 2053 if (dev != grt->dst.dev) {
94e187c0 2054 ip6_rt_put(grt);
1da177e4
LT		 2055 goto out;
2056 }
2057 } else {
d1918542 2058 dev = grt->dst.dev;
1da177e4
LT		 2059 idev = grt->rt6i_idev;
2060 dev_hold(dev);
2061 in6_dev_hold(grt->rt6i_idev);
2062 }
38308473 2063 if (!(grt->rt6i_flags & RTF_GATEWAY))
1da177e4 2064 err = 0;
94e187c0 2065 ip6_rt_put(grt);
1da177e4
LT		 2066
2067 if (err)
2068 goto out;
2069 }
2070 err = -EINVAL;
38308473 2071 if (!dev || (dev->flags & IFF_LOOPBACK))
1da177e4
LT		 2072 goto out;
2073 }
2074
2075 err = -ENODEV;
38308473 2076 if (!dev)
1da177e4
LT		 2077 goto out;
2078
c3968a85
DW		 2079 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
2080 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
2081 err = -EINVAL;
2082 goto out;
2083 }
4e3fd7a0 2084 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
c3968a85
DW		 2085 rt->rt6i_prefsrc.plen = 128;
2086 } else
2087 rt->rt6i_prefsrc.plen = 0;
2088
86872cb5 2089 rt->rt6i_flags = cfg->fc_flags;
1da177e4
LT		 2090
2091install_route:
d8d1f30b 2092 rt->dst.dev = dev;
1da177e4 2093 rt->rt6i_idev = idev;
c71099ac 2094 rt->rt6i_table = table;
63152fc0 2095
c346dca1 2096 cfg->fc_nlinfo.nl_net = dev_net(dev);
63152fc0 2097
8c5b83f0 2098 return rt;
6b9ea5a6
RP		 2099out:
2100 if (dev)
2101 dev_put(dev);
2102 if (idev)
2103 in6_dev_put(idev);
2104 if (rt)
2105 dst_free(&rt->dst);
2106
8c5b83f0 2107 return ERR_PTR(err);
6b9ea5a6
RP		 2108}
2109
2110int ip6_route_add(struct fib6_config *cfg)
2111{
2112 struct mx6_config mxc = { .mx = NULL, };
8c5b83f0 2113 struct rt6_info *rt;
6b9ea5a6
RP		 2114 int err;
2115
8c5b83f0
RP		 2116 rt = ip6_route_info_create(cfg);
2117 if (IS_ERR(rt)) {
2118 err = PTR_ERR(rt);
2119 rt = NULL;
6b9ea5a6 2120 goto out;
8c5b83f0 2121 }
6b9ea5a6 2122
e715b6d3
FW		 2123 err = ip6_convert_metrics(&mxc, cfg);
2124 if (err)
2125 goto out;
1da177e4 2126
e715b6d3
FW		 2127 err = __ip6_ins_rt(rt, &cfg->fc_nlinfo, &mxc);
2128
2129 kfree(mxc.mx);
6b9ea5a6 2130
e715b6d3 2131 return err;
1da177e4 2132out:
1da177e4 2133 if (rt)
d8d1f30b 2134 dst_free(&rt->dst);
6b9ea5a6 2135
1da177e4
LT		 2136 return err;
2137}
2138
86872cb5 2139static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 2140{
2141 int err;
c71099ac 2142 struct fib6_table *table;
d1918542 2143 struct net *net = dev_net(rt->dst.dev);
1da177e4 2144
8e3d5be7
MKL		 2145 if (rt == net->ipv6.ip6_null_entry ||
2146 rt->dst.flags & DST_NOCACHE) {
6825a26c
G		 2147 err = -ENOENT;
2148 goto out;
2149 }
6c813a72 2150
c71099ac
TG		 2151 table = rt->rt6i_table;
2152 write_lock_bh(&table->tb6_lock);
86872cb5 2153 err = fib6_del(rt, info);
c71099ac 2154 write_unlock_bh(&table->tb6_lock);
1da177e4 2155
6825a26c 2156out:
94e187c0 2157 ip6_rt_put(rt);
1da177e4
LT		 2158 return err;
2159}
2160
e0a1ad73
TG		 2161int ip6_del_rt(struct rt6_info *rt)
2162{
4d1169c1 2163 struct nl_info info = {
d1918542 2164 .nl_net = dev_net(rt->dst.dev),
4d1169c1 2165 };
528c4ceb 2166 return __ip6_del_rt(rt, &info);
e0a1ad73
TG		 2167}
2168
0ae81335
DA		 2169static int __ip6_del_rt_siblings(struct rt6_info *rt, struct fib6_config *cfg)
2170{
2171 struct nl_info *info = &cfg->fc_nlinfo;
e3330039 2172 struct net *net = info->nl_net;
16a16cd3 2173 struct sk_buff *skb = NULL;
0ae81335 2174 struct fib6_table *table;
e3330039 2175 int err = -ENOENT;
0ae81335 2176
e3330039
WC		 2177 if (rt == net->ipv6.ip6_null_entry)
2178 goto out_put;
0ae81335
DA		 2179 table = rt->rt6i_table;
2180 write_lock_bh(&table->tb6_lock);
2181
2182 if (rt->rt6i_nsiblings && cfg->fc_delete_all_nh) {
2183 struct rt6_info *sibling, *next_sibling;
2184
16a16cd3
DA		 2185 /* prefer to send a single notification with all hops */
2186 skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
2187 if (skb) {
2188 u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2189
e3330039 2190 if (rt6_fill_node(net, skb, rt,
16a16cd3
DA		 2191 NULL, NULL, 0, RTM_DELROUTE,
2192 info->portid, seq, 0) < 0) {
2193 kfree_skb(skb);
2194 skb = NULL;
2195 } else
2196 info->skip_notify = 1;
2197 }
2198
0ae81335
DA		 2199 list_for_each_entry_safe(sibling, next_sibling,
2200 &rt->rt6i_siblings,
2201 rt6i_siblings) {
2202 err = fib6_del(sibling, info);
2203 if (err)
e3330039 2204 goto out_unlock;
0ae81335
DA		 2205 }
2206 }
2207
2208 err = fib6_del(rt, info);
e3330039 2209out_unlock:
0ae81335 2210 write_unlock_bh(&table->tb6_lock);
e3330039 2211out_put:
0ae81335 2212 ip6_rt_put(rt);
16a16cd3
DA		 2213
2214 if (skb) {
e3330039 2215 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
16a16cd3
DA		 2216 info->nlh, gfp_any());
2217 }
0ae81335
DA		 2218 return err;
2219}
2220
86872cb5 2221static int ip6_route_del(struct fib6_config *cfg)
1da177e4 2222{
c71099ac 2223 struct fib6_table *table;
1da177e4
LT		 2224 struct fib6_node *fn;
2225 struct rt6_info *rt;
2226 int err = -ESRCH;
2227
5578689a 2228 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
38308473 2229 if (!table)
c71099ac
TG		 2230 return err;
2231
2232 read_lock_bh(&table->tb6_lock);
1da177e4 2233
c71099ac 2234 fn = fib6_locate(&table->tb6_root,
86872cb5
TG		 2235 &cfg->fc_dst, cfg->fc_dst_len,
2236 &cfg->fc_src, cfg->fc_src_len);
1ab1457c 2237
1da177e4 2238 if (fn) {
d8d1f30b 2239 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1f56a01f
MKL		 2240 if ((rt->rt6i_flags & RTF_CACHE) &&
2241 !(cfg->fc_flags & RTF_CACHE))
2242 continue;
86872cb5 2243 if (cfg->fc_ifindex &&
d1918542
DM		 2244 (!rt->dst.dev ||
2245 rt->dst.dev->ifindex != cfg->fc_ifindex))
1da177e4 2246 continue;
86872cb5
TG		 2247 if (cfg->fc_flags & RTF_GATEWAY &&
2248 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1da177e4 2249 continue;
86872cb5 2250 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1da177e4 2251 continue;
c2ed1880
M		 2252 if (cfg->fc_protocol && cfg->fc_protocol != rt->rt6i_protocol)
2253 continue;
d8d1f30b 2254 dst_hold(&rt->dst);
c71099ac 2255 read_unlock_bh(&table->tb6_lock);
1da177e4 2256
0ae81335
DA		 2257 /* if gateway was specified only delete the one hop */
2258 if (cfg->fc_flags & RTF_GATEWAY)
2259 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
2260
2261 return __ip6_del_rt_siblings(rt, cfg);
1da177e4
LT		 2262 }
2263 }
c71099ac 2264 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 2265
2266 return err;
2267}
2268
6700c270 2269static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
a6279458 2270{
a6279458 2271 struct netevent_redirect netevent;
e8599ff4 2272 struct rt6_info *rt, *nrt = NULL;
e8599ff4
DM		 2273 struct ndisc_options ndopts;
2274 struct inet6_dev *in6_dev;
2275 struct neighbour *neigh;
71bcdba0 2276 struct rd_msg *msg;
6e157b6a
DM		 2277 int optlen, on_link;
2278 u8 *lladdr;
e8599ff4 2279
29a3cad5 2280 optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
71bcdba0 2281 optlen -= sizeof(*msg);
e8599ff4
DM		 2282
2283 if (optlen < 0) {
6e157b6a 2284 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
e8599ff4
DM		 2285 return;
2286 }
2287
71bcdba0 2288 msg = (struct rd_msg *)icmp6_hdr(skb);
e8599ff4 2289
71bcdba0 2290 if (ipv6_addr_is_multicast(&msg->dest)) {
6e157b6a 2291 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
e8599ff4
DM		 2292 return;
2293 }
2294
6e157b6a 2295 on_link = 0;
71bcdba0 2296 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
e8599ff4 2297 on_link = 1;
71bcdba0 2298 } else if (ipv6_addr_type(&msg->target) !=
e8599ff4 2299 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
6e157b6a 2300 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
e8599ff4
DM		 2301 return;
2302 }
2303
2304 in6_dev = __in6_dev_get(skb->dev);
2305 if (!in6_dev)
2306 return;
2307 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
2308 return;
2309
2310 /* RFC2461 8.1:
2311 * The IP source address of the Redirect MUST be the same as the current
2312 * first-hop router for the specified ICMP Destination Address.
2313 */
2314
f997c55c 2315 if (!ndisc_parse_options(skb->dev, msg->opt, optlen, &ndopts)) {
e8599ff4
DM		 2316 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
2317 return;
2318 }
6e157b6a
DM		 2319
2320 lladdr = NULL;
e8599ff4
DM		 2321 if (ndopts.nd_opts_tgt_lladdr) {
2322 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
2323 skb->dev);
2324 if (!lladdr) {
2325 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
2326 return;
2327 }
2328 }
2329
6e157b6a 2330 rt = (struct rt6_info *) dst;
ec13ad1d 2331 if (rt->rt6i_flags & RTF_REJECT) {
6e157b6a 2332 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
e8599ff4 2333 return;
6e157b6a 2334 }
e8599ff4 2335
6e157b6a
DM		 2336 /* Redirect received -> path was valid.
2337 * Look, redirects are sent only in response to data packets,
2338 * so that this nexthop apparently is reachable. --ANK
2339 */
0dec879f 2340 dst_confirm_neigh(&rt->dst, &ipv6_hdr(skb)->saddr);
a6279458 2341
71bcdba0 2342 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
6e157b6a
DM		 2343 if (!neigh)
2344 return;
a6279458 2345
1da177e4
LT		 2346 /*
2347 * We have finally decided to accept it.
2348 */
2349
f997c55c 2350 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
1da177e4
LT		 2351 NEIGH_UPDATE_F_WEAK_OVERRIDE|
2352 NEIGH_UPDATE_F_OVERRIDE|
2353 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
f997c55c
AA		 2354 NEIGH_UPDATE_F_ISROUTER)),
2355 NDISC_REDIRECT, &ndopts);
1da177e4 2356
83a09abd 2357 nrt = ip6_rt_cache_alloc(rt, &msg->dest, NULL);
38308473 2358 if (!nrt)
1da177e4
LT		 2359 goto out;
2360
2361 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
2362 if (on_link)
2363 nrt->rt6i_flags &= ~RTF_GATEWAY;
2364
4e3fd7a0 2365 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1da177e4 2366
40e22e8f 2367 if (ip6_ins_rt(nrt))
1da177e4
LT		 2368 goto out;
2369
d8d1f30b
CG		 2370 netevent.old = &rt->dst;
2371 netevent.new = &nrt->dst;
71bcdba0 2372 netevent.daddr = &msg->dest;
60592833 2373 netevent.neigh = neigh;
8d71740c
TT		 2374 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
2375
38308473 2376 if (rt->rt6i_flags & RTF_CACHE) {
6e157b6a 2377 rt = (struct rt6_info *) dst_clone(&rt->dst);
e0a1ad73 2378 ip6_del_rt(rt);
1da177e4
LT		 2379 }
2380
2381out:
e8599ff4 2382 neigh_release(neigh);
6e157b6a
DM		 2383}
2384
1da177e4
LT		 2385/*
2386 * Misc support functions
2387 */
2388
4b32b5ad
MKL		 2389static void rt6_set_from(struct rt6_info *rt, struct rt6_info *from)
2390{
2391 BUG_ON(from->dst.from);
2392
2393 rt->rt6i_flags &= ~RTF_EXPIRES;
2394 dst_hold(&from->dst);
2395 rt->dst.from = &from->dst;
2396 dst_init_metrics(&rt->dst, dst_metrics_ptr(&from->dst), true);
2397}
2398
83a09abd
MKL		 2399static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort)
2400{
2401 rt->dst.input = ort->dst.input;
2402 rt->dst.output = ort->dst.output;
2403 rt->rt6i_dst = ort->rt6i_dst;
2404 rt->dst.error = ort->dst.error;
2405 rt->rt6i_idev = ort->rt6i_idev;
2406 if (rt->rt6i_idev)
2407 in6_dev_hold(rt->rt6i_idev);
2408 rt->dst.lastuse = jiffies;
2409 rt->rt6i_gateway = ort->rt6i_gateway;
2410 rt->rt6i_flags = ort->rt6i_flags;
2411 rt6_set_from(rt, ort);
2412 rt->rt6i_metric = ort->rt6i_metric;
1da177e4 2413#ifdef CONFIG_IPV6_SUBTREES
83a09abd 2414 rt->rt6i_src = ort->rt6i_src;
1da177e4 2415#endif
83a09abd
MKL		 2416 rt->rt6i_prefsrc = ort->rt6i_prefsrc;
2417 rt->rt6i_table = ort->rt6i_table;
61adedf3 2418 rt->dst.lwtstate = lwtstate_get(ort->dst.lwtstate);
1da177e4
LT		 2419}
2420
70ceb4f5 2421#ifdef CONFIG_IPV6_ROUTE_INFO
efa2cea0 2422static struct rt6_info *rt6_get_route_info(struct net *net,
b71d1d42 2423 const struct in6_addr *prefix, int prefixlen,
830218c1
DA		 2424 const struct in6_addr *gwaddr,
2425 struct net_device *dev)
70ceb4f5 2426{
830218c1
DA		 2427 u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO;
2428 int ifindex = dev->ifindex;
70ceb4f5
YH		 2429 struct fib6_node *fn;
2430 struct rt6_info *rt = NULL;
c71099ac
TG		 2431 struct fib6_table *table;
2432
830218c1 2433 table = fib6_get_table(net, tb_id);
38308473 2434 if (!table)
c71099ac 2435 return NULL;
70ceb4f5 2436
5744dd9b 2437 read_lock_bh(&table->tb6_lock);
67ba4152 2438 fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);
70ceb4f5
YH		 2439 if (!fn)
2440 goto out;
2441
d8d1f30b 2442 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
d1918542 2443 if (rt->dst.dev->ifindex != ifindex)
70ceb4f5
YH		 2444 continue;
2445 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
2446 continue;
2447 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
2448 continue;
d8d1f30b 2449 dst_hold(&rt->dst);
70ceb4f5
YH		 2450 break;
2451 }
2452out:
5744dd9b 2453 read_unlock_bh(&table->tb6_lock);
70ceb4f5
YH		 2454 return rt;
2455}
2456
efa2cea0 2457static struct rt6_info *rt6_add_route_info(struct net *net,
b71d1d42 2458 const struct in6_addr *prefix, int prefixlen,
830218c1
DA		 2459 const struct in6_addr *gwaddr,
2460 struct net_device *dev,
95c96174 2461 unsigned int pref)
70ceb4f5 2462{
86872cb5 2463 struct fib6_config cfg = {
238fc7ea 2464 .fc_metric = IP6_RT_PRIO_USER,
830218c1 2465 .fc_ifindex = dev->ifindex,
86872cb5
TG		 2466 .fc_dst_len = prefixlen,
2467 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
2468 RTF_UP | RTF_PREF(pref),
15e47304 2469 .fc_nlinfo.portid = 0,
efa2cea0
DL		 2470 .fc_nlinfo.nlh = NULL,
2471 .fc_nlinfo.nl_net = net,
86872cb5
TG		 2472 };
2473
830218c1 2474 cfg.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO,
4e3fd7a0
AD		 2475 cfg.fc_dst = *prefix;
2476 cfg.fc_gateway = *gwaddr;
70ceb4f5 2477
e317da96
YH		 2478 /* We should treat it as a default route if prefix length is 0. */
2479 if (!prefixlen)
86872cb5 2480 cfg.fc_flags |= RTF_DEFAULT;
70ceb4f5 2481
86872cb5 2482 ip6_route_add(&cfg);
70ceb4f5 2483
830218c1 2484 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, dev);
70ceb4f5
YH		 2485}
2486#endif
2487
b71d1d42 2488struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1ab1457c 2489{
830218c1 2490 u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT;
1da177e4 2491 struct rt6_info *rt;
c71099ac 2492 struct fib6_table *table;
1da177e4 2493
830218c1 2494 table = fib6_get_table(dev_net(dev), tb_id);
38308473 2495 if (!table)
c71099ac 2496 return NULL;
1da177e4 2497
5744dd9b 2498 read_lock_bh(&table->tb6_lock);
67ba4152 2499 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
d1918542 2500 if (dev == rt->dst.dev &&
045927ff 2501 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1da177e4
LT		 2502 ipv6_addr_equal(&rt->rt6i_gateway, addr))
2503 break;
2504 }
2505 if (rt)
d8d1f30b 2506 dst_hold(&rt->dst);
5744dd9b 2507 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 2508 return rt;
2509}
2510
b71d1d42 2511struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
ebacaaa0
YH		 2512 struct net_device *dev,
2513 unsigned int pref)
1da177e4 2514{
86872cb5 2515 struct fib6_config cfg = {
ca254490 2516 .fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT,
238fc7ea 2517 .fc_metric = IP6_RT_PRIO_USER,
86872cb5
TG		 2518 .fc_ifindex = dev->ifindex,
2519 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
2520 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
15e47304 2521 .fc_nlinfo.portid = 0,
5578689a 2522 .fc_nlinfo.nlh = NULL,
c346dca1 2523 .fc_nlinfo.nl_net = dev_net(dev),
86872cb5 2524 };
1da177e4 2525
4e3fd7a0 2526 cfg.fc_gateway = *gwaddr;
1da177e4 2527
830218c1
DA		 2528 if (!ip6_route_add(&cfg)) {
2529 struct fib6_table *table;
2530
2531 table = fib6_get_table(dev_net(dev), cfg.fc_table);
2532 if (table)
2533 table->flags |= RT6_TABLE_HAS_DFLT_ROUTER;
2534 }
1da177e4 2535
1da177e4
LT		 2536 return rt6_get_dflt_router(gwaddr, dev);
2537}
2538
830218c1 2539static void __rt6_purge_dflt_routers(struct fib6_table *table)
1da177e4
LT		 2540{
2541 struct rt6_info *rt;
2542
2543restart:
c71099ac 2544 read_lock_bh(&table->tb6_lock);
d8d1f30b 2545 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
3e8b0ac3
LC		 2546 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2547 (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
d8d1f30b 2548 dst_hold(&rt->dst);
c71099ac 2549 read_unlock_bh(&table->tb6_lock);
e0a1ad73 2550 ip6_del_rt(rt);
1da177e4
LT		 2551 goto restart;
2552 }
2553 }
c71099ac 2554 read_unlock_bh(&table->tb6_lock);
830218c1
DA		 2555
2556 table->flags &= ~RT6_TABLE_HAS_DFLT_ROUTER;
2557}
2558
2559void rt6_purge_dflt_routers(struct net *net)
2560{
2561 struct fib6_table *table;
2562 struct hlist_head *head;
2563 unsigned int h;
2564
2565 rcu_read_lock();
2566
2567 for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
2568 head = &net->ipv6.fib_table_hash[h];
2569 hlist_for_each_entry_rcu(table, head, tb6_hlist) {
2570 if (table->flags & RT6_TABLE_HAS_DFLT_ROUTER)
2571 __rt6_purge_dflt_routers(table);
2572 }
2573 }
2574
2575 rcu_read_unlock();
1da177e4
LT		 2576}
2577
5578689a
DL		 2578static void rtmsg_to_fib6_config(struct net *net,
2579 struct in6_rtmsg *rtmsg,
86872cb5
TG		 2580 struct fib6_config *cfg)
2581{
2582 memset(cfg, 0, sizeof(*cfg));
2583
ca254490
DA		 2584 cfg->fc_table = l3mdev_fib_table_by_index(net, rtmsg->rtmsg_ifindex) ?
2585 : RT6_TABLE_MAIN;
86872cb5
TG		 2586 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2587 cfg->fc_metric = rtmsg->rtmsg_metric;
2588 cfg->fc_expires = rtmsg->rtmsg_info;
2589 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2590 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2591 cfg->fc_flags = rtmsg->rtmsg_flags;
2592
5578689a 2593 cfg->fc_nlinfo.nl_net = net;
f1243c2d 2594
4e3fd7a0
AD		 2595 cfg->fc_dst = rtmsg->rtmsg_dst;
2596 cfg->fc_src = rtmsg->rtmsg_src;
2597 cfg->fc_gateway = rtmsg->rtmsg_gateway;
86872cb5
TG		 2598}
2599
5578689a 2600int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1da177e4 2601{
86872cb5 2602 struct fib6_config cfg;
1da177e4
LT		 2603 struct in6_rtmsg rtmsg;
2604 int err;
2605
67ba4152 2606 switch (cmd) {
1da177e4
LT		 2607 case SIOCADDRT: /* Add a route */
2608 case SIOCDELRT: /* Delete a route */
af31f412 2609 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1da177e4
LT		 2610 return -EPERM;
2611 err = copy_from_user(&rtmsg, arg,
2612 sizeof(struct in6_rtmsg));
2613 if (err)
2614 return -EFAULT;
86872cb5 2615
5578689a 2616 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
86872cb5 2617
1da177e4
LT		 2618 rtnl_lock();
2619 switch (cmd) {
2620 case SIOCADDRT:
86872cb5 2621 err = ip6_route_add(&cfg);
1da177e4
LT		 2622 break;
2623 case SIOCDELRT:
86872cb5 2624 err = ip6_route_del(&cfg);
1da177e4
LT		 2625 break;
2626 default:
2627 err = -EINVAL;
2628 }
2629 rtnl_unlock();
2630
2631 return err;
3ff50b79 2632 }
1da177e4
LT		 2633
2634 return -EINVAL;
2635}
2636
2637/*
2638 * Drop the packet on the floor
2639 */
2640
d5fdd6ba 2641static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
1da177e4 2642{
612f09e8 2643 int type;
adf30907 2644 struct dst_entry *dst = skb_dst(skb);
612f09e8
YH		 2645 switch (ipstats_mib_noroutes) {
2646 case IPSTATS_MIB_INNOROUTES:
0660e03f 2647 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
45bb0060 2648 if (type == IPV6_ADDR_ANY) {
3bd653c8
DL		 2649 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2650 IPSTATS_MIB_INADDRERRORS);
612f09e8
YH		 2651 break;
2652 }
2653 /* FALLTHROUGH */
2654 case IPSTATS_MIB_OUTNOROUTES:
3bd653c8
DL		 2655 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2656 ipstats_mib_noroutes);
612f09e8
YH		 2657 break;
2658 }
3ffe533c 2659 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
1da177e4
LT		 2660 kfree_skb(skb);
2661 return 0;
2662}
2663
9ce8ade0
TG		 2664static int ip6_pkt_discard(struct sk_buff *skb)
2665{
612f09e8 2666 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
9ce8ade0
TG		 2667}
2668
ede2059d 2669static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb)
1da177e4 2670{
adf30907 2671 skb->dev = skb_dst(skb)->dev;
612f09e8 2672 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
1da177e4
LT		 2673}
2674
9ce8ade0
TG		 2675static int ip6_pkt_prohibit(struct sk_buff *skb)
2676{
612f09e8 2677 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
9ce8ade0
TG		 2678}
2679
ede2059d 2680static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb)
9ce8ade0 2681{
adf30907 2682 skb->dev = skb_dst(skb)->dev;
612f09e8 2683 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
9ce8ade0
TG		 2684}
2685
1da177e4
LT		 2686/*
2687 * Allocate a dst for local (unicast / anycast) address.
2688 */
2689
2690struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2691 const struct in6_addr *addr,
8f031519 2692 bool anycast)
1da177e4 2693{
ca254490 2694 u32 tb_id;
c346dca1 2695 struct net *net = dev_net(idev->dev);
5f02ce24
DA		 2696 struct net_device *dev = net->loopback_dev;
2697 struct rt6_info *rt;
2698
2699 /* use L3 Master device as loopback for host routes if device
2700 * is enslaved and address is not link local or multicast
2701 */
2702 if (!rt6_need_strict(addr))
2703 dev = l3mdev_master_dev_rcu(idev->dev) ? : dev;
2704
2705 rt = ip6_dst_alloc(net, dev, DST_NOCOUNT);
a3300ef4 2706 if (!rt)
1da177e4
LT		 2707 return ERR_PTR(-ENOMEM);
2708
1da177e4
LT		 2709 in6_dev_hold(idev);
2710
11d53b49 2711 rt->dst.flags |= DST_HOST;
d8d1f30b
CG		 2712 rt->dst.input = ip6_input;
2713 rt->dst.output = ip6_output;
1da177e4 2714 rt->rt6i_idev = idev;
1da177e4 2715
94b5e0f9 2716 rt->rt6i_protocol = RTPROT_KERNEL;
1da177e4 2717 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
58c4fb86
YH		 2718 if (anycast)
2719 rt->rt6i_flags |= RTF_ANYCAST;
2720 else
1da177e4 2721 rt->rt6i_flags |= RTF_LOCAL;
1da177e4 2722
550bab42 2723 rt->rt6i_gateway = *addr;
4e3fd7a0 2724 rt->rt6i_dst.addr = *addr;
1da177e4 2725 rt->rt6i_dst.plen = 128;
ca254490
DA		 2726 tb_id = l3mdev_fib_table(idev->dev) ? : RT6_TABLE_LOCAL;
2727 rt->rt6i_table = fib6_get_table(net, tb_id);
8e3d5be7 2728 rt->dst.flags |= DST_NOCACHE;
1da177e4 2729
d8d1f30b 2730 atomic_set(&rt->dst.__refcnt, 1);
1da177e4
LT		 2731
2732 return rt;
2733}
2734
c3968a85
DW		 2735/* remove deleted ip from prefsrc entries */
2736struct arg_dev_net_ip {
2737 struct net_device *dev;
2738 struct net *net;
2739 struct in6_addr *addr;
2740};
2741
2742static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2743{
2744 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2745 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2746 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2747
d1918542 2748 if (((void *)rt->dst.dev == dev || !dev) &&
c3968a85
DW		 2749 rt != net->ipv6.ip6_null_entry &&
2750 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2751 /* remove prefsrc entry */
2752 rt->rt6i_prefsrc.plen = 0;
2753 }
2754 return 0;
2755}
2756
2757void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2758{
2759 struct net *net = dev_net(ifp->idev->dev);
2760 struct arg_dev_net_ip adni = {
2761 .dev = ifp->idev->dev,
2762 .net = net,
2763 .addr = &ifp->addr,
2764 };
0c3584d5 2765 fib6_clean_all(net, fib6_remove_prefsrc, &adni);
c3968a85
DW		 2766}
2767
be7a010d
DJ		 2768#define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2769#define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)
2770
2771/* Remove routers and update dst entries when gateway turn into host. */
2772static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
2773{
2774 struct in6_addr *gateway = (struct in6_addr *)arg;
2775
2776 if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
2777 ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
2778 ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
2779 return -1;
2780 }
2781 return 0;
2782}
2783
2784void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
2785{
2786 fib6_clean_all(net, fib6_clean_tohost, gateway);
2787}
2788
8ed67789
DL		 2789struct arg_dev_net {
2790 struct net_device *dev;
2791 struct net *net;
2792};
2793
a1a22c12 2794/* called with write lock held for table with rt */
1da177e4
LT		 2795static int fib6_ifdown(struct rt6_info *rt, void *arg)
2796{
bc3ef660 2797 const struct arg_dev_net *adn = arg;
2798 const struct net_device *dev = adn->dev;
8ed67789 2799
d1918542 2800 if ((rt->dst.dev == dev || !dev) &&
a1a22c12
DA		 2801 rt != adn->net->ipv6.ip6_null_entry &&
2802 (rt->rt6i_nsiblings == 0 ||
2803 !rt->rt6i_idev->cnf.ignore_routes_with_linkdown))
1da177e4 2804 return -1;
c159d30c 2805
1da177e4
LT		 2806 return 0;
2807}
2808
f3db4851 2809void rt6_ifdown(struct net *net, struct net_device *dev)
1da177e4 2810{
8ed67789
DL		 2811 struct arg_dev_net adn = {
2812 .dev = dev,
2813 .net = net,
2814 };
2815
0c3584d5 2816 fib6_clean_all(net, fib6_ifdown, &adn);
1e493d19 2817 icmp6_clean_all(fib6_ifdown, &adn);
e332bc67
EB		 2818 if (dev)
2819 rt6_uncached_list_flush_dev(net, dev);
1da177e4
LT		 2820}
2821
95c96174 2822struct rt6_mtu_change_arg {
1da177e4 2823 struct net_device *dev;
95c96174 2824 unsigned int mtu;
1da177e4
LT		 2825};
2826
2827static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2828{
2829 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2830 struct inet6_dev *idev;
2831
2832 /* In IPv6 pmtu discovery is not optional,
2833 so that RTAX_MTU lock cannot disable it.
2834 We still use this lock to block changes
2835 caused by addrconf/ndisc.
2836 */
2837
2838 idev = __in6_dev_get(arg->dev);
38308473 2839 if (!idev)
1da177e4
LT		 2840 return 0;
2841
2842 /* For administrative MTU increase, there is no way to discover
2843 IPv6 PMTU increase, so PMTU increase should be updated here.
2844 Since RFC 1981 doesn't include administrative MTU increase
2845 update PMTU increase is a MUST. (i.e. jumbo frame)
2846 */
2847 /*
2848 If new MTU is less than route PMTU, this new MTU will be the
2849 lowest MTU in the path, update the route PMTU to reflect PMTU
2850 decreases; if new MTU is greater than route PMTU, and the
2851 old MTU is the lowest MTU in the path, update the route PMTU
2852 to reflect the increase. In this case if the other nodes' MTU
2853 also have the lowest MTU, TOO BIG MESSAGE will be lead to
67c408cf 2854 PMTU discovery.
1da177e4 2855 */
d1918542 2856 if (rt->dst.dev == arg->dev &&
fb56be83 2857 dst_metric_raw(&rt->dst, RTAX_MTU) &&
4b32b5ad
MKL		 2858 !dst_metric_locked(&rt->dst, RTAX_MTU)) {
2859 if (rt->rt6i_flags & RTF_CACHE) {
2860 /* For RTF_CACHE with rt6i_pmtu == 0
2861 * (i.e. a redirected route),
2862 * the metrics of its rt->dst.from has already
2863 * been updated.
2864 */
2865 if (rt->rt6i_pmtu && rt->rt6i_pmtu > arg->mtu)
2866 rt->rt6i_pmtu = arg->mtu;
2867 } else if (dst_mtu(&rt->dst) >= arg->mtu ||
2868 (dst_mtu(&rt->dst) < arg->mtu &&
2869 dst_mtu(&rt->dst) == idev->cnf.mtu6)) {
2870 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2871 }
566cfd8f 2872 }
1da177e4
LT		 2873 return 0;
2874}
2875
95c96174 2876void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
1da177e4 2877{
c71099ac
TG		 2878 struct rt6_mtu_change_arg arg = {
2879 .dev = dev,
2880 .mtu = mtu,
2881 };
1da177e4 2882
0c3584d5 2883 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
1da177e4
LT		 2884}
2885
ef7c79ed 2886static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
5176f91e 2887 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
86872cb5 2888 [RTA_OIF] = { .type = NLA_U32 },
ab364a6f 2889 [RTA_IIF] = { .type = NLA_U32 },
86872cb5
TG		 2890 [RTA_PRIORITY] = { .type = NLA_U32 },
2891 [RTA_METRICS] = { .type = NLA_NESTED },
51ebd318 2892 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
c78ba6d6 2893 [RTA_PREF] = { .type = NLA_U8 },
19e42e45
RP		 2894 [RTA_ENCAP_TYPE] = { .type = NLA_U16 },
2895 [RTA_ENCAP] = { .type = NLA_NESTED },
32bc201e 2896 [RTA_EXPIRES] = { .type = NLA_U32 },
622ec2c9 2897 [RTA_UID] = { .type = NLA_U32 },
3b45a410 2898 [RTA_MARK] = { .type = NLA_U32 },
86872cb5
TG		 2899};
2900
2901static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2902 struct fib6_config *cfg)
1da177e4 2903{
86872cb5
TG		 2904 struct rtmsg *rtm;
2905 struct nlattr *tb[RTA_MAX+1];
c78ba6d6 2906 unsigned int pref;
86872cb5 2907 int err;
1da177e4 2908
86872cb5
TG		 2909 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2910 if (err < 0)
2911 goto errout;
1da177e4 2912
86872cb5
TG		 2913 err = -EINVAL;
2914 rtm = nlmsg_data(nlh);
2915 memset(cfg, 0, sizeof(*cfg));
2916
2917 cfg->fc_table = rtm->rtm_table;
2918 cfg->fc_dst_len = rtm->rtm_dst_len;
2919 cfg->fc_src_len = rtm->rtm_src_len;
2920 cfg->fc_flags = RTF_UP;
2921 cfg->fc_protocol = rtm->rtm_protocol;
ef2c7d7b 2922 cfg->fc_type = rtm->rtm_type;
86872cb5 2923
ef2c7d7b
ND		 2924 if (rtm->rtm_type == RTN_UNREACHABLE ||
2925 rtm->rtm_type == RTN_BLACKHOLE ||
b4949ab2
ND		 2926 rtm->rtm_type == RTN_PROHIBIT ||
2927 rtm->rtm_type == RTN_THROW)
86872cb5
TG		 2928 cfg->fc_flags |= RTF_REJECT;
2929
ab79ad14
MŻ		 2930 if (rtm->rtm_type == RTN_LOCAL)
2931 cfg->fc_flags |= RTF_LOCAL;
2932
1f56a01f
MKL		 2933 if (rtm->rtm_flags & RTM_F_CLONED)
2934 cfg->fc_flags |= RTF_CACHE;
2935
15e47304 2936 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
86872cb5 2937 cfg->fc_nlinfo.nlh = nlh;
3b1e0a65 2938 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
86872cb5
TG		 2939
2940 if (tb[RTA_GATEWAY]) {
67b61f6c 2941 cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
86872cb5 2942 cfg->fc_flags |= RTF_GATEWAY;
1da177e4 2943 }
86872cb5
TG		 2944
2945 if (tb[RTA_DST]) {
2946 int plen = (rtm->rtm_dst_len + 7) >> 3;
2947
2948 if (nla_len(tb[RTA_DST]) < plen)
2949 goto errout;
2950
2951 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1da177e4 2952 }
86872cb5
TG		 2953
2954 if (tb[RTA_SRC]) {
2955 int plen = (rtm->rtm_src_len + 7) >> 3;
2956
2957 if (nla_len(tb[RTA_SRC]) < plen)
2958 goto errout;
2959
2960 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1da177e4 2961 }
86872cb5 2962
c3968a85 2963 if (tb[RTA_PREFSRC])
67b61f6c 2964 cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);
c3968a85 2965
86872cb5
TG		 2966 if (tb[RTA_OIF])
2967 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2968
2969 if (tb[RTA_PRIORITY])
2970 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2971
2972 if (tb[RTA_METRICS]) {
2973 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2974 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
1da177e4 2975 }
86872cb5
TG		 2976
2977 if (tb[RTA_TABLE])
2978 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2979
51ebd318
ND		 2980 if (tb[RTA_MULTIPATH]) {
2981 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2982 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
9ed59592
DA		 2983
2984 err = lwtunnel_valid_encap_type_attr(cfg->fc_mp,
2985 cfg->fc_mp_len);
2986 if (err < 0)
2987 goto errout;
51ebd318
ND		 2988 }
2989
c78ba6d6
LR		 2990 if (tb[RTA_PREF]) {
2991 pref = nla_get_u8(tb[RTA_PREF]);
2992 if (pref != ICMPV6_ROUTER_PREF_LOW &&
2993 pref != ICMPV6_ROUTER_PREF_HIGH)
2994 pref = ICMPV6_ROUTER_PREF_MEDIUM;
2995 cfg->fc_flags |= RTF_PREF(pref);
2996 }
2997
19e42e45
RP		 2998 if (tb[RTA_ENCAP])
2999 cfg->fc_encap = tb[RTA_ENCAP];
3000
9ed59592 3001 if (tb[RTA_ENCAP_TYPE]) {
19e42e45
RP		 3002 cfg->fc_encap_type = nla_get_u16(tb[RTA_ENCAP_TYPE]);
3003
9ed59592
DA		 3004 err = lwtunnel_valid_encap_type(cfg->fc_encap_type);
3005 if (err < 0)
3006 goto errout;
3007 }
3008
32bc201e
XL		 3009 if (tb[RTA_EXPIRES]) {
3010 unsigned long timeout = addrconf_timeout_fixup(nla_get_u32(tb[RTA_EXPIRES]), HZ);
3011
3012 if (addrconf_finite_timeout(timeout)) {
3013 cfg->fc_expires = jiffies_to_clock_t(timeout * HZ);
3014 cfg->fc_flags |= RTF_EXPIRES;
3015 }
3016 }
3017
86872cb5
TG		 3018 err = 0;
3019errout:
3020 return err;
1da177e4
LT		 3021}
3022
6b9ea5a6
RP		 3023struct rt6_nh {
3024 struct rt6_info *rt6_info;
3025 struct fib6_config r_cfg;
3026 struct mx6_config mxc;
3027 struct list_head next;
3028};
3029
3030static void ip6_print_replace_route_err(struct list_head *rt6_nh_list)
3031{
3032 struct rt6_nh *nh;
3033
3034 list_for_each_entry(nh, rt6_nh_list, next) {
7d4d5065 3035 pr_warn("IPV6: multipath route replace failed (check consistency of installed routes): %pI6c nexthop %pI6c ifi %d\n",
6b9ea5a6
RP		 3036 &nh->r_cfg.fc_dst, &nh->r_cfg.fc_gateway,
3037 nh->r_cfg.fc_ifindex);
3038 }
3039}
3040
3041static int ip6_route_info_append(struct list_head *rt6_nh_list,
3042 struct rt6_info *rt, struct fib6_config *r_cfg)
3043{
3044 struct rt6_nh *nh;
3045 struct rt6_info *rtnh;
3046 int err = -EEXIST;
3047
3048 list_for_each_entry(nh, rt6_nh_list, next) {
3049 /* check if rt6_info already exists */
3050 rtnh = nh->rt6_info;
3051
3052 if (rtnh->dst.dev == rt->dst.dev &&
3053 rtnh->rt6i_idev == rt->rt6i_idev &&
3054 ipv6_addr_equal(&rtnh->rt6i_gateway,
3055 &rt->rt6i_gateway))
3056 return err;
3057 }
3058
3059 nh = kzalloc(sizeof(*nh), GFP_KERNEL);
3060 if (!nh)
3061 return -ENOMEM;
3062 nh->rt6_info = rt;
3063 err = ip6_convert_metrics(&nh->mxc, r_cfg);
3064 if (err) {
3065 kfree(nh);
3066 return err;
3067 }
3068 memcpy(&nh->r_cfg, r_cfg, sizeof(*r_cfg));
3069 list_add_tail(&nh->next, rt6_nh_list);
3070
3071 return 0;
3072}
3073
3b1137fe
DA		 3074static void ip6_route_mpath_notify(struct rt6_info *rt,
3075 struct rt6_info *rt_last,
3076 struct nl_info *info,
3077 __u16 nlflags)
3078{
3079 /* if this is an APPEND route, then rt points to the first route
3080 * inserted and rt_last points to last route inserted. Userspace
3081 * wants a consistent dump of the route which starts at the first
3082 * nexthop. Since sibling routes are always added at the end of
3083 * the list, find the first sibling of the last route appended
3084 */
3085 if ((nlflags & NLM_F_APPEND) && rt_last && rt_last->rt6i_nsiblings) {
3086 rt = list_first_entry(&rt_last->rt6i_siblings,
3087 struct rt6_info,
3088 rt6i_siblings);
3089 }
3090
3091 if (rt)
3092 inet6_rt_notify(RTM_NEWROUTE, rt, info, nlflags);
3093}
3094
6b9ea5a6 3095static int ip6_route_multipath_add(struct fib6_config *cfg)
51ebd318 3096{
3b1137fe
DA		 3097 struct rt6_info *rt_notif = NULL, *rt_last = NULL;
3098 struct nl_info *info = &cfg->fc_nlinfo;
51ebd318
ND		 3099 struct fib6_config r_cfg;
3100 struct rtnexthop *rtnh;
6b9ea5a6
RP		 3101 struct rt6_info *rt;
3102 struct rt6_nh *err_nh;
3103 struct rt6_nh *nh, *nh_safe;
3b1137fe 3104 __u16 nlflags;
51ebd318
ND		 3105 int remaining;
3106 int attrlen;
6b9ea5a6
RP		 3107 int err = 1;
3108 int nhn = 0;
3109 int replace = (cfg->fc_nlinfo.nlh &&
3110 (cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_REPLACE));
3111 LIST_HEAD(rt6_nh_list);
51ebd318 3112
3b1137fe
DA		 3113 nlflags = replace ? NLM_F_REPLACE : NLM_F_CREATE;
3114 if (info->nlh && info->nlh->nlmsg_flags & NLM_F_APPEND)
3115 nlflags |= NLM_F_APPEND;
3116
35f1b4e9 3117 remaining = cfg->fc_mp_len;
51ebd318 3118 rtnh = (struct rtnexthop *)cfg->fc_mp;
51ebd318 3119
6b9ea5a6
RP		 3120 /* Parse a Multipath Entry and build a list (rt6_nh_list) of
3121 * rt6_info structs per nexthop
3122 */
51ebd318
ND		 3123 while (rtnh_ok(rtnh, remaining)) {
3124 memcpy(&r_cfg, cfg, sizeof(*cfg));
3125 if (rtnh->rtnh_ifindex)
3126 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
3127
3128 attrlen = rtnh_attrlen(rtnh);
3129 if (attrlen > 0) {
3130 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
3131
3132 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
3133 if (nla) {
67b61f6c 3134 r_cfg.fc_gateway = nla_get_in6_addr(nla);
51ebd318
ND		 3135 r_cfg.fc_flags |= RTF_GATEWAY;
3136 }
19e42e45
RP		 3137 r_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
3138 nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
3139 if (nla)
3140 r_cfg.fc_encap_type = nla_get_u16(nla);
51ebd318 3141 }
6b9ea5a6 3142
8c5b83f0
RP		 3143 rt = ip6_route_info_create(&r_cfg);
3144 if (IS_ERR(rt)) {
3145 err = PTR_ERR(rt);
3146 rt = NULL;
6b9ea5a6 3147 goto cleanup;
8c5b83f0 3148 }
6b9ea5a6
RP		 3149
3150 err = ip6_route_info_append(&rt6_nh_list, rt, &r_cfg);
51ebd318 3151 if (err) {
6b9ea5a6
RP		 3152 dst_free(&rt->dst);
3153 goto cleanup;
3154 }
3155
3156 rtnh = rtnh_next(rtnh, &remaining);
3157 }
3158
3b1137fe
DA		 3159 /* for add and replace send one notification with all nexthops.
3160 * Skip the notification in fib6_add_rt2node and send one with
3161 * the full route when done
3162 */
3163 info->skip_notify = 1;
3164
6b9ea5a6
RP		 3165 err_nh = NULL;
3166 list_for_each_entry(nh, &rt6_nh_list, next) {
3b1137fe
DA		 3167 rt_last = nh->rt6_info;
3168 err = __ip6_ins_rt(nh->rt6_info, info, &nh->mxc);
3169 /* save reference to first route for notification */
3170 if (!rt_notif && !err)
3171 rt_notif = nh->rt6_info;
3172
6b9ea5a6
RP		 3173 /* nh->rt6_info is used or freed at this point, reset to NULL*/
3174 nh->rt6_info = NULL;
3175 if (err) {
3176 if (replace && nhn)
3177 ip6_print_replace_route_err(&rt6_nh_list);
3178 err_nh = nh;
3179 goto add_errout;
51ebd318 3180 }
6b9ea5a6 3181
1a72418b 3182 /* Because each route is added like a single route we remove
27596472
MK		 3183 * these flags after the first nexthop: if there is a collision,
3184 * we have already failed to add the first nexthop:
3185 * fib6_add_rt2node() has rejected it; when replacing, old
3186 * nexthops have been replaced by first new, the rest should
3187 * be added to it.
1a72418b 3188 */
27596472
MK		 3189 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
3190 NLM_F_REPLACE);
6b9ea5a6
RP		 3191 nhn++;
3192 }
3193
3b1137fe
DA		 3194 /* success ... tell user about new route */
3195 ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
6b9ea5a6
RP		 3196 goto cleanup;
3197
3198add_errout:
3b1137fe
DA		 3199 /* send notification for routes that were added so that
3200 * the delete notifications sent by ip6_route_del are
3201 * coherent
3202 */
3203 if (rt_notif)
3204 ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
3205
6b9ea5a6
RP		 3206 /* Delete routes that were already added */
3207 list_for_each_entry(nh, &rt6_nh_list, next) {
3208 if (err_nh == nh)
3209 break;
3210 ip6_route_del(&nh->r_cfg);
3211 }
3212
3213cleanup:
3214 list_for_each_entry_safe(nh, nh_safe, &rt6_nh_list, next) {
3215 if (nh->rt6_info)
3216 dst_free(&nh->rt6_info->dst);
52fe51f8 3217 kfree(nh->mxc.mx);
6b9ea5a6
RP		 3218 list_del(&nh->next);
3219 kfree(nh);
3220 }
3221
3222 return err;
3223}
3224
3225static int ip6_route_multipath_del(struct fib6_config *cfg)
3226{
3227 struct fib6_config r_cfg;
3228 struct rtnexthop *rtnh;
3229 int remaining;
3230 int attrlen;
3231 int err = 1, last_err = 0;
3232
3233 remaining = cfg->fc_mp_len;
3234 rtnh = (struct rtnexthop *)cfg->fc_mp;
3235
3236 /* Parse a Multipath Entry */
3237 while (rtnh_ok(rtnh, remaining)) {
3238 memcpy(&r_cfg, cfg, sizeof(*cfg));
3239 if (rtnh->rtnh_ifindex)
3240 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
3241
3242 attrlen = rtnh_attrlen(rtnh);
3243 if (attrlen > 0) {
3244 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
3245
3246 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
3247 if (nla) {
3248 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
3249 r_cfg.fc_flags |= RTF_GATEWAY;
3250 }
3251 }
3252 err = ip6_route_del(&r_cfg);
3253 if (err)
3254 last_err = err;
3255
51ebd318
ND		 3256 rtnh = rtnh_next(rtnh, &remaining);
3257 }
3258
3259 return last_err;
3260}
3261
67ba4152 3262static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
1da177e4 3263{
86872cb5
TG		 3264 struct fib6_config cfg;
3265 int err;
1da177e4 3266
86872cb5
TG		 3267 err = rtm_to_fib6_config(skb, nlh, &cfg);
3268 if (err < 0)
3269 return err;
3270
51ebd318 3271 if (cfg.fc_mp)
6b9ea5a6 3272 return ip6_route_multipath_del(&cfg);
0ae81335
DA		 3273 else {
3274 cfg.fc_delete_all_nh = 1;
51ebd318 3275 return ip6_route_del(&cfg);
0ae81335 3276 }
1da177e4
LT		 3277}
3278
67ba4152 3279static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
1da177e4 3280{
86872cb5
TG		 3281 struct fib6_config cfg;
3282 int err;
1da177e4 3283
86872cb5
TG		 3284 err = rtm_to_fib6_config(skb, nlh, &cfg);
3285 if (err < 0)
3286 return err;
3287
51ebd318 3288 if (cfg.fc_mp)
6b9ea5a6 3289 return ip6_route_multipath_add(&cfg);
51ebd318
ND		 3290 else
3291 return ip6_route_add(&cfg);
1da177e4
LT		 3292}
3293
beb1afac 3294static size_t rt6_nlmsg_size(struct rt6_info *rt)
339bf98f 3295{
beb1afac
DA		 3296 int nexthop_len = 0;
3297
3298 if (rt->rt6i_nsiblings) {
3299 nexthop_len = nla_total_size(0) /* RTA_MULTIPATH */
3300 + NLA_ALIGN(sizeof(struct rtnexthop))
3301 + nla_total_size(16) /* RTA_GATEWAY */
beb1afac
DA		 3302 + lwtunnel_get_encap_size(rt->dst.lwtstate);
3303
3304 nexthop_len *= rt->rt6i_nsiblings;
3305 }
3306
339bf98f
TG		 3307 return NLMSG_ALIGN(sizeof(struct rtmsg))
3308 + nla_total_size(16) /* RTA_SRC */
3309 + nla_total_size(16) /* RTA_DST */
3310 + nla_total_size(16) /* RTA_GATEWAY */
3311 + nla_total_size(16) /* RTA_PREFSRC */
3312 + nla_total_size(4) /* RTA_TABLE */
3313 + nla_total_size(4) /* RTA_IIF */
3314 + nla_total_size(4) /* RTA_OIF */
3315 + nla_total_size(4) /* RTA_PRIORITY */
6a2b9ce0 3316 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
ea697639 3317 + nla_total_size(sizeof(struct rta_cacheinfo))
c78ba6d6 3318 + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
19e42e45 3319 + nla_total_size(1) /* RTA_PREF */
beb1afac
DA		 3320 + lwtunnel_get_encap_size(rt->dst.lwtstate)
3321 + nexthop_len;
3322}
3323
3324static int rt6_nexthop_info(struct sk_buff *skb, struct rt6_info *rt,
5be083ce 3325 unsigned int *flags, bool skip_oif)
beb1afac
DA		 3326{
3327 if (!netif_running(rt->dst.dev) || !netif_carrier_ok(rt->dst.dev)) {
3328 *flags |= RTNH_F_LINKDOWN;
3329 if (rt->rt6i_idev->cnf.ignore_routes_with_linkdown)
3330 *flags |= RTNH_F_DEAD;
3331 }
3332
3333 if (rt->rt6i_flags & RTF_GATEWAY) {
3334 if (nla_put_in6_addr(skb, RTA_GATEWAY, &rt->rt6i_gateway) < 0)
3335 goto nla_put_failure;
3336 }
3337
5be083ce
DA		 3338 /* not needed for multipath encoding b/c it has a rtnexthop struct */
3339 if (!skip_oif && rt->dst.dev &&
beb1afac
DA		 3340 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
3341 goto nla_put_failure;
3342
3343 if (rt->dst.lwtstate &&
3344 lwtunnel_fill_encap(skb, rt->dst.lwtstate) < 0)
3345 goto nla_put_failure;
3346
3347 return 0;
3348
3349nla_put_failure:
3350 return -EMSGSIZE;
3351}
3352
5be083ce 3353/* add multipath next hop */
beb1afac
DA		 3354static int rt6_add_nexthop(struct sk_buff *skb, struct rt6_info *rt)
3355{
3356 struct rtnexthop *rtnh;
3357 unsigned int flags = 0;
3358
3359 rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
3360 if (!rtnh)
3361 goto nla_put_failure;
3362
3363 rtnh->rtnh_hops = 0;
3364 rtnh->rtnh_ifindex = rt->dst.dev ? rt->dst.dev->ifindex : 0;
3365
5be083ce 3366 if (rt6_nexthop_info(skb, rt, &flags, true) < 0)
beb1afac
DA		 3367 goto nla_put_failure;
3368
3369 rtnh->rtnh_flags = flags;
3370
3371 /* length of rtnetlink header + attributes */
3372 rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *)rtnh;
3373
3374 return 0;
3375
3376nla_put_failure:
3377 return -EMSGSIZE;
339bf98f
TG		 3378}
3379
191cd582
BH		 3380static int rt6_fill_node(struct net *net,
3381 struct sk_buff *skb, struct rt6_info *rt,
0d51aa80 3382 struct in6_addr *dst, struct in6_addr *src,
15e47304 3383 int iif, int type, u32 portid, u32 seq,
f8cfe2ce 3384 unsigned int flags)
1da177e4 3385{
4b32b5ad 3386 u32 metrics[RTAX_MAX];
1da177e4 3387 struct rtmsg *rtm;
2d7202bf 3388 struct nlmsghdr *nlh;
e3703b3d 3389 long expires;
9e762a4a 3390 u32 table;
1da177e4 3391
15e47304 3392 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
38308473 3393 if (!nlh)
26932566 3394 return -EMSGSIZE;
2d7202bf
TG		 3395
3396 rtm = nlmsg_data(nlh);
1da177e4
LT		 3397 rtm->rtm_family = AF_INET6;
3398 rtm->rtm_dst_len = rt->rt6i_dst.plen;
3399 rtm->rtm_src_len = rt->rt6i_src.plen;
3400 rtm->rtm_tos = 0;
c71099ac 3401 if (rt->rt6i_table)
9e762a4a 3402 table = rt->rt6i_table->tb6_id;
c71099ac 3403 else
9e762a4a
PM		 3404 table = RT6_TABLE_UNSPEC;
3405 rtm->rtm_table = table;
c78679e8
DM		 3406 if (nla_put_u32(skb, RTA_TABLE, table))
3407 goto nla_put_failure;
ef2c7d7b
ND		 3408 if (rt->rt6i_flags & RTF_REJECT) {
3409 switch (rt->dst.error) {
3410 case -EINVAL:
3411 rtm->rtm_type = RTN_BLACKHOLE;
3412 break;
3413 case -EACCES:
3414 rtm->rtm_type = RTN_PROHIBIT;
3415 break;
b4949ab2
ND		 3416 case -EAGAIN:
3417 rtm->rtm_type = RTN_THROW;
3418 break;
ef2c7d7b
ND		 3419 default:
3420 rtm->rtm_type = RTN_UNREACHABLE;
3421 break;
3422 }
3423 }
38308473 3424 else if (rt->rt6i_flags & RTF_LOCAL)
ab79ad14 3425 rtm->rtm_type = RTN_LOCAL;
4ee39733
DA		 3426 else if (rt->rt6i_flags & RTF_ANYCAST)
3427 rtm->rtm_type = RTN_ANYCAST;
d1918542 3428 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
1da177e4
LT		 3429 rtm->rtm_type = RTN_LOCAL;
3430 else
3431 rtm->rtm_type = RTN_UNICAST;
3432 rtm->rtm_flags = 0;
3433 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
3434 rtm->rtm_protocol = rt->rt6i_protocol;
38308473 3435 if (rt->rt6i_flags & RTF_DYNAMIC)
1da177e4 3436 rtm->rtm_protocol = RTPROT_REDIRECT;
f0396f60
DO		 3437 else if (rt->rt6i_flags & RTF_ADDRCONF) {
3438 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
3439 rtm->rtm_protocol = RTPROT_RA;
3440 else
3441 rtm->rtm_protocol = RTPROT_KERNEL;
3442 }
1da177e4 3443
38308473 3444 if (rt->rt6i_flags & RTF_CACHE)
1da177e4
LT		 3445 rtm->rtm_flags |= RTM_F_CLONED;
3446
3447 if (dst) {
930345ea 3448 if (nla_put_in6_addr(skb, RTA_DST, dst))
c78679e8 3449 goto nla_put_failure;
1ab1457c 3450 rtm->rtm_dst_len = 128;
1da177e4 3451 } else if (rtm->rtm_dst_len)
930345ea 3452 if (nla_put_in6_addr(skb, RTA_DST, &rt->rt6i_dst.addr))
c78679e8 3453 goto nla_put_failure;
1da177e4
LT		 3454#ifdef CONFIG_IPV6_SUBTREES
3455 if (src) {
930345ea 3456 if (nla_put_in6_addr(skb, RTA_SRC, src))
c78679e8 3457 goto nla_put_failure;
1ab1457c 3458 rtm->rtm_src_len = 128;
c78679e8 3459 } else if (rtm->rtm_src_len &&
930345ea 3460 nla_put_in6_addr(skb, RTA_SRC, &rt->rt6i_src.addr))
c78679e8 3461 goto nla_put_failure;
1da177e4 3462#endif
7bc570c8
YH		 3463 if (iif) {
3464#ifdef CONFIG_IPV6_MROUTE
3465 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
fd61c6ba
DA		 3466 int err = ip6mr_get_route(net, skb, rtm, portid);
3467
3468 if (err == 0)
3469 return 0;
3470 if (err < 0)
3471 goto nla_put_failure;
7bc570c8
YH		 3472 } else
3473#endif
c78679e8
DM		 3474 if (nla_put_u32(skb, RTA_IIF, iif))
3475 goto nla_put_failure;
7bc570c8 3476 } else if (dst) {
1da177e4 3477 struct in6_addr saddr_buf;
c78679e8 3478 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
930345ea 3479 nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
c78679e8 3480 goto nla_put_failure;
1da177e4 3481 }
2d7202bf 3482
c3968a85
DW		 3483 if (rt->rt6i_prefsrc.plen) {
3484 struct in6_addr saddr_buf;
4e3fd7a0 3485 saddr_buf = rt->rt6i_prefsrc.addr;
930345ea 3486 if (nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
c78679e8 3487 goto nla_put_failure;
c3968a85
DW		 3488 }
3489
4b32b5ad
MKL		 3490 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
3491 if (rt->rt6i_pmtu)
3492 metrics[RTAX_MTU - 1] = rt->rt6i_pmtu;
3493 if (rtnetlink_put_metrics(skb, metrics) < 0)
2d7202bf
TG		 3494 goto nla_put_failure;
3495
c78679e8
DM		 3496 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
3497 goto nla_put_failure;
8253947e 3498
beb1afac
DA		 3499 /* For multipath routes, walk the siblings list and add
3500 * each as a nexthop within RTA_MULTIPATH.
3501 */
3502 if (rt->rt6i_nsiblings) {
3503 struct rt6_info *sibling, *next_sibling;
3504 struct nlattr *mp;
3505
3506 mp = nla_nest_start(skb, RTA_MULTIPATH);
3507 if (!mp)
3508 goto nla_put_failure;
3509
3510 if (rt6_add_nexthop(skb, rt) < 0)
3511 goto nla_put_failure;
3512
3513 list_for_each_entry_safe(sibling, next_sibling,
3514 &rt->rt6i_siblings, rt6i_siblings) {
3515 if (rt6_add_nexthop(skb, sibling) < 0)
3516 goto nla_put_failure;
3517 }
3518
3519 nla_nest_end(skb, mp);
3520 } else {
5be083ce 3521 if (rt6_nexthop_info(skb, rt, &rtm->rtm_flags, false) < 0)
beb1afac
DA		 3522 goto nla_put_failure;
3523 }
3524
8253947e 3525 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
69cdf8f9 3526
87a50699 3527 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
e3703b3d 3528 goto nla_put_failure;
2d7202bf 3529
c78ba6d6
LR		 3530 if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt->rt6i_flags)))
3531 goto nla_put_failure;
3532
19e42e45 3533
053c095a
JB		 3534 nlmsg_end(skb, nlh);
3535 return 0;
2d7202bf
TG		 3536
3537nla_put_failure:
26932566
PM		 3538 nlmsg_cancel(skb, nlh);
3539 return -EMSGSIZE;
1da177e4
LT		 3540}
3541
1b43af54 3542int rt6_dump_route(struct rt6_info *rt, void *p_arg)
1da177e4
LT		 3543{
3544 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
1f17e2f2
DA		 3545 struct net *net = arg->net;
3546
3547 if (rt == net->ipv6.ip6_null_entry)
3548 return 0;
1da177e4 3549
2d7202bf
TG		 3550 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
3551 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
f8cfe2ce
DA		 3552
3553 /* user wants prefix routes only */
3554 if (rtm->rtm_flags & RTM_F_PREFIX &&
3555 !(rt->rt6i_flags & RTF_PREFIX_RT)) {
3556 /* success since this is not a prefix route */
3557 return 1;
3558 }
3559 }
1da177e4 3560
1f17e2f2 3561 return rt6_fill_node(net,
191cd582 3562 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
15e47304 3563 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
f8cfe2ce 3564 NLM_F_MULTI);
1da177e4
LT		 3565}
3566
67ba4152 3567static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
1da177e4 3568{
3b1e0a65 3569 struct net *net = sock_net(in_skb->sk);
ab364a6f
TG		 3570 struct nlattr *tb[RTA_MAX+1];
3571 struct rt6_info *rt;
1da177e4 3572 struct sk_buff *skb;
ab364a6f 3573 struct rtmsg *rtm;
4c9483b2 3574 struct flowi6 fl6;
72331bc0 3575 int err, iif = 0, oif = 0;
1da177e4 3576
ab364a6f
TG		 3577 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
3578 if (err < 0)
3579 goto errout;
1da177e4 3580
ab364a6f 3581 err = -EINVAL;
4c9483b2 3582 memset(&fl6, 0, sizeof(fl6));
38b7097b
HFS		 3583 rtm = nlmsg_data(nlh);
3584 fl6.flowlabel = ip6_make_flowinfo(rtm->rtm_tos, 0);
1da177e4 3585
ab364a6f
TG		 3586 if (tb[RTA_SRC]) {
3587 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
3588 goto errout;
3589
4e3fd7a0 3590 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
ab364a6f
TG		 3591 }
3592
3593 if (tb[RTA_DST]) {
3594 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
3595 goto errout;
3596
4e3fd7a0 3597 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
ab364a6f
TG		 3598 }
3599
3600 if (tb[RTA_IIF])
3601 iif = nla_get_u32(tb[RTA_IIF]);
3602
3603 if (tb[RTA_OIF])
72331bc0 3604 oif = nla_get_u32(tb[RTA_OIF]);
1da177e4 3605
2e47b291
LC		 3606 if (tb[RTA_MARK])
3607 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
3608
622ec2c9
LC		 3609 if (tb[RTA_UID])
3610 fl6.flowi6_uid = make_kuid(current_user_ns(),
3611 nla_get_u32(tb[RTA_UID]));
3612 else
3613 fl6.flowi6_uid = iif ? INVALID_UID : current_uid();
3614
1da177e4
LT		 3615 if (iif) {
3616 struct net_device *dev;
72331bc0
SL		 3617 int flags = 0;
3618
5578689a 3619 dev = __dev_get_by_index(net, iif);
1da177e4
LT		 3620 if (!dev) {
3621 err = -ENODEV;
ab364a6f 3622 goto errout;
1da177e4 3623 }
72331bc0
SL		 3624
3625 fl6.flowi6_iif = iif;
3626
3627 if (!ipv6_addr_any(&fl6.saddr))
3628 flags |= RT6_LOOKUP_F_HAS_SADDR;
3629
3630 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
3631 flags);
3632 } else {
3633 fl6.flowi6_oif = oif;
3634
3635 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
1da177e4
LT		 3636 }
3637
9d6acb3b
WC		 3638 if (rt == net->ipv6.ip6_null_entry) {
3639 err = rt->dst.error;
3640 ip6_rt_put(rt);
3641 goto errout;
3642 }
3643
ab364a6f 3644 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
38308473 3645 if (!skb) {
94e187c0 3646 ip6_rt_put(rt);
ab364a6f
TG		 3647 err = -ENOBUFS;
3648 goto errout;
3649 }
1da177e4 3650
d8d1f30b 3651 skb_dst_set(skb, &rt->dst);
1da177e4 3652
4c9483b2 3653 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
15e47304 3654 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
f8cfe2ce 3655 nlh->nlmsg_seq, 0);
1da177e4 3656 if (err < 0) {
ab364a6f
TG		 3657 kfree_skb(skb);
3658 goto errout;
1da177e4
LT		 3659 }
3660
15e47304 3661 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
ab364a6f 3662errout:
1da177e4 3663 return err;
1da177e4
LT		 3664}
3665
37a1d361
RP		 3666void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info,
3667 unsigned int nlm_flags)
1da177e4
LT		 3668{
3669 struct sk_buff *skb;
5578689a 3670 struct net *net = info->nl_net;
528c4ceb
DL		 3671 u32 seq;
3672 int err;
3673
3674 err = -ENOBUFS;
38308473 3675 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
86872cb5 3676
19e42e45 3677 skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
38308473 3678 if (!skb)
21713ebc
TG		 3679 goto errout;
3680
191cd582 3681 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
f8cfe2ce 3682 event, info->portid, seq, nlm_flags);
26932566
PM		 3683 if (err < 0) {
3684 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
3685 WARN_ON(err == -EMSGSIZE);
3686 kfree_skb(skb);
3687 goto errout;
3688 }
15e47304 3689 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
1ce85fe4
PNA		 3690 info->nlh, gfp_any());
3691 return;
21713ebc
TG		 3692errout:
3693 if (err < 0)
5578689a 3694 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
1da177e4
LT		 3695}
3696
8ed67789 3697static int ip6_route_dev_notify(struct notifier_block *this,
351638e7 3698 unsigned long event, void *ptr)
8ed67789 3699{
351638e7 3700 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
c346dca1 3701 struct net *net = dev_net(dev);
8ed67789
DL		 3702
3703 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
d8d1f30b 3704 net->ipv6.ip6_null_entry->dst.dev = dev;
8ed67789
DL		 3705 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
3706#ifdef CONFIG_IPV6_MULTIPLE_TABLES
d8d1f30b 3707 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
8ed67789 3708 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
d8d1f30b 3709 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
8ed67789
DL		 3710 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
3711#endif
3712 }
3713
3714 return NOTIFY_OK;
3715}
3716
1da177e4
LT		 3717/*
3718 * /proc
3719 */
3720
3721#ifdef CONFIG_PROC_FS
3722
33120b30
AD		 3723static const struct file_operations ipv6_route_proc_fops = {
3724 .owner = THIS_MODULE,
3725 .open = ipv6_route_open,
3726 .read = seq_read,
3727 .llseek = seq_lseek,
8d2ca1d7 3728 .release = seq_release_net,
33120b30
AD		 3729};
3730
1da177e4
LT		 3731static int rt6_stats_seq_show(struct seq_file *seq, void *v)
3732{
69ddb805 3733 struct net *net = (struct net *)seq->private;
1da177e4 3734 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
69ddb805
DL		 3735 net->ipv6.rt6_stats->fib_nodes,
3736 net->ipv6.rt6_stats->fib_route_nodes,
3737 net->ipv6.rt6_stats->fib_rt_alloc,
3738 net->ipv6.rt6_stats->fib_rt_entries,
3739 net->ipv6.rt6_stats->fib_rt_cache,
fc66f95c 3740 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
69ddb805 3741 net->ipv6.rt6_stats->fib_discarded_routes);
1da177e4
LT		 3742
3743 return 0;
3744}
3745
3746static int rt6_stats_seq_open(struct inode *inode, struct file *file)
3747{
de05c557 3748 return single_open_net(inode, file, rt6_stats_seq_show);
69ddb805
DL		 3749}
3750
9a32144e 3751static const struct file_operations rt6_stats_seq_fops = {
1da177e4
LT		 3752 .owner = THIS_MODULE,
3753 .open = rt6_stats_seq_open,
3754 .read = seq_read,
3755 .llseek = seq_lseek,
b6fcbdb4 3756 .release = single_release_net,
1da177e4
LT		 3757};
3758#endif /* CONFIG_PROC_FS */
3759
3760#ifdef CONFIG_SYSCTL
3761
1da177e4 3762static
fe2c6338 3763int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
1da177e4
LT		 3764 void __user *buffer, size_t *lenp, loff_t *ppos)
3765{
c486da34
LAG		 3766 struct net *net;
3767 int delay;
3768 if (!write)
1da177e4 3769 return -EINVAL;
c486da34
LAG		 3770
3771 net = (struct net *)ctl->extra1;
3772 delay = net->ipv6.sysctl.flush_delay;
3773 proc_dointvec(ctl, write, buffer, lenp, ppos);
2ac3ac8f 3774 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
c486da34 3775 return 0;
1da177e4
LT		 3776}
3777
fe2c6338 3778struct ctl_table ipv6_route_table_template[] = {
1ab1457c 3779 {
1da177e4 3780 .procname = "flush",
4990509f 3781 .data = &init_net.ipv6.sysctl.flush_delay,
1da177e4 3782 .maxlen = sizeof(int),
89c8b3a1 3783 .mode = 0200,
6d9f239a 3784 .proc_handler = ipv6_sysctl_rtcache_flush
1da177e4
LT		 3785 },
3786 {
1da177e4 3787 .procname = "gc_thresh",
9a7ec3a9 3788 .data = &ip6_dst_ops_template.gc_thresh,
1da177e4
LT		 3789 .maxlen = sizeof(int),
3790 .mode = 0644,
6d9f239a 3791 .proc_handler = proc_dointvec,
1da177e4
LT		 3792 },
3793 {
1da177e4 3794 .procname = "max_size",
4990509f 3795 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
1da177e4
LT		 3796 .maxlen = sizeof(int),
3797 .mode = 0644,
6d9f239a 3798 .proc_handler = proc_dointvec,
1da177e4
LT		 3799 },
3800 {
1da177e4 3801 .procname = "gc_min_interval",
4990509f 3802 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 3803 .maxlen = sizeof(int),
3804 .mode = 0644,
6d9f239a 3805 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3806 },
3807 {
1da177e4 3808 .procname = "gc_timeout",
4990509f 3809 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
1da177e4
LT		 3810 .maxlen = sizeof(int),
3811 .mode = 0644,
6d9f239a 3812 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3813 },
3814 {
1da177e4 3815 .procname = "gc_interval",
4990509f 3816 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
1da177e4
LT		 3817 .maxlen = sizeof(int),
3818 .mode = 0644,
6d9f239a 3819 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3820 },
3821 {
1da177e4 3822 .procname = "gc_elasticity",
4990509f 3823 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
1da177e4
LT		 3824 .maxlen = sizeof(int),
3825 .mode = 0644,
f3d3f616 3826 .proc_handler = proc_dointvec,
1da177e4
LT		 3827 },
3828 {
1da177e4 3829 .procname = "mtu_expires",
4990509f 3830 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
1da177e4
LT		 3831 .maxlen = sizeof(int),
3832 .mode = 0644,
6d9f239a 3833 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3834 },
3835 {
1da177e4 3836 .procname = "min_adv_mss",
4990509f 3837 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
1da177e4
LT		 3838 .maxlen = sizeof(int),
3839 .mode = 0644,
f3d3f616 3840 .proc_handler = proc_dointvec,
1da177e4
LT		 3841 },
3842 {
1da177e4 3843 .procname = "gc_min_interval_ms",
4990509f 3844 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 3845 .maxlen = sizeof(int),
3846 .mode = 0644,
6d9f239a 3847 .proc_handler = proc_dointvec_ms_jiffies,
1da177e4 3848 },
f8572d8f 3849 { }
1da177e4
LT		 3850};
3851
2c8c1e72 3852struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
760f2d01
DL		 3853{
3854 struct ctl_table *table;
3855
3856 table = kmemdup(ipv6_route_table_template,
3857 sizeof(ipv6_route_table_template),
3858 GFP_KERNEL);
5ee09105
YH		 3859
3860 if (table) {
3861 table[0].data = &net->ipv6.sysctl.flush_delay;
c486da34 3862 table[0].extra1 = net;
86393e52 3863 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
5ee09105
YH		 3864 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
3865 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3866 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
3867 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
3868 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
3869 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
3870 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
9c69fabe 3871 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
464dc801
EB		 3872
3873 /* Don't export sysctls to unprivileged users */
3874 if (net->user_ns != &init_user_ns)
3875 table[0].procname = NULL;
5ee09105
YH		 3876 }
3877
760f2d01
DL		 3878 return table;
3879}
1da177e4
LT		 3880#endif
3881
2c8c1e72 3882static int __net_init ip6_route_net_init(struct net *net)
cdb18761 3883{
633d424b 3884 int ret = -ENOMEM;
8ed67789 3885
86393e52
AD		 3886 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3887 sizeof(net->ipv6.ip6_dst_ops));
f2fc6a54 3888
fc66f95c
ED		 3889 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
3890 goto out_ip6_dst_ops;
3891
8ed67789
DL		 3892 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
3893 sizeof(*net->ipv6.ip6_null_entry),
3894 GFP_KERNEL);
3895 if (!net->ipv6.ip6_null_entry)
fc66f95c 3896 goto out_ip6_dst_entries;
d8d1f30b 3897 net->ipv6.ip6_null_entry->dst.path =
8ed67789 3898 (struct dst_entry *)net->ipv6.ip6_null_entry;
d8d1f30b 3899 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 3900 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3901 ip6_template_metrics, true);
8ed67789
DL		 3902
3903#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3904 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3905 sizeof(*net->ipv6.ip6_prohibit_entry),
3906 GFP_KERNEL);
68fffc67
PZ		 3907 if (!net->ipv6.ip6_prohibit_entry)
3908 goto out_ip6_null_entry;
d8d1f30b 3909 net->ipv6.ip6_prohibit_entry->dst.path =
8ed67789 3910 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
d8d1f30b 3911 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 3912 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3913 ip6_template_metrics, true);
8ed67789
DL		 3914
3915 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3916 sizeof(*net->ipv6.ip6_blk_hole_entry),
3917 GFP_KERNEL);
68fffc67
PZ		 3918 if (!net->ipv6.ip6_blk_hole_entry)
3919 goto out_ip6_prohibit_entry;
d8d1f30b 3920 net->ipv6.ip6_blk_hole_entry->dst.path =
8ed67789 3921 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
d8d1f30b 3922 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 3923 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3924 ip6_template_metrics, true);
8ed67789
DL		 3925#endif
3926
b339a47c
PZ		 3927 net->ipv6.sysctl.flush_delay = 0;
3928 net->ipv6.sysctl.ip6_rt_max_size = 4096;
3929 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3930 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3931 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3932 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3933 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3934 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3935
6891a346
BT		 3936 net->ipv6.ip6_rt_gc_expire = 30*HZ;
3937
8ed67789
DL		 3938 ret = 0;
3939out:
3940 return ret;
f2fc6a54 3941
68fffc67
PZ		 3942#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3943out_ip6_prohibit_entry:
3944 kfree(net->ipv6.ip6_prohibit_entry);
3945out_ip6_null_entry:
3946 kfree(net->ipv6.ip6_null_entry);
3947#endif
fc66f95c
ED		 3948out_ip6_dst_entries:
3949 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
f2fc6a54 3950out_ip6_dst_ops:
f2fc6a54 3951 goto out;
cdb18761
DL		 3952}
3953
2c8c1e72 3954static void __net_exit ip6_route_net_exit(struct net *net)
cdb18761 3955{
8ed67789
DL		 3956 kfree(net->ipv6.ip6_null_entry);
3957#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3958 kfree(net->ipv6.ip6_prohibit_entry);
3959 kfree(net->ipv6.ip6_blk_hole_entry);
3960#endif
41bb78b4 3961 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
cdb18761
DL		 3962}
3963
d189634e
TG		 3964static int __net_init ip6_route_net_init_late(struct net *net)
3965{
3966#ifdef CONFIG_PROC_FS
d4beaa66
G		 3967 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3968 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
d189634e
TG		 3969#endif
3970 return 0;
3971}
3972
3973static void __net_exit ip6_route_net_exit_late(struct net *net)
3974{
3975#ifdef CONFIG_PROC_FS
ece31ffd
G		 3976 remove_proc_entry("ipv6_route", net->proc_net);
3977 remove_proc_entry("rt6_stats", net->proc_net);
d189634e
TG		 3978#endif
3979}
3980
cdb18761
DL		 3981static struct pernet_operations ip6_route_net_ops = {
3982 .init = ip6_route_net_init,
3983 .exit = ip6_route_net_exit,
3984};
3985
c3426b47
DM		 3986static int __net_init ipv6_inetpeer_init(struct net *net)
3987{
3988 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3989
3990 if (!bp)
3991 return -ENOMEM;
3992 inet_peer_base_init(bp);
3993 net->ipv6.peers = bp;
3994 return 0;
3995}
3996
3997static void __net_exit ipv6_inetpeer_exit(struct net *net)
3998{
3999 struct inet_peer_base *bp = net->ipv6.peers;
4000
4001 net->ipv6.peers = NULL;
56a6b248 4002 inetpeer_invalidate_tree(bp);
c3426b47
DM		 4003 kfree(bp);
4004}
4005
2b823f72 4006static struct pernet_operations ipv6_inetpeer_ops = {
c3426b47
DM		 4007 .init = ipv6_inetpeer_init,
4008 .exit = ipv6_inetpeer_exit,
4009};
4010
d189634e
TG		 4011static struct pernet_operations ip6_route_net_late_ops = {
4012 .init = ip6_route_net_init_late,
4013 .exit = ip6_route_net_exit_late,
4014};
4015
8ed67789
DL		 4016static struct notifier_block ip6_route_dev_notifier = {
4017 .notifier_call = ip6_route_dev_notify,
4018 .priority = 0,
4019};
4020
433d49c3 4021int __init ip6_route_init(void)
1da177e4 4022{
433d49c3 4023 int ret;
8d0b94af 4024 int cpu;
433d49c3 4025
9a7ec3a9
DL		 4026 ret = -ENOMEM;
4027 ip6_dst_ops_template.kmem_cachep =
e5d679f3 4028 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
f845ab6b 4029 SLAB_HWCACHE_ALIGN, NULL);
9a7ec3a9 4030 if (!ip6_dst_ops_template.kmem_cachep)
c19a28e1 4031 goto out;
14e50e57 4032
fc66f95c 4033 ret = dst_entries_init(&ip6_dst_blackhole_ops);
8ed67789 4034 if (ret)
bdb3289f 4035 goto out_kmem_cache;
bdb3289f 4036
c3426b47
DM		 4037 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
4038 if (ret)
e8803b6c 4039 goto out_dst_entries;
2a0c451a 4040
7e52b33b
DM		 4041 ret = register_pernet_subsys(&ip6_route_net_ops);
4042 if (ret)
4043 goto out_register_inetpeer;
c3426b47 4044
5dc121e9
AE		 4045 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
4046
8ed67789
DL		 4047 /* Registering of the loopback is done before this portion of code,
4048 * the loopback reference in rt6_info will not be taken, do it
4049 * manually for init_net */
d8d1f30b 4050 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
8ed67789
DL		 4051 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
4052 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
d8d1f30b 4053 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
8ed67789 4054 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
d8d1f30b 4055 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
8ed67789
DL		 4056 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
4057 #endif
e8803b6c 4058 ret = fib6_init();
433d49c3 4059 if (ret)
8ed67789 4060 goto out_register_subsys;
433d49c3 4061
433d49c3
DL		 4062 ret = xfrm6_init();
4063 if (ret)
e8803b6c 4064 goto out_fib6_init;
c35b7e72 4065
433d49c3
DL		 4066 ret = fib6_rules_init();
4067 if (ret)
4068 goto xfrm6_init;
7e5449c2 4069
d189634e
TG		 4070 ret = register_pernet_subsys(&ip6_route_net_late_ops);
4071 if (ret)
4072 goto fib6_rules_init;
4073
433d49c3 4074 ret = -ENOBUFS;
c7ac8679
GR		 4075 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
4076 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
4077 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
d189634e 4078 goto out_register_late_subsys;
c127ea2c 4079
8ed67789 4080 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
cdb18761 4081 if (ret)
d189634e 4082 goto out_register_late_subsys;
8ed67789 4083
8d0b94af
MKL		 4084 for_each_possible_cpu(cpu) {
4085 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
4086
4087 INIT_LIST_HEAD(&ul->head);
4088 spin_lock_init(&ul->lock);
4089 }
4090
433d49c3
DL		 4091out:
4092 return ret;
4093
d189634e
TG		 4094out_register_late_subsys:
4095 unregister_pernet_subsys(&ip6_route_net_late_ops);
433d49c3 4096fib6_rules_init:
433d49c3
DL		 4097 fib6_rules_cleanup();
4098xfrm6_init:
433d49c3 4099 xfrm6_fini();
2a0c451a
TG		 4100out_fib6_init:
4101 fib6_gc_cleanup();
8ed67789
DL		 4102out_register_subsys:
4103 unregister_pernet_subsys(&ip6_route_net_ops);
7e52b33b
DM		 4104out_register_inetpeer:
4105 unregister_pernet_subsys(&ipv6_inetpeer_ops);
fc66f95c
ED		 4106out_dst_entries:
4107 dst_entries_destroy(&ip6_dst_blackhole_ops);
433d49c3 4108out_kmem_cache:
f2fc6a54 4109 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
433d49c3 4110 goto out;
1da177e4
LT		 4111}
4112
4113void ip6_route_cleanup(void)
4114{
8ed67789 4115 unregister_netdevice_notifier(&ip6_route_dev_notifier);
d189634e 4116 unregister_pernet_subsys(&ip6_route_net_late_ops);
101367c2 4117 fib6_rules_cleanup();
1da177e4 4118 xfrm6_fini();
1da177e4 4119 fib6_gc_cleanup();
c3426b47 4120 unregister_pernet_subsys(&ipv6_inetpeer_ops);
8ed67789 4121 unregister_pernet_subsys(&ip6_route_net_ops);
41bb78b4 4122 dst_entries_destroy(&ip6_dst_blackhole_ops);
f2fc6a54 4123 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
1da177e4 4124}
Ubuntu Artful kernel mirror