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