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