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