blob: fe742fa0f7ff2f8f3d3aea4eceb2fe2701577423 [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
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +020068enum rt6_nud_state {
Jiri Benc7e980562013-12-11 13:48:20 +010069 RT6_NUD_FAIL_HARD = -3,
70 RT6_NUD_FAIL_PROBE = -2,
71 RT6_NUD_FAIL_DO_RR = -1,
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +020072 RT6_NUD_SUCCEED = 1
73};
74
Gao feng1716a962012-04-06 00:13:10 +000075static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
Eric Dumazet21efcfa2011-07-19 20:18:36 +000076 const struct in6_addr *dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
David S. Miller0dbaee32010-12-13 12:52:14 -080078static unsigned int ip6_default_advmss(const struct dst_entry *dst);
Steffen Klassertebb762f2011-11-23 02:12:51 +000079static unsigned int ip6_mtu(const struct dst_entry *dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -070080static struct dst_entry *ip6_negative_advice(struct dst_entry *);
81static void ip6_dst_destroy(struct dst_entry *);
82static void ip6_dst_ifdown(struct dst_entry *,
83 struct net_device *dev, int how);
Daniel Lezcano569d3642008-01-18 03:56:57 -080084static int ip6_dst_gc(struct dst_ops *ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
86static int ip6_pkt_discard(struct sk_buff *skb);
Eric Dumazetaad88722014-04-15 13:47:15 -040087static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb);
Kamala R7150aed2013-12-02 19:55:21 +053088static int ip6_pkt_prohibit(struct sk_buff *skb);
Eric Dumazetaad88722014-04-15 13:47:15 -040089static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090static void ip6_link_failure(struct sk_buff *skb);
David S. Miller6700c272012-07-17 03:29:28 -070091static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
92 struct sk_buff *skb, u32 mtu);
93static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
94 struct sk_buff *skb);
Nicolas Dichtel52bd4c02013-06-28 17:35:48 +020095static int rt6_score_route(struct rt6_info *rt, int oif, int strict);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -080097#ifdef CONFIG_IPV6_ROUTE_INFO
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -080098static struct rt6_info *rt6_add_route_info(struct net *net,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000099 const struct in6_addr *prefix, int prefixlen,
100 const struct in6_addr *gwaddr, int ifindex,
Eric Dumazet95c96172012-04-15 05:58:06 +0000101 unsigned int pref);
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -0800102static struct rt6_info *rt6_get_route_info(struct net *net,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000103 const struct in6_addr *prefix, int prefixlen,
104 const struct in6_addr *gwaddr, int ifindex);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800105#endif
106
stephen hemmingere8243532013-12-29 14:03:31 -0800107static void rt6_bind_peer(struct rt6_info *rt, int create)
108{
109 struct inet_peer_base *base;
110 struct inet_peer *peer;
111
112 base = inetpeer_base_ptr(rt->_rt6i_peer);
113 if (!base)
114 return;
115
116 peer = inet_getpeer_v6(base, &rt->rt6i_dst.addr, create);
117 if (peer) {
118 if (!rt6_set_peer(rt, peer))
119 inet_putpeer(peer);
120 }
121}
122
123static struct inet_peer *__rt6_get_peer(struct rt6_info *rt, int create)
124{
125 if (rt6_has_peer(rt))
126 return rt6_peer_ptr(rt);
127
128 rt6_bind_peer(rt, create);
129 return (rt6_has_peer(rt) ? rt6_peer_ptr(rt) : NULL);
130}
131
132static struct inet_peer *rt6_get_peer_create(struct rt6_info *rt)
133{
134 return __rt6_get_peer(rt, 1);
135}
136
David S. Miller06582542011-01-27 14:58:42 -0800137static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
138{
139 struct rt6_info *rt = (struct rt6_info *) dst;
140 struct inet_peer *peer;
141 u32 *p = NULL;
142
Yan, Zheng8e2ec632011-09-05 21:34:30 +0000143 if (!(rt->dst.flags & DST_HOST))
Martin KaFai Lau3b471172015-02-12 16:14:08 -0800144 return dst_cow_metrics_generic(dst, old);
Yan, Zheng8e2ec632011-09-05 21:34:30 +0000145
David S. Millerfbfe95a2012-06-08 23:24:18 -0700146 peer = rt6_get_peer_create(rt);
David S. Miller06582542011-01-27 14:58:42 -0800147 if (peer) {
148 u32 *old_p = __DST_METRICS_PTR(old);
149 unsigned long prev, new;
150
151 p = peer->metrics;
Michal Kubečeke5fd3872014-03-27 13:04:08 +0100152 if (inet_metrics_new(peer) ||
153 (old & DST_METRICS_FORCE_OVERWRITE))
David S. Miller06582542011-01-27 14:58:42 -0800154 memcpy(p, old_p, sizeof(u32) * RTAX_MAX);
155
156 new = (unsigned long) p;
157 prev = cmpxchg(&dst->_metrics, old, new);
158
159 if (prev != old) {
160 p = __DST_METRICS_PTR(prev);
161 if (prev & DST_METRICS_READ_ONLY)
162 p = NULL;
163 }
164 }
165 return p;
166}
167
David S. Millerf894cbf2012-07-02 21:52:24 -0700168static inline const void *choose_neigh_daddr(struct rt6_info *rt,
169 struct sk_buff *skb,
170 const void *daddr)
David S. Miller39232972012-01-26 15:22:32 -0500171{
172 struct in6_addr *p = &rt->rt6i_gateway;
173
David S. Millera7563f32012-01-26 16:29:16 -0500174 if (!ipv6_addr_any(p))
David S. Miller39232972012-01-26 15:22:32 -0500175 return (const void *) p;
David S. Millerf894cbf2012-07-02 21:52:24 -0700176 else if (skb)
177 return &ipv6_hdr(skb)->daddr;
David S. Miller39232972012-01-26 15:22:32 -0500178 return daddr;
179}
180
David S. Millerf894cbf2012-07-02 21:52:24 -0700181static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
182 struct sk_buff *skb,
183 const void *daddr)
David S. Millerd3aaeb32011-07-18 00:40:17 -0700184{
David S. Miller39232972012-01-26 15:22:32 -0500185 struct rt6_info *rt = (struct rt6_info *) dst;
186 struct neighbour *n;
187
David S. Millerf894cbf2012-07-02 21:52:24 -0700188 daddr = choose_neigh_daddr(rt, skb, daddr);
YOSHIFUJI Hideaki / 吉藤英明8e022ee2013-01-17 12:53:09 +0000189 n = __ipv6_neigh_lookup(dst->dev, daddr);
David S. Millerf83c7792011-12-28 15:41:23 -0500190 if (n)
191 return n;
192 return neigh_create(&nd_tbl, daddr, dst->dev);
193}
194
Daniel Lezcano9a7ec3a2008-03-04 13:48:53 -0800195static struct dst_ops ip6_dst_ops_template = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 .family = AF_INET6,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 .gc = ip6_dst_gc,
198 .gc_thresh = 1024,
199 .check = ip6_dst_check,
David S. Miller0dbaee32010-12-13 12:52:14 -0800200 .default_advmss = ip6_default_advmss,
Steffen Klassertebb762f2011-11-23 02:12:51 +0000201 .mtu = ip6_mtu,
David S. Miller06582542011-01-27 14:58:42 -0800202 .cow_metrics = ipv6_cow_metrics,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 .destroy = ip6_dst_destroy,
204 .ifdown = ip6_dst_ifdown,
205 .negative_advice = ip6_negative_advice,
206 .link_failure = ip6_link_failure,
207 .update_pmtu = ip6_rt_update_pmtu,
David S. Miller6e157b62012-07-12 00:05:02 -0700208 .redirect = rt6_do_redirect,
Herbert Xu1ac06e02008-05-20 14:32:14 -0700209 .local_out = __ip6_local_out,
David S. Millerd3aaeb32011-07-18 00:40:17 -0700210 .neigh_lookup = ip6_neigh_lookup,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211};
212
Steffen Klassertebb762f2011-11-23 02:12:51 +0000213static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
Roland Dreierec831ea2011-01-31 13:16:00 -0800214{
Steffen Klassert618f9bc2011-11-23 02:13:31 +0000215 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
216
217 return mtu ? : dst->dev->mtu;
Roland Dreierec831ea2011-01-31 13:16:00 -0800218}
219
David S. Miller6700c272012-07-17 03:29:28 -0700220static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
221 struct sk_buff *skb, u32 mtu)
David S. Miller14e50e52007-05-24 18:17:54 -0700222{
223}
224
David S. Miller6700c272012-07-17 03:29:28 -0700225static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
226 struct sk_buff *skb)
David S. Millerb587ee32012-07-12 00:39:24 -0700227{
228}
229
Held Bernhard0972ddb2011-04-24 22:07:32 +0000230static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,
231 unsigned long old)
232{
233 return NULL;
234}
235
David S. Miller14e50e52007-05-24 18:17:54 -0700236static struct dst_ops ip6_dst_blackhole_ops = {
237 .family = AF_INET6,
David S. Miller14e50e52007-05-24 18:17:54 -0700238 .destroy = ip6_dst_destroy,
239 .check = ip6_dst_check,
Steffen Klassertebb762f2011-11-23 02:12:51 +0000240 .mtu = ip6_blackhole_mtu,
Eric Dumazet214f45c2011-02-18 11:39:01 -0800241 .default_advmss = ip6_default_advmss,
David S. Miller14e50e52007-05-24 18:17:54 -0700242 .update_pmtu = ip6_rt_blackhole_update_pmtu,
David S. Millerb587ee32012-07-12 00:39:24 -0700243 .redirect = ip6_rt_blackhole_redirect,
Held Bernhard0972ddb2011-04-24 22:07:32 +0000244 .cow_metrics = ip6_rt_blackhole_cow_metrics,
David S. Millerd3aaeb32011-07-18 00:40:17 -0700245 .neigh_lookup = ip6_neigh_lookup,
David S. Miller14e50e52007-05-24 18:17:54 -0700246};
247
David S. Miller62fa8a82011-01-26 20:51:05 -0800248static const u32 ip6_template_metrics[RTAX_MAX] = {
Li RongQing14edd872012-10-24 14:01:18 +0800249 [RTAX_HOPLIMIT - 1] = 0,
David S. Miller62fa8a82011-01-26 20:51:05 -0800250};
251
Eric Dumazetfb0af4c2012-09-11 21:47:51 +0000252static const struct rt6_info ip6_null_entry_template = {
Changli Gaod8d1f302010-06-10 23:31:35 -0700253 .dst = {
254 .__refcnt = ATOMIC_INIT(1),
255 .__use = 1,
Nicolas Dichtel2c20cbd2012-09-10 22:09:47 +0000256 .obsolete = DST_OBSOLETE_FORCE_CHK,
Changli Gaod8d1f302010-06-10 23:31:35 -0700257 .error = -ENETUNREACH,
Changli Gaod8d1f302010-06-10 23:31:35 -0700258 .input = ip6_pkt_discard,
259 .output = ip6_pkt_discard_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 },
261 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
Jean-Mickael Guerin4f724272009-05-20 17:38:59 -0700262 .rt6i_protocol = RTPROT_KERNEL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 .rt6i_metric = ~(u32) 0,
264 .rt6i_ref = ATOMIC_INIT(1),
265};
266
Thomas Graf101367c2006-08-04 03:39:02 -0700267#ifdef CONFIG_IPV6_MULTIPLE_TABLES
268
Eric Dumazetfb0af4c2012-09-11 21:47:51 +0000269static const struct rt6_info ip6_prohibit_entry_template = {
Changli Gaod8d1f302010-06-10 23:31:35 -0700270 .dst = {
271 .__refcnt = ATOMIC_INIT(1),
272 .__use = 1,
Nicolas Dichtel2c20cbd2012-09-10 22:09:47 +0000273 .obsolete = DST_OBSOLETE_FORCE_CHK,
Changli Gaod8d1f302010-06-10 23:31:35 -0700274 .error = -EACCES,
Changli Gaod8d1f302010-06-10 23:31:35 -0700275 .input = ip6_pkt_prohibit,
276 .output = ip6_pkt_prohibit_out,
Thomas Graf101367c2006-08-04 03:39:02 -0700277 },
278 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
Jean-Mickael Guerin4f724272009-05-20 17:38:59 -0700279 .rt6i_protocol = RTPROT_KERNEL,
Thomas Graf101367c2006-08-04 03:39:02 -0700280 .rt6i_metric = ~(u32) 0,
281 .rt6i_ref = ATOMIC_INIT(1),
282};
283
Eric Dumazetfb0af4c2012-09-11 21:47:51 +0000284static const struct rt6_info ip6_blk_hole_entry_template = {
Changli Gaod8d1f302010-06-10 23:31:35 -0700285 .dst = {
286 .__refcnt = ATOMIC_INIT(1),
287 .__use = 1,
Nicolas Dichtel2c20cbd2012-09-10 22:09:47 +0000288 .obsolete = DST_OBSOLETE_FORCE_CHK,
Changli Gaod8d1f302010-06-10 23:31:35 -0700289 .error = -EINVAL,
Changli Gaod8d1f302010-06-10 23:31:35 -0700290 .input = dst_discard,
Eric Dumazetaad88722014-04-15 13:47:15 -0400291 .output = dst_discard_sk,
Thomas Graf101367c2006-08-04 03:39:02 -0700292 },
293 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
Jean-Mickael Guerin4f724272009-05-20 17:38:59 -0700294 .rt6i_protocol = RTPROT_KERNEL,
Thomas Graf101367c2006-08-04 03:39:02 -0700295 .rt6i_metric = ~(u32) 0,
296 .rt6i_ref = ATOMIC_INIT(1),
297};
298
299#endif
300
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301/* allocate dst with ip6_dst_ops */
David S. Miller97bab732012-06-09 22:36:36 -0700302static inline struct rt6_info *ip6_dst_alloc(struct net *net,
David S. Miller957c6652011-06-24 15:25:00 -0700303 struct net_device *dev,
David S. Miller8b96d222012-06-11 02:01:56 -0700304 int flags,
305 struct fib6_table *table)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306{
David S. Miller97bab732012-06-09 22:36:36 -0700307 struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
Nicolas Dichtel6f3118b2012-09-10 22:09:46 +0000308 0, DST_OBSOLETE_FORCE_CHK, flags);
David S. Millercf911662011-04-28 14:31:47 -0700309
David S. Miller97bab732012-06-09 22:36:36 -0700310 if (rt) {
Steffen Klassert81048912012-07-05 23:37:09 +0000311 struct dst_entry *dst = &rt->dst;
312
313 memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
David S. Miller8b96d222012-06-11 02:01:56 -0700314 rt6_init_peer(rt, table ? &table->tb6_peers : net->ipv6.peers);
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000315 INIT_LIST_HEAD(&rt->rt6i_siblings);
David S. Miller97bab732012-06-09 22:36:36 -0700316 }
David S. Millercf911662011-04-28 14:31:47 -0700317 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318}
319
320static void ip6_dst_destroy(struct dst_entry *dst)
321{
322 struct rt6_info *rt = (struct rt6_info *)dst;
323 struct inet6_dev *idev = rt->rt6i_idev;
YOSHIFUJI Hideaki / 吉藤英明ecd98832013-02-20 00:29:08 +0000324 struct dst_entry *from = dst->from;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
Yan, Zheng8e2ec632011-09-05 21:34:30 +0000326 if (!(rt->dst.flags & DST_HOST))
327 dst_destroy_metrics_generic(dst);
328
David S. Miller38308472011-12-03 18:02:47 -0500329 if (idev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 rt->rt6i_idev = NULL;
331 in6_dev_put(idev);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900332 }
Gao feng1716a962012-04-06 00:13:10 +0000333
YOSHIFUJI Hideaki / 吉藤英明ecd98832013-02-20 00:29:08 +0000334 dst->from = NULL;
335 dst_release(from);
Gao feng1716a962012-04-06 00:13:10 +0000336
David S. Miller97bab732012-06-09 22:36:36 -0700337 if (rt6_has_peer(rt)) {
338 struct inet_peer *peer = rt6_peer_ptr(rt);
David S. Millerb3419362010-11-30 12:27:11 -0800339 inet_putpeer(peer);
340 }
341}
342
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
344 int how)
345{
346 struct rt6_info *rt = (struct rt6_info *)dst;
347 struct inet6_dev *idev = rt->rt6i_idev;
Denis V. Lunev5a3e55d2007-12-07 00:38:10 -0800348 struct net_device *loopback_dev =
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900349 dev_net(dev)->loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
David S. Miller97cac082012-07-02 22:43:47 -0700351 if (dev != loopback_dev) {
352 if (idev && idev->dev == dev) {
353 struct inet6_dev *loopback_idev =
354 in6_dev_get(loopback_dev);
355 if (loopback_idev) {
356 rt->rt6i_idev = loopback_idev;
357 in6_dev_put(idev);
358 }
359 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 }
361}
362
Eric Dumazeta50feda2012-05-18 18:57:34 +0000363static bool rt6_check_expired(const struct rt6_info *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364{
Gao feng1716a962012-04-06 00:13:10 +0000365 if (rt->rt6i_flags & RTF_EXPIRES) {
366 if (time_after(jiffies, rt->dst.expires))
Eric Dumazeta50feda2012-05-18 18:57:34 +0000367 return true;
Gao feng1716a962012-04-06 00:13:10 +0000368 } else if (rt->dst.from) {
Li RongQing3fd91fb2012-09-13 19:54:57 +0000369 return rt6_check_expired((struct rt6_info *) rt->dst.from);
Gao feng1716a962012-04-06 00:13:10 +0000370 }
Eric Dumazeta50feda2012-05-18 18:57:34 +0000371 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372}
373
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000374/* Multipath route selection:
375 * Hash based function using packet header and flowlabel.
376 * Adapted from fib_info_hashfn()
377 */
378static int rt6_info_hash_nhsfn(unsigned int candidate_count,
379 const struct flowi6 *fl6)
380{
381 unsigned int val = fl6->flowi6_proto;
382
YOSHIFUJI Hideaki / 吉藤英明c08977b2013-01-13 05:02:29 +0000383 val ^= ipv6_addr_hash(&fl6->daddr);
384 val ^= ipv6_addr_hash(&fl6->saddr);
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000385
386 /* Work only if this not encapsulated */
387 switch (fl6->flowi6_proto) {
388 case IPPROTO_UDP:
389 case IPPROTO_TCP:
390 case IPPROTO_SCTP:
Nicolas Dichtelb3ce5ae2012-10-22 23:35:06 +0000391 val ^= (__force u16)fl6->fl6_sport;
392 val ^= (__force u16)fl6->fl6_dport;
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000393 break;
394
395 case IPPROTO_ICMPV6:
Nicolas Dichtelb3ce5ae2012-10-22 23:35:06 +0000396 val ^= (__force u16)fl6->fl6_icmp_type;
397 val ^= (__force u16)fl6->fl6_icmp_code;
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000398 break;
399 }
400 /* RFC6438 recommands to use flowlabel */
Nicolas Dichtelb3ce5ae2012-10-22 23:35:06 +0000401 val ^= (__force u32)fl6->flowlabel;
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000402
403 /* Perhaps, we need to tune, this function? */
404 val = val ^ (val >> 7) ^ (val >> 12);
405 return val % candidate_count;
406}
407
408static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
Nicolas Dichtel52bd4c02013-06-28 17:35:48 +0200409 struct flowi6 *fl6, int oif,
410 int strict)
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000411{
412 struct rt6_info *sibling, *next_sibling;
413 int route_choosen;
414
415 route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
416 /* Don't change the route, if route_choosen == 0
417 * (siblings does not include ourself)
418 */
419 if (route_choosen)
420 list_for_each_entry_safe(sibling, next_sibling,
421 &match->rt6i_siblings, rt6i_siblings) {
422 route_choosen--;
423 if (route_choosen == 0) {
Nicolas Dichtel52bd4c02013-06-28 17:35:48 +0200424 if (rt6_score_route(sibling, oif, strict) < 0)
425 break;
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000426 match = sibling;
427 break;
428 }
429 }
430 return match;
431}
432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433/*
Thomas Grafc71099a2006-08-04 23:20:06 -0700434 * Route lookup. Any table->tb6_lock is implied.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 */
436
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800437static inline struct rt6_info *rt6_device_match(struct net *net,
438 struct rt6_info *rt,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000439 const struct in6_addr *saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 int oif,
YOSHIFUJI Hideakid4208952008-06-27 20:14:54 -0700441 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442{
443 struct rt6_info *local = NULL;
444 struct rt6_info *sprt;
445
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900446 if (!oif && ipv6_addr_any(saddr))
447 goto out;
448
Changli Gaod8d1f302010-06-10 23:31:35 -0700449 for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
David S. Millerd1918542011-12-28 20:19:20 -0500450 struct net_device *dev = sprt->dst.dev;
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900451
452 if (oif) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 if (dev->ifindex == oif)
454 return sprt;
455 if (dev->flags & IFF_LOOPBACK) {
David S. Miller38308472011-12-03 18:02:47 -0500456 if (!sprt->rt6i_idev ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 sprt->rt6i_idev->dev->ifindex != oif) {
YOSHIFUJI Hideakid4208952008-06-27 20:14:54 -0700458 if (flags & RT6_LOOKUP_F_IFACE && oif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 continue;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900460 if (local && (!oif ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 local->rt6i_idev->dev->ifindex == oif))
462 continue;
463 }
464 local = sprt;
465 }
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900466 } else {
467 if (ipv6_chk_addr(net, saddr, dev,
468 flags & RT6_LOOKUP_F_IFACE))
469 return sprt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 }
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900471 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900473 if (oif) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 if (local)
475 return local;
476
YOSHIFUJI Hideakid4208952008-06-27 20:14:54 -0700477 if (flags & RT6_LOOKUP_F_IFACE)
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800478 return net->ipv6.ip6_null_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 }
YOSHIFUJI Hideakidd3abc42008-07-02 18:30:18 +0900480out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 return rt;
482}
483
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800484#ifdef CONFIG_IPV6_ROUTER_PREF
Hannes Frederic Sowac2f17e82013-10-21 06:17:15 +0200485struct __rt6_probe_work {
486 struct work_struct work;
487 struct in6_addr target;
488 struct net_device *dev;
489};
490
491static void rt6_probe_deferred(struct work_struct *w)
492{
493 struct in6_addr mcaddr;
494 struct __rt6_probe_work *work =
495 container_of(w, struct __rt6_probe_work, work);
496
497 addrconf_addr_solict_mult(&work->target, &mcaddr);
498 ndisc_send_ns(work->dev, NULL, &work->target, &mcaddr, NULL);
499 dev_put(work->dev);
Michael Büsch662f5532015-02-08 10:14:07 +0100500 kfree(work);
Hannes Frederic Sowac2f17e82013-10-21 06:17:15 +0200501}
502
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800503static void rt6_probe(struct rt6_info *rt)
504{
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000505 struct neighbour *neigh;
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800506 /*
507 * Okay, this does not seem to be appropriate
508 * for now, however, we need to check if it
509 * is really so; aka Router Reachability Probing.
510 *
511 * Router Reachability Probe MUST be rate-limited
512 * to no more than one per minute.
513 */
YOSHIFUJI Hideaki / 吉藤英明2152cae2013-01-17 12:53:43 +0000514 if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))
Amerigo Wangfdd66812012-09-10 02:48:44 +0000515 return;
YOSHIFUJI Hideaki / 吉藤英明2152cae2013-01-17 12:53:43 +0000516 rcu_read_lock_bh();
517 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
518 if (neigh) {
519 write_lock(&neigh->lock);
520 if (neigh->nud_state & NUD_VALID)
521 goto out;
YOSHIFUJI Hideaki / 吉藤英明7ff74a52013-01-17 12:53:02 +0000522 }
YOSHIFUJI Hideaki / 吉藤英明2152cae2013-01-17 12:53:43 +0000523
524 if (!neigh ||
YOSHIFUJI Hideaki52e16352006-03-20 17:05:47 -0800525 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
Hannes Frederic Sowac2f17e82013-10-21 06:17:15 +0200526 struct __rt6_probe_work *work;
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800527
Hannes Frederic Sowac2f17e82013-10-21 06:17:15 +0200528 work = kmalloc(sizeof(*work), GFP_ATOMIC);
529
530 if (neigh && work)
Jiri Benc7e980562013-12-11 13:48:20 +0100531 __neigh_set_probe_once(neigh);
YOSHIFUJI Hideaki / 吉藤英明2152cae2013-01-17 12:53:43 +0000532
Hannes Frederic Sowac2f17e82013-10-21 06:17:15 +0200533 if (neigh)
534 write_unlock(&neigh->lock);
535
536 if (work) {
537 INIT_WORK(&work->work, rt6_probe_deferred);
538 work->target = rt->rt6i_gateway;
539 dev_hold(rt->dst.dev);
540 work->dev = rt->dst.dev;
541 schedule_work(&work->work);
542 }
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000543 } else {
YOSHIFUJI Hideaki / 吉藤英明2152cae2013-01-17 12:53:43 +0000544out:
545 write_unlock(&neigh->lock);
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000546 }
YOSHIFUJI Hideaki / 吉藤英明2152cae2013-01-17 12:53:43 +0000547 rcu_read_unlock_bh();
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800548}
549#else
550static inline void rt6_probe(struct rt6_info *rt)
551{
YOSHIFUJI Hideaki27097252006-03-20 17:05:13 -0800552}
553#endif
554
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555/*
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800556 * Default Router Selection (RFC 2461 6.3.6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 */
Dave Jonesb6f99a22007-03-22 12:27:49 -0700558static inline int rt6_check_dev(struct rt6_info *rt, int oif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559{
David S. Millerd1918542011-12-28 20:19:20 -0500560 struct net_device *dev = rt->dst.dev;
David S. Miller161980f2007-04-06 11:42:27 -0700561 if (!oif || dev->ifindex == oif)
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800562 return 2;
David S. Miller161980f2007-04-06 11:42:27 -0700563 if ((dev->flags & IFF_LOOPBACK) &&
564 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
565 return 1;
566 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567}
568
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200569static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570{
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000571 struct neighbour *neigh;
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200572 enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000573
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700574 if (rt->rt6i_flags & RTF_NONEXTHOP ||
575 !(rt->rt6i_flags & RTF_GATEWAY))
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200576 return RT6_NUD_SUCCEED;
YOSHIFUJI Hideaki / 吉藤英明145a3622013-01-17 12:53:38 +0000577
578 rcu_read_lock_bh();
579 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
580 if (neigh) {
581 read_lock(&neigh->lock);
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800582 if (neigh->nud_state & NUD_VALID)
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200583 ret = RT6_NUD_SUCCEED;
YOSHIFUJI Hideaki398bcbe2008-01-19 00:35:16 -0800584#ifdef CONFIG_IPV6_ROUTER_PREF
Paul Marksa5a81f02012-12-03 10:26:54 +0000585 else if (!(neigh->nud_state & NUD_FAILED))
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200586 ret = RT6_NUD_SUCCEED;
Jiri Benc7e980562013-12-11 13:48:20 +0100587 else
588 ret = RT6_NUD_FAIL_PROBE;
YOSHIFUJI Hideaki398bcbe2008-01-19 00:35:16 -0800589#endif
YOSHIFUJI Hideaki / 吉藤英明145a3622013-01-17 12:53:38 +0000590 read_unlock(&neigh->lock);
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200591 } else {
592 ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
Jiri Benc7e980562013-12-11 13:48:20 +0100593 RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;
Paul Marksa5a81f02012-12-03 10:26:54 +0000594 }
YOSHIFUJI Hideaki / 吉藤英明145a3622013-01-17 12:53:38 +0000595 rcu_read_unlock_bh();
596
Paul Marksa5a81f02012-12-03 10:26:54 +0000597 return ret;
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800598}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800600static int rt6_score_route(struct rt6_info *rt, int oif,
601 int strict)
602{
Paul Marksa5a81f02012-12-03 10:26:54 +0000603 int m;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900604
YOSHIFUJI Hideaki4d0c5912006-05-26 13:23:41 -0700605 m = rt6_check_dev(rt, oif);
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700606 if (!m && (strict & RT6_LOOKUP_F_IFACE))
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200607 return RT6_NUD_FAIL_HARD;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -0800608#ifdef CONFIG_IPV6_ROUTER_PREF
609 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
610#endif
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200611 if (strict & RT6_LOOKUP_F_REACHABLE) {
612 int n = rt6_check_neigh(rt);
613 if (n < 0)
614 return n;
615 }
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800616 return m;
617}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
David S. Millerf11e6652007-03-24 20:36:25 -0700619static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200620 int *mpri, struct rt6_info *match,
621 bool *do_rr)
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800622{
David S. Millerf11e6652007-03-24 20:36:25 -0700623 int m;
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200624 bool match_do_rr = false;
David S. Millerf11e6652007-03-24 20:36:25 -0700625
626 if (rt6_check_expired(rt))
627 goto out;
628
629 m = rt6_score_route(rt, oif, strict);
Jiri Benc7e980562013-12-11 13:48:20 +0100630 if (m == RT6_NUD_FAIL_DO_RR) {
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200631 match_do_rr = true;
632 m = 0; /* lowest valid score */
Jiri Benc7e980562013-12-11 13:48:20 +0100633 } else if (m == RT6_NUD_FAIL_HARD) {
David S. Millerf11e6652007-03-24 20:36:25 -0700634 goto out;
David S. Millerf11e6652007-03-24 20:36:25 -0700635 }
636
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200637 if (strict & RT6_LOOKUP_F_REACHABLE)
638 rt6_probe(rt);
639
Jiri Benc7e980562013-12-11 13:48:20 +0100640 /* note that m can be RT6_NUD_FAIL_PROBE at this point */
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200641 if (m > *mpri) {
642 *do_rr = match_do_rr;
643 *mpri = m;
644 match = rt;
645 }
David S. Millerf11e6652007-03-24 20:36:25 -0700646out:
647 return match;
648}
649
650static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
651 struct rt6_info *rr_head,
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200652 u32 metric, int oif, int strict,
653 bool *do_rr)
David S. Millerf11e6652007-03-24 20:36:25 -0700654{
655 struct rt6_info *rt, *match;
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800656 int mpri = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
David S. Millerf11e6652007-03-24 20:36:25 -0700658 match = NULL;
659 for (rt = rr_head; rt && rt->rt6i_metric == metric;
Changli Gaod8d1f302010-06-10 23:31:35 -0700660 rt = rt->dst.rt6_next)
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200661 match = find_match(rt, oif, strict, &mpri, match, do_rr);
David S. Millerf11e6652007-03-24 20:36:25 -0700662 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
Changli Gaod8d1f302010-06-10 23:31:35 -0700663 rt = rt->dst.rt6_next)
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200664 match = find_match(rt, oif, strict, &mpri, match, do_rr);
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800665
David S. Millerf11e6652007-03-24 20:36:25 -0700666 return match;
667}
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800668
David S. Millerf11e6652007-03-24 20:36:25 -0700669static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
670{
671 struct rt6_info *match, *rt0;
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800672 struct net *net;
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200673 bool do_rr = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674
David S. Millerf11e6652007-03-24 20:36:25 -0700675 rt0 = fn->rr_ptr;
676 if (!rt0)
677 fn->rr_ptr = rt0 = fn->leaf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200679 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
680 &do_rr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
Hannes Frederic Sowaafc154e2013-07-11 12:43:42 +0200682 if (do_rr) {
Changli Gaod8d1f302010-06-10 23:31:35 -0700683 struct rt6_info *next = rt0->dst.rt6_next;
David S. Millerf11e6652007-03-24 20:36:25 -0700684
YOSHIFUJI Hideaki554cfb72006-03-20 17:00:26 -0800685 /* no entries matched; do round-robin */
David S. Millerf11e6652007-03-24 20:36:25 -0700686 if (!next || next->rt6i_metric != rt0->rt6i_metric)
687 next = fn->leaf;
688
689 if (next != rt0)
690 fn->rr_ptr = next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 }
692
David S. Millerd1918542011-12-28 20:19:20 -0500693 net = dev_net(rt0->dst.dev);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000694 return match ? match : net->ipv6.ip6_null_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695}
696
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800697#ifdef CONFIG_IPV6_ROUTE_INFO
698int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000699 const struct in6_addr *gwaddr)
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800700{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900701 struct net *net = dev_net(dev);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800702 struct route_info *rinfo = (struct route_info *) opt;
703 struct in6_addr prefix_buf, *prefix;
704 unsigned int pref;
YOSHIFUJI Hideaki4bed72e2008-05-27 17:37:49 +0900705 unsigned long lifetime;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800706 struct rt6_info *rt;
707
708 if (len < sizeof(struct route_info)) {
709 return -EINVAL;
710 }
711
712 /* Sanity check for prefix_len and length */
713 if (rinfo->length > 3) {
714 return -EINVAL;
715 } else if (rinfo->prefix_len > 128) {
716 return -EINVAL;
717 } else if (rinfo->prefix_len > 64) {
718 if (rinfo->length < 2) {
719 return -EINVAL;
720 }
721 } else if (rinfo->prefix_len > 0) {
722 if (rinfo->length < 1) {
723 return -EINVAL;
724 }
725 }
726
727 pref = rinfo->route_pref;
728 if (pref == ICMPV6_ROUTER_PREF_INVALID)
Jens Rosenboom3933fc92009-09-10 06:25:11 +0000729 return -EINVAL;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800730
YOSHIFUJI Hideaki4bed72e2008-05-27 17:37:49 +0900731 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800732
733 if (rinfo->length == 3)
734 prefix = (struct in6_addr *)rinfo->prefix;
735 else {
736 /* this function is safe */
737 ipv6_addr_prefix(&prefix_buf,
738 (struct in6_addr *)rinfo->prefix,
739 rinfo->prefix_len);
740 prefix = &prefix_buf;
741 }
742
Duan Jiongf104a562013-11-08 09:56:53 +0800743 if (rinfo->prefix_len == 0)
744 rt = rt6_get_dflt_router(gwaddr, dev);
745 else
746 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,
747 gwaddr, dev->ifindex);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800748
749 if (rt && !lifetime) {
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700750 ip6_del_rt(rt);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800751 rt = NULL;
752 }
753
754 if (!rt && lifetime)
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -0800755 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800756 pref);
757 else if (rt)
758 rt->rt6i_flags = RTF_ROUTEINFO |
759 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
760
761 if (rt) {
Gao feng1716a962012-04-06 00:13:10 +0000762 if (!addrconf_finite_timeout(lifetime))
763 rt6_clean_expires(rt);
764 else
765 rt6_set_expires(rt, jiffies + HZ * lifetime);
766
Amerigo Wang94e187c2012-10-29 00:13:19 +0000767 ip6_rt_put(rt);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800768 }
769 return 0;
770}
771#endif
772
Martin KaFai Laua3c00e42014-10-20 13:42:43 -0700773static struct fib6_node* fib6_backtrack(struct fib6_node *fn,
774 struct in6_addr *saddr)
775{
776 struct fib6_node *pn;
777 while (1) {
778 if (fn->fn_flags & RTN_TL_ROOT)
779 return NULL;
780 pn = fn->parent;
781 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn)
782 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr);
783 else
784 fn = pn;
785 if (fn->fn_flags & RTN_RTINFO)
786 return fn;
787 }
788}
Thomas Grafc71099a2006-08-04 23:20:06 -0700789
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800790static struct rt6_info *ip6_pol_route_lookup(struct net *net,
791 struct fib6_table *table,
David S. Miller4c9483b2011-03-12 16:22:43 -0500792 struct flowi6 *fl6, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793{
794 struct fib6_node *fn;
795 struct rt6_info *rt;
796
Thomas Grafc71099a2006-08-04 23:20:06 -0700797 read_lock_bh(&table->tb6_lock);
David S. Miller4c9483b2011-03-12 16:22:43 -0500798 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
Thomas Grafc71099a2006-08-04 23:20:06 -0700799restart:
800 rt = fn->leaf;
David S. Miller4c9483b2011-03-12 16:22:43 -0500801 rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000802 if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
Nicolas Dichtel52bd4c02013-06-28 17:35:48 +0200803 rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);
Martin KaFai Laua3c00e42014-10-20 13:42:43 -0700804 if (rt == net->ipv6.ip6_null_entry) {
805 fn = fib6_backtrack(fn, &fl6->saddr);
806 if (fn)
807 goto restart;
808 }
Changli Gaod8d1f302010-06-10 23:31:35 -0700809 dst_use(&rt->dst, jiffies);
Thomas Grafc71099a2006-08-04 23:20:06 -0700810 read_unlock_bh(&table->tb6_lock);
Thomas Grafc71099a2006-08-04 23:20:06 -0700811 return rt;
812
813}
814
Ian Morris67ba4152014-08-24 21:53:10 +0100815struct dst_entry *ip6_route_lookup(struct net *net, struct flowi6 *fl6,
Florian Westphalea6e5742011-09-05 16:05:44 +0200816 int flags)
817{
818 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
819}
820EXPORT_SYMBOL_GPL(ip6_route_lookup);
821
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900822struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
823 const struct in6_addr *saddr, int oif, int strict)
Thomas Grafc71099a2006-08-04 23:20:06 -0700824{
David S. Miller4c9483b2011-03-12 16:22:43 -0500825 struct flowi6 fl6 = {
826 .flowi6_oif = oif,
827 .daddr = *daddr,
Thomas Grafc71099a2006-08-04 23:20:06 -0700828 };
829 struct dst_entry *dst;
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700830 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
Thomas Grafc71099a2006-08-04 23:20:06 -0700831
Thomas Grafadaa70b2006-10-13 15:01:03 -0700832 if (saddr) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500833 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
Thomas Grafadaa70b2006-10-13 15:01:03 -0700834 flags |= RT6_LOOKUP_F_HAS_SADDR;
835 }
836
David S. Miller4c9483b2011-03-12 16:22:43 -0500837 dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
Thomas Grafc71099a2006-08-04 23:20:06 -0700838 if (dst->error == 0)
839 return (struct rt6_info *) dst;
840
841 dst_release(dst);
842
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 return NULL;
844}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900845EXPORT_SYMBOL(rt6_lookup);
846
Thomas Grafc71099a2006-08-04 23:20:06 -0700847/* ip6_ins_rt is called with FREE table->tb6_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 It takes new route entry, the addition fails by any reason the
849 route is freed. In any case, if caller does not hold it, it may
850 be destroyed.
851 */
852
Michal Kubečeke5fd3872014-03-27 13:04:08 +0100853static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,
Florian Westphale715b6d2015-01-05 23:57:44 +0100854 struct mx6_config *mxc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855{
856 int err;
Thomas Grafc71099a2006-08-04 23:20:06 -0700857 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
Thomas Grafc71099a2006-08-04 23:20:06 -0700859 table = rt->rt6i_table;
860 write_lock_bh(&table->tb6_lock);
Florian Westphale715b6d2015-01-05 23:57:44 +0100861 err = fib6_add(&table->tb6_root, rt, info, mxc);
Thomas Grafc71099a2006-08-04 23:20:06 -0700862 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
864 return err;
865}
866
Thomas Graf40e22e82006-08-22 00:00:45 -0700867int ip6_ins_rt(struct rt6_info *rt)
868{
Florian Westphale715b6d2015-01-05 23:57:44 +0100869 struct nl_info info = { .nl_net = dev_net(rt->dst.dev), };
870 struct mx6_config mxc = { .mx = NULL, };
871
872 return __ip6_ins_rt(rt, &info, &mxc);
Thomas Graf40e22e82006-08-22 00:00:45 -0700873}
874
Gao feng1716a962012-04-06 00:13:10 +0000875static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort,
Eric Dumazet21efcfa2011-07-19 20:18:36 +0000876 const struct in6_addr *daddr,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000877 const struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 struct rt6_info *rt;
880
881 /*
882 * Clone the route.
883 */
884
Eric Dumazet21efcfa2011-07-19 20:18:36 +0000885 rt = ip6_rt_copy(ort, daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886
887 if (rt) {
Duan Jiong249a3632013-11-05 13:34:53 +0800888 if (ort->rt6i_dst.plen != 128 &&
889 ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
890 rt->rt6i_flags |= RTF_ANYCAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 rt->rt6i_flags |= RTF_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893
894#ifdef CONFIG_IPV6_SUBTREES
895 if (rt->rt6i_src.plen && saddr) {
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000896 rt->rt6i_src.addr = *saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 rt->rt6i_src.plen = 128;
898 }
899#endif
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800900 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901
YOSHIFUJI Hideaki95a9a5b2006-03-20 16:55:51 -0800902 return rt;
903}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
Eric Dumazet21efcfa2011-07-19 20:18:36 +0000905static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,
906 const struct in6_addr *daddr)
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800907{
Eric Dumazet21efcfa2011-07-19 20:18:36 +0000908 struct rt6_info *rt = ip6_rt_copy(ort, daddr);
909
YOSHIFUJI Hideaki / 吉藤英明887c95c2013-01-17 12:54:05 +0000910 if (rt)
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800911 rt->rt6i_flags |= RTF_CACHE;
YOSHIFUJI Hideaki299d9932006-03-20 16:58:32 -0800912 return rt;
913}
914
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800915static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
David S. Miller4c9483b2011-03-12 16:22:43 -0500916 struct flowi6 *fl6, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917{
Martin KaFai Lau367efcb2014-10-20 13:42:45 -0700918 struct fib6_node *fn, *saved_fn;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800919 struct rt6_info *rt, *nrt;
Thomas Grafc71099a2006-08-04 23:20:06 -0700920 int strict = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 int attempts = 3;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800922 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -0700924 strict |= flags & RT6_LOOKUP_F_IFACE;
Martin KaFai Lau367efcb2014-10-20 13:42:45 -0700925 if (net->ipv6.devconf_all->forwarding == 0)
926 strict |= RT6_LOOKUP_F_REACHABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
Martin KaFai Laua3c00e42014-10-20 13:42:43 -0700928redo_fib6_lookup_lock:
Thomas Grafc71099a2006-08-04 23:20:06 -0700929 read_lock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930
David S. Miller4c9483b2011-03-12 16:22:43 -0500931 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
Martin KaFai Lau367efcb2014-10-20 13:42:45 -0700932 saved_fn = fn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933
Martin KaFai Laua3c00e42014-10-20 13:42:43 -0700934redo_rt6_select:
Martin KaFai Lau367efcb2014-10-20 13:42:45 -0700935 rt = rt6_select(fn, oif, strict);
Nicolas Dichtel52bd4c02013-06-28 17:35:48 +0200936 if (rt->rt6i_nsiblings)
Martin KaFai Lau367efcb2014-10-20 13:42:45 -0700937 rt = rt6_multipath_select(rt, fl6, oif, strict);
Martin KaFai Laua3c00e42014-10-20 13:42:43 -0700938 if (rt == net->ipv6.ip6_null_entry) {
939 fn = fib6_backtrack(fn, &fl6->saddr);
940 if (fn)
941 goto redo_rt6_select;
Martin KaFai Lau367efcb2014-10-20 13:42:45 -0700942 else if (strict & RT6_LOOKUP_F_REACHABLE) {
943 /* also consider unreachable route */
944 strict &= ~RT6_LOOKUP_F_REACHABLE;
945 fn = saved_fn;
946 goto redo_rt6_select;
947 } else {
948 dst_hold(&rt->dst);
949 read_unlock_bh(&table->tb6_lock);
950 goto out2;
951 }
Martin KaFai Laua3c00e42014-10-20 13:42:43 -0700952 }
953
Changli Gaod8d1f302010-06-10 23:31:35 -0700954 dst_hold(&rt->dst);
Thomas Grafc71099a2006-08-04 23:20:06 -0700955 read_unlock_bh(&table->tb6_lock);
YOSHIFUJI Hideakifb9de912006-03-20 16:59:08 -0800956
Martin KaFai Lau94c77bb2014-10-20 13:42:44 -0700957 if (rt->rt6i_flags & RTF_CACHE)
958 goto out2;
959
YOSHIFUJI Hideaki / 吉藤英明c440f162013-01-17 12:53:32 +0000960 if (!(rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY)))
David S. Miller4c9483b2011-03-12 16:22:43 -0500961 nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);
David S. Miller7343ff32011-03-09 19:55:25 -0800962 else if (!(rt->dst.flags & DST_HOST))
David S. Miller4c9483b2011-03-12 16:22:43 -0500963 nrt = rt6_alloc_clone(rt, &fl6->daddr);
David S. Miller7343ff32011-03-09 19:55:25 -0800964 else
965 goto out2;
YOSHIFUJI Hideakie40cf352006-03-20 16:59:27 -0800966
Amerigo Wang94e187c2012-10-29 00:13:19 +0000967 ip6_rt_put(rt);
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800968 rt = nrt ? : net->ipv6.ip6_null_entry;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800969
Changli Gaod8d1f302010-06-10 23:31:35 -0700970 dst_hold(&rt->dst);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800971 if (nrt) {
Thomas Graf40e22e82006-08-22 00:00:45 -0700972 err = ip6_ins_rt(nrt);
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800973 if (!err)
974 goto out2;
975 }
976
977 if (--attempts <= 0)
978 goto out2;
979
980 /*
Thomas Grafc71099a2006-08-04 23:20:06 -0700981 * Race condition! In the gap, when table->tb6_lock was
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800982 * released someone could insert this route. Relookup.
983 */
Amerigo Wang94e187c2012-10-29 00:13:19 +0000984 ip6_rt_put(rt);
Martin KaFai Laua3c00e42014-10-20 13:42:43 -0700985 goto redo_fib6_lookup_lock;
YOSHIFUJI Hideaki519fbd82006-03-20 17:00:05 -0800986
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987out2:
Changli Gaod8d1f302010-06-10 23:31:35 -0700988 rt->dst.lastuse = jiffies;
989 rt->dst.__use++;
Thomas Grafc71099a2006-08-04 23:20:06 -0700990
991 return rt;
992}
993
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800994static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
David S. Miller4c9483b2011-03-12 16:22:43 -0500995 struct flowi6 *fl6, int flags)
Pavel Emelyanov4acad722007-10-15 13:02:51 -0700996{
David S. Miller4c9483b2011-03-12 16:22:43 -0500997 return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
Pavel Emelyanov4acad722007-10-15 13:02:51 -0700998}
999
Shmulik Ladkani72331bc2012-04-01 04:03:45 +00001000static struct dst_entry *ip6_route_input_lookup(struct net *net,
1001 struct net_device *dev,
1002 struct flowi6 *fl6, int flags)
1003{
1004 if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
1005 flags |= RT6_LOOKUP_F_IFACE;
1006
1007 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
1008}
1009
Thomas Grafc71099a2006-08-04 23:20:06 -07001010void ip6_route_input(struct sk_buff *skb)
1011{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001012 const struct ipv6hdr *iph = ipv6_hdr(skb);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001013 struct net *net = dev_net(skb->dev);
Thomas Grafadaa70b2006-10-13 15:01:03 -07001014 int flags = RT6_LOOKUP_F_HAS_SADDR;
David S. Miller4c9483b2011-03-12 16:22:43 -05001015 struct flowi6 fl6 = {
1016 .flowi6_iif = skb->dev->ifindex,
1017 .daddr = iph->daddr,
1018 .saddr = iph->saddr,
YOSHIFUJI Hideaki / 吉藤英明6502ca52013-01-13 05:01:51 +00001019 .flowlabel = ip6_flowinfo(iph),
David S. Miller4c9483b2011-03-12 16:22:43 -05001020 .flowi6_mark = skb->mark,
1021 .flowi6_proto = iph->nexthdr,
Thomas Grafc71099a2006-08-04 23:20:06 -07001022 };
Thomas Grafadaa70b2006-10-13 15:01:03 -07001023
Shmulik Ladkani72331bc2012-04-01 04:03:45 +00001024 skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
Thomas Grafc71099a2006-08-04 23:20:06 -07001025}
1026
Daniel Lezcano8ed67782008-03-04 13:48:30 -08001027static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
David S. Miller4c9483b2011-03-12 16:22:43 -05001028 struct flowi6 *fl6, int flags)
Thomas Grafc71099a2006-08-04 23:20:06 -07001029{
David S. Miller4c9483b2011-03-12 16:22:43 -05001030 return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
Thomas Grafc71099a2006-08-04 23:20:06 -07001031}
1032
Ian Morris67ba4152014-08-24 21:53:10 +01001033struct dst_entry *ip6_route_output(struct net *net, const struct sock *sk,
David S. Miller4c9483b2011-03-12 16:22:43 -05001034 struct flowi6 *fl6)
Thomas Grafc71099a2006-08-04 23:20:06 -07001035{
1036 int flags = 0;
1037
Pavel Emelyanov1fb94892012-08-08 21:53:36 +00001038 fl6->flowi6_iif = LOOPBACK_IFINDEX;
David McCullough4dc27d1c2012-06-25 15:42:26 +00001039
David S. Miller4c9483b2011-03-12 16:22:43 -05001040 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))
YOSHIFUJI Hideaki77d16f42006-08-23 17:25:05 -07001041 flags |= RT6_LOOKUP_F_IFACE;
Thomas Grafc71099a2006-08-04 23:20:06 -07001042
David S. Miller4c9483b2011-03-12 16:22:43 -05001043 if (!ipv6_addr_any(&fl6->saddr))
Thomas Grafadaa70b2006-10-13 15:01:03 -07001044 flags |= RT6_LOOKUP_F_HAS_SADDR;
YOSHIFUJI Hideaki / 吉藤英明0c9a2ac2010-03-07 00:14:44 +00001045 else if (sk)
1046 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
Thomas Grafadaa70b2006-10-13 15:01:03 -07001047
David S. Miller4c9483b2011-03-12 16:22:43 -05001048 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +09001050EXPORT_SYMBOL(ip6_route_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051
David S. Miller2774c132011-03-01 14:59:04 -08001052struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
David S. Miller14e50e52007-05-24 18:17:54 -07001053{
David S. Miller5c1e6aa2011-04-28 14:13:38 -07001054 struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
David S. Miller14e50e52007-05-24 18:17:54 -07001055 struct dst_entry *new = NULL;
1056
David S. Millerf5b0a872012-07-19 12:31:33 -07001057 rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
David S. Miller14e50e52007-05-24 18:17:54 -07001058 if (rt) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001059 new = &rt->dst;
David S. Miller14e50e52007-05-24 18:17:54 -07001060
Steffen Klassert81048912012-07-05 23:37:09 +00001061 memset(new + 1, 0, sizeof(*rt) - sizeof(*new));
1062 rt6_init_peer(rt, net->ipv6.peers);
1063
David S. Miller14e50e52007-05-24 18:17:54 -07001064 new->__use = 1;
Herbert Xu352e5122007-11-13 21:34:06 -08001065 new->input = dst_discard;
Eric Dumazetaad88722014-04-15 13:47:15 -04001066 new->output = dst_discard_sk;
David S. Miller14e50e52007-05-24 18:17:54 -07001067
Eric Dumazet21efcfa2011-07-19 20:18:36 +00001068 if (dst_metrics_read_only(&ort->dst))
1069 new->_metrics = ort->dst._metrics;
1070 else
1071 dst_copy_metrics(new, &ort->dst);
David S. Miller14e50e52007-05-24 18:17:54 -07001072 rt->rt6i_idev = ort->rt6i_idev;
1073 if (rt->rt6i_idev)
1074 in6_dev_hold(rt->rt6i_idev);
David S. Miller14e50e52007-05-24 18:17:54 -07001075
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001076 rt->rt6i_gateway = ort->rt6i_gateway;
Gao feng1716a962012-04-06 00:13:10 +00001077 rt->rt6i_flags = ort->rt6i_flags;
David S. Miller14e50e52007-05-24 18:17:54 -07001078 rt->rt6i_metric = 0;
1079
1080 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1081#ifdef CONFIG_IPV6_SUBTREES
1082 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1083#endif
1084
1085 dst_free(new);
1086 }
1087
David S. Miller69ead7a2011-03-01 14:45:33 -08001088 dst_release(dst_orig);
1089 return new ? new : ERR_PTR(-ENOMEM);
David S. Miller14e50e52007-05-24 18:17:54 -07001090}
David S. Miller14e50e52007-05-24 18:17:54 -07001091
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092/*
1093 * Destination cache support functions
1094 */
1095
1096static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1097{
1098 struct rt6_info *rt;
1099
1100 rt = (struct rt6_info *) dst;
1101
Nicolas Dichtel6f3118b2012-09-10 22:09:46 +00001102 /* All IPV6 dsts are created with ->obsolete set to the value
1103 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1104 * into this function always.
1105 */
Hannes Frederic Sowae3bc10b2013-10-24 07:48:24 +02001106 if (!rt->rt6i_node || (rt->rt6i_node->fn_sernum != cookie))
1107 return NULL;
Li RongQinga4477c42012-11-07 21:56:33 +00001108
Hannes Frederic Sowae3bc10b2013-10-24 07:48:24 +02001109 if (rt6_check_expired(rt))
1110 return NULL;
1111
1112 return dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113}
1114
1115static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1116{
1117 struct rt6_info *rt = (struct rt6_info *) dst;
1118
1119 if (rt) {
YOSHIFUJI Hideaki / 吉藤英明54c1a852010-03-28 07:15:45 +00001120 if (rt->rt6i_flags & RTF_CACHE) {
1121 if (rt6_check_expired(rt)) {
1122 ip6_del_rt(rt);
1123 dst = NULL;
1124 }
1125 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 dst_release(dst);
YOSHIFUJI Hideaki / 吉藤英明54c1a852010-03-28 07:15:45 +00001127 dst = NULL;
1128 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 }
YOSHIFUJI Hideaki / 吉藤英明54c1a852010-03-28 07:15:45 +00001130 return dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131}
1132
1133static void ip6_link_failure(struct sk_buff *skb)
1134{
1135 struct rt6_info *rt;
1136
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +00001137 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
Eric Dumazetadf30902009-06-02 05:19:30 +00001139 rt = (struct rt6_info *) skb_dst(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 if (rt) {
Hannes Frederic Sowa1eb4f752013-07-10 23:00:57 +02001141 if (rt->rt6i_flags & RTF_CACHE) {
1142 dst_hold(&rt->dst);
1143 if (ip6_del_rt(rt))
1144 dst_free(&rt->dst);
1145 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 rt->rt6i_node->fn_sernum = -1;
Hannes Frederic Sowa1eb4f752013-07-10 23:00:57 +02001147 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 }
1149}
1150
David S. Miller6700c272012-07-17 03:29:28 -07001151static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1152 struct sk_buff *skb, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153{
Ian Morris67ba4152014-08-24 21:53:10 +01001154 struct rt6_info *rt6 = (struct rt6_info *)dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
David S. Miller81aded22012-06-15 14:54:11 -07001156 dst_confirm(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
David S. Miller81aded22012-06-15 14:54:11 -07001158 struct net *net = dev_net(dst->dev);
1159
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 rt6->rt6i_flags |= RTF_MODIFIED;
Hagen Paul Pfeifer9d289712015-01-15 22:34:25 +01001161 if (mtu < IPV6_MIN_MTU)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 mtu = IPV6_MIN_MTU;
Hagen Paul Pfeifer9d289712015-01-15 22:34:25 +01001163
David S. Millerdefb3512010-12-08 21:16:57 -08001164 dst_metric_set(dst, RTAX_MTU, mtu);
David S. Miller81aded22012-06-15 14:54:11 -07001165 rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 }
1167}
1168
David S. Miller42ae66c2012-06-15 20:01:57 -07001169void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1170 int oif, u32 mark)
David S. Miller81aded22012-06-15 14:54:11 -07001171{
1172 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1173 struct dst_entry *dst;
1174 struct flowi6 fl6;
1175
1176 memset(&fl6, 0, sizeof(fl6));
1177 fl6.flowi6_oif = oif;
Lorenzo Colitti1b3c61d2014-05-13 10:17:34 -07001178 fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
David S. Miller81aded22012-06-15 14:54:11 -07001179 fl6.daddr = iph->daddr;
1180 fl6.saddr = iph->saddr;
YOSHIFUJI Hideaki / 吉藤英明6502ca52013-01-13 05:01:51 +00001181 fl6.flowlabel = ip6_flowinfo(iph);
David S. Miller81aded22012-06-15 14:54:11 -07001182
1183 dst = ip6_route_output(net, NULL, &fl6);
1184 if (!dst->error)
David S. Miller6700c272012-07-17 03:29:28 -07001185 ip6_rt_update_pmtu(dst, NULL, skb, ntohl(mtu));
David S. Miller81aded22012-06-15 14:54:11 -07001186 dst_release(dst);
1187}
1188EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1189
1190void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1191{
1192 ip6_update_pmtu(skb, sock_net(sk), mtu,
1193 sk->sk_bound_dev_if, sk->sk_mark);
1194}
1195EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1196
Duan Jiongb55b76b2013-09-04 19:44:21 +08001197/* Handle redirects */
1198struct ip6rd_flowi {
1199 struct flowi6 fl6;
1200 struct in6_addr gateway;
1201};
1202
1203static struct rt6_info *__ip6_route_redirect(struct net *net,
1204 struct fib6_table *table,
1205 struct flowi6 *fl6,
1206 int flags)
1207{
1208 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
1209 struct rt6_info *rt;
1210 struct fib6_node *fn;
1211
1212 /* Get the "current" route for this destination and
1213 * check if the redirect has come from approriate router.
1214 *
1215 * RFC 4861 specifies that redirects should only be
1216 * accepted if they come from the nexthop to the target.
1217 * Due to the way the routes are chosen, this notion
1218 * is a bit fuzzy and one might need to check all possible
1219 * routes.
1220 */
1221
1222 read_lock_bh(&table->tb6_lock);
1223 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1224restart:
1225 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1226 if (rt6_check_expired(rt))
1227 continue;
1228 if (rt->dst.error)
1229 break;
1230 if (!(rt->rt6i_flags & RTF_GATEWAY))
1231 continue;
1232 if (fl6->flowi6_oif != rt->dst.dev->ifindex)
1233 continue;
1234 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1235 continue;
1236 break;
1237 }
1238
1239 if (!rt)
1240 rt = net->ipv6.ip6_null_entry;
1241 else if (rt->dst.error) {
1242 rt = net->ipv6.ip6_null_entry;
Martin KaFai Laub0a1ba52015-01-20 19:16:02 -08001243 goto out;
1244 }
1245
1246 if (rt == net->ipv6.ip6_null_entry) {
Martin KaFai Laua3c00e42014-10-20 13:42:43 -07001247 fn = fib6_backtrack(fn, &fl6->saddr);
1248 if (fn)
1249 goto restart;
Duan Jiongb55b76b2013-09-04 19:44:21 +08001250 }
Martin KaFai Laua3c00e42014-10-20 13:42:43 -07001251
Martin KaFai Laub0a1ba52015-01-20 19:16:02 -08001252out:
Duan Jiongb55b76b2013-09-04 19:44:21 +08001253 dst_hold(&rt->dst);
1254
1255 read_unlock_bh(&table->tb6_lock);
1256
1257 return rt;
1258};
1259
1260static struct dst_entry *ip6_route_redirect(struct net *net,
1261 const struct flowi6 *fl6,
1262 const struct in6_addr *gateway)
1263{
1264 int flags = RT6_LOOKUP_F_HAS_SADDR;
1265 struct ip6rd_flowi rdfl;
1266
1267 rdfl.fl6 = *fl6;
1268 rdfl.gateway = *gateway;
1269
1270 return fib6_rule_lookup(net, &rdfl.fl6,
1271 flags, __ip6_route_redirect);
1272}
1273
David S. Miller3a5ad2e2012-07-12 00:08:07 -07001274void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1275{
1276 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1277 struct dst_entry *dst;
1278 struct flowi6 fl6;
1279
1280 memset(&fl6, 0, sizeof(fl6));
Julian Anastasove374c612014-04-28 10:51:56 +03001281 fl6.flowi6_iif = LOOPBACK_IFINDEX;
David S. Miller3a5ad2e2012-07-12 00:08:07 -07001282 fl6.flowi6_oif = oif;
1283 fl6.flowi6_mark = mark;
David S. Miller3a5ad2e2012-07-12 00:08:07 -07001284 fl6.daddr = iph->daddr;
1285 fl6.saddr = iph->saddr;
YOSHIFUJI Hideaki / 吉藤英明6502ca52013-01-13 05:01:51 +00001286 fl6.flowlabel = ip6_flowinfo(iph);
David S. Miller3a5ad2e2012-07-12 00:08:07 -07001287
Duan Jiongb55b76b2013-09-04 19:44:21 +08001288 dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
1289 rt6_do_redirect(dst, NULL, skb);
David S. Miller3a5ad2e2012-07-12 00:08:07 -07001290 dst_release(dst);
1291}
1292EXPORT_SYMBOL_GPL(ip6_redirect);
1293
Duan Jiongc92a59e2013-08-22 12:07:35 +08001294void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
1295 u32 mark)
1296{
1297 const struct ipv6hdr *iph = ipv6_hdr(skb);
1298 const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
1299 struct dst_entry *dst;
1300 struct flowi6 fl6;
1301
1302 memset(&fl6, 0, sizeof(fl6));
Julian Anastasove374c612014-04-28 10:51:56 +03001303 fl6.flowi6_iif = LOOPBACK_IFINDEX;
Duan Jiongc92a59e2013-08-22 12:07:35 +08001304 fl6.flowi6_oif = oif;
1305 fl6.flowi6_mark = mark;
Duan Jiongc92a59e2013-08-22 12:07:35 +08001306 fl6.daddr = msg->dest;
1307 fl6.saddr = iph->daddr;
1308
Duan Jiongb55b76b2013-09-04 19:44:21 +08001309 dst = ip6_route_redirect(net, &fl6, &iph->saddr);
1310 rt6_do_redirect(dst, NULL, skb);
Duan Jiongc92a59e2013-08-22 12:07:35 +08001311 dst_release(dst);
1312}
1313
David S. Miller3a5ad2e2012-07-12 00:08:07 -07001314void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1315{
1316 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1317}
1318EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1319
David S. Miller0dbaee32010-12-13 12:52:14 -08001320static unsigned int ip6_default_advmss(const struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321{
David S. Miller0dbaee32010-12-13 12:52:14 -08001322 struct net_device *dev = dst->dev;
1323 unsigned int mtu = dst_mtu(dst);
1324 struct net *net = dev_net(dev);
1325
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1327
Daniel Lezcano55786892008-03-04 13:47:47 -08001328 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1329 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330
1331 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001332 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1333 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1334 * IPV6_MAXPLEN is also valid and means: "any MSS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 * rely only on pmtu discovery"
1336 */
1337 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1338 mtu = IPV6_MAXPLEN;
1339 return mtu;
1340}
1341
Steffen Klassertebb762f2011-11-23 02:12:51 +00001342static unsigned int ip6_mtu(const struct dst_entry *dst)
David S. Millerd33e4552010-12-14 13:01:14 -08001343{
David S. Millerd33e4552010-12-14 13:01:14 -08001344 struct inet6_dev *idev;
Steffen Klassert618f9bc2011-11-23 02:13:31 +00001345 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
1346
1347 if (mtu)
Eric Dumazet30f78d82014-04-10 21:23:36 -07001348 goto out;
Steffen Klassert618f9bc2011-11-23 02:13:31 +00001349
1350 mtu = IPV6_MIN_MTU;
David S. Millerd33e4552010-12-14 13:01:14 -08001351
1352 rcu_read_lock();
1353 idev = __in6_dev_get(dst->dev);
1354 if (idev)
1355 mtu = idev->cnf.mtu6;
1356 rcu_read_unlock();
1357
Eric Dumazet30f78d82014-04-10 21:23:36 -07001358out:
1359 return min_t(unsigned int, mtu, IP6_MAX_MTU);
David S. Millerd33e4552010-12-14 13:01:14 -08001360}
1361
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001362static struct dst_entry *icmp6_dst_gc_list;
1363static DEFINE_SPINLOCK(icmp6_dst_lock);
Thomas Graf5d0bbee2006-08-04 03:37:36 -07001364
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001365struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
David S. Miller87a11572011-12-06 17:04:13 -05001366 struct flowi6 *fl6)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367{
David S. Miller87a11572011-12-06 17:04:13 -05001368 struct dst_entry *dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 struct rt6_info *rt;
1370 struct inet6_dev *idev = in6_dev_get(dev);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001371 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372
David S. Miller38308472011-12-03 18:02:47 -05001373 if (unlikely(!idev))
Eric Dumazet122bdf62012-03-14 21:13:11 +00001374 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
David S. Miller8b96d222012-06-11 02:01:56 -07001376 rt = ip6_dst_alloc(net, dev, 0, NULL);
David S. Miller38308472011-12-03 18:02:47 -05001377 if (unlikely(!rt)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 in6_dev_put(idev);
David S. Miller87a11572011-12-06 17:04:13 -05001379 dst = ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 goto out;
1381 }
1382
Yan, Zheng8e2ec632011-09-05 21:34:30 +00001383 rt->dst.flags |= DST_HOST;
1384 rt->dst.output = ip6_output;
Changli Gaod8d1f302010-06-10 23:31:35 -07001385 atomic_set(&rt->dst.__refcnt, 1);
Julian Anastasov550bab42013-10-20 15:43:04 +03001386 rt->rt6i_gateway = fl6->daddr;
David S. Miller87a11572011-12-06 17:04:13 -05001387 rt->rt6i_dst.addr = fl6->daddr;
Yan, Zheng8e2ec632011-09-05 21:34:30 +00001388 rt->rt6i_dst.plen = 128;
1389 rt->rt6i_idev = idev;
Li RongQing14edd872012-10-24 14:01:18 +08001390 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001392 spin_lock_bh(&icmp6_dst_lock);
Changli Gaod8d1f302010-06-10 23:31:35 -07001393 rt->dst.next = icmp6_dst_gc_list;
1394 icmp6_dst_gc_list = &rt->dst;
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001395 spin_unlock_bh(&icmp6_dst_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396
Daniel Lezcano55786892008-03-04 13:47:47 -08001397 fib6_force_start_gc(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398
David S. Miller87a11572011-12-06 17:04:13 -05001399 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1400
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401out:
David S. Miller87a11572011-12-06 17:04:13 -05001402 return dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403}
1404
Stephen Hemminger3d0f24a2008-07-22 14:35:50 -07001405int icmp6_dst_gc(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406{
Hagen Paul Pfeifere9476e92011-02-25 05:45:19 +00001407 struct dst_entry *dst, **pprev;
Stephen Hemminger3d0f24a2008-07-22 14:35:50 -07001408 int more = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001410 spin_lock_bh(&icmp6_dst_lock);
1411 pprev = &icmp6_dst_gc_list;
Thomas Graf5d0bbee2006-08-04 03:37:36 -07001412
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 while ((dst = *pprev) != NULL) {
1414 if (!atomic_read(&dst->__refcnt)) {
1415 *pprev = dst->next;
1416 dst_free(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 } else {
1418 pprev = &dst->next;
Stephen Hemminger3d0f24a2008-07-22 14:35:50 -07001419 ++more;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 }
1421 }
1422
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -08001423 spin_unlock_bh(&icmp6_dst_lock);
Thomas Graf5d0bbee2006-08-04 03:37:36 -07001424
Stephen Hemminger3d0f24a2008-07-22 14:35:50 -07001425 return more;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426}
1427
David S. Miller1e493d12008-09-10 17:27:15 -07001428static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1429 void *arg)
1430{
1431 struct dst_entry *dst, **pprev;
1432
1433 spin_lock_bh(&icmp6_dst_lock);
1434 pprev = &icmp6_dst_gc_list;
1435 while ((dst = *pprev) != NULL) {
1436 struct rt6_info *rt = (struct rt6_info *) dst;
1437 if (func(rt, arg)) {
1438 *pprev = dst->next;
1439 dst_free(dst);
1440 } else {
1441 pprev = &dst->next;
1442 }
1443 }
1444 spin_unlock_bh(&icmp6_dst_lock);
1445}
1446
Daniel Lezcano569d3642008-01-18 03:56:57 -08001447static int ip6_dst_gc(struct dst_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448{
Alexey Dobriyan86393e52009-08-29 01:34:49 +00001449 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
Daniel Lezcano7019b782008-03-04 13:50:14 -08001450 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1451 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1452 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1453 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1454 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
Eric Dumazetfc66f952010-10-08 06:37:34 +00001455 int entries;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456
Eric Dumazetfc66f952010-10-08 06:37:34 +00001457 entries = dst_entries_get_fast(ops);
Michal Kubeček49a18d82013-08-01 10:04:24 +02001458 if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
Eric Dumazetfc66f952010-10-08 06:37:34 +00001459 entries <= rt_max_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 goto out;
1461
Benjamin Thery6891a342008-03-04 13:49:47 -08001462 net->ipv6.ip6_rt_gc_expire++;
Li RongQing14956642014-05-19 17:30:28 +08001463 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
Eric Dumazetfc66f952010-10-08 06:37:34 +00001464 entries = dst_entries_get_slow(ops);
1465 if (entries < ops->gc_thresh)
Daniel Lezcano7019b782008-03-04 13:50:14 -08001466 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467out:
Daniel Lezcano7019b782008-03-04 13:50:14 -08001468 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
Eric Dumazetfc66f952010-10-08 06:37:34 +00001469 return entries > rt_max_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470}
1471
Florian Westphale715b6d2015-01-05 23:57:44 +01001472static int ip6_convert_metrics(struct mx6_config *mxc,
1473 const struct fib6_config *cfg)
1474{
1475 struct nlattr *nla;
1476 int remaining;
1477 u32 *mp;
1478
Ian Morris63159f22015-03-29 14:00:04 +01001479 if (!cfg->fc_mx)
Florian Westphale715b6d2015-01-05 23:57:44 +01001480 return 0;
1481
1482 mp = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1483 if (unlikely(!mp))
1484 return -ENOMEM;
1485
1486 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1487 int type = nla_type(nla);
1488
1489 if (type) {
Daniel Borkmannea697632015-01-05 23:57:47 +01001490 u32 val;
1491
Florian Westphale715b6d2015-01-05 23:57:44 +01001492 if (unlikely(type > RTAX_MAX))
1493 goto err;
Daniel Borkmannea697632015-01-05 23:57:47 +01001494 if (type == RTAX_CC_ALGO) {
1495 char tmp[TCP_CA_NAME_MAX];
Florian Westphale715b6d2015-01-05 23:57:44 +01001496
Daniel Borkmannea697632015-01-05 23:57:47 +01001497 nla_strlcpy(tmp, nla, sizeof(tmp));
1498 val = tcp_ca_get_key_by_name(tmp);
1499 if (val == TCP_CA_UNSPEC)
1500 goto err;
1501 } else {
1502 val = nla_get_u32(nla);
1503 }
1504
1505 mp[type - 1] = val;
Florian Westphale715b6d2015-01-05 23:57:44 +01001506 __set_bit(type - 1, mxc->mx_valid);
1507 }
1508 }
1509
1510 mxc->mx = mp;
1511
1512 return 0;
1513 err:
1514 kfree(mp);
1515 return -EINVAL;
1516}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517
Thomas Graf86872cb2006-08-22 00:01:08 -07001518int ip6_route_add(struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519{
1520 int err;
Daniel Lezcano55786892008-03-04 13:47:47 -08001521 struct net *net = cfg->fc_nlinfo.nl_net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 struct rt6_info *rt = NULL;
1523 struct net_device *dev = NULL;
1524 struct inet6_dev *idev = NULL;
Thomas Grafc71099a2006-08-04 23:20:06 -07001525 struct fib6_table *table;
Florian Westphale715b6d2015-01-05 23:57:44 +01001526 struct mx6_config mxc = { .mx = NULL, };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 int addr_type;
1528
Thomas Graf86872cb2006-08-22 00:01:08 -07001529 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 return -EINVAL;
1531#ifndef CONFIG_IPV6_SUBTREES
Thomas Graf86872cb2006-08-22 00:01:08 -07001532 if (cfg->fc_src_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 return -EINVAL;
1534#endif
Thomas Graf86872cb2006-08-22 00:01:08 -07001535 if (cfg->fc_ifindex) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 err = -ENODEV;
Daniel Lezcano55786892008-03-04 13:47:47 -08001537 dev = dev_get_by_index(net, cfg->fc_ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 if (!dev)
1539 goto out;
1540 idev = in6_dev_get(dev);
1541 if (!idev)
1542 goto out;
1543 }
1544
Thomas Graf86872cb2006-08-22 00:01:08 -07001545 if (cfg->fc_metric == 0)
1546 cfg->fc_metric = IP6_RT_PRIO_USER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547
Matti Vaittinend71314b2011-11-14 00:14:49 +00001548 err = -ENOBUFS;
David S. Miller38308472011-12-03 18:02:47 -05001549 if (cfg->fc_nlinfo.nlh &&
1550 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
Matti Vaittinend71314b2011-11-14 00:14:49 +00001551 table = fib6_get_table(net, cfg->fc_table);
David S. Miller38308472011-12-03 18:02:47 -05001552 if (!table) {
Joe Perchesf3213832012-05-15 14:11:53 +00001553 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
Matti Vaittinend71314b2011-11-14 00:14:49 +00001554 table = fib6_new_table(net, cfg->fc_table);
1555 }
1556 } else {
1557 table = fib6_new_table(net, cfg->fc_table);
1558 }
David S. Miller38308472011-12-03 18:02:47 -05001559
1560 if (!table)
Thomas Grafc71099a2006-08-04 23:20:06 -07001561 goto out;
Thomas Grafc71099a2006-08-04 23:20:06 -07001562
Sabrina Dubrocac88507f2014-03-06 17:51:57 +01001563 rt = ip6_dst_alloc(net, NULL, (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT, table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564
David S. Miller38308472011-12-03 18:02:47 -05001565 if (!rt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 err = -ENOMEM;
1567 goto out;
1568 }
1569
Gao feng1716a962012-04-06 00:13:10 +00001570 if (cfg->fc_flags & RTF_EXPIRES)
1571 rt6_set_expires(rt, jiffies +
1572 clock_t_to_jiffies(cfg->fc_expires));
1573 else
1574 rt6_clean_expires(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575
Thomas Graf86872cb2006-08-22 00:01:08 -07001576 if (cfg->fc_protocol == RTPROT_UNSPEC)
1577 cfg->fc_protocol = RTPROT_BOOT;
1578 rt->rt6i_protocol = cfg->fc_protocol;
1579
1580 addr_type = ipv6_addr_type(&cfg->fc_dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581
1582 if (addr_type & IPV6_ADDR_MULTICAST)
Changli Gaod8d1f302010-06-10 23:31:35 -07001583 rt->dst.input = ip6_mc_input;
Maciej Żenczykowskiab79ad12010-09-27 00:07:02 +00001584 else if (cfg->fc_flags & RTF_LOCAL)
1585 rt->dst.input = ip6_input;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 else
Changli Gaod8d1f302010-06-10 23:31:35 -07001587 rt->dst.input = ip6_forward;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588
Changli Gaod8d1f302010-06-10 23:31:35 -07001589 rt->dst.output = ip6_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590
Thomas Graf86872cb2006-08-22 00:01:08 -07001591 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1592 rt->rt6i_dst.plen = cfg->fc_dst_len;
Michal Kubečeke5fd3872014-03-27 13:04:08 +01001593 if (rt->rt6i_dst.plen == 128) {
1594 rt->dst.flags |= DST_HOST;
1595 dst_metrics_set_force_overwrite(&rt->dst);
Yan, Zheng8e2ec632011-09-05 21:34:30 +00001596 }
Michal Kubečeke5fd3872014-03-27 13:04:08 +01001597
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598#ifdef CONFIG_IPV6_SUBTREES
Thomas Graf86872cb2006-08-22 00:01:08 -07001599 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1600 rt->rt6i_src.plen = cfg->fc_src_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601#endif
1602
Thomas Graf86872cb2006-08-22 00:01:08 -07001603 rt->rt6i_metric = cfg->fc_metric;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604
1605 /* We cannot add true routes via loopback here,
1606 they would result in kernel looping; promote them to reject routes
1607 */
Thomas Graf86872cb2006-08-22 00:01:08 -07001608 if ((cfg->fc_flags & RTF_REJECT) ||
David S. Miller38308472011-12-03 18:02:47 -05001609 (dev && (dev->flags & IFF_LOOPBACK) &&
1610 !(addr_type & IPV6_ADDR_LOOPBACK) &&
1611 !(cfg->fc_flags & RTF_LOCAL))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 /* hold loopback dev/idev if we haven't done so. */
Daniel Lezcano55786892008-03-04 13:47:47 -08001613 if (dev != net->loopback_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 if (dev) {
1615 dev_put(dev);
1616 in6_dev_put(idev);
1617 }
Daniel Lezcano55786892008-03-04 13:47:47 -08001618 dev = net->loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 dev_hold(dev);
1620 idev = in6_dev_get(dev);
1621 if (!idev) {
1622 err = -ENODEV;
1623 goto out;
1624 }
1625 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00001627 switch (cfg->fc_type) {
1628 case RTN_BLACKHOLE:
1629 rt->dst.error = -EINVAL;
Eric Dumazetaad88722014-04-15 13:47:15 -04001630 rt->dst.output = dst_discard_sk;
Kamala R7150aed2013-12-02 19:55:21 +05301631 rt->dst.input = dst_discard;
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00001632 break;
1633 case RTN_PROHIBIT:
1634 rt->dst.error = -EACCES;
Kamala R7150aed2013-12-02 19:55:21 +05301635 rt->dst.output = ip6_pkt_prohibit_out;
1636 rt->dst.input = ip6_pkt_prohibit;
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00001637 break;
Nicolas Dichtelb4949ab2012-09-06 05:53:35 +00001638 case RTN_THROW:
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00001639 default:
Kamala R7150aed2013-12-02 19:55:21 +05301640 rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
1641 : -ENETUNREACH;
1642 rt->dst.output = ip6_pkt_discard_out;
1643 rt->dst.input = ip6_pkt_discard;
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00001644 break;
1645 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 goto install_route;
1647 }
1648
Thomas Graf86872cb2006-08-22 00:01:08 -07001649 if (cfg->fc_flags & RTF_GATEWAY) {
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001650 const struct in6_addr *gw_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 int gwa_type;
1652
Thomas Graf86872cb2006-08-22 00:01:08 -07001653 gw_addr = &cfg->fc_gateway;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001654 rt->rt6i_gateway = *gw_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 gwa_type = ipv6_addr_type(gw_addr);
1656
1657 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1658 struct rt6_info *grt;
1659
1660 /* IPv6 strictly inhibits using not link-local
1661 addresses as nexthop address.
1662 Otherwise, router will not able to send redirects.
1663 It is very good, but in some (rare!) circumstances
1664 (SIT, PtP, NBMA NOARP links) it is handy to allow
1665 some exceptions. --ANK
1666 */
1667 err = -EINVAL;
David S. Miller38308472011-12-03 18:02:47 -05001668 if (!(gwa_type & IPV6_ADDR_UNICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 goto out;
1670
Daniel Lezcano55786892008-03-04 13:47:47 -08001671 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672
1673 err = -EHOSTUNREACH;
David S. Miller38308472011-12-03 18:02:47 -05001674 if (!grt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 goto out;
1676 if (dev) {
David S. Millerd1918542011-12-28 20:19:20 -05001677 if (dev != grt->dst.dev) {
Amerigo Wang94e187c2012-10-29 00:13:19 +00001678 ip6_rt_put(grt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 goto out;
1680 }
1681 } else {
David S. Millerd1918542011-12-28 20:19:20 -05001682 dev = grt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 idev = grt->rt6i_idev;
1684 dev_hold(dev);
1685 in6_dev_hold(grt->rt6i_idev);
1686 }
David S. Miller38308472011-12-03 18:02:47 -05001687 if (!(grt->rt6i_flags & RTF_GATEWAY))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 err = 0;
Amerigo Wang94e187c2012-10-29 00:13:19 +00001689 ip6_rt_put(grt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690
1691 if (err)
1692 goto out;
1693 }
1694 err = -EINVAL;
David S. Miller38308472011-12-03 18:02:47 -05001695 if (!dev || (dev->flags & IFF_LOOPBACK))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 goto out;
1697 }
1698
1699 err = -ENODEV;
David S. Miller38308472011-12-03 18:02:47 -05001700 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 goto out;
1702
Daniel Walterc3968a82011-04-13 21:10:57 +00001703 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1704 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1705 err = -EINVAL;
1706 goto out;
1707 }
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001708 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
Daniel Walterc3968a82011-04-13 21:10:57 +00001709 rt->rt6i_prefsrc.plen = 128;
1710 } else
1711 rt->rt6i_prefsrc.plen = 0;
1712
Thomas Graf86872cb2006-08-22 00:01:08 -07001713 rt->rt6i_flags = cfg->fc_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714
1715install_route:
Changli Gaod8d1f302010-06-10 23:31:35 -07001716 rt->dst.dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 rt->rt6i_idev = idev;
Thomas Grafc71099a2006-08-04 23:20:06 -07001718 rt->rt6i_table = table;
Daniel Lezcano63152fc2008-03-03 23:31:11 -08001719
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001720 cfg->fc_nlinfo.nl_net = dev_net(dev);
Daniel Lezcano63152fc2008-03-03 23:31:11 -08001721
Florian Westphale715b6d2015-01-05 23:57:44 +01001722 err = ip6_convert_metrics(&mxc, cfg);
1723 if (err)
1724 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
Florian Westphale715b6d2015-01-05 23:57:44 +01001726 err = __ip6_ins_rt(rt, &cfg->fc_nlinfo, &mxc);
1727
1728 kfree(mxc.mx);
1729 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730out:
1731 if (dev)
1732 dev_put(dev);
1733 if (idev)
1734 in6_dev_put(idev);
1735 if (rt)
Changli Gaod8d1f302010-06-10 23:31:35 -07001736 dst_free(&rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 return err;
1738}
1739
Thomas Graf86872cb2006-08-22 00:01:08 -07001740static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741{
1742 int err;
Thomas Grafc71099a2006-08-04 23:20:06 -07001743 struct fib6_table *table;
David S. Millerd1918542011-12-28 20:19:20 -05001744 struct net *net = dev_net(rt->dst.dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745
Gao feng6825a262012-09-19 19:25:34 +00001746 if (rt == net->ipv6.ip6_null_entry) {
1747 err = -ENOENT;
1748 goto out;
1749 }
Patrick McHardy6c813a72006-08-06 22:22:47 -07001750
Thomas Grafc71099a2006-08-04 23:20:06 -07001751 table = rt->rt6i_table;
1752 write_lock_bh(&table->tb6_lock);
Thomas Graf86872cb2006-08-22 00:01:08 -07001753 err = fib6_del(rt, info);
Thomas Grafc71099a2006-08-04 23:20:06 -07001754 write_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755
Gao feng6825a262012-09-19 19:25:34 +00001756out:
Amerigo Wang94e187c2012-10-29 00:13:19 +00001757 ip6_rt_put(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 return err;
1759}
1760
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001761int ip6_del_rt(struct rt6_info *rt)
1762{
Denis V. Lunev4d1169c2008-01-10 03:26:13 -08001763 struct nl_info info = {
David S. Millerd1918542011-12-28 20:19:20 -05001764 .nl_net = dev_net(rt->dst.dev),
Denis V. Lunev4d1169c2008-01-10 03:26:13 -08001765 };
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08001766 return __ip6_del_rt(rt, &info);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001767}
1768
Thomas Graf86872cb2006-08-22 00:01:08 -07001769static int ip6_route_del(struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770{
Thomas Grafc71099a2006-08-04 23:20:06 -07001771 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 struct fib6_node *fn;
1773 struct rt6_info *rt;
1774 int err = -ESRCH;
1775
Daniel Lezcano55786892008-03-04 13:47:47 -08001776 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
David S. Miller38308472011-12-03 18:02:47 -05001777 if (!table)
Thomas Grafc71099a2006-08-04 23:20:06 -07001778 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779
Thomas Grafc71099a2006-08-04 23:20:06 -07001780 read_lock_bh(&table->tb6_lock);
1781
1782 fn = fib6_locate(&table->tb6_root,
Thomas Graf86872cb2006-08-22 00:01:08 -07001783 &cfg->fc_dst, cfg->fc_dst_len,
1784 &cfg->fc_src, cfg->fc_src_len);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001785
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 if (fn) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001787 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
Thomas Graf86872cb2006-08-22 00:01:08 -07001788 if (cfg->fc_ifindex &&
David S. Millerd1918542011-12-28 20:19:20 -05001789 (!rt->dst.dev ||
1790 rt->dst.dev->ifindex != cfg->fc_ifindex))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 continue;
Thomas Graf86872cb2006-08-22 00:01:08 -07001792 if (cfg->fc_flags & RTF_GATEWAY &&
1793 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 continue;
Thomas Graf86872cb2006-08-22 00:01:08 -07001795 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 continue;
Changli Gaod8d1f302010-06-10 23:31:35 -07001797 dst_hold(&rt->dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07001798 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799
Thomas Graf86872cb2006-08-22 00:01:08 -07001800 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 }
1802 }
Thomas Grafc71099a2006-08-04 23:20:06 -07001803 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804
1805 return err;
1806}
1807
David S. Miller6700c272012-07-17 03:29:28 -07001808static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001809{
David S. Millere8599ff2012-07-11 23:43:53 -07001810 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideakia6279452006-08-23 17:18:26 -07001811 struct netevent_redirect netevent;
David S. Millere8599ff2012-07-11 23:43:53 -07001812 struct rt6_info *rt, *nrt = NULL;
David S. Millere8599ff2012-07-11 23:43:53 -07001813 struct ndisc_options ndopts;
1814 struct inet6_dev *in6_dev;
1815 struct neighbour *neigh;
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001816 struct rd_msg *msg;
David S. Miller6e157b62012-07-12 00:05:02 -07001817 int optlen, on_link;
1818 u8 *lladdr;
David S. Millere8599ff2012-07-11 23:43:53 -07001819
Simon Horman29a3cad2013-05-28 20:34:26 +00001820 optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001821 optlen -= sizeof(*msg);
David S. Millere8599ff2012-07-11 23:43:53 -07001822
1823 if (optlen < 0) {
David S. Miller6e157b62012-07-12 00:05:02 -07001824 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
David S. Millere8599ff2012-07-11 23:43:53 -07001825 return;
1826 }
1827
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001828 msg = (struct rd_msg *)icmp6_hdr(skb);
David S. Millere8599ff2012-07-11 23:43:53 -07001829
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001830 if (ipv6_addr_is_multicast(&msg->dest)) {
David S. Miller6e157b62012-07-12 00:05:02 -07001831 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
David S. Millere8599ff2012-07-11 23:43:53 -07001832 return;
1833 }
1834
David S. Miller6e157b62012-07-12 00:05:02 -07001835 on_link = 0;
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001836 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
David S. Millere8599ff2012-07-11 23:43:53 -07001837 on_link = 1;
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001838 } else if (ipv6_addr_type(&msg->target) !=
David S. Millere8599ff2012-07-11 23:43:53 -07001839 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
David S. Miller6e157b62012-07-12 00:05:02 -07001840 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
David S. Millere8599ff2012-07-11 23:43:53 -07001841 return;
1842 }
1843
1844 in6_dev = __in6_dev_get(skb->dev);
1845 if (!in6_dev)
1846 return;
1847 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1848 return;
1849
1850 /* RFC2461 8.1:
1851 * The IP source address of the Redirect MUST be the same as the current
1852 * first-hop router for the specified ICMP Destination Address.
1853 */
1854
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001855 if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
David S. Millere8599ff2012-07-11 23:43:53 -07001856 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1857 return;
1858 }
David S. Miller6e157b62012-07-12 00:05:02 -07001859
1860 lladdr = NULL;
David S. Millere8599ff2012-07-11 23:43:53 -07001861 if (ndopts.nd_opts_tgt_lladdr) {
1862 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1863 skb->dev);
1864 if (!lladdr) {
1865 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1866 return;
1867 }
1868 }
1869
David S. Miller6e157b62012-07-12 00:05:02 -07001870 rt = (struct rt6_info *) dst;
1871 if (rt == net->ipv6.ip6_null_entry) {
1872 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
1873 return;
1874 }
1875
1876 /* Redirect received -> path was valid.
1877 * Look, redirects are sent only in response to data packets,
1878 * so that this nexthop apparently is reachable. --ANK
1879 */
1880 dst_confirm(&rt->dst);
1881
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001882 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
David S. Millere8599ff2012-07-11 23:43:53 -07001883 if (!neigh)
1884 return;
1885
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 /*
1887 * We have finally decided to accept it.
1888 */
1889
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001890 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1892 NEIGH_UPDATE_F_OVERRIDE|
1893 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1894 NEIGH_UPDATE_F_ISROUTER))
1895 );
1896
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001897 nrt = ip6_rt_copy(rt, &msg->dest);
David S. Miller38308472011-12-03 18:02:47 -05001898 if (!nrt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 goto out;
1900
1901 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1902 if (on_link)
1903 nrt->rt6i_flags &= ~RTF_GATEWAY;
1904
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001905 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906
Thomas Graf40e22e82006-08-22 00:00:45 -07001907 if (ip6_ins_rt(nrt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 goto out;
1909
Changli Gaod8d1f302010-06-10 23:31:35 -07001910 netevent.old = &rt->dst;
1911 netevent.new = &nrt->dst;
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001912 netevent.daddr = &msg->dest;
YOSHIFUJI Hideaki / 吉藤英明60592832013-01-14 09:28:27 +00001913 netevent.neigh = neigh;
Tom Tucker8d717402006-07-30 20:43:36 -07001914 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1915
David S. Miller38308472011-12-03 18:02:47 -05001916 if (rt->rt6i_flags & RTF_CACHE) {
David S. Miller6e157b62012-07-12 00:05:02 -07001917 rt = (struct rt6_info *) dst_clone(&rt->dst);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001918 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 }
1920
1921out:
David S. Millere8599ff2012-07-11 23:43:53 -07001922 neigh_release(neigh);
David S. Miller6e157b62012-07-12 00:05:02 -07001923}
1924
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 * Misc support functions
1927 */
1928
Gao feng1716a962012-04-06 00:13:10 +00001929static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
Eric Dumazet21efcfa2011-07-19 20:18:36 +00001930 const struct in6_addr *dest)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931{
David S. Millerd1918542011-12-28 20:19:20 -05001932 struct net *net = dev_net(ort->dst.dev);
David S. Miller8b96d222012-06-11 02:01:56 -07001933 struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1934 ort->rt6i_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935
1936 if (rt) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001937 rt->dst.input = ort->dst.input;
1938 rt->dst.output = ort->dst.output;
Yan, Zheng8e2ec632011-09-05 21:34:30 +00001939 rt->dst.flags |= DST_HOST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001941 rt->rt6i_dst.addr = *dest;
Yan, Zheng8e2ec632011-09-05 21:34:30 +00001942 rt->rt6i_dst.plen = 128;
David S. Millerdefb3512010-12-08 21:16:57 -08001943 dst_copy_metrics(&rt->dst, &ort->dst);
Changli Gaod8d1f302010-06-10 23:31:35 -07001944 rt->dst.error = ort->dst.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 rt->rt6i_idev = ort->rt6i_idev;
1946 if (rt->rt6i_idev)
1947 in6_dev_hold(rt->rt6i_idev);
Changli Gaod8d1f302010-06-10 23:31:35 -07001948 rt->dst.lastuse = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949
Julian Anastasov550bab42013-10-20 15:43:04 +03001950 if (ort->rt6i_flags & RTF_GATEWAY)
1951 rt->rt6i_gateway = ort->rt6i_gateway;
1952 else
1953 rt->rt6i_gateway = *dest;
Gao feng1716a962012-04-06 00:13:10 +00001954 rt->rt6i_flags = ort->rt6i_flags;
Li RongQing24f5b852013-12-19 12:40:26 +08001955 rt6_set_from(rt, ort);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956 rt->rt6i_metric = 0;
1957
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958#ifdef CONFIG_IPV6_SUBTREES
1959 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1960#endif
Florian Westphal0f6c6392011-05-20 11:27:24 +00001961 memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
Thomas Grafc71099a2006-08-04 23:20:06 -07001962 rt->rt6i_table = ort->rt6i_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 }
1964 return rt;
1965}
1966
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001967#ifdef CONFIG_IPV6_ROUTE_INFO
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08001968static struct rt6_info *rt6_get_route_info(struct net *net,
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001969 const struct in6_addr *prefix, int prefixlen,
1970 const struct in6_addr *gwaddr, int ifindex)
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001971{
1972 struct fib6_node *fn;
1973 struct rt6_info *rt = NULL;
Thomas Grafc71099a2006-08-04 23:20:06 -07001974 struct fib6_table *table;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001975
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08001976 table = fib6_get_table(net, RT6_TABLE_INFO);
David S. Miller38308472011-12-03 18:02:47 -05001977 if (!table)
Thomas Grafc71099a2006-08-04 23:20:06 -07001978 return NULL;
1979
Li RongQing5744dd92012-09-11 21:59:01 +00001980 read_lock_bh(&table->tb6_lock);
Ian Morris67ba4152014-08-24 21:53:10 +01001981 fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001982 if (!fn)
1983 goto out;
1984
Changli Gaod8d1f302010-06-10 23:31:35 -07001985 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
David S. Millerd1918542011-12-28 20:19:20 -05001986 if (rt->dst.dev->ifindex != ifindex)
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001987 continue;
1988 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1989 continue;
1990 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1991 continue;
Changli Gaod8d1f302010-06-10 23:31:35 -07001992 dst_hold(&rt->dst);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001993 break;
1994 }
1995out:
Li RongQing5744dd92012-09-11 21:59:01 +00001996 read_unlock_bh(&table->tb6_lock);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001997 return rt;
1998}
1999
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08002000static struct rt6_info *rt6_add_route_info(struct net *net,
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002001 const struct in6_addr *prefix, int prefixlen,
2002 const struct in6_addr *gwaddr, int ifindex,
Eric Dumazet95c96172012-04-15 05:58:06 +00002003 unsigned int pref)
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08002004{
Thomas Graf86872cb2006-08-22 00:01:08 -07002005 struct fib6_config cfg = {
2006 .fc_table = RT6_TABLE_INFO,
Rami Rosen238fc7e2008-02-09 23:43:11 -08002007 .fc_metric = IP6_RT_PRIO_USER,
Thomas Graf86872cb2006-08-22 00:01:08 -07002008 .fc_ifindex = ifindex,
2009 .fc_dst_len = prefixlen,
2010 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
2011 RTF_UP | RTF_PREF(pref),
Eric W. Biederman15e47302012-09-07 20:12:54 +00002012 .fc_nlinfo.portid = 0,
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08002013 .fc_nlinfo.nlh = NULL,
2014 .fc_nlinfo.nl_net = net,
Thomas Graf86872cb2006-08-22 00:01:08 -07002015 };
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08002016
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002017 cfg.fc_dst = *prefix;
2018 cfg.fc_gateway = *gwaddr;
Thomas Graf86872cb2006-08-22 00:01:08 -07002019
YOSHIFUJI Hideakie317da92006-03-20 17:06:42 -08002020 /* We should treat it as a default route if prefix length is 0. */
2021 if (!prefixlen)
Thomas Graf86872cb2006-08-22 00:01:08 -07002022 cfg.fc_flags |= RTF_DEFAULT;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08002023
Thomas Graf86872cb2006-08-22 00:01:08 -07002024 ip6_route_add(&cfg);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08002025
Daniel Lezcanoefa2cea2008-03-04 13:46:48 -08002026 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08002027}
2028#endif
2029
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002030struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002031{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032 struct rt6_info *rt;
Thomas Grafc71099a2006-08-04 23:20:06 -07002033 struct fib6_table *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002035 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
David S. Miller38308472011-12-03 18:02:47 -05002036 if (!table)
Thomas Grafc71099a2006-08-04 23:20:06 -07002037 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038
Li RongQing5744dd92012-09-11 21:59:01 +00002039 read_lock_bh(&table->tb6_lock);
Ian Morris67ba4152014-08-24 21:53:10 +01002040 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
David S. Millerd1918542011-12-28 20:19:20 -05002041 if (dev == rt->dst.dev &&
YOSHIFUJI Hideaki045927f2006-03-20 17:00:48 -08002042 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 ipv6_addr_equal(&rt->rt6i_gateway, addr))
2044 break;
2045 }
2046 if (rt)
Changli Gaod8d1f302010-06-10 23:31:35 -07002047 dst_hold(&rt->dst);
Li RongQing5744dd92012-09-11 21:59:01 +00002048 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 return rt;
2050}
2051
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002052struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08002053 struct net_device *dev,
2054 unsigned int pref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055{
Thomas Graf86872cb2006-08-22 00:01:08 -07002056 struct fib6_config cfg = {
2057 .fc_table = RT6_TABLE_DFLT,
Rami Rosen238fc7e2008-02-09 23:43:11 -08002058 .fc_metric = IP6_RT_PRIO_USER,
Thomas Graf86872cb2006-08-22 00:01:08 -07002059 .fc_ifindex = dev->ifindex,
2060 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
2061 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
Eric W. Biederman15e47302012-09-07 20:12:54 +00002062 .fc_nlinfo.portid = 0,
Daniel Lezcano55786892008-03-04 13:47:47 -08002063 .fc_nlinfo.nlh = NULL,
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002064 .fc_nlinfo.nl_net = dev_net(dev),
Thomas Graf86872cb2006-08-22 00:01:08 -07002065 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002067 cfg.fc_gateway = *gwaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068
Thomas Graf86872cb2006-08-22 00:01:08 -07002069 ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071 return rt6_get_dflt_router(gwaddr, dev);
2072}
2073
Daniel Lezcano7b4da532008-03-04 13:47:14 -08002074void rt6_purge_dflt_routers(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075{
2076 struct rt6_info *rt;
Thomas Grafc71099a2006-08-04 23:20:06 -07002077 struct fib6_table *table;
2078
2079 /* NOTE: Keep consistent with rt6_get_dflt_router */
Daniel Lezcano7b4da532008-03-04 13:47:14 -08002080 table = fib6_get_table(net, RT6_TABLE_DFLT);
David S. Miller38308472011-12-03 18:02:47 -05002081 if (!table)
Thomas Grafc71099a2006-08-04 23:20:06 -07002082 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083
2084restart:
Thomas Grafc71099a2006-08-04 23:20:06 -07002085 read_lock_bh(&table->tb6_lock);
Changli Gaod8d1f302010-06-10 23:31:35 -07002086 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
Lorenzo Colitti3e8b0ac2013-03-03 20:46:46 +00002087 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2088 (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002089 dst_hold(&rt->dst);
Thomas Grafc71099a2006-08-04 23:20:06 -07002090 read_unlock_bh(&table->tb6_lock);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07002091 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 goto restart;
2093 }
2094 }
Thomas Grafc71099a2006-08-04 23:20:06 -07002095 read_unlock_bh(&table->tb6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096}
2097
Daniel Lezcano55786892008-03-04 13:47:47 -08002098static void rtmsg_to_fib6_config(struct net *net,
2099 struct in6_rtmsg *rtmsg,
Thomas Graf86872cb2006-08-22 00:01:08 -07002100 struct fib6_config *cfg)
2101{
2102 memset(cfg, 0, sizeof(*cfg));
2103
2104 cfg->fc_table = RT6_TABLE_MAIN;
2105 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2106 cfg->fc_metric = rtmsg->rtmsg_metric;
2107 cfg->fc_expires = rtmsg->rtmsg_info;
2108 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2109 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2110 cfg->fc_flags = rtmsg->rtmsg_flags;
2111
Daniel Lezcano55786892008-03-04 13:47:47 -08002112 cfg->fc_nlinfo.nl_net = net;
Benjamin Theryf1243c22008-02-26 18:10:03 -08002113
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002114 cfg->fc_dst = rtmsg->rtmsg_dst;
2115 cfg->fc_src = rtmsg->rtmsg_src;
2116 cfg->fc_gateway = rtmsg->rtmsg_gateway;
Thomas Graf86872cb2006-08-22 00:01:08 -07002117}
2118
Daniel Lezcano55786892008-03-04 13:47:47 -08002119int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120{
Thomas Graf86872cb2006-08-22 00:01:08 -07002121 struct fib6_config cfg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 struct in6_rtmsg rtmsg;
2123 int err;
2124
Ian Morris67ba4152014-08-24 21:53:10 +01002125 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 case SIOCADDRT: /* Add a route */
2127 case SIOCDELRT: /* Delete a route */
Eric W. Biedermanaf31f412012-11-16 03:03:06 +00002128 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 return -EPERM;
2130 err = copy_from_user(&rtmsg, arg,
2131 sizeof(struct in6_rtmsg));
2132 if (err)
2133 return -EFAULT;
Thomas Graf86872cb2006-08-22 00:01:08 -07002134
Daniel Lezcano55786892008-03-04 13:47:47 -08002135 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
Thomas Graf86872cb2006-08-22 00:01:08 -07002136
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 rtnl_lock();
2138 switch (cmd) {
2139 case SIOCADDRT:
Thomas Graf86872cb2006-08-22 00:01:08 -07002140 err = ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 break;
2142 case SIOCDELRT:
Thomas Graf86872cb2006-08-22 00:01:08 -07002143 err = ip6_route_del(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 break;
2145 default:
2146 err = -EINVAL;
2147 }
2148 rtnl_unlock();
2149
2150 return err;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07002151 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152
2153 return -EINVAL;
2154}
2155
2156/*
2157 * Drop the packet on the floor
2158 */
2159
Brian Haleyd5fdd6b2009-06-23 04:31:07 -07002160static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002162 int type;
Eric Dumazetadf30902009-06-02 05:19:30 +00002163 struct dst_entry *dst = skb_dst(skb);
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002164 switch (ipstats_mib_noroutes) {
2165 case IPSTATS_MIB_INNOROUTES:
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07002166 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
Ulrich Weber45bb0062010-02-25 23:28:58 +00002167 if (type == IPV6_ADDR_ANY) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -07002168 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2169 IPSTATS_MIB_INADDRERRORS);
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002170 break;
2171 }
2172 /* FALLTHROUGH */
2173 case IPSTATS_MIB_OUTNOROUTES:
Denis V. Lunev3bd653c2008-10-08 10:54:51 -07002174 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2175 ipstats_mib_noroutes);
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002176 break;
2177 }
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +00002178 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 kfree_skb(skb);
2180 return 0;
2181}
2182
Thomas Graf9ce8ade2006-10-18 20:46:54 -07002183static int ip6_pkt_discard(struct sk_buff *skb)
2184{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002185 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07002186}
2187
Eric Dumazetaad88722014-04-15 13:47:15 -04002188static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189{
Eric Dumazetadf30902009-06-02 05:19:30 +00002190 skb->dev = skb_dst(skb)->dev;
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002191 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192}
2193
Thomas Graf9ce8ade2006-10-18 20:46:54 -07002194static int ip6_pkt_prohibit(struct sk_buff *skb)
2195{
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002196 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07002197}
2198
Eric Dumazetaad88722014-04-15 13:47:15 -04002199static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb)
Thomas Graf9ce8ade2006-10-18 20:46:54 -07002200{
Eric Dumazetadf30902009-06-02 05:19:30 +00002201 skb->dev = skb_dst(skb)->dev;
YOSHIFUJI Hideaki612f09e2007-04-13 16:18:02 -07002202 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
Thomas Graf9ce8ade2006-10-18 20:46:54 -07002203}
2204
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205/*
2206 * Allocate a dst for local (unicast / anycast) address.
2207 */
2208
2209struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2210 const struct in6_addr *addr,
David S. Miller8f031512011-12-06 16:48:14 -05002211 bool anycast)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002213 struct net *net = dev_net(idev->dev);
Hannes Frederic Sowaa3300ef2013-12-07 03:33:45 +01002214 struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,
2215 DST_NOCOUNT, NULL);
2216 if (!rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 return ERR_PTR(-ENOMEM);
2218
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219 in6_dev_hold(idev);
2220
David S. Miller11d53b42011-06-24 15:23:34 -07002221 rt->dst.flags |= DST_HOST;
Changli Gaod8d1f302010-06-10 23:31:35 -07002222 rt->dst.input = ip6_input;
2223 rt->dst.output = ip6_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224 rt->rt6i_idev = idev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225
2226 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
YOSHIFUJI Hideaki58c4fb82005-12-21 22:56:42 +09002227 if (anycast)
2228 rt->rt6i_flags |= RTF_ANYCAST;
2229 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 rt->rt6i_flags |= RTF_LOCAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231
Julian Anastasov550bab42013-10-20 15:43:04 +03002232 rt->rt6i_gateway = *addr;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002233 rt->rt6i_dst.addr = *addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234 rt->rt6i_dst.plen = 128;
Daniel Lezcano55786892008-03-04 13:47:47 -08002235 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236
Changli Gaod8d1f302010-06-10 23:31:35 -07002237 atomic_set(&rt->dst.__refcnt, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238
2239 return rt;
2240}
2241
Daniel Walterc3968a82011-04-13 21:10:57 +00002242int ip6_route_get_saddr(struct net *net,
2243 struct rt6_info *rt,
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002244 const struct in6_addr *daddr,
Daniel Walterc3968a82011-04-13 21:10:57 +00002245 unsigned int prefs,
2246 struct in6_addr *saddr)
2247{
Ian Morris67ba4152014-08-24 21:53:10 +01002248 struct inet6_dev *idev = ip6_dst_idev((struct dst_entry *)rt);
Daniel Walterc3968a82011-04-13 21:10:57 +00002249 int err = 0;
2250 if (rt->rt6i_prefsrc.plen)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002251 *saddr = rt->rt6i_prefsrc.addr;
Daniel Walterc3968a82011-04-13 21:10:57 +00002252 else
2253 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2254 daddr, prefs, saddr);
2255 return err;
2256}
2257
2258/* remove deleted ip from prefsrc entries */
2259struct arg_dev_net_ip {
2260 struct net_device *dev;
2261 struct net *net;
2262 struct in6_addr *addr;
2263};
2264
2265static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2266{
2267 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2268 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2269 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2270
David S. Millerd1918542011-12-28 20:19:20 -05002271 if (((void *)rt->dst.dev == dev || !dev) &&
Daniel Walterc3968a82011-04-13 21:10:57 +00002272 rt != net->ipv6.ip6_null_entry &&
2273 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2274 /* remove prefsrc entry */
2275 rt->rt6i_prefsrc.plen = 0;
2276 }
2277 return 0;
2278}
2279
2280void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2281{
2282 struct net *net = dev_net(ifp->idev->dev);
2283 struct arg_dev_net_ip adni = {
2284 .dev = ifp->idev->dev,
2285 .net = net,
2286 .addr = &ifp->addr,
2287 };
Li RongQing0c3584d2013-12-27 16:32:38 +08002288 fib6_clean_all(net, fib6_remove_prefsrc, &adni);
Daniel Walterc3968a82011-04-13 21:10:57 +00002289}
2290
Duan Jiongbe7a0102014-05-15 15:56:14 +08002291#define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2292#define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)
2293
2294/* Remove routers and update dst entries when gateway turn into host. */
2295static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
2296{
2297 struct in6_addr *gateway = (struct in6_addr *)arg;
2298
2299 if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
2300 ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
2301 ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
2302 return -1;
2303 }
2304 return 0;
2305}
2306
2307void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
2308{
2309 fib6_clean_all(net, fib6_clean_tohost, gateway);
2310}
2311
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002312struct arg_dev_net {
2313 struct net_device *dev;
2314 struct net *net;
2315};
2316
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317static int fib6_ifdown(struct rt6_info *rt, void *arg)
2318{
stephen hemmingerbc3ef662010-12-16 17:42:40 +00002319 const struct arg_dev_net *adn = arg;
2320 const struct net_device *dev = adn->dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002321
David S. Millerd1918542011-12-28 20:19:20 -05002322 if ((rt->dst.dev == dev || !dev) &&
David S. Millerc159d302011-12-26 15:24:36 -05002323 rt != adn->net->ipv6.ip6_null_entry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 return -1;
David S. Millerc159d302011-12-26 15:24:36 -05002325
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 return 0;
2327}
2328
Daniel Lezcanof3db4852008-03-03 23:27:06 -08002329void rt6_ifdown(struct net *net, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330{
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002331 struct arg_dev_net adn = {
2332 .dev = dev,
2333 .net = net,
2334 };
2335
Li RongQing0c3584d2013-12-27 16:32:38 +08002336 fib6_clean_all(net, fib6_ifdown, &adn);
David S. Miller1e493d12008-09-10 17:27:15 -07002337 icmp6_clean_all(fib6_ifdown, &adn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338}
2339
Eric Dumazet95c96172012-04-15 05:58:06 +00002340struct rt6_mtu_change_arg {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 struct net_device *dev;
Eric Dumazet95c96172012-04-15 05:58:06 +00002342 unsigned int mtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343};
2344
2345static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2346{
2347 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2348 struct inet6_dev *idev;
2349
2350 /* In IPv6 pmtu discovery is not optional,
2351 so that RTAX_MTU lock cannot disable it.
2352 We still use this lock to block changes
2353 caused by addrconf/ndisc.
2354 */
2355
2356 idev = __in6_dev_get(arg->dev);
David S. Miller38308472011-12-03 18:02:47 -05002357 if (!idev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 return 0;
2359
2360 /* For administrative MTU increase, there is no way to discover
2361 IPv6 PMTU increase, so PMTU increase should be updated here.
2362 Since RFC 1981 doesn't include administrative MTU increase
2363 update PMTU increase is a MUST. (i.e. jumbo frame)
2364 */
2365 /*
2366 If new MTU is less than route PMTU, this new MTU will be the
2367 lowest MTU in the path, update the route PMTU to reflect PMTU
2368 decreases; if new MTU is greater than route PMTU, and the
2369 old MTU is the lowest MTU in the path, update the route PMTU
2370 to reflect the increase. In this case if the other nodes' MTU
2371 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2372 PMTU discouvery.
2373 */
David S. Millerd1918542011-12-28 20:19:20 -05002374 if (rt->dst.dev == arg->dev &&
Changli Gaod8d1f302010-06-10 23:31:35 -07002375 !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2376 (dst_mtu(&rt->dst) >= arg->mtu ||
2377 (dst_mtu(&rt->dst) < arg->mtu &&
2378 dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
David S. Millerdefb3512010-12-08 21:16:57 -08002379 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
Simon Arlott566cfd82007-07-26 00:09:55 -07002380 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 return 0;
2382}
2383
Eric Dumazet95c96172012-04-15 05:58:06 +00002384void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385{
Thomas Grafc71099a2006-08-04 23:20:06 -07002386 struct rt6_mtu_change_arg arg = {
2387 .dev = dev,
2388 .mtu = mtu,
2389 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390
Li RongQing0c3584d2013-12-27 16:32:38 +08002391 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392}
2393
Patrick McHardyef7c79e2007-06-05 12:38:30 -07002394static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
Thomas Graf5176f912006-08-26 20:13:18 -07002395 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
Thomas Graf86872cb2006-08-22 00:01:08 -07002396 [RTA_OIF] = { .type = NLA_U32 },
Thomas Grafab364a62006-08-22 00:01:47 -07002397 [RTA_IIF] = { .type = NLA_U32 },
Thomas Graf86872cb2006-08-22 00:01:08 -07002398 [RTA_PRIORITY] = { .type = NLA_U32 },
2399 [RTA_METRICS] = { .type = NLA_NESTED },
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00002400 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
Lubomir Rintelc78ba6d2015-03-11 15:39:21 +01002401 [RTA_PREF] = { .type = NLA_U8 },
Thomas Graf86872cb2006-08-22 00:01:08 -07002402};
2403
2404static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2405 struct fib6_config *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406{
Thomas Graf86872cb2006-08-22 00:01:08 -07002407 struct rtmsg *rtm;
2408 struct nlattr *tb[RTA_MAX+1];
Lubomir Rintelc78ba6d2015-03-11 15:39:21 +01002409 unsigned int pref;
Thomas Graf86872cb2006-08-22 00:01:08 -07002410 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411
Thomas Graf86872cb2006-08-22 00:01:08 -07002412 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2413 if (err < 0)
2414 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415
Thomas Graf86872cb2006-08-22 00:01:08 -07002416 err = -EINVAL;
2417 rtm = nlmsg_data(nlh);
2418 memset(cfg, 0, sizeof(*cfg));
2419
2420 cfg->fc_table = rtm->rtm_table;
2421 cfg->fc_dst_len = rtm->rtm_dst_len;
2422 cfg->fc_src_len = rtm->rtm_src_len;
2423 cfg->fc_flags = RTF_UP;
2424 cfg->fc_protocol = rtm->rtm_protocol;
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00002425 cfg->fc_type = rtm->rtm_type;
Thomas Graf86872cb2006-08-22 00:01:08 -07002426
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00002427 if (rtm->rtm_type == RTN_UNREACHABLE ||
2428 rtm->rtm_type == RTN_BLACKHOLE ||
Nicolas Dichtelb4949ab2012-09-06 05:53:35 +00002429 rtm->rtm_type == RTN_PROHIBIT ||
2430 rtm->rtm_type == RTN_THROW)
Thomas Graf86872cb2006-08-22 00:01:08 -07002431 cfg->fc_flags |= RTF_REJECT;
2432
Maciej Żenczykowskiab79ad12010-09-27 00:07:02 +00002433 if (rtm->rtm_type == RTN_LOCAL)
2434 cfg->fc_flags |= RTF_LOCAL;
2435
Eric W. Biederman15e47302012-09-07 20:12:54 +00002436 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
Thomas Graf86872cb2006-08-22 00:01:08 -07002437 cfg->fc_nlinfo.nlh = nlh;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002438 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
Thomas Graf86872cb2006-08-22 00:01:08 -07002439
2440 if (tb[RTA_GATEWAY]) {
2441 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2442 cfg->fc_flags |= RTF_GATEWAY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002444
2445 if (tb[RTA_DST]) {
2446 int plen = (rtm->rtm_dst_len + 7) >> 3;
2447
2448 if (nla_len(tb[RTA_DST]) < plen)
2449 goto errout;
2450
2451 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002453
2454 if (tb[RTA_SRC]) {
2455 int plen = (rtm->rtm_src_len + 7) >> 3;
2456
2457 if (nla_len(tb[RTA_SRC]) < plen)
2458 goto errout;
2459
2460 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002462
Daniel Walterc3968a82011-04-13 21:10:57 +00002463 if (tb[RTA_PREFSRC])
2464 nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2465
Thomas Graf86872cb2006-08-22 00:01:08 -07002466 if (tb[RTA_OIF])
2467 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2468
2469 if (tb[RTA_PRIORITY])
2470 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2471
2472 if (tb[RTA_METRICS]) {
2473 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2474 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 }
Thomas Graf86872cb2006-08-22 00:01:08 -07002476
2477 if (tb[RTA_TABLE])
2478 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2479
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00002480 if (tb[RTA_MULTIPATH]) {
2481 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2482 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2483 }
2484
Lubomir Rintelc78ba6d2015-03-11 15:39:21 +01002485 if (tb[RTA_PREF]) {
2486 pref = nla_get_u8(tb[RTA_PREF]);
2487 if (pref != ICMPV6_ROUTER_PREF_LOW &&
2488 pref != ICMPV6_ROUTER_PREF_HIGH)
2489 pref = ICMPV6_ROUTER_PREF_MEDIUM;
2490 cfg->fc_flags |= RTF_PREF(pref);
2491 }
2492
Thomas Graf86872cb2006-08-22 00:01:08 -07002493 err = 0;
2494errout:
2495 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496}
2497
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00002498static int ip6_route_multipath(struct fib6_config *cfg, int add)
2499{
2500 struct fib6_config r_cfg;
2501 struct rtnexthop *rtnh;
2502 int remaining;
2503 int attrlen;
2504 int err = 0, last_err = 0;
2505
2506beginning:
2507 rtnh = (struct rtnexthop *)cfg->fc_mp;
2508 remaining = cfg->fc_mp_len;
2509
2510 /* Parse a Multipath Entry */
2511 while (rtnh_ok(rtnh, remaining)) {
2512 memcpy(&r_cfg, cfg, sizeof(*cfg));
2513 if (rtnh->rtnh_ifindex)
2514 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2515
2516 attrlen = rtnh_attrlen(rtnh);
2517 if (attrlen > 0) {
2518 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2519
2520 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2521 if (nla) {
2522 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
2523 r_cfg.fc_flags |= RTF_GATEWAY;
2524 }
2525 }
2526 err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2527 if (err) {
2528 last_err = err;
2529 /* If we are trying to remove a route, do not stop the
2530 * loop when ip6_route_del() fails (because next hop is
2531 * already gone), we should try to remove all next hops.
2532 */
2533 if (add) {
2534 /* If add fails, we should try to delete all
2535 * next hops that have been already added.
2536 */
2537 add = 0;
2538 goto beginning;
2539 }
2540 }
Nicolas Dichtel1a724182012-11-01 22:58:22 +00002541 /* Because each route is added like a single route we remove
2542 * this flag after the first nexthop (if there is a collision,
2543 * we have already fail to add the first nexthop:
2544 * fib6_add_rt2node() has reject it).
2545 */
2546 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00002547 rtnh = rtnh_next(rtnh, &remaining);
2548 }
2549
2550 return last_err;
2551}
2552
Ian Morris67ba4152014-08-24 21:53:10 +01002553static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554{
Thomas Graf86872cb2006-08-22 00:01:08 -07002555 struct fib6_config cfg;
2556 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557
Thomas Graf86872cb2006-08-22 00:01:08 -07002558 err = rtm_to_fib6_config(skb, nlh, &cfg);
2559 if (err < 0)
2560 return err;
2561
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00002562 if (cfg.fc_mp)
2563 return ip6_route_multipath(&cfg, 0);
2564 else
2565 return ip6_route_del(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566}
2567
Ian Morris67ba4152014-08-24 21:53:10 +01002568static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569{
Thomas Graf86872cb2006-08-22 00:01:08 -07002570 struct fib6_config cfg;
2571 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572
Thomas Graf86872cb2006-08-22 00:01:08 -07002573 err = rtm_to_fib6_config(skb, nlh, &cfg);
2574 if (err < 0)
2575 return err;
2576
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00002577 if (cfg.fc_mp)
2578 return ip6_route_multipath(&cfg, 1);
2579 else
2580 return ip6_route_add(&cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581}
2582
Thomas Graf339bf982006-11-10 14:10:15 -08002583static inline size_t rt6_nlmsg_size(void)
2584{
2585 return NLMSG_ALIGN(sizeof(struct rtmsg))
2586 + nla_total_size(16) /* RTA_SRC */
2587 + nla_total_size(16) /* RTA_DST */
2588 + nla_total_size(16) /* RTA_GATEWAY */
2589 + nla_total_size(16) /* RTA_PREFSRC */
2590 + nla_total_size(4) /* RTA_TABLE */
2591 + nla_total_size(4) /* RTA_IIF */
2592 + nla_total_size(4) /* RTA_OIF */
2593 + nla_total_size(4) /* RTA_PRIORITY */
Noriaki TAKAMIYA6a2b9ce2007-01-23 22:09:41 -08002594 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
Daniel Borkmannea697632015-01-05 23:57:47 +01002595 + nla_total_size(sizeof(struct rta_cacheinfo))
Lubomir Rintelc78ba6d2015-03-11 15:39:21 +01002596 + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
2597 + nla_total_size(1); /* RTA_PREF */
Thomas Graf339bf982006-11-10 14:10:15 -08002598}
2599
Brian Haley191cd582008-08-14 15:33:21 -07002600static int rt6_fill_node(struct net *net,
2601 struct sk_buff *skb, struct rt6_info *rt,
Jamal Hadi Salim0d51aa82005-06-21 13:51:04 -07002602 struct in6_addr *dst, struct in6_addr *src,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002603 int iif, int type, u32 portid, u32 seq,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002604 int prefix, int nowait, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605{
2606 struct rtmsg *rtm;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002607 struct nlmsghdr *nlh;
Thomas Grafe3703b32006-11-27 09:27:07 -08002608 long expires;
Patrick McHardy9e762a42006-08-10 23:09:48 -07002609 u32 table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610
2611 if (prefix) { /* user wants prefix routes only */
2612 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2613 /* success since this is not a prefix route */
2614 return 1;
2615 }
2616 }
2617
Eric W. Biederman15e47302012-09-07 20:12:54 +00002618 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
David S. Miller38308472011-12-03 18:02:47 -05002619 if (!nlh)
Patrick McHardy26932562007-01-31 23:16:40 -08002620 return -EMSGSIZE;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002621
2622 rtm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623 rtm->rtm_family = AF_INET6;
2624 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2625 rtm->rtm_src_len = rt->rt6i_src.plen;
2626 rtm->rtm_tos = 0;
Thomas Grafc71099a2006-08-04 23:20:06 -07002627 if (rt->rt6i_table)
Patrick McHardy9e762a42006-08-10 23:09:48 -07002628 table = rt->rt6i_table->tb6_id;
Thomas Grafc71099a2006-08-04 23:20:06 -07002629 else
Patrick McHardy9e762a42006-08-10 23:09:48 -07002630 table = RT6_TABLE_UNSPEC;
2631 rtm->rtm_table = table;
David S. Millerc78679e2012-04-01 20:27:33 -04002632 if (nla_put_u32(skb, RTA_TABLE, table))
2633 goto nla_put_failure;
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00002634 if (rt->rt6i_flags & RTF_REJECT) {
2635 switch (rt->dst.error) {
2636 case -EINVAL:
2637 rtm->rtm_type = RTN_BLACKHOLE;
2638 break;
2639 case -EACCES:
2640 rtm->rtm_type = RTN_PROHIBIT;
2641 break;
Nicolas Dichtelb4949ab2012-09-06 05:53:35 +00002642 case -EAGAIN:
2643 rtm->rtm_type = RTN_THROW;
2644 break;
Nicolas Dichtelef2c7d72012-09-05 02:12:42 +00002645 default:
2646 rtm->rtm_type = RTN_UNREACHABLE;
2647 break;
2648 }
2649 }
David S. Miller38308472011-12-03 18:02:47 -05002650 else if (rt->rt6i_flags & RTF_LOCAL)
Maciej Żenczykowskiab79ad12010-09-27 00:07:02 +00002651 rtm->rtm_type = RTN_LOCAL;
David S. Millerd1918542011-12-28 20:19:20 -05002652 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653 rtm->rtm_type = RTN_LOCAL;
2654 else
2655 rtm->rtm_type = RTN_UNICAST;
2656 rtm->rtm_flags = 0;
2657 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2658 rtm->rtm_protocol = rt->rt6i_protocol;
David S. Miller38308472011-12-03 18:02:47 -05002659 if (rt->rt6i_flags & RTF_DYNAMIC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660 rtm->rtm_protocol = RTPROT_REDIRECT;
Denis Ovsienkof0396f602012-07-10 04:45:50 +00002661 else if (rt->rt6i_flags & RTF_ADDRCONF) {
2662 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2663 rtm->rtm_protocol = RTPROT_RA;
2664 else
2665 rtm->rtm_protocol = RTPROT_KERNEL;
2666 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667
David S. Miller38308472011-12-03 18:02:47 -05002668 if (rt->rt6i_flags & RTF_CACHE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669 rtm->rtm_flags |= RTM_F_CLONED;
2670
2671 if (dst) {
David S. Millerc78679e2012-04-01 20:27:33 -04002672 if (nla_put(skb, RTA_DST, 16, dst))
2673 goto nla_put_failure;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002674 rtm->rtm_dst_len = 128;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675 } else if (rtm->rtm_dst_len)
David S. Millerc78679e2012-04-01 20:27:33 -04002676 if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2677 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678#ifdef CONFIG_IPV6_SUBTREES
2679 if (src) {
David S. Millerc78679e2012-04-01 20:27:33 -04002680 if (nla_put(skb, RTA_SRC, 16, src))
2681 goto nla_put_failure;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002682 rtm->rtm_src_len = 128;
David S. Millerc78679e2012-04-01 20:27:33 -04002683 } else if (rtm->rtm_src_len &&
2684 nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2685 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686#endif
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002687 if (iif) {
2688#ifdef CONFIG_IPV6_MROUTE
2689 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
Benjamin Thery8229efd2008-12-10 16:30:15 -08002690 int err = ip6mr_get_route(net, skb, rtm, nowait);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002691 if (err <= 0) {
2692 if (!nowait) {
2693 if (err == 0)
2694 return 0;
2695 goto nla_put_failure;
2696 } else {
2697 if (err == -EMSGSIZE)
2698 goto nla_put_failure;
2699 }
2700 }
2701 } else
2702#endif
David S. Millerc78679e2012-04-01 20:27:33 -04002703 if (nla_put_u32(skb, RTA_IIF, iif))
2704 goto nla_put_failure;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002705 } else if (dst) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706 struct in6_addr saddr_buf;
David S. Millerc78679e2012-04-01 20:27:33 -04002707 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2708 nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2709 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002710 }
Thomas Graf2d7202b2006-08-22 00:01:27 -07002711
Daniel Walterc3968a82011-04-13 21:10:57 +00002712 if (rt->rt6i_prefsrc.plen) {
2713 struct in6_addr saddr_buf;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002714 saddr_buf = rt->rt6i_prefsrc.addr;
David S. Millerc78679e2012-04-01 20:27:33 -04002715 if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2716 goto nla_put_failure;
Daniel Walterc3968a82011-04-13 21:10:57 +00002717 }
2718
David S. Millerdefb3512010-12-08 21:16:57 -08002719 if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
Thomas Graf2d7202b2006-08-22 00:01:27 -07002720 goto nla_put_failure;
2721
YOSHIFUJI Hideaki / 吉藤英明dd0cbf22013-01-17 12:53:15 +00002722 if (rt->rt6i_flags & RTF_GATEWAY) {
2723 if (nla_put(skb, RTA_GATEWAY, 16, &rt->rt6i_gateway) < 0)
Eric Dumazet94f826b2012-03-27 09:53:52 +00002724 goto nla_put_failure;
Eric Dumazet94f826b2012-03-27 09:53:52 +00002725 }
Thomas Graf2d7202b2006-08-22 00:01:27 -07002726
David S. Millerc78679e2012-04-01 20:27:33 -04002727 if (rt->dst.dev &&
2728 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2729 goto nla_put_failure;
2730 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2731 goto nla_put_failure;
Li Wei82539472012-07-29 16:01:30 +00002732
2733 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
YOSHIFUJI Hideaki69cdf8f2008-05-19 16:55:13 -07002734
David S. Miller87a50692012-07-10 05:06:14 -07002735 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
Thomas Grafe3703b32006-11-27 09:27:07 -08002736 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737
Lubomir Rintelc78ba6d2015-03-11 15:39:21 +01002738 if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt->rt6i_flags)))
2739 goto nla_put_failure;
2740
Johannes Berg053c0952015-01-16 22:09:00 +01002741 nlmsg_end(skb, nlh);
2742 return 0;
Thomas Graf2d7202b2006-08-22 00:01:27 -07002743
2744nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002745 nlmsg_cancel(skb, nlh);
2746 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002747}
2748
Patrick McHardy1b43af52006-08-10 23:11:17 -07002749int rt6_dump_route(struct rt6_info *rt, void *p_arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750{
2751 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2752 int prefix;
2753
Thomas Graf2d7202b2006-08-22 00:01:27 -07002754 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2755 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2757 } else
2758 prefix = 0;
2759
Brian Haley191cd582008-08-14 15:33:21 -07002760 return rt6_fill_node(arg->net,
2761 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002762 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002763 prefix, 0, NLM_F_MULTI);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002764}
2765
Ian Morris67ba4152014-08-24 21:53:10 +01002766static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002768 struct net *net = sock_net(in_skb->sk);
Thomas Grafab364a62006-08-22 00:01:47 -07002769 struct nlattr *tb[RTA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 struct rt6_info *rt;
Thomas Grafab364a62006-08-22 00:01:47 -07002771 struct sk_buff *skb;
2772 struct rtmsg *rtm;
David S. Miller4c9483b2011-03-12 16:22:43 -05002773 struct flowi6 fl6;
Shmulik Ladkani72331bc2012-04-01 04:03:45 +00002774 int err, iif = 0, oif = 0;
Thomas Grafab364a62006-08-22 00:01:47 -07002775
2776 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2777 if (err < 0)
2778 goto errout;
2779
2780 err = -EINVAL;
David S. Miller4c9483b2011-03-12 16:22:43 -05002781 memset(&fl6, 0, sizeof(fl6));
Thomas Grafab364a62006-08-22 00:01:47 -07002782
2783 if (tb[RTA_SRC]) {
2784 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2785 goto errout;
2786
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002787 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
Thomas Grafab364a62006-08-22 00:01:47 -07002788 }
2789
2790 if (tb[RTA_DST]) {
2791 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2792 goto errout;
2793
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002794 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
Thomas Grafab364a62006-08-22 00:01:47 -07002795 }
2796
2797 if (tb[RTA_IIF])
2798 iif = nla_get_u32(tb[RTA_IIF]);
2799
2800 if (tb[RTA_OIF])
Shmulik Ladkani72331bc2012-04-01 04:03:45 +00002801 oif = nla_get_u32(tb[RTA_OIF]);
Thomas Grafab364a62006-08-22 00:01:47 -07002802
Lorenzo Colitti2e47b292014-05-15 16:38:41 -07002803 if (tb[RTA_MARK])
2804 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
2805
Thomas Grafab364a62006-08-22 00:01:47 -07002806 if (iif) {
2807 struct net_device *dev;
Shmulik Ladkani72331bc2012-04-01 04:03:45 +00002808 int flags = 0;
2809
Daniel Lezcano55786892008-03-04 13:47:47 -08002810 dev = __dev_get_by_index(net, iif);
Thomas Grafab364a62006-08-22 00:01:47 -07002811 if (!dev) {
2812 err = -ENODEV;
2813 goto errout;
2814 }
Shmulik Ladkani72331bc2012-04-01 04:03:45 +00002815
2816 fl6.flowi6_iif = iif;
2817
2818 if (!ipv6_addr_any(&fl6.saddr))
2819 flags |= RT6_LOOKUP_F_HAS_SADDR;
2820
2821 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2822 flags);
2823 } else {
2824 fl6.flowi6_oif = oif;
2825
2826 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
Thomas Grafab364a62006-08-22 00:01:47 -07002827 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828
2829 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
David S. Miller38308472011-12-03 18:02:47 -05002830 if (!skb) {
Amerigo Wang94e187c2012-10-29 00:13:19 +00002831 ip6_rt_put(rt);
Thomas Grafab364a62006-08-22 00:01:47 -07002832 err = -ENOBUFS;
2833 goto errout;
2834 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835
2836 /* Reserve room for dummy headers, this skb can pass
2837 through good chunk of routing engine.
2838 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07002839 skb_reset_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2841
Changli Gaod8d1f302010-06-10 23:31:35 -07002842 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002843
David S. Miller4c9483b2011-03-12 16:22:43 -05002844 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002845 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002846 nlh->nlmsg_seq, 0, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847 if (err < 0) {
Thomas Grafab364a62006-08-22 00:01:47 -07002848 kfree_skb(skb);
2849 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 }
2851
Eric W. Biederman15e47302012-09-07 20:12:54 +00002852 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
Thomas Grafab364a62006-08-22 00:01:47 -07002853errout:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855}
2856
Thomas Graf86872cb2006-08-22 00:01:08 -07002857void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858{
2859 struct sk_buff *skb;
Daniel Lezcano55786892008-03-04 13:47:47 -08002860 struct net *net = info->nl_net;
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08002861 u32 seq;
2862 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08002864 err = -ENOBUFS;
David S. Miller38308472011-12-03 18:02:47 -05002865 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
Thomas Graf86872cb2006-08-22 00:01:08 -07002866
Thomas Graf339bf982006-11-10 14:10:15 -08002867 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
David S. Miller38308472011-12-03 18:02:47 -05002868 if (!skb)
Thomas Graf21713eb2006-08-15 00:35:24 -07002869 goto errout;
2870
Brian Haley191cd582008-08-14 15:33:21 -07002871 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002872 event, info->portid, seq, 0, 0, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08002873 if (err < 0) {
2874 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2875 WARN_ON(err == -EMSGSIZE);
2876 kfree_skb(skb);
2877 goto errout;
2878 }
Eric W. Biederman15e47302012-09-07 20:12:54 +00002879 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08002880 info->nlh, gfp_any());
2881 return;
Thomas Graf21713eb2006-08-15 00:35:24 -07002882errout:
2883 if (err < 0)
Daniel Lezcano55786892008-03-04 13:47:47 -08002884 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885}
2886
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002887static int ip6_route_dev_notify(struct notifier_block *this,
Jiri Pirko351638e2013-05-28 01:30:21 +00002888 unsigned long event, void *ptr)
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002889{
Jiri Pirko351638e2013-05-28 01:30:21 +00002890 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002891 struct net *net = dev_net(dev);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002892
2893 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07002894 net->ipv6.ip6_null_entry->dst.dev = dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002895 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2896#ifdef CONFIG_IPV6_MULTIPLE_TABLES
Changli Gaod8d1f302010-06-10 23:31:35 -07002897 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002898 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
Changli Gaod8d1f302010-06-10 23:31:35 -07002899 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08002900 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2901#endif
2902 }
2903
2904 return NOTIFY_OK;
2905}
2906
Linus Torvalds1da177e2005-04-16 15:20:36 -07002907/*
2908 * /proc
2909 */
2910
2911#ifdef CONFIG_PROC_FS
2912
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002913static const struct file_operations ipv6_route_proc_fops = {
2914 .owner = THIS_MODULE,
2915 .open = ipv6_route_open,
2916 .read = seq_read,
2917 .llseek = seq_lseek,
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002918 .release = seq_release_net,
Alexey Dobriyan33120b32007-11-06 05:27:11 -08002919};
2920
Linus Torvalds1da177e2005-04-16 15:20:36 -07002921static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2922{
Daniel Lezcano69ddb802008-03-04 13:46:23 -08002923 struct net *net = (struct net *)seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
Daniel Lezcano69ddb802008-03-04 13:46:23 -08002925 net->ipv6.rt6_stats->fib_nodes,
2926 net->ipv6.rt6_stats->fib_route_nodes,
2927 net->ipv6.rt6_stats->fib_rt_alloc,
2928 net->ipv6.rt6_stats->fib_rt_entries,
2929 net->ipv6.rt6_stats->fib_rt_cache,
Eric Dumazetfc66f952010-10-08 06:37:34 +00002930 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
Daniel Lezcano69ddb802008-03-04 13:46:23 -08002931 net->ipv6.rt6_stats->fib_discarded_routes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932
2933 return 0;
2934}
2935
2936static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2937{
Pavel Emelyanovde05c552008-07-18 04:07:21 -07002938 return single_open_net(inode, file, rt6_stats_seq_show);
Daniel Lezcano69ddb802008-03-04 13:46:23 -08002939}
2940
Arjan van de Ven9a321442007-02-12 00:55:35 -08002941static const struct file_operations rt6_stats_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942 .owner = THIS_MODULE,
2943 .open = rt6_stats_seq_open,
2944 .read = seq_read,
2945 .llseek = seq_lseek,
Pavel Emelyanovb6fcbdb2008-07-18 04:07:44 -07002946 .release = single_release_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947};
2948#endif /* CONFIG_PROC_FS */
2949
2950#ifdef CONFIG_SYSCTL
2951
Linus Torvalds1da177e2005-04-16 15:20:36 -07002952static
Joe Perchesfe2c6332013-06-11 23:04:25 -07002953int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002954 void __user *buffer, size_t *lenp, loff_t *ppos)
2955{
Lucian Adrian Grijincuc486da32011-02-24 19:48:03 +00002956 struct net *net;
2957 int delay;
2958 if (!write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002959 return -EINVAL;
Lucian Adrian Grijincuc486da32011-02-24 19:48:03 +00002960
2961 net = (struct net *)ctl->extra1;
2962 delay = net->ipv6.sysctl.flush_delay;
2963 proc_dointvec(ctl, write, buffer, lenp, ppos);
Michal Kubeček2ac3ac82013-08-01 10:04:14 +02002964 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
Lucian Adrian Grijincuc486da32011-02-24 19:48:03 +00002965 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966}
2967
Joe Perchesfe2c6332013-06-11 23:04:25 -07002968struct ctl_table ipv6_route_table_template[] = {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002969 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002970 .procname = "flush",
Daniel Lezcano49905092008-01-10 03:01:01 -08002971 .data = &init_net.ipv6.sysctl.flush_delay,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972 .maxlen = sizeof(int),
Dave Jones89c8b3a12005-04-28 12:11:49 -07002973 .mode = 0200,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002974 .proc_handler = ipv6_sysctl_rtcache_flush
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 },
2976 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002977 .procname = "gc_thresh",
Daniel Lezcano9a7ec3a2008-03-04 13:48:53 -08002978 .data = &ip6_dst_ops_template.gc_thresh,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979 .maxlen = sizeof(int),
2980 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002981 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002982 },
2983 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 .procname = "max_size",
Daniel Lezcano49905092008-01-10 03:01:01 -08002985 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986 .maxlen = sizeof(int),
2987 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002988 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002989 },
2990 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991 .procname = "gc_min_interval",
Daniel Lezcano49905092008-01-10 03:01:01 -08002992 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993 .maxlen = sizeof(int),
2994 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08002995 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002996 },
2997 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998 .procname = "gc_timeout",
Daniel Lezcano49905092008-01-10 03:01:01 -08002999 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003000 .maxlen = sizeof(int),
3001 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003002 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003003 },
3004 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003005 .procname = "gc_interval",
Daniel Lezcano49905092008-01-10 03:01:01 -08003006 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007 .maxlen = sizeof(int),
3008 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003009 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010 },
3011 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012 .procname = "gc_elasticity",
Daniel Lezcano49905092008-01-10 03:01:01 -08003013 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014 .maxlen = sizeof(int),
3015 .mode = 0644,
Min Zhangf3d3f612010-08-14 22:42:51 -07003016 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017 },
3018 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 .procname = "mtu_expires",
Daniel Lezcano49905092008-01-10 03:01:01 -08003020 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021 .maxlen = sizeof(int),
3022 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003023 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024 },
3025 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003026 .procname = "min_adv_mss",
Daniel Lezcano49905092008-01-10 03:01:01 -08003027 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028 .maxlen = sizeof(int),
3029 .mode = 0644,
Min Zhangf3d3f612010-08-14 22:42:51 -07003030 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031 },
3032 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003033 .procname = "gc_min_interval_ms",
Daniel Lezcano49905092008-01-10 03:01:01 -08003034 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035 .maxlen = sizeof(int),
3036 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003037 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003038 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08003039 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040};
3041
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00003042struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
Daniel Lezcano760f2d02008-01-10 02:53:43 -08003043{
3044 struct ctl_table *table;
3045
3046 table = kmemdup(ipv6_route_table_template,
3047 sizeof(ipv6_route_table_template),
3048 GFP_KERNEL);
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09003049
3050 if (table) {
3051 table[0].data = &net->ipv6.sysctl.flush_delay;
Lucian Adrian Grijincuc486da32011-02-24 19:48:03 +00003052 table[0].extra1 = net;
Alexey Dobriyan86393e52009-08-29 01:34:49 +00003053 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09003054 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
3055 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3056 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
3057 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
3058 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
3059 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
3060 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
Alexey Dobriyan9c69fab2009-12-18 20:11:03 -08003061 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
Eric W. Biederman464dc802012-11-16 03:02:59 +00003062
3063 /* Don't export sysctls to unprivileged users */
3064 if (net->user_ns != &init_user_ns)
3065 table[0].procname = NULL;
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09003066 }
3067
Daniel Lezcano760f2d02008-01-10 02:53:43 -08003068 return table;
3069}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003070#endif
3071
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00003072static int __net_init ip6_route_net_init(struct net *net)
Daniel Lezcanocdb18762008-03-04 13:45:33 -08003073{
Pavel Emelyanov633d424b2008-04-21 14:25:23 -07003074 int ret = -ENOMEM;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003075
Alexey Dobriyan86393e52009-08-29 01:34:49 +00003076 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3077 sizeof(net->ipv6.ip6_dst_ops));
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08003078
Eric Dumazetfc66f952010-10-08 06:37:34 +00003079 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
3080 goto out_ip6_dst_ops;
3081
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003082 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
3083 sizeof(*net->ipv6.ip6_null_entry),
3084 GFP_KERNEL);
3085 if (!net->ipv6.ip6_null_entry)
Eric Dumazetfc66f952010-10-08 06:37:34 +00003086 goto out_ip6_dst_entries;
Changli Gaod8d1f302010-06-10 23:31:35 -07003087 net->ipv6.ip6_null_entry->dst.path =
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003088 (struct dst_entry *)net->ipv6.ip6_null_entry;
Changli Gaod8d1f302010-06-10 23:31:35 -07003089 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
David S. Miller62fa8a82011-01-26 20:51:05 -08003090 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3091 ip6_template_metrics, true);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003092
3093#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3094 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3095 sizeof(*net->ipv6.ip6_prohibit_entry),
3096 GFP_KERNEL);
Peter Zijlstra68fffc62008-10-07 14:12:10 -07003097 if (!net->ipv6.ip6_prohibit_entry)
3098 goto out_ip6_null_entry;
Changli Gaod8d1f302010-06-10 23:31:35 -07003099 net->ipv6.ip6_prohibit_entry->dst.path =
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003100 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
Changli Gaod8d1f302010-06-10 23:31:35 -07003101 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
David S. Miller62fa8a82011-01-26 20:51:05 -08003102 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3103 ip6_template_metrics, true);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003104
3105 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3106 sizeof(*net->ipv6.ip6_blk_hole_entry),
3107 GFP_KERNEL);
Peter Zijlstra68fffc62008-10-07 14:12:10 -07003108 if (!net->ipv6.ip6_blk_hole_entry)
3109 goto out_ip6_prohibit_entry;
Changli Gaod8d1f302010-06-10 23:31:35 -07003110 net->ipv6.ip6_blk_hole_entry->dst.path =
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003111 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
Changli Gaod8d1f302010-06-10 23:31:35 -07003112 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
David S. Miller62fa8a82011-01-26 20:51:05 -08003113 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3114 ip6_template_metrics, true);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003115#endif
3116
Peter Zijlstrab339a47c2008-10-07 14:15:00 -07003117 net->ipv6.sysctl.flush_delay = 0;
3118 net->ipv6.sysctl.ip6_rt_max_size = 4096;
3119 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3120 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3121 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3122 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3123 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3124 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3125
Benjamin Thery6891a342008-03-04 13:49:47 -08003126 net->ipv6.ip6_rt_gc_expire = 30*HZ;
3127
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003128 ret = 0;
3129out:
3130 return ret;
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08003131
Peter Zijlstra68fffc62008-10-07 14:12:10 -07003132#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3133out_ip6_prohibit_entry:
3134 kfree(net->ipv6.ip6_prohibit_entry);
3135out_ip6_null_entry:
3136 kfree(net->ipv6.ip6_null_entry);
3137#endif
Eric Dumazetfc66f952010-10-08 06:37:34 +00003138out_ip6_dst_entries:
3139 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08003140out_ip6_dst_ops:
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08003141 goto out;
Daniel Lezcanocdb18762008-03-04 13:45:33 -08003142}
3143
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00003144static void __net_exit ip6_route_net_exit(struct net *net)
Daniel Lezcanocdb18762008-03-04 13:45:33 -08003145{
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003146 kfree(net->ipv6.ip6_null_entry);
3147#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3148 kfree(net->ipv6.ip6_prohibit_entry);
3149 kfree(net->ipv6.ip6_blk_hole_entry);
3150#endif
Xiaotian Feng41bb78b2010-11-02 16:11:05 +00003151 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
Daniel Lezcanocdb18762008-03-04 13:45:33 -08003152}
3153
Thomas Grafd1896342012-06-18 12:08:33 +00003154static int __net_init ip6_route_net_init_late(struct net *net)
3155{
3156#ifdef CONFIG_PROC_FS
Gao fengd4beaa62013-02-18 01:34:54 +00003157 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3158 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
Thomas Grafd1896342012-06-18 12:08:33 +00003159#endif
3160 return 0;
3161}
3162
3163static void __net_exit ip6_route_net_exit_late(struct net *net)
3164{
3165#ifdef CONFIG_PROC_FS
Gao fengece31ff2013-02-18 01:34:56 +00003166 remove_proc_entry("ipv6_route", net->proc_net);
3167 remove_proc_entry("rt6_stats", net->proc_net);
Thomas Grafd1896342012-06-18 12:08:33 +00003168#endif
3169}
3170
Daniel Lezcanocdb18762008-03-04 13:45:33 -08003171static struct pernet_operations ip6_route_net_ops = {
3172 .init = ip6_route_net_init,
3173 .exit = ip6_route_net_exit,
3174};
3175
David S. Millerc3426b42012-06-09 16:27:05 -07003176static int __net_init ipv6_inetpeer_init(struct net *net)
3177{
3178 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3179
3180 if (!bp)
3181 return -ENOMEM;
3182 inet_peer_base_init(bp);
3183 net->ipv6.peers = bp;
3184 return 0;
3185}
3186
3187static void __net_exit ipv6_inetpeer_exit(struct net *net)
3188{
3189 struct inet_peer_base *bp = net->ipv6.peers;
3190
3191 net->ipv6.peers = NULL;
David S. Miller56a6b242012-06-09 16:32:41 -07003192 inetpeer_invalidate_tree(bp);
David S. Millerc3426b42012-06-09 16:27:05 -07003193 kfree(bp);
3194}
3195
David S. Miller2b823f72012-06-09 19:00:16 -07003196static struct pernet_operations ipv6_inetpeer_ops = {
David S. Millerc3426b42012-06-09 16:27:05 -07003197 .init = ipv6_inetpeer_init,
3198 .exit = ipv6_inetpeer_exit,
3199};
3200
Thomas Grafd1896342012-06-18 12:08:33 +00003201static struct pernet_operations ip6_route_net_late_ops = {
3202 .init = ip6_route_net_init_late,
3203 .exit = ip6_route_net_exit_late,
3204};
3205
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003206static struct notifier_block ip6_route_dev_notifier = {
3207 .notifier_call = ip6_route_dev_notify,
3208 .priority = 0,
3209};
3210
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003211int __init ip6_route_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003212{
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003213 int ret;
3214
Daniel Lezcano9a7ec3a2008-03-04 13:48:53 -08003215 ret = -ENOMEM;
3216 ip6_dst_ops_template.kmem_cachep =
3217 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3218 SLAB_HWCACHE_ALIGN, NULL);
3219 if (!ip6_dst_ops_template.kmem_cachep)
Fernando Carrijoc19a28e2009-01-07 18:09:08 -08003220 goto out;
David S. Miller14e50e52007-05-24 18:17:54 -07003221
Eric Dumazetfc66f952010-10-08 06:37:34 +00003222 ret = dst_entries_init(&ip6_dst_blackhole_ops);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003223 if (ret)
Daniel Lezcanobdb32892008-03-04 13:48:10 -08003224 goto out_kmem_cache;
Daniel Lezcanobdb32892008-03-04 13:48:10 -08003225
David S. Millerc3426b42012-06-09 16:27:05 -07003226 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3227 if (ret)
David S. Millere8803b62012-06-16 01:12:19 -07003228 goto out_dst_entries;
Thomas Graf2a0c4512012-06-14 23:00:17 +00003229
David S. Miller7e52b332012-06-15 15:51:55 -07003230 ret = register_pernet_subsys(&ip6_route_net_ops);
3231 if (ret)
3232 goto out_register_inetpeer;
David S. Millerc3426b42012-06-09 16:27:05 -07003233
Arnaud Ebalard5dc121e2008-10-01 02:37:56 -07003234 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3235
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003236 /* Registering of the loopback is done before this portion of code,
3237 * the loopback reference in rt6_info will not be taken, do it
3238 * manually for init_net */
Changli Gaod8d1f302010-06-10 23:31:35 -07003239 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003240 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3241 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
Changli Gaod8d1f302010-06-10 23:31:35 -07003242 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003243 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
Changli Gaod8d1f302010-06-10 23:31:35 -07003244 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003245 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3246 #endif
David S. Millere8803b62012-06-16 01:12:19 -07003247 ret = fib6_init();
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003248 if (ret)
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003249 goto out_register_subsys;
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003250
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003251 ret = xfrm6_init();
3252 if (ret)
David S. Millere8803b62012-06-16 01:12:19 -07003253 goto out_fib6_init;
Daniel Lezcanoc35b7e72007-12-08 00:14:11 -08003254
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003255 ret = fib6_rules_init();
3256 if (ret)
3257 goto xfrm6_init;
Daniel Lezcano7e5449c2007-12-08 00:14:54 -08003258
Thomas Grafd1896342012-06-18 12:08:33 +00003259 ret = register_pernet_subsys(&ip6_route_net_late_ops);
3260 if (ret)
3261 goto fib6_rules_init;
3262
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003263 ret = -ENOBUFS;
Greg Rosec7ac8672011-06-10 01:27:09 +00003264 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3265 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3266 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
Thomas Grafd1896342012-06-18 12:08:33 +00003267 goto out_register_late_subsys;
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003268
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003269 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
Daniel Lezcanocdb18762008-03-04 13:45:33 -08003270 if (ret)
Thomas Grafd1896342012-06-18 12:08:33 +00003271 goto out_register_late_subsys;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003272
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003273out:
3274 return ret;
3275
Thomas Grafd1896342012-06-18 12:08:33 +00003276out_register_late_subsys:
3277 unregister_pernet_subsys(&ip6_route_net_late_ops);
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003278fib6_rules_init:
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003279 fib6_rules_cleanup();
3280xfrm6_init:
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003281 xfrm6_fini();
Thomas Graf2a0c4512012-06-14 23:00:17 +00003282out_fib6_init:
3283 fib6_gc_cleanup();
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003284out_register_subsys:
3285 unregister_pernet_subsys(&ip6_route_net_ops);
David S. Miller7e52b332012-06-15 15:51:55 -07003286out_register_inetpeer:
3287 unregister_pernet_subsys(&ipv6_inetpeer_ops);
Eric Dumazetfc66f952010-10-08 06:37:34 +00003288out_dst_entries:
3289 dst_entries_destroy(&ip6_dst_blackhole_ops);
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003290out_kmem_cache:
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08003291 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
Daniel Lezcano433d49c2007-12-07 00:43:48 -08003292 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003293}
3294
3295void ip6_route_cleanup(void)
3296{
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003297 unregister_netdevice_notifier(&ip6_route_dev_notifier);
Thomas Grafd1896342012-06-18 12:08:33 +00003298 unregister_pernet_subsys(&ip6_route_net_late_ops);
Thomas Graf101367c2006-08-04 03:39:02 -07003299 fib6_rules_cleanup();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003300 xfrm6_fini();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003301 fib6_gc_cleanup();
David S. Millerc3426b42012-06-09 16:27:05 -07003302 unregister_pernet_subsys(&ipv6_inetpeer_ops);
Daniel Lezcano8ed67782008-03-04 13:48:30 -08003303 unregister_pernet_subsys(&ip6_route_net_ops);
Xiaotian Feng41bb78b2010-11-02 16:11:05 +00003304 dst_entries_destroy(&ip6_dst_blackhole_ops);
Benjamin Theryf2fc6a52008-03-04 13:49:23 -08003305 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003306}