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