ndisc.c 41.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 *	Neighbour Discovery for IPv6
3
 *	Linux INET6 implementation
L
Linus Torvalds 已提交
4 5
 *
 *	Authors:
6
 *	Pedro Roque		<roque@di.fc.ul.pt>
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14 15 16 17
 *	Mike Shaver		<shaver@ingenia.com>
 *
 *	This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */

/*
 *	Changes:
 *
18
 *	Alexey I. Froloff		:	RFC6106 (DNSSL) support
19 20
 *	Pierre Ynard			:	export userland ND options
 *						through netlink (RDNSS support)
L
Linus Torvalds 已提交
21 22 23 24 25 26 27 28 29
 *	Lars Fenneberg			:	fixed MTU setting on receipt
 *						of an RA.
 *	Janos Farkas			:	kmalloc failure checks
 *	Alexey Kuznetsov		:	state machine reworked
 *						and moved to net/core.
 *	Pekka Savola			:	RFC2461 validation
 *	YOSHIFUJI Hideaki @USAGI	:	Verify ND options properly
 */

30
#define pr_fmt(fmt) "ICMPv6: " fmt
L
Linus Torvalds 已提交
31 32 33 34 35 36 37 38 39 40 41 42

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/sched.h>
#include <linux/net.h>
#include <linux/in6.h>
#include <linux/route.h>
#include <linux/init.h>
#include <linux/rcupdate.h>
43
#include <linux/slab.h>
L
Linus Torvalds 已提交
44 45 46 47
#ifdef CONFIG_SYSCTL
#include <linux/sysctl.h>
#endif

48
#include <linux/if_addr.h>
L
Linus Torvalds 已提交
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
#include <linux/if_arp.h>
#include <linux/ipv6.h>
#include <linux/icmpv6.h>
#include <linux/jhash.h>

#include <net/sock.h>
#include <net/snmp.h>

#include <net/ipv6.h>
#include <net/protocol.h>
#include <net/ndisc.h>
#include <net/ip6_route.h>
#include <net/addrconf.h>
#include <net/icmp.h>

64 65 66
#include <net/netlink.h>
#include <linux/rtnetlink.h>

L
Linus Torvalds 已提交
67 68
#include <net/flow.h>
#include <net/ip6_checksum.h>
69
#include <net/inet_common.h>
L
Linus Torvalds 已提交
70 71 72 73 74
#include <linux/proc_fs.h>

#include <linux/netfilter.h>
#include <linux/netfilter_ipv6.h>

75 76 77 78 79 80 81 82 83
/* Set to 3 to get tracing... */
#define ND_DEBUG 1

#define ND_PRINTK(val, level, fmt, ...)				\
do {								\
	if (val <= ND_DEBUG)					\
		net_##level##_ratelimited(fmt, ##__VA_ARGS__);	\
} while (0)

84 85
static u32 ndisc_hash(const void *pkey,
		      const struct net_device *dev,
86
		      __u32 *hash_rnd);
L
Linus Torvalds 已提交
87 88 89 90 91 92 93
static int ndisc_constructor(struct neighbour *neigh);
static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
static int pndisc_constructor(struct pneigh_entry *n);
static void pndisc_destructor(struct pneigh_entry *n);
static void pndisc_redo(struct sk_buff *skb);

S
Stephen Hemminger 已提交
94
static const struct neigh_ops ndisc_generic_ops = {
L
Linus Torvalds 已提交
95 96 97 98 99 100 101
	.family =		AF_INET6,
	.solicit =		ndisc_solicit,
	.error_report =		ndisc_error_report,
	.output =		neigh_resolve_output,
	.connected_output =	neigh_connected_output,
};

S
Stephen Hemminger 已提交
102
static const struct neigh_ops ndisc_hh_ops = {
L
Linus Torvalds 已提交
103 104 105 106 107 108 109 110
	.family =		AF_INET6,
	.solicit =		ndisc_solicit,
	.error_report =		ndisc_error_report,
	.output =		neigh_resolve_output,
	.connected_output =	neigh_resolve_output,
};


S
Stephen Hemminger 已提交
111
static const struct neigh_ops ndisc_direct_ops = {
L
Linus Torvalds 已提交
112
	.family =		AF_INET6,
113 114
	.output =		neigh_direct_output,
	.connected_output =	neigh_direct_output,
L
Linus Torvalds 已提交
115 116 117 118 119 120 121 122 123 124 125 126
};

struct neigh_table nd_tbl = {
	.family =	AF_INET6,
	.key_len =	sizeof(struct in6_addr),
	.hash =		ndisc_hash,
	.constructor =	ndisc_constructor,
	.pconstructor =	pndisc_constructor,
	.pdestructor =	pndisc_destructor,
	.proxy_redo =	pndisc_redo,
	.id =		"ndisc_cache",
	.parms = {
127 128 129 130 131 132
		.tbl			= &nd_tbl,
		.base_reachable_time	= ND_REACHABLE_TIME,
		.retrans_time		= ND_RETRANS_TIMER,
		.gc_staletime		= 60 * HZ,
		.reachable_time		= ND_REACHABLE_TIME,
		.delay_probe_time	= 5 * HZ,
E
Eric Dumazet 已提交
133
		.queue_len_bytes	= 64*1024,
134 135 136 137 138
		.ucast_probes		= 3,
		.mcast_probes		= 3,
		.anycast_delay		= 1 * HZ,
		.proxy_delay		= (8 * HZ) / 10,
		.proxy_qlen		= 64,
L
Linus Torvalds 已提交
139 140 141 142 143 144 145
	},
	.gc_interval =	  30 * HZ,
	.gc_thresh1 =	 128,
	.gc_thresh2 =	 512,
	.gc_thresh3 =	1024,
};

146
static void ndisc_fill_addr_option(struct sk_buff *skb, int type, void *data)
L
Linus Torvalds 已提交
147
{
148 149 150 151
	int pad   = ndisc_addr_option_pad(skb->dev->type);
	int data_len = skb->dev->addr_len;
	int space = ndisc_opt_addr_space(skb->dev);
	u8 *opt = skb_put(skb, space);
L
Linus Torvalds 已提交
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176

	opt[0] = type;
	opt[1] = space>>3;

	memset(opt + 2, 0, pad);
	opt   += pad;
	space -= pad;

	memcpy(opt+2, data, data_len);
	data_len += 2;
	opt += data_len;
	if ((space -= data_len) > 0)
		memset(opt, 0, space);
}

static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
					    struct nd_opt_hdr *end)
{
	int type;
	if (!cur || !end || cur >= end)
		return NULL;
	type = cur->nd_opt_type;
	do {
		cur = ((void *)cur) + (cur->nd_opt_len << 3);
	} while(cur < end && cur->nd_opt_type != type);
E
Eric Dumazet 已提交
177
	return cur <= end && cur->nd_opt_type == type ? cur : NULL;
L
Linus Torvalds 已提交
178 179
}

180 181
static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
{
182 183
	return opt->nd_opt_type == ND_OPT_RDNSS ||
		opt->nd_opt_type == ND_OPT_DNSSL;
184 185 186 187 188 189 190 191 192 193
}

static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
					     struct nd_opt_hdr *end)
{
	if (!cur || !end || cur >= end)
		return NULL;
	do {
		cur = ((void *)cur) + (cur->nd_opt_len << 3);
	} while(cur < end && !ndisc_is_useropt(cur));
E
Eric Dumazet 已提交
194
	return cur <= end && ndisc_is_useropt(cur) ? cur : NULL;
195 196
}

197 198
struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
					  struct ndisc_options *ndopts)
L
Linus Torvalds 已提交
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
{
	struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;

	if (!nd_opt || opt_len < 0 || !ndopts)
		return NULL;
	memset(ndopts, 0, sizeof(*ndopts));
	while (opt_len) {
		int l;
		if (opt_len < sizeof(struct nd_opt_hdr))
			return NULL;
		l = nd_opt->nd_opt_len << 3;
		if (opt_len < l || l == 0)
			return NULL;
		switch (nd_opt->nd_opt_type) {
		case ND_OPT_SOURCE_LL_ADDR:
		case ND_OPT_TARGET_LL_ADDR:
		case ND_OPT_MTU:
		case ND_OPT_REDIRECT_HDR:
			if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
218 219 220
				ND_PRINTK(2, warn,
					  "%s: duplicated ND6 option found: type=%d\n",
					  __func__, nd_opt->nd_opt_type);
L
Linus Torvalds 已提交
221 222 223 224 225 226
			} else {
				ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
			}
			break;
		case ND_OPT_PREFIX_INFO:
			ndopts->nd_opts_pi_end = nd_opt;
S
Stephen Hemminger 已提交
227
			if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
L
Linus Torvalds 已提交
228 229
				ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
			break;
230 231 232 233 234 235 236
#ifdef CONFIG_IPV6_ROUTE_INFO
		case ND_OPT_ROUTE_INFO:
			ndopts->nd_opts_ri_end = nd_opt;
			if (!ndopts->nd_opts_ri)
				ndopts->nd_opts_ri = nd_opt;
			break;
#endif
L
Linus Torvalds 已提交
237
		default:
238 239 240 241 242 243 244 245 246 247
			if (ndisc_is_useropt(nd_opt)) {
				ndopts->nd_useropts_end = nd_opt;
				if (!ndopts->nd_useropts)
					ndopts->nd_useropts = nd_opt;
			} else {
				/*
				 * Unknown options must be silently ignored,
				 * to accommodate future extension to the
				 * protocol.
				 */
248 249 250 251 252
				ND_PRINTK(2, notice,
					  "%s: ignored unsupported option; type=%d, len=%d\n",
					  __func__,
					  nd_opt->nd_opt_type,
					  nd_opt->nd_opt_len);
253
			}
L
Linus Torvalds 已提交
254 255 256 257 258 259 260
		}
		opt_len -= l;
		nd_opt = ((void *)nd_opt) + l;
	}
	return ndopts;
}

261
int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
L
Linus Torvalds 已提交
262 263 264 265 266 267 268 269 270 271 272
{
	switch (dev->type) {
	case ARPHRD_ETHER:
	case ARPHRD_IEEE802:	/* Not sure. Check it later. --ANK */
	case ARPHRD_FDDI:
		ipv6_eth_mc_map(addr, buf);
		return 0;
	case ARPHRD_ARCNET:
		ipv6_arcnet_mc_map(addr, buf);
		return 0;
	case ARPHRD_INFINIBAND:
273
		ipv6_ib_mc_map(addr, dev->broadcast, buf);
L
Linus Torvalds 已提交
274
		return 0;
275 276
	case ARPHRD_IPGRE:
		return ipv6_ipgre_mc_map(addr, dev->broadcast, buf);
L
Linus Torvalds 已提交
277 278 279 280 281 282 283 284 285
	default:
		if (dir) {
			memcpy(buf, dev->broadcast, dev->addr_len);
			return 0;
		}
	}
	return -EINVAL;
}

286 287
EXPORT_SYMBOL(ndisc_mc_map);

288 289
static u32 ndisc_hash(const void *pkey,
		      const struct net_device *dev,
290
		      __u32 *hash_rnd)
L
Linus Torvalds 已提交
291
{
292
	return ndisc_hashfn(pkey, dev, hash_rnd);
L
Linus Torvalds 已提交
293 294 295 296 297 298 299 300
}

static int ndisc_constructor(struct neighbour *neigh)
{
	struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
	struct net_device *dev = neigh->dev;
	struct inet6_dev *in6_dev;
	struct neigh_parms *parms;
301
	bool is_multicast = ipv6_addr_is_multicast(addr);
L
Linus Torvalds 已提交
302 303 304 305 306 307 308 309 310 311 312

	in6_dev = in6_dev_get(dev);
	if (in6_dev == NULL) {
		return -EINVAL;
	}

	parms = in6_dev->nd_parms;
	__neigh_parms_put(neigh->parms);
	neigh->parms = neigh_parms_clone(parms);

	neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
313
	if (!dev->header_ops) {
L
Linus Torvalds 已提交
314 315
		neigh->nud_state = NUD_NOARP;
		neigh->ops = &ndisc_direct_ops;
316
		neigh->output = neigh_direct_output;
L
Linus Torvalds 已提交
317 318 319 320 321 322 323 324 325 326 327 328 329
	} else {
		if (is_multicast) {
			neigh->nud_state = NUD_NOARP;
			ndisc_mc_map(addr, neigh->ha, dev, 1);
		} else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
			neigh->nud_state = NUD_NOARP;
			memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
			if (dev->flags&IFF_LOOPBACK)
				neigh->type = RTN_LOCAL;
		} else if (dev->flags&IFF_POINTOPOINT) {
			neigh->nud_state = NUD_NOARP;
			memcpy(neigh->ha, dev->broadcast, dev->addr_len);
		}
330
		if (dev->header_ops->cache)
L
Linus Torvalds 已提交
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
			neigh->ops = &ndisc_hh_ops;
		else
			neigh->ops = &ndisc_generic_ops;
		if (neigh->nud_state&NUD_VALID)
			neigh->output = neigh->ops->connected_output;
		else
			neigh->output = neigh->ops->output;
	}
	in6_dev_put(in6_dev);
	return 0;
}

static int pndisc_constructor(struct pneigh_entry *n)
{
	struct in6_addr *addr = (struct in6_addr*)&n->key;
	struct in6_addr maddr;
	struct net_device *dev = n->dev;

	if (dev == NULL || __in6_dev_get(dev) == NULL)
		return -EINVAL;
	addrconf_addr_solict_mult(addr, &maddr);
	ipv6_dev_mc_inc(dev, &maddr);
	return 0;
}

static void pndisc_destructor(struct pneigh_entry *n)
{
	struct in6_addr *addr = (struct in6_addr*)&n->key;
	struct in6_addr maddr;
	struct net_device *dev = n->dev;

	if (dev == NULL || __in6_dev_get(dev) == NULL)
		return;
	addrconf_addr_solict_mult(addr, &maddr);
	ipv6_dev_mc_dec(dev, &maddr);
}

368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
static struct sk_buff *ndisc_alloc_skb(struct net_device *dev,
				       int len)
{
	int hlen = LL_RESERVED_SPACE(dev);
	int tlen = dev->needed_tailroom;
	struct sock *sk = dev_net(dev)->ipv6.ndisc_sk;
	struct sk_buff *skb;
	int err;

	skb = sock_alloc_send_skb(sk,
				  hlen + sizeof(struct ipv6hdr) + len + tlen,
				  1, &err);
	if (!skb) {
		ND_PRINTK(0, err, "ndisc: %s failed to allocate an skb, err=%d\n",
			  __func__, err);
		return NULL;
	}

386 387 388
	skb->protocol = htons(ETH_P_IPV6);
	skb->dev = dev;

389
	skb_reserve(skb, hlen + sizeof(struct ipv6hdr));
390
	skb_reset_transport_header(skb);
391 392 393 394

	return skb;
}

395
static void ip6_nd_hdr(struct sk_buff *skb,
396 397
		       const struct in6_addr *saddr,
		       const struct in6_addr *daddr,
398
		       int hop_limit, int len)
399 400 401
{
	struct ipv6hdr *hdr;

402
	skb_push(skb, sizeof(*hdr));
403 404 405 406 407 408
	skb_reset_network_header(skb);
	hdr = ipv6_hdr(skb);

	ip6_flow_hdr(hdr, 0, 0);

	hdr->payload_len = htons(len);
409 410
	hdr->nexthdr = IPPROTO_ICMPV6;
	hdr->hop_limit = hop_limit;
411 412 413 414 415

	hdr->saddr = *saddr;
	hdr->daddr = *daddr;
}

416
static void ndisc_send_skb(struct sk_buff *skb,
417
			   const struct in6_addr *daddr,
418
			   const struct in6_addr *saddr)
419
{
420
	struct dst_entry *dst = skb_dst(skb);
421
	struct net *net = dev_net(skb->dev);
422
	struct sock *sk = net->ipv6.ndisc_sk;
423 424
	struct inet6_dev *idev;
	int err;
425
	struct icmp6hdr *icmp6h = icmp6_hdr(skb);
426 427 428 429
	u8 type;

	type = icmp6h->icmp6_type;

430 431 432
	if (!dst) {
		struct sock *sk = net->ipv6.ndisc_sk;
		struct flowi6 fl6;
433

434 435 436 437 438 439 440 441 442
		icmpv6_flow_init(sk, &fl6, type, saddr, daddr, skb->dev->ifindex);
		dst = icmp6_dst_alloc(skb->dev, &fl6);
		if (IS_ERR(dst)) {
			kfree_skb(skb);
			return;
		}

		skb_dst_set(skb, dst);
	}
443

444 445 446 447 448 449 450
	icmp6h->icmp6_cksum = csum_ipv6_magic(saddr, daddr, skb->len,
					      IPPROTO_ICMPV6,
					      csum_partial(icmp6h,
							   skb->len, 0));

	ip6_nd_hdr(skb, saddr, daddr, inet6_sk(sk)->hop_limit, skb->len);

E
Eric Dumazet 已提交
451 452
	rcu_read_lock();
	idev = __in6_dev_get(dst->dev);
453
	IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
454

455
	err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
456
		      dst_output);
L
Linus Torvalds 已提交
457
	if (!err) {
458
		ICMP6MSGOUT_INC_STATS(net, idev, type);
459
		ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
L
Linus Torvalds 已提交
460 461
	}

E
Eric Dumazet 已提交
462
	rcu_read_unlock();
463
}
L
Linus Torvalds 已提交
464

465
static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
466 467
			  const struct in6_addr *daddr,
			  const struct in6_addr *solicited_addr,
468
			  bool router, bool solicited, bool override, bool inc_opt)
469
{
470
	struct sk_buff *skb;
471 472
	struct in6_addr tmpaddr;
	struct inet6_ifaddr *ifp;
473
	const struct in6_addr *src_addr;
474 475
	struct nd_msg *msg;
	int optlen = 0;
476 477

	/* for anycast or proxy, solicited_addr != src_addr */
478
	ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
479 480 481 482
	if (ifp) {
		src_addr = solicited_addr;
		if (ifp->flags & IFA_F_OPTIMISTIC)
			override = 0;
483
		inc_opt |= ifp->idev->cnf.force_tllao;
484 485
		in6_ifa_put(ifp);
	} else {
486
		if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
487
				       inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
488
				       &tmpaddr))
489 490 491 492
			return;
		src_addr = &tmpaddr;
	}

493 494 495 496
	if (!dev->addr_len)
		inc_opt = 0;
	if (inc_opt)
		optlen += ndisc_opt_addr_space(dev);
497

498
	skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
499 500 501
	if (!skb)
		return;

502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
	msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
	*msg = (struct nd_msg) {
		.icmph = {
			.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
			.icmp6_router = router,
			.icmp6_solicited = solicited,
			.icmp6_override = override,
		},
		.target = *solicited_addr,
	};

	if (inc_opt)
		ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR,
				       dev->dev_addr);


518
	ndisc_send_skb(skb, daddr, src_addr);
519 520
}

521 522 523 524 525 526 527 528 529 530 531
static void ndisc_send_unsol_na(struct net_device *dev)
{
	struct inet6_dev *idev;
	struct inet6_ifaddr *ifa;

	idev = in6_dev_get(dev);
	if (!idev)
		return;

	read_lock_bh(&idev->lock);
	list_for_each_entry(ifa, &idev->addr_list, if_list) {
532
		ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &ifa->addr,
533 534 535 536 537 538 539 540 541
			      /*router=*/ !!idev->cnf.forwarding,
			      /*solicited=*/ false, /*override=*/ true,
			      /*inc_opt=*/ true);
	}
	read_unlock_bh(&idev->lock);

	in6_dev_put(idev);
}

L
Linus Torvalds 已提交
542
void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
543 544
		   const struct in6_addr *solicit,
		   const struct in6_addr *daddr, const struct in6_addr *saddr)
L
Linus Torvalds 已提交
545
{
546
	struct sk_buff *skb;
L
Linus Torvalds 已提交
547
	struct in6_addr addr_buf;
548 549 550
	int inc_opt = dev->addr_len;
	int optlen = 0;
	struct nd_msg *msg;
L
Linus Torvalds 已提交
551 552

	if (saddr == NULL) {
553 554
		if (ipv6_get_lladdr(dev, &addr_buf,
				   (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
L
Linus Torvalds 已提交
555 556 557 558
			return;
		saddr = &addr_buf;
	}

559 560 561 562 563 564
	if (ipv6_addr_any(saddr))
		inc_opt = 0;
	if (inc_opt)
		optlen += ndisc_opt_addr_space(dev);

	skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
565 566 567
	if (!skb)
		return;

568 569 570 571 572 573 574 575 576 577 578 579
	msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
	*msg = (struct nd_msg) {
		.icmph = {
			.icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
		},
		.target = *solicit,
	};

	if (inc_opt)
		ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
				       dev->dev_addr);

580
	ndisc_send_skb(skb, daddr, saddr);
L
Linus Torvalds 已提交
581 582
}

583 584
void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
		   const struct in6_addr *daddr)
L
Linus Torvalds 已提交
585
{
586
	struct sk_buff *skb;
587
	struct rs_msg *msg;
588
	int send_sllao = dev->addr_len;
589
	int optlen = 0;
590 591 592 593 594 595 596 597

#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
	/*
	 * According to section 2.2 of RFC 4429, we must not
	 * send router solicitations with a sllao from
	 * optimistic addresses, but we may send the solicitation
	 * if we don't include the sllao.  So here we check
	 * if our address is optimistic, and if so, we
J
Joe Perches 已提交
598
	 * suppress the inclusion of the sllao.
599 600
	 */
	if (send_sllao) {
601
		struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
602
							   dev, 1);
603 604
		if (ifp) {
			if (ifp->flags & IFA_F_OPTIMISTIC)  {
605
				send_sllao = 0;
606
			}
607
			in6_ifa_put(ifp);
608 609 610 611 612
		} else {
			send_sllao = 0;
		}
	}
#endif
613 614 615 616
	if (send_sllao)
		optlen += ndisc_opt_addr_space(dev);

	skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
617 618 619
	if (!skb)
		return;

620 621 622 623 624 625 626 627 628 629 630
	msg = (struct rs_msg *)skb_put(skb, sizeof(*msg));
	*msg = (struct rs_msg) {
		.icmph = {
			.icmp6_type = NDISC_ROUTER_SOLICITATION,
		},
	};

	if (send_sllao)
		ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
				       dev->dev_addr);

631
	ndisc_send_skb(skb, daddr, saddr);
L
Linus Torvalds 已提交
632
}
633

L
Linus Torvalds 已提交
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654

static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
{
	/*
	 *	"The sender MUST return an ICMP
	 *	 destination unreachable"
	 */
	dst_link_failure(skb);
	kfree_skb(skb);
}

/* Called with locked neigh: either read or both */

static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
{
	struct in6_addr *saddr = NULL;
	struct in6_addr mcaddr;
	struct net_device *dev = neigh->dev;
	struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
	int probes = atomic_read(&neigh->probes);

655
	if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
656
		saddr = &ipv6_hdr(skb)->saddr;
L
Linus Torvalds 已提交
657 658 659

	if ((probes -= neigh->parms->ucast_probes) < 0) {
		if (!(neigh->nud_state & NUD_VALID)) {
660 661 662
			ND_PRINTK(1, dbg,
				  "%s: trying to ucast probe in NUD_INVALID: %pI6\n",
				  __func__, target);
L
Linus Torvalds 已提交
663 664 665 666 667 668 669 670 671 672 673 674
		}
		ndisc_send_ns(dev, neigh, target, target, saddr);
	} else if ((probes -= neigh->parms->app_probes) < 0) {
#ifdef CONFIG_ARPD
		neigh_app_ns(neigh);
#endif
	} else {
		addrconf_addr_solict_mult(target, &mcaddr);
		ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
	}
}

675 676
static int pndisc_is_router(const void *pkey,
			    struct net_device *dev)
677 678
{
	struct pneigh_entry *n;
679
	int ret = -1;
680 681

	read_lock_bh(&nd_tbl.lock);
682 683 684
	n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
	if (n)
		ret = !!(n->flags & NTF_ROUTER);
685 686
	read_unlock_bh(&nd_tbl.lock);

687
	return ret;
688 689
}

L
Linus Torvalds 已提交
690 691
static void ndisc_recv_ns(struct sk_buff *skb)
{
692
	struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
693 694
	const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
	const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
L
Linus Torvalds 已提交
695
	u8 *lladdr = NULL;
696 697
	u32 ndoptlen = skb->tail - (skb->transport_header +
				    offsetof(struct nd_msg, opt));
L
Linus Torvalds 已提交
698 699 700 701 702 703
	struct ndisc_options ndopts;
	struct net_device *dev = skb->dev;
	struct inet6_ifaddr *ifp;
	struct inet6_dev *idev = NULL;
	struct neighbour *neigh;
	int dad = ipv6_addr_any(saddr);
704
	bool inc;
705
	int is_router = -1;
L
Linus Torvalds 已提交
706

707 708 709 710 711
	if (skb->len < sizeof(struct nd_msg)) {
		ND_PRINTK(2, warn, "NS: packet too short\n");
		return;
	}

L
Linus Torvalds 已提交
712
	if (ipv6_addr_is_multicast(&msg->target)) {
713
		ND_PRINTK(2, warn, "NS: multicast target address\n");
L
Linus Torvalds 已提交
714 715 716 717 718 719 720
		return;
	}

	/*
	 * RFC2461 7.1.1:
	 * DAD has to be destined for solicited node multicast address.
	 */
721
	if (dad && !ipv6_addr_is_solict_mult(daddr)) {
722
		ND_PRINTK(2, warn, "NS: bad DAD packet (wrong destination)\n");
L
Linus Torvalds 已提交
723 724 725 726
		return;
	}

	if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
727
		ND_PRINTK(2, warn, "NS: invalid ND options\n");
L
Linus Torvalds 已提交
728 729 730 731 732 733
		return;
	}

	if (ndopts.nd_opts_src_lladdr) {
		lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
		if (!lladdr) {
734 735
			ND_PRINTK(2, warn,
				  "NS: invalid link-layer address length\n");
L
Linus Torvalds 已提交
736 737 738 739
			return;
		}

		/* RFC2461 7.1.1:
740 741
		 *	If the IP source address is the unspecified address,
		 *	there MUST NOT be source link-layer address option
L
Linus Torvalds 已提交
742 743 744
		 *	in the message.
		 */
		if (dad) {
745 746
			ND_PRINTK(2, warn,
				  "NS: bad DAD packet (link-layer address option)\n");
L
Linus Torvalds 已提交
747 748 749 750 751 752
			return;
		}
	}

	inc = ipv6_addr_is_multicast(daddr);

753
	ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
754
	if (ifp) {
755 756 757 758 759 760 761 762 763

		if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
			if (dad) {
				/*
				 * We are colliding with another node
				 * who is doing DAD
				 * so fail our DAD process
				 */
				addrconf_dad_failure(ifp);
764
				return;
765 766 767 768 769 770 771 772
			} else {
				/*
				 * This is not a dad solicitation.
				 * If we are an optimistic node,
				 * we should respond.
				 * Otherwise, we should ignore it.
				 */
				if (!(ifp->flags & IFA_F_OPTIMISTIC))
L
Linus Torvalds 已提交
773 774 775 776 777 778
					goto out;
			}
		}

		idev = ifp->idev;
	} else {
779 780
		struct net *net = dev_net(dev);

L
Linus Torvalds 已提交
781 782 783 784 785 786
		idev = in6_dev_get(dev);
		if (!idev) {
			/* XXX: count this drop? */
			return;
		}

787
		if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
788
		    (idev->cnf.forwarding &&
789
		     (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
790
		     (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
791
			if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
L
Linus Torvalds 已提交
792 793 794 795 796
			    skb->pkt_type != PACKET_HOST &&
			    inc != 0 &&
			    idev->nd_parms->proxy_delay != 0) {
				/*
				 * for anycast or proxy,
797 798
				 * sender should delay its response
				 * by a random time between 0 and
L
Linus Torvalds 已提交
799 800 801 802 803 804 805 806 807 808 809 810
				 * MAX_ANYCAST_DELAY_TIME seconds.
				 * (RFC2461) -- yoshfuji
				 */
				struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
				if (n)
					pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
				goto out;
			}
		} else
			goto out;
	}

811
	if (is_router < 0)
812
		is_router = idev->cnf.forwarding;
813

L
Linus Torvalds 已提交
814
	if (dad) {
815
		ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
816
			      !!is_router, false, (ifp != NULL), true);
L
Linus Torvalds 已提交
817 818 819 820 821 822 823 824
		goto out;
	}

	if (inc)
		NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
	else
		NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);

825
	/*
L
Linus Torvalds 已提交
826 827 828 829 830 831
	 *	update / create cache entry
	 *	for the source address
	 */
	neigh = __neigh_lookup(&nd_tbl, saddr, dev,
			       !inc || lladdr || !dev->addr_len);
	if (neigh)
832
		neigh_update(neigh, lladdr, NUD_STALE,
L
Linus Torvalds 已提交
833 834
			     NEIGH_UPDATE_F_WEAK_OVERRIDE|
			     NEIGH_UPDATE_F_OVERRIDE);
835
	if (neigh || !dev->header_ops) {
L
Linus Torvalds 已提交
836
		ndisc_send_na(dev, neigh, saddr, &msg->target,
837 838
			      !!is_router,
			      true, (ifp != NULL && inc), inc);
L
Linus Torvalds 已提交
839 840 841 842 843 844 845 846 847 848 849 850 851
		if (neigh)
			neigh_release(neigh);
	}

out:
	if (ifp)
		in6_ifa_put(ifp);
	else
		in6_dev_put(idev);
}

static void ndisc_recv_na(struct sk_buff *skb)
{
852
	struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
853 854
	const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
	const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
L
Linus Torvalds 已提交
855
	u8 *lladdr = NULL;
856 857
	u32 ndoptlen = skb->tail - (skb->transport_header +
				    offsetof(struct nd_msg, opt));
L
Linus Torvalds 已提交
858 859 860 861 862 863
	struct ndisc_options ndopts;
	struct net_device *dev = skb->dev;
	struct inet6_ifaddr *ifp;
	struct neighbour *neigh;

	if (skb->len < sizeof(struct nd_msg)) {
864
		ND_PRINTK(2, warn, "NA: packet too short\n");
L
Linus Torvalds 已提交
865 866 867 868
		return;
	}

	if (ipv6_addr_is_multicast(&msg->target)) {
869
		ND_PRINTK(2, warn, "NA: target address is multicast\n");
L
Linus Torvalds 已提交
870 871 872 873 874
		return;
	}

	if (ipv6_addr_is_multicast(daddr) &&
	    msg->icmph.icmp6_solicited) {
875
		ND_PRINTK(2, warn, "NA: solicited NA is multicasted\n");
L
Linus Torvalds 已提交
876 877
		return;
	}
878

L
Linus Torvalds 已提交
879
	if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
880
		ND_PRINTK(2, warn, "NS: invalid ND option\n");
L
Linus Torvalds 已提交
881 882 883 884 885
		return;
	}
	if (ndopts.nd_opts_tgt_lladdr) {
		lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
		if (!lladdr) {
886 887
			ND_PRINTK(2, warn,
				  "NA: invalid link-layer address length\n");
L
Linus Torvalds 已提交
888 889 890
			return;
		}
	}
891
	ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
892
	if (ifp) {
893 894 895 896
		if (skb->pkt_type != PACKET_LOOPBACK
		    && (ifp->flags & IFA_F_TENTATIVE)) {
				addrconf_dad_failure(ifp);
				return;
L
Linus Torvalds 已提交
897 898 899 900 901
		}
		/* What should we make now? The advertisement
		   is invalid, but ndisc specs say nothing
		   about it. It could be misconfiguration, or
		   an smart proxy agent tries to help us :-)
902 903 904 905

		   We should not print the error if NA has been
		   received from loopback - it is just our own
		   unsolicited advertisement.
L
Linus Torvalds 已提交
906
		 */
907
		if (skb->pkt_type != PACKET_LOOPBACK)
908 909 910
			ND_PRINTK(1, warn,
				  "NA: someone advertises our address %pI6 on %s!\n",
				  &ifp->addr, ifp->idev->dev->name);
L
Linus Torvalds 已提交
911 912 913 914 915 916 917
		in6_ifa_put(ifp);
		return;
	}
	neigh = neigh_lookup(&nd_tbl, &msg->target, dev);

	if (neigh) {
		u8 old_flags = neigh->flags;
918
		struct net *net = dev_net(dev);
L
Linus Torvalds 已提交
919 920 921 922

		if (neigh->nud_state & NUD_FAILED)
			goto out;

923 924 925 926 927 928
		/*
		 * Don't update the neighbor cache entry on a proxy NA from
		 * ourselves because either the proxied node is off link or it
		 * has already sent a NA to us.
		 */
		if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
929 930
		    net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
		    pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
931
			/* XXX: idev->cnf.proxy_ndp */
932
			goto out;
933
		}
934

L
Linus Torvalds 已提交
935 936 937 938 939 940 941 942 943 944 945 946 947 948
		neigh_update(neigh, lladdr,
			     msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
			     NEIGH_UPDATE_F_WEAK_OVERRIDE|
			     (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
			     NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
			     (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));

		if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
			/*
			 * Change: router to host
			 */
			struct rt6_info *rt;
			rt = rt6_get_dflt_router(saddr, dev);
			if (rt)
949
				ip6_del_rt(rt);
L
Linus Torvalds 已提交
950 951 952 953 954 955 956 957 958
		}

out:
		neigh_release(neigh);
	}
}

static void ndisc_recv_rs(struct sk_buff *skb)
{
959
	struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
L
Linus Torvalds 已提交
960 961 962
	unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
	struct neighbour *neigh;
	struct inet6_dev *idev;
963
	const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
L
Linus Torvalds 已提交
964 965 966 967 968 969
	struct ndisc_options ndopts;
	u8 *lladdr = NULL;

	if (skb->len < sizeof(*rs_msg))
		return;

E
Eric Dumazet 已提交
970
	idev = __in6_dev_get(skb->dev);
L
Linus Torvalds 已提交
971
	if (!idev) {
972
		ND_PRINTK(1, err, "RS: can't find in6 device\n");
L
Linus Torvalds 已提交
973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
		return;
	}

	/* Don't accept RS if we're not in router mode */
	if (!idev->cnf.forwarding)
		goto out;

	/*
	 * Don't update NCE if src = ::;
	 * this implies that the source node has no ip address assigned yet.
	 */
	if (ipv6_addr_any(saddr))
		goto out;

	/* Parse ND options */
	if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
989
		ND_PRINTK(2, notice, "NS: invalid ND option, ignored\n");
L
Linus Torvalds 已提交
990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
		goto out;
	}

	if (ndopts.nd_opts_src_lladdr) {
		lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
					     skb->dev);
		if (!lladdr)
			goto out;
	}

	neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
	if (neigh) {
		neigh_update(neigh, lladdr, NUD_STALE,
			     NEIGH_UPDATE_F_WEAK_OVERRIDE|
			     NEIGH_UPDATE_F_OVERRIDE|
			     NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
		neigh_release(neigh);
	}
out:
E
Eric Dumazet 已提交
1009
	return;
L
Linus Torvalds 已提交
1010 1011
}

1012 1013 1014 1015 1016 1017
static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
{
	struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
	struct sk_buff *skb;
	struct nlmsghdr *nlh;
	struct nduseroptmsg *ndmsg;
1018
	struct net *net = dev_net(ra->dev);
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
	int err;
	int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
				    + (opt->nd_opt_len << 3));
	size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));

	skb = nlmsg_new(msg_size, GFP_ATOMIC);
	if (skb == NULL) {
		err = -ENOBUFS;
		goto errout;
	}

	nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
	if (nlh == NULL) {
		goto nla_put_failure;
	}

	ndmsg = nlmsg_data(nlh);
	ndmsg->nduseropt_family = AF_INET6;
1037
	ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1038 1039 1040 1041 1042 1043
	ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
	ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
	ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;

	memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);

D
David S. Miller 已提交
1044 1045 1046
	if (nla_put(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
		    &ipv6_hdr(ra)->saddr))
		goto nla_put_failure;
1047 1048
	nlmsg_end(skb, nlh);

1049
	rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
1050 1051 1052 1053 1054 1055
	return;

nla_put_failure:
	nlmsg_free(skb);
	err = -EMSGSIZE;
errout:
1056
	rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1057 1058
}

L
Linus Torvalds 已提交
1059 1060
static void ndisc_router_discovery(struct sk_buff *skb)
{
1061
	struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
L
Linus Torvalds 已提交
1062 1063
	struct neighbour *neigh = NULL;
	struct inet6_dev *in6_dev;
1064
	struct rt6_info *rt = NULL;
L
Linus Torvalds 已提交
1065 1066 1067
	int lifetime;
	struct ndisc_options ndopts;
	int optlen;
1068
	unsigned int pref = 0;
L
Linus Torvalds 已提交
1069 1070 1071

	__u8 * opt = (__u8 *)(ra_msg + 1);

1072
	optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
L
Linus Torvalds 已提交
1073

1074
	if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1075
		ND_PRINTK(2, warn, "RA: source address is not link-local\n");
L
Linus Torvalds 已提交
1076 1077 1078
		return;
	}
	if (optlen < 0) {
1079
		ND_PRINTK(2, warn, "RA: packet too short\n");
L
Linus Torvalds 已提交
1080 1081 1082
		return;
	}

1083
#ifdef CONFIG_IPV6_NDISC_NODETYPE
1084
	if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1085
		ND_PRINTK(2, warn, "RA: from host or unauthorized router\n");
1086 1087
		return;
	}
1088
#endif
1089

L
Linus Torvalds 已提交
1090 1091 1092 1093
	/*
	 *	set the RA_RECV flag in the interface
	 */

E
Eric Dumazet 已提交
1094
	in6_dev = __in6_dev_get(skb->dev);
L
Linus Torvalds 已提交
1095
	if (in6_dev == NULL) {
1096 1097
		ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n",
			  skb->dev->name);
L
Linus Torvalds 已提交
1098 1099 1100 1101
		return;
	}

	if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1102
		ND_PRINTK(2, warn, "RA: invalid ND options\n");
L
Linus Torvalds 已提交
1103 1104 1105
		return;
	}

1106
	if (!ipv6_accept_ra(in6_dev))
1107 1108
		goto skip_linkparms;

1109
#ifdef CONFIG_IPV6_NDISC_NODETYPE
1110 1111 1112
	/* skip link-specific parameters from interior routers */
	if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
		goto skip_linkparms;
1113
#endif
1114

L
Linus Torvalds 已提交
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
	if (in6_dev->if_flags & IF_RS_SENT) {
		/*
		 *	flag that an RA was received after an RS was sent
		 *	out on this interface.
		 */
		in6_dev->if_flags |= IF_RA_RCVD;
	}

	/*
	 * Remember the managed/otherconf flags from most recently
	 * received RA message (RFC 2462) -- yoshfuji
	 */
	in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
				IF_RA_OTHERCONF)) |
				(ra_msg->icmph.icmp6_addrconf_managed ?
					IF_RA_MANAGED : 0) |
				(ra_msg->icmph.icmp6_addrconf_other ?
					IF_RA_OTHERCONF : 0);

1134 1135 1136
	if (!in6_dev->cnf.accept_ra_defrtr)
		goto skip_defrtr;

1137 1138 1139
	if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
		goto skip_defrtr;

L
Linus Torvalds 已提交
1140 1141
	lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);

1142 1143 1144
#ifdef CONFIG_IPV6_ROUTER_PREF
	pref = ra_msg->icmph.icmp6_router_pref;
	/* 10b is handled as if it were 00b (medium) */
1145
	if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1146
	    !in6_dev->cnf.accept_ra_rtr_pref)
1147 1148 1149
		pref = ICMPV6_ROUTER_PREF_MEDIUM;
#endif

1150
	rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
L
Linus Torvalds 已提交
1151

1152 1153 1154
	if (rt) {
		neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
		if (!neigh) {
1155 1156 1157
			ND_PRINTK(0, err,
				  "RA: %s got default router without neighbour\n",
				  __func__);
A
Amerigo Wang 已提交
1158
			ip6_rt_put(rt);
1159 1160 1161
			return;
		}
	}
L
Linus Torvalds 已提交
1162
	if (rt && lifetime == 0) {
1163
		ip6_del_rt(rt);
L
Linus Torvalds 已提交
1164 1165 1166 1167
		rt = NULL;
	}

	if (rt == NULL && lifetime) {
1168
		ND_PRINTK(3, dbg, "RA: adding default router\n");
L
Linus Torvalds 已提交
1169

1170
		rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
L
Linus Torvalds 已提交
1171
		if (rt == NULL) {
1172 1173 1174
			ND_PRINTK(0, err,
				  "RA: %s failed to add default route\n",
				  __func__);
L
Linus Torvalds 已提交
1175 1176 1177
			return;
		}

1178
		neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
L
Linus Torvalds 已提交
1179
		if (neigh == NULL) {
1180 1181 1182
			ND_PRINTK(0, err,
				  "RA: %s got default router without neighbour\n",
				  __func__);
A
Amerigo Wang 已提交
1183
			ip6_rt_put(rt);
L
Linus Torvalds 已提交
1184 1185 1186
			return;
		}
		neigh->flags |= NTF_ROUTER;
1187
	} else if (rt) {
1188
		rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
L
Linus Torvalds 已提交
1189 1190 1191
	}

	if (rt)
1192
		rt6_set_expires(rt, jiffies + (HZ * lifetime));
L
Linus Torvalds 已提交
1193 1194 1195
	if (ra_msg->icmph.icmp6_hop_limit) {
		in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
		if (rt)
1196 1197
			dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
				       ra_msg->icmph.icmp6_hop_limit);
L
Linus Torvalds 已提交
1198 1199
	}

1200 1201
skip_defrtr:

L
Linus Torvalds 已提交
1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
	/*
	 *	Update Reachable Time and Retrans Timer
	 */

	if (in6_dev->nd_parms) {
		unsigned long rtime = ntohl(ra_msg->retrans_timer);

		if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
			rtime = (rtime*HZ)/1000;
			if (rtime < HZ/10)
				rtime = HZ/10;
			in6_dev->nd_parms->retrans_time = rtime;
			in6_dev->tstamp = jiffies;
			inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
		}

		rtime = ntohl(ra_msg->reachable_time);
		if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
			rtime = (rtime*HZ)/1000;

			if (rtime < HZ/10)
				rtime = HZ/10;

			if (rtime != in6_dev->nd_parms->base_reachable_time) {
				in6_dev->nd_parms->base_reachable_time = rtime;
				in6_dev->nd_parms->gc_staletime = 3 * rtime;
				in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
				in6_dev->tstamp = jiffies;
				inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
			}
		}
	}

1235 1236
skip_linkparms:

L
Linus Torvalds 已提交
1237 1238 1239 1240 1241
	/*
	 *	Process options.
	 */

	if (!neigh)
1242
		neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
L
Linus Torvalds 已提交
1243 1244 1245 1246 1247 1248 1249
				       skb->dev, 1);
	if (neigh) {
		u8 *lladdr = NULL;
		if (ndopts.nd_opts_src_lladdr) {
			lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
						     skb->dev);
			if (!lladdr) {
1250 1251
				ND_PRINTK(2, warn,
					  "RA: invalid link-layer address length\n");
L
Linus Torvalds 已提交
1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
				goto out;
			}
		}
		neigh_update(neigh, lladdr, NUD_STALE,
			     NEIGH_UPDATE_F_WEAK_OVERRIDE|
			     NEIGH_UPDATE_F_OVERRIDE|
			     NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
			     NEIGH_UPDATE_F_ISROUTER);
	}

1262
	if (!ipv6_accept_ra(in6_dev))
1263 1264
		goto out;

1265
#ifdef CONFIG_IPV6_ROUTE_INFO
1266 1267 1268
	if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
		goto skip_routeinfo;

1269
	if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1270 1271 1272 1273
		struct nd_opt_hdr *p;
		for (p = ndopts.nd_opts_ri;
		     p;
		     p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1274 1275 1276 1277 1278 1279 1280
			struct route_info *ri = (struct route_info *)p;
#ifdef CONFIG_IPV6_NDISC_NODETYPE
			if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
			    ri->prefix_len == 0)
				continue;
#endif
			if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1281
				continue;
1282
			rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1283
				      &ipv6_hdr(skb)->saddr);
1284 1285
		}
	}
1286 1287

skip_routeinfo:
1288 1289
#endif

1290
#ifdef CONFIG_IPV6_NDISC_NODETYPE
1291 1292 1293
	/* skip link-specific ndopts from interior routers */
	if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
		goto out;
1294
#endif
1295

1296
	if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
L
Linus Torvalds 已提交
1297 1298 1299 1300
		struct nd_opt_hdr *p;
		for (p = ndopts.nd_opts_pi;
		     p;
		     p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1301 1302 1303
			addrconf_prefix_rcv(skb->dev, (u8 *)p,
					    (p->nd_opt_len) << 3,
					    ndopts.nd_opts_src_lladdr != NULL);
L
Linus Torvalds 已提交
1304 1305 1306 1307
		}
	}

	if (ndopts.nd_opts_mtu) {
A
Al Viro 已提交
1308
		__be32 n;
L
Linus Torvalds 已提交
1309 1310
		u32 mtu;

A
Al Viro 已提交
1311 1312
		memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
		mtu = ntohl(n);
L
Linus Torvalds 已提交
1313 1314

		if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1315
			ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu);
L
Linus Torvalds 已提交
1316 1317 1318 1319
		} else if (in6_dev->cnf.mtu6 != mtu) {
			in6_dev->cnf.mtu6 = mtu;

			if (rt)
1320
				dst_metric_set(&rt->dst, RTAX_MTU, mtu);
L
Linus Torvalds 已提交
1321 1322 1323 1324

			rt6_mtu_change(skb->dev, mtu);
		}
	}
1325

1326
	if (ndopts.nd_useropts) {
1327 1328 1329 1330 1331
		struct nd_opt_hdr *p;
		for (p = ndopts.nd_useropts;
		     p;
		     p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
			ndisc_ra_useropt(skb, p);
1332 1333 1334
		}
	}

L
Linus Torvalds 已提交
1335
	if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1336
		ND_PRINTK(2, warn, "RA: invalid RA options\n");
L
Linus Torvalds 已提交
1337 1338
	}
out:
A
Amerigo Wang 已提交
1339
	ip6_rt_put(rt);
1340
	if (neigh)
L
Linus Torvalds 已提交
1341 1342 1343 1344 1345
		neigh_release(neigh);
}

static void ndisc_redirect_rcv(struct sk_buff *skb)
{
1346 1347 1348 1349 1350 1351
	u8 *hdr;
	struct ndisc_options ndopts;
	struct rd_msg *msg = (struct rd_msg *)skb_transport_header(skb);
	u32 ndoptlen = skb->tail - (skb->transport_header +
				    offsetof(struct rd_msg, opt));

1352
#ifdef CONFIG_IPV6_NDISC_NODETYPE
1353 1354 1355
	switch (skb->ndisc_nodetype) {
	case NDISC_NODETYPE_HOST:
	case NDISC_NODETYPE_NODEFAULT:
1356 1357
		ND_PRINTK(2, warn,
			  "Redirect: from host or unauthorized router\n");
1358 1359
		return;
	}
1360
#endif
1361

1362
	if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1363 1364
		ND_PRINTK(2, warn,
			  "Redirect: source address is not link-local\n");
L
Linus Torvalds 已提交
1365 1366 1367
		return;
	}

1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378
	if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts))
		return;

	if (!ndopts.nd_opts_rh)
		return;

	hdr = (u8 *)ndopts.nd_opts_rh;
	hdr += 8;
	if (!pskb_pull(skb, hdr - skb_transport_header(skb)))
		return;

1379
	icmpv6_notify(skb, NDISC_REDIRECT, 0, 0);
L
Linus Torvalds 已提交
1380 1381
}

1382 1383 1384
static void ndisc_fill_redirect_hdr_option(struct sk_buff *skb,
					   struct sk_buff *orig_skb,
					   int rd_len)
1385
{
1386 1387
	u8 *opt = skb_put(skb, rd_len);

1388 1389 1390 1391 1392 1393 1394 1395
	memset(opt, 0, 8);
	*(opt++) = ND_OPT_REDIRECT_HDR;
	*(opt++) = (rd_len >> 3);
	opt += 6;

	memcpy(opt, ipv6_hdr(orig_skb), rd_len - 8);
}

1396
void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target)
L
Linus Torvalds 已提交
1397
{
1398
	struct net_device *dev = skb->dev;
1399
	struct net *net = dev_net(dev);
1400
	struct sock *sk = net->ipv6.ndisc_sk;
1401
	int optlen = 0;
1402
	struct inet_peer *peer;
L
Linus Torvalds 已提交
1403
	struct sk_buff *buff;
1404
	struct rd_msg *msg;
L
Linus Torvalds 已提交
1405 1406 1407
	struct in6_addr saddr_buf;
	struct rt6_info *rt;
	struct dst_entry *dst;
1408
	struct flowi6 fl6;
L
Linus Torvalds 已提交
1409 1410
	int rd_len;
	u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1411
	bool ret;
L
Linus Torvalds 已提交
1412

1413
	if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1414 1415
		ND_PRINTK(2, warn, "Redirect: no link-local address on %s\n",
			  dev->name);
1416 1417
		return;
	}
L
Linus Torvalds 已提交
1418

1419
	if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1420
	    ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1421 1422
		ND_PRINTK(2, warn,
			  "Redirect: target address is not link-local unicast\n");
1423 1424 1425
		return;
	}

1426
	icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
1427
			 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
L
Linus Torvalds 已提交
1428

1429
	dst = ip6_route_output(net, NULL, &fl6);
1430 1431
	if (dst->error) {
		dst_release(dst);
L
Linus Torvalds 已提交
1432
		return;
1433
	}
1434
	dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
1435
	if (IS_ERR(dst))
L
Linus Torvalds 已提交
1436 1437 1438 1439 1440
		return;

	rt = (struct rt6_info *) dst;

	if (rt->rt6i_flags & RTF_GATEWAY) {
1441 1442
		ND_PRINTK(2, warn,
			  "Redirect: destination is not a neighbour\n");
I
Ilpo Järvinen 已提交
1443
		goto release;
L
Linus Torvalds 已提交
1444
	}
1445 1446 1447 1448 1449
	peer = inet_getpeer_v6(net->ipv6.peers, &rt->rt6i_dst.addr, 1);
	ret = inet_peer_xrlim_allow(peer, 1*HZ);
	if (peer)
		inet_putpeer(peer);
	if (!ret)
I
Ilpo Järvinen 已提交
1450
		goto release;
L
Linus Torvalds 已提交
1451 1452

	if (dev->addr_len) {
1453 1454
		struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target);
		if (!neigh) {
1455 1456
			ND_PRINTK(2, warn,
				  "Redirect: no neigh for target address\n");
1457 1458 1459
			goto release;
		}

L
Linus Torvalds 已提交
1460 1461 1462 1463 1464
		read_lock_bh(&neigh->lock);
		if (neigh->nud_state & NUD_VALID) {
			memcpy(ha_buf, neigh->ha, dev->addr_len);
			read_unlock_bh(&neigh->lock);
			ha = ha_buf;
1465
			optlen += ndisc_opt_addr_space(dev);
L
Linus Torvalds 已提交
1466 1467
		} else
			read_unlock_bh(&neigh->lock);
1468 1469

		neigh_release(neigh);
L
Linus Torvalds 已提交
1470 1471 1472
	}

	rd_len = min_t(unsigned int,
1473 1474
		       IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(*msg) - optlen,
		       skb->len + 8);
L
Linus Torvalds 已提交
1475
	rd_len &= ~0x7;
1476
	optlen += rd_len;
L
Linus Torvalds 已提交
1477

1478
	buff = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
1479
	if (!buff)
I
Ilpo Järvinen 已提交
1480
		goto release;
L
Linus Torvalds 已提交
1481

1482 1483 1484 1485 1486 1487 1488 1489
	msg = (struct rd_msg *)skb_put(buff, sizeof(*msg));
	*msg = (struct rd_msg) {
		.icmph = {
			.icmp6_type = NDISC_REDIRECT,
		},
		.target = *target,
		.dest = ipv6_hdr(skb)->daddr,
	};
L
Linus Torvalds 已提交
1490 1491 1492 1493 1494 1495

	/*
	 *	include target_address option
	 */

	if (ha)
1496
		ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR, ha);
L
Linus Torvalds 已提交
1497 1498 1499 1500 1501

	/*
	 *	build redirect option and copy skb over to the new packet.
	 */

1502
	if (rd_len)
1503
		ndisc_fill_redirect_hdr_option(buff, skb, rd_len);
L
Linus Torvalds 已提交
1504

E
Eric Dumazet 已提交
1505
	skb_dst_set(buff, dst);
1506
	ndisc_send_skb(buff, &ipv6_hdr(skb)->saddr, &saddr_buf);
I
Ilpo Järvinen 已提交
1507 1508 1509 1510
	return;

release:
	dst_release(dst);
L
Linus Torvalds 已提交
1511 1512 1513 1514
}

static void pndisc_redo(struct sk_buff *skb)
{
1515
	ndisc_recv_ns(skb);
L
Linus Torvalds 已提交
1516 1517 1518 1519 1520 1521 1522
	kfree_skb(skb);
}

int ndisc_rcv(struct sk_buff *skb)
{
	struct nd_msg *msg;

1523
	if (skb_linearize(skb))
L
Linus Torvalds 已提交
1524 1525
		return 0;

1526
	msg = (struct nd_msg *)skb_transport_header(skb);
L
Linus Torvalds 已提交
1527

1528
	__skb_push(skb, skb->data - skb_transport_header(skb));
L
Linus Torvalds 已提交
1529

1530
	if (ipv6_hdr(skb)->hop_limit != 255) {
1531 1532
		ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n",
			  ipv6_hdr(skb)->hop_limit);
L
Linus Torvalds 已提交
1533 1534 1535 1536
		return 0;
	}

	if (msg->icmph.icmp6_code != 0) {
1537 1538
		ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n",
			  msg->icmph.icmp6_code);
L
Linus Torvalds 已提交
1539 1540 1541
		return 0;
	}

1542 1543
	memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));

L
Linus Torvalds 已提交
1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
	switch (msg->icmph.icmp6_type) {
	case NDISC_NEIGHBOUR_SOLICITATION:
		ndisc_recv_ns(skb);
		break;

	case NDISC_NEIGHBOUR_ADVERTISEMENT:
		ndisc_recv_na(skb);
		break;

	case NDISC_ROUTER_SOLICITATION:
		ndisc_recv_rs(skb);
		break;

	case NDISC_ROUTER_ADVERTISEMENT:
		ndisc_router_discovery(skb);
		break;

	case NDISC_REDIRECT:
		ndisc_redirect_rcv(skb);
		break;
1564
	}
L
Linus Torvalds 已提交
1565 1566 1567 1568 1569 1570 1571

	return 0;
}

static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
{
	struct net_device *dev = ptr;
1572
	struct net *net = dev_net(dev);
1573
	struct inet6_dev *idev;
L
Linus Torvalds 已提交
1574 1575 1576 1577

	switch (event) {
	case NETDEV_CHANGEADDR:
		neigh_changeaddr(&nd_tbl, dev);
1578
		fib6_run_gc(~0UL, net);
1579 1580 1581 1582 1583 1584
		idev = in6_dev_get(dev);
		if (!idev)
			break;
		if (idev->cnf.ndisc_notify)
			ndisc_send_unsol_na(dev);
		in6_dev_put(idev);
L
Linus Torvalds 已提交
1585 1586 1587
		break;
	case NETDEV_DOWN:
		neigh_ifdown(&nd_tbl, dev);
1588
		fib6_run_gc(~0UL, net);
L
Linus Torvalds 已提交
1589
		break;
1590 1591 1592
	case NETDEV_NOTIFY_PEERS:
		ndisc_send_unsol_na(dev);
		break;
L
Linus Torvalds 已提交
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611
	default:
		break;
	}

	return NOTIFY_DONE;
}

static struct notifier_block ndisc_netdev_notifier = {
	.notifier_call = ndisc_netdev_event,
};

#ifdef CONFIG_SYSCTL
static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
					 const char *func, const char *dev_name)
{
	static char warncomm[TASK_COMM_LEN];
	static int warned;
	if (strcmp(warncomm, current->comm) && warned < 5) {
		strcpy(warncomm, current->comm);
1612
		pr_warn("process `%s' is using deprecated sysctl (%s) net.ipv6.neigh.%s.%s - use net.ipv6.neigh.%s.%s_ms instead\n",
L
Linus Torvalds 已提交
1613 1614 1615 1616 1617 1618 1619
			warncomm, func,
			dev_name, ctl->procname,
			dev_name, ctl->procname);
		warned++;
	}
}

1620
int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
L
Linus Torvalds 已提交
1621 1622 1623 1624 1625
{
	struct net_device *dev = ctl->extra1;
	struct inet6_dev *idev;
	int ret;

1626 1627
	if ((strcmp(ctl->procname, "retrans_time") == 0) ||
	    (strcmp(ctl->procname, "base_reachable_time") == 0))
L
Linus Torvalds 已提交
1628 1629
		ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");

1630
	if (strcmp(ctl->procname, "retrans_time") == 0)
1631
		ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1632 1633

	else if (strcmp(ctl->procname, "base_reachable_time") == 0)
L
Linus Torvalds 已提交
1634
		ret = proc_dointvec_jiffies(ctl, write,
1635
					    buffer, lenp, ppos);
1636 1637

	else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1638
		 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
L
Linus Torvalds 已提交
1639
		ret = proc_dointvec_ms_jiffies(ctl, write,
1640
					       buffer, lenp, ppos);
1641
	else
L
Linus Torvalds 已提交
1642 1643 1644
		ret = -1;

	if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1645
		if (ctl->data == &idev->nd_parms->base_reachable_time)
L
Linus Torvalds 已提交
1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656
			idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
		idev->tstamp = jiffies;
		inet6_ifinfo_notify(RTM_NEWLINK, idev);
		in6_dev_put(idev);
	}
	return ret;
}


#endif

1657
static int __net_init ndisc_net_init(struct net *net)
L
Linus Torvalds 已提交
1658 1659 1660
{
	struct ipv6_pinfo *np;
	struct sock *sk;
1661
	int err;
L
Linus Torvalds 已提交
1662

1663 1664
	err = inet_ctl_sock_create(&sk, PF_INET6,
				   SOCK_RAW, IPPROTO_ICMPV6, net);
L
Linus Torvalds 已提交
1665
	if (err < 0) {
1666 1667 1668
		ND_PRINTK(0, err,
			  "NDISC: Failed to initialize the control socket (err %d)\n",
			  err);
L
Linus Torvalds 已提交
1669 1670 1671
		return err;
	}

1672
	net->ipv6.ndisc_sk = sk;
1673

L
Linus Torvalds 已提交
1674 1675 1676 1677 1678
	np = inet6_sk(sk);
	np->hop_limit = 255;
	/* Do not loopback ndisc messages */
	np->mc_loop = 0;

1679 1680 1681
	return 0;
}

1682
static void __net_exit ndisc_net_exit(struct net *net)
1683
{
1684
	inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698
}

static struct pernet_operations ndisc_net_ops = {
	.init = ndisc_net_init,
	.exit = ndisc_net_exit,
};

int __init ndisc_init(void)
{
	int err;

	err = register_pernet_subsys(&ndisc_net_ops);
	if (err)
		return err;
1699 1700 1701
	/*
	 * Initialize the neighbour table
	 */
L
Linus Torvalds 已提交
1702 1703 1704
	neigh_table_init(&nd_tbl);

#ifdef CONFIG_SYSCTL
1705
	err = neigh_sysctl_register(NULL, &nd_tbl.parms, "ipv6",
1706
				    &ndisc_ifinfo_sysctl_change);
1707 1708
	if (err)
		goto out_unregister_pernet;
L
Linus Torvalds 已提交
1709
#endif
1710 1711 1712 1713 1714
	err = register_netdevice_notifier(&ndisc_netdev_notifier);
	if (err)
		goto out_unregister_sysctl;
out:
	return err;
L
Linus Torvalds 已提交
1715

1716 1717 1718 1719 1720 1721 1722
out_unregister_sysctl:
#ifdef CONFIG_SYSCTL
	neigh_sysctl_unregister(&nd_tbl.parms);
out_unregister_pernet:
#endif
	unregister_pernet_subsys(&ndisc_net_ops);
	goto out;
L
Linus Torvalds 已提交
1723 1724 1725 1726
}

void ndisc_cleanup(void)
{
1727
	unregister_netdevice_notifier(&ndisc_netdev_notifier);
L
Linus Torvalds 已提交
1728 1729 1730 1731
#ifdef CONFIG_SYSCTL
	neigh_sysctl_unregister(&nd_tbl.parms);
#endif
	neigh_table_clear(&nd_tbl);
1732
	unregister_pernet_subsys(&ndisc_net_ops);
L
Linus Torvalds 已提交
1733
}