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