blob: 7c34c01b515b7ac370f8021ba6f5ec4c654e9e41 [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
Joe Perchesf3213832012-05-15 14:11:53 +000027#define pr_fmt(fmt) "IPv6: " fmt
28
Randy Dunlap4fc268d2006-01-11 12:17:47 -080029#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/errno.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040031#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/types.h>
33#include <linux/times.h>
34#include <linux/socket.h>
35#include <linux/sockios.h>
36#include <linux/net.h>
37#include <linux/route.h>
38#include <linux/netdevice.h>
39#include <linux/in6.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090040#include <linux/mroute6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/if_arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/proc_fs.h>
44#include <linux/seq_file.h>
Daniel Lezcano5b7c9312008-03-03 23:28:58 -080045#include <linux/nsproxy.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090046#include <linux/slab.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020047#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <net/snmp.h>
49#include <net/ipv6.h>
50#include <net/ip6_fib.h>
51#include <net/ip6_route.h>
52#include <net/ndisc.h>
53#include <net/addrconf.h>
54#include <net/tcp.h>
55#include <linux/rtnetlink.h>
56#include <net/dst.h>
57#include <net/xfrm.h>
Tom Tucker8d717402006-07-30 20:43:36 -070058#include <net/netevent.h>
Thomas Graf21713eb2006-08-15 00:35:24 -070059#include <net/netlink.h>
Nicolas Dichtel51ebd312012-10-22 03:42:09 +000060#include <net/nexthop.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62#include <asm/uaccess.h>
63
64#ifdef CONFIG_SYSCTL
65#include <linux/sysctl.h>
66#endif
67
Gao feng1716a962012-04-06 00:13:10 +000068static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
Eric Dumazet21efcfa2011-07-19 20:18:36 +000069 const struct in6_addr *dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
David S. Miller0dbaee32010-12-13 12:52:14 -080071static unsigned int ip6_default_advmss(const struct dst_entry *dst);
Steffen Klassertebb762f2011-11-23 02:12:51 +000072static unsigned int ip6_mtu(const struct dst_entry *dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073static struct dst_entry *ip6_negative_advice(struct dst_entry *);
74static void ip6_dst_destroy(struct dst_entry *);
75static void ip6_dst_ifdown(struct dst_entry *,
76 struct net_device *dev, int how);
Daniel Lezcano569d3642008-01-18 03:56:57 -080077static int ip6_dst_gc(struct dst_ops *ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79static int ip6_pkt_discard(struct sk_buff *skb);
80static int ip6_pkt_discard_out(struct sk_buff *skb);
81static void ip6_link_failure(struct sk_buff *skb);
David S. Miller6700c272012-07-17 03:29:28 -070082static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
83 struct sk_buff *skb, u32 mtu);
84static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
85 struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -080087#ifdef CONFIG_IPV6_ROUTE_INFO
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -080088static struct rt6_info *rt6_add_route_info(struct net *net,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000089 const struct in6_addr *prefix, int prefixlen,
90 const struct in6_addr *gwaddr, int ifindex,
Eric Dumazet95c96172012-04-15 05:58:06 +000091 unsigned int pref);
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -080092static struct rt6_info *rt6_get_route_info(struct net *net,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000093 const struct in6_addr *prefix, int prefixlen,
94 const struct in6_addr *gwaddr, int ifindex);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -080095#endif
96
David S. Miller06582542011-01-27 14:58:42 -080097static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
98{
99 struct rt6_info *rt = (struct rt6_info *) dst;
100 struct inet_peer *peer;
101 u32 *p = NULL;
102
Yan, Zheng8e2ec632011-09-05 21:34:30 +0000103 if (!(rt->dst.flags & DST_HOST))
104 return NULL;
105
David S. Millerfbfe95a2012-06-08 23:24:18 -0700106 peer = rt6_get_peer_create(rt);
David S. Miller06582542011-01-27 14:58:42 -0800107 if (peer) {
108 u32 *old_p = __DST_METRICS_PTR(old);
109 unsigned long prev, new;
110
111 p = peer->metrics;
112 if (inet_metrics_new(peer))
113 memcpy(p, old_p, sizeof(u32) * RTAX_MAX);
114
115 new = (unsigned long) p;
116 prev = cmpxchg(&dst->_metrics, old, new);
117
118 if (prev != old) {
119 p = __DST_METRICS_PTR(prev);
120 if (prev & DST_METRICS_READ_ONLY)
121 p = NULL;
122 }
123 }
124 return p;
125}
126
David S. Millerf894cbf2012-07-02 21:52:24 -0700127static inline const void *choose_neigh_daddr(struct rt6_info *rt,
128 struct sk_buff *skb,
129 const void *daddr)
David S. Miller39232972012-01-26 15:22:32 -0500130{
131 struct in6_addr *p = &rt->rt6i_gateway;
132
David S. Millera7563f32012-01-26 16:29:16 -0500133 if (!ipv6_addr_any(p))
David S. Miller39232972012-01-26 15:22:32 -0500134 return (const void *) p;
David S. Millerf894cbf2012-07-02 21:52:24 -0700135 else if (skb)
136 return &ipv6_hdr(skb)->daddr;
David S. Miller39232972012-01-26 15:22:32 -0500137 return daddr;
138}
139
David S. Millerf894cbf2012-07-02 21:52:24 -0700140static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
141 struct sk_buff *skb,
142 const void *daddr)
David S. Millerd3aaeb32011-07-18 00:40:17 -0700143{
David S. Miller39232972012-01-26 15:22:32 -0500144 struct rt6_info *rt = (struct rt6_info *) dst;
145 struct neighbour *n;
146
David S. Millerf894cbf2012-07-02 21:52:24 -0700147 daddr = choose_neigh_daddr(rt, skb, daddr);
David S. Miller39232972012-01-26 15:22:32 -0500148 n = __ipv6_neigh_lookup(&nd_tbl, dst->dev, daddr);
David S. Millerf83c7792011-12-28 15:41:23 -0500149 if (n)
150 return n;
151 return neigh_create(&nd_tbl, daddr, dst->dev);
152}
153
David S. Miller8ade06c2011-12-29 18:51:57 -0500154static int rt6_bind_neighbour(struct rt6_info *rt, struct net_device *dev)
David S. Millerf83c7792011-12-28 15:41:23 -0500155{
David S. Miller8ade06c2011-12-29 18:51:57 -0500156 struct neighbour *n = __ipv6_neigh_lookup(&nd_tbl, dev, &rt->rt6i_gateway);
157 if (!n) {
158 n = neigh_create(&nd_tbl, &rt->rt6i_gateway, dev);
159 if (IS_ERR(n))
160 return PTR_ERR(n);
161 }
David S. Miller97cac082012-07-02 22:43:47 -0700162 rt->n = n;
David S. Millerf83c7792011-12-28 15:41:23 -0500163
164 return 0;
David S. Millerd3aaeb32011-07-18 00:40:17 -0700165}
166
Daniel Lezcano9a7ec3a2008-03-04 13:48:53 -0800167static struct dst_ops ip6_dst_ops_template = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 .family = AF_INET6,
Harvey Harrison09640e62009-02-01 00:45:17 -0800169 .protocol = cpu_to_be16(ETH_P_IPV6),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 .gc = ip6_dst_gc,
171 .gc_thresh = 1024,
172 .check = ip6_dst_check,
David S. Miller0dbaee32010-12-13 12:52:14 -0800173 .default_advmss = ip6_default_advmss,
Steffen Klassertebb762f2011-11-23 02:12:51 +0000174 .mtu = ip6_mtu,
David S. Miller06582542011-01-27 14:58:42 -0800175 .cow_metrics = ipv6_cow_metrics,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 .destroy = ip6_dst_destroy,
177 .ifdown = ip6_dst_ifdown,
178 .negative_advice = ip6_negative_advice,
179 .link_failure = ip6_link_failure,
180 .update_pmtu = ip6_rt_update_pmtu,
David S. Miller6e157b62012-07-12 00:05:02 -0700181 .redirect = rt6_do_redirect,
Herbert Xu1ac06e02008-05-20 14:32:14 -0700182 .local_out = __ip6_local_out,
David S. Millerd3aaeb32011-07-18 00:40:17 -0700183 .neigh_lookup = ip6_neigh_lookup,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184};
185
Steffen Klassertebb762f2011-11-23 02:12:51 +0000186static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
Roland Dreierec831ea2011-01-31 13:16:00 -0800187{
Steffen Klassert618f9bc2011-11-23 02:13:31 +0000188 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
189
190 return mtu ? : dst->dev->mtu;
Roland Dreierec831ea2011-01-31 13:16:00 -0800191}
192
David S. Miller6700c272012-07-17 03:29:28 -0700193static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
194 struct sk_buff *skb, u32 mtu)
David S. Miller14e50e52007-05-24 18:17:54 -0700195{
196}
197
David S. Miller6700c272012-07-17 03:29:28 -0700198static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
199 struct sk_buff *skb)
David S. Millerb587ee32012-07-12 00:39:24 -0700200{
201}
202
Held Bernhard0972ddb2011-04-24 22:07:32 +0000203static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,
204 unsigned long old)
205{
206 return NULL;
207}
208
David S. Miller14e50e52007-05-24 18:17:54 -0700209static struct dst_ops ip6_dst_blackhole_ops = {
210 .family = AF_INET6,
Harvey Harrison09640e62009-02-01 00:45:17 -0800211 .protocol = cpu_to_be16(ETH_P_IPV6),
David S. Miller14e50e52007-05-24 18:17:54 -0700212 .destroy = ip6_dst_destroy,
213 .check = ip6_dst_check,
Steffen Klassertebb762f2011-11-23 02:12:51 +0000214 .mtu = ip6_blackhole_mtu,
Eric Dumazet214f45c2011-02-18 11:39:01 -0800215 .default_advmss = ip6_default_advmss,
David S. Miller14e50e52007-05-24 18:17:54 -0700216 .update_pmtu = ip6_rt_blackhole_update_pmtu,
David S. Millerb587ee32012-07-12 00:39:24 -0700217 .redirect = ip6_rt_blackhole_redirect,
Held Bernhard0972ddb2011-04-24 22:07:32 +0000218 .cow_metrics = ip6_rt_blackhole_cow_metrics,
David S. Millerd3aaeb32011-07-18 00:40:17 -0700219 .neigh_lookup = ip6_neigh_lookup,
David S. Miller14e50e52007-05-24 18:17:54 -0700220};
221
David S. Miller62fa8a82011-01-26 20:51:05 -0800222static const u32 ip6_template_metrics[RTAX_MAX] = {
Li RongQing14edd872012-10-24 14:01:18 +0800223 [RTAX_HOPLIMIT - 1] = 0,
David S. Miller62fa8a82011-01-26 20:51:05 -0800224};
225
Eric Dumazetfb0af4c2012-09-11 21:47:51 +0000226static const struct rt6_info ip6_null_entry_template = {
Changli Gaod8d1f302010-06-10 23:31:35 -0700227 .dst = {
228 .__refcnt = ATOMIC_INIT(1),
229 .__use = 1,
Nicolas Dichtel2c20cbd2012-09-10 22:09:47 +0000230 .obsolete = DST_OBSOLETE_FORCE_CHK,
Changli Gaod8d1f302010-06-10 23:31:35 -0700231 .error = -ENETUNREACH,
Changli Gaod8d1f302010-06-10 23:31:35 -0700232 .input = ip6_pkt_discard,
233 .output = ip6_pkt_discard_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 },
235 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
Jean-Mickael Guerin4f724272009-05-20 17:38:59 -0700236 .rt6i_protocol = RTPROT_KERNEL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 .rt6i_metric = ~(u32) 0,
238 .rt6i_ref = ATOMIC_INIT(1),
239};
240
Thomas Graf101367c2006-08-04 03:39:02 -0700241#ifdef CONFIG_IPV6_MULTIPLE_TABLES
242
David S. Miller6723ab52006-10-18 21:20:57 -0700243static int ip6_pkt_prohibit(struct sk_buff *skb);
244static int ip6_pkt_prohibit_out(struct sk_buff *skb);
David S. Miller6723ab52006-10-18 21:20:57 -0700245
Eric Dumazetfb0af4c2012-09-11 21:47:51 +0000246static const struct rt6_info ip6_prohibit_entry_template = {
Changli Gaod8d1f302010-06-10 23:31:35 -0700247 .dst = {
248 .__refcnt = ATOMIC_INIT(1),
249 .__use = 1,
Nicolas Dichtel2c20cbd2012-09-10 22:09:47 +0000250 .obsolete = DST_OBSOLETE_FORCE_CHK,
Changli Gaod8d1f302010-06-10 23:31:35 -0700251 .error = -EACCES,
Changli Gaod8d1f302010-06-10 23:31:35 -0700252 .input = ip6_pkt_prohibit,
253 .output = ip6_pkt_prohibit_out,
Thomas Graf101367c2006-08-04 03:39:02 -0700254 },
255 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
Jean-Mickael Guerin4f724272009-05-20 17:38:59 -0700256 .rt6i_protocol = RTPROT_KERNEL,
Thomas Graf101367c2006-08-04 03:39:02 -0700257 .rt6i_metric = ~(u32) 0,
258 .rt6i_ref = ATOMIC_INIT(1),
259};
260
Eric Dumazetfb0af4c2012-09-11 21:47:51 +0000261static const struct rt6_info ip6_blk_hole_entry_template = {
Changli Gaod8d1f302010-06-10 23:31:35 -0700262 .dst = {
263 .__refcnt = ATOMIC_INIT(1),
264 .__use = 1,
Nicolas Dichtel2c20cbd2012-09-10 22:09:47 +0000265 .obsolete = DST_OBSOLETE_FORCE_CHK,
Changli Gaod8d1f302010-06-10 23:31:35 -0700266 .error = -EINVAL,
Changli Gaod8d1f302010-06-10 23:31:35 -0700267 .input = dst_discard,
268 .output = dst_discard,
Thomas Graf101367c2006-08-04 03:39:02 -0700269 },
270 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
Jean-Mickael Guerin4f724272009-05-20 17:38:59 -0700271 .rt6i_protocol = RTPROT_KERNEL,
Thomas Graf101367c2006-08-04 03:39:02 -0700272 .rt6i_metric = ~(u32) 0,
273 .rt6i_ref = ATOMIC_INIT(1),
274};
275
276#endif
277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278/* allocate dst with ip6_dst_ops */
David S. Miller97bab732012-06-09 22:36:36 -0700279static inline struct rt6_info *ip6_dst_alloc(struct net *net,
David S. Miller957c6652011-06-24 15:25:00 -0700280 struct net_device *dev,
David S. Miller8b96d222012-06-11 02:01:56 -0700281 int flags,
282 struct fib6_table *table)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283{
David S. Miller97bab732012-06-09 22:36:36 -0700284 struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
Nicolas Dichtel6f3118b2012-09-10 22:09:46 +0000285 0, DST_OBSOLETE_FORCE_CHK, flags);
David S. Millercf911662011-04-28 14:31:47 -0700286
David S. Miller97bab732012-06-09 22:36:36 -0700287 if (rt) {
Steffen Klassert81048912012-07-05 23:37:09 +0000288 struct dst_entry *dst = &rt->dst;
289
290 memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
David S. Miller8b96d222012-06-11 02:01:56 -0700291 rt6_init_peer(rt, table ? &table->tb6_peers : net->ipv6.peers);
Nicolas Dichtel6f3118b2012-09-10 22:09:46 +0000292 rt->rt6i_genid = rt_genid(net);
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000293 INIT_LIST_HEAD(&rt->rt6i_siblings);
294 rt->rt6i_nsiblings = 0;
David S. Miller97bab732012-06-09 22:36:36 -0700295 }
David S. Millercf911662011-04-28 14:31:47 -0700296 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297}
298
299static void ip6_dst_destroy(struct dst_entry *dst)
300{
301 struct rt6_info *rt = (struct rt6_info *)dst;
302 struct inet6_dev *idev = rt->rt6i_idev;
303
David S. Miller97cac082012-07-02 22:43:47 -0700304 if (rt->n)
305 neigh_release(rt->n);
306
Yan, Zheng8e2ec632011-09-05 21:34:30 +0000307 if (!(rt->dst.flags & DST_HOST))
308 dst_destroy_metrics_generic(dst);
309
David S. Miller38308472011-12-03 18:02:47 -0500310 if (idev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 rt->rt6i_idev = NULL;
312 in6_dev_put(idev);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900313 }
Gao feng1716a962012-04-06 00:13:10 +0000314
315 if (!(rt->rt6i_flags & RTF_EXPIRES) && dst->from)
316 dst_release(dst->from);
317
David S. Miller97bab732012-06-09 22:36:36 -0700318 if (rt6_has_peer(rt)) {
319 struct inet_peer *peer = rt6_peer_ptr(rt);
David S. Millerb3419362010-11-30 12:27:11 -0800320 inet_putpeer(peer);
321 }
322}
323
324void rt6_bind_peer(struct rt6_info *rt, int create)
325{
David S. Miller97bab732012-06-09 22:36:36 -0700326 struct inet_peer_base *base;
David S. Millerb3419362010-11-30 12:27:11 -0800327 struct inet_peer *peer;
328
David S. Miller97bab732012-06-09 22:36:36 -0700329 base = inetpeer_base_ptr(rt->_rt6i_peer);
330 if (!base)
331 return;
332
333 peer = inet_getpeer_v6(base, &rt->rt6i_dst.addr, create);
David S. Miller7b34ca22012-06-11 04:13:57 -0700334 if (peer) {
335 if (!rt6_set_peer(rt, peer))
336 inet_putpeer(peer);
David S. Miller7b34ca22012-06-11 04:13:57 -0700337 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338}
339
340static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
341 int how)
342{
343 struct rt6_info *rt = (struct rt6_info *)dst;
344 struct inet6_dev *idev = rt->rt6i_idev;
Denis V. Lunev5a3e55d2007-12-07 00:38:10 -0800345 struct net_device *loopback_dev =
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900346 dev_net(dev)->loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
David S. Miller97cac082012-07-02 22:43:47 -0700348 if (dev != loopback_dev) {
349 if (idev && idev->dev == dev) {
350 struct inet6_dev *loopback_idev =
351 in6_dev_get(loopback_dev);
352 if (loopback_idev) {
353 rt->rt6i_idev = loopback_idev;
354 in6_dev_put(idev);
355 }
356 }
357 if (rt->n && rt->n->dev == dev) {
358 rt->n->dev = loopback_dev;
359 dev_hold(loopback_dev);
360 dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 }
362 }
363}
364
Eric Dumazeta50feda2012-05-18 18:57:34 +0000365static bool rt6_check_expired(const struct rt6_info *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366{
Gao feng1716a962012-04-06 00:13:10 +0000367 if (rt->rt6i_flags & RTF_EXPIRES) {
368 if (time_after(jiffies, rt->dst.expires))
Eric Dumazeta50feda2012-05-18 18:57:34 +0000369 return true;
Gao feng1716a962012-04-06 00:13:10 +0000370 } else if (rt->dst.from) {
Li RongQing3fd91fb2012-09-13 19:54:57 +0000371 return rt6_check_expired((struct rt6_info *) rt->dst.from);
Gao feng1716a962012-04-06 00:13:10 +0000372 }
Eric Dumazeta50feda2012-05-18 18:57:34 +0000373 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374}
375
Eric Dumazeta50feda2012-05-18 18:57:34 +0000376static bool rt6_need_strict(const struct in6_addr *daddr)
Thomas Grafc71099a2006-08-04 23:20:06 -0700377{
Eric Dumazeta02cec22010-09-22 20:43:57 +0000378 return ipv6_addr_type(daddr) &
379 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
Thomas Grafc71099a2006-08-04 23:20:06 -0700380}
381
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000382/* Multipath route selection:
383 * Hash based function using packet header and flowlabel.
384 * Adapted from fib_info_hashfn()
385 */
386static int rt6_info_hash_nhsfn(unsigned int candidate_count,
387 const struct flowi6 *fl6)
388{
389 unsigned int val = fl6->flowi6_proto;
390
YOSHIFUJI Hideaki / 吉藤英明c08977b2013-01-13 05:02:29 +0000391 val ^= ipv6_addr_hash(&fl6->daddr);
392 val ^= ipv6_addr_hash(&fl6->saddr);
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000393
394 /* Work only if this not encapsulated */
395 switch (fl6->flowi6_proto) {
396 case IPPROTO_UDP:
397 case IPPROTO_TCP:
398 case IPPROTO_SCTP:
Nicolas Dichtelb3ce5ae2012-10-22 23:35:06 +0000399 val ^= (__force u16)fl6->fl6_sport;
400 val ^= (__force u16)fl6->fl6_dport;
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000401 break;
402
403 case IPPROTO_ICMPV6:
Nicolas Dichtelb3ce5ae2012-10-22 23:35:06 +0000404 val ^= (__force u16)fl6->fl6_icmp_type;
405 val ^= (__force u16)fl6->fl6_icmp_code;
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000406 break;
407 }
408 /* RFC6438 recommands to use flowlabel */
Nicolas Dichtelb3ce5ae2012-10-22 23:35:06 +0000409 val ^= (__force u32)fl6->flowlabel;
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000410
411 /* Perhaps, we need to tune, this function? */
412 val = val ^ (val >> 7) ^ (val >> 12);
413 return val % candidate_count;
414}
415
416static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
417 struct flowi6 *fl6)
418{
419 struct rt6_info *sibling, *next_sibling;
420 int route_choosen;
421
422 route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
423 /* Don't change the route, if route_choosen == 0
424 * (siblings does not include ourself)
425 */
426 if (route_choosen)
427 list_for_each_entry_safe(sibling, next_sibling,
428 &match->rt6i_siblings, rt6i_siblings) {
429 route_choosen--;
430 if (route_choosen == 0) {
431 match = sibling;
432 break;
433 }
434 }
435 return match;
436}
437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438/*
Thomas Grafc71099a2006-08-04 23:20:06 -0700439 * Route lookup. Any table->tb6_lock is implied.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 */
441
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800442static inline struct rt6_info *rt6_device_match(struct net *net,
443 struct rt6_info *rt,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000444 const struct in6_addr *saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 int oif,
YOSHIFUJI Hideakid4208952008-06-27 20:14:54 -0700446 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447{
448 struct rt6_info *local = NULL;
449 struct rt6_info *sprt;
450
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900451 if (!oif && ipv6_addr_any(saddr))
452 goto out;
453
Changli Gaod8d1f302010-06-10 23:31:35 -0700454 for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
David S. Millerd1918542011-12-28 20:19:20 -0500455 struct net_device *dev = sprt->dst.dev;
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900456
457 if (oif) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 if (dev->ifindex == oif)
459 return sprt;
460 if (dev->flags & IFF_LOOPBACK) {
David S. Miller38308472011-12-03 18:02:47 -0500461 if (!sprt->rt6i_idev ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 sprt->rt6i_idev->dev->ifindex != oif) {
YOSHIFUJI Hideakid4208952008-06-27 20:14:54 -0700463 if (flags & RT6_LOOKUP_F_IFACE && oif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 continue;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900465 if (local && (!oif ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 local->rt6i_idev->dev->ifindex == oif))
467 continue;
468 }
469 local = sprt;
470 }
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900471 } else {
472 if (ipv6_chk_addr(net, saddr, dev,
473 flags & RT6_LOOKUP_F_IFACE))
474 return sprt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 }
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900476 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900478 if (oif) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 if (local)
480 return local;
481
YOSHIFUJI Hideakid4208952008-06-27 20:14:54 -0700482 if (flags & RT6_LOOKUP_F_IFACE)
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800483 return net->ipv6.ip6_null_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 }
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900485out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 return rt;
487}
488
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800489#ifdef CONFIG_IPV6_ROUTER_PREF
490static void rt6_probe(struct rt6_info *rt)
491{
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000492 struct neighbour *neigh;
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800493 /*
494 * Okay, this does not seem to be appropriate
495 * for now, however, we need to check if it
496 * is really so; aka Router Reachability Probing.
497 *
498 * Router Reachability Probe MUST be rate-limited
499 * to no more than one per minute.
500 */
David S. Miller97cac082012-07-02 22:43:47 -0700501 neigh = rt ? rt->n : NULL;
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800502 if (!neigh || (neigh->nud_state & NUD_VALID))
Amerigo Wangfdd66812012-09-10 02:48:44 +0000503 return;
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800504 read_lock_bh(&neigh->lock);
505 if (!(neigh->nud_state & NUD_VALID) &&
YOSHIFUJI Hideaki52e16352006-03-20 17:05:47 -0800506 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800507 struct in6_addr mcaddr;
508 struct in6_addr *target;
509
510 neigh->updated = jiffies;
511 read_unlock_bh(&neigh->lock);
512
513 target = (struct in6_addr *)&neigh->primary_key;
514 addrconf_addr_solict_mult(target, &mcaddr);
David S. Millerd1918542011-12-28 20:19:20 -0500515 ndisc_send_ns(rt->dst.dev, NULL, target, &mcaddr, NULL);
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000516 } else {
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800517 read_unlock_bh(&neigh->lock);
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000518 }
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800519}
520#else
521static inline void rt6_probe(struct rt6_info *rt)
522{
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800523}
524#endif
525
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526/*
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800527 * Default Router Selection (RFC 2461 6.3.6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 */
Dave Jonesb6f99a22007-03-22 12:27:49 -0700529static inline int rt6_check_dev(struct rt6_info *rt, int oif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530{
David S. Millerd1918542011-12-28 20:19:20 -0500531 struct net_device *dev = rt->dst.dev;
David S. Miller161980f2007-04-06 11:42:27 -0700532 if (!oif || dev->ifindex == oif)
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800533 return 2;
David S. Miller161980f2007-04-06 11:42:27 -0700534 if ((dev->flags & IFF_LOOPBACK) &&
535 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
536 return 1;
537 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538}
539
Paul Marksa5a81f02012-12-03 10:26:54 +0000540static inline bool rt6_check_neigh(struct rt6_info *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000542 struct neighbour *neigh;
Paul Marksa5a81f02012-12-03 10:26:54 +0000543 bool ret = false;
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000544
David S. Miller97cac082012-07-02 22:43:47 -0700545 neigh = rt->n;
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700546 if (rt->rt6i_flags & RTF_NONEXTHOP ||
547 !(rt->rt6i_flags & RTF_GATEWAY))
Paul Marksa5a81f02012-12-03 10:26:54 +0000548 ret = true;
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700549 else if (neigh) {
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800550 read_lock_bh(&neigh->lock);
551 if (neigh->nud_state & NUD_VALID)
Paul Marksa5a81f02012-12-03 10:26:54 +0000552 ret = true;
YOSHIFUJI Hideaki398bcbe2008-01-19 00:35:16 -0800553#ifdef CONFIG_IPV6_ROUTER_PREF
Paul Marksa5a81f02012-12-03 10:26:54 +0000554 else if (!(neigh->nud_state & NUD_FAILED))
555 ret = true;
YOSHIFUJI Hideaki398bcbe2008-01-19 00:35:16 -0800556#endif
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800557 read_unlock_bh(&neigh->lock);
Paul Marksa5a81f02012-12-03 10:26:54 +0000558 }
559 return ret;
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800560}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800562static int rt6_score_route(struct rt6_info *rt, int oif,
563 int strict)
564{
Paul Marksa5a81f02012-12-03 10:26:54 +0000565 int m;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900566
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700567 m = rt6_check_dev(rt, oif);
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700568 if (!m && (strict & RT6_LOOKUP_F_IFACE))
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800569 return -1;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -0800570#ifdef CONFIG_IPV6_ROUTER_PREF
571 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
572#endif
Paul Marksa5a81f02012-12-03 10:26:54 +0000573 if (!rt6_check_neigh(rt) && (strict & RT6_LOOKUP_F_REACHABLE))
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800574 return -1;
575 return m;
576}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
David S. Millerf11e6652007-03-24 20:36:25 -0700578static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
579 int *mpri, struct rt6_info *match)
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800580{
David S. Millerf11e6652007-03-24 20:36:25 -0700581 int m;
582
583 if (rt6_check_expired(rt))
584 goto out;
585
586 m = rt6_score_route(rt, oif, strict);
587 if (m < 0)
588 goto out;
589
590 if (m > *mpri) {
591 if (strict & RT6_LOOKUP_F_REACHABLE)
592 rt6_probe(match);
593 *mpri = m;
594 match = rt;
595 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
596 rt6_probe(rt);
597 }
598
599out:
600 return match;
601}
602
603static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
604 struct rt6_info *rr_head,
605 u32 metric, int oif, int strict)
606{
607 struct rt6_info *rt, *match;
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800608 int mpri = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
David S. Millerf11e6652007-03-24 20:36:25 -0700610 match = NULL;
611 for (rt = rr_head; rt && rt->rt6i_metric == metric;
Changli Gaod8d1f302010-06-10 23:31:35 -0700612 rt = rt->dst.rt6_next)
David S. Millerf11e6652007-03-24 20:36:25 -0700613 match = find_match(rt, oif, strict, &mpri, match);
614 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
Changli Gaod8d1f302010-06-10 23:31:35 -0700615 rt = rt->dst.rt6_next)
David S. Millerf11e6652007-03-24 20:36:25 -0700616 match = find_match(rt, oif, strict, &mpri, match);
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800617
David S. Millerf11e6652007-03-24 20:36:25 -0700618 return match;
619}
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800620
David S. Millerf11e6652007-03-24 20:36:25 -0700621static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
622{
623 struct rt6_info *match, *rt0;
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800624 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
David S. Millerf11e6652007-03-24 20:36:25 -0700626 rt0 = fn->rr_ptr;
627 if (!rt0)
628 fn->rr_ptr = rt0 = fn->leaf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
David S. Millerf11e6652007-03-24 20:36:25 -0700630 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800632 if (!match &&
David S. Millerf11e6652007-03-24 20:36:25 -0700633 (strict & RT6_LOOKUP_F_REACHABLE)) {
Changli Gaod8d1f302010-06-10 23:31:35 -0700634 struct rt6_info *next = rt0->dst.rt6_next;
David S. Millerf11e6652007-03-24 20:36:25 -0700635
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800636 /* no entries matched; do round-robin */
David S. Millerf11e6652007-03-24 20:36:25 -0700637 if (!next || next->rt6i_metric != rt0->rt6i_metric)
638 next = fn->leaf;
639
640 if (next != rt0)
641 fn->rr_ptr = next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 }
643
David S. Millerd1918542011-12-28 20:19:20 -0500644 net = dev_net(rt0->dst.dev);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000645 return match ? match : net->ipv6.ip6_null_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646}
647
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800648#ifdef CONFIG_IPV6_ROUTE_INFO
649int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000650 const struct in6_addr *gwaddr)
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800651{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900652 struct net *net = dev_net(dev);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800653 struct route_info *rinfo = (struct route_info *) opt;
654 struct in6_addr prefix_buf, *prefix;
655 unsigned int pref;
YOSHIFUJI Hideaki4bed72e2008-05-27 17:37:49 +0900656 unsigned long lifetime;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800657 struct rt6_info *rt;
658
659 if (len < sizeof(struct route_info)) {
660 return -EINVAL;
661 }
662
663 /* Sanity check for prefix_len and length */
664 if (rinfo->length > 3) {
665 return -EINVAL;
666 } else if (rinfo->prefix_len > 128) {
667 return -EINVAL;
668 } else if (rinfo->prefix_len > 64) {
669 if (rinfo->length < 2) {
670 return -EINVAL;
671 }
672 } else if (rinfo->prefix_len > 0) {
673 if (rinfo->length < 1) {
674 return -EINVAL;
675 }
676 }
677
678 pref = rinfo->route_pref;
679 if (pref == ICMPV6_ROUTER_PREF_INVALID)
Jens Rosenboom3933fc92009-09-10 06:25:11 +0000680 return -EINVAL;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800681
YOSHIFUJI Hideaki4bed72e2008-05-27 17:37:49 +0900682 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800683
684 if (rinfo->length == 3)
685 prefix = (struct in6_addr *)rinfo->prefix;
686 else {
687 /* this function is safe */
688 ipv6_addr_prefix(&prefix_buf,
689 (struct in6_addr *)rinfo->prefix,
690 rinfo->prefix_len);
691 prefix = &prefix_buf;
692 }
693
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -0800694 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len, gwaddr,
695 dev->ifindex);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800696
697 if (rt && !lifetime) {
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700698 ip6_del_rt(rt);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800699 rt = NULL;
700 }
701
702 if (!rt && lifetime)
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -0800703 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800704 pref);
705 else if (rt)
706 rt->rt6i_flags = RTF_ROUTEINFO |
707 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
708
709 if (rt) {
Gao feng1716a962012-04-06 00:13:10 +0000710 if (!addrconf_finite_timeout(lifetime))
711 rt6_clean_expires(rt);
712 else
713 rt6_set_expires(rt, jiffies + HZ * lifetime);
714
Amerigo Wang94e187c2012-10-29 00:13:19 +0000715 ip6_rt_put(rt);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800716 }
717 return 0;
718}
719#endif
720
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800721#define BACKTRACK(__net, saddr) \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700722do { \
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800723 if (rt == __net->ipv6.ip6_null_entry) { \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700724 struct fib6_node *pn; \
Ville Nuorvalae0eda7b2006-10-16 22:11:11 -0700725 while (1) { \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700726 if (fn->fn_flags & RTN_TL_ROOT) \
727 goto out; \
728 pn = fn->parent; \
729 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
Kim Nordlund8bce65b2006-12-13 16:38:29 -0800730 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
YOSHIFUJI Hideaki982f56f2006-08-23 17:22:39 -0700731 else \
732 fn = pn; \
733 if (fn->fn_flags & RTN_RTINFO) \
734 goto restart; \
Thomas Grafc71099a2006-08-04 23:20:06 -0700735 } \
Thomas Grafc71099a2006-08-04 23:20:06 -0700736 } \
David S. Miller38308472011-12-03 18:02:47 -0500737} while (0)
Thomas Grafc71099a2006-08-04 23:20:06 -0700738
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800739static struct rt6_info *ip6_pol_route_lookup(struct net *net,
740 struct fib6_table *table,
David S. Miller4c9483b2011-03-12 16:22:43 -0500741 struct flowi6 *fl6, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742{
743 struct fib6_node *fn;
744 struct rt6_info *rt;
745
Thomas Grafc71099a2006-08-04 23:20:06 -0700746 read_lock_bh(&table->tb6_lock);
David S. Miller4c9483b2011-03-12 16:22:43 -0500747 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
Thomas Grafc71099a2006-08-04 23:20:06 -0700748restart:
749 rt = fn->leaf;
David S. Miller4c9483b2011-03-12 16:22:43 -0500750 rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000751 if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
752 rt = rt6_multipath_select(rt, fl6);
David S. Miller4c9483b2011-03-12 16:22:43 -0500753 BACKTRACK(net, &fl6->saddr);
Thomas Grafc71099a2006-08-04 23:20:06 -0700754out:
Changli Gaod8d1f302010-06-10 23:31:35 -0700755 dst_use(&rt->dst, jiffies);
Thomas Grafc71099a2006-08-04 23:20:06 -0700756 read_unlock_bh(&table->tb6_lock);
Thomas Grafc71099a2006-08-04 23:20:06 -0700757 return rt;
758
759}
760
Florian Westphalea6e5742011-09-05 16:05:44 +0200761struct dst_entry * ip6_route_lookup(struct net *net, struct flowi6 *fl6,
762 int flags)
763{
764 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
765}
766EXPORT_SYMBOL_GPL(ip6_route_lookup);
767
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900768struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
769 const struct in6_addr *saddr, int oif, int strict)
Thomas Grafc71099a2006-08-04 23:20:06 -0700770{
David S. Miller4c9483b2011-03-12 16:22:43 -0500771 struct flowi6 fl6 = {
772 .flowi6_oif = oif,
773 .daddr = *daddr,
Thomas Grafc71099a2006-08-04 23:20:06 -0700774 };
775 struct dst_entry *dst;
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700776 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
Thomas Grafc71099a2006-08-04 23:20:06 -0700777
Thomas Grafadaa70b2006-10-13 15:01:03 -0700778 if (saddr) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500779 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
Thomas Grafadaa70b2006-10-13 15:01:03 -0700780 flags |= RT6_LOOKUP_F_HAS_SADDR;
781 }
782
David S. Miller4c9483b2011-03-12 16:22:43 -0500783 dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
Thomas Grafc71099a2006-08-04 23:20:06 -0700784 if (dst->error == 0)
785 return (struct rt6_info *) dst;
786
787 dst_release(dst);
788
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 return NULL;
790}
791
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900792EXPORT_SYMBOL(rt6_lookup);
793
Thomas Grafc71099a2006-08-04 23:20:06 -0700794/* ip6_ins_rt is called with FREE table->tb6_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 It takes new route entry, the addition fails by any reason the
796 route is freed. In any case, if caller does not hold it, it may
797 be destroyed.
798 */
799
Thomas Graf86872cb2006-08-22 00:01:08 -0700800static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801{
802 int err;
Thomas Grafc71099a2006-08-04 23:20:06 -0700803 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Thomas Grafc71099a2006-08-04 23:20:06 -0700805 table = rt->rt6i_table;
806 write_lock_bh(&table->tb6_lock);
Thomas Graf86872cb2006-08-22 00:01:08 -0700807 err = fib6_add(&table->tb6_root, rt, info);
Thomas Grafc71099a2006-08-04 23:20:06 -0700808 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
810 return err;
811}
812
Thomas Graf40e22e82006-08-22 00:00:45 -0700813int ip6_ins_rt(struct rt6_info *rt)
814{
Denis V. Lunev4d1169c2008-01-10 03:26:13 -0800815 struct nl_info info = {
David S. Millerd1918542011-12-28 20:19:20 -0500816 .nl_net = dev_net(rt->dst.dev),
Denis V. Lunev4d1169c2008-01-10 03:26:13 -0800817 };
Denis V. Lunev528c4ce2007-12-13 09:45:12 -0800818 return __ip6_ins_rt(rt, &info);
Thomas Graf40e22e82006-08-22 00:00:45 -0700819}
820
Gao feng1716a962012-04-06 00:13:10 +0000821static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort,
Eric Dumazet21efcfa2011-07-19 20:18:36 +0000822 const struct in6_addr *daddr,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000823 const struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 struct rt6_info *rt;
826
827 /*
828 * Clone the route.
829 */
830
Eric Dumazet21efcfa2011-07-19 20:18:36 +0000831 rt = ip6_rt_copy(ort, daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
833 if (rt) {
David S. Miller14deae42009-01-04 16:04:39 -0800834 int attempts = !in_softirq();
835
David S. Miller38308472011-12-03 18:02:47 -0500836 if (!(rt->rt6i_flags & RTF_GATEWAY)) {
David S. Millerbb3c3682011-12-13 17:35:06 -0500837 if (ort->rt6i_dst.plen != 128 &&
Eric Dumazet21efcfa2011-07-19 20:18:36 +0000838 ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900839 rt->rt6i_flags |= RTF_ANYCAST;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000840 rt->rt6i_gateway = *daddr;
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +0900841 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 rt->rt6i_flags |= RTF_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
845#ifdef CONFIG_IPV6_SUBTREES
846 if (rt->rt6i_src.plen && saddr) {
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000847 rt->rt6i_src.addr = *saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 rt->rt6i_src.plen = 128;
849 }
850#endif
851
David S. Miller14deae42009-01-04 16:04:39 -0800852 retry:
David S. Miller8ade06c2011-12-29 18:51:57 -0500853 if (rt6_bind_neighbour(rt, rt->dst.dev)) {
David S. Millerd1918542011-12-28 20:19:20 -0500854 struct net *net = dev_net(rt->dst.dev);
David S. Miller14deae42009-01-04 16:04:39 -0800855 int saved_rt_min_interval =
856 net->ipv6.sysctl.ip6_rt_gc_min_interval;
857 int saved_rt_elasticity =
858 net->ipv6.sysctl.ip6_rt_gc_elasticity;
859
860 if (attempts-- > 0) {
861 net->ipv6.sysctl.ip6_rt_gc_elasticity = 1;
862 net->ipv6.sysctl.ip6_rt_gc_min_interval = 0;
863
Alexey Dobriyan86393e52009-08-29 01:34:49 +0000864 ip6_dst_gc(&net->ipv6.ip6_dst_ops);
David S. Miller14deae42009-01-04 16:04:39 -0800865
866 net->ipv6.sysctl.ip6_rt_gc_elasticity =
867 saved_rt_elasticity;
868 net->ipv6.sysctl.ip6_rt_gc_min_interval =
869 saved_rt_min_interval;
870 goto retry;
871 }
872
Joe Perchesf3213832012-05-15 14:11:53 +0000873 net_warn_ratelimited("Neighbour table overflow\n");
Changli Gaod8d1f302010-06-10 23:31:35 -0700874 dst_free(&rt->dst);
David S. Miller14deae42009-01-04 16:04:39 -0800875 return NULL;
876 }
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800877 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800879 return rt;
880}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
Eric Dumazet21efcfa2011-07-19 20:18:36 +0000882static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,
883 const struct in6_addr *daddr)
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800884{
Eric Dumazet21efcfa2011-07-19 20:18:36 +0000885 struct rt6_info *rt = ip6_rt_copy(ort, daddr);
886
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800887 if (rt) {
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800888 rt->rt6i_flags |= RTF_CACHE;
David S. Miller97cac082012-07-02 22:43:47 -0700889 rt->n = neigh_clone(ort->n);
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800890 }
891 return rt;
892}
893
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800894static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
David S. Miller4c9483b2011-03-12 16:22:43 -0500895 struct flowi6 *fl6, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896{
897 struct fib6_node *fn;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800898 struct rt6_info *rt, *nrt;
Thomas Grafc71099a2006-08-04 23:20:06 -0700899 int strict = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 int attempts = 3;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800901 int err;
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700902 int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700904 strict |= flags & RT6_LOOKUP_F_IFACE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905
906relookup:
Thomas Grafc71099a2006-08-04 23:20:06 -0700907 read_lock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800909restart_2:
David S. Miller4c9483b2011-03-12 16:22:43 -0500910 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911
912restart:
Pavel Emelyanov4acad722007-10-15 13:02:51 -0700913 rt = rt6_select(fn, oif, strict | reachable);
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000914 if (rt->rt6i_nsiblings && oif == 0)
915 rt = rt6_multipath_select(rt, fl6);
David S. Miller4c9483b2011-03-12 16:22:43 -0500916 BACKTRACK(net, &fl6->saddr);
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800917 if (rt == net->ipv6.ip6_null_entry ||
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800918 rt->rt6i_flags & RTF_CACHE)
YOSHIFUJI Hideaki1ddef0442006-03-20 17:01:24 -0800919 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
Changli Gaod8d1f302010-06-10 23:31:35 -0700921 dst_hold(&rt->dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700922 read_unlock_bh(&table->tb6_lock);
YOSHIFUJI Hideakifb9de912006-03-20 16:59:08 -0800923
David S. Miller97cac082012-07-02 22:43:47 -0700924 if (!rt->n && !(rt->rt6i_flags & RTF_NONEXTHOP))
David S. Miller4c9483b2011-03-12 16:22:43 -0500925 nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);
David S. Miller7343ff32011-03-09 19:55:25 -0800926 else if (!(rt->dst.flags & DST_HOST))
David S. Miller4c9483b2011-03-12 16:22:43 -0500927 nrt = rt6_alloc_clone(rt, &fl6->daddr);
David S. Miller7343ff32011-03-09 19:55:25 -0800928 else
929 goto out2;
YOSHIFUJI Hideakie40cf352006-03-20 16:59:27 -0800930
Amerigo Wang94e187c2012-10-29 00:13:19 +0000931 ip6_rt_put(rt);
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800932 rt = nrt ? : net->ipv6.ip6_null_entry;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800933
Changli Gaod8d1f302010-06-10 23:31:35 -0700934 dst_hold(&rt->dst);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800935 if (nrt) {
Thomas Graf40e22e82006-08-22 00:00:45 -0700936 err = ip6_ins_rt(nrt);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800937 if (!err)
938 goto out2;
939 }
940
941 if (--attempts <= 0)
942 goto out2;
943
944 /*
Thomas Grafc71099a2006-08-04 23:20:06 -0700945 * Race condition! In the gap, when table->tb6_lock was
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800946 * released someone could insert this route. Relookup.
947 */
Amerigo Wang94e187c2012-10-29 00:13:19 +0000948 ip6_rt_put(rt);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800949 goto relookup;
950
951out:
YOSHIFUJI Hideaki8238dd02006-03-20 17:04:35 -0800952 if (reachable) {
953 reachable = 0;
954 goto restart_2;
955 }
Changli Gaod8d1f302010-06-10 23:31:35 -0700956 dst_hold(&rt->dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700957 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958out2:
Changli Gaod8d1f302010-06-10 23:31:35 -0700959 rt->dst.lastuse = jiffies;
960 rt->dst.__use++;
Thomas Grafc71099a2006-08-04 23:20:06 -0700961
962 return rt;
963}
964
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800965static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
David S. Miller4c9483b2011-03-12 16:22:43 -0500966 struct flowi6 *fl6, int flags)
Pavel Emelyanov4acad722007-10-15 13:02:51 -0700967{
David S. Miller4c9483b2011-03-12 16:22:43 -0500968 return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
Pavel Emelyanov4acad722007-10-15 13:02:51 -0700969}
970
Shmulik Ladkani72331bc2012-04-01 04:03:45 +0000971static struct dst_entry *ip6_route_input_lookup(struct net *net,
972 struct net_device *dev,
973 struct flowi6 *fl6, int flags)
974{
975 if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
976 flags |= RT6_LOOKUP_F_IFACE;
977
978 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
979}
980
Thomas Grafc71099a2006-08-04 23:20:06 -0700981void ip6_route_input(struct sk_buff *skb)
982{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000983 const struct ipv6hdr *iph = ipv6_hdr(skb);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900984 struct net *net = dev_net(skb->dev);
Thomas Grafadaa70b2006-10-13 15:01:03 -0700985 int flags = RT6_LOOKUP_F_HAS_SADDR;
David S. Miller4c9483b2011-03-12 16:22:43 -0500986 struct flowi6 fl6 = {
987 .flowi6_iif = skb->dev->ifindex,
988 .daddr = iph->daddr,
989 .saddr = iph->saddr,
YOSHIFUJI Hideaki / 吉藤英明6502ca52013-01-13 05:01:51 +0000990 .flowlabel = ip6_flowinfo(iph),
David S. Miller4c9483b2011-03-12 16:22:43 -0500991 .flowi6_mark = skb->mark,
992 .flowi6_proto = iph->nexthdr,
Thomas Grafc71099a2006-08-04 23:20:06 -0700993 };
Thomas Grafadaa70b2006-10-13 15:01:03 -0700994
Shmulik Ladkani72331bc2012-04-01 04:03:45 +0000995 skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
Thomas Grafc71099a2006-08-04 23:20:06 -0700996}
997
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800998static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
David S. Miller4c9483b2011-03-12 16:22:43 -0500999 struct flowi6 *fl6, int flags)
Thomas Grafc71099a2006-08-04 23:20:06 -07001000{
David S. Miller4c9483b2011-03-12 16:22:43 -05001001 return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
Thomas Grafc71099a2006-08-04 23:20:06 -07001002}
1003
Florian Westphal9c7a4f92011-03-22 19:17:36 -07001004struct dst_entry * ip6_route_output(struct net *net, const struct sock *sk,
David S. Miller4c9483b2011-03-12 16:22:43 -05001005 struct flowi6 *fl6)
Thomas Grafc71099a2006-08-04 23:20:06 -07001006{
1007 int flags = 0;
1008
Pavel Emelyanov1fb94892012-08-08 21:53:36 +00001009 fl6->flowi6_iif = LOOPBACK_IFINDEX;
David McCullough4dc27d1c2012-06-25 15:42:26 +00001010
David S. Miller4c9483b2011-03-12 16:22:43 -05001011 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -07001012 flags |= RT6_LOOKUP_F_IFACE;
Thomas Grafc71099a2006-08-04 23:20:06 -07001013
David S. Miller4c9483b2011-03-12 16:22:43 -05001014 if (!ipv6_addr_any(&fl6->saddr))
Thomas Grafadaa70b2006-10-13 15:01:03 -07001015 flags |= RT6_LOOKUP_F_HAS_SADDR;
YOSHIFUJI Hideaki / 吉藤英明0c9a2ac2010-03-07 00:14:44 +00001016 else if (sk)
1017 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
Thomas Grafadaa70b2006-10-13 15:01:03 -07001018
David S. Miller4c9483b2011-03-12 16:22:43 -05001019 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020}
1021
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +09001022EXPORT_SYMBOL(ip6_route_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023
David S. Miller2774c132011-03-01 14:59:04 -08001024struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
David S. Miller14e50e52007-05-24 18:17:54 -07001025{
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001026 struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
David S. Miller14e50e52007-05-24 18:17:54 -07001027 struct dst_entry *new = NULL;
1028
David S. Millerf5b0a872012-07-19 12:31:33 -07001029 rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
David S. Miller14e50e52007-05-24 18:17:54 -07001030 if (rt) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001031 new = &rt->dst;
David S. Miller14e50e52007-05-24 18:17:54 -07001032
Steffen Klassert81048912012-07-05 23:37:09 +00001033 memset(new + 1, 0, sizeof(*rt) - sizeof(*new));
1034 rt6_init_peer(rt, net->ipv6.peers);
1035
David S. Miller14e50e52007-05-24 18:17:54 -07001036 new->__use = 1;
Herbert Xu352e5122007-11-13 21:34:06 -08001037 new->input = dst_discard;
1038 new->output = dst_discard;
David S. Miller14e50e52007-05-24 18:17:54 -07001039
Eric Dumazet21efcfa2011-07-19 20:18:36 +00001040 if (dst_metrics_read_only(&ort->dst))
1041 new->_metrics = ort->dst._metrics;
1042 else
1043 dst_copy_metrics(new, &ort->dst);
David S. Miller14e50e52007-05-24 18:17:54 -07001044 rt->rt6i_idev = ort->rt6i_idev;
1045 if (rt->rt6i_idev)
1046 in6_dev_hold(rt->rt6i_idev);
David S. Miller14e50e52007-05-24 18:17:54 -07001047
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001048 rt->rt6i_gateway = ort->rt6i_gateway;
Gao feng1716a962012-04-06 00:13:10 +00001049 rt->rt6i_flags = ort->rt6i_flags;
1050 rt6_clean_expires(rt);
David S. Miller14e50e52007-05-24 18:17:54 -07001051 rt->rt6i_metric = 0;
1052
1053 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1054#ifdef CONFIG_IPV6_SUBTREES
1055 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1056#endif
1057
1058 dst_free(new);
1059 }
1060
David S. Miller69ead7a2011-03-01 14:45:33 -08001061 dst_release(dst_orig);
1062 return new ? new : ERR_PTR(-ENOMEM);
David S. Miller14e50e52007-05-24 18:17:54 -07001063}
David S. Miller14e50e52007-05-24 18:17:54 -07001064
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065/*
1066 * Destination cache support functions
1067 */
1068
1069static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1070{
1071 struct rt6_info *rt;
1072
1073 rt = (struct rt6_info *) dst;
1074
Nicolas Dichtel6f3118b2012-09-10 22:09:46 +00001075 /* All IPV6 dsts are created with ->obsolete set to the value
1076 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1077 * into this function always.
1078 */
1079 if (rt->rt6i_genid != rt_genid(dev_net(rt->dst.dev)))
1080 return NULL;
1081
Li RongQinga4477c42012-11-07 21:56:33 +00001082 if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 return dst;
Li RongQinga4477c42012-11-07 21:56:33 +00001084
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 return NULL;
1086}
1087
1088static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1089{
1090 struct rt6_info *rt = (struct rt6_info *) dst;
1091
1092 if (rt) {
YOSHIFUJI Hideaki / 吉藤英明54c1a852010-03-28 07:15:45 +00001093 if (rt->rt6i_flags & RTF_CACHE) {
1094 if (rt6_check_expired(rt)) {
1095 ip6_del_rt(rt);
1096 dst = NULL;
1097 }
1098 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 dst_release(dst);
YOSHIFUJI Hideaki / 吉藤英明54c1a852010-03-28 07:15:45 +00001100 dst = NULL;
1101 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 }
YOSHIFUJI Hideaki / 吉藤英明54c1a852010-03-28 07:15:45 +00001103 return dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104}
1105
1106static void ip6_link_failure(struct sk_buff *skb)
1107{
1108 struct rt6_info *rt;
1109
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +00001110 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111
Eric Dumazetadf30902009-06-02 05:19:30 +00001112 rt = (struct rt6_info *) skb_dst(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 if (rt) {
Gao feng1716a962012-04-06 00:13:10 +00001114 if (rt->rt6i_flags & RTF_CACHE)
1115 rt6_update_expires(rt, 0);
1116 else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 rt->rt6i_node->fn_sernum = -1;
1118 }
1119}
1120
David S. Miller6700c272012-07-17 03:29:28 -07001121static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1122 struct sk_buff *skb, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123{
1124 struct rt6_info *rt6 = (struct rt6_info*)dst;
1125
David S. Miller81aded22012-06-15 14:54:11 -07001126 dst_confirm(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
David S. Miller81aded22012-06-15 14:54:11 -07001128 struct net *net = dev_net(dst->dev);
1129
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 rt6->rt6i_flags |= RTF_MODIFIED;
1131 if (mtu < IPV6_MIN_MTU) {
David S. Millerdefb3512010-12-08 21:16:57 -08001132 u32 features = dst_metric(dst, RTAX_FEATURES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 mtu = IPV6_MIN_MTU;
David S. Millerdefb3512010-12-08 21:16:57 -08001134 features |= RTAX_FEATURE_ALLFRAG;
1135 dst_metric_set(dst, RTAX_FEATURES, features);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 }
David S. Millerdefb3512010-12-08 21:16:57 -08001137 dst_metric_set(dst, RTAX_MTU, mtu);
David S. Miller81aded22012-06-15 14:54:11 -07001138 rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 }
1140}
1141
David S. Miller42ae66c2012-06-15 20:01:57 -07001142void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1143 int oif, u32 mark)
David S. Miller81aded22012-06-15 14:54:11 -07001144{
1145 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1146 struct dst_entry *dst;
1147 struct flowi6 fl6;
1148
1149 memset(&fl6, 0, sizeof(fl6));
1150 fl6.flowi6_oif = oif;
1151 fl6.flowi6_mark = mark;
David S. Miller3e129392012-07-10 04:01:57 -07001152 fl6.flowi6_flags = 0;
David S. Miller81aded22012-06-15 14:54:11 -07001153 fl6.daddr = iph->daddr;
1154 fl6.saddr = iph->saddr;
YOSHIFUJI Hideaki / 吉藤英明6502ca52013-01-13 05:01:51 +00001155 fl6.flowlabel = ip6_flowinfo(iph);
David S. Miller81aded22012-06-15 14:54:11 -07001156
1157 dst = ip6_route_output(net, NULL, &fl6);
1158 if (!dst->error)
David S. Miller6700c272012-07-17 03:29:28 -07001159 ip6_rt_update_pmtu(dst, NULL, skb, ntohl(mtu));
David S. Miller81aded22012-06-15 14:54:11 -07001160 dst_release(dst);
1161}
1162EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1163
1164void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1165{
1166 ip6_update_pmtu(skb, sock_net(sk), mtu,
1167 sk->sk_bound_dev_if, sk->sk_mark);
1168}
1169EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1170
David S. Miller3a5ad2e2012-07-12 00:08:07 -07001171void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1172{
1173 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1174 struct dst_entry *dst;
1175 struct flowi6 fl6;
1176
1177 memset(&fl6, 0, sizeof(fl6));
1178 fl6.flowi6_oif = oif;
1179 fl6.flowi6_mark = mark;
1180 fl6.flowi6_flags = 0;
1181 fl6.daddr = iph->daddr;
1182 fl6.saddr = iph->saddr;
YOSHIFUJI Hideaki / 吉藤英明6502ca52013-01-13 05:01:51 +00001183 fl6.flowlabel = ip6_flowinfo(iph);
David S. Miller3a5ad2e2012-07-12 00:08:07 -07001184
1185 dst = ip6_route_output(net, NULL, &fl6);
1186 if (!dst->error)
David S. Miller6700c272012-07-17 03:29:28 -07001187 rt6_do_redirect(dst, NULL, skb);
David S. Miller3a5ad2e2012-07-12 00:08:07 -07001188 dst_release(dst);
1189}
1190EXPORT_SYMBOL_GPL(ip6_redirect);
1191
1192void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1193{
1194 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1195}
1196EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1197
David S. Miller0dbaee32010-12-13 12:52:14 -08001198static unsigned int ip6_default_advmss(const struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199{
David S. Miller0dbaee32010-12-13 12:52:14 -08001200 struct net_device *dev = dst->dev;
1201 unsigned int mtu = dst_mtu(dst);
1202 struct net *net = dev_net(dev);
1203
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1205
Daniel Lezcano55786892008-03-04 13:47:47 -08001206 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1207 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208
1209 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001210 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1211 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1212 * IPV6_MAXPLEN is also valid and means: "any MSS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 * rely only on pmtu discovery"
1214 */
1215 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1216 mtu = IPV6_MAXPLEN;
1217 return mtu;
1218}
1219
Steffen Klassertebb762f2011-11-23 02:12:51 +00001220static unsigned int ip6_mtu(const struct dst_entry *dst)
David S. Millerd33e4552010-12-14 13:01:14 -08001221{
David S. Millerd33e4552010-12-14 13:01:14 -08001222 struct inet6_dev *idev;
Steffen Klassert618f9bc2011-11-23 02:13:31 +00001223 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
1224
1225 if (mtu)
1226 return mtu;
1227
1228 mtu = IPV6_MIN_MTU;
David S. Millerd33e4552010-12-14 13:01:14 -08001229
1230 rcu_read_lock();
1231 idev = __in6_dev_get(dst->dev);
1232 if (idev)
1233 mtu = idev->cnf.mtu6;
1234 rcu_read_unlock();
1235
1236 return mtu;
1237}
1238
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001239static struct dst_entry *icmp6_dst_gc_list;
1240static DEFINE_SPINLOCK(icmp6_dst_lock);
Thomas Graf5d0bbee2006-08-04 03:37:36 -07001241
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001242struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 struct neighbour *neigh,
David S. Miller87a11572011-12-06 17:04:13 -05001244 struct flowi6 *fl6)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245{
David S. Miller87a11572011-12-06 17:04:13 -05001246 struct dst_entry *dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 struct rt6_info *rt;
1248 struct inet6_dev *idev = in6_dev_get(dev);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001249 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250
David S. Miller38308472011-12-03 18:02:47 -05001251 if (unlikely(!idev))
Eric Dumazet122bdf62012-03-14 21:13:11 +00001252 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253
David S. Miller8b96d222012-06-11 02:01:56 -07001254 rt = ip6_dst_alloc(net, dev, 0, NULL);
David S. Miller38308472011-12-03 18:02:47 -05001255 if (unlikely(!rt)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 in6_dev_put(idev);
David S. Miller87a11572011-12-06 17:04:13 -05001257 dst = ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 goto out;
1259 }
1260
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 if (neigh)
1262 neigh_hold(neigh);
David S. Miller14deae42009-01-04 16:04:39 -08001263 else {
David S. Millerf894cbf2012-07-02 21:52:24 -07001264 neigh = ip6_neigh_lookup(&rt->dst, NULL, &fl6->daddr);
David S. Millerb43faac2011-12-13 16:48:21 -05001265 if (IS_ERR(neigh)) {
RongQing.Li252c3d82012-01-12 22:33:46 +00001266 in6_dev_put(idev);
David S. Millerb43faac2011-12-13 16:48:21 -05001267 dst_free(&rt->dst);
1268 return ERR_CAST(neigh);
1269 }
David S. Miller14deae42009-01-04 16:04:39 -08001270 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
Yan, Zheng8e2ec632011-09-05 21:34:30 +00001272 rt->dst.flags |= DST_HOST;
1273 rt->dst.output = ip6_output;
David S. Miller97cac082012-07-02 22:43:47 -07001274 rt->n = neigh;
Changli Gaod8d1f302010-06-10 23:31:35 -07001275 atomic_set(&rt->dst.__refcnt, 1);
David S. Miller87a11572011-12-06 17:04:13 -05001276 rt->rt6i_dst.addr = fl6->daddr;
Yan, Zheng8e2ec632011-09-05 21:34:30 +00001277 rt->rt6i_dst.plen = 128;
1278 rt->rt6i_idev = idev;
Li RongQing14edd872012-10-24 14:01:18 +08001279 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001281 spin_lock_bh(&icmp6_dst_lock);
Changli Gaod8d1f302010-06-10 23:31:35 -07001282 rt->dst.next = icmp6_dst_gc_list;
1283 icmp6_dst_gc_list = &rt->dst;
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001284 spin_unlock_bh(&icmp6_dst_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
Daniel Lezcano55786892008-03-04 13:47:47 -08001286 fib6_force_start_gc(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287
David S. Miller87a11572011-12-06 17:04:13 -05001288 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1289
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290out:
David S. Miller87a11572011-12-06 17:04:13 -05001291 return dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292}
1293
Stephen Hemminger3d0f24a2008-07-22 14:35:50 -07001294int icmp6_dst_gc(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295{
Hagen Paul Pfeifere9476e92011-02-25 05:45:19 +00001296 struct dst_entry *dst, **pprev;
Stephen Hemminger3d0f24a2008-07-22 14:35:50 -07001297 int more = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001299 spin_lock_bh(&icmp6_dst_lock);
1300 pprev = &icmp6_dst_gc_list;
Thomas Graf5d0bbee2006-08-04 03:37:36 -07001301
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 while ((dst = *pprev) != NULL) {
1303 if (!atomic_read(&dst->__refcnt)) {
1304 *pprev = dst->next;
1305 dst_free(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 } else {
1307 pprev = &dst->next;
Stephen Hemminger3d0f24a2008-07-22 14:35:50 -07001308 ++more;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 }
1310 }
1311
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001312 spin_unlock_bh(&icmp6_dst_lock);
Thomas Graf5d0bbee2006-08-04 03:37:36 -07001313
Stephen Hemminger3d0f24a2008-07-22 14:35:50 -07001314 return more;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315}
1316
David S. Miller1e493d12008-09-10 17:27:15 -07001317static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1318 void *arg)
1319{
1320 struct dst_entry *dst, **pprev;
1321
1322 spin_lock_bh(&icmp6_dst_lock);
1323 pprev = &icmp6_dst_gc_list;
1324 while ((dst = *pprev) != NULL) {
1325 struct rt6_info *rt = (struct rt6_info *) dst;
1326 if (func(rt, arg)) {
1327 *pprev = dst->next;
1328 dst_free(dst);
1329 } else {
1330 pprev = &dst->next;
1331 }
1332 }
1333 spin_unlock_bh(&icmp6_dst_lock);
1334}
1335
Daniel Lezcano569d3642008-01-18 03:56:57 -08001336static int ip6_dst_gc(struct dst_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 unsigned long now = jiffies;
Alexey Dobriyan86393e52009-08-29 01:34:49 +00001339 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
Daniel Lezcano7019b782008-03-04 13:50:14 -08001340 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1341 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1342 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1343 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1344 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
Eric Dumazetfc66f952010-10-08 06:37:34 +00001345 int entries;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Eric Dumazetfc66f952010-10-08 06:37:34 +00001347 entries = dst_entries_get_fast(ops);
Daniel Lezcano7019b782008-03-04 13:50:14 -08001348 if (time_after(rt_last_gc + rt_min_interval, now) &&
Eric Dumazetfc66f952010-10-08 06:37:34 +00001349 entries <= rt_max_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 goto out;
1351
Benjamin Thery6891a342008-03-04 13:49:47 -08001352 net->ipv6.ip6_rt_gc_expire++;
1353 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net);
1354 net->ipv6.ip6_rt_last_gc = now;
Eric Dumazetfc66f952010-10-08 06:37:34 +00001355 entries = dst_entries_get_slow(ops);
1356 if (entries < ops->gc_thresh)
Daniel Lezcano7019b782008-03-04 13:50:14 -08001357 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358out:
Daniel Lezcano7019b782008-03-04 13:50:14 -08001359 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
Eric Dumazetfc66f952010-10-08 06:37:34 +00001360 return entries > rt_max_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361}
1362
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -04001363int ip6_dst_hoplimit(struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364{
David S. Miller5170ae82010-12-12 21:35:57 -08001365 int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);
David S. Millera02e4b72010-12-12 21:39:02 -08001366 if (hoplimit == 0) {
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -04001367 struct net_device *dev = dst->dev;
Eric Dumazetc68f24c2010-06-14 04:46:20 +00001368 struct inet6_dev *idev;
1369
1370 rcu_read_lock();
1371 idev = __in6_dev_get(dev);
1372 if (idev)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -04001373 hoplimit = idev->cnf.hop_limit;
Eric Dumazetc68f24c2010-06-14 04:46:20 +00001374 else
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -07001375 hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;
Eric Dumazetc68f24c2010-06-14 04:46:20 +00001376 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 }
1378 return hoplimit;
1379}
David S. Millerabbf46a2010-12-12 21:14:46 -08001380EXPORT_SYMBOL(ip6_dst_hoplimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381
1382/*
1383 *
1384 */
1385
Thomas Graf86872cb2006-08-22 00:01:08 -07001386int ip6_route_add(struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387{
1388 int err;
Daniel Lezcano55786892008-03-04 13:47:47 -08001389 struct net *net = cfg->fc_nlinfo.nl_net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 struct rt6_info *rt = NULL;
1391 struct net_device *dev = NULL;
1392 struct inet6_dev *idev = NULL;
Thomas Grafc71099a2006-08-04 23:20:06 -07001393 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 int addr_type;
1395
Thomas Graf86872cb2006-08-22 00:01:08 -07001396 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 return -EINVAL;
1398#ifndef CONFIG_IPV6_SUBTREES
Thomas Graf86872cb2006-08-22 00:01:08 -07001399 if (cfg->fc_src_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 return -EINVAL;
1401#endif
Thomas Graf86872cb2006-08-22 00:01:08 -07001402 if (cfg->fc_ifindex) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 err = -ENODEV;
Daniel Lezcano55786892008-03-04 13:47:47 -08001404 dev = dev_get_by_index(net, cfg->fc_ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 if (!dev)
1406 goto out;
1407 idev = in6_dev_get(dev);
1408 if (!idev)
1409 goto out;
1410 }
1411
Thomas Graf86872cb2006-08-22 00:01:08 -07001412 if (cfg->fc_metric == 0)
1413 cfg->fc_metric = IP6_RT_PRIO_USER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414
Matti Vaittinend71314b2011-11-14 00:14:49 +00001415 err = -ENOBUFS;
David S. Miller38308472011-12-03 18:02:47 -05001416 if (cfg->fc_nlinfo.nlh &&
1417 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
Matti Vaittinend71314b2011-11-14 00:14:49 +00001418 table = fib6_get_table(net, cfg->fc_table);
David S. Miller38308472011-12-03 18:02:47 -05001419 if (!table) {
Joe Perchesf3213832012-05-15 14:11:53 +00001420 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
Matti Vaittinend71314b2011-11-14 00:14:49 +00001421 table = fib6_new_table(net, cfg->fc_table);
1422 }
1423 } else {
1424 table = fib6_new_table(net, cfg->fc_table);
1425 }
David S. Miller38308472011-12-03 18:02:47 -05001426
1427 if (!table)
Thomas Grafc71099a2006-08-04 23:20:06 -07001428 goto out;
Thomas Grafc71099a2006-08-04 23:20:06 -07001429
David S. Miller8b96d222012-06-11 02:01:56 -07001430 rt = ip6_dst_alloc(net, NULL, DST_NOCOUNT, table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
David S. Miller38308472011-12-03 18:02:47 -05001432 if (!rt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 err = -ENOMEM;
1434 goto out;
1435 }
1436
Gao feng1716a962012-04-06 00:13:10 +00001437 if (cfg->fc_flags & RTF_EXPIRES)
1438 rt6_set_expires(rt, jiffies +
1439 clock_t_to_jiffies(cfg->fc_expires));
1440 else
1441 rt6_clean_expires(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442
Thomas Graf86872cb2006-08-22 00:01:08 -07001443 if (cfg->fc_protocol == RTPROT_UNSPEC)
1444 cfg->fc_protocol = RTPROT_BOOT;
1445 rt->rt6i_protocol = cfg->fc_protocol;
1446
1447 addr_type = ipv6_addr_type(&cfg->fc_dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448
1449 if (addr_type & IPV6_ADDR_MULTICAST)
Changli Gaod8d1f302010-06-10 23:31:35 -07001450 rt->dst.input = ip6_mc_input;
Maciej Żenczykowskiab79ad12010-09-27 00:07:02 +00001451 else if (cfg->fc_flags & RTF_LOCAL)
1452 rt->dst.input = ip6_input;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 else
Changli Gaod8d1f302010-06-10 23:31:35 -07001454 rt->dst.input = ip6_forward;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455
Changli Gaod8d1f302010-06-10 23:31:35 -07001456 rt->dst.output = ip6_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457
Thomas Graf86872cb2006-08-22 00:01:08 -07001458 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1459 rt->rt6i_dst.plen = cfg->fc_dst_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 if (rt->rt6i_dst.plen == 128)
David S. Miller11d53b42011-06-24 15:23:34 -07001461 rt->dst.flags |= DST_HOST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462
Yan, Zheng8e2ec632011-09-05 21:34:30 +00001463 if (!(rt->dst.flags & DST_HOST) && cfg->fc_mx) {
1464 u32 *metrics = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1465 if (!metrics) {
1466 err = -ENOMEM;
1467 goto out;
1468 }
1469 dst_init_metrics(&rt->dst, metrics, 0);
1470 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471#ifdef CONFIG_IPV6_SUBTREES
Thomas Graf86872cb2006-08-22 00:01:08 -07001472 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1473 rt->rt6i_src.plen = cfg->fc_src_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474#endif
1475
Thomas Graf86872cb2006-08-22 00:01:08 -07001476 rt->rt6i_metric = cfg->fc_metric;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477
1478 /* We cannot add true routes via loopback here,
1479 they would result in kernel looping; promote them to reject routes
1480 */
Thomas Graf86872cb2006-08-22 00:01:08 -07001481 if ((cfg->fc_flags & RTF_REJECT) ||
David S. Miller38308472011-12-03 18:02:47 -05001482 (dev && (dev->flags & IFF_LOOPBACK) &&
1483 !(addr_type & IPV6_ADDR_LOOPBACK) &&
1484 !(cfg->fc_flags & RTF_LOCAL))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 /* hold loopback dev/idev if we haven't done so. */
Daniel Lezcano55786892008-03-04 13:47:47 -08001486 if (dev != net->loopback_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 if (dev) {
1488 dev_put(dev);
1489 in6_dev_put(idev);
1490 }
Daniel Lezcano55786892008-03-04 13:47:47 -08001491 dev = net->loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 dev_hold(dev);
1493 idev = in6_dev_get(dev);
1494 if (!idev) {
1495 err = -ENODEV;
1496 goto out;
1497 }
1498 }
Changli Gaod8d1f302010-06-10 23:31:35 -07001499 rt->dst.output = ip6_pkt_discard_out;
1500 rt->dst.input = ip6_pkt_discard;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00001502 switch (cfg->fc_type) {
1503 case RTN_BLACKHOLE:
1504 rt->dst.error = -EINVAL;
1505 break;
1506 case RTN_PROHIBIT:
1507 rt->dst.error = -EACCES;
1508 break;
Nicolas Dichtelb4949ab2012-09-06 05:53:35 +00001509 case RTN_THROW:
1510 rt->dst.error = -EAGAIN;
1511 break;
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00001512 default:
1513 rt->dst.error = -ENETUNREACH;
1514 break;
1515 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 goto install_route;
1517 }
1518
Thomas Graf86872cb2006-08-22 00:01:08 -07001519 if (cfg->fc_flags & RTF_GATEWAY) {
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001520 const struct in6_addr *gw_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 int gwa_type;
1522
Thomas Graf86872cb2006-08-22 00:01:08 -07001523 gw_addr = &cfg->fc_gateway;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001524 rt->rt6i_gateway = *gw_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 gwa_type = ipv6_addr_type(gw_addr);
1526
1527 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1528 struct rt6_info *grt;
1529
1530 /* IPv6 strictly inhibits using not link-local
1531 addresses as nexthop address.
1532 Otherwise, router will not able to send redirects.
1533 It is very good, but in some (rare!) circumstances
1534 (SIT, PtP, NBMA NOARP links) it is handy to allow
1535 some exceptions. --ANK
1536 */
1537 err = -EINVAL;
David S. Miller38308472011-12-03 18:02:47 -05001538 if (!(gwa_type & IPV6_ADDR_UNICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 goto out;
1540
Daniel Lezcano55786892008-03-04 13:47:47 -08001541 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542
1543 err = -EHOSTUNREACH;
David S. Miller38308472011-12-03 18:02:47 -05001544 if (!grt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 goto out;
1546 if (dev) {
David S. Millerd1918542011-12-28 20:19:20 -05001547 if (dev != grt->dst.dev) {
Amerigo Wang94e187c2012-10-29 00:13:19 +00001548 ip6_rt_put(grt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 goto out;
1550 }
1551 } else {
David S. Millerd1918542011-12-28 20:19:20 -05001552 dev = grt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 idev = grt->rt6i_idev;
1554 dev_hold(dev);
1555 in6_dev_hold(grt->rt6i_idev);
1556 }
David S. Miller38308472011-12-03 18:02:47 -05001557 if (!(grt->rt6i_flags & RTF_GATEWAY))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 err = 0;
Amerigo Wang94e187c2012-10-29 00:13:19 +00001559 ip6_rt_put(grt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560
1561 if (err)
1562 goto out;
1563 }
1564 err = -EINVAL;
David S. Miller38308472011-12-03 18:02:47 -05001565 if (!dev || (dev->flags & IFF_LOOPBACK))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 goto out;
1567 }
1568
1569 err = -ENODEV;
David S. Miller38308472011-12-03 18:02:47 -05001570 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 goto out;
1572
Daniel Walterc3968a82011-04-13 21:10:57 +00001573 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1574 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1575 err = -EINVAL;
1576 goto out;
1577 }
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001578 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
Daniel Walterc3968a82011-04-13 21:10:57 +00001579 rt->rt6i_prefsrc.plen = 128;
1580 } else
1581 rt->rt6i_prefsrc.plen = 0;
1582
Thomas Graf86872cb2006-08-22 00:01:08 -07001583 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
David S. Miller8ade06c2011-12-29 18:51:57 -05001584 err = rt6_bind_neighbour(rt, dev);
David S. Millerf83c7792011-12-28 15:41:23 -05001585 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 }
1588
Thomas Graf86872cb2006-08-22 00:01:08 -07001589 rt->rt6i_flags = cfg->fc_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590
1591install_route:
Thomas Graf86872cb2006-08-22 00:01:08 -07001592 if (cfg->fc_mx) {
1593 struct nlattr *nla;
1594 int remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
Thomas Graf86872cb2006-08-22 00:01:08 -07001596 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
Thomas Graf8f4c1f92007-09-12 14:44:36 +02001597 int type = nla_type(nla);
Thomas Graf86872cb2006-08-22 00:01:08 -07001598
1599 if (type) {
1600 if (type > RTAX_MAX) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 err = -EINVAL;
1602 goto out;
1603 }
Thomas Graf86872cb2006-08-22 00:01:08 -07001604
David S. Millerdefb3512010-12-08 21:16:57 -08001605 dst_metric_set(&rt->dst, type, nla_get_u32(nla));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 }
1608 }
1609
Changli Gaod8d1f302010-06-10 23:31:35 -07001610 rt->dst.dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 rt->rt6i_idev = idev;
Thomas Grafc71099a2006-08-04 23:20:06 -07001612 rt->rt6i_table = table;
Daniel Lezcano63152fc2008-03-03 23:31:11 -08001613
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001614 cfg->fc_nlinfo.nl_net = dev_net(dev);
Daniel Lezcano63152fc2008-03-03 23:31:11 -08001615
Thomas Graf86872cb2006-08-22 00:01:08 -07001616 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617
1618out:
1619 if (dev)
1620 dev_put(dev);
1621 if (idev)
1622 in6_dev_put(idev);
1623 if (rt)
Changli Gaod8d1f302010-06-10 23:31:35 -07001624 dst_free(&rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 return err;
1626}
1627
Thomas Graf86872cb2006-08-22 00:01:08 -07001628static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629{
1630 int err;
Thomas Grafc71099a2006-08-04 23:20:06 -07001631 struct fib6_table *table;
David S. Millerd1918542011-12-28 20:19:20 -05001632 struct net *net = dev_net(rt->dst.dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633
Gao feng6825a262012-09-19 19:25:34 +00001634 if (rt == net->ipv6.ip6_null_entry) {
1635 err = -ENOENT;
1636 goto out;
1637 }
Patrick McHardy6c813a72006-08-06 22:22:47 -07001638
Thomas Grafc71099a2006-08-04 23:20:06 -07001639 table = rt->rt6i_table;
1640 write_lock_bh(&table->tb6_lock);
Thomas Graf86872cb2006-08-22 00:01:08 -07001641 err = fib6_del(rt, info);
Thomas Grafc71099a2006-08-04 23:20:06 -07001642 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643
Gao feng6825a262012-09-19 19:25:34 +00001644out:
Amerigo Wang94e187c2012-10-29 00:13:19 +00001645 ip6_rt_put(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 return err;
1647}
1648
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001649int ip6_del_rt(struct rt6_info *rt)
1650{
Denis V. Lunev4d1169c2008-01-10 03:26:13 -08001651 struct nl_info info = {
David S. Millerd1918542011-12-28 20:19:20 -05001652 .nl_net = dev_net(rt->dst.dev),
Denis V. Lunev4d1169c2008-01-10 03:26:13 -08001653 };
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08001654 return __ip6_del_rt(rt, &info);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001655}
1656
Thomas Graf86872cb2006-08-22 00:01:08 -07001657static int ip6_route_del(struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658{
Thomas Grafc71099a2006-08-04 23:20:06 -07001659 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 struct fib6_node *fn;
1661 struct rt6_info *rt;
1662 int err = -ESRCH;
1663
Daniel Lezcano55786892008-03-04 13:47:47 -08001664 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
David S. Miller38308472011-12-03 18:02:47 -05001665 if (!table)
Thomas Grafc71099a2006-08-04 23:20:06 -07001666 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667
Thomas Grafc71099a2006-08-04 23:20:06 -07001668 read_lock_bh(&table->tb6_lock);
1669
1670 fn = fib6_locate(&table->tb6_root,
Thomas Graf86872cb2006-08-22 00:01:08 -07001671 &cfg->fc_dst, cfg->fc_dst_len,
1672 &cfg->fc_src, cfg->fc_src_len);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001673
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 if (fn) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001675 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
Thomas Graf86872cb2006-08-22 00:01:08 -07001676 if (cfg->fc_ifindex &&
David S. Millerd1918542011-12-28 20:19:20 -05001677 (!rt->dst.dev ||
1678 rt->dst.dev->ifindex != cfg->fc_ifindex))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 continue;
Thomas Graf86872cb2006-08-22 00:01:08 -07001680 if (cfg->fc_flags & RTF_GATEWAY &&
1681 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 continue;
Thomas Graf86872cb2006-08-22 00:01:08 -07001683 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 continue;
Changli Gaod8d1f302010-06-10 23:31:35 -07001685 dst_hold(&rt->dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001686 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687
Thomas Graf86872cb2006-08-22 00:01:08 -07001688 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 }
1690 }
Thomas Grafc71099a2006-08-04 23:20:06 -07001691 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692
1693 return err;
1694}
1695
David S. Miller6700c272012-07-17 03:29:28 -07001696static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001697{
David S. Millere8599ff2012-07-11 23:43:53 -07001698 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001699 struct netevent_redirect netevent;
David S. Millere8599ff2012-07-11 23:43:53 -07001700 struct rt6_info *rt, *nrt = NULL;
David S. Millere8599ff2012-07-11 23:43:53 -07001701 struct ndisc_options ndopts;
David S. Miller6e157b62012-07-12 00:05:02 -07001702 struct neighbour *old_neigh;
David S. Millere8599ff2012-07-11 23:43:53 -07001703 struct inet6_dev *in6_dev;
1704 struct neighbour *neigh;
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001705 struct rd_msg *msg;
David S. Miller6e157b62012-07-12 00:05:02 -07001706 int optlen, on_link;
1707 u8 *lladdr;
David S. Millere8599ff2012-07-11 23:43:53 -07001708
1709 optlen = skb->tail - skb->transport_header;
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001710 optlen -= sizeof(*msg);
David S. Millere8599ff2012-07-11 23:43:53 -07001711
1712 if (optlen < 0) {
David S. Miller6e157b62012-07-12 00:05:02 -07001713 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
David S. Millere8599ff2012-07-11 23:43:53 -07001714 return;
1715 }
1716
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001717 msg = (struct rd_msg *)icmp6_hdr(skb);
David S. Millere8599ff2012-07-11 23:43:53 -07001718
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001719 if (ipv6_addr_is_multicast(&msg->dest)) {
David S. Miller6e157b62012-07-12 00:05:02 -07001720 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
David S. Millere8599ff2012-07-11 23:43:53 -07001721 return;
1722 }
1723
David S. Miller6e157b62012-07-12 00:05:02 -07001724 on_link = 0;
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001725 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
David S. Millere8599ff2012-07-11 23:43:53 -07001726 on_link = 1;
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001727 } else if (ipv6_addr_type(&msg->target) !=
David S. Millere8599ff2012-07-11 23:43:53 -07001728 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
David S. Miller6e157b62012-07-12 00:05:02 -07001729 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
David S. Millere8599ff2012-07-11 23:43:53 -07001730 return;
1731 }
1732
1733 in6_dev = __in6_dev_get(skb->dev);
1734 if (!in6_dev)
1735 return;
1736 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1737 return;
1738
1739 /* RFC2461 8.1:
1740 * The IP source address of the Redirect MUST be the same as the current
1741 * first-hop router for the specified ICMP Destination Address.
1742 */
1743
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001744 if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
David S. Millere8599ff2012-07-11 23:43:53 -07001745 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1746 return;
1747 }
David S. Miller6e157b62012-07-12 00:05:02 -07001748
1749 lladdr = NULL;
David S. Millere8599ff2012-07-11 23:43:53 -07001750 if (ndopts.nd_opts_tgt_lladdr) {
1751 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1752 skb->dev);
1753 if (!lladdr) {
1754 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1755 return;
1756 }
1757 }
1758
David S. Miller6e157b62012-07-12 00:05:02 -07001759 rt = (struct rt6_info *) dst;
1760 if (rt == net->ipv6.ip6_null_entry) {
1761 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
1762 return;
1763 }
1764
1765 /* Redirect received -> path was valid.
1766 * Look, redirects are sent only in response to data packets,
1767 * so that this nexthop apparently is reachable. --ANK
1768 */
1769 dst_confirm(&rt->dst);
1770
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001771 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
David S. Millere8599ff2012-07-11 23:43:53 -07001772 if (!neigh)
1773 return;
1774
David S. Miller6e157b62012-07-12 00:05:02 -07001775 /* Duplicate redirect: silently ignore. */
1776 old_neigh = rt->n;
1777 if (neigh == old_neigh)
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001778 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 /*
1781 * We have finally decided to accept it.
1782 */
1783
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001784 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1786 NEIGH_UPDATE_F_OVERRIDE|
1787 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1788 NEIGH_UPDATE_F_ISROUTER))
1789 );
1790
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001791 nrt = ip6_rt_copy(rt, &msg->dest);
David S. Miller38308472011-12-03 18:02:47 -05001792 if (!nrt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 goto out;
1794
1795 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1796 if (on_link)
1797 nrt->rt6i_flags &= ~RTF_GATEWAY;
1798
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001799 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
David S. Miller97cac082012-07-02 22:43:47 -07001800 nrt->n = neigh_clone(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801
Thomas Graf40e22e82006-08-22 00:00:45 -07001802 if (ip6_ins_rt(nrt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 goto out;
1804
Changli Gaod8d1f302010-06-10 23:31:35 -07001805 netevent.old = &rt->dst;
1806 netevent.new = &nrt->dst;
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001807 netevent.daddr = &msg->dest;
YOSHIFUJI Hideaki / 吉藤英明60592832013-01-14 09:28:27 +00001808 netevent.neigh = neigh;
Tom Tucker8d717402006-07-30 20:43:36 -07001809 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1810
David S. Miller38308472011-12-03 18:02:47 -05001811 if (rt->rt6i_flags & RTF_CACHE) {
David S. Miller6e157b62012-07-12 00:05:02 -07001812 rt = (struct rt6_info *) dst_clone(&rt->dst);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001813 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 }
1815
1816out:
David S. Millere8599ff2012-07-11 23:43:53 -07001817 neigh_release(neigh);
David S. Miller6e157b62012-07-12 00:05:02 -07001818}
1819
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 * Misc support functions
1822 */
1823
Gao feng1716a962012-04-06 00:13:10 +00001824static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
Eric Dumazet21efcfa2011-07-19 20:18:36 +00001825 const struct in6_addr *dest)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826{
David S. Millerd1918542011-12-28 20:19:20 -05001827 struct net *net = dev_net(ort->dst.dev);
David S. Miller8b96d222012-06-11 02:01:56 -07001828 struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1829 ort->rt6i_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830
1831 if (rt) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001832 rt->dst.input = ort->dst.input;
1833 rt->dst.output = ort->dst.output;
Yan, Zheng8e2ec632011-09-05 21:34:30 +00001834 rt->dst.flags |= DST_HOST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001836 rt->rt6i_dst.addr = *dest;
Yan, Zheng8e2ec632011-09-05 21:34:30 +00001837 rt->rt6i_dst.plen = 128;
David S. Millerdefb3512010-12-08 21:16:57 -08001838 dst_copy_metrics(&rt->dst, &ort->dst);
Changli Gaod8d1f302010-06-10 23:31:35 -07001839 rt->dst.error = ort->dst.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 rt->rt6i_idev = ort->rt6i_idev;
1841 if (rt->rt6i_idev)
1842 in6_dev_hold(rt->rt6i_idev);
Changli Gaod8d1f302010-06-10 23:31:35 -07001843 rt->dst.lastuse = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001845 rt->rt6i_gateway = ort->rt6i_gateway;
Gao feng1716a962012-04-06 00:13:10 +00001846 rt->rt6i_flags = ort->rt6i_flags;
1847 if ((ort->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) ==
1848 (RTF_DEFAULT | RTF_ADDRCONF))
1849 rt6_set_from(rt, ort);
1850 else
1851 rt6_clean_expires(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 rt->rt6i_metric = 0;
1853
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854#ifdef CONFIG_IPV6_SUBTREES
1855 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1856#endif
Florian Westphal0f6c6392011-05-20 11:27:24 +00001857 memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
Thomas Grafc71099a2006-08-04 23:20:06 -07001858 rt->rt6i_table = ort->rt6i_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 }
1860 return rt;
1861}
1862
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001863#ifdef CONFIG_IPV6_ROUTE_INFO
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08001864static struct rt6_info *rt6_get_route_info(struct net *net,
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001865 const struct in6_addr *prefix, int prefixlen,
1866 const struct in6_addr *gwaddr, int ifindex)
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001867{
1868 struct fib6_node *fn;
1869 struct rt6_info *rt = NULL;
Thomas Grafc71099a2006-08-04 23:20:06 -07001870 struct fib6_table *table;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001871
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08001872 table = fib6_get_table(net, RT6_TABLE_INFO);
David S. Miller38308472011-12-03 18:02:47 -05001873 if (!table)
Thomas Grafc71099a2006-08-04 23:20:06 -07001874 return NULL;
1875
Li RongQing5744dd92012-09-11 21:59:01 +00001876 read_lock_bh(&table->tb6_lock);
Thomas Grafc71099a2006-08-04 23:20:06 -07001877 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001878 if (!fn)
1879 goto out;
1880
Changli Gaod8d1f302010-06-10 23:31:35 -07001881 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
David S. Millerd1918542011-12-28 20:19:20 -05001882 if (rt->dst.dev->ifindex != ifindex)
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001883 continue;
1884 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1885 continue;
1886 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1887 continue;
Changli Gaod8d1f302010-06-10 23:31:35 -07001888 dst_hold(&rt->dst);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001889 break;
1890 }
1891out:
Li RongQing5744dd92012-09-11 21:59:01 +00001892 read_unlock_bh(&table->tb6_lock);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001893 return rt;
1894}
1895
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08001896static struct rt6_info *rt6_add_route_info(struct net *net,
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001897 const struct in6_addr *prefix, int prefixlen,
1898 const struct in6_addr *gwaddr, int ifindex,
Eric Dumazet95c96172012-04-15 05:58:06 +00001899 unsigned int pref)
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001900{
Thomas Graf86872cb2006-08-22 00:01:08 -07001901 struct fib6_config cfg = {
1902 .fc_table = RT6_TABLE_INFO,
Rami Rosen238fc7e2008-02-09 23:43:11 -08001903 .fc_metric = IP6_RT_PRIO_USER,
Thomas Graf86872cb2006-08-22 00:01:08 -07001904 .fc_ifindex = ifindex,
1905 .fc_dst_len = prefixlen,
1906 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1907 RTF_UP | RTF_PREF(pref),
Eric W. Biederman15e47302012-09-07 20:12:54 +00001908 .fc_nlinfo.portid = 0,
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08001909 .fc_nlinfo.nlh = NULL,
1910 .fc_nlinfo.nl_net = net,
Thomas Graf86872cb2006-08-22 00:01:08 -07001911 };
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001912
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001913 cfg.fc_dst = *prefix;
1914 cfg.fc_gateway = *gwaddr;
Thomas Graf86872cb2006-08-22 00:01:08 -07001915
YOSHIFUJI Hideakie317da92006-03-20 17:06:42 -08001916 /* We should treat it as a default route if prefix length is 0. */
1917 if (!prefixlen)
Thomas Graf86872cb2006-08-22 00:01:08 -07001918 cfg.fc_flags |= RTF_DEFAULT;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001919
Thomas Graf86872cb2006-08-22 00:01:08 -07001920 ip6_route_add(&cfg);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001921
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08001922 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001923}
1924#endif
1925
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001926struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001927{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 struct rt6_info *rt;
Thomas Grafc71099a2006-08-04 23:20:06 -07001929 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001931 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
David S. Miller38308472011-12-03 18:02:47 -05001932 if (!table)
Thomas Grafc71099a2006-08-04 23:20:06 -07001933 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934
Li RongQing5744dd92012-09-11 21:59:01 +00001935 read_lock_bh(&table->tb6_lock);
Changli Gaod8d1f302010-06-10 23:31:35 -07001936 for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
David S. Millerd1918542011-12-28 20:19:20 -05001937 if (dev == rt->dst.dev &&
YOSHIFUJI Hideaki045927f2006-03-20 17:00:48 -08001938 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1940 break;
1941 }
1942 if (rt)
Changli Gaod8d1f302010-06-10 23:31:35 -07001943 dst_hold(&rt->dst);
Li RongQing5744dd92012-09-11 21:59:01 +00001944 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 return rt;
1946}
1947
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001948struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001949 struct net_device *dev,
1950 unsigned int pref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951{
Thomas Graf86872cb2006-08-22 00:01:08 -07001952 struct fib6_config cfg = {
1953 .fc_table = RT6_TABLE_DFLT,
Rami Rosen238fc7e2008-02-09 23:43:11 -08001954 .fc_metric = IP6_RT_PRIO_USER,
Thomas Graf86872cb2006-08-22 00:01:08 -07001955 .fc_ifindex = dev->ifindex,
1956 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1957 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
Eric W. Biederman15e47302012-09-07 20:12:54 +00001958 .fc_nlinfo.portid = 0,
Daniel Lezcano55786892008-03-04 13:47:47 -08001959 .fc_nlinfo.nlh = NULL,
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001960 .fc_nlinfo.nl_net = dev_net(dev),
Thomas Graf86872cb2006-08-22 00:01:08 -07001961 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001963 cfg.fc_gateway = *gwaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964
Thomas Graf86872cb2006-08-22 00:01:08 -07001965 ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 return rt6_get_dflt_router(gwaddr, dev);
1968}
1969
Daniel Lezcano7b4da532008-03-04 13:47:14 -08001970void rt6_purge_dflt_routers(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971{
1972 struct rt6_info *rt;
Thomas Grafc71099a2006-08-04 23:20:06 -07001973 struct fib6_table *table;
1974
1975 /* NOTE: Keep consistent with rt6_get_dflt_router */
Daniel Lezcano7b4da532008-03-04 13:47:14 -08001976 table = fib6_get_table(net, RT6_TABLE_DFLT);
David S. Miller38308472011-12-03 18:02:47 -05001977 if (!table)
Thomas Grafc71099a2006-08-04 23:20:06 -07001978 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979
1980restart:
Thomas Grafc71099a2006-08-04 23:20:06 -07001981 read_lock_bh(&table->tb6_lock);
Changli Gaod8d1f302010-06-10 23:31:35 -07001982 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001984 dst_hold(&rt->dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001985 read_unlock_bh(&table->tb6_lock);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001986 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 goto restart;
1988 }
1989 }
Thomas Grafc71099a2006-08-04 23:20:06 -07001990 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991}
1992
Daniel Lezcano55786892008-03-04 13:47:47 -08001993static void rtmsg_to_fib6_config(struct net *net,
1994 struct in6_rtmsg *rtmsg,
Thomas Graf86872cb2006-08-22 00:01:08 -07001995 struct fib6_config *cfg)
1996{
1997 memset(cfg, 0, sizeof(*cfg));
1998
1999 cfg->fc_table = RT6_TABLE_MAIN;
2000 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2001 cfg->fc_metric = rtmsg->rtmsg_metric;
2002 cfg->fc_expires = rtmsg->rtmsg_info;
2003 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2004 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2005 cfg->fc_flags = rtmsg->rtmsg_flags;
2006
Daniel Lezcano55786892008-03-04 13:47:47 -08002007 cfg->fc_nlinfo.nl_net = net;
Benjamin Theryf1243c22008-02-26 18:10:03 -08002008
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002009 cfg->fc_dst = rtmsg->rtmsg_dst;
2010 cfg->fc_src = rtmsg->rtmsg_src;
2011 cfg->fc_gateway = rtmsg->rtmsg_gateway;
Thomas Graf86872cb2006-08-22 00:01:08 -07002012}
2013
Daniel Lezcano55786892008-03-04 13:47:47 -08002014int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015{
Thomas Graf86872cb2006-08-22 00:01:08 -07002016 struct fib6_config cfg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 struct in6_rtmsg rtmsg;
2018 int err;
2019
2020 switch(cmd) {
2021 case SIOCADDRT: /* Add a route */
2022 case SIOCDELRT: /* Delete a route */
Eric W. Biedermanaf31f412012-11-16 03:03:06 +00002023 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 return -EPERM;
2025 err = copy_from_user(&rtmsg, arg,
2026 sizeof(struct in6_rtmsg));
2027 if (err)
2028 return -EFAULT;
Thomas Graf86872cb2006-08-22 00:01:08 -07002029
Daniel Lezcano55786892008-03-04 13:47:47 -08002030 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
Thomas Graf86872cb2006-08-22 00:01:08 -07002031
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032 rtnl_lock();
2033 switch (cmd) {
2034 case SIOCADDRT:
Thomas Graf86872cb2006-08-22 00:01:08 -07002035 err = ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 break;
2037 case SIOCDELRT:
Thomas Graf86872cb2006-08-22 00:01:08 -07002038 err = ip6_route_del(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 break;
2040 default:
2041 err = -EINVAL;
2042 }
2043 rtnl_unlock();
2044
2045 return err;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07002046 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047
2048 return -EINVAL;
2049}
2050
2051/*
2052 * Drop the packet on the floor
2053 */
2054
Brian Haleyd5fdd6b2009-06-23 04:31:07 -07002055static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002057 int type;
Eric Dumazetadf30902009-06-02 05:19:30 +00002058 struct dst_entry *dst = skb_dst(skb);
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002059 switch (ipstats_mib_noroutes) {
2060 case IPSTATS_MIB_INNOROUTES:
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07002061 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
Ulrich Weber45bb0062010-02-25 23:28:58 +00002062 if (type == IPV6_ADDR_ANY) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -07002063 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2064 IPSTATS_MIB_INADDRERRORS);
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002065 break;
2066 }
2067 /* FALLTHROUGH */
2068 case IPSTATS_MIB_OUTNOROUTES:
Denis V. Lunev3bd653c2008-10-08 10:54:51 -07002069 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2070 ipstats_mib_noroutes);
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002071 break;
2072 }
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +00002073 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 kfree_skb(skb);
2075 return 0;
2076}
2077
Thomas Graf9ce8ade2006-10-18 20:46:54 -07002078static int ip6_pkt_discard(struct sk_buff *skb)
2079{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002080 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07002081}
2082
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03002083static int ip6_pkt_discard_out(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084{
Eric Dumazetadf30902009-06-02 05:19:30 +00002085 skb->dev = skb_dst(skb)->dev;
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002086 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087}
2088
David S. Miller6723ab52006-10-18 21:20:57 -07002089#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2090
Thomas Graf9ce8ade2006-10-18 20:46:54 -07002091static int ip6_pkt_prohibit(struct sk_buff *skb)
2092{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002093 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07002094}
2095
2096static int ip6_pkt_prohibit_out(struct sk_buff *skb)
2097{
Eric Dumazetadf30902009-06-02 05:19:30 +00002098 skb->dev = skb_dst(skb)->dev;
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002099 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07002100}
2101
David S. Miller6723ab52006-10-18 21:20:57 -07002102#endif
2103
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104/*
2105 * Allocate a dst for local (unicast / anycast) address.
2106 */
2107
2108struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2109 const struct in6_addr *addr,
David S. Miller8f031512011-12-06 16:48:14 -05002110 bool anycast)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002112 struct net *net = dev_net(idev->dev);
David S. Miller8b96d222012-06-11 02:01:56 -07002113 struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev, 0, NULL);
David S. Millerf83c7792011-12-28 15:41:23 -05002114 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115
David S. Miller38308472011-12-03 18:02:47 -05002116 if (!rt) {
Joe Perchesf3213832012-05-15 14:11:53 +00002117 net_warn_ratelimited("Maximum number of routes reached, consider increasing route/max_size\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 return ERR_PTR(-ENOMEM);
Ben Greear40385652010-11-08 12:33:48 +00002119 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 in6_dev_hold(idev);
2122
David S. Miller11d53b42011-06-24 15:23:34 -07002123 rt->dst.flags |= DST_HOST;
Changli Gaod8d1f302010-06-10 23:31:35 -07002124 rt->dst.input = ip6_input;
2125 rt->dst.output = ip6_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 rt->rt6i_idev = idev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127
2128 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +09002129 if (anycast)
2130 rt->rt6i_flags |= RTF_ANYCAST;
2131 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 rt->rt6i_flags |= RTF_LOCAL;
David S. Miller8ade06c2011-12-29 18:51:57 -05002133 err = rt6_bind_neighbour(rt, rt->dst.dev);
David S. Millerf83c7792011-12-28 15:41:23 -05002134 if (err) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002135 dst_free(&rt->dst);
David S. Millerf83c7792011-12-28 15:41:23 -05002136 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 }
2138
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002139 rt->rt6i_dst.addr = *addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140 rt->rt6i_dst.plen = 128;
Daniel Lezcano55786892008-03-04 13:47:47 -08002141 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142
Changli Gaod8d1f302010-06-10 23:31:35 -07002143 atomic_set(&rt->dst.__refcnt, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144
2145 return rt;
2146}
2147
Daniel Walterc3968a82011-04-13 21:10:57 +00002148int ip6_route_get_saddr(struct net *net,
2149 struct rt6_info *rt,
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002150 const struct in6_addr *daddr,
Daniel Walterc3968a82011-04-13 21:10:57 +00002151 unsigned int prefs,
2152 struct in6_addr *saddr)
2153{
2154 struct inet6_dev *idev = ip6_dst_idev((struct dst_entry*)rt);
2155 int err = 0;
2156 if (rt->rt6i_prefsrc.plen)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002157 *saddr = rt->rt6i_prefsrc.addr;
Daniel Walterc3968a82011-04-13 21:10:57 +00002158 else
2159 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2160 daddr, prefs, saddr);
2161 return err;
2162}
2163
2164/* remove deleted ip from prefsrc entries */
2165struct arg_dev_net_ip {
2166 struct net_device *dev;
2167 struct net *net;
2168 struct in6_addr *addr;
2169};
2170
2171static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2172{
2173 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2174 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2175 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2176
David S. Millerd1918542011-12-28 20:19:20 -05002177 if (((void *)rt->dst.dev == dev || !dev) &&
Daniel Walterc3968a82011-04-13 21:10:57 +00002178 rt != net->ipv6.ip6_null_entry &&
2179 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2180 /* remove prefsrc entry */
2181 rt->rt6i_prefsrc.plen = 0;
2182 }
2183 return 0;
2184}
2185
2186void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2187{
2188 struct net *net = dev_net(ifp->idev->dev);
2189 struct arg_dev_net_ip adni = {
2190 .dev = ifp->idev->dev,
2191 .net = net,
2192 .addr = &ifp->addr,
2193 };
2194 fib6_clean_all(net, fib6_remove_prefsrc, 0, &adni);
2195}
2196
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002197struct arg_dev_net {
2198 struct net_device *dev;
2199 struct net *net;
2200};
2201
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202static int fib6_ifdown(struct rt6_info *rt, void *arg)
2203{
stephen hemmingerbc3ef662010-12-16 17:42:40 +00002204 const struct arg_dev_net *adn = arg;
2205 const struct net_device *dev = adn->dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002206
David S. Millerd1918542011-12-28 20:19:20 -05002207 if ((rt->dst.dev == dev || !dev) &&
David S. Millerc159d302011-12-26 15:24:36 -05002208 rt != adn->net->ipv6.ip6_null_entry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209 return -1;
David S. Millerc159d302011-12-26 15:24:36 -05002210
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211 return 0;
2212}
2213
Daniel Lezcanof3db4852008-03-03 23:27:06 -08002214void rt6_ifdown(struct net *net, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215{
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002216 struct arg_dev_net adn = {
2217 .dev = dev,
2218 .net = net,
2219 };
2220
2221 fib6_clean_all(net, fib6_ifdown, 0, &adn);
David S. Miller1e493d12008-09-10 17:27:15 -07002222 icmp6_clean_all(fib6_ifdown, &adn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223}
2224
Eric Dumazet95c96172012-04-15 05:58:06 +00002225struct rt6_mtu_change_arg {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 struct net_device *dev;
Eric Dumazet95c96172012-04-15 05:58:06 +00002227 unsigned int mtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228};
2229
2230static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2231{
2232 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2233 struct inet6_dev *idev;
2234
2235 /* In IPv6 pmtu discovery is not optional,
2236 so that RTAX_MTU lock cannot disable it.
2237 We still use this lock to block changes
2238 caused by addrconf/ndisc.
2239 */
2240
2241 idev = __in6_dev_get(arg->dev);
David S. Miller38308472011-12-03 18:02:47 -05002242 if (!idev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 return 0;
2244
2245 /* For administrative MTU increase, there is no way to discover
2246 IPv6 PMTU increase, so PMTU increase should be updated here.
2247 Since RFC 1981 doesn't include administrative MTU increase
2248 update PMTU increase is a MUST. (i.e. jumbo frame)
2249 */
2250 /*
2251 If new MTU is less than route PMTU, this new MTU will be the
2252 lowest MTU in the path, update the route PMTU to reflect PMTU
2253 decreases; if new MTU is greater than route PMTU, and the
2254 old MTU is the lowest MTU in the path, update the route PMTU
2255 to reflect the increase. In this case if the other nodes' MTU
2256 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2257 PMTU discouvery.
2258 */
David S. Millerd1918542011-12-28 20:19:20 -05002259 if (rt->dst.dev == arg->dev &&
Changli Gaod8d1f302010-06-10 23:31:35 -07002260 !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2261 (dst_mtu(&rt->dst) >= arg->mtu ||
2262 (dst_mtu(&rt->dst) < arg->mtu &&
2263 dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
David S. Millerdefb3512010-12-08 21:16:57 -08002264 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
Simon Arlott566cfd82007-07-26 00:09:55 -07002265 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 return 0;
2267}
2268
Eric Dumazet95c96172012-04-15 05:58:06 +00002269void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270{
Thomas Grafc71099a2006-08-04 23:20:06 -07002271 struct rt6_mtu_change_arg arg = {
2272 .dev = dev,
2273 .mtu = mtu,
2274 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002276 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277}
2278
Patrick McHardyef7c79e2007-06-05 12:38:30 -07002279static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
Thomas Graf5176f912006-08-26 20:13:18 -07002280 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
Thomas Graf86872cb2006-08-22 00:01:08 -07002281 [RTA_OIF] = { .type = NLA_U32 },
Thomas Grafab364a62006-08-22 00:01:47 -07002282 [RTA_IIF] = { .type = NLA_U32 },
Thomas Graf86872cb2006-08-22 00:01:08 -07002283 [RTA_PRIORITY] = { .type = NLA_U32 },
2284 [RTA_METRICS] = { .type = NLA_NESTED },
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00002285 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
Thomas Graf86872cb2006-08-22 00:01:08 -07002286};
2287
2288static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2289 struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290{
Thomas Graf86872cb2006-08-22 00:01:08 -07002291 struct rtmsg *rtm;
2292 struct nlattr *tb[RTA_MAX+1];
2293 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294
Thomas Graf86872cb2006-08-22 00:01:08 -07002295 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2296 if (err < 0)
2297 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298
Thomas Graf86872cb2006-08-22 00:01:08 -07002299 err = -EINVAL;
2300 rtm = nlmsg_data(nlh);
2301 memset(cfg, 0, sizeof(*cfg));
2302
2303 cfg->fc_table = rtm->rtm_table;
2304 cfg->fc_dst_len = rtm->rtm_dst_len;
2305 cfg->fc_src_len = rtm->rtm_src_len;
2306 cfg->fc_flags = RTF_UP;
2307 cfg->fc_protocol = rtm->rtm_protocol;
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00002308 cfg->fc_type = rtm->rtm_type;
Thomas Graf86872cb2006-08-22 00:01:08 -07002309
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00002310 if (rtm->rtm_type == RTN_UNREACHABLE ||
2311 rtm->rtm_type == RTN_BLACKHOLE ||
Nicolas Dichtelb4949ab2012-09-06 05:53:35 +00002312 rtm->rtm_type == RTN_PROHIBIT ||
2313 rtm->rtm_type == RTN_THROW)
Thomas Graf86872cb2006-08-22 00:01:08 -07002314 cfg->fc_flags |= RTF_REJECT;
2315
Maciej Żenczykowskiab79ad12010-09-27 00:07:02 +00002316 if (rtm->rtm_type == RTN_LOCAL)
2317 cfg->fc_flags |= RTF_LOCAL;
2318
Eric W. Biederman15e47302012-09-07 20:12:54 +00002319 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
Thomas Graf86872cb2006-08-22 00:01:08 -07002320 cfg->fc_nlinfo.nlh = nlh;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002321 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
Thomas Graf86872cb2006-08-22 00:01:08 -07002322
2323 if (tb[RTA_GATEWAY]) {
2324 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2325 cfg->fc_flags |= RTF_GATEWAY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002327
2328 if (tb[RTA_DST]) {
2329 int plen = (rtm->rtm_dst_len + 7) >> 3;
2330
2331 if (nla_len(tb[RTA_DST]) < plen)
2332 goto errout;
2333
2334 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002336
2337 if (tb[RTA_SRC]) {
2338 int plen = (rtm->rtm_src_len + 7) >> 3;
2339
2340 if (nla_len(tb[RTA_SRC]) < plen)
2341 goto errout;
2342
2343 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002345
Daniel Walterc3968a82011-04-13 21:10:57 +00002346 if (tb[RTA_PREFSRC])
2347 nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2348
Thomas Graf86872cb2006-08-22 00:01:08 -07002349 if (tb[RTA_OIF])
2350 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2351
2352 if (tb[RTA_PRIORITY])
2353 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2354
2355 if (tb[RTA_METRICS]) {
2356 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2357 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002359
2360 if (tb[RTA_TABLE])
2361 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2362
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00002363 if (tb[RTA_MULTIPATH]) {
2364 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2365 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2366 }
2367
Thomas Graf86872cb2006-08-22 00:01:08 -07002368 err = 0;
2369errout:
2370 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371}
2372
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00002373static int ip6_route_multipath(struct fib6_config *cfg, int add)
2374{
2375 struct fib6_config r_cfg;
2376 struct rtnexthop *rtnh;
2377 int remaining;
2378 int attrlen;
2379 int err = 0, last_err = 0;
2380
2381beginning:
2382 rtnh = (struct rtnexthop *)cfg->fc_mp;
2383 remaining = cfg->fc_mp_len;
2384
2385 /* Parse a Multipath Entry */
2386 while (rtnh_ok(rtnh, remaining)) {
2387 memcpy(&r_cfg, cfg, sizeof(*cfg));
2388 if (rtnh->rtnh_ifindex)
2389 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2390
2391 attrlen = rtnh_attrlen(rtnh);
2392 if (attrlen > 0) {
2393 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2394
2395 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2396 if (nla) {
2397 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
2398 r_cfg.fc_flags |= RTF_GATEWAY;
2399 }
2400 }
2401 err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2402 if (err) {
2403 last_err = err;
2404 /* If we are trying to remove a route, do not stop the
2405 * loop when ip6_route_del() fails (because next hop is
2406 * already gone), we should try to remove all next hops.
2407 */
2408 if (add) {
2409 /* If add fails, we should try to delete all
2410 * next hops that have been already added.
2411 */
2412 add = 0;
2413 goto beginning;
2414 }
2415 }
Nicolas Dichtel1a724182012-11-01 22:58:22 +00002416 /* Because each route is added like a single route we remove
2417 * this flag after the first nexthop (if there is a collision,
2418 * we have already fail to add the first nexthop:
2419 * fib6_add_rt2node() has reject it).
2420 */
2421 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00002422 rtnh = rtnh_next(rtnh, &remaining);
2423 }
2424
2425 return last_err;
2426}
2427
Thomas Grafc127ea22007-03-22 11:58:32 -07002428static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429{
Thomas Graf86872cb2006-08-22 00:01:08 -07002430 struct fib6_config cfg;
2431 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432
Thomas Graf86872cb2006-08-22 00:01:08 -07002433 err = rtm_to_fib6_config(skb, nlh, &cfg);
2434 if (err < 0)
2435 return err;
2436
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00002437 if (cfg.fc_mp)
2438 return ip6_route_multipath(&cfg, 0);
2439 else
2440 return ip6_route_del(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002441}
2442
Thomas Grafc127ea22007-03-22 11:58:32 -07002443static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444{
Thomas Graf86872cb2006-08-22 00:01:08 -07002445 struct fib6_config cfg;
2446 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447
Thomas Graf86872cb2006-08-22 00:01:08 -07002448 err = rtm_to_fib6_config(skb, nlh, &cfg);
2449 if (err < 0)
2450 return err;
2451
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00002452 if (cfg.fc_mp)
2453 return ip6_route_multipath(&cfg, 1);
2454 else
2455 return ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456}
2457
Thomas Graf339bf982006-11-10 14:10:15 -08002458static inline size_t rt6_nlmsg_size(void)
2459{
2460 return NLMSG_ALIGN(sizeof(struct rtmsg))
2461 + nla_total_size(16) /* RTA_SRC */
2462 + nla_total_size(16) /* RTA_DST */
2463 + nla_total_size(16) /* RTA_GATEWAY */
2464 + nla_total_size(16) /* RTA_PREFSRC */
2465 + nla_total_size(4) /* RTA_TABLE */
2466 + nla_total_size(4) /* RTA_IIF */
2467 + nla_total_size(4) /* RTA_OIF */
2468 + nla_total_size(4) /* RTA_PRIORITY */
Noriaki TAKAMIYA6a2b9ce2007-01-23 22:09:41 -08002469 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
Thomas Graf339bf982006-11-10 14:10:15 -08002470 + nla_total_size(sizeof(struct rta_cacheinfo));
2471}
2472
Brian Haley191cd582008-08-14 15:33:21 -07002473static int rt6_fill_node(struct net *net,
2474 struct sk_buff *skb, struct rt6_info *rt,
Jamal Hadi Salim0d51aa82005-06-21 13:51:04 -07002475 struct in6_addr *dst, struct in6_addr *src,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002476 int iif, int type, u32 portid, u32 seq,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002477 int prefix, int nowait, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478{
2479 struct rtmsg *rtm;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002480 struct nlmsghdr *nlh;
Thomas Grafe3703b32006-11-27 09:27:07 -08002481 long expires;
Patrick McHardy9e762a42006-08-10 23:09:48 -07002482 u32 table;
Eric Dumazetf2c31e32011-07-29 19:00:53 +00002483 struct neighbour *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484
2485 if (prefix) { /* user wants prefix routes only */
2486 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2487 /* success since this is not a prefix route */
2488 return 1;
2489 }
2490 }
2491
Eric W. Biederman15e47302012-09-07 20:12:54 +00002492 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
David S. Miller38308472011-12-03 18:02:47 -05002493 if (!nlh)
Patrick McHardy26932562007-01-31 23:16:40 -08002494 return -EMSGSIZE;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002495
2496 rtm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497 rtm->rtm_family = AF_INET6;
2498 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2499 rtm->rtm_src_len = rt->rt6i_src.plen;
2500 rtm->rtm_tos = 0;
Thomas Grafc71099a2006-08-04 23:20:06 -07002501 if (rt->rt6i_table)
Patrick McHardy9e762a42006-08-10 23:09:48 -07002502 table = rt->rt6i_table->tb6_id;
Thomas Grafc71099a2006-08-04 23:20:06 -07002503 else
Patrick McHardy9e762a42006-08-10 23:09:48 -07002504 table = RT6_TABLE_UNSPEC;
2505 rtm->rtm_table = table;
David S. Millerc78679e2012-04-01 20:27:33 -04002506 if (nla_put_u32(skb, RTA_TABLE, table))
2507 goto nla_put_failure;
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00002508 if (rt->rt6i_flags & RTF_REJECT) {
2509 switch (rt->dst.error) {
2510 case -EINVAL:
2511 rtm->rtm_type = RTN_BLACKHOLE;
2512 break;
2513 case -EACCES:
2514 rtm->rtm_type = RTN_PROHIBIT;
2515 break;
Nicolas Dichtelb4949ab2012-09-06 05:53:35 +00002516 case -EAGAIN:
2517 rtm->rtm_type = RTN_THROW;
2518 break;
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00002519 default:
2520 rtm->rtm_type = RTN_UNREACHABLE;
2521 break;
2522 }
2523 }
David S. Miller38308472011-12-03 18:02:47 -05002524 else if (rt->rt6i_flags & RTF_LOCAL)
Maciej Żenczykowskiab79ad12010-09-27 00:07:02 +00002525 rtm->rtm_type = RTN_LOCAL;
David S. Millerd1918542011-12-28 20:19:20 -05002526 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527 rtm->rtm_type = RTN_LOCAL;
2528 else
2529 rtm->rtm_type = RTN_UNICAST;
2530 rtm->rtm_flags = 0;
2531 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2532 rtm->rtm_protocol = rt->rt6i_protocol;
David S. Miller38308472011-12-03 18:02:47 -05002533 if (rt->rt6i_flags & RTF_DYNAMIC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534 rtm->rtm_protocol = RTPROT_REDIRECT;
Denis Ovsienkof0396f602012-07-10 04:45:50 +00002535 else if (rt->rt6i_flags & RTF_ADDRCONF) {
2536 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2537 rtm->rtm_protocol = RTPROT_RA;
2538 else
2539 rtm->rtm_protocol = RTPROT_KERNEL;
2540 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541
David S. Miller38308472011-12-03 18:02:47 -05002542 if (rt->rt6i_flags & RTF_CACHE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543 rtm->rtm_flags |= RTM_F_CLONED;
2544
2545 if (dst) {
David S. Millerc78679e2012-04-01 20:27:33 -04002546 if (nla_put(skb, RTA_DST, 16, dst))
2547 goto nla_put_failure;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002548 rtm->rtm_dst_len = 128;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549 } else if (rtm->rtm_dst_len)
David S. Millerc78679e2012-04-01 20:27:33 -04002550 if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2551 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552#ifdef CONFIG_IPV6_SUBTREES
2553 if (src) {
David S. Millerc78679e2012-04-01 20:27:33 -04002554 if (nla_put(skb, RTA_SRC, 16, src))
2555 goto nla_put_failure;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002556 rtm->rtm_src_len = 128;
David S. Millerc78679e2012-04-01 20:27:33 -04002557 } else if (rtm->rtm_src_len &&
2558 nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2559 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560#endif
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002561 if (iif) {
2562#ifdef CONFIG_IPV6_MROUTE
2563 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
Benjamin Thery8229efd2008-12-10 16:30:15 -08002564 int err = ip6mr_get_route(net, skb, rtm, nowait);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002565 if (err <= 0) {
2566 if (!nowait) {
2567 if (err == 0)
2568 return 0;
2569 goto nla_put_failure;
2570 } else {
2571 if (err == -EMSGSIZE)
2572 goto nla_put_failure;
2573 }
2574 }
2575 } else
2576#endif
David S. Millerc78679e2012-04-01 20:27:33 -04002577 if (nla_put_u32(skb, RTA_IIF, iif))
2578 goto nla_put_failure;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002579 } else if (dst) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 struct in6_addr saddr_buf;
David S. Millerc78679e2012-04-01 20:27:33 -04002581 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2582 nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2583 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584 }
Thomas Graf2d7202b2006-08-22 00:01:27 -07002585
Daniel Walterc3968a82011-04-13 21:10:57 +00002586 if (rt->rt6i_prefsrc.plen) {
2587 struct in6_addr saddr_buf;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002588 saddr_buf = rt->rt6i_prefsrc.addr;
David S. Millerc78679e2012-04-01 20:27:33 -04002589 if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2590 goto nla_put_failure;
Daniel Walterc3968a82011-04-13 21:10:57 +00002591 }
2592
David S. Millerdefb3512010-12-08 21:16:57 -08002593 if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002594 goto nla_put_failure;
2595
David S. Miller97cac082012-07-02 22:43:47 -07002596 n = rt->n;
Eric Dumazet94f826b2012-03-27 09:53:52 +00002597 if (n) {
Amerigo Wangfdd66812012-09-10 02:48:44 +00002598 if (nla_put(skb, RTA_GATEWAY, 16, &n->primary_key) < 0)
Eric Dumazet94f826b2012-03-27 09:53:52 +00002599 goto nla_put_failure;
Eric Dumazet94f826b2012-03-27 09:53:52 +00002600 }
Thomas Graf2d7202b2006-08-22 00:01:27 -07002601
David S. Millerc78679e2012-04-01 20:27:33 -04002602 if (rt->dst.dev &&
2603 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2604 goto nla_put_failure;
2605 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2606 goto nla_put_failure;
Li Wei82539472012-07-29 16:01:30 +00002607
2608 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
YOSHIFUJI Hideaki69cdf8f2008-05-19 16:55:13 -07002609
David S. Miller87a50692012-07-10 05:06:14 -07002610 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
Thomas Grafe3703b32006-11-27 09:27:07 -08002611 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612
Thomas Graf2d7202b2006-08-22 00:01:27 -07002613 return nlmsg_end(skb, nlh);
2614
2615nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002616 nlmsg_cancel(skb, nlh);
2617 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002618}
2619
Patrick McHardy1b43af52006-08-10 23:11:17 -07002620int rt6_dump_route(struct rt6_info *rt, void *p_arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002621{
2622 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2623 int prefix;
2624
Thomas Graf2d7202b2006-08-22 00:01:27 -07002625 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2626 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2628 } else
2629 prefix = 0;
2630
Brian Haley191cd582008-08-14 15:33:21 -07002631 return rt6_fill_node(arg->net,
2632 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002633 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002634 prefix, 0, NLM_F_MULTI);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635}
2636
Thomas Grafc127ea22007-03-22 11:58:32 -07002637static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002639 struct net *net = sock_net(in_skb->sk);
Thomas Grafab364a62006-08-22 00:01:47 -07002640 struct nlattr *tb[RTA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641 struct rt6_info *rt;
Thomas Grafab364a62006-08-22 00:01:47 -07002642 struct sk_buff *skb;
2643 struct rtmsg *rtm;
David S. Miller4c9483b2011-03-12 16:22:43 -05002644 struct flowi6 fl6;
Shmulik Ladkani72331bc2012-04-01 04:03:45 +00002645 int err, iif = 0, oif = 0;
Thomas Grafab364a62006-08-22 00:01:47 -07002646
2647 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2648 if (err < 0)
2649 goto errout;
2650
2651 err = -EINVAL;
David S. Miller4c9483b2011-03-12 16:22:43 -05002652 memset(&fl6, 0, sizeof(fl6));
Thomas Grafab364a62006-08-22 00:01:47 -07002653
2654 if (tb[RTA_SRC]) {
2655 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2656 goto errout;
2657
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002658 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
Thomas Grafab364a62006-08-22 00:01:47 -07002659 }
2660
2661 if (tb[RTA_DST]) {
2662 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2663 goto errout;
2664
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002665 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
Thomas Grafab364a62006-08-22 00:01:47 -07002666 }
2667
2668 if (tb[RTA_IIF])
2669 iif = nla_get_u32(tb[RTA_IIF]);
2670
2671 if (tb[RTA_OIF])
Shmulik Ladkani72331bc2012-04-01 04:03:45 +00002672 oif = nla_get_u32(tb[RTA_OIF]);
Thomas Grafab364a62006-08-22 00:01:47 -07002673
2674 if (iif) {
2675 struct net_device *dev;
Shmulik Ladkani72331bc2012-04-01 04:03:45 +00002676 int flags = 0;
2677
Daniel Lezcano55786892008-03-04 13:47:47 -08002678 dev = __dev_get_by_index(net, iif);
Thomas Grafab364a62006-08-22 00:01:47 -07002679 if (!dev) {
2680 err = -ENODEV;
2681 goto errout;
2682 }
Shmulik Ladkani72331bc2012-04-01 04:03:45 +00002683
2684 fl6.flowi6_iif = iif;
2685
2686 if (!ipv6_addr_any(&fl6.saddr))
2687 flags |= RT6_LOOKUP_F_HAS_SADDR;
2688
2689 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2690 flags);
2691 } else {
2692 fl6.flowi6_oif = oif;
2693
2694 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
Thomas Grafab364a62006-08-22 00:01:47 -07002695 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696
2697 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
David S. Miller38308472011-12-03 18:02:47 -05002698 if (!skb) {
Amerigo Wang94e187c2012-10-29 00:13:19 +00002699 ip6_rt_put(rt);
Thomas Grafab364a62006-08-22 00:01:47 -07002700 err = -ENOBUFS;
2701 goto errout;
2702 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703
2704 /* Reserve room for dummy headers, this skb can pass
2705 through good chunk of routing engine.
2706 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07002707 skb_reset_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2709
Changli Gaod8d1f302010-06-10 23:31:35 -07002710 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711
David S. Miller4c9483b2011-03-12 16:22:43 -05002712 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002713 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002714 nlh->nlmsg_seq, 0, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715 if (err < 0) {
Thomas Grafab364a62006-08-22 00:01:47 -07002716 kfree_skb(skb);
2717 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718 }
2719
Eric W. Biederman15e47302012-09-07 20:12:54 +00002720 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
Thomas Grafab364a62006-08-22 00:01:47 -07002721errout:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002722 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723}
2724
Thomas Graf86872cb2006-08-22 00:01:08 -07002725void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002726{
2727 struct sk_buff *skb;
Daniel Lezcano55786892008-03-04 13:47:47 -08002728 struct net *net = info->nl_net;
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08002729 u32 seq;
2730 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08002732 err = -ENOBUFS;
David S. Miller38308472011-12-03 18:02:47 -05002733 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
Thomas Graf86872cb2006-08-22 00:01:08 -07002734
Thomas Graf339bf982006-11-10 14:10:15 -08002735 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
David S. Miller38308472011-12-03 18:02:47 -05002736 if (!skb)
Thomas Graf21713eb2006-08-15 00:35:24 -07002737 goto errout;
2738
Brian Haley191cd582008-08-14 15:33:21 -07002739 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002740 event, info->portid, seq, 0, 0, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08002741 if (err < 0) {
2742 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2743 WARN_ON(err == -EMSGSIZE);
2744 kfree_skb(skb);
2745 goto errout;
2746 }
Eric W. Biederman15e47302012-09-07 20:12:54 +00002747 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08002748 info->nlh, gfp_any());
2749 return;
Thomas Graf21713eb2006-08-15 00:35:24 -07002750errout:
2751 if (err < 0)
Daniel Lezcano55786892008-03-04 13:47:47 -08002752 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002753}
2754
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002755static int ip6_route_dev_notify(struct notifier_block *this,
2756 unsigned long event, void *data)
2757{
2758 struct net_device *dev = (struct net_device *)data;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002759 struct net *net = dev_net(dev);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002760
2761 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002762 net->ipv6.ip6_null_entry->dst.dev = dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002763 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2764#ifdef CONFIG_IPV6_MULTIPLE_TABLES
Changli Gaod8d1f302010-06-10 23:31:35 -07002765 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002766 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
Changli Gaod8d1f302010-06-10 23:31:35 -07002767 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002768 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2769#endif
2770 }
2771
2772 return NOTIFY_OK;
2773}
2774
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775/*
2776 * /proc
2777 */
2778
2779#ifdef CONFIG_PROC_FS
2780
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781struct rt6_proc_arg
2782{
2783 char *buffer;
2784 int offset;
2785 int length;
2786 int skip;
2787 int len;
2788};
2789
2790static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2791{
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002792 struct seq_file *m = p_arg;
David S. Miller69cce1d2011-07-17 23:09:49 -07002793 struct neighbour *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794
Harvey Harrison4b7a4272008-10-29 12:50:24 -07002795 seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002796
2797#ifdef CONFIG_IPV6_SUBTREES
Harvey Harrison4b7a4272008-10-29 12:50:24 -07002798 seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799#else
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002800 seq_puts(m, "00000000000000000000000000000000 00 ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801#endif
David S. Miller97cac082012-07-02 22:43:47 -07002802 n = rt->n;
David S. Miller69cce1d2011-07-17 23:09:49 -07002803 if (n) {
2804 seq_printf(m, "%pi6", n->primary_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002805 } else {
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002806 seq_puts(m, "00000000000000000000000000000000");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807 }
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002808 seq_printf(m, " %08x %08x %08x %08x %8s\n",
Changli Gaod8d1f302010-06-10 23:31:35 -07002809 rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
2810 rt->dst.__use, rt->rt6i_flags,
David S. Millerd1918542011-12-28 20:19:20 -05002811 rt->dst.dev ? rt->dst.dev->name : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812 return 0;
2813}
2814
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002815static int ipv6_route_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002816{
Daniel Lezcanof3db4852008-03-03 23:27:06 -08002817 struct net *net = (struct net *)m->private;
Josh Hunt32b293a2011-12-28 13:23:07 +00002818 fib6_clean_all_ro(net, rt6_info_route, 0, m);
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002819 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820}
2821
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002822static int ipv6_route_open(struct inode *inode, struct file *file)
2823{
Pavel Emelyanovde05c552008-07-18 04:07:21 -07002824 return single_open_net(inode, file, ipv6_route_show);
Daniel Lezcanof3db4852008-03-03 23:27:06 -08002825}
2826
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002827static const struct file_operations ipv6_route_proc_fops = {
2828 .owner = THIS_MODULE,
2829 .open = ipv6_route_open,
2830 .read = seq_read,
2831 .llseek = seq_lseek,
Pavel Emelyanovb6fcbdb2008-07-18 04:07:44 -07002832 .release = single_release_net,
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002833};
2834
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2836{
Daniel Lezcano69ddb802008-03-04 13:46:23 -08002837 struct net *net = (struct net *)seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
Daniel Lezcano69ddb802008-03-04 13:46:23 -08002839 net->ipv6.rt6_stats->fib_nodes,
2840 net->ipv6.rt6_stats->fib_route_nodes,
2841 net->ipv6.rt6_stats->fib_rt_alloc,
2842 net->ipv6.rt6_stats->fib_rt_entries,
2843 net->ipv6.rt6_stats->fib_rt_cache,
Eric Dumazetfc66f952010-10-08 06:37:34 +00002844 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
Daniel Lezcano69ddb802008-03-04 13:46:23 -08002845 net->ipv6.rt6_stats->fib_discarded_routes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002846
2847 return 0;
2848}
2849
2850static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2851{
Pavel Emelyanovde05c552008-07-18 04:07:21 -07002852 return single_open_net(inode, file, rt6_stats_seq_show);
Daniel Lezcano69ddb802008-03-04 13:46:23 -08002853}
2854
Arjan van de Ven9a321442007-02-12 00:55:35 -08002855static const struct file_operations rt6_stats_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856 .owner = THIS_MODULE,
2857 .open = rt6_stats_seq_open,
2858 .read = seq_read,
2859 .llseek = seq_lseek,
Pavel Emelyanovb6fcbdb2008-07-18 04:07:44 -07002860 .release = single_release_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861};
2862#endif /* CONFIG_PROC_FS */
2863
2864#ifdef CONFIG_SYSCTL
2865
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866static
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002867int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868 void __user *buffer, size_t *lenp, loff_t *ppos)
2869{
Lucian Adrian Grijincuc486da32011-02-24 19:48:03 +00002870 struct net *net;
2871 int delay;
2872 if (!write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873 return -EINVAL;
Lucian Adrian Grijincuc486da32011-02-24 19:48:03 +00002874
2875 net = (struct net *)ctl->extra1;
2876 delay = net->ipv6.sysctl.flush_delay;
2877 proc_dointvec(ctl, write, buffer, lenp, ppos);
2878 fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
2879 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002880}
2881
Daniel Lezcano760f2d02008-01-10 02:53:43 -08002882ctl_table ipv6_route_table_template[] = {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002883 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002884 .procname = "flush",
Daniel Lezcano49905092008-01-10 03:01:01 -08002885 .data = &init_net.ipv6.sysctl.flush_delay,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 .maxlen = sizeof(int),
Dave Jones89c8b3a12005-04-28 12:11:49 -07002887 .mode = 0200,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002888 .proc_handler = ipv6_sysctl_rtcache_flush
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 },
2890 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891 .procname = "gc_thresh",
Daniel Lezcano9a7ec3a2008-03-04 13:48:53 -08002892 .data = &ip6_dst_ops_template.gc_thresh,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002893 .maxlen = sizeof(int),
2894 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002895 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002896 },
2897 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898 .procname = "max_size",
Daniel Lezcano49905092008-01-10 03:01:01 -08002899 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900 .maxlen = sizeof(int),
2901 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002902 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002903 },
2904 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002905 .procname = "gc_min_interval",
Daniel Lezcano49905092008-01-10 03:01:01 -08002906 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002907 .maxlen = sizeof(int),
2908 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002909 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910 },
2911 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912 .procname = "gc_timeout",
Daniel Lezcano49905092008-01-10 03:01:01 -08002913 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002914 .maxlen = sizeof(int),
2915 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002916 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917 },
2918 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919 .procname = "gc_interval",
Daniel Lezcano49905092008-01-10 03:01:01 -08002920 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002921 .maxlen = sizeof(int),
2922 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002923 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924 },
2925 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002926 .procname = "gc_elasticity",
Daniel Lezcano49905092008-01-10 03:01:01 -08002927 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002928 .maxlen = sizeof(int),
2929 .mode = 0644,
Min Zhangf3d3f612010-08-14 22:42:51 -07002930 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002931 },
2932 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933 .procname = "mtu_expires",
Daniel Lezcano49905092008-01-10 03:01:01 -08002934 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002935 .maxlen = sizeof(int),
2936 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002937 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002938 },
2939 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940 .procname = "min_adv_mss",
Daniel Lezcano49905092008-01-10 03:01:01 -08002941 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942 .maxlen = sizeof(int),
2943 .mode = 0644,
Min Zhangf3d3f612010-08-14 22:42:51 -07002944 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945 },
2946 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947 .procname = "gc_min_interval_ms",
Daniel Lezcano49905092008-01-10 03:01:01 -08002948 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 .maxlen = sizeof(int),
2950 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002951 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002952 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002953 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002954};
2955
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002956struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
Daniel Lezcano760f2d02008-01-10 02:53:43 -08002957{
2958 struct ctl_table *table;
2959
2960 table = kmemdup(ipv6_route_table_template,
2961 sizeof(ipv6_route_table_template),
2962 GFP_KERNEL);
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09002963
2964 if (table) {
2965 table[0].data = &net->ipv6.sysctl.flush_delay;
Lucian Adrian Grijincuc486da32011-02-24 19:48:03 +00002966 table[0].extra1 = net;
Alexey Dobriyan86393e52009-08-29 01:34:49 +00002967 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09002968 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2969 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2970 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2971 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2972 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2973 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2974 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
Alexey Dobriyan9c69fab2009-12-18 20:11:03 -08002975 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
Eric W. Biederman464dc802012-11-16 03:02:59 +00002976
2977 /* Don't export sysctls to unprivileged users */
2978 if (net->user_ns != &init_user_ns)
2979 table[0].procname = NULL;
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09002980 }
2981
Daniel Lezcano760f2d02008-01-10 02:53:43 -08002982 return table;
2983}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984#endif
2985
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002986static int __net_init ip6_route_net_init(struct net *net)
Daniel Lezcanocdb18762008-03-04 13:45:33 -08002987{
Pavel Emelyanov633d424b2008-04-21 14:25:23 -07002988 int ret = -ENOMEM;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002989
Alexey Dobriyan86393e52009-08-29 01:34:49 +00002990 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
2991 sizeof(net->ipv6.ip6_dst_ops));
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08002992
Eric Dumazetfc66f952010-10-08 06:37:34 +00002993 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
2994 goto out_ip6_dst_ops;
2995
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002996 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
2997 sizeof(*net->ipv6.ip6_null_entry),
2998 GFP_KERNEL);
2999 if (!net->ipv6.ip6_null_entry)
Eric Dumazetfc66f952010-10-08 06:37:34 +00003000 goto out_ip6_dst_entries;
Changli Gaod8d1f302010-06-10 23:31:35 -07003001 net->ipv6.ip6_null_entry->dst.path =
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003002 (struct dst_entry *)net->ipv6.ip6_null_entry;
Changli Gaod8d1f302010-06-10 23:31:35 -07003003 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
David S. Miller62fa8a82011-01-26 20:51:05 -08003004 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3005 ip6_template_metrics, true);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003006
3007#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3008 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3009 sizeof(*net->ipv6.ip6_prohibit_entry),
3010 GFP_KERNEL);
Peter Zijlstra68fffc62008-10-07 14:12:10 -07003011 if (!net->ipv6.ip6_prohibit_entry)
3012 goto out_ip6_null_entry;
Changli Gaod8d1f302010-06-10 23:31:35 -07003013 net->ipv6.ip6_prohibit_entry->dst.path =
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003014 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
Changli Gaod8d1f302010-06-10 23:31:35 -07003015 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
David S. Miller62fa8a82011-01-26 20:51:05 -08003016 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3017 ip6_template_metrics, true);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003018
3019 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3020 sizeof(*net->ipv6.ip6_blk_hole_entry),
3021 GFP_KERNEL);
Peter Zijlstra68fffc62008-10-07 14:12:10 -07003022 if (!net->ipv6.ip6_blk_hole_entry)
3023 goto out_ip6_prohibit_entry;
Changli Gaod8d1f302010-06-10 23:31:35 -07003024 net->ipv6.ip6_blk_hole_entry->dst.path =
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003025 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
Changli Gaod8d1f302010-06-10 23:31:35 -07003026 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
David S. Miller62fa8a82011-01-26 20:51:05 -08003027 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3028 ip6_template_metrics, true);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003029#endif
3030
Peter Zijlstrab339a47c2008-10-07 14:15:00 -07003031 net->ipv6.sysctl.flush_delay = 0;
3032 net->ipv6.sysctl.ip6_rt_max_size = 4096;
3033 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3034 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3035 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3036 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3037 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3038 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3039
Benjamin Thery6891a342008-03-04 13:49:47 -08003040 net->ipv6.ip6_rt_gc_expire = 30*HZ;
3041
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003042 ret = 0;
3043out:
3044 return ret;
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08003045
Peter Zijlstra68fffc62008-10-07 14:12:10 -07003046#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3047out_ip6_prohibit_entry:
3048 kfree(net->ipv6.ip6_prohibit_entry);
3049out_ip6_null_entry:
3050 kfree(net->ipv6.ip6_null_entry);
3051#endif
Eric Dumazetfc66f952010-10-08 06:37:34 +00003052out_ip6_dst_entries:
3053 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08003054out_ip6_dst_ops:
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08003055 goto out;
Daniel Lezcanocdb18762008-03-04 13:45:33 -08003056}
3057
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00003058static void __net_exit ip6_route_net_exit(struct net *net)
Daniel Lezcanocdb18762008-03-04 13:45:33 -08003059{
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003060 kfree(net->ipv6.ip6_null_entry);
3061#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3062 kfree(net->ipv6.ip6_prohibit_entry);
3063 kfree(net->ipv6.ip6_blk_hole_entry);
3064#endif
Xiaotian Feng41bb78b2010-11-02 16:11:05 +00003065 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
Daniel Lezcanocdb18762008-03-04 13:45:33 -08003066}
3067
Thomas Grafd1896342012-06-18 12:08:33 +00003068static int __net_init ip6_route_net_init_late(struct net *net)
3069{
3070#ifdef CONFIG_PROC_FS
3071 proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);
3072 proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
3073#endif
3074 return 0;
3075}
3076
3077static void __net_exit ip6_route_net_exit_late(struct net *net)
3078{
3079#ifdef CONFIG_PROC_FS
3080 proc_net_remove(net, "ipv6_route");
3081 proc_net_remove(net, "rt6_stats");
3082#endif
3083}
3084
Daniel Lezcanocdb18762008-03-04 13:45:33 -08003085static struct pernet_operations ip6_route_net_ops = {
3086 .init = ip6_route_net_init,
3087 .exit = ip6_route_net_exit,
3088};
3089
David S. Millerc3426b42012-06-09 16:27:05 -07003090static int __net_init ipv6_inetpeer_init(struct net *net)
3091{
3092 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3093
3094 if (!bp)
3095 return -ENOMEM;
3096 inet_peer_base_init(bp);
3097 net->ipv6.peers = bp;
3098 return 0;
3099}
3100
3101static void __net_exit ipv6_inetpeer_exit(struct net *net)
3102{
3103 struct inet_peer_base *bp = net->ipv6.peers;
3104
3105 net->ipv6.peers = NULL;
David S. Miller56a6b242012-06-09 16:32:41 -07003106 inetpeer_invalidate_tree(bp);
David S. Millerc3426b42012-06-09 16:27:05 -07003107 kfree(bp);
3108}
3109
David S. Miller2b823f72012-06-09 19:00:16 -07003110static struct pernet_operations ipv6_inetpeer_ops = {
David S. Millerc3426b42012-06-09 16:27:05 -07003111 .init = ipv6_inetpeer_init,
3112 .exit = ipv6_inetpeer_exit,
3113};
3114
Thomas Grafd1896342012-06-18 12:08:33 +00003115static struct pernet_operations ip6_route_net_late_ops = {
3116 .init = ip6_route_net_init_late,
3117 .exit = ip6_route_net_exit_late,
3118};
3119
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003120static struct notifier_block ip6_route_dev_notifier = {
3121 .notifier_call = ip6_route_dev_notify,
3122 .priority = 0,
3123};
3124
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003125int __init ip6_route_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003126{
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003127 int ret;
3128
Daniel Lezcano9a7ec3a2008-03-04 13:48:53 -08003129 ret = -ENOMEM;
3130 ip6_dst_ops_template.kmem_cachep =
3131 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3132 SLAB_HWCACHE_ALIGN, NULL);
3133 if (!ip6_dst_ops_template.kmem_cachep)
Fernando Carrijoc19a28e2009-01-07 18:09:08 -08003134 goto out;
David S. Miller14e50e52007-05-24 18:17:54 -07003135
Eric Dumazetfc66f952010-10-08 06:37:34 +00003136 ret = dst_entries_init(&ip6_dst_blackhole_ops);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003137 if (ret)
Daniel Lezcanobdb32892008-03-04 13:48:10 -08003138 goto out_kmem_cache;
Daniel Lezcanobdb32892008-03-04 13:48:10 -08003139
David S. Millerc3426b42012-06-09 16:27:05 -07003140 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3141 if (ret)
David S. Millere8803b62012-06-16 01:12:19 -07003142 goto out_dst_entries;
Thomas Graf2a0c4512012-06-14 23:00:17 +00003143
David S. Miller7e52b332012-06-15 15:51:55 -07003144 ret = register_pernet_subsys(&ip6_route_net_ops);
3145 if (ret)
3146 goto out_register_inetpeer;
David S. Millerc3426b42012-06-09 16:27:05 -07003147
Arnaud Ebalard5dc121e2008-10-01 02:37:56 -07003148 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3149
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003150 /* Registering of the loopback is done before this portion of code,
3151 * the loopback reference in rt6_info will not be taken, do it
3152 * manually for init_net */
Changli Gaod8d1f302010-06-10 23:31:35 -07003153 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003154 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3155 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
Changli Gaod8d1f302010-06-10 23:31:35 -07003156 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003157 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
Changli Gaod8d1f302010-06-10 23:31:35 -07003158 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003159 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3160 #endif
David S. Millere8803b62012-06-16 01:12:19 -07003161 ret = fib6_init();
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003162 if (ret)
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003163 goto out_register_subsys;
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003164
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003165 ret = xfrm6_init();
3166 if (ret)
David S. Millere8803b62012-06-16 01:12:19 -07003167 goto out_fib6_init;
Daniel Lezcanoc35b7e72007-12-08 00:14:11 -08003168
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003169 ret = fib6_rules_init();
3170 if (ret)
3171 goto xfrm6_init;
Daniel Lezcano7e5449c2007-12-08 00:14:54 -08003172
Thomas Grafd1896342012-06-18 12:08:33 +00003173 ret = register_pernet_subsys(&ip6_route_net_late_ops);
3174 if (ret)
3175 goto fib6_rules_init;
3176
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003177 ret = -ENOBUFS;
Greg Rosec7ac8672011-06-10 01:27:09 +00003178 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3179 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3180 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
Thomas Grafd1896342012-06-18 12:08:33 +00003181 goto out_register_late_subsys;
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003182
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003183 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
Daniel Lezcanocdb18762008-03-04 13:45:33 -08003184 if (ret)
Thomas Grafd1896342012-06-18 12:08:33 +00003185 goto out_register_late_subsys;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003186
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003187out:
3188 return ret;
3189
Thomas Grafd1896342012-06-18 12:08:33 +00003190out_register_late_subsys:
3191 unregister_pernet_subsys(&ip6_route_net_late_ops);
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003192fib6_rules_init:
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003193 fib6_rules_cleanup();
3194xfrm6_init:
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003195 xfrm6_fini();
Thomas Graf2a0c4512012-06-14 23:00:17 +00003196out_fib6_init:
3197 fib6_gc_cleanup();
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003198out_register_subsys:
3199 unregister_pernet_subsys(&ip6_route_net_ops);
David S. Miller7e52b332012-06-15 15:51:55 -07003200out_register_inetpeer:
3201 unregister_pernet_subsys(&ipv6_inetpeer_ops);
Eric Dumazetfc66f952010-10-08 06:37:34 +00003202out_dst_entries:
3203 dst_entries_destroy(&ip6_dst_blackhole_ops);
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003204out_kmem_cache:
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08003205 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003206 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207}
3208
3209void ip6_route_cleanup(void)
3210{
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003211 unregister_netdevice_notifier(&ip6_route_dev_notifier);
Thomas Grafd1896342012-06-18 12:08:33 +00003212 unregister_pernet_subsys(&ip6_route_net_late_ops);
Thomas Graf101367c2006-08-04 03:39:02 -07003213 fib6_rules_cleanup();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003214 xfrm6_fini();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003215 fib6_gc_cleanup();
David S. Millerc3426b42012-06-09 16:27:05 -07003216 unregister_pernet_subsys(&ipv6_inetpeer_ops);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003217 unregister_pernet_subsys(&ip6_route_net_ops);
Xiaotian Feng41bb78b2010-11-02 16:11:05 +00003218 dst_entries_destroy(&ip6_dst_blackhole_ops);
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08003219 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003220}