blob: 6264ec3bb154c5cf3cd5929b697d9f2b353bfebf [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Linux INET6 implementation
3 * FIB front-end.
4 *
5 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09006 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
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);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900204 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205}
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) {
Eric Dumazet7cc48262007-02-09 16:22:57 -0800246 for (sprt = rt; sprt; sprt = sprt->u.dst.rt6_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 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;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900255 if (local && (!oif ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 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 */
Dave Jonesb6f99a22007-03-22 12:27:49 -0700311static inline int 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;
David S. Miller161980f2007-04-06 11:42:27 -0700314 if (!oif || dev->ifindex == oif)
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800315 return 2;
David S. Miller161980f2007-04-06 11:42:27 -0700316 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
Dave Jonesb6f99a22007-03-22 12:27:49 -0700322static inline int 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;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900344
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700345 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
David S. Millerf11e6652007-03-24 20:36:25 -0700357static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
358 int *mpri, struct rt6_info *match)
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800359{
David S. Millerf11e6652007-03-24 20:36:25 -0700360 int m;
361
362 if (rt6_check_expired(rt))
363 goto out;
364
365 m = rt6_score_route(rt, oif, strict);
366 if (m < 0)
367 goto out;
368
369 if (m > *mpri) {
370 if (strict & RT6_LOOKUP_F_REACHABLE)
371 rt6_probe(match);
372 *mpri = m;
373 match = rt;
374 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
375 rt6_probe(rt);
376 }
377
378out:
379 return match;
380}
381
382static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
383 struct rt6_info *rr_head,
384 u32 metric, int oif, int strict)
385{
386 struct rt6_info *rt, *match;
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800387 int mpri = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
David S. Millerf11e6652007-03-24 20:36:25 -0700389 match = NULL;
390 for (rt = rr_head; rt && rt->rt6i_metric == metric;
391 rt = rt->u.dst.rt6_next)
392 match = find_match(rt, oif, strict, &mpri, match);
393 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
394 rt = rt->u.dst.rt6_next)
395 match = find_match(rt, oif, strict, &mpri, match);
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800396
David S. Millerf11e6652007-03-24 20:36:25 -0700397 return match;
398}
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800399
David S. Millerf11e6652007-03-24 20:36:25 -0700400static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
401{
402 struct rt6_info *match, *rt0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
David S. Millerf11e6652007-03-24 20:36:25 -0700404 RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
405 __FUNCTION__, fn->leaf, oif);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
David S. Millerf11e6652007-03-24 20:36:25 -0700407 rt0 = fn->rr_ptr;
408 if (!rt0)
409 fn->rr_ptr = rt0 = fn->leaf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
David S. Millerf11e6652007-03-24 20:36:25 -0700411 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800413 if (!match &&
David S. Millerf11e6652007-03-24 20:36:25 -0700414 (strict & RT6_LOOKUP_F_REACHABLE)) {
415 struct rt6_info *next = rt0->u.dst.rt6_next;
416
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800417 /* no entries matched; do round-robin */
David S. Millerf11e6652007-03-24 20:36:25 -0700418 if (!next || next->rt6i_metric != rt0->rt6i_metric)
419 next = fn->leaf;
420
421 if (next != rt0)
422 fn->rr_ptr = next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 }
424
David S. Millerf11e6652007-03-24 20:36:25 -0700425 RT6_TRACE("%s() => %p\n",
426 __FUNCTION__, match);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800428 return (match ? match : &ip6_null_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429}
430
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800431#ifdef CONFIG_IPV6_ROUTE_INFO
432int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
433 struct in6_addr *gwaddr)
434{
435 struct route_info *rinfo = (struct route_info *) opt;
436 struct in6_addr prefix_buf, *prefix;
437 unsigned int pref;
438 u32 lifetime;
439 struct rt6_info *rt;
440
441 if (len < sizeof(struct route_info)) {
442 return -EINVAL;
443 }
444
445 /* Sanity check for prefix_len and length */
446 if (rinfo->length > 3) {
447 return -EINVAL;
448 } else if (rinfo->prefix_len > 128) {
449 return -EINVAL;
450 } else if (rinfo->prefix_len > 64) {
451 if (rinfo->length < 2) {
452 return -EINVAL;
453 }
454 } else if (rinfo->prefix_len > 0) {
455 if (rinfo->length < 1) {
456 return -EINVAL;
457 }
458 }
459
460 pref = rinfo->route_pref;
461 if (pref == ICMPV6_ROUTER_PREF_INVALID)
462 pref = ICMPV6_ROUTER_PREF_MEDIUM;
463
Al Viroe69a4ad2006-11-14 20:56:00 -0800464 lifetime = ntohl(rinfo->lifetime);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800465 if (lifetime == 0xffffffff) {
466 /* infinity */
467 } else if (lifetime > 0x7fffffff/HZ) {
468 /* Avoid arithmetic overflow */
469 lifetime = 0x7fffffff/HZ - 1;
470 }
471
472 if (rinfo->length == 3)
473 prefix = (struct in6_addr *)rinfo->prefix;
474 else {
475 /* this function is safe */
476 ipv6_addr_prefix(&prefix_buf,
477 (struct in6_addr *)rinfo->prefix,
478 rinfo->prefix_len);
479 prefix = &prefix_buf;
480 }
481
482 rt = rt6_get_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex);
483
484 if (rt && !lifetime) {
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700485 ip6_del_rt(rt);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800486 rt = NULL;
487 }
488
489 if (!rt && lifetime)
490 rt = rt6_add_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
491 pref);
492 else if (rt)
493 rt->rt6i_flags = RTF_ROUTEINFO |
494 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
495
496 if (rt) {
497 if (lifetime == 0xffffffff) {
498 rt->rt6i_flags &= ~RTF_EXPIRES;
499 } else {
500 rt->rt6i_expires = jiffies + HZ * lifetime;
501 rt->rt6i_flags |= RTF_EXPIRES;
502 }
503 dst_release(&rt->u.dst);
504 }
505 return 0;
506}
507#endif
508
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700509#define BACKTRACK(saddr) \
510do { \
511 if (rt == &ip6_null_entry) { \
512 struct fib6_node *pn; \
Ville Nuorvalae0eda7b2006-10-16 22:11:11 -0700513 while (1) { \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700514 if (fn->fn_flags & RTN_TL_ROOT) \
515 goto out; \
516 pn = fn->parent; \
517 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
Kim Nordlund8bce65b2006-12-13 16:38:29 -0800518 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700519 else \
520 fn = pn; \
521 if (fn->fn_flags & RTN_RTINFO) \
522 goto restart; \
Thomas Grafc71099a2006-08-04 23:20:06 -0700523 } \
Thomas Grafc71099a2006-08-04 23:20:06 -0700524 } \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700525} while(0)
Thomas Grafc71099a2006-08-04 23:20:06 -0700526
527static struct rt6_info *ip6_pol_route_lookup(struct fib6_table *table,
528 struct flowi *fl, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529{
530 struct fib6_node *fn;
531 struct rt6_info *rt;
532
Thomas Grafc71099a2006-08-04 23:20:06 -0700533 read_lock_bh(&table->tb6_lock);
534 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
535restart:
536 rt = fn->leaf;
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700537 rt = rt6_device_match(rt, fl->oif, flags);
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700538 BACKTRACK(&fl->fl6_src);
Thomas Grafc71099a2006-08-04 23:20:06 -0700539out:
YOSHIFUJI Hideaki33cc4892006-08-28 13:19:30 -0700540 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700541 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542
543 rt->u.dst.lastuse = jiffies;
Thomas Grafc71099a2006-08-04 23:20:06 -0700544 rt->u.dst.__use++;
545
546 return rt;
547
548}
549
550struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
551 int oif, int strict)
552{
553 struct flowi fl = {
554 .oif = oif,
555 .nl_u = {
556 .ip6_u = {
557 .daddr = *daddr,
Thomas Grafc71099a2006-08-04 23:20:06 -0700558 },
559 },
560 };
561 struct dst_entry *dst;
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700562 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
Thomas Grafc71099a2006-08-04 23:20:06 -0700563
Thomas Grafadaa70b2006-10-13 15:01:03 -0700564 if (saddr) {
565 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
566 flags |= RT6_LOOKUP_F_HAS_SADDR;
567 }
568
Thomas Grafc71099a2006-08-04 23:20:06 -0700569 dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_lookup);
570 if (dst->error == 0)
571 return (struct rt6_info *) dst;
572
573 dst_release(dst);
574
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 return NULL;
576}
577
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900578EXPORT_SYMBOL(rt6_lookup);
579
Thomas Grafc71099a2006-08-04 23:20:06 -0700580/* ip6_ins_rt is called with FREE table->tb6_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 It takes new route entry, the addition fails by any reason the
582 route is freed. In any case, if caller does not hold it, it may
583 be destroyed.
584 */
585
Thomas Graf86872cb2006-08-22 00:01:08 -0700586static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587{
588 int err;
Thomas Grafc71099a2006-08-04 23:20:06 -0700589 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Thomas Grafc71099a2006-08-04 23:20:06 -0700591 table = rt->rt6i_table;
592 write_lock_bh(&table->tb6_lock);
Thomas Graf86872cb2006-08-22 00:01:08 -0700593 err = fib6_add(&table->tb6_root, rt, info);
Thomas Grafc71099a2006-08-04 23:20:06 -0700594 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
596 return err;
597}
598
Thomas Graf40e22e82006-08-22 00:00:45 -0700599int ip6_ins_rt(struct rt6_info *rt)
600{
Thomas Graf86872cb2006-08-22 00:01:08 -0700601 return __ip6_ins_rt(rt, NULL);
Thomas Graf40e22e82006-08-22 00:00:45 -0700602}
603
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800604static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
605 struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 struct rt6_info *rt;
608
609 /*
610 * Clone the route.
611 */
612
613 rt = ip6_rt_copy(ort);
614
615 if (rt) {
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900616 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
617 if (rt->rt6i_dst.plen != 128 &&
618 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
619 rt->rt6i_flags |= RTF_ANYCAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900621 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900623 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 rt->rt6i_dst.plen = 128;
625 rt->rt6i_flags |= RTF_CACHE;
626 rt->u.dst.flags |= DST_HOST;
627
628#ifdef CONFIG_IPV6_SUBTREES
629 if (rt->rt6i_src.plen && saddr) {
630 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
631 rt->rt6i_src.plen = 128;
632 }
633#endif
634
635 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
636
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800637 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800639 return rt;
640}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800642static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
643{
644 struct rt6_info *rt = ip6_rt_copy(ort);
645 if (rt) {
646 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
647 rt->rt6i_dst.plen = 128;
648 rt->rt6i_flags |= RTF_CACHE;
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800649 rt->u.dst.flags |= DST_HOST;
650 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
651 }
652 return rt;
653}
654
Adrian Bunk8ce11e62006-08-07 21:50:48 -0700655static struct rt6_info *ip6_pol_route_input(struct fib6_table *table,
656 struct flowi *fl, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657{
658 struct fib6_node *fn;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800659 struct rt6_info *rt, *nrt;
Thomas Grafc71099a2006-08-04 23:20:06 -0700660 int strict = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 int attempts = 3;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800662 int err;
YOSHIFUJI Hideakiea659e02006-11-06 09:45:45 -0800663 int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700665 strict |= flags & RT6_LOOKUP_F_IFACE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666
667relookup:
Thomas Grafc71099a2006-08-04 23:20:06 -0700668 read_lock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800670restart_2:
Thomas Grafc71099a2006-08-04 23:20:06 -0700671 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
673restart:
David S. Millerf11e6652007-03-24 20:36:25 -0700674 rt = rt6_select(fn, fl->iif, strict | reachable);
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700675 BACKTRACK(&fl->fl6_src);
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800676 if (rt == &ip6_null_entry ||
677 rt->rt6i_flags & RTF_CACHE)
YOSHIFUJI Hideaki1ddef042006-03-20 17:01:24 -0800678 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
YOSHIFUJI Hideakifb9de912006-03-20 16:59:08 -0800680 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700681 read_unlock_bh(&table->tb6_lock);
YOSHIFUJI Hideakifb9de912006-03-20 16:59:08 -0800682
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800683 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
YOSHIFUJI Hideakie40cf352006-03-20 16:59:27 -0800684 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800685 else {
686#if CLONE_OFFLINK_ROUTE
687 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
688#else
689 goto out2;
690#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 }
YOSHIFUJI Hideakie40cf352006-03-20 16:59:27 -0800692
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800693 dst_release(&rt->u.dst);
694 rt = nrt ? : &ip6_null_entry;
695
696 dst_hold(&rt->u.dst);
697 if (nrt) {
Thomas Graf40e22e82006-08-22 00:00:45 -0700698 err = ip6_ins_rt(nrt);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800699 if (!err)
700 goto out2;
701 }
702
703 if (--attempts <= 0)
704 goto out2;
705
706 /*
Thomas Grafc71099a2006-08-04 23:20:06 -0700707 * Race condition! In the gap, when table->tb6_lock was
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800708 * released someone could insert this route. Relookup.
709 */
710 dst_release(&rt->u.dst);
711 goto relookup;
712
713out:
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800714 if (reachable) {
715 reachable = 0;
716 goto restart_2;
717 }
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800718 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700719 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720out2:
721 rt->u.dst.lastuse = jiffies;
722 rt->u.dst.__use++;
Thomas Grafc71099a2006-08-04 23:20:06 -0700723
724 return rt;
725}
726
727void ip6_route_input(struct sk_buff *skb)
728{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700729 struct ipv6hdr *iph = ipv6_hdr(skb);
Thomas Grafadaa70b2006-10-13 15:01:03 -0700730 int flags = RT6_LOOKUP_F_HAS_SADDR;
Thomas Grafc71099a2006-08-04 23:20:06 -0700731 struct flowi fl = {
732 .iif = skb->dev->ifindex,
733 .nl_u = {
734 .ip6_u = {
735 .daddr = iph->daddr,
736 .saddr = iph->saddr,
Al Viro90bcaf72006-11-08 00:25:17 -0800737 .flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
Thomas Grafc71099a2006-08-04 23:20:06 -0700738 },
739 },
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900740 .mark = skb->mark,
Thomas Grafc71099a2006-08-04 23:20:06 -0700741 .proto = iph->nexthdr,
742 };
Thomas Grafadaa70b2006-10-13 15:01:03 -0700743
744 if (rt6_need_strict(&iph->daddr))
745 flags |= RT6_LOOKUP_F_IFACE;
Thomas Grafc71099a2006-08-04 23:20:06 -0700746
747 skb->dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_input);
748}
749
750static struct rt6_info *ip6_pol_route_output(struct fib6_table *table,
751 struct flowi *fl, int flags)
752{
753 struct fib6_node *fn;
754 struct rt6_info *rt, *nrt;
755 int strict = 0;
756 int attempts = 3;
757 int err;
YOSHIFUJI Hideakiea659e02006-11-06 09:45:45 -0800758 int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
Thomas Grafc71099a2006-08-04 23:20:06 -0700759
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700760 strict |= flags & RT6_LOOKUP_F_IFACE;
Thomas Grafc71099a2006-08-04 23:20:06 -0700761
762relookup:
763 read_lock_bh(&table->tb6_lock);
764
765restart_2:
766 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
767
768restart:
David S. Millerf11e6652007-03-24 20:36:25 -0700769 rt = rt6_select(fn, fl->oif, strict | reachable);
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700770 BACKTRACK(&fl->fl6_src);
Thomas Grafc71099a2006-08-04 23:20:06 -0700771 if (rt == &ip6_null_entry ||
772 rt->rt6i_flags & RTF_CACHE)
773 goto out;
774
775 dst_hold(&rt->u.dst);
776 read_unlock_bh(&table->tb6_lock);
777
778 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
779 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
780 else {
781#if CLONE_OFFLINK_ROUTE
782 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
783#else
784 goto out2;
785#endif
786 }
787
788 dst_release(&rt->u.dst);
789 rt = nrt ? : &ip6_null_entry;
790
791 dst_hold(&rt->u.dst);
792 if (nrt) {
Thomas Graf40e22e82006-08-22 00:00:45 -0700793 err = ip6_ins_rt(nrt);
Thomas Grafc71099a2006-08-04 23:20:06 -0700794 if (!err)
795 goto out2;
796 }
797
798 if (--attempts <= 0)
799 goto out2;
800
801 /*
802 * Race condition! In the gap, when table->tb6_lock was
803 * released someone could insert this route. Relookup.
804 */
805 dst_release(&rt->u.dst);
806 goto relookup;
807
808out:
809 if (reachable) {
810 reachable = 0;
811 goto restart_2;
812 }
813 dst_hold(&rt->u.dst);
814 read_unlock_bh(&table->tb6_lock);
815out2:
816 rt->u.dst.lastuse = jiffies;
817 rt->u.dst.__use++;
818 return rt;
819}
820
821struct dst_entry * ip6_route_output(struct sock *sk, struct flowi *fl)
822{
823 int flags = 0;
824
825 if (rt6_need_strict(&fl->fl6_dst))
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700826 flags |= RT6_LOOKUP_F_IFACE;
Thomas Grafc71099a2006-08-04 23:20:06 -0700827
Thomas Grafadaa70b2006-10-13 15:01:03 -0700828 if (!ipv6_addr_any(&fl->fl6_src))
829 flags |= RT6_LOOKUP_F_HAS_SADDR;
830
Thomas Grafc71099a2006-08-04 23:20:06 -0700831 return fib6_rule_lookup(fl, flags, ip6_pol_route_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832}
833
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900834EXPORT_SYMBOL(ip6_route_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
836/*
837 * Destination cache support functions
838 */
839
840static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
841{
842 struct rt6_info *rt;
843
844 rt = (struct rt6_info *) dst;
845
846 if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
847 return dst;
848
849 return NULL;
850}
851
852static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
853{
854 struct rt6_info *rt = (struct rt6_info *) dst;
855
856 if (rt) {
857 if (rt->rt6i_flags & RTF_CACHE)
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700858 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 else
860 dst_release(dst);
861 }
862 return NULL;
863}
864
865static void ip6_link_failure(struct sk_buff *skb)
866{
867 struct rt6_info *rt;
868
869 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
870
871 rt = (struct rt6_info *) skb->dst;
872 if (rt) {
873 if (rt->rt6i_flags&RTF_CACHE) {
874 dst_set_expires(&rt->u.dst, 0);
875 rt->rt6i_flags |= RTF_EXPIRES;
876 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
877 rt->rt6i_node->fn_sernum = -1;
878 }
879}
880
881static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
882{
883 struct rt6_info *rt6 = (struct rt6_info*)dst;
884
885 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
886 rt6->rt6i_flags |= RTF_MODIFIED;
887 if (mtu < IPV6_MIN_MTU) {
888 mtu = IPV6_MIN_MTU;
889 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
890 }
891 dst->metrics[RTAX_MTU-1] = mtu;
Tom Tucker8d717402006-07-30 20:43:36 -0700892 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 }
894}
895
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896static int ipv6_get_mtu(struct net_device *dev);
897
898static inline unsigned int ipv6_advmss(unsigned int mtu)
899{
900 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
901
902 if (mtu < ip6_rt_min_advmss)
903 mtu = ip6_rt_min_advmss;
904
905 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900906 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
907 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
908 * IPV6_MAXPLEN is also valid and means: "any MSS,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 * rely only on pmtu discovery"
910 */
911 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
912 mtu = IPV6_MAXPLEN;
913 return mtu;
914}
915
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700916static struct dst_entry *ndisc_dst_gc_list;
Adrian Bunk8ce11e62006-08-07 21:50:48 -0700917static DEFINE_SPINLOCK(ndisc_lock);
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700918
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900919struct dst_entry *ndisc_dst_alloc(struct net_device *dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 struct neighbour *neigh,
921 struct in6_addr *addr,
922 int (*output)(struct sk_buff *))
923{
924 struct rt6_info *rt;
925 struct inet6_dev *idev = in6_dev_get(dev);
926
927 if (unlikely(idev == NULL))
928 return NULL;
929
930 rt = ip6_dst_alloc();
931 if (unlikely(rt == NULL)) {
932 in6_dev_put(idev);
933 goto out;
934 }
935
936 dev_hold(dev);
937 if (neigh)
938 neigh_hold(neigh);
939 else
940 neigh = ndisc_get_neigh(dev, addr);
941
942 rt->rt6i_dev = dev;
943 rt->rt6i_idev = idev;
944 rt->rt6i_nexthop = neigh;
945 atomic_set(&rt->u.dst.__refcnt, 1);
946 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
947 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
948 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
949 rt->u.dst.output = output;
950
951#if 0 /* there's no chance to use these for ndisc */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900952 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
953 ? DST_HOST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 : 0;
955 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
956 rt->rt6i_dst.plen = 128;
957#endif
958
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700959 spin_lock_bh(&ndisc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 rt->u.dst.next = ndisc_dst_gc_list;
961 ndisc_dst_gc_list = &rt->u.dst;
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700962 spin_unlock_bh(&ndisc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
964 fib6_force_start_gc();
965
966out:
YOSHIFUJI Hideaki40aa7b92006-10-19 13:50:09 +0900967 return &rt->u.dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968}
969
970int ndisc_dst_gc(int *more)
971{
972 struct dst_entry *dst, *next, **pprev;
973 int freed;
974
975 next = NULL;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900976 freed = 0;
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700977
978 spin_lock_bh(&ndisc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 pprev = &ndisc_dst_gc_list;
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700980
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 while ((dst = *pprev) != NULL) {
982 if (!atomic_read(&dst->__refcnt)) {
983 *pprev = dst->next;
984 dst_free(dst);
985 freed++;
986 } else {
987 pprev = &dst->next;
988 (*more)++;
989 }
990 }
991
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700992 spin_unlock_bh(&ndisc_lock);
993
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 return freed;
995}
996
997static int ip6_dst_gc(void)
998{
999 static unsigned expire = 30*HZ;
1000 static unsigned long last_gc;
1001 unsigned long now = jiffies;
1002
1003 if (time_after(last_gc + ip6_rt_gc_min_interval, now) &&
1004 atomic_read(&ip6_dst_ops.entries) <= ip6_rt_max_size)
1005 goto out;
1006
1007 expire++;
1008 fib6_run_gc(expire);
1009 last_gc = now;
1010 if (atomic_read(&ip6_dst_ops.entries) < ip6_dst_ops.gc_thresh)
1011 expire = ip6_rt_gc_timeout>>1;
1012
1013out:
1014 expire -= expire>>ip6_rt_gc_elasticity;
1015 return (atomic_read(&ip6_dst_ops.entries) > ip6_rt_max_size);
1016}
1017
1018/* Clean host part of a prefix. Not necessary in radix tree,
1019 but results in cleaner routing tables.
1020
1021 Remove it only when all the things will work!
1022 */
1023
1024static int ipv6_get_mtu(struct net_device *dev)
1025{
1026 int mtu = IPV6_MIN_MTU;
1027 struct inet6_dev *idev;
1028
1029 idev = in6_dev_get(dev);
1030 if (idev) {
1031 mtu = idev->cnf.mtu6;
1032 in6_dev_put(idev);
1033 }
1034 return mtu;
1035}
1036
1037int ipv6_get_hoplimit(struct net_device *dev)
1038{
1039 int hoplimit = ipv6_devconf.hop_limit;
1040 struct inet6_dev *idev;
1041
1042 idev = in6_dev_get(dev);
1043 if (idev) {
1044 hoplimit = idev->cnf.hop_limit;
1045 in6_dev_put(idev);
1046 }
1047 return hoplimit;
1048}
1049
1050/*
1051 *
1052 */
1053
Thomas Graf86872cb2006-08-22 00:01:08 -07001054int ip6_route_add(struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055{
1056 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 struct rt6_info *rt = NULL;
1058 struct net_device *dev = NULL;
1059 struct inet6_dev *idev = NULL;
Thomas Grafc71099a2006-08-04 23:20:06 -07001060 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 int addr_type;
1062
Thomas Graf86872cb2006-08-22 00:01:08 -07001063 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 return -EINVAL;
1065#ifndef CONFIG_IPV6_SUBTREES
Thomas Graf86872cb2006-08-22 00:01:08 -07001066 if (cfg->fc_src_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 return -EINVAL;
1068#endif
Thomas Graf86872cb2006-08-22 00:01:08 -07001069 if (cfg->fc_ifindex) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 err = -ENODEV;
Thomas Graf86872cb2006-08-22 00:01:08 -07001071 dev = dev_get_by_index(cfg->fc_ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 if (!dev)
1073 goto out;
1074 idev = in6_dev_get(dev);
1075 if (!idev)
1076 goto out;
1077 }
1078
Thomas Graf86872cb2006-08-22 00:01:08 -07001079 if (cfg->fc_metric == 0)
1080 cfg->fc_metric = IP6_RT_PRIO_USER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081
Thomas Graf86872cb2006-08-22 00:01:08 -07001082 table = fib6_new_table(cfg->fc_table);
Thomas Grafc71099a2006-08-04 23:20:06 -07001083 if (table == NULL) {
1084 err = -ENOBUFS;
1085 goto out;
1086 }
1087
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 rt = ip6_dst_alloc();
1089
1090 if (rt == NULL) {
1091 err = -ENOMEM;
1092 goto out;
1093 }
1094
1095 rt->u.dst.obsolete = -1;
Thomas Graf86872cb2006-08-22 00:01:08 -07001096 rt->rt6i_expires = jiffies + clock_t_to_jiffies(cfg->fc_expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097
Thomas Graf86872cb2006-08-22 00:01:08 -07001098 if (cfg->fc_protocol == RTPROT_UNSPEC)
1099 cfg->fc_protocol = RTPROT_BOOT;
1100 rt->rt6i_protocol = cfg->fc_protocol;
1101
1102 addr_type = ipv6_addr_type(&cfg->fc_dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103
1104 if (addr_type & IPV6_ADDR_MULTICAST)
1105 rt->u.dst.input = ip6_mc_input;
1106 else
1107 rt->u.dst.input = ip6_forward;
1108
1109 rt->u.dst.output = ip6_output;
1110
Thomas Graf86872cb2006-08-22 00:01:08 -07001111 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1112 rt->rt6i_dst.plen = cfg->fc_dst_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 if (rt->rt6i_dst.plen == 128)
1114 rt->u.dst.flags = DST_HOST;
1115
1116#ifdef CONFIG_IPV6_SUBTREES
Thomas Graf86872cb2006-08-22 00:01:08 -07001117 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1118 rt->rt6i_src.plen = cfg->fc_src_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119#endif
1120
Thomas Graf86872cb2006-08-22 00:01:08 -07001121 rt->rt6i_metric = cfg->fc_metric;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122
1123 /* We cannot add true routes via loopback here,
1124 they would result in kernel looping; promote them to reject routes
1125 */
Thomas Graf86872cb2006-08-22 00:01:08 -07001126 if ((cfg->fc_flags & RTF_REJECT) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
1128 /* hold loopback dev/idev if we haven't done so. */
1129 if (dev != &loopback_dev) {
1130 if (dev) {
1131 dev_put(dev);
1132 in6_dev_put(idev);
1133 }
1134 dev = &loopback_dev;
1135 dev_hold(dev);
1136 idev = in6_dev_get(dev);
1137 if (!idev) {
1138 err = -ENODEV;
1139 goto out;
1140 }
1141 }
1142 rt->u.dst.output = ip6_pkt_discard_out;
1143 rt->u.dst.input = ip6_pkt_discard;
1144 rt->u.dst.error = -ENETUNREACH;
1145 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1146 goto install_route;
1147 }
1148
Thomas Graf86872cb2006-08-22 00:01:08 -07001149 if (cfg->fc_flags & RTF_GATEWAY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 struct in6_addr *gw_addr;
1151 int gwa_type;
1152
Thomas Graf86872cb2006-08-22 00:01:08 -07001153 gw_addr = &cfg->fc_gateway;
1154 ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 gwa_type = ipv6_addr_type(gw_addr);
1156
1157 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1158 struct rt6_info *grt;
1159
1160 /* IPv6 strictly inhibits using not link-local
1161 addresses as nexthop address.
1162 Otherwise, router will not able to send redirects.
1163 It is very good, but in some (rare!) circumstances
1164 (SIT, PtP, NBMA NOARP links) it is handy to allow
1165 some exceptions. --ANK
1166 */
1167 err = -EINVAL;
1168 if (!(gwa_type&IPV6_ADDR_UNICAST))
1169 goto out;
1170
Thomas Graf86872cb2006-08-22 00:01:08 -07001171 grt = rt6_lookup(gw_addr, NULL, cfg->fc_ifindex, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172
1173 err = -EHOSTUNREACH;
1174 if (grt == NULL)
1175 goto out;
1176 if (dev) {
1177 if (dev != grt->rt6i_dev) {
1178 dst_release(&grt->u.dst);
1179 goto out;
1180 }
1181 } else {
1182 dev = grt->rt6i_dev;
1183 idev = grt->rt6i_idev;
1184 dev_hold(dev);
1185 in6_dev_hold(grt->rt6i_idev);
1186 }
1187 if (!(grt->rt6i_flags&RTF_GATEWAY))
1188 err = 0;
1189 dst_release(&grt->u.dst);
1190
1191 if (err)
1192 goto out;
1193 }
1194 err = -EINVAL;
1195 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
1196 goto out;
1197 }
1198
1199 err = -ENODEV;
1200 if (dev == NULL)
1201 goto out;
1202
Thomas Graf86872cb2006-08-22 00:01:08 -07001203 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
1205 if (IS_ERR(rt->rt6i_nexthop)) {
1206 err = PTR_ERR(rt->rt6i_nexthop);
1207 rt->rt6i_nexthop = NULL;
1208 goto out;
1209 }
1210 }
1211
Thomas Graf86872cb2006-08-22 00:01:08 -07001212 rt->rt6i_flags = cfg->fc_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213
1214install_route:
Thomas Graf86872cb2006-08-22 00:01:08 -07001215 if (cfg->fc_mx) {
1216 struct nlattr *nla;
1217 int remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218
Thomas Graf86872cb2006-08-22 00:01:08 -07001219 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1220 int type = nla->nla_type;
1221
1222 if (type) {
1223 if (type > RTAX_MAX) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 err = -EINVAL;
1225 goto out;
1226 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001227
1228 rt->u.dst.metrics[type - 1] = nla_get_u32(nla);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 }
1231 }
1232
1233 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
1234 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1235 if (!rt->u.dst.metrics[RTAX_MTU-1])
1236 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
1237 if (!rt->u.dst.metrics[RTAX_ADVMSS-1])
1238 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1239 rt->u.dst.dev = dev;
1240 rt->rt6i_idev = idev;
Thomas Grafc71099a2006-08-04 23:20:06 -07001241 rt->rt6i_table = table;
Thomas Graf86872cb2006-08-22 00:01:08 -07001242 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243
1244out:
1245 if (dev)
1246 dev_put(dev);
1247 if (idev)
1248 in6_dev_put(idev);
1249 if (rt)
YOSHIFUJI Hideaki40aa7b92006-10-19 13:50:09 +09001250 dst_free(&rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 return err;
1252}
1253
Thomas Graf86872cb2006-08-22 00:01:08 -07001254static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255{
1256 int err;
Thomas Grafc71099a2006-08-04 23:20:06 -07001257 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258
Patrick McHardy6c813a72006-08-06 22:22:47 -07001259 if (rt == &ip6_null_entry)
1260 return -ENOENT;
1261
Thomas Grafc71099a2006-08-04 23:20:06 -07001262 table = rt->rt6i_table;
1263 write_lock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264
Thomas Graf86872cb2006-08-22 00:01:08 -07001265 err = fib6_del(rt, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 dst_release(&rt->u.dst);
1267
Thomas Grafc71099a2006-08-04 23:20:06 -07001268 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269
1270 return err;
1271}
1272
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001273int ip6_del_rt(struct rt6_info *rt)
1274{
Thomas Graf86872cb2006-08-22 00:01:08 -07001275 return __ip6_del_rt(rt, NULL);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001276}
1277
Thomas Graf86872cb2006-08-22 00:01:08 -07001278static int ip6_route_del(struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279{
Thomas Grafc71099a2006-08-04 23:20:06 -07001280 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 struct fib6_node *fn;
1282 struct rt6_info *rt;
1283 int err = -ESRCH;
1284
Thomas Graf86872cb2006-08-22 00:01:08 -07001285 table = fib6_get_table(cfg->fc_table);
Thomas Grafc71099a2006-08-04 23:20:06 -07001286 if (table == NULL)
1287 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
Thomas Grafc71099a2006-08-04 23:20:06 -07001289 read_lock_bh(&table->tb6_lock);
1290
1291 fn = fib6_locate(&table->tb6_root,
Thomas Graf86872cb2006-08-22 00:01:08 -07001292 &cfg->fc_dst, cfg->fc_dst_len,
1293 &cfg->fc_src, cfg->fc_src_len);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001294
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 if (fn) {
Eric Dumazet7cc48262007-02-09 16:22:57 -08001296 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
Thomas Graf86872cb2006-08-22 00:01:08 -07001297 if (cfg->fc_ifindex &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 (rt->rt6i_dev == NULL ||
Thomas Graf86872cb2006-08-22 00:01:08 -07001299 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 continue;
Thomas Graf86872cb2006-08-22 00:01:08 -07001301 if (cfg->fc_flags & RTF_GATEWAY &&
1302 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 continue;
Thomas Graf86872cb2006-08-22 00:01:08 -07001304 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 continue;
1306 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001307 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
Thomas Graf86872cb2006-08-22 00:01:08 -07001309 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 }
1311 }
Thomas Grafc71099a2006-08-04 23:20:06 -07001312 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313
1314 return err;
1315}
1316
1317/*
1318 * Handle redirects
1319 */
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001320struct ip6rd_flowi {
1321 struct flowi fl;
1322 struct in6_addr gateway;
1323};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001325static struct rt6_info *__ip6_route_redirect(struct fib6_table *table,
1326 struct flowi *fl,
1327 int flags)
1328{
1329 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1330 struct rt6_info *rt;
1331 struct fib6_node *fn;
Thomas Grafc71099a2006-08-04 23:20:06 -07001332
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 /*
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001334 * Get the "current" route for this destination and
1335 * check if the redirect has come from approriate router.
1336 *
1337 * RFC 2461 specifies that redirects should only be
1338 * accepted if they come from the nexthop to the target.
1339 * Due to the way the routes are chosen, this notion
1340 * is a bit fuzzy and one might need to check all possible
1341 * routes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
Thomas Grafc71099a2006-08-04 23:20:06 -07001344 read_lock_bh(&table->tb6_lock);
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001345 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001346restart:
Eric Dumazet7cc48262007-02-09 16:22:57 -08001347 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001348 /*
1349 * Current route is on-link; redirect is always invalid.
1350 *
1351 * Seems, previous statement is not true. It could
1352 * be node, which looks for us as on-link (f.e. proxy ndisc)
1353 * But then router serving it might decide, that we should
1354 * know truth 8)8) --ANK (980726).
1355 */
1356 if (rt6_check_expired(rt))
1357 continue;
1358 if (!(rt->rt6i_flags & RTF_GATEWAY))
1359 continue;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001360 if (fl->oif != rt->rt6i_dev->ifindex)
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001361 continue;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001362 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001363 continue;
1364 break;
1365 }
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001366
YOSHIFUJI Hideakicb15d9c2006-08-23 17:23:11 -07001367 if (!rt)
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001368 rt = &ip6_null_entry;
YOSHIFUJI Hideakicb15d9c2006-08-23 17:23:11 -07001369 BACKTRACK(&fl->fl6_src);
1370out:
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001371 dst_hold(&rt->u.dst);
1372
1373 read_unlock_bh(&table->tb6_lock);
1374
1375 return rt;
1376};
1377
1378static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1379 struct in6_addr *src,
1380 struct in6_addr *gateway,
1381 struct net_device *dev)
1382{
Thomas Grafadaa70b2006-10-13 15:01:03 -07001383 int flags = RT6_LOOKUP_F_HAS_SADDR;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001384 struct ip6rd_flowi rdfl = {
1385 .fl = {
1386 .oif = dev->ifindex,
1387 .nl_u = {
1388 .ip6_u = {
1389 .daddr = *dest,
1390 .saddr = *src,
1391 },
1392 },
1393 },
1394 .gateway = *gateway,
1395 };
Thomas Grafadaa70b2006-10-13 15:01:03 -07001396
1397 if (rt6_need_strict(dest))
1398 flags |= RT6_LOOKUP_F_IFACE;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001399
1400 return (struct rt6_info *)fib6_rule_lookup((struct flowi *)&rdfl, flags, __ip6_route_redirect);
1401}
1402
1403void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1404 struct in6_addr *saddr,
1405 struct neighbour *neigh, u8 *lladdr, int on_link)
1406{
1407 struct rt6_info *rt, *nrt = NULL;
1408 struct netevent_redirect netevent;
1409
1410 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1411
1412 if (rt == &ip6_null_entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 if (net_ratelimit())
1414 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1415 "for redirect target\n");
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001416 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 }
1418
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 /*
1420 * We have finally decided to accept it.
1421 */
1422
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001423 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1425 NEIGH_UPDATE_F_OVERRIDE|
1426 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1427 NEIGH_UPDATE_F_ISROUTER))
1428 );
1429
1430 /*
1431 * Redirect received -> path was valid.
1432 * Look, redirects are sent only in response to data packets,
1433 * so that this nexthop apparently is reachable. --ANK
1434 */
1435 dst_confirm(&rt->u.dst);
1436
1437 /* Duplicate redirect: silently ignore. */
1438 if (neigh == rt->u.dst.neighbour)
1439 goto out;
1440
1441 nrt = ip6_rt_copy(rt);
1442 if (nrt == NULL)
1443 goto out;
1444
1445 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1446 if (on_link)
1447 nrt->rt6i_flags &= ~RTF_GATEWAY;
1448
1449 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1450 nrt->rt6i_dst.plen = 128;
1451 nrt->u.dst.flags |= DST_HOST;
1452
1453 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1454 nrt->rt6i_nexthop = neigh_clone(neigh);
1455 /* Reset pmtu, it may be better */
1456 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1457 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1458
Thomas Graf40e22e82006-08-22 00:00:45 -07001459 if (ip6_ins_rt(nrt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 goto out;
1461
Tom Tucker8d717402006-07-30 20:43:36 -07001462 netevent.old = &rt->u.dst;
1463 netevent.new = &nrt->u.dst;
1464 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1465
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 if (rt->rt6i_flags&RTF_CACHE) {
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001467 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 return;
1469 }
1470
1471out:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001472 dst_release(&rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 return;
1474}
1475
1476/*
1477 * Handle ICMP "packet too big" messages
1478 * i.e. Path MTU discovery
1479 */
1480
1481void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1482 struct net_device *dev, u32 pmtu)
1483{
1484 struct rt6_info *rt, *nrt;
1485 int allfrag = 0;
1486
1487 rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1488 if (rt == NULL)
1489 return;
1490
1491 if (pmtu >= dst_mtu(&rt->u.dst))
1492 goto out;
1493
1494 if (pmtu < IPV6_MIN_MTU) {
1495 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001496 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 * MTU (1280) and a fragment header should always be included
1498 * after a node receiving Too Big message reporting PMTU is
1499 * less than the IPv6 Minimum Link MTU.
1500 */
1501 pmtu = IPV6_MIN_MTU;
1502 allfrag = 1;
1503 }
1504
1505 /* New mtu received -> path was valid.
1506 They are sent only in response to data packets,
1507 so that this nexthop apparently is reachable. --ANK
1508 */
1509 dst_confirm(&rt->u.dst);
1510
1511 /* Host route. If it is static, it would be better
1512 not to override it, but add new one, so that
1513 when cache entry will expire old pmtu
1514 would return automatically.
1515 */
1516 if (rt->rt6i_flags & RTF_CACHE) {
1517 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1518 if (allfrag)
1519 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1520 dst_set_expires(&rt->u.dst, ip6_rt_mtu_expires);
1521 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1522 goto out;
1523 }
1524
1525 /* Network route.
1526 Two cases are possible:
1527 1. It is connected route. Action: COW
1528 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1529 */
YOSHIFUJI Hideakid5315b52006-03-20 16:58:48 -08001530 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001531 nrt = rt6_alloc_cow(rt, daddr, saddr);
YOSHIFUJI Hideakid5315b52006-03-20 16:58:48 -08001532 else
1533 nrt = rt6_alloc_clone(rt, daddr);
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001534
YOSHIFUJI Hideakid5315b52006-03-20 16:58:48 -08001535 if (nrt) {
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001536 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1537 if (allfrag)
1538 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1539
1540 /* According to RFC 1981, detecting PMTU increase shouldn't be
1541 * happened within 5 mins, the recommended timer is 10 mins.
1542 * Here this route expiration time is set to ip6_rt_mtu_expires
1543 * which is 10 mins. After 10 mins the decreased pmtu is expired
1544 * and detecting PMTU increase will be automatically happened.
1545 */
1546 dst_set_expires(&nrt->u.dst, ip6_rt_mtu_expires);
1547 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1548
Thomas Graf40e22e82006-08-22 00:00:45 -07001549 ip6_ins_rt(nrt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551out:
1552 dst_release(&rt->u.dst);
1553}
1554
1555/*
1556 * Misc support functions
1557 */
1558
1559static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1560{
1561 struct rt6_info *rt = ip6_dst_alloc();
1562
1563 if (rt) {
1564 rt->u.dst.input = ort->u.dst.input;
1565 rt->u.dst.output = ort->u.dst.output;
1566
1567 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
Ville Nuorvala22e1e4d2006-10-16 22:14:26 -07001568 rt->u.dst.error = ort->u.dst.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 rt->u.dst.dev = ort->u.dst.dev;
1570 if (rt->u.dst.dev)
1571 dev_hold(rt->u.dst.dev);
1572 rt->rt6i_idev = ort->rt6i_idev;
1573 if (rt->rt6i_idev)
1574 in6_dev_hold(rt->rt6i_idev);
1575 rt->u.dst.lastuse = jiffies;
1576 rt->rt6i_expires = 0;
1577
1578 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1579 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1580 rt->rt6i_metric = 0;
1581
1582 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1583#ifdef CONFIG_IPV6_SUBTREES
1584 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1585#endif
Thomas Grafc71099a2006-08-04 23:20:06 -07001586 rt->rt6i_table = ort->rt6i_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 }
1588 return rt;
1589}
1590
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001591#ifdef CONFIG_IPV6_ROUTE_INFO
1592static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
1593 struct in6_addr *gwaddr, int ifindex)
1594{
1595 struct fib6_node *fn;
1596 struct rt6_info *rt = NULL;
Thomas Grafc71099a2006-08-04 23:20:06 -07001597 struct fib6_table *table;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001598
Thomas Grafc71099a2006-08-04 23:20:06 -07001599 table = fib6_get_table(RT6_TABLE_INFO);
1600 if (table == NULL)
1601 return NULL;
1602
1603 write_lock_bh(&table->tb6_lock);
1604 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001605 if (!fn)
1606 goto out;
1607
Eric Dumazet7cc48262007-02-09 16:22:57 -08001608 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001609 if (rt->rt6i_dev->ifindex != ifindex)
1610 continue;
1611 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1612 continue;
1613 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1614 continue;
1615 dst_hold(&rt->u.dst);
1616 break;
1617 }
1618out:
Thomas Grafc71099a2006-08-04 23:20:06 -07001619 write_unlock_bh(&table->tb6_lock);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001620 return rt;
1621}
1622
1623static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
1624 struct in6_addr *gwaddr, int ifindex,
1625 unsigned pref)
1626{
Thomas Graf86872cb2006-08-22 00:01:08 -07001627 struct fib6_config cfg = {
1628 .fc_table = RT6_TABLE_INFO,
1629 .fc_metric = 1024,
1630 .fc_ifindex = ifindex,
1631 .fc_dst_len = prefixlen,
1632 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1633 RTF_UP | RTF_PREF(pref),
1634 };
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001635
Thomas Graf86872cb2006-08-22 00:01:08 -07001636 ipv6_addr_copy(&cfg.fc_dst, prefix);
1637 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1638
YOSHIFUJI Hideakie317da92006-03-20 17:06:42 -08001639 /* We should treat it as a default route if prefix length is 0. */
1640 if (!prefixlen)
Thomas Graf86872cb2006-08-22 00:01:08 -07001641 cfg.fc_flags |= RTF_DEFAULT;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001642
Thomas Graf86872cb2006-08-22 00:01:08 -07001643 ip6_route_add(&cfg);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001644
1645 return rt6_get_route_info(prefix, prefixlen, gwaddr, ifindex);
1646}
1647#endif
1648
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001650{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 struct rt6_info *rt;
Thomas Grafc71099a2006-08-04 23:20:06 -07001652 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
Thomas Grafc71099a2006-08-04 23:20:06 -07001654 table = fib6_get_table(RT6_TABLE_DFLT);
1655 if (table == NULL)
1656 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657
Thomas Grafc71099a2006-08-04 23:20:06 -07001658 write_lock_bh(&table->tb6_lock);
Eric Dumazet7cc48262007-02-09 16:22:57 -08001659 for (rt = table->tb6_root.leaf; rt; rt=rt->u.dst.rt6_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 if (dev == rt->rt6i_dev &&
YOSHIFUJI Hideaki045927f2006-03-20 17:00:48 -08001661 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1663 break;
1664 }
1665 if (rt)
1666 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001667 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 return rt;
1669}
1670
1671struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001672 struct net_device *dev,
1673 unsigned int pref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674{
Thomas Graf86872cb2006-08-22 00:01:08 -07001675 struct fib6_config cfg = {
1676 .fc_table = RT6_TABLE_DFLT,
1677 .fc_metric = 1024,
1678 .fc_ifindex = dev->ifindex,
1679 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1680 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1681 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682
Thomas Graf86872cb2006-08-22 00:01:08 -07001683 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684
Thomas Graf86872cb2006-08-22 00:01:08 -07001685 ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 return rt6_get_dflt_router(gwaddr, dev);
1688}
1689
1690void rt6_purge_dflt_routers(void)
1691{
1692 struct rt6_info *rt;
Thomas Grafc71099a2006-08-04 23:20:06 -07001693 struct fib6_table *table;
1694
1695 /* NOTE: Keep consistent with rt6_get_dflt_router */
1696 table = fib6_get_table(RT6_TABLE_DFLT);
1697 if (table == NULL)
1698 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699
1700restart:
Thomas Grafc71099a2006-08-04 23:20:06 -07001701 read_lock_bh(&table->tb6_lock);
Eric Dumazet7cc48262007-02-09 16:22:57 -08001702 for (rt = table->tb6_root.leaf; rt; rt = rt->u.dst.rt6_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1704 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001705 read_unlock_bh(&table->tb6_lock);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001706 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 goto restart;
1708 }
1709 }
Thomas Grafc71099a2006-08-04 23:20:06 -07001710 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711}
1712
Thomas Graf86872cb2006-08-22 00:01:08 -07001713static void rtmsg_to_fib6_config(struct in6_rtmsg *rtmsg,
1714 struct fib6_config *cfg)
1715{
1716 memset(cfg, 0, sizeof(*cfg));
1717
1718 cfg->fc_table = RT6_TABLE_MAIN;
1719 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1720 cfg->fc_metric = rtmsg->rtmsg_metric;
1721 cfg->fc_expires = rtmsg->rtmsg_info;
1722 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1723 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1724 cfg->fc_flags = rtmsg->rtmsg_flags;
1725
1726 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1727 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1728 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1729}
1730
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1732{
Thomas Graf86872cb2006-08-22 00:01:08 -07001733 struct fib6_config cfg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 struct in6_rtmsg rtmsg;
1735 int err;
1736
1737 switch(cmd) {
1738 case SIOCADDRT: /* Add a route */
1739 case SIOCDELRT: /* Delete a route */
1740 if (!capable(CAP_NET_ADMIN))
1741 return -EPERM;
1742 err = copy_from_user(&rtmsg, arg,
1743 sizeof(struct in6_rtmsg));
1744 if (err)
1745 return -EFAULT;
Thomas Graf86872cb2006-08-22 00:01:08 -07001746
1747 rtmsg_to_fib6_config(&rtmsg, &cfg);
1748
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 rtnl_lock();
1750 switch (cmd) {
1751 case SIOCADDRT:
Thomas Graf86872cb2006-08-22 00:01:08 -07001752 err = ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 break;
1754 case SIOCDELRT:
Thomas Graf86872cb2006-08-22 00:01:08 -07001755 err = ip6_route_del(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 break;
1757 default:
1758 err = -EINVAL;
1759 }
1760 rtnl_unlock();
1761
1762 return err;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001763 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764
1765 return -EINVAL;
1766}
1767
1768/*
1769 * Drop the packet on the floor
1770 */
1771
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001772static inline int ip6_pkt_drop(struct sk_buff *skb, int code,
1773 int ipstats_mib_noroutes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001775 int type;
1776 switch (ipstats_mib_noroutes) {
1777 case IPSTATS_MIB_INNOROUTES:
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001778 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001779 if (type == IPV6_ADDR_ANY || type == IPV6_ADDR_RESERVED) {
1780 IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
1781 break;
1782 }
1783 /* FALLTHROUGH */
1784 case IPSTATS_MIB_OUTNOROUTES:
1785 IP6_INC_STATS(ip6_dst_idev(skb->dst), ipstats_mib_noroutes);
1786 break;
1787 }
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001788 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 kfree_skb(skb);
1790 return 0;
1791}
1792
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001793static int ip6_pkt_discard(struct sk_buff *skb)
1794{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001795 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001796}
1797
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001798static int ip6_pkt_discard_out(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799{
1800 skb->dev = skb->dst->dev;
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001801 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802}
1803
David S. Miller6723ab52006-10-18 21:20:57 -07001804#ifdef CONFIG_IPV6_MULTIPLE_TABLES
1805
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001806static int ip6_pkt_prohibit(struct sk_buff *skb)
1807{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001808 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001809}
1810
1811static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1812{
1813 skb->dev = skb->dst->dev;
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001814 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001815}
1816
1817static int ip6_pkt_blk_hole(struct sk_buff *skb)
1818{
1819 kfree_skb(skb);
1820 return 0;
1821}
1822
David S. Miller6723ab52006-10-18 21:20:57 -07001823#endif
1824
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825/*
1826 * Allocate a dst for local (unicast / anycast) address.
1827 */
1828
1829struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1830 const struct in6_addr *addr,
1831 int anycast)
1832{
1833 struct rt6_info *rt = ip6_dst_alloc();
1834
1835 if (rt == NULL)
1836 return ERR_PTR(-ENOMEM);
1837
1838 dev_hold(&loopback_dev);
1839 in6_dev_hold(idev);
1840
1841 rt->u.dst.flags = DST_HOST;
1842 rt->u.dst.input = ip6_input;
1843 rt->u.dst.output = ip6_output;
1844 rt->rt6i_dev = &loopback_dev;
1845 rt->rt6i_idev = idev;
1846 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1847 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1848 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1849 rt->u.dst.obsolete = -1;
1850
1851 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +09001852 if (anycast)
1853 rt->rt6i_flags |= RTF_ANYCAST;
1854 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 rt->rt6i_flags |= RTF_LOCAL;
1856 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1857 if (rt->rt6i_nexthop == NULL) {
YOSHIFUJI Hideaki40aa7b92006-10-19 13:50:09 +09001858 dst_free(&rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 return ERR_PTR(-ENOMEM);
1860 }
1861
1862 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1863 rt->rt6i_dst.plen = 128;
Thomas Grafc71099a2006-08-04 23:20:06 -07001864 rt->rt6i_table = fib6_get_table(RT6_TABLE_LOCAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
1866 atomic_set(&rt->u.dst.__refcnt, 1);
1867
1868 return rt;
1869}
1870
1871static int fib6_ifdown(struct rt6_info *rt, void *arg)
1872{
1873 if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1874 rt != &ip6_null_entry) {
1875 RT6_TRACE("deleted by ifdown %p\n", rt);
1876 return -1;
1877 }
1878 return 0;
1879}
1880
1881void rt6_ifdown(struct net_device *dev)
1882{
Thomas Grafc71099a2006-08-04 23:20:06 -07001883 fib6_clean_all(fib6_ifdown, 0, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884}
1885
1886struct rt6_mtu_change_arg
1887{
1888 struct net_device *dev;
1889 unsigned mtu;
1890};
1891
1892static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1893{
1894 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1895 struct inet6_dev *idev;
1896
1897 /* In IPv6 pmtu discovery is not optional,
1898 so that RTAX_MTU lock cannot disable it.
1899 We still use this lock to block changes
1900 caused by addrconf/ndisc.
1901 */
1902
1903 idev = __in6_dev_get(arg->dev);
1904 if (idev == NULL)
1905 return 0;
1906
1907 /* For administrative MTU increase, there is no way to discover
1908 IPv6 PMTU increase, so PMTU increase should be updated here.
1909 Since RFC 1981 doesn't include administrative MTU increase
1910 update PMTU increase is a MUST. (i.e. jumbo frame)
1911 */
1912 /*
1913 If new MTU is less than route PMTU, this new MTU will be the
1914 lowest MTU in the path, update the route PMTU to reflect PMTU
1915 decreases; if new MTU is greater than route PMTU, and the
1916 old MTU is the lowest MTU in the path, update the route PMTU
1917 to reflect the increase. In this case if the other nodes' MTU
1918 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1919 PMTU discouvery.
1920 */
1921 if (rt->rt6i_dev == arg->dev &&
1922 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001923 (dst_mtu(&rt->u.dst) > arg->mtu ||
1924 (dst_mtu(&rt->u.dst) < arg->mtu &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 dst_mtu(&rt->u.dst) == idev->cnf.mtu6)))
1926 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
1927 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1928 return 0;
1929}
1930
1931void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1932{
Thomas Grafc71099a2006-08-04 23:20:06 -07001933 struct rt6_mtu_change_arg arg = {
1934 .dev = dev,
1935 .mtu = mtu,
1936 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937
Thomas Grafc71099a2006-08-04 23:20:06 -07001938 fib6_clean_all(rt6_mtu_change_route, 0, &arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939}
1940
Thomas Graf86872cb2006-08-22 00:01:08 -07001941static struct nla_policy rtm_ipv6_policy[RTA_MAX+1] __read_mostly = {
Thomas Graf5176f912006-08-26 20:13:18 -07001942 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
Thomas Graf86872cb2006-08-22 00:01:08 -07001943 [RTA_OIF] = { .type = NLA_U32 },
Thomas Grafab364a62006-08-22 00:01:47 -07001944 [RTA_IIF] = { .type = NLA_U32 },
Thomas Graf86872cb2006-08-22 00:01:08 -07001945 [RTA_PRIORITY] = { .type = NLA_U32 },
1946 [RTA_METRICS] = { .type = NLA_NESTED },
1947};
1948
1949static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
1950 struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951{
Thomas Graf86872cb2006-08-22 00:01:08 -07001952 struct rtmsg *rtm;
1953 struct nlattr *tb[RTA_MAX+1];
1954 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955
Thomas Graf86872cb2006-08-22 00:01:08 -07001956 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
1957 if (err < 0)
1958 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959
Thomas Graf86872cb2006-08-22 00:01:08 -07001960 err = -EINVAL;
1961 rtm = nlmsg_data(nlh);
1962 memset(cfg, 0, sizeof(*cfg));
1963
1964 cfg->fc_table = rtm->rtm_table;
1965 cfg->fc_dst_len = rtm->rtm_dst_len;
1966 cfg->fc_src_len = rtm->rtm_src_len;
1967 cfg->fc_flags = RTF_UP;
1968 cfg->fc_protocol = rtm->rtm_protocol;
1969
1970 if (rtm->rtm_type == RTN_UNREACHABLE)
1971 cfg->fc_flags |= RTF_REJECT;
1972
1973 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
1974 cfg->fc_nlinfo.nlh = nlh;
1975
1976 if (tb[RTA_GATEWAY]) {
1977 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
1978 cfg->fc_flags |= RTF_GATEWAY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001980
1981 if (tb[RTA_DST]) {
1982 int plen = (rtm->rtm_dst_len + 7) >> 3;
1983
1984 if (nla_len(tb[RTA_DST]) < plen)
1985 goto errout;
1986
1987 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001989
1990 if (tb[RTA_SRC]) {
1991 int plen = (rtm->rtm_src_len + 7) >> 3;
1992
1993 if (nla_len(tb[RTA_SRC]) < plen)
1994 goto errout;
1995
1996 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001998
1999 if (tb[RTA_OIF])
2000 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2001
2002 if (tb[RTA_PRIORITY])
2003 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2004
2005 if (tb[RTA_METRICS]) {
2006 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2007 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002009
2010 if (tb[RTA_TABLE])
2011 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2012
2013 err = 0;
2014errout:
2015 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016}
2017
Thomas Grafc127ea22007-03-22 11:58:32 -07002018static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019{
Thomas Graf86872cb2006-08-22 00:01:08 -07002020 struct fib6_config cfg;
2021 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022
Thomas Graf86872cb2006-08-22 00:01:08 -07002023 err = rtm_to_fib6_config(skb, nlh, &cfg);
2024 if (err < 0)
2025 return err;
2026
2027 return ip6_route_del(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028}
2029
Thomas Grafc127ea22007-03-22 11:58:32 -07002030static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031{
Thomas Graf86872cb2006-08-22 00:01:08 -07002032 struct fib6_config cfg;
2033 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034
Thomas Graf86872cb2006-08-22 00:01:08 -07002035 err = rtm_to_fib6_config(skb, nlh, &cfg);
2036 if (err < 0)
2037 return err;
2038
2039 return ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040}
2041
Thomas Graf339bf982006-11-10 14:10:15 -08002042static inline size_t rt6_nlmsg_size(void)
2043{
2044 return NLMSG_ALIGN(sizeof(struct rtmsg))
2045 + nla_total_size(16) /* RTA_SRC */
2046 + nla_total_size(16) /* RTA_DST */
2047 + nla_total_size(16) /* RTA_GATEWAY */
2048 + nla_total_size(16) /* RTA_PREFSRC */
2049 + nla_total_size(4) /* RTA_TABLE */
2050 + nla_total_size(4) /* RTA_IIF */
2051 + nla_total_size(4) /* RTA_OIF */
2052 + nla_total_size(4) /* RTA_PRIORITY */
Noriaki TAKAMIYA6a2b9ce2007-01-23 22:09:41 -08002053 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
Thomas Graf339bf982006-11-10 14:10:15 -08002054 + nla_total_size(sizeof(struct rta_cacheinfo));
2055}
2056
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
Jamal Hadi Salim0d51aa82005-06-21 13:51:04 -07002058 struct in6_addr *dst, struct in6_addr *src,
2059 int iif, int type, u32 pid, u32 seq,
2060 int prefix, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061{
2062 struct rtmsg *rtm;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002063 struct nlmsghdr *nlh;
Thomas Grafe3703b32006-11-27 09:27:07 -08002064 long expires;
Patrick McHardy9e762a42006-08-10 23:09:48 -07002065 u32 table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066
2067 if (prefix) { /* user wants prefix routes only */
2068 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2069 /* success since this is not a prefix route */
2070 return 1;
2071 }
2072 }
2073
Thomas Graf2d7202b2006-08-22 00:01:27 -07002074 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2075 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08002076 return -EMSGSIZE;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002077
2078 rtm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079 rtm->rtm_family = AF_INET6;
2080 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2081 rtm->rtm_src_len = rt->rt6i_src.plen;
2082 rtm->rtm_tos = 0;
Thomas Grafc71099a2006-08-04 23:20:06 -07002083 if (rt->rt6i_table)
Patrick McHardy9e762a42006-08-10 23:09:48 -07002084 table = rt->rt6i_table->tb6_id;
Thomas Grafc71099a2006-08-04 23:20:06 -07002085 else
Patrick McHardy9e762a42006-08-10 23:09:48 -07002086 table = RT6_TABLE_UNSPEC;
2087 rtm->rtm_table = table;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002088 NLA_PUT_U32(skb, RTA_TABLE, table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 if (rt->rt6i_flags&RTF_REJECT)
2090 rtm->rtm_type = RTN_UNREACHABLE;
2091 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2092 rtm->rtm_type = RTN_LOCAL;
2093 else
2094 rtm->rtm_type = RTN_UNICAST;
2095 rtm->rtm_flags = 0;
2096 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2097 rtm->rtm_protocol = rt->rt6i_protocol;
2098 if (rt->rt6i_flags&RTF_DYNAMIC)
2099 rtm->rtm_protocol = RTPROT_REDIRECT;
2100 else if (rt->rt6i_flags & RTF_ADDRCONF)
2101 rtm->rtm_protocol = RTPROT_KERNEL;
2102 else if (rt->rt6i_flags&RTF_DEFAULT)
2103 rtm->rtm_protocol = RTPROT_RA;
2104
2105 if (rt->rt6i_flags&RTF_CACHE)
2106 rtm->rtm_flags |= RTM_F_CLONED;
2107
2108 if (dst) {
Thomas Graf2d7202b2006-08-22 00:01:27 -07002109 NLA_PUT(skb, RTA_DST, 16, dst);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002110 rtm->rtm_dst_len = 128;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 } else if (rtm->rtm_dst_len)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002112 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113#ifdef CONFIG_IPV6_SUBTREES
2114 if (src) {
Thomas Graf2d7202b2006-08-22 00:01:27 -07002115 NLA_PUT(skb, RTA_SRC, 16, src);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002116 rtm->rtm_src_len = 128;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 } else if (rtm->rtm_src_len)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002118 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119#endif
2120 if (iif)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002121 NLA_PUT_U32(skb, RTA_IIF, iif);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 else if (dst) {
2123 struct in6_addr saddr_buf;
2124 if (ipv6_get_saddr(&rt->u.dst, dst, &saddr_buf) == 0)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002125 NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 }
Thomas Graf2d7202b2006-08-22 00:01:27 -07002127
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002129 goto nla_put_failure;
2130
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 if (rt->u.dst.neighbour)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002132 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
2133
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 if (rt->u.dst.dev)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002135 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2136
2137 NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
Thomas Grafe3703b32006-11-27 09:27:07 -08002138
2139 expires = rt->rt6i_expires ? rt->rt6i_expires - jiffies : 0;
2140 if (rtnl_put_cacheinfo(skb, &rt->u.dst, 0, 0, 0,
2141 expires, rt->u.dst.error) < 0)
2142 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143
Thomas Graf2d7202b2006-08-22 00:01:27 -07002144 return nlmsg_end(skb, nlh);
2145
2146nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002147 nlmsg_cancel(skb, nlh);
2148 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149}
2150
Patrick McHardy1b43af52006-08-10 23:11:17 -07002151int rt6_dump_route(struct rt6_info *rt, void *p_arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152{
2153 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2154 int prefix;
2155
Thomas Graf2d7202b2006-08-22 00:01:27 -07002156 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2157 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2159 } else
2160 prefix = 0;
2161
2162 return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2163 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
Jamal Hadi Salim0d51aa82005-06-21 13:51:04 -07002164 prefix, NLM_F_MULTI);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165}
2166
Thomas Grafc127ea22007-03-22 11:58:32 -07002167static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168{
Thomas Grafab364a62006-08-22 00:01:47 -07002169 struct nlattr *tb[RTA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170 struct rt6_info *rt;
Thomas Grafab364a62006-08-22 00:01:47 -07002171 struct sk_buff *skb;
2172 struct rtmsg *rtm;
2173 struct flowi fl;
2174 int err, iif = 0;
2175
2176 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2177 if (err < 0)
2178 goto errout;
2179
2180 err = -EINVAL;
2181 memset(&fl, 0, sizeof(fl));
2182
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]);
2202
2203 if (iif) {
2204 struct net_device *dev;
2205 dev = __dev_get_by_index(iif);
2206 if (!dev) {
2207 err = -ENODEV;
2208 goto errout;
2209 }
2210 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211
2212 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
Thomas Grafab364a62006-08-22 00:01:47 -07002213 if (skb == NULL) {
2214 err = -ENOBUFS;
2215 goto errout;
2216 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217
2218 /* Reserve room for dummy headers, this skb can pass
2219 through good chunk of routing engine.
2220 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07002221 skb_reset_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2223
Thomas Grafab364a62006-08-22 00:01:47 -07002224 rt = (struct rt6_info*) ip6_route_output(NULL, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 skb->dst = &rt->u.dst;
2226
Thomas Grafab364a62006-08-22 00:01:47 -07002227 err = rt6_fill_node(skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
Jamal Hadi Salim0d51aa82005-06-21 13:51:04 -07002229 nlh->nlmsg_seq, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 if (err < 0) {
Thomas Grafab364a62006-08-22 00:01:47 -07002231 kfree_skb(skb);
2232 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 }
2234
Thomas Graf2942e902006-08-15 00:30:25 -07002235 err = rtnl_unicast(skb, NETLINK_CB(in_skb).pid);
Thomas Grafab364a62006-08-22 00:01:47 -07002236errout:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238}
2239
Thomas Graf86872cb2006-08-22 00:01:08 -07002240void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241{
2242 struct sk_buff *skb;
Thomas Graf86872cb2006-08-22 00:01:08 -07002243 u32 pid = 0, seq = 0;
2244 struct nlmsghdr *nlh = NULL;
Thomas Graf21713eb2006-08-15 00:35:24 -07002245 int err = -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246
Thomas Graf86872cb2006-08-22 00:01:08 -07002247 if (info) {
2248 pid = info->pid;
2249 nlh = info->nlh;
2250 if (nlh)
2251 seq = nlh->nlmsg_seq;
2252 }
2253
Thomas Graf339bf982006-11-10 14:10:15 -08002254 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
Thomas Graf21713eb2006-08-15 00:35:24 -07002255 if (skb == NULL)
2256 goto errout;
2257
2258 err = rt6_fill_node(skb, rt, NULL, NULL, 0, event, pid, seq, 0, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08002259 if (err < 0) {
2260 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2261 WARN_ON(err == -EMSGSIZE);
2262 kfree_skb(skb);
2263 goto errout;
2264 }
Thomas Graf21713eb2006-08-15 00:35:24 -07002265 err = rtnl_notify(skb, pid, RTNLGRP_IPV6_ROUTE, nlh, gfp_any());
2266errout:
2267 if (err < 0)
2268 rtnl_set_sk_err(RTNLGRP_IPV6_ROUTE, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002269}
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{
2290 struct rt6_proc_arg *arg = (struct rt6_proc_arg *) p_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291
2292 if (arg->skip < arg->offset / RT6_INFO_LEN) {
2293 arg->skip++;
2294 return 0;
2295 }
2296
2297 if (arg->len >= arg->length)
2298 return 0;
2299
YOSHIFUJI Hideaki33e93c92006-10-14 02:00:56 +09002300 arg->len += sprintf(arg->buffer + arg->len,
2301 NIP6_SEQFMT " %02x ",
2302 NIP6(rt->rt6i_dst.addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303 rt->rt6i_dst.plen);
2304
2305#ifdef CONFIG_IPV6_SUBTREES
YOSHIFUJI Hideaki33e93c92006-10-14 02:00:56 +09002306 arg->len += sprintf(arg->buffer + arg->len,
2307 NIP6_SEQFMT " %02x ",
2308 NIP6(rt->rt6i_src.addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 rt->rt6i_src.plen);
2310#else
YOSHIFUJI Hideaki33e93c92006-10-14 02:00:56 +09002311 arg->len += sprintf(arg->buffer + arg->len,
2312 "00000000000000000000000000000000 00 ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313#endif
2314
2315 if (rt->rt6i_nexthop) {
YOSHIFUJI Hideaki33e93c92006-10-14 02:00:56 +09002316 arg->len += sprintf(arg->buffer + arg->len,
2317 NIP6_SEQFMT,
2318 NIP6(*((struct in6_addr *)rt->rt6i_nexthop->primary_key)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319 } else {
YOSHIFUJI Hideaki33e93c92006-10-14 02:00:56 +09002320 arg->len += sprintf(arg->buffer + arg->len,
2321 "00000000000000000000000000000000");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322 }
2323 arg->len += sprintf(arg->buffer + arg->len,
2324 " %08x %08x %08x %08x %8s\n",
2325 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002326 rt->u.dst.__use, rt->rt6i_flags,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 rt->rt6i_dev ? rt->rt6i_dev->name : "");
2328 return 0;
2329}
2330
2331static int rt6_proc_info(char *buffer, char **start, off_t offset, int length)
2332{
Thomas Grafc71099a2006-08-04 23:20:06 -07002333 struct rt6_proc_arg arg = {
2334 .buffer = buffer,
2335 .offset = offset,
2336 .length = length,
2337 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338
Thomas Grafc71099a2006-08-04 23:20:06 -07002339 fib6_clean_all(rt6_info_route, 0, &arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340
2341 *start = buffer;
2342 if (offset)
2343 *start += offset % RT6_INFO_LEN;
2344
2345 arg.len -= offset % RT6_INFO_LEN;
2346
2347 if (arg.len > length)
2348 arg.len = length;
2349 if (arg.len < 0)
2350 arg.len = 0;
2351
2352 return arg.len;
2353}
2354
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2356{
2357 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2358 rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
2359 rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
2360 rt6_stats.fib_rt_cache,
2361 atomic_read(&ip6_dst_ops.entries),
2362 rt6_stats.fib_discarded_routes);
2363
2364 return 0;
2365}
2366
2367static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2368{
2369 return single_open(file, rt6_stats_seq_show, NULL);
2370}
2371
Arjan van de Ven9a321442007-02-12 00:55:35 -08002372static const struct file_operations rt6_stats_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373 .owner = THIS_MODULE,
2374 .open = rt6_stats_seq_open,
2375 .read = seq_read,
2376 .llseek = seq_lseek,
2377 .release = single_release,
2378};
2379#endif /* CONFIG_PROC_FS */
2380
2381#ifdef CONFIG_SYSCTL
2382
2383static int flush_delay;
2384
2385static
2386int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
2387 void __user *buffer, size_t *lenp, loff_t *ppos)
2388{
2389 if (write) {
2390 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2391 fib6_run_gc(flush_delay <= 0 ? ~0UL : (unsigned long)flush_delay);
2392 return 0;
2393 } else
2394 return -EINVAL;
2395}
2396
2397ctl_table ipv6_route_table[] = {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002398 {
2399 .ctl_name = NET_IPV6_ROUTE_FLUSH,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400 .procname = "flush",
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002401 .data = &flush_delay,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402 .maxlen = sizeof(int),
Dave Jones89c8b3a2005-04-28 12:11:49 -07002403 .mode = 0200,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002404 .proc_handler = &ipv6_sysctl_rtcache_flush
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405 },
2406 {
2407 .ctl_name = NET_IPV6_ROUTE_GC_THRESH,
2408 .procname = "gc_thresh",
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002409 .data = &ip6_dst_ops.gc_thresh,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 .maxlen = sizeof(int),
2411 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002412 .proc_handler = &proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413 },
2414 {
2415 .ctl_name = NET_IPV6_ROUTE_MAX_SIZE,
2416 .procname = "max_size",
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002417 .data = &ip6_rt_max_size,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 .maxlen = sizeof(int),
2419 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002420 .proc_handler = &proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421 },
2422 {
2423 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL,
2424 .procname = "gc_min_interval",
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002425 .data = &ip6_rt_gc_min_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426 .maxlen = sizeof(int),
2427 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002428 .proc_handler = &proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 .strategy = &sysctl_jiffies,
2430 },
2431 {
2432 .ctl_name = NET_IPV6_ROUTE_GC_TIMEOUT,
2433 .procname = "gc_timeout",
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002434 .data = &ip6_rt_gc_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435 .maxlen = sizeof(int),
2436 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002437 .proc_handler = &proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438 .strategy = &sysctl_jiffies,
2439 },
2440 {
2441 .ctl_name = NET_IPV6_ROUTE_GC_INTERVAL,
2442 .procname = "gc_interval",
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002443 .data = &ip6_rt_gc_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444 .maxlen = sizeof(int),
2445 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002446 .proc_handler = &proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447 .strategy = &sysctl_jiffies,
2448 },
2449 {
2450 .ctl_name = NET_IPV6_ROUTE_GC_ELASTICITY,
2451 .procname = "gc_elasticity",
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002452 .data = &ip6_rt_gc_elasticity,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453 .maxlen = sizeof(int),
2454 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002455 .proc_handler = &proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 .strategy = &sysctl_jiffies,
2457 },
2458 {
2459 .ctl_name = NET_IPV6_ROUTE_MTU_EXPIRES,
2460 .procname = "mtu_expires",
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002461 .data = &ip6_rt_mtu_expires,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462 .maxlen = sizeof(int),
2463 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002464 .proc_handler = &proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 .strategy = &sysctl_jiffies,
2466 },
2467 {
2468 .ctl_name = NET_IPV6_ROUTE_MIN_ADVMSS,
2469 .procname = "min_adv_mss",
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002470 .data = &ip6_rt_min_advmss,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 .maxlen = sizeof(int),
2472 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002473 .proc_handler = &proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474 .strategy = &sysctl_jiffies,
2475 },
2476 {
2477 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2478 .procname = "gc_min_interval_ms",
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002479 .data = &ip6_rt_gc_min_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480 .maxlen = sizeof(int),
2481 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002482 .proc_handler = &proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 .strategy = &sysctl_ms_jiffies,
2484 },
2485 { .ctl_name = 0 }
2486};
2487
2488#endif
2489
2490void __init ip6_route_init(void)
2491{
2492 struct proc_dir_entry *p;
2493
Alexey Dobriyane5d679f2006-08-26 19:25:52 -07002494 ip6_dst_ops.kmem_cachep =
2495 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
2496 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497 fib6_init();
2498#ifdef CONFIG_PROC_FS
2499 p = proc_net_create("ipv6_route", 0, rt6_proc_info);
2500 if (p)
2501 p->owner = THIS_MODULE;
2502
2503 proc_net_fops_create("rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2504#endif
2505#ifdef CONFIG_XFRM
2506 xfrm6_init();
2507#endif
Thomas Graf101367c2006-08-04 03:39:02 -07002508#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2509 fib6_rules_init();
2510#endif
Thomas Grafc127ea22007-03-22 11:58:32 -07002511
2512 __rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL);
2513 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL);
2514 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515}
2516
2517void ip6_route_cleanup(void)
2518{
Thomas Graf101367c2006-08-04 03:39:02 -07002519#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2520 fib6_rules_cleanup();
2521#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522#ifdef CONFIG_PROC_FS
2523 proc_net_remove("ipv6_route");
2524 proc_net_remove("rt6_stats");
2525#endif
2526#ifdef CONFIG_XFRM
2527 xfrm6_fini();
2528#endif
2529 rt6_ifdown(NULL);
2530 fib6_gc_cleanup();
2531 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);
2532}