projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ipv6: Consider RTF_CACHE when searching the fib6 tree
[linux-2.6-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) {
1f56a01f
MKL		 1788 if ((rt->rt6i_flags & RTF_CACHE) &&
1789 !(cfg->fc_flags & RTF_CACHE))
1790 continue;
86872cb5 1791 if (cfg->fc_ifindex &&
d1918542
DM		 1792 (!rt->dst.dev ||
1793 rt->dst.dev->ifindex != cfg->fc_ifindex))
1da177e4 1794 continue;
86872cb5
TG		 1795 if (cfg->fc_flags & RTF_GATEWAY &&
1796 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1da177e4 1797 continue;
86872cb5 1798 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1da177e4 1799 continue;
d8d1f30b 1800 dst_hold(&rt->dst);
c71099ac 1801 read_unlock_bh(&table->tb6_lock);
1da177e4 1802
86872cb5 1803 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1da177e4
LT		 1804 }
1805 }
c71099ac 1806 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1807
1808 return err;
1809}
1810
6700c270 1811static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
a6279458 1812{
e8599ff4 1813 struct net *net = dev_net(skb->dev);
a6279458 1814 struct netevent_redirect netevent;
e8599ff4 1815 struct rt6_info *rt, *nrt = NULL;
e8599ff4
DM		 1816 struct ndisc_options ndopts;
1817 struct inet6_dev *in6_dev;
1818 struct neighbour *neigh;
71bcdba0 1819 struct rd_msg *msg;
6e157b6a
DM		 1820 int optlen, on_link;
1821 u8 *lladdr;
e8599ff4 1822
29a3cad5 1823 optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
71bcdba0 1824 optlen -= sizeof(*msg);
e8599ff4
DM		 1825
1826 if (optlen < 0) {
6e157b6a 1827 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
e8599ff4
DM		 1828 return;
1829 }
1830
71bcdba0 1831 msg = (struct rd_msg *)icmp6_hdr(skb);
e8599ff4 1832
71bcdba0 1833 if (ipv6_addr_is_multicast(&msg->dest)) {
6e157b6a 1834 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
e8599ff4
DM		 1835 return;
1836 }
1837
6e157b6a 1838 on_link = 0;
71bcdba0 1839 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
e8599ff4 1840 on_link = 1;
71bcdba0 1841 } else if (ipv6_addr_type(&msg->target) !=
e8599ff4 1842 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
6e157b6a 1843 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
e8599ff4
DM		 1844 return;
1845 }
1846
1847 in6_dev = __in6_dev_get(skb->dev);
1848 if (!in6_dev)
1849 return;
1850 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1851 return;
1852
1853 /* RFC2461 8.1:
1854 * The IP source address of the Redirect MUST be the same as the current
1855 * first-hop router for the specified ICMP Destination Address.
1856 */
1857
71bcdba0 1858 if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
e8599ff4
DM		 1859 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1860 return;
1861 }
6e157b6a
DM		 1862
1863 lladdr = NULL;
e8599ff4
DM		 1864 if (ndopts.nd_opts_tgt_lladdr) {
1865 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1866 skb->dev);
1867 if (!lladdr) {
1868 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1869 return;
1870 }
1871 }
1872
6e157b6a
DM		 1873 rt = (struct rt6_info *) dst;
1874 if (rt == net->ipv6.ip6_null_entry) {
1875 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
e8599ff4 1876 return;
6e157b6a 1877 }
e8599ff4 1878
6e157b6a
DM		 1879 /* Redirect received -> path was valid.
1880 * Look, redirects are sent only in response to data packets,
1881 * so that this nexthop apparently is reachable. --ANK
1882 */
1883 dst_confirm(&rt->dst);
a6279458 1884
71bcdba0 1885 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
6e157b6a
DM		 1886 if (!neigh)
1887 return;
a6279458 1888
1da177e4
LT		 1889 /*
1890 * We have finally decided to accept it.
1891 */
1892
1ab1457c 1893 neigh_update(neigh, lladdr, NUD_STALE,
1da177e4
LT		 1894 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1895 NEIGH_UPDATE_F_OVERRIDE|
1896 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1897 NEIGH_UPDATE_F_ISROUTER))
1898 );
1899
71bcdba0 1900 nrt = ip6_rt_copy(rt, &msg->dest);
38308473 1901 if (!nrt)
1da177e4
LT		 1902 goto out;
1903
1904 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1905 if (on_link)
1906 nrt->rt6i_flags &= ~RTF_GATEWAY;
1907
4e3fd7a0 1908 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1da177e4 1909
40e22e8f 1910 if (ip6_ins_rt(nrt))
1da177e4
LT		 1911 goto out;
1912
d8d1f30b
CG		 1913 netevent.old = &rt->dst;
1914 netevent.new = &nrt->dst;
71bcdba0 1915 netevent.daddr = &msg->dest;
60592833 1916 netevent.neigh = neigh;
8d71740c
TT		 1917 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1918
38308473 1919 if (rt->rt6i_flags & RTF_CACHE) {
6e157b6a 1920 rt = (struct rt6_info *) dst_clone(&rt->dst);
e0a1ad73 1921 ip6_del_rt(rt);
1da177e4
LT		 1922 }
1923
1924out:
e8599ff4 1925 neigh_release(neigh);
6e157b6a
DM		 1926}
1927
1da177e4
LT		 1928/*
1929 * Misc support functions
1930 */
1931
1716a961 1932static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
21efcfa0 1933 const struct in6_addr *dest)
1da177e4 1934{
d1918542 1935 struct net *net = dev_net(ort->dst.dev);
8b96d22d
DM		 1936 struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1937 ort->rt6i_table);
1da177e4
LT		 1938
1939 if (rt) {
d8d1f30b
CG		 1940 rt->dst.input = ort->dst.input;
1941 rt->dst.output = ort->dst.output;
8e2ec639 1942 rt->dst.flags |= DST_HOST;
d8d1f30b 1943
4e3fd7a0 1944 rt->rt6i_dst.addr = *dest;
8e2ec639 1945 rt->rt6i_dst.plen = 128;
defb3519 1946 dst_copy_metrics(&rt->dst, &ort->dst);
d8d1f30b 1947 rt->dst.error = ort->dst.error;
1da177e4
LT		 1948 rt->rt6i_idev = ort->rt6i_idev;
1949 if (rt->rt6i_idev)
1950 in6_dev_hold(rt->rt6i_idev);
d8d1f30b 1951 rt->dst.lastuse = jiffies;
1da177e4 1952
550bab42
JA		 1953 if (ort->rt6i_flags & RTF_GATEWAY)
1954 rt->rt6i_gateway = ort->rt6i_gateway;
1955 else
1956 rt->rt6i_gateway = *dest;
1716a961 1957 rt->rt6i_flags = ort->rt6i_flags;
24f5b855 1958 rt6_set_from(rt, ort);
1da177e4
LT		 1959 rt->rt6i_metric = 0;
1960
1da177e4
LT		 1961#ifdef CONFIG_IPV6_SUBTREES
1962 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1963#endif
0f6c6392 1964 memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
c71099ac 1965 rt->rt6i_table = ort->rt6i_table;
1da177e4
LT		 1966 }
1967 return rt;
1968}
1969
70ceb4f5 1970#ifdef CONFIG_IPV6_ROUTE_INFO
efa2cea0 1971static struct rt6_info *rt6_get_route_info(struct net *net,
b71d1d42
ED		 1972 const struct in6_addr *prefix, int prefixlen,
1973 const struct in6_addr *gwaddr, int ifindex)
70ceb4f5
YH		 1974{
1975 struct fib6_node *fn;
1976 struct rt6_info *rt = NULL;
c71099ac
TG		 1977 struct fib6_table *table;
1978
efa2cea0 1979 table = fib6_get_table(net, RT6_TABLE_INFO);
38308473 1980 if (!table)
c71099ac 1981 return NULL;
70ceb4f5 1982
5744dd9b 1983 read_lock_bh(&table->tb6_lock);
67ba4152 1984 fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);
70ceb4f5
YH		 1985 if (!fn)
1986 goto out;
1987
d8d1f30b 1988 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
d1918542 1989 if (rt->dst.dev->ifindex != ifindex)
70ceb4f5
YH		 1990 continue;
1991 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1992 continue;
1993 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1994 continue;
d8d1f30b 1995 dst_hold(&rt->dst);
70ceb4f5
YH		 1996 break;
1997 }
1998out:
5744dd9b 1999 read_unlock_bh(&table->tb6_lock);
70ceb4f5
YH		 2000 return rt;
2001}
2002
efa2cea0 2003static struct rt6_info *rt6_add_route_info(struct net *net,
b71d1d42
ED		 2004 const struct in6_addr *prefix, int prefixlen,
2005 const struct in6_addr *gwaddr, int ifindex,
95c96174 2006 unsigned int pref)
70ceb4f5 2007{
86872cb5
TG		 2008 struct fib6_config cfg = {
2009 .fc_table = RT6_TABLE_INFO,
238fc7ea 2010 .fc_metric = IP6_RT_PRIO_USER,
86872cb5
TG		 2011 .fc_ifindex = ifindex,
2012 .fc_dst_len = prefixlen,
2013 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
2014 RTF_UP | RTF_PREF(pref),
15e47304 2015 .fc_nlinfo.portid = 0,
efa2cea0
DL		 2016 .fc_nlinfo.nlh = NULL,
2017 .fc_nlinfo.nl_net = net,
86872cb5
TG		 2018 };
2019
4e3fd7a0
AD		 2020 cfg.fc_dst = *prefix;
2021 cfg.fc_gateway = *gwaddr;
70ceb4f5 2022
e317da96
YH		 2023 /* We should treat it as a default route if prefix length is 0. */
2024 if (!prefixlen)
86872cb5 2025 cfg.fc_flags |= RTF_DEFAULT;
70ceb4f5 2026
86872cb5 2027 ip6_route_add(&cfg);
70ceb4f5 2028
efa2cea0 2029 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
70ceb4f5
YH		 2030}
2031#endif
2032
b71d1d42 2033struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1ab1457c 2034{
1da177e4 2035 struct rt6_info *rt;
c71099ac 2036 struct fib6_table *table;
1da177e4 2037
c346dca1 2038 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
38308473 2039 if (!table)
c71099ac 2040 return NULL;
1da177e4 2041
5744dd9b 2042 read_lock_bh(&table->tb6_lock);
67ba4152 2043 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
d1918542 2044 if (dev == rt->dst.dev &&
045927ff 2045 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1da177e4
LT		 2046 ipv6_addr_equal(&rt->rt6i_gateway, addr))
2047 break;
2048 }
2049 if (rt)
d8d1f30b 2050 dst_hold(&rt->dst);
5744dd9b 2051 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 2052 return rt;
2053}
2054
b71d1d42 2055struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
ebacaaa0
YH		 2056 struct net_device *dev,
2057 unsigned int pref)
1da177e4 2058{
86872cb5
TG		 2059 struct fib6_config cfg = {
2060 .fc_table = RT6_TABLE_DFLT,
238fc7ea 2061 .fc_metric = IP6_RT_PRIO_USER,
86872cb5
TG		 2062 .fc_ifindex = dev->ifindex,
2063 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
2064 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
15e47304 2065 .fc_nlinfo.portid = 0,
5578689a 2066 .fc_nlinfo.nlh = NULL,
c346dca1 2067 .fc_nlinfo.nl_net = dev_net(dev),
86872cb5 2068 };
1da177e4 2069
4e3fd7a0 2070 cfg.fc_gateway = *gwaddr;
1da177e4 2071
86872cb5 2072 ip6_route_add(&cfg);
1da177e4 2073
1da177e4
LT		 2074 return rt6_get_dflt_router(gwaddr, dev);
2075}
2076
7b4da532 2077void rt6_purge_dflt_routers(struct net *net)
1da177e4
LT		 2078{
2079 struct rt6_info *rt;
c71099ac
TG		 2080 struct fib6_table *table;
2081
2082 /* NOTE: Keep consistent with rt6_get_dflt_router */
7b4da532 2083 table = fib6_get_table(net, RT6_TABLE_DFLT);
38308473 2084 if (!table)
c71099ac 2085 return;
1da177e4
LT		 2086
2087restart:
c71099ac 2088 read_lock_bh(&table->tb6_lock);
d8d1f30b 2089 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
3e8b0ac3
LC		 2090 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2091 (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
d8d1f30b 2092 dst_hold(&rt->dst);
c71099ac 2093 read_unlock_bh(&table->tb6_lock);
e0a1ad73 2094 ip6_del_rt(rt);
1da177e4
LT		 2095 goto restart;
2096 }
2097 }
c71099ac 2098 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 2099}
2100
5578689a
DL		 2101static void rtmsg_to_fib6_config(struct net *net,
2102 struct in6_rtmsg *rtmsg,
86872cb5
TG		 2103 struct fib6_config *cfg)
2104{
2105 memset(cfg, 0, sizeof(*cfg));
2106
2107 cfg->fc_table = RT6_TABLE_MAIN;
2108 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2109 cfg->fc_metric = rtmsg->rtmsg_metric;
2110 cfg->fc_expires = rtmsg->rtmsg_info;
2111 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2112 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2113 cfg->fc_flags = rtmsg->rtmsg_flags;
2114
5578689a 2115 cfg->fc_nlinfo.nl_net = net;
f1243c2d 2116
4e3fd7a0
AD		 2117 cfg->fc_dst = rtmsg->rtmsg_dst;
2118 cfg->fc_src = rtmsg->rtmsg_src;
2119 cfg->fc_gateway = rtmsg->rtmsg_gateway;
86872cb5
TG		 2120}
2121
5578689a 2122int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1da177e4 2123{
86872cb5 2124 struct fib6_config cfg;
1da177e4
LT		 2125 struct in6_rtmsg rtmsg;
2126 int err;
2127
67ba4152 2128 switch (cmd) {
1da177e4
LT		 2129 case SIOCADDRT: /* Add a route */
2130 case SIOCDELRT: /* Delete a route */
af31f412 2131 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1da177e4
LT		 2132 return -EPERM;
2133 err = copy_from_user(&rtmsg, arg,
2134 sizeof(struct in6_rtmsg));
2135 if (err)
2136 return -EFAULT;
86872cb5 2137
5578689a 2138 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
86872cb5 2139
1da177e4
LT		 2140 rtnl_lock();
2141 switch (cmd) {
2142 case SIOCADDRT:
86872cb5 2143 err = ip6_route_add(&cfg);
1da177e4
LT		 2144 break;
2145 case SIOCDELRT:
86872cb5 2146 err = ip6_route_del(&cfg);
1da177e4
LT		 2147 break;
2148 default:
2149 err = -EINVAL;
2150 }
2151 rtnl_unlock();
2152
2153 return err;
3ff50b79 2154 }
1da177e4
LT		 2155
2156 return -EINVAL;
2157}
2158
2159/*
2160 * Drop the packet on the floor
2161 */
2162
d5fdd6ba 2163static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
1da177e4 2164{
612f09e8 2165 int type;
adf30907 2166 struct dst_entry *dst = skb_dst(skb);
612f09e8
YH		 2167 switch (ipstats_mib_noroutes) {
2168 case IPSTATS_MIB_INNOROUTES:
0660e03f 2169 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
45bb0060 2170 if (type == IPV6_ADDR_ANY) {
3bd653c8
DL		 2171 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2172 IPSTATS_MIB_INADDRERRORS);
612f09e8
YH		 2173 break;
2174 }
2175 /* FALLTHROUGH */
2176 case IPSTATS_MIB_OUTNOROUTES:
3bd653c8
DL		 2177 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2178 ipstats_mib_noroutes);
612f09e8
YH		 2179 break;
2180 }
3ffe533c 2181 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
1da177e4
LT		 2182 kfree_skb(skb);
2183 return 0;
2184}
2185
9ce8ade0
TG		 2186static int ip6_pkt_discard(struct sk_buff *skb)
2187{
612f09e8 2188 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
9ce8ade0
TG		 2189}
2190
aad88724 2191static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb)
1da177e4 2192{
adf30907 2193 skb->dev = skb_dst(skb)->dev;
612f09e8 2194 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
1da177e4
LT		 2195}
2196
9ce8ade0
TG		 2197static int ip6_pkt_prohibit(struct sk_buff *skb)
2198{
612f09e8 2199 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
9ce8ade0
TG		 2200}
2201
aad88724 2202static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb)
9ce8ade0 2203{
adf30907 2204 skb->dev = skb_dst(skb)->dev;
612f09e8 2205 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
9ce8ade0
TG		 2206}
2207
1da177e4
LT		 2208/*
2209 * Allocate a dst for local (unicast / anycast) address.
2210 */
2211
2212struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2213 const struct in6_addr *addr,
8f031519 2214 bool anycast)
1da177e4 2215{
c346dca1 2216 struct net *net = dev_net(idev->dev);
a3300ef4
HFS		 2217 struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,
2218 DST_NOCOUNT, NULL);
2219 if (!rt)
1da177e4
LT		 2220 return ERR_PTR(-ENOMEM);
2221
1da177e4
LT		 2222 in6_dev_hold(idev);
2223
11d53b49 2224 rt->dst.flags |= DST_HOST;
d8d1f30b
CG		 2225 rt->dst.input = ip6_input;
2226 rt->dst.output = ip6_output;
1da177e4 2227 rt->rt6i_idev = idev;
1da177e4
LT		 2228
2229 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
58c4fb86
YH		 2230 if (anycast)
2231 rt->rt6i_flags |= RTF_ANYCAST;
2232 else
1da177e4 2233 rt->rt6i_flags |= RTF_LOCAL;
1da177e4 2234
550bab42 2235 rt->rt6i_gateway = *addr;
4e3fd7a0 2236 rt->rt6i_dst.addr = *addr;
1da177e4 2237 rt->rt6i_dst.plen = 128;
5578689a 2238 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
1da177e4 2239
d8d1f30b 2240 atomic_set(&rt->dst.__refcnt, 1);
1da177e4
LT		 2241
2242 return rt;
2243}
2244
c3968a85
DW		 2245int ip6_route_get_saddr(struct net *net,
2246 struct rt6_info *rt,
b71d1d42 2247 const struct in6_addr *daddr,
c3968a85
DW		 2248 unsigned int prefs,
2249 struct in6_addr *saddr)
2250{
67ba4152 2251 struct inet6_dev *idev = ip6_dst_idev((struct dst_entry *)rt);
c3968a85
DW		 2252 int err = 0;
2253 if (rt->rt6i_prefsrc.plen)
4e3fd7a0 2254 *saddr = rt->rt6i_prefsrc.addr;
c3968a85
DW		 2255 else
2256 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2257 daddr, prefs, saddr);
2258 return err;
2259}
2260
2261/* remove deleted ip from prefsrc entries */
2262struct arg_dev_net_ip {
2263 struct net_device *dev;
2264 struct net *net;
2265 struct in6_addr *addr;
2266};
2267
2268static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2269{
2270 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2271 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2272 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2273
d1918542 2274 if (((void *)rt->dst.dev == dev || !dev) &&
c3968a85
DW		 2275 rt != net->ipv6.ip6_null_entry &&
2276 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2277 /* remove prefsrc entry */
2278 rt->rt6i_prefsrc.plen = 0;
2279 }
2280 return 0;
2281}
2282
2283void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2284{
2285 struct net *net = dev_net(ifp->idev->dev);
2286 struct arg_dev_net_ip adni = {
2287 .dev = ifp->idev->dev,
2288 .net = net,
2289 .addr = &ifp->addr,
2290 };
0c3584d5 2291 fib6_clean_all(net, fib6_remove_prefsrc, &adni);
c3968a85
DW		 2292}
2293
be7a010d
DJ		 2294#define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2295#define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)
2296
2297/* Remove routers and update dst entries when gateway turn into host. */
2298static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
2299{
2300 struct in6_addr *gateway = (struct in6_addr *)arg;
2301
2302 if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
2303 ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
2304 ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
2305 return -1;
2306 }
2307 return 0;
2308}
2309
2310void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
2311{
2312 fib6_clean_all(net, fib6_clean_tohost, gateway);
2313}
2314
8ed67789
DL		 2315struct arg_dev_net {
2316 struct net_device *dev;
2317 struct net *net;
2318};
2319
1da177e4
LT		 2320static int fib6_ifdown(struct rt6_info *rt, void *arg)
2321{
bc3ef660 2322 const struct arg_dev_net *adn = arg;
2323 const struct net_device *dev = adn->dev;
8ed67789 2324
d1918542 2325 if ((rt->dst.dev == dev || !dev) &&
c159d30c 2326 rt != adn->net->ipv6.ip6_null_entry)
1da177e4 2327 return -1;
c159d30c 2328
1da177e4
LT		 2329 return 0;
2330}
2331
f3db4851 2332void rt6_ifdown(struct net *net, struct net_device *dev)
1da177e4 2333{
8ed67789
DL		 2334 struct arg_dev_net adn = {
2335 .dev = dev,
2336 .net = net,
2337 };
2338
0c3584d5 2339 fib6_clean_all(net, fib6_ifdown, &adn);
1e493d19 2340 icmp6_clean_all(fib6_ifdown, &adn);
1da177e4
LT		 2341}
2342
95c96174 2343struct rt6_mtu_change_arg {
1da177e4 2344 struct net_device *dev;
95c96174 2345 unsigned int mtu;
1da177e4
LT		 2346};
2347
2348static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2349{
2350 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2351 struct inet6_dev *idev;
2352
2353 /* In IPv6 pmtu discovery is not optional,
2354 so that RTAX_MTU lock cannot disable it.
2355 We still use this lock to block changes
2356 caused by addrconf/ndisc.
2357 */
2358
2359 idev = __in6_dev_get(arg->dev);
38308473 2360 if (!idev)
1da177e4
LT		 2361 return 0;
2362
2363 /* For administrative MTU increase, there is no way to discover
2364 IPv6 PMTU increase, so PMTU increase should be updated here.
2365 Since RFC 1981 doesn't include administrative MTU increase
2366 update PMTU increase is a MUST. (i.e. jumbo frame)
2367 */
2368 /*
2369 If new MTU is less than route PMTU, this new MTU will be the
2370 lowest MTU in the path, update the route PMTU to reflect PMTU
2371 decreases; if new MTU is greater than route PMTU, and the
2372 old MTU is the lowest MTU in the path, update the route PMTU
2373 to reflect the increase. In this case if the other nodes' MTU
2374 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2375 PMTU discouvery.
2376 */
d1918542 2377 if (rt->dst.dev == arg->dev &&
d8d1f30b
CG		 2378 !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2379 (dst_mtu(&rt->dst) >= arg->mtu ||
2380 (dst_mtu(&rt->dst) < arg->mtu &&
2381 dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
defb3519 2382 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
566cfd8f 2383 }
1da177e4
LT		 2384 return 0;
2385}
2386
95c96174 2387void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
1da177e4 2388{
c71099ac
TG		 2389 struct rt6_mtu_change_arg arg = {
2390 .dev = dev,
2391 .mtu = mtu,
2392 };
1da177e4 2393
0c3584d5 2394 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
1da177e4
LT		 2395}
2396
ef7c79ed 2397static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
5176f91e 2398 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
86872cb5 2399 [RTA_OIF] = { .type = NLA_U32 },
ab364a6f 2400 [RTA_IIF] = { .type = NLA_U32 },
86872cb5
TG		 2401 [RTA_PRIORITY] = { .type = NLA_U32 },
2402 [RTA_METRICS] = { .type = NLA_NESTED },
51ebd318 2403 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
c78ba6d6 2404 [RTA_PREF] = { .type = NLA_U8 },
86872cb5
TG		 2405};
2406
2407static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2408 struct fib6_config *cfg)
1da177e4 2409{
86872cb5
TG		 2410 struct rtmsg *rtm;
2411 struct nlattr *tb[RTA_MAX+1];
c78ba6d6 2412 unsigned int pref;
86872cb5 2413 int err;
1da177e4 2414
86872cb5
TG		 2415 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2416 if (err < 0)
2417 goto errout;
1da177e4 2418
86872cb5
TG		 2419 err = -EINVAL;
2420 rtm = nlmsg_data(nlh);
2421 memset(cfg, 0, sizeof(*cfg));
2422
2423 cfg->fc_table = rtm->rtm_table;
2424 cfg->fc_dst_len = rtm->rtm_dst_len;
2425 cfg->fc_src_len = rtm->rtm_src_len;
2426 cfg->fc_flags = RTF_UP;
2427 cfg->fc_protocol = rtm->rtm_protocol;
ef2c7d7b 2428 cfg->fc_type = rtm->rtm_type;
86872cb5 2429
ef2c7d7b
ND		 2430 if (rtm->rtm_type == RTN_UNREACHABLE ||
2431 rtm->rtm_type == RTN_BLACKHOLE ||
b4949ab2
ND		 2432 rtm->rtm_type == RTN_PROHIBIT ||
2433 rtm->rtm_type == RTN_THROW)
86872cb5
TG		 2434 cfg->fc_flags |= RTF_REJECT;
2435
ab79ad14
MŻ		 2436 if (rtm->rtm_type == RTN_LOCAL)
2437 cfg->fc_flags |= RTF_LOCAL;
2438
1f56a01f
MKL		 2439 if (rtm->rtm_flags & RTM_F_CLONED)
2440 cfg->fc_flags |= RTF_CACHE;
2441
15e47304 2442 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
86872cb5 2443 cfg->fc_nlinfo.nlh = nlh;
3b1e0a65 2444 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
86872cb5
TG		 2445
2446 if (tb[RTA_GATEWAY]) {
67b61f6c 2447 cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
86872cb5 2448 cfg->fc_flags |= RTF_GATEWAY;
1da177e4 2449 }
86872cb5
TG		 2450
2451 if (tb[RTA_DST]) {
2452 int plen = (rtm->rtm_dst_len + 7) >> 3;
2453
2454 if (nla_len(tb[RTA_DST]) < plen)
2455 goto errout;
2456
2457 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1da177e4 2458 }
86872cb5
TG		 2459
2460 if (tb[RTA_SRC]) {
2461 int plen = (rtm->rtm_src_len + 7) >> 3;
2462
2463 if (nla_len(tb[RTA_SRC]) < plen)
2464 goto errout;
2465
2466 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1da177e4 2467 }
86872cb5 2468
c3968a85 2469 if (tb[RTA_PREFSRC])
67b61f6c 2470 cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);
c3968a85 2471
86872cb5
TG		 2472 if (tb[RTA_OIF])
2473 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2474
2475 if (tb[RTA_PRIORITY])
2476 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2477
2478 if (tb[RTA_METRICS]) {
2479 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2480 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
1da177e4 2481 }
86872cb5
TG		 2482
2483 if (tb[RTA_TABLE])
2484 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2485
51ebd318
ND		 2486 if (tb[RTA_MULTIPATH]) {
2487 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2488 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2489 }
2490
c78ba6d6
LR		 2491 if (tb[RTA_PREF]) {
2492 pref = nla_get_u8(tb[RTA_PREF]);
2493 if (pref != ICMPV6_ROUTER_PREF_LOW &&
2494 pref != ICMPV6_ROUTER_PREF_HIGH)
2495 pref = ICMPV6_ROUTER_PREF_MEDIUM;
2496 cfg->fc_flags |= RTF_PREF(pref);
2497 }
2498
86872cb5
TG		 2499 err = 0;
2500errout:
2501 return err;
1da177e4
LT		 2502}
2503
51ebd318
ND		 2504static int ip6_route_multipath(struct fib6_config *cfg, int add)
2505{
2506 struct fib6_config r_cfg;
2507 struct rtnexthop *rtnh;
2508 int remaining;
2509 int attrlen;
2510 int err = 0, last_err = 0;
2511
2512beginning:
2513 rtnh = (struct rtnexthop *)cfg->fc_mp;
2514 remaining = cfg->fc_mp_len;
2515
2516 /* Parse a Multipath Entry */
2517 while (rtnh_ok(rtnh, remaining)) {
2518 memcpy(&r_cfg, cfg, sizeof(*cfg));
2519 if (rtnh->rtnh_ifindex)
2520 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2521
2522 attrlen = rtnh_attrlen(rtnh);
2523 if (attrlen > 0) {
2524 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2525
2526 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2527 if (nla) {
67b61f6c 2528 r_cfg.fc_gateway = nla_get_in6_addr(nla);
51ebd318
ND		 2529 r_cfg.fc_flags |= RTF_GATEWAY;
2530 }
2531 }
2532 err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2533 if (err) {
2534 last_err = err;
2535 /* If we are trying to remove a route, do not stop the
2536 * loop when ip6_route_del() fails (because next hop is
2537 * already gone), we should try to remove all next hops.
2538 */
2539 if (add) {
2540 /* If add fails, we should try to delete all
2541 * next hops that have been already added.
2542 */
2543 add = 0;
2544 goto beginning;
2545 }
2546 }
1a72418b
ND		 2547 /* Because each route is added like a single route we remove
2548 * this flag after the first nexthop (if there is a collision,
2549 * we have already fail to add the first nexthop:
2550 * fib6_add_rt2node() has reject it).
2551 */
2552 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;
51ebd318
ND		 2553 rtnh = rtnh_next(rtnh, &remaining);
2554 }
2555
2556 return last_err;
2557}
2558
67ba4152 2559static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
1da177e4 2560{
86872cb5
TG		 2561 struct fib6_config cfg;
2562 int err;
1da177e4 2563
86872cb5
TG		 2564 err = rtm_to_fib6_config(skb, nlh, &cfg);
2565 if (err < 0)
2566 return err;
2567
51ebd318
ND		 2568 if (cfg.fc_mp)
2569 return ip6_route_multipath(&cfg, 0);
2570 else
2571 return ip6_route_del(&cfg);
1da177e4
LT		 2572}
2573
67ba4152 2574static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
1da177e4 2575{
86872cb5
TG		 2576 struct fib6_config cfg;
2577 int err;
1da177e4 2578
86872cb5
TG		 2579 err = rtm_to_fib6_config(skb, nlh, &cfg);
2580 if (err < 0)
2581 return err;
2582
51ebd318
ND		 2583 if (cfg.fc_mp)
2584 return ip6_route_multipath(&cfg, 1);
2585 else
2586 return ip6_route_add(&cfg);
1da177e4
LT		 2587}
2588
339bf98f
TG		 2589static inline size_t rt6_nlmsg_size(void)
2590{
2591 return NLMSG_ALIGN(sizeof(struct rtmsg))
2592 + nla_total_size(16) /* RTA_SRC */
2593 + nla_total_size(16) /* RTA_DST */
2594 + nla_total_size(16) /* RTA_GATEWAY */
2595 + nla_total_size(16) /* RTA_PREFSRC */
2596 + nla_total_size(4) /* RTA_TABLE */
2597 + nla_total_size(4) /* RTA_IIF */
2598 + nla_total_size(4) /* RTA_OIF */
2599 + nla_total_size(4) /* RTA_PRIORITY */
6a2b9ce0 2600 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
ea697639 2601 + nla_total_size(sizeof(struct rta_cacheinfo))
c78ba6d6
LR		 2602 + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
2603 + nla_total_size(1); /* RTA_PREF */
339bf98f
TG		 2604}
2605
191cd582
BH		 2606static int rt6_fill_node(struct net *net,
2607 struct sk_buff *skb, struct rt6_info *rt,
0d51aa80 2608 struct in6_addr *dst, struct in6_addr *src,
15e47304 2609 int iif, int type, u32 portid, u32 seq,
7bc570c8 2610 int prefix, int nowait, unsigned int flags)
1da177e4
LT		 2611{
2612 struct rtmsg *rtm;
2d7202bf 2613 struct nlmsghdr *nlh;
e3703b3d 2614 long expires;
9e762a4a 2615 u32 table;
1da177e4
LT		 2616
2617 if (prefix) { /* user wants prefix routes only */
2618 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2619 /* success since this is not a prefix route */
2620 return 1;
2621 }
2622 }
2623
15e47304 2624 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
38308473 2625 if (!nlh)
26932566 2626 return -EMSGSIZE;
2d7202bf
TG		 2627
2628 rtm = nlmsg_data(nlh);
1da177e4
LT		 2629 rtm->rtm_family = AF_INET6;
2630 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2631 rtm->rtm_src_len = rt->rt6i_src.plen;
2632 rtm->rtm_tos = 0;
c71099ac 2633 if (rt->rt6i_table)
9e762a4a 2634 table = rt->rt6i_table->tb6_id;
c71099ac 2635 else
9e762a4a
PM		 2636 table = RT6_TABLE_UNSPEC;
2637 rtm->rtm_table = table;
c78679e8
DM		 2638 if (nla_put_u32(skb, RTA_TABLE, table))
2639 goto nla_put_failure;
ef2c7d7b
ND		 2640 if (rt->rt6i_flags & RTF_REJECT) {
2641 switch (rt->dst.error) {
2642 case -EINVAL:
2643 rtm->rtm_type = RTN_BLACKHOLE;
2644 break;
2645 case -EACCES:
2646 rtm->rtm_type = RTN_PROHIBIT;
2647 break;
b4949ab2
ND		 2648 case -EAGAIN:
2649 rtm->rtm_type = RTN_THROW;
2650 break;
ef2c7d7b
ND		 2651 default:
2652 rtm->rtm_type = RTN_UNREACHABLE;
2653 break;
2654 }
2655 }
38308473 2656 else if (rt->rt6i_flags & RTF_LOCAL)
ab79ad14 2657 rtm->rtm_type = RTN_LOCAL;
d1918542 2658 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
1da177e4
LT		 2659 rtm->rtm_type = RTN_LOCAL;
2660 else
2661 rtm->rtm_type = RTN_UNICAST;
2662 rtm->rtm_flags = 0;
2663 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2664 rtm->rtm_protocol = rt->rt6i_protocol;
38308473 2665 if (rt->rt6i_flags & RTF_DYNAMIC)
1da177e4 2666 rtm->rtm_protocol = RTPROT_REDIRECT;
f0396f60
DO		 2667 else if (rt->rt6i_flags & RTF_ADDRCONF) {
2668 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2669 rtm->rtm_protocol = RTPROT_RA;
2670 else
2671 rtm->rtm_protocol = RTPROT_KERNEL;
2672 }
1da177e4 2673
38308473 2674 if (rt->rt6i_flags & RTF_CACHE)
1da177e4
LT		 2675 rtm->rtm_flags |= RTM_F_CLONED;
2676
2677 if (dst) {
930345ea 2678 if (nla_put_in6_addr(skb, RTA_DST, dst))
c78679e8 2679 goto nla_put_failure;
1ab1457c 2680 rtm->rtm_dst_len = 128;
1da177e4 2681 } else if (rtm->rtm_dst_len)
930345ea 2682 if (nla_put_in6_addr(skb, RTA_DST, &rt->rt6i_dst.addr))
c78679e8 2683 goto nla_put_failure;
1da177e4
LT		 2684#ifdef CONFIG_IPV6_SUBTREES
2685 if (src) {
930345ea 2686 if (nla_put_in6_addr(skb, RTA_SRC, src))
c78679e8 2687 goto nla_put_failure;
1ab1457c 2688 rtm->rtm_src_len = 128;
c78679e8 2689 } else if (rtm->rtm_src_len &&
930345ea 2690 nla_put_in6_addr(skb, RTA_SRC, &rt->rt6i_src.addr))
c78679e8 2691 goto nla_put_failure;
1da177e4 2692#endif
7bc570c8
YH		 2693 if (iif) {
2694#ifdef CONFIG_IPV6_MROUTE
2695 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
8229efda 2696 int err = ip6mr_get_route(net, skb, rtm, nowait);
7bc570c8
YH		 2697 if (err <= 0) {
2698 if (!nowait) {
2699 if (err == 0)
2700 return 0;
2701 goto nla_put_failure;
2702 } else {
2703 if (err == -EMSGSIZE)
2704 goto nla_put_failure;
2705 }
2706 }
2707 } else
2708#endif
c78679e8
DM		 2709 if (nla_put_u32(skb, RTA_IIF, iif))
2710 goto nla_put_failure;
7bc570c8 2711 } else if (dst) {
1da177e4 2712 struct in6_addr saddr_buf;
c78679e8 2713 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
930345ea 2714 nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
c78679e8 2715 goto nla_put_failure;
1da177e4 2716 }
2d7202bf 2717
c3968a85
DW		 2718 if (rt->rt6i_prefsrc.plen) {
2719 struct in6_addr saddr_buf;
4e3fd7a0 2720 saddr_buf = rt->rt6i_prefsrc.addr;
930345ea 2721 if (nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
c78679e8 2722 goto nla_put_failure;
c3968a85
DW		 2723 }
2724
defb3519 2725 if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2d7202bf
TG		 2726 goto nla_put_failure;
2727
dd0cbf29 2728 if (rt->rt6i_flags & RTF_GATEWAY) {
930345ea 2729 if (nla_put_in6_addr(skb, RTA_GATEWAY, &rt->rt6i_gateway) < 0)
94f826b8 2730 goto nla_put_failure;
94f826b8 2731 }
2d7202bf 2732
c78679e8
DM		 2733 if (rt->dst.dev &&
2734 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2735 goto nla_put_failure;
2736 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2737 goto nla_put_failure;
8253947e
LW		 2738
2739 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
69cdf8f9 2740
87a50699 2741 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
e3703b3d 2742 goto nla_put_failure;
2d7202bf 2743
c78ba6d6
LR		 2744 if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt->rt6i_flags)))
2745 goto nla_put_failure;
2746
053c095a
JB		 2747 nlmsg_end(skb, nlh);
2748 return 0;
2d7202bf
TG		 2749
2750nla_put_failure:
26932566
PM		 2751 nlmsg_cancel(skb, nlh);
2752 return -EMSGSIZE;
1da177e4
LT		 2753}
2754
1b43af54 2755int rt6_dump_route(struct rt6_info *rt, void *p_arg)
1da177e4
LT		 2756{
2757 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2758 int prefix;
2759
2d7202bf
TG		 2760 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2761 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
1da177e4
LT		 2762 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2763 } else
2764 prefix = 0;
2765
191cd582
BH		 2766 return rt6_fill_node(arg->net,
2767 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
15e47304 2768 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
7bc570c8 2769 prefix, 0, NLM_F_MULTI);
1da177e4
LT		 2770}
2771
67ba4152 2772static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
1da177e4 2773{
3b1e0a65 2774 struct net *net = sock_net(in_skb->sk);
ab364a6f
TG		 2775 struct nlattr *tb[RTA_MAX+1];
2776 struct rt6_info *rt;
1da177e4 2777 struct sk_buff *skb;
ab364a6f 2778 struct rtmsg *rtm;
4c9483b2 2779 struct flowi6 fl6;
72331bc0 2780 int err, iif = 0, oif = 0;
1da177e4 2781
ab364a6f
TG		 2782 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2783 if (err < 0)
2784 goto errout;
1da177e4 2785
ab364a6f 2786 err = -EINVAL;
4c9483b2 2787 memset(&fl6, 0, sizeof(fl6));
1da177e4 2788
ab364a6f
TG		 2789 if (tb[RTA_SRC]) {
2790 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2791 goto errout;
2792
4e3fd7a0 2793 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
ab364a6f
TG		 2794 }
2795
2796 if (tb[RTA_DST]) {
2797 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2798 goto errout;
2799
4e3fd7a0 2800 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
ab364a6f
TG		 2801 }
2802
2803 if (tb[RTA_IIF])
2804 iif = nla_get_u32(tb[RTA_IIF]);
2805
2806 if (tb[RTA_OIF])
72331bc0 2807 oif = nla_get_u32(tb[RTA_OIF]);
1da177e4 2808
2e47b291
LC		 2809 if (tb[RTA_MARK])
2810 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
2811
1da177e4
LT		 2812 if (iif) {
2813 struct net_device *dev;
72331bc0
SL		 2814 int flags = 0;
2815
5578689a 2816 dev = __dev_get_by_index(net, iif);
1da177e4
LT		 2817 if (!dev) {
2818 err = -ENODEV;
ab364a6f 2819 goto errout;
1da177e4 2820 }
72331bc0
SL		 2821
2822 fl6.flowi6_iif = iif;
2823
2824 if (!ipv6_addr_any(&fl6.saddr))
2825 flags |= RT6_LOOKUP_F_HAS_SADDR;
2826
2827 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2828 flags);
2829 } else {
2830 fl6.flowi6_oif = oif;
2831
2832 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
1da177e4
LT		 2833 }
2834
ab364a6f 2835 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
38308473 2836 if (!skb) {
94e187c0 2837 ip6_rt_put(rt);
ab364a6f
TG		 2838 err = -ENOBUFS;
2839 goto errout;
2840 }
1da177e4 2841
ab364a6f
TG		 2842 /* Reserve room for dummy headers, this skb can pass
2843 through good chunk of routing engine.
2844 */
459a98ed 2845 skb_reset_mac_header(skb);
ab364a6f 2846 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
1da177e4 2847
d8d1f30b 2848 skb_dst_set(skb, &rt->dst);
1da177e4 2849
4c9483b2 2850 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
15e47304 2851 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
7bc570c8 2852 nlh->nlmsg_seq, 0, 0, 0);
1da177e4 2853 if (err < 0) {
ab364a6f
TG		 2854 kfree_skb(skb);
2855 goto errout;
1da177e4
LT		 2856 }
2857
15e47304 2858 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
ab364a6f 2859errout:
1da177e4 2860 return err;
1da177e4
LT		 2861}
2862
86872cb5 2863void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 2864{
2865 struct sk_buff *skb;
5578689a 2866 struct net *net = info->nl_net;
528c4ceb
DL		 2867 u32 seq;
2868 int err;
2869
2870 err = -ENOBUFS;
38308473 2871 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
86872cb5 2872
339bf98f 2873 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
38308473 2874 if (!skb)
21713ebc
TG		 2875 goto errout;
2876
191cd582 2877 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
15e47304 2878 event, info->portid, seq, 0, 0, 0);
26932566
PM		 2879 if (err < 0) {
2880 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2881 WARN_ON(err == -EMSGSIZE);
2882 kfree_skb(skb);
2883 goto errout;
2884 }
15e47304 2885 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
1ce85fe4
PNA		 2886 info->nlh, gfp_any());
2887 return;
21713ebc
TG		 2888errout:
2889 if (err < 0)
5578689a 2890 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
1da177e4
LT		 2891}
2892
8ed67789 2893static int ip6_route_dev_notify(struct notifier_block *this,
351638e7 2894 unsigned long event, void *ptr)
8ed67789 2895{
351638e7 2896 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
c346dca1 2897 struct net *net = dev_net(dev);
8ed67789
DL		 2898
2899 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
d8d1f30b 2900 net->ipv6.ip6_null_entry->dst.dev = dev;
8ed67789
DL		 2901 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2902#ifdef CONFIG_IPV6_MULTIPLE_TABLES
d8d1f30b 2903 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
8ed67789 2904 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
d8d1f30b 2905 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
8ed67789
DL		 2906 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2907#endif
2908 }
2909
2910 return NOTIFY_OK;
2911}
2912
1da177e4
LT		 2913/*
2914 * /proc
2915 */
2916
2917#ifdef CONFIG_PROC_FS
2918
33120b30
AD		 2919static const struct file_operations ipv6_route_proc_fops = {
2920 .owner = THIS_MODULE,
2921 .open = ipv6_route_open,
2922 .read = seq_read,
2923 .llseek = seq_lseek,
8d2ca1d7 2924 .release = seq_release_net,
33120b30
AD		 2925};
2926
1da177e4
LT		 2927static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2928{
69ddb805 2929 struct net *net = (struct net *)seq->private;
1da177e4 2930 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
69ddb805
DL		 2931 net->ipv6.rt6_stats->fib_nodes,
2932 net->ipv6.rt6_stats->fib_route_nodes,
2933 net->ipv6.rt6_stats->fib_rt_alloc,
2934 net->ipv6.rt6_stats->fib_rt_entries,
2935 net->ipv6.rt6_stats->fib_rt_cache,
fc66f95c 2936 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
69ddb805 2937 net->ipv6.rt6_stats->fib_discarded_routes);
1da177e4
LT		 2938
2939 return 0;
2940}
2941
2942static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2943{
de05c557 2944 return single_open_net(inode, file, rt6_stats_seq_show);
69ddb805
DL		 2945}
2946
9a32144e 2947static const struct file_operations rt6_stats_seq_fops = {
1da177e4
LT		 2948 .owner = THIS_MODULE,
2949 .open = rt6_stats_seq_open,
2950 .read = seq_read,
2951 .llseek = seq_lseek,
b6fcbdb4 2952 .release = single_release_net,
1da177e4
LT		 2953};
2954#endif /* CONFIG_PROC_FS */
2955
2956#ifdef CONFIG_SYSCTL
2957
1da177e4 2958static
fe2c6338 2959int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
1da177e4
LT		 2960 void __user *buffer, size_t *lenp, loff_t *ppos)
2961{
c486da34
LAG		 2962 struct net *net;
2963 int delay;
2964 if (!write)
1da177e4 2965 return -EINVAL;
c486da34
LAG		 2966
2967 net = (struct net *)ctl->extra1;
2968 delay = net->ipv6.sysctl.flush_delay;
2969 proc_dointvec(ctl, write, buffer, lenp, ppos);
2ac3ac8f 2970 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
c486da34 2971 return 0;
1da177e4
LT		 2972}
2973
fe2c6338 2974struct ctl_table ipv6_route_table_template[] = {
1ab1457c 2975 {
1da177e4 2976 .procname = "flush",
4990509f 2977 .data = &init_net.ipv6.sysctl.flush_delay,
1da177e4 2978 .maxlen = sizeof(int),
89c8b3a1 2979 .mode = 0200,
6d9f239a 2980 .proc_handler = ipv6_sysctl_rtcache_flush
1da177e4
LT		 2981 },
2982 {
1da177e4 2983 .procname = "gc_thresh",
9a7ec3a9 2984 .data = &ip6_dst_ops_template.gc_thresh,
1da177e4
LT		 2985 .maxlen = sizeof(int),
2986 .mode = 0644,
6d9f239a 2987 .proc_handler = proc_dointvec,
1da177e4
LT		 2988 },
2989 {
1da177e4 2990 .procname = "max_size",
4990509f 2991 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
1da177e4
LT		 2992 .maxlen = sizeof(int),
2993 .mode = 0644,
6d9f239a 2994 .proc_handler = proc_dointvec,
1da177e4
LT		 2995 },
2996 {
1da177e4 2997 .procname = "gc_min_interval",
4990509f 2998 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 2999 .maxlen = sizeof(int),
3000 .mode = 0644,
6d9f239a 3001 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3002 },
3003 {
1da177e4 3004 .procname = "gc_timeout",
4990509f 3005 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
1da177e4
LT		 3006 .maxlen = sizeof(int),
3007 .mode = 0644,
6d9f239a 3008 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3009 },
3010 {
1da177e4 3011 .procname = "gc_interval",
4990509f 3012 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
1da177e4
LT		 3013 .maxlen = sizeof(int),
3014 .mode = 0644,
6d9f239a 3015 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3016 },
3017 {
1da177e4 3018 .procname = "gc_elasticity",
4990509f 3019 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
1da177e4
LT		 3020 .maxlen = sizeof(int),
3021 .mode = 0644,
f3d3f616 3022 .proc_handler = proc_dointvec,
1da177e4
LT		 3023 },
3024 {
1da177e4 3025 .procname = "mtu_expires",
4990509f 3026 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
1da177e4
LT		 3027 .maxlen = sizeof(int),
3028 .mode = 0644,
6d9f239a 3029 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3030 },
3031 {
1da177e4 3032 .procname = "min_adv_mss",
4990509f 3033 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
1da177e4
LT		 3034 .maxlen = sizeof(int),
3035 .mode = 0644,
f3d3f616 3036 .proc_handler = proc_dointvec,
1da177e4
LT		 3037 },
3038 {
1da177e4 3039 .procname = "gc_min_interval_ms",
4990509f 3040 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 3041 .maxlen = sizeof(int),
3042 .mode = 0644,
6d9f239a 3043 .proc_handler = proc_dointvec_ms_jiffies,
1da177e4 3044 },
f8572d8f 3045 { }
1da177e4
LT		 3046};
3047
2c8c1e72 3048struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
760f2d01
DL		 3049{
3050 struct ctl_table *table;
3051
3052 table = kmemdup(ipv6_route_table_template,
3053 sizeof(ipv6_route_table_template),
3054 GFP_KERNEL);
5ee09105
YH		 3055
3056 if (table) {
3057 table[0].data = &net->ipv6.sysctl.flush_delay;
c486da34 3058 table[0].extra1 = net;
86393e52 3059 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
5ee09105
YH		 3060 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
3061 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3062 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
3063 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
3064 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
3065 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
3066 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
9c69fabe 3067 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
464dc801
EB		 3068
3069 /* Don't export sysctls to unprivileged users */
3070 if (net->user_ns != &init_user_ns)
3071 table[0].procname = NULL;
5ee09105
YH		 3072 }
3073
760f2d01
DL		 3074 return table;
3075}
1da177e4
LT		 3076#endif
3077
2c8c1e72 3078static int __net_init ip6_route_net_init(struct net *net)
cdb18761 3079{
633d424b 3080 int ret = -ENOMEM;
8ed67789 3081
86393e52
AD		 3082 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3083 sizeof(net->ipv6.ip6_dst_ops));
f2fc6a54 3084
fc66f95c
ED		 3085 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
3086 goto out_ip6_dst_ops;
3087
8ed67789
DL		 3088 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
3089 sizeof(*net->ipv6.ip6_null_entry),
3090 GFP_KERNEL);
3091 if (!net->ipv6.ip6_null_entry)
fc66f95c 3092 goto out_ip6_dst_entries;
d8d1f30b 3093 net->ipv6.ip6_null_entry->dst.path =
8ed67789 3094 (struct dst_entry *)net->ipv6.ip6_null_entry;
d8d1f30b 3095 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 3096 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3097 ip6_template_metrics, true);
8ed67789
DL		 3098
3099#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3100 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3101 sizeof(*net->ipv6.ip6_prohibit_entry),
3102 GFP_KERNEL);
68fffc67
PZ		 3103 if (!net->ipv6.ip6_prohibit_entry)
3104 goto out_ip6_null_entry;
d8d1f30b 3105 net->ipv6.ip6_prohibit_entry->dst.path =
8ed67789 3106 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
d8d1f30b 3107 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 3108 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3109 ip6_template_metrics, true);
8ed67789
DL		 3110
3111 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3112 sizeof(*net->ipv6.ip6_blk_hole_entry),
3113 GFP_KERNEL);
68fffc67
PZ		 3114 if (!net->ipv6.ip6_blk_hole_entry)
3115 goto out_ip6_prohibit_entry;
d8d1f30b 3116 net->ipv6.ip6_blk_hole_entry->dst.path =
8ed67789 3117 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
d8d1f30b 3118 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 3119 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3120 ip6_template_metrics, true);
8ed67789
DL		 3121#endif
3122
b339a47c
PZ		 3123 net->ipv6.sysctl.flush_delay = 0;
3124 net->ipv6.sysctl.ip6_rt_max_size = 4096;
3125 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3126 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3127 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3128 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3129 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3130 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3131
6891a346
BT		 3132 net->ipv6.ip6_rt_gc_expire = 30*HZ;
3133
8ed67789
DL		 3134 ret = 0;
3135out:
3136 return ret;
f2fc6a54 3137
68fffc67
PZ		 3138#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3139out_ip6_prohibit_entry:
3140 kfree(net->ipv6.ip6_prohibit_entry);
3141out_ip6_null_entry:
3142 kfree(net->ipv6.ip6_null_entry);
3143#endif
fc66f95c
ED		 3144out_ip6_dst_entries:
3145 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
f2fc6a54 3146out_ip6_dst_ops:
f2fc6a54 3147 goto out;
cdb18761
DL		 3148}
3149
2c8c1e72 3150static void __net_exit ip6_route_net_exit(struct net *net)
cdb18761 3151{
8ed67789
DL		 3152 kfree(net->ipv6.ip6_null_entry);
3153#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3154 kfree(net->ipv6.ip6_prohibit_entry);
3155 kfree(net->ipv6.ip6_blk_hole_entry);
3156#endif
41bb78b4 3157 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
cdb18761
DL		 3158}
3159
d189634e
TG		 3160static int __net_init ip6_route_net_init_late(struct net *net)
3161{
3162#ifdef CONFIG_PROC_FS
d4beaa66
G		 3163 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3164 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
d189634e
TG		 3165#endif
3166 return 0;
3167}
3168
3169static void __net_exit ip6_route_net_exit_late(struct net *net)
3170{
3171#ifdef CONFIG_PROC_FS
ece31ffd
G		 3172 remove_proc_entry("ipv6_route", net->proc_net);
3173 remove_proc_entry("rt6_stats", net->proc_net);
d189634e
TG		 3174#endif
3175}
3176
cdb18761
DL		 3177static struct pernet_operations ip6_route_net_ops = {
3178 .init = ip6_route_net_init,
3179 .exit = ip6_route_net_exit,
3180};
3181
c3426b47
DM		 3182static int __net_init ipv6_inetpeer_init(struct net *net)
3183{
3184 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3185
3186 if (!bp)
3187 return -ENOMEM;
3188 inet_peer_base_init(bp);
3189 net->ipv6.peers = bp;
3190 return 0;
3191}
3192
3193static void __net_exit ipv6_inetpeer_exit(struct net *net)
3194{
3195 struct inet_peer_base *bp = net->ipv6.peers;
3196
3197 net->ipv6.peers = NULL;
56a6b248 3198 inetpeer_invalidate_tree(bp);
c3426b47
DM		 3199 kfree(bp);
3200}
3201
2b823f72 3202static struct pernet_operations ipv6_inetpeer_ops = {
c3426b47
DM		 3203 .init = ipv6_inetpeer_init,
3204 .exit = ipv6_inetpeer_exit,
3205};
3206
d189634e
TG		 3207static struct pernet_operations ip6_route_net_late_ops = {
3208 .init = ip6_route_net_init_late,
3209 .exit = ip6_route_net_exit_late,
3210};
3211
8ed67789
DL		 3212static struct notifier_block ip6_route_dev_notifier = {
3213 .notifier_call = ip6_route_dev_notify,
3214 .priority = 0,
3215};
3216
433d49c3 3217int __init ip6_route_init(void)
1da177e4 3218{
433d49c3
DL		 3219 int ret;
3220
9a7ec3a9
DL		 3221 ret = -ENOMEM;
3222 ip6_dst_ops_template.kmem_cachep =
e5d679f3 3223 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
f845ab6b 3224 SLAB_HWCACHE_ALIGN, NULL);
9a7ec3a9 3225 if (!ip6_dst_ops_template.kmem_cachep)
c19a28e1 3226 goto out;
14e50e57 3227
fc66f95c 3228 ret = dst_entries_init(&ip6_dst_blackhole_ops);
8ed67789 3229 if (ret)
bdb3289f 3230 goto out_kmem_cache;
bdb3289f 3231
c3426b47
DM		 3232 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3233 if (ret)
e8803b6c 3234 goto out_dst_entries;
2a0c451a 3235
7e52b33b
DM		 3236 ret = register_pernet_subsys(&ip6_route_net_ops);
3237 if (ret)
3238 goto out_register_inetpeer;
c3426b47 3239
5dc121e9
AE		 3240 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3241
8ed67789
DL		 3242 /* Registering of the loopback is done before this portion of code,
3243 * the loopback reference in rt6_info will not be taken, do it
3244 * manually for init_net */
d8d1f30b 3245 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
8ed67789
DL		 3246 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3247 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
d8d1f30b 3248 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
8ed67789 3249 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
d8d1f30b 3250 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
8ed67789
DL		 3251 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3252 #endif
e8803b6c 3253 ret = fib6_init();
433d49c3 3254 if (ret)
8ed67789 3255 goto out_register_subsys;
433d49c3 3256
433d49c3
DL		 3257 ret = xfrm6_init();
3258 if (ret)
e8803b6c 3259 goto out_fib6_init;
c35b7e72 3260
433d49c3
DL		 3261 ret = fib6_rules_init();
3262 if (ret)
3263 goto xfrm6_init;
7e5449c2 3264
d189634e
TG		 3265 ret = register_pernet_subsys(&ip6_route_net_late_ops);
3266 if (ret)
3267 goto fib6_rules_init;
3268
433d49c3 3269 ret = -ENOBUFS;
c7ac8679
GR		 3270 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3271 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3272 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
d189634e 3273 goto out_register_late_subsys;
c127ea2c 3274
8ed67789 3275 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
cdb18761 3276 if (ret)
d189634e 3277 goto out_register_late_subsys;
8ed67789 3278
433d49c3
DL		 3279out:
3280 return ret;
3281
d189634e
TG		 3282out_register_late_subsys:
3283 unregister_pernet_subsys(&ip6_route_net_late_ops);
433d49c3 3284fib6_rules_init:
433d49c3
DL		 3285 fib6_rules_cleanup();
3286xfrm6_init:
433d49c3 3287 xfrm6_fini();
2a0c451a
TG		 3288out_fib6_init:
3289 fib6_gc_cleanup();
8ed67789
DL		 3290out_register_subsys:
3291 unregister_pernet_subsys(&ip6_route_net_ops);
7e52b33b
DM		 3292out_register_inetpeer:
3293 unregister_pernet_subsys(&ipv6_inetpeer_ops);
fc66f95c
ED		 3294out_dst_entries:
3295 dst_entries_destroy(&ip6_dst_blackhole_ops);
433d49c3 3296out_kmem_cache:
f2fc6a54 3297 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
433d49c3 3298 goto out;
1da177e4
LT		 3299}
3300
3301void ip6_route_cleanup(void)
3302{
8ed67789 3303 unregister_netdevice_notifier(&ip6_route_dev_notifier);
d189634e 3304 unregister_pernet_subsys(&ip6_route_net_late_ops);
101367c2 3305 fib6_rules_cleanup();
1da177e4 3306 xfrm6_fini();
1da177e4 3307 fib6_gc_cleanup();
c3426b47 3308 unregister_pernet_subsys(&ipv6_inetpeer_ops);
8ed67789 3309 unregister_pernet_subsys(&ip6_route_net_ops);
41bb78b4 3310 dst_entries_destroy(&ip6_dst_blackhole_ops);
f2fc6a54 3311 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
1da177e4 3312}
Linux 6.x block layer and io_uring tree(s)