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