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