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