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