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