]> git.ipfire.org Git - thirdparty/kernel/stable.git/blame - net/ipv6/route.c
projects / thirdparty / kernel / stable.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'rt6i_gateway'
[thirdparty/kernel/stable.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;
58c4fb86 854 }
1da177e4 855
1da177e4 856 rt->rt6i_flags |= RTF_CACHE;
1da177e4
LT		 857
858#ifdef CONFIG_IPV6_SUBTREES
859 if (rt->rt6i_src.plen && saddr) {
4e3fd7a0 860 rt->rt6i_src.addr = *saddr;
1da177e4
LT		 861 rt->rt6i_src.plen = 128;
862 }
863#endif
95a9a5ba 864 }
1da177e4 865
95a9a5ba
YH		 866 return rt;
867}
1da177e4 868
21efcfa0
ED		 869static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,
870 const struct in6_addr *daddr)
299d9939 871{
21efcfa0
ED		 872 struct rt6_info *rt = ip6_rt_copy(ort, daddr);
873
887c95cc 874 if (rt)
299d9939 875 rt->rt6i_flags |= RTF_CACHE;
299d9939
YH		 876 return rt;
877}
878
8ed67789 879static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
4c9483b2 880 struct flowi6 *fl6, int flags)
1da177e4
LT		 881{
882 struct fib6_node *fn;
519fbd87 883 struct rt6_info *rt, *nrt;
c71099ac 884 int strict = 0;
1da177e4 885 int attempts = 3;
519fbd87 886 int err;
53b7997f 887 int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
1da177e4 888
77d16f45 889 strict |= flags & RT6_LOOKUP_F_IFACE;
1da177e4
LT		 890
891relookup:
c71099ac 892 read_lock_bh(&table->tb6_lock);
1da177e4 893
8238dd06 894restart_2:
4c9483b2 895 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1da177e4
LT		 896
897restart:
4acad72d 898 rt = rt6_select(fn, oif, strict | reachable);
52bd4c0c
ND		 899 if (rt->rt6i_nsiblings)
900 rt = rt6_multipath_select(rt, fl6, oif, strict | reachable);
4c9483b2 901 BACKTRACK(net, &fl6->saddr);
8ed67789 902 if (rt == net->ipv6.ip6_null_entry ||
8238dd06 903 rt->rt6i_flags & RTF_CACHE)
1ddef044 904 goto out;
1da177e4 905
d8d1f30b 906 dst_hold(&rt->dst);
c71099ac 907 read_unlock_bh(&table->tb6_lock);
fb9de91e 908
c440f160 909 if (!(rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY)))
4c9483b2 910 nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);
7343ff31 911 else if (!(rt->dst.flags & DST_HOST))
4c9483b2 912 nrt = rt6_alloc_clone(rt, &fl6->daddr);
7343ff31
DM		 913 else
914 goto out2;
e40cf353 915
94e187c0 916 ip6_rt_put(rt);
8ed67789 917 rt = nrt ? : net->ipv6.ip6_null_entry;
1da177e4 918
d8d1f30b 919 dst_hold(&rt->dst);
519fbd87 920 if (nrt) {
40e22e8f 921 err = ip6_ins_rt(nrt);
519fbd87 922 if (!err)
1da177e4 923 goto out2;
1da177e4 924 }
1da177e4 925
519fbd87
YH		 926 if (--attempts <= 0)
927 goto out2;
928
929 /*
c71099ac 930 * Race condition! In the gap, when table->tb6_lock was
519fbd87
YH		 931 * released someone could insert this route. Relookup.
932 */
94e187c0 933 ip6_rt_put(rt);
519fbd87
YH		 934 goto relookup;
935
936out:
8238dd06
YH		 937 if (reachable) {
938 reachable = 0;
939 goto restart_2;
940 }
d8d1f30b 941 dst_hold(&rt->dst);
c71099ac 942 read_unlock_bh(&table->tb6_lock);
1da177e4 943out2:
d8d1f30b
CG		 944 rt->dst.lastuse = jiffies;
945 rt->dst.__use++;
c71099ac
TG		 946
947 return rt;
1da177e4
LT		 948}
949
8ed67789 950static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
4c9483b2 951 struct flowi6 *fl6, int flags)
4acad72d 952{
4c9483b2 953 return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
4acad72d
PE		 954}
955
72331bc0
SL		 956static struct dst_entry *ip6_route_input_lookup(struct net *net,
957 struct net_device *dev,
958 struct flowi6 *fl6, int flags)
959{
960 if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
961 flags |= RT6_LOOKUP_F_IFACE;
962
963 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
964}
965
c71099ac
TG		 966void ip6_route_input(struct sk_buff *skb)
967{
b71d1d42 968 const struct ipv6hdr *iph = ipv6_hdr(skb);
c346dca1 969 struct net *net = dev_net(skb->dev);
adaa70bb 970 int flags = RT6_LOOKUP_F_HAS_SADDR;
4c9483b2
DM		 971 struct flowi6 fl6 = {
972 .flowi6_iif = skb->dev->ifindex,
973 .daddr = iph->daddr,
974 .saddr = iph->saddr,
6502ca52 975 .flowlabel = ip6_flowinfo(iph),
4c9483b2
DM		 976 .flowi6_mark = skb->mark,
977 .flowi6_proto = iph->nexthdr,
c71099ac 978 };
adaa70bb 979
72331bc0 980 skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
c71099ac
TG		 981}
982
8ed67789 983static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
4c9483b2 984 struct flowi6 *fl6, int flags)
1da177e4 985{
4c9483b2 986 return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
c71099ac
TG		 987}
988
9c7a4f9c 989struct dst_entry * ip6_route_output(struct net *net, const struct sock *sk,
4c9483b2 990 struct flowi6 *fl6)
c71099ac
TG		 991{
992 int flags = 0;
993
1fb9489b 994 fl6->flowi6_iif = LOOPBACK_IFINDEX;
4dc27d1c 995
4c9483b2 996 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))
77d16f45 997 flags |= RT6_LOOKUP_F_IFACE;
c71099ac 998
4c9483b2 999 if (!ipv6_addr_any(&fl6->saddr))
adaa70bb 1000 flags |= RT6_LOOKUP_F_HAS_SADDR;
0c9a2ac1
YH		 1001 else if (sk)
1002 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
adaa70bb 1003
4c9483b2 1004 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
1da177e4
LT		 1005}
1006
7159039a 1007EXPORT_SYMBOL(ip6_route_output);
1da177e4 1008
2774c131 1009struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
14e50e57 1010{
5c1e6aa3 1011 struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
14e50e57
DM		 1012 struct dst_entry *new = NULL;
1013
f5b0a874 1014 rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
14e50e57 1015 if (rt) {
d8d1f30b 1016 new = &rt->dst;
14e50e57 1017
8104891b
SK		 1018 memset(new + 1, 0, sizeof(*rt) - sizeof(*new));
1019 rt6_init_peer(rt, net->ipv6.peers);
1020
14e50e57 1021 new->__use = 1;
352e512c
HX		 1022 new->input = dst_discard;
1023 new->output = dst_discard;
14e50e57 1024
21efcfa0
ED		 1025 if (dst_metrics_read_only(&ort->dst))
1026 new->_metrics = ort->dst._metrics;
1027 else
1028 dst_copy_metrics(new, &ort->dst);
14e50e57
DM		 1029 rt->rt6i_idev = ort->rt6i_idev;
1030 if (rt->rt6i_idev)
1031 in6_dev_hold(rt->rt6i_idev);
14e50e57 1032
4e3fd7a0 1033 rt->rt6i_gateway = ort->rt6i_gateway;
1716a961 1034 rt->rt6i_flags = ort->rt6i_flags;
14e50e57
DM		 1035 rt->rt6i_metric = 0;
1036
1037 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1038#ifdef CONFIG_IPV6_SUBTREES
1039 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1040#endif
1041
1042 dst_free(new);
1043 }
1044
69ead7af
DM		 1045 dst_release(dst_orig);
1046 return new ? new : ERR_PTR(-ENOMEM);
14e50e57 1047}
14e50e57 1048
1da177e4
LT		 1049/*
1050 * Destination cache support functions
1051 */
1052
1053static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1054{
1055 struct rt6_info *rt;
1056
1057 rt = (struct rt6_info *) dst;
1058
6f3118b5
ND		 1059 /* All IPV6 dsts are created with ->obsolete set to the value
1060 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1061 * into this function always.
1062 */
ca4c3fc2 1063 if (rt->rt6i_genid != rt_genid_ipv6(dev_net(rt->dst.dev)))
6f3118b5
ND		 1064 return NULL;
1065
a4477c4d 1066 if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
1da177e4 1067 return dst;
a4477c4d 1068
1da177e4
LT		 1069 return NULL;
1070}
1071
1072static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1073{
1074 struct rt6_info *rt = (struct rt6_info *) dst;
1075
1076 if (rt) {
54c1a859
YH		 1077 if (rt->rt6i_flags & RTF_CACHE) {
1078 if (rt6_check_expired(rt)) {
1079 ip6_del_rt(rt);
1080 dst = NULL;
1081 }
1082 } else {
1da177e4 1083 dst_release(dst);
54c1a859
YH		 1084 dst = NULL;
1085 }
1da177e4 1086 }
54c1a859 1087 return dst;
1da177e4
LT		 1088}
1089
1090static void ip6_link_failure(struct sk_buff *skb)
1091{
1092 struct rt6_info *rt;
1093
3ffe533c 1094 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1da177e4 1095
adf30907 1096 rt = (struct rt6_info *) skb_dst(skb);
1da177e4 1097 if (rt) {
1eb4f758
HFS		 1098 if (rt->rt6i_flags & RTF_CACHE) {
1099 dst_hold(&rt->dst);
1100 if (ip6_del_rt(rt))
1101 dst_free(&rt->dst);
1102 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {
1da177e4 1103 rt->rt6i_node->fn_sernum = -1;
1eb4f758 1104 }
1da177e4
LT		 1105 }
1106}
1107
6700c270
DM		 1108static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1109 struct sk_buff *skb, u32 mtu)
1da177e4
LT		 1110{
1111 struct rt6_info *rt6 = (struct rt6_info*)dst;
1112
81aded24 1113 dst_confirm(dst);
1da177e4 1114 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
81aded24
DM		 1115 struct net *net = dev_net(dst->dev);
1116
1da177e4
LT		 1117 rt6->rt6i_flags |= RTF_MODIFIED;
1118 if (mtu < IPV6_MIN_MTU) {
defb3519 1119 u32 features = dst_metric(dst, RTAX_FEATURES);
1da177e4 1120 mtu = IPV6_MIN_MTU;
defb3519
DM		 1121 features |= RTAX_FEATURE_ALLFRAG;
1122 dst_metric_set(dst, RTAX_FEATURES, features);
1da177e4 1123 }
defb3519 1124 dst_metric_set(dst, RTAX_MTU, mtu);
81aded24 1125 rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);
1da177e4
LT		 1126 }
1127}
1128
42ae66c8
DM		 1129void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1130 int oif, u32 mark)
81aded24
DM		 1131{
1132 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1133 struct dst_entry *dst;
1134 struct flowi6 fl6;
1135
1136 memset(&fl6, 0, sizeof(fl6));
1137 fl6.flowi6_oif = oif;
1138 fl6.flowi6_mark = mark;
3e12939a 1139 fl6.flowi6_flags = 0;
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;
1238 fl6.flowi6_flags = 0;
1239 fl6.daddr = iph->daddr;
1240 fl6.saddr = iph->saddr;
6502ca52 1241 fl6.flowlabel = ip6_flowinfo(iph);
3a5ad2ee 1242
b55b76b2
DJ		 1243 dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
1244 rt6_do_redirect(dst, NULL, skb);
3a5ad2ee
DM		 1245 dst_release(dst);
1246}
1247EXPORT_SYMBOL_GPL(ip6_redirect);
1248
c92a59ec
DJ		 1249void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
1250 u32 mark)
1251{
1252 const struct ipv6hdr *iph = ipv6_hdr(skb);
1253 const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
1254 struct dst_entry *dst;
1255 struct flowi6 fl6;
1256
1257 memset(&fl6, 0, sizeof(fl6));
1258 fl6.flowi6_oif = oif;
1259 fl6.flowi6_mark = mark;
1260 fl6.flowi6_flags = 0;
1261 fl6.daddr = msg->dest;
1262 fl6.saddr = iph->daddr;
1263
b55b76b2
DJ		 1264 dst = ip6_route_redirect(net, &fl6, &iph->saddr);
1265 rt6_do_redirect(dst, NULL, skb);
c92a59ec
DJ		 1266 dst_release(dst);
1267}
1268
3a5ad2ee
DM		 1269void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1270{
1271 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1272}
1273EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1274
0dbaee3b 1275static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1da177e4 1276{
0dbaee3b
DM		 1277 struct net_device *dev = dst->dev;
1278 unsigned int mtu = dst_mtu(dst);
1279 struct net *net = dev_net(dev);
1280
1da177e4
LT		 1281 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1282
5578689a
DL		 1283 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1284 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1da177e4
LT		 1285
1286 /*
1ab1457c
YH		 1287 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1288 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1289 * IPV6_MAXPLEN is also valid and means: "any MSS,
1da177e4
LT		 1290 * rely only on pmtu discovery"
1291 */
1292 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1293 mtu = IPV6_MAXPLEN;
1294 return mtu;
1295}
1296
ebb762f2 1297static unsigned int ip6_mtu(const struct dst_entry *dst)
d33e4553 1298{
d33e4553 1299 struct inet6_dev *idev;
618f9bc7
SK		 1300 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
1301
1302 if (mtu)
1303 return mtu;
1304
1305 mtu = IPV6_MIN_MTU;
d33e4553
DM		 1306
1307 rcu_read_lock();
1308 idev = __in6_dev_get(dst->dev);
1309 if (idev)
1310 mtu = idev->cnf.mtu6;
1311 rcu_read_unlock();
1312
1313 return mtu;
1314}
1315
3b00944c
YH		 1316static struct dst_entry *icmp6_dst_gc_list;
1317static DEFINE_SPINLOCK(icmp6_dst_lock);
5d0bbeeb 1318
3b00944c 1319struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
87a11578 1320 struct flowi6 *fl6)
1da177e4 1321{
87a11578 1322 struct dst_entry *dst;
1da177e4
LT		 1323 struct rt6_info *rt;
1324 struct inet6_dev *idev = in6_dev_get(dev);
c346dca1 1325 struct net *net = dev_net(dev);
1da177e4 1326
38308473 1327 if (unlikely(!idev))
122bdf67 1328 return ERR_PTR(-ENODEV);
1da177e4 1329
8b96d22d 1330 rt = ip6_dst_alloc(net, dev, 0, NULL);
38308473 1331 if (unlikely(!rt)) {
1da177e4 1332 in6_dev_put(idev);
87a11578 1333 dst = ERR_PTR(-ENOMEM);
1da177e4
LT		 1334 goto out;
1335 }
1336
8e2ec639
YZ		 1337 rt->dst.flags |= DST_HOST;
1338 rt->dst.output = ip6_output;
d8d1f30b 1339 atomic_set(&rt->dst.__refcnt, 1);
550bab42 1340 rt->rt6i_gateway = fl6->daddr;
87a11578 1341 rt->rt6i_dst.addr = fl6->daddr;
8e2ec639
YZ		 1342 rt->rt6i_dst.plen = 128;
1343 rt->rt6i_idev = idev;
14edd87d 1344 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1da177e4 1345
3b00944c 1346 spin_lock_bh(&icmp6_dst_lock);
d8d1f30b
CG		 1347 rt->dst.next = icmp6_dst_gc_list;
1348 icmp6_dst_gc_list = &rt->dst;
3b00944c 1349 spin_unlock_bh(&icmp6_dst_lock);
1da177e4 1350
5578689a 1351 fib6_force_start_gc(net);
1da177e4 1352
87a11578
DM		 1353 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1354
1da177e4 1355out:
87a11578 1356 return dst;
1da177e4
LT		 1357}
1358
3d0f24a7 1359int icmp6_dst_gc(void)
1da177e4 1360{
e9476e95 1361 struct dst_entry *dst, **pprev;
3d0f24a7 1362 int more = 0;
1da177e4 1363
3b00944c
YH		 1364 spin_lock_bh(&icmp6_dst_lock);
1365 pprev = &icmp6_dst_gc_list;
5d0bbeeb 1366
1da177e4
LT		 1367 while ((dst = *pprev) != NULL) {
1368 if (!atomic_read(&dst->__refcnt)) {
1369 *pprev = dst->next;
1370 dst_free(dst);
1da177e4
LT		 1371 } else {
1372 pprev = &dst->next;
3d0f24a7 1373 ++more;
1da177e4
LT		 1374 }
1375 }
1376
3b00944c 1377 spin_unlock_bh(&icmp6_dst_lock);
5d0bbeeb 1378
3d0f24a7 1379 return more;
1da177e4
LT		 1380}
1381
1e493d19
DM		 1382static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1383 void *arg)
1384{
1385 struct dst_entry *dst, **pprev;
1386
1387 spin_lock_bh(&icmp6_dst_lock);
1388 pprev = &icmp6_dst_gc_list;
1389 while ((dst = *pprev) != NULL) {
1390 struct rt6_info *rt = (struct rt6_info *) dst;
1391 if (func(rt, arg)) {
1392 *pprev = dst->next;
1393 dst_free(dst);
1394 } else {
1395 pprev = &dst->next;
1396 }
1397 }
1398 spin_unlock_bh(&icmp6_dst_lock);
1399}
1400
569d3645 1401static int ip6_dst_gc(struct dst_ops *ops)
1da177e4 1402{
86393e52 1403 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
7019b78e
DL		 1404 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1405 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1406 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1407 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1408 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
fc66f95c 1409 int entries;
7019b78e 1410
fc66f95c 1411 entries = dst_entries_get_fast(ops);
49a18d86 1412 if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
fc66f95c 1413 entries <= rt_max_size)
1da177e4
LT		 1414 goto out;
1415
6891a346 1416 net->ipv6.ip6_rt_gc_expire++;
2ac3ac8f 1417 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, entries > rt_max_size);
fc66f95c
ED		 1418 entries = dst_entries_get_slow(ops);
1419 if (entries < ops->gc_thresh)
7019b78e 1420 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1da177e4 1421out:
7019b78e 1422 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
fc66f95c 1423 return entries > rt_max_size;
1da177e4
LT		 1424}
1425
1da177e4
LT		 1426/*
1427 *
1428 */
1429
86872cb5 1430int ip6_route_add(struct fib6_config *cfg)
1da177e4
LT		 1431{
1432 int err;
5578689a 1433 struct net *net = cfg->fc_nlinfo.nl_net;
1da177e4
LT		 1434 struct rt6_info *rt = NULL;
1435 struct net_device *dev = NULL;
1436 struct inet6_dev *idev = NULL;
c71099ac 1437 struct fib6_table *table;
1da177e4
LT		 1438 int addr_type;
1439
86872cb5 1440 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1da177e4
LT		 1441 return -EINVAL;
1442#ifndef CONFIG_IPV6_SUBTREES
86872cb5 1443 if (cfg->fc_src_len)
1da177e4
LT		 1444 return -EINVAL;
1445#endif
86872cb5 1446 if (cfg->fc_ifindex) {
1da177e4 1447 err = -ENODEV;
5578689a 1448 dev = dev_get_by_index(net, cfg->fc_ifindex);
1da177e4
LT		 1449 if (!dev)
1450 goto out;
1451 idev = in6_dev_get(dev);
1452 if (!idev)
1453 goto out;
1454 }
1455
86872cb5
TG		 1456 if (cfg->fc_metric == 0)
1457 cfg->fc_metric = IP6_RT_PRIO_USER;
1da177e4 1458
d71314b4 1459 err = -ENOBUFS;
38308473
DM		 1460 if (cfg->fc_nlinfo.nlh &&
1461 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
d71314b4 1462 table = fib6_get_table(net, cfg->fc_table);
38308473 1463 if (!table) {
f3213831 1464 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
d71314b4
MV		 1465 table = fib6_new_table(net, cfg->fc_table);
1466 }
1467 } else {
1468 table = fib6_new_table(net, cfg->fc_table);
1469 }
38308473
DM		 1470
1471 if (!table)
c71099ac 1472 goto out;
c71099ac 1473
8b96d22d 1474 rt = ip6_dst_alloc(net, NULL, DST_NOCOUNT, table);
1da177e4 1475
38308473 1476 if (!rt) {
1da177e4
LT		 1477 err = -ENOMEM;
1478 goto out;
1479 }
1480
1716a961
G		 1481 if (cfg->fc_flags & RTF_EXPIRES)
1482 rt6_set_expires(rt, jiffies +
1483 clock_t_to_jiffies(cfg->fc_expires));
1484 else
1485 rt6_clean_expires(rt);
1da177e4 1486
86872cb5
TG		 1487 if (cfg->fc_protocol == RTPROT_UNSPEC)
1488 cfg->fc_protocol = RTPROT_BOOT;
1489 rt->rt6i_protocol = cfg->fc_protocol;
1490
1491 addr_type = ipv6_addr_type(&cfg->fc_dst);
1da177e4
LT		 1492
1493 if (addr_type & IPV6_ADDR_MULTICAST)
d8d1f30b 1494 rt->dst.input = ip6_mc_input;
ab79ad14
MŻ		 1495 else if (cfg->fc_flags & RTF_LOCAL)
1496 rt->dst.input = ip6_input;
1da177e4 1497 else
d8d1f30b 1498 rt->dst.input = ip6_forward;
1da177e4 1499
d8d1f30b 1500 rt->dst.output = ip6_output;
1da177e4 1501
86872cb5
TG		 1502 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1503 rt->rt6i_dst.plen = cfg->fc_dst_len;
1da177e4 1504 if (rt->rt6i_dst.plen == 128)
11d53b49 1505 rt->dst.flags |= DST_HOST;
1da177e4 1506
8e2ec639
YZ		 1507 if (!(rt->dst.flags & DST_HOST) && cfg->fc_mx) {
1508 u32 *metrics = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1509 if (!metrics) {
1510 err = -ENOMEM;
1511 goto out;
1512 }
1513 dst_init_metrics(&rt->dst, metrics, 0);
1514 }
1da177e4 1515#ifdef CONFIG_IPV6_SUBTREES
86872cb5
TG		 1516 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1517 rt->rt6i_src.plen = cfg->fc_src_len;
1da177e4
LT		 1518#endif
1519
86872cb5 1520 rt->rt6i_metric = cfg->fc_metric;
1da177e4
LT		 1521
1522 /* We cannot add true routes via loopback here,
1523 they would result in kernel looping; promote them to reject routes
1524 */
86872cb5 1525 if ((cfg->fc_flags & RTF_REJECT) ||
38308473
DM		 1526 (dev && (dev->flags & IFF_LOOPBACK) &&
1527 !(addr_type & IPV6_ADDR_LOOPBACK) &&
1528 !(cfg->fc_flags & RTF_LOCAL))) {
1da177e4 1529 /* hold loopback dev/idev if we haven't done so. */
5578689a 1530 if (dev != net->loopback_dev) {
1da177e4
LT		 1531 if (dev) {
1532 dev_put(dev);
1533 in6_dev_put(idev);
1534 }
5578689a 1535 dev = net->loopback_dev;
1da177e4
LT		 1536 dev_hold(dev);
1537 idev = in6_dev_get(dev);
1538 if (!idev) {
1539 err = -ENODEV;
1540 goto out;
1541 }
1542 }
d8d1f30b
CG		 1543 rt->dst.output = ip6_pkt_discard_out;
1544 rt->dst.input = ip6_pkt_discard;
1da177e4 1545 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
ef2c7d7b
ND		 1546 switch (cfg->fc_type) {
1547 case RTN_BLACKHOLE:
1548 rt->dst.error = -EINVAL;
1549 break;
1550 case RTN_PROHIBIT:
1551 rt->dst.error = -EACCES;
1552 break;
b4949ab2
ND		 1553 case RTN_THROW:
1554 rt->dst.error = -EAGAIN;
1555 break;
ef2c7d7b
ND		 1556 default:
1557 rt->dst.error = -ENETUNREACH;
1558 break;
1559 }
1da177e4
LT		 1560 goto install_route;
1561 }
1562
86872cb5 1563 if (cfg->fc_flags & RTF_GATEWAY) {
b71d1d42 1564 const struct in6_addr *gw_addr;
1da177e4
LT		 1565 int gwa_type;
1566
86872cb5 1567 gw_addr = &cfg->fc_gateway;
4e3fd7a0 1568 rt->rt6i_gateway = *gw_addr;
1da177e4
LT		 1569 gwa_type = ipv6_addr_type(gw_addr);
1570
1571 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1572 struct rt6_info *grt;
1573
1574 /* IPv6 strictly inhibits using not link-local
1575 addresses as nexthop address.
1576 Otherwise, router will not able to send redirects.
1577 It is very good, but in some (rare!) circumstances
1578 (SIT, PtP, NBMA NOARP links) it is handy to allow
1579 some exceptions. --ANK
1580 */
1581 err = -EINVAL;
38308473 1582 if (!(gwa_type & IPV6_ADDR_UNICAST))
1da177e4
LT		 1583 goto out;
1584
5578689a 1585 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1da177e4
LT		 1586
1587 err = -EHOSTUNREACH;
38308473 1588 if (!grt)
1da177e4
LT		 1589 goto out;
1590 if (dev) {
d1918542 1591 if (dev != grt->dst.dev) {
94e187c0 1592 ip6_rt_put(grt);
1da177e4
LT		 1593 goto out;
1594 }
1595 } else {
d1918542 1596 dev = grt->dst.dev;
1da177e4
LT		 1597 idev = grt->rt6i_idev;
1598 dev_hold(dev);
1599 in6_dev_hold(grt->rt6i_idev);
1600 }
38308473 1601 if (!(grt->rt6i_flags & RTF_GATEWAY))
1da177e4 1602 err = 0;
94e187c0 1603 ip6_rt_put(grt);
1da177e4
LT		 1604
1605 if (err)
1606 goto out;
1607 }
1608 err = -EINVAL;
38308473 1609 if (!dev || (dev->flags & IFF_LOOPBACK))
1da177e4
LT		 1610 goto out;
1611 }
1612
1613 err = -ENODEV;
38308473 1614 if (!dev)
1da177e4
LT		 1615 goto out;
1616
c3968a85
DW		 1617 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1618 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1619 err = -EINVAL;
1620 goto out;
1621 }
4e3fd7a0 1622 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
c3968a85
DW		 1623 rt->rt6i_prefsrc.plen = 128;
1624 } else
1625 rt->rt6i_prefsrc.plen = 0;
1626
86872cb5 1627 rt->rt6i_flags = cfg->fc_flags;
1da177e4
LT		 1628
1629install_route:
86872cb5
TG		 1630 if (cfg->fc_mx) {
1631 struct nlattr *nla;
1632 int remaining;
1633
1634 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
8f4c1f9b 1635 int type = nla_type(nla);
86872cb5
TG		 1636
1637 if (type) {
1638 if (type > RTAX_MAX) {
1da177e4
LT		 1639 err = -EINVAL;
1640 goto out;
1641 }
86872cb5 1642
defb3519 1643 dst_metric_set(&rt->dst, type, nla_get_u32(nla));
1da177e4 1644 }
1da177e4
LT		 1645 }
1646 }
1647
d8d1f30b 1648 rt->dst.dev = dev;
1da177e4 1649 rt->rt6i_idev = idev;
c71099ac 1650 rt->rt6i_table = table;
63152fc0 1651
c346dca1 1652 cfg->fc_nlinfo.nl_net = dev_net(dev);
63152fc0 1653
86872cb5 1654 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1da177e4
LT		 1655
1656out:
1657 if (dev)
1658 dev_put(dev);
1659 if (idev)
1660 in6_dev_put(idev);
1661 if (rt)
d8d1f30b 1662 dst_free(&rt->dst);
1da177e4
LT		 1663 return err;
1664}
1665
86872cb5 1666static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 1667{
1668 int err;
c71099ac 1669 struct fib6_table *table;
d1918542 1670 struct net *net = dev_net(rt->dst.dev);
1da177e4 1671
6825a26c
G		 1672 if (rt == net->ipv6.ip6_null_entry) {
1673 err = -ENOENT;
1674 goto out;
1675 }
6c813a72 1676
c71099ac
TG		 1677 table = rt->rt6i_table;
1678 write_lock_bh(&table->tb6_lock);
86872cb5 1679 err = fib6_del(rt, info);
c71099ac 1680 write_unlock_bh(&table->tb6_lock);
1da177e4 1681
6825a26c 1682out:
94e187c0 1683 ip6_rt_put(rt);
1da177e4
LT		 1684 return err;
1685}
1686
e0a1ad73
TG		 1687int ip6_del_rt(struct rt6_info *rt)
1688{
4d1169c1 1689 struct nl_info info = {
d1918542 1690 .nl_net = dev_net(rt->dst.dev),
4d1169c1 1691 };
528c4ceb 1692 return __ip6_del_rt(rt, &info);
e0a1ad73
TG		 1693}
1694
86872cb5 1695static int ip6_route_del(struct fib6_config *cfg)
1da177e4 1696{
c71099ac 1697 struct fib6_table *table;
1da177e4
LT		 1698 struct fib6_node *fn;
1699 struct rt6_info *rt;
1700 int err = -ESRCH;
1701
5578689a 1702 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
38308473 1703 if (!table)
c71099ac
TG		 1704 return err;
1705
1706 read_lock_bh(&table->tb6_lock);
1da177e4 1707
c71099ac 1708 fn = fib6_locate(&table->tb6_root,
86872cb5
TG		 1709 &cfg->fc_dst, cfg->fc_dst_len,
1710 &cfg->fc_src, cfg->fc_src_len);
1ab1457c 1711
1da177e4 1712 if (fn) {
d8d1f30b 1713 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
86872cb5 1714 if (cfg->fc_ifindex &&
d1918542
DM		 1715 (!rt->dst.dev ||
1716 rt->dst.dev->ifindex != cfg->fc_ifindex))
1da177e4 1717 continue;
86872cb5
TG		 1718 if (cfg->fc_flags & RTF_GATEWAY &&
1719 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1da177e4 1720 continue;
86872cb5 1721 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1da177e4 1722 continue;
d8d1f30b 1723 dst_hold(&rt->dst);
c71099ac 1724 read_unlock_bh(&table->tb6_lock);
1da177e4 1725
86872cb5 1726 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1da177e4
LT		 1727 }
1728 }
c71099ac 1729 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1730
1731 return err;
1732}
1733
6700c270 1734static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
a6279458 1735{
e8599ff4 1736 struct net *net = dev_net(skb->dev);
a6279458 1737 struct netevent_redirect netevent;
e8599ff4 1738 struct rt6_info *rt, *nrt = NULL;
e8599ff4
DM		 1739 struct ndisc_options ndopts;
1740 struct inet6_dev *in6_dev;
1741 struct neighbour *neigh;
71bcdba0 1742 struct rd_msg *msg;
6e157b6a
DM		 1743 int optlen, on_link;
1744 u8 *lladdr;
e8599ff4 1745
29a3cad5 1746 optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
71bcdba0 1747 optlen -= sizeof(*msg);
e8599ff4
DM		 1748
1749 if (optlen < 0) {
6e157b6a 1750 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
e8599ff4
DM		 1751 return;
1752 }
1753
71bcdba0 1754 msg = (struct rd_msg *)icmp6_hdr(skb);
e8599ff4 1755
71bcdba0 1756 if (ipv6_addr_is_multicast(&msg->dest)) {
6e157b6a 1757 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
e8599ff4
DM		 1758 return;
1759 }
1760
6e157b6a 1761 on_link = 0;
71bcdba0 1762 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
e8599ff4 1763 on_link = 1;
71bcdba0 1764 } else if (ipv6_addr_type(&msg->target) !=
e8599ff4 1765 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
6e157b6a 1766 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
e8599ff4
DM		 1767 return;
1768 }
1769
1770 in6_dev = __in6_dev_get(skb->dev);
1771 if (!in6_dev)
1772 return;
1773 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1774 return;
1775
1776 /* RFC2461 8.1:
1777 * The IP source address of the Redirect MUST be the same as the current
1778 * first-hop router for the specified ICMP Destination Address.
1779 */
1780
71bcdba0 1781 if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
e8599ff4
DM		 1782 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1783 return;
1784 }
6e157b6a
DM		 1785
1786 lladdr = NULL;
e8599ff4
DM		 1787 if (ndopts.nd_opts_tgt_lladdr) {
1788 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1789 skb->dev);
1790 if (!lladdr) {
1791 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1792 return;
1793 }
1794 }
1795
6e157b6a
DM		 1796 rt = (struct rt6_info *) dst;
1797 if (rt == net->ipv6.ip6_null_entry) {
1798 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
e8599ff4 1799 return;
6e157b6a 1800 }
e8599ff4 1801
6e157b6a
DM		 1802 /* Redirect received -> path was valid.
1803 * Look, redirects are sent only in response to data packets,
1804 * so that this nexthop apparently is reachable. --ANK
1805 */
1806 dst_confirm(&rt->dst);
a6279458 1807
71bcdba0 1808 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
6e157b6a
DM		 1809 if (!neigh)
1810 return;
a6279458 1811
1da177e4
LT		 1812 /*
1813 * We have finally decided to accept it.
1814 */
1815
1ab1457c 1816 neigh_update(neigh, lladdr, NUD_STALE,
1da177e4
LT		 1817 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1818 NEIGH_UPDATE_F_OVERRIDE|
1819 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1820 NEIGH_UPDATE_F_ISROUTER))
1821 );
1822
71bcdba0 1823 nrt = ip6_rt_copy(rt, &msg->dest);
38308473 1824 if (!nrt)
1da177e4
LT		 1825 goto out;
1826
1827 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1828 if (on_link)
1829 nrt->rt6i_flags &= ~RTF_GATEWAY;
1830
4e3fd7a0 1831 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1da177e4 1832
40e22e8f 1833 if (ip6_ins_rt(nrt))
1da177e4
LT		 1834 goto out;
1835
d8d1f30b
CG		 1836 netevent.old = &rt->dst;
1837 netevent.new = &nrt->dst;
71bcdba0 1838 netevent.daddr = &msg->dest;
60592833 1839 netevent.neigh = neigh;
8d71740c
TT		 1840 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1841
38308473 1842 if (rt->rt6i_flags & RTF_CACHE) {
6e157b6a 1843 rt = (struct rt6_info *) dst_clone(&rt->dst);
e0a1ad73 1844 ip6_del_rt(rt);
1da177e4
LT		 1845 }
1846
1847out:
e8599ff4 1848 neigh_release(neigh);
6e157b6a
DM		 1849}
1850
1da177e4
LT		 1851/*
1852 * Misc support functions
1853 */
1854
1716a961 1855static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
21efcfa0 1856 const struct in6_addr *dest)
1da177e4 1857{
d1918542 1858 struct net *net = dev_net(ort->dst.dev);
8b96d22d
DM		 1859 struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1860 ort->rt6i_table);
1da177e4
LT		 1861
1862 if (rt) {
d8d1f30b
CG		 1863 rt->dst.input = ort->dst.input;
1864 rt->dst.output = ort->dst.output;
8e2ec639 1865 rt->dst.flags |= DST_HOST;
d8d1f30b 1866
4e3fd7a0 1867 rt->rt6i_dst.addr = *dest;
8e2ec639 1868 rt->rt6i_dst.plen = 128;
defb3519 1869 dst_copy_metrics(&rt->dst, &ort->dst);
d8d1f30b 1870 rt->dst.error = ort->dst.error;
1da177e4
LT		 1871 rt->rt6i_idev = ort->rt6i_idev;
1872 if (rt->rt6i_idev)
1873 in6_dev_hold(rt->rt6i_idev);
d8d1f30b 1874 rt->dst.lastuse = jiffies;
1da177e4 1875
550bab42
JA		 1876 if (ort->rt6i_flags & RTF_GATEWAY)
1877 rt->rt6i_gateway = ort->rt6i_gateway;
1878 else
1879 rt->rt6i_gateway = *dest;
1716a961
G		 1880 rt->rt6i_flags = ort->rt6i_flags;
1881 if ((ort->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) ==
1882 (RTF_DEFAULT | RTF_ADDRCONF))
1883 rt6_set_from(rt, ort);
1da177e4
LT		 1884 rt->rt6i_metric = 0;
1885
1da177e4
LT		 1886#ifdef CONFIG_IPV6_SUBTREES
1887 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1888#endif
0f6c6392 1889 memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
c71099ac 1890 rt->rt6i_table = ort->rt6i_table;
1da177e4
LT		 1891 }
1892 return rt;
1893}
1894
70ceb4f5 1895#ifdef CONFIG_IPV6_ROUTE_INFO
efa2cea0 1896static struct rt6_info *rt6_get_route_info(struct net *net,
b71d1d42
ED		 1897 const struct in6_addr *prefix, int prefixlen,
1898 const struct in6_addr *gwaddr, int ifindex)
70ceb4f5
YH		 1899{
1900 struct fib6_node *fn;
1901 struct rt6_info *rt = NULL;
c71099ac
TG		 1902 struct fib6_table *table;
1903
efa2cea0 1904 table = fib6_get_table(net, RT6_TABLE_INFO);
38308473 1905 if (!table)
c71099ac 1906 return NULL;
70ceb4f5 1907
5744dd9b 1908 read_lock_bh(&table->tb6_lock);
c71099ac 1909 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
70ceb4f5
YH		 1910 if (!fn)
1911 goto out;
1912
d8d1f30b 1913 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
d1918542 1914 if (rt->dst.dev->ifindex != ifindex)
70ceb4f5
YH		 1915 continue;
1916 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1917 continue;
1918 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1919 continue;
d8d1f30b 1920 dst_hold(&rt->dst);
70ceb4f5
YH		 1921 break;
1922 }
1923out:
5744dd9b 1924 read_unlock_bh(&table->tb6_lock);
70ceb4f5
YH		 1925 return rt;
1926}
1927
efa2cea0 1928static struct rt6_info *rt6_add_route_info(struct net *net,
b71d1d42
ED		 1929 const struct in6_addr *prefix, int prefixlen,
1930 const struct in6_addr *gwaddr, int ifindex,
95c96174 1931 unsigned int pref)
70ceb4f5 1932{
86872cb5
TG		 1933 struct fib6_config cfg = {
1934 .fc_table = RT6_TABLE_INFO,
238fc7ea 1935 .fc_metric = IP6_RT_PRIO_USER,
86872cb5
TG		 1936 .fc_ifindex = ifindex,
1937 .fc_dst_len = prefixlen,
1938 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1939 RTF_UP | RTF_PREF(pref),
15e47304 1940 .fc_nlinfo.portid = 0,
efa2cea0
DL		 1941 .fc_nlinfo.nlh = NULL,
1942 .fc_nlinfo.nl_net = net,
86872cb5
TG		 1943 };
1944
4e3fd7a0
AD		 1945 cfg.fc_dst = *prefix;
1946 cfg.fc_gateway = *gwaddr;
70ceb4f5 1947
e317da96
YH		 1948 /* We should treat it as a default route if prefix length is 0. */
1949 if (!prefixlen)
86872cb5 1950 cfg.fc_flags |= RTF_DEFAULT;
70ceb4f5 1951
86872cb5 1952 ip6_route_add(&cfg);
70ceb4f5 1953
efa2cea0 1954 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
70ceb4f5
YH		 1955}
1956#endif
1957
b71d1d42 1958struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1ab1457c 1959{
1da177e4 1960 struct rt6_info *rt;
c71099ac 1961 struct fib6_table *table;
1da177e4 1962
c346dca1 1963 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
38308473 1964 if (!table)
c71099ac 1965 return NULL;
1da177e4 1966
5744dd9b 1967 read_lock_bh(&table->tb6_lock);
d8d1f30b 1968 for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
d1918542 1969 if (dev == rt->dst.dev &&
045927ff 1970 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1da177e4
LT		 1971 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1972 break;
1973 }
1974 if (rt)
d8d1f30b 1975 dst_hold(&rt->dst);
5744dd9b 1976 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1977 return rt;
1978}
1979
b71d1d42 1980struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
ebacaaa0
YH		 1981 struct net_device *dev,
1982 unsigned int pref)
1da177e4 1983{
86872cb5
TG		 1984 struct fib6_config cfg = {
1985 .fc_table = RT6_TABLE_DFLT,
238fc7ea 1986 .fc_metric = IP6_RT_PRIO_USER,
86872cb5
TG		 1987 .fc_ifindex = dev->ifindex,
1988 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1989 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
15e47304 1990 .fc_nlinfo.portid = 0,
5578689a 1991 .fc_nlinfo.nlh = NULL,
c346dca1 1992 .fc_nlinfo.nl_net = dev_net(dev),
86872cb5 1993 };
1da177e4 1994
4e3fd7a0 1995 cfg.fc_gateway = *gwaddr;
1da177e4 1996
86872cb5 1997 ip6_route_add(&cfg);
1da177e4 1998
1da177e4
LT		 1999 return rt6_get_dflt_router(gwaddr, dev);
2000}
2001
7b4da532 2002void rt6_purge_dflt_routers(struct net *net)
1da177e4
LT		 2003{
2004 struct rt6_info *rt;
c71099ac
TG		 2005 struct fib6_table *table;
2006
2007 /* NOTE: Keep consistent with rt6_get_dflt_router */
7b4da532 2008 table = fib6_get_table(net, RT6_TABLE_DFLT);
38308473 2009 if (!table)
c71099ac 2010 return;
1da177e4
LT		 2011
2012restart:
c71099ac 2013 read_lock_bh(&table->tb6_lock);
d8d1f30b 2014 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
3e8b0ac3
LC		 2015 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2016 (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
d8d1f30b 2017 dst_hold(&rt->dst);
c71099ac 2018 read_unlock_bh(&table->tb6_lock);
e0a1ad73 2019 ip6_del_rt(rt);
1da177e4
LT		 2020 goto restart;
2021 }
2022 }
c71099ac 2023 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 2024}
2025
5578689a
DL		 2026static void rtmsg_to_fib6_config(struct net *net,
2027 struct in6_rtmsg *rtmsg,
86872cb5
TG		 2028 struct fib6_config *cfg)
2029{
2030 memset(cfg, 0, sizeof(*cfg));
2031
2032 cfg->fc_table = RT6_TABLE_MAIN;
2033 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2034 cfg->fc_metric = rtmsg->rtmsg_metric;
2035 cfg->fc_expires = rtmsg->rtmsg_info;
2036 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2037 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2038 cfg->fc_flags = rtmsg->rtmsg_flags;
2039
5578689a 2040 cfg->fc_nlinfo.nl_net = net;
f1243c2d 2041
4e3fd7a0
AD		 2042 cfg->fc_dst = rtmsg->rtmsg_dst;
2043 cfg->fc_src = rtmsg->rtmsg_src;
2044 cfg->fc_gateway = rtmsg->rtmsg_gateway;
86872cb5
TG		 2045}
2046
5578689a 2047int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1da177e4 2048{
86872cb5 2049 struct fib6_config cfg;
1da177e4
LT		 2050 struct in6_rtmsg rtmsg;
2051 int err;
2052
2053 switch(cmd) {
2054 case SIOCADDRT: /* Add a route */
2055 case SIOCDELRT: /* Delete a route */
af31f412 2056 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1da177e4
LT		 2057 return -EPERM;
2058 err = copy_from_user(&rtmsg, arg,
2059 sizeof(struct in6_rtmsg));
2060 if (err)
2061 return -EFAULT;
86872cb5 2062
5578689a 2063 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
86872cb5 2064
1da177e4
LT		 2065 rtnl_lock();
2066 switch (cmd) {
2067 case SIOCADDRT:
86872cb5 2068 err = ip6_route_add(&cfg);
1da177e4
LT		 2069 break;
2070 case SIOCDELRT:
86872cb5 2071 err = ip6_route_del(&cfg);
1da177e4
LT		 2072 break;
2073 default:
2074 err = -EINVAL;
2075 }
2076 rtnl_unlock();
2077
2078 return err;
3ff50b79 2079 }
1da177e4
LT		 2080
2081 return -EINVAL;
2082}
2083
2084/*
2085 * Drop the packet on the floor
2086 */
2087
d5fdd6ba 2088static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
1da177e4 2089{
612f09e8 2090 int type;
adf30907 2091 struct dst_entry *dst = skb_dst(skb);
612f09e8
YH		 2092 switch (ipstats_mib_noroutes) {
2093 case IPSTATS_MIB_INNOROUTES:
0660e03f 2094 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
45bb0060 2095 if (type == IPV6_ADDR_ANY) {
3bd653c8
DL		 2096 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2097 IPSTATS_MIB_INADDRERRORS);
612f09e8
YH		 2098 break;
2099 }
2100 /* FALLTHROUGH */
2101 case IPSTATS_MIB_OUTNOROUTES:
3bd653c8
DL		 2102 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2103 ipstats_mib_noroutes);
612f09e8
YH		 2104 break;
2105 }
3ffe533c 2106 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
1da177e4
LT		 2107 kfree_skb(skb);
2108 return 0;
2109}
2110
9ce8ade0
TG		 2111static int ip6_pkt_discard(struct sk_buff *skb)
2112{
612f09e8 2113 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
9ce8ade0
TG		 2114}
2115
20380731 2116static int ip6_pkt_discard_out(struct sk_buff *skb)
1da177e4 2117{
adf30907 2118 skb->dev = skb_dst(skb)->dev;
612f09e8 2119 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
1da177e4
LT		 2120}
2121
6723ab54
DM		 2122#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2123
9ce8ade0
TG		 2124static int ip6_pkt_prohibit(struct sk_buff *skb)
2125{
612f09e8 2126 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
9ce8ade0
TG		 2127}
2128
2129static int ip6_pkt_prohibit_out(struct sk_buff *skb)
2130{
adf30907 2131 skb->dev = skb_dst(skb)->dev;
612f09e8 2132 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
9ce8ade0
TG		 2133}
2134
6723ab54
DM		 2135#endif
2136
1da177e4
LT		 2137/*
2138 * Allocate a dst for local (unicast / anycast) address.
2139 */
2140
2141struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2142 const struct in6_addr *addr,
8f031519 2143 bool anycast)
1da177e4 2144{
c346dca1 2145 struct net *net = dev_net(idev->dev);
8b96d22d 2146 struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev, 0, NULL);
1da177e4 2147
38308473 2148 if (!rt) {
f3213831 2149 net_warn_ratelimited("Maximum number of routes reached, consider increasing route/max_size\n");
1da177e4 2150 return ERR_PTR(-ENOMEM);
40385653 2151 }
1da177e4 2152
1da177e4
LT		 2153 in6_dev_hold(idev);
2154
11d53b49 2155 rt->dst.flags |= DST_HOST;
d8d1f30b
CG		 2156 rt->dst.input = ip6_input;
2157 rt->dst.output = ip6_output;
1da177e4 2158 rt->rt6i_idev = idev;
1da177e4
LT		 2159
2160 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
58c4fb86
YH		 2161 if (anycast)
2162 rt->rt6i_flags |= RTF_ANYCAST;
2163 else
1da177e4 2164 rt->rt6i_flags |= RTF_LOCAL;
1da177e4 2165
550bab42 2166 rt->rt6i_gateway = *addr;
4e3fd7a0 2167 rt->rt6i_dst.addr = *addr;
1da177e4 2168 rt->rt6i_dst.plen = 128;
5578689a 2169 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
1da177e4 2170
d8d1f30b 2171 atomic_set(&rt->dst.__refcnt, 1);
1da177e4
LT		 2172
2173 return rt;
2174}
2175
c3968a85
DW		 2176int ip6_route_get_saddr(struct net *net,
2177 struct rt6_info *rt,
b71d1d42 2178 const struct in6_addr *daddr,
c3968a85
DW		 2179 unsigned int prefs,
2180 struct in6_addr *saddr)
2181{
2182 struct inet6_dev *idev = ip6_dst_idev((struct dst_entry*)rt);
2183 int err = 0;
2184 if (rt->rt6i_prefsrc.plen)
4e3fd7a0 2185 *saddr = rt->rt6i_prefsrc.addr;
c3968a85
DW		 2186 else
2187 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2188 daddr, prefs, saddr);
2189 return err;
2190}
2191
2192/* remove deleted ip from prefsrc entries */
2193struct arg_dev_net_ip {
2194 struct net_device *dev;
2195 struct net *net;
2196 struct in6_addr *addr;
2197};
2198
2199static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2200{
2201 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2202 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2203 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2204
d1918542 2205 if (((void *)rt->dst.dev == dev || !dev) &&
c3968a85
DW		 2206 rt != net->ipv6.ip6_null_entry &&
2207 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2208 /* remove prefsrc entry */
2209 rt->rt6i_prefsrc.plen = 0;
2210 }
2211 return 0;
2212}
2213
2214void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2215{
2216 struct net *net = dev_net(ifp->idev->dev);
2217 struct arg_dev_net_ip adni = {
2218 .dev = ifp->idev->dev,
2219 .net = net,
2220 .addr = &ifp->addr,
2221 };
2222 fib6_clean_all(net, fib6_remove_prefsrc, 0, &adni);
2223}
2224
8ed67789
DL		 2225struct arg_dev_net {
2226 struct net_device *dev;
2227 struct net *net;
2228};
2229
1da177e4
LT		 2230static int fib6_ifdown(struct rt6_info *rt, void *arg)
2231{
bc3ef660 2232 const struct arg_dev_net *adn = arg;
2233 const struct net_device *dev = adn->dev;
8ed67789 2234
d1918542 2235 if ((rt->dst.dev == dev || !dev) &&
c159d30c 2236 rt != adn->net->ipv6.ip6_null_entry)
1da177e4 2237 return -1;
c159d30c 2238
1da177e4
LT		 2239 return 0;
2240}
2241
f3db4851 2242void rt6_ifdown(struct net *net, struct net_device *dev)
1da177e4 2243{
8ed67789
DL		 2244 struct arg_dev_net adn = {
2245 .dev = dev,
2246 .net = net,
2247 };
2248
2249 fib6_clean_all(net, fib6_ifdown, 0, &adn);
1e493d19 2250 icmp6_clean_all(fib6_ifdown, &adn);
1da177e4
LT		 2251}
2252
95c96174 2253struct rt6_mtu_change_arg {
1da177e4 2254 struct net_device *dev;
95c96174 2255 unsigned int mtu;
1da177e4
LT		 2256};
2257
2258static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2259{
2260 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2261 struct inet6_dev *idev;
2262
2263 /* In IPv6 pmtu discovery is not optional,
2264 so that RTAX_MTU lock cannot disable it.
2265 We still use this lock to block changes
2266 caused by addrconf/ndisc.
2267 */
2268
2269 idev = __in6_dev_get(arg->dev);
38308473 2270 if (!idev)
1da177e4
LT		 2271 return 0;
2272
2273 /* For administrative MTU increase, there is no way to discover
2274 IPv6 PMTU increase, so PMTU increase should be updated here.
2275 Since RFC 1981 doesn't include administrative MTU increase
2276 update PMTU increase is a MUST. (i.e. jumbo frame)
2277 */
2278 /*
2279 If new MTU is less than route PMTU, this new MTU will be the
2280 lowest MTU in the path, update the route PMTU to reflect PMTU
2281 decreases; if new MTU is greater than route PMTU, and the
2282 old MTU is the lowest MTU in the path, update the route PMTU
2283 to reflect the increase. In this case if the other nodes' MTU
2284 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2285 PMTU discouvery.
2286 */
d1918542 2287 if (rt->dst.dev == arg->dev &&
d8d1f30b
CG		 2288 !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2289 (dst_mtu(&rt->dst) >= arg->mtu ||
2290 (dst_mtu(&rt->dst) < arg->mtu &&
2291 dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
defb3519 2292 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
566cfd8f 2293 }
1da177e4
LT		 2294 return 0;
2295}
2296
95c96174 2297void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
1da177e4 2298{
c71099ac
TG		 2299 struct rt6_mtu_change_arg arg = {
2300 .dev = dev,
2301 .mtu = mtu,
2302 };
1da177e4 2303
c346dca1 2304 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
1da177e4
LT		 2305}
2306
ef7c79ed 2307static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
5176f91e 2308 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
86872cb5 2309 [RTA_OIF] = { .type = NLA_U32 },
ab364a6f 2310 [RTA_IIF] = { .type = NLA_U32 },
86872cb5
TG		 2311 [RTA_PRIORITY] = { .type = NLA_U32 },
2312 [RTA_METRICS] = { .type = NLA_NESTED },
51ebd318 2313 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
86872cb5
TG		 2314};
2315
2316static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2317 struct fib6_config *cfg)
1da177e4 2318{
86872cb5
TG		 2319 struct rtmsg *rtm;
2320 struct nlattr *tb[RTA_MAX+1];
2321 int err;
1da177e4 2322
86872cb5
TG		 2323 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2324 if (err < 0)
2325 goto errout;
1da177e4 2326
86872cb5
TG		 2327 err = -EINVAL;
2328 rtm = nlmsg_data(nlh);
2329 memset(cfg, 0, sizeof(*cfg));
2330
2331 cfg->fc_table = rtm->rtm_table;
2332 cfg->fc_dst_len = rtm->rtm_dst_len;
2333 cfg->fc_src_len = rtm->rtm_src_len;
2334 cfg->fc_flags = RTF_UP;
2335 cfg->fc_protocol = rtm->rtm_protocol;
ef2c7d7b 2336 cfg->fc_type = rtm->rtm_type;
86872cb5 2337
ef2c7d7b
ND		 2338 if (rtm->rtm_type == RTN_UNREACHABLE ||
2339 rtm->rtm_type == RTN_BLACKHOLE ||
b4949ab2
ND		 2340 rtm->rtm_type == RTN_PROHIBIT ||
2341 rtm->rtm_type == RTN_THROW)
86872cb5
TG		 2342 cfg->fc_flags |= RTF_REJECT;
2343
ab79ad14
MŻ		 2344 if (rtm->rtm_type == RTN_LOCAL)
2345 cfg->fc_flags |= RTF_LOCAL;
2346
15e47304 2347 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
86872cb5 2348 cfg->fc_nlinfo.nlh = nlh;
3b1e0a65 2349 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
86872cb5
TG		 2350
2351 if (tb[RTA_GATEWAY]) {
2352 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2353 cfg->fc_flags |= RTF_GATEWAY;
1da177e4 2354 }
86872cb5
TG		 2355
2356 if (tb[RTA_DST]) {
2357 int plen = (rtm->rtm_dst_len + 7) >> 3;
2358
2359 if (nla_len(tb[RTA_DST]) < plen)
2360 goto errout;
2361
2362 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1da177e4 2363 }
86872cb5
TG		 2364
2365 if (tb[RTA_SRC]) {
2366 int plen = (rtm->rtm_src_len + 7) >> 3;
2367
2368 if (nla_len(tb[RTA_SRC]) < plen)
2369 goto errout;
2370
2371 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1da177e4 2372 }
86872cb5 2373
c3968a85
DW		 2374 if (tb[RTA_PREFSRC])
2375 nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2376
86872cb5
TG		 2377 if (tb[RTA_OIF])
2378 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2379
2380 if (tb[RTA_PRIORITY])
2381 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2382
2383 if (tb[RTA_METRICS]) {
2384 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2385 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
1da177e4 2386 }
86872cb5
TG		 2387
2388 if (tb[RTA_TABLE])
2389 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2390
51ebd318
ND		 2391 if (tb[RTA_MULTIPATH]) {
2392 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2393 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2394 }
2395
86872cb5
TG		 2396 err = 0;
2397errout:
2398 return err;
1da177e4
LT		 2399}
2400
51ebd318
ND		 2401static int ip6_route_multipath(struct fib6_config *cfg, int add)
2402{
2403 struct fib6_config r_cfg;
2404 struct rtnexthop *rtnh;
2405 int remaining;
2406 int attrlen;
2407 int err = 0, last_err = 0;
2408
2409beginning:
2410 rtnh = (struct rtnexthop *)cfg->fc_mp;
2411 remaining = cfg->fc_mp_len;
2412
2413 /* Parse a Multipath Entry */
2414 while (rtnh_ok(rtnh, remaining)) {
2415 memcpy(&r_cfg, cfg, sizeof(*cfg));
2416 if (rtnh->rtnh_ifindex)
2417 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2418
2419 attrlen = rtnh_attrlen(rtnh);
2420 if (attrlen > 0) {
2421 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2422
2423 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2424 if (nla) {
2425 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
2426 r_cfg.fc_flags |= RTF_GATEWAY;
2427 }
2428 }
2429 err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2430 if (err) {
2431 last_err = err;
2432 /* If we are trying to remove a route, do not stop the
2433 * loop when ip6_route_del() fails (because next hop is
2434 * already gone), we should try to remove all next hops.
2435 */
2436 if (add) {
2437 /* If add fails, we should try to delete all
2438 * next hops that have been already added.
2439 */
2440 add = 0;
2441 goto beginning;
2442 }
2443 }
1a72418b
ND		 2444 /* Because each route is added like a single route we remove
2445 * this flag after the first nexthop (if there is a collision,
2446 * we have already fail to add the first nexthop:
2447 * fib6_add_rt2node() has reject it).
2448 */
2449 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;
51ebd318
ND		 2450 rtnh = rtnh_next(rtnh, &remaining);
2451 }
2452
2453 return last_err;
2454}
2455
661d2967 2456static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh)
1da177e4 2457{
86872cb5
TG		 2458 struct fib6_config cfg;
2459 int err;
1da177e4 2460
86872cb5
TG		 2461 err = rtm_to_fib6_config(skb, nlh, &cfg);
2462 if (err < 0)
2463 return err;
2464
51ebd318
ND		 2465 if (cfg.fc_mp)
2466 return ip6_route_multipath(&cfg, 0);
2467 else
2468 return ip6_route_del(&cfg);
1da177e4
LT		 2469}
2470
661d2967 2471static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh)
1da177e4 2472{
86872cb5
TG		 2473 struct fib6_config cfg;
2474 int err;
1da177e4 2475
86872cb5
TG		 2476 err = rtm_to_fib6_config(skb, nlh, &cfg);
2477 if (err < 0)
2478 return err;
2479
51ebd318
ND		 2480 if (cfg.fc_mp)
2481 return ip6_route_multipath(&cfg, 1);
2482 else
2483 return ip6_route_add(&cfg);
1da177e4
LT		 2484}
2485
339bf98f
TG		 2486static inline size_t rt6_nlmsg_size(void)
2487{
2488 return NLMSG_ALIGN(sizeof(struct rtmsg))
2489 + nla_total_size(16) /* RTA_SRC */
2490 + nla_total_size(16) /* RTA_DST */
2491 + nla_total_size(16) /* RTA_GATEWAY */
2492 + nla_total_size(16) /* RTA_PREFSRC */
2493 + nla_total_size(4) /* RTA_TABLE */
2494 + nla_total_size(4) /* RTA_IIF */
2495 + nla_total_size(4) /* RTA_OIF */
2496 + nla_total_size(4) /* RTA_PRIORITY */
6a2b9ce0 2497 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
339bf98f
TG		 2498 + nla_total_size(sizeof(struct rta_cacheinfo));
2499}
2500
191cd582
BH		 2501static int rt6_fill_node(struct net *net,
2502 struct sk_buff *skb, struct rt6_info *rt,
0d51aa80 2503 struct in6_addr *dst, struct in6_addr *src,
15e47304 2504 int iif, int type, u32 portid, u32 seq,
7bc570c8 2505 int prefix, int nowait, unsigned int flags)
1da177e4
LT		 2506{
2507 struct rtmsg *rtm;
2d7202bf 2508 struct nlmsghdr *nlh;
e3703b3d 2509 long expires;
9e762a4a 2510 u32 table;
1da177e4
LT		 2511
2512 if (prefix) { /* user wants prefix routes only */
2513 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2514 /* success since this is not a prefix route */
2515 return 1;
2516 }
2517 }
2518
15e47304 2519 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
38308473 2520 if (!nlh)
26932566 2521 return -EMSGSIZE;
2d7202bf
TG		 2522
2523 rtm = nlmsg_data(nlh);
1da177e4
LT		 2524 rtm->rtm_family = AF_INET6;
2525 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2526 rtm->rtm_src_len = rt->rt6i_src.plen;
2527 rtm->rtm_tos = 0;
c71099ac 2528 if (rt->rt6i_table)
9e762a4a 2529 table = rt->rt6i_table->tb6_id;
c71099ac 2530 else
9e762a4a
PM		 2531 table = RT6_TABLE_UNSPEC;
2532 rtm->rtm_table = table;
c78679e8
DM		 2533 if (nla_put_u32(skb, RTA_TABLE, table))
2534 goto nla_put_failure;
ef2c7d7b
ND		 2535 if (rt->rt6i_flags & RTF_REJECT) {
2536 switch (rt->dst.error) {
2537 case -EINVAL:
2538 rtm->rtm_type = RTN_BLACKHOLE;
2539 break;
2540 case -EACCES:
2541 rtm->rtm_type = RTN_PROHIBIT;
2542 break;
b4949ab2
ND		 2543 case -EAGAIN:
2544 rtm->rtm_type = RTN_THROW;
2545 break;
ef2c7d7b
ND		 2546 default:
2547 rtm->rtm_type = RTN_UNREACHABLE;
2548 break;
2549 }
2550 }
38308473 2551 else if (rt->rt6i_flags & RTF_LOCAL)
ab79ad14 2552 rtm->rtm_type = RTN_LOCAL;
d1918542 2553 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
1da177e4
LT		 2554 rtm->rtm_type = RTN_LOCAL;
2555 else
2556 rtm->rtm_type = RTN_UNICAST;
2557 rtm->rtm_flags = 0;
2558 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2559 rtm->rtm_protocol = rt->rt6i_protocol;
38308473 2560 if (rt->rt6i_flags & RTF_DYNAMIC)
1da177e4 2561 rtm->rtm_protocol = RTPROT_REDIRECT;
f0396f60
DO		 2562 else if (rt->rt6i_flags & RTF_ADDRCONF) {
2563 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2564 rtm->rtm_protocol = RTPROT_RA;
2565 else
2566 rtm->rtm_protocol = RTPROT_KERNEL;
2567 }
1da177e4 2568
38308473 2569 if (rt->rt6i_flags & RTF_CACHE)
1da177e4
LT		 2570 rtm->rtm_flags |= RTM_F_CLONED;
2571
2572 if (dst) {
c78679e8
DM		 2573 if (nla_put(skb, RTA_DST, 16, dst))
2574 goto nla_put_failure;
1ab1457c 2575 rtm->rtm_dst_len = 128;
1da177e4 2576 } else if (rtm->rtm_dst_len)
c78679e8
DM		 2577 if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2578 goto nla_put_failure;
1da177e4
LT		 2579#ifdef CONFIG_IPV6_SUBTREES
2580 if (src) {
c78679e8
DM		 2581 if (nla_put(skb, RTA_SRC, 16, src))
2582 goto nla_put_failure;
1ab1457c 2583 rtm->rtm_src_len = 128;
c78679e8
DM		 2584 } else if (rtm->rtm_src_len &&
2585 nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2586 goto nla_put_failure;
1da177e4 2587#endif
7bc570c8
YH		 2588 if (iif) {
2589#ifdef CONFIG_IPV6_MROUTE
2590 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
8229efda 2591 int err = ip6mr_get_route(net, skb, rtm, nowait);
7bc570c8
YH		 2592 if (err <= 0) {
2593 if (!nowait) {
2594 if (err == 0)
2595 return 0;
2596 goto nla_put_failure;
2597 } else {
2598 if (err == -EMSGSIZE)
2599 goto nla_put_failure;
2600 }
2601 }
2602 } else
2603#endif
c78679e8
DM		 2604 if (nla_put_u32(skb, RTA_IIF, iif))
2605 goto nla_put_failure;
7bc570c8 2606 } else if (dst) {
1da177e4 2607 struct in6_addr saddr_buf;
c78679e8
DM		 2608 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2609 nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2610 goto nla_put_failure;
1da177e4 2611 }
2d7202bf 2612
c3968a85
DW		 2613 if (rt->rt6i_prefsrc.plen) {
2614 struct in6_addr saddr_buf;
4e3fd7a0 2615 saddr_buf = rt->rt6i_prefsrc.addr;
c78679e8
DM		 2616 if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2617 goto nla_put_failure;
c3968a85
DW		 2618 }
2619
defb3519 2620 if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2d7202bf
TG		 2621 goto nla_put_failure;
2622
dd0cbf29
YH		 2623 if (rt->rt6i_flags & RTF_GATEWAY) {
2624 if (nla_put(skb, RTA_GATEWAY, 16, &rt->rt6i_gateway) < 0)
94f826b8 2625 goto nla_put_failure;
94f826b8 2626 }
2d7202bf 2627
c78679e8
DM		 2628 if (rt->dst.dev &&
2629 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2630 goto nla_put_failure;
2631 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2632 goto nla_put_failure;
8253947e
LW		 2633
2634 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
69cdf8f9 2635
87a50699 2636 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
e3703b3d 2637 goto nla_put_failure;
2d7202bf
TG		 2638
2639 return nlmsg_end(skb, nlh);
2640
2641nla_put_failure:
26932566
PM		 2642 nlmsg_cancel(skb, nlh);
2643 return -EMSGSIZE;
1da177e4
LT		 2644}
2645
1b43af54 2646int rt6_dump_route(struct rt6_info *rt, void *p_arg)
1da177e4
LT		 2647{
2648 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2649 int prefix;
2650
2d7202bf
TG		 2651 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2652 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
1da177e4
LT		 2653 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2654 } else
2655 prefix = 0;
2656
191cd582
BH		 2657 return rt6_fill_node(arg->net,
2658 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
15e47304 2659 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
7bc570c8 2660 prefix, 0, NLM_F_MULTI);
1da177e4
LT		 2661}
2662
661d2967 2663static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh)
1da177e4 2664{
3b1e0a65 2665 struct net *net = sock_net(in_skb->sk);
ab364a6f
TG		 2666 struct nlattr *tb[RTA_MAX+1];
2667 struct rt6_info *rt;
1da177e4 2668 struct sk_buff *skb;
ab364a6f 2669 struct rtmsg *rtm;
4c9483b2 2670 struct flowi6 fl6;
72331bc0 2671 int err, iif = 0, oif = 0;
1da177e4 2672
ab364a6f
TG		 2673 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2674 if (err < 0)
2675 goto errout;
1da177e4 2676
ab364a6f 2677 err = -EINVAL;
4c9483b2 2678 memset(&fl6, 0, sizeof(fl6));
1da177e4 2679
ab364a6f
TG		 2680 if (tb[RTA_SRC]) {
2681 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2682 goto errout;
2683
4e3fd7a0 2684 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
ab364a6f
TG		 2685 }
2686
2687 if (tb[RTA_DST]) {
2688 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2689 goto errout;
2690
4e3fd7a0 2691 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
ab364a6f
TG		 2692 }
2693
2694 if (tb[RTA_IIF])
2695 iif = nla_get_u32(tb[RTA_IIF]);
2696
2697 if (tb[RTA_OIF])
72331bc0 2698 oif = nla_get_u32(tb[RTA_OIF]);
1da177e4
LT		 2699
2700 if (iif) {
2701 struct net_device *dev;
72331bc0
SL		 2702 int flags = 0;
2703
5578689a 2704 dev = __dev_get_by_index(net, iif);
1da177e4
LT		 2705 if (!dev) {
2706 err = -ENODEV;
ab364a6f 2707 goto errout;
1da177e4 2708 }
72331bc0
SL		 2709
2710 fl6.flowi6_iif = iif;
2711
2712 if (!ipv6_addr_any(&fl6.saddr))
2713 flags |= RT6_LOOKUP_F_HAS_SADDR;
2714
2715 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2716 flags);
2717 } else {
2718 fl6.flowi6_oif = oif;
2719
2720 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
1da177e4
LT		 2721 }
2722
ab364a6f 2723 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
38308473 2724 if (!skb) {
94e187c0 2725 ip6_rt_put(rt);
ab364a6f
TG		 2726 err = -ENOBUFS;
2727 goto errout;
2728 }
1da177e4 2729
ab364a6f
TG		 2730 /* Reserve room for dummy headers, this skb can pass
2731 through good chunk of routing engine.
2732 */
459a98ed 2733 skb_reset_mac_header(skb);
ab364a6f 2734 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
1da177e4 2735
d8d1f30b 2736 skb_dst_set(skb, &rt->dst);
1da177e4 2737
4c9483b2 2738 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
15e47304 2739 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
7bc570c8 2740 nlh->nlmsg_seq, 0, 0, 0);
1da177e4 2741 if (err < 0) {
ab364a6f
TG		 2742 kfree_skb(skb);
2743 goto errout;
1da177e4
LT		 2744 }
2745
15e47304 2746 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
ab364a6f 2747errout:
1da177e4 2748 return err;
1da177e4
LT		 2749}
2750
86872cb5 2751void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 2752{
2753 struct sk_buff *skb;
5578689a 2754 struct net *net = info->nl_net;
528c4ceb
DL		 2755 u32 seq;
2756 int err;
2757
2758 err = -ENOBUFS;
38308473 2759 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
86872cb5 2760
339bf98f 2761 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
38308473 2762 if (!skb)
21713ebc
TG		 2763 goto errout;
2764
191cd582 2765 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
15e47304 2766 event, info->portid, seq, 0, 0, 0);
26932566
PM		 2767 if (err < 0) {
2768 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2769 WARN_ON(err == -EMSGSIZE);
2770 kfree_skb(skb);
2771 goto errout;
2772 }
15e47304 2773 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
1ce85fe4
PNA		 2774 info->nlh, gfp_any());
2775 return;
21713ebc
TG		 2776errout:
2777 if (err < 0)
5578689a 2778 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
1da177e4
LT		 2779}
2780
8ed67789 2781static int ip6_route_dev_notify(struct notifier_block *this,
351638e7 2782 unsigned long event, void *ptr)
8ed67789 2783{
351638e7 2784 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
c346dca1 2785 struct net *net = dev_net(dev);
8ed67789
DL		 2786
2787 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
d8d1f30b 2788 net->ipv6.ip6_null_entry->dst.dev = dev;
8ed67789
DL		 2789 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2790#ifdef CONFIG_IPV6_MULTIPLE_TABLES
d8d1f30b 2791 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
8ed67789 2792 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
d8d1f30b 2793 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
8ed67789
DL		 2794 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2795#endif
2796 }
2797
2798 return NOTIFY_OK;
2799}
2800
1da177e4
LT		 2801/*
2802 * /proc
2803 */
2804
2805#ifdef CONFIG_PROC_FS
2806
1da177e4
LT		 2807struct rt6_proc_arg
2808{
2809 char *buffer;
2810 int offset;
2811 int length;
2812 int skip;
2813 int len;
2814};
2815
2816static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2817{
33120b30 2818 struct seq_file *m = p_arg;
1da177e4 2819
4b7a4274 2820 seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
1da177e4
LT		 2821
2822#ifdef CONFIG_IPV6_SUBTREES
4b7a4274 2823 seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
1da177e4 2824#else
33120b30 2825 seq_puts(m, "00000000000000000000000000000000 00 ");
1da177e4 2826#endif
dd0cbf29
YH		 2827 if (rt->rt6i_flags & RTF_GATEWAY) {
2828 seq_printf(m, "%pi6", &rt->rt6i_gateway);
1da177e4 2829 } else {
33120b30 2830 seq_puts(m, "00000000000000000000000000000000");
1da177e4 2831 }
33120b30 2832 seq_printf(m, " %08x %08x %08x %08x %8s\n",
d8d1f30b
CG		 2833 rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
2834 rt->dst.__use, rt->rt6i_flags,
d1918542 2835 rt->dst.dev ? rt->dst.dev->name : "");
1da177e4
LT		 2836 return 0;
2837}
2838
33120b30 2839static int ipv6_route_show(struct seq_file *m, void *v)
1da177e4 2840{
f3db4851 2841 struct net *net = (struct net *)m->private;
32b293a5 2842 fib6_clean_all_ro(net, rt6_info_route, 0, m);
33120b30
AD		 2843 return 0;
2844}
1da177e4 2845
33120b30
AD		 2846static int ipv6_route_open(struct inode *inode, struct file *file)
2847{
de05c557 2848 return single_open_net(inode, file, ipv6_route_show);
f3db4851
DL		 2849}
2850
33120b30
AD		 2851static const struct file_operations ipv6_route_proc_fops = {
2852 .owner = THIS_MODULE,
2853 .open = ipv6_route_open,
2854 .read = seq_read,
2855 .llseek = seq_lseek,
b6fcbdb4 2856 .release = single_release_net,
33120b30
AD		 2857};
2858
1da177e4
LT		 2859static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2860{
69ddb805 2861 struct net *net = (struct net *)seq->private;
1da177e4 2862 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
69ddb805
DL		 2863 net->ipv6.rt6_stats->fib_nodes,
2864 net->ipv6.rt6_stats->fib_route_nodes,
2865 net->ipv6.rt6_stats->fib_rt_alloc,
2866 net->ipv6.rt6_stats->fib_rt_entries,
2867 net->ipv6.rt6_stats->fib_rt_cache,
fc66f95c 2868 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
69ddb805 2869 net->ipv6.rt6_stats->fib_discarded_routes);
1da177e4
LT		 2870
2871 return 0;
2872}
2873
2874static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2875{
de05c557 2876 return single_open_net(inode, file, rt6_stats_seq_show);
69ddb805
DL		 2877}
2878
9a32144e 2879static const struct file_operations rt6_stats_seq_fops = {
1da177e4
LT		 2880 .owner = THIS_MODULE,
2881 .open = rt6_stats_seq_open,
2882 .read = seq_read,
2883 .llseek = seq_lseek,
b6fcbdb4 2884 .release = single_release_net,
1da177e4
LT		 2885};
2886#endif /* CONFIG_PROC_FS */
2887
2888#ifdef CONFIG_SYSCTL
2889
1da177e4 2890static
fe2c6338 2891int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
1da177e4
LT		 2892 void __user *buffer, size_t *lenp, loff_t *ppos)
2893{
c486da34
LAG		 2894 struct net *net;
2895 int delay;
2896 if (!write)
1da177e4 2897 return -EINVAL;
c486da34
LAG		 2898
2899 net = (struct net *)ctl->extra1;
2900 delay = net->ipv6.sysctl.flush_delay;
2901 proc_dointvec(ctl, write, buffer, lenp, ppos);
2ac3ac8f 2902 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
c486da34 2903 return 0;
1da177e4
LT		 2904}
2905
fe2c6338 2906struct ctl_table ipv6_route_table_template[] = {
1ab1457c 2907 {
1da177e4 2908 .procname = "flush",
4990509f 2909 .data = &init_net.ipv6.sysctl.flush_delay,
1da177e4 2910 .maxlen = sizeof(int),
89c8b3a1 2911 .mode = 0200,
6d9f239a 2912 .proc_handler = ipv6_sysctl_rtcache_flush
1da177e4
LT		 2913 },
2914 {
1da177e4 2915 .procname = "gc_thresh",
9a7ec3a9 2916 .data = &ip6_dst_ops_template.gc_thresh,
1da177e4
LT		 2917 .maxlen = sizeof(int),
2918 .mode = 0644,
6d9f239a 2919 .proc_handler = proc_dointvec,
1da177e4
LT		 2920 },
2921 {
1da177e4 2922 .procname = "max_size",
4990509f 2923 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
1da177e4
LT		 2924 .maxlen = sizeof(int),
2925 .mode = 0644,
6d9f239a 2926 .proc_handler = proc_dointvec,
1da177e4
LT		 2927 },
2928 {
1da177e4 2929 .procname = "gc_min_interval",
4990509f 2930 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 2931 .maxlen = sizeof(int),
2932 .mode = 0644,
6d9f239a 2933 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2934 },
2935 {
1da177e4 2936 .procname = "gc_timeout",
4990509f 2937 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
1da177e4
LT		 2938 .maxlen = sizeof(int),
2939 .mode = 0644,
6d9f239a 2940 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2941 },
2942 {
1da177e4 2943 .procname = "gc_interval",
4990509f 2944 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
1da177e4
LT		 2945 .maxlen = sizeof(int),
2946 .mode = 0644,
6d9f239a 2947 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2948 },
2949 {
1da177e4 2950 .procname = "gc_elasticity",
4990509f 2951 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
1da177e4
LT		 2952 .maxlen = sizeof(int),
2953 .mode = 0644,
f3d3f616 2954 .proc_handler = proc_dointvec,
1da177e4
LT		 2955 },
2956 {
1da177e4 2957 .procname = "mtu_expires",
4990509f 2958 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
1da177e4
LT		 2959 .maxlen = sizeof(int),
2960 .mode = 0644,
6d9f239a 2961 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2962 },
2963 {
1da177e4 2964 .procname = "min_adv_mss",
4990509f 2965 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
1da177e4
LT		 2966 .maxlen = sizeof(int),
2967 .mode = 0644,
f3d3f616 2968 .proc_handler = proc_dointvec,
1da177e4
LT		 2969 },
2970 {
1da177e4 2971 .procname = "gc_min_interval_ms",
4990509f 2972 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 2973 .maxlen = sizeof(int),
2974 .mode = 0644,
6d9f239a 2975 .proc_handler = proc_dointvec_ms_jiffies,
1da177e4 2976 },
f8572d8f 2977 { }
1da177e4
LT		 2978};
2979
2c8c1e72 2980struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
760f2d01
DL		 2981{
2982 struct ctl_table *table;
2983
2984 table = kmemdup(ipv6_route_table_template,
2985 sizeof(ipv6_route_table_template),
2986 GFP_KERNEL);
5ee09105
YH		 2987
2988 if (table) {
2989 table[0].data = &net->ipv6.sysctl.flush_delay;
c486da34 2990 table[0].extra1 = net;
86393e52 2991 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
5ee09105
YH		 2992 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2993 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2994 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2995 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2996 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2997 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2998 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
9c69fabe 2999 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
464dc801
EB		 3000
3001 /* Don't export sysctls to unprivileged users */
3002 if (net->user_ns != &init_user_ns)
3003 table[0].procname = NULL;
5ee09105
YH		 3004 }
3005
760f2d01
DL		 3006 return table;
3007}
1da177e4
LT		 3008#endif
3009
2c8c1e72 3010static int __net_init ip6_route_net_init(struct net *net)
cdb18761 3011{
633d424b 3012 int ret = -ENOMEM;
8ed67789 3013
86393e52
AD		 3014 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3015 sizeof(net->ipv6.ip6_dst_ops));
f2fc6a54 3016
fc66f95c
ED		 3017 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
3018 goto out_ip6_dst_ops;
3019
8ed67789
DL		 3020 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
3021 sizeof(*net->ipv6.ip6_null_entry),
3022 GFP_KERNEL);
3023 if (!net->ipv6.ip6_null_entry)
fc66f95c 3024 goto out_ip6_dst_entries;
d8d1f30b 3025 net->ipv6.ip6_null_entry->dst.path =
8ed67789 3026 (struct dst_entry *)net->ipv6.ip6_null_entry;
d8d1f30b 3027 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 3028 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3029 ip6_template_metrics, true);
8ed67789
DL		 3030
3031#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3032 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3033 sizeof(*net->ipv6.ip6_prohibit_entry),
3034 GFP_KERNEL);
68fffc67
PZ		 3035 if (!net->ipv6.ip6_prohibit_entry)
3036 goto out_ip6_null_entry;
d8d1f30b 3037 net->ipv6.ip6_prohibit_entry->dst.path =
8ed67789 3038 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
d8d1f30b 3039 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 3040 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3041 ip6_template_metrics, true);
8ed67789
DL		 3042
3043 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3044 sizeof(*net->ipv6.ip6_blk_hole_entry),
3045 GFP_KERNEL);
68fffc67
PZ		 3046 if (!net->ipv6.ip6_blk_hole_entry)
3047 goto out_ip6_prohibit_entry;
d8d1f30b 3048 net->ipv6.ip6_blk_hole_entry->dst.path =
8ed67789 3049 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
d8d1f30b 3050 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 3051 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3052 ip6_template_metrics, true);
8ed67789
DL		 3053#endif
3054
b339a47c
PZ		 3055 net->ipv6.sysctl.flush_delay = 0;
3056 net->ipv6.sysctl.ip6_rt_max_size = 4096;
3057 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3058 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3059 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3060 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3061 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3062 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3063
6891a346
BT		 3064 net->ipv6.ip6_rt_gc_expire = 30*HZ;
3065
8ed67789
DL		 3066 ret = 0;
3067out:
3068 return ret;
f2fc6a54 3069
68fffc67
PZ		 3070#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3071out_ip6_prohibit_entry:
3072 kfree(net->ipv6.ip6_prohibit_entry);
3073out_ip6_null_entry:
3074 kfree(net->ipv6.ip6_null_entry);
3075#endif
fc66f95c
ED		 3076out_ip6_dst_entries:
3077 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
f2fc6a54 3078out_ip6_dst_ops:
f2fc6a54 3079 goto out;
cdb18761
DL		 3080}
3081
2c8c1e72 3082static void __net_exit ip6_route_net_exit(struct net *net)
cdb18761 3083{
8ed67789
DL		 3084 kfree(net->ipv6.ip6_null_entry);
3085#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3086 kfree(net->ipv6.ip6_prohibit_entry);
3087 kfree(net->ipv6.ip6_blk_hole_entry);
3088#endif
41bb78b4 3089 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
cdb18761
DL		 3090}
3091
d189634e
TG		 3092static int __net_init ip6_route_net_init_late(struct net *net)
3093{
3094#ifdef CONFIG_PROC_FS
d4beaa66
G		 3095 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3096 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
d189634e
TG		 3097#endif
3098 return 0;
3099}
3100
3101static void __net_exit ip6_route_net_exit_late(struct net *net)
3102{
3103#ifdef CONFIG_PROC_FS
ece31ffd
G		 3104 remove_proc_entry("ipv6_route", net->proc_net);
3105 remove_proc_entry("rt6_stats", net->proc_net);
d189634e
TG		 3106#endif
3107}
3108
cdb18761
DL		 3109static struct pernet_operations ip6_route_net_ops = {
3110 .init = ip6_route_net_init,
3111 .exit = ip6_route_net_exit,
3112};
3113
c3426b47
DM		 3114static int __net_init ipv6_inetpeer_init(struct net *net)
3115{
3116 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3117
3118 if (!bp)
3119 return -ENOMEM;
3120 inet_peer_base_init(bp);
3121 net->ipv6.peers = bp;
3122 return 0;
3123}
3124
3125static void __net_exit ipv6_inetpeer_exit(struct net *net)
3126{
3127 struct inet_peer_base *bp = net->ipv6.peers;
3128
3129 net->ipv6.peers = NULL;
56a6b248 3130 inetpeer_invalidate_tree(bp);
c3426b47
DM		 3131 kfree(bp);
3132}
3133
2b823f72 3134static struct pernet_operations ipv6_inetpeer_ops = {
c3426b47
DM		 3135 .init = ipv6_inetpeer_init,
3136 .exit = ipv6_inetpeer_exit,
3137};
3138
d189634e
TG		 3139static struct pernet_operations ip6_route_net_late_ops = {
3140 .init = ip6_route_net_init_late,
3141 .exit = ip6_route_net_exit_late,
3142};
3143
8ed67789
DL		 3144static struct notifier_block ip6_route_dev_notifier = {
3145 .notifier_call = ip6_route_dev_notify,
3146 .priority = 0,
3147};
3148
433d49c3 3149int __init ip6_route_init(void)
1da177e4 3150{
433d49c3
DL		 3151 int ret;
3152
9a7ec3a9
DL		 3153 ret = -ENOMEM;
3154 ip6_dst_ops_template.kmem_cachep =
e5d679f3 3155 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
f845ab6b 3156 SLAB_HWCACHE_ALIGN, NULL);
9a7ec3a9 3157 if (!ip6_dst_ops_template.kmem_cachep)
c19a28e1 3158 goto out;
14e50e57 3159
fc66f95c 3160 ret = dst_entries_init(&ip6_dst_blackhole_ops);
8ed67789 3161 if (ret)
bdb3289f 3162 goto out_kmem_cache;
bdb3289f 3163
c3426b47
DM		 3164 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3165 if (ret)
e8803b6c 3166 goto out_dst_entries;
2a0c451a 3167
7e52b33b
DM		 3168 ret = register_pernet_subsys(&ip6_route_net_ops);
3169 if (ret)
3170 goto out_register_inetpeer;
c3426b47 3171
5dc121e9
AE		 3172 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3173
8ed67789
DL		 3174 /* Registering of the loopback is done before this portion of code,
3175 * the loopback reference in rt6_info will not be taken, do it
3176 * manually for init_net */
d8d1f30b 3177 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
8ed67789
DL		 3178 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3179 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
d8d1f30b 3180 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
8ed67789 3181 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
d8d1f30b 3182 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
8ed67789
DL		 3183 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3184 #endif
e8803b6c 3185 ret = fib6_init();
433d49c3 3186 if (ret)
8ed67789 3187 goto out_register_subsys;
433d49c3 3188
433d49c3
DL		 3189 ret = xfrm6_init();
3190 if (ret)
e8803b6c 3191 goto out_fib6_init;
c35b7e72 3192
433d49c3
DL		 3193 ret = fib6_rules_init();
3194 if (ret)
3195 goto xfrm6_init;
7e5449c2 3196
d189634e
TG		 3197 ret = register_pernet_subsys(&ip6_route_net_late_ops);
3198 if (ret)
3199 goto fib6_rules_init;
3200
433d49c3 3201 ret = -ENOBUFS;
c7ac8679
GR		 3202 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3203 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3204 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
d189634e 3205 goto out_register_late_subsys;
c127ea2c 3206
8ed67789 3207 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
cdb18761 3208 if (ret)
d189634e 3209 goto out_register_late_subsys;
8ed67789 3210
433d49c3
DL		 3211out:
3212 return ret;
3213
d189634e
TG		 3214out_register_late_subsys:
3215 unregister_pernet_subsys(&ip6_route_net_late_ops);
433d49c3 3216fib6_rules_init:
433d49c3
DL		 3217 fib6_rules_cleanup();
3218xfrm6_init:
433d49c3 3219 xfrm6_fini();
2a0c451a
TG		 3220out_fib6_init:
3221 fib6_gc_cleanup();
8ed67789
DL		 3222out_register_subsys:
3223 unregister_pernet_subsys(&ip6_route_net_ops);
7e52b33b
DM		 3224out_register_inetpeer:
3225 unregister_pernet_subsys(&ipv6_inetpeer_ops);
fc66f95c
ED		 3226out_dst_entries:
3227 dst_entries_destroy(&ip6_dst_blackhole_ops);
433d49c3 3228out_kmem_cache:
f2fc6a54 3229 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
433d49c3 3230 goto out;
1da177e4
LT		 3231}
3232
3233void ip6_route_cleanup(void)
3234{
8ed67789 3235 unregister_netdevice_notifier(&ip6_route_dev_notifier);
d189634e 3236 unregister_pernet_subsys(&ip6_route_net_late_ops);
101367c2 3237 fib6_rules_cleanup();
1da177e4 3238 xfrm6_fini();
1da177e4 3239 fib6_gc_cleanup();
c3426b47 3240 unregister_pernet_subsys(&ipv6_inetpeer_ops);
8ed67789 3241 unregister_pernet_subsys(&ip6_route_net_ops);
41bb78b4 3242 dst_entries_destroy(&ip6_dst_blackhole_ops);
f2fc6a54 3243 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
1da177e4 3244}
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git