projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'ktest-v3.9' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux...
[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) {
1da177e4 1918 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
d8d1f30b 1919 dst_hold(&rt->dst);
c71099ac 1920 read_unlock_bh(&table->tb6_lock);
e0a1ad73 1921 ip6_del_rt(rt);
1da177e4
LT		 1922 goto restart;
1923 }
1924 }
c71099ac 1925 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1926}
1927
5578689a
DL		 1928static void rtmsg_to_fib6_config(struct net *net,
1929 struct in6_rtmsg *rtmsg,
86872cb5
TG		 1930 struct fib6_config *cfg)
1931{
1932 memset(cfg, 0, sizeof(*cfg));
1933
1934 cfg->fc_table = RT6_TABLE_MAIN;
1935 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1936 cfg->fc_metric = rtmsg->rtmsg_metric;
1937 cfg->fc_expires = rtmsg->rtmsg_info;
1938 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1939 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1940 cfg->fc_flags = rtmsg->rtmsg_flags;
1941
5578689a 1942 cfg->fc_nlinfo.nl_net = net;
f1243c2d 1943
4e3fd7a0
AD		 1944 cfg->fc_dst = rtmsg->rtmsg_dst;
1945 cfg->fc_src = rtmsg->rtmsg_src;
1946 cfg->fc_gateway = rtmsg->rtmsg_gateway;
86872cb5
TG		 1947}
1948
5578689a 1949int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1da177e4 1950{
86872cb5 1951 struct fib6_config cfg;
1da177e4
LT		 1952 struct in6_rtmsg rtmsg;
1953 int err;
1954
1955 switch(cmd) {
1956 case SIOCADDRT: /* Add a route */
1957 case SIOCDELRT: /* Delete a route */
af31f412 1958 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1da177e4
LT		 1959 return -EPERM;
1960 err = copy_from_user(&rtmsg, arg,
1961 sizeof(struct in6_rtmsg));
1962 if (err)
1963 return -EFAULT;
86872cb5 1964
5578689a 1965 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
86872cb5 1966
1da177e4
LT		 1967 rtnl_lock();
1968 switch (cmd) {
1969 case SIOCADDRT:
86872cb5 1970 err = ip6_route_add(&cfg);
1da177e4
LT		 1971 break;
1972 case SIOCDELRT:
86872cb5 1973 err = ip6_route_del(&cfg);
1da177e4
LT		 1974 break;
1975 default:
1976 err = -EINVAL;
1977 }
1978 rtnl_unlock();
1979
1980 return err;
3ff50b79 1981 }
1da177e4
LT		 1982
1983 return -EINVAL;
1984}
1985
1986/*
1987 * Drop the packet on the floor
1988 */
1989
d5fdd6ba 1990static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
1da177e4 1991{
612f09e8 1992 int type;
adf30907 1993 struct dst_entry *dst = skb_dst(skb);
612f09e8
YH		 1994 switch (ipstats_mib_noroutes) {
1995 case IPSTATS_MIB_INNOROUTES:
0660e03f 1996 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
45bb0060 1997 if (type == IPV6_ADDR_ANY) {
3bd653c8
DL		 1998 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
1999 IPSTATS_MIB_INADDRERRORS);
612f09e8
YH		 2000 break;
2001 }
2002 /* FALLTHROUGH */
2003 case IPSTATS_MIB_OUTNOROUTES:
3bd653c8
DL		 2004 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2005 ipstats_mib_noroutes);
612f09e8
YH		 2006 break;
2007 }
3ffe533c 2008 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
1da177e4
LT		 2009 kfree_skb(skb);
2010 return 0;
2011}
2012
9ce8ade0
TG		 2013static int ip6_pkt_discard(struct sk_buff *skb)
2014{
612f09e8 2015 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
9ce8ade0
TG		 2016}
2017
20380731 2018static int ip6_pkt_discard_out(struct sk_buff *skb)
1da177e4 2019{
adf30907 2020 skb->dev = skb_dst(skb)->dev;
612f09e8 2021 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
1da177e4
LT		 2022}
2023
6723ab54
DM		 2024#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2025
9ce8ade0
TG		 2026static int ip6_pkt_prohibit(struct sk_buff *skb)
2027{
612f09e8 2028 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
9ce8ade0
TG		 2029}
2030
2031static int ip6_pkt_prohibit_out(struct sk_buff *skb)
2032{
adf30907 2033 skb->dev = skb_dst(skb)->dev;
612f09e8 2034 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
9ce8ade0
TG		 2035}
2036
6723ab54
DM		 2037#endif
2038
1da177e4
LT		 2039/*
2040 * Allocate a dst for local (unicast / anycast) address.
2041 */
2042
2043struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2044 const struct in6_addr *addr,
8f031519 2045 bool anycast)
1da177e4 2046{
c346dca1 2047 struct net *net = dev_net(idev->dev);
8b96d22d 2048 struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev, 0, NULL);
1da177e4 2049
38308473 2050 if (!rt) {
f3213831 2051 net_warn_ratelimited("Maximum number of routes reached, consider increasing route/max_size\n");
1da177e4 2052 return ERR_PTR(-ENOMEM);
40385653 2053 }
1da177e4 2054
1da177e4
LT		 2055 in6_dev_hold(idev);
2056
11d53b49 2057 rt->dst.flags |= DST_HOST;
d8d1f30b
CG		 2058 rt->dst.input = ip6_input;
2059 rt->dst.output = ip6_output;
1da177e4 2060 rt->rt6i_idev = idev;
1da177e4
LT		 2061
2062 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
58c4fb86
YH		 2063 if (anycast)
2064 rt->rt6i_flags |= RTF_ANYCAST;
2065 else
1da177e4 2066 rt->rt6i_flags |= RTF_LOCAL;
1da177e4 2067
4e3fd7a0 2068 rt->rt6i_dst.addr = *addr;
1da177e4 2069 rt->rt6i_dst.plen = 128;
5578689a 2070 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
1da177e4 2071
d8d1f30b 2072 atomic_set(&rt->dst.__refcnt, 1);
1da177e4
LT		 2073
2074 return rt;
2075}
2076
c3968a85
DW		 2077int ip6_route_get_saddr(struct net *net,
2078 struct rt6_info *rt,
b71d1d42 2079 const struct in6_addr *daddr,
c3968a85
DW		 2080 unsigned int prefs,
2081 struct in6_addr *saddr)
2082{
2083 struct inet6_dev *idev = ip6_dst_idev((struct dst_entry*)rt);
2084 int err = 0;
2085 if (rt->rt6i_prefsrc.plen)
4e3fd7a0 2086 *saddr = rt->rt6i_prefsrc.addr;
c3968a85
DW		 2087 else
2088 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2089 daddr, prefs, saddr);
2090 return err;
2091}
2092
2093/* remove deleted ip from prefsrc entries */
2094struct arg_dev_net_ip {
2095 struct net_device *dev;
2096 struct net *net;
2097 struct in6_addr *addr;
2098};
2099
2100static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2101{
2102 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2103 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2104 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2105
d1918542 2106 if (((void *)rt->dst.dev == dev || !dev) &&
c3968a85
DW		 2107 rt != net->ipv6.ip6_null_entry &&
2108 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2109 /* remove prefsrc entry */
2110 rt->rt6i_prefsrc.plen = 0;
2111 }
2112 return 0;
2113}
2114
2115void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2116{
2117 struct net *net = dev_net(ifp->idev->dev);
2118 struct arg_dev_net_ip adni = {
2119 .dev = ifp->idev->dev,
2120 .net = net,
2121 .addr = &ifp->addr,
2122 };
2123 fib6_clean_all(net, fib6_remove_prefsrc, 0, &adni);
2124}
2125
8ed67789
DL		 2126struct arg_dev_net {
2127 struct net_device *dev;
2128 struct net *net;
2129};
2130
1da177e4
LT		 2131static int fib6_ifdown(struct rt6_info *rt, void *arg)
2132{
bc3ef660 2133 const struct arg_dev_net *adn = arg;
2134 const struct net_device *dev = adn->dev;
8ed67789 2135
d1918542 2136 if ((rt->dst.dev == dev || !dev) &&
c159d30c 2137 rt != adn->net->ipv6.ip6_null_entry)
1da177e4 2138 return -1;
c159d30c 2139
1da177e4
LT		 2140 return 0;
2141}
2142
f3db4851 2143void rt6_ifdown(struct net *net, struct net_device *dev)
1da177e4 2144{
8ed67789
DL		 2145 struct arg_dev_net adn = {
2146 .dev = dev,
2147 .net = net,
2148 };
2149
2150 fib6_clean_all(net, fib6_ifdown, 0, &adn);
1e493d19 2151 icmp6_clean_all(fib6_ifdown, &adn);
1da177e4
LT		 2152}
2153
95c96174 2154struct rt6_mtu_change_arg {
1da177e4 2155 struct net_device *dev;
95c96174 2156 unsigned int mtu;
1da177e4
LT		 2157};
2158
2159static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2160{
2161 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2162 struct inet6_dev *idev;
2163
2164 /* In IPv6 pmtu discovery is not optional,
2165 so that RTAX_MTU lock cannot disable it.
2166 We still use this lock to block changes
2167 caused by addrconf/ndisc.
2168 */
2169
2170 idev = __in6_dev_get(arg->dev);
38308473 2171 if (!idev)
1da177e4
LT		 2172 return 0;
2173
2174 /* For administrative MTU increase, there is no way to discover
2175 IPv6 PMTU increase, so PMTU increase should be updated here.
2176 Since RFC 1981 doesn't include administrative MTU increase
2177 update PMTU increase is a MUST. (i.e. jumbo frame)
2178 */
2179 /*
2180 If new MTU is less than route PMTU, this new MTU will be the
2181 lowest MTU in the path, update the route PMTU to reflect PMTU
2182 decreases; if new MTU is greater than route PMTU, and the
2183 old MTU is the lowest MTU in the path, update the route PMTU
2184 to reflect the increase. In this case if the other nodes' MTU
2185 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2186 PMTU discouvery.
2187 */
d1918542 2188 if (rt->dst.dev == arg->dev &&
d8d1f30b
CG		 2189 !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2190 (dst_mtu(&rt->dst) >= arg->mtu ||
2191 (dst_mtu(&rt->dst) < arg->mtu &&
2192 dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
defb3519 2193 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
566cfd8f 2194 }
1da177e4
LT		 2195 return 0;
2196}
2197
95c96174 2198void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
1da177e4 2199{
c71099ac
TG		 2200 struct rt6_mtu_change_arg arg = {
2201 .dev = dev,
2202 .mtu = mtu,
2203 };
1da177e4 2204
c346dca1 2205 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
1da177e4
LT		 2206}
2207
ef7c79ed 2208static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
5176f91e 2209 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
86872cb5 2210 [RTA_OIF] = { .type = NLA_U32 },
ab364a6f 2211 [RTA_IIF] = { .type = NLA_U32 },
86872cb5
TG		 2212 [RTA_PRIORITY] = { .type = NLA_U32 },
2213 [RTA_METRICS] = { .type = NLA_NESTED },
51ebd318 2214 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
86872cb5
TG		 2215};
2216
2217static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2218 struct fib6_config *cfg)
1da177e4 2219{
86872cb5
TG		 2220 struct rtmsg *rtm;
2221 struct nlattr *tb[RTA_MAX+1];
2222 int err;
1da177e4 2223
86872cb5
TG		 2224 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2225 if (err < 0)
2226 goto errout;
1da177e4 2227
86872cb5
TG		 2228 err = -EINVAL;
2229 rtm = nlmsg_data(nlh);
2230 memset(cfg, 0, sizeof(*cfg));
2231
2232 cfg->fc_table = rtm->rtm_table;
2233 cfg->fc_dst_len = rtm->rtm_dst_len;
2234 cfg->fc_src_len = rtm->rtm_src_len;
2235 cfg->fc_flags = RTF_UP;
2236 cfg->fc_protocol = rtm->rtm_protocol;
ef2c7d7b 2237 cfg->fc_type = rtm->rtm_type;
86872cb5 2238
ef2c7d7b
ND		 2239 if (rtm->rtm_type == RTN_UNREACHABLE ||
2240 rtm->rtm_type == RTN_BLACKHOLE ||
b4949ab2
ND		 2241 rtm->rtm_type == RTN_PROHIBIT ||
2242 rtm->rtm_type == RTN_THROW)
86872cb5
TG		 2243 cfg->fc_flags |= RTF_REJECT;
2244
ab79ad14
MŻ		 2245 if (rtm->rtm_type == RTN_LOCAL)
2246 cfg->fc_flags |= RTF_LOCAL;
2247
15e47304 2248 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
86872cb5 2249 cfg->fc_nlinfo.nlh = nlh;
3b1e0a65 2250 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
86872cb5
TG		 2251
2252 if (tb[RTA_GATEWAY]) {
2253 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2254 cfg->fc_flags |= RTF_GATEWAY;
1da177e4 2255 }
86872cb5
TG		 2256
2257 if (tb[RTA_DST]) {
2258 int plen = (rtm->rtm_dst_len + 7) >> 3;
2259
2260 if (nla_len(tb[RTA_DST]) < plen)
2261 goto errout;
2262
2263 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1da177e4 2264 }
86872cb5
TG		 2265
2266 if (tb[RTA_SRC]) {
2267 int plen = (rtm->rtm_src_len + 7) >> 3;
2268
2269 if (nla_len(tb[RTA_SRC]) < plen)
2270 goto errout;
2271
2272 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1da177e4 2273 }
86872cb5 2274
c3968a85
DW		 2275 if (tb[RTA_PREFSRC])
2276 nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2277
86872cb5
TG		 2278 if (tb[RTA_OIF])
2279 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2280
2281 if (tb[RTA_PRIORITY])
2282 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2283
2284 if (tb[RTA_METRICS]) {
2285 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2286 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
1da177e4 2287 }
86872cb5
TG		 2288
2289 if (tb[RTA_TABLE])
2290 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2291
51ebd318
ND		 2292 if (tb[RTA_MULTIPATH]) {
2293 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2294 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2295 }
2296
86872cb5
TG		 2297 err = 0;
2298errout:
2299 return err;
1da177e4
LT		 2300}
2301
51ebd318
ND		 2302static int ip6_route_multipath(struct fib6_config *cfg, int add)
2303{
2304 struct fib6_config r_cfg;
2305 struct rtnexthop *rtnh;
2306 int remaining;
2307 int attrlen;
2308 int err = 0, last_err = 0;
2309
2310beginning:
2311 rtnh = (struct rtnexthop *)cfg->fc_mp;
2312 remaining = cfg->fc_mp_len;
2313
2314 /* Parse a Multipath Entry */
2315 while (rtnh_ok(rtnh, remaining)) {
2316 memcpy(&r_cfg, cfg, sizeof(*cfg));
2317 if (rtnh->rtnh_ifindex)
2318 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2319
2320 attrlen = rtnh_attrlen(rtnh);
2321 if (attrlen > 0) {
2322 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2323
2324 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2325 if (nla) {
2326 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
2327 r_cfg.fc_flags |= RTF_GATEWAY;
2328 }
2329 }
2330 err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2331 if (err) {
2332 last_err = err;
2333 /* If we are trying to remove a route, do not stop the
2334 * loop when ip6_route_del() fails (because next hop is
2335 * already gone), we should try to remove all next hops.
2336 */
2337 if (add) {
2338 /* If add fails, we should try to delete all
2339 * next hops that have been already added.
2340 */
2341 add = 0;
2342 goto beginning;
2343 }
2344 }
1a72418b
ND		 2345 /* Because each route is added like a single route we remove
2346 * this flag after the first nexthop (if there is a collision,
2347 * we have already fail to add the first nexthop:
2348 * fib6_add_rt2node() has reject it).
2349 */
2350 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;
51ebd318
ND		 2351 rtnh = rtnh_next(rtnh, &remaining);
2352 }
2353
2354 return last_err;
2355}
2356
c127ea2c 2357static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1da177e4 2358{
86872cb5
TG		 2359 struct fib6_config cfg;
2360 int err;
1da177e4 2361
86872cb5
TG		 2362 err = rtm_to_fib6_config(skb, nlh, &cfg);
2363 if (err < 0)
2364 return err;
2365
51ebd318
ND		 2366 if (cfg.fc_mp)
2367 return ip6_route_multipath(&cfg, 0);
2368 else
2369 return ip6_route_del(&cfg);
1da177e4
LT		 2370}
2371
c127ea2c 2372static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1da177e4 2373{
86872cb5
TG		 2374 struct fib6_config cfg;
2375 int err;
1da177e4 2376
86872cb5
TG		 2377 err = rtm_to_fib6_config(skb, nlh, &cfg);
2378 if (err < 0)
2379 return err;
2380
51ebd318
ND		 2381 if (cfg.fc_mp)
2382 return ip6_route_multipath(&cfg, 1);
2383 else
2384 return ip6_route_add(&cfg);
1da177e4
LT		 2385}
2386
339bf98f
TG		 2387static inline size_t rt6_nlmsg_size(void)
2388{
2389 return NLMSG_ALIGN(sizeof(struct rtmsg))
2390 + nla_total_size(16) /* RTA_SRC */
2391 + nla_total_size(16) /* RTA_DST */
2392 + nla_total_size(16) /* RTA_GATEWAY */
2393 + nla_total_size(16) /* RTA_PREFSRC */
2394 + nla_total_size(4) /* RTA_TABLE */
2395 + nla_total_size(4) /* RTA_IIF */
2396 + nla_total_size(4) /* RTA_OIF */
2397 + nla_total_size(4) /* RTA_PRIORITY */
6a2b9ce0 2398 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
339bf98f
TG		 2399 + nla_total_size(sizeof(struct rta_cacheinfo));
2400}
2401
191cd582
BH		 2402static int rt6_fill_node(struct net *net,
2403 struct sk_buff *skb, struct rt6_info *rt,
0d51aa80 2404 struct in6_addr *dst, struct in6_addr *src,
15e47304 2405 int iif, int type, u32 portid, u32 seq,
7bc570c8 2406 int prefix, int nowait, unsigned int flags)
1da177e4
LT		 2407{
2408 struct rtmsg *rtm;
2d7202bf 2409 struct nlmsghdr *nlh;
e3703b3d 2410 long expires;
9e762a4a 2411 u32 table;
1da177e4
LT		 2412
2413 if (prefix) { /* user wants prefix routes only */
2414 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2415 /* success since this is not a prefix route */
2416 return 1;
2417 }
2418 }
2419
15e47304 2420 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
38308473 2421 if (!nlh)
26932566 2422 return -EMSGSIZE;
2d7202bf
TG		 2423
2424 rtm = nlmsg_data(nlh);
1da177e4
LT		 2425 rtm->rtm_family = AF_INET6;
2426 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2427 rtm->rtm_src_len = rt->rt6i_src.plen;
2428 rtm->rtm_tos = 0;
c71099ac 2429 if (rt->rt6i_table)
9e762a4a 2430 table = rt->rt6i_table->tb6_id;
c71099ac 2431 else
9e762a4a
PM		 2432 table = RT6_TABLE_UNSPEC;
2433 rtm->rtm_table = table;
c78679e8
DM		 2434 if (nla_put_u32(skb, RTA_TABLE, table))
2435 goto nla_put_failure;
ef2c7d7b
ND		 2436 if (rt->rt6i_flags & RTF_REJECT) {
2437 switch (rt->dst.error) {
2438 case -EINVAL:
2439 rtm->rtm_type = RTN_BLACKHOLE;
2440 break;
2441 case -EACCES:
2442 rtm->rtm_type = RTN_PROHIBIT;
2443 break;
b4949ab2
ND		 2444 case -EAGAIN:
2445 rtm->rtm_type = RTN_THROW;
2446 break;
ef2c7d7b
ND		 2447 default:
2448 rtm->rtm_type = RTN_UNREACHABLE;
2449 break;
2450 }
2451 }
38308473 2452 else if (rt->rt6i_flags & RTF_LOCAL)
ab79ad14 2453 rtm->rtm_type = RTN_LOCAL;
d1918542 2454 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
1da177e4
LT		 2455 rtm->rtm_type = RTN_LOCAL;
2456 else
2457 rtm->rtm_type = RTN_UNICAST;
2458 rtm->rtm_flags = 0;
2459 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2460 rtm->rtm_protocol = rt->rt6i_protocol;
38308473 2461 if (rt->rt6i_flags & RTF_DYNAMIC)
1da177e4 2462 rtm->rtm_protocol = RTPROT_REDIRECT;
f0396f60
DO		 2463 else if (rt->rt6i_flags & RTF_ADDRCONF) {
2464 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2465 rtm->rtm_protocol = RTPROT_RA;
2466 else
2467 rtm->rtm_protocol = RTPROT_KERNEL;
2468 }
1da177e4 2469
38308473 2470 if (rt->rt6i_flags & RTF_CACHE)
1da177e4
LT		 2471 rtm->rtm_flags |= RTM_F_CLONED;
2472
2473 if (dst) {
c78679e8
DM		 2474 if (nla_put(skb, RTA_DST, 16, dst))
2475 goto nla_put_failure;
1ab1457c 2476 rtm->rtm_dst_len = 128;
1da177e4 2477 } else if (rtm->rtm_dst_len)
c78679e8
DM		 2478 if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2479 goto nla_put_failure;
1da177e4
LT		 2480#ifdef CONFIG_IPV6_SUBTREES
2481 if (src) {
c78679e8
DM		 2482 if (nla_put(skb, RTA_SRC, 16, src))
2483 goto nla_put_failure;
1ab1457c 2484 rtm->rtm_src_len = 128;
c78679e8
DM		 2485 } else if (rtm->rtm_src_len &&
2486 nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2487 goto nla_put_failure;
1da177e4 2488#endif
7bc570c8
YH		 2489 if (iif) {
2490#ifdef CONFIG_IPV6_MROUTE
2491 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
8229efda 2492 int err = ip6mr_get_route(net, skb, rtm, nowait);
7bc570c8
YH		 2493 if (err <= 0) {
2494 if (!nowait) {
2495 if (err == 0)
2496 return 0;
2497 goto nla_put_failure;
2498 } else {
2499 if (err == -EMSGSIZE)
2500 goto nla_put_failure;
2501 }
2502 }
2503 } else
2504#endif
c78679e8
DM		 2505 if (nla_put_u32(skb, RTA_IIF, iif))
2506 goto nla_put_failure;
7bc570c8 2507 } else if (dst) {
1da177e4 2508 struct in6_addr saddr_buf;
c78679e8
DM		 2509 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2510 nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2511 goto nla_put_failure;
1da177e4 2512 }
2d7202bf 2513
c3968a85
DW		 2514 if (rt->rt6i_prefsrc.plen) {
2515 struct in6_addr saddr_buf;
4e3fd7a0 2516 saddr_buf = rt->rt6i_prefsrc.addr;
c78679e8
DM		 2517 if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2518 goto nla_put_failure;
c3968a85
DW		 2519 }
2520
defb3519 2521 if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2d7202bf
TG		 2522 goto nla_put_failure;
2523
dd0cbf29
YH		 2524 if (rt->rt6i_flags & RTF_GATEWAY) {
2525 if (nla_put(skb, RTA_GATEWAY, 16, &rt->rt6i_gateway) < 0)
94f826b8 2526 goto nla_put_failure;
94f826b8 2527 }
2d7202bf 2528
c78679e8
DM		 2529 if (rt->dst.dev &&
2530 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2531 goto nla_put_failure;
2532 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2533 goto nla_put_failure;
8253947e
LW		 2534
2535 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
69cdf8f9 2536
87a50699 2537 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
e3703b3d 2538 goto nla_put_failure;
2d7202bf
TG		 2539
2540 return nlmsg_end(skb, nlh);
2541
2542nla_put_failure:
26932566
PM		 2543 nlmsg_cancel(skb, nlh);
2544 return -EMSGSIZE;
1da177e4
LT		 2545}
2546
1b43af54 2547int rt6_dump_route(struct rt6_info *rt, void *p_arg)
1da177e4
LT		 2548{
2549 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2550 int prefix;
2551
2d7202bf
TG		 2552 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2553 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
1da177e4
LT		 2554 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2555 } else
2556 prefix = 0;
2557
191cd582
BH		 2558 return rt6_fill_node(arg->net,
2559 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
15e47304 2560 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
7bc570c8 2561 prefix, 0, NLM_F_MULTI);
1da177e4
LT		 2562}
2563
c127ea2c 2564static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
1da177e4 2565{
3b1e0a65 2566 struct net *net = sock_net(in_skb->sk);
ab364a6f
TG		 2567 struct nlattr *tb[RTA_MAX+1];
2568 struct rt6_info *rt;
1da177e4 2569 struct sk_buff *skb;
ab364a6f 2570 struct rtmsg *rtm;
4c9483b2 2571 struct flowi6 fl6;
72331bc0 2572 int err, iif = 0, oif = 0;
1da177e4 2573
ab364a6f
TG		 2574 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2575 if (err < 0)
2576 goto errout;
1da177e4 2577
ab364a6f 2578 err = -EINVAL;
4c9483b2 2579 memset(&fl6, 0, sizeof(fl6));
1da177e4 2580
ab364a6f
TG		 2581 if (tb[RTA_SRC]) {
2582 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2583 goto errout;
2584
4e3fd7a0 2585 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
ab364a6f
TG		 2586 }
2587
2588 if (tb[RTA_DST]) {
2589 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2590 goto errout;
2591
4e3fd7a0 2592 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
ab364a6f
TG		 2593 }
2594
2595 if (tb[RTA_IIF])
2596 iif = nla_get_u32(tb[RTA_IIF]);
2597
2598 if (tb[RTA_OIF])
72331bc0 2599 oif = nla_get_u32(tb[RTA_OIF]);
1da177e4
LT		 2600
2601 if (iif) {
2602 struct net_device *dev;
72331bc0
SL		 2603 int flags = 0;
2604
5578689a 2605 dev = __dev_get_by_index(net, iif);
1da177e4
LT		 2606 if (!dev) {
2607 err = -ENODEV;
ab364a6f 2608 goto errout;
1da177e4 2609 }
72331bc0
SL		 2610
2611 fl6.flowi6_iif = iif;
2612
2613 if (!ipv6_addr_any(&fl6.saddr))
2614 flags |= RT6_LOOKUP_F_HAS_SADDR;
2615
2616 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2617 flags);
2618 } else {
2619 fl6.flowi6_oif = oif;
2620
2621 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
1da177e4
LT		 2622 }
2623
ab364a6f 2624 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
38308473 2625 if (!skb) {
94e187c0 2626 ip6_rt_put(rt);
ab364a6f
TG		 2627 err = -ENOBUFS;
2628 goto errout;
2629 }
1da177e4 2630
ab364a6f
TG		 2631 /* Reserve room for dummy headers, this skb can pass
2632 through good chunk of routing engine.
2633 */
459a98ed 2634 skb_reset_mac_header(skb);
ab364a6f 2635 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
1da177e4 2636
d8d1f30b 2637 skb_dst_set(skb, &rt->dst);
1da177e4 2638
4c9483b2 2639 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
15e47304 2640 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
7bc570c8 2641 nlh->nlmsg_seq, 0, 0, 0);
1da177e4 2642 if (err < 0) {
ab364a6f
TG		 2643 kfree_skb(skb);
2644 goto errout;
1da177e4
LT		 2645 }
2646
15e47304 2647 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
ab364a6f 2648errout:
1da177e4 2649 return err;
1da177e4
LT		 2650}
2651
86872cb5 2652void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 2653{
2654 struct sk_buff *skb;
5578689a 2655 struct net *net = info->nl_net;
528c4ceb
DL		 2656 u32 seq;
2657 int err;
2658
2659 err = -ENOBUFS;
38308473 2660 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
86872cb5 2661
339bf98f 2662 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
38308473 2663 if (!skb)
21713ebc
TG		 2664 goto errout;
2665
191cd582 2666 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
15e47304 2667 event, info->portid, seq, 0, 0, 0);
26932566
PM		 2668 if (err < 0) {
2669 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2670 WARN_ON(err == -EMSGSIZE);
2671 kfree_skb(skb);
2672 goto errout;
2673 }
15e47304 2674 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
1ce85fe4
PNA		 2675 info->nlh, gfp_any());
2676 return;
21713ebc
TG		 2677errout:
2678 if (err < 0)
5578689a 2679 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
1da177e4
LT		 2680}
2681
8ed67789
DL		 2682static int ip6_route_dev_notify(struct notifier_block *this,
2683 unsigned long event, void *data)
2684{
2685 struct net_device *dev = (struct net_device *)data;
c346dca1 2686 struct net *net = dev_net(dev);
8ed67789
DL		 2687
2688 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
d8d1f30b 2689 net->ipv6.ip6_null_entry->dst.dev = dev;
8ed67789
DL		 2690 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2691#ifdef CONFIG_IPV6_MULTIPLE_TABLES
d8d1f30b 2692 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
8ed67789 2693 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
d8d1f30b 2694 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
8ed67789
DL		 2695 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2696#endif
2697 }
2698
2699 return NOTIFY_OK;
2700}
2701
1da177e4
LT		 2702/*
2703 * /proc
2704 */
2705
2706#ifdef CONFIG_PROC_FS
2707
1da177e4
LT		 2708struct rt6_proc_arg
2709{
2710 char *buffer;
2711 int offset;
2712 int length;
2713 int skip;
2714 int len;
2715};
2716
2717static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2718{
33120b30 2719 struct seq_file *m = p_arg;
1da177e4 2720
4b7a4274 2721 seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
1da177e4
LT		 2722
2723#ifdef CONFIG_IPV6_SUBTREES
4b7a4274 2724 seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
1da177e4 2725#else
33120b30 2726 seq_puts(m, "00000000000000000000000000000000 00 ");
1da177e4 2727#endif
dd0cbf29
YH		 2728 if (rt->rt6i_flags & RTF_GATEWAY) {
2729 seq_printf(m, "%pi6", &rt->rt6i_gateway);
1da177e4 2730 } else {
33120b30 2731 seq_puts(m, "00000000000000000000000000000000");
1da177e4 2732 }
33120b30 2733 seq_printf(m, " %08x %08x %08x %08x %8s\n",
d8d1f30b
CG		 2734 rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
2735 rt->dst.__use, rt->rt6i_flags,
d1918542 2736 rt->dst.dev ? rt->dst.dev->name : "");
1da177e4
LT		 2737 return 0;
2738}
2739
33120b30 2740static int ipv6_route_show(struct seq_file *m, void *v)
1da177e4 2741{
f3db4851 2742 struct net *net = (struct net *)m->private;
32b293a5 2743 fib6_clean_all_ro(net, rt6_info_route, 0, m);
33120b30
AD		 2744 return 0;
2745}
1da177e4 2746
33120b30
AD		 2747static int ipv6_route_open(struct inode *inode, struct file *file)
2748{
de05c557 2749 return single_open_net(inode, file, ipv6_route_show);
f3db4851
DL		 2750}
2751
33120b30
AD		 2752static const struct file_operations ipv6_route_proc_fops = {
2753 .owner = THIS_MODULE,
2754 .open = ipv6_route_open,
2755 .read = seq_read,
2756 .llseek = seq_lseek,
b6fcbdb4 2757 .release = single_release_net,
33120b30
AD		 2758};
2759
1da177e4
LT		 2760static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2761{
69ddb805 2762 struct net *net = (struct net *)seq->private;
1da177e4 2763 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
69ddb805
DL		 2764 net->ipv6.rt6_stats->fib_nodes,
2765 net->ipv6.rt6_stats->fib_route_nodes,
2766 net->ipv6.rt6_stats->fib_rt_alloc,
2767 net->ipv6.rt6_stats->fib_rt_entries,
2768 net->ipv6.rt6_stats->fib_rt_cache,
fc66f95c 2769 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
69ddb805 2770 net->ipv6.rt6_stats->fib_discarded_routes);
1da177e4
LT		 2771
2772 return 0;
2773}
2774
2775static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2776{
de05c557 2777 return single_open_net(inode, file, rt6_stats_seq_show);
69ddb805
DL		 2778}
2779
9a32144e 2780static const struct file_operations rt6_stats_seq_fops = {
1da177e4
LT		 2781 .owner = THIS_MODULE,
2782 .open = rt6_stats_seq_open,
2783 .read = seq_read,
2784 .llseek = seq_lseek,
b6fcbdb4 2785 .release = single_release_net,
1da177e4
LT		 2786};
2787#endif /* CONFIG_PROC_FS */
2788
2789#ifdef CONFIG_SYSCTL
2790
1da177e4 2791static
8d65af78 2792int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,
1da177e4
LT		 2793 void __user *buffer, size_t *lenp, loff_t *ppos)
2794{
c486da34
LAG		 2795 struct net *net;
2796 int delay;
2797 if (!write)
1da177e4 2798 return -EINVAL;
c486da34
LAG		 2799
2800 net = (struct net *)ctl->extra1;
2801 delay = net->ipv6.sysctl.flush_delay;
2802 proc_dointvec(ctl, write, buffer, lenp, ppos);
2803 fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
2804 return 0;
1da177e4
LT		 2805}
2806
760f2d01 2807ctl_table ipv6_route_table_template[] = {
1ab1457c 2808 {
1da177e4 2809 .procname = "flush",
4990509f 2810 .data = &init_net.ipv6.sysctl.flush_delay,
1da177e4 2811 .maxlen = sizeof(int),
89c8b3a1 2812 .mode = 0200,
6d9f239a 2813 .proc_handler = ipv6_sysctl_rtcache_flush
1da177e4
LT		 2814 },
2815 {
1da177e4 2816 .procname = "gc_thresh",
9a7ec3a9 2817 .data = &ip6_dst_ops_template.gc_thresh,
1da177e4
LT		 2818 .maxlen = sizeof(int),
2819 .mode = 0644,
6d9f239a 2820 .proc_handler = proc_dointvec,
1da177e4
LT		 2821 },
2822 {
1da177e4 2823 .procname = "max_size",
4990509f 2824 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
1da177e4
LT		 2825 .maxlen = sizeof(int),
2826 .mode = 0644,
6d9f239a 2827 .proc_handler = proc_dointvec,
1da177e4
LT		 2828 },
2829 {
1da177e4 2830 .procname = "gc_min_interval",
4990509f 2831 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 2832 .maxlen = sizeof(int),
2833 .mode = 0644,
6d9f239a 2834 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2835 },
2836 {
1da177e4 2837 .procname = "gc_timeout",
4990509f 2838 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
1da177e4
LT		 2839 .maxlen = sizeof(int),
2840 .mode = 0644,
6d9f239a 2841 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2842 },
2843 {
1da177e4 2844 .procname = "gc_interval",
4990509f 2845 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
1da177e4
LT		 2846 .maxlen = sizeof(int),
2847 .mode = 0644,
6d9f239a 2848 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2849 },
2850 {
1da177e4 2851 .procname = "gc_elasticity",
4990509f 2852 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
1da177e4
LT		 2853 .maxlen = sizeof(int),
2854 .mode = 0644,
f3d3f616 2855 .proc_handler = proc_dointvec,
1da177e4
LT		 2856 },
2857 {
1da177e4 2858 .procname = "mtu_expires",
4990509f 2859 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
1da177e4
LT		 2860 .maxlen = sizeof(int),
2861 .mode = 0644,
6d9f239a 2862 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2863 },
2864 {
1da177e4 2865 .procname = "min_adv_mss",
4990509f 2866 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
1da177e4
LT		 2867 .maxlen = sizeof(int),
2868 .mode = 0644,
f3d3f616 2869 .proc_handler = proc_dointvec,
1da177e4
LT		 2870 },
2871 {
1da177e4 2872 .procname = "gc_min_interval_ms",
4990509f 2873 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 2874 .maxlen = sizeof(int),
2875 .mode = 0644,
6d9f239a 2876 .proc_handler = proc_dointvec_ms_jiffies,
1da177e4 2877 },
f8572d8f 2878 { }
1da177e4
LT		 2879};
2880
2c8c1e72 2881struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
760f2d01
DL		 2882{
2883 struct ctl_table *table;
2884
2885 table = kmemdup(ipv6_route_table_template,
2886 sizeof(ipv6_route_table_template),
2887 GFP_KERNEL);
5ee09105
YH		 2888
2889 if (table) {
2890 table[0].data = &net->ipv6.sysctl.flush_delay;
c486da34 2891 table[0].extra1 = net;
86393e52 2892 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
5ee09105
YH		 2893 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2894 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2895 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2896 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2897 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2898 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2899 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
9c69fabe 2900 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
464dc801
EB		 2901
2902 /* Don't export sysctls to unprivileged users */
2903 if (net->user_ns != &init_user_ns)
2904 table[0].procname = NULL;
5ee09105
YH		 2905 }
2906
760f2d01
DL		 2907 return table;
2908}
1da177e4
LT		 2909#endif
2910
2c8c1e72 2911static int __net_init ip6_route_net_init(struct net *net)
cdb18761 2912{
633d424b 2913 int ret = -ENOMEM;
8ed67789 2914
86393e52
AD		 2915 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
2916 sizeof(net->ipv6.ip6_dst_ops));
f2fc6a54 2917
fc66f95c
ED		 2918 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
2919 goto out_ip6_dst_ops;
2920
8ed67789
DL		 2921 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
2922 sizeof(*net->ipv6.ip6_null_entry),
2923 GFP_KERNEL);
2924 if (!net->ipv6.ip6_null_entry)
fc66f95c 2925 goto out_ip6_dst_entries;
d8d1f30b 2926 net->ipv6.ip6_null_entry->dst.path =
8ed67789 2927 (struct dst_entry *)net->ipv6.ip6_null_entry;
d8d1f30b 2928 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 2929 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
2930 ip6_template_metrics, true);
8ed67789
DL		 2931
2932#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2933 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
2934 sizeof(*net->ipv6.ip6_prohibit_entry),
2935 GFP_KERNEL);
68fffc67
PZ		 2936 if (!net->ipv6.ip6_prohibit_entry)
2937 goto out_ip6_null_entry;
d8d1f30b 2938 net->ipv6.ip6_prohibit_entry->dst.path =
8ed67789 2939 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
d8d1f30b 2940 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 2941 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
2942 ip6_template_metrics, true);
8ed67789
DL		 2943
2944 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
2945 sizeof(*net->ipv6.ip6_blk_hole_entry),
2946 GFP_KERNEL);
68fffc67
PZ		 2947 if (!net->ipv6.ip6_blk_hole_entry)
2948 goto out_ip6_prohibit_entry;
d8d1f30b 2949 net->ipv6.ip6_blk_hole_entry->dst.path =
8ed67789 2950 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
d8d1f30b 2951 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 2952 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
2953 ip6_template_metrics, true);
8ed67789
DL		 2954#endif
2955
b339a47c
PZ		 2956 net->ipv6.sysctl.flush_delay = 0;
2957 net->ipv6.sysctl.ip6_rt_max_size = 4096;
2958 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
2959 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
2960 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
2961 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
2962 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
2963 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
2964
6891a346
BT		 2965 net->ipv6.ip6_rt_gc_expire = 30*HZ;
2966
8ed67789
DL		 2967 ret = 0;
2968out:
2969 return ret;
f2fc6a54 2970
68fffc67
PZ		 2971#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2972out_ip6_prohibit_entry:
2973 kfree(net->ipv6.ip6_prohibit_entry);
2974out_ip6_null_entry:
2975 kfree(net->ipv6.ip6_null_entry);
2976#endif
fc66f95c
ED		 2977out_ip6_dst_entries:
2978 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
f2fc6a54 2979out_ip6_dst_ops:
f2fc6a54 2980 goto out;
cdb18761
DL		 2981}
2982
2c8c1e72 2983static void __net_exit ip6_route_net_exit(struct net *net)
cdb18761 2984{
8ed67789
DL		 2985 kfree(net->ipv6.ip6_null_entry);
2986#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2987 kfree(net->ipv6.ip6_prohibit_entry);
2988 kfree(net->ipv6.ip6_blk_hole_entry);
2989#endif
41bb78b4 2990 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
cdb18761
DL		 2991}
2992
d189634e
TG		 2993static int __net_init ip6_route_net_init_late(struct net *net)
2994{
2995#ifdef CONFIG_PROC_FS
d4beaa66
G		 2996 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
2997 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
d189634e
TG		 2998#endif
2999 return 0;
3000}
3001
3002static void __net_exit ip6_route_net_exit_late(struct net *net)
3003{
3004#ifdef CONFIG_PROC_FS
ece31ffd
G		 3005 remove_proc_entry("ipv6_route", net->proc_net);
3006 remove_proc_entry("rt6_stats", net->proc_net);
d189634e
TG		 3007#endif
3008}
3009
cdb18761
DL		 3010static struct pernet_operations ip6_route_net_ops = {
3011 .init = ip6_route_net_init,
3012 .exit = ip6_route_net_exit,
3013};
3014
c3426b47
DM		 3015static int __net_init ipv6_inetpeer_init(struct net *net)
3016{
3017 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3018
3019 if (!bp)
3020 return -ENOMEM;
3021 inet_peer_base_init(bp);
3022 net->ipv6.peers = bp;
3023 return 0;
3024}
3025
3026static void __net_exit ipv6_inetpeer_exit(struct net *net)
3027{
3028 struct inet_peer_base *bp = net->ipv6.peers;
3029
3030 net->ipv6.peers = NULL;
56a6b248 3031 inetpeer_invalidate_tree(bp);
c3426b47
DM		 3032 kfree(bp);
3033}
3034
2b823f72 3035static struct pernet_operations ipv6_inetpeer_ops = {
c3426b47
DM		 3036 .init = ipv6_inetpeer_init,
3037 .exit = ipv6_inetpeer_exit,
3038};
3039
d189634e
TG		 3040static struct pernet_operations ip6_route_net_late_ops = {
3041 .init = ip6_route_net_init_late,
3042 .exit = ip6_route_net_exit_late,
3043};
3044
8ed67789
DL		 3045static struct notifier_block ip6_route_dev_notifier = {
3046 .notifier_call = ip6_route_dev_notify,
3047 .priority = 0,
3048};
3049
433d49c3 3050int __init ip6_route_init(void)
1da177e4 3051{
433d49c3
DL		 3052 int ret;
3053
9a7ec3a9
DL		 3054 ret = -ENOMEM;
3055 ip6_dst_ops_template.kmem_cachep =
e5d679f3 3056 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
f845ab6b 3057 SLAB_HWCACHE_ALIGN, NULL);
9a7ec3a9 3058 if (!ip6_dst_ops_template.kmem_cachep)
c19a28e1 3059 goto out;
14e50e57 3060
fc66f95c 3061 ret = dst_entries_init(&ip6_dst_blackhole_ops);
8ed67789 3062 if (ret)
bdb3289f 3063 goto out_kmem_cache;
bdb3289f 3064
c3426b47
DM		 3065 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3066 if (ret)
e8803b6c 3067 goto out_dst_entries;
2a0c451a 3068
7e52b33b
DM		 3069 ret = register_pernet_subsys(&ip6_route_net_ops);
3070 if (ret)
3071 goto out_register_inetpeer;
c3426b47 3072
5dc121e9
AE		 3073 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3074
8ed67789
DL		 3075 /* Registering of the loopback is done before this portion of code,
3076 * the loopback reference in rt6_info will not be taken, do it
3077 * manually for init_net */
d8d1f30b 3078 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
8ed67789
DL		 3079 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3080 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
d8d1f30b 3081 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
8ed67789 3082 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
d8d1f30b 3083 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
8ed67789
DL		 3084 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3085 #endif
e8803b6c 3086 ret = fib6_init();
433d49c3 3087 if (ret)
8ed67789 3088 goto out_register_subsys;
433d49c3 3089
433d49c3
DL		 3090 ret = xfrm6_init();
3091 if (ret)
e8803b6c 3092 goto out_fib6_init;
c35b7e72 3093
433d49c3
DL		 3094 ret = fib6_rules_init();
3095 if (ret)
3096 goto xfrm6_init;
7e5449c2 3097
d189634e
TG		 3098 ret = register_pernet_subsys(&ip6_route_net_late_ops);
3099 if (ret)
3100 goto fib6_rules_init;
3101
433d49c3 3102 ret = -ENOBUFS;
c7ac8679
GR		 3103 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3104 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3105 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
d189634e 3106 goto out_register_late_subsys;
c127ea2c 3107
8ed67789 3108 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
cdb18761 3109 if (ret)
d189634e 3110 goto out_register_late_subsys;
8ed67789 3111
433d49c3
DL		 3112out:
3113 return ret;
3114
d189634e
TG		 3115out_register_late_subsys:
3116 unregister_pernet_subsys(&ip6_route_net_late_ops);
433d49c3 3117fib6_rules_init:
433d49c3
DL		 3118 fib6_rules_cleanup();
3119xfrm6_init:
433d49c3 3120 xfrm6_fini();
2a0c451a
TG		 3121out_fib6_init:
3122 fib6_gc_cleanup();
8ed67789
DL		 3123out_register_subsys:
3124 unregister_pernet_subsys(&ip6_route_net_ops);
7e52b33b
DM		 3125out_register_inetpeer:
3126 unregister_pernet_subsys(&ipv6_inetpeer_ops);
fc66f95c
ED		 3127out_dst_entries:
3128 dst_entries_destroy(&ip6_dst_blackhole_ops);
433d49c3 3129out_kmem_cache:
f2fc6a54 3130 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
433d49c3 3131 goto out;
1da177e4
LT		 3132}
3133
3134void ip6_route_cleanup(void)
3135{
8ed67789 3136 unregister_netdevice_notifier(&ip6_route_dev_notifier);
d189634e 3137 unregister_pernet_subsys(&ip6_route_net_late_ops);
101367c2 3138 fib6_rules_cleanup();
1da177e4 3139 xfrm6_fini();
1da177e4 3140 fib6_gc_cleanup();
c3426b47 3141 unregister_pernet_subsys(&ipv6_inetpeer_ops);
8ed67789 3142 unregister_pernet_subsys(&ip6_route_net_ops);
41bb78b4 3143 dst_entries_destroy(&ip6_dst_blackhole_ops);
f2fc6a54 3144 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
1da177e4 3145}
kernel source for telekom puls (alcatel/mediatek)