]> bbs.cooldavid.org Git - net-next-2.6.git/blame - net/ipv6/route.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
iwlwifi: don't include iwl-dev.h from iwl-devtrace.h
[net-next-2.6.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
4fc268d2 27#include <linux/capability.h>
1da177e4
LT		 28#include <linux/errno.h>
29#include <linux/types.h>
30#include <linux/times.h>
31#include <linux/socket.h>
32#include <linux/sockios.h>
33#include <linux/net.h>
34#include <linux/route.h>
35#include <linux/netdevice.h>
36#include <linux/in6.h>
7bc570c8 37#include <linux/mroute6.h>
1da177e4 38#include <linux/init.h>
1da177e4 39#include <linux/if_arp.h>
1da177e4
LT		 40#include <linux/proc_fs.h>
41#include <linux/seq_file.h>
5b7c931d 42#include <linux/nsproxy.h>
457c4cbc 43#include <net/net_namespace.h>
1da177e4
LT		 44#include <net/snmp.h>
45#include <net/ipv6.h>
46#include <net/ip6_fib.h>
47#include <net/ip6_route.h>
48#include <net/ndisc.h>
49#include <net/addrconf.h>
50#include <net/tcp.h>
51#include <linux/rtnetlink.h>
52#include <net/dst.h>
53#include <net/xfrm.h>
8d71740c 54#include <net/netevent.h>
21713ebc 55#include <net/netlink.h>
1da177e4
LT		 56
57#include <asm/uaccess.h>
58
59#ifdef CONFIG_SYSCTL
60#include <linux/sysctl.h>
61#endif
62
63/* Set to 3 to get tracing. */
64#define RT6_DEBUG 2
65
66#if RT6_DEBUG >= 3
67#define RDBG(x) printk x
68#define RT6_TRACE(x...) printk(KERN_DEBUG x)
69#else
70#define RDBG(x)
71#define RT6_TRACE(x...) do { ; } while (0)
72#endif
73
519fbd87 74#define CLONE_OFFLINK_ROUTE 0
1da177e4 75
1da177e4
LT		 76static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
77static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
78static struct dst_entry *ip6_negative_advice(struct dst_entry *);
79static void ip6_dst_destroy(struct dst_entry *);
80static void ip6_dst_ifdown(struct dst_entry *,
81 struct net_device *dev, int how);
569d3645 82static int ip6_dst_gc(struct dst_ops *ops);
1da177e4
LT		 83
84static int ip6_pkt_discard(struct sk_buff *skb);
85static int ip6_pkt_discard_out(struct sk_buff *skb);
86static void ip6_link_failure(struct sk_buff *skb);
87static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
88
70ceb4f5 89#ifdef CONFIG_IPV6_ROUTE_INFO
efa2cea0
DL		 90static struct rt6_info *rt6_add_route_info(struct net *net,
91 struct in6_addr *prefix, int prefixlen,
70ceb4f5
YH		 92 struct in6_addr *gwaddr, int ifindex,
93 unsigned pref);
efa2cea0
DL		 94static struct rt6_info *rt6_get_route_info(struct net *net,
95 struct in6_addr *prefix, int prefixlen,
70ceb4f5
YH		 96 struct in6_addr *gwaddr, int ifindex);
97#endif
98
9a7ec3a9 99static struct dst_ops ip6_dst_ops_template = {
1da177e4 100 .family = AF_INET6,
09640e63 101 .protocol = cpu_to_be16(ETH_P_IPV6),
1da177e4
LT		 102 .gc = ip6_dst_gc,
103 .gc_thresh = 1024,
104 .check = ip6_dst_check,
105 .destroy = ip6_dst_destroy,
106 .ifdown = ip6_dst_ifdown,
107 .negative_advice = ip6_negative_advice,
108 .link_failure = ip6_link_failure,
109 .update_pmtu = ip6_rt_update_pmtu,
1ac06e03 110 .local_out = __ip6_local_out,
e2422970 111 .entries = ATOMIC_INIT(0),
1da177e4
LT		 112};
113
14e50e57
DM		 114static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
115{
116}
117
118static struct dst_ops ip6_dst_blackhole_ops = {
119 .family = AF_INET6,
09640e63 120 .protocol = cpu_to_be16(ETH_P_IPV6),
14e50e57
DM		 121 .destroy = ip6_dst_destroy,
122 .check = ip6_dst_check,
123 .update_pmtu = ip6_rt_blackhole_update_pmtu,
e2422970 124 .entries = ATOMIC_INIT(0),
14e50e57
DM		 125};
126
bdb3289f 127static struct rt6_info ip6_null_entry_template = {
1da177e4
LT		 128 .u = {
129 .dst = {
130 .__refcnt = ATOMIC_INIT(1),
131 .__use = 1,
1da177e4
LT		 132 .obsolete = -1,
133 .error = -ENETUNREACH,
134 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
135 .input = ip6_pkt_discard,
136 .output = ip6_pkt_discard_out,
1da177e4
LT		 137 }
138 },
139 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
4f724279 140 .rt6i_protocol = RTPROT_KERNEL,
1da177e4
LT		 141 .rt6i_metric = ~(u32) 0,
142 .rt6i_ref = ATOMIC_INIT(1),
143};
144
101367c2
TG		 145#ifdef CONFIG_IPV6_MULTIPLE_TABLES
146
6723ab54
DM		 147static int ip6_pkt_prohibit(struct sk_buff *skb);
148static int ip6_pkt_prohibit_out(struct sk_buff *skb);
6723ab54 149
280a34c8 150static struct rt6_info ip6_prohibit_entry_template = {
101367c2
TG		 151 .u = {
152 .dst = {
153 .__refcnt = ATOMIC_INIT(1),
154 .__use = 1,
101367c2
TG		 155 .obsolete = -1,
156 .error = -EACCES,
157 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
9ce8ade0
TG		 158 .input = ip6_pkt_prohibit,
159 .output = ip6_pkt_prohibit_out,
101367c2
TG		 160 }
161 },
162 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
4f724279 163 .rt6i_protocol = RTPROT_KERNEL,
101367c2
TG		 164 .rt6i_metric = ~(u32) 0,
165 .rt6i_ref = ATOMIC_INIT(1),
166};
167
bdb3289f 168static struct rt6_info ip6_blk_hole_entry_template = {
101367c2
TG		 169 .u = {
170 .dst = {
171 .__refcnt = ATOMIC_INIT(1),
172 .__use = 1,
101367c2
TG		 173 .obsolete = -1,
174 .error = -EINVAL,
175 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
352e512c
HX		 176 .input = dst_discard,
177 .output = dst_discard,
101367c2
TG		 178 }
179 },
180 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
4f724279 181 .rt6i_protocol = RTPROT_KERNEL,
101367c2
TG		 182 .rt6i_metric = ~(u32) 0,
183 .rt6i_ref = ATOMIC_INIT(1),
184};
185
186#endif
187
1da177e4 188/* allocate dst with ip6_dst_ops */
f2fc6a54 189static inline struct rt6_info *ip6_dst_alloc(struct dst_ops *ops)
1da177e4 190{
f2fc6a54 191 return (struct rt6_info *)dst_alloc(ops);
1da177e4
LT		 192}
193
194static void ip6_dst_destroy(struct dst_entry *dst)
195{
196 struct rt6_info *rt = (struct rt6_info *)dst;
197 struct inet6_dev *idev = rt->rt6i_idev;
198
199 if (idev != NULL) {
200 rt->rt6i_idev = NULL;
201 in6_dev_put(idev);
1ab1457c 202 }
1da177e4
LT		 203}
204
205static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
206 int how)
207{
208 struct rt6_info *rt = (struct rt6_info *)dst;
209 struct inet6_dev *idev = rt->rt6i_idev;
5a3e55d6 210 struct net_device *loopback_dev =
c346dca1 211 dev_net(dev)->loopback_dev;
1da177e4 212
5a3e55d6
DL		 213 if (dev != loopback_dev && idev != NULL && idev->dev == dev) {
214 struct inet6_dev *loopback_idev =
215 in6_dev_get(loopback_dev);
1da177e4
LT		 216 if (loopback_idev != NULL) {
217 rt->rt6i_idev = loopback_idev;
218 in6_dev_put(idev);
219 }
220 }
221}
222
223static __inline__ int rt6_check_expired(const struct rt6_info *rt)
224{
225 return (rt->rt6i_flags & RTF_EXPIRES &&
226 time_after(jiffies, rt->rt6i_expires));
227}
228
c71099ac
TG		 229static inline int rt6_need_strict(struct in6_addr *daddr)
230{
231 return (ipv6_addr_type(daddr) &
5ce83afa 232 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK));
c71099ac
TG		 233}
234
1da177e4 235/*
c71099ac 236 * Route lookup. Any table->tb6_lock is implied.
1da177e4
LT		 237 */
238
8ed67789
DL		 239static inline struct rt6_info *rt6_device_match(struct net *net,
240 struct rt6_info *rt,
dd3abc4e 241 struct in6_addr *saddr,
1da177e4 242 int oif,
d420895e 243 int flags)
1da177e4
LT		 244{
245 struct rt6_info *local = NULL;
246 struct rt6_info *sprt;
247
dd3abc4e
YH		 248 if (!oif && ipv6_addr_any(saddr))
249 goto out;
250
251 for (sprt = rt; sprt; sprt = sprt->u.dst.rt6_next) {
252 struct net_device *dev = sprt->rt6i_dev;
253
254 if (oif) {
1da177e4
LT		 255 if (dev->ifindex == oif)
256 return sprt;
257 if (dev->flags & IFF_LOOPBACK) {
258 if (sprt->rt6i_idev == NULL ||
259 sprt->rt6i_idev->dev->ifindex != oif) {
d420895e 260 if (flags & RT6_LOOKUP_F_IFACE && oif)
1da177e4 261 continue;
1ab1457c 262 if (local && (!oif ||
1da177e4
LT		 263 local->rt6i_idev->dev->ifindex == oif))
264 continue;
265 }
266 local = sprt;
267 }
dd3abc4e
YH		 268 } else {
269 if (ipv6_chk_addr(net, saddr, dev,
270 flags & RT6_LOOKUP_F_IFACE))
271 return sprt;
1da177e4 272 }
dd3abc4e 273 }
1da177e4 274
dd3abc4e 275 if (oif) {
1da177e4
LT		 276 if (local)
277 return local;
278
d420895e 279 if (flags & RT6_LOOKUP_F_IFACE)
8ed67789 280 return net->ipv6.ip6_null_entry;
1da177e4 281 }
dd3abc4e 282out:
1da177e4
LT		 283 return rt;
284}
285
27097255
YH		 286#ifdef CONFIG_IPV6_ROUTER_PREF
287static void rt6_probe(struct rt6_info *rt)
288{
289 struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
290 /*
291 * Okay, this does not seem to be appropriate
292 * for now, however, we need to check if it
293 * is really so; aka Router Reachability Probing.
294 *
295 * Router Reachability Probe MUST be rate-limited
296 * to no more than one per minute.
297 */
298 if (!neigh || (neigh->nud_state & NUD_VALID))
299 return;
300 read_lock_bh(&neigh->lock);
301 if (!(neigh->nud_state & NUD_VALID) &&
52e16356 302 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
27097255
YH		 303 struct in6_addr mcaddr;
304 struct in6_addr *target;
305
306 neigh->updated = jiffies;
307 read_unlock_bh(&neigh->lock);
308
309 target = (struct in6_addr *)&neigh->primary_key;
310 addrconf_addr_solict_mult(target, &mcaddr);
311 ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
312 } else
313 read_unlock_bh(&neigh->lock);
314}
315#else
316static inline void rt6_probe(struct rt6_info *rt)
317{
318 return;
319}
320#endif
321
1da177e4 322/*
554cfb7e 323 * Default Router Selection (RFC 2461 6.3.6)
1da177e4 324 */
b6f99a21 325static inline int rt6_check_dev(struct rt6_info *rt, int oif)
554cfb7e
YH		 326{
327 struct net_device *dev = rt->rt6i_dev;
161980f4 328 if (!oif || dev->ifindex == oif)
554cfb7e 329 return 2;
161980f4
DM		 330 if ((dev->flags & IFF_LOOPBACK) &&
331 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
332 return 1;
333 return 0;
554cfb7e 334}
1da177e4 335
b6f99a21 336static inline int rt6_check_neigh(struct rt6_info *rt)
1da177e4 337{
554cfb7e 338 struct neighbour *neigh = rt->rt6i_nexthop;
398bcbeb 339 int m;
4d0c5911
YH		 340 if (rt->rt6i_flags & RTF_NONEXTHOP ||
341 !(rt->rt6i_flags & RTF_GATEWAY))
342 m = 1;
343 else if (neigh) {
554cfb7e
YH		 344 read_lock_bh(&neigh->lock);
345 if (neigh->nud_state & NUD_VALID)
4d0c5911 346 m = 2;
398bcbeb
YH		 347#ifdef CONFIG_IPV6_ROUTER_PREF
348 else if (neigh->nud_state & NUD_FAILED)
349 m = 0;
350#endif
351 else
ea73ee23 352 m = 1;
554cfb7e 353 read_unlock_bh(&neigh->lock);
398bcbeb
YH		 354 } else
355 m = 0;
554cfb7e 356 return m;
1da177e4
LT		 357}
358
554cfb7e
YH		 359static int rt6_score_route(struct rt6_info *rt, int oif,
360 int strict)
1da177e4 361{
4d0c5911 362 int m, n;
1ab1457c 363
4d0c5911 364 m = rt6_check_dev(rt, oif);
77d16f45 365 if (!m && (strict & RT6_LOOKUP_F_IFACE))
554cfb7e 366 return -1;
ebacaaa0
YH		 367#ifdef CONFIG_IPV6_ROUTER_PREF
368 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
369#endif
4d0c5911 370 n = rt6_check_neigh(rt);
557e92ef 371 if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
554cfb7e
YH		 372 return -1;
373 return m;
374}
375
f11e6659
DM		 376static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
377 int *mpri, struct rt6_info *match)
554cfb7e 378{
f11e6659
DM		 379 int m;
380
381 if (rt6_check_expired(rt))
382 goto out;
383
384 m = rt6_score_route(rt, oif, strict);
385 if (m < 0)
386 goto out;
387
388 if (m > *mpri) {
389 if (strict & RT6_LOOKUP_F_REACHABLE)
390 rt6_probe(match);
391 *mpri = m;
392 match = rt;
393 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
394 rt6_probe(rt);
395 }
396
397out:
398 return match;
399}
400
401static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
402 struct rt6_info *rr_head,
403 u32 metric, int oif, int strict)
404{
405 struct rt6_info *rt, *match;
554cfb7e 406 int mpri = -1;
1da177e4 407
f11e6659
DM		 408 match = NULL;
409 for (rt = rr_head; rt && rt->rt6i_metric == metric;
410 rt = rt->u.dst.rt6_next)
411 match = find_match(rt, oif, strict, &mpri, match);
412 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
413 rt = rt->u.dst.rt6_next)
414 match = find_match(rt, oif, strict, &mpri, match);
1da177e4 415
f11e6659
DM		 416 return match;
417}
1da177e4 418
f11e6659
DM		 419static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
420{
421 struct rt6_info *match, *rt0;
8ed67789 422 struct net *net;
1da177e4 423
f11e6659 424 RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
0dc47877 425 __func__, fn->leaf, oif);
554cfb7e 426
f11e6659
DM		 427 rt0 = fn->rr_ptr;
428 if (!rt0)
429 fn->rr_ptr = rt0 = fn->leaf;
1da177e4 430
f11e6659 431 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
1da177e4 432
554cfb7e 433 if (!match &&
f11e6659
DM		 434 (strict & RT6_LOOKUP_F_REACHABLE)) {
435 struct rt6_info *next = rt0->u.dst.rt6_next;
436
554cfb7e 437 /* no entries matched; do round-robin */
f11e6659
DM		 438 if (!next || next->rt6i_metric != rt0->rt6i_metric)
439 next = fn->leaf;
440
441 if (next != rt0)
442 fn->rr_ptr = next;
1da177e4 443 }
1da177e4 444
f11e6659 445 RT6_TRACE("%s() => %p\n",
0dc47877 446 __func__, match);
1da177e4 447
c346dca1 448 net = dev_net(rt0->rt6i_dev);
8ed67789 449 return (match ? match : net->ipv6.ip6_null_entry);
1da177e4
LT		 450}
451
70ceb4f5
YH		 452#ifdef CONFIG_IPV6_ROUTE_INFO
453int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
454 struct in6_addr *gwaddr)
455{
c346dca1 456 struct net *net = dev_net(dev);
70ceb4f5
YH		 457 struct route_info *rinfo = (struct route_info *) opt;
458 struct in6_addr prefix_buf, *prefix;
459 unsigned int pref;
4bed72e4 460 unsigned long lifetime;
70ceb4f5
YH		 461 struct rt6_info *rt;
462
463 if (len < sizeof(struct route_info)) {
464 return -EINVAL;
465 }
466
467 /* Sanity check for prefix_len and length */
468 if (rinfo->length > 3) {
469 return -EINVAL;
470 } else if (rinfo->prefix_len > 128) {
471 return -EINVAL;
472 } else if (rinfo->prefix_len > 64) {
473 if (rinfo->length < 2) {
474 return -EINVAL;
475 }
476 } else if (rinfo->prefix_len > 0) {
477 if (rinfo->length < 1) {
478 return -EINVAL;
479 }
480 }
481
482 pref = rinfo->route_pref;
483 if (pref == ICMPV6_ROUTER_PREF_INVALID)
3933fc95 484 return -EINVAL;
70ceb4f5 485
4bed72e4 486 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
70ceb4f5
YH		 487
488 if (rinfo->length == 3)
489 prefix = (struct in6_addr *)rinfo->prefix;
490 else {
491 /* this function is safe */
492 ipv6_addr_prefix(&prefix_buf,
493 (struct in6_addr *)rinfo->prefix,
494 rinfo->prefix_len);
495 prefix = &prefix_buf;
496 }
497
efa2cea0
DL		 498 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len, gwaddr,
499 dev->ifindex);
70ceb4f5
YH		 500
501 if (rt && !lifetime) {
e0a1ad73 502 ip6_del_rt(rt);
70ceb4f5
YH		 503 rt = NULL;
504 }
505
506 if (!rt && lifetime)
efa2cea0 507 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
70ceb4f5
YH		 508 pref);
509 else if (rt)
510 rt->rt6i_flags = RTF_ROUTEINFO |
511 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
512
513 if (rt) {
4bed72e4 514 if (!addrconf_finite_timeout(lifetime)) {
70ceb4f5
YH		 515 rt->rt6i_flags &= ~RTF_EXPIRES;
516 } else {
517 rt->rt6i_expires = jiffies + HZ * lifetime;
518 rt->rt6i_flags |= RTF_EXPIRES;
519 }
520 dst_release(&rt->u.dst);
521 }
522 return 0;
523}
524#endif
525
8ed67789 526#define BACKTRACK(__net, saddr) \
982f56f3 527do { \
8ed67789 528 if (rt == __net->ipv6.ip6_null_entry) { \
982f56f3 529 struct fib6_node *pn; \
e0eda7bb 530 while (1) { \
982f56f3
YH		 531 if (fn->fn_flags & RTN_TL_ROOT) \
532 goto out; \
533 pn = fn->parent; \
534 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
8bce65b9 535 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
982f56f3
YH		 536 else \
537 fn = pn; \
538 if (fn->fn_flags & RTN_RTINFO) \
539 goto restart; \
c71099ac 540 } \
c71099ac 541 } \
982f56f3 542} while(0)
c71099ac 543
8ed67789
DL		 544static struct rt6_info *ip6_pol_route_lookup(struct net *net,
545 struct fib6_table *table,
c71099ac 546 struct flowi *fl, int flags)
1da177e4
LT		 547{
548 struct fib6_node *fn;
549 struct rt6_info *rt;
550
c71099ac
TG		 551 read_lock_bh(&table->tb6_lock);
552 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
553restart:
554 rt = fn->leaf;
dd3abc4e 555 rt = rt6_device_match(net, rt, &fl->fl6_src, fl->oif, flags);
8ed67789 556 BACKTRACK(net, &fl->fl6_src);
c71099ac 557out:
03f49f34 558 dst_use(&rt->u.dst, jiffies);
c71099ac 559 read_unlock_bh(&table->tb6_lock);
c71099ac
TG		 560 return rt;
561
562}
563
9acd9f3a
YH		 564struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
565 const struct in6_addr *saddr, int oif, int strict)
c71099ac
TG		 566{
567 struct flowi fl = {
568 .oif = oif,
569 .nl_u = {
570 .ip6_u = {
571 .daddr = *daddr,
c71099ac
TG		 572 },
573 },
574 };
575 struct dst_entry *dst;
77d16f45 576 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
c71099ac 577
adaa70bb
TG		 578 if (saddr) {
579 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
580 flags |= RT6_LOOKUP_F_HAS_SADDR;
581 }
582
606a2b48 583 dst = fib6_rule_lookup(net, &fl, flags, ip6_pol_route_lookup);
c71099ac
TG		 584 if (dst->error == 0)
585 return (struct rt6_info *) dst;
586
587 dst_release(dst);
588
1da177e4
LT		 589 return NULL;
590}
591
7159039a
YH		 592EXPORT_SYMBOL(rt6_lookup);
593
c71099ac 594/* ip6_ins_rt is called with FREE table->tb6_lock.
1da177e4
LT		 595 It takes new route entry, the addition fails by any reason the
596 route is freed. In any case, if caller does not hold it, it may
597 be destroyed.
598 */
599
86872cb5 600static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 601{
602 int err;
c71099ac 603 struct fib6_table *table;
1da177e4 604
c71099ac
TG		 605 table = rt->rt6i_table;
606 write_lock_bh(&table->tb6_lock);
86872cb5 607 err = fib6_add(&table->tb6_root, rt, info);
c71099ac 608 write_unlock_bh(&table->tb6_lock);
1da177e4
LT		 609
610 return err;
611}
612
40e22e8f
TG		 613int ip6_ins_rt(struct rt6_info *rt)
614{
4d1169c1 615 struct nl_info info = {
c346dca1 616 .nl_net = dev_net(rt->rt6i_dev),
4d1169c1 617 };
528c4ceb 618 return __ip6_ins_rt(rt, &info);
40e22e8f
TG		 619}
620
95a9a5ba
YH		 621static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
622 struct in6_addr *saddr)
1da177e4 623{
1da177e4
LT		 624 struct rt6_info *rt;
625
626 /*
627 * Clone the route.
628 */
629
630 rt = ip6_rt_copy(ort);
631
632 if (rt) {
14deae41
DM		 633 struct neighbour *neigh;
634 int attempts = !in_softirq();
635
58c4fb86
YH		 636 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
637 if (rt->rt6i_dst.plen != 128 &&
638 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
639 rt->rt6i_flags |= RTF_ANYCAST;
1da177e4 640 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
58c4fb86 641 }
1da177e4 642
58c4fb86 643 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
1da177e4
LT		 644 rt->rt6i_dst.plen = 128;
645 rt->rt6i_flags |= RTF_CACHE;
646 rt->u.dst.flags |= DST_HOST;
647
648#ifdef CONFIG_IPV6_SUBTREES
649 if (rt->rt6i_src.plen && saddr) {
650 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
651 rt->rt6i_src.plen = 128;
652 }
653#endif
654
14deae41
DM		 655 retry:
656 neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
657 if (IS_ERR(neigh)) {
658 struct net *net = dev_net(rt->rt6i_dev);
659 int saved_rt_min_interval =
660 net->ipv6.sysctl.ip6_rt_gc_min_interval;
661 int saved_rt_elasticity =
662 net->ipv6.sysctl.ip6_rt_gc_elasticity;
663
664 if (attempts-- > 0) {
665 net->ipv6.sysctl.ip6_rt_gc_elasticity = 1;
666 net->ipv6.sysctl.ip6_rt_gc_min_interval = 0;
667
86393e52 668 ip6_dst_gc(&net->ipv6.ip6_dst_ops);
14deae41
DM		 669
670 net->ipv6.sysctl.ip6_rt_gc_elasticity =
671 saved_rt_elasticity;
672 net->ipv6.sysctl.ip6_rt_gc_min_interval =
673 saved_rt_min_interval;
674 goto retry;
675 }
676
677 if (net_ratelimit())
678 printk(KERN_WARNING
679 "Neighbour table overflow.\n");
680 dst_free(&rt->u.dst);
681 return NULL;
682 }
683 rt->rt6i_nexthop = neigh;
1da177e4 684
95a9a5ba 685 }
1da177e4 686
95a9a5ba
YH		 687 return rt;
688}
1da177e4 689
299d9939
YH		 690static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
691{
692 struct rt6_info *rt = ip6_rt_copy(ort);
693 if (rt) {
694 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
695 rt->rt6i_dst.plen = 128;
696 rt->rt6i_flags |= RTF_CACHE;
299d9939
YH		 697 rt->u.dst.flags |= DST_HOST;
698 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
699 }
700 return rt;
701}
702
8ed67789
DL		 703static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
704 struct flowi *fl, int flags)
1da177e4
LT		 705{
706 struct fib6_node *fn;
519fbd87 707 struct rt6_info *rt, *nrt;
c71099ac 708 int strict = 0;
1da177e4 709 int attempts = 3;
519fbd87 710 int err;
53b7997f 711 int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
1da177e4 712
77d16f45 713 strict |= flags & RT6_LOOKUP_F_IFACE;
1da177e4
LT		 714
715relookup:
c71099ac 716 read_lock_bh(&table->tb6_lock);
1da177e4 717
8238dd06 718restart_2:
c71099ac 719 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1da177e4
LT		 720
721restart:
4acad72d 722 rt = rt6_select(fn, oif, strict | reachable);
8ed67789
DL		 723
724 BACKTRACK(net, &fl->fl6_src);
725 if (rt == net->ipv6.ip6_null_entry ||
8238dd06 726 rt->rt6i_flags & RTF_CACHE)
1ddef044 727 goto out;
1da177e4 728
fb9de91e 729 dst_hold(&rt->u.dst);
c71099ac 730 read_unlock_bh(&table->tb6_lock);
fb9de91e 731
519fbd87 732 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
c71099ac 733 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
519fbd87
YH		 734 else {
735#if CLONE_OFFLINK_ROUTE
c71099ac 736 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
519fbd87
YH		 737#else
738 goto out2;
739#endif
740 }
e40cf353 741
519fbd87 742 dst_release(&rt->u.dst);
8ed67789 743 rt = nrt ? : net->ipv6.ip6_null_entry;
1da177e4 744
519fbd87
YH		 745 dst_hold(&rt->u.dst);
746 if (nrt) {
40e22e8f 747 err = ip6_ins_rt(nrt);
519fbd87 748 if (!err)
1da177e4 749 goto out2;
1da177e4 750 }
1da177e4 751
519fbd87
YH		 752 if (--attempts <= 0)
753 goto out2;
754
755 /*
c71099ac 756 * Race condition! In the gap, when table->tb6_lock was
519fbd87
YH		 757 * released someone could insert this route. Relookup.
758 */
759 dst_release(&rt->u.dst);
760 goto relookup;
761
762out:
8238dd06
YH		 763 if (reachable) {
764 reachable = 0;
765 goto restart_2;
766 }
519fbd87 767 dst_hold(&rt->u.dst);
c71099ac 768 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 769out2:
770 rt->u.dst.lastuse = jiffies;
771 rt->u.dst.__use++;
c71099ac
TG		 772
773 return rt;
1da177e4
LT		 774}
775
8ed67789 776static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
4acad72d
PE		 777 struct flowi *fl, int flags)
778{
8ed67789 779 return ip6_pol_route(net, table, fl->iif, fl, flags);
4acad72d
PE		 780}
781
c71099ac
TG		 782void ip6_route_input(struct sk_buff *skb)
783{
0660e03f 784 struct ipv6hdr *iph = ipv6_hdr(skb);
c346dca1 785 struct net *net = dev_net(skb->dev);
adaa70bb 786 int flags = RT6_LOOKUP_F_HAS_SADDR;
c71099ac
TG		 787 struct flowi fl = {
788 .iif = skb->dev->ifindex,
789 .nl_u = {
790 .ip6_u = {
791 .daddr = iph->daddr,
792 .saddr = iph->saddr,
90bcaf7b 793 .flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
c71099ac
TG		 794 },
795 },
1ab1457c 796 .mark = skb->mark,
c71099ac
TG		 797 .proto = iph->nexthdr,
798 };
adaa70bb 799
1d6e55f1 800 if (rt6_need_strict(&iph->daddr) && skb->dev->type != ARPHRD_PIMREG)
adaa70bb 801 flags |= RT6_LOOKUP_F_IFACE;
c71099ac 802
adf30907 803 skb_dst_set(skb, fib6_rule_lookup(net, &fl, flags, ip6_pol_route_input));
c71099ac
TG		 804}
805
8ed67789 806static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
c71099ac 807 struct flowi *fl, int flags)
1da177e4 808{
8ed67789 809 return ip6_pol_route(net, table, fl->oif, fl, flags);
c71099ac
TG		 810}
811
4591db4f
DL		 812struct dst_entry * ip6_route_output(struct net *net, struct sock *sk,
813 struct flowi *fl)
c71099ac
TG		 814{
815 int flags = 0;
816
817 if (rt6_need_strict(&fl->fl6_dst))
77d16f45 818 flags |= RT6_LOOKUP_F_IFACE;
c71099ac 819
adaa70bb
TG		 820 if (!ipv6_addr_any(&fl->fl6_src))
821 flags |= RT6_LOOKUP_F_HAS_SADDR;
0c9a2ac1
YH		 822 else if (sk)
823 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
adaa70bb 824
4591db4f 825 return fib6_rule_lookup(net, fl, flags, ip6_pol_route_output);
1da177e4
LT		 826}
827
7159039a 828EXPORT_SYMBOL(ip6_route_output);
1da177e4 829
14e50e57
DM		 830int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl)
831{
832 struct rt6_info *ort = (struct rt6_info *) *dstp;
833 struct rt6_info *rt = (struct rt6_info *)
834 dst_alloc(&ip6_dst_blackhole_ops);
835 struct dst_entry *new = NULL;
836
837 if (rt) {
838 new = &rt->u.dst;
839
840 atomic_set(&new->__refcnt, 1);
841 new->__use = 1;
352e512c
HX		 842 new->input = dst_discard;
843 new->output = dst_discard;
14e50e57
DM		 844
845 memcpy(new->metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
846 new->dev = ort->u.dst.dev;
847 if (new->dev)
848 dev_hold(new->dev);
849 rt->rt6i_idev = ort->rt6i_idev;
850 if (rt->rt6i_idev)
851 in6_dev_hold(rt->rt6i_idev);
852 rt->rt6i_expires = 0;
853
854 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
855 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
856 rt->rt6i_metric = 0;
857
858 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
859#ifdef CONFIG_IPV6_SUBTREES
860 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
861#endif
862
863 dst_free(new);
864 }
865
866 dst_release(*dstp);
867 *dstp = new;
868 return (new ? 0 : -ENOMEM);
869}
870EXPORT_SYMBOL_GPL(ip6_dst_blackhole);
871
1da177e4
LT		 872/*
873 * Destination cache support functions
874 */
875
876static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
877{
878 struct rt6_info *rt;
879
880 rt = (struct rt6_info *) dst;
881
10414444 882 if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
1da177e4
LT		 883 return dst;
884
885 return NULL;
886}
887
888static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
889{
890 struct rt6_info *rt = (struct rt6_info *) dst;
891
892 if (rt) {
54c1a859
YH		 893 if (rt->rt6i_flags & RTF_CACHE) {
894 if (rt6_check_expired(rt)) {
895 ip6_del_rt(rt);
896 dst = NULL;
897 }
898 } else {
1da177e4 899 dst_release(dst);
54c1a859
YH		 900 dst = NULL;
901 }
1da177e4 902 }
54c1a859 903 return dst;
1da177e4
LT		 904}
905
906static void ip6_link_failure(struct sk_buff *skb)
907{
908 struct rt6_info *rt;
909
3ffe533c 910 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1da177e4 911
adf30907 912 rt = (struct rt6_info *) skb_dst(skb);
1da177e4
LT		 913 if (rt) {
914 if (rt->rt6i_flags&RTF_CACHE) {
915 dst_set_expires(&rt->u.dst, 0);
916 rt->rt6i_flags |= RTF_EXPIRES;
917 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
918 rt->rt6i_node->fn_sernum = -1;
919 }
920}
921
922static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
923{
924 struct rt6_info *rt6 = (struct rt6_info*)dst;
925
926 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
927 rt6->rt6i_flags |= RTF_MODIFIED;
928 if (mtu < IPV6_MIN_MTU) {
929 mtu = IPV6_MIN_MTU;
930 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
931 }
932 dst->metrics[RTAX_MTU-1] = mtu;
8d71740c 933 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
1da177e4
LT		 934 }
935}
936
1da177e4
LT		 937static int ipv6_get_mtu(struct net_device *dev);
938
5578689a 939static inline unsigned int ipv6_advmss(struct net *net, unsigned int mtu)
1da177e4
LT		 940{
941 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
942
5578689a
DL		 943 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
944 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1da177e4
LT		 945
946 /*
1ab1457c
YH		 947 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
948 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
949 * IPV6_MAXPLEN is also valid and means: "any MSS,
1da177e4
LT		 950 * rely only on pmtu discovery"
951 */
952 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
953 mtu = IPV6_MAXPLEN;
954 return mtu;
955}
956
3b00944c
YH		 957static struct dst_entry *icmp6_dst_gc_list;
958static DEFINE_SPINLOCK(icmp6_dst_lock);
5d0bbeeb 959
3b00944c 960struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1da177e4 961 struct neighbour *neigh,
9acd9f3a 962 const struct in6_addr *addr)
1da177e4
LT		 963{
964 struct rt6_info *rt;
965 struct inet6_dev *idev = in6_dev_get(dev);
c346dca1 966 struct net *net = dev_net(dev);
1da177e4
LT		 967
968 if (unlikely(idev == NULL))
969 return NULL;
970
86393e52 971 rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
1da177e4
LT		 972 if (unlikely(rt == NULL)) {
973 in6_dev_put(idev);
974 goto out;
975 }
976
977 dev_hold(dev);
978 if (neigh)
979 neigh_hold(neigh);
14deae41 980 else {
1da177e4 981 neigh = ndisc_get_neigh(dev, addr);
14deae41
DM		 982 if (IS_ERR(neigh))
983 neigh = NULL;
984 }
1da177e4
LT		 985
986 rt->rt6i_dev = dev;
987 rt->rt6i_idev = idev;
988 rt->rt6i_nexthop = neigh;
989 atomic_set(&rt->u.dst.__refcnt, 1);
990 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
991 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
5578689a 992 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, dst_mtu(&rt->u.dst));
3b00944c 993 rt->u.dst.output = ip6_output;
1da177e4
LT		 994
995#if 0 /* there's no chance to use these for ndisc */
1ab1457c
YH		 996 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
997 ? DST_HOST
1da177e4
LT		 998 : 0;
999 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1000 rt->rt6i_dst.plen = 128;
1001#endif
1002
3b00944c
YH		 1003 spin_lock_bh(&icmp6_dst_lock);
1004 rt->u.dst.next = icmp6_dst_gc_list;
1005 icmp6_dst_gc_list = &rt->u.dst;
1006 spin_unlock_bh(&icmp6_dst_lock);
1da177e4 1007
5578689a 1008 fib6_force_start_gc(net);
1da177e4
LT		 1009
1010out:
40aa7b90 1011 return &rt->u.dst;
1da177e4
LT		 1012}
1013
3d0f24a7 1014int icmp6_dst_gc(void)
1da177e4
LT		 1015{
1016 struct dst_entry *dst, *next, **pprev;
3d0f24a7 1017 int more = 0;
1da177e4
LT		 1018
1019 next = NULL;
5d0bbeeb 1020
3b00944c
YH		 1021 spin_lock_bh(&icmp6_dst_lock);
1022 pprev = &icmp6_dst_gc_list;
5d0bbeeb 1023
1da177e4
LT		 1024 while ((dst = *pprev) != NULL) {
1025 if (!atomic_read(&dst->__refcnt)) {
1026 *pprev = dst->next;
1027 dst_free(dst);
1da177e4
LT		 1028 } else {
1029 pprev = &dst->next;
3d0f24a7 1030 ++more;
1da177e4
LT		 1031 }
1032 }
1033
3b00944c 1034 spin_unlock_bh(&icmp6_dst_lock);
5d0bbeeb 1035
3d0f24a7 1036 return more;
1da177e4
LT		 1037}
1038
1e493d19
DM		 1039static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1040 void *arg)
1041{
1042 struct dst_entry *dst, **pprev;
1043
1044 spin_lock_bh(&icmp6_dst_lock);
1045 pprev = &icmp6_dst_gc_list;
1046 while ((dst = *pprev) != NULL) {
1047 struct rt6_info *rt = (struct rt6_info *) dst;
1048 if (func(rt, arg)) {
1049 *pprev = dst->next;
1050 dst_free(dst);
1051 } else {
1052 pprev = &dst->next;
1053 }
1054 }
1055 spin_unlock_bh(&icmp6_dst_lock);
1056}
1057
569d3645 1058static int ip6_dst_gc(struct dst_ops *ops)
1da177e4 1059{
1da177e4 1060 unsigned long now = jiffies;
86393e52 1061 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
7019b78e
DL		 1062 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1063 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1064 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1065 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1066 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1067
1068 if (time_after(rt_last_gc + rt_min_interval, now) &&
1069 atomic_read(&ops->entries) <= rt_max_size)
1da177e4
LT		 1070 goto out;
1071
6891a346
BT		 1072 net->ipv6.ip6_rt_gc_expire++;
1073 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net);
1074 net->ipv6.ip6_rt_last_gc = now;
7019b78e
DL		 1075 if (atomic_read(&ops->entries) < ops->gc_thresh)
1076 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1da177e4 1077out:
7019b78e
DL		 1078 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1079 return (atomic_read(&ops->entries) > rt_max_size);
1da177e4
LT		 1080}
1081
1082/* Clean host part of a prefix. Not necessary in radix tree,
1083 but results in cleaner routing tables.
1084
1085 Remove it only when all the things will work!
1086 */
1087
1088static int ipv6_get_mtu(struct net_device *dev)
1089{
1090 int mtu = IPV6_MIN_MTU;
1091 struct inet6_dev *idev;
1092
1093 idev = in6_dev_get(dev);
1094 if (idev) {
1095 mtu = idev->cnf.mtu6;
1096 in6_dev_put(idev);
1097 }
1098 return mtu;
1099}
1100
6b75d090 1101int ip6_dst_hoplimit(struct dst_entry *dst)
1da177e4 1102{
6b75d090
YH		 1103 int hoplimit = dst_metric(dst, RTAX_HOPLIMIT);
1104 if (hoplimit < 0) {
1105 struct net_device *dev = dst->dev;
1106 struct inet6_dev *idev = in6_dev_get(dev);
1107 if (idev) {
1108 hoplimit = idev->cnf.hop_limit;
1109 in6_dev_put(idev);
1110 } else
53b7997f 1111 hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;
1da177e4
LT		 1112 }
1113 return hoplimit;
1114}
1115
1116/*
1117 *
1118 */
1119
86872cb5 1120int ip6_route_add(struct fib6_config *cfg)
1da177e4
LT		 1121{
1122 int err;
5578689a 1123 struct net *net = cfg->fc_nlinfo.nl_net;
1da177e4
LT		 1124 struct rt6_info *rt = NULL;
1125 struct net_device *dev = NULL;
1126 struct inet6_dev *idev = NULL;
c71099ac 1127 struct fib6_table *table;
1da177e4
LT		 1128 int addr_type;
1129
86872cb5 1130 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1da177e4
LT		 1131 return -EINVAL;
1132#ifndef CONFIG_IPV6_SUBTREES
86872cb5 1133 if (cfg->fc_src_len)
1da177e4
LT		 1134 return -EINVAL;
1135#endif
86872cb5 1136 if (cfg->fc_ifindex) {
1da177e4 1137 err = -ENODEV;
5578689a 1138 dev = dev_get_by_index(net, cfg->fc_ifindex);
1da177e4
LT		 1139 if (!dev)
1140 goto out;
1141 idev = in6_dev_get(dev);
1142 if (!idev)
1143 goto out;
1144 }
1145
86872cb5
TG		 1146 if (cfg->fc_metric == 0)
1147 cfg->fc_metric = IP6_RT_PRIO_USER;
1da177e4 1148
5578689a 1149 table = fib6_new_table(net, cfg->fc_table);
c71099ac
TG		 1150 if (table == NULL) {
1151 err = -ENOBUFS;
1152 goto out;
1153 }
1154
86393e52 1155 rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
1da177e4
LT		 1156
1157 if (rt == NULL) {
1158 err = -ENOMEM;
1159 goto out;
1160 }
1161
1162 rt->u.dst.obsolete = -1;
6f704992
YH		 1163 rt->rt6i_expires = (cfg->fc_flags & RTF_EXPIRES) ?
1164 jiffies + clock_t_to_jiffies(cfg->fc_expires) :
1165 0;
1da177e4 1166
86872cb5
TG		 1167 if (cfg->fc_protocol == RTPROT_UNSPEC)
1168 cfg->fc_protocol = RTPROT_BOOT;
1169 rt->rt6i_protocol = cfg->fc_protocol;
1170
1171 addr_type = ipv6_addr_type(&cfg->fc_dst);
1da177e4
LT		 1172
1173 if (addr_type & IPV6_ADDR_MULTICAST)
1174 rt->u.dst.input = ip6_mc_input;
1175 else
1176 rt->u.dst.input = ip6_forward;
1177
1178 rt->u.dst.output = ip6_output;
1179
86872cb5
TG		 1180 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1181 rt->rt6i_dst.plen = cfg->fc_dst_len;
1da177e4
LT		 1182 if (rt->rt6i_dst.plen == 128)
1183 rt->u.dst.flags = DST_HOST;
1184
1185#ifdef CONFIG_IPV6_SUBTREES
86872cb5
TG		 1186 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1187 rt->rt6i_src.plen = cfg->fc_src_len;
1da177e4
LT		 1188#endif
1189
86872cb5 1190 rt->rt6i_metric = cfg->fc_metric;
1da177e4
LT		 1191
1192 /* We cannot add true routes via loopback here,
1193 they would result in kernel looping; promote them to reject routes
1194 */
86872cb5 1195 if ((cfg->fc_flags & RTF_REJECT) ||
1da177e4
LT		 1196 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
1197 /* hold loopback dev/idev if we haven't done so. */
5578689a 1198 if (dev != net->loopback_dev) {
1da177e4
LT		 1199 if (dev) {
1200 dev_put(dev);
1201 in6_dev_put(idev);
1202 }
5578689a 1203 dev = net->loopback_dev;
1da177e4
LT		 1204 dev_hold(dev);
1205 idev = in6_dev_get(dev);
1206 if (!idev) {
1207 err = -ENODEV;
1208 goto out;
1209 }
1210 }
1211 rt->u.dst.output = ip6_pkt_discard_out;
1212 rt->u.dst.input = ip6_pkt_discard;
1213 rt->u.dst.error = -ENETUNREACH;
1214 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1215 goto install_route;
1216 }
1217
86872cb5 1218 if (cfg->fc_flags & RTF_GATEWAY) {
1da177e4
LT		 1219 struct in6_addr *gw_addr;
1220 int gwa_type;
1221
86872cb5
TG		 1222 gw_addr = &cfg->fc_gateway;
1223 ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
1da177e4
LT		 1224 gwa_type = ipv6_addr_type(gw_addr);
1225
1226 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1227 struct rt6_info *grt;
1228
1229 /* IPv6 strictly inhibits using not link-local
1230 addresses as nexthop address.
1231 Otherwise, router will not able to send redirects.
1232 It is very good, but in some (rare!) circumstances
1233 (SIT, PtP, NBMA NOARP links) it is handy to allow
1234 some exceptions. --ANK
1235 */
1236 err = -EINVAL;
1237 if (!(gwa_type&IPV6_ADDR_UNICAST))
1238 goto out;
1239
5578689a 1240 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1da177e4
LT		 1241
1242 err = -EHOSTUNREACH;
1243 if (grt == NULL)
1244 goto out;
1245 if (dev) {
1246 if (dev != grt->rt6i_dev) {
1247 dst_release(&grt->u.dst);
1248 goto out;
1249 }
1250 } else {
1251 dev = grt->rt6i_dev;
1252 idev = grt->rt6i_idev;
1253 dev_hold(dev);
1254 in6_dev_hold(grt->rt6i_idev);
1255 }
1256 if (!(grt->rt6i_flags&RTF_GATEWAY))
1257 err = 0;
1258 dst_release(&grt->u.dst);
1259
1260 if (err)
1261 goto out;
1262 }
1263 err = -EINVAL;
1264 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
1265 goto out;
1266 }
1267
1268 err = -ENODEV;
1269 if (dev == NULL)
1270 goto out;
1271
86872cb5 1272 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
1da177e4
LT		 1273 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
1274 if (IS_ERR(rt->rt6i_nexthop)) {
1275 err = PTR_ERR(rt->rt6i_nexthop);
1276 rt->rt6i_nexthop = NULL;
1277 goto out;
1278 }
1279 }
1280
86872cb5 1281 rt->rt6i_flags = cfg->fc_flags;
1da177e4
LT		 1282
1283install_route:
86872cb5
TG		 1284 if (cfg->fc_mx) {
1285 struct nlattr *nla;
1286 int remaining;
1287
1288 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
8f4c1f9b 1289 int type = nla_type(nla);
86872cb5
TG		 1290
1291 if (type) {
1292 if (type > RTAX_MAX) {
1da177e4
LT		 1293 err = -EINVAL;
1294 goto out;
1295 }
86872cb5
TG		 1296
1297 rt->u.dst.metrics[type - 1] = nla_get_u32(nla);
1da177e4 1298 }
1da177e4
LT		 1299 }
1300 }
1301
5ffc02a1 1302 if (dst_metric(&rt->u.dst, RTAX_HOPLIMIT) == 0)
1da177e4 1303 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1ca615fb 1304 if (!dst_mtu(&rt->u.dst))
1da177e4 1305 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
5ffc02a1 1306 if (!dst_metric(&rt->u.dst, RTAX_ADVMSS))
5578689a 1307 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, dst_mtu(&rt->u.dst));
1da177e4
LT		 1308 rt->u.dst.dev = dev;
1309 rt->rt6i_idev = idev;
c71099ac 1310 rt->rt6i_table = table;
63152fc0 1311
c346dca1 1312 cfg->fc_nlinfo.nl_net = dev_net(dev);
63152fc0 1313
86872cb5 1314 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1da177e4
LT		 1315
1316out:
1317 if (dev)
1318 dev_put(dev);
1319 if (idev)
1320 in6_dev_put(idev);
1321 if (rt)
40aa7b90 1322 dst_free(&rt->u.dst);
1da177e4
LT		 1323 return err;
1324}
1325
86872cb5 1326static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 1327{
1328 int err;
c71099ac 1329 struct fib6_table *table;
c346dca1 1330 struct net *net = dev_net(rt->rt6i_dev);
1da177e4 1331
8ed67789 1332 if (rt == net->ipv6.ip6_null_entry)
6c813a72
PM		 1333 return -ENOENT;
1334
c71099ac
TG		 1335 table = rt->rt6i_table;
1336 write_lock_bh(&table->tb6_lock);
1da177e4 1337
86872cb5 1338 err = fib6_del(rt, info);
1da177e4
LT		 1339 dst_release(&rt->u.dst);
1340
c71099ac 1341 write_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1342
1343 return err;
1344}
1345
e0a1ad73
TG		 1346int ip6_del_rt(struct rt6_info *rt)
1347{
4d1169c1 1348 struct nl_info info = {
c346dca1 1349 .nl_net = dev_net(rt->rt6i_dev),
4d1169c1 1350 };
528c4ceb 1351 return __ip6_del_rt(rt, &info);
e0a1ad73
TG		 1352}
1353
86872cb5 1354static int ip6_route_del(struct fib6_config *cfg)
1da177e4 1355{
c71099ac 1356 struct fib6_table *table;
1da177e4
LT		 1357 struct fib6_node *fn;
1358 struct rt6_info *rt;
1359 int err = -ESRCH;
1360
5578689a 1361 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
c71099ac
TG		 1362 if (table == NULL)
1363 return err;
1364
1365 read_lock_bh(&table->tb6_lock);
1da177e4 1366
c71099ac 1367 fn = fib6_locate(&table->tb6_root,
86872cb5
TG		 1368 &cfg->fc_dst, cfg->fc_dst_len,
1369 &cfg->fc_src, cfg->fc_src_len);
1ab1457c 1370
1da177e4 1371 if (fn) {
7cc48263 1372 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
86872cb5 1373 if (cfg->fc_ifindex &&
1da177e4 1374 (rt->rt6i_dev == NULL ||
86872cb5 1375 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
1da177e4 1376 continue;
86872cb5
TG		 1377 if (cfg->fc_flags & RTF_GATEWAY &&
1378 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1da177e4 1379 continue;
86872cb5 1380 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1da177e4
LT		 1381 continue;
1382 dst_hold(&rt->u.dst);
c71099ac 1383 read_unlock_bh(&table->tb6_lock);
1da177e4 1384
86872cb5 1385 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1da177e4
LT		 1386 }
1387 }
c71099ac 1388 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1389
1390 return err;
1391}
1392
1393/*
1394 * Handle redirects
1395 */
a6279458
YH		 1396struct ip6rd_flowi {
1397 struct flowi fl;
1398 struct in6_addr gateway;
1399};
1400
8ed67789
DL		 1401static struct rt6_info *__ip6_route_redirect(struct net *net,
1402 struct fib6_table *table,
a6279458
YH		 1403 struct flowi *fl,
1404 int flags)
1da177e4 1405{
a6279458
YH		 1406 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1407 struct rt6_info *rt;
e843b9e1 1408 struct fib6_node *fn;
c71099ac 1409
1da177e4 1410 /*
e843b9e1
YH		 1411 * Get the "current" route for this destination and
1412 * check if the redirect has come from approriate router.
1413 *
1414 * RFC 2461 specifies that redirects should only be
1415 * accepted if they come from the nexthop to the target.
1416 * Due to the way the routes are chosen, this notion
1417 * is a bit fuzzy and one might need to check all possible
1418 * routes.
1da177e4 1419 */
1da177e4 1420
c71099ac 1421 read_lock_bh(&table->tb6_lock);
a6279458 1422 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
e843b9e1 1423restart:
7cc48263 1424 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
e843b9e1
YH		 1425 /*
1426 * Current route is on-link; redirect is always invalid.
1427 *
1428 * Seems, previous statement is not true. It could
1429 * be node, which looks for us as on-link (f.e. proxy ndisc)
1430 * But then router serving it might decide, that we should
1431 * know truth 8)8) --ANK (980726).
1432 */
1433 if (rt6_check_expired(rt))
1434 continue;
1435 if (!(rt->rt6i_flags & RTF_GATEWAY))
1436 continue;
a6279458 1437 if (fl->oif != rt->rt6i_dev->ifindex)
e843b9e1 1438 continue;
a6279458 1439 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
e843b9e1
YH		 1440 continue;
1441 break;
1442 }
a6279458 1443
cb15d9c2 1444 if (!rt)
8ed67789
DL		 1445 rt = net->ipv6.ip6_null_entry;
1446 BACKTRACK(net, &fl->fl6_src);
cb15d9c2 1447out:
a6279458
YH		 1448 dst_hold(&rt->u.dst);
1449
c71099ac 1450 read_unlock_bh(&table->tb6_lock);
e843b9e1 1451
a6279458
YH		 1452 return rt;
1453};
1454
1455static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1456 struct in6_addr *src,
1457 struct in6_addr *gateway,
1458 struct net_device *dev)
1459{
adaa70bb 1460 int flags = RT6_LOOKUP_F_HAS_SADDR;
c346dca1 1461 struct net *net = dev_net(dev);
a6279458
YH		 1462 struct ip6rd_flowi rdfl = {
1463 .fl = {
1464 .oif = dev->ifindex,
1465 .nl_u = {
1466 .ip6_u = {
1467 .daddr = *dest,
1468 .saddr = *src,
1469 },
1470 },
1471 },
a6279458 1472 };
adaa70bb 1473
86c36ce4
BH		 1474 ipv6_addr_copy(&rdfl.gateway, gateway);
1475
adaa70bb
TG		 1476 if (rt6_need_strict(dest))
1477 flags |= RT6_LOOKUP_F_IFACE;
a6279458 1478
5578689a 1479 return (struct rt6_info *)fib6_rule_lookup(net, (struct flowi *)&rdfl,
58f09b78 1480 flags, __ip6_route_redirect);
a6279458
YH		 1481}
1482
1483void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1484 struct in6_addr *saddr,
1485 struct neighbour *neigh, u8 *lladdr, int on_link)
1486{
1487 struct rt6_info *rt, *nrt = NULL;
1488 struct netevent_redirect netevent;
c346dca1 1489 struct net *net = dev_net(neigh->dev);
a6279458
YH		 1490
1491 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1492
8ed67789 1493 if (rt == net->ipv6.ip6_null_entry) {
1da177e4
LT		 1494 if (net_ratelimit())
1495 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1496 "for redirect target\n");
a6279458 1497 goto out;
1da177e4
LT		 1498 }
1499
1da177e4
LT		 1500 /*
1501 * We have finally decided to accept it.
1502 */
1503
1ab1457c 1504 neigh_update(neigh, lladdr, NUD_STALE,
1da177e4
LT		 1505 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1506 NEIGH_UPDATE_F_OVERRIDE|
1507 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1508 NEIGH_UPDATE_F_ISROUTER))
1509 );
1510
1511 /*
1512 * Redirect received -> path was valid.
1513 * Look, redirects are sent only in response to data packets,
1514 * so that this nexthop apparently is reachable. --ANK
1515 */
1516 dst_confirm(&rt->u.dst);
1517
1518 /* Duplicate redirect: silently ignore. */
1519 if (neigh == rt->u.dst.neighbour)
1520 goto out;
1521
1522 nrt = ip6_rt_copy(rt);
1523 if (nrt == NULL)
1524 goto out;
1525
1526 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1527 if (on_link)
1528 nrt->rt6i_flags &= ~RTF_GATEWAY;
1529
1530 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1531 nrt->rt6i_dst.plen = 128;
1532 nrt->u.dst.flags |= DST_HOST;
1533
1534 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1535 nrt->rt6i_nexthop = neigh_clone(neigh);
1536 /* Reset pmtu, it may be better */
1537 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
c346dca1 1538 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dev_net(neigh->dev),
5578689a 1539 dst_mtu(&nrt->u.dst));
1da177e4 1540
40e22e8f 1541 if (ip6_ins_rt(nrt))
1da177e4
LT		 1542 goto out;
1543
8d71740c
TT		 1544 netevent.old = &rt->u.dst;
1545 netevent.new = &nrt->u.dst;
1546 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1547
1da177e4 1548 if (rt->rt6i_flags&RTF_CACHE) {
e0a1ad73 1549 ip6_del_rt(rt);
1da177e4
LT		 1550 return;
1551 }
1552
1553out:
1ab1457c 1554 dst_release(&rt->u.dst);
1da177e4
LT		 1555 return;
1556}
1557
1558/*
1559 * Handle ICMP "packet too big" messages
1560 * i.e. Path MTU discovery
1561 */
1562
1563void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1564 struct net_device *dev, u32 pmtu)
1565{
1566 struct rt6_info *rt, *nrt;
c346dca1 1567 struct net *net = dev_net(dev);
1da177e4
LT		 1568 int allfrag = 0;
1569
5578689a 1570 rt = rt6_lookup(net, daddr, saddr, dev->ifindex, 0);
1da177e4
LT		 1571 if (rt == NULL)
1572 return;
1573
1574 if (pmtu >= dst_mtu(&rt->u.dst))
1575 goto out;
1576
1577 if (pmtu < IPV6_MIN_MTU) {
1578 /*
1ab1457c 1579 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1da177e4
LT		 1580 * MTU (1280) and a fragment header should always be included
1581 * after a node receiving Too Big message reporting PMTU is
1582 * less than the IPv6 Minimum Link MTU.
1583 */
1584 pmtu = IPV6_MIN_MTU;
1585 allfrag = 1;
1586 }
1587
1588 /* New mtu received -> path was valid.
1589 They are sent only in response to data packets,
1590 so that this nexthop apparently is reachable. --ANK
1591 */
1592 dst_confirm(&rt->u.dst);
1593
1594 /* Host route. If it is static, it would be better
1595 not to override it, but add new one, so that
1596 when cache entry will expire old pmtu
1597 would return automatically.
1598 */
1599 if (rt->rt6i_flags & RTF_CACHE) {
1600 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1601 if (allfrag)
1602 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
5578689a 1603 dst_set_expires(&rt->u.dst, net->ipv6.sysctl.ip6_rt_mtu_expires);
1da177e4
LT		 1604 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1605 goto out;
1606 }
1607
1608 /* Network route.
1609 Two cases are possible:
1610 1. It is connected route. Action: COW
1611 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1612 */
d5315b50 1613 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
a1e78363 1614 nrt = rt6_alloc_cow(rt, daddr, saddr);
d5315b50
YH		 1615 else
1616 nrt = rt6_alloc_clone(rt, daddr);
a1e78363 1617
d5315b50 1618 if (nrt) {
a1e78363
YH		 1619 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1620 if (allfrag)
1621 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1622
1623 /* According to RFC 1981, detecting PMTU increase shouldn't be
1624 * happened within 5 mins, the recommended timer is 10 mins.
1625 * Here this route expiration time is set to ip6_rt_mtu_expires
1626 * which is 10 mins. After 10 mins the decreased pmtu is expired
1627 * and detecting PMTU increase will be automatically happened.
1628 */
5578689a 1629 dst_set_expires(&nrt->u.dst, net->ipv6.sysctl.ip6_rt_mtu_expires);
a1e78363
YH		 1630 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1631
40e22e8f 1632 ip6_ins_rt(nrt);
1da177e4 1633 }
1da177e4
LT		 1634out:
1635 dst_release(&rt->u.dst);
1636}
1637
1638/*
1639 * Misc support functions
1640 */
1641
1642static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1643{
c346dca1 1644 struct net *net = dev_net(ort->rt6i_dev);
86393e52 1645 struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
1da177e4
LT		 1646
1647 if (rt) {
1648 rt->u.dst.input = ort->u.dst.input;
1649 rt->u.dst.output = ort->u.dst.output;
1650
1651 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
22e1e4d8 1652 rt->u.dst.error = ort->u.dst.error;
1da177e4
LT		 1653 rt->u.dst.dev = ort->u.dst.dev;
1654 if (rt->u.dst.dev)
1655 dev_hold(rt->u.dst.dev);
1656 rt->rt6i_idev = ort->rt6i_idev;
1657 if (rt->rt6i_idev)
1658 in6_dev_hold(rt->rt6i_idev);
1659 rt->u.dst.lastuse = jiffies;
1660 rt->rt6i_expires = 0;
1661
1662 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1663 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1664 rt->rt6i_metric = 0;
1665
1666 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1667#ifdef CONFIG_IPV6_SUBTREES
1668 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1669#endif
c71099ac 1670 rt->rt6i_table = ort->rt6i_table;
1da177e4
LT		 1671 }
1672 return rt;
1673}
1674
70ceb4f5 1675#ifdef CONFIG_IPV6_ROUTE_INFO
efa2cea0
DL		 1676static struct rt6_info *rt6_get_route_info(struct net *net,
1677 struct in6_addr *prefix, int prefixlen,
70ceb4f5
YH		 1678 struct in6_addr *gwaddr, int ifindex)
1679{
1680 struct fib6_node *fn;
1681 struct rt6_info *rt = NULL;
c71099ac
TG		 1682 struct fib6_table *table;
1683
efa2cea0 1684 table = fib6_get_table(net, RT6_TABLE_INFO);
c71099ac
TG		 1685 if (table == NULL)
1686 return NULL;
70ceb4f5 1687
c71099ac
TG		 1688 write_lock_bh(&table->tb6_lock);
1689 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
70ceb4f5
YH		 1690 if (!fn)
1691 goto out;
1692
7cc48263 1693 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
70ceb4f5
YH		 1694 if (rt->rt6i_dev->ifindex != ifindex)
1695 continue;
1696 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1697 continue;
1698 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1699 continue;
1700 dst_hold(&rt->u.dst);
1701 break;
1702 }
1703out:
c71099ac 1704 write_unlock_bh(&table->tb6_lock);
70ceb4f5
YH		 1705 return rt;
1706}
1707
efa2cea0
DL		 1708static struct rt6_info *rt6_add_route_info(struct net *net,
1709 struct in6_addr *prefix, int prefixlen,
70ceb4f5
YH		 1710 struct in6_addr *gwaddr, int ifindex,
1711 unsigned pref)
1712{
86872cb5
TG		 1713 struct fib6_config cfg = {
1714 .fc_table = RT6_TABLE_INFO,
238fc7ea 1715 .fc_metric = IP6_RT_PRIO_USER,
86872cb5
TG		 1716 .fc_ifindex = ifindex,
1717 .fc_dst_len = prefixlen,
1718 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1719 RTF_UP | RTF_PREF(pref),
efa2cea0
DL		 1720 .fc_nlinfo.pid = 0,
1721 .fc_nlinfo.nlh = NULL,
1722 .fc_nlinfo.nl_net = net,
86872cb5
TG		 1723 };
1724
1725 ipv6_addr_copy(&cfg.fc_dst, prefix);
1726 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
70ceb4f5 1727
e317da96
YH		 1728 /* We should treat it as a default route if prefix length is 0. */
1729 if (!prefixlen)
86872cb5 1730 cfg.fc_flags |= RTF_DEFAULT;
70ceb4f5 1731
86872cb5 1732 ip6_route_add(&cfg);
70ceb4f5 1733
efa2cea0 1734 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
70ceb4f5
YH		 1735}
1736#endif
1737
1da177e4 1738struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1ab1457c 1739{
1da177e4 1740 struct rt6_info *rt;
c71099ac 1741 struct fib6_table *table;
1da177e4 1742
c346dca1 1743 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
c71099ac
TG		 1744 if (table == NULL)
1745 return NULL;
1da177e4 1746
c71099ac 1747 write_lock_bh(&table->tb6_lock);
7cc48263 1748 for (rt = table->tb6_root.leaf; rt; rt=rt->u.dst.rt6_next) {
1da177e4 1749 if (dev == rt->rt6i_dev &&
045927ff 1750 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1da177e4
LT		 1751 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1752 break;
1753 }
1754 if (rt)
1755 dst_hold(&rt->u.dst);
c71099ac 1756 write_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1757 return rt;
1758}
1759
1760struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
ebacaaa0
YH		 1761 struct net_device *dev,
1762 unsigned int pref)
1da177e4 1763{
86872cb5
TG		 1764 struct fib6_config cfg = {
1765 .fc_table = RT6_TABLE_DFLT,
238fc7ea 1766 .fc_metric = IP6_RT_PRIO_USER,
86872cb5
TG		 1767 .fc_ifindex = dev->ifindex,
1768 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1769 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
5578689a
DL		 1770 .fc_nlinfo.pid = 0,
1771 .fc_nlinfo.nlh = NULL,
c346dca1 1772 .fc_nlinfo.nl_net = dev_net(dev),
86872cb5 1773 };
1da177e4 1774
86872cb5 1775 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1da177e4 1776
86872cb5 1777 ip6_route_add(&cfg);
1da177e4 1778
1da177e4
LT		 1779 return rt6_get_dflt_router(gwaddr, dev);
1780}
1781
7b4da532 1782void rt6_purge_dflt_routers(struct net *net)
1da177e4
LT		 1783{
1784 struct rt6_info *rt;
c71099ac
TG		 1785 struct fib6_table *table;
1786
1787 /* NOTE: Keep consistent with rt6_get_dflt_router */
7b4da532 1788 table = fib6_get_table(net, RT6_TABLE_DFLT);
c71099ac
TG		 1789 if (table == NULL)
1790 return;
1da177e4
LT		 1791
1792restart:
c71099ac 1793 read_lock_bh(&table->tb6_lock);
7cc48263 1794 for (rt = table->tb6_root.leaf; rt; rt = rt->u.dst.rt6_next) {
1da177e4
LT		 1795 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1796 dst_hold(&rt->u.dst);
c71099ac 1797 read_unlock_bh(&table->tb6_lock);
e0a1ad73 1798 ip6_del_rt(rt);
1da177e4
LT		 1799 goto restart;
1800 }
1801 }
c71099ac 1802 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1803}
1804
5578689a
DL		 1805static void rtmsg_to_fib6_config(struct net *net,
1806 struct in6_rtmsg *rtmsg,
86872cb5
TG		 1807 struct fib6_config *cfg)
1808{
1809 memset(cfg, 0, sizeof(*cfg));
1810
1811 cfg->fc_table = RT6_TABLE_MAIN;
1812 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1813 cfg->fc_metric = rtmsg->rtmsg_metric;
1814 cfg->fc_expires = rtmsg->rtmsg_info;
1815 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1816 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1817 cfg->fc_flags = rtmsg->rtmsg_flags;
1818
5578689a 1819 cfg->fc_nlinfo.nl_net = net;
f1243c2d 1820
86872cb5
TG		 1821 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1822 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1823 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1824}
1825
5578689a 1826int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1da177e4 1827{
86872cb5 1828 struct fib6_config cfg;
1da177e4
LT		 1829 struct in6_rtmsg rtmsg;
1830 int err;
1831
1832 switch(cmd) {
1833 case SIOCADDRT: /* Add a route */
1834 case SIOCDELRT: /* Delete a route */
1835 if (!capable(CAP_NET_ADMIN))
1836 return -EPERM;
1837 err = copy_from_user(&rtmsg, arg,
1838 sizeof(struct in6_rtmsg));
1839 if (err)
1840 return -EFAULT;
86872cb5 1841
5578689a 1842 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
86872cb5 1843
1da177e4
LT		 1844 rtnl_lock();
1845 switch (cmd) {
1846 case SIOCADDRT:
86872cb5 1847 err = ip6_route_add(&cfg);
1da177e4
LT		 1848 break;
1849 case SIOCDELRT:
86872cb5 1850 err = ip6_route_del(&cfg);
1da177e4
LT		 1851 break;
1852 default:
1853 err = -EINVAL;
1854 }
1855 rtnl_unlock();
1856
1857 return err;
3ff50b79 1858 }
1da177e4
LT		 1859
1860 return -EINVAL;
1861}
1862
1863/*
1864 * Drop the packet on the floor
1865 */
1866
d5fdd6ba 1867static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
1da177e4 1868{
612f09e8 1869 int type;
adf30907 1870 struct dst_entry *dst = skb_dst(skb);
612f09e8
YH		 1871 switch (ipstats_mib_noroutes) {
1872 case IPSTATS_MIB_INNOROUTES:
0660e03f 1873 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
45bb0060 1874 if (type == IPV6_ADDR_ANY) {
3bd653c8
DL		 1875 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
1876 IPSTATS_MIB_INADDRERRORS);
612f09e8
YH		 1877 break;
1878 }
1879 /* FALLTHROUGH */
1880 case IPSTATS_MIB_OUTNOROUTES:
3bd653c8
DL		 1881 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
1882 ipstats_mib_noroutes);
612f09e8
YH		 1883 break;
1884 }
3ffe533c 1885 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
1da177e4
LT		 1886 kfree_skb(skb);
1887 return 0;
1888}
1889
9ce8ade0
TG		 1890static int ip6_pkt_discard(struct sk_buff *skb)
1891{
612f09e8 1892 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
9ce8ade0
TG		 1893}
1894
20380731 1895static int ip6_pkt_discard_out(struct sk_buff *skb)
1da177e4 1896{
adf30907 1897 skb->dev = skb_dst(skb)->dev;
612f09e8 1898 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
1da177e4
LT		 1899}
1900
6723ab54
DM		 1901#ifdef CONFIG_IPV6_MULTIPLE_TABLES
1902
9ce8ade0
TG		 1903static int ip6_pkt_prohibit(struct sk_buff *skb)
1904{
612f09e8 1905 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
9ce8ade0
TG		 1906}
1907
1908static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1909{
adf30907 1910 skb->dev = skb_dst(skb)->dev;
612f09e8 1911 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
9ce8ade0
TG		 1912}
1913
6723ab54
DM		 1914#endif
1915
1da177e4
LT		 1916/*
1917 * Allocate a dst for local (unicast / anycast) address.
1918 */
1919
1920struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1921 const struct in6_addr *addr,
1922 int anycast)
1923{
c346dca1 1924 struct net *net = dev_net(idev->dev);
86393e52 1925 struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
14deae41 1926 struct neighbour *neigh;
1da177e4
LT		 1927
1928 if (rt == NULL)
1929 return ERR_PTR(-ENOMEM);
1930
5578689a 1931 dev_hold(net->loopback_dev);
1da177e4
LT		 1932 in6_dev_hold(idev);
1933
1934 rt->u.dst.flags = DST_HOST;
1935 rt->u.dst.input = ip6_input;
1936 rt->u.dst.output = ip6_output;
5578689a 1937 rt->rt6i_dev = net->loopback_dev;
1da177e4
LT		 1938 rt->rt6i_idev = idev;
1939 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
5578689a 1940 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, dst_mtu(&rt->u.dst));
1da177e4
LT		 1941 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1942 rt->u.dst.obsolete = -1;
1943
1944 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
58c4fb86
YH		 1945 if (anycast)
1946 rt->rt6i_flags |= RTF_ANYCAST;
1947 else
1da177e4 1948 rt->rt6i_flags |= RTF_LOCAL;
14deae41
DM		 1949 neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1950 if (IS_ERR(neigh)) {
40aa7b90 1951 dst_free(&rt->u.dst);
14deae41
DM		 1952
1953 /* We are casting this because that is the return
1954 * value type. But an errno encoded pointer is the
1955 * same regardless of the underlying pointer type,
1956 * and that's what we are returning. So this is OK.
1957 */
1958 return (struct rt6_info *) neigh;
1da177e4 1959 }
14deae41 1960 rt->rt6i_nexthop = neigh;
1da177e4
LT		 1961
1962 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1963 rt->rt6i_dst.plen = 128;
5578689a 1964 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
1da177e4
LT		 1965
1966 atomic_set(&rt->u.dst.__refcnt, 1);
1967
1968 return rt;
1969}
1970
8ed67789
DL		 1971struct arg_dev_net {
1972 struct net_device *dev;
1973 struct net *net;
1974};
1975
1da177e4
LT		 1976static int fib6_ifdown(struct rt6_info *rt, void *arg)
1977{
8ed67789
DL		 1978 struct net_device *dev = ((struct arg_dev_net *)arg)->dev;
1979 struct net *net = ((struct arg_dev_net *)arg)->net;
1980
1981 if (((void *)rt->rt6i_dev == dev || dev == NULL) &&
1982 rt != net->ipv6.ip6_null_entry) {
1da177e4
LT		 1983 RT6_TRACE("deleted by ifdown %p\n", rt);
1984 return -1;
1985 }
1986 return 0;
1987}
1988
f3db4851 1989void rt6_ifdown(struct net *net, struct net_device *dev)
1da177e4 1990{
8ed67789
DL		 1991 struct arg_dev_net adn = {
1992 .dev = dev,
1993 .net = net,
1994 };
1995
1996 fib6_clean_all(net, fib6_ifdown, 0, &adn);
1e493d19 1997 icmp6_clean_all(fib6_ifdown, &adn);
1da177e4
LT		 1998}
1999
2000struct rt6_mtu_change_arg
2001{
2002 struct net_device *dev;
2003 unsigned mtu;
2004};
2005
2006static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2007{
2008 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2009 struct inet6_dev *idev;
c346dca1 2010 struct net *net = dev_net(arg->dev);
1da177e4
LT		 2011
2012 /* In IPv6 pmtu discovery is not optional,
2013 so that RTAX_MTU lock cannot disable it.
2014 We still use this lock to block changes
2015 caused by addrconf/ndisc.
2016 */
2017
2018 idev = __in6_dev_get(arg->dev);
2019 if (idev == NULL)
2020 return 0;
2021
2022 /* For administrative MTU increase, there is no way to discover
2023 IPv6 PMTU increase, so PMTU increase should be updated here.
2024 Since RFC 1981 doesn't include administrative MTU increase
2025 update PMTU increase is a MUST. (i.e. jumbo frame)
2026 */
2027 /*
2028 If new MTU is less than route PMTU, this new MTU will be the
2029 lowest MTU in the path, update the route PMTU to reflect PMTU
2030 decreases; if new MTU is greater than route PMTU, and the
2031 old MTU is the lowest MTU in the path, update the route PMTU
2032 to reflect the increase. In this case if the other nodes' MTU
2033 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2034 PMTU discouvery.
2035 */
2036 if (rt->rt6i_dev == arg->dev &&
2037 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
23717795 2038 (dst_mtu(&rt->u.dst) >= arg->mtu ||
1ab1457c 2039 (dst_mtu(&rt->u.dst) < arg->mtu &&
566cfd8f 2040 dst_mtu(&rt->u.dst) == idev->cnf.mtu6))) {
1da177e4 2041 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
5578689a 2042 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, arg->mtu);
566cfd8f 2043 }
1da177e4
LT		 2044 return 0;
2045}
2046
2047void rt6_mtu_change(struct net_device *dev, unsigned mtu)
2048{
c71099ac
TG		 2049 struct rt6_mtu_change_arg arg = {
2050 .dev = dev,
2051 .mtu = mtu,
2052 };
1da177e4 2053
c346dca1 2054 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
1da177e4
LT		 2055}
2056
ef7c79ed 2057static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
5176f91e 2058 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
86872cb5 2059 [RTA_OIF] = { .type = NLA_U32 },
ab364a6f 2060 [RTA_IIF] = { .type = NLA_U32 },
86872cb5
TG		 2061 [RTA_PRIORITY] = { .type = NLA_U32 },
2062 [RTA_METRICS] = { .type = NLA_NESTED },
2063};
2064
2065static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2066 struct fib6_config *cfg)
1da177e4 2067{
86872cb5
TG		 2068 struct rtmsg *rtm;
2069 struct nlattr *tb[RTA_MAX+1];
2070 int err;
1da177e4 2071
86872cb5
TG		 2072 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2073 if (err < 0)
2074 goto errout;
1da177e4 2075
86872cb5
TG		 2076 err = -EINVAL;
2077 rtm = nlmsg_data(nlh);
2078 memset(cfg, 0, sizeof(*cfg));
2079
2080 cfg->fc_table = rtm->rtm_table;
2081 cfg->fc_dst_len = rtm->rtm_dst_len;
2082 cfg->fc_src_len = rtm->rtm_src_len;
2083 cfg->fc_flags = RTF_UP;
2084 cfg->fc_protocol = rtm->rtm_protocol;
2085
2086 if (rtm->rtm_type == RTN_UNREACHABLE)
2087 cfg->fc_flags |= RTF_REJECT;
2088
2089 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
2090 cfg->fc_nlinfo.nlh = nlh;
3b1e0a65 2091 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
86872cb5
TG		 2092
2093 if (tb[RTA_GATEWAY]) {
2094 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2095 cfg->fc_flags |= RTF_GATEWAY;
1da177e4 2096 }
86872cb5
TG		 2097
2098 if (tb[RTA_DST]) {
2099 int plen = (rtm->rtm_dst_len + 7) >> 3;
2100
2101 if (nla_len(tb[RTA_DST]) < plen)
2102 goto errout;
2103
2104 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1da177e4 2105 }
86872cb5
TG		 2106
2107 if (tb[RTA_SRC]) {
2108 int plen = (rtm->rtm_src_len + 7) >> 3;
2109
2110 if (nla_len(tb[RTA_SRC]) < plen)
2111 goto errout;
2112
2113 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1da177e4 2114 }
86872cb5
TG		 2115
2116 if (tb[RTA_OIF])
2117 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2118
2119 if (tb[RTA_PRIORITY])
2120 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2121
2122 if (tb[RTA_METRICS]) {
2123 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2124 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
1da177e4 2125 }
86872cb5
TG		 2126
2127 if (tb[RTA_TABLE])
2128 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2129
2130 err = 0;
2131errout:
2132 return err;
1da177e4
LT		 2133}
2134
c127ea2c 2135static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1da177e4 2136{
86872cb5
TG		 2137 struct fib6_config cfg;
2138 int err;
1da177e4 2139
86872cb5
TG		 2140 err = rtm_to_fib6_config(skb, nlh, &cfg);
2141 if (err < 0)
2142 return err;
2143
2144 return ip6_route_del(&cfg);
1da177e4
LT		 2145}
2146
c127ea2c 2147static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1da177e4 2148{
86872cb5
TG		 2149 struct fib6_config cfg;
2150 int err;
1da177e4 2151
86872cb5
TG		 2152 err = rtm_to_fib6_config(skb, nlh, &cfg);
2153 if (err < 0)
2154 return err;
2155
2156 return ip6_route_add(&cfg);
1da177e4
LT		 2157}
2158
339bf98f
TG		 2159static inline size_t rt6_nlmsg_size(void)
2160{
2161 return NLMSG_ALIGN(sizeof(struct rtmsg))
2162 + nla_total_size(16) /* RTA_SRC */
2163 + nla_total_size(16) /* RTA_DST */
2164 + nla_total_size(16) /* RTA_GATEWAY */
2165 + nla_total_size(16) /* RTA_PREFSRC */
2166 + nla_total_size(4) /* RTA_TABLE */
2167 + nla_total_size(4) /* RTA_IIF */
2168 + nla_total_size(4) /* RTA_OIF */
2169 + nla_total_size(4) /* RTA_PRIORITY */
6a2b9ce0 2170 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
339bf98f
TG		 2171 + nla_total_size(sizeof(struct rta_cacheinfo));
2172}
2173
191cd582
BH		 2174static int rt6_fill_node(struct net *net,
2175 struct sk_buff *skb, struct rt6_info *rt,
0d51aa80
JHS		 2176 struct in6_addr *dst, struct in6_addr *src,
2177 int iif, int type, u32 pid, u32 seq,
7bc570c8 2178 int prefix, int nowait, unsigned int flags)
1da177e4
LT		 2179{
2180 struct rtmsg *rtm;
2d7202bf 2181 struct nlmsghdr *nlh;
e3703b3d 2182 long expires;
9e762a4a 2183 u32 table;
1da177e4
LT		 2184
2185 if (prefix) { /* user wants prefix routes only */
2186 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2187 /* success since this is not a prefix route */
2188 return 1;
2189 }
2190 }
2191
2d7202bf
TG		 2192 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2193 if (nlh == NULL)
26932566 2194 return -EMSGSIZE;
2d7202bf
TG		 2195
2196 rtm = nlmsg_data(nlh);
1da177e4
LT		 2197 rtm->rtm_family = AF_INET6;
2198 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2199 rtm->rtm_src_len = rt->rt6i_src.plen;
2200 rtm->rtm_tos = 0;
c71099ac 2201 if (rt->rt6i_table)
9e762a4a 2202 table = rt->rt6i_table->tb6_id;
c71099ac 2203 else
9e762a4a
PM		 2204 table = RT6_TABLE_UNSPEC;
2205 rtm->rtm_table = table;
2d7202bf 2206 NLA_PUT_U32(skb, RTA_TABLE, table);
1da177e4
LT		 2207 if (rt->rt6i_flags&RTF_REJECT)
2208 rtm->rtm_type = RTN_UNREACHABLE;
2209 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2210 rtm->rtm_type = RTN_LOCAL;
2211 else
2212 rtm->rtm_type = RTN_UNICAST;
2213 rtm->rtm_flags = 0;
2214 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2215 rtm->rtm_protocol = rt->rt6i_protocol;
2216 if (rt->rt6i_flags&RTF_DYNAMIC)
2217 rtm->rtm_protocol = RTPROT_REDIRECT;
2218 else if (rt->rt6i_flags & RTF_ADDRCONF)
2219 rtm->rtm_protocol = RTPROT_KERNEL;
2220 else if (rt->rt6i_flags&RTF_DEFAULT)
2221 rtm->rtm_protocol = RTPROT_RA;
2222
2223 if (rt->rt6i_flags&RTF_CACHE)
2224 rtm->rtm_flags |= RTM_F_CLONED;
2225
2226 if (dst) {
2d7202bf 2227 NLA_PUT(skb, RTA_DST, 16, dst);
1ab1457c 2228 rtm->rtm_dst_len = 128;
1da177e4 2229 } else if (rtm->rtm_dst_len)
2d7202bf 2230 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
1da177e4
LT		 2231#ifdef CONFIG_IPV6_SUBTREES
2232 if (src) {
2d7202bf 2233 NLA_PUT(skb, RTA_SRC, 16, src);
1ab1457c 2234 rtm->rtm_src_len = 128;
1da177e4 2235 } else if (rtm->rtm_src_len)
2d7202bf 2236 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
1da177e4 2237#endif
7bc570c8
YH		 2238 if (iif) {
2239#ifdef CONFIG_IPV6_MROUTE
2240 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
8229efda 2241 int err = ip6mr_get_route(net, skb, rtm, nowait);
7bc570c8
YH		 2242 if (err <= 0) {
2243 if (!nowait) {
2244 if (err == 0)
2245 return 0;
2246 goto nla_put_failure;
2247 } else {
2248 if (err == -EMSGSIZE)
2249 goto nla_put_failure;
2250 }
2251 }
2252 } else
2253#endif
2254 NLA_PUT_U32(skb, RTA_IIF, iif);
2255 } else if (dst) {
5e0115e5 2256 struct inet6_dev *idev = ip6_dst_idev(&rt->u.dst);
1da177e4 2257 struct in6_addr saddr_buf;
191cd582 2258 if (ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
7cbca67c 2259 dst, 0, &saddr_buf) == 0)
2d7202bf 2260 NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
1da177e4 2261 }
2d7202bf 2262
1da177e4 2263 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
2d7202bf
TG		 2264 goto nla_put_failure;
2265
1da177e4 2266 if (rt->u.dst.neighbour)
2d7202bf
TG		 2267 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
2268
1da177e4 2269 if (rt->u.dst.dev)
2d7202bf
TG		 2270 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2271
2272 NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
e3703b3d 2273
36e3deae
YH		 2274 if (!(rt->rt6i_flags & RTF_EXPIRES))
2275 expires = 0;
2276 else if (rt->rt6i_expires - jiffies < INT_MAX)
2277 expires = rt->rt6i_expires - jiffies;
2278 else
2279 expires = INT_MAX;
69cdf8f9 2280
e3703b3d
TG		 2281 if (rtnl_put_cacheinfo(skb, &rt->u.dst, 0, 0, 0,
2282 expires, rt->u.dst.error) < 0)
2283 goto nla_put_failure;
2d7202bf
TG		 2284
2285 return nlmsg_end(skb, nlh);
2286
2287nla_put_failure:
26932566
PM		 2288 nlmsg_cancel(skb, nlh);
2289 return -EMSGSIZE;
1da177e4
LT		 2290}
2291
1b43af54 2292int rt6_dump_route(struct rt6_info *rt, void *p_arg)
1da177e4
LT		 2293{
2294 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2295 int prefix;
2296
2d7202bf
TG		 2297 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2298 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
1da177e4
LT		 2299 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2300 } else
2301 prefix = 0;
2302
191cd582
BH		 2303 return rt6_fill_node(arg->net,
2304 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
1da177e4 2305 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
7bc570c8 2306 prefix, 0, NLM_F_MULTI);
1da177e4
LT		 2307}
2308
c127ea2c 2309static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
1da177e4 2310{
3b1e0a65 2311 struct net *net = sock_net(in_skb->sk);
ab364a6f
TG		 2312 struct nlattr *tb[RTA_MAX+1];
2313 struct rt6_info *rt;
1da177e4 2314 struct sk_buff *skb;
ab364a6f 2315 struct rtmsg *rtm;
1da177e4 2316 struct flowi fl;
ab364a6f 2317 int err, iif = 0;
1da177e4 2318
ab364a6f
TG		 2319 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2320 if (err < 0)
2321 goto errout;
1da177e4 2322
ab364a6f 2323 err = -EINVAL;
1da177e4 2324 memset(&fl, 0, sizeof(fl));
1da177e4 2325
ab364a6f
TG		 2326 if (tb[RTA_SRC]) {
2327 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2328 goto errout;
2329
2330 ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2331 }
2332
2333 if (tb[RTA_DST]) {
2334 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2335 goto errout;
2336
2337 ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2338 }
2339
2340 if (tb[RTA_IIF])
2341 iif = nla_get_u32(tb[RTA_IIF]);
2342
2343 if (tb[RTA_OIF])
2344 fl.oif = nla_get_u32(tb[RTA_OIF]);
1da177e4
LT		 2345
2346 if (iif) {
2347 struct net_device *dev;
5578689a 2348 dev = __dev_get_by_index(net, iif);
1da177e4
LT		 2349 if (!dev) {
2350 err = -ENODEV;
ab364a6f 2351 goto errout;
1da177e4
LT		 2352 }
2353 }
2354
ab364a6f
TG		 2355 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2356 if (skb == NULL) {
2357 err = -ENOBUFS;
2358 goto errout;
2359 }
1da177e4 2360
ab364a6f
TG		 2361 /* Reserve room for dummy headers, this skb can pass
2362 through good chunk of routing engine.
2363 */
459a98ed 2364 skb_reset_mac_header(skb);
ab364a6f 2365 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
1da177e4 2366
8a3edd80 2367 rt = (struct rt6_info*) ip6_route_output(net, NULL, &fl);
adf30907 2368 skb_dst_set(skb, &rt->u.dst);
1da177e4 2369
191cd582 2370 err = rt6_fill_node(net, skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
1da177e4 2371 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
7bc570c8 2372 nlh->nlmsg_seq, 0, 0, 0);
1da177e4 2373 if (err < 0) {
ab364a6f
TG		 2374 kfree_skb(skb);
2375 goto errout;
1da177e4
LT		 2376 }
2377
5578689a 2378 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
ab364a6f 2379errout:
1da177e4 2380 return err;
1da177e4
LT		 2381}
2382
86872cb5 2383void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 2384{
2385 struct sk_buff *skb;
5578689a 2386 struct net *net = info->nl_net;
528c4ceb
DL		 2387 u32 seq;
2388 int err;
2389
2390 err = -ENOBUFS;
2391 seq = info->nlh != NULL ? info->nlh->nlmsg_seq : 0;
86872cb5 2392
339bf98f 2393 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
21713ebc
TG		 2394 if (skb == NULL)
2395 goto errout;
2396
191cd582 2397 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
7bc570c8 2398 event, info->pid, seq, 0, 0, 0);
26932566
PM		 2399 if (err < 0) {
2400 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2401 WARN_ON(err == -EMSGSIZE);
2402 kfree_skb(skb);
2403 goto errout;
2404 }
1ce85fe4
PNA		 2405 rtnl_notify(skb, net, info->pid, RTNLGRP_IPV6_ROUTE,
2406 info->nlh, gfp_any());
2407 return;
21713ebc
TG		 2408errout:
2409 if (err < 0)
5578689a 2410 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
1da177e4
LT		 2411}
2412
8ed67789
DL		 2413static int ip6_route_dev_notify(struct notifier_block *this,
2414 unsigned long event, void *data)
2415{
2416 struct net_device *dev = (struct net_device *)data;
c346dca1 2417 struct net *net = dev_net(dev);
8ed67789
DL		 2418
2419 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2420 net->ipv6.ip6_null_entry->u.dst.dev = dev;
2421 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2422#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2423 net->ipv6.ip6_prohibit_entry->u.dst.dev = dev;
2424 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2425 net->ipv6.ip6_blk_hole_entry->u.dst.dev = dev;
2426 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2427#endif
2428 }
2429
2430 return NOTIFY_OK;
2431}
2432
1da177e4
LT		 2433/*
2434 * /proc
2435 */
2436
2437#ifdef CONFIG_PROC_FS
2438
2439#define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2440
2441struct rt6_proc_arg
2442{
2443 char *buffer;
2444 int offset;
2445 int length;
2446 int skip;
2447 int len;
2448};
2449
2450static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2451{
33120b30 2452 struct seq_file *m = p_arg;
1da177e4 2453
4b7a4274 2454 seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
1da177e4
LT		 2455
2456#ifdef CONFIG_IPV6_SUBTREES
4b7a4274 2457 seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
1da177e4 2458#else
33120b30 2459 seq_puts(m, "00000000000000000000000000000000 00 ");
1da177e4
LT		 2460#endif
2461
2462 if (rt->rt6i_nexthop) {
4b7a4274 2463 seq_printf(m, "%pi6", rt->rt6i_nexthop->primary_key);
1da177e4 2464 } else {
33120b30 2465 seq_puts(m, "00000000000000000000000000000000");
1da177e4 2466 }
33120b30
AD		 2467 seq_printf(m, " %08x %08x %08x %08x %8s\n",
2468 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
2469 rt->u.dst.__use, rt->rt6i_flags,
2470 rt->rt6i_dev ? rt->rt6i_dev->name : "");
1da177e4
LT		 2471 return 0;
2472}
2473
33120b30 2474static int ipv6_route_show(struct seq_file *m, void *v)
1da177e4 2475{
f3db4851
DL		 2476 struct net *net = (struct net *)m->private;
2477 fib6_clean_all(net, rt6_info_route, 0, m);
33120b30
AD		 2478 return 0;
2479}
1da177e4 2480
33120b30
AD		 2481static int ipv6_route_open(struct inode *inode, struct file *file)
2482{
de05c557 2483 return single_open_net(inode, file, ipv6_route_show);
f3db4851
DL		 2484}
2485
33120b30
AD		 2486static const struct file_operations ipv6_route_proc_fops = {
2487 .owner = THIS_MODULE,
2488 .open = ipv6_route_open,
2489 .read = seq_read,
2490 .llseek = seq_lseek,
b6fcbdb4 2491 .release = single_release_net,
33120b30
AD		 2492};
2493
1da177e4
LT		 2494static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2495{
69ddb805 2496 struct net *net = (struct net *)seq->private;
1da177e4 2497 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
69ddb805
DL		 2498 net->ipv6.rt6_stats->fib_nodes,
2499 net->ipv6.rt6_stats->fib_route_nodes,
2500 net->ipv6.rt6_stats->fib_rt_alloc,
2501 net->ipv6.rt6_stats->fib_rt_entries,
2502 net->ipv6.rt6_stats->fib_rt_cache,
86393e52 2503 atomic_read(&net->ipv6.ip6_dst_ops.entries),
69ddb805 2504 net->ipv6.rt6_stats->fib_discarded_routes);
1da177e4
LT		 2505
2506 return 0;
2507}
2508
2509static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2510{
de05c557 2511 return single_open_net(inode, file, rt6_stats_seq_show);
69ddb805
DL		 2512}
2513
9a32144e 2514static const struct file_operations rt6_stats_seq_fops = {
1da177e4
LT		 2515 .owner = THIS_MODULE,
2516 .open = rt6_stats_seq_open,
2517 .read = seq_read,
2518 .llseek = seq_lseek,
b6fcbdb4 2519 .release = single_release_net,
1da177e4
LT		 2520};
2521#endif /* CONFIG_PROC_FS */
2522
2523#ifdef CONFIG_SYSCTL
2524
1da177e4 2525static
8d65af78 2526int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,
1da177e4
LT		 2527 void __user *buffer, size_t *lenp, loff_t *ppos)
2528{
5b7c931d
DL		 2529 struct net *net = current->nsproxy->net_ns;
2530 int delay = net->ipv6.sysctl.flush_delay;
1da177e4 2531 if (write) {
8d65af78 2532 proc_dointvec(ctl, write, buffer, lenp, ppos);
5b7c931d 2533 fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
1da177e4
LT		 2534 return 0;
2535 } else
2536 return -EINVAL;
2537}
2538
760f2d01 2539ctl_table ipv6_route_table_template[] = {
1ab1457c 2540 {
1da177e4 2541 .procname = "flush",
4990509f 2542 .data = &init_net.ipv6.sysctl.flush_delay,
1da177e4 2543 .maxlen = sizeof(int),
89c8b3a1 2544 .mode = 0200,
6d9f239a 2545 .proc_handler = ipv6_sysctl_rtcache_flush
1da177e4
LT		 2546 },
2547 {
1da177e4 2548 .procname = "gc_thresh",
9a7ec3a9 2549 .data = &ip6_dst_ops_template.gc_thresh,
1da177e4
LT		 2550 .maxlen = sizeof(int),
2551 .mode = 0644,
6d9f239a 2552 .proc_handler = proc_dointvec,
1da177e4
LT		 2553 },
2554 {
1da177e4 2555 .procname = "max_size",
4990509f 2556 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
1da177e4
LT		 2557 .maxlen = sizeof(int),
2558 .mode = 0644,
6d9f239a 2559 .proc_handler = proc_dointvec,
1da177e4
LT		 2560 },
2561 {
1da177e4 2562 .procname = "gc_min_interval",
4990509f 2563 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 2564 .maxlen = sizeof(int),
2565 .mode = 0644,
6d9f239a 2566 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2567 },
2568 {
1da177e4 2569 .procname = "gc_timeout",
4990509f 2570 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
1da177e4
LT		 2571 .maxlen = sizeof(int),
2572 .mode = 0644,
6d9f239a 2573 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2574 },
2575 {
1da177e4 2576 .procname = "gc_interval",
4990509f 2577 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
1da177e4
LT		 2578 .maxlen = sizeof(int),
2579 .mode = 0644,
6d9f239a 2580 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2581 },
2582 {
1da177e4 2583 .procname = "gc_elasticity",
4990509f 2584 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
1da177e4
LT		 2585 .maxlen = sizeof(int),
2586 .mode = 0644,
6d9f239a 2587 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2588 },
2589 {
1da177e4 2590 .procname = "mtu_expires",
4990509f 2591 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
1da177e4
LT		 2592 .maxlen = sizeof(int),
2593 .mode = 0644,
6d9f239a 2594 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2595 },
2596 {
1da177e4 2597 .procname = "min_adv_mss",
4990509f 2598 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
1da177e4
LT		 2599 .maxlen = sizeof(int),
2600 .mode = 0644,
6d9f239a 2601 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 2602 },
2603 {
1da177e4 2604 .procname = "gc_min_interval_ms",
4990509f 2605 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 2606 .maxlen = sizeof(int),
2607 .mode = 0644,
6d9f239a 2608 .proc_handler = proc_dointvec_ms_jiffies,
1da177e4 2609 },
f8572d8f 2610 { }
1da177e4
LT		 2611};
2612
2c8c1e72 2613struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
760f2d01
DL		 2614{
2615 struct ctl_table *table;
2616
2617 table = kmemdup(ipv6_route_table_template,
2618 sizeof(ipv6_route_table_template),
2619 GFP_KERNEL);
5ee09105
YH		 2620
2621 if (table) {
2622 table[0].data = &net->ipv6.sysctl.flush_delay;
86393e52 2623 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
5ee09105
YH		 2624 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2625 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2626 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2627 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2628 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2629 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2630 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
9c69fabe 2631 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
5ee09105
YH		 2632 }
2633
760f2d01
DL		 2634 return table;
2635}
1da177e4
LT		 2636#endif
2637
2c8c1e72 2638static int __net_init ip6_route_net_init(struct net *net)
cdb18761 2639{
633d424b 2640 int ret = -ENOMEM;
8ed67789 2641
86393e52
AD		 2642 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
2643 sizeof(net->ipv6.ip6_dst_ops));
f2fc6a54 2644
8ed67789
DL		 2645 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
2646 sizeof(*net->ipv6.ip6_null_entry),
2647 GFP_KERNEL);
2648 if (!net->ipv6.ip6_null_entry)
f2fc6a54 2649 goto out_ip6_dst_ops;
8ed67789
DL		 2650 net->ipv6.ip6_null_entry->u.dst.path =
2651 (struct dst_entry *)net->ipv6.ip6_null_entry;
86393e52 2652 net->ipv6.ip6_null_entry->u.dst.ops = &net->ipv6.ip6_dst_ops;
8ed67789
DL		 2653
2654#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2655 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
2656 sizeof(*net->ipv6.ip6_prohibit_entry),
2657 GFP_KERNEL);
68fffc67
PZ		 2658 if (!net->ipv6.ip6_prohibit_entry)
2659 goto out_ip6_null_entry;
8ed67789
DL		 2660 net->ipv6.ip6_prohibit_entry->u.dst.path =
2661 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
86393e52 2662 net->ipv6.ip6_prohibit_entry->u.dst.ops = &net->ipv6.ip6_dst_ops;
8ed67789
DL		 2663
2664 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
2665 sizeof(*net->ipv6.ip6_blk_hole_entry),
2666 GFP_KERNEL);
68fffc67
PZ		 2667 if (!net->ipv6.ip6_blk_hole_entry)
2668 goto out_ip6_prohibit_entry;
8ed67789
DL		 2669 net->ipv6.ip6_blk_hole_entry->u.dst.path =
2670 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
86393e52 2671 net->ipv6.ip6_blk_hole_entry->u.dst.ops = &net->ipv6.ip6_dst_ops;
8ed67789
DL		 2672#endif
2673
b339a47c
PZ		 2674 net->ipv6.sysctl.flush_delay = 0;
2675 net->ipv6.sysctl.ip6_rt_max_size = 4096;
2676 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
2677 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
2678 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
2679 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
2680 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
2681 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
2682
cdb18761
DL		 2683#ifdef CONFIG_PROC_FS
2684 proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);
2685 proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2686#endif
6891a346
BT		 2687 net->ipv6.ip6_rt_gc_expire = 30*HZ;
2688
8ed67789
DL		 2689 ret = 0;
2690out:
2691 return ret;
f2fc6a54 2692
68fffc67
PZ		 2693#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2694out_ip6_prohibit_entry:
2695 kfree(net->ipv6.ip6_prohibit_entry);
2696out_ip6_null_entry:
2697 kfree(net->ipv6.ip6_null_entry);
2698#endif
f2fc6a54 2699out_ip6_dst_ops:
f2fc6a54 2700 goto out;
cdb18761
DL		 2701}
2702
2c8c1e72 2703static void __net_exit ip6_route_net_exit(struct net *net)
cdb18761
DL		 2704{
2705#ifdef CONFIG_PROC_FS
2706 proc_net_remove(net, "ipv6_route");
2707 proc_net_remove(net, "rt6_stats");
2708#endif
8ed67789
DL		 2709 kfree(net->ipv6.ip6_null_entry);
2710#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2711 kfree(net->ipv6.ip6_prohibit_entry);
2712 kfree(net->ipv6.ip6_blk_hole_entry);
2713#endif
cdb18761
DL		 2714}
2715
2716static struct pernet_operations ip6_route_net_ops = {
2717 .init = ip6_route_net_init,
2718 .exit = ip6_route_net_exit,
2719};
2720
8ed67789
DL		 2721static struct notifier_block ip6_route_dev_notifier = {
2722 .notifier_call = ip6_route_dev_notify,
2723 .priority = 0,
2724};
2725
433d49c3 2726int __init ip6_route_init(void)
1da177e4 2727{
433d49c3
DL		 2728 int ret;
2729
9a7ec3a9
DL		 2730 ret = -ENOMEM;
2731 ip6_dst_ops_template.kmem_cachep =
e5d679f3 2732 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
f845ab6b 2733 SLAB_HWCACHE_ALIGN, NULL);
9a7ec3a9 2734 if (!ip6_dst_ops_template.kmem_cachep)
c19a28e1 2735 goto out;
14e50e57 2736
8ed67789
DL		 2737 ret = register_pernet_subsys(&ip6_route_net_ops);
2738 if (ret)
bdb3289f 2739 goto out_kmem_cache;
bdb3289f 2740
5dc121e9
AE		 2741 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
2742
8ed67789
DL		 2743 /* Registering of the loopback is done before this portion of code,
2744 * the loopback reference in rt6_info will not be taken, do it
2745 * manually for init_net */
2746 init_net.ipv6.ip6_null_entry->u.dst.dev = init_net.loopback_dev;
2747 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
2748 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2749 init_net.ipv6.ip6_prohibit_entry->u.dst.dev = init_net.loopback_dev;
2750 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
2751 init_net.ipv6.ip6_blk_hole_entry->u.dst.dev = init_net.loopback_dev;
2752 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
2753 #endif
433d49c3
DL		 2754 ret = fib6_init();
2755 if (ret)
8ed67789 2756 goto out_register_subsys;
433d49c3 2757
433d49c3
DL		 2758 ret = xfrm6_init();
2759 if (ret)
cdb18761 2760 goto out_fib6_init;
c35b7e72 2761
433d49c3
DL		 2762 ret = fib6_rules_init();
2763 if (ret)
2764 goto xfrm6_init;
7e5449c2 2765
433d49c3
DL		 2766 ret = -ENOBUFS;
2767 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL) ||
2768 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL) ||
2769 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL))
2770 goto fib6_rules_init;
c127ea2c 2771
8ed67789 2772 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
cdb18761
DL		 2773 if (ret)
2774 goto fib6_rules_init;
8ed67789 2775
433d49c3
DL		 2776out:
2777 return ret;
2778
2779fib6_rules_init:
433d49c3
DL		 2780 fib6_rules_cleanup();
2781xfrm6_init:
433d49c3 2782 xfrm6_fini();
433d49c3 2783out_fib6_init:
433d49c3 2784 fib6_gc_cleanup();
8ed67789
DL		 2785out_register_subsys:
2786 unregister_pernet_subsys(&ip6_route_net_ops);
433d49c3 2787out_kmem_cache:
f2fc6a54 2788 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
433d49c3 2789 goto out;
1da177e4
LT		 2790}
2791
2792void ip6_route_cleanup(void)
2793{
8ed67789 2794 unregister_netdevice_notifier(&ip6_route_dev_notifier);
101367c2 2795 fib6_rules_cleanup();
1da177e4 2796 xfrm6_fini();
1da177e4 2797 fib6_gc_cleanup();
8ed67789 2798 unregister_pernet_subsys(&ip6_route_net_ops);
f2fc6a54 2799 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
1da177e4 2800}
Clone of davem's net-next-2.6 tree