blob: 505d048ffff54f2f6af9b9f0a2e3fc0cd0a28387 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Neighbour Discovery for IPv6
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09003 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
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 * Mike Shaver <shaver@ingenia.com>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
13 */
14
15/*
16 * Changes:
17 *
Alexey I. Froloffe35f30c2012-04-06 05:50:58 +000018 * Alexey I. Froloff : RFC6106 (DNSSL) support
Pierre Ynard31910572007-10-10 21:22:05 -070019 * Pierre Ynard : export userland ND options
20 * through netlink (RDNSS support)
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 * Lars Fenneberg : fixed MTU setting on receipt
22 * of an RA.
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 * Janos Farkas : kmalloc failure checks
24 * Alexey Kuznetsov : state machine reworked
25 * and moved to net/core.
26 * Pekka Savola : RFC2461 validation
27 * YOSHIFUJI Hideaki @USAGI : Verify ND options properly
28 */
29
Joe Perches675418d2012-05-16 19:28:38 +000030#define pr_fmt(fmt) "ICMPv6: " fmt
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/errno.h>
34#include <linux/types.h>
35#include <linux/socket.h>
36#include <linux/sockios.h>
37#include <linux/sched.h>
38#include <linux/net.h>
39#include <linux/in6.h>
40#include <linux/route.h>
41#include <linux/init.h>
42#include <linux/rcupdate.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090043#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#ifdef CONFIG_SYSCTL
45#include <linux/sysctl.h>
46#endif
47
Thomas Graf18237302006-08-04 23:04:54 -070048#include <linux/if_addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include <linux/if_arp.h>
50#include <linux/ipv6.h>
51#include <linux/icmpv6.h>
52#include <linux/jhash.h>
53
54#include <net/sock.h>
55#include <net/snmp.h>
56
57#include <net/ipv6.h>
58#include <net/protocol.h>
59#include <net/ndisc.h>
60#include <net/ip6_route.h>
61#include <net/addrconf.h>
62#include <net/icmp.h>
63
Pierre Ynard31910572007-10-10 21:22:05 -070064#include <net/netlink.h>
65#include <linux/rtnetlink.h>
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <net/flow.h>
68#include <net/ip6_checksum.h>
Denis V. Lunev1ed85162008-04-03 14:31:03 -070069#include <net/inet_common.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#include <linux/proc_fs.h>
71
72#include <linux/netfilter.h>
73#include <linux/netfilter_ipv6.h>
74
Eric Dumazetd6bf7812010-10-04 06:15:44 +000075static u32 ndisc_hash(const void *pkey,
76 const struct net_device *dev,
David S. Miller2c2aba62011-12-28 15:06:58 -050077 __u32 *hash_rnd);
Eric W. Biederman60395a22015-03-03 17:10:44 -060078static bool ndisc_key_eq(const struct neighbour *neigh, const void *pkey);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079static int ndisc_constructor(struct neighbour *neigh);
80static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
81static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
82static int pndisc_constructor(struct pneigh_entry *n);
83static void pndisc_destructor(struct pneigh_entry *n);
84static void pndisc_redo(struct sk_buff *skb);
85
Stephen Hemminger89d69d22009-09-01 11:13:19 +000086static const struct neigh_ops ndisc_generic_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 .family = AF_INET6,
88 .solicit = ndisc_solicit,
89 .error_report = ndisc_error_report,
90 .output = neigh_resolve_output,
91 .connected_output = neigh_connected_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -070092};
93
Stephen Hemminger89d69d22009-09-01 11:13:19 +000094static const struct neigh_ops ndisc_hh_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 .family = AF_INET6,
96 .solicit = ndisc_solicit,
97 .error_report = ndisc_error_report,
98 .output = neigh_resolve_output,
99 .connected_output = neigh_resolve_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100};
101
102
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000103static const struct neigh_ops ndisc_direct_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 .family = AF_INET6,
David S. Miller8f40b162011-07-17 13:34:11 -0700105 .output = neigh_direct_output,
106 .connected_output = neigh_direct_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107};
108
109struct neigh_table nd_tbl = {
110 .family = AF_INET6,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 .key_len = sizeof(struct in6_addr),
Eric W. Biedermanbdf53c52015-03-02 00:13:22 -0600112 .protocol = cpu_to_be16(ETH_P_IPV6),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 .hash = ndisc_hash,
Eric W. Biederman60395a22015-03-03 17:10:44 -0600114 .key_eq = ndisc_key_eq,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 .constructor = ndisc_constructor,
116 .pconstructor = pndisc_constructor,
117 .pdestructor = pndisc_destructor,
118 .proxy_redo = pndisc_redo,
119 .id = "ndisc_cache",
120 .parms = {
Shan Weib6720832010-12-01 18:05:12 +0000121 .tbl = &nd_tbl,
Shan Weib6720832010-12-01 18:05:12 +0000122 .reachable_time = ND_REACHABLE_TIME,
Jiri Pirko1f9248e52013-12-07 19:26:53 +0100123 .data = {
124 [NEIGH_VAR_MCAST_PROBES] = 3,
125 [NEIGH_VAR_UCAST_PROBES] = 3,
126 [NEIGH_VAR_RETRANS_TIME] = ND_RETRANS_TIMER,
127 [NEIGH_VAR_BASE_REACHABLE_TIME] = ND_REACHABLE_TIME,
128 [NEIGH_VAR_DELAY_PROBE_TIME] = 5 * HZ,
129 [NEIGH_VAR_GC_STALETIME] = 60 * HZ,
130 [NEIGH_VAR_QUEUE_LEN_BYTES] = 64 * 1024,
131 [NEIGH_VAR_PROXY_QLEN] = 64,
132 [NEIGH_VAR_ANYCAST_DELAY] = 1 * HZ,
133 [NEIGH_VAR_PROXY_DELAY] = (8 * HZ) / 10,
134 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 },
136 .gc_interval = 30 * HZ,
137 .gc_thresh1 = 128,
138 .gc_thresh2 = 512,
139 .gc_thresh3 = 1024,
140};
David Ahernc4850682015-10-12 11:47:08 -0700141EXPORT_SYMBOL_GPL(nd_tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
Alexander Aringcc84b3c2016-06-15 21:20:24 +0200143void __ndisc_fill_addr_option(struct sk_buff *skb, int type, void *data,
144 int data_len, int pad)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145{
Alexander Aring8ec5da42016-06-15 21:20:21 +0200146 int space = __ndisc_opt_addr_space(data_len, pad);
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +0000147 u8 *opt = skb_put(skb, space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
149 opt[0] = type;
150 opt[1] = space>>3;
151
152 memset(opt + 2, 0, pad);
153 opt += pad;
154 space -= pad;
155
156 memcpy(opt+2, data, data_len);
157 data_len += 2;
158 opt += data_len;
Ian Morrise5d08d72014-11-23 21:28:43 +0000159 space -= data_len;
160 if (space > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 memset(opt, 0, space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162}
Alexander Aringcc84b3c2016-06-15 21:20:24 +0200163EXPORT_SYMBOL_GPL(__ndisc_fill_addr_option);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
Alexander Aring8ec5da42016-06-15 21:20:21 +0200165static inline void ndisc_fill_addr_option(struct sk_buff *skb, int type,
Alexander Aringf997c552016-06-15 21:20:23 +0200166 void *data, u8 icmp6_type)
Alexander Aring8ec5da42016-06-15 21:20:21 +0200167{
168 __ndisc_fill_addr_option(skb, type, data, skb->dev->addr_len,
169 ndisc_addr_option_pad(skb->dev->type));
Alexander Aringf997c552016-06-15 21:20:23 +0200170 ndisc_ops_fill_addr_option(skb->dev, skb, icmp6_type);
171}
172
173static inline void ndisc_fill_redirect_addr_option(struct sk_buff *skb,
174 void *ha,
175 const u8 *ops_data)
176{
177 ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR, ha, NDISC_REDIRECT);
178 ndisc_ops_fill_redirect_addr_option(skb->dev, skb, ops_data);
Alexander Aring8ec5da42016-06-15 21:20:21 +0200179}
180
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
182 struct nd_opt_hdr *end)
183{
184 int type;
185 if (!cur || !end || cur >= end)
186 return NULL;
187 type = cur->nd_opt_type;
188 do {
189 cur = ((void *)cur) + (cur->nd_opt_len << 3);
Ian Morris67ba4152014-08-24 21:53:10 +0100190 } while (cur < end && cur->nd_opt_type != type);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000191 return cur <= end && cur->nd_opt_type == type ? cur : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192}
193
Alexander Aringf997c552016-06-15 21:20:23 +0200194static inline int ndisc_is_useropt(const struct net_device *dev,
195 struct nd_opt_hdr *opt)
Pierre Ynard31910572007-10-10 21:22:05 -0700196{
Alexey I. Froloffe35f30c2012-04-06 05:50:58 +0000197 return opt->nd_opt_type == ND_OPT_RDNSS ||
Alexander Aringf997c552016-06-15 21:20:23 +0200198 opt->nd_opt_type == ND_OPT_DNSSL ||
199 ndisc_ops_is_useropt(dev, opt->nd_opt_type);
Pierre Ynard31910572007-10-10 21:22:05 -0700200}
201
Alexander Aringf997c552016-06-15 21:20:23 +0200202static struct nd_opt_hdr *ndisc_next_useropt(const struct net_device *dev,
203 struct nd_opt_hdr *cur,
Pierre Ynard31910572007-10-10 21:22:05 -0700204 struct nd_opt_hdr *end)
205{
206 if (!cur || !end || cur >= end)
207 return NULL;
208 do {
209 cur = ((void *)cur) + (cur->nd_opt_len << 3);
Alexander Aringf997c552016-06-15 21:20:23 +0200210 } while (cur < end && !ndisc_is_useropt(dev, cur));
211 return cur <= end && ndisc_is_useropt(dev, cur) ? cur : NULL;
Pierre Ynard31910572007-10-10 21:22:05 -0700212}
213
Alexander Aringf997c552016-06-15 21:20:23 +0200214struct ndisc_options *ndisc_parse_options(const struct net_device *dev,
215 u8 *opt, int opt_len,
David S. Miller30f2a5f2012-07-11 23:26:46 -0700216 struct ndisc_options *ndopts)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
218 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
219
220 if (!nd_opt || opt_len < 0 || !ndopts)
221 return NULL;
222 memset(ndopts, 0, sizeof(*ndopts));
223 while (opt_len) {
224 int l;
225 if (opt_len < sizeof(struct nd_opt_hdr))
226 return NULL;
227 l = nd_opt->nd_opt_len << 3;
228 if (opt_len < l || l == 0)
229 return NULL;
Alexander Aringf997c552016-06-15 21:20:23 +0200230 if (ndisc_ops_parse_options(dev, nd_opt, ndopts))
231 goto next_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 switch (nd_opt->nd_opt_type) {
233 case ND_OPT_SOURCE_LL_ADDR:
234 case ND_OPT_TARGET_LL_ADDR:
235 case ND_OPT_MTU:
236 case ND_OPT_REDIRECT_HDR:
237 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
Joe Perches675418d2012-05-16 19:28:38 +0000238 ND_PRINTK(2, warn,
239 "%s: duplicated ND6 option found: type=%d\n",
240 __func__, nd_opt->nd_opt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 } else {
242 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
243 }
244 break;
245 case ND_OPT_PREFIX_INFO:
246 ndopts->nd_opts_pi_end = nd_opt;
Stephen Hemmingercfcabdc2007-10-09 01:59:42 -0700247 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
249 break;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800250#ifdef CONFIG_IPV6_ROUTE_INFO
251 case ND_OPT_ROUTE_INFO:
252 ndopts->nd_opts_ri_end = nd_opt;
253 if (!ndopts->nd_opts_ri)
254 ndopts->nd_opts_ri = nd_opt;
255 break;
256#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 default:
Alexander Aringf997c552016-06-15 21:20:23 +0200258 if (ndisc_is_useropt(dev, nd_opt)) {
Pierre Ynard31910572007-10-10 21:22:05 -0700259 ndopts->nd_useropts_end = nd_opt;
260 if (!ndopts->nd_useropts)
261 ndopts->nd_useropts = nd_opt;
262 } else {
263 /*
264 * Unknown options must be silently ignored,
265 * to accommodate future extension to the
266 * protocol.
267 */
Joe Perches675418d2012-05-16 19:28:38 +0000268 ND_PRINTK(2, notice,
269 "%s: ignored unsupported option; type=%d, len=%d\n",
270 __func__,
271 nd_opt->nd_opt_type,
272 nd_opt->nd_opt_len);
Pierre Ynard31910572007-10-10 21:22:05 -0700273 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 }
Alexander Aringf997c552016-06-15 21:20:23 +0200275next_opt:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 opt_len -= l;
277 nd_opt = ((void *)nd_opt) + l;
278 }
279 return ndopts;
280}
281
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000282int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283{
284 switch (dev->type) {
285 case ARPHRD_ETHER:
286 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
287 case ARPHRD_FDDI:
288 ipv6_eth_mc_map(addr, buf);
289 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 case ARPHRD_ARCNET:
291 ipv6_arcnet_mc_map(addr, buf);
292 return 0;
293 case ARPHRD_INFINIBAND:
Rolf Manderscheida9e527e2007-12-10 13:38:41 -0700294 ipv6_ib_mc_map(addr, dev->broadcast, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 return 0;
Timo Teräs93ca3bb2011-03-28 22:40:53 +0000296 case ARPHRD_IPGRE:
297 return ipv6_ipgre_mc_map(addr, dev->broadcast, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 default:
299 if (dir) {
300 memcpy(buf, dev->broadcast, dev->addr_len);
301 return 0;
302 }
303 }
304 return -EINVAL;
305}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900306EXPORT_SYMBOL(ndisc_mc_map);
307
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000308static u32 ndisc_hash(const void *pkey,
309 const struct net_device *dev,
David S. Miller2c2aba62011-12-28 15:06:58 -0500310 __u32 *hash_rnd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311{
David S. Miller2c2aba62011-12-28 15:06:58 -0500312 return ndisc_hashfn(pkey, dev, hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313}
314
Eric W. Biederman60395a22015-03-03 17:10:44 -0600315static bool ndisc_key_eq(const struct neighbour *n, const void *pkey)
316{
317 return neigh_key_eq128(n, pkey);
318}
319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320static int ndisc_constructor(struct neighbour *neigh)
321{
Ian Morris67ba4152014-08-24 21:53:10 +0100322 struct in6_addr *addr = (struct in6_addr *)&neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 struct net_device *dev = neigh->dev;
324 struct inet6_dev *in6_dev;
325 struct neigh_parms *parms;
Eric Dumazeta50feda2012-05-18 18:57:34 +0000326 bool is_multicast = ipv6_addr_is_multicast(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 in6_dev = in6_dev_get(dev);
Ian Morris63159f22015-03-29 14:00:04 +0100329 if (!in6_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 return -EINVAL;
331 }
332
333 parms = in6_dev->nd_parms;
334 __neigh_parms_put(neigh->parms);
335 neigh->parms = neigh_parms_clone(parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
337 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700338 if (!dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 neigh->nud_state = NUD_NOARP;
340 neigh->ops = &ndisc_direct_ops;
David S. Miller8f40b162011-07-17 13:34:11 -0700341 neigh->output = neigh_direct_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 } else {
343 if (is_multicast) {
344 neigh->nud_state = NUD_NOARP;
345 ndisc_mc_map(addr, neigh->ha, dev, 1);
346 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
347 neigh->nud_state = NUD_NOARP;
348 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
349 if (dev->flags&IFF_LOOPBACK)
350 neigh->type = RTN_LOCAL;
351 } else if (dev->flags&IFF_POINTOPOINT) {
352 neigh->nud_state = NUD_NOARP;
353 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
354 }
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700355 if (dev->header_ops->cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 neigh->ops = &ndisc_hh_ops;
357 else
358 neigh->ops = &ndisc_generic_ops;
359 if (neigh->nud_state&NUD_VALID)
360 neigh->output = neigh->ops->connected_output;
361 else
362 neigh->output = neigh->ops->output;
363 }
364 in6_dev_put(in6_dev);
365 return 0;
366}
367
368static int pndisc_constructor(struct pneigh_entry *n)
369{
Ian Morris67ba4152014-08-24 21:53:10 +0100370 struct in6_addr *addr = (struct in6_addr *)&n->key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 struct in6_addr maddr;
372 struct net_device *dev = n->dev;
373
Ian Morris63159f22015-03-29 14:00:04 +0100374 if (!dev || !__in6_dev_get(dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 return -EINVAL;
376 addrconf_addr_solict_mult(addr, &maddr);
377 ipv6_dev_mc_inc(dev, &maddr);
378 return 0;
379}
380
381static void pndisc_destructor(struct pneigh_entry *n)
382{
Ian Morris67ba4152014-08-24 21:53:10 +0100383 struct in6_addr *addr = (struct in6_addr *)&n->key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 struct in6_addr maddr;
385 struct net_device *dev = n->dev;
386
Ian Morris63159f22015-03-29 14:00:04 +0100387 if (!dev || !__in6_dev_get(dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 return;
389 addrconf_addr_solict_mult(addr, &maddr);
390 ipv6_dev_mc_dec(dev, &maddr);
391}
392
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000393static struct sk_buff *ndisc_alloc_skb(struct net_device *dev,
394 int len)
395{
396 int hlen = LL_RESERVED_SPACE(dev);
397 int tlen = dev->needed_tailroom;
398 struct sock *sk = dev_net(dev)->ipv6.ndisc_sk;
399 struct sk_buff *skb;
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000400
Thomas Graf25a6e6b2013-09-03 13:37:01 +0200401 skb = alloc_skb(hlen + sizeof(struct ipv6hdr) + len + tlen, GFP_ATOMIC);
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000402 if (!skb) {
Thomas Graf25a6e6b2013-09-03 13:37:01 +0200403 ND_PRINTK(0, err, "ndisc: %s failed to allocate an skb\n",
404 __func__);
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000405 return NULL;
406 }
407
YOSHIFUJI Hideaki / 吉藤英明f382d032013-01-21 06:48:29 +0000408 skb->protocol = htons(ETH_P_IPV6);
409 skb->dev = dev;
410
YOSHIFUJI Hideaki / 吉藤英明527a1502013-01-21 06:48:39 +0000411 skb_reserve(skb, hlen + sizeof(struct ipv6hdr));
YOSHIFUJI Hideaki / 吉藤英明5135e632013-01-21 06:48:44 +0000412 skb_reset_transport_header(skb);
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000413
Thomas Graf25a6e6b2013-09-03 13:37:01 +0200414 /* Manually assign socket ownership as we avoid calling
415 * sock_alloc_send_pskb() to bypass wmem buffer limits
416 */
417 skb_set_owner_w(skb, sk);
418
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000419 return skb;
420}
421
YOSHIFUJI Hideaki / 吉藤英明f382d032013-01-21 06:48:29 +0000422static void ip6_nd_hdr(struct sk_buff *skb,
YOSHIFUJI Hideaki / 吉藤英明2576f172013-01-21 06:48:19 +0000423 const struct in6_addr *saddr,
424 const struct in6_addr *daddr,
YOSHIFUJI Hideaki / 吉藤英明c8d6c382013-01-21 06:48:24 +0000425 int hop_limit, int len)
YOSHIFUJI Hideaki / 吉藤英明2576f172013-01-21 06:48:19 +0000426{
427 struct ipv6hdr *hdr;
428
YOSHIFUJI Hideaki / 吉藤英明527a1502013-01-21 06:48:39 +0000429 skb_push(skb, sizeof(*hdr));
YOSHIFUJI Hideaki / 吉藤英明2576f172013-01-21 06:48:19 +0000430 skb_reset_network_header(skb);
YOSHIFUJI Hideaki / 吉藤英明2576f172013-01-21 06:48:19 +0000431 hdr = ipv6_hdr(skb);
432
433 ip6_flow_hdr(hdr, 0, 0);
434
435 hdr->payload_len = htons(len);
YOSHIFUJI Hideaki / 吉藤英明c8d6c382013-01-21 06:48:24 +0000436 hdr->nexthdr = IPPROTO_ICMPV6;
437 hdr->hop_limit = hop_limit;
YOSHIFUJI Hideaki / 吉藤英明2576f172013-01-21 06:48:19 +0000438
439 hdr->saddr = *saddr;
440 hdr->daddr = *daddr;
441}
442
YOSHIFUJI Hideaki / 吉藤英明af9a9972013-01-21 06:48:34 +0000443static void ndisc_send_skb(struct sk_buff *skb,
YOSHIFUJI Hideakifd0ea7d2012-12-13 02:40:26 +0900444 const struct in6_addr *daddr,
YOSHIFUJI Hideaki / 吉藤英明aa4bdd42013-01-21 06:48:58 +0000445 const struct in6_addr *saddr)
Brian Haley305d5522008-11-04 17:51:14 -0800446{
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +0000447 struct dst_entry *dst = skb_dst(skb);
YOSHIFUJI Hideaki / 吉藤英明af9a9972013-01-21 06:48:34 +0000448 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideaki / 吉藤英明7b3d9b02013-01-21 06:49:08 +0000449 struct sock *sk = net->ipv6.ndisc_sk;
Brian Haley305d5522008-11-04 17:51:14 -0800450 struct inet6_dev *idev;
451 int err;
YOSHIFUJI Hideaki / 吉藤英明aa4bdd42013-01-21 06:48:58 +0000452 struct icmp6hdr *icmp6h = icmp6_hdr(skb);
Brian Haley305d5522008-11-04 17:51:14 -0800453 u8 type;
454
455 type = icmp6h->icmp6_type;
456
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +0000457 if (!dst) {
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +0000458 struct flowi6 fl6;
David Aherne0d56fd2016-09-10 12:09:57 -0700459 int oif = skb->dev->ifindex;
Brian Haley305d5522008-11-04 17:51:14 -0800460
David Ahernca254492015-10-12 11:47:10 -0700461 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, oif);
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +0000462 dst = icmp6_dst_alloc(skb->dev, &fl6);
463 if (IS_ERR(dst)) {
464 kfree_skb(skb);
465 return;
466 }
467
468 skb_dst_set(skb, dst);
469 }
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900470
YOSHIFUJI Hideaki / 吉藤英明7b3d9b02013-01-21 06:49:08 +0000471 icmp6h->icmp6_cksum = csum_ipv6_magic(saddr, daddr, skb->len,
472 IPPROTO_ICMPV6,
473 csum_partial(icmp6h,
474 skb->len, 0));
475
476 ip6_nd_hdr(skb, saddr, daddr, inet6_sk(sk)->hop_limit, skb->len);
477
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000478 rcu_read_lock();
479 idev = __in6_dev_get(dst->dev);
Neil Hormanedf391f2009-04-27 02:45:02 -0700480 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900481
Eric W. Biederman29a26a52015-09-15 20:04:16 -0500482 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT,
483 net, sk, skb, NULL, dst->dev,
Eric W. Biederman13206b62015-10-07 16:48:35 -0500484 dst_output);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900485 if (!err) {
Denis V. Lunev5c5d2442008-10-08 10:33:50 -0700486 ICMP6MSGOUT_INC_STATS(net, idev, type);
Denis V. Luneva862f6a2008-10-08 10:33:06 -0700487 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900488 }
489
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000490 rcu_read_unlock();
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900491}
492
Jiri Benc38cf5952015-09-22 18:57:13 +0200493void ndisc_send_na(struct net_device *dev, const struct in6_addr *daddr,
Cong Wangf564f452013-08-31 13:44:36 +0800494 const struct in6_addr *solicited_addr,
495 bool router, bool solicited, bool override, bool inc_opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000497 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 struct in6_addr tmpaddr;
499 struct inet6_ifaddr *ifp;
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900500 const struct in6_addr *src_addr;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000501 struct nd_msg *msg;
502 int optlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504 /* for anycast or proxy, solicited_addr != src_addr */
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900505 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900506 if (ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 src_addr = solicited_addr;
Neil Horman95c385b2007-04-25 17:08:10 -0700508 if (ifp->flags & IFA_F_OPTIMISTIC)
Daniel Balutaf2f79cc2013-07-13 11:26:51 +0300509 override = false;
stephen hemminger9f888162010-06-21 11:00:13 +0000510 inc_opt |= ifp->idev->cnf.force_tllao;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 in6_ifa_put(ifp);
512 } else {
Brian Haley191cd582008-08-14 15:33:21 -0700513 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900514 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
YOSHIFUJI Hideaki7cbca672008-03-25 09:37:42 +0900515 &tmpaddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 return;
517 src_addr = &tmpaddr;
518 }
519
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000520 if (!dev->addr_len)
521 inc_opt = 0;
522 if (inc_opt)
Alexander Aringf997c552016-06-15 21:20:23 +0200523 optlen += ndisc_opt_addr_space(dev,
524 NDISC_NEIGHBOUR_ADVERTISEMENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000526 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000527 if (!skb)
528 return;
529
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000530 msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
531 *msg = (struct nd_msg) {
532 .icmph = {
533 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
534 .icmp6_router = router,
535 .icmp6_solicited = solicited,
536 .icmp6_override = override,
537 },
538 .target = *solicited_addr,
539 };
540
541 if (inc_opt)
542 ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR,
Alexander Aringf997c552016-06-15 21:20:23 +0200543 dev->dev_addr,
544 NDISC_NEIGHBOUR_ADVERTISEMENT);
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000545
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000546 ndisc_send_skb(skb, daddr, src_addr);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900547}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
Ben Hutchingsf47b9462011-04-15 13:46:02 +0000549static void ndisc_send_unsol_na(struct net_device *dev)
550{
551 struct inet6_dev *idev;
552 struct inet6_ifaddr *ifa;
Ben Hutchingsf47b9462011-04-15 13:46:02 +0000553
554 idev = in6_dev_get(dev);
555 if (!idev)
556 return;
557
558 read_lock_bh(&idev->lock);
559 list_for_each_entry(ifa, &idev->addr_list, if_list) {
Jiri Benc38cf5952015-09-22 18:57:13 +0200560 ndisc_send_na(dev, &in6addr_linklocal_allnodes, &ifa->addr,
Ben Hutchingsf47b9462011-04-15 13:46:02 +0000561 /*router=*/ !!idev->cnf.forwarding,
562 /*solicited=*/ false, /*override=*/ true,
563 /*inc_opt=*/ true);
564 }
565 read_unlock_bh(&idev->lock);
566
567 in6_dev_put(idev);
568}
569
Jiri Benc38cf5952015-09-22 18:57:13 +0200570void ndisc_send_ns(struct net_device *dev, const struct in6_addr *solicit,
Nicolas Dichtel304d8882015-11-27 18:17:05 +0100571 const struct in6_addr *daddr, const struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572{
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000573 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 struct in6_addr addr_buf;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000575 int inc_opt = dev->addr_len;
576 int optlen = 0;
577 struct nd_msg *msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
Ian Morris63159f22015-03-29 14:00:04 +0100579 if (!saddr) {
Neil Horman95c385b2007-04-25 17:08:10 -0700580 if (ipv6_get_lladdr(dev, &addr_buf,
581 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 return;
583 saddr = &addr_buf;
584 }
585
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000586 if (ipv6_addr_any(saddr))
Daniel Balutaf2f79cc2013-07-13 11:26:51 +0300587 inc_opt = false;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000588 if (inc_opt)
Alexander Aringf997c552016-06-15 21:20:23 +0200589 optlen += ndisc_opt_addr_space(dev,
590 NDISC_NEIGHBOUR_SOLICITATION);
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000591
592 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000593 if (!skb)
594 return;
595
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000596 msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
597 *msg = (struct nd_msg) {
598 .icmph = {
599 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
600 },
601 .target = *solicit,
602 };
603
604 if (inc_opt)
605 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
Alexander Aringf997c552016-06-15 21:20:23 +0200606 dev->dev_addr,
607 NDISC_NEIGHBOUR_SOLICITATION);
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000608
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000609 ndisc_send_skb(skb, daddr, saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610}
611
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900612void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
613 const struct in6_addr *daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614{
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000615 struct sk_buff *skb;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000616 struct rs_msg *msg;
Neil Horman95c385b2007-04-25 17:08:10 -0700617 int send_sllao = dev->addr_len;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000618 int optlen = 0;
Neil Horman95c385b2007-04-25 17:08:10 -0700619
620#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
621 /*
622 * According to section 2.2 of RFC 4429, we must not
623 * send router solicitations with a sllao from
624 * optimistic addresses, but we may send the solicitation
625 * if we don't include the sllao. So here we check
626 * if our address is optimistic, and if so, we
Joe Perchesbea85192007-12-20 14:01:35 -0800627 * suppress the inclusion of the sllao.
Neil Horman95c385b2007-04-25 17:08:10 -0700628 */
629 if (send_sllao) {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900630 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
Daniel Lezcano1cab3da2008-01-10 22:44:09 -0800631 dev, 1);
Neil Horman95c385b2007-04-25 17:08:10 -0700632 if (ifp) {
633 if (ifp->flags & IFA_F_OPTIMISTIC) {
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900634 send_sllao = 0;
Neil Horman95c385b2007-04-25 17:08:10 -0700635 }
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900636 in6_ifa_put(ifp);
Neil Horman95c385b2007-04-25 17:08:10 -0700637 } else {
638 send_sllao = 0;
639 }
640 }
641#endif
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000642 if (send_sllao)
Alexander Aringf997c552016-06-15 21:20:23 +0200643 optlen += ndisc_opt_addr_space(dev, NDISC_ROUTER_SOLICITATION);
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000644
645 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000646 if (!skb)
647 return;
648
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000649 msg = (struct rs_msg *)skb_put(skb, sizeof(*msg));
650 *msg = (struct rs_msg) {
651 .icmph = {
652 .icmp6_type = NDISC_ROUTER_SOLICITATION,
653 },
654 };
655
656 if (send_sllao)
657 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
Alexander Aringf997c552016-06-15 21:20:23 +0200658 dev->dev_addr,
659 NDISC_ROUTER_SOLICITATION);
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000660
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000661 ndisc_send_skb(skb, daddr, saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900663
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
665static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
666{
667 /*
668 * "The sender MUST return an ICMP
669 * destination unreachable"
670 */
671 dst_link_failure(skb);
672 kfree_skb(skb);
673}
674
675/* Called with locked neigh: either read or both */
676
677static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
678{
679 struct in6_addr *saddr = NULL;
680 struct in6_addr mcaddr;
681 struct net_device *dev = neigh->dev;
682 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
683 int probes = atomic_read(&neigh->probes);
684
Erik Klinec58da4c2015-02-04 20:01:23 +0900685 if (skb && ipv6_chk_addr_and_flags(dev_net(dev), &ipv6_hdr(skb)->saddr,
686 dev, 1,
687 IFA_F_TENTATIVE|IFA_F_OPTIMISTIC))
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700688 saddr = &ipv6_hdr(skb)->saddr;
Ian Morrise5d08d72014-11-23 21:28:43 +0000689 probes -= NEIGH_VAR(neigh->parms, UCAST_PROBES);
690 if (probes < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 if (!(neigh->nud_state & NUD_VALID)) {
Joe Perches675418d2012-05-16 19:28:38 +0000692 ND_PRINTK(1, dbg,
693 "%s: trying to ucast probe in NUD_INVALID: %pI6\n",
694 __func__, target);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 }
Nicolas Dichtel304d8882015-11-27 18:17:05 +0100696 ndisc_send_ns(dev, target, target, saddr);
Jiri Pirko1f9248e52013-12-07 19:26:53 +0100697 } else if ((probes -= NEIGH_VAR(neigh->parms, APP_PROBES)) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 neigh_app_ns(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 } else {
700 addrconf_addr_solict_mult(target, &mcaddr);
Nicolas Dichtel304d8882015-11-27 18:17:05 +0100701 ndisc_send_ns(dev, target, &mcaddr, saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 }
703}
704
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900705static int pndisc_is_router(const void *pkey,
706 struct net_device *dev)
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700707{
708 struct pneigh_entry *n;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900709 int ret = -1;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700710
711 read_lock_bh(&nd_tbl.lock);
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900712 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
713 if (n)
714 ret = !!(n->flags & NTF_ROUTER);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700715 read_unlock_bh(&nd_tbl.lock);
716
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900717 return ret;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700718}
719
Alexander Aringf997c552016-06-15 21:20:23 +0200720void ndisc_update(const struct net_device *dev, struct neighbour *neigh,
721 const u8 *lladdr, u8 new, u32 flags, u8 icmp6_type,
722 struct ndisc_options *ndopts)
723{
724 neigh_update(neigh, lladdr, new, flags);
725 /* report ndisc ops about neighbour update */
726 ndisc_ops_update(dev, neigh, flags, icmp6_type, ndopts);
727}
728
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729static void ndisc_recv_ns(struct sk_buff *skb)
730{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700731 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000732 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
733 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 u8 *lladdr = NULL;
Simon Horman29a3cad2013-05-28 20:34:26 +0000735 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700736 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 struct ndisc_options ndopts;
738 struct net_device *dev = skb->dev;
739 struct inet6_ifaddr *ifp;
740 struct inet6_dev *idev = NULL;
741 struct neighbour *neigh;
742 int dad = ipv6_addr_any(saddr);
Eric Dumazeta50feda2012-05-18 18:57:34 +0000743 bool inc;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900744 int is_router = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
YOSHIFUJI Hideaki / 吉藤英明115b0aa2013-01-18 02:05:03 +0000746 if (skb->len < sizeof(struct nd_msg)) {
747 ND_PRINTK(2, warn, "NS: packet too short\n");
748 return;
749 }
750
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 if (ipv6_addr_is_multicast(&msg->target)) {
Joe Perches675418d2012-05-16 19:28:38 +0000752 ND_PRINTK(2, warn, "NS: multicast target address\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 return;
754 }
755
756 /*
757 * RFC2461 7.1.1:
758 * DAD has to be destined for solicited node multicast address.
759 */
YOSHIFUJI Hideaki / 吉藤英明ca97a642013-01-20 07:39:00 +0000760 if (dad && !ipv6_addr_is_solict_mult(daddr)) {
Joe Perches675418d2012-05-16 19:28:38 +0000761 ND_PRINTK(2, warn, "NS: bad DAD packet (wrong destination)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 return;
763 }
764
Alexander Aringf997c552016-06-15 21:20:23 +0200765 if (!ndisc_parse_options(dev, msg->opt, ndoptlen, &ndopts)) {
Joe Perches675418d2012-05-16 19:28:38 +0000766 ND_PRINTK(2, warn, "NS: invalid ND options\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 return;
768 }
769
770 if (ndopts.nd_opts_src_lladdr) {
771 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
772 if (!lladdr) {
Joe Perches675418d2012-05-16 19:28:38 +0000773 ND_PRINTK(2, warn,
774 "NS: invalid link-layer address length\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 return;
776 }
777
778 /* RFC2461 7.1.1:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900779 * If the IP source address is the unspecified address,
780 * there MUST NOT be source link-layer address option
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 * in the message.
782 */
783 if (dad) {
Joe Perches675418d2012-05-16 19:28:38 +0000784 ND_PRINTK(2, warn,
785 "NS: bad DAD packet (link-layer address option)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 return;
787 }
788 }
789
790 inc = ipv6_addr_is_multicast(daddr);
791
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900792 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800793 if (ifp) {
David Ahernca254492015-10-12 11:47:10 -0700794have_ifp:
Neil Horman95c385b2007-04-25 17:08:10 -0700795 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
796 if (dad) {
Neil Horman95c385b2007-04-25 17:08:10 -0700797 /*
798 * We are colliding with another node
799 * who is doing DAD
800 * so fail our DAD process
801 */
802 addrconf_dad_failure(ifp);
Denis V. Lunev9e3be4b2007-09-11 11:04:49 +0200803 return;
Neil Horman95c385b2007-04-25 17:08:10 -0700804 } else {
805 /*
806 * This is not a dad solicitation.
807 * If we are an optimistic node,
808 * we should respond.
809 * Otherwise, we should ignore it.
810 */
811 if (!(ifp->flags & IFA_F_OPTIMISTIC))
812 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 }
815
816 idev = ifp->idev;
817 } else {
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700818 struct net *net = dev_net(dev);
819
David Ahernca254492015-10-12 11:47:10 -0700820 /* perhaps an address on the master device */
821 if (netif_is_l3_slave(dev)) {
822 struct net_device *mdev;
823
824 mdev = netdev_master_upper_dev_get_rcu(dev);
825 if (mdev) {
826 ifp = ipv6_get_ifaddr(net, &msg->target, mdev, 1);
827 if (ifp)
828 goto have_ifp;
829 }
830 }
831
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 idev = in6_dev_get(dev);
833 if (!idev) {
834 /* XXX: count this drop? */
835 return;
836 }
837
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700838 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900839 (idev->cnf.forwarding &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700840 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900841 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700842 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 skb->pkt_type != PACKET_HOST &&
Daniel Balutaf2f79cc2013-07-13 11:26:51 +0300844 inc &&
Jiri Pirko1f9248e52013-12-07 19:26:53 +0100845 NEIGH_VAR(idev->nd_parms, PROXY_DELAY) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 /*
847 * for anycast or proxy,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900848 * sender should delay its response
849 * by a random time between 0 and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 * MAX_ANYCAST_DELAY_TIME seconds.
851 * (RFC2461) -- yoshfuji
852 */
853 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
854 if (n)
855 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
856 goto out;
857 }
858 } else
859 goto out;
860 }
861
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900862 if (is_router < 0)
YOSHIFUJI Hideaki / 吉藤英明fb568632013-01-20 07:39:18 +0000863 is_router = idev->cnf.forwarding;
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700864
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 if (dad) {
Jiri Benc38cf5952015-09-22 18:57:13 +0200866 ndisc_send_na(dev, &in6addr_linklocal_allnodes, &msg->target,
YOSHIFUJI Hideaki / 吉藤英明fb568632013-01-20 07:39:18 +0000867 !!is_router, false, (ifp != NULL), true);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 goto out;
869 }
870
871 if (inc)
872 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
873 else
874 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
875
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900876 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 * update / create cache entry
878 * for the source address
879 */
880 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
881 !inc || lladdr || !dev->addr_len);
882 if (neigh)
Alexander Aringf997c552016-06-15 21:20:23 +0200883 ndisc_update(dev, neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 NEIGH_UPDATE_F_WEAK_OVERRIDE|
Alexander Aringf997c552016-06-15 21:20:23 +0200885 NEIGH_UPDATE_F_OVERRIDE,
886 NDISC_NEIGHBOUR_SOLICITATION, &ndopts);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700887 if (neigh || !dev->header_ops) {
Jiri Benc38cf5952015-09-22 18:57:13 +0200888 ndisc_send_na(dev, saddr, &msg->target, !!is_router,
YOSHIFUJI Hideaki / 吉藤英明fb568632013-01-20 07:39:18 +0000889 true, (ifp != NULL && inc), inc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 if (neigh)
891 neigh_release(neigh);
892 }
893
894out:
895 if (ifp)
896 in6_ifa_put(ifp);
897 else
898 in6_dev_put(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899}
900
901static void ndisc_recv_na(struct sk_buff *skb)
902{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700903 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Duan Jiongbe7a0102014-05-15 15:56:14 +0800904 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000905 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 u8 *lladdr = NULL;
Simon Horman29a3cad2013-05-28 20:34:26 +0000907 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700908 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 struct ndisc_options ndopts;
910 struct net_device *dev = skb->dev;
Johannes Berg7a02bf82016-02-04 13:31:20 +0100911 struct inet6_dev *idev = __in6_dev_get(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 struct inet6_ifaddr *ifp;
913 struct neighbour *neigh;
914
915 if (skb->len < sizeof(struct nd_msg)) {
Joe Perches675418d2012-05-16 19:28:38 +0000916 ND_PRINTK(2, warn, "NA: packet too short\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 return;
918 }
919
920 if (ipv6_addr_is_multicast(&msg->target)) {
Joe Perches675418d2012-05-16 19:28:38 +0000921 ND_PRINTK(2, warn, "NA: target address is multicast\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 return;
923 }
924
925 if (ipv6_addr_is_multicast(daddr) &&
926 msg->icmph.icmp6_solicited) {
Joe Perches675418d2012-05-16 19:28:38 +0000927 ND_PRINTK(2, warn, "NA: solicited NA is multicasted\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 return;
929 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900930
Johannes Berg7a02bf82016-02-04 13:31:20 +0100931 /* For some 802.11 wireless deployments (and possibly other networks),
932 * there will be a NA proxy and unsolicitd packets are attacks
933 * and thus should not be accepted.
934 */
935 if (!msg->icmph.icmp6_solicited && idev &&
936 idev->cnf.drop_unsolicited_na)
937 return;
938
Alexander Aringf997c552016-06-15 21:20:23 +0200939 if (!ndisc_parse_options(dev, msg->opt, ndoptlen, &ndopts)) {
Joe Perches675418d2012-05-16 19:28:38 +0000940 ND_PRINTK(2, warn, "NS: invalid ND option\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 return;
942 }
943 if (ndopts.nd_opts_tgt_lladdr) {
944 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
945 if (!lladdr) {
Joe Perches675418d2012-05-16 19:28:38 +0000946 ND_PRINTK(2, warn,
947 "NA: invalid link-layer address length\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 return;
949 }
950 }
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900951 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800952 if (ifp) {
Daniel Walterbd015922011-04-13 21:09:25 +0000953 if (skb->pkt_type != PACKET_LOOPBACK
954 && (ifp->flags & IFA_F_TENTATIVE)) {
955 addrconf_dad_failure(ifp);
956 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 }
958 /* What should we make now? The advertisement
959 is invalid, but ndisc specs say nothing
960 about it. It could be misconfiguration, or
961 an smart proxy agent tries to help us :-)
Jan Sembera24fc7b82008-12-09 15:48:32 -0800962
963 We should not print the error if NA has been
964 received from loopback - it is just our own
965 unsolicited advertisement.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 */
Jan Sembera24fc7b82008-12-09 15:48:32 -0800967 if (skb->pkt_type != PACKET_LOOPBACK)
Joe Perches675418d2012-05-16 19:28:38 +0000968 ND_PRINTK(1, warn,
969 "NA: someone advertises our address %pI6 on %s!\n",
970 &ifp->addr, ifp->idev->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 in6_ifa_put(ifp);
972 return;
973 }
974 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
975
976 if (neigh) {
977 u8 old_flags = neigh->flags;
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700978 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
980 if (neigh->nud_state & NUD_FAILED)
981 goto out;
982
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700983 /*
984 * Don't update the neighbor cache entry on a proxy NA from
985 * ourselves because either the proxied node is off link or it
986 * has already sent a NA to us.
987 */
988 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700989 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
990 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
Nicolas Dichtelb20b6d92012-11-07 05:05:38 +0000991 /* XXX: idev->cnf.proxy_ndp */
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700992 goto out;
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700993 }
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700994
Alexander Aringf997c552016-06-15 21:20:23 +0200995 ndisc_update(dev, neigh, lladdr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
997 NEIGH_UPDATE_F_WEAK_OVERRIDE|
998 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
999 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
Alexander Aringf997c552016-06-15 21:20:23 +02001000 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0),
1001 NDISC_NEIGHBOUR_ADVERTISEMENT, &ndopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002
1003 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
1004 /*
1005 * Change: router to host
1006 */
Duan Jiongbe7a0102014-05-15 15:56:14 +08001007 rt6_clean_tohost(dev_net(dev), saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 }
1009
1010out:
1011 neigh_release(neigh);
1012 }
1013}
1014
1015static void ndisc_recv_rs(struct sk_buff *skb)
1016{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001017 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1019 struct neighbour *neigh;
1020 struct inet6_dev *idev;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001021 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 struct ndisc_options ndopts;
1023 u8 *lladdr = NULL;
1024
1025 if (skb->len < sizeof(*rs_msg))
1026 return;
1027
Eric Dumazetcfdf7642011-07-27 21:13:03 +00001028 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 if (!idev) {
Joe Perches675418d2012-05-16 19:28:38 +00001030 ND_PRINTK(1, err, "RS: can't find in6 device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 return;
1032 }
1033
1034 /* Don't accept RS if we're not in router mode */
1035 if (!idev->cnf.forwarding)
1036 goto out;
1037
1038 /*
1039 * Don't update NCE if src = ::;
1040 * this implies that the source node has no ip address assigned yet.
1041 */
1042 if (ipv6_addr_any(saddr))
1043 goto out;
1044
1045 /* Parse ND options */
Alexander Aringf997c552016-06-15 21:20:23 +02001046 if (!ndisc_parse_options(skb->dev, rs_msg->opt, ndoptlen, &ndopts)) {
Joe Perches675418d2012-05-16 19:28:38 +00001047 ND_PRINTK(2, notice, "NS: invalid ND option, ignored\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 goto out;
1049 }
1050
1051 if (ndopts.nd_opts_src_lladdr) {
1052 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1053 skb->dev);
1054 if (!lladdr)
1055 goto out;
1056 }
1057
1058 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1059 if (neigh) {
Alexander Aringf997c552016-06-15 21:20:23 +02001060 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1062 NEIGH_UPDATE_F_OVERRIDE|
Alexander Aringf997c552016-06-15 21:20:23 +02001063 NEIGH_UPDATE_F_OVERRIDE_ISROUTER,
1064 NDISC_ROUTER_SOLICITATION, &ndopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 neigh_release(neigh);
1066 }
1067out:
Eric Dumazetcfdf7642011-07-27 21:13:03 +00001068 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069}
1070
Pierre Ynard31910572007-10-10 21:22:05 -07001071static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1072{
1073 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1074 struct sk_buff *skb;
1075 struct nlmsghdr *nlh;
1076 struct nduseroptmsg *ndmsg;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001077 struct net *net = dev_net(ra->dev);
Pierre Ynard31910572007-10-10 21:22:05 -07001078 int err;
1079 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1080 + (opt->nd_opt_len << 3));
1081 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1082
1083 skb = nlmsg_new(msg_size, GFP_ATOMIC);
Ian Morris63159f22015-03-29 14:00:04 +01001084 if (!skb) {
Pierre Ynard31910572007-10-10 21:22:05 -07001085 err = -ENOBUFS;
1086 goto errout;
1087 }
1088
1089 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
Ian Morris63159f22015-03-29 14:00:04 +01001090 if (!nlh) {
Pierre Ynard31910572007-10-10 21:22:05 -07001091 goto nla_put_failure;
1092 }
1093
1094 ndmsg = nlmsg_data(nlh);
1095 ndmsg->nduseropt_family = AF_INET6;
Pierre Ynarddbb2ed22007-11-12 17:58:35 -08001096 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
Pierre Ynard31910572007-10-10 21:22:05 -07001097 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1098 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1099 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1100
1101 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1102
Jiri Benc930345e2015-03-29 16:59:25 +02001103 if (nla_put_in6_addr(skb, NDUSEROPT_SRCADDR, &ipv6_hdr(ra)->saddr))
David S. Millerc78679e2012-04-01 20:27:33 -04001104 goto nla_put_failure;
Pierre Ynard31910572007-10-10 21:22:05 -07001105 nlmsg_end(skb, nlh);
1106
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001107 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
Pierre Ynard31910572007-10-10 21:22:05 -07001108 return;
1109
1110nla_put_failure:
1111 nlmsg_free(skb);
1112 err = -EMSGSIZE;
1113errout:
Daniel Lezcanoa18bc692008-03-07 11:14:49 -08001114 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
Pierre Ynard31910572007-10-10 21:22:05 -07001115}
1116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117static void ndisc_router_discovery(struct sk_buff *skb)
1118{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001119 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 struct neighbour *neigh = NULL;
1121 struct inet6_dev *in6_dev;
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001122 struct rt6_info *rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 int lifetime;
1124 struct ndisc_options ndopts;
1125 int optlen;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001126 unsigned int pref = 0;
Marius Tomaschewskia394eef2015-08-31 15:59:22 +02001127 __u32 old_if_flags;
Marius Tomaschewski2053aeb2015-09-01 01:57:30 +02001128 bool send_ifinfo_notify = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
Ian Morris67ba4152014-08-24 21:53:10 +01001130 __u8 *opt = (__u8 *)(ra_msg + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131
Simon Horman29a3cad2013-05-28 20:34:26 +00001132 optlen = (skb_tail_pointer(skb) - skb_transport_header(skb)) -
1133 sizeof(struct ra_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134
Ben Greearf2a762d2014-06-25 14:44:52 -07001135 ND_PRINTK(2, info,
1136 "RA: %s, dev: %s\n",
1137 __func__, skb->dev->name);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001138 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Joe Perches675418d2012-05-16 19:28:38 +00001139 ND_PRINTK(2, warn, "RA: source address is not link-local\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 return;
1141 }
1142 if (optlen < 0) {
Joe Perches675418d2012-05-16 19:28:38 +00001143 ND_PRINTK(2, warn, "RA: packet too short\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 return;
1145 }
1146
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001147#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001148 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
Joe Perches675418d2012-05-16 19:28:38 +00001149 ND_PRINTK(2, warn, "RA: from host or unauthorized router\n");
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001150 return;
1151 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001152#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001153
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 /*
1155 * set the RA_RECV flag in the interface
1156 */
1157
Eric Dumazetcfdf7642011-07-27 21:13:03 +00001158 in6_dev = __in6_dev_get(skb->dev);
Ian Morris63159f22015-03-29 14:00:04 +01001159 if (!in6_dev) {
Joe Perches675418d2012-05-16 19:28:38 +00001160 ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n",
1161 skb->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 return;
1163 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
Alexander Aringf997c552016-06-15 21:20:23 +02001165 if (!ndisc_parse_options(skb->dev, opt, optlen, &ndopts)) {
Joe Perches675418d2012-05-16 19:28:38 +00001166 ND_PRINTK(2, warn, "RA: invalid ND options\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 return;
1168 }
1169
Ben Greearf2a762d2014-06-25 14:44:52 -07001170 if (!ipv6_accept_ra(in6_dev)) {
1171 ND_PRINTK(2, info,
1172 "RA: %s, did not accept ra for dev: %s\n",
1173 __func__, skb->dev->name);
David Ward31ce8c72009-08-29 00:04:09 -07001174 goto skip_linkparms;
Ben Greearf2a762d2014-06-25 14:44:52 -07001175 }
David Ward31ce8c72009-08-29 00:04:09 -07001176
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001177#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001178 /* skip link-specific parameters from interior routers */
Ben Greearf2a762d2014-06-25 14:44:52 -07001179 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) {
1180 ND_PRINTK(2, info,
1181 "RA: %s, nodetype is NODEFAULT, dev: %s\n",
1182 __func__, skb->dev->name);
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001183 goto skip_linkparms;
Ben Greearf2a762d2014-06-25 14:44:52 -07001184 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001185#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001186
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 if (in6_dev->if_flags & IF_RS_SENT) {
1188 /*
1189 * flag that an RA was received after an RS was sent
1190 * out on this interface.
1191 */
1192 in6_dev->if_flags |= IF_RA_RCVD;
1193 }
1194
1195 /*
1196 * Remember the managed/otherconf flags from most recently
1197 * received RA message (RFC 2462) -- yoshfuji
1198 */
Marius Tomaschewskia394eef2015-08-31 15:59:22 +02001199 old_if_flags = in6_dev->if_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1201 IF_RA_OTHERCONF)) |
1202 (ra_msg->icmph.icmp6_addrconf_managed ?
1203 IF_RA_MANAGED : 0) |
1204 (ra_msg->icmph.icmp6_addrconf_other ?
1205 IF_RA_OTHERCONF : 0);
1206
Marius Tomaschewskia394eef2015-08-31 15:59:22 +02001207 if (old_if_flags != in6_dev->if_flags)
Marius Tomaschewski2053aeb2015-09-01 01:57:30 +02001208 send_ifinfo_notify = true;
Marius Tomaschewskia394eef2015-08-31 15:59:22 +02001209
Ben Greearf2a762d2014-06-25 14:44:52 -07001210 if (!in6_dev->cnf.accept_ra_defrtr) {
1211 ND_PRINTK(2, info,
1212 "RA: %s, defrtr is false for dev: %s\n",
1213 __func__, skb->dev->name);
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001214 goto skip_defrtr;
Ben Greearf2a762d2014-06-25 14:44:52 -07001215 }
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001216
Ben Greeard9333192014-06-25 14:44:53 -07001217 /* Do not accept RA with source-addr found on local machine unless
1218 * accept_ra_from_local is set to true.
1219 */
Li RongQingb6428812014-07-10 18:02:46 +08001220 if (!in6_dev->cnf.accept_ra_from_local &&
1221 ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr,
Hannes Frederic Sowac1a9a292015-12-23 22:44:37 +01001222 in6_dev->dev, 0)) {
Ben Greearf2a762d2014-06-25 14:44:52 -07001223 ND_PRINTK(2, info,
Ben Greeard9333192014-06-25 14:44:53 -07001224 "RA from local address detected on dev: %s: default router ignored\n",
1225 skb->dev->name);
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001226 goto skip_defrtr;
Ben Greearf2a762d2014-06-25 14:44:52 -07001227 }
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001228
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1230
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001231#ifdef CONFIG_IPV6_ROUTER_PREF
1232 pref = ra_msg->icmph.icmp6_router_pref;
1233 /* 10b is handled as if it were 00b (medium) */
YOSHIFUJI Hideaki930d6ff2006-03-20 17:05:30 -08001234 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
YOSHIFUJI Hideaki6d5b78c2007-06-22 16:07:04 -07001235 !in6_dev->cnf.accept_ra_rtr_pref)
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001236 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1237#endif
1238
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001239 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240
David S. Millereb857182012-01-27 15:07:56 -08001241 if (rt) {
1242 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1243 if (!neigh) {
Joe Perches675418d2012-05-16 19:28:38 +00001244 ND_PRINTK(0, err,
1245 "RA: %s got default router without neighbour\n",
1246 __func__);
Amerigo Wang94e187c2012-10-29 00:13:19 +00001247 ip6_rt_put(rt);
David S. Millereb857182012-01-27 15:07:56 -08001248 return;
1249 }
1250 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 if (rt && lifetime == 0) {
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001252 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 rt = NULL;
1254 }
1255
Ben Greearf2a762d2014-06-25 14:44:52 -07001256 ND_PRINTK(3, info, "RA: rt: %p lifetime: %d, for dev: %s\n",
1257 rt, lifetime, skb->dev->name);
Ian Morris63159f22015-03-29 14:00:04 +01001258 if (!rt && lifetime) {
Ben Greearf2a762d2014-06-25 14:44:52 -07001259 ND_PRINTK(3, info, "RA: adding default router\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001261 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
Ian Morris63159f22015-03-29 14:00:04 +01001262 if (!rt) {
Joe Perches675418d2012-05-16 19:28:38 +00001263 ND_PRINTK(0, err,
1264 "RA: %s failed to add default route\n",
1265 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 return;
1267 }
1268
David S. Millereb857182012-01-27 15:07:56 -08001269 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
Ian Morris63159f22015-03-29 14:00:04 +01001270 if (!neigh) {
Joe Perches675418d2012-05-16 19:28:38 +00001271 ND_PRINTK(0, err,
1272 "RA: %s got default router without neighbour\n",
1273 __func__);
Amerigo Wang94e187c2012-10-29 00:13:19 +00001274 ip6_rt_put(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 return;
1276 }
1277 neigh->flags |= NTF_ROUTER;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001278 } else if (rt) {
Pedro Ribeiro22441cf2008-10-15 15:47:49 -07001279 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 }
1281
1282 if (rt)
Gao feng1716a962012-04-06 00:13:10 +00001283 rt6_set_expires(rt, jiffies + (HZ * lifetime));
Hangbin Liu8013d1d2015-07-30 14:28:42 +08001284 if (in6_dev->cnf.accept_ra_min_hop_limit < 256 &&
1285 ra_msg->icmph.icmp6_hop_limit) {
1286 if (in6_dev->cnf.accept_ra_min_hop_limit <= ra_msg->icmph.icmp6_hop_limit) {
D.S. Ljungmark6fd99092015-03-25 09:28:15 +01001287 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
Hangbin Liu8013d1d2015-07-30 14:28:42 +08001288 if (rt)
1289 dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1290 ra_msg->icmph.icmp6_hop_limit);
D.S. Ljungmark6fd99092015-03-25 09:28:15 +01001291 } else {
Hangbin Liu8013d1d2015-07-30 14:28:42 +08001292 ND_PRINTK(2, warn, "RA: Got route advertisement with lower hop_limit than minimum\n");
D.S. Ljungmark6fd99092015-03-25 09:28:15 +01001293 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 }
1295
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001296skip_defrtr:
1297
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 /*
1299 * Update Reachable Time and Retrans Timer
1300 */
1301
1302 if (in6_dev->nd_parms) {
1303 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1304
1305 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1306 rtime = (rtime*HZ)/1000;
1307 if (rtime < HZ/10)
1308 rtime = HZ/10;
Jiri Pirko1f9248e52013-12-07 19:26:53 +01001309 NEIGH_VAR_SET(in6_dev->nd_parms, RETRANS_TIME, rtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 in6_dev->tstamp = jiffies;
Marius Tomaschewski2053aeb2015-09-01 01:57:30 +02001311 send_ifinfo_notify = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 }
1313
1314 rtime = ntohl(ra_msg->reachable_time);
1315 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1316 rtime = (rtime*HZ)/1000;
1317
1318 if (rtime < HZ/10)
1319 rtime = HZ/10;
1320
Jiri Pirko1f9248e52013-12-07 19:26:53 +01001321 if (rtime != NEIGH_VAR(in6_dev->nd_parms, BASE_REACHABLE_TIME)) {
1322 NEIGH_VAR_SET(in6_dev->nd_parms,
1323 BASE_REACHABLE_TIME, rtime);
1324 NEIGH_VAR_SET(in6_dev->nd_parms,
1325 GC_STALETIME, 3 * rtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1327 in6_dev->tstamp = jiffies;
Marius Tomaschewski2053aeb2015-09-01 01:57:30 +02001328 send_ifinfo_notify = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 }
1330 }
1331 }
1332
Marius Tomaschewski2053aeb2015-09-01 01:57:30 +02001333 /*
1334 * Send a notify if RA changed managed/otherconf flags or timer settings
1335 */
1336 if (send_ifinfo_notify)
1337 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1338
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001339skip_linkparms:
1340
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 /*
1342 * Process options.
1343 */
1344
1345 if (!neigh)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001346 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 skb->dev, 1);
1348 if (neigh) {
1349 u8 *lladdr = NULL;
1350 if (ndopts.nd_opts_src_lladdr) {
1351 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1352 skb->dev);
1353 if (!lladdr) {
Joe Perches675418d2012-05-16 19:28:38 +00001354 ND_PRINTK(2, warn,
1355 "RA: invalid link-layer address length\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 goto out;
1357 }
1358 }
Alexander Aringf997c552016-06-15 21:20:23 +02001359 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1361 NEIGH_UPDATE_F_OVERRIDE|
1362 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
Alexander Aringf997c552016-06-15 21:20:23 +02001363 NEIGH_UPDATE_F_ISROUTER,
1364 NDISC_ROUTER_ADVERTISEMENT, &ndopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 }
1366
Ben Greearf2a762d2014-06-25 14:44:52 -07001367 if (!ipv6_accept_ra(in6_dev)) {
1368 ND_PRINTK(2, info,
1369 "RA: %s, accept_ra is false for dev: %s\n",
1370 __func__, skb->dev->name);
David Ward31ce8c72009-08-29 00:04:09 -07001371 goto out;
Ben Greearf2a762d2014-06-25 14:44:52 -07001372 }
David Ward31ce8c72009-08-29 00:04:09 -07001373
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001374#ifdef CONFIG_IPV6_ROUTE_INFO
Li RongQingb6428812014-07-10 18:02:46 +08001375 if (!in6_dev->cnf.accept_ra_from_local &&
1376 ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr,
Hannes Frederic Sowac1a9a292015-12-23 22:44:37 +01001377 in6_dev->dev, 0)) {
Ben Greearf2a762d2014-06-25 14:44:52 -07001378 ND_PRINTK(2, info,
Ben Greeard9333192014-06-25 14:44:53 -07001379 "RA from local address detected on dev: %s: router info ignored.\n",
1380 skb->dev->name);
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001381 goto skip_routeinfo;
Ben Greearf2a762d2014-06-25 14:44:52 -07001382 }
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001383
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001384 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001385 struct nd_opt_hdr *p;
1386 for (p = ndopts.nd_opts_ri;
1387 p;
1388 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
YOSHIFUJI Hideaki6294e002008-03-15 23:56:52 -04001389 struct route_info *ri = (struct route_info *)p;
1390#ifdef CONFIG_IPV6_NDISC_NODETYPE
1391 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1392 ri->prefix_len == 0)
1393 continue;
1394#endif
Duan Jiong30e56912013-11-26 15:46:56 +08001395 if (ri->prefix_len == 0 &&
1396 !in6_dev->cnf.accept_ra_defrtr)
1397 continue;
YOSHIFUJI Hideaki6294e002008-03-15 23:56:52 -04001398 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001399 continue;
Ian Morris67ba4152014-08-24 21:53:10 +01001400 rt6_route_rcv(skb->dev, (u8 *)p, (p->nd_opt_len) << 3,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001401 &ipv6_hdr(skb)->saddr);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001402 }
1403 }
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001404
1405skip_routeinfo:
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001406#endif
1407
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001408#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001409 /* skip link-specific ndopts from interior routers */
Ben Greearf2a762d2014-06-25 14:44:52 -07001410 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) {
1411 ND_PRINTK(2, info,
1412 "RA: %s, nodetype is NODEFAULT (interior routes), dev: %s\n",
1413 __func__, skb->dev->name);
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001414 goto out;
Ben Greearf2a762d2014-06-25 14:44:52 -07001415 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001416#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001417
YOSHIFUJI Hideakic4fd30e2006-03-20 16:55:26 -08001418 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 struct nd_opt_hdr *p;
1420 for (p = ndopts.nd_opts_pi;
1421 p;
1422 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
Neil Hormane6bff992012-01-04 10:49:15 +00001423 addrconf_prefix_rcv(skb->dev, (u8 *)p,
1424 (p->nd_opt_len) << 3,
1425 ndopts.nd_opts_src_lladdr != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 }
1427 }
1428
Harout Hedeshianc2943f12015-01-20 10:06:05 -07001429 if (ndopts.nd_opts_mtu && in6_dev->cnf.accept_ra_mtu) {
Al Viroe69a4adc2006-11-14 20:56:00 -08001430 __be32 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 u32 mtu;
1432
Ian Morris67ba4152014-08-24 21:53:10 +01001433 memcpy(&n, ((u8 *)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
Al Viroe69a4adc2006-11-14 20:56:00 -08001434 mtu = ntohl(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435
1436 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
Joe Perches675418d2012-05-16 19:28:38 +00001437 ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 } else if (in6_dev->cnf.mtu6 != mtu) {
1439 in6_dev->cnf.mtu6 = mtu;
1440
1441 if (rt)
David S. Millerdefb3512010-12-08 21:16:57 -08001442 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443
1444 rt6_mtu_change(skb->dev, mtu);
1445 }
1446 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001447
Pierre Ynard31910572007-10-10 21:22:05 -07001448 if (ndopts.nd_useropts) {
YOSHIFUJI Hideaki61cf46ad2008-01-22 17:32:53 +09001449 struct nd_opt_hdr *p;
1450 for (p = ndopts.nd_useropts;
1451 p;
Alexander Aringf997c552016-06-15 21:20:23 +02001452 p = ndisc_next_useropt(skb->dev, p,
1453 ndopts.nd_useropts_end)) {
YOSHIFUJI Hideaki61cf46ad2008-01-22 17:32:53 +09001454 ndisc_ra_useropt(skb, p);
Pierre Ynard31910572007-10-10 21:22:05 -07001455 }
1456 }
1457
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
Joe Perches675418d2012-05-16 19:28:38 +00001459 ND_PRINTK(2, warn, "RA: invalid RA options\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 }
1461out:
Amerigo Wang94e187c2012-10-29 00:13:19 +00001462 ip6_rt_put(rt);
David S. Millereb857182012-01-27 15:07:56 -08001463 if (neigh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465}
1466
1467static void ndisc_redirect_rcv(struct sk_buff *skb)
1468{
Duan Jiong093d04d2012-12-14 02:59:59 +00001469 u8 *hdr;
1470 struct ndisc_options ndopts;
1471 struct rd_msg *msg = (struct rd_msg *)skb_transport_header(skb);
Simon Horman29a3cad2013-05-28 20:34:26 +00001472 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
Duan Jiong093d04d2012-12-14 02:59:59 +00001473 offsetof(struct rd_msg, opt));
1474
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001475#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001476 switch (skb->ndisc_nodetype) {
1477 case NDISC_NODETYPE_HOST:
1478 case NDISC_NODETYPE_NODEFAULT:
Joe Perches675418d2012-05-16 19:28:38 +00001479 ND_PRINTK(2, warn,
1480 "Redirect: from host or unauthorized router\n");
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001481 return;
1482 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001483#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001484
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001485 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Joe Perches675418d2012-05-16 19:28:38 +00001486 ND_PRINTK(2, warn,
1487 "Redirect: source address is not link-local\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 return;
1489 }
1490
Alexander Aringf997c552016-06-15 21:20:23 +02001491 if (!ndisc_parse_options(skb->dev, msg->opt, ndoptlen, &ndopts))
Duan Jiong093d04d2012-12-14 02:59:59 +00001492 return;
1493
Duan Jiongc92a59e2013-08-22 12:07:35 +08001494 if (!ndopts.nd_opts_rh) {
Duan Jiongb55b76b2013-09-04 19:44:21 +08001495 ip6_redirect_no_header(skb, dev_net(skb->dev),
1496 skb->dev->ifindex, 0);
Duan Jiong093d04d2012-12-14 02:59:59 +00001497 return;
Duan Jiongc92a59e2013-08-22 12:07:35 +08001498 }
Duan Jiong093d04d2012-12-14 02:59:59 +00001499
1500 hdr = (u8 *)ndopts.nd_opts_rh;
1501 hdr += 8;
1502 if (!pskb_pull(skb, hdr - skb_transport_header(skb)))
1503 return;
1504
David S. Millerb94f1c02012-07-12 00:33:37 -07001505 icmpv6_notify(skb, NDISC_REDIRECT, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506}
1507
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +00001508static void ndisc_fill_redirect_hdr_option(struct sk_buff *skb,
1509 struct sk_buff *orig_skb,
1510 int rd_len)
YOSHIFUJI Hideaki / 吉藤英明9c86daf2013-01-21 06:48:09 +00001511{
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +00001512 u8 *opt = skb_put(skb, rd_len);
1513
YOSHIFUJI Hideaki / 吉藤英明9c86daf2013-01-21 06:48:09 +00001514 memset(opt, 0, 8);
1515 *(opt++) = ND_OPT_REDIRECT_HDR;
1516 *(opt++) = (rd_len >> 3);
1517 opt += 6;
1518
Lorenzo Bianconic5e64392018-03-08 17:00:02 +01001519 skb_copy_bits(orig_skb, skb_network_offset(orig_skb), opt,
1520 rd_len - 8);
YOSHIFUJI Hideaki / 吉藤英明9c86daf2013-01-21 06:48:09 +00001521}
1522
David S. Miller49919692012-01-27 15:30:48 -08001523void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524{
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001525 struct net_device *dev = skb->dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001526 struct net *net = dev_net(dev);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001527 struct sock *sk = net->ipv6.ndisc_sk;
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001528 int optlen = 0;
David S. Millerfbfe95a2012-06-08 23:24:18 -07001529 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 struct sk_buff *buff;
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001531 struct rd_msg *msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 struct in6_addr saddr_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 struct rt6_info *rt;
1534 struct dst_entry *dst;
David S. Miller4c9483b2011-03-12 16:22:43 -05001535 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 int rd_len;
Alexander Aringf997c552016-06-15 21:20:23 +02001537 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL,
1538 ops_data_buf[NDISC_OPS_REDIRECT_DATA_SPACE], *ops_data = NULL;
David S. Miller1d861aa2012-07-10 03:58:16 -07001539 bool ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540
Stephen Suryaputra869584e2018-06-01 00:05:21 -04001541 if (netif_is_l3_master(skb->dev)) {
1542 dev = __dev_get_by_index(dev_net(skb->dev), IPCB(skb)->iif);
1543 if (!dev)
1544 return;
1545 }
1546
Neil Horman95c385b2007-04-25 17:08:10 -07001547 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
Joe Perches675418d2012-05-16 19:28:38 +00001548 ND_PRINTK(2, warn, "Redirect: no link-local address on %s\n",
1549 dev->name);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001550 return;
1551 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001553 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
Brian Haleybf0b48d2007-10-08 00:12:05 -07001554 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
Joe Perches675418d2012-05-16 19:28:38 +00001555 ND_PRINTK(2, warn,
1556 "Redirect: target address is not link-local unicast\n");
Li Yewang29556522007-01-30 14:33:20 -08001557 return;
1558 }
1559
David S. Miller4c9483b2011-03-12 16:22:43 -05001560 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
David Aherne0d56fd2016-09-10 12:09:57 -07001561 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562
David S. Miller4c9483b2011-03-12 16:22:43 -05001563 dst = ip6_route_output(net, NULL, &fl6);
RongQing.Li5095d642012-02-21 22:10:49 +00001564 if (dst->error) {
1565 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 return;
RongQing.Li5095d642012-02-21 22:10:49 +00001567 }
David S. Miller4c9483b2011-03-12 16:22:43 -05001568 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
David S. Miller452edd52011-03-02 13:27:41 -08001569 if (IS_ERR(dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571
1572 rt = (struct rt6_info *) dst;
1573
1574 if (rt->rt6i_flags & RTF_GATEWAY) {
Joe Perches675418d2012-05-16 19:28:38 +00001575 ND_PRINTK(2, warn,
1576 "Redirect: destination is not a neighbour\n");
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001577 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 }
Martin KaFai Laufd0273d2015-05-22 20:55:57 -07001579 peer = inet_getpeer_v6(net->ipv6.peers, &ipv6_hdr(skb)->saddr, 1);
David S. Miller1d861aa2012-07-10 03:58:16 -07001580 ret = inet_peer_xrlim_allow(peer, 1*HZ);
1581 if (peer)
1582 inet_putpeer(peer);
1583 if (!ret)
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001584 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585
1586 if (dev->addr_len) {
David S. Miller49919692012-01-27 15:30:48 -08001587 struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target);
1588 if (!neigh) {
Joe Perches675418d2012-05-16 19:28:38 +00001589 ND_PRINTK(2, warn,
1590 "Redirect: no neigh for target address\n");
David S. Miller49919692012-01-27 15:30:48 -08001591 goto release;
1592 }
1593
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 read_lock_bh(&neigh->lock);
1595 if (neigh->nud_state & NUD_VALID) {
1596 memcpy(ha_buf, neigh->ha, dev->addr_len);
1597 read_unlock_bh(&neigh->lock);
1598 ha = ha_buf;
Alexander Aringf997c552016-06-15 21:20:23 +02001599 optlen += ndisc_redirect_opt_addr_space(dev, neigh,
1600 ops_data_buf,
1601 &ops_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 } else
1603 read_unlock_bh(&neigh->lock);
David S. Miller49919692012-01-27 15:30:48 -08001604
1605 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 }
1607
1608 rd_len = min_t(unsigned int,
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001609 IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(*msg) - optlen,
1610 skb->len + 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 rd_len &= ~0x7;
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001612 optlen += rd_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001614 buff = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +00001615 if (!buff)
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001616 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617
YOSHIFUJI Hideaki / 吉藤英明4d5c1522013-01-21 06:49:25 +00001618 msg = (struct rd_msg *)skb_put(buff, sizeof(*msg));
1619 *msg = (struct rd_msg) {
1620 .icmph = {
1621 .icmp6_type = NDISC_REDIRECT,
1622 },
1623 .target = *target,
1624 .dest = ipv6_hdr(skb)->daddr,
1625 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 /*
1628 * include target_address option
1629 */
1630
1631 if (ha)
Alexander Aringf997c552016-06-15 21:20:23 +02001632 ndisc_fill_redirect_addr_option(buff, ha, ops_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633
1634 /*
1635 * build redirect option and copy skb over to the new packet.
1636 */
1637
YOSHIFUJI Hideaki / 吉藤英明9c86daf2013-01-21 06:48:09 +00001638 if (rd_len)
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +00001639 ndisc_fill_redirect_hdr_option(buff, skb, rd_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640
Eric Dumazetadf30902009-06-02 05:19:30 +00001641 skb_dst_set(buff, dst);
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +00001642 ndisc_send_skb(buff, &ipv6_hdr(skb)->saddr, &saddr_buf);
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001643 return;
1644
1645release:
1646 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647}
1648
1649static void pndisc_redo(struct sk_buff *skb)
1650{
YOSHIFUJI Hideaki140e26fc2005-10-05 12:11:41 -07001651 ndisc_recv_ns(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 kfree_skb(skb);
1653}
1654
Hannes Frederic Sowab800c3b2013-08-27 01:36:51 +02001655static bool ndisc_suppress_frag_ndisc(struct sk_buff *skb)
1656{
1657 struct inet6_dev *idev = __in6_dev_get(skb->dev);
1658
1659 if (!idev)
1660 return true;
1661 if (IP6CB(skb)->flags & IP6SKB_FRAGMENTED &&
1662 idev->cnf.suppress_frag_ndisc) {
1663 net_warn_ratelimited("Received fragmented ndisc packet. Carefully consider disabling suppress_frag_ndisc.\n");
1664 return true;
1665 }
1666 return false;
1667}
1668
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669int ndisc_rcv(struct sk_buff *skb)
1670{
1671 struct nd_msg *msg;
1672
Hannes Frederic Sowab800c3b2013-08-27 01:36:51 +02001673 if (ndisc_suppress_frag_ndisc(skb))
1674 return 0;
1675
YOSHIFUJI Hideaki / 吉藤英明6bce6b42013-01-21 06:48:03 +00001676 if (skb_linearize(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 return 0;
1678
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001679 msg = (struct nd_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001681 __skb_push(skb, skb->data - skb_transport_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001683 if (ipv6_hdr(skb)->hop_limit != 255) {
Joe Perches675418d2012-05-16 19:28:38 +00001684 ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n",
1685 ipv6_hdr(skb)->hop_limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 return 0;
1687 }
1688
1689 if (msg->icmph.icmp6_code != 0) {
Joe Perches675418d2012-05-16 19:28:38 +00001690 ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n",
1691 msg->icmph.icmp6_code);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 return 0;
1693 }
1694
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 switch (msg->icmph.icmp6_type) {
1696 case NDISC_NEIGHBOUR_SOLICITATION:
Stefano Brivio510e6c32018-10-24 14:37:21 +02001697 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 ndisc_recv_ns(skb);
1699 break;
1700
1701 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1702 ndisc_recv_na(skb);
1703 break;
1704
1705 case NDISC_ROUTER_SOLICITATION:
1706 ndisc_recv_rs(skb);
1707 break;
1708
1709 case NDISC_ROUTER_ADVERTISEMENT:
1710 ndisc_router_discovery(skb);
1711 break;
1712
1713 case NDISC_REDIRECT:
1714 ndisc_redirect_rcv(skb);
1715 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001716 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717
1718 return 0;
1719}
1720
1721static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1722{
Jiri Pirko351638e2013-05-28 01:30:21 +00001723 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Eric Dumazetc8507fb2015-07-29 12:01:41 +02001724 struct netdev_notifier_change_info *change_info;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001725 struct net *net = dev_net(dev);
Hannes Frederic Sowa5cb04432012-11-06 16:46:20 +00001726 struct inet6_dev *idev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727
1728 switch (event) {
1729 case NETDEV_CHANGEADDR:
1730 neigh_changeaddr(&nd_tbl, dev);
Michal Kubeček2ac3ac82013-08-01 10:04:14 +02001731 fib6_run_gc(0, net, false);
David Ahern2bea4872017-04-12 11:49:04 -07001732 /* fallthrough */
1733 case NETDEV_UP:
Hannes Frederic Sowa5cb04432012-11-06 16:46:20 +00001734 idev = in6_dev_get(dev);
1735 if (!idev)
1736 break;
1737 if (idev->cnf.ndisc_notify)
1738 ndisc_send_unsol_na(dev);
1739 in6_dev_put(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 break;
Eric Dumazetc8507fb2015-07-29 12:01:41 +02001741 case NETDEV_CHANGE:
1742 change_info = ptr;
1743 if (change_info->flags_changed & IFF_NOARP)
1744 neigh_changeaddr(&nd_tbl, dev);
1745 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 case NETDEV_DOWN:
1747 neigh_ifdown(&nd_tbl, dev);
Michal Kubeček2ac3ac82013-08-01 10:04:14 +02001748 fib6_run_gc(0, net, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 break;
Ben Hutchingsf47b9462011-04-15 13:46:02 +00001750 case NETDEV_NOTIFY_PEERS:
1751 ndisc_send_unsol_na(dev);
1752 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 default:
1754 break;
1755 }
1756
1757 return NOTIFY_DONE;
1758}
1759
1760static struct notifier_block ndisc_netdev_notifier = {
1761 .notifier_call = ndisc_netdev_event,
1762};
1763
1764#ifdef CONFIG_SYSCTL
1765static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1766 const char *func, const char *dev_name)
1767{
1768 static char warncomm[TASK_COMM_LEN];
1769 static int warned;
1770 if (strcmp(warncomm, current->comm) && warned < 5) {
1771 strcpy(warncomm, current->comm);
Joe Perchesf3213832012-05-15 14:11:53 +00001772 pr_warn("process `%s' is using deprecated sysctl (%s) net.ipv6.neigh.%s.%s - use net.ipv6.neigh.%s.%s_ms instead\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 warncomm, func,
1774 dev_name, ctl->procname,
1775 dev_name, ctl->procname);
1776 warned++;
1777 }
1778}
1779
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001780int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781{
1782 struct net_device *dev = ctl->extra1;
1783 struct inet6_dev *idev;
1784 int ret;
1785
Eric W. Biedermand12af672007-10-18 03:05:25 -07001786 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1787 (strcmp(ctl->procname, "base_reachable_time") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1789
Eric W. Biedermand12af672007-10-18 03:05:25 -07001790 if (strcmp(ctl->procname, "retrans_time") == 0)
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01001791 ret = neigh_proc_dointvec(ctl, write, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001792
1793 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01001794 ret = neigh_proc_dointvec_jiffies(ctl, write,
1795 buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001796
1797 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
YOSHIFUJI Hideakiad02ac12007-10-29 01:32:23 -07001798 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01001799 ret = neigh_proc_dointvec_ms_jiffies(ctl, write,
1800 buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001801 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 ret = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803
1804 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
Jiri Pirko1f9248e52013-12-07 19:26:53 +01001805 if (ctl->data == &NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME))
1806 idev->nd_parms->reachable_time =
1807 neigh_rand_reach_time(NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 idev->tstamp = jiffies;
1809 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1810 in6_dev_put(idev);
1811 }
1812 return ret;
1813}
1814
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815
1816#endif
1817
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001818static int __net_init ndisc_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819{
1820 struct ipv6_pinfo *np;
1821 struct sock *sk;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001822 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001824 err = inet_ctl_sock_create(&sk, PF_INET6,
1825 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 if (err < 0) {
Joe Perches675418d2012-05-16 19:28:38 +00001827 ND_PRINTK(0, err,
1828 "NDISC: Failed to initialize the control socket (err %d)\n",
1829 err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 return err;
1831 }
1832
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001833 net->ipv6.ndisc_sk = sk;
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001834
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 np->hop_limit = 255;
1837 /* Do not loopback ndisc messages */
1838 np->mc_loop = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001840 return 0;
1841}
1842
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001843static void __net_exit ndisc_net_exit(struct net *net)
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001844{
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001845 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001846}
1847
1848static struct pernet_operations ndisc_net_ops = {
1849 .init = ndisc_net_init,
1850 .exit = ndisc_net_exit,
1851};
1852
1853int __init ndisc_init(void)
1854{
1855 int err;
1856
1857 err = register_pernet_subsys(&ndisc_net_ops);
1858 if (err)
1859 return err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001860 /*
1861 * Initialize the neighbour table
1862 */
WANG Congd7480fd2014-11-10 15:59:36 -08001863 neigh_table_init(NEIGH_ND_TABLE, &nd_tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864
1865#ifdef CONFIG_SYSCTL
Jiri Pirko73af6142013-12-07 19:26:55 +01001866 err = neigh_sysctl_register(NULL, &nd_tbl.parms,
Himangi Saraogi56ec0fb2014-07-25 01:49:37 +05301867 ndisc_ifinfo_sysctl_change);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001868 if (err)
1869 goto out_unregister_pernet;
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001870out:
Fabio Estevambcd081a2013-11-16 00:52:08 -02001871#endif
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001872 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001874#ifdef CONFIG_SYSCTL
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001875out_unregister_pernet:
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001876 unregister_pernet_subsys(&ndisc_net_ops);
1877 goto out;
Michal Kubeček2c861cc2013-09-09 21:45:04 +02001878#endif
1879}
1880
1881int __init ndisc_late_init(void)
1882{
1883 return register_netdevice_notifier(&ndisc_netdev_notifier);
1884}
1885
1886void ndisc_late_cleanup(void)
1887{
1888 unregister_netdevice_notifier(&ndisc_netdev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889}
1890
1891void ndisc_cleanup(void)
1892{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893#ifdef CONFIG_SYSCTL
1894 neigh_sysctl_unregister(&nd_tbl.parms);
1895#endif
WANG Congd7480fd2014-11-10 15:59:36 -08001896 neigh_table_clear(NEIGH_ND_TABLE, &nd_tbl);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001897 unregister_pernet_subsys(&ndisc_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898}