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