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