blob: 9f80518aacbdf5069a10484c8235aec80ac0cbe6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Linux INET6 implementation
3 * FIB front-end.
4 *
5 * Authors:
6 * Pedro Roque <roque@di.fc.ul.pt>
7 *
8 * $Id: route.c,v 1.56 2001/10/31 21:55:55 davem Exp $
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 */
15
16/* Changes:
17 *
18 * YOSHIFUJI Hideaki @USAGI
19 * reworked default router selection.
20 * - respect outgoing interface
21 * - select from (probably) reachable routers (i.e.
22 * routers in REACHABLE, STALE, DELAY or PROBE states).
23 * - always select the same router if it is (probably)
24 * reachable. otherwise, round-robin the list.
YOSHIFUJI Hideakic0bece92006-08-23 17:23:25 -070025 * Ville Nuorvala
26 * Fixed routing subtrees.
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 */
28
Randy Dunlap4fc268d2006-01-11 12:17:47 -080029#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/if_arp.h>
41
42#ifdef CONFIG_PROC_FS
43#include <linux/proc_fs.h>
44#include <linux/seq_file.h>
45#endif
46
47#include <net/snmp.h>
48#include <net/ipv6.h>
49#include <net/ip6_fib.h>
50#include <net/ip6_route.h>
51#include <net/ndisc.h>
52#include <net/addrconf.h>
53#include <net/tcp.h>
54#include <linux/rtnetlink.h>
55#include <net/dst.h>
56#include <net/xfrm.h>
Tom Tucker8d717402006-07-30 20:43:36 -070057#include <net/netevent.h>
Thomas Graf21713eb2006-08-15 00:35:24 -070058#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
60#include <asm/uaccess.h>
61
62#ifdef CONFIG_SYSCTL
63#include <linux/sysctl.h>
64#endif
65
66/* Set to 3 to get tracing. */
67#define RT6_DEBUG 2
68
69#if RT6_DEBUG >= 3
70#define RDBG(x) printk x
71#define RT6_TRACE(x...) printk(KERN_DEBUG x)
72#else
73#define RDBG(x)
74#define RT6_TRACE(x...) do { ; } while (0)
75#endif
76
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -080077#define CLONE_OFFLINK_ROUTE 0
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79static int ip6_rt_max_size = 4096;
80static int ip6_rt_gc_min_interval = HZ / 2;
81static int ip6_rt_gc_timeout = 60*HZ;
82int ip6_rt_gc_interval = 30*HZ;
83static int ip6_rt_gc_elasticity = 9;
84static int ip6_rt_mtu_expires = 10*60*HZ;
85static int ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
86
87static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
88static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
89static struct dst_entry *ip6_negative_advice(struct dst_entry *);
90static void ip6_dst_destroy(struct dst_entry *);
91static void ip6_dst_ifdown(struct dst_entry *,
92 struct net_device *dev, int how);
93static int ip6_dst_gc(void);
94
95static int ip6_pkt_discard(struct sk_buff *skb);
96static int ip6_pkt_discard_out(struct sk_buff *skb);
97static void ip6_link_failure(struct sk_buff *skb);
98static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
99
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800100#ifdef CONFIG_IPV6_ROUTE_INFO
101static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
102 struct in6_addr *gwaddr, int ifindex,
103 unsigned pref);
104static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
105 struct in6_addr *gwaddr, int ifindex);
106#endif
107
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108static struct dst_ops ip6_dst_ops = {
109 .family = AF_INET6,
110 .protocol = __constant_htons(ETH_P_IPV6),
111 .gc = ip6_dst_gc,
112 .gc_thresh = 1024,
113 .check = ip6_dst_check,
114 .destroy = ip6_dst_destroy,
115 .ifdown = ip6_dst_ifdown,
116 .negative_advice = ip6_negative_advice,
117 .link_failure = ip6_link_failure,
118 .update_pmtu = ip6_rt_update_pmtu,
119 .entry_size = sizeof(struct rt6_info),
120};
121
122struct rt6_info ip6_null_entry = {
123 .u = {
124 .dst = {
125 .__refcnt = ATOMIC_INIT(1),
126 .__use = 1,
127 .dev = &loopback_dev,
128 .obsolete = -1,
129 .error = -ENETUNREACH,
130 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
131 .input = ip6_pkt_discard,
132 .output = ip6_pkt_discard_out,
133 .ops = &ip6_dst_ops,
134 .path = (struct dst_entry*)&ip6_null_entry,
135 }
136 },
137 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
138 .rt6i_metric = ~(u32) 0,
139 .rt6i_ref = ATOMIC_INIT(1),
140};
141
Thomas Graf101367c2006-08-04 03:39:02 -0700142#ifdef CONFIG_IPV6_MULTIPLE_TABLES
143
David S. Miller6723ab52006-10-18 21:20:57 -0700144static int ip6_pkt_prohibit(struct sk_buff *skb);
145static int ip6_pkt_prohibit_out(struct sk_buff *skb);
146static int ip6_pkt_blk_hole(struct sk_buff *skb);
147
Thomas Graf101367c2006-08-04 03:39:02 -0700148struct rt6_info ip6_prohibit_entry = {
149 .u = {
150 .dst = {
151 .__refcnt = ATOMIC_INIT(1),
152 .__use = 1,
153 .dev = &loopback_dev,
154 .obsolete = -1,
155 .error = -EACCES,
156 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
Thomas Graf9ce8ade2006-10-18 20:46:54 -0700157 .input = ip6_pkt_prohibit,
158 .output = ip6_pkt_prohibit_out,
Thomas Graf101367c2006-08-04 03:39:02 -0700159 .ops = &ip6_dst_ops,
160 .path = (struct dst_entry*)&ip6_prohibit_entry,
161 }
162 },
163 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
164 .rt6i_metric = ~(u32) 0,
165 .rt6i_ref = ATOMIC_INIT(1),
166};
167
168struct rt6_info ip6_blk_hole_entry = {
169 .u = {
170 .dst = {
171 .__refcnt = ATOMIC_INIT(1),
172 .__use = 1,
173 .dev = &loopback_dev,
174 .obsolete = -1,
175 .error = -EINVAL,
176 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
Thomas Graf9ce8ade2006-10-18 20:46:54 -0700177 .input = ip6_pkt_blk_hole,
178 .output = ip6_pkt_blk_hole,
Thomas Graf101367c2006-08-04 03:39:02 -0700179 .ops = &ip6_dst_ops,
180 .path = (struct dst_entry*)&ip6_blk_hole_entry,
181 }
182 },
183 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
184 .rt6i_metric = ~(u32) 0,
185 .rt6i_ref = ATOMIC_INIT(1),
186};
187
188#endif
189
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190/* allocate dst with ip6_dst_ops */
191static __inline__ struct rt6_info *ip6_dst_alloc(void)
192{
193 return (struct rt6_info *)dst_alloc(&ip6_dst_ops);
194}
195
196static void ip6_dst_destroy(struct dst_entry *dst)
197{
198 struct rt6_info *rt = (struct rt6_info *)dst;
199 struct inet6_dev *idev = rt->rt6i_idev;
200
201 if (idev != NULL) {
202 rt->rt6i_idev = NULL;
203 in6_dev_put(idev);
204 }
205}
206
207static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
208 int how)
209{
210 struct rt6_info *rt = (struct rt6_info *)dst;
211 struct inet6_dev *idev = rt->rt6i_idev;
212
213 if (dev != &loopback_dev && idev != NULL && idev->dev == dev) {
214 struct inet6_dev *loopback_idev = in6_dev_get(&loopback_dev);
215 if (loopback_idev != NULL) {
216 rt->rt6i_idev = loopback_idev;
217 in6_dev_put(idev);
218 }
219 }
220}
221
222static __inline__ int rt6_check_expired(const struct rt6_info *rt)
223{
224 return (rt->rt6i_flags & RTF_EXPIRES &&
225 time_after(jiffies, rt->rt6i_expires));
226}
227
Thomas Grafc71099a2006-08-04 23:20:06 -0700228static inline int rt6_need_strict(struct in6_addr *daddr)
229{
230 return (ipv6_addr_type(daddr) &
231 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL));
232}
233
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234/*
Thomas Grafc71099a2006-08-04 23:20:06 -0700235 * Route lookup. Any table->tb6_lock is implied.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 */
237
238static __inline__ struct rt6_info *rt6_device_match(struct rt6_info *rt,
239 int oif,
240 int strict)
241{
242 struct rt6_info *local = NULL;
243 struct rt6_info *sprt;
244
245 if (oif) {
246 for (sprt = rt; sprt; sprt = sprt->u.next) {
247 struct net_device *dev = sprt->rt6i_dev;
248 if (dev->ifindex == oif)
249 return sprt;
250 if (dev->flags & IFF_LOOPBACK) {
251 if (sprt->rt6i_idev == NULL ||
252 sprt->rt6i_idev->dev->ifindex != oif) {
253 if (strict && oif)
254 continue;
255 if (local && (!oif ||
256 local->rt6i_idev->dev->ifindex == oif))
257 continue;
258 }
259 local = sprt;
260 }
261 }
262
263 if (local)
264 return local;
265
266 if (strict)
267 return &ip6_null_entry;
268 }
269 return rt;
270}
271
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800272#ifdef CONFIG_IPV6_ROUTER_PREF
273static void rt6_probe(struct rt6_info *rt)
274{
275 struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
276 /*
277 * Okay, this does not seem to be appropriate
278 * for now, however, we need to check if it
279 * is really so; aka Router Reachability Probing.
280 *
281 * Router Reachability Probe MUST be rate-limited
282 * to no more than one per minute.
283 */
284 if (!neigh || (neigh->nud_state & NUD_VALID))
285 return;
286 read_lock_bh(&neigh->lock);
287 if (!(neigh->nud_state & NUD_VALID) &&
YOSHIFUJI Hideaki52e16352006-03-20 17:05:47 -0800288 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800289 struct in6_addr mcaddr;
290 struct in6_addr *target;
291
292 neigh->updated = jiffies;
293 read_unlock_bh(&neigh->lock);
294
295 target = (struct in6_addr *)&neigh->primary_key;
296 addrconf_addr_solict_mult(target, &mcaddr);
297 ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
298 } else
299 read_unlock_bh(&neigh->lock);
300}
301#else
302static inline void rt6_probe(struct rt6_info *rt)
303{
304 return;
305}
306#endif
307
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308/*
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800309 * Default Router Selection (RFC 2461 6.3.6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 */
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800311static int inline rt6_check_dev(struct rt6_info *rt, int oif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312{
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800313 struct net_device *dev = rt->rt6i_dev;
314 if (!oif || dev->ifindex == oif)
315 return 2;
316 if ((dev->flags & IFF_LOOPBACK) &&
317 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
318 return 1;
319 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320}
321
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800322static int inline rt6_check_neigh(struct rt6_info *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800324 struct neighbour *neigh = rt->rt6i_nexthop;
325 int m = 0;
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700326 if (rt->rt6i_flags & RTF_NONEXTHOP ||
327 !(rt->rt6i_flags & RTF_GATEWAY))
328 m = 1;
329 else if (neigh) {
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800330 read_lock_bh(&neigh->lock);
331 if (neigh->nud_state & NUD_VALID)
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700332 m = 2;
YOSHIFUJI Hideakiea73ee22006-11-06 09:45:44 -0800333 else if (!(neigh->nud_state & NUD_FAILED))
334 m = 1;
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800335 read_unlock_bh(&neigh->lock);
336 }
337 return m;
338}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800340static int rt6_score_route(struct rt6_info *rt, int oif,
341 int strict)
342{
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700343 int m, n;
344
345 m = rt6_check_dev(rt, oif);
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700346 if (!m && (strict & RT6_LOOKUP_F_IFACE))
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800347 return -1;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -0800348#ifdef CONFIG_IPV6_ROUTER_PREF
349 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
350#endif
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700351 n = rt6_check_neigh(rt);
YOSHIFUJI Hideaki557e92e2006-11-06 09:45:45 -0800352 if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800353 return -1;
354 return m;
355}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800357static struct rt6_info *rt6_select(struct rt6_info **head, int oif,
358 int strict)
359{
360 struct rt6_info *match = NULL, *last = NULL;
361 struct rt6_info *rt, *rt0 = *head;
362 u32 metric;
363 int mpri = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800365 RT6_TRACE("%s(head=%p(*head=%p), oif=%d)\n",
366 __FUNCTION__, head, head ? *head : NULL, oif);
367
368 for (rt = rt0, metric = rt0->rt6i_metric;
YOSHIFUJI Hideakic302e6d2006-04-28 15:59:15 -0700369 rt && rt->rt6i_metric == metric && (!last || rt != rt0);
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800370 rt = rt->u.next) {
371 int m;
372
373 if (rt6_check_expired(rt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 continue;
375
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800376 last = rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800378 m = rt6_score_route(rt, oif, strict);
379 if (m < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800382 if (m > mpri) {
YOSHIFUJI Hideakiea659e02006-11-06 09:45:45 -0800383 if (strict & RT6_LOOKUP_F_REACHABLE)
384 rt6_probe(match);
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800385 match = rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 mpri = m;
YOSHIFUJI Hideakiea659e02006-11-06 09:45:45 -0800387 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800388 rt6_probe(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 }
390 }
391
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800392 if (!match &&
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700393 (strict & RT6_LOOKUP_F_REACHABLE) &&
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800394 last && last != rt0) {
395 /* no entries matched; do round-robin */
Ingo Molnar34af9462006-06-27 02:53:55 -0700396 static DEFINE_SPINLOCK(lock);
YOSHIFUJI Hideakic302e6d2006-04-28 15:59:15 -0700397 spin_lock(&lock);
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800398 *head = rt0->u.next;
399 rt0->u.next = last->u.next;
400 last->u.next = rt0;
YOSHIFUJI Hideakic302e6d2006-04-28 15:59:15 -0700401 spin_unlock(&lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 }
403
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800404 RT6_TRACE("%s() => %p, score=%d\n",
405 __FUNCTION__, match, mpri);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800407 return (match ? match : &ip6_null_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408}
409
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800410#ifdef CONFIG_IPV6_ROUTE_INFO
411int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
412 struct in6_addr *gwaddr)
413{
414 struct route_info *rinfo = (struct route_info *) opt;
415 struct in6_addr prefix_buf, *prefix;
416 unsigned int pref;
417 u32 lifetime;
418 struct rt6_info *rt;
419
420 if (len < sizeof(struct route_info)) {
421 return -EINVAL;
422 }
423
424 /* Sanity check for prefix_len and length */
425 if (rinfo->length > 3) {
426 return -EINVAL;
427 } else if (rinfo->prefix_len > 128) {
428 return -EINVAL;
429 } else if (rinfo->prefix_len > 64) {
430 if (rinfo->length < 2) {
431 return -EINVAL;
432 }
433 } else if (rinfo->prefix_len > 0) {
434 if (rinfo->length < 1) {
435 return -EINVAL;
436 }
437 }
438
439 pref = rinfo->route_pref;
440 if (pref == ICMPV6_ROUTER_PREF_INVALID)
441 pref = ICMPV6_ROUTER_PREF_MEDIUM;
442
Al Viroe69a4ad2006-11-14 20:56:00 -0800443 lifetime = ntohl(rinfo->lifetime);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800444 if (lifetime == 0xffffffff) {
445 /* infinity */
446 } else if (lifetime > 0x7fffffff/HZ) {
447 /* Avoid arithmetic overflow */
448 lifetime = 0x7fffffff/HZ - 1;
449 }
450
451 if (rinfo->length == 3)
452 prefix = (struct in6_addr *)rinfo->prefix;
453 else {
454 /* this function is safe */
455 ipv6_addr_prefix(&prefix_buf,
456 (struct in6_addr *)rinfo->prefix,
457 rinfo->prefix_len);
458 prefix = &prefix_buf;
459 }
460
461 rt = rt6_get_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex);
462
463 if (rt && !lifetime) {
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700464 ip6_del_rt(rt);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800465 rt = NULL;
466 }
467
468 if (!rt && lifetime)
469 rt = rt6_add_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
470 pref);
471 else if (rt)
472 rt->rt6i_flags = RTF_ROUTEINFO |
473 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
474
475 if (rt) {
476 if (lifetime == 0xffffffff) {
477 rt->rt6i_flags &= ~RTF_EXPIRES;
478 } else {
479 rt->rt6i_expires = jiffies + HZ * lifetime;
480 rt->rt6i_flags |= RTF_EXPIRES;
481 }
482 dst_release(&rt->u.dst);
483 }
484 return 0;
485}
486#endif
487
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700488#define BACKTRACK(saddr) \
489do { \
490 if (rt == &ip6_null_entry) { \
491 struct fib6_node *pn; \
Ville Nuorvalae0eda7b2006-10-16 22:11:11 -0700492 while (1) { \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700493 if (fn->fn_flags & RTN_TL_ROOT) \
494 goto out; \
495 pn = fn->parent; \
496 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
497 fn = fib6_lookup(pn->subtree, NULL, saddr); \
498 else \
499 fn = pn; \
500 if (fn->fn_flags & RTN_RTINFO) \
501 goto restart; \
Thomas Grafc71099a2006-08-04 23:20:06 -0700502 } \
Thomas Grafc71099a2006-08-04 23:20:06 -0700503 } \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700504} while(0)
Thomas Grafc71099a2006-08-04 23:20:06 -0700505
506static struct rt6_info *ip6_pol_route_lookup(struct fib6_table *table,
507 struct flowi *fl, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508{
509 struct fib6_node *fn;
510 struct rt6_info *rt;
511
Thomas Grafc71099a2006-08-04 23:20:06 -0700512 read_lock_bh(&table->tb6_lock);
513 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
514restart:
515 rt = fn->leaf;
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700516 rt = rt6_device_match(rt, fl->oif, flags);
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700517 BACKTRACK(&fl->fl6_src);
Thomas Grafc71099a2006-08-04 23:20:06 -0700518out:
YOSHIFUJI Hideaki33cc4892006-08-28 13:19:30 -0700519 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700520 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521
522 rt->u.dst.lastuse = jiffies;
Thomas Grafc71099a2006-08-04 23:20:06 -0700523 rt->u.dst.__use++;
524
525 return rt;
526
527}
528
529struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
530 int oif, int strict)
531{
532 struct flowi fl = {
533 .oif = oif,
534 .nl_u = {
535 .ip6_u = {
536 .daddr = *daddr,
Thomas Grafc71099a2006-08-04 23:20:06 -0700537 },
538 },
539 };
540 struct dst_entry *dst;
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700541 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
Thomas Grafc71099a2006-08-04 23:20:06 -0700542
Thomas Grafadaa70b2006-10-13 15:01:03 -0700543 if (saddr) {
544 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
545 flags |= RT6_LOOKUP_F_HAS_SADDR;
546 }
547
Thomas Grafc71099a2006-08-04 23:20:06 -0700548 dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_lookup);
549 if (dst->error == 0)
550 return (struct rt6_info *) dst;
551
552 dst_release(dst);
553
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 return NULL;
555}
556
Thomas Grafc71099a2006-08-04 23:20:06 -0700557/* ip6_ins_rt is called with FREE table->tb6_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 It takes new route entry, the addition fails by any reason the
559 route is freed. In any case, if caller does not hold it, it may
560 be destroyed.
561 */
562
Thomas Graf86872cb2006-08-22 00:01:08 -0700563static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564{
565 int err;
Thomas Grafc71099a2006-08-04 23:20:06 -0700566 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
Thomas Grafc71099a2006-08-04 23:20:06 -0700568 table = rt->rt6i_table;
569 write_lock_bh(&table->tb6_lock);
Thomas Graf86872cb2006-08-22 00:01:08 -0700570 err = fib6_add(&table->tb6_root, rt, info);
Thomas Grafc71099a2006-08-04 23:20:06 -0700571 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
573 return err;
574}
575
Thomas Graf40e22e82006-08-22 00:00:45 -0700576int ip6_ins_rt(struct rt6_info *rt)
577{
Thomas Graf86872cb2006-08-22 00:01:08 -0700578 return __ip6_ins_rt(rt, NULL);
Thomas Graf40e22e82006-08-22 00:00:45 -0700579}
580
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800581static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
582 struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 struct rt6_info *rt;
585
586 /*
587 * Clone the route.
588 */
589
590 rt = ip6_rt_copy(ort);
591
592 if (rt) {
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900593 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
594 if (rt->rt6i_dst.plen != 128 &&
595 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
596 rt->rt6i_flags |= RTF_ANYCAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900598 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900600 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 rt->rt6i_dst.plen = 128;
602 rt->rt6i_flags |= RTF_CACHE;
603 rt->u.dst.flags |= DST_HOST;
604
605#ifdef CONFIG_IPV6_SUBTREES
606 if (rt->rt6i_src.plen && saddr) {
607 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
608 rt->rt6i_src.plen = 128;
609 }
610#endif
611
612 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
613
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800614 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800616 return rt;
617}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800619static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
620{
621 struct rt6_info *rt = ip6_rt_copy(ort);
622 if (rt) {
623 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
624 rt->rt6i_dst.plen = 128;
625 rt->rt6i_flags |= RTF_CACHE;
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800626 rt->u.dst.flags |= DST_HOST;
627 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
628 }
629 return rt;
630}
631
Adrian Bunk8ce11e62006-08-07 21:50:48 -0700632static struct rt6_info *ip6_pol_route_input(struct fib6_table *table,
633 struct flowi *fl, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634{
635 struct fib6_node *fn;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800636 struct rt6_info *rt, *nrt;
Thomas Grafc71099a2006-08-04 23:20:06 -0700637 int strict = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 int attempts = 3;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800639 int err;
YOSHIFUJI Hideakiea659e02006-11-06 09:45:45 -0800640 int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700642 strict |= flags & RT6_LOOKUP_F_IFACE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
644relookup:
Thomas Grafc71099a2006-08-04 23:20:06 -0700645 read_lock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800647restart_2:
Thomas Grafc71099a2006-08-04 23:20:06 -0700648 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
650restart:
Thomas Grafc71099a2006-08-04 23:20:06 -0700651 rt = rt6_select(&fn->leaf, fl->iif, strict | reachable);
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700652 BACKTRACK(&fl->fl6_src);
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800653 if (rt == &ip6_null_entry ||
654 rt->rt6i_flags & RTF_CACHE)
YOSHIFUJI Hideaki1ddef042006-03-20 17:01:24 -0800655 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
YOSHIFUJI Hideakifb9de912006-03-20 16:59:08 -0800657 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700658 read_unlock_bh(&table->tb6_lock);
YOSHIFUJI Hideakifb9de912006-03-20 16:59:08 -0800659
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800660 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
YOSHIFUJI Hideakie40cf352006-03-20 16:59:27 -0800661 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800662 else {
663#if CLONE_OFFLINK_ROUTE
664 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
665#else
666 goto out2;
667#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 }
YOSHIFUJI Hideakie40cf352006-03-20 16:59:27 -0800669
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800670 dst_release(&rt->u.dst);
671 rt = nrt ? : &ip6_null_entry;
672
673 dst_hold(&rt->u.dst);
674 if (nrt) {
Thomas Graf40e22e82006-08-22 00:00:45 -0700675 err = ip6_ins_rt(nrt);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800676 if (!err)
677 goto out2;
678 }
679
680 if (--attempts <= 0)
681 goto out2;
682
683 /*
Thomas Grafc71099a2006-08-04 23:20:06 -0700684 * Race condition! In the gap, when table->tb6_lock was
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800685 * released someone could insert this route. Relookup.
686 */
687 dst_release(&rt->u.dst);
688 goto relookup;
689
690out:
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800691 if (reachable) {
692 reachable = 0;
693 goto restart_2;
694 }
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800695 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700696 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697out2:
698 rt->u.dst.lastuse = jiffies;
699 rt->u.dst.__use++;
Thomas Grafc71099a2006-08-04 23:20:06 -0700700
701 return rt;
702}
703
704void ip6_route_input(struct sk_buff *skb)
705{
706 struct ipv6hdr *iph = skb->nh.ipv6h;
Thomas Grafadaa70b2006-10-13 15:01:03 -0700707 int flags = RT6_LOOKUP_F_HAS_SADDR;
Thomas Grafc71099a2006-08-04 23:20:06 -0700708 struct flowi fl = {
709 .iif = skb->dev->ifindex,
710 .nl_u = {
711 .ip6_u = {
712 .daddr = iph->daddr,
713 .saddr = iph->saddr,
Al Viro90bcaf72006-11-08 00:25:17 -0800714 .flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
Thomas Grafc71099a2006-08-04 23:20:06 -0700715 },
716 },
Thomas Graf47dcf0c2006-11-09 15:20:38 -0800717 .mark = skb->mark,
Thomas Grafc71099a2006-08-04 23:20:06 -0700718 .proto = iph->nexthdr,
719 };
Thomas Grafadaa70b2006-10-13 15:01:03 -0700720
721 if (rt6_need_strict(&iph->daddr))
722 flags |= RT6_LOOKUP_F_IFACE;
Thomas Grafc71099a2006-08-04 23:20:06 -0700723
724 skb->dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_input);
725}
726
727static struct rt6_info *ip6_pol_route_output(struct fib6_table *table,
728 struct flowi *fl, int flags)
729{
730 struct fib6_node *fn;
731 struct rt6_info *rt, *nrt;
732 int strict = 0;
733 int attempts = 3;
734 int err;
YOSHIFUJI Hideakiea659e02006-11-06 09:45:45 -0800735 int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
Thomas Grafc71099a2006-08-04 23:20:06 -0700736
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700737 strict |= flags & RT6_LOOKUP_F_IFACE;
Thomas Grafc71099a2006-08-04 23:20:06 -0700738
739relookup:
740 read_lock_bh(&table->tb6_lock);
741
742restart_2:
743 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
744
745restart:
746 rt = rt6_select(&fn->leaf, fl->oif, strict | reachable);
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700747 BACKTRACK(&fl->fl6_src);
Thomas Grafc71099a2006-08-04 23:20:06 -0700748 if (rt == &ip6_null_entry ||
749 rt->rt6i_flags & RTF_CACHE)
750 goto out;
751
752 dst_hold(&rt->u.dst);
753 read_unlock_bh(&table->tb6_lock);
754
755 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
756 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
757 else {
758#if CLONE_OFFLINK_ROUTE
759 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
760#else
761 goto out2;
762#endif
763 }
764
765 dst_release(&rt->u.dst);
766 rt = nrt ? : &ip6_null_entry;
767
768 dst_hold(&rt->u.dst);
769 if (nrt) {
Thomas Graf40e22e82006-08-22 00:00:45 -0700770 err = ip6_ins_rt(nrt);
Thomas Grafc71099a2006-08-04 23:20:06 -0700771 if (!err)
772 goto out2;
773 }
774
775 if (--attempts <= 0)
776 goto out2;
777
778 /*
779 * Race condition! In the gap, when table->tb6_lock was
780 * released someone could insert this route. Relookup.
781 */
782 dst_release(&rt->u.dst);
783 goto relookup;
784
785out:
786 if (reachable) {
787 reachable = 0;
788 goto restart_2;
789 }
790 dst_hold(&rt->u.dst);
791 read_unlock_bh(&table->tb6_lock);
792out2:
793 rt->u.dst.lastuse = jiffies;
794 rt->u.dst.__use++;
795 return rt;
796}
797
798struct dst_entry * ip6_route_output(struct sock *sk, struct flowi *fl)
799{
800 int flags = 0;
801
802 if (rt6_need_strict(&fl->fl6_dst))
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700803 flags |= RT6_LOOKUP_F_IFACE;
Thomas Grafc71099a2006-08-04 23:20:06 -0700804
Thomas Grafadaa70b2006-10-13 15:01:03 -0700805 if (!ipv6_addr_any(&fl->fl6_src))
806 flags |= RT6_LOOKUP_F_HAS_SADDR;
807
Thomas Grafc71099a2006-08-04 23:20:06 -0700808 return fib6_rule_lookup(fl, flags, ip6_pol_route_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809}
810
811
812/*
813 * Destination cache support functions
814 */
815
816static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
817{
818 struct rt6_info *rt;
819
820 rt = (struct rt6_info *) dst;
821
822 if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
823 return dst;
824
825 return NULL;
826}
827
828static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
829{
830 struct rt6_info *rt = (struct rt6_info *) dst;
831
832 if (rt) {
833 if (rt->rt6i_flags & RTF_CACHE)
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700834 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 else
836 dst_release(dst);
837 }
838 return NULL;
839}
840
841static void ip6_link_failure(struct sk_buff *skb)
842{
843 struct rt6_info *rt;
844
845 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
846
847 rt = (struct rt6_info *) skb->dst;
848 if (rt) {
849 if (rt->rt6i_flags&RTF_CACHE) {
850 dst_set_expires(&rt->u.dst, 0);
851 rt->rt6i_flags |= RTF_EXPIRES;
852 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
853 rt->rt6i_node->fn_sernum = -1;
854 }
855}
856
857static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
858{
859 struct rt6_info *rt6 = (struct rt6_info*)dst;
860
861 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
862 rt6->rt6i_flags |= RTF_MODIFIED;
863 if (mtu < IPV6_MIN_MTU) {
864 mtu = IPV6_MIN_MTU;
865 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
866 }
867 dst->metrics[RTAX_MTU-1] = mtu;
Tom Tucker8d717402006-07-30 20:43:36 -0700868 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 }
870}
871
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872static int ipv6_get_mtu(struct net_device *dev);
873
874static inline unsigned int ipv6_advmss(unsigned int mtu)
875{
876 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
877
878 if (mtu < ip6_rt_min_advmss)
879 mtu = ip6_rt_min_advmss;
880
881 /*
882 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
883 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
884 * IPV6_MAXPLEN is also valid and means: "any MSS,
885 * rely only on pmtu discovery"
886 */
887 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
888 mtu = IPV6_MAXPLEN;
889 return mtu;
890}
891
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700892static struct dst_entry *ndisc_dst_gc_list;
Adrian Bunk8ce11e62006-08-07 21:50:48 -0700893static DEFINE_SPINLOCK(ndisc_lock);
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700894
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895struct dst_entry *ndisc_dst_alloc(struct net_device *dev,
896 struct neighbour *neigh,
897 struct in6_addr *addr,
898 int (*output)(struct sk_buff *))
899{
900 struct rt6_info *rt;
901 struct inet6_dev *idev = in6_dev_get(dev);
902
903 if (unlikely(idev == NULL))
904 return NULL;
905
906 rt = ip6_dst_alloc();
907 if (unlikely(rt == NULL)) {
908 in6_dev_put(idev);
909 goto out;
910 }
911
912 dev_hold(dev);
913 if (neigh)
914 neigh_hold(neigh);
915 else
916 neigh = ndisc_get_neigh(dev, addr);
917
918 rt->rt6i_dev = dev;
919 rt->rt6i_idev = idev;
920 rt->rt6i_nexthop = neigh;
921 atomic_set(&rt->u.dst.__refcnt, 1);
922 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
923 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
924 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
925 rt->u.dst.output = output;
926
927#if 0 /* there's no chance to use these for ndisc */
928 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
929 ? DST_HOST
930 : 0;
931 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
932 rt->rt6i_dst.plen = 128;
933#endif
934
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700935 spin_lock_bh(&ndisc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 rt->u.dst.next = ndisc_dst_gc_list;
937 ndisc_dst_gc_list = &rt->u.dst;
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700938 spin_unlock_bh(&ndisc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939
940 fib6_force_start_gc();
941
942out:
YOSHIFUJI Hideaki40aa7b92006-10-19 13:50:09 +0900943 return &rt->u.dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944}
945
946int ndisc_dst_gc(int *more)
947{
948 struct dst_entry *dst, *next, **pprev;
949 int freed;
950
951 next = NULL;
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700952 freed = 0;
953
954 spin_lock_bh(&ndisc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 pprev = &ndisc_dst_gc_list;
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700956
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 while ((dst = *pprev) != NULL) {
958 if (!atomic_read(&dst->__refcnt)) {
959 *pprev = dst->next;
960 dst_free(dst);
961 freed++;
962 } else {
963 pprev = &dst->next;
964 (*more)++;
965 }
966 }
967
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700968 spin_unlock_bh(&ndisc_lock);
969
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 return freed;
971}
972
973static int ip6_dst_gc(void)
974{
975 static unsigned expire = 30*HZ;
976 static unsigned long last_gc;
977 unsigned long now = jiffies;
978
979 if (time_after(last_gc + ip6_rt_gc_min_interval, now) &&
980 atomic_read(&ip6_dst_ops.entries) <= ip6_rt_max_size)
981 goto out;
982
983 expire++;
984 fib6_run_gc(expire);
985 last_gc = now;
986 if (atomic_read(&ip6_dst_ops.entries) < ip6_dst_ops.gc_thresh)
987 expire = ip6_rt_gc_timeout>>1;
988
989out:
990 expire -= expire>>ip6_rt_gc_elasticity;
991 return (atomic_read(&ip6_dst_ops.entries) > ip6_rt_max_size);
992}
993
994/* Clean host part of a prefix. Not necessary in radix tree,
995 but results in cleaner routing tables.
996
997 Remove it only when all the things will work!
998 */
999
1000static int ipv6_get_mtu(struct net_device *dev)
1001{
1002 int mtu = IPV6_MIN_MTU;
1003 struct inet6_dev *idev;
1004
1005 idev = in6_dev_get(dev);
1006 if (idev) {
1007 mtu = idev->cnf.mtu6;
1008 in6_dev_put(idev);
1009 }
1010 return mtu;
1011}
1012
1013int ipv6_get_hoplimit(struct net_device *dev)
1014{
1015 int hoplimit = ipv6_devconf.hop_limit;
1016 struct inet6_dev *idev;
1017
1018 idev = in6_dev_get(dev);
1019 if (idev) {
1020 hoplimit = idev->cnf.hop_limit;
1021 in6_dev_put(idev);
1022 }
1023 return hoplimit;
1024}
1025
1026/*
1027 *
1028 */
1029
Thomas Graf86872cb2006-08-22 00:01:08 -07001030int ip6_route_add(struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031{
1032 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 struct rt6_info *rt = NULL;
1034 struct net_device *dev = NULL;
1035 struct inet6_dev *idev = NULL;
Thomas Grafc71099a2006-08-04 23:20:06 -07001036 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 int addr_type;
1038
Thomas Graf86872cb2006-08-22 00:01:08 -07001039 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 return -EINVAL;
1041#ifndef CONFIG_IPV6_SUBTREES
Thomas Graf86872cb2006-08-22 00:01:08 -07001042 if (cfg->fc_src_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 return -EINVAL;
1044#endif
Thomas Graf86872cb2006-08-22 00:01:08 -07001045 if (cfg->fc_ifindex) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 err = -ENODEV;
Thomas Graf86872cb2006-08-22 00:01:08 -07001047 dev = dev_get_by_index(cfg->fc_ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 if (!dev)
1049 goto out;
1050 idev = in6_dev_get(dev);
1051 if (!idev)
1052 goto out;
1053 }
1054
Thomas Graf86872cb2006-08-22 00:01:08 -07001055 if (cfg->fc_metric == 0)
1056 cfg->fc_metric = IP6_RT_PRIO_USER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
Thomas Graf86872cb2006-08-22 00:01:08 -07001058 table = fib6_new_table(cfg->fc_table);
Thomas Grafc71099a2006-08-04 23:20:06 -07001059 if (table == NULL) {
1060 err = -ENOBUFS;
1061 goto out;
1062 }
1063
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 rt = ip6_dst_alloc();
1065
1066 if (rt == NULL) {
1067 err = -ENOMEM;
1068 goto out;
1069 }
1070
1071 rt->u.dst.obsolete = -1;
Thomas Graf86872cb2006-08-22 00:01:08 -07001072 rt->rt6i_expires = jiffies + clock_t_to_jiffies(cfg->fc_expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073
Thomas Graf86872cb2006-08-22 00:01:08 -07001074 if (cfg->fc_protocol == RTPROT_UNSPEC)
1075 cfg->fc_protocol = RTPROT_BOOT;
1076 rt->rt6i_protocol = cfg->fc_protocol;
1077
1078 addr_type = ipv6_addr_type(&cfg->fc_dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
1080 if (addr_type & IPV6_ADDR_MULTICAST)
1081 rt->u.dst.input = ip6_mc_input;
1082 else
1083 rt->u.dst.input = ip6_forward;
1084
1085 rt->u.dst.output = ip6_output;
1086
Thomas Graf86872cb2006-08-22 00:01:08 -07001087 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1088 rt->rt6i_dst.plen = cfg->fc_dst_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 if (rt->rt6i_dst.plen == 128)
1090 rt->u.dst.flags = DST_HOST;
1091
1092#ifdef CONFIG_IPV6_SUBTREES
Thomas Graf86872cb2006-08-22 00:01:08 -07001093 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1094 rt->rt6i_src.plen = cfg->fc_src_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095#endif
1096
Thomas Graf86872cb2006-08-22 00:01:08 -07001097 rt->rt6i_metric = cfg->fc_metric;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098
1099 /* We cannot add true routes via loopback here,
1100 they would result in kernel looping; promote them to reject routes
1101 */
Thomas Graf86872cb2006-08-22 00:01:08 -07001102 if ((cfg->fc_flags & RTF_REJECT) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
1104 /* hold loopback dev/idev if we haven't done so. */
1105 if (dev != &loopback_dev) {
1106 if (dev) {
1107 dev_put(dev);
1108 in6_dev_put(idev);
1109 }
1110 dev = &loopback_dev;
1111 dev_hold(dev);
1112 idev = in6_dev_get(dev);
1113 if (!idev) {
1114 err = -ENODEV;
1115 goto out;
1116 }
1117 }
1118 rt->u.dst.output = ip6_pkt_discard_out;
1119 rt->u.dst.input = ip6_pkt_discard;
1120 rt->u.dst.error = -ENETUNREACH;
1121 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1122 goto install_route;
1123 }
1124
Thomas Graf86872cb2006-08-22 00:01:08 -07001125 if (cfg->fc_flags & RTF_GATEWAY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 struct in6_addr *gw_addr;
1127 int gwa_type;
1128
Thomas Graf86872cb2006-08-22 00:01:08 -07001129 gw_addr = &cfg->fc_gateway;
1130 ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 gwa_type = ipv6_addr_type(gw_addr);
1132
1133 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1134 struct rt6_info *grt;
1135
1136 /* IPv6 strictly inhibits using not link-local
1137 addresses as nexthop address.
1138 Otherwise, router will not able to send redirects.
1139 It is very good, but in some (rare!) circumstances
1140 (SIT, PtP, NBMA NOARP links) it is handy to allow
1141 some exceptions. --ANK
1142 */
1143 err = -EINVAL;
1144 if (!(gwa_type&IPV6_ADDR_UNICAST))
1145 goto out;
1146
Thomas Graf86872cb2006-08-22 00:01:08 -07001147 grt = rt6_lookup(gw_addr, NULL, cfg->fc_ifindex, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
1149 err = -EHOSTUNREACH;
1150 if (grt == NULL)
1151 goto out;
1152 if (dev) {
1153 if (dev != grt->rt6i_dev) {
1154 dst_release(&grt->u.dst);
1155 goto out;
1156 }
1157 } else {
1158 dev = grt->rt6i_dev;
1159 idev = grt->rt6i_idev;
1160 dev_hold(dev);
1161 in6_dev_hold(grt->rt6i_idev);
1162 }
1163 if (!(grt->rt6i_flags&RTF_GATEWAY))
1164 err = 0;
1165 dst_release(&grt->u.dst);
1166
1167 if (err)
1168 goto out;
1169 }
1170 err = -EINVAL;
1171 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
1172 goto out;
1173 }
1174
1175 err = -ENODEV;
1176 if (dev == NULL)
1177 goto out;
1178
Thomas Graf86872cb2006-08-22 00:01:08 -07001179 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
1181 if (IS_ERR(rt->rt6i_nexthop)) {
1182 err = PTR_ERR(rt->rt6i_nexthop);
1183 rt->rt6i_nexthop = NULL;
1184 goto out;
1185 }
1186 }
1187
Thomas Graf86872cb2006-08-22 00:01:08 -07001188 rt->rt6i_flags = cfg->fc_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
1190install_route:
Thomas Graf86872cb2006-08-22 00:01:08 -07001191 if (cfg->fc_mx) {
1192 struct nlattr *nla;
1193 int remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194
Thomas Graf86872cb2006-08-22 00:01:08 -07001195 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1196 int type = nla->nla_type;
1197
1198 if (type) {
1199 if (type > RTAX_MAX) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 err = -EINVAL;
1201 goto out;
1202 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001203
1204 rt->u.dst.metrics[type - 1] = nla_get_u32(nla);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 }
1207 }
1208
1209 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
1210 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1211 if (!rt->u.dst.metrics[RTAX_MTU-1])
1212 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
1213 if (!rt->u.dst.metrics[RTAX_ADVMSS-1])
1214 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1215 rt->u.dst.dev = dev;
1216 rt->rt6i_idev = idev;
Thomas Grafc71099a2006-08-04 23:20:06 -07001217 rt->rt6i_table = table;
Thomas Graf86872cb2006-08-22 00:01:08 -07001218 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219
1220out:
1221 if (dev)
1222 dev_put(dev);
1223 if (idev)
1224 in6_dev_put(idev);
1225 if (rt)
YOSHIFUJI Hideaki40aa7b92006-10-19 13:50:09 +09001226 dst_free(&rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 return err;
1228}
1229
Thomas Graf86872cb2006-08-22 00:01:08 -07001230static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231{
1232 int err;
Thomas Grafc71099a2006-08-04 23:20:06 -07001233 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234
Patrick McHardy6c813a72006-08-06 22:22:47 -07001235 if (rt == &ip6_null_entry)
1236 return -ENOENT;
1237
Thomas Grafc71099a2006-08-04 23:20:06 -07001238 table = rt->rt6i_table;
1239 write_lock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240
Thomas Graf86872cb2006-08-22 00:01:08 -07001241 err = fib6_del(rt, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 dst_release(&rt->u.dst);
1243
Thomas Grafc71099a2006-08-04 23:20:06 -07001244 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
1246 return err;
1247}
1248
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001249int ip6_del_rt(struct rt6_info *rt)
1250{
Thomas Graf86872cb2006-08-22 00:01:08 -07001251 return __ip6_del_rt(rt, NULL);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001252}
1253
Thomas Graf86872cb2006-08-22 00:01:08 -07001254static int ip6_route_del(struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255{
Thomas Grafc71099a2006-08-04 23:20:06 -07001256 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 struct fib6_node *fn;
1258 struct rt6_info *rt;
1259 int err = -ESRCH;
1260
Thomas Graf86872cb2006-08-22 00:01:08 -07001261 table = fib6_get_table(cfg->fc_table);
Thomas Grafc71099a2006-08-04 23:20:06 -07001262 if (table == NULL)
1263 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264
Thomas Grafc71099a2006-08-04 23:20:06 -07001265 read_lock_bh(&table->tb6_lock);
1266
1267 fn = fib6_locate(&table->tb6_root,
Thomas Graf86872cb2006-08-22 00:01:08 -07001268 &cfg->fc_dst, cfg->fc_dst_len,
1269 &cfg->fc_src, cfg->fc_src_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
1271 if (fn) {
1272 for (rt = fn->leaf; rt; rt = rt->u.next) {
Thomas Graf86872cb2006-08-22 00:01:08 -07001273 if (cfg->fc_ifindex &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 (rt->rt6i_dev == NULL ||
Thomas Graf86872cb2006-08-22 00:01:08 -07001275 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 continue;
Thomas Graf86872cb2006-08-22 00:01:08 -07001277 if (cfg->fc_flags & RTF_GATEWAY &&
1278 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 continue;
Thomas Graf86872cb2006-08-22 00:01:08 -07001280 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 continue;
1282 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001283 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284
Thomas Graf86872cb2006-08-22 00:01:08 -07001285 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 }
1287 }
Thomas Grafc71099a2006-08-04 23:20:06 -07001288 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289
1290 return err;
1291}
1292
1293/*
1294 * Handle redirects
1295 */
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001296struct ip6rd_flowi {
1297 struct flowi fl;
1298 struct in6_addr gateway;
1299};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001301static struct rt6_info *__ip6_route_redirect(struct fib6_table *table,
1302 struct flowi *fl,
1303 int flags)
1304{
1305 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1306 struct rt6_info *rt;
1307 struct fib6_node *fn;
Thomas Grafc71099a2006-08-04 23:20:06 -07001308
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 /*
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001310 * Get the "current" route for this destination and
1311 * check if the redirect has come from approriate router.
1312 *
1313 * RFC 2461 specifies that redirects should only be
1314 * accepted if they come from the nexthop to the target.
1315 * Due to the way the routes are chosen, this notion
1316 * is a bit fuzzy and one might need to check all possible
1317 * routes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
Thomas Grafc71099a2006-08-04 23:20:06 -07001320 read_lock_bh(&table->tb6_lock);
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001321 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001322restart:
1323 for (rt = fn->leaf; rt; rt = rt->u.next) {
1324 /*
1325 * Current route is on-link; redirect is always invalid.
1326 *
1327 * Seems, previous statement is not true. It could
1328 * be node, which looks for us as on-link (f.e. proxy ndisc)
1329 * But then router serving it might decide, that we should
1330 * know truth 8)8) --ANK (980726).
1331 */
1332 if (rt6_check_expired(rt))
1333 continue;
1334 if (!(rt->rt6i_flags & RTF_GATEWAY))
1335 continue;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001336 if (fl->oif != rt->rt6i_dev->ifindex)
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001337 continue;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001338 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001339 continue;
1340 break;
1341 }
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001342
YOSHIFUJI Hideakicb15d9c2006-08-23 17:23:11 -07001343 if (!rt)
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001344 rt = &ip6_null_entry;
YOSHIFUJI Hideakicb15d9c2006-08-23 17:23:11 -07001345 BACKTRACK(&fl->fl6_src);
1346out:
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001347 dst_hold(&rt->u.dst);
1348
1349 read_unlock_bh(&table->tb6_lock);
1350
1351 return rt;
1352};
1353
1354static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1355 struct in6_addr *src,
1356 struct in6_addr *gateway,
1357 struct net_device *dev)
1358{
Thomas Grafadaa70b2006-10-13 15:01:03 -07001359 int flags = RT6_LOOKUP_F_HAS_SADDR;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001360 struct ip6rd_flowi rdfl = {
1361 .fl = {
1362 .oif = dev->ifindex,
1363 .nl_u = {
1364 .ip6_u = {
1365 .daddr = *dest,
1366 .saddr = *src,
1367 },
1368 },
1369 },
1370 .gateway = *gateway,
1371 };
Thomas Grafadaa70b2006-10-13 15:01:03 -07001372
1373 if (rt6_need_strict(dest))
1374 flags |= RT6_LOOKUP_F_IFACE;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001375
1376 return (struct rt6_info *)fib6_rule_lookup((struct flowi *)&rdfl, flags, __ip6_route_redirect);
1377}
1378
1379void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1380 struct in6_addr *saddr,
1381 struct neighbour *neigh, u8 *lladdr, int on_link)
1382{
1383 struct rt6_info *rt, *nrt = NULL;
1384 struct netevent_redirect netevent;
1385
1386 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1387
1388 if (rt == &ip6_null_entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 if (net_ratelimit())
1390 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1391 "for redirect target\n");
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001392 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 }
1394
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 /*
1396 * We have finally decided to accept it.
1397 */
1398
1399 neigh_update(neigh, lladdr, NUD_STALE,
1400 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1401 NEIGH_UPDATE_F_OVERRIDE|
1402 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1403 NEIGH_UPDATE_F_ISROUTER))
1404 );
1405
1406 /*
1407 * Redirect received -> path was valid.
1408 * Look, redirects are sent only in response to data packets,
1409 * so that this nexthop apparently is reachable. --ANK
1410 */
1411 dst_confirm(&rt->u.dst);
1412
1413 /* Duplicate redirect: silently ignore. */
1414 if (neigh == rt->u.dst.neighbour)
1415 goto out;
1416
1417 nrt = ip6_rt_copy(rt);
1418 if (nrt == NULL)
1419 goto out;
1420
1421 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1422 if (on_link)
1423 nrt->rt6i_flags &= ~RTF_GATEWAY;
1424
1425 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1426 nrt->rt6i_dst.plen = 128;
1427 nrt->u.dst.flags |= DST_HOST;
1428
1429 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1430 nrt->rt6i_nexthop = neigh_clone(neigh);
1431 /* Reset pmtu, it may be better */
1432 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1433 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1434
Thomas Graf40e22e82006-08-22 00:00:45 -07001435 if (ip6_ins_rt(nrt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 goto out;
1437
Tom Tucker8d717402006-07-30 20:43:36 -07001438 netevent.old = &rt->u.dst;
1439 netevent.new = &nrt->u.dst;
1440 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1441
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 if (rt->rt6i_flags&RTF_CACHE) {
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001443 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 return;
1445 }
1446
1447out:
1448 dst_release(&rt->u.dst);
1449 return;
1450}
1451
1452/*
1453 * Handle ICMP "packet too big" messages
1454 * i.e. Path MTU discovery
1455 */
1456
1457void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1458 struct net_device *dev, u32 pmtu)
1459{
1460 struct rt6_info *rt, *nrt;
1461 int allfrag = 0;
1462
1463 rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1464 if (rt == NULL)
1465 return;
1466
1467 if (pmtu >= dst_mtu(&rt->u.dst))
1468 goto out;
1469
1470 if (pmtu < IPV6_MIN_MTU) {
1471 /*
1472 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1473 * MTU (1280) and a fragment header should always be included
1474 * after a node receiving Too Big message reporting PMTU is
1475 * less than the IPv6 Minimum Link MTU.
1476 */
1477 pmtu = IPV6_MIN_MTU;
1478 allfrag = 1;
1479 }
1480
1481 /* New mtu received -> path was valid.
1482 They are sent only in response to data packets,
1483 so that this nexthop apparently is reachable. --ANK
1484 */
1485 dst_confirm(&rt->u.dst);
1486
1487 /* Host route. If it is static, it would be better
1488 not to override it, but add new one, so that
1489 when cache entry will expire old pmtu
1490 would return automatically.
1491 */
1492 if (rt->rt6i_flags & RTF_CACHE) {
1493 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1494 if (allfrag)
1495 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1496 dst_set_expires(&rt->u.dst, ip6_rt_mtu_expires);
1497 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1498 goto out;
1499 }
1500
1501 /* Network route.
1502 Two cases are possible:
1503 1. It is connected route. Action: COW
1504 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1505 */
YOSHIFUJI Hideakid5315b52006-03-20 16:58:48 -08001506 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001507 nrt = rt6_alloc_cow(rt, daddr, saddr);
YOSHIFUJI Hideakid5315b52006-03-20 16:58:48 -08001508 else
1509 nrt = rt6_alloc_clone(rt, daddr);
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001510
YOSHIFUJI Hideakid5315b52006-03-20 16:58:48 -08001511 if (nrt) {
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001512 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1513 if (allfrag)
1514 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1515
1516 /* According to RFC 1981, detecting PMTU increase shouldn't be
1517 * happened within 5 mins, the recommended timer is 10 mins.
1518 * Here this route expiration time is set to ip6_rt_mtu_expires
1519 * which is 10 mins. After 10 mins the decreased pmtu is expired
1520 * and detecting PMTU increase will be automatically happened.
1521 */
1522 dst_set_expires(&nrt->u.dst, ip6_rt_mtu_expires);
1523 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1524
Thomas Graf40e22e82006-08-22 00:00:45 -07001525 ip6_ins_rt(nrt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527out:
1528 dst_release(&rt->u.dst);
1529}
1530
1531/*
1532 * Misc support functions
1533 */
1534
1535static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1536{
1537 struct rt6_info *rt = ip6_dst_alloc();
1538
1539 if (rt) {
1540 rt->u.dst.input = ort->u.dst.input;
1541 rt->u.dst.output = ort->u.dst.output;
1542
1543 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
Ville Nuorvala22e1e4d2006-10-16 22:14:26 -07001544 rt->u.dst.error = ort->u.dst.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 rt->u.dst.dev = ort->u.dst.dev;
1546 if (rt->u.dst.dev)
1547 dev_hold(rt->u.dst.dev);
1548 rt->rt6i_idev = ort->rt6i_idev;
1549 if (rt->rt6i_idev)
1550 in6_dev_hold(rt->rt6i_idev);
1551 rt->u.dst.lastuse = jiffies;
1552 rt->rt6i_expires = 0;
1553
1554 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1555 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1556 rt->rt6i_metric = 0;
1557
1558 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1559#ifdef CONFIG_IPV6_SUBTREES
1560 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1561#endif
Thomas Grafc71099a2006-08-04 23:20:06 -07001562 rt->rt6i_table = ort->rt6i_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 }
1564 return rt;
1565}
1566
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001567#ifdef CONFIG_IPV6_ROUTE_INFO
1568static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
1569 struct in6_addr *gwaddr, int ifindex)
1570{
1571 struct fib6_node *fn;
1572 struct rt6_info *rt = NULL;
Thomas Grafc71099a2006-08-04 23:20:06 -07001573 struct fib6_table *table;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001574
Thomas Grafc71099a2006-08-04 23:20:06 -07001575 table = fib6_get_table(RT6_TABLE_INFO);
1576 if (table == NULL)
1577 return NULL;
1578
1579 write_lock_bh(&table->tb6_lock);
1580 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001581 if (!fn)
1582 goto out;
1583
1584 for (rt = fn->leaf; rt; rt = rt->u.next) {
1585 if (rt->rt6i_dev->ifindex != ifindex)
1586 continue;
1587 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1588 continue;
1589 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1590 continue;
1591 dst_hold(&rt->u.dst);
1592 break;
1593 }
1594out:
Thomas Grafc71099a2006-08-04 23:20:06 -07001595 write_unlock_bh(&table->tb6_lock);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001596 return rt;
1597}
1598
1599static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
1600 struct in6_addr *gwaddr, int ifindex,
1601 unsigned pref)
1602{
Thomas Graf86872cb2006-08-22 00:01:08 -07001603 struct fib6_config cfg = {
1604 .fc_table = RT6_TABLE_INFO,
1605 .fc_metric = 1024,
1606 .fc_ifindex = ifindex,
1607 .fc_dst_len = prefixlen,
1608 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1609 RTF_UP | RTF_PREF(pref),
1610 };
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001611
Thomas Graf86872cb2006-08-22 00:01:08 -07001612 ipv6_addr_copy(&cfg.fc_dst, prefix);
1613 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1614
YOSHIFUJI Hideakie317da92006-03-20 17:06:42 -08001615 /* We should treat it as a default route if prefix length is 0. */
1616 if (!prefixlen)
Thomas Graf86872cb2006-08-22 00:01:08 -07001617 cfg.fc_flags |= RTF_DEFAULT;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001618
Thomas Graf86872cb2006-08-22 00:01:08 -07001619 ip6_route_add(&cfg);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001620
1621 return rt6_get_route_info(prefix, prefixlen, gwaddr, ifindex);
1622}
1623#endif
1624
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1626{
1627 struct rt6_info *rt;
Thomas Grafc71099a2006-08-04 23:20:06 -07001628 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629
Thomas Grafc71099a2006-08-04 23:20:06 -07001630 table = fib6_get_table(RT6_TABLE_DFLT);
1631 if (table == NULL)
1632 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633
Thomas Grafc71099a2006-08-04 23:20:06 -07001634 write_lock_bh(&table->tb6_lock);
1635 for (rt = table->tb6_root.leaf; rt; rt=rt->u.next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 if (dev == rt->rt6i_dev &&
YOSHIFUJI Hideaki045927f2006-03-20 17:00:48 -08001637 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1639 break;
1640 }
1641 if (rt)
1642 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001643 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 return rt;
1645}
1646
1647struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001648 struct net_device *dev,
1649 unsigned int pref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650{
Thomas Graf86872cb2006-08-22 00:01:08 -07001651 struct fib6_config cfg = {
1652 .fc_table = RT6_TABLE_DFLT,
1653 .fc_metric = 1024,
1654 .fc_ifindex = dev->ifindex,
1655 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1656 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1657 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658
Thomas Graf86872cb2006-08-22 00:01:08 -07001659 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
Thomas Graf86872cb2006-08-22 00:01:08 -07001661 ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 return rt6_get_dflt_router(gwaddr, dev);
1664}
1665
1666void rt6_purge_dflt_routers(void)
1667{
1668 struct rt6_info *rt;
Thomas Grafc71099a2006-08-04 23:20:06 -07001669 struct fib6_table *table;
1670
1671 /* NOTE: Keep consistent with rt6_get_dflt_router */
1672 table = fib6_get_table(RT6_TABLE_DFLT);
1673 if (table == NULL)
1674 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675
1676restart:
Thomas Grafc71099a2006-08-04 23:20:06 -07001677 read_lock_bh(&table->tb6_lock);
1678 for (rt = table->tb6_root.leaf; rt; rt = rt->u.next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1680 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001681 read_unlock_bh(&table->tb6_lock);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001682 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 goto restart;
1684 }
1685 }
Thomas Grafc71099a2006-08-04 23:20:06 -07001686 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687}
1688
Thomas Graf86872cb2006-08-22 00:01:08 -07001689static void rtmsg_to_fib6_config(struct in6_rtmsg *rtmsg,
1690 struct fib6_config *cfg)
1691{
1692 memset(cfg, 0, sizeof(*cfg));
1693
1694 cfg->fc_table = RT6_TABLE_MAIN;
1695 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1696 cfg->fc_metric = rtmsg->rtmsg_metric;
1697 cfg->fc_expires = rtmsg->rtmsg_info;
1698 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1699 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1700 cfg->fc_flags = rtmsg->rtmsg_flags;
1701
1702 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1703 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1704 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1705}
1706
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1708{
Thomas Graf86872cb2006-08-22 00:01:08 -07001709 struct fib6_config cfg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 struct in6_rtmsg rtmsg;
1711 int err;
1712
1713 switch(cmd) {
1714 case SIOCADDRT: /* Add a route */
1715 case SIOCDELRT: /* Delete a route */
1716 if (!capable(CAP_NET_ADMIN))
1717 return -EPERM;
1718 err = copy_from_user(&rtmsg, arg,
1719 sizeof(struct in6_rtmsg));
1720 if (err)
1721 return -EFAULT;
Thomas Graf86872cb2006-08-22 00:01:08 -07001722
1723 rtmsg_to_fib6_config(&rtmsg, &cfg);
1724
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 rtnl_lock();
1726 switch (cmd) {
1727 case SIOCADDRT:
Thomas Graf86872cb2006-08-22 00:01:08 -07001728 err = ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 break;
1730 case SIOCDELRT:
Thomas Graf86872cb2006-08-22 00:01:08 -07001731 err = ip6_route_del(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 break;
1733 default:
1734 err = -EINVAL;
1735 }
1736 rtnl_unlock();
1737
1738 return err;
1739 };
1740
1741 return -EINVAL;
1742}
1743
1744/*
1745 * Drop the packet on the floor
1746 */
1747
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001748static inline int ip6_pkt_drop(struct sk_buff *skb, int code)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749{
Lv Liangying76d0cc12006-08-29 00:00:47 -07001750 int type = ipv6_addr_type(&skb->nh.ipv6h->daddr);
1751 if (type == IPV6_ADDR_ANY || type == IPV6_ADDR_RESERVED)
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +09001752 IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
Lv Liangying76d0cc12006-08-29 00:00:47 -07001753
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +09001754 IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_OUTNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001755 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 kfree_skb(skb);
1757 return 0;
1758}
1759
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001760static int ip6_pkt_discard(struct sk_buff *skb)
1761{
1762 return ip6_pkt_drop(skb, ICMPV6_NOROUTE);
1763}
1764
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001765static int ip6_pkt_discard_out(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766{
1767 skb->dev = skb->dst->dev;
1768 return ip6_pkt_discard(skb);
1769}
1770
David S. Miller6723ab52006-10-18 21:20:57 -07001771#ifdef CONFIG_IPV6_MULTIPLE_TABLES
1772
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001773static int ip6_pkt_prohibit(struct sk_buff *skb)
1774{
1775 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED);
1776}
1777
1778static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1779{
1780 skb->dev = skb->dst->dev;
1781 return ip6_pkt_prohibit(skb);
1782}
1783
1784static int ip6_pkt_blk_hole(struct sk_buff *skb)
1785{
1786 kfree_skb(skb);
1787 return 0;
1788}
1789
David S. Miller6723ab52006-10-18 21:20:57 -07001790#endif
1791
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792/*
1793 * Allocate a dst for local (unicast / anycast) address.
1794 */
1795
1796struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1797 const struct in6_addr *addr,
1798 int anycast)
1799{
1800 struct rt6_info *rt = ip6_dst_alloc();
1801
1802 if (rt == NULL)
1803 return ERR_PTR(-ENOMEM);
1804
1805 dev_hold(&loopback_dev);
1806 in6_dev_hold(idev);
1807
1808 rt->u.dst.flags = DST_HOST;
1809 rt->u.dst.input = ip6_input;
1810 rt->u.dst.output = ip6_output;
1811 rt->rt6i_dev = &loopback_dev;
1812 rt->rt6i_idev = idev;
1813 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1814 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1815 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1816 rt->u.dst.obsolete = -1;
1817
1818 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +09001819 if (anycast)
1820 rt->rt6i_flags |= RTF_ANYCAST;
1821 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 rt->rt6i_flags |= RTF_LOCAL;
1823 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1824 if (rt->rt6i_nexthop == NULL) {
YOSHIFUJI Hideaki40aa7b92006-10-19 13:50:09 +09001825 dst_free(&rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 return ERR_PTR(-ENOMEM);
1827 }
1828
1829 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1830 rt->rt6i_dst.plen = 128;
Thomas Grafc71099a2006-08-04 23:20:06 -07001831 rt->rt6i_table = fib6_get_table(RT6_TABLE_LOCAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832
1833 atomic_set(&rt->u.dst.__refcnt, 1);
1834
1835 return rt;
1836}
1837
1838static int fib6_ifdown(struct rt6_info *rt, void *arg)
1839{
1840 if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1841 rt != &ip6_null_entry) {
1842 RT6_TRACE("deleted by ifdown %p\n", rt);
1843 return -1;
1844 }
1845 return 0;
1846}
1847
1848void rt6_ifdown(struct net_device *dev)
1849{
Thomas Grafc71099a2006-08-04 23:20:06 -07001850 fib6_clean_all(fib6_ifdown, 0, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851}
1852
1853struct rt6_mtu_change_arg
1854{
1855 struct net_device *dev;
1856 unsigned mtu;
1857};
1858
1859static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1860{
1861 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1862 struct inet6_dev *idev;
1863
1864 /* In IPv6 pmtu discovery is not optional,
1865 so that RTAX_MTU lock cannot disable it.
1866 We still use this lock to block changes
1867 caused by addrconf/ndisc.
1868 */
1869
1870 idev = __in6_dev_get(arg->dev);
1871 if (idev == NULL)
1872 return 0;
1873
1874 /* For administrative MTU increase, there is no way to discover
1875 IPv6 PMTU increase, so PMTU increase should be updated here.
1876 Since RFC 1981 doesn't include administrative MTU increase
1877 update PMTU increase is a MUST. (i.e. jumbo frame)
1878 */
1879 /*
1880 If new MTU is less than route PMTU, this new MTU will be the
1881 lowest MTU in the path, update the route PMTU to reflect PMTU
1882 decreases; if new MTU is greater than route PMTU, and the
1883 old MTU is the lowest MTU in the path, update the route PMTU
1884 to reflect the increase. In this case if the other nodes' MTU
1885 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1886 PMTU discouvery.
1887 */
1888 if (rt->rt6i_dev == arg->dev &&
1889 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
1890 (dst_mtu(&rt->u.dst) > arg->mtu ||
1891 (dst_mtu(&rt->u.dst) < arg->mtu &&
1892 dst_mtu(&rt->u.dst) == idev->cnf.mtu6)))
1893 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
1894 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1895 return 0;
1896}
1897
1898void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1899{
Thomas Grafc71099a2006-08-04 23:20:06 -07001900 struct rt6_mtu_change_arg arg = {
1901 .dev = dev,
1902 .mtu = mtu,
1903 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904
Thomas Grafc71099a2006-08-04 23:20:06 -07001905 fib6_clean_all(rt6_mtu_change_route, 0, &arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906}
1907
Thomas Graf86872cb2006-08-22 00:01:08 -07001908static struct nla_policy rtm_ipv6_policy[RTA_MAX+1] __read_mostly = {
Thomas Graf5176f912006-08-26 20:13:18 -07001909 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
Thomas Graf86872cb2006-08-22 00:01:08 -07001910 [RTA_OIF] = { .type = NLA_U32 },
Thomas Grafab364a62006-08-22 00:01:47 -07001911 [RTA_IIF] = { .type = NLA_U32 },
Thomas Graf86872cb2006-08-22 00:01:08 -07001912 [RTA_PRIORITY] = { .type = NLA_U32 },
1913 [RTA_METRICS] = { .type = NLA_NESTED },
1914};
1915
1916static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
1917 struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918{
Thomas Graf86872cb2006-08-22 00:01:08 -07001919 struct rtmsg *rtm;
1920 struct nlattr *tb[RTA_MAX+1];
1921 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922
Thomas Graf86872cb2006-08-22 00:01:08 -07001923 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
1924 if (err < 0)
1925 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926
Thomas Graf86872cb2006-08-22 00:01:08 -07001927 err = -EINVAL;
1928 rtm = nlmsg_data(nlh);
1929 memset(cfg, 0, sizeof(*cfg));
1930
1931 cfg->fc_table = rtm->rtm_table;
1932 cfg->fc_dst_len = rtm->rtm_dst_len;
1933 cfg->fc_src_len = rtm->rtm_src_len;
1934 cfg->fc_flags = RTF_UP;
1935 cfg->fc_protocol = rtm->rtm_protocol;
1936
1937 if (rtm->rtm_type == RTN_UNREACHABLE)
1938 cfg->fc_flags |= RTF_REJECT;
1939
1940 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
1941 cfg->fc_nlinfo.nlh = nlh;
1942
1943 if (tb[RTA_GATEWAY]) {
1944 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
1945 cfg->fc_flags |= RTF_GATEWAY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001947
1948 if (tb[RTA_DST]) {
1949 int plen = (rtm->rtm_dst_len + 7) >> 3;
1950
1951 if (nla_len(tb[RTA_DST]) < plen)
1952 goto errout;
1953
1954 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001956
1957 if (tb[RTA_SRC]) {
1958 int plen = (rtm->rtm_src_len + 7) >> 3;
1959
1960 if (nla_len(tb[RTA_SRC]) < plen)
1961 goto errout;
1962
1963 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001965
1966 if (tb[RTA_OIF])
1967 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
1968
1969 if (tb[RTA_PRIORITY])
1970 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
1971
1972 if (tb[RTA_METRICS]) {
1973 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
1974 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001976
1977 if (tb[RTA_TABLE])
1978 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
1979
1980 err = 0;
1981errout:
1982 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983}
1984
1985int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1986{
Thomas Graf86872cb2006-08-22 00:01:08 -07001987 struct fib6_config cfg;
1988 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989
Thomas Graf86872cb2006-08-22 00:01:08 -07001990 err = rtm_to_fib6_config(skb, nlh, &cfg);
1991 if (err < 0)
1992 return err;
1993
1994 return ip6_route_del(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995}
1996
1997int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1998{
Thomas Graf86872cb2006-08-22 00:01:08 -07001999 struct fib6_config cfg;
2000 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001
Thomas Graf86872cb2006-08-22 00:01:08 -07002002 err = rtm_to_fib6_config(skb, nlh, &cfg);
2003 if (err < 0)
2004 return err;
2005
2006 return ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007}
2008
Thomas Graf339bf982006-11-10 14:10:15 -08002009static inline size_t rt6_nlmsg_size(void)
2010{
2011 return NLMSG_ALIGN(sizeof(struct rtmsg))
2012 + nla_total_size(16) /* RTA_SRC */
2013 + nla_total_size(16) /* RTA_DST */
2014 + nla_total_size(16) /* RTA_GATEWAY */
2015 + nla_total_size(16) /* RTA_PREFSRC */
2016 + nla_total_size(4) /* RTA_TABLE */
2017 + nla_total_size(4) /* RTA_IIF */
2018 + nla_total_size(4) /* RTA_OIF */
2019 + nla_total_size(4) /* RTA_PRIORITY */
2020 + nla_total_size(sizeof(struct rta_cacheinfo));
2021}
2022
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
Jamal Hadi Salim0d51aa82005-06-21 13:51:04 -07002024 struct in6_addr *dst, struct in6_addr *src,
2025 int iif, int type, u32 pid, u32 seq,
2026 int prefix, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027{
2028 struct rtmsg *rtm;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002029 struct nlmsghdr *nlh;
Thomas Grafe3703b32006-11-27 09:27:07 -08002030 long expires;
Patrick McHardy9e762a42006-08-10 23:09:48 -07002031 u32 table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032
2033 if (prefix) { /* user wants prefix routes only */
2034 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2035 /* success since this is not a prefix route */
2036 return 1;
2037 }
2038 }
2039
Thomas Graf2d7202b2006-08-22 00:01:27 -07002040 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2041 if (nlh == NULL)
2042 return -ENOBUFS;
2043
2044 rtm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 rtm->rtm_family = AF_INET6;
2046 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2047 rtm->rtm_src_len = rt->rt6i_src.plen;
2048 rtm->rtm_tos = 0;
Thomas Grafc71099a2006-08-04 23:20:06 -07002049 if (rt->rt6i_table)
Patrick McHardy9e762a42006-08-10 23:09:48 -07002050 table = rt->rt6i_table->tb6_id;
Thomas Grafc71099a2006-08-04 23:20:06 -07002051 else
Patrick McHardy9e762a42006-08-10 23:09:48 -07002052 table = RT6_TABLE_UNSPEC;
2053 rtm->rtm_table = table;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002054 NLA_PUT_U32(skb, RTA_TABLE, table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 if (rt->rt6i_flags&RTF_REJECT)
2056 rtm->rtm_type = RTN_UNREACHABLE;
2057 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2058 rtm->rtm_type = RTN_LOCAL;
2059 else
2060 rtm->rtm_type = RTN_UNICAST;
2061 rtm->rtm_flags = 0;
2062 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2063 rtm->rtm_protocol = rt->rt6i_protocol;
2064 if (rt->rt6i_flags&RTF_DYNAMIC)
2065 rtm->rtm_protocol = RTPROT_REDIRECT;
2066 else if (rt->rt6i_flags & RTF_ADDRCONF)
2067 rtm->rtm_protocol = RTPROT_KERNEL;
2068 else if (rt->rt6i_flags&RTF_DEFAULT)
2069 rtm->rtm_protocol = RTPROT_RA;
2070
2071 if (rt->rt6i_flags&RTF_CACHE)
2072 rtm->rtm_flags |= RTM_F_CLONED;
2073
2074 if (dst) {
Thomas Graf2d7202b2006-08-22 00:01:27 -07002075 NLA_PUT(skb, RTA_DST, 16, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 rtm->rtm_dst_len = 128;
2077 } else if (rtm->rtm_dst_len)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002078 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079#ifdef CONFIG_IPV6_SUBTREES
2080 if (src) {
Thomas Graf2d7202b2006-08-22 00:01:27 -07002081 NLA_PUT(skb, RTA_SRC, 16, src);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 rtm->rtm_src_len = 128;
2083 } else if (rtm->rtm_src_len)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002084 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085#endif
2086 if (iif)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002087 NLA_PUT_U32(skb, RTA_IIF, iif);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 else if (dst) {
2089 struct in6_addr saddr_buf;
2090 if (ipv6_get_saddr(&rt->u.dst, dst, &saddr_buf) == 0)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002091 NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 }
Thomas Graf2d7202b2006-08-22 00:01:27 -07002093
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002095 goto nla_put_failure;
2096
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 if (rt->u.dst.neighbour)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002098 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
2099
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 if (rt->u.dst.dev)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002101 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2102
2103 NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
Thomas Grafe3703b32006-11-27 09:27:07 -08002104
2105 expires = rt->rt6i_expires ? rt->rt6i_expires - jiffies : 0;
2106 if (rtnl_put_cacheinfo(skb, &rt->u.dst, 0, 0, 0,
2107 expires, rt->u.dst.error) < 0)
2108 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109
Thomas Graf2d7202b2006-08-22 00:01:27 -07002110 return nlmsg_end(skb, nlh);
2111
2112nla_put_failure:
2113 return nlmsg_cancel(skb, nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114}
2115
Patrick McHardy1b43af52006-08-10 23:11:17 -07002116int rt6_dump_route(struct rt6_info *rt, void *p_arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117{
2118 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2119 int prefix;
2120
Thomas Graf2d7202b2006-08-22 00:01:27 -07002121 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2122 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2124 } else
2125 prefix = 0;
2126
2127 return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2128 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
Jamal Hadi Salim0d51aa82005-06-21 13:51:04 -07002129 prefix, NLM_F_MULTI);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130}
2131
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2133{
Thomas Grafab364a62006-08-22 00:01:47 -07002134 struct nlattr *tb[RTA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 struct rt6_info *rt;
Thomas Grafab364a62006-08-22 00:01:47 -07002136 struct sk_buff *skb;
2137 struct rtmsg *rtm;
2138 struct flowi fl;
2139 int err, iif = 0;
2140
2141 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2142 if (err < 0)
2143 goto errout;
2144
2145 err = -EINVAL;
2146 memset(&fl, 0, sizeof(fl));
2147
2148 if (tb[RTA_SRC]) {
2149 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2150 goto errout;
2151
2152 ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2153 }
2154
2155 if (tb[RTA_DST]) {
2156 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2157 goto errout;
2158
2159 ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2160 }
2161
2162 if (tb[RTA_IIF])
2163 iif = nla_get_u32(tb[RTA_IIF]);
2164
2165 if (tb[RTA_OIF])
2166 fl.oif = nla_get_u32(tb[RTA_OIF]);
2167
2168 if (iif) {
2169 struct net_device *dev;
2170 dev = __dev_get_by_index(iif);
2171 if (!dev) {
2172 err = -ENODEV;
2173 goto errout;
2174 }
2175 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176
2177 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
Thomas Grafab364a62006-08-22 00:01:47 -07002178 if (skb == NULL) {
2179 err = -ENOBUFS;
2180 goto errout;
2181 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182
2183 /* Reserve room for dummy headers, this skb can pass
2184 through good chunk of routing engine.
2185 */
2186 skb->mac.raw = skb->data;
2187 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2188
Thomas Grafab364a62006-08-22 00:01:47 -07002189 rt = (struct rt6_info*) ip6_route_output(NULL, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190 skb->dst = &rt->u.dst;
2191
Thomas Grafab364a62006-08-22 00:01:47 -07002192 err = rt6_fill_node(skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
Jamal Hadi Salim0d51aa82005-06-21 13:51:04 -07002194 nlh->nlmsg_seq, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 if (err < 0) {
Thomas Grafab364a62006-08-22 00:01:47 -07002196 kfree_skb(skb);
2197 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 }
2199
Thomas Graf2942e902006-08-15 00:30:25 -07002200 err = rtnl_unicast(skb, NETLINK_CB(in_skb).pid);
Thomas Grafab364a62006-08-22 00:01:47 -07002201errout:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203}
2204
Thomas Graf86872cb2006-08-22 00:01:08 -07002205void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206{
2207 struct sk_buff *skb;
Thomas Graf86872cb2006-08-22 00:01:08 -07002208 u32 pid = 0, seq = 0;
2209 struct nlmsghdr *nlh = NULL;
Thomas Graf21713eb2006-08-15 00:35:24 -07002210 int err = -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211
Thomas Graf86872cb2006-08-22 00:01:08 -07002212 if (info) {
2213 pid = info->pid;
2214 nlh = info->nlh;
2215 if (nlh)
2216 seq = nlh->nlmsg_seq;
2217 }
2218
Thomas Graf339bf982006-11-10 14:10:15 -08002219 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
Thomas Graf21713eb2006-08-15 00:35:24 -07002220 if (skb == NULL)
2221 goto errout;
2222
2223 err = rt6_fill_node(skb, rt, NULL, NULL, 0, event, pid, seq, 0, 0);
Thomas Graf339bf982006-11-10 14:10:15 -08002224 /* failure implies BUG in rt6_nlmsg_size() */
2225 BUG_ON(err < 0);
Thomas Graf21713eb2006-08-15 00:35:24 -07002226
2227 err = rtnl_notify(skb, pid, RTNLGRP_IPV6_ROUTE, nlh, gfp_any());
2228errout:
2229 if (err < 0)
2230 rtnl_set_sk_err(RTNLGRP_IPV6_ROUTE, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231}
2232
2233/*
2234 * /proc
2235 */
2236
2237#ifdef CONFIG_PROC_FS
2238
2239#define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2240
2241struct rt6_proc_arg
2242{
2243 char *buffer;
2244 int offset;
2245 int length;
2246 int skip;
2247 int len;
2248};
2249
2250static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2251{
2252 struct rt6_proc_arg *arg = (struct rt6_proc_arg *) p_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253
2254 if (arg->skip < arg->offset / RT6_INFO_LEN) {
2255 arg->skip++;
2256 return 0;
2257 }
2258
2259 if (arg->len >= arg->length)
2260 return 0;
2261
YOSHIFUJI Hideaki33e93c92006-10-14 02:00:56 +09002262 arg->len += sprintf(arg->buffer + arg->len,
2263 NIP6_SEQFMT " %02x ",
2264 NIP6(rt->rt6i_dst.addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 rt->rt6i_dst.plen);
2266
2267#ifdef CONFIG_IPV6_SUBTREES
YOSHIFUJI Hideaki33e93c92006-10-14 02:00:56 +09002268 arg->len += sprintf(arg->buffer + arg->len,
2269 NIP6_SEQFMT " %02x ",
2270 NIP6(rt->rt6i_src.addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 rt->rt6i_src.plen);
2272#else
YOSHIFUJI Hideaki33e93c92006-10-14 02:00:56 +09002273 arg->len += sprintf(arg->buffer + arg->len,
2274 "00000000000000000000000000000000 00 ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275#endif
2276
2277 if (rt->rt6i_nexthop) {
YOSHIFUJI Hideaki33e93c92006-10-14 02:00:56 +09002278 arg->len += sprintf(arg->buffer + arg->len,
2279 NIP6_SEQFMT,
2280 NIP6(*((struct in6_addr *)rt->rt6i_nexthop->primary_key)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 } else {
YOSHIFUJI Hideaki33e93c92006-10-14 02:00:56 +09002282 arg->len += sprintf(arg->buffer + arg->len,
2283 "00000000000000000000000000000000");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284 }
2285 arg->len += sprintf(arg->buffer + arg->len,
2286 " %08x %08x %08x %08x %8s\n",
2287 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
2288 rt->u.dst.__use, rt->rt6i_flags,
2289 rt->rt6i_dev ? rt->rt6i_dev->name : "");
2290 return 0;
2291}
2292
2293static int rt6_proc_info(char *buffer, char **start, off_t offset, int length)
2294{
Thomas Grafc71099a2006-08-04 23:20:06 -07002295 struct rt6_proc_arg arg = {
2296 .buffer = buffer,
2297 .offset = offset,
2298 .length = length,
2299 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300
Thomas Grafc71099a2006-08-04 23:20:06 -07002301 fib6_clean_all(rt6_info_route, 0, &arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302
2303 *start = buffer;
2304 if (offset)
2305 *start += offset % RT6_INFO_LEN;
2306
2307 arg.len -= offset % RT6_INFO_LEN;
2308
2309 if (arg.len > length)
2310 arg.len = length;
2311 if (arg.len < 0)
2312 arg.len = 0;
2313
2314 return arg.len;
2315}
2316
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2318{
2319 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2320 rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
2321 rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
2322 rt6_stats.fib_rt_cache,
2323 atomic_read(&ip6_dst_ops.entries),
2324 rt6_stats.fib_discarded_routes);
2325
2326 return 0;
2327}
2328
2329static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2330{
2331 return single_open(file, rt6_stats_seq_show, NULL);
2332}
2333
2334static struct file_operations rt6_stats_seq_fops = {
2335 .owner = THIS_MODULE,
2336 .open = rt6_stats_seq_open,
2337 .read = seq_read,
2338 .llseek = seq_lseek,
2339 .release = single_release,
2340};
2341#endif /* CONFIG_PROC_FS */
2342
2343#ifdef CONFIG_SYSCTL
2344
2345static int flush_delay;
2346
2347static
2348int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
2349 void __user *buffer, size_t *lenp, loff_t *ppos)
2350{
2351 if (write) {
2352 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2353 fib6_run_gc(flush_delay <= 0 ? ~0UL : (unsigned long)flush_delay);
2354 return 0;
2355 } else
2356 return -EINVAL;
2357}
2358
2359ctl_table ipv6_route_table[] = {
2360 {
2361 .ctl_name = NET_IPV6_ROUTE_FLUSH,
2362 .procname = "flush",
2363 .data = &flush_delay,
2364 .maxlen = sizeof(int),
Dave Jones89c8b3a2005-04-28 12:11:49 -07002365 .mode = 0200,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366 .proc_handler = &ipv6_sysctl_rtcache_flush
2367 },
2368 {
2369 .ctl_name = NET_IPV6_ROUTE_GC_THRESH,
2370 .procname = "gc_thresh",
2371 .data = &ip6_dst_ops.gc_thresh,
2372 .maxlen = sizeof(int),
2373 .mode = 0644,
2374 .proc_handler = &proc_dointvec,
2375 },
2376 {
2377 .ctl_name = NET_IPV6_ROUTE_MAX_SIZE,
2378 .procname = "max_size",
2379 .data = &ip6_rt_max_size,
2380 .maxlen = sizeof(int),
2381 .mode = 0644,
2382 .proc_handler = &proc_dointvec,
2383 },
2384 {
2385 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL,
2386 .procname = "gc_min_interval",
2387 .data = &ip6_rt_gc_min_interval,
2388 .maxlen = sizeof(int),
2389 .mode = 0644,
2390 .proc_handler = &proc_dointvec_jiffies,
2391 .strategy = &sysctl_jiffies,
2392 },
2393 {
2394 .ctl_name = NET_IPV6_ROUTE_GC_TIMEOUT,
2395 .procname = "gc_timeout",
2396 .data = &ip6_rt_gc_timeout,
2397 .maxlen = sizeof(int),
2398 .mode = 0644,
2399 .proc_handler = &proc_dointvec_jiffies,
2400 .strategy = &sysctl_jiffies,
2401 },
2402 {
2403 .ctl_name = NET_IPV6_ROUTE_GC_INTERVAL,
2404 .procname = "gc_interval",
2405 .data = &ip6_rt_gc_interval,
2406 .maxlen = sizeof(int),
2407 .mode = 0644,
2408 .proc_handler = &proc_dointvec_jiffies,
2409 .strategy = &sysctl_jiffies,
2410 },
2411 {
2412 .ctl_name = NET_IPV6_ROUTE_GC_ELASTICITY,
2413 .procname = "gc_elasticity",
2414 .data = &ip6_rt_gc_elasticity,
2415 .maxlen = sizeof(int),
2416 .mode = 0644,
2417 .proc_handler = &proc_dointvec_jiffies,
2418 .strategy = &sysctl_jiffies,
2419 },
2420 {
2421 .ctl_name = NET_IPV6_ROUTE_MTU_EXPIRES,
2422 .procname = "mtu_expires",
2423 .data = &ip6_rt_mtu_expires,
2424 .maxlen = sizeof(int),
2425 .mode = 0644,
2426 .proc_handler = &proc_dointvec_jiffies,
2427 .strategy = &sysctl_jiffies,
2428 },
2429 {
2430 .ctl_name = NET_IPV6_ROUTE_MIN_ADVMSS,
2431 .procname = "min_adv_mss",
2432 .data = &ip6_rt_min_advmss,
2433 .maxlen = sizeof(int),
2434 .mode = 0644,
2435 .proc_handler = &proc_dointvec_jiffies,
2436 .strategy = &sysctl_jiffies,
2437 },
2438 {
2439 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2440 .procname = "gc_min_interval_ms",
2441 .data = &ip6_rt_gc_min_interval,
2442 .maxlen = sizeof(int),
2443 .mode = 0644,
2444 .proc_handler = &proc_dointvec_ms_jiffies,
2445 .strategy = &sysctl_ms_jiffies,
2446 },
2447 { .ctl_name = 0 }
2448};
2449
2450#endif
2451
2452void __init ip6_route_init(void)
2453{
2454 struct proc_dir_entry *p;
2455
Alexey Dobriyane5d679f2006-08-26 19:25:52 -07002456 ip6_dst_ops.kmem_cachep =
2457 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
2458 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459 fib6_init();
2460#ifdef CONFIG_PROC_FS
2461 p = proc_net_create("ipv6_route", 0, rt6_proc_info);
2462 if (p)
2463 p->owner = THIS_MODULE;
2464
2465 proc_net_fops_create("rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2466#endif
2467#ifdef CONFIG_XFRM
2468 xfrm6_init();
2469#endif
Thomas Graf101367c2006-08-04 03:39:02 -07002470#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2471 fib6_rules_init();
2472#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473}
2474
2475void ip6_route_cleanup(void)
2476{
Thomas Graf101367c2006-08-04 03:39:02 -07002477#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2478 fib6_rules_cleanup();
2479#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480#ifdef CONFIG_PROC_FS
2481 proc_net_remove("ipv6_route");
2482 proc_net_remove("rt6_stats");
2483#endif
2484#ifdef CONFIG_XFRM
2485 xfrm6_fini();
2486#endif
2487 rt6_ifdown(NULL);
2488 fib6_gc_cleanup();
2489 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);
2490}