blob: e8b241cb60bc434a4240e0d955f0a1d168b39e07 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/proc_fs.h>
42#include <linux/seq_file.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020043#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <net/snmp.h>
45#include <net/ipv6.h>
46#include <net/ip6_fib.h>
47#include <net/ip6_route.h>
48#include <net/ndisc.h>
49#include <net/addrconf.h>
50#include <net/tcp.h>
51#include <linux/rtnetlink.h>
52#include <net/dst.h>
53#include <net/xfrm.h>
Tom Tucker8d717402006-07-30 20:43:36 -070054#include <net/netevent.h>
Thomas Graf21713eb2006-08-15 00:35:24 -070055#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
57#include <asm/uaccess.h>
58
59#ifdef CONFIG_SYSCTL
60#include <linux/sysctl.h>
61#endif
62
63/* Set to 3 to get tracing. */
64#define RT6_DEBUG 2
65
66#if RT6_DEBUG >= 3
67#define RDBG(x) printk x
68#define RT6_TRACE(x...) printk(KERN_DEBUG x)
69#else
70#define RDBG(x)
71#define RT6_TRACE(x...) do { ; } while (0)
72#endif
73
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -080074#define CLONE_OFFLINK_ROUTE 0
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Linus Torvalds1da177e2005-04-16 15:20:36 -070076static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
77static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
78static struct dst_entry *ip6_negative_advice(struct dst_entry *);
79static void ip6_dst_destroy(struct dst_entry *);
80static void ip6_dst_ifdown(struct dst_entry *,
81 struct net_device *dev, int how);
Daniel Lezcano569d3642008-01-18 03:56:57 -080082static int ip6_dst_gc(struct dst_ops *ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
84static int ip6_pkt_discard(struct sk_buff *skb);
85static int ip6_pkt_discard_out(struct sk_buff *skb);
86static void ip6_link_failure(struct sk_buff *skb);
87static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
88
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -080089#ifdef CONFIG_IPV6_ROUTE_INFO
90static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
91 struct in6_addr *gwaddr, int ifindex,
92 unsigned pref);
93static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
94 struct in6_addr *gwaddr, int ifindex);
95#endif
96
Linus Torvalds1da177e2005-04-16 15:20:36 -070097static struct dst_ops ip6_dst_ops = {
98 .family = AF_INET6,
99 .protocol = __constant_htons(ETH_P_IPV6),
100 .gc = ip6_dst_gc,
101 .gc_thresh = 1024,
102 .check = ip6_dst_check,
103 .destroy = ip6_dst_destroy,
104 .ifdown = ip6_dst_ifdown,
105 .negative_advice = ip6_negative_advice,
106 .link_failure = ip6_link_failure,
107 .update_pmtu = ip6_rt_update_pmtu,
Herbert Xu862b82c2007-11-13 21:43:11 -0800108 .local_out = ip6_local_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 .entry_size = sizeof(struct rt6_info),
Eric Dumazete2422972008-01-30 20:07:45 -0800110 .entries = ATOMIC_INIT(0),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111};
112
David S. Miller14e50e52007-05-24 18:17:54 -0700113static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
114{
115}
116
117static struct dst_ops ip6_dst_blackhole_ops = {
118 .family = AF_INET6,
119 .protocol = __constant_htons(ETH_P_IPV6),
120 .destroy = ip6_dst_destroy,
121 .check = ip6_dst_check,
122 .update_pmtu = ip6_rt_blackhole_update_pmtu,
123 .entry_size = sizeof(struct rt6_info),
Eric Dumazete2422972008-01-30 20:07:45 -0800124 .entries = ATOMIC_INIT(0),
David S. Miller14e50e52007-05-24 18:17:54 -0700125};
126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127struct rt6_info ip6_null_entry = {
128 .u = {
129 .dst = {
130 .__refcnt = ATOMIC_INIT(1),
131 .__use = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 .obsolete = -1,
133 .error = -ENETUNREACH,
134 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
135 .input = ip6_pkt_discard,
136 .output = ip6_pkt_discard_out,
137 .ops = &ip6_dst_ops,
138 .path = (struct dst_entry*)&ip6_null_entry,
139 }
140 },
141 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
142 .rt6i_metric = ~(u32) 0,
143 .rt6i_ref = ATOMIC_INIT(1),
144};
145
Thomas Graf101367c2006-08-04 03:39:02 -0700146#ifdef CONFIG_IPV6_MULTIPLE_TABLES
147
David S. Miller6723ab52006-10-18 21:20:57 -0700148static int ip6_pkt_prohibit(struct sk_buff *skb);
149static int ip6_pkt_prohibit_out(struct sk_buff *skb);
David S. Miller6723ab52006-10-18 21:20:57 -0700150
Thomas Graf101367c2006-08-04 03:39:02 -0700151struct rt6_info ip6_prohibit_entry = {
152 .u = {
153 .dst = {
154 .__refcnt = ATOMIC_INIT(1),
155 .__use = 1,
Thomas Graf101367c2006-08-04 03:39:02 -0700156 .obsolete = -1,
157 .error = -EACCES,
158 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
Thomas Graf9ce8ade2006-10-18 20:46:54 -0700159 .input = ip6_pkt_prohibit,
160 .output = ip6_pkt_prohibit_out,
Thomas Graf101367c2006-08-04 03:39:02 -0700161 .ops = &ip6_dst_ops,
162 .path = (struct dst_entry*)&ip6_prohibit_entry,
163 }
164 },
165 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
166 .rt6i_metric = ~(u32) 0,
167 .rt6i_ref = ATOMIC_INIT(1),
168};
169
170struct rt6_info ip6_blk_hole_entry = {
171 .u = {
172 .dst = {
173 .__refcnt = ATOMIC_INIT(1),
174 .__use = 1,
Thomas Graf101367c2006-08-04 03:39:02 -0700175 .obsolete = -1,
176 .error = -EINVAL,
177 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
Herbert Xu352e5122007-11-13 21:34:06 -0800178 .input = dst_discard,
179 .output = dst_discard,
Thomas Graf101367c2006-08-04 03:39:02 -0700180 .ops = &ip6_dst_ops,
181 .path = (struct dst_entry*)&ip6_blk_hole_entry,
182 }
183 },
184 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
185 .rt6i_metric = ~(u32) 0,
186 .rt6i_ref = ATOMIC_INIT(1),
187};
188
189#endif
190
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191/* allocate dst with ip6_dst_ops */
192static __inline__ struct rt6_info *ip6_dst_alloc(void)
193{
194 return (struct rt6_info *)dst_alloc(&ip6_dst_ops);
195}
196
197static void ip6_dst_destroy(struct dst_entry *dst)
198{
199 struct rt6_info *rt = (struct rt6_info *)dst;
200 struct inet6_dev *idev = rt->rt6i_idev;
201
202 if (idev != NULL) {
203 rt->rt6i_idev = NULL;
204 in6_dev_put(idev);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900205 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206}
207
208static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
209 int how)
210{
211 struct rt6_info *rt = (struct rt6_info *)dst;
212 struct inet6_dev *idev = rt->rt6i_idev;
Denis V. Lunev5a3e55d2007-12-07 00:38:10 -0800213 struct net_device *loopback_dev =
214 dev->nd_net->loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Denis V. Lunev5a3e55d2007-12-07 00:38:10 -0800216 if (dev != loopback_dev && idev != NULL && idev->dev == dev) {
217 struct inet6_dev *loopback_idev =
218 in6_dev_get(loopback_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 if (loopback_idev != NULL) {
220 rt->rt6i_idev = loopback_idev;
221 in6_dev_put(idev);
222 }
223 }
224}
225
226static __inline__ int rt6_check_expired(const struct rt6_info *rt)
227{
228 return (rt->rt6i_flags & RTF_EXPIRES &&
229 time_after(jiffies, rt->rt6i_expires));
230}
231
Thomas Grafc71099a2006-08-04 23:20:06 -0700232static inline int rt6_need_strict(struct in6_addr *daddr)
233{
234 return (ipv6_addr_type(daddr) &
235 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL));
236}
237
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238/*
Thomas Grafc71099a2006-08-04 23:20:06 -0700239 * Route lookup. Any table->tb6_lock is implied.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 */
241
242static __inline__ struct rt6_info *rt6_device_match(struct rt6_info *rt,
243 int oif,
244 int strict)
245{
246 struct rt6_info *local = NULL;
247 struct rt6_info *sprt;
248
249 if (oif) {
Eric Dumazet7cc48262007-02-09 16:22:57 -0800250 for (sprt = rt; sprt; sprt = sprt->u.dst.rt6_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 struct net_device *dev = sprt->rt6i_dev;
252 if (dev->ifindex == oif)
253 return sprt;
254 if (dev->flags & IFF_LOOPBACK) {
255 if (sprt->rt6i_idev == NULL ||
256 sprt->rt6i_idev->dev->ifindex != oif) {
257 if (strict && oif)
258 continue;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900259 if (local && (!oif ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 local->rt6i_idev->dev->ifindex == oif))
261 continue;
262 }
263 local = sprt;
264 }
265 }
266
267 if (local)
268 return local;
269
270 if (strict)
271 return &ip6_null_entry;
272 }
273 return rt;
274}
275
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800276#ifdef CONFIG_IPV6_ROUTER_PREF
277static void rt6_probe(struct rt6_info *rt)
278{
279 struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
280 /*
281 * Okay, this does not seem to be appropriate
282 * for now, however, we need to check if it
283 * is really so; aka Router Reachability Probing.
284 *
285 * Router Reachability Probe MUST be rate-limited
286 * to no more than one per minute.
287 */
288 if (!neigh || (neigh->nud_state & NUD_VALID))
289 return;
290 read_lock_bh(&neigh->lock);
291 if (!(neigh->nud_state & NUD_VALID) &&
YOSHIFUJI Hideaki52e16352006-03-20 17:05:47 -0800292 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800293 struct in6_addr mcaddr;
294 struct in6_addr *target;
295
296 neigh->updated = jiffies;
297 read_unlock_bh(&neigh->lock);
298
299 target = (struct in6_addr *)&neigh->primary_key;
300 addrconf_addr_solict_mult(target, &mcaddr);
301 ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
302 } else
303 read_unlock_bh(&neigh->lock);
304}
305#else
306static inline void rt6_probe(struct rt6_info *rt)
307{
308 return;
309}
310#endif
311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312/*
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800313 * Default Router Selection (RFC 2461 6.3.6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 */
Dave Jonesb6f99a22007-03-22 12:27:49 -0700315static inline int rt6_check_dev(struct rt6_info *rt, int oif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316{
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800317 struct net_device *dev = rt->rt6i_dev;
David S. Miller161980f2007-04-06 11:42:27 -0700318 if (!oif || dev->ifindex == oif)
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800319 return 2;
David S. Miller161980f2007-04-06 11:42:27 -0700320 if ((dev->flags & IFF_LOOPBACK) &&
321 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
322 return 1;
323 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324}
325
Dave Jonesb6f99a22007-03-22 12:27:49 -0700326static inline int rt6_check_neigh(struct rt6_info *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327{
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800328 struct neighbour *neigh = rt->rt6i_nexthop;
YOSHIFUJI Hideaki398bcbe2008-01-19 00:35:16 -0800329 int m;
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700330 if (rt->rt6i_flags & RTF_NONEXTHOP ||
331 !(rt->rt6i_flags & RTF_GATEWAY))
332 m = 1;
333 else if (neigh) {
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800334 read_lock_bh(&neigh->lock);
335 if (neigh->nud_state & NUD_VALID)
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700336 m = 2;
YOSHIFUJI Hideaki398bcbe2008-01-19 00:35:16 -0800337#ifdef CONFIG_IPV6_ROUTER_PREF
338 else if (neigh->nud_state & NUD_FAILED)
339 m = 0;
340#endif
341 else
YOSHIFUJI Hideakiea73ee22006-11-06 09:45:44 -0800342 m = 1;
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800343 read_unlock_bh(&neigh->lock);
YOSHIFUJI Hideaki398bcbe2008-01-19 00:35:16 -0800344 } else
345 m = 0;
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800346 return m;
347}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800349static int rt6_score_route(struct rt6_info *rt, int oif,
350 int strict)
351{
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700352 int m, n;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900353
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700354 m = rt6_check_dev(rt, oif);
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700355 if (!m && (strict & RT6_LOOKUP_F_IFACE))
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800356 return -1;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -0800357#ifdef CONFIG_IPV6_ROUTER_PREF
358 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
359#endif
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700360 n = rt6_check_neigh(rt);
YOSHIFUJI Hideaki557e92e2006-11-06 09:45:45 -0800361 if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800362 return -1;
363 return m;
364}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
David S. Millerf11e6652007-03-24 20:36:25 -0700366static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
367 int *mpri, struct rt6_info *match)
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800368{
David S. Millerf11e6652007-03-24 20:36:25 -0700369 int m;
370
371 if (rt6_check_expired(rt))
372 goto out;
373
374 m = rt6_score_route(rt, oif, strict);
375 if (m < 0)
376 goto out;
377
378 if (m > *mpri) {
379 if (strict & RT6_LOOKUP_F_REACHABLE)
380 rt6_probe(match);
381 *mpri = m;
382 match = rt;
383 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
384 rt6_probe(rt);
385 }
386
387out:
388 return match;
389}
390
391static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
392 struct rt6_info *rr_head,
393 u32 metric, int oif, int strict)
394{
395 struct rt6_info *rt, *match;
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800396 int mpri = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
David S. Millerf11e6652007-03-24 20:36:25 -0700398 match = NULL;
399 for (rt = rr_head; rt && rt->rt6i_metric == metric;
400 rt = rt->u.dst.rt6_next)
401 match = find_match(rt, oif, strict, &mpri, match);
402 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
403 rt = rt->u.dst.rt6_next)
404 match = find_match(rt, oif, strict, &mpri, match);
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800405
David S. Millerf11e6652007-03-24 20:36:25 -0700406 return match;
407}
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800408
David S. Millerf11e6652007-03-24 20:36:25 -0700409static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
410{
411 struct rt6_info *match, *rt0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
David S. Millerf11e6652007-03-24 20:36:25 -0700413 RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
414 __FUNCTION__, fn->leaf, oif);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
David S. Millerf11e6652007-03-24 20:36:25 -0700416 rt0 = fn->rr_ptr;
417 if (!rt0)
418 fn->rr_ptr = rt0 = fn->leaf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
David S. Millerf11e6652007-03-24 20:36:25 -0700420 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800422 if (!match &&
David S. Millerf11e6652007-03-24 20:36:25 -0700423 (strict & RT6_LOOKUP_F_REACHABLE)) {
424 struct rt6_info *next = rt0->u.dst.rt6_next;
425
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800426 /* no entries matched; do round-robin */
David S. Millerf11e6652007-03-24 20:36:25 -0700427 if (!next || next->rt6i_metric != rt0->rt6i_metric)
428 next = fn->leaf;
429
430 if (next != rt0)
431 fn->rr_ptr = next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 }
433
David S. Millerf11e6652007-03-24 20:36:25 -0700434 RT6_TRACE("%s() => %p\n",
435 __FUNCTION__, match);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800437 return (match ? match : &ip6_null_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438}
439
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800440#ifdef CONFIG_IPV6_ROUTE_INFO
441int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
442 struct in6_addr *gwaddr)
443{
444 struct route_info *rinfo = (struct route_info *) opt;
445 struct in6_addr prefix_buf, *prefix;
446 unsigned int pref;
447 u32 lifetime;
448 struct rt6_info *rt;
449
450 if (len < sizeof(struct route_info)) {
451 return -EINVAL;
452 }
453
454 /* Sanity check for prefix_len and length */
455 if (rinfo->length > 3) {
456 return -EINVAL;
457 } else if (rinfo->prefix_len > 128) {
458 return -EINVAL;
459 } else if (rinfo->prefix_len > 64) {
460 if (rinfo->length < 2) {
461 return -EINVAL;
462 }
463 } else if (rinfo->prefix_len > 0) {
464 if (rinfo->length < 1) {
465 return -EINVAL;
466 }
467 }
468
469 pref = rinfo->route_pref;
470 if (pref == ICMPV6_ROUTER_PREF_INVALID)
471 pref = ICMPV6_ROUTER_PREF_MEDIUM;
472
Al Viroe69a4adc2006-11-14 20:56:00 -0800473 lifetime = ntohl(rinfo->lifetime);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800474 if (lifetime == 0xffffffff) {
475 /* infinity */
476 } else if (lifetime > 0x7fffffff/HZ) {
477 /* Avoid arithmetic overflow */
478 lifetime = 0x7fffffff/HZ - 1;
479 }
480
481 if (rinfo->length == 3)
482 prefix = (struct in6_addr *)rinfo->prefix;
483 else {
484 /* this function is safe */
485 ipv6_addr_prefix(&prefix_buf,
486 (struct in6_addr *)rinfo->prefix,
487 rinfo->prefix_len);
488 prefix = &prefix_buf;
489 }
490
491 rt = rt6_get_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex);
492
493 if (rt && !lifetime) {
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700494 ip6_del_rt(rt);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800495 rt = NULL;
496 }
497
498 if (!rt && lifetime)
499 rt = rt6_add_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
500 pref);
501 else if (rt)
502 rt->rt6i_flags = RTF_ROUTEINFO |
503 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
504
505 if (rt) {
506 if (lifetime == 0xffffffff) {
507 rt->rt6i_flags &= ~RTF_EXPIRES;
508 } else {
509 rt->rt6i_expires = jiffies + HZ * lifetime;
510 rt->rt6i_flags |= RTF_EXPIRES;
511 }
512 dst_release(&rt->u.dst);
513 }
514 return 0;
515}
516#endif
517
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700518#define BACKTRACK(saddr) \
519do { \
520 if (rt == &ip6_null_entry) { \
521 struct fib6_node *pn; \
Ville Nuorvalae0eda7b2006-10-16 22:11:11 -0700522 while (1) { \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700523 if (fn->fn_flags & RTN_TL_ROOT) \
524 goto out; \
525 pn = fn->parent; \
526 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
Kim Nordlund8bce65b2006-12-13 16:38:29 -0800527 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700528 else \
529 fn = pn; \
530 if (fn->fn_flags & RTN_RTINFO) \
531 goto restart; \
Thomas Grafc71099a2006-08-04 23:20:06 -0700532 } \
Thomas Grafc71099a2006-08-04 23:20:06 -0700533 } \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700534} while(0)
Thomas Grafc71099a2006-08-04 23:20:06 -0700535
536static struct rt6_info *ip6_pol_route_lookup(struct fib6_table *table,
537 struct flowi *fl, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538{
539 struct fib6_node *fn;
540 struct rt6_info *rt;
541
Thomas Grafc71099a2006-08-04 23:20:06 -0700542 read_lock_bh(&table->tb6_lock);
543 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
544restart:
545 rt = fn->leaf;
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700546 rt = rt6_device_match(rt, fl->oif, flags);
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700547 BACKTRACK(&fl->fl6_src);
Thomas Grafc71099a2006-08-04 23:20:06 -0700548out:
Pavel Emelyanov03f49f32007-11-10 21:28:34 -0800549 dst_use(&rt->u.dst, jiffies);
Thomas Grafc71099a2006-08-04 23:20:06 -0700550 read_unlock_bh(&table->tb6_lock);
Thomas Grafc71099a2006-08-04 23:20:06 -0700551 return rt;
552
553}
554
555struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
556 int oif, int strict)
557{
558 struct flowi fl = {
559 .oif = oif,
560 .nl_u = {
561 .ip6_u = {
562 .daddr = *daddr,
Thomas Grafc71099a2006-08-04 23:20:06 -0700563 },
564 },
565 };
566 struct dst_entry *dst;
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700567 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
Thomas Grafc71099a2006-08-04 23:20:06 -0700568
Thomas Grafadaa70b2006-10-13 15:01:03 -0700569 if (saddr) {
570 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
571 flags |= RT6_LOOKUP_F_HAS_SADDR;
572 }
573
Thomas Grafc71099a2006-08-04 23:20:06 -0700574 dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_lookup);
575 if (dst->error == 0)
576 return (struct rt6_info *) dst;
577
578 dst_release(dst);
579
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 return NULL;
581}
582
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900583EXPORT_SYMBOL(rt6_lookup);
584
Thomas Grafc71099a2006-08-04 23:20:06 -0700585/* ip6_ins_rt is called with FREE table->tb6_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 It takes new route entry, the addition fails by any reason the
587 route is freed. In any case, if caller does not hold it, it may
588 be destroyed.
589 */
590
Thomas Graf86872cb2006-08-22 00:01:08 -0700591static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592{
593 int err;
Thomas Grafc71099a2006-08-04 23:20:06 -0700594 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Thomas Grafc71099a2006-08-04 23:20:06 -0700596 table = rt->rt6i_table;
597 write_lock_bh(&table->tb6_lock);
Thomas Graf86872cb2006-08-22 00:01:08 -0700598 err = fib6_add(&table->tb6_root, rt, info);
Thomas Grafc71099a2006-08-04 23:20:06 -0700599 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
601 return err;
602}
603
Thomas Graf40e22e82006-08-22 00:00:45 -0700604int ip6_ins_rt(struct rt6_info *rt)
605{
Denis V. Lunev4d1169c2008-01-10 03:26:13 -0800606 struct nl_info info = {
607 .nl_net = &init_net,
608 };
Denis V. Lunev528c4ce2007-12-13 09:45:12 -0800609 return __ip6_ins_rt(rt, &info);
Thomas Graf40e22e82006-08-22 00:00:45 -0700610}
611
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800612static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
613 struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 struct rt6_info *rt;
616
617 /*
618 * Clone the route.
619 */
620
621 rt = ip6_rt_copy(ort);
622
623 if (rt) {
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900624 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
625 if (rt->rt6i_dst.plen != 128 &&
626 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
627 rt->rt6i_flags |= RTF_ANYCAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900629 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900631 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 rt->rt6i_dst.plen = 128;
633 rt->rt6i_flags |= RTF_CACHE;
634 rt->u.dst.flags |= DST_HOST;
635
636#ifdef CONFIG_IPV6_SUBTREES
637 if (rt->rt6i_src.plen && saddr) {
638 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
639 rt->rt6i_src.plen = 128;
640 }
641#endif
642
643 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
644
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800645 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800647 return rt;
648}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800650static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
651{
652 struct rt6_info *rt = ip6_rt_copy(ort);
653 if (rt) {
654 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
655 rt->rt6i_dst.plen = 128;
656 rt->rt6i_flags |= RTF_CACHE;
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800657 rt->u.dst.flags |= DST_HOST;
658 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
659 }
660 return rt;
661}
662
Pavel Emelyanov4acad722007-10-15 13:02:51 -0700663static struct rt6_info *ip6_pol_route(struct fib6_table *table, int oif,
Adrian Bunk8ce11e62006-08-07 21:50:48 -0700664 struct flowi *fl, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665{
666 struct fib6_node *fn;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800667 struct rt6_info *rt, *nrt;
Thomas Grafc71099a2006-08-04 23:20:06 -0700668 int strict = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 int attempts = 3;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800670 int err;
YOSHIFUJI Hideakiea659e02006-11-06 09:45:45 -0800671 int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700673 strict |= flags & RT6_LOOKUP_F_IFACE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674
675relookup:
Thomas Grafc71099a2006-08-04 23:20:06 -0700676 read_lock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800678restart_2:
Thomas Grafc71099a2006-08-04 23:20:06 -0700679 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
681restart:
Pavel Emelyanov4acad722007-10-15 13:02:51 -0700682 rt = rt6_select(fn, oif, strict | reachable);
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700683 BACKTRACK(&fl->fl6_src);
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800684 if (rt == &ip6_null_entry ||
685 rt->rt6i_flags & RTF_CACHE)
YOSHIFUJI Hideaki1ddef0442006-03-20 17:01:24 -0800686 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
YOSHIFUJI Hideakifb9de912006-03-20 16:59:08 -0800688 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700689 read_unlock_bh(&table->tb6_lock);
YOSHIFUJI Hideakifb9de912006-03-20 16:59:08 -0800690
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800691 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
YOSHIFUJI Hideakie40cf352006-03-20 16:59:27 -0800692 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800693 else {
694#if CLONE_OFFLINK_ROUTE
695 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
696#else
697 goto out2;
698#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 }
YOSHIFUJI Hideakie40cf352006-03-20 16:59:27 -0800700
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800701 dst_release(&rt->u.dst);
702 rt = nrt ? : &ip6_null_entry;
703
704 dst_hold(&rt->u.dst);
705 if (nrt) {
Thomas Graf40e22e82006-08-22 00:00:45 -0700706 err = ip6_ins_rt(nrt);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800707 if (!err)
708 goto out2;
709 }
710
711 if (--attempts <= 0)
712 goto out2;
713
714 /*
Thomas Grafc71099a2006-08-04 23:20:06 -0700715 * Race condition! In the gap, when table->tb6_lock was
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800716 * released someone could insert this route. Relookup.
717 */
718 dst_release(&rt->u.dst);
719 goto relookup;
720
721out:
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800722 if (reachable) {
723 reachable = 0;
724 goto restart_2;
725 }
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800726 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700727 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728out2:
729 rt->u.dst.lastuse = jiffies;
730 rt->u.dst.__use++;
Thomas Grafc71099a2006-08-04 23:20:06 -0700731
732 return rt;
733}
734
Pavel Emelyanov4acad722007-10-15 13:02:51 -0700735static struct rt6_info *ip6_pol_route_input(struct fib6_table *table,
736 struct flowi *fl, int flags)
737{
738 return ip6_pol_route(table, fl->iif, fl, flags);
739}
740
Thomas Grafc71099a2006-08-04 23:20:06 -0700741void ip6_route_input(struct sk_buff *skb)
742{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700743 struct ipv6hdr *iph = ipv6_hdr(skb);
Thomas Grafadaa70b2006-10-13 15:01:03 -0700744 int flags = RT6_LOOKUP_F_HAS_SADDR;
Thomas Grafc71099a2006-08-04 23:20:06 -0700745 struct flowi fl = {
746 .iif = skb->dev->ifindex,
747 .nl_u = {
748 .ip6_u = {
749 .daddr = iph->daddr,
750 .saddr = iph->saddr,
Al Viro90bcaf72006-11-08 00:25:17 -0800751 .flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
Thomas Grafc71099a2006-08-04 23:20:06 -0700752 },
753 },
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900754 .mark = skb->mark,
Thomas Grafc71099a2006-08-04 23:20:06 -0700755 .proto = iph->nexthdr,
756 };
Thomas Grafadaa70b2006-10-13 15:01:03 -0700757
758 if (rt6_need_strict(&iph->daddr))
759 flags |= RT6_LOOKUP_F_IFACE;
Thomas Grafc71099a2006-08-04 23:20:06 -0700760
761 skb->dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_input);
762}
763
764static struct rt6_info *ip6_pol_route_output(struct fib6_table *table,
765 struct flowi *fl, int flags)
766{
Pavel Emelyanov4acad722007-10-15 13:02:51 -0700767 return ip6_pol_route(table, fl->oif, fl, flags);
Thomas Grafc71099a2006-08-04 23:20:06 -0700768}
769
770struct dst_entry * ip6_route_output(struct sock *sk, struct flowi *fl)
771{
772 int flags = 0;
773
774 if (rt6_need_strict(&fl->fl6_dst))
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700775 flags |= RT6_LOOKUP_F_IFACE;
Thomas Grafc71099a2006-08-04 23:20:06 -0700776
Thomas Grafadaa70b2006-10-13 15:01:03 -0700777 if (!ipv6_addr_any(&fl->fl6_src))
778 flags |= RT6_LOOKUP_F_HAS_SADDR;
779
Thomas Grafc71099a2006-08-04 23:20:06 -0700780 return fib6_rule_lookup(fl, flags, ip6_pol_route_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781}
782
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900783EXPORT_SYMBOL(ip6_route_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
David S. Miller14e50e52007-05-24 18:17:54 -0700785int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl)
786{
787 struct rt6_info *ort = (struct rt6_info *) *dstp;
788 struct rt6_info *rt = (struct rt6_info *)
789 dst_alloc(&ip6_dst_blackhole_ops);
790 struct dst_entry *new = NULL;
791
792 if (rt) {
793 new = &rt->u.dst;
794
795 atomic_set(&new->__refcnt, 1);
796 new->__use = 1;
Herbert Xu352e5122007-11-13 21:34:06 -0800797 new->input = dst_discard;
798 new->output = dst_discard;
David S. Miller14e50e52007-05-24 18:17:54 -0700799
800 memcpy(new->metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
801 new->dev = ort->u.dst.dev;
802 if (new->dev)
803 dev_hold(new->dev);
804 rt->rt6i_idev = ort->rt6i_idev;
805 if (rt->rt6i_idev)
806 in6_dev_hold(rt->rt6i_idev);
807 rt->rt6i_expires = 0;
808
809 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
810 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
811 rt->rt6i_metric = 0;
812
813 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
814#ifdef CONFIG_IPV6_SUBTREES
815 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
816#endif
817
818 dst_free(new);
819 }
820
821 dst_release(*dstp);
822 *dstp = new;
823 return (new ? 0 : -ENOMEM);
824}
825EXPORT_SYMBOL_GPL(ip6_dst_blackhole);
826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827/*
828 * Destination cache support functions
829 */
830
831static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
832{
833 struct rt6_info *rt;
834
835 rt = (struct rt6_info *) dst;
836
837 if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
838 return dst;
839
840 return NULL;
841}
842
843static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
844{
845 struct rt6_info *rt = (struct rt6_info *) dst;
846
847 if (rt) {
848 if (rt->rt6i_flags & RTF_CACHE)
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700849 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 else
851 dst_release(dst);
852 }
853 return NULL;
854}
855
856static void ip6_link_failure(struct sk_buff *skb)
857{
858 struct rt6_info *rt;
859
860 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
861
862 rt = (struct rt6_info *) skb->dst;
863 if (rt) {
864 if (rt->rt6i_flags&RTF_CACHE) {
865 dst_set_expires(&rt->u.dst, 0);
866 rt->rt6i_flags |= RTF_EXPIRES;
867 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
868 rt->rt6i_node->fn_sernum = -1;
869 }
870}
871
872static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
873{
874 struct rt6_info *rt6 = (struct rt6_info*)dst;
875
876 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
877 rt6->rt6i_flags |= RTF_MODIFIED;
878 if (mtu < IPV6_MIN_MTU) {
879 mtu = IPV6_MIN_MTU;
880 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
881 }
882 dst->metrics[RTAX_MTU-1] = mtu;
Tom Tucker8d717402006-07-30 20:43:36 -0700883 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 }
885}
886
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887static int ipv6_get_mtu(struct net_device *dev);
888
889static inline unsigned int ipv6_advmss(unsigned int mtu)
890{
891 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
892
Daniel Lezcano49905092008-01-10 03:01:01 -0800893 if (mtu < init_net.ipv6.sysctl.ip6_rt_min_advmss)
894 mtu = init_net.ipv6.sysctl.ip6_rt_min_advmss;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
896 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900897 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
898 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
899 * IPV6_MAXPLEN is also valid and means: "any MSS,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 * rely only on pmtu discovery"
901 */
902 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
903 mtu = IPV6_MAXPLEN;
904 return mtu;
905}
906
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700907static struct dst_entry *ndisc_dst_gc_list;
Adrian Bunk8ce11e62006-08-07 21:50:48 -0700908static DEFINE_SPINLOCK(ndisc_lock);
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700909
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900910struct dst_entry *ndisc_dst_alloc(struct net_device *dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 struct neighbour *neigh,
912 struct in6_addr *addr,
913 int (*output)(struct sk_buff *))
914{
915 struct rt6_info *rt;
916 struct inet6_dev *idev = in6_dev_get(dev);
917
918 if (unlikely(idev == NULL))
919 return NULL;
920
921 rt = ip6_dst_alloc();
922 if (unlikely(rt == NULL)) {
923 in6_dev_put(idev);
924 goto out;
925 }
926
927 dev_hold(dev);
928 if (neigh)
929 neigh_hold(neigh);
930 else
931 neigh = ndisc_get_neigh(dev, addr);
932
933 rt->rt6i_dev = dev;
934 rt->rt6i_idev = idev;
935 rt->rt6i_nexthop = neigh;
936 atomic_set(&rt->u.dst.__refcnt, 1);
937 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
938 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
939 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
940 rt->u.dst.output = output;
941
942#if 0 /* there's no chance to use these for ndisc */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900943 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
944 ? DST_HOST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 : 0;
946 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
947 rt->rt6i_dst.plen = 128;
948#endif
949
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700950 spin_lock_bh(&ndisc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 rt->u.dst.next = ndisc_dst_gc_list;
952 ndisc_dst_gc_list = &rt->u.dst;
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700953 spin_unlock_bh(&ndisc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954
955 fib6_force_start_gc();
956
957out:
YOSHIFUJI Hideaki40aa7b92006-10-19 13:50:09 +0900958 return &rt->u.dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959}
960
961int ndisc_dst_gc(int *more)
962{
963 struct dst_entry *dst, *next, **pprev;
964 int freed;
965
966 next = NULL;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900967 freed = 0;
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700968
969 spin_lock_bh(&ndisc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 pprev = &ndisc_dst_gc_list;
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700971
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 while ((dst = *pprev) != NULL) {
973 if (!atomic_read(&dst->__refcnt)) {
974 *pprev = dst->next;
975 dst_free(dst);
976 freed++;
977 } else {
978 pprev = &dst->next;
979 (*more)++;
980 }
981 }
982
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700983 spin_unlock_bh(&ndisc_lock);
984
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 return freed;
986}
987
Daniel Lezcano569d3642008-01-18 03:56:57 -0800988static int ip6_dst_gc(struct dst_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989{
990 static unsigned expire = 30*HZ;
991 static unsigned long last_gc;
992 unsigned long now = jiffies;
993
Daniel Lezcano49905092008-01-10 03:01:01 -0800994 if (time_after(last_gc + init_net.ipv6.sysctl.ip6_rt_gc_min_interval, now) &&
995 atomic_read(&ip6_dst_ops.entries) <= init_net.ipv6.sysctl.ip6_rt_max_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 goto out;
997
998 expire++;
999 fib6_run_gc(expire);
1000 last_gc = now;
1001 if (atomic_read(&ip6_dst_ops.entries) < ip6_dst_ops.gc_thresh)
Daniel Lezcano49905092008-01-10 03:01:01 -08001002 expire = init_net.ipv6.sysctl.ip6_rt_gc_timeout>>1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003
1004out:
Daniel Lezcano49905092008-01-10 03:01:01 -08001005 expire -= expire>>init_net.ipv6.sysctl.ip6_rt_gc_elasticity;
1006 return (atomic_read(&ip6_dst_ops.entries) > init_net.ipv6.sysctl.ip6_rt_max_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007}
1008
1009/* Clean host part of a prefix. Not necessary in radix tree,
1010 but results in cleaner routing tables.
1011
1012 Remove it only when all the things will work!
1013 */
1014
1015static int ipv6_get_mtu(struct net_device *dev)
1016{
1017 int mtu = IPV6_MIN_MTU;
1018 struct inet6_dev *idev;
1019
1020 idev = in6_dev_get(dev);
1021 if (idev) {
1022 mtu = idev->cnf.mtu6;
1023 in6_dev_put(idev);
1024 }
1025 return mtu;
1026}
1027
1028int ipv6_get_hoplimit(struct net_device *dev)
1029{
1030 int hoplimit = ipv6_devconf.hop_limit;
1031 struct inet6_dev *idev;
1032
1033 idev = in6_dev_get(dev);
1034 if (idev) {
1035 hoplimit = idev->cnf.hop_limit;
1036 in6_dev_put(idev);
1037 }
1038 return hoplimit;
1039}
1040
1041/*
1042 *
1043 */
1044
Thomas Graf86872cb2006-08-22 00:01:08 -07001045int ip6_route_add(struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046{
1047 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 struct rt6_info *rt = NULL;
1049 struct net_device *dev = NULL;
1050 struct inet6_dev *idev = NULL;
Thomas Grafc71099a2006-08-04 23:20:06 -07001051 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 int addr_type;
1053
Thomas Graf86872cb2006-08-22 00:01:08 -07001054 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 return -EINVAL;
1056#ifndef CONFIG_IPV6_SUBTREES
Thomas Graf86872cb2006-08-22 00:01:08 -07001057 if (cfg->fc_src_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 return -EINVAL;
1059#endif
Thomas Graf86872cb2006-08-22 00:01:08 -07001060 if (cfg->fc_ifindex) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 err = -ENODEV;
Eric W. Biederman881d9662007-09-17 11:56:21 -07001062 dev = dev_get_by_index(&init_net, cfg->fc_ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 if (!dev)
1064 goto out;
1065 idev = in6_dev_get(dev);
1066 if (!idev)
1067 goto out;
1068 }
1069
Thomas Graf86872cb2006-08-22 00:01:08 -07001070 if (cfg->fc_metric == 0)
1071 cfg->fc_metric = IP6_RT_PRIO_USER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072
Thomas Graf86872cb2006-08-22 00:01:08 -07001073 table = fib6_new_table(cfg->fc_table);
Thomas Grafc71099a2006-08-04 23:20:06 -07001074 if (table == NULL) {
1075 err = -ENOBUFS;
1076 goto out;
1077 }
1078
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 rt = ip6_dst_alloc();
1080
1081 if (rt == NULL) {
1082 err = -ENOMEM;
1083 goto out;
1084 }
1085
1086 rt->u.dst.obsolete = -1;
Thomas Graf86872cb2006-08-22 00:01:08 -07001087 rt->rt6i_expires = jiffies + clock_t_to_jiffies(cfg->fc_expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088
Thomas Graf86872cb2006-08-22 00:01:08 -07001089 if (cfg->fc_protocol == RTPROT_UNSPEC)
1090 cfg->fc_protocol = RTPROT_BOOT;
1091 rt->rt6i_protocol = cfg->fc_protocol;
1092
1093 addr_type = ipv6_addr_type(&cfg->fc_dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094
1095 if (addr_type & IPV6_ADDR_MULTICAST)
1096 rt->u.dst.input = ip6_mc_input;
1097 else
1098 rt->u.dst.input = ip6_forward;
1099
1100 rt->u.dst.output = ip6_output;
1101
Thomas Graf86872cb2006-08-22 00:01:08 -07001102 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1103 rt->rt6i_dst.plen = cfg->fc_dst_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 if (rt->rt6i_dst.plen == 128)
1105 rt->u.dst.flags = DST_HOST;
1106
1107#ifdef CONFIG_IPV6_SUBTREES
Thomas Graf86872cb2006-08-22 00:01:08 -07001108 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1109 rt->rt6i_src.plen = cfg->fc_src_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110#endif
1111
Thomas Graf86872cb2006-08-22 00:01:08 -07001112 rt->rt6i_metric = cfg->fc_metric;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
1114 /* We cannot add true routes via loopback here,
1115 they would result in kernel looping; promote them to reject routes
1116 */
Thomas Graf86872cb2006-08-22 00:01:08 -07001117 if ((cfg->fc_flags & RTF_REJECT) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
1119 /* hold loopback dev/idev if we haven't done so. */
Eric W. Biederman2774c7a2007-09-26 22:10:56 -07001120 if (dev != init_net.loopback_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 if (dev) {
1122 dev_put(dev);
1123 in6_dev_put(idev);
1124 }
Eric W. Biederman2774c7a2007-09-26 22:10:56 -07001125 dev = init_net.loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 dev_hold(dev);
1127 idev = in6_dev_get(dev);
1128 if (!idev) {
1129 err = -ENODEV;
1130 goto out;
1131 }
1132 }
1133 rt->u.dst.output = ip6_pkt_discard_out;
1134 rt->u.dst.input = ip6_pkt_discard;
1135 rt->u.dst.error = -ENETUNREACH;
1136 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1137 goto install_route;
1138 }
1139
Thomas Graf86872cb2006-08-22 00:01:08 -07001140 if (cfg->fc_flags & RTF_GATEWAY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 struct in6_addr *gw_addr;
1142 int gwa_type;
1143
Thomas Graf86872cb2006-08-22 00:01:08 -07001144 gw_addr = &cfg->fc_gateway;
1145 ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 gwa_type = ipv6_addr_type(gw_addr);
1147
1148 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1149 struct rt6_info *grt;
1150
1151 /* IPv6 strictly inhibits using not link-local
1152 addresses as nexthop address.
1153 Otherwise, router will not able to send redirects.
1154 It is very good, but in some (rare!) circumstances
1155 (SIT, PtP, NBMA NOARP links) it is handy to allow
1156 some exceptions. --ANK
1157 */
1158 err = -EINVAL;
1159 if (!(gwa_type&IPV6_ADDR_UNICAST))
1160 goto out;
1161
Thomas Graf86872cb2006-08-22 00:01:08 -07001162 grt = rt6_lookup(gw_addr, NULL, cfg->fc_ifindex, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163
1164 err = -EHOSTUNREACH;
1165 if (grt == NULL)
1166 goto out;
1167 if (dev) {
1168 if (dev != grt->rt6i_dev) {
1169 dst_release(&grt->u.dst);
1170 goto out;
1171 }
1172 } else {
1173 dev = grt->rt6i_dev;
1174 idev = grt->rt6i_idev;
1175 dev_hold(dev);
1176 in6_dev_hold(grt->rt6i_idev);
1177 }
1178 if (!(grt->rt6i_flags&RTF_GATEWAY))
1179 err = 0;
1180 dst_release(&grt->u.dst);
1181
1182 if (err)
1183 goto out;
1184 }
1185 err = -EINVAL;
1186 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
1187 goto out;
1188 }
1189
1190 err = -ENODEV;
1191 if (dev == NULL)
1192 goto out;
1193
Thomas Graf86872cb2006-08-22 00:01:08 -07001194 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
1196 if (IS_ERR(rt->rt6i_nexthop)) {
1197 err = PTR_ERR(rt->rt6i_nexthop);
1198 rt->rt6i_nexthop = NULL;
1199 goto out;
1200 }
1201 }
1202
Thomas Graf86872cb2006-08-22 00:01:08 -07001203 rt->rt6i_flags = cfg->fc_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204
1205install_route:
Thomas Graf86872cb2006-08-22 00:01:08 -07001206 if (cfg->fc_mx) {
1207 struct nlattr *nla;
1208 int remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209
Thomas Graf86872cb2006-08-22 00:01:08 -07001210 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
Thomas Graf8f4c1f92007-09-12 14:44:36 +02001211 int type = nla_type(nla);
Thomas Graf86872cb2006-08-22 00:01:08 -07001212
1213 if (type) {
1214 if (type > RTAX_MAX) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 err = -EINVAL;
1216 goto out;
1217 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001218
1219 rt->u.dst.metrics[type - 1] = nla_get_u32(nla);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 }
1222 }
1223
1224 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
1225 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1226 if (!rt->u.dst.metrics[RTAX_MTU-1])
1227 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
1228 if (!rt->u.dst.metrics[RTAX_ADVMSS-1])
1229 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1230 rt->u.dst.dev = dev;
1231 rt->rt6i_idev = idev;
Thomas Grafc71099a2006-08-04 23:20:06 -07001232 rt->rt6i_table = table;
Thomas Graf86872cb2006-08-22 00:01:08 -07001233 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234
1235out:
1236 if (dev)
1237 dev_put(dev);
1238 if (idev)
1239 in6_dev_put(idev);
1240 if (rt)
YOSHIFUJI Hideaki40aa7b92006-10-19 13:50:09 +09001241 dst_free(&rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 return err;
1243}
1244
Thomas Graf86872cb2006-08-22 00:01:08 -07001245static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246{
1247 int err;
Thomas Grafc71099a2006-08-04 23:20:06 -07001248 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249
Patrick McHardy6c813a72006-08-06 22:22:47 -07001250 if (rt == &ip6_null_entry)
1251 return -ENOENT;
1252
Thomas Grafc71099a2006-08-04 23:20:06 -07001253 table = rt->rt6i_table;
1254 write_lock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255
Thomas Graf86872cb2006-08-22 00:01:08 -07001256 err = fib6_del(rt, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 dst_release(&rt->u.dst);
1258
Thomas Grafc71099a2006-08-04 23:20:06 -07001259 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
1261 return err;
1262}
1263
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001264int ip6_del_rt(struct rt6_info *rt)
1265{
Denis V. Lunev4d1169c2008-01-10 03:26:13 -08001266 struct nl_info info = {
1267 .nl_net = &init_net,
1268 };
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08001269 return __ip6_del_rt(rt, &info);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001270}
1271
Thomas Graf86872cb2006-08-22 00:01:08 -07001272static int ip6_route_del(struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273{
Thomas Grafc71099a2006-08-04 23:20:06 -07001274 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 struct fib6_node *fn;
1276 struct rt6_info *rt;
1277 int err = -ESRCH;
1278
Thomas Graf86872cb2006-08-22 00:01:08 -07001279 table = fib6_get_table(cfg->fc_table);
Thomas Grafc71099a2006-08-04 23:20:06 -07001280 if (table == NULL)
1281 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282
Thomas Grafc71099a2006-08-04 23:20:06 -07001283 read_lock_bh(&table->tb6_lock);
1284
1285 fn = fib6_locate(&table->tb6_root,
Thomas Graf86872cb2006-08-22 00:01:08 -07001286 &cfg->fc_dst, cfg->fc_dst_len,
1287 &cfg->fc_src, cfg->fc_src_len);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001288
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 if (fn) {
Eric Dumazet7cc48262007-02-09 16:22:57 -08001290 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
Thomas Graf86872cb2006-08-22 00:01:08 -07001291 if (cfg->fc_ifindex &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 (rt->rt6i_dev == NULL ||
Thomas Graf86872cb2006-08-22 00:01:08 -07001293 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 continue;
Thomas Graf86872cb2006-08-22 00:01:08 -07001295 if (cfg->fc_flags & RTF_GATEWAY &&
1296 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 continue;
Thomas Graf86872cb2006-08-22 00:01:08 -07001298 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 continue;
1300 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001301 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
Thomas Graf86872cb2006-08-22 00:01:08 -07001303 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 }
1305 }
Thomas Grafc71099a2006-08-04 23:20:06 -07001306 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307
1308 return err;
1309}
1310
1311/*
1312 * Handle redirects
1313 */
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001314struct ip6rd_flowi {
1315 struct flowi fl;
1316 struct in6_addr gateway;
1317};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001319static struct rt6_info *__ip6_route_redirect(struct fib6_table *table,
1320 struct flowi *fl,
1321 int flags)
1322{
1323 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1324 struct rt6_info *rt;
1325 struct fib6_node *fn;
Thomas Grafc71099a2006-08-04 23:20:06 -07001326
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 /*
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001328 * Get the "current" route for this destination and
1329 * check if the redirect has come from approriate router.
1330 *
1331 * RFC 2461 specifies that redirects should only be
1332 * accepted if they come from the nexthop to the target.
1333 * Due to the way the routes are chosen, this notion
1334 * is a bit fuzzy and one might need to check all possible
1335 * routes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337
Thomas Grafc71099a2006-08-04 23:20:06 -07001338 read_lock_bh(&table->tb6_lock);
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001339 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001340restart:
Eric Dumazet7cc48262007-02-09 16:22:57 -08001341 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001342 /*
1343 * Current route is on-link; redirect is always invalid.
1344 *
1345 * Seems, previous statement is not true. It could
1346 * be node, which looks for us as on-link (f.e. proxy ndisc)
1347 * But then router serving it might decide, that we should
1348 * know truth 8)8) --ANK (980726).
1349 */
1350 if (rt6_check_expired(rt))
1351 continue;
1352 if (!(rt->rt6i_flags & RTF_GATEWAY))
1353 continue;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001354 if (fl->oif != rt->rt6i_dev->ifindex)
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001355 continue;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001356 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001357 continue;
1358 break;
1359 }
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001360
YOSHIFUJI Hideakicb15d9c2006-08-23 17:23:11 -07001361 if (!rt)
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001362 rt = &ip6_null_entry;
YOSHIFUJI Hideakicb15d9c2006-08-23 17:23:11 -07001363 BACKTRACK(&fl->fl6_src);
1364out:
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001365 dst_hold(&rt->u.dst);
1366
1367 read_unlock_bh(&table->tb6_lock);
1368
1369 return rt;
1370};
1371
1372static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1373 struct in6_addr *src,
1374 struct in6_addr *gateway,
1375 struct net_device *dev)
1376{
Thomas Grafadaa70b2006-10-13 15:01:03 -07001377 int flags = RT6_LOOKUP_F_HAS_SADDR;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001378 struct ip6rd_flowi rdfl = {
1379 .fl = {
1380 .oif = dev->ifindex,
1381 .nl_u = {
1382 .ip6_u = {
1383 .daddr = *dest,
1384 .saddr = *src,
1385 },
1386 },
1387 },
1388 .gateway = *gateway,
1389 };
Thomas Grafadaa70b2006-10-13 15:01:03 -07001390
1391 if (rt6_need_strict(dest))
1392 flags |= RT6_LOOKUP_F_IFACE;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001393
1394 return (struct rt6_info *)fib6_rule_lookup((struct flowi *)&rdfl, flags, __ip6_route_redirect);
1395}
1396
1397void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1398 struct in6_addr *saddr,
1399 struct neighbour *neigh, u8 *lladdr, int on_link)
1400{
1401 struct rt6_info *rt, *nrt = NULL;
1402 struct netevent_redirect netevent;
1403
1404 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1405
1406 if (rt == &ip6_null_entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 if (net_ratelimit())
1408 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1409 "for redirect target\n");
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001410 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 }
1412
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 /*
1414 * We have finally decided to accept it.
1415 */
1416
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001417 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1419 NEIGH_UPDATE_F_OVERRIDE|
1420 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1421 NEIGH_UPDATE_F_ISROUTER))
1422 );
1423
1424 /*
1425 * Redirect received -> path was valid.
1426 * Look, redirects are sent only in response to data packets,
1427 * so that this nexthop apparently is reachable. --ANK
1428 */
1429 dst_confirm(&rt->u.dst);
1430
1431 /* Duplicate redirect: silently ignore. */
1432 if (neigh == rt->u.dst.neighbour)
1433 goto out;
1434
1435 nrt = ip6_rt_copy(rt);
1436 if (nrt == NULL)
1437 goto out;
1438
1439 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1440 if (on_link)
1441 nrt->rt6i_flags &= ~RTF_GATEWAY;
1442
1443 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1444 nrt->rt6i_dst.plen = 128;
1445 nrt->u.dst.flags |= DST_HOST;
1446
1447 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1448 nrt->rt6i_nexthop = neigh_clone(neigh);
1449 /* Reset pmtu, it may be better */
1450 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1451 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1452
Thomas Graf40e22e82006-08-22 00:00:45 -07001453 if (ip6_ins_rt(nrt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 goto out;
1455
Tom Tucker8d717402006-07-30 20:43:36 -07001456 netevent.old = &rt->u.dst;
1457 netevent.new = &nrt->u.dst;
1458 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1459
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 if (rt->rt6i_flags&RTF_CACHE) {
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001461 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 return;
1463 }
1464
1465out:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001466 dst_release(&rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 return;
1468}
1469
1470/*
1471 * Handle ICMP "packet too big" messages
1472 * i.e. Path MTU discovery
1473 */
1474
1475void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1476 struct net_device *dev, u32 pmtu)
1477{
1478 struct rt6_info *rt, *nrt;
1479 int allfrag = 0;
1480
1481 rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1482 if (rt == NULL)
1483 return;
1484
1485 if (pmtu >= dst_mtu(&rt->u.dst))
1486 goto out;
1487
1488 if (pmtu < IPV6_MIN_MTU) {
1489 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001490 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 * MTU (1280) and a fragment header should always be included
1492 * after a node receiving Too Big message reporting PMTU is
1493 * less than the IPv6 Minimum Link MTU.
1494 */
1495 pmtu = IPV6_MIN_MTU;
1496 allfrag = 1;
1497 }
1498
1499 /* New mtu received -> path was valid.
1500 They are sent only in response to data packets,
1501 so that this nexthop apparently is reachable. --ANK
1502 */
1503 dst_confirm(&rt->u.dst);
1504
1505 /* Host route. If it is static, it would be better
1506 not to override it, but add new one, so that
1507 when cache entry will expire old pmtu
1508 would return automatically.
1509 */
1510 if (rt->rt6i_flags & RTF_CACHE) {
1511 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1512 if (allfrag)
1513 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
Daniel Lezcano49905092008-01-10 03:01:01 -08001514 dst_set_expires(&rt->u.dst, init_net.ipv6.sysctl.ip6_rt_mtu_expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1516 goto out;
1517 }
1518
1519 /* Network route.
1520 Two cases are possible:
1521 1. It is connected route. Action: COW
1522 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1523 */
YOSHIFUJI Hideakid5315b52006-03-20 16:58:48 -08001524 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001525 nrt = rt6_alloc_cow(rt, daddr, saddr);
YOSHIFUJI Hideakid5315b52006-03-20 16:58:48 -08001526 else
1527 nrt = rt6_alloc_clone(rt, daddr);
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001528
YOSHIFUJI Hideakid5315b52006-03-20 16:58:48 -08001529 if (nrt) {
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001530 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1531 if (allfrag)
1532 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1533
1534 /* According to RFC 1981, detecting PMTU increase shouldn't be
1535 * happened within 5 mins, the recommended timer is 10 mins.
1536 * Here this route expiration time is set to ip6_rt_mtu_expires
1537 * which is 10 mins. After 10 mins the decreased pmtu is expired
1538 * and detecting PMTU increase will be automatically happened.
1539 */
Daniel Lezcano49905092008-01-10 03:01:01 -08001540 dst_set_expires(&nrt->u.dst, init_net.ipv6.sysctl.ip6_rt_mtu_expires);
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001541 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1542
Thomas Graf40e22e82006-08-22 00:00:45 -07001543 ip6_ins_rt(nrt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545out:
1546 dst_release(&rt->u.dst);
1547}
1548
1549/*
1550 * Misc support functions
1551 */
1552
1553static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1554{
1555 struct rt6_info *rt = ip6_dst_alloc();
1556
1557 if (rt) {
1558 rt->u.dst.input = ort->u.dst.input;
1559 rt->u.dst.output = ort->u.dst.output;
1560
1561 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
Ville Nuorvala22e1e4d2006-10-16 22:14:26 -07001562 rt->u.dst.error = ort->u.dst.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 rt->u.dst.dev = ort->u.dst.dev;
1564 if (rt->u.dst.dev)
1565 dev_hold(rt->u.dst.dev);
1566 rt->rt6i_idev = ort->rt6i_idev;
1567 if (rt->rt6i_idev)
1568 in6_dev_hold(rt->rt6i_idev);
1569 rt->u.dst.lastuse = jiffies;
1570 rt->rt6i_expires = 0;
1571
1572 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1573 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1574 rt->rt6i_metric = 0;
1575
1576 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1577#ifdef CONFIG_IPV6_SUBTREES
1578 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1579#endif
Thomas Grafc71099a2006-08-04 23:20:06 -07001580 rt->rt6i_table = ort->rt6i_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 }
1582 return rt;
1583}
1584
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001585#ifdef CONFIG_IPV6_ROUTE_INFO
1586static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
1587 struct in6_addr *gwaddr, int ifindex)
1588{
1589 struct fib6_node *fn;
1590 struct rt6_info *rt = NULL;
Thomas Grafc71099a2006-08-04 23:20:06 -07001591 struct fib6_table *table;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001592
Thomas Grafc71099a2006-08-04 23:20:06 -07001593 table = fib6_get_table(RT6_TABLE_INFO);
1594 if (table == NULL)
1595 return NULL;
1596
1597 write_lock_bh(&table->tb6_lock);
1598 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001599 if (!fn)
1600 goto out;
1601
Eric Dumazet7cc48262007-02-09 16:22:57 -08001602 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001603 if (rt->rt6i_dev->ifindex != ifindex)
1604 continue;
1605 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1606 continue;
1607 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1608 continue;
1609 dst_hold(&rt->u.dst);
1610 break;
1611 }
1612out:
Thomas Grafc71099a2006-08-04 23:20:06 -07001613 write_unlock_bh(&table->tb6_lock);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001614 return rt;
1615}
1616
1617static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
1618 struct in6_addr *gwaddr, int ifindex,
1619 unsigned pref)
1620{
Thomas Graf86872cb2006-08-22 00:01:08 -07001621 struct fib6_config cfg = {
1622 .fc_table = RT6_TABLE_INFO,
Rami Rosen238fc7e2008-02-09 23:43:11 -08001623 .fc_metric = IP6_RT_PRIO_USER,
Thomas Graf86872cb2006-08-22 00:01:08 -07001624 .fc_ifindex = ifindex,
1625 .fc_dst_len = prefixlen,
1626 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1627 RTF_UP | RTF_PREF(pref),
1628 };
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001629
Thomas Graf86872cb2006-08-22 00:01:08 -07001630 ipv6_addr_copy(&cfg.fc_dst, prefix);
1631 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1632
YOSHIFUJI Hideakie317da92006-03-20 17:06:42 -08001633 /* We should treat it as a default route if prefix length is 0. */
1634 if (!prefixlen)
Thomas Graf86872cb2006-08-22 00:01:08 -07001635 cfg.fc_flags |= RTF_DEFAULT;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001636
Thomas Graf86872cb2006-08-22 00:01:08 -07001637 ip6_route_add(&cfg);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001638
1639 return rt6_get_route_info(prefix, prefixlen, gwaddr, ifindex);
1640}
1641#endif
1642
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001644{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 struct rt6_info *rt;
Thomas Grafc71099a2006-08-04 23:20:06 -07001646 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
Thomas Grafc71099a2006-08-04 23:20:06 -07001648 table = fib6_get_table(RT6_TABLE_DFLT);
1649 if (table == NULL)
1650 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651
Thomas Grafc71099a2006-08-04 23:20:06 -07001652 write_lock_bh(&table->tb6_lock);
Eric Dumazet7cc48262007-02-09 16:22:57 -08001653 for (rt = table->tb6_root.leaf; rt; rt=rt->u.dst.rt6_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 if (dev == rt->rt6i_dev &&
YOSHIFUJI Hideaki045927f2006-03-20 17:00:48 -08001655 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1657 break;
1658 }
1659 if (rt)
1660 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001661 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 return rt;
1663}
1664
Fred L. Templinc7dc89c2007-11-29 22:11:40 +11001665EXPORT_SYMBOL(rt6_get_dflt_router);
1666
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001668 struct net_device *dev,
1669 unsigned int pref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670{
Thomas Graf86872cb2006-08-22 00:01:08 -07001671 struct fib6_config cfg = {
1672 .fc_table = RT6_TABLE_DFLT,
Rami Rosen238fc7e2008-02-09 23:43:11 -08001673 .fc_metric = IP6_RT_PRIO_USER,
Thomas Graf86872cb2006-08-22 00:01:08 -07001674 .fc_ifindex = dev->ifindex,
1675 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1676 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1677 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678
Thomas Graf86872cb2006-08-22 00:01:08 -07001679 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680
Thomas Graf86872cb2006-08-22 00:01:08 -07001681 ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 return rt6_get_dflt_router(gwaddr, dev);
1684}
1685
1686void rt6_purge_dflt_routers(void)
1687{
1688 struct rt6_info *rt;
Thomas Grafc71099a2006-08-04 23:20:06 -07001689 struct fib6_table *table;
1690
1691 /* NOTE: Keep consistent with rt6_get_dflt_router */
1692 table = fib6_get_table(RT6_TABLE_DFLT);
1693 if (table == NULL)
1694 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695
1696restart:
Thomas Grafc71099a2006-08-04 23:20:06 -07001697 read_lock_bh(&table->tb6_lock);
Eric Dumazet7cc48262007-02-09 16:22:57 -08001698 for (rt = table->tb6_root.leaf; rt; rt = rt->u.dst.rt6_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1700 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001701 read_unlock_bh(&table->tb6_lock);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001702 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 goto restart;
1704 }
1705 }
Thomas Grafc71099a2006-08-04 23:20:06 -07001706 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707}
1708
Thomas Graf86872cb2006-08-22 00:01:08 -07001709static void rtmsg_to_fib6_config(struct in6_rtmsg *rtmsg,
1710 struct fib6_config *cfg)
1711{
1712 memset(cfg, 0, sizeof(*cfg));
1713
1714 cfg->fc_table = RT6_TABLE_MAIN;
1715 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1716 cfg->fc_metric = rtmsg->rtmsg_metric;
1717 cfg->fc_expires = rtmsg->rtmsg_info;
1718 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1719 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1720 cfg->fc_flags = rtmsg->rtmsg_flags;
1721
Benjamin Theryf1243c22008-02-26 18:10:03 -08001722 cfg->fc_nlinfo.nl_net = &init_net;
1723
Thomas Graf86872cb2006-08-22 00:01:08 -07001724 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1725 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1726 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1727}
1728
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1730{
Thomas Graf86872cb2006-08-22 00:01:08 -07001731 struct fib6_config cfg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 struct in6_rtmsg rtmsg;
1733 int err;
1734
1735 switch(cmd) {
1736 case SIOCADDRT: /* Add a route */
1737 case SIOCDELRT: /* Delete a route */
1738 if (!capable(CAP_NET_ADMIN))
1739 return -EPERM;
1740 err = copy_from_user(&rtmsg, arg,
1741 sizeof(struct in6_rtmsg));
1742 if (err)
1743 return -EFAULT;
Thomas Graf86872cb2006-08-22 00:01:08 -07001744
1745 rtmsg_to_fib6_config(&rtmsg, &cfg);
1746
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 rtnl_lock();
1748 switch (cmd) {
1749 case SIOCADDRT:
Thomas Graf86872cb2006-08-22 00:01:08 -07001750 err = ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 break;
1752 case SIOCDELRT:
Thomas Graf86872cb2006-08-22 00:01:08 -07001753 err = ip6_route_del(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 break;
1755 default:
1756 err = -EINVAL;
1757 }
1758 rtnl_unlock();
1759
1760 return err;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001761 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762
1763 return -EINVAL;
1764}
1765
1766/*
1767 * Drop the packet on the floor
1768 */
1769
Ilpo Järvinen50eb4312008-01-12 03:21:00 -08001770static int ip6_pkt_drop(struct sk_buff *skb, int code, int ipstats_mib_noroutes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001772 int type;
1773 switch (ipstats_mib_noroutes) {
1774 case IPSTATS_MIB_INNOROUTES:
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001775 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001776 if (type == IPV6_ADDR_ANY || type == IPV6_ADDR_RESERVED) {
1777 IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
1778 break;
1779 }
1780 /* FALLTHROUGH */
1781 case IPSTATS_MIB_OUTNOROUTES:
1782 IP6_INC_STATS(ip6_dst_idev(skb->dst), ipstats_mib_noroutes);
1783 break;
1784 }
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001785 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 kfree_skb(skb);
1787 return 0;
1788}
1789
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001790static int ip6_pkt_discard(struct sk_buff *skb)
1791{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001792 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001793}
1794
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001795static int ip6_pkt_discard_out(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796{
1797 skb->dev = skb->dst->dev;
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001798 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799}
1800
David S. Miller6723ab52006-10-18 21:20:57 -07001801#ifdef CONFIG_IPV6_MULTIPLE_TABLES
1802
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001803static int ip6_pkt_prohibit(struct sk_buff *skb)
1804{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001805 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001806}
1807
1808static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1809{
1810 skb->dev = skb->dst->dev;
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001811 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001812}
1813
David S. Miller6723ab52006-10-18 21:20:57 -07001814#endif
1815
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816/*
1817 * Allocate a dst for local (unicast / anycast) address.
1818 */
1819
1820struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1821 const struct in6_addr *addr,
1822 int anycast)
1823{
1824 struct rt6_info *rt = ip6_dst_alloc();
1825
1826 if (rt == NULL)
1827 return ERR_PTR(-ENOMEM);
1828
Eric W. Biederman2774c7a2007-09-26 22:10:56 -07001829 dev_hold(init_net.loopback_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 in6_dev_hold(idev);
1831
1832 rt->u.dst.flags = DST_HOST;
1833 rt->u.dst.input = ip6_input;
1834 rt->u.dst.output = ip6_output;
Eric W. Biederman2774c7a2007-09-26 22:10:56 -07001835 rt->rt6i_dev = init_net.loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 rt->rt6i_idev = idev;
1837 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1838 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1839 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1840 rt->u.dst.obsolete = -1;
1841
1842 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +09001843 if (anycast)
1844 rt->rt6i_flags |= RTF_ANYCAST;
1845 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 rt->rt6i_flags |= RTF_LOCAL;
1847 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1848 if (rt->rt6i_nexthop == NULL) {
YOSHIFUJI Hideaki40aa7b92006-10-19 13:50:09 +09001849 dst_free(&rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 return ERR_PTR(-ENOMEM);
1851 }
1852
1853 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1854 rt->rt6i_dst.plen = 128;
Thomas Grafc71099a2006-08-04 23:20:06 -07001855 rt->rt6i_table = fib6_get_table(RT6_TABLE_LOCAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856
1857 atomic_set(&rt->u.dst.__refcnt, 1);
1858
1859 return rt;
1860}
1861
1862static int fib6_ifdown(struct rt6_info *rt, void *arg)
1863{
1864 if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1865 rt != &ip6_null_entry) {
1866 RT6_TRACE("deleted by ifdown %p\n", rt);
1867 return -1;
1868 }
1869 return 0;
1870}
1871
1872void rt6_ifdown(struct net_device *dev)
1873{
Thomas Grafc71099a2006-08-04 23:20:06 -07001874 fib6_clean_all(fib6_ifdown, 0, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875}
1876
1877struct rt6_mtu_change_arg
1878{
1879 struct net_device *dev;
1880 unsigned mtu;
1881};
1882
1883static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1884{
1885 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1886 struct inet6_dev *idev;
1887
1888 /* In IPv6 pmtu discovery is not optional,
1889 so that RTAX_MTU lock cannot disable it.
1890 We still use this lock to block changes
1891 caused by addrconf/ndisc.
1892 */
1893
1894 idev = __in6_dev_get(arg->dev);
1895 if (idev == NULL)
1896 return 0;
1897
1898 /* For administrative MTU increase, there is no way to discover
1899 IPv6 PMTU increase, so PMTU increase should be updated here.
1900 Since RFC 1981 doesn't include administrative MTU increase
1901 update PMTU increase is a MUST. (i.e. jumbo frame)
1902 */
1903 /*
1904 If new MTU is less than route PMTU, this new MTU will be the
1905 lowest MTU in the path, update the route PMTU to reflect PMTU
1906 decreases; if new MTU is greater than route PMTU, and the
1907 old MTU is the lowest MTU in the path, update the route PMTU
1908 to reflect the increase. In this case if the other nodes' MTU
1909 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1910 PMTU discouvery.
1911 */
1912 if (rt->rt6i_dev == arg->dev &&
1913 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
Jim Paris23717792008-01-31 16:36:25 -08001914 (dst_mtu(&rt->u.dst) >= arg->mtu ||
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001915 (dst_mtu(&rt->u.dst) < arg->mtu &&
Simon Arlott566cfd82007-07-26 00:09:55 -07001916 dst_mtu(&rt->u.dst) == idev->cnf.mtu6))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
Simon Arlott566cfd82007-07-26 00:09:55 -07001918 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1919 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 return 0;
1921}
1922
1923void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1924{
Thomas Grafc71099a2006-08-04 23:20:06 -07001925 struct rt6_mtu_change_arg arg = {
1926 .dev = dev,
1927 .mtu = mtu,
1928 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929
Thomas Grafc71099a2006-08-04 23:20:06 -07001930 fib6_clean_all(rt6_mtu_change_route, 0, &arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931}
1932
Patrick McHardyef7c79e2007-06-05 12:38:30 -07001933static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
Thomas Graf5176f912006-08-26 20:13:18 -07001934 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
Thomas Graf86872cb2006-08-22 00:01:08 -07001935 [RTA_OIF] = { .type = NLA_U32 },
Thomas Grafab364a62006-08-22 00:01:47 -07001936 [RTA_IIF] = { .type = NLA_U32 },
Thomas Graf86872cb2006-08-22 00:01:08 -07001937 [RTA_PRIORITY] = { .type = NLA_U32 },
1938 [RTA_METRICS] = { .type = NLA_NESTED },
1939};
1940
1941static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
1942 struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943{
Thomas Graf86872cb2006-08-22 00:01:08 -07001944 struct rtmsg *rtm;
1945 struct nlattr *tb[RTA_MAX+1];
1946 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947
Thomas Graf86872cb2006-08-22 00:01:08 -07001948 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
1949 if (err < 0)
1950 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951
Thomas Graf86872cb2006-08-22 00:01:08 -07001952 err = -EINVAL;
1953 rtm = nlmsg_data(nlh);
1954 memset(cfg, 0, sizeof(*cfg));
1955
1956 cfg->fc_table = rtm->rtm_table;
1957 cfg->fc_dst_len = rtm->rtm_dst_len;
1958 cfg->fc_src_len = rtm->rtm_src_len;
1959 cfg->fc_flags = RTF_UP;
1960 cfg->fc_protocol = rtm->rtm_protocol;
1961
1962 if (rtm->rtm_type == RTN_UNREACHABLE)
1963 cfg->fc_flags |= RTF_REJECT;
1964
1965 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
1966 cfg->fc_nlinfo.nlh = nlh;
Benjamin Thery2216b482008-01-30 19:09:35 -08001967 cfg->fc_nlinfo.nl_net = skb->sk->sk_net;
Thomas Graf86872cb2006-08-22 00:01:08 -07001968
1969 if (tb[RTA_GATEWAY]) {
1970 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
1971 cfg->fc_flags |= RTF_GATEWAY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001973
1974 if (tb[RTA_DST]) {
1975 int plen = (rtm->rtm_dst_len + 7) >> 3;
1976
1977 if (nla_len(tb[RTA_DST]) < plen)
1978 goto errout;
1979
1980 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001982
1983 if (tb[RTA_SRC]) {
1984 int plen = (rtm->rtm_src_len + 7) >> 3;
1985
1986 if (nla_len(tb[RTA_SRC]) < plen)
1987 goto errout;
1988
1989 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001991
1992 if (tb[RTA_OIF])
1993 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
1994
1995 if (tb[RTA_PRIORITY])
1996 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
1997
1998 if (tb[RTA_METRICS]) {
1999 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2000 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002002
2003 if (tb[RTA_TABLE])
2004 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2005
2006 err = 0;
2007errout:
2008 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009}
2010
Thomas Grafc127ea22007-03-22 11:58:32 -07002011static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012{
Denis V. Lunevb8542722007-12-01 00:21:31 +11002013 struct net *net = skb->sk->sk_net;
Thomas Graf86872cb2006-08-22 00:01:08 -07002014 struct fib6_config cfg;
2015 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016
Denis V. Lunevb8542722007-12-01 00:21:31 +11002017 if (net != &init_net)
2018 return -EINVAL;
2019
Thomas Graf86872cb2006-08-22 00:01:08 -07002020 err = rtm_to_fib6_config(skb, nlh, &cfg);
2021 if (err < 0)
2022 return err;
2023
2024 return ip6_route_del(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025}
2026
Thomas Grafc127ea22007-03-22 11:58:32 -07002027static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028{
Denis V. Lunevb8542722007-12-01 00:21:31 +11002029 struct net *net = skb->sk->sk_net;
Thomas Graf86872cb2006-08-22 00:01:08 -07002030 struct fib6_config cfg;
2031 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032
Denis V. Lunevb8542722007-12-01 00:21:31 +11002033 if (net != &init_net)
2034 return -EINVAL;
2035
Thomas Graf86872cb2006-08-22 00:01:08 -07002036 err = rtm_to_fib6_config(skb, nlh, &cfg);
2037 if (err < 0)
2038 return err;
2039
2040 return ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041}
2042
Thomas Graf339bf982006-11-10 14:10:15 -08002043static inline size_t rt6_nlmsg_size(void)
2044{
2045 return NLMSG_ALIGN(sizeof(struct rtmsg))
2046 + nla_total_size(16) /* RTA_SRC */
2047 + nla_total_size(16) /* RTA_DST */
2048 + nla_total_size(16) /* RTA_GATEWAY */
2049 + nla_total_size(16) /* RTA_PREFSRC */
2050 + nla_total_size(4) /* RTA_TABLE */
2051 + nla_total_size(4) /* RTA_IIF */
2052 + nla_total_size(4) /* RTA_OIF */
2053 + nla_total_size(4) /* RTA_PRIORITY */
Noriaki TAKAMIYA6a2b9ce2007-01-23 22:09:41 -08002054 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
Thomas Graf339bf982006-11-10 14:10:15 -08002055 + nla_total_size(sizeof(struct rta_cacheinfo));
2056}
2057
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
Jamal Hadi Salim0d51aa82005-06-21 13:51:04 -07002059 struct in6_addr *dst, struct in6_addr *src,
2060 int iif, int type, u32 pid, u32 seq,
2061 int prefix, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062{
2063 struct rtmsg *rtm;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002064 struct nlmsghdr *nlh;
Thomas Grafe3703b32006-11-27 09:27:07 -08002065 long expires;
Patrick McHardy9e762a42006-08-10 23:09:48 -07002066 u32 table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067
2068 if (prefix) { /* user wants prefix routes only */
2069 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2070 /* success since this is not a prefix route */
2071 return 1;
2072 }
2073 }
2074
Thomas Graf2d7202b2006-08-22 00:01:27 -07002075 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2076 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08002077 return -EMSGSIZE;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002078
2079 rtm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 rtm->rtm_family = AF_INET6;
2081 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2082 rtm->rtm_src_len = rt->rt6i_src.plen;
2083 rtm->rtm_tos = 0;
Thomas Grafc71099a2006-08-04 23:20:06 -07002084 if (rt->rt6i_table)
Patrick McHardy9e762a42006-08-10 23:09:48 -07002085 table = rt->rt6i_table->tb6_id;
Thomas Grafc71099a2006-08-04 23:20:06 -07002086 else
Patrick McHardy9e762a42006-08-10 23:09:48 -07002087 table = RT6_TABLE_UNSPEC;
2088 rtm->rtm_table = table;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002089 NLA_PUT_U32(skb, RTA_TABLE, table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090 if (rt->rt6i_flags&RTF_REJECT)
2091 rtm->rtm_type = RTN_UNREACHABLE;
2092 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2093 rtm->rtm_type = RTN_LOCAL;
2094 else
2095 rtm->rtm_type = RTN_UNICAST;
2096 rtm->rtm_flags = 0;
2097 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2098 rtm->rtm_protocol = rt->rt6i_protocol;
2099 if (rt->rt6i_flags&RTF_DYNAMIC)
2100 rtm->rtm_protocol = RTPROT_REDIRECT;
2101 else if (rt->rt6i_flags & RTF_ADDRCONF)
2102 rtm->rtm_protocol = RTPROT_KERNEL;
2103 else if (rt->rt6i_flags&RTF_DEFAULT)
2104 rtm->rtm_protocol = RTPROT_RA;
2105
2106 if (rt->rt6i_flags&RTF_CACHE)
2107 rtm->rtm_flags |= RTM_F_CLONED;
2108
2109 if (dst) {
Thomas Graf2d7202b2006-08-22 00:01:27 -07002110 NLA_PUT(skb, RTA_DST, 16, dst);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002111 rtm->rtm_dst_len = 128;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 } else if (rtm->rtm_dst_len)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002113 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114#ifdef CONFIG_IPV6_SUBTREES
2115 if (src) {
Thomas Graf2d7202b2006-08-22 00:01:27 -07002116 NLA_PUT(skb, RTA_SRC, 16, src);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002117 rtm->rtm_src_len = 128;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 } else if (rtm->rtm_src_len)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002119 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120#endif
2121 if (iif)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002122 NLA_PUT_U32(skb, RTA_IIF, iif);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 else if (dst) {
2124 struct in6_addr saddr_buf;
2125 if (ipv6_get_saddr(&rt->u.dst, dst, &saddr_buf) == 0)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002126 NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 }
Thomas Graf2d7202b2006-08-22 00:01:27 -07002128
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002130 goto nla_put_failure;
2131
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 if (rt->u.dst.neighbour)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002133 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
2134
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 if (rt->u.dst.dev)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002136 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2137
2138 NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
Thomas Grafe3703b32006-11-27 09:27:07 -08002139
2140 expires = rt->rt6i_expires ? rt->rt6i_expires - jiffies : 0;
2141 if (rtnl_put_cacheinfo(skb, &rt->u.dst, 0, 0, 0,
2142 expires, rt->u.dst.error) < 0)
2143 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144
Thomas Graf2d7202b2006-08-22 00:01:27 -07002145 return nlmsg_end(skb, nlh);
2146
2147nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002148 nlmsg_cancel(skb, nlh);
2149 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150}
2151
Patrick McHardy1b43af52006-08-10 23:11:17 -07002152int rt6_dump_route(struct rt6_info *rt, void *p_arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153{
2154 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2155 int prefix;
2156
Thomas Graf2d7202b2006-08-22 00:01:27 -07002157 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2158 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2160 } else
2161 prefix = 0;
2162
2163 return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2164 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
Jamal Hadi Salim0d51aa82005-06-21 13:51:04 -07002165 prefix, NLM_F_MULTI);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166}
2167
Thomas Grafc127ea22007-03-22 11:58:32 -07002168static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169{
Denis V. Lunevb8542722007-12-01 00:21:31 +11002170 struct net *net = in_skb->sk->sk_net;
Thomas Grafab364a62006-08-22 00:01:47 -07002171 struct nlattr *tb[RTA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 struct rt6_info *rt;
Thomas Grafab364a62006-08-22 00:01:47 -07002173 struct sk_buff *skb;
2174 struct rtmsg *rtm;
2175 struct flowi fl;
2176 int err, iif = 0;
2177
Denis V. Lunevb8542722007-12-01 00:21:31 +11002178 if (net != &init_net)
2179 return -EINVAL;
2180
Thomas Grafab364a62006-08-22 00:01:47 -07002181 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2182 if (err < 0)
2183 goto errout;
2184
2185 err = -EINVAL;
2186 memset(&fl, 0, sizeof(fl));
2187
2188 if (tb[RTA_SRC]) {
2189 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2190 goto errout;
2191
2192 ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2193 }
2194
2195 if (tb[RTA_DST]) {
2196 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2197 goto errout;
2198
2199 ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2200 }
2201
2202 if (tb[RTA_IIF])
2203 iif = nla_get_u32(tb[RTA_IIF]);
2204
2205 if (tb[RTA_OIF])
2206 fl.oif = nla_get_u32(tb[RTA_OIF]);
2207
2208 if (iif) {
2209 struct net_device *dev;
Eric W. Biederman881d9662007-09-17 11:56:21 -07002210 dev = __dev_get_by_index(&init_net, iif);
Thomas Grafab364a62006-08-22 00:01:47 -07002211 if (!dev) {
2212 err = -ENODEV;
2213 goto errout;
2214 }
2215 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216
2217 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
Thomas Grafab364a62006-08-22 00:01:47 -07002218 if (skb == NULL) {
2219 err = -ENOBUFS;
2220 goto errout;
2221 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222
2223 /* Reserve room for dummy headers, this skb can pass
2224 through good chunk of routing engine.
2225 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07002226 skb_reset_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2228
Thomas Grafab364a62006-08-22 00:01:47 -07002229 rt = (struct rt6_info*) ip6_route_output(NULL, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 skb->dst = &rt->u.dst;
2231
Thomas Grafab364a62006-08-22 00:01:47 -07002232 err = rt6_fill_node(skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
Jamal Hadi Salim0d51aa82005-06-21 13:51:04 -07002234 nlh->nlmsg_seq, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 if (err < 0) {
Thomas Grafab364a62006-08-22 00:01:47 -07002236 kfree_skb(skb);
2237 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 }
2239
Denis V. Lunev97c53ca2007-11-19 22:26:51 -08002240 err = rtnl_unicast(skb, &init_net, NETLINK_CB(in_skb).pid);
Thomas Grafab364a62006-08-22 00:01:47 -07002241errout:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243}
2244
Thomas Graf86872cb2006-08-22 00:01:08 -07002245void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246{
2247 struct sk_buff *skb;
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08002248 u32 seq;
2249 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08002251 err = -ENOBUFS;
2252 seq = info->nlh != NULL ? info->nlh->nlmsg_seq : 0;
Thomas Graf86872cb2006-08-22 00:01:08 -07002253
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
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08002258 err = rt6_fill_node(skb, rt, NULL, NULL, 0,
2259 event, info->pid, seq, 0, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08002260 if (err < 0) {
2261 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2262 WARN_ON(err == -EMSGSIZE);
2263 kfree_skb(skb);
2264 goto errout;
2265 }
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08002266 err = rtnl_notify(skb, &init_net, info->pid,
2267 RTNLGRP_IPV6_ROUTE, info->nlh, gfp_any());
Thomas Graf21713eb2006-08-15 00:35:24 -07002268errout:
2269 if (err < 0)
Denis V. Lunev97c53ca2007-11-19 22:26:51 -08002270 rtnl_set_sk_err(&init_net, RTNLGRP_IPV6_ROUTE, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271}
2272
2273/*
2274 * /proc
2275 */
2276
2277#ifdef CONFIG_PROC_FS
2278
2279#define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2280
2281struct rt6_proc_arg
2282{
2283 char *buffer;
2284 int offset;
2285 int length;
2286 int skip;
2287 int len;
2288};
2289
2290static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2291{
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002292 struct seq_file *m = p_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002294 seq_printf(m, NIP6_SEQFMT " %02x ", NIP6(rt->rt6i_dst.addr),
2295 rt->rt6i_dst.plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296
2297#ifdef CONFIG_IPV6_SUBTREES
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002298 seq_printf(m, NIP6_SEQFMT " %02x ", NIP6(rt->rt6i_src.addr),
2299 rt->rt6i_src.plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300#else
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002301 seq_puts(m, "00000000000000000000000000000000 00 ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302#endif
2303
2304 if (rt->rt6i_nexthop) {
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002305 seq_printf(m, NIP6_SEQFMT,
2306 NIP6(*((struct in6_addr *)rt->rt6i_nexthop->primary_key)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 } else {
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002308 seq_puts(m, "00000000000000000000000000000000");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 }
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002310 seq_printf(m, " %08x %08x %08x %08x %8s\n",
2311 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
2312 rt->u.dst.__use, rt->rt6i_flags,
2313 rt->rt6i_dev ? rt->rt6i_dev->name : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 return 0;
2315}
2316
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002317static int ipv6_route_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318{
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002319 fib6_clean_all(rt6_info_route, 0, m);
2320 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321}
2322
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002323static int ipv6_route_open(struct inode *inode, struct file *file)
2324{
2325 return single_open(file, ipv6_route_show, NULL);
2326}
2327
2328static const struct file_operations ipv6_route_proc_fops = {
2329 .owner = THIS_MODULE,
2330 .open = ipv6_route_open,
2331 .read = seq_read,
2332 .llseek = seq_lseek,
2333 .release = single_release,
2334};
2335
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2337{
2338 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2339 rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
2340 rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
2341 rt6_stats.fib_rt_cache,
2342 atomic_read(&ip6_dst_ops.entries),
2343 rt6_stats.fib_discarded_routes);
2344
2345 return 0;
2346}
2347
2348static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2349{
2350 return single_open(file, rt6_stats_seq_show, NULL);
2351}
2352
Arjan van de Ven9a321442007-02-12 00:55:35 -08002353static const struct file_operations rt6_stats_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354 .owner = THIS_MODULE,
2355 .open = rt6_stats_seq_open,
2356 .read = seq_read,
2357 .llseek = seq_lseek,
2358 .release = single_release,
2359};
Daniel Lezcano75314fb2007-12-08 00:13:32 -08002360
2361static int ipv6_route_proc_init(struct net *net)
2362{
2363 int ret = -ENOMEM;
2364 if (!proc_net_fops_create(net, "ipv6_route",
2365 0, &ipv6_route_proc_fops))
2366 goto out;
2367
2368 if (!proc_net_fops_create(net, "rt6_stats",
2369 S_IRUGO, &rt6_stats_seq_fops))
2370 goto out_ipv6_route;
2371
2372 ret = 0;
2373out:
2374 return ret;
2375out_ipv6_route:
2376 proc_net_remove(net, "ipv6_route");
2377 goto out;
2378}
2379
2380static void ipv6_route_proc_fini(struct net *net)
2381{
2382 proc_net_remove(net, "ipv6_route");
2383 proc_net_remove(net, "rt6_stats");
2384}
2385#else
2386static inline int ipv6_route_proc_init(struct net *net)
2387{
2388 return 0;
2389}
2390static inline void ipv6_route_proc_fini(struct net *net)
2391{
2392 return ;
2393}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394#endif /* CONFIG_PROC_FS */
2395
2396#ifdef CONFIG_SYSCTL
2397
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398static
2399int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
2400 void __user *buffer, size_t *lenp, loff_t *ppos)
2401{
Daniel Lezcano49905092008-01-10 03:01:01 -08002402 int delay = init_net.ipv6.sysctl.flush_delay;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 if (write) {
2404 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
Daniel Lezcano49905092008-01-10 03:01:01 -08002405 fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406 return 0;
2407 } else
2408 return -EINVAL;
2409}
2410
Daniel Lezcano760f2d02008-01-10 02:53:43 -08002411ctl_table ipv6_route_table_template[] = {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002412 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413 .procname = "flush",
Daniel Lezcano49905092008-01-10 03:01:01 -08002414 .data = &init_net.ipv6.sysctl.flush_delay,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415 .maxlen = sizeof(int),
Dave Jones89c8b3a12005-04-28 12:11:49 -07002416 .mode = 0200,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002417 .proc_handler = &ipv6_sysctl_rtcache_flush
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 },
2419 {
2420 .ctl_name = NET_IPV6_ROUTE_GC_THRESH,
2421 .procname = "gc_thresh",
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002422 .data = &ip6_dst_ops.gc_thresh,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 .maxlen = sizeof(int),
2424 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002425 .proc_handler = &proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426 },
2427 {
2428 .ctl_name = NET_IPV6_ROUTE_MAX_SIZE,
2429 .procname = "max_size",
Daniel Lezcano49905092008-01-10 03:01:01 -08002430 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 .maxlen = sizeof(int),
2432 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002433 .proc_handler = &proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434 },
2435 {
2436 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL,
2437 .procname = "gc_min_interval",
Daniel Lezcano49905092008-01-10 03:01:01 -08002438 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439 .maxlen = sizeof(int),
2440 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002441 .proc_handler = &proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442 .strategy = &sysctl_jiffies,
2443 },
2444 {
2445 .ctl_name = NET_IPV6_ROUTE_GC_TIMEOUT,
2446 .procname = "gc_timeout",
Daniel Lezcano49905092008-01-10 03:01:01 -08002447 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448 .maxlen = sizeof(int),
2449 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002450 .proc_handler = &proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451 .strategy = &sysctl_jiffies,
2452 },
2453 {
2454 .ctl_name = NET_IPV6_ROUTE_GC_INTERVAL,
2455 .procname = "gc_interval",
Daniel Lezcano49905092008-01-10 03:01:01 -08002456 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002457 .maxlen = sizeof(int),
2458 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002459 .proc_handler = &proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460 .strategy = &sysctl_jiffies,
2461 },
2462 {
2463 .ctl_name = NET_IPV6_ROUTE_GC_ELASTICITY,
2464 .procname = "gc_elasticity",
Daniel Lezcano49905092008-01-10 03:01:01 -08002465 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 .maxlen = sizeof(int),
2467 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002468 .proc_handler = &proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469 .strategy = &sysctl_jiffies,
2470 },
2471 {
2472 .ctl_name = NET_IPV6_ROUTE_MTU_EXPIRES,
2473 .procname = "mtu_expires",
Daniel Lezcano49905092008-01-10 03:01:01 -08002474 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 .maxlen = sizeof(int),
2476 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002477 .proc_handler = &proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478 .strategy = &sysctl_jiffies,
2479 },
2480 {
2481 .ctl_name = NET_IPV6_ROUTE_MIN_ADVMSS,
2482 .procname = "min_adv_mss",
Daniel Lezcano49905092008-01-10 03:01:01 -08002483 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484 .maxlen = sizeof(int),
2485 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002486 .proc_handler = &proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487 .strategy = &sysctl_jiffies,
2488 },
2489 {
2490 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2491 .procname = "gc_min_interval_ms",
Daniel Lezcano49905092008-01-10 03:01:01 -08002492 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 .maxlen = sizeof(int),
2494 .mode = 0644,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002495 .proc_handler = &proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 .strategy = &sysctl_ms_jiffies,
2497 },
2498 { .ctl_name = 0 }
2499};
2500
Daniel Lezcano760f2d02008-01-10 02:53:43 -08002501struct ctl_table *ipv6_route_sysctl_init(struct net *net)
2502{
2503 struct ctl_table *table;
2504
2505 table = kmemdup(ipv6_route_table_template,
2506 sizeof(ipv6_route_table_template),
2507 GFP_KERNEL);
2508 return table;
2509}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002510#endif
2511
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002512int __init ip6_route_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513{
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002514 int ret;
2515
Alexey Dobriyane5d679f332006-08-26 19:25:52 -07002516 ip6_dst_ops.kmem_cachep =
2517 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
Daniel Lezcanof845ab62007-12-07 00:45:16 -08002518 SLAB_HWCACHE_ALIGN, NULL);
2519 if (!ip6_dst_ops.kmem_cachep)
2520 return -ENOMEM;
2521
David S. Miller14e50e52007-05-24 18:17:54 -07002522 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops.kmem_cachep;
2523
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002524 ret = fib6_init();
2525 if (ret)
2526 goto out_kmem_cache;
2527
Daniel Lezcano75314fb2007-12-08 00:13:32 -08002528 ret = ipv6_route_proc_init(&init_net);
2529 if (ret)
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002530 goto out_fib6_init;
2531
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002532 ret = xfrm6_init();
2533 if (ret)
Daniel Lezcano75314fb2007-12-08 00:13:32 -08002534 goto out_proc_init;
Daniel Lezcanoc35b7e72007-12-08 00:14:11 -08002535
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002536 ret = fib6_rules_init();
2537 if (ret)
2538 goto xfrm6_init;
Daniel Lezcano7e5449c2007-12-08 00:14:54 -08002539
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002540 ret = -ENOBUFS;
2541 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL) ||
2542 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL) ||
2543 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL))
2544 goto fib6_rules_init;
2545
2546 ret = 0;
2547out:
2548 return ret;
2549
2550fib6_rules_init:
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002551 fib6_rules_cleanup();
2552xfrm6_init:
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002553 xfrm6_fini();
Daniel Lezcano75314fb2007-12-08 00:13:32 -08002554out_proc_init:
2555 ipv6_route_proc_fini(&init_net);
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002556out_fib6_init:
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002557 rt6_ifdown(NULL);
2558 fib6_gc_cleanup();
2559out_kmem_cache:
2560 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);
2561 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562}
2563
2564void ip6_route_cleanup(void)
2565{
Thomas Graf101367c2006-08-04 03:39:02 -07002566 fib6_rules_cleanup();
Daniel Lezcano75314fb2007-12-08 00:13:32 -08002567 ipv6_route_proc_fini(&init_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 xfrm6_fini();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569 rt6_ifdown(NULL);
2570 fib6_gc_cleanup();
2571 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);
2572}