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