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