blob: 05ebd7833043c687010382fb2d1534ef1bd45b8a [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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 */
13
14/* Changes:
15 *
16 * YOSHIFUJI Hideaki @USAGI
17 * reworked default router selection.
18 * - respect outgoing interface
19 * - select from (probably) reachable routers (i.e.
20 * routers in REACHABLE, STALE, DELAY or PROBE states).
21 * - always select the same router if it is (probably)
22 * reachable. otherwise, round-robin the list.
YOSHIFUJI Hideakic0bece92006-08-23 17:23:25 -070023 * Ville Nuorvala
24 * Fixed routing subtrees.
Linus Torvalds1da177e2005-04-16 15:20:36 -070025 */
26
Randy Dunlap4fc268d2006-01-11 12:17:47 -080027#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/errno.h>
29#include <linux/types.h>
30#include <linux/times.h>
31#include <linux/socket.h>
32#include <linux/sockios.h>
33#include <linux/net.h>
34#include <linux/route.h>
35#include <linux/netdevice.h>
36#include <linux/in6.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090037#include <linux/mroute6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <linux/if_arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/proc_fs.h>
41#include <linux/seq_file.h>
Daniel Lezcano5b7c9312008-03-03 23:28:58 -080042#include <linux/nsproxy.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090043#include <linux/slab.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020044#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <net/snmp.h>
46#include <net/ipv6.h>
47#include <net/ip6_fib.h>
48#include <net/ip6_route.h>
49#include <net/ndisc.h>
50#include <net/addrconf.h>
51#include <net/tcp.h>
52#include <linux/rtnetlink.h>
53#include <net/dst.h>
54#include <net/xfrm.h>
Tom Tucker8d717402006-07-30 20:43:36 -070055#include <net/netevent.h>
Thomas Graf21713eb2006-08-15 00:35:24 -070056#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
58#include <asm/uaccess.h>
59
60#ifdef CONFIG_SYSCTL
61#include <linux/sysctl.h>
62#endif
63
64/* Set to 3 to get tracing. */
65#define RT6_DEBUG 2
66
67#if RT6_DEBUG >= 3
68#define RDBG(x) printk x
69#define RT6_TRACE(x...) printk(KERN_DEBUG x)
70#else
71#define RDBG(x)
72#define RT6_TRACE(x...) do { ; } while (0)
73#endif
74
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -080075#define CLONE_OFFLINK_ROUTE 0
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Linus Torvalds1da177e2005-04-16 15:20:36 -070077static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
78static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
79static struct dst_entry *ip6_negative_advice(struct dst_entry *);
80static void ip6_dst_destroy(struct dst_entry *);
81static void ip6_dst_ifdown(struct dst_entry *,
82 struct net_device *dev, int how);
Daniel Lezcano569d3642008-01-18 03:56:57 -080083static int ip6_dst_gc(struct dst_ops *ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
85static int ip6_pkt_discard(struct sk_buff *skb);
86static int ip6_pkt_discard_out(struct sk_buff *skb);
87static void ip6_link_failure(struct sk_buff *skb);
88static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
89
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -080090#ifdef CONFIG_IPV6_ROUTE_INFO
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -080091static struct rt6_info *rt6_add_route_info(struct net *net,
92 struct in6_addr *prefix, int prefixlen,
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -080093 struct in6_addr *gwaddr, int ifindex,
94 unsigned pref);
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -080095static struct rt6_info *rt6_get_route_info(struct net *net,
96 struct in6_addr *prefix, int prefixlen,
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -080097 struct in6_addr *gwaddr, int ifindex);
98#endif
99
Daniel Lezcano9a7ec3a2008-03-04 13:48:53 -0800100static struct dst_ops ip6_dst_ops_template = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 .family = AF_INET6,
Harvey Harrison09640e62009-02-01 00:45:17 -0800102 .protocol = cpu_to_be16(ETH_P_IPV6),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 .gc = ip6_dst_gc,
104 .gc_thresh = 1024,
105 .check = ip6_dst_check,
106 .destroy = ip6_dst_destroy,
107 .ifdown = ip6_dst_ifdown,
108 .negative_advice = ip6_negative_advice,
109 .link_failure = ip6_link_failure,
110 .update_pmtu = ip6_rt_update_pmtu,
Herbert Xu1ac06e02008-05-20 14:32:14 -0700111 .local_out = __ip6_local_out,
Eric Dumazete2422972008-01-30 20:07:45 -0800112 .entries = ATOMIC_INIT(0),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113};
114
David S. Miller14e50e52007-05-24 18:17:54 -0700115static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
116{
117}
118
119static struct dst_ops ip6_dst_blackhole_ops = {
120 .family = AF_INET6,
Harvey Harrison09640e62009-02-01 00:45:17 -0800121 .protocol = cpu_to_be16(ETH_P_IPV6),
David S. Miller14e50e52007-05-24 18:17:54 -0700122 .destroy = ip6_dst_destroy,
123 .check = ip6_dst_check,
124 .update_pmtu = ip6_rt_blackhole_update_pmtu,
Eric Dumazete2422972008-01-30 20:07:45 -0800125 .entries = ATOMIC_INIT(0),
David S. Miller14e50e52007-05-24 18:17:54 -0700126};
127
Daniel Lezcanobdb32892008-03-04 13:48:10 -0800128static struct rt6_info ip6_null_entry_template = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 .u = {
130 .dst = {
131 .__refcnt = ATOMIC_INIT(1),
132 .__use = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 .obsolete = -1,
134 .error = -ENETUNREACH,
135 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
136 .input = ip6_pkt_discard,
137 .output = ip6_pkt_discard_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 }
139 },
140 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
Jean-Mickael Guerin4f724272009-05-20 17:38:59 -0700141 .rt6i_protocol = RTPROT_KERNEL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 .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
Adrian Bunk280a34c2008-04-21 02:29:32 -0700151static struct rt6_info ip6_prohibit_entry_template = {
Thomas Graf101367c2006-08-04 03:39:02 -0700152 .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 }
162 },
163 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
Jean-Mickael Guerin4f724272009-05-20 17:38:59 -0700164 .rt6i_protocol = RTPROT_KERNEL,
Thomas Graf101367c2006-08-04 03:39:02 -0700165 .rt6i_metric = ~(u32) 0,
166 .rt6i_ref = ATOMIC_INIT(1),
167};
168
Daniel Lezcanobdb32892008-03-04 13:48:10 -0800169static struct rt6_info ip6_blk_hole_entry_template = {
Thomas Graf101367c2006-08-04 03:39:02 -0700170 .u = {
171 .dst = {
172 .__refcnt = ATOMIC_INIT(1),
173 .__use = 1,
Thomas Graf101367c2006-08-04 03:39:02 -0700174 .obsolete = -1,
175 .error = -EINVAL,
176 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
Herbert Xu352e5122007-11-13 21:34:06 -0800177 .input = dst_discard,
178 .output = dst_discard,
Thomas Graf101367c2006-08-04 03:39:02 -0700179 }
180 },
181 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
Jean-Mickael Guerin4f724272009-05-20 17:38:59 -0700182 .rt6i_protocol = RTPROT_KERNEL,
Thomas Graf101367c2006-08-04 03:39:02 -0700183 .rt6i_metric = ~(u32) 0,
184 .rt6i_ref = ATOMIC_INIT(1),
185};
186
187#endif
188
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189/* allocate dst with ip6_dst_ops */
Benjamin Theryf2fc6a52008-03-04 13:49:23 -0800190static inline struct rt6_info *ip6_dst_alloc(struct dst_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191{
Benjamin Theryf2fc6a52008-03-04 13:49:23 -0800192 return (struct rt6_info *)dst_alloc(ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193}
194
195static void ip6_dst_destroy(struct dst_entry *dst)
196{
197 struct rt6_info *rt = (struct rt6_info *)dst;
198 struct inet6_dev *idev = rt->rt6i_idev;
199
200 if (idev != NULL) {
201 rt->rt6i_idev = NULL;
202 in6_dev_put(idev);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900203 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204}
205
206static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
207 int how)
208{
209 struct rt6_info *rt = (struct rt6_info *)dst;
210 struct inet6_dev *idev = rt->rt6i_idev;
Denis V. Lunev5a3e55d2007-12-07 00:38:10 -0800211 struct net_device *loopback_dev =
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900212 dev_net(dev)->loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Denis V. Lunev5a3e55d2007-12-07 00:38:10 -0800214 if (dev != loopback_dev && idev != NULL && idev->dev == dev) {
215 struct inet6_dev *loopback_idev =
216 in6_dev_get(loopback_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 if (loopback_idev != NULL) {
218 rt->rt6i_idev = loopback_idev;
219 in6_dev_put(idev);
220 }
221 }
222}
223
224static __inline__ int rt6_check_expired(const struct rt6_info *rt)
225{
226 return (rt->rt6i_flags & RTF_EXPIRES &&
227 time_after(jiffies, rt->rt6i_expires));
228}
229
Thomas Grafc71099a2006-08-04 23:20:06 -0700230static inline int rt6_need_strict(struct in6_addr *daddr)
231{
232 return (ipv6_addr_type(daddr) &
YOSHIFUJI Hideaki5ce83af2008-06-25 16:58:17 +0900233 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK));
Thomas Grafc71099a2006-08-04 23:20:06 -0700234}
235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236/*
Thomas Grafc71099a2006-08-04 23:20:06 -0700237 * Route lookup. Any table->tb6_lock is implied.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 */
239
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800240static inline struct rt6_info *rt6_device_match(struct net *net,
241 struct rt6_info *rt,
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900242 struct in6_addr *saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 int oif,
YOSHIFUJI Hideakid4208952008-06-27 20:14:54 -0700244 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245{
246 struct rt6_info *local = NULL;
247 struct rt6_info *sprt;
248
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900249 if (!oif && ipv6_addr_any(saddr))
250 goto out;
251
252 for (sprt = rt; sprt; sprt = sprt->u.dst.rt6_next) {
253 struct net_device *dev = sprt->rt6i_dev;
254
255 if (oif) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 if (dev->ifindex == oif)
257 return sprt;
258 if (dev->flags & IFF_LOOPBACK) {
259 if (sprt->rt6i_idev == NULL ||
260 sprt->rt6i_idev->dev->ifindex != oif) {
YOSHIFUJI Hideakid4208952008-06-27 20:14:54 -0700261 if (flags & RT6_LOOKUP_F_IFACE && oif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 continue;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900263 if (local && (!oif ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 local->rt6i_idev->dev->ifindex == oif))
265 continue;
266 }
267 local = sprt;
268 }
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900269 } else {
270 if (ipv6_chk_addr(net, saddr, dev,
271 flags & RT6_LOOKUP_F_IFACE))
272 return sprt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 }
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900274 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900276 if (oif) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 if (local)
278 return local;
279
YOSHIFUJI Hideakid4208952008-06-27 20:14:54 -0700280 if (flags & RT6_LOOKUP_F_IFACE)
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800281 return net->ipv6.ip6_null_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 }
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900283out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 return rt;
285}
286
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800287#ifdef CONFIG_IPV6_ROUTER_PREF
288static void rt6_probe(struct rt6_info *rt)
289{
290 struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
291 /*
292 * Okay, this does not seem to be appropriate
293 * for now, however, we need to check if it
294 * is really so; aka Router Reachability Probing.
295 *
296 * Router Reachability Probe MUST be rate-limited
297 * to no more than one per minute.
298 */
299 if (!neigh || (neigh->nud_state & NUD_VALID))
300 return;
301 read_lock_bh(&neigh->lock);
302 if (!(neigh->nud_state & NUD_VALID) &&
YOSHIFUJI Hideaki52e16352006-03-20 17:05:47 -0800303 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800304 struct in6_addr mcaddr;
305 struct in6_addr *target;
306
307 neigh->updated = jiffies;
308 read_unlock_bh(&neigh->lock);
309
310 target = (struct in6_addr *)&neigh->primary_key;
311 addrconf_addr_solict_mult(target, &mcaddr);
312 ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
313 } else
314 read_unlock_bh(&neigh->lock);
315}
316#else
317static inline void rt6_probe(struct rt6_info *rt)
318{
319 return;
320}
321#endif
322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323/*
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800324 * Default Router Selection (RFC 2461 6.3.6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 */
Dave Jonesb6f99a22007-03-22 12:27:49 -0700326static inline int rt6_check_dev(struct rt6_info *rt, int oif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327{
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800328 struct net_device *dev = rt->rt6i_dev;
David S. Miller161980f2007-04-06 11:42:27 -0700329 if (!oif || dev->ifindex == oif)
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800330 return 2;
David S. Miller161980f2007-04-06 11:42:27 -0700331 if ((dev->flags & IFF_LOOPBACK) &&
332 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
333 return 1;
334 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335}
336
Dave Jonesb6f99a22007-03-22 12:27:49 -0700337static inline int rt6_check_neigh(struct rt6_info *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338{
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800339 struct neighbour *neigh = rt->rt6i_nexthop;
YOSHIFUJI Hideaki398bcbe2008-01-19 00:35:16 -0800340 int m;
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700341 if (rt->rt6i_flags & RTF_NONEXTHOP ||
342 !(rt->rt6i_flags & RTF_GATEWAY))
343 m = 1;
344 else if (neigh) {
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800345 read_lock_bh(&neigh->lock);
346 if (neigh->nud_state & NUD_VALID)
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700347 m = 2;
YOSHIFUJI Hideaki398bcbe2008-01-19 00:35:16 -0800348#ifdef CONFIG_IPV6_ROUTER_PREF
349 else if (neigh->nud_state & NUD_FAILED)
350 m = 0;
351#endif
352 else
YOSHIFUJI Hideakiea73ee22006-11-06 09:45:44 -0800353 m = 1;
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800354 read_unlock_bh(&neigh->lock);
YOSHIFUJI Hideaki398bcbe2008-01-19 00:35:16 -0800355 } else
356 m = 0;
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800357 return m;
358}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800360static int rt6_score_route(struct rt6_info *rt, int oif,
361 int strict)
362{
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700363 int m, n;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900364
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700365 m = rt6_check_dev(rt, oif);
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700366 if (!m && (strict & RT6_LOOKUP_F_IFACE))
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800367 return -1;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -0800368#ifdef CONFIG_IPV6_ROUTER_PREF
369 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
370#endif
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700371 n = rt6_check_neigh(rt);
YOSHIFUJI Hideaki557e92e2006-11-06 09:45:45 -0800372 if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800373 return -1;
374 return m;
375}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
David S. Millerf11e6652007-03-24 20:36:25 -0700377static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
378 int *mpri, struct rt6_info *match)
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800379{
David S. Millerf11e6652007-03-24 20:36:25 -0700380 int m;
381
382 if (rt6_check_expired(rt))
383 goto out;
384
385 m = rt6_score_route(rt, oif, strict);
386 if (m < 0)
387 goto out;
388
389 if (m > *mpri) {
390 if (strict & RT6_LOOKUP_F_REACHABLE)
391 rt6_probe(match);
392 *mpri = m;
393 match = rt;
394 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
395 rt6_probe(rt);
396 }
397
398out:
399 return match;
400}
401
402static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
403 struct rt6_info *rr_head,
404 u32 metric, int oif, int strict)
405{
406 struct rt6_info *rt, *match;
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800407 int mpri = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
David S. Millerf11e6652007-03-24 20:36:25 -0700409 match = NULL;
410 for (rt = rr_head; rt && rt->rt6i_metric == metric;
411 rt = rt->u.dst.rt6_next)
412 match = find_match(rt, oif, strict, &mpri, match);
413 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
414 rt = rt->u.dst.rt6_next)
415 match = find_match(rt, oif, strict, &mpri, match);
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800416
David S. Millerf11e6652007-03-24 20:36:25 -0700417 return match;
418}
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800419
David S. Millerf11e6652007-03-24 20:36:25 -0700420static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
421{
422 struct rt6_info *match, *rt0;
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800423 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
David S. Millerf11e6652007-03-24 20:36:25 -0700425 RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800426 __func__, fn->leaf, oif);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
David S. Millerf11e6652007-03-24 20:36:25 -0700428 rt0 = fn->rr_ptr;
429 if (!rt0)
430 fn->rr_ptr = rt0 = fn->leaf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
David S. Millerf11e6652007-03-24 20:36:25 -0700432 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800434 if (!match &&
David S. Millerf11e6652007-03-24 20:36:25 -0700435 (strict & RT6_LOOKUP_F_REACHABLE)) {
436 struct rt6_info *next = rt0->u.dst.rt6_next;
437
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800438 /* no entries matched; do round-robin */
David S. Millerf11e6652007-03-24 20:36:25 -0700439 if (!next || next->rt6i_metric != rt0->rt6i_metric)
440 next = fn->leaf;
441
442 if (next != rt0)
443 fn->rr_ptr = next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
445
David S. Millerf11e6652007-03-24 20:36:25 -0700446 RT6_TRACE("%s() => %p\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800447 __func__, match);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900449 net = dev_net(rt0->rt6i_dev);
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800450 return (match ? match : net->ipv6.ip6_null_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451}
452
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800453#ifdef CONFIG_IPV6_ROUTE_INFO
454int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
455 struct in6_addr *gwaddr)
456{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900457 struct net *net = dev_net(dev);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800458 struct route_info *rinfo = (struct route_info *) opt;
459 struct in6_addr prefix_buf, *prefix;
460 unsigned int pref;
YOSHIFUJI Hideaki4bed72e2008-05-27 17:37:49 +0900461 unsigned long lifetime;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800462 struct rt6_info *rt;
463
464 if (len < sizeof(struct route_info)) {
465 return -EINVAL;
466 }
467
468 /* Sanity check for prefix_len and length */
469 if (rinfo->length > 3) {
470 return -EINVAL;
471 } else if (rinfo->prefix_len > 128) {
472 return -EINVAL;
473 } else if (rinfo->prefix_len > 64) {
474 if (rinfo->length < 2) {
475 return -EINVAL;
476 }
477 } else if (rinfo->prefix_len > 0) {
478 if (rinfo->length < 1) {
479 return -EINVAL;
480 }
481 }
482
483 pref = rinfo->route_pref;
484 if (pref == ICMPV6_ROUTER_PREF_INVALID)
Jens Rosenboom3933fc92009-09-10 06:25:11 +0000485 return -EINVAL;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800486
YOSHIFUJI Hideaki4bed72e2008-05-27 17:37:49 +0900487 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800488
489 if (rinfo->length == 3)
490 prefix = (struct in6_addr *)rinfo->prefix;
491 else {
492 /* this function is safe */
493 ipv6_addr_prefix(&prefix_buf,
494 (struct in6_addr *)rinfo->prefix,
495 rinfo->prefix_len);
496 prefix = &prefix_buf;
497 }
498
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -0800499 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len, gwaddr,
500 dev->ifindex);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800501
502 if (rt && !lifetime) {
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700503 ip6_del_rt(rt);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800504 rt = NULL;
505 }
506
507 if (!rt && lifetime)
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -0800508 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800509 pref);
510 else if (rt)
511 rt->rt6i_flags = RTF_ROUTEINFO |
512 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
513
514 if (rt) {
YOSHIFUJI Hideaki4bed72e2008-05-27 17:37:49 +0900515 if (!addrconf_finite_timeout(lifetime)) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800516 rt->rt6i_flags &= ~RTF_EXPIRES;
517 } else {
518 rt->rt6i_expires = jiffies + HZ * lifetime;
519 rt->rt6i_flags |= RTF_EXPIRES;
520 }
521 dst_release(&rt->u.dst);
522 }
523 return 0;
524}
525#endif
526
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800527#define BACKTRACK(__net, saddr) \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700528do { \
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800529 if (rt == __net->ipv6.ip6_null_entry) { \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700530 struct fib6_node *pn; \
Ville Nuorvalae0eda7b2006-10-16 22:11:11 -0700531 while (1) { \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700532 if (fn->fn_flags & RTN_TL_ROOT) \
533 goto out; \
534 pn = fn->parent; \
535 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
Kim Nordlund8bce65b2006-12-13 16:38:29 -0800536 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700537 else \
538 fn = pn; \
539 if (fn->fn_flags & RTN_RTINFO) \
540 goto restart; \
Thomas Grafc71099a2006-08-04 23:20:06 -0700541 } \
Thomas Grafc71099a2006-08-04 23:20:06 -0700542 } \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700543} while(0)
Thomas Grafc71099a2006-08-04 23:20:06 -0700544
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800545static struct rt6_info *ip6_pol_route_lookup(struct net *net,
546 struct fib6_table *table,
Thomas Grafc71099a2006-08-04 23:20:06 -0700547 struct flowi *fl, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548{
549 struct fib6_node *fn;
550 struct rt6_info *rt;
551
Thomas Grafc71099a2006-08-04 23:20:06 -0700552 read_lock_bh(&table->tb6_lock);
553 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
554restart:
555 rt = fn->leaf;
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900556 rt = rt6_device_match(net, rt, &fl->fl6_src, fl->oif, flags);
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800557 BACKTRACK(net, &fl->fl6_src);
Thomas Grafc71099a2006-08-04 23:20:06 -0700558out:
Pavel Emelyanov03f49f32007-11-10 21:28:34 -0800559 dst_use(&rt->u.dst, jiffies);
Thomas Grafc71099a2006-08-04 23:20:06 -0700560 read_unlock_bh(&table->tb6_lock);
Thomas Grafc71099a2006-08-04 23:20:06 -0700561 return rt;
562
563}
564
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900565struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
566 const struct in6_addr *saddr, int oif, int strict)
Thomas Grafc71099a2006-08-04 23:20:06 -0700567{
568 struct flowi fl = {
569 .oif = oif,
570 .nl_u = {
571 .ip6_u = {
572 .daddr = *daddr,
Thomas Grafc71099a2006-08-04 23:20:06 -0700573 },
574 },
575 };
576 struct dst_entry *dst;
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700577 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
Thomas Grafc71099a2006-08-04 23:20:06 -0700578
Thomas Grafadaa70b2006-10-13 15:01:03 -0700579 if (saddr) {
580 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
581 flags |= RT6_LOOKUP_F_HAS_SADDR;
582 }
583
Daniel Lezcano606a2b42008-03-04 13:45:59 -0800584 dst = fib6_rule_lookup(net, &fl, flags, ip6_pol_route_lookup);
Thomas Grafc71099a2006-08-04 23:20:06 -0700585 if (dst->error == 0)
586 return (struct rt6_info *) dst;
587
588 dst_release(dst);
589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 return NULL;
591}
592
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900593EXPORT_SYMBOL(rt6_lookup);
594
Thomas Grafc71099a2006-08-04 23:20:06 -0700595/* ip6_ins_rt is called with FREE table->tb6_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 It takes new route entry, the addition fails by any reason the
597 route is freed. In any case, if caller does not hold it, it may
598 be destroyed.
599 */
600
Thomas Graf86872cb2006-08-22 00:01:08 -0700601static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
603 int err;
Thomas Grafc71099a2006-08-04 23:20:06 -0700604 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
Thomas Grafc71099a2006-08-04 23:20:06 -0700606 table = rt->rt6i_table;
607 write_lock_bh(&table->tb6_lock);
Thomas Graf86872cb2006-08-22 00:01:08 -0700608 err = fib6_add(&table->tb6_root, rt, info);
Thomas Grafc71099a2006-08-04 23:20:06 -0700609 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
611 return err;
612}
613
Thomas Graf40e22e82006-08-22 00:00:45 -0700614int ip6_ins_rt(struct rt6_info *rt)
615{
Denis V. Lunev4d1169c2008-01-10 03:26:13 -0800616 struct nl_info info = {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900617 .nl_net = dev_net(rt->rt6i_dev),
Denis V. Lunev4d1169c2008-01-10 03:26:13 -0800618 };
Denis V. Lunev528c4ce2007-12-13 09:45:12 -0800619 return __ip6_ins_rt(rt, &info);
Thomas Graf40e22e82006-08-22 00:00:45 -0700620}
621
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800622static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
623 struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 struct rt6_info *rt;
626
627 /*
628 * Clone the route.
629 */
630
631 rt = ip6_rt_copy(ort);
632
633 if (rt) {
David S. Miller14deae42009-01-04 16:04:39 -0800634 struct neighbour *neigh;
635 int attempts = !in_softirq();
636
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900637 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
638 if (rt->rt6i_dst.plen != 128 &&
639 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
640 rt->rt6i_flags |= RTF_ANYCAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900642 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900644 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 rt->rt6i_dst.plen = 128;
646 rt->rt6i_flags |= RTF_CACHE;
647 rt->u.dst.flags |= DST_HOST;
648
649#ifdef CONFIG_IPV6_SUBTREES
650 if (rt->rt6i_src.plen && saddr) {
651 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
652 rt->rt6i_src.plen = 128;
653 }
654#endif
655
David S. Miller14deae42009-01-04 16:04:39 -0800656 retry:
657 neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
658 if (IS_ERR(neigh)) {
659 struct net *net = dev_net(rt->rt6i_dev);
660 int saved_rt_min_interval =
661 net->ipv6.sysctl.ip6_rt_gc_min_interval;
662 int saved_rt_elasticity =
663 net->ipv6.sysctl.ip6_rt_gc_elasticity;
664
665 if (attempts-- > 0) {
666 net->ipv6.sysctl.ip6_rt_gc_elasticity = 1;
667 net->ipv6.sysctl.ip6_rt_gc_min_interval = 0;
668
Alexey Dobriyan86393e52009-08-29 01:34:49 +0000669 ip6_dst_gc(&net->ipv6.ip6_dst_ops);
David S. Miller14deae42009-01-04 16:04:39 -0800670
671 net->ipv6.sysctl.ip6_rt_gc_elasticity =
672 saved_rt_elasticity;
673 net->ipv6.sysctl.ip6_rt_gc_min_interval =
674 saved_rt_min_interval;
675 goto retry;
676 }
677
678 if (net_ratelimit())
679 printk(KERN_WARNING
680 "Neighbour table overflow.\n");
681 dst_free(&rt->u.dst);
682 return NULL;
683 }
684 rt->rt6i_nexthop = neigh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800686 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800688 return rt;
689}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800691static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
692{
693 struct rt6_info *rt = ip6_rt_copy(ort);
694 if (rt) {
695 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
696 rt->rt6i_dst.plen = 128;
697 rt->rt6i_flags |= RTF_CACHE;
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800698 rt->u.dst.flags |= DST_HOST;
699 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
700 }
701 return rt;
702}
703
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800704static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
705 struct flowi *fl, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706{
707 struct fib6_node *fn;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800708 struct rt6_info *rt, *nrt;
Thomas Grafc71099a2006-08-04 23:20:06 -0700709 int strict = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 int attempts = 3;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800711 int err;
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700712 int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700714 strict |= flags & RT6_LOOKUP_F_IFACE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
716relookup:
Thomas Grafc71099a2006-08-04 23:20:06 -0700717 read_lock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800719restart_2:
Thomas Grafc71099a2006-08-04 23:20:06 -0700720 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
722restart:
Pavel Emelyanov4acad722007-10-15 13:02:51 -0700723 rt = rt6_select(fn, oif, strict | reachable);
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800724
725 BACKTRACK(net, &fl->fl6_src);
726 if (rt == net->ipv6.ip6_null_entry ||
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800727 rt->rt6i_flags & RTF_CACHE)
YOSHIFUJI Hideaki1ddef0442006-03-20 17:01:24 -0800728 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
YOSHIFUJI Hideakifb9de912006-03-20 16:59:08 -0800730 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700731 read_unlock_bh(&table->tb6_lock);
YOSHIFUJI Hideakifb9de912006-03-20 16:59:08 -0800732
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800733 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
YOSHIFUJI Hideakie40cf352006-03-20 16:59:27 -0800734 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800735 else {
736#if CLONE_OFFLINK_ROUTE
737 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
738#else
739 goto out2;
740#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 }
YOSHIFUJI Hideakie40cf352006-03-20 16:59:27 -0800742
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800743 dst_release(&rt->u.dst);
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800744 rt = nrt ? : net->ipv6.ip6_null_entry;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800745
746 dst_hold(&rt->u.dst);
747 if (nrt) {
Thomas Graf40e22e82006-08-22 00:00:45 -0700748 err = ip6_ins_rt(nrt);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800749 if (!err)
750 goto out2;
751 }
752
753 if (--attempts <= 0)
754 goto out2;
755
756 /*
Thomas Grafc71099a2006-08-04 23:20:06 -0700757 * Race condition! In the gap, when table->tb6_lock was
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800758 * released someone could insert this route. Relookup.
759 */
760 dst_release(&rt->u.dst);
761 goto relookup;
762
763out:
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800764 if (reachable) {
765 reachable = 0;
766 goto restart_2;
767 }
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800768 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700769 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770out2:
771 rt->u.dst.lastuse = jiffies;
772 rt->u.dst.__use++;
Thomas Grafc71099a2006-08-04 23:20:06 -0700773
774 return rt;
775}
776
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800777static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
Pavel Emelyanov4acad722007-10-15 13:02:51 -0700778 struct flowi *fl, int flags)
779{
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800780 return ip6_pol_route(net, table, fl->iif, fl, flags);
Pavel Emelyanov4acad722007-10-15 13:02:51 -0700781}
782
Thomas Grafc71099a2006-08-04 23:20:06 -0700783void ip6_route_input(struct sk_buff *skb)
784{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700785 struct ipv6hdr *iph = ipv6_hdr(skb);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900786 struct net *net = dev_net(skb->dev);
Thomas Grafadaa70b2006-10-13 15:01:03 -0700787 int flags = RT6_LOOKUP_F_HAS_SADDR;
Thomas Grafc71099a2006-08-04 23:20:06 -0700788 struct flowi fl = {
789 .iif = skb->dev->ifindex,
790 .nl_u = {
791 .ip6_u = {
792 .daddr = iph->daddr,
793 .saddr = iph->saddr,
Al Viro90bcaf72006-11-08 00:25:17 -0800794 .flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
Thomas Grafc71099a2006-08-04 23:20:06 -0700795 },
796 },
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900797 .mark = skb->mark,
Thomas Grafc71099a2006-08-04 23:20:06 -0700798 .proto = iph->nexthdr,
799 };
Thomas Grafadaa70b2006-10-13 15:01:03 -0700800
Thomas Goff1d6e55f2009-01-27 22:39:59 -0800801 if (rt6_need_strict(&iph->daddr) && skb->dev->type != ARPHRD_PIMREG)
Thomas Grafadaa70b2006-10-13 15:01:03 -0700802 flags |= RT6_LOOKUP_F_IFACE;
Thomas Grafc71099a2006-08-04 23:20:06 -0700803
Eric Dumazetadf30902009-06-02 05:19:30 +0000804 skb_dst_set(skb, fib6_rule_lookup(net, &fl, flags, ip6_pol_route_input));
Thomas Grafc71099a2006-08-04 23:20:06 -0700805}
806
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800807static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
Thomas Grafc71099a2006-08-04 23:20:06 -0700808 struct flowi *fl, int flags)
809{
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800810 return ip6_pol_route(net, table, fl->oif, fl, flags);
Thomas Grafc71099a2006-08-04 23:20:06 -0700811}
812
Daniel Lezcano4591db42008-03-05 10:48:10 -0800813struct dst_entry * ip6_route_output(struct net *net, struct sock *sk,
814 struct flowi *fl)
Thomas Grafc71099a2006-08-04 23:20:06 -0700815{
816 int flags = 0;
817
Jiri Olsaf4f914b2010-04-20 21:21:26 +0000818 if (fl->oif || rt6_need_strict(&fl->fl6_dst))
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700819 flags |= RT6_LOOKUP_F_IFACE;
Thomas Grafc71099a2006-08-04 23:20:06 -0700820
Thomas Grafadaa70b2006-10-13 15:01:03 -0700821 if (!ipv6_addr_any(&fl->fl6_src))
822 flags |= RT6_LOOKUP_F_HAS_SADDR;
YOSHIFUJI Hideaki / 吉藤英明0c9a2ac2010-03-07 00:14:44 +0000823 else if (sk)
824 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
Thomas Grafadaa70b2006-10-13 15:01:03 -0700825
Daniel Lezcano4591db42008-03-05 10:48:10 -0800826 return fib6_rule_lookup(net, fl, flags, ip6_pol_route_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827}
828
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900829EXPORT_SYMBOL(ip6_route_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
David S. Miller14e50e52007-05-24 18:17:54 -0700831int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl)
832{
833 struct rt6_info *ort = (struct rt6_info *) *dstp;
834 struct rt6_info *rt = (struct rt6_info *)
835 dst_alloc(&ip6_dst_blackhole_ops);
836 struct dst_entry *new = NULL;
837
838 if (rt) {
839 new = &rt->u.dst;
840
841 atomic_set(&new->__refcnt, 1);
842 new->__use = 1;
Herbert Xu352e5122007-11-13 21:34:06 -0800843 new->input = dst_discard;
844 new->output = dst_discard;
David S. Miller14e50e52007-05-24 18:17:54 -0700845
846 memcpy(new->metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
847 new->dev = ort->u.dst.dev;
848 if (new->dev)
849 dev_hold(new->dev);
850 rt->rt6i_idev = ort->rt6i_idev;
851 if (rt->rt6i_idev)
852 in6_dev_hold(rt->rt6i_idev);
853 rt->rt6i_expires = 0;
854
855 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
856 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
857 rt->rt6i_metric = 0;
858
859 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
860#ifdef CONFIG_IPV6_SUBTREES
861 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
862#endif
863
864 dst_free(new);
865 }
866
867 dst_release(*dstp);
868 *dstp = new;
869 return (new ? 0 : -ENOMEM);
870}
871EXPORT_SYMBOL_GPL(ip6_dst_blackhole);
872
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873/*
874 * Destination cache support functions
875 */
876
877static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
878{
879 struct rt6_info *rt;
880
881 rt = (struct rt6_info *) dst;
882
Herbert Xu10414442010-03-18 23:00:22 +0000883 if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 return dst;
885
886 return NULL;
887}
888
889static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
890{
891 struct rt6_info *rt = (struct rt6_info *) dst;
892
893 if (rt) {
YOSHIFUJI Hideaki / 吉藤英明54c1a852010-03-28 07:15:45 +0000894 if (rt->rt6i_flags & RTF_CACHE) {
895 if (rt6_check_expired(rt)) {
896 ip6_del_rt(rt);
897 dst = NULL;
898 }
899 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 dst_release(dst);
YOSHIFUJI Hideaki / 吉藤英明54c1a852010-03-28 07:15:45 +0000901 dst = NULL;
902 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 }
YOSHIFUJI Hideaki / 吉藤英明54c1a852010-03-28 07:15:45 +0000904 return dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905}
906
907static void ip6_link_failure(struct sk_buff *skb)
908{
909 struct rt6_info *rt;
910
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000911 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
Eric Dumazetadf30902009-06-02 05:19:30 +0000913 rt = (struct rt6_info *) skb_dst(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 if (rt) {
915 if (rt->rt6i_flags&RTF_CACHE) {
916 dst_set_expires(&rt->u.dst, 0);
917 rt->rt6i_flags |= RTF_EXPIRES;
918 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
919 rt->rt6i_node->fn_sernum = -1;
920 }
921}
922
923static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
924{
925 struct rt6_info *rt6 = (struct rt6_info*)dst;
926
927 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
928 rt6->rt6i_flags |= RTF_MODIFIED;
929 if (mtu < IPV6_MIN_MTU) {
930 mtu = IPV6_MIN_MTU;
931 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
932 }
933 dst->metrics[RTAX_MTU-1] = mtu;
Tom Tucker8d717402006-07-30 20:43:36 -0700934 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 }
936}
937
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938static int ipv6_get_mtu(struct net_device *dev);
939
Daniel Lezcano55786892008-03-04 13:47:47 -0800940static inline unsigned int ipv6_advmss(struct net *net, unsigned int mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941{
942 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
943
Daniel Lezcano55786892008-03-04 13:47:47 -0800944 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
945 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
947 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900948 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
949 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
950 * IPV6_MAXPLEN is also valid and means: "any MSS,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 * rely only on pmtu discovery"
952 */
953 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
954 mtu = IPV6_MAXPLEN;
955 return mtu;
956}
957
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -0800958static struct dst_entry *icmp6_dst_gc_list;
959static DEFINE_SPINLOCK(icmp6_dst_lock);
Thomas Graf5d0bbee2006-08-04 03:37:36 -0700960
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -0800961struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900963 const struct in6_addr *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964{
965 struct rt6_info *rt;
966 struct inet6_dev *idev = in6_dev_get(dev);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900967 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968
969 if (unlikely(idev == NULL))
970 return NULL;
971
Alexey Dobriyan86393e52009-08-29 01:34:49 +0000972 rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 if (unlikely(rt == NULL)) {
974 in6_dev_put(idev);
975 goto out;
976 }
977
978 dev_hold(dev);
979 if (neigh)
980 neigh_hold(neigh);
David S. Miller14deae42009-01-04 16:04:39 -0800981 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 neigh = ndisc_get_neigh(dev, addr);
David S. Miller14deae42009-01-04 16:04:39 -0800983 if (IS_ERR(neigh))
984 neigh = NULL;
985 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986
987 rt->rt6i_dev = dev;
988 rt->rt6i_idev = idev;
989 rt->rt6i_nexthop = neigh;
990 atomic_set(&rt->u.dst.__refcnt, 1);
991 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
992 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
Daniel Lezcano55786892008-03-04 13:47:47 -0800993 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, dst_mtu(&rt->u.dst));
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -0800994 rt->u.dst.output = ip6_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995
996#if 0 /* there's no chance to use these for ndisc */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900997 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
998 ? DST_HOST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 : 0;
1000 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1001 rt->rt6i_dst.plen = 128;
1002#endif
1003
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001004 spin_lock_bh(&icmp6_dst_lock);
1005 rt->u.dst.next = icmp6_dst_gc_list;
1006 icmp6_dst_gc_list = &rt->u.dst;
1007 spin_unlock_bh(&icmp6_dst_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
Daniel Lezcano55786892008-03-04 13:47:47 -08001009 fib6_force_start_gc(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010
1011out:
YOSHIFUJI Hideaki40aa7b92006-10-19 13:50:09 +09001012 return &rt->u.dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013}
1014
Stephen Hemminger3d0f24a2008-07-22 14:35:50 -07001015int icmp6_dst_gc(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016{
1017 struct dst_entry *dst, *next, **pprev;
Stephen Hemminger3d0f24a2008-07-22 14:35:50 -07001018 int more = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019
1020 next = NULL;
Thomas Graf5d0bbee2006-08-04 03:37:36 -07001021
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001022 spin_lock_bh(&icmp6_dst_lock);
1023 pprev = &icmp6_dst_gc_list;
Thomas Graf5d0bbee2006-08-04 03:37:36 -07001024
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 while ((dst = *pprev) != NULL) {
1026 if (!atomic_read(&dst->__refcnt)) {
1027 *pprev = dst->next;
1028 dst_free(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 } else {
1030 pprev = &dst->next;
Stephen Hemminger3d0f24a2008-07-22 14:35:50 -07001031 ++more;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 }
1033 }
1034
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001035 spin_unlock_bh(&icmp6_dst_lock);
Thomas Graf5d0bbee2006-08-04 03:37:36 -07001036
Stephen Hemminger3d0f24a2008-07-22 14:35:50 -07001037 return more;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038}
1039
David S. Miller1e493d12008-09-10 17:27:15 -07001040static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1041 void *arg)
1042{
1043 struct dst_entry *dst, **pprev;
1044
1045 spin_lock_bh(&icmp6_dst_lock);
1046 pprev = &icmp6_dst_gc_list;
1047 while ((dst = *pprev) != NULL) {
1048 struct rt6_info *rt = (struct rt6_info *) dst;
1049 if (func(rt, arg)) {
1050 *pprev = dst->next;
1051 dst_free(dst);
1052 } else {
1053 pprev = &dst->next;
1054 }
1055 }
1056 spin_unlock_bh(&icmp6_dst_lock);
1057}
1058
Daniel Lezcano569d3642008-01-18 03:56:57 -08001059static int ip6_dst_gc(struct dst_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 unsigned long now = jiffies;
Alexey Dobriyan86393e52009-08-29 01:34:49 +00001062 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
Daniel Lezcano7019b782008-03-04 13:50:14 -08001063 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1064 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1065 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1066 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1067 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068
Daniel Lezcano7019b782008-03-04 13:50:14 -08001069 if (time_after(rt_last_gc + rt_min_interval, now) &&
1070 atomic_read(&ops->entries) <= rt_max_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 goto out;
1072
Benjamin Thery6891a342008-03-04 13:49:47 -08001073 net->ipv6.ip6_rt_gc_expire++;
1074 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net);
1075 net->ipv6.ip6_rt_last_gc = now;
Daniel Lezcano7019b782008-03-04 13:50:14 -08001076 if (atomic_read(&ops->entries) < ops->gc_thresh)
1077 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078out:
Daniel Lezcano7019b782008-03-04 13:50:14 -08001079 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1080 return (atomic_read(&ops->entries) > rt_max_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081}
1082
1083/* Clean host part of a prefix. Not necessary in radix tree,
1084 but results in cleaner routing tables.
1085
1086 Remove it only when all the things will work!
1087 */
1088
1089static int ipv6_get_mtu(struct net_device *dev)
1090{
1091 int mtu = IPV6_MIN_MTU;
1092 struct inet6_dev *idev;
1093
1094 idev = in6_dev_get(dev);
1095 if (idev) {
1096 mtu = idev->cnf.mtu6;
1097 in6_dev_put(idev);
1098 }
1099 return mtu;
1100}
1101
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -04001102int ip6_dst_hoplimit(struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103{
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -04001104 int hoplimit = dst_metric(dst, RTAX_HOPLIMIT);
1105 if (hoplimit < 0) {
1106 struct net_device *dev = dst->dev;
1107 struct inet6_dev *idev = in6_dev_get(dev);
1108 if (idev) {
1109 hoplimit = idev->cnf.hop_limit;
1110 in6_dev_put(idev);
1111 } else
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -07001112 hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 }
1114 return hoplimit;
1115}
1116
1117/*
1118 *
1119 */
1120
Thomas Graf86872cb2006-08-22 00:01:08 -07001121int ip6_route_add(struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122{
1123 int err;
Daniel Lezcano55786892008-03-04 13:47:47 -08001124 struct net *net = cfg->fc_nlinfo.nl_net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 struct rt6_info *rt = NULL;
1126 struct net_device *dev = NULL;
1127 struct inet6_dev *idev = NULL;
Thomas Grafc71099a2006-08-04 23:20:06 -07001128 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 int addr_type;
1130
Thomas Graf86872cb2006-08-22 00:01:08 -07001131 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 return -EINVAL;
1133#ifndef CONFIG_IPV6_SUBTREES
Thomas Graf86872cb2006-08-22 00:01:08 -07001134 if (cfg->fc_src_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 return -EINVAL;
1136#endif
Thomas Graf86872cb2006-08-22 00:01:08 -07001137 if (cfg->fc_ifindex) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 err = -ENODEV;
Daniel Lezcano55786892008-03-04 13:47:47 -08001139 dev = dev_get_by_index(net, cfg->fc_ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 if (!dev)
1141 goto out;
1142 idev = in6_dev_get(dev);
1143 if (!idev)
1144 goto out;
1145 }
1146
Thomas Graf86872cb2006-08-22 00:01:08 -07001147 if (cfg->fc_metric == 0)
1148 cfg->fc_metric = IP6_RT_PRIO_USER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149
Daniel Lezcano55786892008-03-04 13:47:47 -08001150 table = fib6_new_table(net, cfg->fc_table);
Thomas Grafc71099a2006-08-04 23:20:06 -07001151 if (table == NULL) {
1152 err = -ENOBUFS;
1153 goto out;
1154 }
1155
Alexey Dobriyan86393e52009-08-29 01:34:49 +00001156 rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
1158 if (rt == NULL) {
1159 err = -ENOMEM;
1160 goto out;
1161 }
1162
1163 rt->u.dst.obsolete = -1;
YOSHIFUJI Hideaki6f704992008-05-19 16:56:11 -07001164 rt->rt6i_expires = (cfg->fc_flags & RTF_EXPIRES) ?
1165 jiffies + clock_t_to_jiffies(cfg->fc_expires) :
1166 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167
Thomas Graf86872cb2006-08-22 00:01:08 -07001168 if (cfg->fc_protocol == RTPROT_UNSPEC)
1169 cfg->fc_protocol = RTPROT_BOOT;
1170 rt->rt6i_protocol = cfg->fc_protocol;
1171
1172 addr_type = ipv6_addr_type(&cfg->fc_dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
1174 if (addr_type & IPV6_ADDR_MULTICAST)
1175 rt->u.dst.input = ip6_mc_input;
1176 else
1177 rt->u.dst.input = ip6_forward;
1178
1179 rt->u.dst.output = ip6_output;
1180
Thomas Graf86872cb2006-08-22 00:01:08 -07001181 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1182 rt->rt6i_dst.plen = cfg->fc_dst_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 if (rt->rt6i_dst.plen == 128)
1184 rt->u.dst.flags = DST_HOST;
1185
1186#ifdef CONFIG_IPV6_SUBTREES
Thomas Graf86872cb2006-08-22 00:01:08 -07001187 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1188 rt->rt6i_src.plen = cfg->fc_src_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189#endif
1190
Thomas Graf86872cb2006-08-22 00:01:08 -07001191 rt->rt6i_metric = cfg->fc_metric;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
1193 /* We cannot add true routes via loopback here,
1194 they would result in kernel looping; promote them to reject routes
1195 */
Thomas Graf86872cb2006-08-22 00:01:08 -07001196 if ((cfg->fc_flags & RTF_REJECT) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
1198 /* hold loopback dev/idev if we haven't done so. */
Daniel Lezcano55786892008-03-04 13:47:47 -08001199 if (dev != net->loopback_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 if (dev) {
1201 dev_put(dev);
1202 in6_dev_put(idev);
1203 }
Daniel Lezcano55786892008-03-04 13:47:47 -08001204 dev = net->loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 dev_hold(dev);
1206 idev = in6_dev_get(dev);
1207 if (!idev) {
1208 err = -ENODEV;
1209 goto out;
1210 }
1211 }
1212 rt->u.dst.output = ip6_pkt_discard_out;
1213 rt->u.dst.input = ip6_pkt_discard;
1214 rt->u.dst.error = -ENETUNREACH;
1215 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1216 goto install_route;
1217 }
1218
Thomas Graf86872cb2006-08-22 00:01:08 -07001219 if (cfg->fc_flags & RTF_GATEWAY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 struct in6_addr *gw_addr;
1221 int gwa_type;
1222
Thomas Graf86872cb2006-08-22 00:01:08 -07001223 gw_addr = &cfg->fc_gateway;
1224 ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 gwa_type = ipv6_addr_type(gw_addr);
1226
1227 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1228 struct rt6_info *grt;
1229
1230 /* IPv6 strictly inhibits using not link-local
1231 addresses as nexthop address.
1232 Otherwise, router will not able to send redirects.
1233 It is very good, but in some (rare!) circumstances
1234 (SIT, PtP, NBMA NOARP links) it is handy to allow
1235 some exceptions. --ANK
1236 */
1237 err = -EINVAL;
1238 if (!(gwa_type&IPV6_ADDR_UNICAST))
1239 goto out;
1240
Daniel Lezcano55786892008-03-04 13:47:47 -08001241 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242
1243 err = -EHOSTUNREACH;
1244 if (grt == NULL)
1245 goto out;
1246 if (dev) {
1247 if (dev != grt->rt6i_dev) {
1248 dst_release(&grt->u.dst);
1249 goto out;
1250 }
1251 } else {
1252 dev = grt->rt6i_dev;
1253 idev = grt->rt6i_idev;
1254 dev_hold(dev);
1255 in6_dev_hold(grt->rt6i_idev);
1256 }
1257 if (!(grt->rt6i_flags&RTF_GATEWAY))
1258 err = 0;
1259 dst_release(&grt->u.dst);
1260
1261 if (err)
1262 goto out;
1263 }
1264 err = -EINVAL;
1265 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
1266 goto out;
1267 }
1268
1269 err = -ENODEV;
1270 if (dev == NULL)
1271 goto out;
1272
Thomas Graf86872cb2006-08-22 00:01:08 -07001273 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
1275 if (IS_ERR(rt->rt6i_nexthop)) {
1276 err = PTR_ERR(rt->rt6i_nexthop);
1277 rt->rt6i_nexthop = NULL;
1278 goto out;
1279 }
1280 }
1281
Thomas Graf86872cb2006-08-22 00:01:08 -07001282 rt->rt6i_flags = cfg->fc_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
1284install_route:
Thomas Graf86872cb2006-08-22 00:01:08 -07001285 if (cfg->fc_mx) {
1286 struct nlattr *nla;
1287 int remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
Thomas Graf86872cb2006-08-22 00:01:08 -07001289 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
Thomas Graf8f4c1f92007-09-12 14:44:36 +02001290 int type = nla_type(nla);
Thomas Graf86872cb2006-08-22 00:01:08 -07001291
1292 if (type) {
1293 if (type > RTAX_MAX) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 err = -EINVAL;
1295 goto out;
1296 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001297
1298 rt->u.dst.metrics[type - 1] = nla_get_u32(nla);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 }
1301 }
1302
Satoru SATOH5ffc02a2008-05-04 22:14:42 -07001303 if (dst_metric(&rt->u.dst, RTAX_HOPLIMIT) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
Rami Rosen1ca615f2008-08-06 02:34:21 -07001305 if (!dst_mtu(&rt->u.dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
Satoru SATOH5ffc02a2008-05-04 22:14:42 -07001307 if (!dst_metric(&rt->u.dst, RTAX_ADVMSS))
Daniel Lezcano55786892008-03-04 13:47:47 -08001308 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, dst_mtu(&rt->u.dst));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 rt->u.dst.dev = dev;
1310 rt->rt6i_idev = idev;
Thomas Grafc71099a2006-08-04 23:20:06 -07001311 rt->rt6i_table = table;
Daniel Lezcano63152fc2008-03-03 23:31:11 -08001312
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001313 cfg->fc_nlinfo.nl_net = dev_net(dev);
Daniel Lezcano63152fc2008-03-03 23:31:11 -08001314
Thomas Graf86872cb2006-08-22 00:01:08 -07001315 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
1317out:
1318 if (dev)
1319 dev_put(dev);
1320 if (idev)
1321 in6_dev_put(idev);
1322 if (rt)
YOSHIFUJI Hideaki40aa7b92006-10-19 13:50:09 +09001323 dst_free(&rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 return err;
1325}
1326
Thomas Graf86872cb2006-08-22 00:01:08 -07001327static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328{
1329 int err;
Thomas Grafc71099a2006-08-04 23:20:06 -07001330 struct fib6_table *table;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001331 struct net *net = dev_net(rt->rt6i_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
Daniel Lezcano8ed67782008-03-04 13:48:30 -08001333 if (rt == net->ipv6.ip6_null_entry)
Patrick McHardy6c813a72006-08-06 22:22:47 -07001334 return -ENOENT;
1335
Thomas Grafc71099a2006-08-04 23:20:06 -07001336 table = rt->rt6i_table;
1337 write_lock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338
Thomas Graf86872cb2006-08-22 00:01:08 -07001339 err = fib6_del(rt, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 dst_release(&rt->u.dst);
1341
Thomas Grafc71099a2006-08-04 23:20:06 -07001342 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
1344 return err;
1345}
1346
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001347int ip6_del_rt(struct rt6_info *rt)
1348{
Denis V. Lunev4d1169c2008-01-10 03:26:13 -08001349 struct nl_info info = {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001350 .nl_net = dev_net(rt->rt6i_dev),
Denis V. Lunev4d1169c2008-01-10 03:26:13 -08001351 };
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08001352 return __ip6_del_rt(rt, &info);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001353}
1354
Thomas Graf86872cb2006-08-22 00:01:08 -07001355static int ip6_route_del(struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356{
Thomas Grafc71099a2006-08-04 23:20:06 -07001357 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 struct fib6_node *fn;
1359 struct rt6_info *rt;
1360 int err = -ESRCH;
1361
Daniel Lezcano55786892008-03-04 13:47:47 -08001362 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
Thomas Grafc71099a2006-08-04 23:20:06 -07001363 if (table == NULL)
1364 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365
Thomas Grafc71099a2006-08-04 23:20:06 -07001366 read_lock_bh(&table->tb6_lock);
1367
1368 fn = fib6_locate(&table->tb6_root,
Thomas Graf86872cb2006-08-22 00:01:08 -07001369 &cfg->fc_dst, cfg->fc_dst_len,
1370 &cfg->fc_src, cfg->fc_src_len);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001371
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 if (fn) {
Eric Dumazet7cc48262007-02-09 16:22:57 -08001373 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
Thomas Graf86872cb2006-08-22 00:01:08 -07001374 if (cfg->fc_ifindex &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 (rt->rt6i_dev == NULL ||
Thomas Graf86872cb2006-08-22 00:01:08 -07001376 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 continue;
Thomas Graf86872cb2006-08-22 00:01:08 -07001378 if (cfg->fc_flags & RTF_GATEWAY &&
1379 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 continue;
Thomas Graf86872cb2006-08-22 00:01:08 -07001381 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 continue;
1383 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001384 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385
Thomas Graf86872cb2006-08-22 00:01:08 -07001386 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 }
1388 }
Thomas Grafc71099a2006-08-04 23:20:06 -07001389 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390
1391 return err;
1392}
1393
1394/*
1395 * Handle redirects
1396 */
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001397struct ip6rd_flowi {
1398 struct flowi fl;
1399 struct in6_addr gateway;
1400};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401
Daniel Lezcano8ed67782008-03-04 13:48:30 -08001402static struct rt6_info *__ip6_route_redirect(struct net *net,
1403 struct fib6_table *table,
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001404 struct flowi *fl,
1405 int flags)
1406{
1407 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1408 struct rt6_info *rt;
1409 struct fib6_node *fn;
Thomas Grafc71099a2006-08-04 23:20:06 -07001410
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 /*
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001412 * Get the "current" route for this destination and
1413 * check if the redirect has come from approriate router.
1414 *
1415 * RFC 2461 specifies that redirects should only be
1416 * accepted if they come from the nexthop to the target.
1417 * Due to the way the routes are chosen, this notion
1418 * is a bit fuzzy and one might need to check all possible
1419 * routes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421
Thomas Grafc71099a2006-08-04 23:20:06 -07001422 read_lock_bh(&table->tb6_lock);
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001423 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001424restart:
Eric Dumazet7cc48262007-02-09 16:22:57 -08001425 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001426 /*
1427 * Current route is on-link; redirect is always invalid.
1428 *
1429 * Seems, previous statement is not true. It could
1430 * be node, which looks for us as on-link (f.e. proxy ndisc)
1431 * But then router serving it might decide, that we should
1432 * know truth 8)8) --ANK (980726).
1433 */
1434 if (rt6_check_expired(rt))
1435 continue;
1436 if (!(rt->rt6i_flags & RTF_GATEWAY))
1437 continue;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001438 if (fl->oif != rt->rt6i_dev->ifindex)
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001439 continue;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001440 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001441 continue;
1442 break;
1443 }
YOSHIFUJI Hideakie843b9e2006-03-20 17:07:49 -08001444
YOSHIFUJI Hideakicb15d9c2006-08-23 17:23:11 -07001445 if (!rt)
Daniel Lezcano8ed67782008-03-04 13:48:30 -08001446 rt = net->ipv6.ip6_null_entry;
1447 BACKTRACK(net, &fl->fl6_src);
YOSHIFUJI Hideakicb15d9c2006-08-23 17:23:11 -07001448out:
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001449 dst_hold(&rt->u.dst);
1450
1451 read_unlock_bh(&table->tb6_lock);
1452
1453 return rt;
1454};
1455
1456static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1457 struct in6_addr *src,
1458 struct in6_addr *gateway,
1459 struct net_device *dev)
1460{
Thomas Grafadaa70b2006-10-13 15:01:03 -07001461 int flags = RT6_LOOKUP_F_HAS_SADDR;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001462 struct net *net = dev_net(dev);
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001463 struct ip6rd_flowi rdfl = {
1464 .fl = {
1465 .oif = dev->ifindex,
1466 .nl_u = {
1467 .ip6_u = {
1468 .daddr = *dest,
1469 .saddr = *src,
1470 },
1471 },
1472 },
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001473 };
Thomas Grafadaa70b2006-10-13 15:01:03 -07001474
Brian Haley86c36ce2009-10-07 13:58:01 -07001475 ipv6_addr_copy(&rdfl.gateway, gateway);
1476
Thomas Grafadaa70b2006-10-13 15:01:03 -07001477 if (rt6_need_strict(dest))
1478 flags |= RT6_LOOKUP_F_IFACE;
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001479
Daniel Lezcano55786892008-03-04 13:47:47 -08001480 return (struct rt6_info *)fib6_rule_lookup(net, (struct flowi *)&rdfl,
Daniel Lezcano58f09b72008-03-03 23:25:27 -08001481 flags, __ip6_route_redirect);
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001482}
1483
1484void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1485 struct in6_addr *saddr,
1486 struct neighbour *neigh, u8 *lladdr, int on_link)
1487{
1488 struct rt6_info *rt, *nrt = NULL;
1489 struct netevent_redirect netevent;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001490 struct net *net = dev_net(neigh->dev);
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001491
1492 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1493
Daniel Lezcano8ed67782008-03-04 13:48:30 -08001494 if (rt == net->ipv6.ip6_null_entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 if (net_ratelimit())
1496 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1497 "for redirect target\n");
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001498 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 }
1500
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 /*
1502 * We have finally decided to accept it.
1503 */
1504
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001505 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1507 NEIGH_UPDATE_F_OVERRIDE|
1508 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1509 NEIGH_UPDATE_F_ISROUTER))
1510 );
1511
1512 /*
1513 * Redirect received -> path was valid.
1514 * Look, redirects are sent only in response to data packets,
1515 * so that this nexthop apparently is reachable. --ANK
1516 */
1517 dst_confirm(&rt->u.dst);
1518
1519 /* Duplicate redirect: silently ignore. */
1520 if (neigh == rt->u.dst.neighbour)
1521 goto out;
1522
1523 nrt = ip6_rt_copy(rt);
1524 if (nrt == NULL)
1525 goto out;
1526
1527 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1528 if (on_link)
1529 nrt->rt6i_flags &= ~RTF_GATEWAY;
1530
1531 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1532 nrt->rt6i_dst.plen = 128;
1533 nrt->u.dst.flags |= DST_HOST;
1534
1535 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1536 nrt->rt6i_nexthop = neigh_clone(neigh);
1537 /* Reset pmtu, it may be better */
1538 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001539 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dev_net(neigh->dev),
Daniel Lezcano55786892008-03-04 13:47:47 -08001540 dst_mtu(&nrt->u.dst));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541
Thomas Graf40e22e82006-08-22 00:00:45 -07001542 if (ip6_ins_rt(nrt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 goto out;
1544
Tom Tucker8d717402006-07-30 20:43:36 -07001545 netevent.old = &rt->u.dst;
1546 netevent.new = &nrt->u.dst;
1547 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1548
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 if (rt->rt6i_flags&RTF_CACHE) {
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001550 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 return;
1552 }
1553
1554out:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001555 dst_release(&rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 return;
1557}
1558
1559/*
1560 * Handle ICMP "packet too big" messages
1561 * i.e. Path MTU discovery
1562 */
1563
1564void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1565 struct net_device *dev, u32 pmtu)
1566{
1567 struct rt6_info *rt, *nrt;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001568 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 int allfrag = 0;
1570
Daniel Lezcano55786892008-03-04 13:47:47 -08001571 rt = rt6_lookup(net, daddr, saddr, dev->ifindex, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 if (rt == NULL)
1573 return;
1574
1575 if (pmtu >= dst_mtu(&rt->u.dst))
1576 goto out;
1577
1578 if (pmtu < IPV6_MIN_MTU) {
1579 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001580 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 * MTU (1280) and a fragment header should always be included
1582 * after a node receiving Too Big message reporting PMTU is
1583 * less than the IPv6 Minimum Link MTU.
1584 */
1585 pmtu = IPV6_MIN_MTU;
1586 allfrag = 1;
1587 }
1588
1589 /* New mtu received -> path was valid.
1590 They are sent only in response to data packets,
1591 so that this nexthop apparently is reachable. --ANK
1592 */
1593 dst_confirm(&rt->u.dst);
1594
1595 /* Host route. If it is static, it would be better
1596 not to override it, but add new one, so that
1597 when cache entry will expire old pmtu
1598 would return automatically.
1599 */
1600 if (rt->rt6i_flags & RTF_CACHE) {
1601 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1602 if (allfrag)
1603 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
Daniel Lezcano55786892008-03-04 13:47:47 -08001604 dst_set_expires(&rt->u.dst, net->ipv6.sysctl.ip6_rt_mtu_expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1606 goto out;
1607 }
1608
1609 /* Network route.
1610 Two cases are possible:
1611 1. It is connected route. Action: COW
1612 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1613 */
YOSHIFUJI Hideakid5315b52006-03-20 16:58:48 -08001614 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001615 nrt = rt6_alloc_cow(rt, daddr, saddr);
YOSHIFUJI Hideakid5315b52006-03-20 16:58:48 -08001616 else
1617 nrt = rt6_alloc_clone(rt, daddr);
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001618
YOSHIFUJI Hideakid5315b52006-03-20 16:58:48 -08001619 if (nrt) {
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001620 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1621 if (allfrag)
1622 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1623
1624 /* According to RFC 1981, detecting PMTU increase shouldn't be
1625 * happened within 5 mins, the recommended timer is 10 mins.
1626 * Here this route expiration time is set to ip6_rt_mtu_expires
1627 * which is 10 mins. After 10 mins the decreased pmtu is expired
1628 * and detecting PMTU increase will be automatically happened.
1629 */
Daniel Lezcano55786892008-03-04 13:47:47 -08001630 dst_set_expires(&nrt->u.dst, net->ipv6.sysctl.ip6_rt_mtu_expires);
YOSHIFUJI Hideakia1e78362006-03-20 16:56:32 -08001631 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1632
Thomas Graf40e22e82006-08-22 00:00:45 -07001633 ip6_ins_rt(nrt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635out:
1636 dst_release(&rt->u.dst);
1637}
1638
1639/*
1640 * Misc support functions
1641 */
1642
1643static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1644{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001645 struct net *net = dev_net(ort->rt6i_dev);
Alexey Dobriyan86393e52009-08-29 01:34:49 +00001646 struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
1648 if (rt) {
1649 rt->u.dst.input = ort->u.dst.input;
1650 rt->u.dst.output = ort->u.dst.output;
1651
1652 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
Ville Nuorvala22e1e4d2006-10-16 22:14:26 -07001653 rt->u.dst.error = ort->u.dst.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 rt->u.dst.dev = ort->u.dst.dev;
1655 if (rt->u.dst.dev)
1656 dev_hold(rt->u.dst.dev);
1657 rt->rt6i_idev = ort->rt6i_idev;
1658 if (rt->rt6i_idev)
1659 in6_dev_hold(rt->rt6i_idev);
1660 rt->u.dst.lastuse = jiffies;
1661 rt->rt6i_expires = 0;
1662
1663 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1664 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1665 rt->rt6i_metric = 0;
1666
1667 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1668#ifdef CONFIG_IPV6_SUBTREES
1669 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1670#endif
Thomas Grafc71099a2006-08-04 23:20:06 -07001671 rt->rt6i_table = ort->rt6i_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 }
1673 return rt;
1674}
1675
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001676#ifdef CONFIG_IPV6_ROUTE_INFO
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08001677static struct rt6_info *rt6_get_route_info(struct net *net,
1678 struct in6_addr *prefix, int prefixlen,
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001679 struct in6_addr *gwaddr, int ifindex)
1680{
1681 struct fib6_node *fn;
1682 struct rt6_info *rt = NULL;
Thomas Grafc71099a2006-08-04 23:20:06 -07001683 struct fib6_table *table;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001684
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08001685 table = fib6_get_table(net, RT6_TABLE_INFO);
Thomas Grafc71099a2006-08-04 23:20:06 -07001686 if (table == NULL)
1687 return NULL;
1688
1689 write_lock_bh(&table->tb6_lock);
1690 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001691 if (!fn)
1692 goto out;
1693
Eric Dumazet7cc48262007-02-09 16:22:57 -08001694 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001695 if (rt->rt6i_dev->ifindex != ifindex)
1696 continue;
1697 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1698 continue;
1699 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1700 continue;
1701 dst_hold(&rt->u.dst);
1702 break;
1703 }
1704out:
Thomas Grafc71099a2006-08-04 23:20:06 -07001705 write_unlock_bh(&table->tb6_lock);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001706 return rt;
1707}
1708
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08001709static struct rt6_info *rt6_add_route_info(struct net *net,
1710 struct in6_addr *prefix, int prefixlen,
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001711 struct in6_addr *gwaddr, int ifindex,
1712 unsigned pref)
1713{
Thomas Graf86872cb2006-08-22 00:01:08 -07001714 struct fib6_config cfg = {
1715 .fc_table = RT6_TABLE_INFO,
Rami Rosen238fc7e2008-02-09 23:43:11 -08001716 .fc_metric = IP6_RT_PRIO_USER,
Thomas Graf86872cb2006-08-22 00:01:08 -07001717 .fc_ifindex = ifindex,
1718 .fc_dst_len = prefixlen,
1719 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1720 RTF_UP | RTF_PREF(pref),
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08001721 .fc_nlinfo.pid = 0,
1722 .fc_nlinfo.nlh = NULL,
1723 .fc_nlinfo.nl_net = net,
Thomas Graf86872cb2006-08-22 00:01:08 -07001724 };
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001725
Thomas Graf86872cb2006-08-22 00:01:08 -07001726 ipv6_addr_copy(&cfg.fc_dst, prefix);
1727 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1728
YOSHIFUJI Hideakie317da92006-03-20 17:06:42 -08001729 /* We should treat it as a default route if prefix length is 0. */
1730 if (!prefixlen)
Thomas Graf86872cb2006-08-22 00:01:08 -07001731 cfg.fc_flags |= RTF_DEFAULT;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001732
Thomas Graf86872cb2006-08-22 00:01:08 -07001733 ip6_route_add(&cfg);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001734
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08001735 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001736}
1737#endif
1738
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001740{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 struct rt6_info *rt;
Thomas Grafc71099a2006-08-04 23:20:06 -07001742 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001744 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
Thomas Grafc71099a2006-08-04 23:20:06 -07001745 if (table == NULL)
1746 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747
Thomas Grafc71099a2006-08-04 23:20:06 -07001748 write_lock_bh(&table->tb6_lock);
Eric Dumazet7cc48262007-02-09 16:22:57 -08001749 for (rt = table->tb6_root.leaf; rt; rt=rt->u.dst.rt6_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 if (dev == rt->rt6i_dev &&
YOSHIFUJI Hideaki045927f2006-03-20 17:00:48 -08001751 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1753 break;
1754 }
1755 if (rt)
1756 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001757 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 return rt;
1759}
1760
1761struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001762 struct net_device *dev,
1763 unsigned int pref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764{
Thomas Graf86872cb2006-08-22 00:01:08 -07001765 struct fib6_config cfg = {
1766 .fc_table = RT6_TABLE_DFLT,
Rami Rosen238fc7e2008-02-09 23:43:11 -08001767 .fc_metric = IP6_RT_PRIO_USER,
Thomas Graf86872cb2006-08-22 00:01:08 -07001768 .fc_ifindex = dev->ifindex,
1769 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1770 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
Daniel Lezcano55786892008-03-04 13:47:47 -08001771 .fc_nlinfo.pid = 0,
1772 .fc_nlinfo.nlh = NULL,
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001773 .fc_nlinfo.nl_net = dev_net(dev),
Thomas Graf86872cb2006-08-22 00:01:08 -07001774 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775
Thomas Graf86872cb2006-08-22 00:01:08 -07001776 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
Thomas Graf86872cb2006-08-22 00:01:08 -07001778 ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 return rt6_get_dflt_router(gwaddr, dev);
1781}
1782
Daniel Lezcano7b4da532008-03-04 13:47:14 -08001783void rt6_purge_dflt_routers(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784{
1785 struct rt6_info *rt;
Thomas Grafc71099a2006-08-04 23:20:06 -07001786 struct fib6_table *table;
1787
1788 /* NOTE: Keep consistent with rt6_get_dflt_router */
Daniel Lezcano7b4da532008-03-04 13:47:14 -08001789 table = fib6_get_table(net, RT6_TABLE_DFLT);
Thomas Grafc71099a2006-08-04 23:20:06 -07001790 if (table == NULL)
1791 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792
1793restart:
Thomas Grafc71099a2006-08-04 23:20:06 -07001794 read_lock_bh(&table->tb6_lock);
Eric Dumazet7cc48262007-02-09 16:22:57 -08001795 for (rt = table->tb6_root.leaf; rt; rt = rt->u.dst.rt6_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1797 dst_hold(&rt->u.dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001798 read_unlock_bh(&table->tb6_lock);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001799 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 goto restart;
1801 }
1802 }
Thomas Grafc71099a2006-08-04 23:20:06 -07001803 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804}
1805
Daniel Lezcano55786892008-03-04 13:47:47 -08001806static void rtmsg_to_fib6_config(struct net *net,
1807 struct in6_rtmsg *rtmsg,
Thomas Graf86872cb2006-08-22 00:01:08 -07001808 struct fib6_config *cfg)
1809{
1810 memset(cfg, 0, sizeof(*cfg));
1811
1812 cfg->fc_table = RT6_TABLE_MAIN;
1813 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1814 cfg->fc_metric = rtmsg->rtmsg_metric;
1815 cfg->fc_expires = rtmsg->rtmsg_info;
1816 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1817 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1818 cfg->fc_flags = rtmsg->rtmsg_flags;
1819
Daniel Lezcano55786892008-03-04 13:47:47 -08001820 cfg->fc_nlinfo.nl_net = net;
Benjamin Theryf1243c22008-02-26 18:10:03 -08001821
Thomas Graf86872cb2006-08-22 00:01:08 -07001822 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1823 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1824 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1825}
1826
Daniel Lezcano55786892008-03-04 13:47:47 -08001827int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828{
Thomas Graf86872cb2006-08-22 00:01:08 -07001829 struct fib6_config cfg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 struct in6_rtmsg rtmsg;
1831 int err;
1832
1833 switch(cmd) {
1834 case SIOCADDRT: /* Add a route */
1835 case SIOCDELRT: /* Delete a route */
1836 if (!capable(CAP_NET_ADMIN))
1837 return -EPERM;
1838 err = copy_from_user(&rtmsg, arg,
1839 sizeof(struct in6_rtmsg));
1840 if (err)
1841 return -EFAULT;
Thomas Graf86872cb2006-08-22 00:01:08 -07001842
Daniel Lezcano55786892008-03-04 13:47:47 -08001843 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
Thomas Graf86872cb2006-08-22 00:01:08 -07001844
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 rtnl_lock();
1846 switch (cmd) {
1847 case SIOCADDRT:
Thomas Graf86872cb2006-08-22 00:01:08 -07001848 err = ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 break;
1850 case SIOCDELRT:
Thomas Graf86872cb2006-08-22 00:01:08 -07001851 err = ip6_route_del(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 break;
1853 default:
1854 err = -EINVAL;
1855 }
1856 rtnl_unlock();
1857
1858 return err;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001859 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860
1861 return -EINVAL;
1862}
1863
1864/*
1865 * Drop the packet on the floor
1866 */
1867
Brian Haleyd5fdd6b2009-06-23 04:31:07 -07001868static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001870 int type;
Eric Dumazetadf30902009-06-02 05:19:30 +00001871 struct dst_entry *dst = skb_dst(skb);
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001872 switch (ipstats_mib_noroutes) {
1873 case IPSTATS_MIB_INNOROUTES:
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001874 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
Ulrich Weber45bb0062010-02-25 23:28:58 +00001875 if (type == IPV6_ADDR_ANY) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -07001876 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
1877 IPSTATS_MIB_INADDRERRORS);
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001878 break;
1879 }
1880 /* FALLTHROUGH */
1881 case IPSTATS_MIB_OUTNOROUTES:
Denis V. Lunev3bd653c2008-10-08 10:54:51 -07001882 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
1883 ipstats_mib_noroutes);
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001884 break;
1885 }
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +00001886 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 kfree_skb(skb);
1888 return 0;
1889}
1890
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001891static int ip6_pkt_discard(struct sk_buff *skb)
1892{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001893 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001894}
1895
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001896static int ip6_pkt_discard_out(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897{
Eric Dumazetadf30902009-06-02 05:19:30 +00001898 skb->dev = skb_dst(skb)->dev;
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001899 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900}
1901
David S. Miller6723ab52006-10-18 21:20:57 -07001902#ifdef CONFIG_IPV6_MULTIPLE_TABLES
1903
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001904static int ip6_pkt_prohibit(struct sk_buff *skb)
1905{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001906 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001907}
1908
1909static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1910{
Eric Dumazetadf30902009-06-02 05:19:30 +00001911 skb->dev = skb_dst(skb)->dev;
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07001912 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07001913}
1914
David S. Miller6723ab52006-10-18 21:20:57 -07001915#endif
1916
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917/*
1918 * Allocate a dst for local (unicast / anycast) address.
1919 */
1920
1921struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1922 const struct in6_addr *addr,
1923 int anycast)
1924{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001925 struct net *net = dev_net(idev->dev);
Alexey Dobriyan86393e52009-08-29 01:34:49 +00001926 struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
David S. Miller14deae42009-01-04 16:04:39 -08001927 struct neighbour *neigh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928
1929 if (rt == NULL)
1930 return ERR_PTR(-ENOMEM);
1931
Daniel Lezcano55786892008-03-04 13:47:47 -08001932 dev_hold(net->loopback_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 in6_dev_hold(idev);
1934
1935 rt->u.dst.flags = DST_HOST;
1936 rt->u.dst.input = ip6_input;
1937 rt->u.dst.output = ip6_output;
Daniel Lezcano55786892008-03-04 13:47:47 -08001938 rt->rt6i_dev = net->loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 rt->rt6i_idev = idev;
1940 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
Daniel Lezcano55786892008-03-04 13:47:47 -08001941 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, dst_mtu(&rt->u.dst));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1943 rt->u.dst.obsolete = -1;
1944
1945 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +09001946 if (anycast)
1947 rt->rt6i_flags |= RTF_ANYCAST;
1948 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 rt->rt6i_flags |= RTF_LOCAL;
David S. Miller14deae42009-01-04 16:04:39 -08001950 neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1951 if (IS_ERR(neigh)) {
YOSHIFUJI Hideaki40aa7b92006-10-19 13:50:09 +09001952 dst_free(&rt->u.dst);
David S. Miller14deae42009-01-04 16:04:39 -08001953
1954 /* We are casting this because that is the return
1955 * value type. But an errno encoded pointer is the
1956 * same regardless of the underlying pointer type,
1957 * and that's what we are returning. So this is OK.
1958 */
1959 return (struct rt6_info *) neigh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 }
David S. Miller14deae42009-01-04 16:04:39 -08001961 rt->rt6i_nexthop = neigh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962
1963 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1964 rt->rt6i_dst.plen = 128;
Daniel Lezcano55786892008-03-04 13:47:47 -08001965 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966
1967 atomic_set(&rt->u.dst.__refcnt, 1);
1968
1969 return rt;
1970}
1971
Daniel Lezcano8ed67782008-03-04 13:48:30 -08001972struct arg_dev_net {
1973 struct net_device *dev;
1974 struct net *net;
1975};
1976
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977static int fib6_ifdown(struct rt6_info *rt, void *arg)
1978{
Daniel Lezcano8ed67782008-03-04 13:48:30 -08001979 struct net_device *dev = ((struct arg_dev_net *)arg)->dev;
1980 struct net *net = ((struct arg_dev_net *)arg)->net;
1981
1982 if (((void *)rt->rt6i_dev == dev || dev == NULL) &&
1983 rt != net->ipv6.ip6_null_entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 RT6_TRACE("deleted by ifdown %p\n", rt);
1985 return -1;
1986 }
1987 return 0;
1988}
1989
Daniel Lezcanof3db4852008-03-03 23:27:06 -08001990void rt6_ifdown(struct net *net, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991{
Daniel Lezcano8ed67782008-03-04 13:48:30 -08001992 struct arg_dev_net adn = {
1993 .dev = dev,
1994 .net = net,
1995 };
1996
1997 fib6_clean_all(net, fib6_ifdown, 0, &adn);
David S. Miller1e493d12008-09-10 17:27:15 -07001998 icmp6_clean_all(fib6_ifdown, &adn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999}
2000
2001struct rt6_mtu_change_arg
2002{
2003 struct net_device *dev;
2004 unsigned mtu;
2005};
2006
2007static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2008{
2009 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2010 struct inet6_dev *idev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002011 struct net *net = dev_net(arg->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012
2013 /* In IPv6 pmtu discovery is not optional,
2014 so that RTAX_MTU lock cannot disable it.
2015 We still use this lock to block changes
2016 caused by addrconf/ndisc.
2017 */
2018
2019 idev = __in6_dev_get(arg->dev);
2020 if (idev == NULL)
2021 return 0;
2022
2023 /* For administrative MTU increase, there is no way to discover
2024 IPv6 PMTU increase, so PMTU increase should be updated here.
2025 Since RFC 1981 doesn't include administrative MTU increase
2026 update PMTU increase is a MUST. (i.e. jumbo frame)
2027 */
2028 /*
2029 If new MTU is less than route PMTU, this new MTU will be the
2030 lowest MTU in the path, update the route PMTU to reflect PMTU
2031 decreases; if new MTU is greater than route PMTU, and the
2032 old MTU is the lowest MTU in the path, update the route PMTU
2033 to reflect the increase. In this case if the other nodes' MTU
2034 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2035 PMTU discouvery.
2036 */
2037 if (rt->rt6i_dev == arg->dev &&
2038 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
Jim Paris23717792008-01-31 16:36:25 -08002039 (dst_mtu(&rt->u.dst) >= arg->mtu ||
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002040 (dst_mtu(&rt->u.dst) < arg->mtu &&
Simon Arlott566cfd82007-07-26 00:09:55 -07002041 dst_mtu(&rt->u.dst) == idev->cnf.mtu6))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
Daniel Lezcano55786892008-03-04 13:47:47 -08002043 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, arg->mtu);
Simon Arlott566cfd82007-07-26 00:09:55 -07002044 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 return 0;
2046}
2047
2048void rt6_mtu_change(struct net_device *dev, unsigned mtu)
2049{
Thomas Grafc71099a2006-08-04 23:20:06 -07002050 struct rt6_mtu_change_arg arg = {
2051 .dev = dev,
2052 .mtu = mtu,
2053 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002055 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056}
2057
Patrick McHardyef7c79e2007-06-05 12:38:30 -07002058static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
Thomas Graf5176f912006-08-26 20:13:18 -07002059 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
Thomas Graf86872cb2006-08-22 00:01:08 -07002060 [RTA_OIF] = { .type = NLA_U32 },
Thomas Grafab364a62006-08-22 00:01:47 -07002061 [RTA_IIF] = { .type = NLA_U32 },
Thomas Graf86872cb2006-08-22 00:01:08 -07002062 [RTA_PRIORITY] = { .type = NLA_U32 },
2063 [RTA_METRICS] = { .type = NLA_NESTED },
2064};
2065
2066static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2067 struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068{
Thomas Graf86872cb2006-08-22 00:01:08 -07002069 struct rtmsg *rtm;
2070 struct nlattr *tb[RTA_MAX+1];
2071 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072
Thomas Graf86872cb2006-08-22 00:01:08 -07002073 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2074 if (err < 0)
2075 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076
Thomas Graf86872cb2006-08-22 00:01:08 -07002077 err = -EINVAL;
2078 rtm = nlmsg_data(nlh);
2079 memset(cfg, 0, sizeof(*cfg));
2080
2081 cfg->fc_table = rtm->rtm_table;
2082 cfg->fc_dst_len = rtm->rtm_dst_len;
2083 cfg->fc_src_len = rtm->rtm_src_len;
2084 cfg->fc_flags = RTF_UP;
2085 cfg->fc_protocol = rtm->rtm_protocol;
2086
2087 if (rtm->rtm_type == RTN_UNREACHABLE)
2088 cfg->fc_flags |= RTF_REJECT;
2089
2090 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
2091 cfg->fc_nlinfo.nlh = nlh;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002092 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
Thomas Graf86872cb2006-08-22 00:01:08 -07002093
2094 if (tb[RTA_GATEWAY]) {
2095 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2096 cfg->fc_flags |= RTF_GATEWAY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002098
2099 if (tb[RTA_DST]) {
2100 int plen = (rtm->rtm_dst_len + 7) >> 3;
2101
2102 if (nla_len(tb[RTA_DST]) < plen)
2103 goto errout;
2104
2105 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002107
2108 if (tb[RTA_SRC]) {
2109 int plen = (rtm->rtm_src_len + 7) >> 3;
2110
2111 if (nla_len(tb[RTA_SRC]) < plen)
2112 goto errout;
2113
2114 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002116
2117 if (tb[RTA_OIF])
2118 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2119
2120 if (tb[RTA_PRIORITY])
2121 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2122
2123 if (tb[RTA_METRICS]) {
2124 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2125 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002127
2128 if (tb[RTA_TABLE])
2129 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2130
2131 err = 0;
2132errout:
2133 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134}
2135
Thomas Grafc127ea22007-03-22 11:58:32 -07002136static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137{
Thomas Graf86872cb2006-08-22 00:01:08 -07002138 struct fib6_config cfg;
2139 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140
Thomas Graf86872cb2006-08-22 00:01:08 -07002141 err = rtm_to_fib6_config(skb, nlh, &cfg);
2142 if (err < 0)
2143 return err;
2144
2145 return ip6_route_del(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146}
2147
Thomas Grafc127ea22007-03-22 11:58:32 -07002148static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149{
Thomas Graf86872cb2006-08-22 00:01:08 -07002150 struct fib6_config cfg;
2151 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152
Thomas Graf86872cb2006-08-22 00:01:08 -07002153 err = rtm_to_fib6_config(skb, nlh, &cfg);
2154 if (err < 0)
2155 return err;
2156
2157 return ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158}
2159
Thomas Graf339bf982006-11-10 14:10:15 -08002160static inline size_t rt6_nlmsg_size(void)
2161{
2162 return NLMSG_ALIGN(sizeof(struct rtmsg))
2163 + nla_total_size(16) /* RTA_SRC */
2164 + nla_total_size(16) /* RTA_DST */
2165 + nla_total_size(16) /* RTA_GATEWAY */
2166 + nla_total_size(16) /* RTA_PREFSRC */
2167 + nla_total_size(4) /* RTA_TABLE */
2168 + nla_total_size(4) /* RTA_IIF */
2169 + nla_total_size(4) /* RTA_OIF */
2170 + nla_total_size(4) /* RTA_PRIORITY */
Noriaki TAKAMIYA6a2b9ce2007-01-23 22:09:41 -08002171 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
Thomas Graf339bf982006-11-10 14:10:15 -08002172 + nla_total_size(sizeof(struct rta_cacheinfo));
2173}
2174
Brian Haley191cd582008-08-14 15:33:21 -07002175static int rt6_fill_node(struct net *net,
2176 struct sk_buff *skb, struct rt6_info *rt,
Jamal Hadi Salim0d51aa82005-06-21 13:51:04 -07002177 struct in6_addr *dst, struct in6_addr *src,
2178 int iif, int type, u32 pid, u32 seq,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002179 int prefix, int nowait, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180{
2181 struct rtmsg *rtm;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002182 struct nlmsghdr *nlh;
Thomas Grafe3703b32006-11-27 09:27:07 -08002183 long expires;
Patrick McHardy9e762a42006-08-10 23:09:48 -07002184 u32 table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185
2186 if (prefix) { /* user wants prefix routes only */
2187 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2188 /* success since this is not a prefix route */
2189 return 1;
2190 }
2191 }
2192
Thomas Graf2d7202b2006-08-22 00:01:27 -07002193 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2194 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08002195 return -EMSGSIZE;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002196
2197 rtm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 rtm->rtm_family = AF_INET6;
2199 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2200 rtm->rtm_src_len = rt->rt6i_src.plen;
2201 rtm->rtm_tos = 0;
Thomas Grafc71099a2006-08-04 23:20:06 -07002202 if (rt->rt6i_table)
Patrick McHardy9e762a42006-08-10 23:09:48 -07002203 table = rt->rt6i_table->tb6_id;
Thomas Grafc71099a2006-08-04 23:20:06 -07002204 else
Patrick McHardy9e762a42006-08-10 23:09:48 -07002205 table = RT6_TABLE_UNSPEC;
2206 rtm->rtm_table = table;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002207 NLA_PUT_U32(skb, RTA_TABLE, table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 if (rt->rt6i_flags&RTF_REJECT)
2209 rtm->rtm_type = RTN_UNREACHABLE;
2210 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2211 rtm->rtm_type = RTN_LOCAL;
2212 else
2213 rtm->rtm_type = RTN_UNICAST;
2214 rtm->rtm_flags = 0;
2215 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2216 rtm->rtm_protocol = rt->rt6i_protocol;
2217 if (rt->rt6i_flags&RTF_DYNAMIC)
2218 rtm->rtm_protocol = RTPROT_REDIRECT;
2219 else if (rt->rt6i_flags & RTF_ADDRCONF)
2220 rtm->rtm_protocol = RTPROT_KERNEL;
2221 else if (rt->rt6i_flags&RTF_DEFAULT)
2222 rtm->rtm_protocol = RTPROT_RA;
2223
2224 if (rt->rt6i_flags&RTF_CACHE)
2225 rtm->rtm_flags |= RTM_F_CLONED;
2226
2227 if (dst) {
Thomas Graf2d7202b2006-08-22 00:01:27 -07002228 NLA_PUT(skb, RTA_DST, 16, dst);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002229 rtm->rtm_dst_len = 128;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 } else if (rtm->rtm_dst_len)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002231 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232#ifdef CONFIG_IPV6_SUBTREES
2233 if (src) {
Thomas Graf2d7202b2006-08-22 00:01:27 -07002234 NLA_PUT(skb, RTA_SRC, 16, src);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002235 rtm->rtm_src_len = 128;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 } else if (rtm->rtm_src_len)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002237 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238#endif
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002239 if (iif) {
2240#ifdef CONFIG_IPV6_MROUTE
2241 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
Benjamin Thery8229efd2008-12-10 16:30:15 -08002242 int err = ip6mr_get_route(net, skb, rtm, nowait);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002243 if (err <= 0) {
2244 if (!nowait) {
2245 if (err == 0)
2246 return 0;
2247 goto nla_put_failure;
2248 } else {
2249 if (err == -EMSGSIZE)
2250 goto nla_put_failure;
2251 }
2252 }
2253 } else
2254#endif
2255 NLA_PUT_U32(skb, RTA_IIF, iif);
2256 } else if (dst) {
Brian Haley5e0115e2008-08-13 01:58:57 -07002257 struct inet6_dev *idev = ip6_dst_idev(&rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258 struct in6_addr saddr_buf;
Brian Haley191cd582008-08-14 15:33:21 -07002259 if (ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
YOSHIFUJI Hideaki7cbca672008-03-25 09:37:42 +09002260 dst, 0, &saddr_buf) == 0)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002261 NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262 }
Thomas Graf2d7202b2006-08-22 00:01:27 -07002263
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002265 goto nla_put_failure;
2266
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267 if (rt->u.dst.neighbour)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002268 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
2269
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 if (rt->u.dst.dev)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002271 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2272
2273 NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
Thomas Grafe3703b32006-11-27 09:27:07 -08002274
YOSHIFUJI Hideaki36e3dea2008-05-13 02:52:55 +09002275 if (!(rt->rt6i_flags & RTF_EXPIRES))
2276 expires = 0;
2277 else if (rt->rt6i_expires - jiffies < INT_MAX)
2278 expires = rt->rt6i_expires - jiffies;
2279 else
2280 expires = INT_MAX;
YOSHIFUJI Hideaki69cdf8f2008-05-19 16:55:13 -07002281
Thomas Grafe3703b32006-11-27 09:27:07 -08002282 if (rtnl_put_cacheinfo(skb, &rt->u.dst, 0, 0, 0,
2283 expires, rt->u.dst.error) < 0)
2284 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285
Thomas Graf2d7202b2006-08-22 00:01:27 -07002286 return nlmsg_end(skb, nlh);
2287
2288nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002289 nlmsg_cancel(skb, nlh);
2290 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291}
2292
Patrick McHardy1b43af52006-08-10 23:11:17 -07002293int rt6_dump_route(struct rt6_info *rt, void *p_arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294{
2295 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2296 int prefix;
2297
Thomas Graf2d7202b2006-08-22 00:01:27 -07002298 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2299 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2301 } else
2302 prefix = 0;
2303
Brian Haley191cd582008-08-14 15:33:21 -07002304 return rt6_fill_node(arg->net,
2305 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002307 prefix, 0, NLM_F_MULTI);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308}
2309
Thomas Grafc127ea22007-03-22 11:58:32 -07002310static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002312 struct net *net = sock_net(in_skb->sk);
Thomas Grafab364a62006-08-22 00:01:47 -07002313 struct nlattr *tb[RTA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 struct rt6_info *rt;
Thomas Grafab364a62006-08-22 00:01:47 -07002315 struct sk_buff *skb;
2316 struct rtmsg *rtm;
2317 struct flowi fl;
2318 int err, iif = 0;
2319
2320 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2321 if (err < 0)
2322 goto errout;
2323
2324 err = -EINVAL;
2325 memset(&fl, 0, sizeof(fl));
2326
2327 if (tb[RTA_SRC]) {
2328 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2329 goto errout;
2330
2331 ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2332 }
2333
2334 if (tb[RTA_DST]) {
2335 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2336 goto errout;
2337
2338 ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2339 }
2340
2341 if (tb[RTA_IIF])
2342 iif = nla_get_u32(tb[RTA_IIF]);
2343
2344 if (tb[RTA_OIF])
2345 fl.oif = nla_get_u32(tb[RTA_OIF]);
2346
2347 if (iif) {
2348 struct net_device *dev;
Daniel Lezcano55786892008-03-04 13:47:47 -08002349 dev = __dev_get_by_index(net, iif);
Thomas Grafab364a62006-08-22 00:01:47 -07002350 if (!dev) {
2351 err = -ENODEV;
2352 goto errout;
2353 }
2354 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355
2356 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
Thomas Grafab364a62006-08-22 00:01:47 -07002357 if (skb == NULL) {
2358 err = -ENOBUFS;
2359 goto errout;
2360 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002361
2362 /* Reserve room for dummy headers, this skb can pass
2363 through good chunk of routing engine.
2364 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07002365 skb_reset_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2367
Daniel Lezcano8a3edd82008-03-07 11:14:16 -08002368 rt = (struct rt6_info*) ip6_route_output(net, NULL, &fl);
Eric Dumazetadf30902009-06-02 05:19:30 +00002369 skb_dst_set(skb, &rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370
Brian Haley191cd582008-08-14 15:33:21 -07002371 err = rt6_fill_node(net, skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002373 nlh->nlmsg_seq, 0, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 if (err < 0) {
Thomas Grafab364a62006-08-22 00:01:47 -07002375 kfree_skb(skb);
2376 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 }
2378
Daniel Lezcano55786892008-03-04 13:47:47 -08002379 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
Thomas Grafab364a62006-08-22 00:01:47 -07002380errout:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382}
2383
Thomas Graf86872cb2006-08-22 00:01:08 -07002384void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385{
2386 struct sk_buff *skb;
Daniel Lezcano55786892008-03-04 13:47:47 -08002387 struct net *net = info->nl_net;
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08002388 u32 seq;
2389 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08002391 err = -ENOBUFS;
2392 seq = info->nlh != NULL ? info->nlh->nlmsg_seq : 0;
Thomas Graf86872cb2006-08-22 00:01:08 -07002393
Thomas Graf339bf982006-11-10 14:10:15 -08002394 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
Thomas Graf21713eb2006-08-15 00:35:24 -07002395 if (skb == NULL)
2396 goto errout;
2397
Brian Haley191cd582008-08-14 15:33:21 -07002398 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002399 event, info->pid, seq, 0, 0, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08002400 if (err < 0) {
2401 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2402 WARN_ON(err == -EMSGSIZE);
2403 kfree_skb(skb);
2404 goto errout;
2405 }
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08002406 rtnl_notify(skb, net, info->pid, RTNLGRP_IPV6_ROUTE,
2407 info->nlh, gfp_any());
2408 return;
Thomas Graf21713eb2006-08-15 00:35:24 -07002409errout:
2410 if (err < 0)
Daniel Lezcano55786892008-03-04 13:47:47 -08002411 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412}
2413
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002414static int ip6_route_dev_notify(struct notifier_block *this,
2415 unsigned long event, void *data)
2416{
2417 struct net_device *dev = (struct net_device *)data;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002418 struct net *net = dev_net(dev);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002419
2420 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2421 net->ipv6.ip6_null_entry->u.dst.dev = dev;
2422 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2423#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2424 net->ipv6.ip6_prohibit_entry->u.dst.dev = dev;
2425 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2426 net->ipv6.ip6_blk_hole_entry->u.dst.dev = dev;
2427 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2428#endif
2429 }
2430
2431 return NOTIFY_OK;
2432}
2433
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434/*
2435 * /proc
2436 */
2437
2438#ifdef CONFIG_PROC_FS
2439
2440#define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2441
2442struct rt6_proc_arg
2443{
2444 char *buffer;
2445 int offset;
2446 int length;
2447 int skip;
2448 int len;
2449};
2450
2451static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2452{
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002453 struct seq_file *m = p_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454
Harvey Harrison4b7a4272008-10-29 12:50:24 -07002455 seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456
2457#ifdef CONFIG_IPV6_SUBTREES
Harvey Harrison4b7a4272008-10-29 12:50:24 -07002458 seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459#else
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002460 seq_puts(m, "00000000000000000000000000000000 00 ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461#endif
2462
2463 if (rt->rt6i_nexthop) {
Harvey Harrison4b7a4272008-10-29 12:50:24 -07002464 seq_printf(m, "%pi6", rt->rt6i_nexthop->primary_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 } else {
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002466 seq_puts(m, "00000000000000000000000000000000");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467 }
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002468 seq_printf(m, " %08x %08x %08x %08x %8s\n",
2469 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
2470 rt->u.dst.__use, rt->rt6i_flags,
2471 rt->rt6i_dev ? rt->rt6i_dev->name : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472 return 0;
2473}
2474
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002475static int ipv6_route_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476{
Daniel Lezcanof3db4852008-03-03 23:27:06 -08002477 struct net *net = (struct net *)m->private;
2478 fib6_clean_all(net, rt6_info_route, 0, m);
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002479 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480}
2481
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002482static int ipv6_route_open(struct inode *inode, struct file *file)
2483{
Pavel Emelyanovde05c552008-07-18 04:07:21 -07002484 return single_open_net(inode, file, ipv6_route_show);
Daniel Lezcanof3db4852008-03-03 23:27:06 -08002485}
2486
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002487static const struct file_operations ipv6_route_proc_fops = {
2488 .owner = THIS_MODULE,
2489 .open = ipv6_route_open,
2490 .read = seq_read,
2491 .llseek = seq_lseek,
Pavel Emelyanovb6fcbdb2008-07-18 04:07:44 -07002492 .release = single_release_net,
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002493};
2494
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2496{
Daniel Lezcano69ddb802008-03-04 13:46:23 -08002497 struct net *net = (struct net *)seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002498 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
Daniel Lezcano69ddb802008-03-04 13:46:23 -08002499 net->ipv6.rt6_stats->fib_nodes,
2500 net->ipv6.rt6_stats->fib_route_nodes,
2501 net->ipv6.rt6_stats->fib_rt_alloc,
2502 net->ipv6.rt6_stats->fib_rt_entries,
2503 net->ipv6.rt6_stats->fib_rt_cache,
Alexey Dobriyan86393e52009-08-29 01:34:49 +00002504 atomic_read(&net->ipv6.ip6_dst_ops.entries),
Daniel Lezcano69ddb802008-03-04 13:46:23 -08002505 net->ipv6.rt6_stats->fib_discarded_routes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002506
2507 return 0;
2508}
2509
2510static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2511{
Pavel Emelyanovde05c552008-07-18 04:07:21 -07002512 return single_open_net(inode, file, rt6_stats_seq_show);
Daniel Lezcano69ddb802008-03-04 13:46:23 -08002513}
2514
Arjan van de Ven9a321442007-02-12 00:55:35 -08002515static const struct file_operations rt6_stats_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516 .owner = THIS_MODULE,
2517 .open = rt6_stats_seq_open,
2518 .read = seq_read,
2519 .llseek = seq_lseek,
Pavel Emelyanovb6fcbdb2008-07-18 04:07:44 -07002520 .release = single_release_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002521};
2522#endif /* CONFIG_PROC_FS */
2523
2524#ifdef CONFIG_SYSCTL
2525
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526static
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002527int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528 void __user *buffer, size_t *lenp, loff_t *ppos)
2529{
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08002530 struct net *net = current->nsproxy->net_ns;
2531 int delay = net->ipv6.sysctl.flush_delay;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532 if (write) {
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002533 proc_dointvec(ctl, write, buffer, lenp, ppos);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08002534 fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535 return 0;
2536 } else
2537 return -EINVAL;
2538}
2539
Daniel Lezcano760f2d02008-01-10 02:53:43 -08002540ctl_table ipv6_route_table_template[] = {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002541 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 .procname = "flush",
Daniel Lezcano49905092008-01-10 03:01:01 -08002543 .data = &init_net.ipv6.sysctl.flush_delay,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 .maxlen = sizeof(int),
Dave Jones89c8b3a12005-04-28 12:11:49 -07002545 .mode = 0200,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002546 .proc_handler = ipv6_sysctl_rtcache_flush
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547 },
2548 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549 .procname = "gc_thresh",
Daniel Lezcano9a7ec3a2008-03-04 13:48:53 -08002550 .data = &ip6_dst_ops_template.gc_thresh,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551 .maxlen = sizeof(int),
2552 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002553 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554 },
2555 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002556 .procname = "max_size",
Daniel Lezcano49905092008-01-10 03:01:01 -08002557 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558 .maxlen = sizeof(int),
2559 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002560 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561 },
2562 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563 .procname = "gc_min_interval",
Daniel Lezcano49905092008-01-10 03:01:01 -08002564 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002565 .maxlen = sizeof(int),
2566 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002567 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 },
2569 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570 .procname = "gc_timeout",
Daniel Lezcano49905092008-01-10 03:01:01 -08002571 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572 .maxlen = sizeof(int),
2573 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002574 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575 },
2576 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 .procname = "gc_interval",
Daniel Lezcano49905092008-01-10 03:01:01 -08002578 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579 .maxlen = sizeof(int),
2580 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002581 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 },
2583 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584 .procname = "gc_elasticity",
Daniel Lezcano49905092008-01-10 03:01:01 -08002585 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586 .maxlen = sizeof(int),
2587 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002588 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589 },
2590 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591 .procname = "mtu_expires",
Daniel Lezcano49905092008-01-10 03:01:01 -08002592 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593 .maxlen = sizeof(int),
2594 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002595 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596 },
2597 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598 .procname = "min_adv_mss",
Daniel Lezcano49905092008-01-10 03:01:01 -08002599 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600 .maxlen = sizeof(int),
2601 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002602 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603 },
2604 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605 .procname = "gc_min_interval_ms",
Daniel Lezcano49905092008-01-10 03:01:01 -08002606 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607 .maxlen = sizeof(int),
2608 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002609 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002611 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612};
2613
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002614struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
Daniel Lezcano760f2d02008-01-10 02:53:43 -08002615{
2616 struct ctl_table *table;
2617
2618 table = kmemdup(ipv6_route_table_template,
2619 sizeof(ipv6_route_table_template),
2620 GFP_KERNEL);
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09002621
2622 if (table) {
2623 table[0].data = &net->ipv6.sysctl.flush_delay;
Alexey Dobriyan86393e52009-08-29 01:34:49 +00002624 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09002625 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2626 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2627 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2628 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2629 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2630 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2631 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
Alexey Dobriyan9c69fab2009-12-18 20:11:03 -08002632 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09002633 }
2634
Daniel Lezcano760f2d02008-01-10 02:53:43 -08002635 return table;
2636}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637#endif
2638
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002639static int __net_init ip6_route_net_init(struct net *net)
Daniel Lezcanocdb18762008-03-04 13:45:33 -08002640{
Pavel Emelyanov633d424b2008-04-21 14:25:23 -07002641 int ret = -ENOMEM;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002642
Alexey Dobriyan86393e52009-08-29 01:34:49 +00002643 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
2644 sizeof(net->ipv6.ip6_dst_ops));
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08002645
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002646 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
2647 sizeof(*net->ipv6.ip6_null_entry),
2648 GFP_KERNEL);
2649 if (!net->ipv6.ip6_null_entry)
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08002650 goto out_ip6_dst_ops;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002651 net->ipv6.ip6_null_entry->u.dst.path =
2652 (struct dst_entry *)net->ipv6.ip6_null_entry;
Alexey Dobriyan86393e52009-08-29 01:34:49 +00002653 net->ipv6.ip6_null_entry->u.dst.ops = &net->ipv6.ip6_dst_ops;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002654
2655#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2656 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
2657 sizeof(*net->ipv6.ip6_prohibit_entry),
2658 GFP_KERNEL);
Peter Zijlstra68fffc62008-10-07 14:12:10 -07002659 if (!net->ipv6.ip6_prohibit_entry)
2660 goto out_ip6_null_entry;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002661 net->ipv6.ip6_prohibit_entry->u.dst.path =
2662 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
Alexey Dobriyan86393e52009-08-29 01:34:49 +00002663 net->ipv6.ip6_prohibit_entry->u.dst.ops = &net->ipv6.ip6_dst_ops;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002664
2665 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
2666 sizeof(*net->ipv6.ip6_blk_hole_entry),
2667 GFP_KERNEL);
Peter Zijlstra68fffc62008-10-07 14:12:10 -07002668 if (!net->ipv6.ip6_blk_hole_entry)
2669 goto out_ip6_prohibit_entry;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002670 net->ipv6.ip6_blk_hole_entry->u.dst.path =
2671 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
Alexey Dobriyan86393e52009-08-29 01:34:49 +00002672 net->ipv6.ip6_blk_hole_entry->u.dst.ops = &net->ipv6.ip6_dst_ops;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002673#endif
2674
Peter Zijlstrab339a47c2008-10-07 14:15:00 -07002675 net->ipv6.sysctl.flush_delay = 0;
2676 net->ipv6.sysctl.ip6_rt_max_size = 4096;
2677 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
2678 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
2679 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
2680 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
2681 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
2682 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
2683
Daniel Lezcanocdb18762008-03-04 13:45:33 -08002684#ifdef CONFIG_PROC_FS
2685 proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);
2686 proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2687#endif
Benjamin Thery6891a342008-03-04 13:49:47 -08002688 net->ipv6.ip6_rt_gc_expire = 30*HZ;
2689
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002690 ret = 0;
2691out:
2692 return ret;
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08002693
Peter Zijlstra68fffc62008-10-07 14:12:10 -07002694#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2695out_ip6_prohibit_entry:
2696 kfree(net->ipv6.ip6_prohibit_entry);
2697out_ip6_null_entry:
2698 kfree(net->ipv6.ip6_null_entry);
2699#endif
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08002700out_ip6_dst_ops:
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08002701 goto out;
Daniel Lezcanocdb18762008-03-04 13:45:33 -08002702}
2703
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002704static void __net_exit ip6_route_net_exit(struct net *net)
Daniel Lezcanocdb18762008-03-04 13:45:33 -08002705{
2706#ifdef CONFIG_PROC_FS
2707 proc_net_remove(net, "ipv6_route");
2708 proc_net_remove(net, "rt6_stats");
2709#endif
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002710 kfree(net->ipv6.ip6_null_entry);
2711#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2712 kfree(net->ipv6.ip6_prohibit_entry);
2713 kfree(net->ipv6.ip6_blk_hole_entry);
2714#endif
Daniel Lezcanocdb18762008-03-04 13:45:33 -08002715}
2716
2717static struct pernet_operations ip6_route_net_ops = {
2718 .init = ip6_route_net_init,
2719 .exit = ip6_route_net_exit,
2720};
2721
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002722static struct notifier_block ip6_route_dev_notifier = {
2723 .notifier_call = ip6_route_dev_notify,
2724 .priority = 0,
2725};
2726
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002727int __init ip6_route_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728{
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002729 int ret;
2730
Daniel Lezcano9a7ec3a2008-03-04 13:48:53 -08002731 ret = -ENOMEM;
2732 ip6_dst_ops_template.kmem_cachep =
2733 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
2734 SLAB_HWCACHE_ALIGN, NULL);
2735 if (!ip6_dst_ops_template.kmem_cachep)
Fernando Carrijoc19a28e2009-01-07 18:09:08 -08002736 goto out;
David S. Miller14e50e52007-05-24 18:17:54 -07002737
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002738 ret = register_pernet_subsys(&ip6_route_net_ops);
2739 if (ret)
Daniel Lezcanobdb32892008-03-04 13:48:10 -08002740 goto out_kmem_cache;
Daniel Lezcanobdb32892008-03-04 13:48:10 -08002741
Arnaud Ebalard5dc121e2008-10-01 02:37:56 -07002742 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
2743
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002744 /* Registering of the loopback is done before this portion of code,
2745 * the loopback reference in rt6_info will not be taken, do it
2746 * manually for init_net */
2747 init_net.ipv6.ip6_null_entry->u.dst.dev = init_net.loopback_dev;
2748 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
2749 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2750 init_net.ipv6.ip6_prohibit_entry->u.dst.dev = init_net.loopback_dev;
2751 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
2752 init_net.ipv6.ip6_blk_hole_entry->u.dst.dev = init_net.loopback_dev;
2753 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
2754 #endif
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002755 ret = fib6_init();
2756 if (ret)
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002757 goto out_register_subsys;
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002758
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002759 ret = xfrm6_init();
2760 if (ret)
Daniel Lezcanocdb18762008-03-04 13:45:33 -08002761 goto out_fib6_init;
Daniel Lezcanoc35b7e72007-12-08 00:14:11 -08002762
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002763 ret = fib6_rules_init();
2764 if (ret)
2765 goto xfrm6_init;
Daniel Lezcano7e5449c2007-12-08 00:14:54 -08002766
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002767 ret = -ENOBUFS;
2768 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL) ||
2769 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL) ||
2770 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL))
2771 goto fib6_rules_init;
2772
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002773 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
Daniel Lezcanocdb18762008-03-04 13:45:33 -08002774 if (ret)
2775 goto fib6_rules_init;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002776
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002777out:
2778 return ret;
2779
2780fib6_rules_init:
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002781 fib6_rules_cleanup();
2782xfrm6_init:
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002783 xfrm6_fini();
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002784out_fib6_init:
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002785 fib6_gc_cleanup();
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002786out_register_subsys:
2787 unregister_pernet_subsys(&ip6_route_net_ops);
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002788out_kmem_cache:
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08002789 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
Daniel Lezcano433d49c2007-12-07 00:43:48 -08002790 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791}
2792
2793void ip6_route_cleanup(void)
2794{
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002795 unregister_netdevice_notifier(&ip6_route_dev_notifier);
Thomas Graf101367c2006-08-04 03:39:02 -07002796 fib6_rules_cleanup();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797 xfrm6_fini();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798 fib6_gc_cleanup();
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002799 unregister_pernet_subsys(&ip6_route_net_ops);
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08002800 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801}