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