addrconf.c 131.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 *	IPv6 Address [auto]configuration
 *	Linux INET6 implementation
 *
 *	Authors:
6
 *	Pedro Roque		<roque@di.fc.ul.pt>
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 *	Alexey Kuznetsov	<kuznet@ms2.inr.ac.ru>
 *
 *	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:
 *
 *	Janos Farkas			:	delete timer on ifdown
 *	<chexum@bankinf.banki.hu>
 *	Andi Kleen			:	kill double kfree on module
 *						unload.
 *	Maciej W. Rozycki		:	FDDI support
 *	sekiya@USAGI			:	Don't send too many RS
 *						packets.
 *	yoshfuji@USAGI			:       Fixed interval between DAD
 *						packets.
 *	YOSHIFUJI Hideaki @USAGI	:	improved accuracy of
 *						address validation timer.
 *	YOSHIFUJI Hideaki @USAGI	:	Privacy Extensions (RFC3041)
 *						support.
 *	Yuji SEKIYA @USAGI		:	Don't assign a same IPv6
 *						address on a same interface.
 *	YOSHIFUJI Hideaki @USAGI	:	ARCnet support
 *	YOSHIFUJI Hideaki @USAGI	:	convert /proc/net/if_inet6 to
 *						seq_file.
36 37 38
 *	YOSHIFUJI Hideaki @USAGI	:	improved source address
 *						selection; consider scope,
 *						status etc.
L
Linus Torvalds 已提交
39 40
 */

41 42
#define pr_fmt(fmt) "IPv6: " fmt

L
Linus Torvalds 已提交
43 44
#include <linux/errno.h>
#include <linux/types.h>
45
#include <linux/kernel.h>
L
Linus Torvalds 已提交
46 47 48 49 50
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/in6.h>
#include <linux/netdevice.h>
51
#include <linux/if_addr.h>
L
Linus Torvalds 已提交
52 53 54 55 56 57
#include <linux/if_arp.h>
#include <linux/if_arcnet.h>
#include <linux/if_infiniband.h>
#include <linux/route.h>
#include <linux/inetdevice.h>
#include <linux/init.h>
58
#include <linux/slab.h>
L
Linus Torvalds 已提交
59 60 61
#ifdef CONFIG_SYSCTL
#include <linux/sysctl.h>
#endif
62
#include <linux/capability.h>
L
Linus Torvalds 已提交
63 64
#include <linux/delay.h>
#include <linux/notifier.h>
65
#include <linux/string.h>
E
Eric Dumazet 已提交
66
#include <linux/hash.h>
L
Linus Torvalds 已提交
67

68
#include <net/net_namespace.h>
L
Linus Torvalds 已提交
69 70 71
#include <net/sock.h>
#include <net/snmp.h>

72
#include <net/af_ieee802154.h>
73
#include <net/firewire.h>
L
Linus Torvalds 已提交
74 75 76 77 78 79 80
#include <net/ipv6.h>
#include <net/protocol.h>
#include <net/ndisc.h>
#include <net/ip6_route.h>
#include <net/addrconf.h>
#include <net/tcp.h>
#include <net/ip.h>
81
#include <net/netlink.h>
82
#include <net/pkt_sched.h>
L
Linus Torvalds 已提交
83 84
#include <linux/if_tunnel.h>
#include <linux/rtnetlink.h>
85
#include <linux/netconf.h>
L
Linus Torvalds 已提交
86
#include <linux/random.h>
S
Stephen Hemminger 已提交
87
#include <linux/uaccess.h>
88
#include <asm/unaligned.h>
L
Linus Torvalds 已提交
89 90 91

#include <linux/proc_fs.h>
#include <linux/seq_file.h>
92
#include <linux/export.h>
L
Linus Torvalds 已提交
93 94 95 96 97

/* Set to 3 to get tracing... */
#define ACONF_DEBUG 2

#if ACONF_DEBUG >= 3
98
#define ADBG(fmt, ...) printk(fmt, ##__VA_ARGS__)
L
Linus Torvalds 已提交
99
#else
100
#define ADBG(fmt, ...) do { if (0) printk(fmt, ##__VA_ARGS__); } while (0)
L
Linus Torvalds 已提交
101 102 103
#endif

#define	INFINITY_LIFE_TIME	0xFFFFFFFF
104 105 106 107 108

static inline u32 cstamp_delta(unsigned long cstamp)
{
	return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
}
L
Linus Torvalds 已提交
109 110

#ifdef CONFIG_SYSCTL
111
static int addrconf_sysctl_register(struct inet6_dev *idev);
112 113
static void addrconf_sysctl_unregister(struct inet6_dev *idev);
#else
114
static inline int addrconf_sysctl_register(struct inet6_dev *idev)
115
{
116
	return 0;
117 118 119 120 121
}

static inline void addrconf_sysctl_unregister(struct inet6_dev *idev)
{
}
L
Linus Torvalds 已提交
122 123
#endif

S
Sorin Dumitru 已提交
124 125
static void __ipv6_regen_rndid(struct inet6_dev *idev);
static void __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr);
L
Linus Torvalds 已提交
126 127
static void ipv6_regen_rndid(unsigned long data);

128
static int ipv6_generate_eui64(u8 *eui, struct net_device *dev);
L
Linus Torvalds 已提交
129 130 131 132 133
static int ipv6_count_addresses(struct inet6_dev *idev);

/*
 *	Configured unicast address hash table
 */
134
static struct hlist_head inet6_addr_lst[IN6_ADDR_HSIZE];
135
static DEFINE_SPINLOCK(addrconf_hash_lock);
L
Linus Torvalds 已提交
136

137 138 139
static void addrconf_verify(void);
static void addrconf_verify_rtnl(void);
static void addrconf_verify_work(struct work_struct *);
L
Linus Torvalds 已提交
140

141 142
static struct workqueue_struct *addrconf_wq;
static DECLARE_DELAYED_WORK(addr_chk_work, addrconf_verify_work);
L
Linus Torvalds 已提交
143 144 145 146

static void addrconf_join_anycast(struct inet6_ifaddr *ifp);
static void addrconf_leave_anycast(struct inet6_ifaddr *ifp);

147 148
static void addrconf_type_change(struct net_device *dev,
				 unsigned long event);
L
Linus Torvalds 已提交
149 150
static int addrconf_ifdown(struct net_device *dev, int how);

151 152 153 154 155
static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
						  int plen,
						  const struct net_device *dev,
						  u32 flags, u32 noflags);

156
static void addrconf_dad_start(struct inet6_ifaddr *ifp);
157
static void addrconf_dad_work(struct work_struct *w);
L
Linus Torvalds 已提交
158
static void addrconf_dad_completed(struct inet6_ifaddr *ifp);
159
static void addrconf_dad_run(struct inet6_dev *idev);
L
Linus Torvalds 已提交
160 161 162 163
static void addrconf_rs_timer(unsigned long data);
static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);

164
static void inet6_prefix_notify(int event, struct inet6_dev *idev,
L
Linus Torvalds 已提交
165
				struct prefix_info *pinfo);
166 167
static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
			       struct net_device *dev);
L
Linus Torvalds 已提交
168

169
static struct ipv6_devconf ipv6_devconf __read_mostly = {
L
Linus Torvalds 已提交
170 171 172 173 174 175 176
	.forwarding		= 0,
	.hop_limit		= IPV6_DEFAULT_HOPLIMIT,
	.mtu6			= IPV6_MIN_MTU,
	.accept_ra		= 1,
	.accept_redirects	= 1,
	.autoconf		= 1,
	.force_mld_version	= 0,
177 178
	.mldv1_unsolicited_report_interval = 10 * HZ,
	.mldv2_unsolicited_report_interval = HZ,
L
Linus Torvalds 已提交
179 180 181 182 183 184 185 186 187 188
	.dad_transmits		= 1,
	.rtr_solicits		= MAX_RTR_SOLICITATIONS,
	.rtr_solicit_interval	= RTR_SOLICITATION_INTERVAL,
	.rtr_solicit_delay	= MAX_RTR_SOLICITATION_DELAY,
	.use_tempaddr 		= 0,
	.temp_valid_lft		= TEMP_VALID_LIFETIME,
	.temp_prefered_lft	= TEMP_PREFERRED_LIFETIME,
	.regen_max_retry	= REGEN_MAX_RETRY,
	.max_desync_factor	= MAX_DESYNC_FACTOR,
	.max_addresses		= IPV6_MAX_ADDRESSES,
189
	.accept_ra_defrtr	= 1,
190
	.accept_ra_from_local	= 0,
191
	.accept_ra_pinfo	= 1,
192 193
#ifdef CONFIG_IPV6_ROUTER_PREF
	.accept_ra_rtr_pref	= 1,
194
	.rtr_probe_interval	= 60 * HZ,
195 196 197
#ifdef CONFIG_IPV6_ROUTE_INFO
	.accept_ra_rt_info_max_plen = 0,
#endif
198
#endif
199
	.proxy_ndp		= 0,
200
	.accept_source_route	= 0,	/* we do not accept RH0 by default. */
201
	.disable_ipv6		= 0,
202
	.accept_dad		= 1,
203
	.suppress_frag_ndisc	= 1,
L
Linus Torvalds 已提交
204 205
};

206
static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = {
L
Linus Torvalds 已提交
207 208 209 210 211 212
	.forwarding		= 0,
	.hop_limit		= IPV6_DEFAULT_HOPLIMIT,
	.mtu6			= IPV6_MIN_MTU,
	.accept_ra		= 1,
	.accept_redirects	= 1,
	.autoconf		= 1,
213 214 215
	.force_mld_version	= 0,
	.mldv1_unsolicited_report_interval = 10 * HZ,
	.mldv2_unsolicited_report_interval = HZ,
L
Linus Torvalds 已提交
216 217 218 219 220 221 222 223 224 225
	.dad_transmits		= 1,
	.rtr_solicits		= MAX_RTR_SOLICITATIONS,
	.rtr_solicit_interval	= RTR_SOLICITATION_INTERVAL,
	.rtr_solicit_delay	= MAX_RTR_SOLICITATION_DELAY,
	.use_tempaddr		= 0,
	.temp_valid_lft		= TEMP_VALID_LIFETIME,
	.temp_prefered_lft	= TEMP_PREFERRED_LIFETIME,
	.regen_max_retry	= REGEN_MAX_RETRY,
	.max_desync_factor	= MAX_DESYNC_FACTOR,
	.max_addresses		= IPV6_MAX_ADDRESSES,
226
	.accept_ra_defrtr	= 1,
227
	.accept_ra_from_local	= 0,
228
	.accept_ra_pinfo	= 1,
229 230
#ifdef CONFIG_IPV6_ROUTER_PREF
	.accept_ra_rtr_pref	= 1,
231
	.rtr_probe_interval	= 60 * HZ,
232 233 234
#ifdef CONFIG_IPV6_ROUTE_INFO
	.accept_ra_rt_info_max_plen = 0,
#endif
235
#endif
236
	.proxy_ndp		= 0,
237
	.accept_source_route	= 0,	/* we do not accept RH0 by default. */
238
	.disable_ipv6		= 0,
239
	.accept_dad		= 1,
240
	.suppress_frag_ndisc	= 1,
L
Linus Torvalds 已提交
241 242
};

243
/* Check if a valid qdisc is available */
244
static inline bool addrconf_qdisc_ok(const struct net_device *dev)
245
{
246
	return !qdisc_tx_is_noop(dev);
247 248
}

249
static void addrconf_del_rs_timer(struct inet6_dev *idev)
L
Linus Torvalds 已提交
250
{
251 252 253 254
	if (del_timer(&idev->rs_timer))
		__in6_dev_put(idev);
}

255
static void addrconf_del_dad_work(struct inet6_ifaddr *ifp)
256
{
257
	if (cancel_delayed_work(&ifp->dad_work))
L
Linus Torvalds 已提交
258 259 260
		__in6_ifa_put(ifp);
}

261 262 263 264 265 266 267
static void addrconf_mod_rs_timer(struct inet6_dev *idev,
				  unsigned long when)
{
	if (!timer_pending(&idev->rs_timer))
		in6_dev_hold(idev);
	mod_timer(&idev->rs_timer, jiffies + when);
}
L
Linus Torvalds 已提交
268

269 270
static void addrconf_mod_dad_work(struct inet6_ifaddr *ifp,
				   unsigned long delay)
L
Linus Torvalds 已提交
271
{
272
	if (!delayed_work_pending(&ifp->dad_work))
L
Linus Torvalds 已提交
273
		in6_ifa_hold(ifp);
274
	mod_delayed_work(addrconf_wq, &ifp->dad_work, delay);
L
Linus Torvalds 已提交
275 276
}

277 278
static int snmp6_alloc_dev(struct inet6_dev *idev)
{
279 280
	int i;

W
WANG Cong 已提交
281 282
	idev->stats.ipv6 = alloc_percpu(struct ipstats_mib);
	if (!idev->stats.ipv6)
283
		goto err_ip;
284 285 286

	for_each_possible_cpu(i) {
		struct ipstats_mib *addrconf_stats;
W
WANG Cong 已提交
287
		addrconf_stats = per_cpu_ptr(idev->stats.ipv6, i);
288 289 290 291
		u64_stats_init(&addrconf_stats->syncp);
	}


292 293 294
	idev->stats.icmpv6dev = kzalloc(sizeof(struct icmpv6_mib_device),
					GFP_KERNEL);
	if (!idev->stats.icmpv6dev)
295
		goto err_icmp;
296 297 298
	idev->stats.icmpv6msgdev = kzalloc(sizeof(struct icmpv6msg_mib_device),
					   GFP_KERNEL);
	if (!idev->stats.icmpv6msgdev)
299
		goto err_icmpmsg;
300 301 302

	return 0;

303
err_icmpmsg:
304
	kfree(idev->stats.icmpv6dev);
305
err_icmp:
W
WANG Cong 已提交
306
	free_percpu(idev->stats.ipv6);
307
err_ip:
308
	return -ENOMEM;
309 310
}

311
static struct inet6_dev *ipv6_add_dev(struct net_device *dev)
L
Linus Torvalds 已提交
312 313
{
	struct inet6_dev *ndev;
314
	int err = -ENOMEM;
L
Linus Torvalds 已提交
315 316 317 318

	ASSERT_RTNL();

	if (dev->mtu < IPV6_MIN_MTU)
319
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
320

321 322
	ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL);
	if (ndev == NULL)
323
		return ERR_PTR(err);
324 325 326

	rwlock_init(&ndev->lock);
	ndev->dev = dev;
327
	INIT_LIST_HEAD(&ndev->addr_list);
328 329
	setup_timer(&ndev->rs_timer, addrconf_rs_timer,
		    (unsigned long)ndev);
330
	memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf));
331 332 333 334 335
	ndev->cnf.mtu6 = dev->mtu;
	ndev->cnf.sysctl = NULL;
	ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
	if (ndev->nd_parms == NULL) {
		kfree(ndev);
336
		return ERR_PTR(err);
337
	}
338 339
	if (ndev->cnf.forwarding)
		dev_disable_lro(dev);
340 341
	/* We refer to the device */
	dev_hold(dev);
L
Linus Torvalds 已提交
342

343
	if (snmp6_alloc_dev(ndev) < 0) {
344
		ADBG(KERN_WARNING
345
			"%s: cannot allocate memory for statistics; dev=%s.\n",
346
			__func__, dev->name);
347
		neigh_parms_release(&nd_tbl, ndev->nd_parms);
R
Roy Li 已提交
348 349
		dev_put(dev);
		kfree(ndev);
350
		return ERR_PTR(err);
351
	}
L
Linus Torvalds 已提交
352

353
	if (snmp6_register_dev(ndev) < 0) {
354
		ADBG(KERN_WARNING
355
			"%s: cannot create /proc/net/dev_snmp6/%s\n",
356
			__func__, dev->name);
357
		goto err_release;
358 359 360 361 362 363
	}

	/* One reference from device.  We must do this before
	 * we invoke __ipv6_regen_rndid().
	 */
	in6_dev_hold(ndev);
L
Linus Torvalds 已提交
364

365 366 367
	if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
		ndev->cnf.accept_dad = -1;

A
Amerigo Wang 已提交
368
#if IS_ENABLED(CONFIG_IPV6_SIT)
369
	if (dev->type == ARPHRD_SIT && (dev->priv_flags & IFF_ISATAP)) {
370
		pr_info("%s: Disabled Multicast RS\n", dev->name);
371 372 373 374
		ndev->cnf.rtr_solicits = 0;
	}
#endif

375
	INIT_LIST_HEAD(&ndev->tempaddr_list);
376
	setup_timer(&ndev->regen_timer, ipv6_regen_rndid, (unsigned long)ndev);
377 378
	if ((dev->flags&IFF_LOOPBACK) ||
	    dev->type == ARPHRD_TUNNEL ||
379
	    dev->type == ARPHRD_TUNNEL6 ||
380 381
	    dev->type == ARPHRD_SIT ||
	    dev->type == ARPHRD_NONE) {
382 383 384 385 386
		ndev->cnf.use_tempaddr = -1;
	} else {
		in6_dev_hold(ndev);
		ipv6_regen_rndid((unsigned long) ndev);
	}
387

388
	ndev->token = in6addr_any;
L
Linus Torvalds 已提交
389

390
	if (netif_running(dev) && addrconf_qdisc_ok(dev))
391 392
		ndev->if_flags |= IF_READY;

393 394
	ipv6_mc_init_dev(ndev);
	ndev->tstamp = jiffies;
395 396 397 398 399 400
	err = addrconf_sysctl_register(ndev);
	if (err) {
		ipv6_mc_destroy_dev(ndev);
		del_timer(&ndev->regen_timer);
		goto err_release;
	}
401
	/* protected by rtnl_lock */
402
	rcu_assign_pointer(dev->ip6_ptr, ndev);
403

404 405 406
	/* Join interface-local all-node multicast group */
	ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allnodes);

407
	/* Join all-node multicast group */
408
	ipv6_dev_mc_inc(dev, &in6addr_linklocal_allnodes);
409

410
	/* Join all-router multicast group if forwarding is set */
L
Li Wei 已提交
411
	if (ndev->cnf.forwarding && (dev->flags & IFF_MULTICAST))
412 413
		ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);

L
Linus Torvalds 已提交
414
	return ndev;
415 416 417 418 419 420

err_release:
	neigh_parms_release(&nd_tbl, ndev->nd_parms);
	ndev->dead = 1;
	in6_dev_finish_destroy(ndev);
	return ERR_PTR(err);
L
Linus Torvalds 已提交
421 422
}

423
static struct inet6_dev *ipv6_find_idev(struct net_device *dev)
L
Linus Torvalds 已提交
424 425 426 427 428
{
	struct inet6_dev *idev;

	ASSERT_RTNL();

S
Stephen Hemminger 已提交
429 430 431
	idev = __in6_dev_get(dev);
	if (!idev) {
		idev = ipv6_add_dev(dev);
432
		if (IS_ERR(idev))
L
Linus Torvalds 已提交
433 434
			return NULL;
	}
435

L
Linus Torvalds 已提交
436 437 438 439 440
	if (dev->flags&IFF_UP)
		ipv6_mc_up(idev);
	return idev;
}

441 442 443 444 445
static int inet6_netconf_msgsize_devconf(int type)
{
	int size =  NLMSG_ALIGN(sizeof(struct netconfmsg))
		    + nla_total_size(4);	/* NETCONFA_IFINDEX */

446 447
	/* type -1 is used for ALL */
	if (type == -1 || type == NETCONFA_FORWARDING)
448
		size += nla_total_size(4);
449
#ifdef CONFIG_IPV6_MROUTE
450 451
	if (type == -1 || type == NETCONFA_MC_FORWARDING)
		size += nla_total_size(4);
452
#endif
453 454
	if (type == -1 || type == NETCONFA_PROXY_NEIGH)
		size += nla_total_size(4);
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477

	return size;
}

static int inet6_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
				      struct ipv6_devconf *devconf, u32 portid,
				      u32 seq, int event, unsigned int flags,
				      int type)
{
	struct nlmsghdr  *nlh;
	struct netconfmsg *ncm;

	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
			flags);
	if (nlh == NULL)
		return -EMSGSIZE;

	ncm = nlmsg_data(nlh);
	ncm->ncm_family = AF_INET6;

	if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
		goto nla_put_failure;

478 479
	/* type -1 is used for ALL */
	if ((type == -1 || type == NETCONFA_FORWARDING) &&
480 481
	    nla_put_s32(skb, NETCONFA_FORWARDING, devconf->forwarding) < 0)
		goto nla_put_failure;
482
#ifdef CONFIG_IPV6_MROUTE
483 484 485 486
	if ((type == -1 || type == NETCONFA_MC_FORWARDING) &&
	    nla_put_s32(skb, NETCONFA_MC_FORWARDING,
			devconf->mc_forwarding) < 0)
		goto nla_put_failure;
487
#endif
488 489 490 491
	if ((type == -1 || type == NETCONFA_PROXY_NEIGH) &&
	    nla_put_s32(skb, NETCONFA_PROXY_NEIGH, devconf->proxy_ndp) < 0)
		goto nla_put_failure;

492 493 494 495 496 497 498
	return nlmsg_end(skb, nlh);

nla_put_failure:
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
}

499 500
void inet6_netconf_notify_devconf(struct net *net, int type, int ifindex,
				  struct ipv6_devconf *devconf)
501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
{
	struct sk_buff *skb;
	int err = -ENOBUFS;

	skb = nlmsg_new(inet6_netconf_msgsize_devconf(type), GFP_ATOMIC);
	if (skb == NULL)
		goto errout;

	err = inet6_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
					 RTM_NEWNETCONF, 0, type);
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_NETCONF, NULL, GFP_ATOMIC);
	return;
errout:
520
	rtnl_set_sk_err(net, RTNLGRP_IPV6_NETCONF, err);
521 522
}

523 524 525
static const struct nla_policy devconf_ipv6_policy[NETCONFA_MAX+1] = {
	[NETCONFA_IFINDEX]	= { .len = sizeof(int) },
	[NETCONFA_FORWARDING]	= { .len = sizeof(int) },
526
	[NETCONFA_PROXY_NEIGH]	= { .len = sizeof(int) },
527 528 529
};

static int inet6_netconf_get_devconf(struct sk_buff *in_skb,
530
				     struct nlmsghdr *nlh)
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
{
	struct net *net = sock_net(in_skb->sk);
	struct nlattr *tb[NETCONFA_MAX+1];
	struct netconfmsg *ncm;
	struct sk_buff *skb;
	struct ipv6_devconf *devconf;
	struct inet6_dev *in6_dev;
	struct net_device *dev;
	int ifindex;
	int err;

	err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
			  devconf_ipv6_policy);
	if (err < 0)
		goto errout;

	err = EINVAL;
	if (!tb[NETCONFA_IFINDEX])
		goto errout;

	ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
	switch (ifindex) {
	case NETCONFA_IFINDEX_ALL:
		devconf = net->ipv6.devconf_all;
		break;
	case NETCONFA_IFINDEX_DEFAULT:
		devconf = net->ipv6.devconf_dflt;
		break;
	default:
		dev = __dev_get_by_index(net, ifindex);
		if (dev == NULL)
			goto errout;
		in6_dev = __in6_dev_get(dev);
		if (in6_dev == NULL)
			goto errout;
		devconf = &in6_dev->cnf;
		break;
	}

	err = -ENOBUFS;
	skb = nlmsg_new(inet6_netconf_msgsize_devconf(-1), GFP_ATOMIC);
	if (skb == NULL)
		goto errout;

	err = inet6_netconf_fill_devconf(skb, ifindex, devconf,
					 NETLINK_CB(in_skb).portid,
					 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
					 -1);
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
errout:
	return err;
}

590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
static int inet6_netconf_dump_devconf(struct sk_buff *skb,
				      struct netlink_callback *cb)
{
	struct net *net = sock_net(skb->sk);
	int h, s_h;
	int idx, s_idx;
	struct net_device *dev;
	struct inet6_dev *idev;
	struct hlist_head *head;

	s_h = cb->args[0];
	s_idx = idx = cb->args[1];

	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
		head = &net->dev_index_head[h];
		rcu_read_lock();
607 608
		cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^
			  net->dev_base_seq;
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
			if (idx < s_idx)
				goto cont;
			idev = __in6_dev_get(dev);
			if (!idev)
				goto cont;

			if (inet6_netconf_fill_devconf(skb, dev->ifindex,
						       &idev->cnf,
						       NETLINK_CB(cb->skb).portid,
						       cb->nlh->nlmsg_seq,
						       RTM_NEWNETCONF,
						       NLM_F_MULTI,
						       -1) <= 0) {
				rcu_read_unlock();
				goto done;
			}
626
			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
cont:
			idx++;
		}
		rcu_read_unlock();
	}
	if (h == NETDEV_HASHENTRIES) {
		if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
					       net->ipv6.devconf_all,
					       NETLINK_CB(cb->skb).portid,
					       cb->nlh->nlmsg_seq,
					       RTM_NEWNETCONF, NLM_F_MULTI,
					       -1) <= 0)
			goto done;
		else
			h++;
	}
	if (h == NETDEV_HASHENTRIES + 1) {
		if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
					       net->ipv6.devconf_dflt,
					       NETLINK_CB(cb->skb).portid,
					       cb->nlh->nlmsg_seq,
					       RTM_NEWNETCONF, NLM_F_MULTI,
					       -1) <= 0)
			goto done;
		else
			h++;
	}
done:
	cb->args[0] = h;
	cb->args[1] = idx;

	return skb->len;
}

L
Linus Torvalds 已提交
661 662 663 664 665 666 667 668 669
#ifdef CONFIG_SYSCTL
static void dev_forward_change(struct inet6_dev *idev)
{
	struct net_device *dev;
	struct inet6_ifaddr *ifa;

	if (!idev)
		return;
	dev = idev->dev;
670 671
	if (idev->cnf.forwarding)
		dev_disable_lro(dev);
A
Amerigo Wang 已提交
672
	if (dev->flags & IFF_MULTICAST) {
673
		if (idev->cnf.forwarding) {
674
			ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
675 676 677
			ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allrouters);
			ipv6_dev_mc_inc(dev, &in6addr_sitelocal_allrouters);
		} else {
678
			ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters);
679 680 681
			ipv6_dev_mc_dec(dev, &in6addr_interfacelocal_allrouters);
			ipv6_dev_mc_dec(dev, &in6addr_sitelocal_allrouters);
		}
L
Linus Torvalds 已提交
682
	}
683 684

	list_for_each_entry(ifa, &idev->addr_list, if_list) {
M
Michal Wrobel 已提交
685 686
		if (ifa->flags&IFA_F_TENTATIVE)
			continue;
L
Linus Torvalds 已提交
687 688 689 690 691
		if (idev->cnf.forwarding)
			addrconf_join_anycast(ifa);
		else
			addrconf_leave_anycast(ifa);
	}
692 693
	inet6_netconf_notify_devconf(dev_net(dev), NETCONFA_FORWARDING,
				     dev->ifindex, &idev->cnf);
L
Linus Torvalds 已提交
694 695 696
}


697
static void addrconf_forward_change(struct net *net, __s32 newf)
L
Linus Torvalds 已提交
698 699 700 701
{
	struct net_device *dev;
	struct inet6_dev *idev;

702
	for_each_netdev(net, dev) {
L
Linus Torvalds 已提交
703 704
		idev = __in6_dev_get(dev);
		if (idev) {
705 706
			int changed = (!idev->cnf.forwarding) ^ (!newf);
			idev->cnf.forwarding = newf;
L
Linus Torvalds 已提交
707 708 709 710 711
			if (changed)
				dev_forward_change(idev);
		}
	}
}
712

713
static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int newf)
714
{
715
	struct net *net;
716 717 718 719
	int old;

	if (!rtnl_trylock())
		return restart_syscall();
720 721

	net = (struct net *)table->extra2;
722 723
	old = *p;
	*p = newf;
724

725
	if (p == &net->ipv6.devconf_dflt->forwarding) {
726 727 728 729
		if ((!newf) ^ (!old))
			inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING,
						     NETCONFA_IFINDEX_DEFAULT,
						     net->ipv6.devconf_dflt);
730 731
		rtnl_unlock();
		return 0;
E
Eric W. Biederman 已提交
732
	}
733

734 735 736
	if (p == &net->ipv6.devconf_all->forwarding) {
		net->ipv6.devconf_dflt->forwarding = newf;
		addrconf_forward_change(net, newf);
737 738 739 740
		if ((!newf) ^ (!old))
			inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING,
						     NETCONFA_IFINDEX_ALL,
						     net->ipv6.devconf_all);
741
	} else if ((!newf) ^ (!old))
742
		dev_forward_change((struct inet6_dev *)table->extra1);
743
	rtnl_unlock();
744

745
	if (newf)
746
		rt6_purge_dflt_routers(net);
747
	return 1;
748
}
L
Linus Torvalds 已提交
749 750
#endif

751
/* Nobody refers to this ifaddr, destroy it */
L
Linus Torvalds 已提交
752 753
void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
{
754
	WARN_ON(!hlist_unhashed(&ifp->addr_lst));
755

L
Linus Torvalds 已提交
756
#ifdef NET_REFCNT_DEBUG
757
	pr_debug("%s\n", __func__);
L
Linus Torvalds 已提交
758 759 760 761
#endif

	in6_dev_put(ifp->idev);

762 763 764
	if (cancel_delayed_work(&ifp->dad_work))
		pr_notice("delayed DAD work was pending while freeing ifa=%p\n",
			  ifp);
L
Linus Torvalds 已提交
765

766
	if (ifp->state != INET6_IFADDR_STATE_DEAD) {
767
		pr_warn("Freeing alive inet6 address %p\n", ifp);
L
Linus Torvalds 已提交
768 769
		return;
	}
A
Amerigo Wang 已提交
770
	ip6_rt_put(ifp->rt);
L
Linus Torvalds 已提交
771

772
	kfree_rcu(ifp, rcu);
L
Linus Torvalds 已提交
773 774
}

B
Brian Haley 已提交
775 776 777
static void
ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp)
{
778
	struct list_head *p;
779
	int ifp_scope = ipv6_addr_src_scope(&ifp->addr);
B
Brian Haley 已提交
780 781 782 783 784

	/*
	 * Each device address list is sorted in order of scope -
	 * global before linklocal.
	 */
785 786 787
	list_for_each(p, &idev->addr_list) {
		struct inet6_ifaddr *ifa
			= list_entry(p, struct inet6_ifaddr, if_list);
788
		if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr))
B
Brian Haley 已提交
789 790 791
			break;
	}

792
	list_add_tail(&ifp->if_list, p);
B
Brian Haley 已提交
793 794
}

E
Eric Dumazet 已提交
795
static u32 inet6_addr_hash(const struct in6_addr *addr)
796
{
E
Eric Dumazet 已提交
797
	return hash_32(ipv6_addr_hash(addr), IN6_ADDR_HSIZE_SHIFT);
798 799
}

L
Linus Torvalds 已提交
800 801 802
/* On success it returns ifp with increased reference count */

static struct inet6_ifaddr *
803 804
ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
	      const struct in6_addr *peer_addr, int pfxlen,
805
	      int scope, u32 flags, u32 valid_lft, u32 prefered_lft)
L
Linus Torvalds 已提交
806 807 808
{
	struct inet6_ifaddr *ifa = NULL;
	struct rt6_info *rt;
809
	unsigned int hash;
L
Linus Torvalds 已提交
810
	int err = 0;
811 812 813 814 815 816 817
	int addr_type = ipv6_addr_type(addr);

	if (addr_type == IPV6_ADDR_ANY ||
	    addr_type & IPV6_ADDR_MULTICAST ||
	    (!(idev->dev->flags & IFF_LOOPBACK) &&
	     addr_type & IPV6_ADDR_LOOPBACK))
		return ERR_PTR(-EADDRNOTAVAIL);
L
Linus Torvalds 已提交
818

819
	rcu_read_lock_bh();
L
Linus Torvalds 已提交
820 821 822 823 824
	if (idev->dead) {
		err = -ENODEV;			/*XXX*/
		goto out2;
	}

825
	if (idev->cnf.disable_ipv6) {
826 827 828 829
		err = -EACCES;
		goto out2;
	}

830
	spin_lock(&addrconf_hash_lock);
L
Linus Torvalds 已提交
831 832

	/* Ignore adding duplicate addresses on an interface */
833
	if (ipv6_chk_same_addr(dev_net(idev->dev), addr, idev->dev)) {
834
		ADBG("ipv6_add_addr: already assigned\n");
L
Linus Torvalds 已提交
835 836 837 838
		err = -EEXIST;
		goto out;
	}

839
	ifa = kzalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC);
L
Linus Torvalds 已提交
840 841

	if (ifa == NULL) {
842
		ADBG("ipv6_add_addr: malloc failed\n");
L
Linus Torvalds 已提交
843 844 845 846
		err = -ENOBUFS;
		goto out;
	}

847
	rt = addrconf_dst_alloc(idev, addr, false);
L
Linus Torvalds 已提交
848 849 850 851 852
	if (IS_ERR(rt)) {
		err = PTR_ERR(rt);
		goto out;
	}

853 854
	neigh_parms_data_state_setall(idev->nd_parms);

A
Alexey Dobriyan 已提交
855
	ifa->addr = *addr;
856 857
	if (peer_addr)
		ifa->peer_addr = *peer_addr;
L
Linus Torvalds 已提交
858 859

	spin_lock_init(&ifa->lock);
860
	spin_lock_init(&ifa->state_lock);
861
	INIT_DELAYED_WORK(&ifa->dad_work, addrconf_dad_work);
862
	INIT_HLIST_NODE(&ifa->addr_lst);
L
Linus Torvalds 已提交
863 864 865
	ifa->scope = scope;
	ifa->prefix_len = pfxlen;
	ifa->flags = flags | IFA_F_TENTATIVE;
866 867
	ifa->valid_lft = valid_lft;
	ifa->prefered_lft = prefered_lft;
L
Linus Torvalds 已提交
868
	ifa->cstamp = ifa->tstamp = jiffies;
869
	ifa->tokenized = false;
L
Linus Torvalds 已提交
870

871 872
	ifa->rt = rt;

L
Linus Torvalds 已提交
873 874 875 876 877 878
	ifa->idev = idev;
	in6_dev_hold(idev);
	/* For caller */
	in6_ifa_hold(ifa);

	/* Add to big hash table */
E
Eric Dumazet 已提交
879
	hash = inet6_addr_hash(addr);
L
Linus Torvalds 已提交
880

881 882
	hlist_add_head_rcu(&ifa->addr_lst, &inet6_addr_lst[hash]);
	spin_unlock(&addrconf_hash_lock);
L
Linus Torvalds 已提交
883 884 885

	write_lock(&idev->lock);
	/* Add to inet6_dev unicast addr list. */
B
Brian Haley 已提交
886
	ipv6_link_dev_addr(idev, ifa);
L
Linus Torvalds 已提交
887 888

	if (ifa->flags&IFA_F_TEMPORARY) {
889
		list_add(&ifa->tmp_list, &idev->tempaddr_list);
L
Linus Torvalds 已提交
890 891 892 893 894 895
		in6_ifa_hold(ifa);
	}

	in6_ifa_hold(ifa);
	write_unlock(&idev->lock);
out2:
896
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
897

898
	if (likely(err == 0))
899
		inet6addr_notifier_call_chain(NETDEV_UP, ifa);
L
Linus Torvalds 已提交
900 901 902 903 904 905 906
	else {
		kfree(ifa);
		ifa = ERR_PTR(err);
	}

	return ifa;
out:
907
	spin_unlock(&addrconf_hash_lock);
L
Linus Torvalds 已提交
908 909 910
	goto out2;
}

911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992
enum cleanup_prefix_rt_t {
	CLEANUP_PREFIX_RT_NOP,    /* no cleanup action for prefix route */
	CLEANUP_PREFIX_RT_DEL,    /* delete the prefix route */
	CLEANUP_PREFIX_RT_EXPIRE, /* update the lifetime of the prefix route */
};

/*
 * Check, whether the prefix for ifp would still need a prefix route
 * after deleting ifp. The function returns one of the CLEANUP_PREFIX_RT_*
 * constants.
 *
 * 1) we don't purge prefix if address was not permanent.
 *    prefix is managed by its own lifetime.
 * 2) we also don't purge, if the address was IFA_F_NOPREFIXROUTE.
 * 3) if there are no addresses, delete prefix.
 * 4) if there are still other permanent address(es),
 *    corresponding prefix is still permanent.
 * 5) if there are still other addresses with IFA_F_NOPREFIXROUTE,
 *    don't purge the prefix, assume user space is managing it.
 * 6) otherwise, update prefix lifetime to the
 *    longest valid lifetime among the corresponding
 *    addresses on the device.
 *    Note: subsequent RA will update lifetime.
 **/
static enum cleanup_prefix_rt_t
check_cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long *expires)
{
	struct inet6_ifaddr *ifa;
	struct inet6_dev *idev = ifp->idev;
	unsigned long lifetime;
	enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_DEL;

	*expires = jiffies;

	list_for_each_entry(ifa, &idev->addr_list, if_list) {
		if (ifa == ifp)
			continue;
		if (!ipv6_prefix_equal(&ifa->addr, &ifp->addr,
				       ifp->prefix_len))
			continue;
		if (ifa->flags & (IFA_F_PERMANENT | IFA_F_NOPREFIXROUTE))
			return CLEANUP_PREFIX_RT_NOP;

		action = CLEANUP_PREFIX_RT_EXPIRE;

		spin_lock(&ifa->lock);

		lifetime = addrconf_timeout_fixup(ifa->valid_lft, HZ);
		/*
		 * Note: Because this address is
		 * not permanent, lifetime <
		 * LONG_MAX / HZ here.
		 */
		if (time_before(*expires, ifa->tstamp + lifetime * HZ))
			*expires = ifa->tstamp + lifetime * HZ;
		spin_unlock(&ifa->lock);
	}

	return action;
}

static void
cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long expires, bool del_rt)
{
	struct rt6_info *rt;

	rt = addrconf_get_prefix_route(&ifp->addr,
				       ifp->prefix_len,
				       ifp->idev->dev,
				       0, RTF_GATEWAY | RTF_DEFAULT);
	if (rt) {
		if (del_rt)
			ip6_del_rt(rt);
		else {
			if (!(rt->rt6i_flags & RTF_EXPIRES))
				rt6_set_expires(rt, expires);
			ip6_rt_put(rt);
		}
	}
}


L
Linus Torvalds 已提交
993 994 995 996
/* This function wants to get referenced ifp and releases it before return */

static void ipv6_del_addr(struct inet6_ifaddr *ifp)
{
997
	int state;
998 999
	enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_NOP;
	unsigned long expires;
L
Linus Torvalds 已提交
1000

1001 1002
	ASSERT_RTNL();

1003 1004
	spin_lock_bh(&ifp->state_lock);
	state = ifp->state;
1005
	ifp->state = INET6_IFADDR_STATE_DEAD;
1006 1007 1008 1009
	spin_unlock_bh(&ifp->state_lock);

	if (state == INET6_IFADDR_STATE_DEAD)
		goto out;
L
Linus Torvalds 已提交
1010

1011 1012 1013
	spin_lock_bh(&addrconf_hash_lock);
	hlist_del_init_rcu(&ifp->addr_lst);
	spin_unlock_bh(&addrconf_hash_lock);
L
Linus Torvalds 已提交
1014

1015
	write_lock_bh(&ifp->idev->lock);
1016

L
Linus Torvalds 已提交
1017
	if (ifp->flags&IFA_F_TEMPORARY) {
1018 1019 1020 1021
		list_del(&ifp->tmp_list);
		if (ifp->ifpub) {
			in6_ifa_put(ifp->ifpub);
			ifp->ifpub = NULL;
L
Linus Torvalds 已提交
1022
		}
1023
		__in6_ifa_put(ifp);
L
Linus Torvalds 已提交
1024 1025
	}

1026 1027
	if (ifp->flags & IFA_F_PERMANENT && !(ifp->flags & IFA_F_NOPREFIXROUTE))
		action = check_cleanup_prefix_route(ifp, &expires);
1028

1029 1030 1031 1032
	list_del_init(&ifp->if_list);
	__in6_ifa_put(ifp);

	write_unlock_bh(&ifp->idev->lock);
L
Linus Torvalds 已提交
1033

1034
	addrconf_del_dad_work(ifp);
1035

L
Linus Torvalds 已提交
1036 1037
	ipv6_ifa_notify(RTM_DELADDR, ifp);

1038
	inet6addr_notifier_call_chain(NETDEV_DOWN, ifp);
L
Linus Torvalds 已提交
1039

1040 1041 1042
	if (action != CLEANUP_PREFIX_RT_NOP) {
		cleanup_prefix_route(ifp, expires,
			action == CLEANUP_PREFIX_RT_DEL);
L
Linus Torvalds 已提交
1043 1044
	}

1045 1046
	/* clean up prefsrc entries */
	rt6_remove_prefsrc(ifp);
1047
out:
L
Linus Torvalds 已提交
1048 1049 1050 1051 1052 1053 1054
	in6_ifa_put(ifp);
}

static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, struct inet6_ifaddr *ift)
{
	struct inet6_dev *idev = ifp->idev;
	struct in6_addr addr, *tmpaddr;
1055
	unsigned long tmp_prefered_lft, tmp_valid_lft, tmp_tstamp, age;
1056
	unsigned long regen_advance;
L
Linus Torvalds 已提交
1057 1058
	int tmp_plen;
	int ret = 0;
1059
	u32 addr_flags;
1060
	unsigned long now = jiffies;
L
Linus Torvalds 已提交
1061

1062
	write_lock_bh(&idev->lock);
L
Linus Torvalds 已提交
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
	if (ift) {
		spin_lock_bh(&ift->lock);
		memcpy(&addr.s6_addr[8], &ift->addr.s6_addr[8], 8);
		spin_unlock_bh(&ift->lock);
		tmpaddr = &addr;
	} else {
		tmpaddr = NULL;
	}
retry:
	in6_dev_hold(idev);
	if (idev->cnf.use_tempaddr <= 0) {
1074
		write_unlock_bh(&idev->lock);
1075
		pr_info("%s: use_tempaddr is disabled\n", __func__);
L
Linus Torvalds 已提交
1076 1077 1078 1079 1080 1081 1082 1083
		in6_dev_put(idev);
		ret = -1;
		goto out;
	}
	spin_lock_bh(&ifp->lock);
	if (ifp->regen_count++ >= idev->cnf.regen_max_retry) {
		idev->cnf.use_tempaddr = -1;	/*XXX*/
		spin_unlock_bh(&ifp->lock);
1084
		write_unlock_bh(&idev->lock);
1085 1086
		pr_warn("%s: regeneration time exceeded - disabled temporary address support\n",
			__func__);
L
Linus Torvalds 已提交
1087 1088 1089 1090 1091 1092
		in6_dev_put(idev);
		ret = -1;
		goto out;
	}
	in6_ifa_hold(ifp);
	memcpy(addr.s6_addr, ifp->addr.s6_addr, 8);
S
Sorin Dumitru 已提交
1093
	__ipv6_try_regen_rndid(idev, tmpaddr);
L
Linus Torvalds 已提交
1094
	memcpy(&addr.s6_addr[8], idev->rndid, 8);
1095
	age = (now - ifp->tstamp) / HZ;
L
Linus Torvalds 已提交
1096 1097
	tmp_valid_lft = min_t(__u32,
			      ifp->valid_lft,
1098
			      idev->cnf.temp_valid_lft + age);
1099 1100
	tmp_prefered_lft = min_t(__u32,
				 ifp->prefered_lft,
1101
				 idev->cnf.temp_prefered_lft + age -
1102
				 idev->cnf.max_desync_factor);
L
Linus Torvalds 已提交
1103 1104 1105 1106
	tmp_plen = ifp->prefix_len;
	tmp_tstamp = ifp->tstamp;
	spin_unlock_bh(&ifp->lock);

1107
	regen_advance = idev->cnf.regen_max_retry *
1108
	                idev->cnf.dad_transmits *
J
Jiri Pirko 已提交
1109
	                NEIGH_VAR(idev->nd_parms, RETRANS_TIME) / HZ;
1110
	write_unlock_bh(&idev->lock);
1111

1112 1113 1114 1115
	/* A temporary address is created only if this calculated Preferred
	 * Lifetime is greater than REGEN_ADVANCE time units.  In particular,
	 * an implementation must not create a temporary address with a zero
	 * Preferred Lifetime.
1116 1117
	 * Use age calculation as in addrconf_verify to avoid unnecessary
	 * temporary addresses being generated.
1118
	 */
1119 1120
	age = (now - tmp_tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
	if (tmp_prefered_lft <= regen_advance + age) {
1121 1122 1123 1124 1125 1126
		in6_ifa_put(ifp);
		in6_dev_put(idev);
		ret = -1;
		goto out;
	}

1127 1128 1129 1130 1131
	addr_flags = IFA_F_TEMPORARY;
	/* set in addrconf_prefix_rcv() */
	if (ifp->flags & IFA_F_OPTIMISTIC)
		addr_flags |= IFA_F_OPTIMISTIC;

1132 1133 1134 1135
	ift = ipv6_add_addr(idev, &addr, NULL, tmp_plen,
			    ipv6_addr_scope(&addr), addr_flags,
			    tmp_valid_lft, tmp_prefered_lft);
	if (IS_ERR(ift)) {
L
Linus Torvalds 已提交
1136 1137
		in6_ifa_put(ifp);
		in6_dev_put(idev);
1138
		pr_info("%s: retry temporary address regeneration\n", __func__);
L
Linus Torvalds 已提交
1139
		tmpaddr = &addr;
1140
		write_lock_bh(&idev->lock);
L
Linus Torvalds 已提交
1141 1142 1143 1144 1145
		goto retry;
	}

	spin_lock_bh(&ift->lock);
	ift->ifpub = ifp;
1146
	ift->cstamp = now;
L
Linus Torvalds 已提交
1147 1148 1149
	ift->tstamp = tmp_tstamp;
	spin_unlock_bh(&ift->lock);

1150
	addrconf_dad_start(ift);
L
Linus Torvalds 已提交
1151 1152 1153 1154 1155 1156 1157
	in6_ifa_put(ift);
	in6_dev_put(idev);
out:
	return ret;
}

/*
1158
 *	Choose an appropriate source address (RFC3484)
L
Linus Torvalds 已提交
1159
 */
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
enum {
	IPV6_SADDR_RULE_INIT = 0,
	IPV6_SADDR_RULE_LOCAL,
	IPV6_SADDR_RULE_SCOPE,
	IPV6_SADDR_RULE_PREFERRED,
#ifdef CONFIG_IPV6_MIP6
	IPV6_SADDR_RULE_HOA,
#endif
	IPV6_SADDR_RULE_OIF,
	IPV6_SADDR_RULE_LABEL,
	IPV6_SADDR_RULE_PRIVACY,
	IPV6_SADDR_RULE_ORCHID,
	IPV6_SADDR_RULE_PREFIX,
	IPV6_SADDR_RULE_MAX
};

1176
struct ipv6_saddr_score {
1177 1178 1179 1180 1181 1182
	int			rule;
	int			addr_type;
	struct inet6_ifaddr	*ifa;
	DECLARE_BITMAP(scorebits, IPV6_SADDR_RULE_MAX);
	int			scopedist;
	int			matchlen;
1183 1184
};

1185
struct ipv6_saddr_dst {
1186
	const struct in6_addr *addr;
1187 1188 1189
	int ifindex;
	int scope;
	int label;
1190
	unsigned int prefs;
1191
};
1192

D
Dave Jones 已提交
1193
static inline int ipv6_saddr_preferred(int type)
L
Linus Torvalds 已提交
1194
{
U
Ulrich Weber 已提交
1195
	if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4|IPV6_ADDR_LOOPBACK))
1196 1197
		return 1;
	return 0;
L
Linus Torvalds 已提交
1198 1199
}

1200 1201
static int ipv6_get_saddr_eval(struct net *net,
			       struct ipv6_saddr_score *score,
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 1235 1236 1237 1238 1239 1240
			       struct ipv6_saddr_dst *dst,
			       int i)
{
	int ret;

	if (i <= score->rule) {
		switch (i) {
		case IPV6_SADDR_RULE_SCOPE:
			ret = score->scopedist;
			break;
		case IPV6_SADDR_RULE_PREFIX:
			ret = score->matchlen;
			break;
		default:
			ret = !!test_bit(i, score->scorebits);
		}
		goto out;
	}

	switch (i) {
	case IPV6_SADDR_RULE_INIT:
		/* Rule 0: remember if hiscore is not ready yet */
		ret = !!score->ifa;
		break;
	case IPV6_SADDR_RULE_LOCAL:
		/* Rule 1: Prefer same address */
		ret = ipv6_addr_equal(&score->ifa->addr, dst->addr);
		break;
	case IPV6_SADDR_RULE_SCOPE:
		/* Rule 2: Prefer appropriate scope
		 *
		 *      ret
		 *       ^
		 *    -1 |  d 15
		 *    ---+--+-+---> scope
		 *       |
		 *       |             d is scope of the destination.
		 *  B-d  |  \
		 *       |   \      <- smaller scope is better if
1241
		 *  B-15 |    \        if scope is enough for destination.
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
		 *       |             ret = B - scope (-1 <= scope >= d <= 15).
		 * d-C-1 | /
		 *       |/         <- greater is better
		 *   -C  /             if scope is not enough for destination.
		 *      /|             ret = scope - C (-1 <= d < scope <= 15).
		 *
		 * d - C - 1 < B -15 (for all -1 <= d <= 15).
		 * C > d + 14 - B >= 15 + 14 - B = 29 - B.
		 * Assume B = 0 and we get C > 29.
		 */
		ret = __ipv6_addr_src_scope(score->addr_type);
		if (ret >= dst->scope)
			ret = -ret;
		else
			ret -= 128;	/* 30 is enough */
		score->scopedist = ret;
		break;
	case IPV6_SADDR_RULE_PREFERRED:
		/* Rule 3: Avoid deprecated and optimistic addresses */
		ret = ipv6_saddr_preferred(score->addr_type) ||
		      !(score->ifa->flags & (IFA_F_DEPRECATED|IFA_F_OPTIMISTIC));
		break;
#ifdef CONFIG_IPV6_MIP6
	case IPV6_SADDR_RULE_HOA:
1266
	    {
1267
		/* Rule 4: Prefer home address */
1268 1269
		int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA);
		ret = !(score->ifa->flags & IFA_F_HOMEADDRESS) ^ prefhome;
1270
		break;
1271
	    }
1272 1273 1274 1275 1276 1277 1278 1279
#endif
	case IPV6_SADDR_RULE_OIF:
		/* Rule 5: Prefer outgoing interface */
		ret = (!dst->ifindex ||
		       dst->ifindex == score->ifa->idev->dev->ifindex);
		break;
	case IPV6_SADDR_RULE_LABEL:
		/* Rule 6: Prefer matching label */
1280 1281
		ret = ipv6_addr_label(net,
				      &score->ifa->addr, score->addr_type,
1282 1283 1284
				      score->ifa->idev->dev->ifindex) == dst->label;
		break;
	case IPV6_SADDR_RULE_PRIVACY:
1285
	    {
1286
		/* Rule 7: Prefer public address
L
Lucas De Marchi 已提交
1287
		 * Note: prefer temporary address if use_tempaddr >= 2
1288
		 */
1289 1290 1291 1292
		int preftmp = dst->prefs & (IPV6_PREFER_SRC_PUBLIC|IPV6_PREFER_SRC_TMP) ?
				!!(dst->prefs & IPV6_PREFER_SRC_TMP) :
				score->ifa->idev->cnf.use_tempaddr >= 2;
		ret = (!(score->ifa->flags & IFA_F_TEMPORARY)) ^ preftmp;
1293
		break;
1294
	    }
1295 1296 1297 1298 1299 1300 1301 1302 1303
	case IPV6_SADDR_RULE_ORCHID:
		/* Rule 8-: Prefer ORCHID vs ORCHID or
		 *	    non-ORCHID vs non-ORCHID
		 */
		ret = !(ipv6_addr_orchid(&score->ifa->addr) ^
			ipv6_addr_orchid(dst->addr));
		break;
	case IPV6_SADDR_RULE_PREFIX:
		/* Rule 8: Use longest matching prefix */
1304 1305 1306 1307
		ret = ipv6_addr_diff(&score->ifa->addr, dst->addr);
		if (ret > score->ifa->prefix_len)
			ret = score->ifa->prefix_len;
		score->matchlen = ret;
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
		break;
	default:
		ret = 0;
	}

	if (ret)
		__set_bit(i, score->scorebits);
	score->rule = i;
out:
	return ret;
}

1320
int ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev,
1321
		       const struct in6_addr *daddr, unsigned int prefs,
1322
		       struct in6_addr *saddr)
L
Linus Torvalds 已提交
1323
{
1324 1325 1326
	struct ipv6_saddr_score scores[2],
				*score = &scores[0], *hiscore = &scores[1];
	struct ipv6_saddr_dst dst;
1327
	struct net_device *dev;
1328
	int dst_type;
L
Linus Torvalds 已提交
1329

1330 1331 1332 1333
	dst_type = __ipv6_addr_type(daddr);
	dst.addr = daddr;
	dst.ifindex = dst_dev ? dst_dev->ifindex : 0;
	dst.scope = __ipv6_addr_src_scope(dst_type);
1334
	dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex);
1335
	dst.prefs = prefs;
1336 1337 1338

	hiscore->rule = -1;
	hiscore->ifa = NULL;
L
Linus Torvalds 已提交
1339

1340
	rcu_read_lock();
L
Linus Torvalds 已提交
1341

1342
	for_each_netdev_rcu(net, dev) {
1343 1344
		struct inet6_dev *idev;

1345
		/* Candidate Source Address (section 4)
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356
		 *  - multicast and link-local destination address,
		 *    the set of candidate source address MUST only
		 *    include addresses assigned to interfaces
		 *    belonging to the same link as the outgoing
		 *    interface.
		 * (- For site-local destination addresses, the
		 *    set of candidate source addresses MUST only
		 *    include addresses assigned to interfaces
		 *    belonging to the same site as the outgoing
		 *    interface.)
		 */
1357 1358 1359
		if (((dst_type & IPV6_ADDR_MULTICAST) ||
		     dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL) &&
		    dst.ifindex && dev->ifindex != dst.ifindex)
1360
			continue;
L
Linus Torvalds 已提交
1361 1362

		idev = __in6_dev_get(dev);
1363 1364 1365 1366
		if (!idev)
			continue;

		read_lock_bh(&idev->lock);
1367
		list_for_each_entry(score->ifa, &idev->addr_list, if_list) {
1368
			int i;
1369

1370
			/*
1371 1372 1373
			 * - Tentative Address (RFC2462 section 5.4)
			 *  - A tentative address is not considered
			 *    "assigned to an interface" in the traditional
1374
			 *    sense, unless it is also flagged as optimistic.
1375
			 * - Candidate Source Address (section 4)
1376 1377 1378 1379
			 *  - In any case, anycast addresses, multicast
			 *    addresses, and the unspecified address MUST
			 *    NOT be included in a candidate set.
			 */
1380 1381
			if ((score->ifa->flags & IFA_F_TENTATIVE) &&
			    (!(score->ifa->flags & IFA_F_OPTIMISTIC)))
1382
				continue;
1383 1384 1385 1386 1387

			score->addr_type = __ipv6_addr_type(&score->ifa->addr);

			if (unlikely(score->addr_type == IPV6_ADDR_ANY ||
				     score->addr_type & IPV6_ADDR_MULTICAST)) {
1388
				LIMIT_NETDEBUG(KERN_DEBUG
J
Joe Perches 已提交
1389
					       "ADDRCONF: unspecified / multicast address "
1390 1391 1392 1393 1394
					       "assigned as unicast address on %s",
					       dev->name);
				continue;
			}

1395 1396 1397 1398 1399 1400
			score->rule = -1;
			bitmap_zero(score->scorebits, IPV6_SADDR_RULE_MAX);

			for (i = 0; i < IPV6_SADDR_RULE_MAX; i++) {
				int minihiscore, miniscore;

1401 1402
				minihiscore = ipv6_get_saddr_eval(net, hiscore, &dst, i);
				miniscore = ipv6_get_saddr_eval(net, score, &dst, i);
1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423

				if (minihiscore > miniscore) {
					if (i == IPV6_SADDR_RULE_SCOPE &&
					    score->scopedist > 0) {
						/*
						 * special case:
						 * each remaining entry
						 * has too small (not enough)
						 * scope, because ifa entries
						 * are sorted by their scope
						 * values.
						 */
						goto try_nextdev;
					}
					break;
				} else if (minihiscore < miniscore) {
					if (hiscore->ifa)
						in6_ifa_put(hiscore->ifa);

					in6_ifa_hold(score->ifa);

1424
					swap(hiscore, score);
1425 1426 1427 1428 1429

					/* restore our iterator */
					score->ifa = hiscore->ifa;

					break;
L
Linus Torvalds 已提交
1430
				}
1431
			}
L
Linus Torvalds 已提交
1432
		}
1433
try_nextdev:
1434
		read_unlock_bh(&idev->lock);
L
Linus Torvalds 已提交
1435
	}
1436
	rcu_read_unlock();
L
Linus Torvalds 已提交
1437

1438
	if (!hiscore->ifa)
1439
		return -EADDRNOTAVAIL;
1440

A
Alexey Dobriyan 已提交
1441
	*saddr = hiscore->ifa->addr;
1442
	in6_ifa_put(hiscore->ifa);
1443
	return 0;
L
Linus Torvalds 已提交
1444
}
1445
EXPORT_SYMBOL(ipv6_dev_get_saddr);
L
Linus Torvalds 已提交
1446

1447
int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr,
1448
		      u32 banned_flags)
1449 1450 1451 1452
{
	struct inet6_ifaddr *ifp;
	int err = -EADDRNOTAVAIL;

1453 1454 1455
	list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
		if (ifp->scope > IFA_LINK)
			break;
1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
		if (ifp->scope == IFA_LINK &&
		    !(ifp->flags & banned_flags)) {
			*addr = ifp->addr;
			err = 0;
			break;
		}
	}
	return err;
}

1466
int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
1467
		    u32 banned_flags)
L
Linus Torvalds 已提交
1468 1469 1470 1471
{
	struct inet6_dev *idev;
	int err = -EADDRNOTAVAIL;

1472
	rcu_read_lock();
S
Stephen Hemminger 已提交
1473 1474
	idev = __in6_dev_get(dev);
	if (idev) {
L
Linus Torvalds 已提交
1475
		read_lock_bh(&idev->lock);
1476
		err = __ipv6_get_lladdr(idev, addr, banned_flags);
L
Linus Torvalds 已提交
1477 1478
		read_unlock_bh(&idev->lock);
	}
1479
	rcu_read_unlock();
L
Linus Torvalds 已提交
1480 1481 1482 1483 1484 1485 1486 1487 1488
	return err;
}

static int ipv6_count_addresses(struct inet6_dev *idev)
{
	int cnt = 0;
	struct inet6_ifaddr *ifp;

	read_lock_bh(&idev->lock);
1489
	list_for_each_entry(ifp, &idev->addr_list, if_list)
L
Linus Torvalds 已提交
1490 1491 1492 1493 1494
		cnt++;
	read_unlock_bh(&idev->lock);
	return cnt;
}

1495
int ipv6_chk_addr(struct net *net, const struct in6_addr *addr,
1496
		  const struct net_device *dev, int strict)
L
Linus Torvalds 已提交
1497
{
1498
	struct inet6_ifaddr *ifp;
E
Eric Dumazet 已提交
1499
	unsigned int hash = inet6_addr_hash(addr);
L
Linus Torvalds 已提交
1500

1501
	rcu_read_lock_bh();
1502
	hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
1503
		if (!net_eq(dev_net(ifp->idev->dev), net))
1504
			continue;
L
Linus Torvalds 已提交
1505
		if (ipv6_addr_equal(&ifp->addr, addr) &&
1506 1507 1508 1509 1510
		    !(ifp->flags&IFA_F_TENTATIVE) &&
		    (dev == NULL || ifp->idev->dev == dev ||
		     !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))) {
			rcu_read_unlock_bh();
			return 1;
L
Linus Torvalds 已提交
1511 1512
		}
	}
1513

1514 1515
	rcu_read_unlock_bh();
	return 0;
L
Linus Torvalds 已提交
1516
}
1517 1518
EXPORT_SYMBOL(ipv6_chk_addr);

1519 1520
static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
			       struct net_device *dev)
L
Linus Torvalds 已提交
1521
{
E
Eric Dumazet 已提交
1522
	unsigned int hash = inet6_addr_hash(addr);
1523
	struct inet6_ifaddr *ifp;
L
Linus Torvalds 已提交
1524

1525
	hlist_for_each_entry(ifp, &inet6_addr_lst[hash], addr_lst) {
1526
		if (!net_eq(dev_net(ifp->idev->dev), net))
1527
			continue;
L
Linus Torvalds 已提交
1528 1529
		if (ipv6_addr_equal(&ifp->addr, addr)) {
			if (dev == NULL || ifp->idev->dev == dev)
1530
				return true;
L
Linus Torvalds 已提交
1531 1532
		}
	}
1533
	return false;
L
Linus Torvalds 已提交
1534 1535
}

1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
/* Compares an address/prefix_len with addresses on device @dev.
 * If one is found it returns true.
 */
bool ipv6_chk_custom_prefix(const struct in6_addr *addr,
	const unsigned int prefix_len, struct net_device *dev)
{
	struct inet6_dev *idev;
	struct inet6_ifaddr *ifa;
	bool ret = false;

	rcu_read_lock();
	idev = __in6_dev_get(dev);
	if (idev) {
		read_lock_bh(&idev->lock);
		list_for_each_entry(ifa, &idev->addr_list, if_list) {
			ret = ipv6_prefix_equal(addr, &ifa->addr, prefix_len);
			if (ret)
				break;
		}
		read_unlock_bh(&idev->lock);
	}
	rcu_read_unlock();

	return ret;
}
EXPORT_SYMBOL(ipv6_chk_custom_prefix);

1563
int ipv6_chk_prefix(const struct in6_addr *addr, struct net_device *dev)
1564 1565 1566 1567 1568 1569 1570 1571 1572 1573
{
	struct inet6_dev *idev;
	struct inet6_ifaddr *ifa;
	int	onlink;

	onlink = 0;
	rcu_read_lock();
	idev = __in6_dev_get(dev);
	if (idev) {
		read_lock_bh(&idev->lock);
1574
		list_for_each_entry(ifa, &idev->addr_list, if_list) {
1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
			onlink = ipv6_prefix_equal(addr, &ifa->addr,
						   ifa->prefix_len);
			if (onlink)
				break;
		}
		read_unlock_bh(&idev->lock);
	}
	rcu_read_unlock();
	return onlink;
}
EXPORT_SYMBOL(ipv6_chk_prefix);

1587
struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr,
1588
				     struct net_device *dev, int strict)
L
Linus Torvalds 已提交
1589
{
1590
	struct inet6_ifaddr *ifp, *result = NULL;
E
Eric Dumazet 已提交
1591
	unsigned int hash = inet6_addr_hash(addr);
L
Linus Torvalds 已提交
1592

1593
	rcu_read_lock_bh();
1594
	hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) {
1595
		if (!net_eq(dev_net(ifp->idev->dev), net))
1596
			continue;
L
Linus Torvalds 已提交
1597 1598 1599
		if (ipv6_addr_equal(&ifp->addr, addr)) {
			if (dev == NULL || ifp->idev->dev == dev ||
			    !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
1600
				result = ifp;
L
Linus Torvalds 已提交
1601 1602 1603 1604 1605
				in6_ifa_hold(ifp);
				break;
			}
		}
	}
1606
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
1607

1608
	return result;
L
Linus Torvalds 已提交
1609 1610 1611 1612
}

/* Gets referenced address, destroys ifaddr */

B
Brian Haley 已提交
1613
static void addrconf_dad_stop(struct inet6_ifaddr *ifp, int dad_failed)
L
Linus Torvalds 已提交
1614 1615 1616
{
	if (ifp->flags&IFA_F_PERMANENT) {
		spin_lock_bh(&ifp->lock);
1617
		addrconf_del_dad_work(ifp);
L
Linus Torvalds 已提交
1618
		ifp->flags |= IFA_F_TENTATIVE;
B
Brian Haley 已提交
1619 1620
		if (dad_failed)
			ifp->flags |= IFA_F_DADFAILED;
L
Linus Torvalds 已提交
1621
		spin_unlock_bh(&ifp->lock);
1622 1623
		if (dad_failed)
			ipv6_ifa_notify(0, ifp);
L
Linus Torvalds 已提交
1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637
		in6_ifa_put(ifp);
	} else if (ifp->flags&IFA_F_TEMPORARY) {
		struct inet6_ifaddr *ifpub;
		spin_lock_bh(&ifp->lock);
		ifpub = ifp->ifpub;
		if (ifpub) {
			in6_ifa_hold(ifpub);
			spin_unlock_bh(&ifp->lock);
			ipv6_create_tempaddr(ifpub, ifp);
			in6_ifa_put(ifpub);
		} else {
			spin_unlock_bh(&ifp->lock);
		}
		ipv6_del_addr(ifp);
1638
	} else {
L
Linus Torvalds 已提交
1639
		ipv6_del_addr(ifp);
1640
	}
L
Linus Torvalds 已提交
1641 1642
}

H
Herbert Xu 已提交
1643 1644 1645 1646
static int addrconf_dad_end(struct inet6_ifaddr *ifp)
{
	int err = -ENOENT;

1647
	spin_lock_bh(&ifp->state_lock);
H
Herbert Xu 已提交
1648 1649 1650 1651
	if (ifp->state == INET6_IFADDR_STATE_DAD) {
		ifp->state = INET6_IFADDR_STATE_POSTDAD;
		err = 0;
	}
1652
	spin_unlock_bh(&ifp->state_lock);
H
Herbert Xu 已提交
1653 1654 1655 1656

	return err;
}

1657 1658
void addrconf_dad_failure(struct inet6_ifaddr *ifp)
{
1659
	struct inet6_dev *idev = ifp->idev;
1660

1661 1662
	if (addrconf_dad_end(ifp)) {
		in6_ifa_put(ifp);
H
Herbert Xu 已提交
1663
		return;
1664
	}
H
Herbert Xu 已提交
1665

1666 1667
	net_info_ratelimited("%s: IPv6 duplicate address %pI6c detected!\n",
			     ifp->idev->dev->name, &ifp->addr);
1668

1669 1670 1671 1672 1673 1674 1675 1676 1677 1678
	if (idev->cnf.accept_dad > 1 && !idev->cnf.disable_ipv6) {
		struct in6_addr addr;

		addr.s6_addr32[0] = htonl(0xfe800000);
		addr.s6_addr32[1] = 0;

		if (!ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) &&
		    ipv6_addr_equal(&ifp->addr, &addr)) {
			/* DAD failed for link-local based on MAC address */
			idev->cnf.disable_ipv6 = 1;
1679

1680
			pr_info("%s: IPv6 being disabled!\n",
1681
				ifp->idev->dev->name);
1682 1683 1684
		}
	}

1685 1686 1687 1688 1689 1690
	spin_lock_bh(&ifp->state_lock);
	/* transition from _POSTDAD to _ERRDAD */
	ifp->state = INET6_IFADDR_STATE_ERRDAD;
	spin_unlock_bh(&ifp->state_lock);

	addrconf_mod_dad_work(ifp, 0);
1691
}
L
Linus Torvalds 已提交
1692

1693 1694
/* Join to solicited addr multicast group.
 * caller must hold RTNL */
1695
void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr)
L
Linus Torvalds 已提交
1696 1697 1698 1699 1700 1701 1702 1703 1704 1705
{
	struct in6_addr maddr;

	if (dev->flags&(IFF_LOOPBACK|IFF_NOARP))
		return;

	addrconf_addr_solict_mult(addr, &maddr);
	ipv6_dev_mc_inc(dev, &maddr);
}

1706
/* caller must hold RTNL */
1707
void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr)
L
Linus Torvalds 已提交
1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
{
	struct in6_addr maddr;

	if (idev->dev->flags&(IFF_LOOPBACK|IFF_NOARP))
		return;

	addrconf_addr_solict_mult(addr, &maddr);
	__ipv6_dev_mc_dec(idev, &maddr);
}

1718
/* caller must hold RTNL */
1719
static void addrconf_join_anycast(struct inet6_ifaddr *ifp)
L
Linus Torvalds 已提交
1720 1721
{
	struct in6_addr addr;
1722

1723
	if (ifp->prefix_len >= 127) /* RFC 6164 */
1724
		return;
L
Linus Torvalds 已提交
1725 1726 1727 1728 1729 1730
	ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
	if (ipv6_addr_any(&addr))
		return;
	ipv6_dev_ac_inc(ifp->idev->dev, &addr);
}

1731
/* caller must hold RTNL */
1732
static void addrconf_leave_anycast(struct inet6_ifaddr *ifp)
L
Linus Torvalds 已提交
1733 1734
{
	struct in6_addr addr;
1735

1736
	if (ifp->prefix_len >= 127) /* RFC 6164 */
1737
		return;
L
Linus Torvalds 已提交
1738 1739 1740 1741 1742 1743
	ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
	if (ipv6_addr_any(&addr))
		return;
	__ipv6_dev_ac_dec(ifp->idev, &addr);
}

1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774
static int addrconf_ifid_eui48(u8 *eui, struct net_device *dev)
{
	if (dev->addr_len != ETH_ALEN)
		return -1;
	memcpy(eui, dev->dev_addr, 3);
	memcpy(eui + 5, dev->dev_addr + 3, 3);

	/*
	 * The zSeries OSA network cards can be shared among various
	 * OS instances, but the OSA cards have only one MAC address.
	 * This leads to duplicate address conflicts in conjunction
	 * with IPv6 if more than one instance uses the same card.
	 *
	 * The driver for these cards can deliver a unique 16-bit
	 * identifier for each instance sharing the same card.  It is
	 * placed instead of 0xFFFE in the interface identifier.  The
	 * "u" bit of the interface identifier is not inverted in this
	 * case.  Hence the resulting interface identifier has local
	 * scope according to RFC2373.
	 */
	if (dev->dev_id) {
		eui[3] = (dev->dev_id >> 8) & 0xFF;
		eui[4] = dev->dev_id & 0xFF;
	} else {
		eui[3] = 0xFF;
		eui[4] = 0xFE;
		eui[0] ^= 2;
	}
	return 0;
}

1775 1776 1777 1778 1779
static int addrconf_ifid_eui64(u8 *eui, struct net_device *dev)
{
	if (dev->addr_len != IEEE802154_ADDR_LEN)
		return -1;
	memcpy(eui, dev->dev_addr, 8);
1780
	eui[0] ^= 2;
1781 1782 1783
	return 0;
}

1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797
static int addrconf_ifid_ieee1394(u8 *eui, struct net_device *dev)
{
	union fwnet_hwaddr *ha;

	if (dev->addr_len != FWNET_ALEN)
		return -1;

	ha = (union fwnet_hwaddr *)dev->dev_addr;

	memcpy(eui, &ha->uc.uniq_id, sizeof(ha->uc.uniq_id));
	eui[0] ^= 2;
	return 0;
}

1798 1799 1800 1801 1802 1803
static int addrconf_ifid_arcnet(u8 *eui, struct net_device *dev)
{
	/* XXX: inherit EUI-64 from other interface -- yoshfuji */
	if (dev->addr_len != ARCNET_ALEN)
		return -1;
	memset(eui, 0, 7);
1804
	eui[7] = *(u8 *)dev->dev_addr;
1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
	return 0;
}

static int addrconf_ifid_infiniband(u8 *eui, struct net_device *dev)
{
	if (dev->addr_len != INFINIBAND_ALEN)
		return -1;
	memcpy(eui, dev->dev_addr + 12, 8);
	eui[0] |= 2;
	return 0;
}

1817
static int __ipv6_isatap_ifid(u8 *eui, __be32 addr)
1818
{
1819 1820
	if (addr == 0)
		return -1;
1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840
	eui[0] = (ipv4_is_zeronet(addr) || ipv4_is_private_10(addr) ||
		  ipv4_is_loopback(addr) || ipv4_is_linklocal_169(addr) ||
		  ipv4_is_private_172(addr) || ipv4_is_test_192(addr) ||
		  ipv4_is_anycast_6to4(addr) || ipv4_is_private_192(addr) ||
		  ipv4_is_test_198(addr) || ipv4_is_multicast(addr) ||
		  ipv4_is_lbcast(addr)) ? 0x00 : 0x02;
	eui[1] = 0;
	eui[2] = 0x5E;
	eui[3] = 0xFE;
	memcpy(eui + 4, &addr, 4);
	return 0;
}

static int addrconf_ifid_sit(u8 *eui, struct net_device *dev)
{
	if (dev->priv_flags & IFF_ISATAP)
		return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
	return -1;
}

1841 1842 1843 1844 1845
static int addrconf_ifid_gre(u8 *eui, struct net_device *dev)
{
	return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
}

1846 1847 1848 1849 1850 1851 1852 1853 1854 1855
static int addrconf_ifid_ip6tnl(u8 *eui, struct net_device *dev)
{
	memcpy(eui, dev->perm_addr, 3);
	memcpy(eui + 5, dev->perm_addr + 3, 3);
	eui[3] = 0xFF;
	eui[4] = 0xFE;
	eui[0] ^= 2;
	return 0;
}

L
Linus Torvalds 已提交
1856 1857 1858 1859 1860
static int ipv6_generate_eui64(u8 *eui, struct net_device *dev)
{
	switch (dev->type) {
	case ARPHRD_ETHER:
	case ARPHRD_FDDI:
1861
		return addrconf_ifid_eui48(eui, dev);
L
Linus Torvalds 已提交
1862
	case ARPHRD_ARCNET:
1863
		return addrconf_ifid_arcnet(eui, dev);
L
Linus Torvalds 已提交
1864
	case ARPHRD_INFINIBAND:
1865
		return addrconf_ifid_infiniband(eui, dev);
F
Fred L. Templin 已提交
1866
	case ARPHRD_SIT:
1867
		return addrconf_ifid_sit(eui, dev);
1868 1869
	case ARPHRD_IPGRE:
		return addrconf_ifid_gre(eui, dev);
1870
	case ARPHRD_6LOWPAN:
1871 1872
	case ARPHRD_IEEE802154:
		return addrconf_ifid_eui64(eui, dev);
1873 1874
	case ARPHRD_IEEE1394:
		return addrconf_ifid_ieee1394(eui, dev);
1875 1876
	case ARPHRD_TUNNEL6:
		return addrconf_ifid_ip6tnl(eui, dev);
L
Linus Torvalds 已提交
1877 1878 1879 1880 1881 1882 1883 1884 1885 1886
	}
	return -1;
}

static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev)
{
	int err = -1;
	struct inet6_ifaddr *ifp;

	read_lock_bh(&idev->lock);
1887 1888 1889
	list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
		if (ifp->scope > IFA_LINK)
			break;
L
Linus Torvalds 已提交
1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900
		if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
			memcpy(eui, ifp->addr.s6_addr+8, 8);
			err = 0;
			break;
		}
	}
	read_unlock_bh(&idev->lock);
	return err;
}

/* (re)generation of randomized interface identifier (RFC 3041 3.2, 3.5) */
S
Sorin Dumitru 已提交
1901
static void __ipv6_regen_rndid(struct inet6_dev *idev)
L
Linus Torvalds 已提交
1902 1903
{
regen:
1904
	get_random_bytes(idev->rndid, sizeof(idev->rndid));
L
Linus Torvalds 已提交
1905 1906 1907 1908 1909 1910 1911 1912
	idev->rndid[0] &= ~0x02;

	/*
	 * <draft-ietf-ipngwg-temp-addresses-v2-00.txt>:
	 * check if generated address is not inappropriate
	 *
	 *  - Reserved subnet anycast (RFC 2526)
	 *	11111101 11....11 1xxxxxxx
F
Fred L. Templin 已提交
1913
	 *  - ISATAP (RFC4214) 6.1
L
Linus Torvalds 已提交
1914 1915 1916 1917
	 *	00-00-5E-FE-xx-xx-xx-xx
	 *  - value 0
	 *  - XXX: already assigned to an address on the device
	 */
1918
	if (idev->rndid[0] == 0xfd &&
L
Linus Torvalds 已提交
1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
	    (idev->rndid[1]&idev->rndid[2]&idev->rndid[3]&idev->rndid[4]&idev->rndid[5]&idev->rndid[6]) == 0xff &&
	    (idev->rndid[7]&0x80))
		goto regen;
	if ((idev->rndid[0]|idev->rndid[1]) == 0) {
		if (idev->rndid[2] == 0x5e && idev->rndid[3] == 0xfe)
			goto regen;
		if ((idev->rndid[2]|idev->rndid[3]|idev->rndid[4]|idev->rndid[5]|idev->rndid[6]|idev->rndid[7]) == 0x00)
			goto regen;
	}
}

static void ipv6_regen_rndid(unsigned long data)
{
	struct inet6_dev *idev = (struct inet6_dev *) data;
	unsigned long expires;

1935
	rcu_read_lock_bh();
L
Linus Torvalds 已提交
1936 1937 1938 1939 1940
	write_lock_bh(&idev->lock);

	if (idev->dead)
		goto out;

S
Sorin Dumitru 已提交
1941
	__ipv6_regen_rndid(idev);
1942

L
Linus Torvalds 已提交
1943
	expires = jiffies +
1944
		idev->cnf.temp_prefered_lft * HZ -
J
Jiri Pirko 已提交
1945 1946
		idev->cnf.regen_max_retry * idev->cnf.dad_transmits *
		NEIGH_VAR(idev->nd_parms, RETRANS_TIME) -
1947
		idev->cnf.max_desync_factor * HZ;
L
Linus Torvalds 已提交
1948
	if (time_before(expires, jiffies)) {
1949 1950
		pr_warn("%s: too short regeneration interval; timer disabled for %s\n",
			__func__, idev->dev->name);
L
Linus Torvalds 已提交
1951 1952 1953 1954 1955 1956 1957 1958
		goto out;
	}

	if (!mod_timer(&idev->regen_timer, expires))
		in6_dev_hold(idev);

out:
	write_unlock_bh(&idev->lock);
1959
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
1960 1961 1962
	in6_dev_put(idev);
}

S
Sorin Dumitru 已提交
1963
static void  __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr)
1964
{
L
Linus Torvalds 已提交
1965
	if (tmpaddr && memcmp(idev->rndid, &tmpaddr->s6_addr[8], 8) == 0)
S
Sorin Dumitru 已提交
1966
		__ipv6_regen_rndid(idev);
L
Linus Torvalds 已提交
1967 1968 1969 1970 1971 1972 1973 1974
}

/*
 *	Add prefix route.
 */

static void
addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev,
J
Jamal Hadi Salim 已提交
1975
		      unsigned long expires, u32 flags)
L
Linus Torvalds 已提交
1976
{
1977 1978 1979 1980 1981 1982 1983
	struct fib6_config cfg = {
		.fc_table = RT6_TABLE_PREFIX,
		.fc_metric = IP6_RT_PRIO_ADDRCONF,
		.fc_ifindex = dev->ifindex,
		.fc_expires = expires,
		.fc_dst_len = plen,
		.fc_flags = RTF_UP | flags,
1984
		.fc_nlinfo.nl_net = dev_net(dev),
1985
		.fc_protocol = RTPROT_KERNEL,
1986
	};
L
Linus Torvalds 已提交
1987

A
Alexey Dobriyan 已提交
1988
	cfg.fc_dst = *pfx;
L
Linus Torvalds 已提交
1989 1990 1991 1992 1993

	/* Prevent useless cloning on PtP SIT.
	   This thing is done here expecting that the whole
	   class of non-broadcast devices need not cloning.
	 */
A
Amerigo Wang 已提交
1994
#if IS_ENABLED(CONFIG_IPV6_SIT)
1995 1996
	if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT))
		cfg.fc_flags |= RTF_NONEXTHOP;
1997
#endif
L
Linus Torvalds 已提交
1998

1999
	ip6_route_add(&cfg);
L
Linus Torvalds 已提交
2000 2001
}

2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015

static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
						  int plen,
						  const struct net_device *dev,
						  u32 flags, u32 noflags)
{
	struct fib6_node *fn;
	struct rt6_info *rt = NULL;
	struct fib6_table *table;

	table = fib6_get_table(dev_net(dev), RT6_TABLE_PREFIX);
	if (table == NULL)
		return NULL;

2016
	read_lock_bh(&table->tb6_lock);
2017 2018 2019 2020
	fn = fib6_locate(&table->tb6_root, pfx, plen, NULL, 0);
	if (!fn)
		goto out;
	for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
2021
		if (rt->dst.dev->ifindex != dev->ifindex)
2022 2023 2024
			continue;
		if ((rt->rt6i_flags & flags) != flags)
			continue;
2025
		if ((rt->rt6i_flags & noflags) != 0)
2026 2027 2028 2029 2030
			continue;
		dst_hold(&rt->dst);
		break;
	}
out:
2031
	read_unlock_bh(&table->tb6_lock);
2032 2033 2034 2035
	return rt;
}


L
Linus Torvalds 已提交
2036 2037 2038 2039
/* Create "default" multicast route to the interface */

static void addrconf_add_mroute(struct net_device *dev)
{
2040 2041 2042 2043 2044 2045
	struct fib6_config cfg = {
		.fc_table = RT6_TABLE_LOCAL,
		.fc_metric = IP6_RT_PRIO_ADDRCONF,
		.fc_ifindex = dev->ifindex,
		.fc_dst_len = 8,
		.fc_flags = RTF_UP,
2046
		.fc_nlinfo.nl_net = dev_net(dev),
2047 2048 2049 2050 2051
	};

	ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0);

	ip6_route_add(&cfg);
L
Linus Torvalds 已提交
2052 2053 2054 2055 2056 2057 2058 2059
}

static struct inet6_dev *addrconf_add_dev(struct net_device *dev)
{
	struct inet6_dev *idev;

	ASSERT_RTNL();

S
Stephen Hemminger 已提交
2060 2061
	idev = ipv6_find_idev(dev);
	if (!idev)
2062 2063 2064 2065
		return ERR_PTR(-ENOBUFS);

	if (idev->cnf.disable_ipv6)
		return ERR_PTR(-EACCES);
L
Linus Torvalds 已提交
2066 2067

	/* Add default multicast route */
2068 2069
	if (!(dev->flags & IFF_LOOPBACK))
		addrconf_add_mroute(dev);
L
Linus Torvalds 已提交
2070 2071 2072 2073

	return idev;
}

2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140
static void manage_tempaddrs(struct inet6_dev *idev,
			     struct inet6_ifaddr *ifp,
			     __u32 valid_lft, __u32 prefered_lft,
			     bool create, unsigned long now)
{
	u32 flags;
	struct inet6_ifaddr *ift;

	read_lock_bh(&idev->lock);
	/* update all temporary addresses in the list */
	list_for_each_entry(ift, &idev->tempaddr_list, tmp_list) {
		int age, max_valid, max_prefered;

		if (ifp != ift->ifpub)
			continue;

		/* RFC 4941 section 3.3:
		 * If a received option will extend the lifetime of a public
		 * address, the lifetimes of temporary addresses should
		 * be extended, subject to the overall constraint that no
		 * temporary addresses should ever remain "valid" or "preferred"
		 * for a time longer than (TEMP_VALID_LIFETIME) or
		 * (TEMP_PREFERRED_LIFETIME - DESYNC_FACTOR), respectively.
		 */
		age = (now - ift->cstamp) / HZ;
		max_valid = idev->cnf.temp_valid_lft - age;
		if (max_valid < 0)
			max_valid = 0;

		max_prefered = idev->cnf.temp_prefered_lft -
			       idev->cnf.max_desync_factor - age;
		if (max_prefered < 0)
			max_prefered = 0;

		if (valid_lft > max_valid)
			valid_lft = max_valid;

		if (prefered_lft > max_prefered)
			prefered_lft = max_prefered;

		spin_lock(&ift->lock);
		flags = ift->flags;
		ift->valid_lft = valid_lft;
		ift->prefered_lft = prefered_lft;
		ift->tstamp = now;
		if (prefered_lft > 0)
			ift->flags &= ~IFA_F_DEPRECATED;

		spin_unlock(&ift->lock);
		if (!(flags&IFA_F_TENTATIVE))
			ipv6_ifa_notify(0, ift);
	}

	if ((create || list_empty(&idev->tempaddr_list)) &&
	    idev->cnf.use_tempaddr > 0) {
		/* When a new public address is created as described
		 * in [ADDRCONF], also create a new temporary address.
		 * Also create a temporary address if it's enabled but
		 * no temporary address currently exists.
		 */
		read_unlock_bh(&idev->lock);
		ipv6_create_tempaddr(ifp, NULL);
	} else {
		read_unlock_bh(&idev->lock);
	}
}

2141
void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len, bool sllao)
L
Linus Torvalds 已提交
2142 2143 2144 2145 2146 2147
{
	struct prefix_info *pinfo;
	__u32 valid_lft;
	__u32 prefered_lft;
	int addr_type;
	struct inet6_dev *in6_dev;
2148
	struct net *net = dev_net(dev);
L
Linus Torvalds 已提交
2149 2150

	pinfo = (struct prefix_info *) opt;
2151

L
Linus Torvalds 已提交
2152
	if (len < sizeof(struct prefix_info)) {
2153
		ADBG("addrconf: prefix option too short\n");
L
Linus Torvalds 已提交
2154 2155
		return;
	}
2156

L
Linus Torvalds 已提交
2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169
	/*
	 *	Validation checks ([ADDRCONF], page 19)
	 */

	addr_type = ipv6_addr_type(&pinfo->prefix);

	if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL))
		return;

	valid_lft = ntohl(pinfo->valid);
	prefered_lft = ntohl(pinfo->prefered);

	if (prefered_lft > valid_lft) {
2170
		net_warn_ratelimited("addrconf: prefix option has invalid lifetime\n");
L
Linus Torvalds 已提交
2171 2172 2173 2174 2175 2176
		return;
	}

	in6_dev = in6_dev_get(dev);

	if (in6_dev == NULL) {
2177 2178
		net_dbg_ratelimited("addrconf: device %s not configured\n",
				    dev->name);
L
Linus Torvalds 已提交
2179 2180 2181 2182 2183 2184 2185 2186 2187
		return;
	}

	/*
	 *	Two things going on here:
	 *	1) Add routes for on-link prefixes
	 *	2) Configure prefixes with the auto flag set
	 */

2188 2189 2190 2191
	if (pinfo->onlink) {
		struct rt6_info *rt;
		unsigned long rt_expires;

2192 2193 2194 2195 2196
		/* Avoid arithmetic overflow. Really, we could
		 * save rt_expires in seconds, likely valid_lft,
		 * but it would require division in fib gc, that it
		 * not good.
		 */
2197 2198 2199 2200
		if (HZ > USER_HZ)
			rt_expires = addrconf_timeout_fixup(valid_lft, HZ);
		else
			rt_expires = addrconf_timeout_fixup(valid_lft, USER_HZ);
Y
YOSHIFUJI Hideaki 已提交
2201

2202 2203
		if (addrconf_finite_timeout(rt_expires))
			rt_expires *= HZ;
L
Linus Torvalds 已提交
2204

2205 2206 2207 2208 2209
		rt = addrconf_get_prefix_route(&pinfo->prefix,
					       pinfo->prefix_len,
					       dev,
					       RTF_ADDRCONF | RTF_PREFIX_RT,
					       RTF_GATEWAY | RTF_DEFAULT);
L
Linus Torvalds 已提交
2210

2211
		if (rt) {
2212 2213 2214 2215
			/* Autoconf prefix route */
			if (valid_lft == 0) {
				ip6_del_rt(rt);
				rt = NULL;
2216
			} else if (addrconf_finite_timeout(rt_expires)) {
2217
				/* not infinity */
2218
				rt6_set_expires(rt, jiffies + rt_expires);
2219
			} else {
2220
				rt6_clean_expires(rt);
L
Linus Torvalds 已提交
2221 2222
			}
		} else if (valid_lft) {
2223
			clock_t expires = 0;
2224 2225
			int flags = RTF_ADDRCONF | RTF_PREFIX_RT;
			if (addrconf_finite_timeout(rt_expires)) {
2226 2227 2228 2229
				/* not infinity */
				flags |= RTF_EXPIRES;
				expires = jiffies_to_clock_t(rt_expires);
			}
L
Linus Torvalds 已提交
2230
			addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
2231
					      dev, expires, flags);
L
Linus Torvalds 已提交
2232
		}
A
Amerigo Wang 已提交
2233
		ip6_rt_put(rt);
L
Linus Torvalds 已提交
2234 2235 2236 2237 2238
	}

	/* Try to figure out our local address for this prefix */

	if (pinfo->autoconf && in6_dev->cnf.autoconf) {
2239
		struct inet6_ifaddr *ifp;
L
Linus Torvalds 已提交
2240 2241
		struct in6_addr addr;
		int create = 0, update_lft = 0;
2242
		bool tokenized = false;
L
Linus Torvalds 已提交
2243 2244 2245

		if (pinfo->prefix_len == 64) {
			memcpy(&addr, &pinfo->prefix, 8);
2246 2247 2248 2249 2250 2251

			if (!ipv6_addr_any(&in6_dev->token)) {
				read_lock_bh(&in6_dev->lock);
				memcpy(addr.s6_addr + 8,
				       in6_dev->token.s6_addr + 8, 8);
				read_unlock_bh(&in6_dev->lock);
2252
				tokenized = true;
2253 2254
			} else if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
				   ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
L
Linus Torvalds 已提交
2255 2256 2257 2258 2259
				in6_dev_put(in6_dev);
				return;
			}
			goto ok;
		}
2260 2261
		net_dbg_ratelimited("IPv6 addrconf: prefix with wrong length %d\n",
				    pinfo->prefix_len);
L
Linus Torvalds 已提交
2262 2263 2264 2265 2266
		in6_dev_put(in6_dev);
		return;

ok:

2267
		ifp = ipv6_get_ifaddr(net, &addr, dev, 1);
L
Linus Torvalds 已提交
2268 2269 2270

		if (ifp == NULL && valid_lft) {
			int max_addresses = in6_dev->cnf.max_addresses;
2271 2272 2273 2274
			u32 addr_flags = 0;

#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
			if (in6_dev->cnf.optimistic_dad &&
2275
			    !net->ipv6.devconf_all->forwarding && sllao)
2276 2277
				addr_flags = IFA_F_OPTIMISTIC;
#endif
L
Linus Torvalds 已提交
2278 2279 2280 2281 2282 2283

			/* Do not allow to create too much of autoconfigured
			 * addresses; this would be too easy way to crash kernel.
			 */
			if (!max_addresses ||
			    ipv6_count_addresses(in6_dev) < max_addresses)
2284 2285
				ifp = ipv6_add_addr(in6_dev, &addr, NULL,
						    pinfo->prefix_len,
2286
						    addr_type&IPV6_ADDR_SCOPE_MASK,
2287 2288
						    addr_flags, valid_lft,
						    prefered_lft);
L
Linus Torvalds 已提交
2289

2290
			if (IS_ERR_OR_NULL(ifp)) {
L
Linus Torvalds 已提交
2291 2292 2293 2294
				in6_dev_put(in6_dev);
				return;
			}

2295 2296
			update_lft = 0;
			create = 1;
2297 2298
			spin_lock_bh(&ifp->lock);
			ifp->flags |= IFA_F_MANAGETEMPADDR;
L
Linus Torvalds 已提交
2299
			ifp->cstamp = jiffies;
2300
			ifp->tokenized = tokenized;
2301
			spin_unlock_bh(&ifp->lock);
2302
			addrconf_dad_start(ifp);
L
Linus Torvalds 已提交
2303 2304 2305
		}

		if (ifp) {
2306
			u32 flags;
L
Linus Torvalds 已提交
2307 2308 2309 2310 2311 2312 2313 2314 2315 2316
			unsigned long now;
			u32 stored_lft;

			/* update lifetime (RFC2462 5.5.3 e) */
			spin_lock(&ifp->lock);
			now = jiffies;
			if (ifp->valid_lft > (now - ifp->tstamp) / HZ)
				stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ;
			else
				stored_lft = 0;
2317
			if (!update_lft && !create && stored_lft) {
2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332
				const u32 minimum_lft = min(
					stored_lft, (u32)MIN_VALID_LIFETIME);
				valid_lft = max(valid_lft, minimum_lft);

				/* RFC4862 Section 5.5.3e:
				 * "Note that the preferred lifetime of the
				 *  corresponding address is always reset to
				 *  the Preferred Lifetime in the received
				 *  Prefix Information option, regardless of
				 *  whether the valid lifetime is also reset or
				 *  ignored."
				 *
				 * So we should always update prefered_lft here.
				 */
				update_lft = 1;
L
Linus Torvalds 已提交
2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347
			}

			if (update_lft) {
				ifp->valid_lft = valid_lft;
				ifp->prefered_lft = prefered_lft;
				ifp->tstamp = now;
				flags = ifp->flags;
				ifp->flags &= ~IFA_F_DEPRECATED;
				spin_unlock(&ifp->lock);

				if (!(flags&IFA_F_TENTATIVE))
					ipv6_ifa_notify(0, ifp);
			} else
				spin_unlock(&ifp->lock);

2348 2349
			manage_tempaddrs(in6_dev, ifp, valid_lft, prefered_lft,
					 create, now);
2350

L
Linus Torvalds 已提交
2351
			in6_ifa_put(ifp);
2352
			addrconf_verify();
L
Linus Torvalds 已提交
2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363
		}
	}
	inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo);
	in6_dev_put(in6_dev);
}

/*
 *	Set destination address.
 *	Special case for SIT interfaces where we create a new "virtual"
 *	device.
 */
2364
int addrconf_set_dstaddr(struct net *net, void __user *arg)
L
Linus Torvalds 已提交
2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375
{
	struct in6_ifreq ireq;
	struct net_device *dev;
	int err = -EINVAL;

	rtnl_lock();

	err = -EFAULT;
	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
		goto err_exit;

2376
	dev = __dev_get_by_index(net, ireq.ifr6_ifindex);
L
Linus Torvalds 已提交
2377 2378 2379 2380 2381

	err = -ENODEV;
	if (dev == NULL)
		goto err_exit;

A
Amerigo Wang 已提交
2382
#if IS_ENABLED(CONFIG_IPV6_SIT)
L
Linus Torvalds 已提交
2383
	if (dev->type == ARPHRD_SIT) {
2384
		const struct net_device_ops *ops = dev->netdev_ops;
L
Linus Torvalds 已提交
2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398
		struct ifreq ifr;
		struct ip_tunnel_parm p;

		err = -EADDRNOTAVAIL;
		if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4))
			goto err_exit;

		memset(&p, 0, sizeof(p));
		p.iph.daddr = ireq.ifr6_addr.s6_addr32[3];
		p.iph.saddr = 0;
		p.iph.version = 4;
		p.iph.ihl = 5;
		p.iph.protocol = IPPROTO_IPV6;
		p.iph.ttl = 64;
2399
		ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
L
Linus Torvalds 已提交
2400

2401 2402 2403 2404 2405 2406 2407 2408
		if (ops->ndo_do_ioctl) {
			mm_segment_t oldfs = get_fs();

			set_fs(KERNEL_DS);
			err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
			set_fs(oldfs);
		} else
			err = -EOPNOTSUPP;
L
Linus Torvalds 已提交
2409 2410 2411

		if (err == 0) {
			err = -ENOBUFS;
2412 2413
			dev = __dev_get_by_name(net, p.name);
			if (!dev)
L
Linus Torvalds 已提交
2414 2415 2416 2417
				goto err_exit;
			err = dev_open(dev);
		}
	}
2418
#endif
L
Linus Torvalds 已提交
2419 2420 2421 2422 2423 2424 2425 2426 2427

err_exit:
	rtnl_unlock();
	return err;
}

/*
 *	Manual configuration of address on an interface
 */
2428 2429
static int inet6_addr_add(struct net *net, int ifindex,
			  const struct in6_addr *pfx,
2430
			  const struct in6_addr *peer_pfx,
2431 2432
			  unsigned int plen, __u32 ifa_flags,
			  __u32 prefered_lft, __u32 valid_lft)
L
Linus Torvalds 已提交
2433 2434 2435 2436 2437
{
	struct inet6_ifaddr *ifp;
	struct inet6_dev *idev;
	struct net_device *dev;
	int scope;
2438 2439
	u32 flags;
	clock_t expires;
2440
	unsigned long timeout;
L
Linus Torvalds 已提交
2441 2442

	ASSERT_RTNL();
2443

2444 2445 2446
	if (plen > 128)
		return -EINVAL;

2447 2448 2449 2450
	/* check the lifetime */
	if (!valid_lft || prefered_lft > valid_lft)
		return -EINVAL;

2451 2452 2453
	if (ifa_flags & IFA_F_MANAGETEMPADDR && plen != 64)
		return -EINVAL;

2454 2455
	dev = __dev_get_by_index(net, ifindex);
	if (!dev)
L
Linus Torvalds 已提交
2456
		return -ENODEV;
2457

2458 2459 2460
	idev = addrconf_add_dev(dev);
	if (IS_ERR(idev))
		return PTR_ERR(idev);
L
Linus Torvalds 已提交
2461 2462 2463

	scope = ipv6_addr_scope(pfx);

2464 2465 2466 2467
	timeout = addrconf_timeout_fixup(valid_lft, HZ);
	if (addrconf_finite_timeout(timeout)) {
		expires = jiffies_to_clock_t(timeout * HZ);
		valid_lft = timeout;
2468
		flags = RTF_EXPIRES;
2469 2470 2471 2472
	} else {
		expires = 0;
		flags = 0;
		ifa_flags |= IFA_F_PERMANENT;
2473
	}
2474

2475 2476 2477 2478 2479 2480
	timeout = addrconf_timeout_fixup(prefered_lft, HZ);
	if (addrconf_finite_timeout(timeout)) {
		if (timeout == 0)
			ifa_flags |= IFA_F_DEPRECATED;
		prefered_lft = timeout;
	}
2481

2482 2483
	ifp = ipv6_add_addr(idev, pfx, peer_pfx, plen, scope, ifa_flags,
			    valid_lft, prefered_lft);
2484

L
Linus Torvalds 已提交
2485
	if (!IS_ERR(ifp)) {
2486 2487 2488 2489 2490
		if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) {
			addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev,
					      expires, flags);
		}

2491 2492 2493 2494 2495
		/*
		 * Note that section 3.1 of RFC 4429 indicates
		 * that the Optimistic flag should not be set for
		 * manually configured addresses
		 */
2496
		addrconf_dad_start(ifp);
2497 2498 2499
		if (ifa_flags & IFA_F_MANAGETEMPADDR)
			manage_tempaddrs(idev, ifp, valid_lft, prefered_lft,
					 true, jiffies);
L
Linus Torvalds 已提交
2500
		in6_ifa_put(ifp);
2501
		addrconf_verify_rtnl();
L
Linus Torvalds 已提交
2502 2503 2504 2505 2506 2507
		return 0;
	}

	return PTR_ERR(ifp);
}

2508 2509
static int inet6_addr_del(struct net *net, int ifindex, u32 ifa_flags,
			  const struct in6_addr *pfx, unsigned int plen)
L
Linus Torvalds 已提交
2510 2511 2512 2513
{
	struct inet6_ifaddr *ifp;
	struct inet6_dev *idev;
	struct net_device *dev;
2514

2515 2516 2517
	if (plen > 128)
		return -EINVAL;

2518 2519
	dev = __dev_get_by_index(net, ifindex);
	if (!dev)
L
Linus Torvalds 已提交
2520 2521
		return -ENODEV;

2522
	if ((idev = __in6_dev_get(dev)) == NULL)
L
Linus Torvalds 已提交
2523 2524 2525
		return -ENXIO;

	read_lock_bh(&idev->lock);
2526
	list_for_each_entry(ifp, &idev->addr_list, if_list) {
L
Linus Torvalds 已提交
2527 2528 2529 2530
		if (ifp->prefix_len == plen &&
		    ipv6_addr_equal(pfx, &ifp->addr)) {
			in6_ifa_hold(ifp);
			read_unlock_bh(&idev->lock);
2531

2532 2533 2534 2535
			if (!(ifp->flags & IFA_F_TEMPORARY) &&
			    (ifa_flags & IFA_F_MANAGETEMPADDR))
				manage_tempaddrs(idev, ifp, 0, 0, false,
						 jiffies);
L
Linus Torvalds 已提交
2536
			ipv6_del_addr(ifp);
2537
			addrconf_verify_rtnl();
L
Linus Torvalds 已提交
2538 2539 2540 2541 2542 2543 2544 2545
			return 0;
		}
	}
	read_unlock_bh(&idev->lock);
	return -EADDRNOTAVAIL;
}


2546
int addrconf_add_ifaddr(struct net *net, void __user *arg)
L
Linus Torvalds 已提交
2547 2548 2549
{
	struct in6_ifreq ireq;
	int err;
2550

2551
	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
2552
		return -EPERM;
2553

L
Linus Torvalds 已提交
2554 2555 2556 2557
	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
		return -EFAULT;

	rtnl_lock();
2558
	err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL,
2559 2560
			     ireq.ifr6_prefixlen, IFA_F_PERMANENT,
			     INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
L
Linus Torvalds 已提交
2561 2562 2563 2564
	rtnl_unlock();
	return err;
}

2565
int addrconf_del_ifaddr(struct net *net, void __user *arg)
L
Linus Torvalds 已提交
2566 2567 2568
{
	struct in6_ifreq ireq;
	int err;
2569

2570
	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
2571 2572 2573 2574 2575 2576
		return -EPERM;

	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
		return -EFAULT;

	rtnl_lock();
2577
	err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr,
2578
			     ireq.ifr6_prefixlen);
L
Linus Torvalds 已提交
2579 2580 2581 2582
	rtnl_unlock();
	return err;
}

2583 2584 2585 2586 2587
static void add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
		     int plen, int scope)
{
	struct inet6_ifaddr *ifp;

2588
	ifp = ipv6_add_addr(idev, addr, NULL, plen,
2589 2590
			    scope, IFA_F_PERMANENT,
			    INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
2591 2592 2593 2594 2595 2596 2597 2598 2599
	if (!IS_ERR(ifp)) {
		spin_lock_bh(&ifp->lock);
		ifp->flags &= ~IFA_F_TENTATIVE;
		spin_unlock_bh(&ifp->lock);
		ipv6_ifa_notify(RTM_NEWADDR, ifp);
		in6_ifa_put(ifp);
	}
}

A
Amerigo Wang 已提交
2600
#if IS_ENABLED(CONFIG_IPV6_SIT)
L
Linus Torvalds 已提交
2601 2602 2603 2604
static void sit_add_v4_addrs(struct inet6_dev *idev)
{
	struct in6_addr addr;
	struct net_device *dev;
2605
	struct net *net = dev_net(idev->dev);
2606
	int scope, plen;
2607
	u32 pflags = 0;
L
Linus Torvalds 已提交
2608 2609 2610 2611 2612 2613 2614 2615 2616

	ASSERT_RTNL();

	memset(&addr, 0, sizeof(struct in6_addr));
	memcpy(&addr.s6_addr32[3], idev->dev->dev_addr, 4);

	if (idev->dev->flags&IFF_POINTOPOINT) {
		addr.s6_addr32[0] = htonl(0xfe800000);
		scope = IFA_LINK;
2617
		plen = 64;
L
Linus Torvalds 已提交
2618 2619
	} else {
		scope = IPV6_ADDR_COMPATv4;
2620
		plen = 96;
2621
		pflags |= RTF_NONEXTHOP;
L
Linus Torvalds 已提交
2622 2623 2624
	}

	if (addr.s6_addr32[3]) {
2625
		add_addr(idev, &addr, plen, scope);
2626
		addrconf_prefix_route(&addr, plen, idev->dev, 0, pflags);
L
Linus Torvalds 已提交
2627 2628 2629
		return;
	}

2630
	for_each_netdev(net, dev) {
2631
		struct in_device *in_dev = __in_dev_get_rtnl(dev);
L
Linus Torvalds 已提交
2632
		if (in_dev && (dev->flags & IFF_UP)) {
2633
			struct in_ifaddr *ifa;
L
Linus Torvalds 已提交
2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648

			int flag = scope;

			for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {

				addr.s6_addr32[3] = ifa->ifa_local;

				if (ifa->ifa_scope == RT_SCOPE_LINK)
					continue;
				if (ifa->ifa_scope >= RT_SCOPE_HOST) {
					if (idev->dev->flags&IFF_POINTOPOINT)
						continue;
					flag |= IFA_HOST;
				}

2649
				add_addr(idev, &addr, plen, flag);
2650 2651
				addrconf_prefix_route(&addr, plen, idev->dev, 0,
						      pflags);
L
Linus Torvalds 已提交
2652 2653
			}
		}
2654
	}
L
Linus Torvalds 已提交
2655
}
2656
#endif
L
Linus Torvalds 已提交
2657 2658 2659 2660

static void init_loopback(struct net_device *dev)
{
	struct inet6_dev  *idev;
2661 2662 2663
	struct net_device *sp_dev;
	struct inet6_ifaddr *sp_ifa;
	struct rt6_info *sp_rt;
L
Linus Torvalds 已提交
2664 2665 2666 2667 2668

	/* ::1 */

	ASSERT_RTNL();

2669
	if ((idev = ipv6_find_idev(dev)) == NULL) {
2670
		pr_debug("%s: add_dev failed\n", __func__);
L
Linus Torvalds 已提交
2671 2672 2673
		return;
	}

2674
	add_addr(idev, &in6addr_loopback, 128, IFA_HOST);
2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690

	/* Add routes to other interface's IPv6 addresses */
	for_each_netdev(dev_net(dev), sp_dev) {
		if (!strcmp(sp_dev->name, dev->name))
			continue;

		idev = __in6_dev_get(sp_dev);
		if (!idev)
			continue;

		read_lock_bh(&idev->lock);
		list_for_each_entry(sp_ifa, &idev->addr_list, if_list) {

			if (sp_ifa->flags & (IFA_F_DADFAILED | IFA_F_TENTATIVE))
				continue;

2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702
			if (sp_ifa->rt) {
				/* This dst has been added to garbage list when
				 * lo device down, release this obsolete dst and
				 * reallocate a new router for ifa.
				 */
				if (sp_ifa->rt->dst.obsolete > 0) {
					ip6_rt_put(sp_ifa->rt);
					sp_ifa->rt = NULL;
				} else {
					continue;
				}
			}
2703

2704
			sp_rt = addrconf_dst_alloc(idev, &sp_ifa->addr, false);
2705 2706

			/* Failure cases are ignored */
2707 2708
			if (!IS_ERR(sp_rt)) {
				sp_ifa->rt = sp_rt;
2709
				ip6_ins_rt(sp_rt);
2710
			}
2711 2712 2713
		}
		read_unlock_bh(&idev->lock);
	}
L
Linus Torvalds 已提交
2714 2715
}

2716
static void addrconf_add_linklocal(struct inet6_dev *idev, const struct in6_addr *addr)
L
Linus Torvalds 已提交
2717
{
2718
	struct inet6_ifaddr *ifp;
2719 2720 2721 2722
	u32 addr_flags = IFA_F_PERMANENT;

#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
	if (idev->cnf.optimistic_dad &&
2723
	    !dev_net(idev->dev)->ipv6.devconf_all->forwarding)
2724 2725
		addr_flags |= IFA_F_OPTIMISTIC;
#endif
L
Linus Torvalds 已提交
2726

2727

2728 2729
	ifp = ipv6_add_addr(idev, addr, NULL, 64, IFA_LINK, addr_flags,
			    INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
L
Linus Torvalds 已提交
2730
	if (!IS_ERR(ifp)) {
2731
		addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev, 0, 0);
2732
		addrconf_dad_start(ifp);
L
Linus Torvalds 已提交
2733 2734 2735 2736
		in6_ifa_put(ifp);
	}
}

2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753
static void addrconf_addr_gen(struct inet6_dev *idev, bool prefix_route)
{
	if (idev->addr_gen_mode == IN6_ADDR_GEN_MODE_EUI64) {
		struct in6_addr addr;

		ipv6_addr_set(&addr,  htonl(0xFE800000), 0, 0, 0);
		/* addrconf_add_linklocal also adds a prefix_route and we
		 * only need to care about prefix routes if ipv6_generate_eui64
		 * couldn't generate one.
		 */
		if (ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) == 0)
			addrconf_add_linklocal(idev, &addr);
		else if (prefix_route)
			addrconf_prefix_route(&addr, 64, idev->dev, 0, 0);
	}
}

L
Linus Torvalds 已提交
2754 2755
static void addrconf_dev_config(struct net_device *dev)
{
2756
	struct inet6_dev *idev;
L
Linus Torvalds 已提交
2757 2758 2759

	ASSERT_RTNL();

2760 2761 2762
	if ((dev->type != ARPHRD_ETHER) &&
	    (dev->type != ARPHRD_FDDI) &&
	    (dev->type != ARPHRD_ARCNET) &&
2763
	    (dev->type != ARPHRD_INFINIBAND) &&
2764
	    (dev->type != ARPHRD_IEEE802154) &&
2765
	    (dev->type != ARPHRD_IEEE1394) &&
2766 2767
	    (dev->type != ARPHRD_TUNNEL6) &&
	    (dev->type != ARPHRD_6LOWPAN)) {
2768 2769 2770 2771
		/* Alas, we support only Ethernet autoconfiguration. */
		return;
	}

L
Linus Torvalds 已提交
2772
	idev = addrconf_add_dev(dev);
2773
	if (IS_ERR(idev))
L
Linus Torvalds 已提交
2774 2775
		return;

2776
	addrconf_addr_gen(idev, false);
L
Linus Torvalds 已提交
2777 2778
}

A
Amerigo Wang 已提交
2779
#if IS_ENABLED(CONFIG_IPV6_SIT)
L
Linus Torvalds 已提交
2780 2781 2782 2783 2784 2785
static void addrconf_sit_config(struct net_device *dev)
{
	struct inet6_dev *idev;

	ASSERT_RTNL();

2786 2787 2788
	/*
	 * Configure the tunnel with one of our IPv4
	 * addresses... we should configure all of
L
Linus Torvalds 已提交
2789 2790 2791
	 * our v4 addrs in the tunnel
	 */

2792
	if ((idev = ipv6_find_idev(dev)) == NULL) {
2793
		pr_debug("%s: add_dev failed\n", __func__);
L
Linus Torvalds 已提交
2794 2795 2796
		return;
	}

F
Fred L. Templin 已提交
2797
	if (dev->priv_flags & IFF_ISATAP) {
2798
		addrconf_addr_gen(idev, false);
F
Fred L. Templin 已提交
2799 2800 2801
		return;
	}

L
Linus Torvalds 已提交
2802 2803
	sit_add_v4_addrs(idev);

2804
	if (dev->flags&IFF_POINTOPOINT)
L
Linus Torvalds 已提交
2805 2806
		addrconf_add_mroute(dev);
}
2807
#endif
L
Linus Torvalds 已提交
2808

A
Amerigo Wang 已提交
2809
#if IS_ENABLED(CONFIG_NET_IPGRE)
2810 2811 2812 2813 2814 2815
static void addrconf_gre_config(struct net_device *dev)
{
	struct inet6_dev *idev;

	ASSERT_RTNL();

2816
	if ((idev = ipv6_find_idev(dev)) == NULL) {
2817
		pr_debug("%s: add_dev failed\n", __func__);
2818 2819 2820
		return;
	}

2821
	addrconf_addr_gen(idev, true);
2822 2823 2824
}
#endif

2825
static int addrconf_notify(struct notifier_block *this, unsigned long event,
2826
			   void *ptr)
L
Linus Torvalds 已提交
2827
{
2828
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2829
	struct inet6_dev *idev = __in6_dev_get(dev);
2830
	int run_pending = 0;
2831
	int err;
L
Linus Torvalds 已提交
2832

S
Stephen Hemminger 已提交
2833
	switch (event) {
2834
	case NETDEV_REGISTER:
2835
		if (!idev && dev->mtu >= IPV6_MIN_MTU) {
2836
			idev = ipv6_add_dev(dev);
2837 2838
			if (IS_ERR(idev))
				return notifier_from_errno(PTR_ERR(idev));
2839 2840
		}
		break;
S
Stephen Hemminger 已提交
2841

L
Linus Torvalds 已提交
2842
	case NETDEV_UP:
2843
	case NETDEV_CHANGE:
2844 2845 2846
		if (dev->flags & IFF_SLAVE)
			break;

2847
		if (event == NETDEV_UP) {
2848
			if (!addrconf_qdisc_ok(dev)) {
2849
				/* device is not ready yet. */
2850
				pr_info("ADDRCONF(NETDEV_UP): %s: link is not ready\n",
2851 2852 2853
					dev->name);
				break;
			}
2854

2855 2856 2857
			if (!idev && dev->mtu >= IPV6_MIN_MTU)
				idev = ipv6_add_dev(dev);

2858
			if (!IS_ERR_OR_NULL(idev)) {
2859
				idev->if_flags |= IF_READY;
2860 2861
				run_pending = 1;
			}
2862
		} else {
2863
			if (!addrconf_qdisc_ok(dev)) {
2864 2865 2866 2867 2868
				/* device is still not ready. */
				break;
			}

			if (idev) {
S
Stephen Hemminger 已提交
2869
				if (idev->if_flags & IF_READY)
2870 2871 2872 2873 2874
					/* device is already configured. */
					break;
				idev->if_flags |= IF_READY;
			}

2875 2876
			pr_info("ADDRCONF(NETDEV_CHANGE): %s: link becomes ready\n",
				dev->name);
2877

2878
			run_pending = 1;
2879 2880
		}

S
Stephen Hemminger 已提交
2881
		switch (dev->type) {
A
Amerigo Wang 已提交
2882
#if IS_ENABLED(CONFIG_IPV6_SIT)
L
Linus Torvalds 已提交
2883 2884 2885
		case ARPHRD_SIT:
			addrconf_sit_config(dev);
			break;
2886
#endif
A
Amerigo Wang 已提交
2887
#if IS_ENABLED(CONFIG_NET_IPGRE)
2888 2889 2890
		case ARPHRD_IPGRE:
			addrconf_gre_config(dev);
			break;
2891
#endif
L
Linus Torvalds 已提交
2892 2893 2894 2895 2896 2897 2898
		case ARPHRD_LOOPBACK:
			init_loopback(dev);
			break;

		default:
			addrconf_dev_config(dev);
			break;
2899
		}
S
Stephen Hemminger 已提交
2900

2901
		if (!IS_ERR_OR_NULL(idev)) {
2902 2903 2904
			if (run_pending)
				addrconf_dad_run(idev);

S
Stephen Hemminger 已提交
2905 2906 2907 2908
			/*
			 * If the MTU changed during the interface down,
			 * when the interface up, the changed MTU must be
			 * reflected in the idev as well as routers.
L
Linus Torvalds 已提交
2909
			 */
S
Stephen Hemminger 已提交
2910 2911
			if (idev->cnf.mtu6 != dev->mtu &&
			    dev->mtu >= IPV6_MIN_MTU) {
L
Linus Torvalds 已提交
2912 2913 2914 2915 2916
				rt6_mtu_change(dev, dev->mtu);
				idev->cnf.mtu6 = dev->mtu;
			}
			idev->tstamp = jiffies;
			inet6_ifinfo_notify(RTM_NEWLINK, idev);
S
Stephen Hemminger 已提交
2917 2918 2919 2920

			/*
			 * If the changed mtu during down is lower than
			 * IPV6_MIN_MTU stop IPv6 on this interface.
L
Linus Torvalds 已提交
2921 2922
			 */
			if (dev->mtu < IPV6_MIN_MTU)
S
Stephen Hemminger 已提交
2923
				addrconf_ifdown(dev, 1);
L
Linus Torvalds 已提交
2924 2925 2926 2927
		}
		break;

	case NETDEV_CHANGEMTU:
2928
		if (idev && dev->mtu >= IPV6_MIN_MTU) {
L
Linus Torvalds 已提交
2929 2930 2931 2932 2933
			rt6_mtu_change(dev, dev->mtu);
			idev->cnf.mtu6 = dev->mtu;
			break;
		}

2934 2935
		if (!idev && dev->mtu >= IPV6_MIN_MTU) {
			idev = ipv6_add_dev(dev);
2936
			if (!IS_ERR(idev))
2937 2938 2939
				break;
		}

S
Stephen Hemminger 已提交
2940
		/*
2941
		 * if MTU under IPV6_MIN_MTU.
S
Stephen Hemminger 已提交
2942 2943
		 * Stop IPv6 on this interface.
		 */
L
Linus Torvalds 已提交
2944 2945 2946 2947 2948 2949 2950 2951

	case NETDEV_DOWN:
	case NETDEV_UNREGISTER:
		/*
		 *	Remove all addresses from this interface.
		 */
		addrconf_ifdown(dev, event != NETDEV_DOWN);
		break;
2952

L
Linus Torvalds 已提交
2953 2954
	case NETDEV_CHANGENAME:
		if (idev) {
2955
			snmp6_unregister_dev(idev);
2956
			addrconf_sysctl_unregister(idev);
2957
			err = addrconf_sysctl_register(idev);
2958 2959
			if (err)
				return notifier_from_errno(err);
2960 2961 2962 2963 2964
			err = snmp6_register_dev(idev);
			if (err) {
				addrconf_sysctl_unregister(idev);
				return notifier_from_errno(err);
			}
2965
		}
L
Linus Torvalds 已提交
2966
		break;
S
Stephen Hemminger 已提交
2967

2968 2969 2970
	case NETDEV_PRE_TYPE_CHANGE:
	case NETDEV_POST_TYPE_CHANGE:
		addrconf_type_change(dev, event);
2971
		break;
2972
	}
L
Linus Torvalds 已提交
2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983

	return NOTIFY_OK;
}

/*
 *	addrconf module should be notified of a device going up
 */
static struct notifier_block ipv6_dev_notf = {
	.notifier_call = addrconf_notify,
};

2984
static void addrconf_type_change(struct net_device *dev, unsigned long event)
2985 2986 2987 2988 2989 2990
{
	struct inet6_dev *idev;
	ASSERT_RTNL();

	idev = __in6_dev_get(dev);

2991
	if (event == NETDEV_POST_TYPE_CHANGE)
2992
		ipv6_mc_remap(idev);
2993
	else if (event == NETDEV_PRE_TYPE_CHANGE)
2994 2995 2996
		ipv6_mc_unmap(idev);
}

L
Linus Torvalds 已提交
2997 2998
static int addrconf_ifdown(struct net_device *dev, int how)
{
2999
	struct net *net = dev_net(dev);
3000 3001
	struct inet6_dev *idev;
	struct inet6_ifaddr *ifa;
3002
	int state, i;
L
Linus Torvalds 已提交
3003 3004 3005

	ASSERT_RTNL();

3006 3007
	rt6_ifdown(net, dev);
	neigh_ifdown(&nd_tbl, dev);
L
Linus Torvalds 已提交
3008 3009 3010 3011 3012

	idev = __in6_dev_get(dev);
	if (idev == NULL)
		return -ENODEV;

S
Stephen Hemminger 已提交
3013 3014 3015
	/*
	 * Step 1: remove reference to ipv6 device from parent device.
	 *	   Do not dev_put!
L
Linus Torvalds 已提交
3016
	 */
3017
	if (how) {
L
Linus Torvalds 已提交
3018
		idev->dead = 1;
3019 3020

		/* protected by rtnl_lock */
3021
		RCU_INIT_POINTER(dev->ip6_ptr, NULL);
L
Linus Torvalds 已提交
3022 3023 3024 3025 3026 3027

		/* Step 1.5: remove snmp6 entry */
		snmp6_unregister_dev(idev);

	}

3028 3029 3030 3031 3032 3033
	/* Step 2: clear hash table */
	for (i = 0; i < IN6_ADDR_HSIZE; i++) {
		struct hlist_head *h = &inet6_addr_lst[i];

		spin_lock_bh(&addrconf_hash_lock);
	restart:
3034
		hlist_for_each_entry_rcu(ifa, h, addr_lst) {
3035 3036
			if (ifa->idev == idev) {
				hlist_del_init_rcu(&ifa->addr_lst);
3037
				addrconf_del_dad_work(ifa);
3038 3039 3040 3041 3042 3043
				goto restart;
			}
		}
		spin_unlock_bh(&addrconf_hash_lock);
	}

L
Linus Torvalds 已提交
3044 3045
	write_lock_bh(&idev->lock);

3046 3047
	addrconf_del_rs_timer(idev);

S
Stephen Hemminger 已提交
3048
	/* Step 2: clear flags for stateless addrconf */
3049
	if (!how)
3050
		idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY);
L
Linus Torvalds 已提交
3051

3052
	if (how && del_timer(&idev->regen_timer))
L
Linus Torvalds 已提交
3053 3054
		in6_dev_put(idev);

S
Stephen Hemminger 已提交
3055
	/* Step 3: clear tempaddr list */
3056 3057 3058 3059
	while (!list_empty(&idev->tempaddr_list)) {
		ifa = list_first_entry(&idev->tempaddr_list,
				       struct inet6_ifaddr, tmp_list);
		list_del(&ifa->tmp_list);
L
Linus Torvalds 已提交
3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070
		write_unlock_bh(&idev->lock);
		spin_lock_bh(&ifa->lock);

		if (ifa->ifpub) {
			in6_ifa_put(ifa->ifpub);
			ifa->ifpub = NULL;
		}
		spin_unlock_bh(&ifa->lock);
		in6_ifa_put(ifa);
		write_lock_bh(&idev->lock);
	}
3071

3072 3073 3074
	while (!list_empty(&idev->addr_list)) {
		ifa = list_first_entry(&idev->addr_list,
				       struct inet6_ifaddr, if_list);
3075
		addrconf_del_dad_work(ifa);
3076

3077
		list_del(&ifa->if_list);
3078

3079
		write_unlock_bh(&idev->lock);
3080

3081 3082 3083 3084
		spin_lock_bh(&ifa->state_lock);
		state = ifa->state;
		ifa->state = INET6_IFADDR_STATE_DEAD;
		spin_unlock_bh(&ifa->state_lock);
3085

3086 3087
		if (state != INET6_IFADDR_STATE_DEAD) {
			__ipv6_ifa_notify(RTM_DELADDR, ifa);
3088
			inet6addr_notifier_call_chain(NETDEV_DOWN, ifa);
3089
		}
3090
		in6_ifa_put(ifa);
3091

3092 3093
		write_lock_bh(&idev->lock);
	}
3094

L
Linus Torvalds 已提交
3095 3096
	write_unlock_bh(&idev->lock);

3097 3098 3099
	/* Step 5: Discard anycast and multicast list */
	if (how) {
		ipv6_ac_destroy_dev(idev);
L
Linus Torvalds 已提交
3100
		ipv6_mc_destroy_dev(idev);
3101
	} else {
L
Linus Torvalds 已提交
3102
		ipv6_mc_down(idev);
3103
	}
L
Linus Torvalds 已提交
3104 3105

	idev->tstamp = jiffies;
3106

S
Stephen Hemminger 已提交
3107
	/* Last: Shot the device (if unregistered) */
3108
	if (how) {
3109
		addrconf_sysctl_unregister(idev);
L
Linus Torvalds 已提交
3110 3111 3112 3113 3114 3115 3116 3117 3118
		neigh_parms_release(&nd_tbl, idev->nd_parms);
		neigh_ifdown(&nd_tbl, dev);
		in6_dev_put(idev);
	}
	return 0;
}

static void addrconf_rs_timer(unsigned long data)
{
3119
	struct inet6_dev *idev = (struct inet6_dev *)data;
3120
	struct net_device *dev = idev->dev;
3121
	struct in6_addr lladdr;
L
Linus Torvalds 已提交
3122

3123
	write_lock(&idev->lock);
S
stephen hemminger 已提交
3124
	if (idev->dead || !(idev->if_flags & IF_READY))
L
Linus Torvalds 已提交
3125 3126
		goto out;

3127
	if (!ipv6_accept_ra(idev))
S
stephen hemminger 已提交
3128 3129 3130 3131
		goto out;

	/* Announcement received after solicitation was sent */
	if (idev->if_flags & IF_RA_RCVD)
L
Linus Torvalds 已提交
3132 3133
		goto out;

3134
	if (idev->rs_probes++ < idev->cnf.rtr_solicits) {
3135 3136 3137
		write_unlock(&idev->lock);
		if (!ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
			ndisc_send_rs(dev, &lladdr,
3138 3139
				      &in6addr_linklocal_allrouters);
		else
3140
			goto put;
L
Linus Torvalds 已提交
3141

3142
		write_lock(&idev->lock);
3143 3144 3145 3146 3147
		/* The wait after the last probe can be shorter */
		addrconf_mod_rs_timer(idev, (idev->rs_probes ==
					     idev->cnf.rtr_solicits) ?
				      idev->cnf.rtr_solicit_delay :
				      idev->cnf.rtr_solicit_interval);
L
Linus Torvalds 已提交
3148 3149 3150 3151 3152
	} else {
		/*
		 * Note: we do not support deprecated "all on-link"
		 * assumption any longer.
		 */
3153
		pr_debug("%s: no IPv6 routers present\n", idev->dev->name);
L
Linus Torvalds 已提交
3154 3155 3156
	}

out:
3157
	write_unlock(&idev->lock);
3158
put:
3159
	in6_dev_put(idev);
L
Linus Torvalds 已提交
3160 3161 3162 3163 3164
}

/*
 *	Duplicate Address Detection
 */
3165 3166 3167 3168 3169
static void addrconf_dad_kick(struct inet6_ifaddr *ifp)
{
	unsigned long rand_num;
	struct inet6_dev *idev = ifp->idev;

3170 3171 3172
	if (ifp->flags & IFA_F_OPTIMISTIC)
		rand_num = 0;
	else
3173
		rand_num = prandom_u32() % (idev->cnf.rtr_solicit_delay ? : 1);
3174

3175
	ifp->dad_probes = idev->cnf.dad_transmits;
3176
	addrconf_mod_dad_work(ifp, rand_num);
3177 3178
}

3179
static void addrconf_dad_begin(struct inet6_ifaddr *ifp)
L
Linus Torvalds 已提交
3180 3181 3182 3183 3184 3185
{
	struct inet6_dev *idev = ifp->idev;
	struct net_device *dev = idev->dev;

	addrconf_join_solict(dev, &ifp->addr);

3186
	prandom_seed((__force u32) ifp->addr.s6_addr32[3]);
L
Linus Torvalds 已提交
3187 3188

	read_lock_bh(&idev->lock);
3189
	spin_lock(&ifp->lock);
3190
	if (ifp->state == INET6_IFADDR_STATE_DEAD)
L
Linus Torvalds 已提交
3191 3192 3193
		goto out;

	if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) ||
3194
	    idev->cnf.accept_dad < 1 ||
3195 3196
	    !(ifp->flags&IFA_F_TENTATIVE) ||
	    ifp->flags & IFA_F_NODAD) {
B
Brian Haley 已提交
3197
		ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
3198
		spin_unlock(&ifp->lock);
L
Linus Torvalds 已提交
3199 3200 3201 3202 3203 3204
		read_unlock_bh(&idev->lock);

		addrconf_dad_completed(ifp);
		return;
	}

3205
	if (!(idev->if_flags & IF_READY)) {
3206
		spin_unlock(&ifp->lock);
3207
		read_unlock_bh(&idev->lock);
3208
		/*
3209
		 * If the device is not ready:
3210 3211 3212 3213
		 * - keep it tentative if it is a permanent address.
		 * - otherwise, kill it.
		 */
		in6_ifa_hold(ifp);
B
Brian Haley 已提交
3214
		addrconf_dad_stop(ifp, 0);
3215
		return;
3216
	}
3217 3218 3219 3220 3221

	/*
	 * Optimistic nodes can start receiving
	 * Frames right away
	 */
S
Stephen Hemminger 已提交
3222
	if (ifp->flags & IFA_F_OPTIMISTIC)
3223 3224
		ip6_ins_rt(ifp->rt);

3225
	addrconf_dad_kick(ifp);
L
Linus Torvalds 已提交
3226
out:
3227
	spin_unlock(&ifp->lock);
L
Linus Torvalds 已提交
3228 3229 3230
	read_unlock_bh(&idev->lock);
}

3231
static void addrconf_dad_start(struct inet6_ifaddr *ifp)
L
Linus Torvalds 已提交
3232
{
3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250
	bool begin_dad = false;

	spin_lock_bh(&ifp->state_lock);
	if (ifp->state != INET6_IFADDR_STATE_DEAD) {
		ifp->state = INET6_IFADDR_STATE_PREDAD;
		begin_dad = true;
	}
	spin_unlock_bh(&ifp->state_lock);

	if (begin_dad)
		addrconf_mod_dad_work(ifp, 0);
}

static void addrconf_dad_work(struct work_struct *w)
{
	struct inet6_ifaddr *ifp = container_of(to_delayed_work(w),
						struct inet6_ifaddr,
						dad_work);
L
Linus Torvalds 已提交
3251 3252 3253
	struct inet6_dev *idev = ifp->idev;
	struct in6_addr mcaddr;

3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279
	enum {
		DAD_PROCESS,
		DAD_BEGIN,
		DAD_ABORT,
	} action = DAD_PROCESS;

	rtnl_lock();

	spin_lock_bh(&ifp->state_lock);
	if (ifp->state == INET6_IFADDR_STATE_PREDAD) {
		action = DAD_BEGIN;
		ifp->state = INET6_IFADDR_STATE_DAD;
	} else if (ifp->state == INET6_IFADDR_STATE_ERRDAD) {
		action = DAD_ABORT;
		ifp->state = INET6_IFADDR_STATE_POSTDAD;
	}
	spin_unlock_bh(&ifp->state_lock);

	if (action == DAD_BEGIN) {
		addrconf_dad_begin(ifp);
		goto out;
	} else if (action == DAD_ABORT) {
		addrconf_dad_stop(ifp, 1);
		goto out;
	}

3280
	if (!ifp->dad_probes && addrconf_dad_end(ifp))
H
Herbert Xu 已提交
3281 3282
		goto out;

3283
	write_lock_bh(&idev->lock);
3284
	if (idev->dead || !(idev->if_flags & IF_READY)) {
3285
		write_unlock_bh(&idev->lock);
L
Linus Torvalds 已提交
3286 3287
		goto out;
	}
3288 3289

	spin_lock(&ifp->lock);
3290 3291
	if (ifp->state == INET6_IFADDR_STATE_DEAD) {
		spin_unlock(&ifp->lock);
3292
		write_unlock_bh(&idev->lock);
3293 3294 3295
		goto out;
	}

3296
	if (ifp->dad_probes == 0) {
L
Linus Torvalds 已提交
3297 3298 3299 3300
		/*
		 * DAD was successful
		 */

B
Brian Haley 已提交
3301
		ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
3302
		spin_unlock(&ifp->lock);
3303
		write_unlock_bh(&idev->lock);
L
Linus Torvalds 已提交
3304 3305 3306 3307 3308 3309

		addrconf_dad_completed(ifp);

		goto out;
	}

3310
	ifp->dad_probes--;
3311 3312
	addrconf_mod_dad_work(ifp,
			      NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME));
3313
	spin_unlock(&ifp->lock);
3314
	write_unlock_bh(&idev->lock);
L
Linus Torvalds 已提交
3315 3316 3317

	/* send a neighbour solicitation for our addr */
	addrconf_addr_solict_mult(&ifp->addr, &mcaddr);
3318
	ndisc_send_ns(ifp->idev->dev, NULL, &ifp->addr, &mcaddr, &in6addr_any);
L
Linus Torvalds 已提交
3319 3320
out:
	in6_ifa_put(ifp);
3321
	rtnl_unlock();
L
Linus Torvalds 已提交
3322 3323
}

3324 3325 3326 3327 3328 3329
/* ifp->idev must be at least read locked */
static bool ipv6_lonely_lladdr(struct inet6_ifaddr *ifp)
{
	struct inet6_ifaddr *ifpiter;
	struct inet6_dev *idev = ifp->idev;

3330 3331 3332
	list_for_each_entry_reverse(ifpiter, &idev->addr_list, if_list) {
		if (ifpiter->scope > IFA_LINK)
			break;
3333 3334 3335 3336 3337 3338 3339 3340 3341
		if (ifp != ifpiter && ifpiter->scope == IFA_LINK &&
		    (ifpiter->flags & (IFA_F_PERMANENT|IFA_F_TENTATIVE|
				       IFA_F_OPTIMISTIC|IFA_F_DADFAILED)) ==
		    IFA_F_PERMANENT)
			return false;
	}
	return true;
}

L
Linus Torvalds 已提交
3342 3343
static void addrconf_dad_completed(struct inet6_ifaddr *ifp)
{
S
Stephen Hemminger 已提交
3344
	struct net_device *dev = ifp->idev->dev;
3345
	struct in6_addr lladdr;
3346
	bool send_rs, send_mld;
3347

3348
	addrconf_del_dad_work(ifp);
L
Linus Torvalds 已提交
3349 3350 3351 3352 3353 3354 3355

	/*
	 *	Configure the address for reception. Now it is valid.
	 */

	ipv6_ifa_notify(RTM_NEWADDR, ifp);

3356 3357
	/* If added prefix is link local and we are prepared to process
	   router advertisements, start sending router solicitations.
L
Linus Torvalds 已提交
3358 3359
	 */

3360
	read_lock_bh(&ifp->idev->lock);
3361
	send_mld = ifp->scope == IFA_LINK && ipv6_lonely_lladdr(ifp);
3362 3363
	send_rs = send_mld &&
		  ipv6_accept_ra(ifp->idev) &&
3364
		  ifp->idev->cnf.rtr_solicits > 0 &&
3365
		  (dev->flags&IFF_LOOPBACK) == 0;
3366 3367
	read_unlock_bh(&ifp->idev->lock);

3368 3369 3370 3371 3372 3373
	/* While dad is in progress mld report's source address is in6_addrany.
	 * Resend with proper ll now.
	 */
	if (send_mld)
		ipv6_mc_dad_complete(ifp->idev);

3374
	if (send_rs) {
L
Linus Torvalds 已提交
3375 3376 3377 3378 3379
		/*
		 *	If a host as already performed a random delay
		 *	[...] as part of DAD [...] there is no need
		 *	to delay again before sending the first RS
		 */
3380
		if (ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
3381
			return;
3382
		ndisc_send_rs(dev, &lladdr, &in6addr_linklocal_allrouters);
L
Linus Torvalds 已提交
3383

3384 3385 3386
		write_lock_bh(&ifp->idev->lock);
		spin_lock(&ifp->lock);
		ifp->idev->rs_probes = 1;
L
Linus Torvalds 已提交
3387
		ifp->idev->if_flags |= IF_RS_SENT;
3388 3389 3390 3391
		addrconf_mod_rs_timer(ifp->idev,
				      ifp->idev->cnf.rtr_solicit_interval);
		spin_unlock(&ifp->lock);
		write_unlock_bh(&ifp->idev->lock);
L
Linus Torvalds 已提交
3392 3393 3394
	}
}

S
Stephen Hemminger 已提交
3395 3396
static void addrconf_dad_run(struct inet6_dev *idev)
{
3397 3398 3399
	struct inet6_ifaddr *ifp;

	read_lock_bh(&idev->lock);
3400
	list_for_each_entry(ifp, &idev->addr_list, if_list) {
3401
		spin_lock(&ifp->lock);
H
Herbert Xu 已提交
3402 3403 3404
		if (ifp->flags & IFA_F_TENTATIVE &&
		    ifp->state == INET6_IFADDR_STATE_DAD)
			addrconf_dad_kick(ifp);
3405
		spin_unlock(&ifp->lock);
3406 3407 3408 3409
	}
	read_unlock_bh(&idev->lock);
}

L
Linus Torvalds 已提交
3410 3411
#ifdef CONFIG_PROC_FS
struct if6_iter_state {
3412
	struct seq_net_private p;
L
Linus Torvalds 已提交
3413
	int bucket;
3414
	int offset;
L
Linus Torvalds 已提交
3415 3416
};

3417
static struct inet6_ifaddr *if6_get_first(struct seq_file *seq, loff_t pos)
L
Linus Torvalds 已提交
3418 3419 3420
{
	struct inet6_ifaddr *ifa = NULL;
	struct if6_iter_state *state = seq->private;
3421
	struct net *net = seq_file_net(seq);
3422
	int p = 0;
L
Linus Torvalds 已提交
3423

3424 3425 3426 3427 3428 3429 3430
	/* initial bucket if pos is 0 */
	if (pos == 0) {
		state->bucket = 0;
		state->offset = 0;
	}

	for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {
3431
		hlist_for_each_entry_rcu_bh(ifa, &inet6_addr_lst[state->bucket],
3432
					 addr_lst) {
3433 3434
			if (!net_eq(dev_net(ifa->idev->dev), net))
				continue;
3435 3436 3437 3438 3439 3440
			/* sync with offset */
			if (p < state->offset) {
				p++;
				continue;
			}
			state->offset++;
3441
			return ifa;
3442 3443 3444 3445 3446
		}

		/* prepare for next bucket */
		state->offset = 0;
		p = 0;
L
Linus Torvalds 已提交
3447
	}
3448
	return NULL;
L
Linus Torvalds 已提交
3449 3450
}

3451 3452
static struct inet6_ifaddr *if6_get_next(struct seq_file *seq,
					 struct inet6_ifaddr *ifa)
L
Linus Torvalds 已提交
3453 3454
{
	struct if6_iter_state *state = seq->private;
3455
	struct net *net = seq_file_net(seq);
L
Linus Torvalds 已提交
3456

3457
	hlist_for_each_entry_continue_rcu_bh(ifa, addr_lst) {
3458 3459
		if (!net_eq(dev_net(ifa->idev->dev), net))
			continue;
3460
		state->offset++;
3461
		return ifa;
3462
	}
3463

3464
	while (++state->bucket < IN6_ADDR_HSIZE) {
3465
		state->offset = 0;
3466
		hlist_for_each_entry_rcu_bh(ifa,
3467
				     &inet6_addr_lst[state->bucket], addr_lst) {
3468 3469
			if (!net_eq(dev_net(ifa->idev->dev), net))
				continue;
3470
			state->offset++;
3471
			return ifa;
3472
		}
L
Linus Torvalds 已提交
3473
	}
3474

3475
	return NULL;
L
Linus Torvalds 已提交
3476 3477 3478
}

static void *if6_seq_start(struct seq_file *seq, loff_t *pos)
E
Eric Dumazet 已提交
3479
	__acquires(rcu_bh)
L
Linus Torvalds 已提交
3480
{
3481
	rcu_read_lock_bh();
3482
	return if6_get_first(seq, *pos);
L
Linus Torvalds 已提交
3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494
}

static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	struct inet6_ifaddr *ifa;

	ifa = if6_get_next(seq, v);
	++*pos;
	return ifa;
}

static void if6_seq_stop(struct seq_file *seq, void *v)
E
Eric Dumazet 已提交
3495
	__releases(rcu_bh)
L
Linus Torvalds 已提交
3496
{
3497
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
3498 3499 3500 3501 3502
}

static int if6_seq_show(struct seq_file *seq, void *v)
{
	struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v;
3503
	seq_printf(seq, "%pi6 %02x %02x %02x %02x %8s\n",
3504
		   &ifp->addr,
L
Linus Torvalds 已提交
3505 3506 3507
		   ifp->idev->dev->ifindex,
		   ifp->prefix_len,
		   ifp->scope,
3508
		   (u8) ifp->flags,
L
Linus Torvalds 已提交
3509 3510 3511 3512
		   ifp->idev->dev->name);
	return 0;
}

3513
static const struct seq_operations if6_seq_ops = {
L
Linus Torvalds 已提交
3514 3515 3516 3517 3518 3519 3520 3521
	.start	= if6_seq_start,
	.next	= if6_seq_next,
	.show	= if6_seq_show,
	.stop	= if6_seq_stop,
};

static int if6_seq_open(struct inode *inode, struct file *file)
{
3522 3523
	return seq_open_net(inode, file, &if6_seq_ops,
			    sizeof(struct if6_iter_state));
L
Linus Torvalds 已提交
3524 3525
}

3526
static const struct file_operations if6_fops = {
L
Linus Torvalds 已提交
3527 3528 3529 3530
	.owner		= THIS_MODULE,
	.open		= if6_seq_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
3531
	.release	= seq_release_net,
L
Linus Torvalds 已提交
3532 3533
};

3534
static int __net_init if6_proc_net_init(struct net *net)
L
Linus Torvalds 已提交
3535
{
3536
	if (!proc_create("if_inet6", S_IRUGO, net->proc_net, &if6_fops))
L
Linus Torvalds 已提交
3537 3538 3539 3540
		return -ENOMEM;
	return 0;
}

3541
static void __net_exit if6_proc_net_exit(struct net *net)
3542
{
3543
	remove_proc_entry("if_inet6", net->proc_net);
3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555
}

static struct pernet_operations if6_proc_net_ops = {
       .init = if6_proc_net_init,
       .exit = if6_proc_net_exit,
};

int __init if6_proc_init(void)
{
	return register_pernet_subsys(&if6_proc_net_ops);
}

L
Linus Torvalds 已提交
3556 3557
void if6_proc_exit(void)
{
3558
	unregister_pernet_subsys(&if6_proc_net_ops);
L
Linus Torvalds 已提交
3559 3560 3561
}
#endif	/* CONFIG_PROC_FS */

A
Amerigo Wang 已提交
3562
#if IS_ENABLED(CONFIG_IPV6_MIP6)
3563
/* Check if address is a home address configured on any interface. */
3564
int ipv6_chk_home_addr(struct net *net, const struct in6_addr *addr)
3565 3566
{
	int ret = 0;
3567
	struct inet6_ifaddr *ifp = NULL;
E
Eric Dumazet 已提交
3568
	unsigned int hash = inet6_addr_hash(addr);
3569

3570
	rcu_read_lock_bh();
3571
	hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) {
3572
		if (!net_eq(dev_net(ifp->idev->dev), net))
3573
			continue;
3574
		if (ipv6_addr_equal(&ifp->addr, addr) &&
3575 3576 3577 3578 3579
		    (ifp->flags & IFA_F_HOMEADDRESS)) {
			ret = 1;
			break;
		}
	}
3580
	rcu_read_unlock_bh();
3581 3582 3583 3584
	return ret;
}
#endif

L
Linus Torvalds 已提交
3585 3586 3587 3588
/*
 *	Periodic address status verification
 */

3589
static void addrconf_verify_rtnl(void)
L
Linus Torvalds 已提交
3590
{
3591
	unsigned long now, next, next_sec, next_sched;
L
Linus Torvalds 已提交
3592 3593 3594
	struct inet6_ifaddr *ifp;
	int i;

3595 3596
	ASSERT_RTNL();

3597
	rcu_read_lock_bh();
L
Linus Torvalds 已提交
3598
	now = jiffies;
3599
	next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
L
Linus Torvalds 已提交
3600

3601
	cancel_delayed_work(&addr_chk_work);
L
Linus Torvalds 已提交
3602

S
Stephen Hemminger 已提交
3603
	for (i = 0; i < IN6_ADDR_HSIZE; i++) {
L
Linus Torvalds 已提交
3604
restart:
3605
		hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[i], addr_lst) {
L
Linus Torvalds 已提交
3606 3607
			unsigned long age;

3608 3609 3610 3611 3612 3613
			/* When setting preferred_lft to a value not zero or
			 * infinity, while valid_lft is infinity
			 * IFA_F_PERMANENT has a non-infinity life time.
			 */
			if ((ifp->flags & IFA_F_PERMANENT) &&
			    (ifp->prefered_lft == INFINITY_LIFE_TIME))
L
Linus Torvalds 已提交
3614 3615 3616
				continue;

			spin_lock(&ifp->lock);
3617 3618
			/* We try to batch several events at once. */
			age = (now - ifp->tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
L
Linus Torvalds 已提交
3619

3620 3621
			if (ifp->valid_lft != INFINITY_LIFE_TIME &&
			    age >= ifp->valid_lft) {
L
Linus Torvalds 已提交
3622 3623 3624 3625
				spin_unlock(&ifp->lock);
				in6_ifa_hold(ifp);
				ipv6_del_addr(ifp);
				goto restart;
3626 3627 3628
			} else if (ifp->prefered_lft == INFINITY_LIFE_TIME) {
				spin_unlock(&ifp->lock);
				continue;
L
Linus Torvalds 已提交
3629
			} else if (age >= ifp->prefered_lft) {
3630
				/* jiffies - ifp->tstamp > age >= ifp->prefered_lft */
L
Linus Torvalds 已提交
3631 3632 3633 3634 3635 3636 3637
				int deprecate = 0;

				if (!(ifp->flags&IFA_F_DEPRECATED)) {
					deprecate = 1;
					ifp->flags |= IFA_F_DEPRECATED;
				}

3638 3639
				if ((ifp->valid_lft != INFINITY_LIFE_TIME) &&
				    (time_before(ifp->tstamp + ifp->valid_lft * HZ, next)))
L
Linus Torvalds 已提交
3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652
					next = ifp->tstamp + ifp->valid_lft * HZ;

				spin_unlock(&ifp->lock);

				if (deprecate) {
					in6_ifa_hold(ifp);

					ipv6_ifa_notify(0, ifp);
					in6_ifa_put(ifp);
					goto restart;
				}
			} else if ((ifp->flags&IFA_F_TEMPORARY) &&
				   !(ifp->flags&IFA_F_TENTATIVE)) {
3653 3654
				unsigned long regen_advance = ifp->idev->cnf.regen_max_retry *
					ifp->idev->cnf.dad_transmits *
J
Jiri Pirko 已提交
3655
					NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME) / HZ;
3656

L
Linus Torvalds 已提交
3657 3658 3659 3660 3661 3662 3663 3664 3665
				if (age >= ifp->prefered_lft - regen_advance) {
					struct inet6_ifaddr *ifpub = ifp->ifpub;
					if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
						next = ifp->tstamp + ifp->prefered_lft * HZ;
					if (!ifp->regen_count && ifpub) {
						ifp->regen_count++;
						in6_ifa_hold(ifp);
						in6_ifa_hold(ifpub);
						spin_unlock(&ifp->lock);
3666

3667 3668 3669
						spin_lock(&ifpub->lock);
						ifpub->regen_count = 0;
						spin_unlock(&ifpub->lock);
L
Linus Torvalds 已提交
3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686
						ipv6_create_tempaddr(ifpub, ifp);
						in6_ifa_put(ifpub);
						in6_ifa_put(ifp);
						goto restart;
					}
				} else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next))
					next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ;
				spin_unlock(&ifp->lock);
			} else {
				/* ifp->prefered_lft <= ifp->valid_lft */
				if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
					next = ifp->tstamp + ifp->prefered_lft * HZ;
				spin_unlock(&ifp->lock);
			}
		}
	}

3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697
	next_sec = round_jiffies_up(next);
	next_sched = next;

	/* If rounded timeout is accurate enough, accept it. */
	if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
		next_sched = next_sec;

	/* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
	if (time_before(next_sched, jiffies + ADDRCONF_TIMER_FUZZ_MAX))
		next_sched = jiffies + ADDRCONF_TIMER_FUZZ_MAX;

3698 3699
	ADBG(KERN_DEBUG "now = %lu, schedule = %lu, rounded schedule = %lu => %lu\n",
	      now, next, next_sec, next_sched);
3700
	mod_delayed_work(addrconf_wq, &addr_chk_work, next_sched - now);
3701
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
3702 3703
}

3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715
static void addrconf_verify_work(struct work_struct *w)
{
	rtnl_lock();
	addrconf_verify_rtnl();
	rtnl_unlock();
}

static void addrconf_verify(void)
{
	mod_delayed_work(addrconf_wq, &addr_chk_work, 0);
}

3716 3717
static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local,
				     struct in6_addr **peer_pfx)
3718 3719 3720
{
	struct in6_addr *pfx = NULL;

3721 3722
	*peer_pfx = NULL;

3723 3724 3725 3726 3727
	if (addr)
		pfx = nla_data(addr);

	if (local) {
		if (pfx && nla_memcmp(local, pfx, sizeof(*pfx)))
3728 3729
			*peer_pfx = pfx;
		pfx = nla_data(local);
3730 3731 3732 3733 3734
	}

	return pfx;
}

3735
static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = {
3736 3737 3738
	[IFA_ADDRESS]		= { .len = sizeof(struct in6_addr) },
	[IFA_LOCAL]		= { .len = sizeof(struct in6_addr) },
	[IFA_CACHEINFO]		= { .len = sizeof(struct ifa_cacheinfo) },
3739
	[IFA_FLAGS]		= { .len = sizeof(u32) },
3740 3741
};

L
Linus Torvalds 已提交
3742
static int
3743
inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
L
Linus Torvalds 已提交
3744
{
3745
	struct net *net = sock_net(skb->sk);
3746 3747
	struct ifaddrmsg *ifm;
	struct nlattr *tb[IFA_MAX+1];
3748
	struct in6_addr *pfx, *peer_pfx;
3749
	u32 ifa_flags;
3750
	int err;
L
Linus Torvalds 已提交
3751

3752 3753 3754 3755 3756
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
	if (err < 0)
		return err;

	ifm = nlmsg_data(nlh);
3757
	pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
L
Linus Torvalds 已提交
3758 3759 3760
	if (pfx == NULL)
		return -EINVAL;

3761 3762 3763 3764 3765 3766 3767
	ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;

	/* We ignore other flags so far. */
	ifa_flags &= IFA_F_MANAGETEMPADDR;

	return inet6_addr_del(net, ifm->ifa_index, ifa_flags, pfx,
			      ifm->ifa_prefixlen);
L
Linus Torvalds 已提交
3768 3769
}

3770
static int inet6_addr_modify(struct inet6_ifaddr *ifp, u32 ifa_flags,
3771
			     u32 prefered_lft, u32 valid_lft)
3772
{
3773 3774
	u32 flags;
	clock_t expires;
3775
	unsigned long timeout;
3776
	bool was_managetempaddr;
3777
	bool had_prefixroute;
3778

3779 3780
	ASSERT_RTNL();

3781 3782 3783
	if (!valid_lft || (prefered_lft > valid_lft))
		return -EINVAL;

3784 3785 3786 3787
	if (ifa_flags & IFA_F_MANAGETEMPADDR &&
	    (ifp->flags & IFA_F_TEMPORARY || ifp->prefix_len != 64))
		return -EINVAL;

3788 3789 3790 3791
	timeout = addrconf_timeout_fixup(valid_lft, HZ);
	if (addrconf_finite_timeout(timeout)) {
		expires = jiffies_to_clock_t(timeout * HZ);
		valid_lft = timeout;
3792
		flags = RTF_EXPIRES;
3793 3794 3795 3796
	} else {
		expires = 0;
		flags = 0;
		ifa_flags |= IFA_F_PERMANENT;
3797
	}
3798

3799 3800 3801 3802 3803 3804
	timeout = addrconf_timeout_fixup(prefered_lft, HZ);
	if (addrconf_finite_timeout(timeout)) {
		if (timeout == 0)
			ifa_flags |= IFA_F_DEPRECATED;
		prefered_lft = timeout;
	}
3805 3806

	spin_lock_bh(&ifp->lock);
3807
	was_managetempaddr = ifp->flags & IFA_F_MANAGETEMPADDR;
3808 3809
	had_prefixroute = ifp->flags & IFA_F_PERMANENT &&
			  !(ifp->flags & IFA_F_NOPREFIXROUTE);
3810
	ifp->flags &= ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD |
3811 3812
			IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR |
			IFA_F_NOPREFIXROUTE);
3813
	ifp->flags |= ifa_flags;
3814 3815 3816 3817 3818 3819 3820 3821
	ifp->tstamp = jiffies;
	ifp->valid_lft = valid_lft;
	ifp->prefered_lft = prefered_lft;

	spin_unlock_bh(&ifp->lock);
	if (!(ifp->flags&IFA_F_TENTATIVE))
		ipv6_ifa_notify(0, ifp);

3822 3823 3824
	if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) {
		addrconf_prefix_route(&ifp->addr, ifp->prefix_len, ifp->idev->dev,
				      expires, flags);
3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836
	} else if (had_prefixroute) {
		enum cleanup_prefix_rt_t action;
		unsigned long rt_expires;

		write_lock_bh(&ifp->idev->lock);
		action = check_cleanup_prefix_route(ifp, &rt_expires);
		write_unlock_bh(&ifp->idev->lock);

		if (action != CLEANUP_PREFIX_RT_NOP) {
			cleanup_prefix_route(ifp, rt_expires,
				action == CLEANUP_PREFIX_RT_DEL);
		}
3837
	}
3838 3839 3840 3841 3842 3843 3844 3845

	if (was_managetempaddr || ifp->flags & IFA_F_MANAGETEMPADDR) {
		if (was_managetempaddr && !(ifp->flags & IFA_F_MANAGETEMPADDR))
			valid_lft = prefered_lft = 0;
		manage_tempaddrs(ifp->idev, ifp, valid_lft, prefered_lft,
				 !was_managetempaddr, jiffies);
	}

3846
	addrconf_verify_rtnl();
3847 3848 3849 3850

	return 0;
}

L
Linus Torvalds 已提交
3851
static int
3852
inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
L
Linus Torvalds 已提交
3853
{
3854
	struct net *net = sock_net(skb->sk);
3855 3856
	struct ifaddrmsg *ifm;
	struct nlattr *tb[IFA_MAX+1];
3857
	struct in6_addr *pfx, *peer_pfx;
3858 3859
	struct inet6_ifaddr *ifa;
	struct net_device *dev;
3860
	u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME;
3861
	u32 ifa_flags;
3862
	int err;
L
Linus Torvalds 已提交
3863

3864 3865 3866 3867 3868
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
	if (err < 0)
		return err;

	ifm = nlmsg_data(nlh);
3869
	pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
L
Linus Torvalds 已提交
3870 3871 3872
	if (pfx == NULL)
		return -EINVAL;

3873
	if (tb[IFA_CACHEINFO]) {
3874
		struct ifa_cacheinfo *ci;
3875 3876

		ci = nla_data(tb[IFA_CACHEINFO]);
3877
		valid_lft = ci->ifa_valid;
3878 3879 3880 3881
		preferred_lft = ci->ifa_prefered;
	} else {
		preferred_lft = INFINITY_LIFE_TIME;
		valid_lft = INFINITY_LIFE_TIME;
3882 3883
	}

3884
	dev =  __dev_get_by_index(net, ifm->ifa_index);
3885 3886 3887
	if (dev == NULL)
		return -ENODEV;

3888 3889
	ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;

3890
	/* We ignore other flags so far. */
3891 3892
	ifa_flags &= IFA_F_NODAD | IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR |
		     IFA_F_NOPREFIXROUTE;
3893

3894
	ifa = ipv6_get_ifaddr(net, pfx, dev, 1);
3895 3896 3897
	if (ifa == NULL) {
		/*
		 * It would be best to check for !NLM_F_CREATE here but
3898
		 * userspace already relies on not having to provide this.
3899
		 */
3900
		return inet6_addr_add(net, ifm->ifa_index, pfx, peer_pfx,
3901 3902
				      ifm->ifa_prefixlen, ifa_flags,
				      preferred_lft, valid_lft);
3903 3904
	}

3905 3906 3907 3908
	if (nlh->nlmsg_flags & NLM_F_EXCL ||
	    !(nlh->nlmsg_flags & NLM_F_REPLACE))
		err = -EEXIST;
	else
3909
		err = inet6_addr_modify(ifa, ifa_flags, preferred_lft, valid_lft);
3910 3911 3912 3913

	in6_ifa_put(ifa);

	return err;
L
Linus Torvalds 已提交
3914 3915
}

3916
static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u32 flags,
3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928
			  u8 scope, int ifindex)
{
	struct ifaddrmsg *ifm;

	ifm = nlmsg_data(nlh);
	ifm->ifa_family = AF_INET6;
	ifm->ifa_prefixlen = prefixlen;
	ifm->ifa_flags = flags;
	ifm->ifa_scope = scope;
	ifm->ifa_index = ifindex;
}

3929 3930 3931 3932 3933
static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
			 unsigned long tstamp, u32 preferred, u32 valid)
{
	struct ifa_cacheinfo ci;

3934 3935
	ci.cstamp = cstamp_delta(cstamp);
	ci.tstamp = cstamp_delta(tstamp);
3936 3937 3938 3939 3940 3941
	ci.ifa_prefered = preferred;
	ci.ifa_valid = valid;

	return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
}

3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953
static inline int rt_scope(int ifa_scope)
{
	if (ifa_scope & IFA_HOST)
		return RT_SCOPE_HOST;
	else if (ifa_scope & IFA_LINK)
		return RT_SCOPE_LINK;
	else if (ifa_scope & IFA_SITE)
		return RT_SCOPE_SITE;
	else
		return RT_SCOPE_UNIVERSE;
}

3954 3955
static inline int inet6_ifaddr_msgsize(void)
{
3956
	return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
3957
	       + nla_total_size(16) /* IFA_LOCAL */
3958
	       + nla_total_size(16) /* IFA_ADDRESS */
3959 3960
	       + nla_total_size(sizeof(struct ifa_cacheinfo))
	       + nla_total_size(4)  /* IFA_FLAGS */;
3961
}
3962

L
Linus Torvalds 已提交
3963
static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
3964
			     u32 portid, u32 seq, int event, unsigned int flags)
L
Linus Torvalds 已提交
3965 3966
{
	struct nlmsghdr  *nlh;
3967
	u32 preferred, valid;
L
Linus Torvalds 已提交
3968

3969
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
3970
	if (nlh == NULL)
3971
		return -EMSGSIZE;
3972

3973 3974 3975
	put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope),
		      ifa->idev->dev->ifindex);

3976 3977
	if (!((ifa->flags&IFA_F_PERMANENT) &&
	      (ifa->prefered_lft == INFINITY_LIFE_TIME))) {
3978 3979 3980
		preferred = ifa->prefered_lft;
		valid = ifa->valid_lft;
		if (preferred != INFINITY_LIFE_TIME) {
L
Linus Torvalds 已提交
3981
			long tval = (jiffies - ifa->tstamp)/HZ;
3982 3983 3984 3985
			if (preferred > tval)
				preferred -= tval;
			else
				preferred = 0;
3986 3987 3988 3989 3990 3991
			if (valid != INFINITY_LIFE_TIME) {
				if (valid > tval)
					valid -= tval;
				else
					valid = 0;
			}
L
Linus Torvalds 已提交
3992 3993
		}
	} else {
3994 3995 3996 3997
		preferred = INFINITY_LIFE_TIME;
		valid = INFINITY_LIFE_TIME;
	}

C
Cong Wang 已提交
3998
	if (!ipv6_addr_any(&ifa->peer_addr)) {
3999 4000 4001 4002 4003 4004 4005 4006 4007
		if (nla_put(skb, IFA_LOCAL, 16, &ifa->addr) < 0 ||
		    nla_put(skb, IFA_ADDRESS, 16, &ifa->peer_addr) < 0)
			goto error;
	} else
		if (nla_put(skb, IFA_ADDRESS, 16, &ifa->addr) < 0)
			goto error;

	if (put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0)
		goto error;
L
Linus Torvalds 已提交
4008

4009 4010 4011
	if (nla_put_u32(skb, IFA_FLAGS, ifa->flags) < 0)
		goto error;

4012
	return nlmsg_end(skb, nlh);
4013 4014 4015 4016

error:
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
4017 4018 4019
}

static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca,
4020
				u32 portid, u32 seq, int event, u16 flags)
L
Linus Torvalds 已提交
4021 4022
{
	struct nlmsghdr  *nlh;
4023 4024 4025 4026 4027
	u8 scope = RT_SCOPE_UNIVERSE;
	int ifindex = ifmca->idev->dev->ifindex;

	if (ipv6_addr_scope(&ifmca->mca_addr) & IFA_SITE)
		scope = RT_SCOPE_SITE;
L
Linus Torvalds 已提交
4028

4029
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4030
	if (nlh == NULL)
4031
		return -EMSGSIZE;
4032

4033 4034 4035
	put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
	if (nla_put(skb, IFA_MULTICAST, 16, &ifmca->mca_addr) < 0 ||
	    put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp,
4036 4037 4038 4039
			  INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
		nlmsg_cancel(skb, nlh);
		return -EMSGSIZE;
	}
4040

4041
	return nlmsg_end(skb, nlh);
L
Linus Torvalds 已提交
4042 4043 4044
}

static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
4045
				u32 portid, u32 seq, int event, unsigned int flags)
L
Linus Torvalds 已提交
4046 4047
{
	struct nlmsghdr  *nlh;
4048 4049 4050 4051 4052
	u8 scope = RT_SCOPE_UNIVERSE;
	int ifindex = ifaca->aca_idev->dev->ifindex;

	if (ipv6_addr_scope(&ifaca->aca_addr) & IFA_SITE)
		scope = RT_SCOPE_SITE;
L
Linus Torvalds 已提交
4053

4054
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4055
	if (nlh == NULL)
4056
		return -EMSGSIZE;
4057

4058 4059 4060
	put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
	if (nla_put(skb, IFA_ANYCAST, 16, &ifaca->aca_addr) < 0 ||
	    put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp,
4061 4062 4063 4064
			  INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
		nlmsg_cancel(skb, nlh);
		return -EMSGSIZE;
	}
L
Linus Torvalds 已提交
4065

4066
	return nlmsg_end(skb, nlh);
L
Linus Torvalds 已提交
4067 4068
}

S
Stephen Hemminger 已提交
4069
enum addr_type_t {
L
Linus Torvalds 已提交
4070 4071 4072 4073 4074
	UNICAST_ADDR,
	MULTICAST_ADDR,
	ANYCAST_ADDR,
};

E
Eric Dumazet 已提交
4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086
/* called with rcu_read_lock() */
static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
			  struct netlink_callback *cb, enum addr_type_t type,
			  int s_ip_idx, int *p_ip_idx)
{
	struct ifmcaddr6 *ifmca;
	struct ifacaddr6 *ifaca;
	int err = 1;
	int ip_idx = *p_ip_idx;

	read_lock_bh(&idev->lock);
	switch (type) {
4087 4088 4089
	case UNICAST_ADDR: {
		struct inet6_ifaddr *ifa;

E
Eric Dumazet 已提交
4090
		/* unicast address incl. temp addr */
4091 4092
		list_for_each_entry(ifa, &idev->addr_list, if_list) {
			if (++ip_idx < s_ip_idx)
E
Eric Dumazet 已提交
4093 4094
				continue;
			err = inet6_fill_ifaddr(skb, ifa,
4095
						NETLINK_CB(cb->skb).portid,
E
Eric Dumazet 已提交
4096 4097 4098 4099 4100
						cb->nlh->nlmsg_seq,
						RTM_NEWADDR,
						NLM_F_MULTI);
			if (err <= 0)
				break;
4101
			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
E
Eric Dumazet 已提交
4102 4103
		}
		break;
4104
	}
E
Eric Dumazet 已提交
4105 4106 4107 4108 4109 4110 4111
	case MULTICAST_ADDR:
		/* multicast address */
		for (ifmca = idev->mc_list; ifmca;
		     ifmca = ifmca->next, ip_idx++) {
			if (ip_idx < s_ip_idx)
				continue;
			err = inet6_fill_ifmcaddr(skb, ifmca,
4112
						  NETLINK_CB(cb->skb).portid,
E
Eric Dumazet 已提交
4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126
						  cb->nlh->nlmsg_seq,
						  RTM_GETMULTICAST,
						  NLM_F_MULTI);
			if (err <= 0)
				break;
		}
		break;
	case ANYCAST_ADDR:
		/* anycast address */
		for (ifaca = idev->ac_list; ifaca;
		     ifaca = ifaca->aca_next, ip_idx++) {
			if (ip_idx < s_ip_idx)
				continue;
			err = inet6_fill_ifacaddr(skb, ifaca,
4127
						  NETLINK_CB(cb->skb).portid,
E
Eric Dumazet 已提交
4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142
						  cb->nlh->nlmsg_seq,
						  RTM_GETANYCAST,
						  NLM_F_MULTI);
			if (err <= 0)
				break;
		}
		break;
	default:
		break;
	}
	read_unlock_bh(&idev->lock);
	*p_ip_idx = ip_idx;
	return err;
}

L
Linus Torvalds 已提交
4143 4144 4145
static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
			   enum addr_type_t type)
{
E
Eric Dumazet 已提交
4146 4147
	struct net *net = sock_net(skb->sk);
	int h, s_h;
L
Linus Torvalds 已提交
4148 4149 4150
	int idx, ip_idx;
	int s_idx, s_ip_idx;
	struct net_device *dev;
E
Eric Dumazet 已提交
4151 4152
	struct inet6_dev *idev;
	struct hlist_head *head;
4153

E
Eric Dumazet 已提交
4154 4155 4156
	s_h = cb->args[0];
	s_idx = idx = cb->args[1];
	s_ip_idx = ip_idx = cb->args[2];
4157

E
Eric Dumazet 已提交
4158
	rcu_read_lock();
4159
	cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ net->dev_base_seq;
E
Eric Dumazet 已提交
4160 4161 4162
	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
		head = &net->dev_index_head[h];
4163
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
E
Eric Dumazet 已提交
4164 4165
			if (idx < s_idx)
				goto cont;
4166
			if (h > s_h || idx > s_idx)
E
Eric Dumazet 已提交
4167 4168
				s_ip_idx = 0;
			ip_idx = 0;
S
Stephen Hemminger 已提交
4169 4170
			idev = __in6_dev_get(dev);
			if (!idev)
E
Eric Dumazet 已提交
4171 4172 4173 4174 4175
				goto cont;

			if (in6_dump_addrs(idev, skb, cb, type,
					   s_ip_idx, &ip_idx) <= 0)
				goto done;
4176
cont:
E
Eric Dumazet 已提交
4177 4178
			idx++;
		}
L
Linus Torvalds 已提交
4179
	}
E
Eric Dumazet 已提交
4180 4181 4182 4183 4184 4185
done:
	rcu_read_unlock();
	cb->args[0] = h;
	cb->args[1] = idx;
	cb->args[2] = ip_idx;

L
Linus Torvalds 已提交
4186 4187 4188 4189 4190 4191
	return skb->len;
}

static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
{
	enum addr_type_t type = UNICAST_ADDR;
4192

L
Linus Torvalds 已提交
4193 4194 4195 4196 4197 4198
	return inet6_dump_addr(skb, cb, type);
}

static int inet6_dump_ifmcaddr(struct sk_buff *skb, struct netlink_callback *cb)
{
	enum addr_type_t type = MULTICAST_ADDR;
4199

L
Linus Torvalds 已提交
4200 4201 4202 4203 4204 4205 4206
	return inet6_dump_addr(skb, cb, type);
}


static int inet6_dump_ifacaddr(struct sk_buff *skb, struct netlink_callback *cb)
{
	enum addr_type_t type = ANYCAST_ADDR;
4207

L
Linus Torvalds 已提交
4208 4209 4210
	return inet6_dump_addr(skb, cb, type);
}

4211
static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh)
4212
{
4213
	struct net *net = sock_net(in_skb->sk);
4214 4215
	struct ifaddrmsg *ifm;
	struct nlattr *tb[IFA_MAX+1];
4216
	struct in6_addr *addr = NULL, *peer;
4217 4218 4219 4220 4221
	struct net_device *dev = NULL;
	struct inet6_ifaddr *ifa;
	struct sk_buff *skb;
	int err;

4222 4223 4224 4225
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
	if (err < 0)
		goto errout;

4226
	addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer);
4227 4228 4229
	if (addr == NULL) {
		err = -EINVAL;
		goto errout;
4230 4231
	}

4232
	ifm = nlmsg_data(nlh);
4233
	if (ifm->ifa_index)
4234
		dev = __dev_get_by_index(net, ifm->ifa_index);
4235

S
Stephen Hemminger 已提交
4236 4237
	ifa = ipv6_get_ifaddr(net, addr, dev, 1);
	if (!ifa) {
4238 4239 4240
		err = -EADDRNOTAVAIL;
		goto errout;
	}
4241

S
Stephen Hemminger 已提交
4242 4243
	skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL);
	if (!skb) {
4244
		err = -ENOBUFS;
4245
		goto errout_ifa;
4246 4247
	}

4248
	err = inet6_fill_ifaddr(skb, ifa, NETLINK_CB(in_skb).portid,
4249
				nlh->nlmsg_seq, RTM_NEWADDR, 0);
4250 4251 4252 4253 4254 4255
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout_ifa;
	}
4256
	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
4257
errout_ifa:
4258
	in6_ifa_put(ifa);
4259
errout:
4260 4261 4262
	return err;
}

L
Linus Torvalds 已提交
4263 4264 4265
static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa)
{
	struct sk_buff *skb;
4266
	struct net *net = dev_net(ifa->idev->dev);
4267
	int err = -ENOBUFS;
L
Linus Torvalds 已提交
4268

4269
	skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC);
4270 4271 4272 4273
	if (skb == NULL)
		goto errout;

	err = inet6_fill_ifaddr(skb, ifa, 0, 0, event, 0);
4274 4275 4276 4277 4278 4279
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
4280 4281
	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC);
	return;
4282 4283
errout:
	if (err < 0)
4284
		rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err);
L
Linus Torvalds 已提交
4285 4286
}

D
Dave Jones 已提交
4287
static inline void ipv6_store_devconf(struct ipv6_devconf *cnf,
L
Linus Torvalds 已提交
4288 4289
				__s32 *array, int bytes)
{
4290 4291
	BUG_ON(bytes < (DEVCONF_MAX * 4));

L
Linus Torvalds 已提交
4292 4293 4294 4295 4296 4297 4298 4299 4300
	memset(array, 0, bytes);
	array[DEVCONF_FORWARDING] = cnf->forwarding;
	array[DEVCONF_HOPLIMIT] = cnf->hop_limit;
	array[DEVCONF_MTU6] = cnf->mtu6;
	array[DEVCONF_ACCEPT_RA] = cnf->accept_ra;
	array[DEVCONF_ACCEPT_REDIRECTS] = cnf->accept_redirects;
	array[DEVCONF_AUTOCONF] = cnf->autoconf;
	array[DEVCONF_DAD_TRANSMITS] = cnf->dad_transmits;
	array[DEVCONF_RTR_SOLICITS] = cnf->rtr_solicits;
4301 4302 4303 4304
	array[DEVCONF_RTR_SOLICIT_INTERVAL] =
		jiffies_to_msecs(cnf->rtr_solicit_interval);
	array[DEVCONF_RTR_SOLICIT_DELAY] =
		jiffies_to_msecs(cnf->rtr_solicit_delay);
L
Linus Torvalds 已提交
4305
	array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version;
4306 4307 4308 4309
	array[DEVCONF_MLDV1_UNSOLICITED_REPORT_INTERVAL] =
		jiffies_to_msecs(cnf->mldv1_unsolicited_report_interval);
	array[DEVCONF_MLDV2_UNSOLICITED_REPORT_INTERVAL] =
		jiffies_to_msecs(cnf->mldv2_unsolicited_report_interval);
L
Linus Torvalds 已提交
4310 4311 4312 4313 4314 4315
	array[DEVCONF_USE_TEMPADDR] = cnf->use_tempaddr;
	array[DEVCONF_TEMP_VALID_LFT] = cnf->temp_valid_lft;
	array[DEVCONF_TEMP_PREFERED_LFT] = cnf->temp_prefered_lft;
	array[DEVCONF_REGEN_MAX_RETRY] = cnf->regen_max_retry;
	array[DEVCONF_MAX_DESYNC_FACTOR] = cnf->max_desync_factor;
	array[DEVCONF_MAX_ADDRESSES] = cnf->max_addresses;
4316
	array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr;
4317
	array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo;
4318 4319
#ifdef CONFIG_IPV6_ROUTER_PREF
	array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref;
4320 4321
	array[DEVCONF_RTR_PROBE_INTERVAL] =
		jiffies_to_msecs(cnf->rtr_probe_interval);
N
Neil Horman 已提交
4322
#ifdef CONFIG_IPV6_ROUTE_INFO
4323 4324
	array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen;
#endif
4325
#endif
4326
	array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp;
4327
	array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route;
4328 4329 4330
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
	array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad;
#endif
4331 4332 4333
#ifdef CONFIG_IPV6_MROUTE
	array[DEVCONF_MC_FORWARDING] = cnf->mc_forwarding;
#endif
4334
	array[DEVCONF_DISABLE_IPV6] = cnf->disable_ipv6;
4335
	array[DEVCONF_ACCEPT_DAD] = cnf->accept_dad;
4336
	array[DEVCONF_FORCE_TLLAO] = cnf->force_tllao;
4337
	array[DEVCONF_NDISC_NOTIFY] = cnf->ndisc_notify;
4338
	array[DEVCONF_SUPPRESS_FRAG_NDISC] = cnf->suppress_frag_ndisc;
4339
	array[DEVCONF_ACCEPT_RA_FROM_LOCAL] = cnf->accept_ra_from_local;
L
Linus Torvalds 已提交
4340 4341
}

T
Thomas Graf 已提交
4342 4343 4344 4345 4346 4347
static inline size_t inet6_ifla6_size(void)
{
	return nla_total_size(4) /* IFLA_INET6_FLAGS */
	     + nla_total_size(sizeof(struct ifla_cacheinfo))
	     + nla_total_size(DEVCONF_MAX * 4) /* IFLA_INET6_CONF */
	     + nla_total_size(IPSTATS_MIB_MAX * 8) /* IFLA_INET6_STATS */
4348 4349
	     + nla_total_size(ICMP6_MIB_MAX * 8) /* IFLA_INET6_ICMP6STATS */
	     + nla_total_size(sizeof(struct in6_addr)); /* IFLA_INET6_TOKEN */
T
Thomas Graf 已提交
4350 4351
}

4352 4353 4354 4355 4356 4357 4358
static inline size_t inet6_if_nlmsg_size(void)
{
	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
	       + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
	       + nla_total_size(4) /* IFLA_MTU */
	       + nla_total_size(4) /* IFLA_LINK */
T
Thomas Graf 已提交
4359
	       + nla_total_size(inet6_ifla6_size()); /* IFLA_PROTINFO */
4360
}
4361

4362
static inline void __snmp6_fill_statsdev(u64 *stats, atomic_long_t *mib,
4363
				      int items, int bytes)
4364 4365 4366 4367 4368 4369 4370 4371
{
	int i;
	int pad = bytes - sizeof(u64) * items;
	BUG_ON(pad < 0);

	/* Use put_unaligned() because stats may not be aligned for u64. */
	put_unaligned(items, &stats[0]);
	for (i = 1; i < items; i++)
4372
		put_unaligned(atomic_long_read(&mib[i]), &stats[i]);
4373 4374 4375 4376

	memset(&stats[items], 0, pad);
}

W
WANG Cong 已提交
4377
static inline void __snmp6_fill_stats64(u64 *stats, void __percpu *mib,
4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391
				      int items, int bytes, size_t syncpoff)
{
	int i;
	int pad = bytes - sizeof(u64) * items;
	BUG_ON(pad < 0);

	/* Use put_unaligned() because stats may not be aligned for u64. */
	put_unaligned(items, &stats[0]);
	for (i = 1; i < items; i++)
		put_unaligned(snmp_fold_field64(mib, i, syncpoff), &stats[i]);

	memset(&stats[items], 0, pad);
}

4392 4393 4394
static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype,
			     int bytes)
{
S
Stephen Hemminger 已提交
4395
	switch (attrtype) {
4396
	case IFLA_INET6_STATS:
W
WANG Cong 已提交
4397
		__snmp6_fill_stats64(stats, idev->stats.ipv6,
4398
				     IPSTATS_MIB_MAX, bytes, offsetof(struct ipstats_mib, syncp));
4399 4400
		break;
	case IFLA_INET6_ICMP6STATS:
4401
		__snmp6_fill_statsdev(stats, idev->stats.icmpv6dev->mibs, ICMP6_MIB_MAX, bytes);
4402 4403 4404 4405
		break;
	}
}

T
Thomas Graf 已提交
4406 4407 4408 4409 4410
static int inet6_fill_ifla6_attrs(struct sk_buff *skb, struct inet6_dev *idev)
{
	struct nlattr *nla;
	struct ifla_cacheinfo ci;

D
David S. Miller 已提交
4411 4412
	if (nla_put_u32(skb, IFLA_INET6_FLAGS, idev->if_flags))
		goto nla_put_failure;
T
Thomas Graf 已提交
4413
	ci.max_reasm_len = IPV6_MAXPLEN;
4414 4415
	ci.tstamp = cstamp_delta(idev->tstamp);
	ci.reachable_time = jiffies_to_msecs(idev->nd_parms->reachable_time);
J
Jiri Pirko 已提交
4416
	ci.retrans_time = jiffies_to_msecs(NEIGH_VAR(idev->nd_parms, RETRANS_TIME));
D
David S. Miller 已提交
4417 4418
	if (nla_put(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci))
		goto nla_put_failure;
T
Thomas Graf 已提交
4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435
	nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32));
	if (nla == NULL)
		goto nla_put_failure;
	ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla));

	/* XXX - MC not implemented */

	nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64));
	if (nla == NULL)
		goto nla_put_failure;
	snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_STATS, nla_len(nla));

	nla = nla_reserve(skb, IFLA_INET6_ICMP6STATS, ICMP6_MIB_MAX * sizeof(u64));
	if (nla == NULL)
		goto nla_put_failure;
	snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla));

4436 4437 4438
	nla = nla_reserve(skb, IFLA_INET6_TOKEN, sizeof(struct in6_addr));
	if (nla == NULL)
		goto nla_put_failure;
4439 4440 4441 4442

	if (nla_put_u8(skb, IFLA_INET6_ADDR_GEN_MODE, idev->addr_gen_mode))
		goto nla_put_failure;

4443 4444 4445 4446
	read_lock_bh(&idev->lock);
	memcpy(nla_data(nla), idev->token.s6_addr, nla_len(nla));
	read_unlock_bh(&idev->lock);

T
Thomas Graf 已提交
4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

static size_t inet6_get_link_af_size(const struct net_device *dev)
{
	if (!__in6_dev_get(dev))
		return 0;

	return inet6_ifla6_size();
}

static int inet6_fill_link_af(struct sk_buff *skb, const struct net_device *dev)
{
	struct inet6_dev *idev = __in6_dev_get(dev);

	if (!idev)
		return -ENODATA;

	if (inet6_fill_ifla6_attrs(skb, idev) < 0)
		return -EMSGSIZE;

	return 0;
}

4474 4475 4476 4477
static int inet6_set_iftoken(struct inet6_dev *idev, struct in6_addr *token)
{
	struct inet6_ifaddr *ifp;
	struct net_device *dev = idev->dev;
4478
	bool update_rs = false;
4479
	struct in6_addr ll_addr;
4480

4481 4482
	ASSERT_RTNL();

4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500
	if (token == NULL)
		return -EINVAL;
	if (ipv6_addr_any(token))
		return -EINVAL;
	if (dev->flags & (IFF_LOOPBACK | IFF_NOARP))
		return -EINVAL;
	if (!ipv6_accept_ra(idev))
		return -EINVAL;
	if (idev->cnf.rtr_solicits <= 0)
		return -EINVAL;

	write_lock_bh(&idev->lock);

	BUILD_BUG_ON(sizeof(token->s6_addr) != 16);
	memcpy(idev->token.s6_addr + 8, token->s6_addr + 8, 8);

	write_unlock_bh(&idev->lock);

4501 4502 4503
	if (!idev->dead && (idev->if_flags & IF_READY) &&
	    !ipv6_get_lladdr(dev, &ll_addr, IFA_F_TENTATIVE |
			     IFA_F_OPTIMISTIC)) {
4504 4505 4506 4507 4508 4509 4510

		/* If we're not ready, then normal ifup will take care
		 * of this. Otherwise, we need to request our rs here.
		 */
		ndisc_send_rs(dev, &ll_addr, &in6addr_linklocal_allrouters);
		update_rs = true;
	}
4511 4512

	write_lock_bh(&idev->lock);
4513

4514
	if (update_rs) {
4515
		idev->if_flags |= IF_RS_SENT;
4516 4517 4518
		idev->rs_probes = 1;
		addrconf_mod_rs_timer(idev, idev->cnf.rtr_solicit_interval);
	}
4519 4520 4521 4522

	/* Well, that's kinda nasty ... */
	list_for_each_entry(ifp, &idev->addr_list, if_list) {
		spin_lock(&ifp->lock);
4523
		if (ifp->tokenized) {
4524 4525 4526 4527 4528 4529 4530
			ifp->valid_lft = 0;
			ifp->prefered_lft = 0;
		}
		spin_unlock(&ifp->lock);
	}

	write_unlock_bh(&idev->lock);
4531
	addrconf_verify_rtnl();
4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546
	return 0;
}

static int inet6_set_link_af(struct net_device *dev, const struct nlattr *nla)
{
	int err = -EINVAL;
	struct inet6_dev *idev = __in6_dev_get(dev);
	struct nlattr *tb[IFLA_INET6_MAX + 1];

	if (!idev)
		return -EAFNOSUPPORT;

	if (nla_parse_nested(tb, IFLA_INET6_MAX, nla, NULL) < 0)
		BUG();

4547
	if (tb[IFLA_INET6_TOKEN]) {
4548
		err = inet6_set_iftoken(idev, nla_data(tb[IFLA_INET6_TOKEN]));
4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561
		if (err)
			return err;
	}

	if (tb[IFLA_INET6_ADDR_GEN_MODE]) {
		u8 mode = nla_get_u8(tb[IFLA_INET6_ADDR_GEN_MODE]);

		if (mode != IN6_ADDR_GEN_MODE_EUI64 &&
		    mode != IN6_ADDR_GEN_MODE_NONE)
			return -EINVAL;
		idev->addr_gen_mode = mode;
		err = 0;
	}
4562 4563 4564 4565

	return err;
}

4566
static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev,
4567
			     u32 portid, u32 seq, int event, unsigned int flags)
L
Linus Torvalds 已提交
4568
{
4569 4570 4571 4572 4573
	struct net_device *dev = idev->dev;
	struct ifinfomsg *hdr;
	struct nlmsghdr *nlh;
	void *protoinfo;

4574
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags);
4575
	if (nlh == NULL)
4576
		return -EMSGSIZE;
4577 4578 4579 4580 4581 4582 4583 4584 4585

	hdr = nlmsg_data(nlh);
	hdr->ifi_family = AF_INET6;
	hdr->__ifi_pad = 0;
	hdr->ifi_type = dev->type;
	hdr->ifi_index = dev->ifindex;
	hdr->ifi_flags = dev_get_flags(dev);
	hdr->ifi_change = 0;

D
David S. Miller 已提交
4586 4587 4588 4589 4590 4591 4592
	if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
	    (dev->addr_len &&
	     nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
	    nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
	    (dev->ifindex != dev->iflink &&
	     nla_put_u32(skb, IFLA_LINK, dev->iflink)))
		goto nla_put_failure;
4593 4594 4595
	protoinfo = nla_nest_start(skb, IFLA_PROTINFO);
	if (protoinfo == NULL)
		goto nla_put_failure;
L
Linus Torvalds 已提交
4596

T
Thomas Graf 已提交
4597
	if (inet6_fill_ifla6_attrs(skb, idev) < 0)
4598
		goto nla_put_failure;
L
Linus Torvalds 已提交
4599

4600 4601
	nla_nest_end(skb, protoinfo);
	return nlmsg_end(skb, nlh);
L
Linus Torvalds 已提交
4602

4603
nla_put_failure:
4604 4605
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
4606 4607 4608 4609
}

static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
{
4610
	struct net *net = sock_net(skb->sk);
E
Eric Dumazet 已提交
4611
	int h, s_h;
4612
	int idx = 0, s_idx;
L
Linus Torvalds 已提交
4613 4614
	struct net_device *dev;
	struct inet6_dev *idev;
E
Eric Dumazet 已提交
4615
	struct hlist_head *head;
L
Linus Torvalds 已提交
4616

E
Eric Dumazet 已提交
4617 4618 4619 4620 4621 4622 4623
	s_h = cb->args[0];
	s_idx = cb->args[1];

	rcu_read_lock();
	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
		head = &net->dev_index_head[h];
4624
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
E
Eric Dumazet 已提交
4625 4626 4627 4628 4629 4630
			if (idx < s_idx)
				goto cont;
			idev = __in6_dev_get(dev);
			if (!idev)
				goto cont;
			if (inet6_fill_ifinfo(skb, idev,
4631
					      NETLINK_CB(cb->skb).portid,
E
Eric Dumazet 已提交
4632 4633 4634
					      cb->nlh->nlmsg_seq,
					      RTM_NEWLINK, NLM_F_MULTI) <= 0)
				goto out;
4635
cont:
E
Eric Dumazet 已提交
4636 4637
			idx++;
		}
L
Linus Torvalds 已提交
4638
	}
E
Eric Dumazet 已提交
4639 4640 4641 4642
out:
	rcu_read_unlock();
	cb->args[1] = idx;
	cb->args[0] = h;
L
Linus Torvalds 已提交
4643 4644 4645 4646 4647 4648 4649

	return skb->len;
}

void inet6_ifinfo_notify(int event, struct inet6_dev *idev)
{
	struct sk_buff *skb;
4650
	struct net *net = dev_net(idev->dev);
4651
	int err = -ENOBUFS;
4652

4653
	skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC);
4654 4655 4656 4657
	if (skb == NULL)
		goto errout;

	err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0);
4658 4659 4660 4661 4662 4663
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_if_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
4664
	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFINFO, NULL, GFP_ATOMIC);
4665
	return;
4666 4667
errout:
	if (err < 0)
4668
		rtnl_set_sk_err(net, RTNLGRP_IPV6_IFINFO, err);
L
Linus Torvalds 已提交
4669 4670
}

4671 4672 4673 4674 4675 4676
static inline size_t inet6_prefix_nlmsg_size(void)
{
	return NLMSG_ALIGN(sizeof(struct prefixmsg))
	       + nla_total_size(sizeof(struct in6_addr))
	       + nla_total_size(sizeof(struct prefix_cacheinfo));
}
4677

L
Linus Torvalds 已提交
4678
static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev,
4679
			     struct prefix_info *pinfo, u32 portid, u32 seq,
4680
			     int event, unsigned int flags)
L
Linus Torvalds 已提交
4681
{
4682 4683
	struct prefixmsg *pmsg;
	struct nlmsghdr *nlh;
L
Linus Torvalds 已提交
4684 4685
	struct prefix_cacheinfo	ci;

4686
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*pmsg), flags);
4687
	if (nlh == NULL)
4688
		return -EMSGSIZE;
4689 4690

	pmsg = nlmsg_data(nlh);
L
Linus Torvalds 已提交
4691
	pmsg->prefix_family = AF_INET6;
4692 4693
	pmsg->prefix_pad1 = 0;
	pmsg->prefix_pad2 = 0;
L
Linus Torvalds 已提交
4694 4695 4696
	pmsg->prefix_ifindex = idev->dev->ifindex;
	pmsg->prefix_len = pinfo->prefix_len;
	pmsg->prefix_type = pinfo->type;
4697
	pmsg->prefix_pad3 = 0;
L
Linus Torvalds 已提交
4698 4699 4700 4701 4702 4703
	pmsg->prefix_flags = 0;
	if (pinfo->onlink)
		pmsg->prefix_flags |= IF_PREFIX_ONLINK;
	if (pinfo->autoconf)
		pmsg->prefix_flags |= IF_PREFIX_AUTOCONF;

D
David S. Miller 已提交
4704 4705
	if (nla_put(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix))
		goto nla_put_failure;
L
Linus Torvalds 已提交
4706 4707
	ci.preferred_time = ntohl(pinfo->prefered);
	ci.valid_time = ntohl(pinfo->valid);
D
David S. Miller 已提交
4708 4709
	if (nla_put(skb, PREFIX_CACHEINFO, sizeof(ci), &ci))
		goto nla_put_failure;
4710
	return nlmsg_end(skb, nlh);
L
Linus Torvalds 已提交
4711

4712
nla_put_failure:
4713 4714
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
4715 4716
}

4717
static void inet6_prefix_notify(int event, struct inet6_dev *idev,
L
Linus Torvalds 已提交
4718 4719 4720
			 struct prefix_info *pinfo)
{
	struct sk_buff *skb;
4721
	struct net *net = dev_net(idev->dev);
4722
	int err = -ENOBUFS;
L
Linus Torvalds 已提交
4723

4724
	skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC);
4725 4726 4727 4728
	if (skb == NULL)
		goto errout;

	err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0);
4729 4730 4731 4732 4733 4734
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_prefix_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
4735 4736
	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC);
	return;
4737 4738
errout:
	if (err < 0)
4739
		rtnl_set_sk_err(net, RTNLGRP_IPV6_PREFIX, err);
L
Linus Torvalds 已提交
4740 4741 4742 4743
}

static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
{
4744 4745
	struct net *net = dev_net(ifp->idev->dev);

4746 4747 4748
	if (event)
		ASSERT_RTNL();

L
Linus Torvalds 已提交
4749 4750 4751 4752
	inet6_ifa_notify(event ? : RTM_NEWADDR, ifp);

	switch (event) {
	case RTM_NEWADDR:
4753 4754 4755 4756 4757 4758 4759 4760
		/*
		 * If the address was optimistic
		 * we inserted the route at the start of
		 * our DAD process, so we don't need
		 * to do it again
		 */
		if (!(ifp->rt->rt6i_node))
			ip6_ins_rt(ifp->rt);
L
Linus Torvalds 已提交
4761 4762
		if (ifp->idev->cnf.forwarding)
			addrconf_join_anycast(ifp);
C
Cong Wang 已提交
4763
		if (!ipv6_addr_any(&ifp->peer_addr))
4764 4765
			addrconf_prefix_route(&ifp->peer_addr, 128,
					      ifp->idev->dev, 0, 0);
L
Linus Torvalds 已提交
4766 4767 4768 4769 4770
		break;
	case RTM_DELADDR:
		if (ifp->idev->cnf.forwarding)
			addrconf_leave_anycast(ifp);
		addrconf_leave_solict(ifp->idev, &ifp->addr);
C
Cong Wang 已提交
4771
		if (!ipv6_addr_any(&ifp->peer_addr)) {
4772 4773
			struct rt6_info *rt;

4774 4775
			rt = addrconf_get_prefix_route(&ifp->peer_addr, 128,
						       ifp->idev->dev, 0, 0);
4776 4777
			if (rt && ip6_del_rt(rt))
				dst_free(&rt->dst);
4778
		}
4779
		dst_hold(&ifp->rt->dst);
4780

4781
		if (ip6_del_rt(ifp->rt))
4782
			dst_free(&ifp->rt->dst);
L
Linus Torvalds 已提交
4783 4784
		break;
	}
4785
	atomic_inc(&net->ipv6.dev_addr_genid);
4786
	rt_genid_bump_ipv6(net);
L
Linus Torvalds 已提交
4787 4788 4789 4790
}

static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
{
4791
	rcu_read_lock_bh();
L
Linus Torvalds 已提交
4792 4793
	if (likely(ifp->idev->dead == 0))
		__ipv6_ifa_notify(event, ifp);
4794
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
4795 4796 4797 4798 4799
}

#ifdef CONFIG_SYSCTL

static
4800
int addrconf_sysctl_forward(struct ctl_table *ctl, int write,
L
Linus Torvalds 已提交
4801 4802 4803 4804
			   void __user *buffer, size_t *lenp, loff_t *ppos)
{
	int *valp = ctl->data;
	int val = *valp;
E
Eric W. Biederman 已提交
4805
	loff_t pos = *ppos;
4806
	struct ctl_table lctl;
L
Linus Torvalds 已提交
4807 4808
	int ret;

4809 4810 4811 4812 4813 4814 4815 4816
	/*
	 * ctl->data points to idev->cnf.forwarding, we should
	 * not modify it until we get the rtnl lock.
	 */
	lctl = *ctl;
	lctl.data = &val;

	ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
L
Linus Torvalds 已提交
4817

4818
	if (write)
4819
		ret = addrconf_fixup_forwarding(ctl, valp, val);
E
Eric W. Biederman 已提交
4820 4821
	if (ret)
		*ppos = pos;
4822
	return ret;
L
Linus Torvalds 已提交
4823 4824
}

4825 4826
static void dev_disable_change(struct inet6_dev *idev)
{
4827 4828
	struct netdev_notifier_info info;

4829 4830 4831
	if (!idev || !idev->dev)
		return;

4832
	netdev_notifier_info_init(&info, idev->dev);
4833
	if (idev->cnf.disable_ipv6)
4834
		addrconf_notify(NULL, NETDEV_DOWN, &info);
4835
	else
4836
		addrconf_notify(NULL, NETDEV_UP, &info);
4837 4838 4839 4840 4841 4842 4843
}

static void addrconf_disable_change(struct net *net, __s32 newf)
{
	struct net_device *dev;
	struct inet6_dev *idev;

4844 4845
	rcu_read_lock();
	for_each_netdev_rcu(net, dev) {
4846 4847 4848 4849 4850 4851 4852 4853
		idev = __in6_dev_get(dev);
		if (idev) {
			int changed = (!idev->cnf.disable_ipv6) ^ (!newf);
			idev->cnf.disable_ipv6 = newf;
			if (changed)
				dev_disable_change(idev);
		}
	}
4854
	rcu_read_unlock();
4855 4856
}

4857
static int addrconf_disable_ipv6(struct ctl_table *table, int *p, int newf)
4858 4859
{
	struct net *net;
4860 4861 4862 4863
	int old;

	if (!rtnl_trylock())
		return restart_syscall();
4864 4865

	net = (struct net *)table->extra2;
4866 4867
	old = *p;
	*p = newf;
4868

4869 4870
	if (p == &net->ipv6.devconf_dflt->disable_ipv6) {
		rtnl_unlock();
4871
		return 0;
E
Eric W. Biederman 已提交
4872
	}
4873 4874 4875 4876

	if (p == &net->ipv6.devconf_all->disable_ipv6) {
		net->ipv6.devconf_dflt->disable_ipv6 = newf;
		addrconf_disable_change(net, newf);
4877
	} else if ((!newf) ^ (!old))
4878 4879 4880 4881 4882 4883 4884
		dev_disable_change((struct inet6_dev *)table->extra1);

	rtnl_unlock();
	return 0;
}

static
4885
int addrconf_sysctl_disable(struct ctl_table *ctl, int write,
4886 4887 4888 4889
			    void __user *buffer, size_t *lenp, loff_t *ppos)
{
	int *valp = ctl->data;
	int val = *valp;
E
Eric W. Biederman 已提交
4890
	loff_t pos = *ppos;
4891
	struct ctl_table lctl;
4892 4893
	int ret;

4894 4895 4896 4897 4898 4899 4900 4901
	/*
	 * ctl->data points to idev->cnf.disable_ipv6, we should
	 * not modify it until we get the rtnl lock.
	 */
	lctl = *ctl;
	lctl.data = &val;

	ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
4902 4903 4904

	if (write)
		ret = addrconf_disable_ipv6(ctl, valp, val);
E
Eric W. Biederman 已提交
4905 4906
	if (ret)
		*ppos = pos;
4907 4908 4909
	return ret;
}

4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949
static
int addrconf_sysctl_proxy_ndp(struct ctl_table *ctl, int write,
			      void __user *buffer, size_t *lenp, loff_t *ppos)
{
	int *valp = ctl->data;
	int ret;
	int old, new;

	old = *valp;
	ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
	new = *valp;

	if (write && old != new) {
		struct net *net = ctl->extra2;

		if (!rtnl_trylock())
			return restart_syscall();

		if (valp == &net->ipv6.devconf_dflt->proxy_ndp)
			inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
						     NETCONFA_IFINDEX_DEFAULT,
						     net->ipv6.devconf_dflt);
		else if (valp == &net->ipv6.devconf_all->proxy_ndp)
			inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
						     NETCONFA_IFINDEX_ALL,
						     net->ipv6.devconf_all);
		else {
			struct inet6_dev *idev = ctl->extra1;

			inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
						     idev->dev->ifindex,
						     &idev->cnf);
		}
		rtnl_unlock();
	}

	return ret;
}


L
Linus Torvalds 已提交
4950 4951 4952
static struct addrconf_sysctl_table
{
	struct ctl_table_header *sysctl_header;
4953
	struct ctl_table addrconf_vars[DEVCONF_MAX+1];
4954
} addrconf_sysctl __read_mostly = {
L
Linus Torvalds 已提交
4955 4956
	.sysctl_header = NULL,
	.addrconf_vars = {
4957
		{
S
Stephen Hemminger 已提交
4958 4959 4960 4961 4962
			.procname	= "forwarding",
			.data		= &ipv6_devconf.forwarding,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= addrconf_sysctl_forward,
L
Linus Torvalds 已提交
4963 4964
		},
		{
S
Stephen Hemminger 已提交
4965 4966 4967 4968 4969
			.procname	= "hop_limit",
			.data		= &ipv6_devconf.hop_limit,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
4970 4971
		},
		{
S
Stephen Hemminger 已提交
4972 4973 4974 4975 4976
			.procname	= "mtu",
			.data		= &ipv6_devconf.mtu6,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
4977 4978
		},
		{
S
Stephen Hemminger 已提交
4979 4980 4981 4982 4983
			.procname	= "accept_ra",
			.data		= &ipv6_devconf.accept_ra,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
4984 4985
		},
		{
S
Stephen Hemminger 已提交
4986 4987 4988 4989 4990
			.procname	= "accept_redirects",
			.data		= &ipv6_devconf.accept_redirects,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
4991 4992
		},
		{
S
Stephen Hemminger 已提交
4993 4994 4995 4996 4997
			.procname	= "autoconf",
			.data		= &ipv6_devconf.autoconf,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
4998 4999
		},
		{
S
Stephen Hemminger 已提交
5000 5001 5002 5003 5004
			.procname	= "dad_transmits",
			.data		= &ipv6_devconf.dad_transmits,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5005 5006
		},
		{
S
Stephen Hemminger 已提交
5007 5008 5009 5010 5011
			.procname	= "router_solicitations",
			.data		= &ipv6_devconf.rtr_solicits,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5012 5013
		},
		{
S
Stephen Hemminger 已提交
5014 5015 5016 5017 5018
			.procname	= "router_solicitation_interval",
			.data		= &ipv6_devconf.rtr_solicit_interval,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec_jiffies,
L
Linus Torvalds 已提交
5019 5020
		},
		{
S
Stephen Hemminger 已提交
5021 5022 5023 5024 5025
			.procname	= "router_solicitation_delay",
			.data		= &ipv6_devconf.rtr_solicit_delay,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec_jiffies,
L
Linus Torvalds 已提交
5026 5027
		},
		{
S
Stephen Hemminger 已提交
5028 5029 5030 5031 5032
			.procname	= "force_mld_version",
			.data		= &ipv6_devconf.force_mld_version,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5033
		},
5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049
		{
			.procname	= "mldv1_unsolicited_report_interval",
			.data		=
				&ipv6_devconf.mldv1_unsolicited_report_interval,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec_ms_jiffies,
		},
		{
			.procname	= "mldv2_unsolicited_report_interval",
			.data		=
				&ipv6_devconf.mldv2_unsolicited_report_interval,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec_ms_jiffies,
		},
L
Linus Torvalds 已提交
5050
		{
S
Stephen Hemminger 已提交
5051 5052 5053 5054 5055
			.procname	= "use_tempaddr",
			.data		= &ipv6_devconf.use_tempaddr,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5056 5057
		},
		{
S
Stephen Hemminger 已提交
5058 5059 5060 5061 5062
			.procname	= "temp_valid_lft",
			.data		= &ipv6_devconf.temp_valid_lft,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5063 5064
		},
		{
S
Stephen Hemminger 已提交
5065 5066 5067 5068 5069
			.procname	= "temp_prefered_lft",
			.data		= &ipv6_devconf.temp_prefered_lft,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5070 5071
		},
		{
S
Stephen Hemminger 已提交
5072 5073 5074 5075 5076
			.procname	= "regen_max_retry",
			.data		= &ipv6_devconf.regen_max_retry,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5077 5078
		},
		{
S
Stephen Hemminger 已提交
5079 5080 5081 5082 5083
			.procname	= "max_desync_factor",
			.data		= &ipv6_devconf.max_desync_factor,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5084 5085
		},
		{
S
Stephen Hemminger 已提交
5086 5087 5088 5089 5090
			.procname	= "max_addresses",
			.data		= &ipv6_devconf.max_addresses,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5091
		},
5092
		{
S
Stephen Hemminger 已提交
5093 5094 5095 5096 5097
			.procname	= "accept_ra_defrtr",
			.data		= &ipv6_devconf.accept_ra_defrtr,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
5098
		},
5099
		{
S
Stephen Hemminger 已提交
5100 5101 5102 5103 5104
			.procname	= "accept_ra_pinfo",
			.data		= &ipv6_devconf.accept_ra_pinfo,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
5105
		},
5106 5107
#ifdef CONFIG_IPV6_ROUTER_PREF
		{
S
Stephen Hemminger 已提交
5108 5109 5110 5111 5112
			.procname	= "accept_ra_rtr_pref",
			.data		= &ipv6_devconf.accept_ra_rtr_pref,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
5113
		},
5114
		{
S
Stephen Hemminger 已提交
5115 5116 5117 5118 5119
			.procname	= "router_probe_interval",
			.data		= &ipv6_devconf.rtr_probe_interval,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec_jiffies,
5120
		},
N
Neil Horman 已提交
5121
#ifdef CONFIG_IPV6_ROUTE_INFO
5122
		{
S
Stephen Hemminger 已提交
5123 5124 5125 5126 5127
			.procname	= "accept_ra_rt_info_max_plen",
			.data		= &ipv6_devconf.accept_ra_rt_info_max_plen,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
5128 5129
		},
#endif
5130
#endif
5131
		{
S
Stephen Hemminger 已提交
5132 5133 5134 5135
			.procname	= "proxy_ndp",
			.data		= &ipv6_devconf.proxy_ndp,
			.maxlen		= sizeof(int),
			.mode		= 0644,
5136
			.proc_handler	= addrconf_sysctl_proxy_ndp,
5137
		},
5138
		{
S
Stephen Hemminger 已提交
5139 5140 5141 5142 5143
			.procname	= "accept_source_route",
			.data		= &ipv6_devconf.accept_source_route,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
5144
		},
5145 5146
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
		{
S
Stephen Hemminger 已提交
5147 5148 5149 5150 5151
			.procname       = "optimistic_dad",
			.data           = &ipv6_devconf.optimistic_dad,
			.maxlen         = sizeof(int),
			.mode           = 0644,
			.proc_handler   = proc_dointvec,
5152 5153

		},
5154 5155 5156
#endif
#ifdef CONFIG_IPV6_MROUTE
		{
S
Stephen Hemminger 已提交
5157 5158 5159 5160 5161
			.procname	= "mc_forwarding",
			.data		= &ipv6_devconf.mc_forwarding,
			.maxlen		= sizeof(int),
			.mode		= 0444,
			.proc_handler	= proc_dointvec,
5162
		},
5163
#endif
5164
		{
S
Stephen Hemminger 已提交
5165 5166 5167 5168 5169
			.procname	= "disable_ipv6",
			.data		= &ipv6_devconf.disable_ipv6,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= addrconf_sysctl_disable,
5170
		},
5171
		{
S
Stephen Hemminger 已提交
5172 5173 5174 5175 5176
			.procname	= "accept_dad",
			.data		= &ipv6_devconf.accept_dad,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
5177
		},
5178 5179 5180 5181 5182 5183 5184
		{
			.procname       = "force_tllao",
			.data           = &ipv6_devconf.force_tllao,
			.maxlen         = sizeof(int),
			.mode           = 0644,
			.proc_handler   = proc_dointvec
		},
5185 5186 5187 5188 5189 5190 5191
		{
			.procname       = "ndisc_notify",
			.data           = &ipv6_devconf.ndisc_notify,
			.maxlen         = sizeof(int),
			.mode           = 0644,
			.proc_handler   = proc_dointvec
		},
5192 5193 5194 5195 5196 5197 5198
		{
			.procname	= "suppress_frag_ndisc",
			.data		= &ipv6_devconf.suppress_frag_ndisc,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec
		},
5199 5200 5201 5202 5203 5204 5205
		{
			.procname	= "accept_ra_from_local",
			.data		= &ipv6_devconf.accept_ra_from_local,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
		},
L
Linus Torvalds 已提交
5206
		{
5207
			/* sentinel */
L
Linus Torvalds 已提交
5208 5209 5210 5211
		}
	},
};

5212
static int __addrconf_sysctl_register(struct net *net, char *dev_name,
5213
		struct inet6_dev *idev, struct ipv6_devconf *p)
L
Linus Torvalds 已提交
5214 5215 5216
{
	int i;
	struct addrconf_sysctl_table *t;
5217
	char path[sizeof("net/ipv6/conf/") + IFNAMSIZ];
5218

A
Arnaldo Carvalho de Melo 已提交
5219
	t = kmemdup(&addrconf_sysctl, sizeof(*t), GFP_KERNEL);
L
Linus Torvalds 已提交
5220
	if (t == NULL)
5221 5222
		goto out;

S
Stephen Hemminger 已提交
5223
	for (i = 0; t->addrconf_vars[i].data; i++) {
S
Stephen Hemminger 已提交
5224
		t->addrconf_vars[i].data += (char *)p - (char *)&ipv6_devconf;
L
Linus Torvalds 已提交
5225
		t->addrconf_vars[i].extra1 = idev; /* embedded; no ref */
5226
		t->addrconf_vars[i].extra2 = net;
L
Linus Torvalds 已提交
5227 5228
	}

5229
	snprintf(path, sizeof(path), "net/ipv6/conf/%s", dev_name);
L
Linus Torvalds 已提交
5230

5231
	t->sysctl_header = register_net_sysctl(net, path, t->addrconf_vars);
L
Linus Torvalds 已提交
5232
	if (t->sysctl_header == NULL)
5233
		goto free;
5234 5235

	p->sysctl = t;
5236
	return 0;
L
Linus Torvalds 已提交
5237

5238
free:
L
Linus Torvalds 已提交
5239
	kfree(t);
5240
out:
5241
	return -ENOBUFS;
L
Linus Torvalds 已提交
5242 5243
}

5244 5245 5246 5247 5248 5249 5250 5251 5252
static void __addrconf_sysctl_unregister(struct ipv6_devconf *p)
{
	struct addrconf_sysctl_table *t;

	if (p->sysctl == NULL)
		return;

	t = p->sysctl;
	p->sysctl = NULL;
5253
	unregister_net_sysctl_table(t->sysctl_header);
5254 5255 5256
	kfree(t);
}

5257
static int addrconf_sysctl_register(struct inet6_dev *idev)
5258
{
5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273
	int err;

	if (!sysctl_dev_name_is_allowed(idev->dev->name))
		return -EINVAL;

	err = neigh_sysctl_register(idev->dev, idev->nd_parms,
				    &ndisc_ifinfo_sysctl_change);
	if (err)
		return err;
	err = __addrconf_sysctl_register(dev_net(idev->dev), idev->dev->name,
					 idev, &idev->cnf);
	if (err)
		neigh_sysctl_unregister(idev->nd_parms);

	return err;
5274 5275
}

5276
static void addrconf_sysctl_unregister(struct inet6_dev *idev)
L
Linus Torvalds 已提交
5277
{
5278 5279
	__addrconf_sysctl_unregister(&idev->cnf);
	neigh_sysctl_unregister(idev->nd_parms);
L
Linus Torvalds 已提交
5280 5281 5282 5283 5284
}


#endif

5285
static int __net_init addrconf_init_net(struct net *net)
5286
{
5287
	int err = -ENOMEM;
5288 5289
	struct ipv6_devconf *all, *dflt;

5290 5291 5292
	all = kmemdup(&ipv6_devconf, sizeof(ipv6_devconf), GFP_KERNEL);
	if (all == NULL)
		goto err_alloc_all;
5293

5294 5295 5296
	dflt = kmemdup(&ipv6_devconf_dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
	if (dflt == NULL)
		goto err_alloc_dflt;
5297

5298 5299 5300
	/* these will be inherited by all namespaces */
	dflt->autoconf = ipv6_defaults.autoconf;
	dflt->disable_ipv6 = ipv6_defaults.disable_ipv6;
5301 5302 5303 5304 5305

	net->ipv6.devconf_all = all;
	net->ipv6.devconf_dflt = dflt;

#ifdef CONFIG_SYSCTL
5306
	err = __addrconf_sysctl_register(net, "all", NULL, all);
5307 5308 5309
	if (err < 0)
		goto err_reg_all;

5310
	err = __addrconf_sysctl_register(net, "default", NULL, dflt);
5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327
	if (err < 0)
		goto err_reg_dflt;
#endif
	return 0;

#ifdef CONFIG_SYSCTL
err_reg_dflt:
	__addrconf_sysctl_unregister(all);
err_reg_all:
	kfree(dflt);
#endif
err_alloc_dflt:
	kfree(all);
err_alloc_all:
	return err;
}

5328
static void __net_exit addrconf_exit_net(struct net *net)
5329 5330 5331 5332 5333
{
#ifdef CONFIG_SYSCTL
	__addrconf_sysctl_unregister(net->ipv6.devconf_dflt);
	__addrconf_sysctl_unregister(net->ipv6.devconf_all);
#endif
O
Octavian Purdila 已提交
5334
	if (!net_eq(net, &init_net)) {
5335 5336 5337 5338 5339 5340 5341 5342 5343 5344
		kfree(net->ipv6.devconf_dflt);
		kfree(net->ipv6.devconf_all);
	}
}

static struct pernet_operations addrconf_ops = {
	.init = addrconf_init_net,
	.exit = addrconf_exit_net,
};

T
Thomas Graf 已提交
5345 5346 5347 5348
static struct rtnl_af_ops inet6_ops = {
	.family		  = AF_INET6,
	.fill_link_af	  = inet6_fill_link_af,
	.get_link_af_size = inet6_get_link_af_size,
5349
	.set_link_af	  = inet6_set_link_af,
T
Thomas Graf 已提交
5350 5351
};

L
Linus Torvalds 已提交
5352 5353 5354 5355 5356 5357
/*
 *	Init / cleanup code
 */

int __init addrconf_init(void)
{
5358
	struct inet6_dev *idev;
5359
	int i, err;
5360

S
Stephen Hemminger 已提交
5361 5362
	err = ipv6_addr_label_init();
	if (err < 0) {
5363 5364
		pr_crit("%s: cannot initialize default policy table: %d\n",
			__func__, err);
5365
		goto out;
5366
	}
L
Linus Torvalds 已提交
5367

5368 5369 5370
	err = register_pernet_subsys(&addrconf_ops);
	if (err < 0)
		goto out_addrlabel;
5371

5372 5373 5374 5375 5376 5377
	addrconf_wq = create_workqueue("ipv6_addrconf");
	if (!addrconf_wq) {
		err = -ENOMEM;
		goto out_nowq;
	}

L
Linus Torvalds 已提交
5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396
	/* The addrconf netdev notifier requires that loopback_dev
	 * has it's ipv6 private information allocated and setup
	 * before it can bring up and give link-local addresses
	 * to other devices which are up.
	 *
	 * Unfortunately, loopback_dev is not necessarily the first
	 * entry in the global dev_base list of net devices.  In fact,
	 * it is likely to be the very last entry on that list.
	 * So this causes the notifier registry below to try and
	 * give link-local addresses to all devices besides loopback_dev
	 * first, then loopback_dev, which cases all the non-loopback_dev
	 * devices to fail to get a link-local address.
	 *
	 * So, as a temporary fix, allocate the ipv6 structure for
	 * loopback_dev first by hand.
	 * Longer term, all of the dependencies ipv6 has upon the loopback
	 * device and it being up should be removed.
	 */
	rtnl_lock();
5397
	idev = ipv6_add_dev(init_net.loopback_dev);
L
Linus Torvalds 已提交
5398
	rtnl_unlock();
5399 5400
	if (IS_ERR(idev)) {
		err = PTR_ERR(idev);
5401
		goto errlo;
5402
	}
L
Linus Torvalds 已提交
5403

5404 5405 5406
	for (i = 0; i < IN6_ADDR_HSIZE; i++)
		INIT_HLIST_HEAD(&inet6_addr_lst[i]);

L
Linus Torvalds 已提交
5407 5408
	register_netdevice_notifier(&ipv6_dev_notf);

5409
	addrconf_verify();
5410

5411
	rtnl_af_register(&inet6_ops);
T
Thomas Graf 已提交
5412

5413 5414
	err = __rtnl_register(PF_INET6, RTM_GETLINK, NULL, inet6_dump_ifinfo,
			      NULL);
5415 5416 5417 5418
	if (err < 0)
		goto errout;

	/* Only the first call to __rtnl_register can fail */
5419 5420 5421 5422 5423 5424 5425 5426
	__rtnl_register(PF_INET6, RTM_NEWADDR, inet6_rtm_newaddr, NULL, NULL);
	__rtnl_register(PF_INET6, RTM_DELADDR, inet6_rtm_deladdr, NULL, NULL);
	__rtnl_register(PF_INET6, RTM_GETADDR, inet6_rtm_getaddr,
			inet6_dump_ifaddr, NULL);
	__rtnl_register(PF_INET6, RTM_GETMULTICAST, NULL,
			inet6_dump_ifmcaddr, NULL);
	__rtnl_register(PF_INET6, RTM_GETANYCAST, NULL,
			inet6_dump_ifacaddr, NULL);
5427
	__rtnl_register(PF_INET6, RTM_GETNETCONF, inet6_netconf_get_devconf,
5428
			inet6_netconf_dump_devconf, NULL);
5429

5430 5431
	ipv6_addr_label_rtnl_register();

L
Linus Torvalds 已提交
5432
	return 0;
5433
errout:
T
Thomas Graf 已提交
5434
	rtnl_af_unregister(&inet6_ops);
5435
	unregister_netdevice_notifier(&ipv6_dev_notf);
5436
errlo:
5437 5438
	destroy_workqueue(addrconf_wq);
out_nowq:
5439
	unregister_pernet_subsys(&addrconf_ops);
5440 5441 5442
out_addrlabel:
	ipv6_addr_label_cleanup();
out:
5443
	return err;
L
Linus Torvalds 已提交
5444 5445
}

5446
void addrconf_cleanup(void)
L
Linus Torvalds 已提交
5447
{
5448
	struct net_device *dev;
L
Linus Torvalds 已提交
5449 5450 5451
	int i;

	unregister_netdevice_notifier(&ipv6_dev_notf);
5452
	unregister_pernet_subsys(&addrconf_ops);
5453
	ipv6_addr_label_cleanup();
L
Linus Torvalds 已提交
5454 5455 5456

	rtnl_lock();

T
Thomas Graf 已提交
5457 5458
	__rtnl_af_unregister(&inet6_ops);

5459 5460 5461 5462 5463 5464 5465 5466
	/* clean dev list */
	for_each_netdev(&init_net, dev) {
		if (__in6_dev_get(dev) == NULL)
			continue;
		addrconf_ifdown(dev, 1);
	}
	addrconf_ifdown(init_net.loopback_dev, 2);

L
Linus Torvalds 已提交
5467 5468 5469
	/*
	 *	Check hash table.
	 */
5470
	spin_lock_bh(&addrconf_hash_lock);
5471 5472
	for (i = 0; i < IN6_ADDR_HSIZE; i++)
		WARN_ON(!hlist_empty(&inet6_addr_lst[i]));
5473
	spin_unlock_bh(&addrconf_hash_lock);
5474
	cancel_delayed_work(&addr_chk_work);
L
Linus Torvalds 已提交
5475
	rtnl_unlock();
5476 5477

	destroy_workqueue(addrconf_wq);
L
Linus Torvalds 已提交
5478
}