blob: 79aa9652ed86d9cac754366c075800fbbe4aca1b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Neighbour Discovery for IPv6
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09003 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09006 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * Mike Shaver <shaver@ingenia.com>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
13 */
14
15/*
16 * Changes:
17 *
Alexey I. Froloffe35f30c2012-04-06 05:50:58 +000018 * Alexey I. Froloff : RFC6106 (DNSSL) support
Pierre Ynard31910572007-10-10 21:22:05 -070019 * Pierre Ynard : export userland ND options
20 * through netlink (RDNSS support)
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 * Lars Fenneberg : fixed MTU setting on receipt
22 * of an RA.
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 * Janos Farkas : kmalloc failure checks
24 * Alexey Kuznetsov : state machine reworked
25 * and moved to net/core.
26 * Pekka Savola : RFC2461 validation
27 * YOSHIFUJI Hideaki @USAGI : Verify ND options properly
28 */
29
Joe Perches675418d2012-05-16 19:28:38 +000030#define pr_fmt(fmt) "ICMPv6: " fmt
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/errno.h>
34#include <linux/types.h>
35#include <linux/socket.h>
36#include <linux/sockios.h>
37#include <linux/sched.h>
38#include <linux/net.h>
39#include <linux/in6.h>
40#include <linux/route.h>
41#include <linux/init.h>
42#include <linux/rcupdate.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090043#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#ifdef CONFIG_SYSCTL
45#include <linux/sysctl.h>
46#endif
47
Thomas Graf18237302006-08-04 23:04:54 -070048#include <linux/if_addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include <linux/if_arp.h>
50#include <linux/ipv6.h>
51#include <linux/icmpv6.h>
52#include <linux/jhash.h>
53
54#include <net/sock.h>
55#include <net/snmp.h>
56
57#include <net/ipv6.h>
58#include <net/protocol.h>
59#include <net/ndisc.h>
60#include <net/ip6_route.h>
61#include <net/addrconf.h>
62#include <net/icmp.h>
63
Pierre Ynard31910572007-10-10 21:22:05 -070064#include <net/netlink.h>
65#include <linux/rtnetlink.h>
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <net/flow.h>
68#include <net/ip6_checksum.h>
Denis V. Lunev1ed85162008-04-03 14:31:03 -070069#include <net/inet_common.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#include <linux/proc_fs.h>
71
72#include <linux/netfilter.h>
73#include <linux/netfilter_ipv6.h>
74
Joe Perches675418d2012-05-16 19:28:38 +000075/* Set to 3 to get tracing... */
76#define ND_DEBUG 1
77
78#define ND_PRINTK(val, level, fmt, ...) \
79do { \
80 if (val <= ND_DEBUG) \
81 net_##level##_ratelimited(fmt, ##__VA_ARGS__); \
82} while (0)
83
Eric Dumazetd6bf7812010-10-04 06:15:44 +000084static u32 ndisc_hash(const void *pkey,
85 const struct net_device *dev,
David S. Miller2c2aba62011-12-28 15:06:58 -050086 __u32 *hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087static int ndisc_constructor(struct neighbour *neigh);
88static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
89static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
90static int pndisc_constructor(struct pneigh_entry *n);
91static void pndisc_destructor(struct pneigh_entry *n);
92static void pndisc_redo(struct sk_buff *skb);
93
Stephen Hemminger89d69d22009-09-01 11:13:19 +000094static const struct neigh_ops ndisc_generic_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_connected_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100};
101
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000102static const struct neigh_ops ndisc_hh_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 .family = AF_INET6,
104 .solicit = ndisc_solicit,
105 .error_report = ndisc_error_report,
106 .output = neigh_resolve_output,
107 .connected_output = neigh_resolve_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108};
109
110
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000111static const struct neigh_ops ndisc_direct_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 .family = AF_INET6,
David S. Miller8f40b162011-07-17 13:34:11 -0700113 .output = neigh_direct_output,
114 .connected_output = neigh_direct_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115};
116
117struct neigh_table nd_tbl = {
118 .family = AF_INET6,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 .key_len = sizeof(struct in6_addr),
120 .hash = ndisc_hash,
121 .constructor = ndisc_constructor,
122 .pconstructor = pndisc_constructor,
123 .pdestructor = pndisc_destructor,
124 .proxy_redo = pndisc_redo,
125 .id = "ndisc_cache",
126 .parms = {
Shan Weib6720832010-12-01 18:05:12 +0000127 .tbl = &nd_tbl,
128 .base_reachable_time = ND_REACHABLE_TIME,
129 .retrans_time = ND_RETRANS_TIMER,
130 .gc_staletime = 60 * HZ,
131 .reachable_time = ND_REACHABLE_TIME,
132 .delay_probe_time = 5 * HZ,
Eric Dumazet8b5c1712011-11-09 12:07:14 +0000133 .queue_len_bytes = 64*1024,
Shan Weib6720832010-12-01 18:05:12 +0000134 .ucast_probes = 3,
135 .mcast_probes = 3,
136 .anycast_delay = 1 * HZ,
137 .proxy_delay = (8 * HZ) / 10,
138 .proxy_qlen = 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 },
140 .gc_interval = 30 * HZ,
141 .gc_thresh1 = 128,
142 .gc_thresh2 = 512,
143 .gc_thresh3 = 1024,
144};
145
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +0000146static void ndisc_fill_addr_option(struct sk_buff *skb, int type, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +0000148 int pad = ndisc_addr_option_pad(skb->dev->type);
149 int data_len = skb->dev->addr_len;
150 int space = ndisc_opt_addr_space(skb->dev);
151 u8 *opt = skb_put(skb, space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153 opt[0] = type;
154 opt[1] = space>>3;
155
156 memset(opt + 2, 0, pad);
157 opt += pad;
158 space -= pad;
159
160 memcpy(opt+2, data, data_len);
161 data_len += 2;
162 opt += data_len;
163 if ((space -= data_len) > 0)
164 memset(opt, 0, space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165}
166
167static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
168 struct nd_opt_hdr *end)
169{
170 int type;
171 if (!cur || !end || cur >= end)
172 return NULL;
173 type = cur->nd_opt_type;
174 do {
175 cur = ((void *)cur) + (cur->nd_opt_len << 3);
176 } while(cur < end && cur->nd_opt_type != type);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000177 return cur <= end && cur->nd_opt_type == type ? cur : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178}
179
Pierre Ynard31910572007-10-10 21:22:05 -0700180static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
181{
Alexey I. Froloffe35f30c2012-04-06 05:50:58 +0000182 return opt->nd_opt_type == ND_OPT_RDNSS ||
183 opt->nd_opt_type == ND_OPT_DNSSL;
Pierre Ynard31910572007-10-10 21:22:05 -0700184}
185
186static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
187 struct nd_opt_hdr *end)
188{
189 if (!cur || !end || cur >= end)
190 return NULL;
191 do {
192 cur = ((void *)cur) + (cur->nd_opt_len << 3);
193 } while(cur < end && !ndisc_is_useropt(cur));
Eric Dumazeta02cec22010-09-22 20:43:57 +0000194 return cur <= end && ndisc_is_useropt(cur) ? cur : NULL;
Pierre Ynard31910572007-10-10 21:22:05 -0700195}
196
David S. Miller30f2a5f2012-07-11 23:26:46 -0700197struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
198 struct ndisc_options *ndopts)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199{
200 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
201
202 if (!nd_opt || opt_len < 0 || !ndopts)
203 return NULL;
204 memset(ndopts, 0, sizeof(*ndopts));
205 while (opt_len) {
206 int l;
207 if (opt_len < sizeof(struct nd_opt_hdr))
208 return NULL;
209 l = nd_opt->nd_opt_len << 3;
210 if (opt_len < l || l == 0)
211 return NULL;
212 switch (nd_opt->nd_opt_type) {
213 case ND_OPT_SOURCE_LL_ADDR:
214 case ND_OPT_TARGET_LL_ADDR:
215 case ND_OPT_MTU:
216 case ND_OPT_REDIRECT_HDR:
217 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
Joe Perches675418d2012-05-16 19:28:38 +0000218 ND_PRINTK(2, warn,
219 "%s: duplicated ND6 option found: type=%d\n",
220 __func__, nd_opt->nd_opt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 } else {
222 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
223 }
224 break;
225 case ND_OPT_PREFIX_INFO:
226 ndopts->nd_opts_pi_end = nd_opt;
Stephen Hemmingercfcabdc2007-10-09 01:59:42 -0700227 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
229 break;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800230#ifdef CONFIG_IPV6_ROUTE_INFO
231 case ND_OPT_ROUTE_INFO:
232 ndopts->nd_opts_ri_end = nd_opt;
233 if (!ndopts->nd_opts_ri)
234 ndopts->nd_opts_ri = nd_opt;
235 break;
236#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 default:
Pierre Ynard31910572007-10-10 21:22:05 -0700238 if (ndisc_is_useropt(nd_opt)) {
239 ndopts->nd_useropts_end = nd_opt;
240 if (!ndopts->nd_useropts)
241 ndopts->nd_useropts = nd_opt;
242 } else {
243 /*
244 * Unknown options must be silently ignored,
245 * to accommodate future extension to the
246 * protocol.
247 */
Joe Perches675418d2012-05-16 19:28:38 +0000248 ND_PRINTK(2, notice,
249 "%s: ignored unsupported option; type=%d, len=%d\n",
250 __func__,
251 nd_opt->nd_opt_type,
252 nd_opt->nd_opt_len);
Pierre Ynard31910572007-10-10 21:22:05 -0700253 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 }
255 opt_len -= l;
256 nd_opt = ((void *)nd_opt) + l;
257 }
258 return ndopts;
259}
260
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000261int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262{
263 switch (dev->type) {
264 case ARPHRD_ETHER:
265 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
266 case ARPHRD_FDDI:
267 ipv6_eth_mc_map(addr, buf);
268 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 case ARPHRD_ARCNET:
270 ipv6_arcnet_mc_map(addr, buf);
271 return 0;
272 case ARPHRD_INFINIBAND:
Rolf Manderscheida9e527e2007-12-10 13:38:41 -0700273 ipv6_ib_mc_map(addr, dev->broadcast, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 return 0;
Timo Teräs93ca3bb2011-03-28 22:40:53 +0000275 case ARPHRD_IPGRE:
276 return ipv6_ipgre_mc_map(addr, dev->broadcast, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 default:
278 if (dir) {
279 memcpy(buf, dev->broadcast, dev->addr_len);
280 return 0;
281 }
282 }
283 return -EINVAL;
284}
285
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900286EXPORT_SYMBOL(ndisc_mc_map);
287
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000288static u32 ndisc_hash(const void *pkey,
289 const struct net_device *dev,
David S. Miller2c2aba62011-12-28 15:06:58 -0500290 __u32 *hash_rnd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291{
David S. Miller2c2aba62011-12-28 15:06:58 -0500292 return ndisc_hashfn(pkey, dev, hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293}
294
295static int ndisc_constructor(struct neighbour *neigh)
296{
297 struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
298 struct net_device *dev = neigh->dev;
299 struct inet6_dev *in6_dev;
300 struct neigh_parms *parms;
Eric Dumazeta50feda2012-05-18 18:57:34 +0000301 bool is_multicast = ipv6_addr_is_multicast(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 in6_dev = in6_dev_get(dev);
304 if (in6_dev == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 return -EINVAL;
306 }
307
308 parms = in6_dev->nd_parms;
309 __neigh_parms_put(neigh->parms);
310 neigh->parms = neigh_parms_clone(parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
312 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700313 if (!dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 neigh->nud_state = NUD_NOARP;
315 neigh->ops = &ndisc_direct_ops;
David S. Miller8f40b162011-07-17 13:34:11 -0700316 neigh->output = neigh_direct_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 } else {
318 if (is_multicast) {
319 neigh->nud_state = NUD_NOARP;
320 ndisc_mc_map(addr, neigh->ha, dev, 1);
321 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
322 neigh->nud_state = NUD_NOARP;
323 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
324 if (dev->flags&IFF_LOOPBACK)
325 neigh->type = RTN_LOCAL;
326 } else if (dev->flags&IFF_POINTOPOINT) {
327 neigh->nud_state = NUD_NOARP;
328 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
329 }
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700330 if (dev->header_ops->cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 neigh->ops = &ndisc_hh_ops;
332 else
333 neigh->ops = &ndisc_generic_ops;
334 if (neigh->nud_state&NUD_VALID)
335 neigh->output = neigh->ops->connected_output;
336 else
337 neigh->output = neigh->ops->output;
338 }
339 in6_dev_put(in6_dev);
340 return 0;
341}
342
343static int pndisc_constructor(struct pneigh_entry *n)
344{
345 struct in6_addr *addr = (struct in6_addr*)&n->key;
346 struct in6_addr maddr;
347 struct net_device *dev = n->dev;
348
349 if (dev == NULL || __in6_dev_get(dev) == NULL)
350 return -EINVAL;
351 addrconf_addr_solict_mult(addr, &maddr);
352 ipv6_dev_mc_inc(dev, &maddr);
353 return 0;
354}
355
356static void pndisc_destructor(struct pneigh_entry *n)
357{
358 struct in6_addr *addr = (struct in6_addr*)&n->key;
359 struct in6_addr maddr;
360 struct net_device *dev = n->dev;
361
362 if (dev == NULL || __in6_dev_get(dev) == NULL)
363 return;
364 addrconf_addr_solict_mult(addr, &maddr);
365 ipv6_dev_mc_dec(dev, &maddr);
366}
367
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000368static struct sk_buff *ndisc_alloc_skb(struct net_device *dev,
369 int len)
370{
371 int hlen = LL_RESERVED_SPACE(dev);
372 int tlen = dev->needed_tailroom;
373 struct sock *sk = dev_net(dev)->ipv6.ndisc_sk;
374 struct sk_buff *skb;
375 int err;
376
377 skb = sock_alloc_send_skb(sk,
378 hlen + sizeof(struct ipv6hdr) + len + tlen,
379 1, &err);
380 if (!skb) {
381 ND_PRINTK(0, err, "ndisc: %s failed to allocate an skb, err=%d\n",
382 __func__, err);
383 return NULL;
384 }
385
YOSHIFUJI Hideaki / 吉藤英明f382d032013-01-21 06:48:29 +0000386 skb->protocol = htons(ETH_P_IPV6);
387 skb->dev = dev;
388
YOSHIFUJI Hideaki / 吉藤英明527a1502013-01-21 06:48:39 +0000389 skb_reserve(skb, hlen + sizeof(struct ipv6hdr));
YOSHIFUJI Hideaki / 吉藤英明5135e632013-01-21 06:48:44 +0000390 skb_reset_transport_header(skb);
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +0000391
392 return skb;
393}
394
YOSHIFUJI Hideaki / 吉藤英明f382d032013-01-21 06:48:29 +0000395static void ip6_nd_hdr(struct sk_buff *skb,
YOSHIFUJI Hideaki / 吉藤英明2576f172013-01-21 06:48:19 +0000396 const struct in6_addr *saddr,
397 const struct in6_addr *daddr,
YOSHIFUJI Hideaki / 吉藤英明c8d6c382013-01-21 06:48:24 +0000398 int hop_limit, int len)
YOSHIFUJI Hideaki / 吉藤英明2576f172013-01-21 06:48:19 +0000399{
400 struct ipv6hdr *hdr;
401
YOSHIFUJI Hideaki / 吉藤英明527a1502013-01-21 06:48:39 +0000402 skb_push(skb, sizeof(*hdr));
YOSHIFUJI Hideaki / 吉藤英明2576f172013-01-21 06:48:19 +0000403 skb_reset_network_header(skb);
YOSHIFUJI Hideaki / 吉藤英明2576f172013-01-21 06:48:19 +0000404 hdr = ipv6_hdr(skb);
405
406 ip6_flow_hdr(hdr, 0, 0);
407
408 hdr->payload_len = htons(len);
YOSHIFUJI Hideaki / 吉藤英明c8d6c382013-01-21 06:48:24 +0000409 hdr->nexthdr = IPPROTO_ICMPV6;
410 hdr->hop_limit = hop_limit;
YOSHIFUJI Hideaki / 吉藤英明2576f172013-01-21 06:48:19 +0000411
412 hdr->saddr = *saddr;
413 hdr->daddr = *daddr;
414}
415
YOSHIFUJI Hideaki / 吉藤英明af9a9972013-01-21 06:48:34 +0000416static void ndisc_send_skb(struct sk_buff *skb,
YOSHIFUJI Hideakifd0ea7d2012-12-13 02:40:26 +0900417 const struct in6_addr *daddr,
YOSHIFUJI Hideaki / 吉藤英明aa4bdd42013-01-21 06:48:58 +0000418 const struct in6_addr *saddr)
Brian Haley305d5522008-11-04 17:51:14 -0800419{
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +0000420 struct dst_entry *dst = skb_dst(skb);
YOSHIFUJI Hideaki / 吉藤英明af9a9972013-01-21 06:48:34 +0000421 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideaki / 吉藤英明7b3d9b02013-01-21 06:49:08 +0000422 struct sock *sk = net->ipv6.ndisc_sk;
Brian Haley305d5522008-11-04 17:51:14 -0800423 struct inet6_dev *idev;
424 int err;
YOSHIFUJI Hideaki / 吉藤英明aa4bdd42013-01-21 06:48:58 +0000425 struct icmp6hdr *icmp6h = icmp6_hdr(skb);
Brian Haley305d5522008-11-04 17:51:14 -0800426 u8 type;
427
428 type = icmp6h->icmp6_type;
429
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +0000430 if (!dst) {
431 struct sock *sk = net->ipv6.ndisc_sk;
432 struct flowi6 fl6;
Brian Haley305d5522008-11-04 17:51:14 -0800433
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +0000434 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, skb->dev->ifindex);
435 dst = icmp6_dst_alloc(skb->dev, &fl6);
436 if (IS_ERR(dst)) {
437 kfree_skb(skb);
438 return;
439 }
440
441 skb_dst_set(skb, dst);
442 }
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900443
YOSHIFUJI Hideaki / 吉藤英明7b3d9b02013-01-21 06:49:08 +0000444 icmp6h->icmp6_cksum = csum_ipv6_magic(saddr, daddr, skb->len,
445 IPPROTO_ICMPV6,
446 csum_partial(icmp6h,
447 skb->len, 0));
448
449 ip6_nd_hdr(skb, saddr, daddr, inet6_sk(sk)->hop_limit, skb->len);
450
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000451 rcu_read_lock();
452 idev = __in6_dev_get(dst->dev);
Neil Hormanedf391f2009-04-27 02:45:02 -0700453 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900454
Jan Engelhardtb2e0b382010-03-23 04:09:07 +0100455 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
Patrick McHardy6e23ae22007-11-19 18:53:30 -0800456 dst_output);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900457 if (!err) {
Denis V. Lunev5c5d2442008-10-08 10:33:50 -0700458 ICMP6MSGOUT_INC_STATS(net, idev, type);
Denis V. Luneva862f6a2008-10-08 10:33:06 -0700459 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900460 }
461
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000462 rcu_read_unlock();
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900463}
464
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900466 const struct in6_addr *daddr,
467 const struct in6_addr *solicited_addr,
YOSHIFUJI Hideaki / 吉藤英明fb568632013-01-20 07:39:18 +0000468 bool router, bool solicited, bool override, bool inc_opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469{
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000470 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 struct in6_addr tmpaddr;
472 struct inet6_ifaddr *ifp;
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900473 const struct in6_addr *src_addr;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000474 struct nd_msg *msg;
475 int optlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
477 /* for anycast or proxy, solicited_addr != src_addr */
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900478 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900479 if (ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 src_addr = solicited_addr;
Neil Horman95c385b2007-04-25 17:08:10 -0700481 if (ifp->flags & IFA_F_OPTIMISTIC)
Daniel Balutaf2f79cc2013-07-13 11:26:51 +0300482 override = false;
stephen hemminger9f888162010-06-21 11:00:13 +0000483 inc_opt |= ifp->idev->cnf.force_tllao;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 in6_ifa_put(ifp);
485 } else {
Brian Haley191cd582008-08-14 15:33:21 -0700486 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900487 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
YOSHIFUJI Hideaki7cbca672008-03-25 09:37:42 +0900488 &tmpaddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 return;
490 src_addr = &tmpaddr;
491 }
492
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000493 if (!dev->addr_len)
494 inc_opt = 0;
495 if (inc_opt)
496 optlen += ndisc_opt_addr_space(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000498 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000499 if (!skb)
500 return;
501
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000502 msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
503 *msg = (struct nd_msg) {
504 .icmph = {
505 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
506 .icmp6_router = router,
507 .icmp6_solicited = solicited,
508 .icmp6_override = override,
509 },
510 .target = *solicited_addr,
511 };
512
513 if (inc_opt)
514 ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR,
515 dev->dev_addr);
516
517
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000518 ndisc_send_skb(skb, daddr, src_addr);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900519}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
Ben Hutchingsf47b9462011-04-15 13:46:02 +0000521static void ndisc_send_unsol_na(struct net_device *dev)
522{
523 struct inet6_dev *idev;
524 struct inet6_ifaddr *ifa;
Ben Hutchingsf47b9462011-04-15 13:46:02 +0000525
526 idev = in6_dev_get(dev);
527 if (!idev)
528 return;
529
530 read_lock_bh(&idev->lock);
531 list_for_each_entry(ifa, &idev->addr_list, if_list) {
YOSHIFUJI Hideaki / 吉藤英明9fafd652012-11-12 07:50:17 +0000532 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &ifa->addr,
Ben Hutchingsf47b9462011-04-15 13:46:02 +0000533 /*router=*/ !!idev->cnf.forwarding,
534 /*solicited=*/ false, /*override=*/ true,
535 /*inc_opt=*/ true);
536 }
537 read_unlock_bh(&idev->lock);
538
539 in6_dev_put(idev);
540}
541
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900543 const struct in6_addr *solicit,
544 const struct in6_addr *daddr, const struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545{
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000546 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 struct in6_addr addr_buf;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000548 int inc_opt = dev->addr_len;
549 int optlen = 0;
550 struct nd_msg *msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
552 if (saddr == NULL) {
Neil Horman95c385b2007-04-25 17:08:10 -0700553 if (ipv6_get_lladdr(dev, &addr_buf,
554 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 return;
556 saddr = &addr_buf;
557 }
558
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000559 if (ipv6_addr_any(saddr))
Daniel Balutaf2f79cc2013-07-13 11:26:51 +0300560 inc_opt = false;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000561 if (inc_opt)
562 optlen += ndisc_opt_addr_space(dev);
563
564 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000565 if (!skb)
566 return;
567
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000568 msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
569 *msg = (struct nd_msg) {
570 .icmph = {
571 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
572 },
573 .target = *solicit,
574 };
575
576 if (inc_opt)
577 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
578 dev->dev_addr);
579
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000580 ndisc_send_skb(skb, daddr, saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581}
582
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900583void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
584 const struct in6_addr *daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000586 struct sk_buff *skb;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000587 struct rs_msg *msg;
Neil Horman95c385b2007-04-25 17:08:10 -0700588 int send_sllao = dev->addr_len;
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000589 int optlen = 0;
Neil Horman95c385b2007-04-25 17:08:10 -0700590
591#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
592 /*
593 * According to section 2.2 of RFC 4429, we must not
594 * send router solicitations with a sllao from
595 * optimistic addresses, but we may send the solicitation
596 * if we don't include the sllao. So here we check
597 * if our address is optimistic, and if so, we
Joe Perchesbea85192007-12-20 14:01:35 -0800598 * suppress the inclusion of the sllao.
Neil Horman95c385b2007-04-25 17:08:10 -0700599 */
600 if (send_sllao) {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900601 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
Daniel Lezcano1cab3da2008-01-10 22:44:09 -0800602 dev, 1);
Neil Horman95c385b2007-04-25 17:08:10 -0700603 if (ifp) {
604 if (ifp->flags & IFA_F_OPTIMISTIC) {
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900605 send_sllao = 0;
Neil Horman95c385b2007-04-25 17:08:10 -0700606 }
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900607 in6_ifa_put(ifp);
Neil Horman95c385b2007-04-25 17:08:10 -0700608 } else {
609 send_sllao = 0;
610 }
611 }
612#endif
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000613 if (send_sllao)
614 optlen += ndisc_opt_addr_space(dev);
615
616 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000617 if (!skb)
618 return;
619
YOSHIFUJI Hideaki / 吉藤英明1cb3fe52013-01-21 06:49:17 +0000620 msg = (struct rs_msg *)skb_put(skb, sizeof(*msg));
621 *msg = (struct rs_msg) {
622 .icmph = {
623 .icmp6_type = NDISC_ROUTER_SOLICITATION,
624 },
625 };
626
627 if (send_sllao)
628 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
629 dev->dev_addr);
630
YOSHIFUJI Hideaki / 吉藤英明b44b5f42013-01-21 06:49:13 +0000631 ndisc_send_skb(skb, daddr, saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900633
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634
635static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
636{
637 /*
638 * "The sender MUST return an ICMP
639 * destination unreachable"
640 */
641 dst_link_failure(skb);
642 kfree_skb(skb);
643}
644
645/* Called with locked neigh: either read or both */
646
647static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
648{
649 struct in6_addr *saddr = NULL;
650 struct in6_addr mcaddr;
651 struct net_device *dev = neigh->dev;
652 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
653 int probes = atomic_read(&neigh->probes);
654
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900655 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700656 saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
658 if ((probes -= neigh->parms->ucast_probes) < 0) {
659 if (!(neigh->nud_state & NUD_VALID)) {
Joe Perches675418d2012-05-16 19:28:38 +0000660 ND_PRINTK(1, dbg,
661 "%s: trying to ucast probe in NUD_INVALID: %pI6\n",
662 __func__, target);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 }
664 ndisc_send_ns(dev, neigh, target, target, saddr);
665 } else if ((probes -= neigh->parms->app_probes) < 0) {
666#ifdef CONFIG_ARPD
667 neigh_app_ns(neigh);
668#endif
669 } else {
670 addrconf_addr_solict_mult(target, &mcaddr);
671 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
672 }
673}
674
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900675static int pndisc_is_router(const void *pkey,
676 struct net_device *dev)
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700677{
678 struct pneigh_entry *n;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900679 int ret = -1;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700680
681 read_lock_bh(&nd_tbl.lock);
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900682 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
683 if (n)
684 ret = !!(n->flags & NTF_ROUTER);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700685 read_unlock_bh(&nd_tbl.lock);
686
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900687 return ret;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700688}
689
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690static void ndisc_recv_ns(struct sk_buff *skb)
691{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700692 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000693 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
694 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 u8 *lladdr = NULL;
Simon Horman29a3cad2013-05-28 20:34:26 +0000696 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700697 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 struct ndisc_options ndopts;
699 struct net_device *dev = skb->dev;
700 struct inet6_ifaddr *ifp;
701 struct inet6_dev *idev = NULL;
702 struct neighbour *neigh;
703 int dad = ipv6_addr_any(saddr);
Eric Dumazeta50feda2012-05-18 18:57:34 +0000704 bool inc;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900705 int is_router = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
YOSHIFUJI Hideaki / 吉藤英明115b0aa2013-01-18 02:05:03 +0000707 if (skb->len < sizeof(struct nd_msg)) {
708 ND_PRINTK(2, warn, "NS: packet too short\n");
709 return;
710 }
711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 if (ipv6_addr_is_multicast(&msg->target)) {
Joe Perches675418d2012-05-16 19:28:38 +0000713 ND_PRINTK(2, warn, "NS: multicast target address\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 return;
715 }
716
717 /*
718 * RFC2461 7.1.1:
719 * DAD has to be destined for solicited node multicast address.
720 */
YOSHIFUJI Hideaki / 吉藤英明ca97a642013-01-20 07:39:00 +0000721 if (dad && !ipv6_addr_is_solict_mult(daddr)) {
Joe Perches675418d2012-05-16 19:28:38 +0000722 ND_PRINTK(2, warn, "NS: bad DAD packet (wrong destination)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 return;
724 }
725
726 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
Joe Perches675418d2012-05-16 19:28:38 +0000727 ND_PRINTK(2, warn, "NS: invalid ND options\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 return;
729 }
730
731 if (ndopts.nd_opts_src_lladdr) {
732 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
733 if (!lladdr) {
Joe Perches675418d2012-05-16 19:28:38 +0000734 ND_PRINTK(2, warn,
735 "NS: invalid link-layer address length\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 return;
737 }
738
739 /* RFC2461 7.1.1:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900740 * If the IP source address is the unspecified address,
741 * there MUST NOT be source link-layer address option
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 * in the message.
743 */
744 if (dad) {
Joe Perches675418d2012-05-16 19:28:38 +0000745 ND_PRINTK(2, warn,
746 "NS: bad DAD packet (link-layer address option)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 return;
748 }
749 }
750
751 inc = ipv6_addr_is_multicast(daddr);
752
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900753 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800754 if (ifp) {
Neil Horman95c385b2007-04-25 17:08:10 -0700755
756 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
757 if (dad) {
Neil Horman95c385b2007-04-25 17:08:10 -0700758 /*
759 * We are colliding with another node
760 * who is doing DAD
761 * so fail our DAD process
762 */
763 addrconf_dad_failure(ifp);
Denis V. Lunev9e3be4b2007-09-11 11:04:49 +0200764 return;
Neil Horman95c385b2007-04-25 17:08:10 -0700765 } else {
766 /*
767 * This is not a dad solicitation.
768 * If we are an optimistic node,
769 * we should respond.
770 * Otherwise, we should ignore it.
771 */
772 if (!(ifp->flags & IFA_F_OPTIMISTIC))
773 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 }
776
777 idev = ifp->idev;
778 } else {
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700779 struct net *net = dev_net(dev);
780
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 idev = in6_dev_get(dev);
782 if (!idev) {
783 /* XXX: count this drop? */
784 return;
785 }
786
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700787 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900788 (idev->cnf.forwarding &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700789 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900790 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700791 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 skb->pkt_type != PACKET_HOST &&
Daniel Balutaf2f79cc2013-07-13 11:26:51 +0300793 inc &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 idev->nd_parms->proxy_delay != 0) {
795 /*
796 * for anycast or proxy,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900797 * sender should delay its response
798 * by a random time between 0 and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 * MAX_ANYCAST_DELAY_TIME seconds.
800 * (RFC2461) -- yoshfuji
801 */
802 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
803 if (n)
804 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
805 goto out;
806 }
807 } else
808 goto out;
809 }
810
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900811 if (is_router < 0)
YOSHIFUJI Hideaki / 吉藤英明fb568632013-01-20 07:39:18 +0000812 is_router = idev->cnf.forwarding;
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700813
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 if (dad) {
YOSHIFUJI Hideakif3ee4012008-04-10 15:42:11 +0900815 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
YOSHIFUJI Hideaki / 吉藤英明fb568632013-01-20 07:39:18 +0000816 !!is_router, false, (ifp != NULL), true);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 goto out;
818 }
819
820 if (inc)
821 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
822 else
823 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
824
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900825 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 * update / create cache entry
827 * for the source address
828 */
829 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
830 !inc || lladdr || !dev->addr_len);
831 if (neigh)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900832 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 NEIGH_UPDATE_F_WEAK_OVERRIDE|
834 NEIGH_UPDATE_F_OVERRIDE);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700835 if (neigh || !dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 ndisc_send_na(dev, neigh, saddr, &msg->target,
YOSHIFUJI Hideaki / 吉藤英明fb568632013-01-20 07:39:18 +0000837 !!is_router,
838 true, (ifp != NULL && inc), inc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 if (neigh)
840 neigh_release(neigh);
841 }
842
843out:
844 if (ifp)
845 in6_ifa_put(ifp);
846 else
847 in6_dev_put(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848}
849
850static void ndisc_recv_na(struct sk_buff *skb)
851{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700852 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000853 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
854 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 u8 *lladdr = NULL;
Simon Horman29a3cad2013-05-28 20:34:26 +0000856 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700857 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 struct ndisc_options ndopts;
859 struct net_device *dev = skb->dev;
860 struct inet6_ifaddr *ifp;
861 struct neighbour *neigh;
862
863 if (skb->len < sizeof(struct nd_msg)) {
Joe Perches675418d2012-05-16 19:28:38 +0000864 ND_PRINTK(2, warn, "NA: packet too short\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 return;
866 }
867
868 if (ipv6_addr_is_multicast(&msg->target)) {
Joe Perches675418d2012-05-16 19:28:38 +0000869 ND_PRINTK(2, warn, "NA: target address is multicast\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 return;
871 }
872
873 if (ipv6_addr_is_multicast(daddr) &&
874 msg->icmph.icmp6_solicited) {
Joe Perches675418d2012-05-16 19:28:38 +0000875 ND_PRINTK(2, warn, "NA: solicited NA is multicasted\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 return;
877 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900878
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
Joe Perches675418d2012-05-16 19:28:38 +0000880 ND_PRINTK(2, warn, "NS: invalid ND option\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 return;
882 }
883 if (ndopts.nd_opts_tgt_lladdr) {
884 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
885 if (!lladdr) {
Joe Perches675418d2012-05-16 19:28:38 +0000886 ND_PRINTK(2, warn,
887 "NA: invalid link-layer address length\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 return;
889 }
890 }
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900891 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800892 if (ifp) {
Daniel Walterbd015922011-04-13 21:09:25 +0000893 if (skb->pkt_type != PACKET_LOOPBACK
894 && (ifp->flags & IFA_F_TENTATIVE)) {
895 addrconf_dad_failure(ifp);
896 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 }
898 /* What should we make now? The advertisement
899 is invalid, but ndisc specs say nothing
900 about it. It could be misconfiguration, or
901 an smart proxy agent tries to help us :-)
Jan Sembera24fc7b82008-12-09 15:48:32 -0800902
903 We should not print the error if NA has been
904 received from loopback - it is just our own
905 unsolicited advertisement.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 */
Jan Sembera24fc7b82008-12-09 15:48:32 -0800907 if (skb->pkt_type != PACKET_LOOPBACK)
Joe Perches675418d2012-05-16 19:28:38 +0000908 ND_PRINTK(1, warn,
909 "NA: someone advertises our address %pI6 on %s!\n",
910 &ifp->addr, ifp->idev->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 in6_ifa_put(ifp);
912 return;
913 }
914 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
915
916 if (neigh) {
917 u8 old_flags = neigh->flags;
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700918 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
920 if (neigh->nud_state & NUD_FAILED)
921 goto out;
922
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700923 /*
924 * Don't update the neighbor cache entry on a proxy NA from
925 * ourselves because either the proxied node is off link or it
926 * has already sent a NA to us.
927 */
928 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700929 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
930 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
Nicolas Dichtelb20b6d92012-11-07 05:05:38 +0000931 /* XXX: idev->cnf.proxy_ndp */
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700932 goto out;
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700933 }
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700934
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 neigh_update(neigh, lladdr,
936 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
937 NEIGH_UPDATE_F_WEAK_OVERRIDE|
938 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
939 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
940 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
941
942 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
943 /*
944 * Change: router to host
945 */
946 struct rt6_info *rt;
947 rt = rt6_get_dflt_router(saddr, dev);
948 if (rt)
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700949 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 }
951
952out:
953 neigh_release(neigh);
954 }
955}
956
957static void ndisc_recv_rs(struct sk_buff *skb)
958{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700959 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
961 struct neighbour *neigh;
962 struct inet6_dev *idev;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000963 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 struct ndisc_options ndopts;
965 u8 *lladdr = NULL;
966
967 if (skb->len < sizeof(*rs_msg))
968 return;
969
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000970 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 if (!idev) {
Joe Perches675418d2012-05-16 19:28:38 +0000972 ND_PRINTK(1, err, "RS: can't find in6 device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 return;
974 }
975
976 /* Don't accept RS if we're not in router mode */
977 if (!idev->cnf.forwarding)
978 goto out;
979
980 /*
981 * Don't update NCE if src = ::;
982 * this implies that the source node has no ip address assigned yet.
983 */
984 if (ipv6_addr_any(saddr))
985 goto out;
986
987 /* Parse ND options */
988 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
Joe Perches675418d2012-05-16 19:28:38 +0000989 ND_PRINTK(2, notice, "NS: invalid ND option, ignored\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 goto out;
991 }
992
993 if (ndopts.nd_opts_src_lladdr) {
994 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
995 skb->dev);
996 if (!lladdr)
997 goto out;
998 }
999
1000 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1001 if (neigh) {
1002 neigh_update(neigh, lladdr, NUD_STALE,
1003 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1004 NEIGH_UPDATE_F_OVERRIDE|
1005 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1006 neigh_release(neigh);
1007 }
1008out:
Eric Dumazetcfdf7642011-07-27 21:13:03 +00001009 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010}
1011
Pierre Ynard31910572007-10-10 21:22:05 -07001012static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1013{
1014 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1015 struct sk_buff *skb;
1016 struct nlmsghdr *nlh;
1017 struct nduseroptmsg *ndmsg;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001018 struct net *net = dev_net(ra->dev);
Pierre Ynard31910572007-10-10 21:22:05 -07001019 int err;
1020 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1021 + (opt->nd_opt_len << 3));
1022 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1023
1024 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1025 if (skb == NULL) {
1026 err = -ENOBUFS;
1027 goto errout;
1028 }
1029
1030 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1031 if (nlh == NULL) {
1032 goto nla_put_failure;
1033 }
1034
1035 ndmsg = nlmsg_data(nlh);
1036 ndmsg->nduseropt_family = AF_INET6;
Pierre Ynarddbb2ed22007-11-12 17:58:35 -08001037 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
Pierre Ynard31910572007-10-10 21:22:05 -07001038 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1039 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1040 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1041
1042 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1043
David S. Millerc78679e2012-04-01 20:27:33 -04001044 if (nla_put(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1045 &ipv6_hdr(ra)->saddr))
1046 goto nla_put_failure;
Pierre Ynard31910572007-10-10 21:22:05 -07001047 nlmsg_end(skb, nlh);
1048
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001049 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
Pierre Ynard31910572007-10-10 21:22:05 -07001050 return;
1051
1052nla_put_failure:
1053 nlmsg_free(skb);
1054 err = -EMSGSIZE;
1055errout:
Daniel Lezcanoa18bc692008-03-07 11:14:49 -08001056 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
Pierre Ynard31910572007-10-10 21:22:05 -07001057}
1058
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059static void ndisc_router_discovery(struct sk_buff *skb)
1060{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001061 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 struct neighbour *neigh = NULL;
1063 struct inet6_dev *in6_dev;
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001064 struct rt6_info *rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 int lifetime;
1066 struct ndisc_options ndopts;
1067 int optlen;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001068 unsigned int pref = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069
1070 __u8 * opt = (__u8 *)(ra_msg + 1);
1071
Simon Horman29a3cad2013-05-28 20:34:26 +00001072 optlen = (skb_tail_pointer(skb) - skb_transport_header(skb)) -
1073 sizeof(struct ra_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001075 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Joe Perches675418d2012-05-16 19:28:38 +00001076 ND_PRINTK(2, warn, "RA: source address is not link-local\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 return;
1078 }
1079 if (optlen < 0) {
Joe Perches675418d2012-05-16 19:28:38 +00001080 ND_PRINTK(2, warn, "RA: packet too short\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 return;
1082 }
1083
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001084#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001085 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
Joe Perches675418d2012-05-16 19:28:38 +00001086 ND_PRINTK(2, warn, "RA: from host or unauthorized router\n");
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001087 return;
1088 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001089#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001090
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 /*
1092 * set the RA_RECV flag in the interface
1093 */
1094
Eric Dumazetcfdf7642011-07-27 21:13:03 +00001095 in6_dev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 if (in6_dev == NULL) {
Joe Perches675418d2012-05-16 19:28:38 +00001097 ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n",
1098 skb->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 return;
1100 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101
1102 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
Joe Perches675418d2012-05-16 19:28:38 +00001103 ND_PRINTK(2, warn, "RA: invalid ND options\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 return;
1105 }
1106
Shmulik Ladkaniaeaf6e92012-11-30 10:25:59 +00001107 if (!ipv6_accept_ra(in6_dev))
David Ward31ce8c72009-08-29 00:04:09 -07001108 goto skip_linkparms;
1109
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001110#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001111 /* skip link-specific parameters from interior routers */
1112 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1113 goto skip_linkparms;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001114#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001115
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 if (in6_dev->if_flags & IF_RS_SENT) {
1117 /*
1118 * flag that an RA was received after an RS was sent
1119 * out on this interface.
1120 */
1121 in6_dev->if_flags |= IF_RA_RCVD;
1122 }
1123
1124 /*
1125 * Remember the managed/otherconf flags from most recently
1126 * received RA message (RFC 2462) -- yoshfuji
1127 */
1128 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1129 IF_RA_OTHERCONF)) |
1130 (ra_msg->icmph.icmp6_addrconf_managed ?
1131 IF_RA_MANAGED : 0) |
1132 (ra_msg->icmph.icmp6_addrconf_other ?
1133 IF_RA_OTHERCONF : 0);
1134
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001135 if (!in6_dev->cnf.accept_ra_defrtr)
1136 goto skip_defrtr;
1137
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001138 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1139 goto skip_defrtr;
1140
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1142
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001143#ifdef CONFIG_IPV6_ROUTER_PREF
1144 pref = ra_msg->icmph.icmp6_router_pref;
1145 /* 10b is handled as if it were 00b (medium) */
YOSHIFUJI Hideaki930d6ff2006-03-20 17:05:30 -08001146 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
YOSHIFUJI Hideaki6d5b78c2007-06-22 16:07:04 -07001147 !in6_dev->cnf.accept_ra_rtr_pref)
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001148 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1149#endif
1150
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001151 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152
David S. Millereb857182012-01-27 15:07:56 -08001153 if (rt) {
1154 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1155 if (!neigh) {
Joe Perches675418d2012-05-16 19:28:38 +00001156 ND_PRINTK(0, err,
1157 "RA: %s got default router without neighbour\n",
1158 __func__);
Amerigo Wang94e187c2012-10-29 00:13:19 +00001159 ip6_rt_put(rt);
David S. Millereb857182012-01-27 15:07:56 -08001160 return;
1161 }
1162 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 if (rt && lifetime == 0) {
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001164 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 rt = NULL;
1166 }
1167
1168 if (rt == NULL && lifetime) {
Joe Perches675418d2012-05-16 19:28:38 +00001169 ND_PRINTK(3, dbg, "RA: adding default router\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001171 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 if (rt == NULL) {
Joe Perches675418d2012-05-16 19:28:38 +00001173 ND_PRINTK(0, err,
1174 "RA: %s failed to add default route\n",
1175 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 return;
1177 }
1178
David S. Millereb857182012-01-27 15:07:56 -08001179 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 if (neigh == NULL) {
Joe Perches675418d2012-05-16 19:28:38 +00001181 ND_PRINTK(0, err,
1182 "RA: %s got default router without neighbour\n",
1183 __func__);
Amerigo Wang94e187c2012-10-29 00:13:19 +00001184 ip6_rt_put(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 return;
1186 }
1187 neigh->flags |= NTF_ROUTER;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001188 } else if (rt) {
Pedro Ribeiro22441cf2008-10-15 15:47:49 -07001189 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 }
1191
1192 if (rt)
Gao feng1716a962012-04-06 00:13:10 +00001193 rt6_set_expires(rt, jiffies + (HZ * lifetime));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 if (ra_msg->icmph.icmp6_hop_limit) {
1195 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1196 if (rt)
David S. Millerdefb3512010-12-08 21:16:57 -08001197 dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1198 ra_msg->icmph.icmp6_hop_limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 }
1200
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001201skip_defrtr:
1202
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 /*
1204 * Update Reachable Time and Retrans Timer
1205 */
1206
1207 if (in6_dev->nd_parms) {
1208 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1209
1210 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1211 rtime = (rtime*HZ)/1000;
1212 if (rtime < HZ/10)
1213 rtime = HZ/10;
1214 in6_dev->nd_parms->retrans_time = rtime;
1215 in6_dev->tstamp = jiffies;
1216 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1217 }
1218
1219 rtime = ntohl(ra_msg->reachable_time);
1220 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1221 rtime = (rtime*HZ)/1000;
1222
1223 if (rtime < HZ/10)
1224 rtime = HZ/10;
1225
1226 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1227 in6_dev->nd_parms->base_reachable_time = rtime;
1228 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1229 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1230 in6_dev->tstamp = jiffies;
1231 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1232 }
1233 }
1234 }
1235
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001236skip_linkparms:
1237
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 /*
1239 * Process options.
1240 */
1241
1242 if (!neigh)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001243 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 skb->dev, 1);
1245 if (neigh) {
1246 u8 *lladdr = NULL;
1247 if (ndopts.nd_opts_src_lladdr) {
1248 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1249 skb->dev);
1250 if (!lladdr) {
Joe Perches675418d2012-05-16 19:28:38 +00001251 ND_PRINTK(2, warn,
1252 "RA: invalid link-layer address length\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 goto out;
1254 }
1255 }
1256 neigh_update(neigh, lladdr, NUD_STALE,
1257 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1258 NEIGH_UPDATE_F_OVERRIDE|
1259 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1260 NEIGH_UPDATE_F_ISROUTER);
1261 }
1262
Shmulik Ladkaniaeaf6e92012-11-30 10:25:59 +00001263 if (!ipv6_accept_ra(in6_dev))
David Ward31ce8c72009-08-29 00:04:09 -07001264 goto out;
1265
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001266#ifdef CONFIG_IPV6_ROUTE_INFO
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001267 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1268 goto skip_routeinfo;
1269
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001270 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001271 struct nd_opt_hdr *p;
1272 for (p = ndopts.nd_opts_ri;
1273 p;
1274 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
YOSHIFUJI Hideaki6294e002008-03-15 23:56:52 -04001275 struct route_info *ri = (struct route_info *)p;
1276#ifdef CONFIG_IPV6_NDISC_NODETYPE
1277 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1278 ri->prefix_len == 0)
1279 continue;
1280#endif
1281 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001282 continue;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001283 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001284 &ipv6_hdr(skb)->saddr);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001285 }
1286 }
Andreas Hofmeister9f562202011-10-24 19:13:15 -04001287
1288skip_routeinfo:
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001289#endif
1290
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001291#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001292 /* skip link-specific ndopts from interior routers */
1293 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1294 goto out;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001295#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001296
YOSHIFUJI Hideakic4fd30e2006-03-20 16:55:26 -08001297 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 struct nd_opt_hdr *p;
1299 for (p = ndopts.nd_opts_pi;
1300 p;
1301 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
Neil Hormane6bff992012-01-04 10:49:15 +00001302 addrconf_prefix_rcv(skb->dev, (u8 *)p,
1303 (p->nd_opt_len) << 3,
1304 ndopts.nd_opts_src_lladdr != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 }
1306 }
1307
1308 if (ndopts.nd_opts_mtu) {
Al Viroe69a4adc2006-11-14 20:56:00 -08001309 __be32 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 u32 mtu;
1311
Al Viroe69a4adc2006-11-14 20:56:00 -08001312 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1313 mtu = ntohl(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314
1315 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
Joe Perches675418d2012-05-16 19:28:38 +00001316 ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 } else if (in6_dev->cnf.mtu6 != mtu) {
1318 in6_dev->cnf.mtu6 = mtu;
1319
1320 if (rt)
David S. Millerdefb3512010-12-08 21:16:57 -08001321 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322
1323 rt6_mtu_change(skb->dev, mtu);
1324 }
1325 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001326
Pierre Ynard31910572007-10-10 21:22:05 -07001327 if (ndopts.nd_useropts) {
YOSHIFUJI Hideaki61cf46ad2008-01-22 17:32:53 +09001328 struct nd_opt_hdr *p;
1329 for (p = ndopts.nd_useropts;
1330 p;
1331 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1332 ndisc_ra_useropt(skb, p);
Pierre Ynard31910572007-10-10 21:22:05 -07001333 }
1334 }
1335
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
Joe Perches675418d2012-05-16 19:28:38 +00001337 ND_PRINTK(2, warn, "RA: invalid RA options\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 }
1339out:
Amerigo Wang94e187c2012-10-29 00:13:19 +00001340 ip6_rt_put(rt);
David S. Millereb857182012-01-27 15:07:56 -08001341 if (neigh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343}
1344
1345static void ndisc_redirect_rcv(struct sk_buff *skb)
1346{
Duan Jiong093d04d2012-12-14 02:59:59 +00001347 u8 *hdr;
1348 struct ndisc_options ndopts;
1349 struct rd_msg *msg = (struct rd_msg *)skb_transport_header(skb);
Simon Horman29a3cad2013-05-28 20:34:26 +00001350 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
Duan Jiong093d04d2012-12-14 02:59:59 +00001351 offsetof(struct rd_msg, opt));
1352
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001353#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001354 switch (skb->ndisc_nodetype) {
1355 case NDISC_NODETYPE_HOST:
1356 case NDISC_NODETYPE_NODEFAULT:
Joe Perches675418d2012-05-16 19:28:38 +00001357 ND_PRINTK(2, warn,
1358 "Redirect: from host or unauthorized router\n");
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001359 return;
1360 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001361#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001362
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001363 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Joe Perches675418d2012-05-16 19:28:38 +00001364 ND_PRINTK(2, warn,
1365 "Redirect: source address is not link-local\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 return;
1367 }
1368
Duan Jiong093d04d2012-12-14 02:59:59 +00001369 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts))
1370 return;
1371
1372 if (!ndopts.nd_opts_rh)
1373 return;
1374
1375 hdr = (u8 *)ndopts.nd_opts_rh;
1376 hdr += 8;
1377 if (!pskb_pull(skb, hdr - skb_transport_header(skb)))
1378 return;
1379
David S. Millerb94f1c02012-07-12 00:33:37 -07001380 icmpv6_notify(skb, NDISC_REDIRECT, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381}
1382
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +00001383static void ndisc_fill_redirect_hdr_option(struct sk_buff *skb,
1384 struct sk_buff *orig_skb,
1385 int rd_len)
YOSHIFUJI Hideaki / 吉藤英明9c86daf2013-01-21 06:48:09 +00001386{
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +00001387 u8 *opt = skb_put(skb, rd_len);
1388
YOSHIFUJI Hideaki / 吉藤英明9c86daf2013-01-21 06:48:09 +00001389 memset(opt, 0, 8);
1390 *(opt++) = ND_OPT_REDIRECT_HDR;
1391 *(opt++) = (rd_len >> 3);
1392 opt += 6;
1393
1394 memcpy(opt, ipv6_hdr(orig_skb), rd_len - 8);
YOSHIFUJI Hideaki / 吉藤英明9c86daf2013-01-21 06:48:09 +00001395}
1396
David S. Miller49919692012-01-27 15:30:48 -08001397void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398{
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001399 struct net_device *dev = skb->dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001400 struct net *net = dev_net(dev);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001401 struct sock *sk = net->ipv6.ndisc_sk;
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001402 int optlen = 0;
David S. Millerfbfe95a2012-06-08 23:24:18 -07001403 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 struct sk_buff *buff;
YOSHIFUJI Hideaki / 吉藤英明71bcdba2013-01-05 16:34:51 +00001405 struct rd_msg *msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 struct in6_addr saddr_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 struct rt6_info *rt;
1408 struct dst_entry *dst;
David S. Miller4c9483b2011-03-12 16:22:43 -05001409 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 int rd_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
David S. Miller1d861aa2012-07-10 03:58:16 -07001412 bool ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
Neil Horman95c385b2007-04-25 17:08:10 -07001414 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
Joe Perches675418d2012-05-16 19:28:38 +00001415 ND_PRINTK(2, warn, "Redirect: no link-local address on %s\n",
1416 dev->name);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001417 return;
1418 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001420 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
Brian Haleybf0b48d2007-10-08 00:12:05 -07001421 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
Joe Perches675418d2012-05-16 19:28:38 +00001422 ND_PRINTK(2, warn,
1423 "Redirect: target address is not link-local unicast\n");
Li Yewang29556522007-01-30 14:33:20 -08001424 return;
1425 }
1426
David S. Miller4c9483b2011-03-12 16:22:43 -05001427 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -08001428 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
David S. Miller4c9483b2011-03-12 16:22:43 -05001430 dst = ip6_route_output(net, NULL, &fl6);
RongQing.Li5095d642012-02-21 22:10:49 +00001431 if (dst->error) {
1432 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 return;
RongQing.Li5095d642012-02-21 22:10:49 +00001434 }
David S. Miller4c9483b2011-03-12 16:22:43 -05001435 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
David S. Miller452edd52011-03-02 13:27:41 -08001436 if (IS_ERR(dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438
1439 rt = (struct rt6_info *) dst;
1440
1441 if (rt->rt6i_flags & RTF_GATEWAY) {
Joe Perches675418d2012-05-16 19:28:38 +00001442 ND_PRINTK(2, warn,
1443 "Redirect: destination is not a neighbour\n");
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001444 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 }
David S. Miller1d861aa2012-07-10 03:58:16 -07001446 peer = inet_getpeer_v6(net->ipv6.peers, &rt->rt6i_dst.addr, 1);
1447 ret = inet_peer_xrlim_allow(peer, 1*HZ);
1448 if (peer)
1449 inet_putpeer(peer);
1450 if (!ret)
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001451 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452
1453 if (dev->addr_len) {
David S. Miller49919692012-01-27 15:30:48 -08001454 struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target);
1455 if (!neigh) {
Joe Perches675418d2012-05-16 19:28:38 +00001456 ND_PRINTK(2, warn,
1457 "Redirect: no neigh for target address\n");
David S. Miller49919692012-01-27 15:30:48 -08001458 goto release;
1459 }
1460
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 read_lock_bh(&neigh->lock);
1462 if (neigh->nud_state & NUD_VALID) {
1463 memcpy(ha_buf, neigh->ha, dev->addr_len);
1464 read_unlock_bh(&neigh->lock);
1465 ha = ha_buf;
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001466 optlen += ndisc_opt_addr_space(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 } else
1468 read_unlock_bh(&neigh->lock);
David S. Miller49919692012-01-27 15:30:48 -08001469
1470 neigh_release(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 }
1472
1473 rd_len = min_t(unsigned int,
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001474 IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(*msg) - optlen,
1475 skb->len + 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 rd_len &= ~0x7;
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001477 optlen += rd_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478
YOSHIFUJI Hideaki / 吉藤英明2ce135762013-01-21 06:48:49 +00001479 buff = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
YOSHIFUJI Hideaki / 吉藤英明de093342013-01-21 06:48:14 +00001480 if (!buff)
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001481 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482
YOSHIFUJI Hideaki / 吉藤英明4d5c1522013-01-21 06:49:25 +00001483 msg = (struct rd_msg *)skb_put(buff, sizeof(*msg));
1484 *msg = (struct rd_msg) {
1485 .icmph = {
1486 .icmp6_type = NDISC_REDIRECT,
1487 },
1488 .target = *target,
1489 .dest = ipv6_hdr(skb)->daddr,
1490 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 /*
1493 * include target_address option
1494 */
1495
1496 if (ha)
Matthias Schiffer33be0812013-05-31 03:27:55 +02001497 ndisc_fill_addr_option(buff, ND_OPT_TARGET_LL_ADDR, ha);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498
1499 /*
1500 * build redirect option and copy skb over to the new packet.
1501 */
1502
YOSHIFUJI Hideaki / 吉藤英明9c86daf2013-01-21 06:48:09 +00001503 if (rd_len)
YOSHIFUJI Hideaki / 吉藤英明5f5a0112013-01-21 06:48:53 +00001504 ndisc_fill_redirect_hdr_option(buff, skb, rd_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505
Eric Dumazetadf30902009-06-02 05:19:30 +00001506 skb_dst_set(buff, dst);
YOSHIFUJI Hideaki / 吉藤英明f4de84c2013-01-21 06:49:03 +00001507 ndisc_send_skb(buff, &ipv6_hdr(skb)->saddr, &saddr_buf);
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001508 return;
1509
1510release:
1511 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512}
1513
1514static void pndisc_redo(struct sk_buff *skb)
1515{
YOSHIFUJI Hideaki140e26fc2005-10-05 12:11:41 -07001516 ndisc_recv_ns(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 kfree_skb(skb);
1518}
1519
1520int ndisc_rcv(struct sk_buff *skb)
1521{
1522 struct nd_msg *msg;
1523
YOSHIFUJI Hideaki / 吉藤英明6bce6b42013-01-21 06:48:03 +00001524 if (skb_linearize(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 return 0;
1526
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001527 msg = (struct nd_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001529 __skb_push(skb, skb->data - skb_transport_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001531 if (ipv6_hdr(skb)->hop_limit != 255) {
Joe Perches675418d2012-05-16 19:28:38 +00001532 ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n",
1533 ipv6_hdr(skb)->hop_limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 return 0;
1535 }
1536
1537 if (msg->icmph.icmp6_code != 0) {
Joe Perches675418d2012-05-16 19:28:38 +00001538 ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n",
1539 msg->icmph.icmp6_code);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 return 0;
1541 }
1542
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001543 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1544
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 switch (msg->icmph.icmp6_type) {
1546 case NDISC_NEIGHBOUR_SOLICITATION:
1547 ndisc_recv_ns(skb);
1548 break;
1549
1550 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1551 ndisc_recv_na(skb);
1552 break;
1553
1554 case NDISC_ROUTER_SOLICITATION:
1555 ndisc_recv_rs(skb);
1556 break;
1557
1558 case NDISC_ROUTER_ADVERTISEMENT:
1559 ndisc_router_discovery(skb);
1560 break;
1561
1562 case NDISC_REDIRECT:
1563 ndisc_redirect_rcv(skb);
1564 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001565 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566
1567 return 0;
1568}
1569
1570static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1571{
Jiri Pirko351638e2013-05-28 01:30:21 +00001572 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001573 struct net *net = dev_net(dev);
Hannes Frederic Sowa5cb04432012-11-06 16:46:20 +00001574 struct inet6_dev *idev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575
1576 switch (event) {
1577 case NETDEV_CHANGEADDR:
1578 neigh_changeaddr(&nd_tbl, dev);
Michal Kubeček2ac3ac82013-08-01 10:04:14 +02001579 fib6_run_gc(0, net, false);
Hannes Frederic Sowa5cb04432012-11-06 16:46:20 +00001580 idev = in6_dev_get(dev);
1581 if (!idev)
1582 break;
1583 if (idev->cnf.ndisc_notify)
1584 ndisc_send_unsol_na(dev);
1585 in6_dev_put(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 break;
1587 case NETDEV_DOWN:
1588 neigh_ifdown(&nd_tbl, dev);
Michal Kubeček2ac3ac82013-08-01 10:04:14 +02001589 fib6_run_gc(0, net, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 break;
Ben Hutchingsf47b9462011-04-15 13:46:02 +00001591 case NETDEV_NOTIFY_PEERS:
1592 ndisc_send_unsol_na(dev);
1593 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 default:
1595 break;
1596 }
1597
1598 return NOTIFY_DONE;
1599}
1600
1601static struct notifier_block ndisc_netdev_notifier = {
1602 .notifier_call = ndisc_netdev_event,
1603};
1604
1605#ifdef CONFIG_SYSCTL
1606static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1607 const char *func, const char *dev_name)
1608{
1609 static char warncomm[TASK_COMM_LEN];
1610 static int warned;
1611 if (strcmp(warncomm, current->comm) && warned < 5) {
1612 strcpy(warncomm, current->comm);
Joe Perchesf3213832012-05-15 14:11:53 +00001613 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 -07001614 warncomm, func,
1615 dev_name, ctl->procname,
1616 dev_name, ctl->procname);
1617 warned++;
1618 }
1619}
1620
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001621int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622{
1623 struct net_device *dev = ctl->extra1;
1624 struct inet6_dev *idev;
1625 int ret;
1626
Eric W. Biedermand12af672007-10-18 03:05:25 -07001627 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1628 (strcmp(ctl->procname, "base_reachable_time") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1630
Eric W. Biedermand12af672007-10-18 03:05:25 -07001631 if (strcmp(ctl->procname, "retrans_time") == 0)
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001632 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001633
1634 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 ret = proc_dointvec_jiffies(ctl, write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001636 buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001637
1638 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
YOSHIFUJI Hideakiad02ac12007-10-29 01:32:23 -07001639 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 ret = proc_dointvec_ms_jiffies(ctl, write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001641 buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001642 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 ret = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644
1645 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
Eric W. Biedermand12af672007-10-18 03:05:25 -07001646 if (ctl->data == &idev->nd_parms->base_reachable_time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1648 idev->tstamp = jiffies;
1649 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1650 in6_dev_put(idev);
1651 }
1652 return ret;
1653}
1654
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
1656#endif
1657
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001658static int __net_init ndisc_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659{
1660 struct ipv6_pinfo *np;
1661 struct sock *sk;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001662 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001664 err = inet_ctl_sock_create(&sk, PF_INET6,
1665 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 if (err < 0) {
Joe Perches675418d2012-05-16 19:28:38 +00001667 ND_PRINTK(0, err,
1668 "NDISC: Failed to initialize the control socket (err %d)\n",
1669 err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 return err;
1671 }
1672
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001673 net->ipv6.ndisc_sk = sk;
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001674
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 np->hop_limit = 255;
1677 /* Do not loopback ndisc messages */
1678 np->mc_loop = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001680 return 0;
1681}
1682
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001683static void __net_exit ndisc_net_exit(struct net *net)
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001684{
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001685 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001686}
1687
1688static struct pernet_operations ndisc_net_ops = {
1689 .init = ndisc_net_init,
1690 .exit = ndisc_net_exit,
1691};
1692
1693int __init ndisc_init(void)
1694{
1695 int err;
1696
1697 err = register_pernet_subsys(&ndisc_net_ops);
1698 if (err)
1699 return err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001700 /*
1701 * Initialize the neighbour table
1702 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 neigh_table_init(&nd_tbl);
1704
1705#ifdef CONFIG_SYSCTL
Eric W. Biederman54716e32010-02-14 03:27:03 +00001706 err = neigh_sysctl_register(NULL, &nd_tbl.parms, "ipv6",
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001707 &ndisc_ifinfo_sysctl_change);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001708 if (err)
1709 goto out_unregister_pernet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710#endif
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001711 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1712 if (err)
1713 goto out_unregister_sysctl;
1714out:
1715 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001717out_unregister_sysctl:
1718#ifdef CONFIG_SYSCTL
1719 neigh_sysctl_unregister(&nd_tbl.parms);
1720out_unregister_pernet:
1721#endif
1722 unregister_pernet_subsys(&ndisc_net_ops);
1723 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724}
1725
1726void ndisc_cleanup(void)
1727{
Dmitry Mishin36f73d02006-11-03 16:08:19 -08001728 unregister_netdevice_notifier(&ndisc_netdev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729#ifdef CONFIG_SYSCTL
1730 neigh_sysctl_unregister(&nd_tbl.parms);
1731#endif
1732 neigh_table_clear(&nd_tbl);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001733 unregister_pernet_subsys(&ndisc_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734}