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