blob: c467c6419893cddf845448c0e34eec37455a55ff [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * Neighbour Discovery for IPv6
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09004 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09007 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * Mike Shaver <shaver@ingenia.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 */
10
11/*
12 * Changes:
13 *
Alexey I. Froloffe35f30c2012-04-06 05:50:58 +000014 * Alexey I. Froloff : RFC6106 (DNSSL) support
Pierre Ynard31910572007-10-10 21:22:05 -070015 * Pierre Ynard : export userland ND options
16 * through netlink (RDNSS support)
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 * Lars Fenneberg : fixed MTU setting on receipt
18 * of an RA.
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 * Janos Farkas : kmalloc failure checks
20 * Alexey Kuznetsov : state machine reworked
21 * and moved to net/core.
22 * Pekka Savola : RFC2461 validation
23 * YOSHIFUJI Hideaki @USAGI : Verify ND options properly
24 */
25
Joe Perches675418d2012-05-16 19:28:38 +000026#define pr_fmt(fmt) "ICMPv6: " fmt
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
28#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/errno.h>
30#include <linux/types.h>
31#include <linux/socket.h>
32#include <linux/sockios.h>
33#include <linux/sched.h>
34#include <linux/net.h>
35#include <linux/in6.h>
36#include <linux/route.h>
37#include <linux/init.h>
38#include <linux/rcupdate.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090039#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#ifdef CONFIG_SYSCTL
41#include <linux/sysctl.h>
42#endif
43
Thomas Graf18237302006-08-04 23:04:54 -070044#include <linux/if_addr.h>
Vishwanath Paida13c592017-10-30 19:38:52 -040045#include <linux/if_ether.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <linux/if_arp.h>
47#include <linux/ipv6.h>
48#include <linux/icmpv6.h>
49#include <linux/jhash.h>
50
51#include <net/sock.h>
52#include <net/snmp.h>
53
54#include <net/ipv6.h>
55#include <net/protocol.h>
56#include <net/ndisc.h>
57#include <net/ip6_route.h>
58#include <net/addrconf.h>
59#include <net/icmp.h>
60
Pierre Ynard31910572007-10-10 21:22:05 -070061#include <net/netlink.h>
62#include <linux/rtnetlink.h>
63
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#include <net/flow.h>
65#include <net/ip6_checksum.h>
Denis V. Lunev1ed85162008-04-03 14:31:03 -070066#include <net/inet_common.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <linux/proc_fs.h>
68
69#include <linux/netfilter.h>
70#include <linux/netfilter_ipv6.h>
71
Eric Dumazetd6bf7812010-10-04 06:15:44 +000072static u32 ndisc_hash(const void *pkey,
73 const struct net_device *dev,
David S. Miller2c2aba62011-12-28 15:06:58 -050074 __u32 *hash_rnd);
Eric W. Biederman60395a22015-03-03 17:10:44 -060075static bool ndisc_key_eq(const struct neighbour *neigh, const void *pkey);
David Ahernb8fb1ab2019-04-16 17:31:43 -070076static bool ndisc_allow_add(const struct net_device *dev,
77 struct netlink_ext_ack *extack);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078static int ndisc_constructor(struct neighbour *neigh);
79static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
80static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
81static int pndisc_constructor(struct pneigh_entry *n);
82static void pndisc_destructor(struct pneigh_entry *n);
83static void pndisc_redo(struct sk_buff *skb);
Jeff Dike8cf88212020-11-12 20:58:15 -050084static int ndisc_is_multicast(const void *pkey);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
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,
Jeff Dike8cf88212020-11-12 20:58:15 -0500119 .is_multicast = ndisc_is_multicast,
David Ahernb8fb1ab2019-04-16 17:31:43 -0700120 .allow_add = ndisc_allow_add,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 .id = "ndisc_cache",
122 .parms = {
Shan Weib6720832010-12-01 18:05:12 +0000123 .tbl = &nd_tbl,
Shan Weib6720832010-12-01 18:05:12 +0000124 .reachable_time = ND_REACHABLE_TIME,
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100125 .data = {
126 [NEIGH_VAR_MCAST_PROBES] = 3,
127 [NEIGH_VAR_UCAST_PROBES] = 3,
128 [NEIGH_VAR_RETRANS_TIME] = ND_RETRANS_TIMER,
129 [NEIGH_VAR_BASE_REACHABLE_TIME] = ND_REACHABLE_TIME,
130 [NEIGH_VAR_DELAY_PROBE_TIME] = 5 * HZ,
131 [NEIGH_VAR_GC_STALETIME] = 60 * HZ,
Eric Dumazeteaa72dc2017-08-29 15:16:01 -0700132 [NEIGH_VAR_QUEUE_LEN_BYTES] = SK_WMEM_MAX,
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100133 [NEIGH_VAR_PROXY_QLEN] = 64,
134 [NEIGH_VAR_ANYCAST_DELAY] = 1 * HZ,
135 [NEIGH_VAR_PROXY_DELAY] = (8 * HZ) / 10,
136 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 },
138 .gc_interval = 30 * HZ,
139 .gc_thresh1 = 128,
140 .gc_thresh2 = 512,
141 .gc_thresh3 = 1024,
142};
David Ahernc4850682015-10-12 11:47:08 -0700143EXPORT_SYMBOL_GPL(nd_tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Alexander Aringcc84b3c2016-06-15 21:20:24 +0200145void __ndisc_fill_addr_option(struct sk_buff *skb, int type, void *data,
146 int data_len, int pad)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
Alexander Aring8ec5da42016-06-15 21:20:21 +0200148 int space = __ndisc_opt_addr_space(data_len, pad);
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +0000149 u8 *opt = skb_put(skb, space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
151 opt[0] = type;
152 opt[1] = space>>3;
153
154 memset(opt + 2, 0, pad);
155 opt += pad;
156 space -= pad;
157
158 memcpy(opt+2, data, data_len);
159 data_len += 2;
160 opt += data_len;
Ian Morrise5d08d72014-11-23 21:28:43 +0000161 space -= data_len;
162 if (space > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 memset(opt, 0, space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164}
Alexander Aringcc84b3c2016-06-15 21:20:24 +0200165EXPORT_SYMBOL_GPL(__ndisc_fill_addr_option);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Alexander Aring8ec5da42016-06-15 21:20:21 +0200167static inline void ndisc_fill_addr_option(struct sk_buff *skb, int type,
Alexander Aringf997c552016-06-15 21:20:23 +0200168 void *data, u8 icmp6_type)
Alexander Aring8ec5da42016-06-15 21:20:21 +0200169{
170 __ndisc_fill_addr_option(skb, type, data, skb->dev->addr_len,
171 ndisc_addr_option_pad(skb->dev->type));
Alexander Aringf997c552016-06-15 21:20:23 +0200172 ndisc_ops_fill_addr_option(skb->dev, skb, icmp6_type);
173}
174
175static inline void ndisc_fill_redirect_addr_option(struct sk_buff *skb,
176 void *ha,
177 const u8 *ops_data)
178{
179 ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR, ha, NDISC_REDIRECT);
180 ndisc_ops_fill_redirect_addr_option(skb->dev, skb, ops_data);
Alexander Aring8ec5da42016-06-15 21:20:21 +0200181}
182
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
184 struct nd_opt_hdr *end)
185{
186 int type;
187 if (!cur || !end || cur >= end)
188 return NULL;
189 type = cur->nd_opt_type;
190 do {
191 cur = ((void *)cur) + (cur->nd_opt_len << 3);
Ian Morris67ba4152014-08-24 21:53:10 +0100192 } while (cur < end && cur->nd_opt_type != type);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000193 return cur <= end && cur->nd_opt_type == type ? cur : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194}
195
Alexander Aringf997c552016-06-15 21:20:23 +0200196static inline int ndisc_is_useropt(const struct net_device *dev,
197 struct nd_opt_hdr *opt)
Pierre Ynard31910572007-10-10 21:22:05 -0700198{
Alexey I. Froloffe35f30c2012-04-06 05:50:58 +0000199 return opt->nd_opt_type == ND_OPT_RDNSS ||
Alexander Aringf997c552016-06-15 21:20:23 +0200200 opt->nd_opt_type == ND_OPT_DNSSL ||
Maciej Żenczykowski66b5f1c2019-07-18 23:30:03 -0700201 opt->nd_opt_type == ND_OPT_CAPTIVE_PORTAL ||
Maciej Żenczykowskic24a77e2020-03-23 18:10:19 -0700202 opt->nd_opt_type == ND_OPT_PREF64 ||
Alexander Aringf997c552016-06-15 21:20:23 +0200203 ndisc_ops_is_useropt(dev, opt->nd_opt_type);
Pierre Ynard31910572007-10-10 21:22:05 -0700204}
205
Alexander Aringf997c552016-06-15 21:20:23 +0200206static struct nd_opt_hdr *ndisc_next_useropt(const struct net_device *dev,
207 struct nd_opt_hdr *cur,
Pierre Ynard31910572007-10-10 21:22:05 -0700208 struct nd_opt_hdr *end)
209{
210 if (!cur || !end || cur >= end)
211 return NULL;
212 do {
213 cur = ((void *)cur) + (cur->nd_opt_len << 3);
Alexander Aringf997c552016-06-15 21:20:23 +0200214 } while (cur < end && !ndisc_is_useropt(dev, cur));
215 return cur <= end && ndisc_is_useropt(dev, cur) ? cur : NULL;
Pierre Ynard31910572007-10-10 21:22:05 -0700216}
217
Alexander Aringf997c552016-06-15 21:20:23 +0200218struct ndisc_options *ndisc_parse_options(const struct net_device *dev,
219 u8 *opt, int opt_len,
David S. Miller30f2a5f2012-07-11 23:26:46 -0700220 struct ndisc_options *ndopts)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221{
222 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
223
224 if (!nd_opt || opt_len < 0 || !ndopts)
225 return NULL;
226 memset(ndopts, 0, sizeof(*ndopts));
227 while (opt_len) {
228 int l;
229 if (opt_len < sizeof(struct nd_opt_hdr))
230 return NULL;
231 l = nd_opt->nd_opt_len << 3;
232 if (opt_len < l || l == 0)
233 return NULL;
Alexander Aringf997c552016-06-15 21:20:23 +0200234 if (ndisc_ops_parse_options(dev, nd_opt, ndopts))
235 goto next_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 switch (nd_opt->nd_opt_type) {
237 case ND_OPT_SOURCE_LL_ADDR:
238 case ND_OPT_TARGET_LL_ADDR:
239 case ND_OPT_MTU:
Erik Nordmarkadc176c2016-12-02 14:00:08 -0800240 case ND_OPT_NONCE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 case ND_OPT_REDIRECT_HDR:
242 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
Joe Perches675418d2012-05-16 19:28:38 +0000243 ND_PRINTK(2, warn,
244 "%s: duplicated ND6 option found: type=%d\n",
245 __func__, nd_opt->nd_opt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 } else {
247 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
248 }
249 break;
250 case ND_OPT_PREFIX_INFO:
251 ndopts->nd_opts_pi_end = nd_opt;
Stephen Hemmingercfcabdc2007-10-09 01:59:42 -0700252 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
254 break;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800255#ifdef CONFIG_IPV6_ROUTE_INFO
256 case ND_OPT_ROUTE_INFO:
257 ndopts->nd_opts_ri_end = nd_opt;
258 if (!ndopts->nd_opts_ri)
259 ndopts->nd_opts_ri = nd_opt;
260 break;
261#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 default:
Alexander Aringf997c552016-06-15 21:20:23 +0200263 if (ndisc_is_useropt(dev, nd_opt)) {
Pierre Ynard31910572007-10-10 21:22:05 -0700264 ndopts->nd_useropts_end = nd_opt;
265 if (!ndopts->nd_useropts)
266 ndopts->nd_useropts = nd_opt;
267 } else {
268 /*
269 * Unknown options must be silently ignored,
270 * to accommodate future extension to the
271 * protocol.
272 */
Joe Perches675418d2012-05-16 19:28:38 +0000273 ND_PRINTK(2, notice,
274 "%s: ignored unsupported option; type=%d, len=%d\n",
275 __func__,
276 nd_opt->nd_opt_type,
277 nd_opt->nd_opt_len);
Pierre Ynard31910572007-10-10 21:22:05 -0700278 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 }
Alexander Aringf997c552016-06-15 21:20:23 +0200280next_opt:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 opt_len -= l;
282 nd_opt = ((void *)nd_opt) + l;
283 }
284 return ndopts;
285}
286
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000287int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
289 switch (dev->type) {
290 case ARPHRD_ETHER:
291 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
292 case ARPHRD_FDDI:
293 ipv6_eth_mc_map(addr, buf);
294 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 case ARPHRD_ARCNET:
296 ipv6_arcnet_mc_map(addr, buf);
297 return 0;
298 case ARPHRD_INFINIBAND:
Rolf Manderscheida9e527e2007-12-10 13:38:41 -0700299 ipv6_ib_mc_map(addr, dev->broadcast, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 return 0;
Timo Teräs93ca3bb2011-03-28 22:40:53 +0000301 case ARPHRD_IPGRE:
302 return ipv6_ipgre_mc_map(addr, dev->broadcast, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 default:
304 if (dir) {
305 memcpy(buf, dev->broadcast, dev->addr_len);
306 return 0;
307 }
308 }
309 return -EINVAL;
310}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900311EXPORT_SYMBOL(ndisc_mc_map);
312
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000313static u32 ndisc_hash(const void *pkey,
314 const struct net_device *dev,
David S. Miller2c2aba62011-12-28 15:06:58 -0500315 __u32 *hash_rnd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316{
David S. Miller2c2aba62011-12-28 15:06:58 -0500317 return ndisc_hashfn(pkey, dev, hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318}
319
Eric W. Biederman60395a22015-03-03 17:10:44 -0600320static bool ndisc_key_eq(const struct neighbour *n, const void *pkey)
321{
322 return neigh_key_eq128(n, pkey);
323}
324
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325static int ndisc_constructor(struct neighbour *neigh)
326{
Ian Morris67ba4152014-08-24 21:53:10 +0100327 struct in6_addr *addr = (struct in6_addr *)&neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 struct net_device *dev = neigh->dev;
329 struct inet6_dev *in6_dev;
330 struct neigh_parms *parms;
Eric Dumazeta50feda2012-05-18 18:57:34 +0000331 bool is_multicast = ipv6_addr_is_multicast(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 in6_dev = in6_dev_get(dev);
Ian Morris63159f22015-03-29 14:00:04 +0100334 if (!in6_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 return -EINVAL;
336 }
337
338 parms = in6_dev->nd_parms;
339 __neigh_parms_put(neigh->parms);
340 neigh->parms = neigh_parms_clone(parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
342 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700343 if (!dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 neigh->nud_state = NUD_NOARP;
345 neigh->ops = &ndisc_direct_ops;
David S. Miller8f40b162011-07-17 13:34:11 -0700346 neigh->output = neigh_direct_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 } else {
348 if (is_multicast) {
349 neigh->nud_state = NUD_NOARP;
350 ndisc_mc_map(addr, neigh->ha, dev, 1);
351 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
352 neigh->nud_state = NUD_NOARP;
353 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
354 if (dev->flags&IFF_LOOPBACK)
355 neigh->type = RTN_LOCAL;
356 } else if (dev->flags&IFF_POINTOPOINT) {
357 neigh->nud_state = NUD_NOARP;
358 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
359 }
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700360 if (dev->header_ops->cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 neigh->ops = &ndisc_hh_ops;
362 else
363 neigh->ops = &ndisc_generic_ops;
364 if (neigh->nud_state&NUD_VALID)
365 neigh->output = neigh->ops->connected_output;
366 else
367 neigh->output = neigh->ops->output;
368 }
369 in6_dev_put(in6_dev);
370 return 0;
371}
372
373static int pndisc_constructor(struct pneigh_entry *n)
374{
Ian Morris67ba4152014-08-24 21:53:10 +0100375 struct in6_addr *addr = (struct in6_addr *)&n->key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 struct in6_addr maddr;
377 struct net_device *dev = n->dev;
378
Ian Morris63159f22015-03-29 14:00:04 +0100379 if (!dev || !__in6_dev_get(dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 return -EINVAL;
381 addrconf_addr_solict_mult(addr, &maddr);
382 ipv6_dev_mc_inc(dev, &maddr);
383 return 0;
384}
385
386static void pndisc_destructor(struct pneigh_entry *n)
387{
Ian Morris67ba4152014-08-24 21:53:10 +0100388 struct in6_addr *addr = (struct in6_addr *)&n->key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 struct in6_addr maddr;
390 struct net_device *dev = n->dev;
391
Ian Morris63159f22015-03-29 14:00:04 +0100392 if (!dev || !__in6_dev_get(dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 return;
394 addrconf_addr_solict_mult(addr, &maddr);
395 ipv6_dev_mc_dec(dev, &maddr);
396}
397
David Ahernb8fb1ab2019-04-16 17:31:43 -0700398/* called with rtnl held */
399static bool ndisc_allow_add(const struct net_device *dev,
400 struct netlink_ext_ack *extack)
401{
402 struct inet6_dev *idev = __in6_dev_get(dev);
403
404 if (!idev || idev->cnf.disable_ipv6) {
405 NL_SET_ERR_MSG(extack, "IPv6 is disabled on this device");
406 return false;
407 }
408
409 return true;
410}
411
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000412static struct sk_buff *ndisc_alloc_skb(struct net_device *dev,
413 int len)
414{
415 int hlen = LL_RESERVED_SPACE(dev);
416 int tlen = dev->needed_tailroom;
417 struct sock *sk = dev_net(dev)->ipv6.ndisc_sk;
418 struct sk_buff *skb;
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000419
Thomas Graf25a6e6b2013-09-03 13:37:01 +0200420 skb = alloc_skb(hlen + sizeof(struct ipv6hdr) + len + tlen, GFP_ATOMIC);
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000421 if (!skb) {
Thomas Graf25a6e6b2013-09-03 13:37:01 +0200422 ND_PRINTK(0, err, "ndisc: %s failed to allocate an skb\n",
423 __func__);
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000424 return NULL;
425 }
426
YOSHIFUJI Hideaki / 吉藤英明f382d032013-01-21 06:48:29 +0000427 skb->protocol = htons(ETH_P_IPV6);
428 skb->dev = dev;
429
YOSHIFUJI Hideaki / 吉藤英明527a1502013-01-21 06:48:39 +0000430 skb_reserve(skb, hlen + sizeof(struct ipv6hdr));
YOSHIFUJI Hideaki / 吉藤英明5135e632013-01-21 06:48:44 +0000431 skb_reset_transport_header(skb);
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000432
Thomas Graf25a6e6b2013-09-03 13:37:01 +0200433 /* Manually assign socket ownership as we avoid calling
434 * sock_alloc_send_pskb() to bypass wmem buffer limits
435 */
436 skb_set_owner_w(skb, sk);
437
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000438 return skb;
439}
440
YOSHIFUJI Hideaki / 吉藤英明f382d032013-01-21 06:48:29 +0000441static void ip6_nd_hdr(struct sk_buff *skb,
YOSHIFUJI Hideaki / 吉藤英明2576f17d2013-01-21 06:48:19 +0000442 const struct in6_addr *saddr,
443 const struct in6_addr *daddr,
YOSHIFUJI Hideaki / 吉藤英明c8d6c382013-01-21 06:48:24 +0000444 int hop_limit, int len)
YOSHIFUJI Hideaki / 吉藤英明2576f17d2013-01-21 06:48:19 +0000445{
446 struct ipv6hdr *hdr;
Maciej Żenczykowski2210d6b2017-11-07 21:52:09 -0800447 struct inet6_dev *idev;
448 unsigned tclass;
449
450 rcu_read_lock();
451 idev = __in6_dev_get(skb->dev);
452 tclass = idev ? idev->cnf.ndisc_tclass : 0;
453 rcu_read_unlock();
YOSHIFUJI Hideaki / 吉藤英明2576f17d2013-01-21 06:48:19 +0000454
YOSHIFUJI Hideaki / 吉藤英明527a1502013-01-21 06:48:39 +0000455 skb_push(skb, sizeof(*hdr));
YOSHIFUJI Hideaki / 吉藤英明2576f17d2013-01-21 06:48:19 +0000456 skb_reset_network_header(skb);
YOSHIFUJI Hideaki / 吉藤英明2576f17d2013-01-21 06:48:19 +0000457 hdr = ipv6_hdr(skb);
458
Maciej Żenczykowski2210d6b2017-11-07 21:52:09 -0800459 ip6_flow_hdr(hdr, tclass, 0);
YOSHIFUJI Hideaki / 吉藤英明2576f17d2013-01-21 06:48:19 +0000460
461 hdr->payload_len = htons(len);
YOSHIFUJI Hideaki / 吉藤英明c8d6c382013-01-21 06:48:24 +0000462 hdr->nexthdr = IPPROTO_ICMPV6;
463 hdr->hop_limit = hop_limit;
YOSHIFUJI Hideaki / 吉藤英明2576f17d2013-01-21 06:48:19 +0000464
465 hdr->saddr = *saddr;
466 hdr->daddr = *daddr;
467}
468
YOSHIFUJI Hideaki / 吉藤英明af9a9972013-01-21 06:48:34 +0000469static void ndisc_send_skb(struct sk_buff *skb,
YOSHIFUJI Hideakifd0ea7d2012-12-13 02:40:26 +0900470 const struct in6_addr *daddr,
YOSHIFUJI Hideaki / 吉藤英明aa4bdd42013-01-21 06:48:58 +0000471 const struct in6_addr *saddr)
Brian Haley305d5522008-11-04 17:51:14 -0800472{
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +0000473 struct dst_entry *dst = skb_dst(skb);
YOSHIFUJI Hideaki / 吉藤英明af9a9972013-01-21 06:48:34 +0000474 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideaki / 吉藤英明7b3d9b02013-01-21 06:49:08 +0000475 struct sock *sk = net->ipv6.ndisc_sk;
Brian Haley305d5522008-11-04 17:51:14 -0800476 struct inet6_dev *idev;
477 int err;
YOSHIFUJI Hideaki / 吉藤英明aa4bdd42013-01-21 06:48:58 +0000478 struct icmp6hdr *icmp6h = icmp6_hdr(skb);
Brian Haley305d5522008-11-04 17:51:14 -0800479 u8 type;
480
481 type = icmp6h->icmp6_type;
482
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +0000483 if (!dst) {
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +0000484 struct flowi6 fl6;
David Aherne0d56fd2016-09-10 12:09:57 -0700485 int oif = skb->dev->ifindex;
Brian Haley305d5522008-11-04 17:51:14 -0800486
David Ahernca254492015-10-12 11:47:10 -0700487 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, oif);
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +0000488 dst = icmp6_dst_alloc(skb->dev, &fl6);
489 if (IS_ERR(dst)) {
490 kfree_skb(skb);
491 return;
492 }
493
494 skb_dst_set(skb, dst);
495 }
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900496
YOSHIFUJI Hideaki / 吉藤英明7b3d9b02013-01-21 06:49:08 +0000497 icmp6h->icmp6_cksum = csum_ipv6_magic(saddr, daddr, skb->len,
498 IPPROTO_ICMPV6,
499 csum_partial(icmp6h,
500 skb->len, 0));
501
502 ip6_nd_hdr(skb, saddr, daddr, inet6_sk(sk)->hop_limit, skb->len);
503
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000504 rcu_read_lock();
505 idev = __in6_dev_get(dst->dev);
Neil Hormanedf391f2009-04-27 02:45:02 -0700506 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900507
Eric W. Biederman29a26a52015-09-15 20:04:16 -0500508 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT,
509 net, sk, skb, NULL, dst->dev,
Eric W. Biederman13206b62015-10-07 16:48:35 -0500510 dst_output);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900511 if (!err) {
Denis V. Lunev5c5d2442008-10-08 10:33:50 -0700512 ICMP6MSGOUT_INC_STATS(net, idev, type);
Denis V. Luneva862f6a2008-10-08 10:33:06 -0700513 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900514 }
515
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000516 rcu_read_unlock();
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900517}
518
Jiri Benc38cf5952015-09-22 18:57:13 +0200519void ndisc_send_na(struct net_device *dev, const struct in6_addr *daddr,
Cong Wangf564f452013-08-31 13:44:36 +0800520 const struct in6_addr *solicited_addr,
521 bool router, bool solicited, bool override, bool inc_opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522{
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000523 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 struct in6_addr tmpaddr;
525 struct inet6_ifaddr *ifp;
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900526 const struct in6_addr *src_addr;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000527 struct nd_msg *msg;
528 int optlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
530 /* for anycast or proxy, solicited_addr != src_addr */
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900531 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900532 if (ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 src_addr = solicited_addr;
Neil Horman95c385b2007-04-25 17:08:10 -0700534 if (ifp->flags & IFA_F_OPTIMISTIC)
Daniel Balutaf2f79cc2013-07-13 11:26:51 +0300535 override = false;
stephen hemminger9f888162010-06-21 11:00:13 +0000536 inc_opt |= ifp->idev->cnf.force_tllao;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 in6_ifa_put(ifp);
538 } else {
Brian Haley191cd582008-08-14 15:33:21 -0700539 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900540 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
YOSHIFUJI Hideaki7cbca672008-03-25 09:37:42 +0900541 &tmpaddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 return;
543 src_addr = &tmpaddr;
544 }
545
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000546 if (!dev->addr_len)
Gustavo A. R. Silva9a21ac942018-03-05 16:11:54 -0600547 inc_opt = false;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000548 if (inc_opt)
Alexander Aringf997c552016-06-15 21:20:23 +0200549 optlen += ndisc_opt_addr_space(dev,
550 NDISC_NEIGHBOUR_ADVERTISEMENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000552 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000553 if (!skb)
554 return;
555
Johannes Berg4df864c2017-06-16 14:29:21 +0200556 msg = skb_put(skb, sizeof(*msg));
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000557 *msg = (struct nd_msg) {
558 .icmph = {
559 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
560 .icmp6_router = router,
561 .icmp6_solicited = solicited,
562 .icmp6_override = override,
563 },
564 .target = *solicited_addr,
565 };
566
567 if (inc_opt)
568 ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR,
Alexander Aringf997c552016-06-15 21:20:23 +0200569 dev->dev_addr,
570 NDISC_NEIGHBOUR_ADVERTISEMENT);
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000571
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000572 ndisc_send_skb(skb, daddr, src_addr);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900573}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
Ben Hutchingsf47b9462011-04-15 13:46:02 +0000575static void ndisc_send_unsol_na(struct net_device *dev)
576{
577 struct inet6_dev *idev;
578 struct inet6_ifaddr *ifa;
Ben Hutchingsf47b9462011-04-15 13:46:02 +0000579
580 idev = in6_dev_get(dev);
581 if (!idev)
582 return;
583
584 read_lock_bh(&idev->lock);
585 list_for_each_entry(ifa, &idev->addr_list, if_list) {
David Ahernc76fe2d2018-01-25 20:16:29 -0800586 /* skip tentative addresses until dad completes */
587 if (ifa->flags & IFA_F_TENTATIVE &&
588 !(ifa->flags & IFA_F_OPTIMISTIC))
589 continue;
590
Jiri Benc38cf5952015-09-22 18:57:13 +0200591 ndisc_send_na(dev, &in6addr_linklocal_allnodes, &ifa->addr,
Ben Hutchingsf47b9462011-04-15 13:46:02 +0000592 /*router=*/ !!idev->cnf.forwarding,
593 /*solicited=*/ false, /*override=*/ true,
594 /*inc_opt=*/ true);
595 }
596 read_unlock_bh(&idev->lock);
597
598 in6_dev_put(idev);
599}
600
Jiri Benc38cf5952015-09-22 18:57:13 +0200601void ndisc_send_ns(struct net_device *dev, const struct in6_addr *solicit,
Erik Nordmarkadc176c2016-12-02 14:00:08 -0800602 const struct in6_addr *daddr, const struct in6_addr *saddr,
603 u64 nonce)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604{
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000605 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 struct in6_addr addr_buf;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000607 int inc_opt = dev->addr_len;
608 int optlen = 0;
609 struct nd_msg *msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
Ian Morris63159f22015-03-29 14:00:04 +0100611 if (!saddr) {
Neil Horman95c385b2007-04-25 17:08:10 -0700612 if (ipv6_get_lladdr(dev, &addr_buf,
613 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 return;
615 saddr = &addr_buf;
616 }
617
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000618 if (ipv6_addr_any(saddr))
Daniel Balutaf2f79cc2013-07-13 11:26:51 +0300619 inc_opt = false;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000620 if (inc_opt)
Alexander Aringf997c552016-06-15 21:20:23 +0200621 optlen += ndisc_opt_addr_space(dev,
622 NDISC_NEIGHBOUR_SOLICITATION);
Erik Nordmarkadc176c2016-12-02 14:00:08 -0800623 if (nonce != 0)
624 optlen += 8;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000625
626 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000627 if (!skb)
628 return;
629
Johannes Berg4df864c2017-06-16 14:29:21 +0200630 msg = skb_put(skb, sizeof(*msg));
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000631 *msg = (struct nd_msg) {
632 .icmph = {
633 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
634 },
635 .target = *solicit,
636 };
637
638 if (inc_opt)
639 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
Alexander Aringf997c552016-06-15 21:20:23 +0200640 dev->dev_addr,
641 NDISC_NEIGHBOUR_SOLICITATION);
Erik Nordmarkadc176c2016-12-02 14:00:08 -0800642 if (nonce != 0) {
643 u8 *opt = skb_put(skb, 8);
644
645 opt[0] = ND_OPT_NONCE;
646 opt[1] = 8 >> 3;
647 memcpy(opt + 2, &nonce, 6);
648 }
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000649
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000650 ndisc_send_skb(skb, daddr, saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651}
652
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900653void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
654 const struct in6_addr *daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655{
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000656 struct sk_buff *skb;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000657 struct rs_msg *msg;
Neil Horman95c385b2007-04-25 17:08:10 -0700658 int send_sllao = dev->addr_len;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000659 int optlen = 0;
Neil Horman95c385b2007-04-25 17:08:10 -0700660
661#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
662 /*
663 * According to section 2.2 of RFC 4429, we must not
664 * send router solicitations with a sllao from
665 * optimistic addresses, but we may send the solicitation
666 * if we don't include the sllao. So here we check
667 * if our address is optimistic, and if so, we
Joe Perchesbea85192007-12-20 14:01:35 -0800668 * suppress the inclusion of the sllao.
Neil Horman95c385b2007-04-25 17:08:10 -0700669 */
670 if (send_sllao) {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900671 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
Daniel Lezcano1cab3da2008-01-10 22:44:09 -0800672 dev, 1);
Neil Horman95c385b2007-04-25 17:08:10 -0700673 if (ifp) {
674 if (ifp->flags & IFA_F_OPTIMISTIC) {
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900675 send_sllao = 0;
Neil Horman95c385b2007-04-25 17:08:10 -0700676 }
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900677 in6_ifa_put(ifp);
Neil Horman95c385b2007-04-25 17:08:10 -0700678 } else {
679 send_sllao = 0;
680 }
681 }
682#endif
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000683 if (send_sllao)
Alexander Aringf997c552016-06-15 21:20:23 +0200684 optlen += ndisc_opt_addr_space(dev, NDISC_ROUTER_SOLICITATION);
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000685
686 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000687 if (!skb)
688 return;
689
Johannes Berg4df864c2017-06-16 14:29:21 +0200690 msg = skb_put(skb, sizeof(*msg));
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000691 *msg = (struct rs_msg) {
692 .icmph = {
693 .icmp6_type = NDISC_ROUTER_SOLICITATION,
694 },
695 };
696
697 if (send_sllao)
698 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
Alexander Aringf997c552016-06-15 21:20:23 +0200699 dev->dev_addr,
700 NDISC_ROUTER_SOLICITATION);
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000701
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000702 ndisc_send_skb(skb, daddr, saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900704
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
706static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
707{
708 /*
709 * "The sender MUST return an ICMP
710 * destination unreachable"
711 */
712 dst_link_failure(skb);
713 kfree_skb(skb);
714}
715
716/* Called with locked neigh: either read or both */
717
718static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
719{
720 struct in6_addr *saddr = NULL;
721 struct in6_addr mcaddr;
722 struct net_device *dev = neigh->dev;
723 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
724 int probes = atomic_read(&neigh->probes);
725
Erik Klinec58da4c2015-02-04 20:01:23 +0900726 if (skb && ipv6_chk_addr_and_flags(dev_net(dev), &ipv6_hdr(skb)->saddr,
David Ahern232378e2018-03-13 08:29:37 -0700727 dev, false, 1,
Erik Klinec58da4c2015-02-04 20:01:23 +0900728 IFA_F_TENTATIVE|IFA_F_OPTIMISTIC))
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700729 saddr = &ipv6_hdr(skb)->saddr;
Ian Morrise5d08d72014-11-23 21:28:43 +0000730 probes -= NEIGH_VAR(neigh->parms, UCAST_PROBES);
731 if (probes < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 if (!(neigh->nud_state & NUD_VALID)) {
Joe Perches675418d2012-05-16 19:28:38 +0000733 ND_PRINTK(1, dbg,
734 "%s: trying to ucast probe in NUD_INVALID: %pI6\n",
735 __func__, target);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 }
Erik Nordmarkadc176c2016-12-02 14:00:08 -0800737 ndisc_send_ns(dev, target, target, saddr, 0);
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100738 } else if ((probes -= NEIGH_VAR(neigh->parms, APP_PROBES)) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 neigh_app_ns(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 } else {
741 addrconf_addr_solict_mult(target, &mcaddr);
Erik Nordmarkadc176c2016-12-02 14:00:08 -0800742 ndisc_send_ns(dev, target, &mcaddr, saddr, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 }
744}
745
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900746static int pndisc_is_router(const void *pkey,
747 struct net_device *dev)
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700748{
749 struct pneigh_entry *n;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900750 int ret = -1;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700751
752 read_lock_bh(&nd_tbl.lock);
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900753 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
754 if (n)
755 ret = !!(n->flags & NTF_ROUTER);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700756 read_unlock_bh(&nd_tbl.lock);
757
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900758 return ret;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700759}
760
Alexander Aringf997c552016-06-15 21:20:23 +0200761void ndisc_update(const struct net_device *dev, struct neighbour *neigh,
762 const u8 *lladdr, u8 new, u32 flags, u8 icmp6_type,
763 struct ndisc_options *ndopts)
764{
Roopa Prabhu7b8f7a42017-03-19 22:01:28 -0700765 neigh_update(neigh, lladdr, new, flags, 0);
Alexander Aringf997c552016-06-15 21:20:23 +0200766 /* report ndisc ops about neighbour update */
767 ndisc_ops_update(dev, neigh, flags, icmp6_type, ndopts);
768}
769
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770static void ndisc_recv_ns(struct sk_buff *skb)
771{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700772 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000773 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
774 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 u8 *lladdr = NULL;
Simon Horman29a3cad2013-05-28 20:34:26 +0000776 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700777 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 struct ndisc_options ndopts;
779 struct net_device *dev = skb->dev;
780 struct inet6_ifaddr *ifp;
781 struct inet6_dev *idev = NULL;
782 struct neighbour *neigh;
783 int dad = ipv6_addr_any(saddr);
Eric Dumazeta50feda2012-05-18 18:57:34 +0000784 bool inc;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900785 int is_router = -1;
Erik Nordmarkadc176c2016-12-02 14:00:08 -0800786 u64 nonce = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
YOSHIFUJI Hideaki / 吉藤英明115b0aa2013-01-18 02:05:03 +0000788 if (skb->len < sizeof(struct nd_msg)) {
789 ND_PRINTK(2, warn, "NS: packet too short\n");
790 return;
791 }
792
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 if (ipv6_addr_is_multicast(&msg->target)) {
Joe Perches675418d2012-05-16 19:28:38 +0000794 ND_PRINTK(2, warn, "NS: multicast target address\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 return;
796 }
797
798 /*
799 * RFC2461 7.1.1:
800 * DAD has to be destined for solicited node multicast address.
801 */
YOSHIFUJI Hideaki / 吉藤英明ca97a642013-01-20 07:39:00 +0000802 if (dad && !ipv6_addr_is_solict_mult(daddr)) {
Joe Perches675418d2012-05-16 19:28:38 +0000803 ND_PRINTK(2, warn, "NS: bad DAD packet (wrong destination)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 return;
805 }
806
Alexander Aringf997c552016-06-15 21:20:23 +0200807 if (!ndisc_parse_options(dev, msg->opt, ndoptlen, &ndopts)) {
Joe Perches675418d2012-05-16 19:28:38 +0000808 ND_PRINTK(2, warn, "NS: invalid ND options\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 return;
810 }
811
812 if (ndopts.nd_opts_src_lladdr) {
813 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
814 if (!lladdr) {
Joe Perches675418d2012-05-16 19:28:38 +0000815 ND_PRINTK(2, warn,
816 "NS: invalid link-layer address length\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 return;
818 }
819
820 /* RFC2461 7.1.1:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900821 * If the IP source address is the unspecified address,
822 * there MUST NOT be source link-layer address option
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 * in the message.
824 */
825 if (dad) {
Joe Perches675418d2012-05-16 19:28:38 +0000826 ND_PRINTK(2, warn,
827 "NS: bad DAD packet (link-layer address option)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 return;
829 }
830 }
Sabrina Dubrocae6651592018-07-13 17:21:42 +0200831 if (ndopts.nd_opts_nonce && ndopts.nd_opts_nonce->nd_opt_len == 1)
Erik Nordmarkadc176c2016-12-02 14:00:08 -0800832 memcpy(&nonce, (u8 *)(ndopts.nd_opts_nonce + 1), 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 inc = ipv6_addr_is_multicast(daddr);
835
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900836 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800837 if (ifp) {
David Ahernca254492015-10-12 11:47:10 -0700838have_ifp:
Neil Horman95c385b2007-04-25 17:08:10 -0700839 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
840 if (dad) {
Erik Nordmarkadc176c2016-12-02 14:00:08 -0800841 if (nonce != 0 && ifp->dad_nonce == nonce) {
842 u8 *np = (u8 *)&nonce;
843 /* Matching nonce if looped back */
844 ND_PRINTK(2, notice,
845 "%s: IPv6 DAD loopback for address %pI6c nonce %pM ignored\n",
846 ifp->idev->dev->name,
847 &ifp->addr, np);
848 goto out;
849 }
Neil Horman95c385b2007-04-25 17:08:10 -0700850 /*
851 * We are colliding with another node
852 * who is doing DAD
853 * so fail our DAD process
854 */
Vishwanath Paida13c592017-10-30 19:38:52 -0400855 addrconf_dad_failure(skb, ifp);
Denis V. Lunev9e3be4b2007-09-11 11:04:49 +0200856 return;
Neil Horman95c385b2007-04-25 17:08:10 -0700857 } else {
858 /*
859 * This is not a dad solicitation.
860 * If we are an optimistic node,
861 * we should respond.
862 * Otherwise, we should ignore it.
863 */
864 if (!(ifp->flags & IFA_F_OPTIMISTIC))
865 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 }
868
869 idev = ifp->idev;
870 } else {
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700871 struct net *net = dev_net(dev);
872
David Ahernca254492015-10-12 11:47:10 -0700873 /* perhaps an address on the master device */
874 if (netif_is_l3_slave(dev)) {
875 struct net_device *mdev;
876
877 mdev = netdev_master_upper_dev_get_rcu(dev);
878 if (mdev) {
879 ifp = ipv6_get_ifaddr(net, &msg->target, mdev, 1);
880 if (ifp)
881 goto have_ifp;
882 }
883 }
884
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 idev = in6_dev_get(dev);
886 if (!idev) {
887 /* XXX: count this drop? */
888 return;
889 }
890
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700891 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900892 (idev->cnf.forwarding &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700893 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900894 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700895 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 skb->pkt_type != PACKET_HOST &&
Daniel Balutaf2f79cc2013-07-13 11:26:51 +0300897 inc &&
Jiri Pirko1f9248e2013-12-07 19:26:53 +0100898 NEIGH_VAR(idev->nd_parms, PROXY_DELAY) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 /*
900 * for anycast or proxy,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900901 * sender should delay its response
902 * by a random time between 0 and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 * MAX_ANYCAST_DELAY_TIME seconds.
904 * (RFC2461) -- yoshfuji
905 */
906 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
907 if (n)
908 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
909 goto out;
910 }
911 } else
912 goto out;
913 }
914
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900915 if (is_router < 0)
YOSHIFUJI Hideaki / 吉藤英明fb568632013-01-20 07:39:18 +0000916 is_router = idev->cnf.forwarding;
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700917
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 if (dad) {
Jiri Benc38cf5952015-09-22 18:57:13 +0200919 ndisc_send_na(dev, &in6addr_linklocal_allnodes, &msg->target,
YOSHIFUJI Hideaki / 吉藤英明fb568632013-01-20 07:39:18 +0000920 !!is_router, false, (ifp != NULL), true);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 goto out;
922 }
923
924 if (inc)
925 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
926 else
927 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
928
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900929 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 * update / create cache entry
931 * for the source address
932 */
933 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
934 !inc || lladdr || !dev->addr_len);
935 if (neigh)
Alexander Aringf997c552016-06-15 21:20:23 +0200936 ndisc_update(dev, neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 NEIGH_UPDATE_F_WEAK_OVERRIDE|
Alexander Aringf997c552016-06-15 21:20:23 +0200938 NEIGH_UPDATE_F_OVERRIDE,
939 NDISC_NEIGHBOUR_SOLICITATION, &ndopts);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700940 if (neigh || !dev->header_ops) {
Jiri Benc38cf5952015-09-22 18:57:13 +0200941 ndisc_send_na(dev, saddr, &msg->target, !!is_router,
YOSHIFUJI Hideaki / 吉藤英明fb568632013-01-20 07:39:18 +0000942 true, (ifp != NULL && inc), inc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 if (neigh)
944 neigh_release(neigh);
945 }
946
947out:
948 if (ifp)
949 in6_ifa_put(ifp);
950 else
951 in6_dev_put(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952}
953
954static void ndisc_recv_na(struct sk_buff *skb)
955{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700956 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Duan Jiongbe7a0102014-05-15 15:56:14 +0800957 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000958 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 u8 *lladdr = NULL;
Simon Horman29a3cad2013-05-28 20:34:26 +0000960 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700961 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 struct ndisc_options ndopts;
963 struct net_device *dev = skb->dev;
Johannes Berg7a02bf82016-02-04 13:31:20 +0100964 struct inet6_dev *idev = __in6_dev_get(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 struct inet6_ifaddr *ifp;
966 struct neighbour *neigh;
967
968 if (skb->len < sizeof(struct nd_msg)) {
Joe Perches675418d2012-05-16 19:28:38 +0000969 ND_PRINTK(2, warn, "NA: packet too short\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 return;
971 }
972
973 if (ipv6_addr_is_multicast(&msg->target)) {
Joe Perches675418d2012-05-16 19:28:38 +0000974 ND_PRINTK(2, warn, "NA: target address is multicast\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 return;
976 }
977
978 if (ipv6_addr_is_multicast(daddr) &&
979 msg->icmph.icmp6_solicited) {
Joe Perches675418d2012-05-16 19:28:38 +0000980 ND_PRINTK(2, warn, "NA: solicited NA is multicasted\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 return;
982 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900983
Johannes Berg7a02bf82016-02-04 13:31:20 +0100984 /* For some 802.11 wireless deployments (and possibly other networks),
985 * there will be a NA proxy and unsolicitd packets are attacks
986 * and thus should not be accepted.
987 */
988 if (!msg->icmph.icmp6_solicited && idev &&
989 idev->cnf.drop_unsolicited_na)
990 return;
991
Alexander Aringf997c552016-06-15 21:20:23 +0200992 if (!ndisc_parse_options(dev, msg->opt, ndoptlen, &ndopts)) {
Joe Perches675418d2012-05-16 19:28:38 +0000993 ND_PRINTK(2, warn, "NS: invalid ND option\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 return;
995 }
996 if (ndopts.nd_opts_tgt_lladdr) {
997 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
998 if (!lladdr) {
Joe Perches675418d2012-05-16 19:28:38 +0000999 ND_PRINTK(2, warn,
1000 "NA: invalid link-layer address length\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 return;
1002 }
1003 }
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001004 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -08001005 if (ifp) {
Daniel Walterbd015922011-04-13 21:09:25 +00001006 if (skb->pkt_type != PACKET_LOOPBACK
1007 && (ifp->flags & IFA_F_TENTATIVE)) {
Vishwanath Paida13c592017-10-30 19:38:52 -04001008 addrconf_dad_failure(skb, ifp);
Daniel Walterbd015922011-04-13 21:09:25 +00001009 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 }
1011 /* What should we make now? The advertisement
1012 is invalid, but ndisc specs say nothing
1013 about it. It could be misconfiguration, or
1014 an smart proxy agent tries to help us :-)
Jan Sembera24fc7b82008-12-09 15:48:32 -08001015
1016 We should not print the error if NA has been
1017 received from loopback - it is just our own
1018 unsolicited advertisement.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 */
Jan Sembera24fc7b82008-12-09 15:48:32 -08001020 if (skb->pkt_type != PACKET_LOOPBACK)
Joe Perches675418d2012-05-16 19:28:38 +00001021 ND_PRINTK(1, warn,
Vishwanath Paida13c592017-10-30 19:38:52 -04001022 "NA: %pM advertised our address %pI6c on %s!\n",
1023 eth_hdr(skb)->h_source, &ifp->addr, ifp->idev->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 in6_ifa_put(ifp);
1025 return;
1026 }
1027 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
1028
1029 if (neigh) {
1030 u8 old_flags = neigh->flags;
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -07001031 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032
1033 if (neigh->nud_state & NUD_FAILED)
1034 goto out;
1035
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -07001036 /*
1037 * Don't update the neighbor cache entry on a proxy NA from
1038 * ourselves because either the proxied node is off link or it
1039 * has already sent a NA to us.
1040 */
1041 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -07001042 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
1043 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
Nicolas Dichtelb20b6d92012-11-07 05:05:38 +00001044 /* XXX: idev->cnf.proxy_ndp */
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -07001045 goto out;
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -07001046 }
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -07001047
Alexander Aringf997c552016-06-15 21:20:23 +02001048 ndisc_update(dev, neigh, lladdr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
1050 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1051 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
1052 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
Alexander Aringf997c552016-06-15 21:20:23 +02001053 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0),
1054 NDISC_NEIGHBOUR_ADVERTISEMENT, &ndopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055
1056 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
1057 /*
1058 * Change: router to host
1059 */
Duan Jiongbe7a0102014-05-15 15:56:14 +08001060 rt6_clean_tohost(dev_net(dev), saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 }
1062
1063out:
1064 neigh_release(neigh);
1065 }
1066}
1067
1068static void ndisc_recv_rs(struct sk_buff *skb)
1069{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001070 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1072 struct neighbour *neigh;
1073 struct inet6_dev *idev;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001074 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 struct ndisc_options ndopts;
1076 u8 *lladdr = NULL;
1077
1078 if (skb->len < sizeof(*rs_msg))
1079 return;
1080
Eric Dumazetcfdf7642011-07-27 21:13:03 +00001081 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 if (!idev) {
Joe Perches675418d2012-05-16 19:28:38 +00001083 ND_PRINTK(1, err, "RS: can't find in6 device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 return;
1085 }
1086
1087 /* Don't accept RS if we're not in router mode */
1088 if (!idev->cnf.forwarding)
1089 goto out;
1090
1091 /*
1092 * Don't update NCE if src = ::;
1093 * this implies that the source node has no ip address assigned yet.
1094 */
1095 if (ipv6_addr_any(saddr))
1096 goto out;
1097
1098 /* Parse ND options */
Alexander Aringf997c552016-06-15 21:20:23 +02001099 if (!ndisc_parse_options(skb->dev, rs_msg->opt, ndoptlen, &ndopts)) {
Joe Perches675418d2012-05-16 19:28:38 +00001100 ND_PRINTK(2, notice, "NS: invalid ND option, ignored\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 goto out;
1102 }
1103
1104 if (ndopts.nd_opts_src_lladdr) {
1105 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1106 skb->dev);
1107 if (!lladdr)
1108 goto out;
1109 }
1110
1111 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1112 if (neigh) {
Alexander Aringf997c552016-06-15 21:20:23 +02001113 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1115 NEIGH_UPDATE_F_OVERRIDE|
Alexander Aringf997c552016-06-15 21:20:23 +02001116 NEIGH_UPDATE_F_OVERRIDE_ISROUTER,
1117 NDISC_ROUTER_SOLICITATION, &ndopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 neigh_release(neigh);
1119 }
1120out:
Eric Dumazetcfdf7642011-07-27 21:13:03 +00001121 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122}
1123
Pierre Ynard31910572007-10-10 21:22:05 -07001124static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1125{
1126 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1127 struct sk_buff *skb;
1128 struct nlmsghdr *nlh;
1129 struct nduseroptmsg *ndmsg;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001130 struct net *net = dev_net(ra->dev);
Pierre Ynard31910572007-10-10 21:22:05 -07001131 int err;
1132 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1133 + (opt->nd_opt_len << 3));
1134 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1135
1136 skb = nlmsg_new(msg_size, GFP_ATOMIC);
Ian Morris63159f22015-03-29 14:00:04 +01001137 if (!skb) {
Pierre Ynard31910572007-10-10 21:22:05 -07001138 err = -ENOBUFS;
1139 goto errout;
1140 }
1141
1142 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
Ian Morris63159f22015-03-29 14:00:04 +01001143 if (!nlh) {
Pierre Ynard31910572007-10-10 21:22:05 -07001144 goto nla_put_failure;
1145 }
1146
1147 ndmsg = nlmsg_data(nlh);
1148 ndmsg->nduseropt_family = AF_INET6;
Pierre Ynarddbb2ed22007-11-12 17:58:35 -08001149 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
Pierre Ynard31910572007-10-10 21:22:05 -07001150 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1151 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1152 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1153
1154 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1155
Jiri Benc930345e2015-03-29 16:59:25 +02001156 if (nla_put_in6_addr(skb, NDUSEROPT_SRCADDR, &ipv6_hdr(ra)->saddr))
David S. Millerc78679e2012-04-01 20:27:33 -04001157 goto nla_put_failure;
Pierre Ynard31910572007-10-10 21:22:05 -07001158 nlmsg_end(skb, nlh);
1159
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001160 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
Pierre Ynard31910572007-10-10 21:22:05 -07001161 return;
1162
1163nla_put_failure:
1164 nlmsg_free(skb);
1165 err = -EMSGSIZE;
1166errout:
Daniel Lezcanoa18bc692008-03-07 11:14:49 -08001167 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
Pierre Ynard31910572007-10-10 21:22:05 -07001168}
1169
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170static void ndisc_router_discovery(struct sk_buff *skb)
1171{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001172 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 struct neighbour *neigh = NULL;
1174 struct inet6_dev *in6_dev;
David Ahern8d1c8022018-04-17 17:33:26 -07001175 struct fib6_info *rt = NULL;
Praveen Chaudhary6b2e04b2021-01-25 13:44:30 -08001176 u32 defrtr_usr_metric;
David Ahernafb1d4b52018-04-17 17:33:11 -07001177 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 int lifetime;
1179 struct ndisc_options ndopts;
1180 int optlen;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001181 unsigned int pref = 0;
Marius Tomaschewskia394eef2015-08-31 15:59:22 +02001182 __u32 old_if_flags;
Marius Tomaschewski2053aeb2015-09-01 01:57:30 +02001183 bool send_ifinfo_notify = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184
Ian Morris67ba4152014-08-24 21:53:10 +01001185 __u8 *opt = (__u8 *)(ra_msg + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
Simon Horman29a3cad2013-05-28 20:34:26 +00001187 optlen = (skb_tail_pointer(skb) - skb_transport_header(skb)) -
1188 sizeof(struct ra_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
Ben Greearf2a762d2014-06-25 14:44:52 -07001190 ND_PRINTK(2, info,
1191 "RA: %s, dev: %s\n",
1192 __func__, skb->dev->name);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001193 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Joe Perches675418d2012-05-16 19:28:38 +00001194 ND_PRINTK(2, warn, "RA: source address is not link-local\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 return;
1196 }
1197 if (optlen < 0) {
Joe Perches675418d2012-05-16 19:28:38 +00001198 ND_PRINTK(2, warn, "RA: packet too short\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 return;
1200 }
1201
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001202#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001203 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
Joe Perches675418d2012-05-16 19:28:38 +00001204 ND_PRINTK(2, warn, "RA: from host or unauthorized router\n");
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001205 return;
1206 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001207#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001208
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 /*
1210 * set the RA_RECV flag in the interface
1211 */
1212
Eric Dumazetcfdf7642011-07-27 21:13:03 +00001213 in6_dev = __in6_dev_get(skb->dev);
Ian Morris63159f22015-03-29 14:00:04 +01001214 if (!in6_dev) {
Joe Perches675418d2012-05-16 19:28:38 +00001215 ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n",
1216 skb->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 return;
1218 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219
Alexander Aringf997c552016-06-15 21:20:23 +02001220 if (!ndisc_parse_options(skb->dev, opt, optlen, &ndopts)) {
Joe Perches675418d2012-05-16 19:28:38 +00001221 ND_PRINTK(2, warn, "RA: invalid ND options\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 return;
1223 }
1224
Ben Greearf2a762d2014-06-25 14:44:52 -07001225 if (!ipv6_accept_ra(in6_dev)) {
1226 ND_PRINTK(2, info,
1227 "RA: %s, did not accept ra for dev: %s\n",
1228 __func__, skb->dev->name);
David Ward31ce8c72009-08-29 00:04:09 -07001229 goto skip_linkparms;
Ben Greearf2a762d2014-06-25 14:44:52 -07001230 }
David Ward31ce8c72009-08-29 00:04:09 -07001231
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001232#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001233 /* skip link-specific parameters from interior routers */
Ben Greearf2a762d2014-06-25 14:44:52 -07001234 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) {
1235 ND_PRINTK(2, info,
1236 "RA: %s, nodetype is NODEFAULT, dev: %s\n",
1237 __func__, skb->dev->name);
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001238 goto skip_linkparms;
Ben Greearf2a762d2014-06-25 14:44:52 -07001239 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001240#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001241
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 if (in6_dev->if_flags & IF_RS_SENT) {
1243 /*
1244 * flag that an RA was received after an RS was sent
1245 * out on this interface.
1246 */
1247 in6_dev->if_flags |= IF_RA_RCVD;
1248 }
1249
1250 /*
1251 * Remember the managed/otherconf flags from most recently
1252 * received RA message (RFC 2462) -- yoshfuji
1253 */
Marius Tomaschewskia394eef2015-08-31 15:59:22 +02001254 old_if_flags = in6_dev->if_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1256 IF_RA_OTHERCONF)) |
1257 (ra_msg->icmph.icmp6_addrconf_managed ?
1258 IF_RA_MANAGED : 0) |
1259 (ra_msg->icmph.icmp6_addrconf_other ?
1260 IF_RA_OTHERCONF : 0);
1261
Marius Tomaschewskia394eef2015-08-31 15:59:22 +02001262 if (old_if_flags != in6_dev->if_flags)
Marius Tomaschewski2053aeb2015-09-01 01:57:30 +02001263 send_ifinfo_notify = true;
Marius Tomaschewskia394eef2015-08-31 15:59:22 +02001264
Ben Greearf2a762d2014-06-25 14:44:52 -07001265 if (!in6_dev->cnf.accept_ra_defrtr) {
1266 ND_PRINTK(2, info,
1267 "RA: %s, defrtr is false for dev: %s\n",
1268 __func__, skb->dev->name);
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001269 goto skip_defrtr;
Ben Greearf2a762d2014-06-25 14:44:52 -07001270 }
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001271
Ben Greeard9333192014-06-25 14:44:53 -07001272 /* Do not accept RA with source-addr found on local machine unless
1273 * accept_ra_from_local is set to true.
1274 */
David Ahernafb1d4b52018-04-17 17:33:11 -07001275 net = dev_net(in6_dev->dev);
Li RongQingb6428812014-07-10 18:02:46 +08001276 if (!in6_dev->cnf.accept_ra_from_local &&
David Ahernafb1d4b52018-04-17 17:33:11 -07001277 ipv6_chk_addr(net, &ipv6_hdr(skb)->saddr, in6_dev->dev, 0)) {
Ben Greearf2a762d2014-06-25 14:44:52 -07001278 ND_PRINTK(2, info,
Ben Greeard9333192014-06-25 14:44:53 -07001279 "RA from local address detected on dev: %s: default router ignored\n",
1280 skb->dev->name);
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001281 goto skip_defrtr;
Ben Greearf2a762d2014-06-25 14:44:52 -07001282 }
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001283
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1285
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001286#ifdef CONFIG_IPV6_ROUTER_PREF
1287 pref = ra_msg->icmph.icmp6_router_pref;
1288 /* 10b is handled as if it were 00b (medium) */
YOSHIFUJI Hideaki930d6ff2006-03-20 17:05:30 -08001289 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
YOSHIFUJI Hideaki6d5b78c2007-06-22 16:07:04 -07001290 !in6_dev->cnf.accept_ra_rtr_pref)
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001291 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1292#endif
David Ahernf88d8ea2019-06-03 20:19:52 -07001293 /* routes added from RAs do not use nexthop objects */
David Ahernafb1d4b52018-04-17 17:33:11 -07001294 rt = rt6_get_dflt_router(net, &ipv6_hdr(skb)->saddr, skb->dev);
David S. Millereb857182012-01-27 15:07:56 -08001295 if (rt) {
David Ahern1cf844c2019-05-22 20:27:59 -07001296 neigh = ip6_neigh_lookup(&rt->fib6_nh->fib_nh_gw6,
1297 rt->fib6_nh->fib_nh_dev, NULL,
David Ahernf8a1b432018-04-17 17:33:21 -07001298 &ipv6_hdr(skb)->saddr);
David S. Millereb857182012-01-27 15:07:56 -08001299 if (!neigh) {
Joe Perches675418d2012-05-16 19:28:38 +00001300 ND_PRINTK(0, err,
1301 "RA: %s got default router without neighbour\n",
1302 __func__);
David Ahern93531c62018-04-17 17:33:25 -07001303 fib6_info_release(rt);
David S. Millereb857182012-01-27 15:07:56 -08001304 return;
1305 }
1306 }
Praveen Chaudhary6b2e04b2021-01-25 13:44:30 -08001307 /* Set default route metric as specified by user */
1308 defrtr_usr_metric = in6_dev->cnf.ra_defrtr_metric;
1309 /* delete the route if lifetime is 0 or if metric needs change */
1310 if (rt && (lifetime == 0 || rt->fib6_metric != defrtr_usr_metric)) {
Roopa Prabhu11dd74b2020-04-27 13:56:45 -07001311 ip6_del_rt(net, rt, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 rt = NULL;
1313 }
1314
Praveen Chaudhary6b2e04b2021-01-25 13:44:30 -08001315 ND_PRINTK(3, info, "RA: rt: %p lifetime: %d, metric: %d, for dev: %s\n",
1316 rt, lifetime, defrtr_usr_metric, skb->dev->name);
Ian Morris63159f22015-03-29 14:00:04 +01001317 if (!rt && lifetime) {
Ben Greearf2a762d2014-06-25 14:44:52 -07001318 ND_PRINTK(3, info, "RA: adding default router\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
David Ahernafb1d4b52018-04-17 17:33:11 -07001320 rt = rt6_add_dflt_router(net, &ipv6_hdr(skb)->saddr,
Praveen Chaudhary6b2e04b2021-01-25 13:44:30 -08001321 skb->dev, pref, defrtr_usr_metric);
Ian Morris63159f22015-03-29 14:00:04 +01001322 if (!rt) {
Joe Perches675418d2012-05-16 19:28:38 +00001323 ND_PRINTK(0, err,
1324 "RA: %s failed to add default route\n",
1325 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 return;
1327 }
1328
David Ahern1cf844c2019-05-22 20:27:59 -07001329 neigh = ip6_neigh_lookup(&rt->fib6_nh->fib_nh_gw6,
1330 rt->fib6_nh->fib_nh_dev, NULL,
David Ahernf8a1b432018-04-17 17:33:21 -07001331 &ipv6_hdr(skb)->saddr);
Ian Morris63159f22015-03-29 14:00:04 +01001332 if (!neigh) {
Joe Perches675418d2012-05-16 19:28:38 +00001333 ND_PRINTK(0, err,
1334 "RA: %s got default router without neighbour\n",
1335 __func__);
David Ahern93531c62018-04-17 17:33:25 -07001336 fib6_info_release(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 return;
1338 }
1339 neigh->flags |= NTF_ROUTER;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001340 } else if (rt) {
David Ahern93c2fb22018-04-18 15:38:59 -07001341 rt->fib6_flags = (rt->fib6_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 }
1343
1344 if (rt)
David Ahern14895682018-04-17 17:33:17 -07001345 fib6_set_expires(rt, jiffies + (HZ * lifetime));
Hangbin Liu8013d1d2015-07-30 14:28:42 +08001346 if (in6_dev->cnf.accept_ra_min_hop_limit < 256 &&
1347 ra_msg->icmph.icmp6_hop_limit) {
1348 if (in6_dev->cnf.accept_ra_min_hop_limit <= ra_msg->icmph.icmp6_hop_limit) {
D.S. Ljungmark6fd99092015-03-25 09:28:15 +01001349 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
David Ahernd4ead6b2018-04-17 17:33:16 -07001350 fib6_metric_set(rt, RTAX_HOPLIMIT,
1351 ra_msg->icmph.icmp6_hop_limit);
D.S. Ljungmark6fd99092015-03-25 09:28:15 +01001352 } else {
Hangbin Liu8013d1d2015-07-30 14:28:42 +08001353 ND_PRINTK(2, warn, "RA: Got route advertisement with lower hop_limit than minimum\n");
D.S. Ljungmark6fd99092015-03-25 09:28:15 +01001354 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 }
1356
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001357skip_defrtr:
1358
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 /*
1360 * Update Reachable Time and Retrans Timer
1361 */
1362
1363 if (in6_dev->nd_parms) {
1364 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1365
1366 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1367 rtime = (rtime*HZ)/1000;
Hangbin Liu19e16d22020-04-01 14:46:20 +08001368 if (rtime < HZ/100)
1369 rtime = HZ/100;
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001370 NEIGH_VAR_SET(in6_dev->nd_parms, RETRANS_TIME, rtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 in6_dev->tstamp = jiffies;
Marius Tomaschewski2053aeb2015-09-01 01:57:30 +02001372 send_ifinfo_notify = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 }
1374
1375 rtime = ntohl(ra_msg->reachable_time);
1376 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1377 rtime = (rtime*HZ)/1000;
1378
1379 if (rtime < HZ/10)
1380 rtime = HZ/10;
1381
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001382 if (rtime != NEIGH_VAR(in6_dev->nd_parms, BASE_REACHABLE_TIME)) {
1383 NEIGH_VAR_SET(in6_dev->nd_parms,
1384 BASE_REACHABLE_TIME, rtime);
1385 NEIGH_VAR_SET(in6_dev->nd_parms,
1386 GC_STALETIME, 3 * rtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1388 in6_dev->tstamp = jiffies;
Marius Tomaschewski2053aeb2015-09-01 01:57:30 +02001389 send_ifinfo_notify = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 }
1391 }
1392 }
1393
Marius Tomaschewski2053aeb2015-09-01 01:57:30 +02001394 /*
1395 * Send a notify if RA changed managed/otherconf flags or timer settings
1396 */
1397 if (send_ifinfo_notify)
1398 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1399
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001400skip_linkparms:
1401
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 /*
1403 * Process options.
1404 */
1405
1406 if (!neigh)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001407 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 skb->dev, 1);
1409 if (neigh) {
1410 u8 *lladdr = NULL;
1411 if (ndopts.nd_opts_src_lladdr) {
1412 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1413 skb->dev);
1414 if (!lladdr) {
Joe Perches675418d2012-05-16 19:28:38 +00001415 ND_PRINTK(2, warn,
1416 "RA: invalid link-layer address length\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 goto out;
1418 }
1419 }
Alexander Aringf997c552016-06-15 21:20:23 +02001420 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1422 NEIGH_UPDATE_F_OVERRIDE|
1423 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
Alexander Aringf997c552016-06-15 21:20:23 +02001424 NEIGH_UPDATE_F_ISROUTER,
1425 NDISC_ROUTER_ADVERTISEMENT, &ndopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 }
1427
Ben Greearf2a762d2014-06-25 14:44:52 -07001428 if (!ipv6_accept_ra(in6_dev)) {
1429 ND_PRINTK(2, info,
1430 "RA: %s, accept_ra is false for dev: %s\n",
1431 __func__, skb->dev->name);
David Ward31ce8c72009-08-29 00:04:09 -07001432 goto out;
Ben Greearf2a762d2014-06-25 14:44:52 -07001433 }
David Ward31ce8c72009-08-29 00:04:09 -07001434
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001435#ifdef CONFIG_IPV6_ROUTE_INFO
Li RongQingb6428812014-07-10 18:02:46 +08001436 if (!in6_dev->cnf.accept_ra_from_local &&
1437 ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr,
Hannes Frederic Sowac1a9a292015-12-23 22:44:37 +01001438 in6_dev->dev, 0)) {
Ben Greearf2a762d2014-06-25 14:44:52 -07001439 ND_PRINTK(2, info,
Ben Greeard9333192014-06-25 14:44:53 -07001440 "RA from local address detected on dev: %s: router info ignored.\n",
1441 skb->dev->name);
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001442 goto skip_routeinfo;
Ben Greearf2a762d2014-06-25 14:44:52 -07001443 }
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001444
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001445 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001446 struct nd_opt_hdr *p;
1447 for (p = ndopts.nd_opts_ri;
1448 p;
1449 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
YOSHIFUJI Hideaki6294e002008-03-15 23:56:52 -04001450 struct route_info *ri = (struct route_info *)p;
1451#ifdef CONFIG_IPV6_NDISC_NODETYPE
1452 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1453 ri->prefix_len == 0)
1454 continue;
1455#endif
Duan Jiong30e56912013-11-26 15:46:56 +08001456 if (ri->prefix_len == 0 &&
1457 !in6_dev->cnf.accept_ra_defrtr)
1458 continue;
Joel Scherpelzbbea1242017-03-22 18:19:04 +09001459 if (ri->prefix_len < in6_dev->cnf.accept_ra_rt_info_min_plen)
1460 continue;
YOSHIFUJI Hideaki6294e002008-03-15 23:56:52 -04001461 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001462 continue;
Ian Morris67ba4152014-08-24 21:53:10 +01001463 rt6_route_rcv(skb->dev, (u8 *)p, (p->nd_opt_len) << 3,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001464 &ipv6_hdr(skb)->saddr);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001465 }
1466 }
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001467
1468skip_routeinfo:
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001469#endif
1470
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001471#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001472 /* skip link-specific ndopts from interior routers */
Ben Greearf2a762d2014-06-25 14:44:52 -07001473 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) {
1474 ND_PRINTK(2, info,
1475 "RA: %s, nodetype is NODEFAULT (interior routes), dev: %s\n",
1476 __func__, skb->dev->name);
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001477 goto out;
Ben Greearf2a762d2014-06-25 14:44:52 -07001478 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001479#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001480
YOSHIFUJI Hideakic4fd30e2006-03-20 16:55:26 -08001481 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 struct nd_opt_hdr *p;
1483 for (p = ndopts.nd_opts_pi;
1484 p;
1485 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
Neil Hormane6bff992012-01-04 10:49:15 +00001486 addrconf_prefix_rcv(skb->dev, (u8 *)p,
1487 (p->nd_opt_len) << 3,
1488 ndopts.nd_opts_src_lladdr != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 }
1490 }
1491
Harout Hedeshianc2943f12015-01-20 10:06:05 -07001492 if (ndopts.nd_opts_mtu && in6_dev->cnf.accept_ra_mtu) {
Al Viroe69a4ad2006-11-14 20:56:00 -08001493 __be32 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 u32 mtu;
1495
Ian Morris67ba4152014-08-24 21:53:10 +01001496 memcpy(&n, ((u8 *)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
Al Viroe69a4ad2006-11-14 20:56:00 -08001497 mtu = ntohl(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498
1499 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
Joe Perches675418d2012-05-16 19:28:38 +00001500 ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 } else if (in6_dev->cnf.mtu6 != mtu) {
1502 in6_dev->cnf.mtu6 = mtu;
David Ahernd4ead6b2018-04-17 17:33:16 -07001503 fib6_metric_set(rt, RTAX_MTU, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 rt6_mtu_change(skb->dev, mtu);
1505 }
1506 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001507
Pierre Ynard31910572007-10-10 21:22:05 -07001508 if (ndopts.nd_useropts) {
YOSHIFUJI Hideaki61cf46ad2008-01-22 17:32:53 +09001509 struct nd_opt_hdr *p;
1510 for (p = ndopts.nd_useropts;
1511 p;
Alexander Aringf997c552016-06-15 21:20:23 +02001512 p = ndisc_next_useropt(skb->dev, p,
1513 ndopts.nd_useropts_end)) {
YOSHIFUJI Hideaki61cf46ad2008-01-22 17:32:53 +09001514 ndisc_ra_useropt(skb, p);
Pierre Ynard31910572007-10-10 21:22:05 -07001515 }
1516 }
1517
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
Joe Perches675418d2012-05-16 19:28:38 +00001519 ND_PRINTK(2, warn, "RA: invalid RA options\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 }
1521out:
David Ahern93531c62018-04-17 17:33:25 -07001522 fib6_info_release(rt);
David S. Millereb857182012-01-27 15:07:56 -08001523 if (neigh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525}
1526
1527static void ndisc_redirect_rcv(struct sk_buff *skb)
1528{
Duan Jiong093d04d2012-12-14 02:59:59 +00001529 u8 *hdr;
1530 struct ndisc_options ndopts;
1531 struct rd_msg *msg = (struct rd_msg *)skb_transport_header(skb);
Simon Horman29a3cad2013-05-28 20:34:26 +00001532 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
Duan Jiong093d04d2012-12-14 02:59:59 +00001533 offsetof(struct rd_msg, opt));
1534
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001535#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001536 switch (skb->ndisc_nodetype) {
1537 case NDISC_NODETYPE_HOST:
1538 case NDISC_NODETYPE_NODEFAULT:
Joe Perches675418d2012-05-16 19:28:38 +00001539 ND_PRINTK(2, warn,
1540 "Redirect: from host or unauthorized router\n");
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001541 return;
1542 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001543#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001544
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001545 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Joe Perches675418d2012-05-16 19:28:38 +00001546 ND_PRINTK(2, warn,
1547 "Redirect: source address is not link-local\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 return;
1549 }
1550
Alexander Aringf997c552016-06-15 21:20:23 +02001551 if (!ndisc_parse_options(skb->dev, msg->opt, ndoptlen, &ndopts))
Duan Jiong093d04d2012-12-14 02:59:59 +00001552 return;
1553
Duan Jiongc92a59e2013-08-22 12:07:35 +08001554 if (!ndopts.nd_opts_rh) {
Duan Jiongb55b76b2013-09-04 19:44:21 +08001555 ip6_redirect_no_header(skb, dev_net(skb->dev),
Maciej Żenczykowskid4563362018-09-29 23:44:50 -07001556 skb->dev->ifindex);
Duan Jiong093d04d2012-12-14 02:59:59 +00001557 return;
Duan Jiongc92a59e2013-08-22 12:07:35 +08001558 }
Duan Jiong093d04d2012-12-14 02:59:59 +00001559
1560 hdr = (u8 *)ndopts.nd_opts_rh;
1561 hdr += 8;
1562 if (!pskb_pull(skb, hdr - skb_transport_header(skb)))
1563 return;
1564
David S. Millerb94f1c02012-07-12 00:33:37 -07001565 icmpv6_notify(skb, NDISC_REDIRECT, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566}
1567
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +00001568static void ndisc_fill_redirect_hdr_option(struct sk_buff *skb,
1569 struct sk_buff *orig_skb,
1570 int rd_len)
YOSHIFUJI Hideaki / 吉藤英明9c86daf2013-01-21 06:48:09 +00001571{
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +00001572 u8 *opt = skb_put(skb, rd_len);
1573
YOSHIFUJI Hideaki / 吉藤英明9c86daf2013-01-21 06:48:09 +00001574 memset(opt, 0, 8);
1575 *(opt++) = ND_OPT_REDIRECT_HDR;
1576 *(opt++) = (rd_len >> 3);
1577 opt += 6;
1578
Lorenzo Bianconi9f62c152018-03-08 17:00:02 +01001579 skb_copy_bits(orig_skb, skb_network_offset(orig_skb), opt,
1580 rd_len - 8);
YOSHIFUJI Hideaki / 吉藤英明9c86daf2013-01-21 06:48:09 +00001581}
1582
David S. Miller49919692012-01-27 15:30:48 -08001583void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584{
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001585 struct net_device *dev = skb->dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001586 struct net *net = dev_net(dev);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001587 struct sock *sk = net->ipv6.ndisc_sk;
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001588 int optlen = 0;
David S. Millerfbfe95a2012-06-08 23:24:18 -07001589 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 struct sk_buff *buff;
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001591 struct rd_msg *msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 struct in6_addr saddr_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 struct rt6_info *rt;
1594 struct dst_entry *dst;
David S. Miller4c9483b2011-03-12 16:22:43 -05001595 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 int rd_len;
Alexander Aringf997c552016-06-15 21:20:23 +02001597 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL,
1598 ops_data_buf[NDISC_OPS_REDIRECT_DATA_SPACE], *ops_data = NULL;
David S. Miller1d861aa2012-07-10 03:58:16 -07001599 bool ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600
Stephen Suryaputra2f17bec2018-06-01 00:05:21 -04001601 if (netif_is_l3_master(skb->dev)) {
1602 dev = __dev_get_by_index(dev_net(skb->dev), IPCB(skb)->iif);
1603 if (!dev)
1604 return;
1605 }
1606
Neil Horman95c385b2007-04-25 17:08:10 -07001607 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
Joe Perches675418d2012-05-16 19:28:38 +00001608 ND_PRINTK(2, warn, "Redirect: no link-local address on %s\n",
1609 dev->name);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001610 return;
1611 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001613 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
Brian Haleybf0b48d2007-10-08 00:12:05 -07001614 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
Joe Perches675418d2012-05-16 19:28:38 +00001615 ND_PRINTK(2, warn,
1616 "Redirect: target address is not link-local unicast\n");
Li Yewang29556522007-01-30 14:33:20 -08001617 return;
1618 }
1619
David S. Miller4c9483b2011-03-12 16:22:43 -05001620 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
David Aherne0d56fd2016-09-10 12:09:57 -07001621 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622
David S. Miller4c9483b2011-03-12 16:22:43 -05001623 dst = ip6_route_output(net, NULL, &fl6);
RongQing.Li5095d642012-02-21 22:10:49 +00001624 if (dst->error) {
1625 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 return;
RongQing.Li5095d642012-02-21 22:10:49 +00001627 }
David S. Miller4c9483b2011-03-12 16:22:43 -05001628 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
David S. Miller452edd52011-03-02 13:27:41 -08001629 if (IS_ERR(dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631
1632 rt = (struct rt6_info *) dst;
1633
1634 if (rt->rt6i_flags & RTF_GATEWAY) {
Joe Perches675418d2012-05-16 19:28:38 +00001635 ND_PRINTK(2, warn,
1636 "Redirect: destination is not a neighbour\n");
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001637 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 }
Martin KaFai Laufd0273d2015-05-22 20:55:57 -07001639 peer = inet_getpeer_v6(net->ipv6.peers, &ipv6_hdr(skb)->saddr, 1);
David S. Miller1d861aa2012-07-10 03:58:16 -07001640 ret = inet_peer_xrlim_allow(peer, 1*HZ);
1641 if (peer)
1642 inet_putpeer(peer);
1643 if (!ret)
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001644 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645
1646 if (dev->addr_len) {
David S. Miller49919692012-01-27 15:30:48 -08001647 struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target);
1648 if (!neigh) {
Joe Perches675418d2012-05-16 19:28:38 +00001649 ND_PRINTK(2, warn,
1650 "Redirect: no neigh for target address\n");
David S. Miller49919692012-01-27 15:30:48 -08001651 goto release;
1652 }
1653
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 read_lock_bh(&neigh->lock);
1655 if (neigh->nud_state & NUD_VALID) {
1656 memcpy(ha_buf, neigh->ha, dev->addr_len);
1657 read_unlock_bh(&neigh->lock);
1658 ha = ha_buf;
Alexander Aringf997c552016-06-15 21:20:23 +02001659 optlen += ndisc_redirect_opt_addr_space(dev, neigh,
1660 ops_data_buf,
1661 &ops_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 } else
1663 read_unlock_bh(&neigh->lock);
David S. Miller49919692012-01-27 15:30:48 -08001664
1665 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 }
1667
1668 rd_len = min_t(unsigned int,
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001669 IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(*msg) - optlen,
1670 skb->len + 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 rd_len &= ~0x7;
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001672 optlen += rd_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001674 buff = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +00001675 if (!buff)
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001676 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
Johannes Berg4df864c2017-06-16 14:29:21 +02001678 msg = skb_put(buff, sizeof(*msg));
YOSHIFUJI Hideaki / 吉藤英明4d5c1522013-01-21 06:49:25 +00001679 *msg = (struct rd_msg) {
1680 .icmph = {
1681 .icmp6_type = NDISC_REDIRECT,
1682 },
1683 .target = *target,
1684 .dest = ipv6_hdr(skb)->daddr,
1685 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 /*
1688 * include target_address option
1689 */
1690
1691 if (ha)
Alexander Aringf997c552016-06-15 21:20:23 +02001692 ndisc_fill_redirect_addr_option(buff, ha, ops_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693
1694 /*
1695 * build redirect option and copy skb over to the new packet.
1696 */
1697
YOSHIFUJI Hideaki / 吉藤英明9c86daf2013-01-21 06:48:09 +00001698 if (rd_len)
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +00001699 ndisc_fill_redirect_hdr_option(buff, skb, rd_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700
Eric Dumazetadf30902009-06-02 05:19:30 +00001701 skb_dst_set(buff, dst);
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +00001702 ndisc_send_skb(buff, &ipv6_hdr(skb)->saddr, &saddr_buf);
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001703 return;
1704
1705release:
1706 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707}
1708
1709static void pndisc_redo(struct sk_buff *skb)
1710{
YOSHIFUJI Hideaki140e26fc2005-10-05 12:11:41 -07001711 ndisc_recv_ns(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 kfree_skb(skb);
1713}
1714
Jeff Dike8cf88212020-11-12 20:58:15 -05001715static int ndisc_is_multicast(const void *pkey)
1716{
1717 return ipv6_addr_is_multicast((struct in6_addr *)pkey);
1718}
1719
Hannes Frederic Sowab800c3b2013-08-27 01:36:51 +02001720static bool ndisc_suppress_frag_ndisc(struct sk_buff *skb)
1721{
1722 struct inet6_dev *idev = __in6_dev_get(skb->dev);
1723
1724 if (!idev)
1725 return true;
1726 if (IP6CB(skb)->flags & IP6SKB_FRAGMENTED &&
1727 idev->cnf.suppress_frag_ndisc) {
1728 net_warn_ratelimited("Received fragmented ndisc packet. Carefully consider disabling suppress_frag_ndisc.\n");
1729 return true;
1730 }
1731 return false;
1732}
1733
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734int ndisc_rcv(struct sk_buff *skb)
1735{
1736 struct nd_msg *msg;
1737
Hannes Frederic Sowab800c3b2013-08-27 01:36:51 +02001738 if (ndisc_suppress_frag_ndisc(skb))
1739 return 0;
1740
YOSHIFUJI Hideaki / 吉藤英明6bce6b42013-01-21 06:48:03 +00001741 if (skb_linearize(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 return 0;
1743
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001744 msg = (struct nd_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001746 __skb_push(skb, skb->data - skb_transport_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001748 if (ipv6_hdr(skb)->hop_limit != 255) {
Joe Perches675418d2012-05-16 19:28:38 +00001749 ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n",
1750 ipv6_hdr(skb)->hop_limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 return 0;
1752 }
1753
1754 if (msg->icmph.icmp6_code != 0) {
Joe Perches675418d2012-05-16 19:28:38 +00001755 ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n",
1756 msg->icmph.icmp6_code);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 return 0;
1758 }
1759
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 switch (msg->icmph.icmp6_type) {
1761 case NDISC_NEIGHBOUR_SOLICITATION:
Stefano Brivioee1abcf2018-10-24 14:37:21 +02001762 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 ndisc_recv_ns(skb);
1764 break;
1765
1766 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1767 ndisc_recv_na(skb);
1768 break;
1769
1770 case NDISC_ROUTER_SOLICITATION:
1771 ndisc_recv_rs(skb);
1772 break;
1773
1774 case NDISC_ROUTER_ADVERTISEMENT:
1775 ndisc_router_discovery(skb);
1776 break;
1777
1778 case NDISC_REDIRECT:
1779 ndisc_redirect_rcv(skb);
1780 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001781 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782
1783 return 0;
1784}
1785
1786static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1787{
Jiri Pirko351638e2013-05-28 01:30:21 +00001788 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Eric Dumazetc8507fb2015-07-29 12:01:41 +02001789 struct netdev_notifier_change_info *change_info;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001790 struct net *net = dev_net(dev);
Hannes Frederic Sowa5cb04432012-11-06 16:46:20 +00001791 struct inet6_dev *idev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792
1793 switch (event) {
1794 case NETDEV_CHANGEADDR:
1795 neigh_changeaddr(&nd_tbl, dev);
Michal Kubeček2ac3ac82013-08-01 10:04:14 +02001796 fib6_run_gc(0, net, false);
Joe Perchesa8eceea2020-03-12 15:50:22 -07001797 fallthrough;
David Ahern4a6e3c52017-04-12 11:49:04 -07001798 case NETDEV_UP:
Hannes Frederic Sowa5cb04432012-11-06 16:46:20 +00001799 idev = in6_dev_get(dev);
1800 if (!idev)
1801 break;
David Ahernfc1f8f42017-04-22 09:10:13 -07001802 if (idev->cnf.ndisc_notify ||
1803 net->ipv6.devconf_all->ndisc_notify)
Hannes Frederic Sowa5cb04432012-11-06 16:46:20 +00001804 ndisc_send_unsol_na(dev);
1805 in6_dev_put(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 break;
Eric Dumazetc8507fb2015-07-29 12:01:41 +02001807 case NETDEV_CHANGE:
1808 change_info = ptr;
1809 if (change_info->flags_changed & IFF_NOARP)
1810 neigh_changeaddr(&nd_tbl, dev);
David Ahern859bd2e2018-10-11 20:33:49 -07001811 if (!netif_carrier_ok(dev))
1812 neigh_carrier_down(&nd_tbl, dev);
Eric Dumazetc8507fb2015-07-29 12:01:41 +02001813 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 case NETDEV_DOWN:
1815 neigh_ifdown(&nd_tbl, dev);
Michal Kubeček2ac3ac82013-08-01 10:04:14 +02001816 fib6_run_gc(0, net, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 break;
Ben Hutchingsf47b9462011-04-15 13:46:02 +00001818 case NETDEV_NOTIFY_PEERS:
1819 ndisc_send_unsol_na(dev);
1820 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 default:
1822 break;
1823 }
1824
1825 return NOTIFY_DONE;
1826}
1827
1828static struct notifier_block ndisc_netdev_notifier = {
1829 .notifier_call = ndisc_netdev_event,
David Ahern6eb79392017-08-08 15:51:02 -06001830 .priority = ADDRCONF_NOTIFY_PRIORITY - 5,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831};
1832
1833#ifdef CONFIG_SYSCTL
1834static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1835 const char *func, const char *dev_name)
1836{
1837 static char warncomm[TASK_COMM_LEN];
1838 static int warned;
1839 if (strcmp(warncomm, current->comm) && warned < 5) {
1840 strcpy(warncomm, current->comm);
Joe Perchesf3213832012-05-15 14:11:53 +00001841 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 -07001842 warncomm, func,
1843 dev_name, ctl->procname,
1844 dev_name, ctl->procname);
1845 warned++;
1846 }
1847}
1848
Christoph Hellwig32927392020-04-24 08:43:38 +02001849int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void *buffer,
1850 size_t *lenp, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851{
1852 struct net_device *dev = ctl->extra1;
1853 struct inet6_dev *idev;
1854 int ret;
1855
Eric W. Biedermand12af672007-10-18 03:05:25 -07001856 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1857 (strcmp(ctl->procname, "base_reachable_time") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1859
Eric W. Biedermand12af672007-10-18 03:05:25 -07001860 if (strcmp(ctl->procname, "retrans_time") == 0)
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01001861 ret = neigh_proc_dointvec(ctl, write, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001862
1863 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01001864 ret = neigh_proc_dointvec_jiffies(ctl, write,
1865 buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001866
1867 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
YOSHIFUJI Hideakiad02ac12007-10-29 01:32:23 -07001868 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
Jiri Pirkocb5b09c2013-12-07 19:26:54 +01001869 ret = neigh_proc_dointvec_ms_jiffies(ctl, write,
1870 buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001871 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 ret = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873
1874 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
Jiri Pirko1f9248e2013-12-07 19:26:53 +01001875 if (ctl->data == &NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME))
1876 idev->nd_parms->reachable_time =
1877 neigh_rand_reach_time(NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 idev->tstamp = jiffies;
1879 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1880 in6_dev_put(idev);
1881 }
1882 return ret;
1883}
1884
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885
1886#endif
1887
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001888static int __net_init ndisc_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889{
1890 struct ipv6_pinfo *np;
1891 struct sock *sk;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001892 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001894 err = inet_ctl_sock_create(&sk, PF_INET6,
1895 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 if (err < 0) {
Joe Perches675418d2012-05-16 19:28:38 +00001897 ND_PRINTK(0, err,
1898 "NDISC: Failed to initialize the control socket (err %d)\n",
1899 err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 return err;
1901 }
1902
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001903 net->ipv6.ndisc_sk = sk;
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001904
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 np->hop_limit = 255;
1907 /* Do not loopback ndisc messages */
1908 np->mc_loop = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001910 return 0;
1911}
1912
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001913static void __net_exit ndisc_net_exit(struct net *net)
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001914{
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001915 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001916}
1917
1918static struct pernet_operations ndisc_net_ops = {
1919 .init = ndisc_net_init,
1920 .exit = ndisc_net_exit,
1921};
1922
1923int __init ndisc_init(void)
1924{
1925 int err;
1926
1927 err = register_pernet_subsys(&ndisc_net_ops);
1928 if (err)
1929 return err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001930 /*
1931 * Initialize the neighbour table
1932 */
WANG Congd7480fd2014-11-10 15:59:36 -08001933 neigh_table_init(NEIGH_ND_TABLE, &nd_tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934
1935#ifdef CONFIG_SYSCTL
Jiri Pirko73af6142013-12-07 19:26:55 +01001936 err = neigh_sysctl_register(NULL, &nd_tbl.parms,
Himangi Saraogi56ec0fb2014-07-25 01:49:37 +05301937 ndisc_ifinfo_sysctl_change);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001938 if (err)
1939 goto out_unregister_pernet;
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001940out:
Fabio Estevambcd081a2013-11-16 00:52:08 -02001941#endif
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001942 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001944#ifdef CONFIG_SYSCTL
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001945out_unregister_pernet:
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001946 unregister_pernet_subsys(&ndisc_net_ops);
1947 goto out;
Michal Kubeček2c861cc2013-09-09 21:45:04 +02001948#endif
1949}
1950
1951int __init ndisc_late_init(void)
1952{
1953 return register_netdevice_notifier(&ndisc_netdev_notifier);
1954}
1955
1956void ndisc_late_cleanup(void)
1957{
1958 unregister_netdevice_notifier(&ndisc_netdev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959}
1960
1961void ndisc_cleanup(void)
1962{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963#ifdef CONFIG_SYSCTL
1964 neigh_sysctl_unregister(&nd_tbl.parms);
1965#endif
WANG Congd7480fd2014-11-10 15:59:36 -08001966 neigh_table_clear(NEIGH_ND_TABLE, &nd_tbl);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001967 unregister_pernet_subsys(&ndisc_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968}