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