addrconf.c 175.0 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
L
Linus Torvalds 已提交
2 3 4 5 6
/*
 *	IPv6 Address [auto]configuration
 *	Linux INET6 implementation
 *
 *	Authors:
7
 *	Pedro Roque		<roque@di.fc.ul.pt>
L
Linus Torvalds 已提交
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 *	Alexey Kuznetsov	<kuznet@ms2.inr.ac.ru>
 */

/*
 *	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.
32 33 34
 *	YOSHIFUJI Hideaki @USAGI	:	improved source address
 *						selection; consider scope,
 *						status etc.
L
Linus Torvalds 已提交
35 36
 */

37 38
#define pr_fmt(fmt) "IPv6: " fmt

L
Linus Torvalds 已提交
39 40
#include <linux/errno.h>
#include <linux/types.h>
41
#include <linux/kernel.h>
42
#include <linux/sched/signal.h>
L
Linus Torvalds 已提交
43 44 45
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/net.h>
46
#include <linux/inet.h>
L
Linus Torvalds 已提交
47 48
#include <linux/in6.h>
#include <linux/netdevice.h>
49
#include <linux/if_addr.h>
L
Linus Torvalds 已提交
50 51 52 53 54 55
#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>
56
#include <linux/slab.h>
L
Linus Torvalds 已提交
57 58 59
#ifdef CONFIG_SYSCTL
#include <linux/sysctl.h>
#endif
60
#include <linux/capability.h>
L
Linus Torvalds 已提交
61 62
#include <linux/delay.h>
#include <linux/notifier.h>
63
#include <linux/string.h>
E
Eric Dumazet 已提交
64
#include <linux/hash.h>
L
Linus Torvalds 已提交
65

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

70
#include <net/6lowpan.h>
71
#include <net/firewire.h>
L
Linus Torvalds 已提交
72 73 74 75 76 77 78
#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>
79
#include <net/netlink.h>
80
#include <net/pkt_sched.h>
D
David Ahern 已提交
81
#include <net/l3mdev.h>
L
Linus Torvalds 已提交
82 83
#include <linux/if_tunnel.h>
#include <linux/rtnetlink.h>
84
#include <linux/netconf.h>
L
Linus Torvalds 已提交
85
#include <linux/random.h>
S
Stephen Hemminger 已提交
86
#include <linux/uaccess.h>
87
#include <asm/unaligned.h>
L
Linus Torvalds 已提交
88 89 90

#include <linux/proc_fs.h>
#include <linux/seq_file.h>
91
#include <linux/export.h>
L
Linus Torvalds 已提交
92 93

#define	INFINITY_LIFE_TIME	0xFFFFFFFF
94

95 96 97
#define IPV6_MAX_STRLEN \
	sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")

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

103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
static inline s32 rfc3315_s14_backoff_init(s32 irt)
{
	/* multiply 'initial retransmission time' by 0.9 .. 1.1 */
	u64 tmp = (900000 + prandom_u32() % 200001) * (u64)irt;
	do_div(tmp, 1000000);
	return (s32)tmp;
}

static inline s32 rfc3315_s14_backoff_update(s32 rt, s32 mrt)
{
	/* multiply 'retransmission timeout' by 1.9 .. 2.1 */
	u64 tmp = (1900000 + prandom_u32() % 200001) * (u64)rt;
	do_div(tmp, 1000000);
	if ((s32)tmp > mrt) {
		/* multiply 'maximum retransmission time' by 0.9 .. 1.1 */
		tmp = (900000 + prandom_u32() % 200001) * (u64)mrt;
		do_div(tmp, 1000000);
	}
	return (s32)tmp;
}

L
Linus Torvalds 已提交
124
#ifdef CONFIG_SYSCTL
125
static int addrconf_sysctl_register(struct inet6_dev *idev);
126 127
static void addrconf_sysctl_unregister(struct inet6_dev *idev);
#else
128
static inline int addrconf_sysctl_register(struct inet6_dev *idev)
129
{
130
	return 0;
131 132 133 134 135
}

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

138
static void ipv6_gen_rnd_iid(struct in6_addr *addr);
L
Linus Torvalds 已提交
139

140
static int ipv6_generate_eui64(u8 *eui, struct net_device *dev);
141
static int ipv6_count_addresses(const struct inet6_dev *idev);
142 143 144
static int ipv6_generate_stable_address(struct in6_addr *addr,
					u8 dad_count,
					const struct inet6_dev *idev);
L
Linus Torvalds 已提交
145

146 147
#define IN6_ADDR_HSIZE_SHIFT	8
#define IN6_ADDR_HSIZE		(1 << IN6_ADDR_HSIZE_SHIFT)
L
Linus Torvalds 已提交
148 149 150
/*
 *	Configured unicast address hash table
 */
151
static struct hlist_head inet6_addr_lst[IN6_ADDR_HSIZE];
152
static DEFINE_SPINLOCK(addrconf_hash_lock);
L
Linus Torvalds 已提交
153

154 155 156
static void addrconf_verify(void);
static void addrconf_verify_rtnl(void);
static void addrconf_verify_work(struct work_struct *);
L
Linus Torvalds 已提交
157

158 159
static struct workqueue_struct *addrconf_wq;
static DECLARE_DELAYED_WORK(addr_chk_work, addrconf_verify_work);
L
Linus Torvalds 已提交
160 161 162 163

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

164 165
static void addrconf_type_change(struct net_device *dev,
				 unsigned long event);
166
static int addrconf_ifdown(struct net_device *dev, bool unregister);
L
Linus Torvalds 已提交
167

168
static struct fib6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
169 170
						  int plen,
						  const struct net_device *dev,
171 172
						  u32 flags, u32 noflags,
						  bool no_gw);
173

174
static void addrconf_dad_start(struct inet6_ifaddr *ifp);
175
static void addrconf_dad_work(struct work_struct *w);
176 177
static void addrconf_dad_completed(struct inet6_ifaddr *ifp, bool bump_id,
				   bool send_na);
178
static void addrconf_dad_run(struct inet6_dev *idev, bool restart);
179
static void addrconf_rs_timer(struct timer_list *t);
L
Linus Torvalds 已提交
180 181 182
static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);

183
static void inet6_prefix_notify(int event, struct inet6_dev *idev,
L
Linus Torvalds 已提交
184 185
				struct prefix_info *pinfo);

186
static struct ipv6_devconf ipv6_devconf __read_mostly = {
L
Linus Torvalds 已提交
187 188 189 190 191 192 193
	.forwarding		= 0,
	.hop_limit		= IPV6_DEFAULT_HOPLIMIT,
	.mtu6			= IPV6_MIN_MTU,
	.accept_ra		= 1,
	.accept_redirects	= 1,
	.autoconf		= 1,
	.force_mld_version	= 0,
194 195
	.mldv1_unsolicited_report_interval = 10 * HZ,
	.mldv2_unsolicited_report_interval = HZ,
L
Linus Torvalds 已提交
196 197 198
	.dad_transmits		= 1,
	.rtr_solicits		= MAX_RTR_SOLICITATIONS,
	.rtr_solicit_interval	= RTR_SOLICITATION_INTERVAL,
199
	.rtr_solicit_max_interval = RTR_SOLICITATION_MAX_INTERVAL,
L
Linus Torvalds 已提交
200
	.rtr_solicit_delay	= MAX_RTR_SOLICITATION_DELAY,
201
	.use_tempaddr		= 0,
L
Linus Torvalds 已提交
202 203 204 205 206
	.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,
207
	.accept_ra_defrtr	= 1,
208
	.accept_ra_from_local	= 0,
209
	.accept_ra_min_hop_limit= 1,
210
	.accept_ra_pinfo	= 1,
211 212
#ifdef CONFIG_IPV6_ROUTER_PREF
	.accept_ra_rtr_pref	= 1,
213
	.rtr_probe_interval	= 60 * HZ,
214
#ifdef CONFIG_IPV6_ROUTE_INFO
215
	.accept_ra_rt_info_min_plen = 0,
216 217
	.accept_ra_rt_info_max_plen = 0,
#endif
218
#endif
219
	.proxy_ndp		= 0,
220
	.accept_source_route	= 0,	/* we do not accept RH0 by default. */
221
	.disable_ipv6		= 0,
222
	.accept_dad		= 0,
223
	.suppress_frag_ndisc	= 1,
224
	.accept_ra_mtu		= 1,
225 226
	.stable_secret		= {
		.initialized = false,
227 228
	},
	.use_oif_addrs_only	= 0,
229
	.ignore_routes_with_linkdown = 0,
230
	.keep_addr_on_down	= 0,
231
	.seg6_enabled		= 0,
232 233 234
#ifdef CONFIG_IPV6_SEG6_HMAC
	.seg6_require_hmac	= 0,
#endif
235
	.enhanced_dad           = 1,
236
	.addr_gen_mode		= IN6_ADDR_GEN_MODE_EUI64,
237
	.disable_policy		= 0,
238
	.rpl_seg_enabled	= 0,
L
Linus Torvalds 已提交
239 240
};

241
static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = {
L
Linus Torvalds 已提交
242 243 244 245 246 247
	.forwarding		= 0,
	.hop_limit		= IPV6_DEFAULT_HOPLIMIT,
	.mtu6			= IPV6_MIN_MTU,
	.accept_ra		= 1,
	.accept_redirects	= 1,
	.autoconf		= 1,
248 249 250
	.force_mld_version	= 0,
	.mldv1_unsolicited_report_interval = 10 * HZ,
	.mldv2_unsolicited_report_interval = HZ,
L
Linus Torvalds 已提交
251 252 253
	.dad_transmits		= 1,
	.rtr_solicits		= MAX_RTR_SOLICITATIONS,
	.rtr_solicit_interval	= RTR_SOLICITATION_INTERVAL,
254
	.rtr_solicit_max_interval = RTR_SOLICITATION_MAX_INTERVAL,
L
Linus Torvalds 已提交
255 256 257 258 259 260 261
	.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,
262
	.accept_ra_defrtr	= 1,
263
	.accept_ra_from_local	= 0,
264
	.accept_ra_min_hop_limit= 1,
265
	.accept_ra_pinfo	= 1,
266 267
#ifdef CONFIG_IPV6_ROUTER_PREF
	.accept_ra_rtr_pref	= 1,
268
	.rtr_probe_interval	= 60 * HZ,
269
#ifdef CONFIG_IPV6_ROUTE_INFO
270
	.accept_ra_rt_info_min_plen = 0,
271 272
	.accept_ra_rt_info_max_plen = 0,
#endif
273
#endif
274
	.proxy_ndp		= 0,
275
	.accept_source_route	= 0,	/* we do not accept RH0 by default. */
276
	.disable_ipv6		= 0,
277
	.accept_dad		= 1,
278
	.suppress_frag_ndisc	= 1,
279
	.accept_ra_mtu		= 1,
280 281 282
	.stable_secret		= {
		.initialized = false,
	},
283
	.use_oif_addrs_only	= 0,
284
	.ignore_routes_with_linkdown = 0,
285
	.keep_addr_on_down	= 0,
286
	.seg6_enabled		= 0,
287 288 289
#ifdef CONFIG_IPV6_SEG6_HMAC
	.seg6_require_hmac	= 0,
#endif
290
	.enhanced_dad           = 1,
291
	.addr_gen_mode		= IN6_ADDR_GEN_MODE_EUI64,
292
	.disable_policy		= 0,
293
	.rpl_seg_enabled	= 0,
L
Linus Torvalds 已提交
294 295
};

296 297
/* Check if link is ready: is it up and is a valid qdisc available */
static inline bool addrconf_link_ready(const struct net_device *dev)
298
{
299
	return netif_oper_up(dev) && !qdisc_tx_is_noop(dev);
300 301
}

302
static void addrconf_del_rs_timer(struct inet6_dev *idev)
L
Linus Torvalds 已提交
303
{
304 305 306 307
	if (del_timer(&idev->rs_timer))
		__in6_dev_put(idev);
}

308
static void addrconf_del_dad_work(struct inet6_ifaddr *ifp)
309
{
310
	if (cancel_delayed_work(&ifp->dad_work))
L
Linus Torvalds 已提交
311 312 313
		__in6_ifa_put(ifp);
}

314 315 316
static void addrconf_mod_rs_timer(struct inet6_dev *idev,
				  unsigned long when)
{
317
	if (!mod_timer(&idev->rs_timer, jiffies + when))
318 319
		in6_dev_hold(idev);
}
L
Linus Torvalds 已提交
320

321 322
static void addrconf_mod_dad_work(struct inet6_ifaddr *ifp,
				   unsigned long delay)
L
Linus Torvalds 已提交
323
{
324 325 326
	in6_ifa_hold(ifp);
	if (mod_delayed_work(addrconf_wq, &ifp->dad_work, delay))
		in6_ifa_put(ifp);
L
Linus Torvalds 已提交
327 328
}

329 330
static int snmp6_alloc_dev(struct inet6_dev *idev)
{
331 332
	int i;

W
WANG Cong 已提交
333 334
	idev->stats.ipv6 = alloc_percpu(struct ipstats_mib);
	if (!idev->stats.ipv6)
335
		goto err_ip;
336 337 338

	for_each_possible_cpu(i) {
		struct ipstats_mib *addrconf_stats;
W
WANG Cong 已提交
339
		addrconf_stats = per_cpu_ptr(idev->stats.ipv6, i);
340 341 342 343
		u64_stats_init(&addrconf_stats->syncp);
	}


344 345 346
	idev->stats.icmpv6dev = kzalloc(sizeof(struct icmpv6_mib_device),
					GFP_KERNEL);
	if (!idev->stats.icmpv6dev)
347
		goto err_icmp;
348 349 350
	idev->stats.icmpv6msgdev = kzalloc(sizeof(struct icmpv6msg_mib_device),
					   GFP_KERNEL);
	if (!idev->stats.icmpv6msgdev)
351
		goto err_icmpmsg;
352 353 354

	return 0;

355
err_icmpmsg:
356
	kfree(idev->stats.icmpv6dev);
357
err_icmp:
W
WANG Cong 已提交
358
	free_percpu(idev->stats.ipv6);
359
err_ip:
360
	return -ENOMEM;
361 362
}

363
static struct inet6_dev *ipv6_add_dev(struct net_device *dev)
L
Linus Torvalds 已提交
364 365
{
	struct inet6_dev *ndev;
366
	int err = -ENOMEM;
L
Linus Torvalds 已提交
367 368 369

	ASSERT_RTNL();

370
	if (dev->mtu < IPV6_MIN_MTU && dev != blackhole_netdev)
371
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
372

373
	ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL);
374
	if (!ndev)
375
		return ERR_PTR(err);
376 377 378

	rwlock_init(&ndev->lock);
	ndev->dev = dev;
379
	INIT_LIST_HEAD(&ndev->addr_list);
380
	timer_setup(&ndev->rs_timer, addrconf_rs_timer, 0);
381
	memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf));
382 383

	if (ndev->cnf.stable_secret.initialized)
384
		ndev->cnf.addr_gen_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
385

386 387
	ndev->cnf.mtu6 = dev->mtu;
	ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
388
	if (!ndev->nd_parms) {
389
		kfree(ndev);
390
		return ERR_PTR(err);
391
	}
392 393
	if (ndev->cnf.forwarding)
		dev_disable_lro(dev);
394 395
	/* We refer to the device */
	dev_hold(dev);
L
Linus Torvalds 已提交
396

397 398 399 400 401 402 403 404
	if (snmp6_alloc_dev(ndev) < 0) {
		netdev_dbg(dev, "%s: cannot allocate memory for statistics\n",
			   __func__);
		neigh_parms_release(&nd_tbl, ndev->nd_parms);
		dev_put(dev);
		kfree(ndev);
		return ERR_PTR(err);
	}
L
Linus Torvalds 已提交
405

406
	if (dev != blackhole_netdev) {
407 408 409 410 411
		if (snmp6_register_dev(ndev) < 0) {
			netdev_dbg(dev, "%s: cannot create /proc/net/dev_snmp6/%s\n",
				   __func__, dev->name);
			goto err_release;
		}
412
	}
413
	/* One reference from device. */
414
	refcount_set(&ndev->refcnt, 1);
L
Linus Torvalds 已提交
415

416 417 418
	if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
		ndev->cnf.accept_dad = -1;

A
Amerigo Wang 已提交
419
#if IS_ENABLED(CONFIG_IPV6_SIT)
420
	if (dev->type == ARPHRD_SIT && (dev->priv_flags & IFF_ISATAP)) {
421
		pr_info("%s: Disabled Multicast RS\n", dev->name);
422 423 424 425
		ndev->cnf.rtr_solicits = 0;
	}
#endif

426
	INIT_LIST_HEAD(&ndev->tempaddr_list);
J
Jiri Bohac 已提交
427
	ndev->desync_factor = U32_MAX;
428 429
	if ((dev->flags&IFF_LOOPBACK) ||
	    dev->type == ARPHRD_TUNNEL ||
430
	    dev->type == ARPHRD_TUNNEL6 ||
431 432
	    dev->type == ARPHRD_SIT ||
	    dev->type == ARPHRD_NONE) {
433
		ndev->cnf.use_tempaddr = -1;
434
	}
435

436
	ndev->token = in6addr_any;
L
Linus Torvalds 已提交
437

438
	if (netif_running(dev) && addrconf_link_ready(dev))
439 440
		ndev->if_flags |= IF_READY;

441 442
	ipv6_mc_init_dev(ndev);
	ndev->tstamp = jiffies;
443 444 445 446 447 448 449
	if (dev != blackhole_netdev) {
		err = addrconf_sysctl_register(ndev);
		if (err) {
			ipv6_mc_destroy_dev(ndev);
			snmp6_unregister_dev(ndev);
			goto err_release;
		}
450
	}
451
	/* protected by rtnl_lock */
452
	rcu_assign_pointer(dev->ip6_ptr, ndev);
453

454 455 456
	if (dev != blackhole_netdev) {
		/* Join interface-local all-node multicast group */
		ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allnodes);
457

458 459
		/* Join all-node multicast group */
		ipv6_dev_mc_inc(dev, &in6addr_linklocal_allnodes);
460

461 462 463 464
		/* Join all-router multicast group if forwarding is set */
		if (ndev->cnf.forwarding && (dev->flags & IFF_MULTICAST))
			ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
	}
L
Linus Torvalds 已提交
465
	return ndev;
466 467 468 469 470 471

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 已提交
472 473
}

474
static struct inet6_dev *ipv6_find_idev(struct net_device *dev)
L
Linus Torvalds 已提交
475 476 477 478 479
{
	struct inet6_dev *idev;

	ASSERT_RTNL();

S
Stephen Hemminger 已提交
480 481 482
	idev = __in6_dev_get(dev);
	if (!idev) {
		idev = ipv6_add_dev(dev);
483
		if (IS_ERR(idev))
484
			return idev;
L
Linus Torvalds 已提交
485
	}
486

L
Linus Torvalds 已提交
487 488 489 490 491
	if (dev->flags&IFF_UP)
		ipv6_mc_up(idev);
	return idev;
}

492 493 494 495
static int inet6_netconf_msgsize_devconf(int type)
{
	int size =  NLMSG_ALIGN(sizeof(struct netconfmsg))
		    + nla_total_size(4);	/* NETCONFA_IFINDEX */
496
	bool all = false;
497

498 499 500 501
	if (type == NETCONFA_ALL)
		all = true;

	if (all || type == NETCONFA_FORWARDING)
502
		size += nla_total_size(4);
503
#ifdef CONFIG_IPV6_MROUTE
504
	if (all || type == NETCONFA_MC_FORWARDING)
505
		size += nla_total_size(4);
506
#endif
507
	if (all || type == NETCONFA_PROXY_NEIGH)
508
		size += nla_total_size(4);
509

510
	if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
511 512
		size += nla_total_size(4);

513 514 515 516 517 518 519 520 521 522
	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;
523
	bool all = false;
524 525 526

	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
			flags);
527
	if (!nlh)
528 529
		return -EMSGSIZE;

530 531 532
	if (type == NETCONFA_ALL)
		all = true;

533 534 535 536 537 538
	ncm = nlmsg_data(nlh);
	ncm->ncm_family = AF_INET6;

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

539 540 541
	if (!devconf)
		goto out;

542
	if ((all || type == NETCONFA_FORWARDING) &&
543 544
	    nla_put_s32(skb, NETCONFA_FORWARDING, devconf->forwarding) < 0)
		goto nla_put_failure;
545
#ifdef CONFIG_IPV6_MROUTE
546
	if ((all || type == NETCONFA_MC_FORWARDING) &&
547
	    nla_put_s32(skb, NETCONFA_MC_FORWARDING,
E
Eric Dumazet 已提交
548
			atomic_read(&devconf->mc_forwarding)) < 0)
549
		goto nla_put_failure;
550
#endif
551
	if ((all || type == NETCONFA_PROXY_NEIGH) &&
552 553 554
	    nla_put_s32(skb, NETCONFA_PROXY_NEIGH, devconf->proxy_ndp) < 0)
		goto nla_put_failure;

555
	if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
556 557 558 559
	    nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
			devconf->ignore_routes_with_linkdown) < 0)
		goto nla_put_failure;

560
out:
561 562
	nlmsg_end(skb, nlh);
	return 0;
563 564 565 566 567 568

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

569 570
void inet6_netconf_notify_devconf(struct net *net, int event, int type,
				  int ifindex, struct ipv6_devconf *devconf)
571 572 573 574
{
	struct sk_buff *skb;
	int err = -ENOBUFS;

575
	skb = nlmsg_new(inet6_netconf_msgsize_devconf(type), GFP_KERNEL);
576
	if (!skb)
577 578 579
		goto errout;

	err = inet6_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
580
					 event, 0, type);
581 582 583 584 585 586
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
587
	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_NETCONF, NULL, GFP_KERNEL);
588 589
	return;
errout:
590
	rtnl_set_sk_err(net, RTNLGRP_IPV6_NETCONF, err);
591 592
}

593 594 595
static const struct nla_policy devconf_ipv6_policy[NETCONFA_MAX+1] = {
	[NETCONFA_IFINDEX]	= { .len = sizeof(int) },
	[NETCONFA_FORWARDING]	= { .len = sizeof(int) },
596
	[NETCONFA_PROXY_NEIGH]	= { .len = sizeof(int) },
597
	[NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN]	= { .len = sizeof(int) },
598 599
};

600 601 602 603 604 605 606 607 608 609 610 611 612
static int inet6_netconf_valid_get_req(struct sk_buff *skb,
				       const struct nlmsghdr *nlh,
				       struct nlattr **tb,
				       struct netlink_ext_ack *extack)
{
	int i, err;

	if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(struct netconfmsg))) {
		NL_SET_ERR_MSG_MOD(extack, "Invalid header for netconf get request");
		return -EINVAL;
	}

	if (!netlink_strict_get_check(skb))
613 614 615
		return nlmsg_parse_deprecated(nlh, sizeof(struct netconfmsg),
					      tb, NETCONFA_MAX,
					      devconf_ipv6_policy, extack);
616

617 618 619
	err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct netconfmsg),
					    tb, NETCONFA_MAX,
					    devconf_ipv6_policy, extack);
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
	if (err)
		return err;

	for (i = 0; i <= NETCONFA_MAX; i++) {
		if (!tb[i])
			continue;

		switch (i) {
		case NETCONFA_IFINDEX:
			break;
		default:
			NL_SET_ERR_MSG_MOD(extack, "Unsupported attribute in netconf get request");
			return -EINVAL;
		}
	}

	return 0;
}

639
static int inet6_netconf_get_devconf(struct sk_buff *in_skb,
640 641
				     struct nlmsghdr *nlh,
				     struct netlink_ext_ack *extack)
642 643 644
{
	struct net *net = sock_net(in_skb->sk);
	struct nlattr *tb[NETCONFA_MAX+1];
645 646
	struct inet6_dev *in6_dev = NULL;
	struct net_device *dev = NULL;
647 648 649 650 651
	struct sk_buff *skb;
	struct ipv6_devconf *devconf;
	int ifindex;
	int err;

652
	err = inet6_netconf_valid_get_req(in_skb, nlh, tb, extack);
653
	if (err < 0)
654
		return err;
655 656

	if (!tb[NETCONFA_IFINDEX])
657
		return -EINVAL;
658

659
	err = -EINVAL;
660 661 662 663 664 665 666 667 668
	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:
669
		dev = dev_get_by_index(net, ifindex);
670
		if (!dev)
671 672
			return -EINVAL;
		in6_dev = in6_dev_get(dev);
673
		if (!in6_dev)
674 675 676 677 678 679
			goto errout;
		devconf = &in6_dev->cnf;
		break;
	}

	err = -ENOBUFS;
680
	skb = nlmsg_new(inet6_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
681
	if (!skb)
682 683 684 685 686
		goto errout;

	err = inet6_netconf_fill_devconf(skb, ifindex, devconf,
					 NETLINK_CB(in_skb).portid,
					 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
687
					 NETCONFA_ALL);
688 689 690 691 692 693 694 695
	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:
696 697 698 699
	if (in6_dev)
		in6_dev_put(in6_dev);
	if (dev)
		dev_put(dev);
700 701 702
	return err;
}

703 704 705
static int inet6_netconf_dump_devconf(struct sk_buff *skb,
				      struct netlink_callback *cb)
{
706
	const struct nlmsghdr *nlh = cb->nlh;
707 708 709 710 711 712 713
	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;

714 715 716 717 718 719 720 721 722 723 724 725 726 727 728
	if (cb->strict_check) {
		struct netlink_ext_ack *extack = cb->extack;
		struct netconfmsg *ncm;

		if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ncm))) {
			NL_SET_ERR_MSG_MOD(extack, "Invalid header for netconf dump request");
			return -EINVAL;
		}

		if (nlmsg_attrlen(nlh, sizeof(*ncm))) {
			NL_SET_ERR_MSG_MOD(extack, "Invalid data after header in netconf dump request");
			return -EINVAL;
		}
	}

729 730 731 732 733 734 735
	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();
736 737
		cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^
			  net->dev_base_seq;
738 739 740 741 742 743 744 745 746 747
		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,
748
						       nlh->nlmsg_seq,
749 750
						       RTM_NEWNETCONF,
						       NLM_F_MULTI,
751
						       NETCONFA_ALL) < 0) {
752 753 754
				rcu_read_unlock();
				goto done;
			}
755
			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
756 757 758 759 760 761 762 763 764
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,
765
					       nlh->nlmsg_seq,
766
					       RTM_NEWNETCONF, NLM_F_MULTI,
767
					       NETCONFA_ALL) < 0)
768 769 770 771 772 773 774 775
			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,
776
					       nlh->nlmsg_seq,
777
					       RTM_NEWNETCONF, NLM_F_MULTI,
778
					       NETCONFA_ALL) < 0)
779 780 781 782 783 784 785 786 787 788 789
			goto done;
		else
			h++;
	}
done:
	cb->args[0] = h;
	cb->args[1] = idx;

	return skb->len;
}

L
Linus Torvalds 已提交
790 791 792 793 794
#ifdef CONFIG_SYSCTL
static void dev_forward_change(struct inet6_dev *idev)
{
	struct net_device *dev;
	struct inet6_ifaddr *ifa;
795
	LIST_HEAD(tmp_addr_list);
L
Linus Torvalds 已提交
796 797 798 799

	if (!idev)
		return;
	dev = idev->dev;
800 801
	if (idev->cnf.forwarding)
		dev_disable_lro(dev);
A
Amerigo Wang 已提交
802
	if (dev->flags & IFF_MULTICAST) {
803
		if (idev->cnf.forwarding) {
804
			ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
805 806 807
			ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allrouters);
			ipv6_dev_mc_inc(dev, &in6addr_sitelocal_allrouters);
		} else {
808
			ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters);
809 810 811
			ipv6_dev_mc_dec(dev, &in6addr_interfacelocal_allrouters);
			ipv6_dev_mc_dec(dev, &in6addr_sitelocal_allrouters);
		}
L
Linus Torvalds 已提交
812
	}
813

814
	read_lock_bh(&idev->lock);
815
	list_for_each_entry(ifa, &idev->addr_list, if_list) {
M
Michal Wrobel 已提交
816 817
		if (ifa->flags&IFA_F_TENTATIVE)
			continue;
818 819 820 821 822 823 824 825
		list_add_tail(&ifa->if_list_aux, &tmp_addr_list);
	}
	read_unlock_bh(&idev->lock);

	while (!list_empty(&tmp_addr_list)) {
		ifa = list_first_entry(&tmp_addr_list,
				       struct inet6_ifaddr, if_list_aux);
		list_del(&ifa->if_list_aux);
L
Linus Torvalds 已提交
826 827 828 829 830
		if (idev->cnf.forwarding)
			addrconf_join_anycast(ifa);
		else
			addrconf_leave_anycast(ifa);
	}
831

832 833
	inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
				     NETCONFA_FORWARDING,
834
				     dev->ifindex, &idev->cnf);
L
Linus Torvalds 已提交
835 836 837
}


838
static void addrconf_forward_change(struct net *net, __s32 newf)
L
Linus Torvalds 已提交
839 840 841 842
{
	struct net_device *dev;
	struct inet6_dev *idev;

843
	for_each_netdev(net, dev) {
L
Linus Torvalds 已提交
844 845
		idev = __in6_dev_get(dev);
		if (idev) {
846 847
			int changed = (!idev->cnf.forwarding) ^ (!newf);
			idev->cnf.forwarding = newf;
L
Linus Torvalds 已提交
848 849 850 851 852
			if (changed)
				dev_forward_change(idev);
		}
	}
}
853

854
static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int newf)
855
{
856
	struct net *net;
857 858 859 860
	int old;

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

	net = (struct net *)table->extra2;
863 864
	old = *p;
	*p = newf;
865

866
	if (p == &net->ipv6.devconf_dflt->forwarding) {
867
		if ((!newf) ^ (!old))
868 869
			inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
						     NETCONFA_FORWARDING,
870 871
						     NETCONFA_IFINDEX_DEFAULT,
						     net->ipv6.devconf_dflt);
872 873
		rtnl_unlock();
		return 0;
E
Eric W. Biederman 已提交
874
	}
875

876
	if (p == &net->ipv6.devconf_all->forwarding) {
877 878
		int old_dflt = net->ipv6.devconf_dflt->forwarding;

879
		net->ipv6.devconf_dflt->forwarding = newf;
880
		if ((!newf) ^ (!old_dflt))
881 882
			inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
						     NETCONFA_FORWARDING,
883 884 885
						     NETCONFA_IFINDEX_DEFAULT,
						     net->ipv6.devconf_dflt);

886
		addrconf_forward_change(net, newf);
887
		if ((!newf) ^ (!old))
888 889
			inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
						     NETCONFA_FORWARDING,
890 891
						     NETCONFA_IFINDEX_ALL,
						     net->ipv6.devconf_all);
892
	} else if ((!newf) ^ (!old))
893
		dev_forward_change((struct inet6_dev *)table->extra1);
894
	rtnl_unlock();
895

896
	if (newf)
897
		rt6_purge_dflt_routers(net);
898
	return 1;
899
}
900 901 902 903 904 905 906 907 908 909 910 911 912 913

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

	for_each_netdev(net, dev) {
		idev = __in6_dev_get(dev);
		if (idev) {
			int changed = (!idev->cnf.ignore_routes_with_linkdown) ^ (!newf);

			idev->cnf.ignore_routes_with_linkdown = newf;
			if (changed)
				inet6_netconf_notify_devconf(dev_net(dev),
914
							     RTM_NEWNETCONF,
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936
							     NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
							     dev->ifindex,
							     &idev->cnf);
		}
	}
}

static int addrconf_fixup_linkdown(struct ctl_table *table, int *p, int newf)
{
	struct net *net;
	int old;

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

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

	if (p == &net->ipv6.devconf_dflt->ignore_routes_with_linkdown) {
		if ((!newf) ^ (!old))
			inet6_netconf_notify_devconf(net,
937
						     RTM_NEWNETCONF,
938 939 940 941 942 943 944 945 946 947 948 949
						     NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
						     NETCONFA_IFINDEX_DEFAULT,
						     net->ipv6.devconf_dflt);
		rtnl_unlock();
		return 0;
	}

	if (p == &net->ipv6.devconf_all->ignore_routes_with_linkdown) {
		net->ipv6.devconf_dflt->ignore_routes_with_linkdown = newf;
		addrconf_linkdown_change(net, newf);
		if ((!newf) ^ (!old))
			inet6_netconf_notify_devconf(net,
950
						     RTM_NEWNETCONF,
951 952 953 954 955 956 957 958 959
						     NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
						     NETCONFA_IFINDEX_ALL,
						     net->ipv6.devconf_all);
	}
	rtnl_unlock();

	return 1;
}

L
Linus Torvalds 已提交
960 961
#endif

962
/* Nobody refers to this ifaddr, destroy it */
L
Linus Torvalds 已提交
963 964
void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
{
965
	WARN_ON(!hlist_unhashed(&ifp->addr_lst));
966

L
Linus Torvalds 已提交
967
#ifdef NET_REFCNT_DEBUG
968
	pr_debug("%s\n", __func__);
L
Linus Torvalds 已提交
969 970 971 972
#endif

	in6_dev_put(ifp->idev);

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

977
	if (ifp->state != INET6_IFADDR_STATE_DEAD) {
978
		pr_warn("Freeing alive inet6 address %p\n", ifp);
L
Linus Torvalds 已提交
979 980 981
		return;
	}

982
	kfree_rcu(ifp, rcu);
L
Linus Torvalds 已提交
983 984
}

B
Brian Haley 已提交
985 986 987
static void
ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp)
{
988
	struct list_head *p;
989
	int ifp_scope = ipv6_addr_src_scope(&ifp->addr);
B
Brian Haley 已提交
990 991 992 993 994

	/*
	 * Each device address list is sorted in order of scope -
	 * global before linklocal.
	 */
995 996 997
	list_for_each(p, &idev->addr_list) {
		struct inet6_ifaddr *ifa
			= list_entry(p, struct inet6_ifaddr, if_list);
998
		if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr))
B
Brian Haley 已提交
999 1000 1001
			break;
	}

1002
	list_add_tail_rcu(&ifp->if_list, p);
B
Brian Haley 已提交
1003 1004
}

1005
static u32 inet6_addr_hash(const struct net *net, const struct in6_addr *addr)
1006
{
1007 1008 1009
	u32 val = ipv6_addr_hash(addr) ^ net_hash_mix(net);

	return hash_32(val, IN6_ADDR_HSIZE_SHIFT);
1010 1011
}

1012
static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
1013
			       struct net_device *dev, unsigned int hash)
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
{
	struct inet6_ifaddr *ifp;

	hlist_for_each_entry(ifp, &inet6_addr_lst[hash], addr_lst) {
		if (!net_eq(dev_net(ifp->idev->dev), net))
			continue;
		if (ipv6_addr_equal(&ifp->addr, addr)) {
			if (!dev || ifp->idev->dev == dev)
				return true;
		}
	}
	return false;
}

1028 1029
static int ipv6_add_addr_hash(struct net_device *dev, struct inet6_ifaddr *ifa)
{
1030
	unsigned int hash = inet6_addr_hash(dev_net(dev), &ifa->addr);
1031 1032 1033 1034 1035
	int err = 0;

	spin_lock(&addrconf_hash_lock);

	/* Ignore adding duplicate addresses on an interface */
1036
	if (ipv6_chk_same_addr(dev_net(dev), &ifa->addr, dev, hash)) {
1037
		netdev_dbg(dev, "ipv6_add_addr: already assigned\n");
1038
		err = -EEXIST;
1039 1040
	} else {
		hlist_add_head_rcu(&ifa->addr_lst, &inet6_addr_lst[hash]);
1041 1042 1043 1044 1045 1046 1047
	}

	spin_unlock(&addrconf_hash_lock);

	return err;
}

L
Linus Torvalds 已提交
1048 1049 1050
/* On success it returns ifp with increased reference count */

static struct inet6_ifaddr *
1051
ipv6_add_addr(struct inet6_dev *idev, struct ifa6_config *cfg,
1052
	      bool can_block, struct netlink_ext_ack *extack)
L
Linus Torvalds 已提交
1053
{
1054
	gfp_t gfp_flags = can_block ? GFP_KERNEL : GFP_ATOMIC;
1055
	int addr_type = ipv6_addr_type(cfg->pfx);
1056
	struct net *net = dev_net(idev->dev);
L
Linus Torvalds 已提交
1057
	struct inet6_ifaddr *ifa = NULL;
1058
	struct fib6_info *f6i = NULL;
L
Linus Torvalds 已提交
1059
	int err = 0;
1060 1061

	if (addr_type == IPV6_ADDR_ANY ||
1062 1063
	    (addr_type & IPV6_ADDR_MULTICAST &&
	     !(cfg->ifa_flags & IFA_F_MCAUTOJOIN)) ||
1064
	    (!(idev->dev->flags & IFF_LOOPBACK) &&
1065
	     !netif_is_l3_master(idev->dev) &&
1066 1067
	     addr_type & IPV6_ADDR_LOOPBACK))
		return ERR_PTR(-EADDRNOTAVAIL);
L
Linus Torvalds 已提交
1068 1069 1070

	if (idev->dead) {
		err = -ENODEV;			/*XXX*/
1071
		goto out;
L
Linus Torvalds 已提交
1072 1073
	}

1074
	if (idev->cnf.disable_ipv6) {
1075
		err = -EACCES;
1076
		goto out;
1077 1078
	}

1079 1080 1081 1082 1083
	/* validator notifier needs to be blocking;
	 * do not call in atomic context
	 */
	if (can_block) {
		struct in6_validator_info i6vi = {
1084
			.i6vi_addr = *cfg->pfx,
1085
			.i6vi_dev = idev,
1086
			.extack = extack,
1087 1088 1089 1090 1091 1092 1093
		};

		err = inet6addr_validator_notifier_call_chain(NETDEV_UP, &i6vi);
		err = notifier_to_errno(err);
		if (err < 0)
			goto out;
	}
L
Linus Torvalds 已提交
1094

1095
	ifa = kzalloc(sizeof(*ifa), gfp_flags);
1096
	if (!ifa) {
L
Linus Torvalds 已提交
1097 1098 1099 1100
		err = -ENOBUFS;
		goto out;
	}

1101
	f6i = addrconf_f6i_alloc(net, idev, cfg->pfx, false, gfp_flags);
1102 1103 1104
	if (IS_ERR(f6i)) {
		err = PTR_ERR(f6i);
		f6i = NULL;
L
Linus Torvalds 已提交
1105 1106 1107
		goto out;
	}

1108 1109
	neigh_parms_data_state_setall(idev->nd_parms);

1110 1111 1112
	ifa->addr = *cfg->pfx;
	if (cfg->peer_pfx)
		ifa->peer_addr = *cfg->peer_pfx;
L
Linus Torvalds 已提交
1113 1114

	spin_lock_init(&ifa->lock);
1115
	INIT_DELAYED_WORK(&ifa->dad_work, addrconf_dad_work);
1116
	INIT_HLIST_NODE(&ifa->addr_lst);
1117 1118
	ifa->scope = cfg->scope;
	ifa->prefix_len = cfg->plen;
1119
	ifa->rt_priority = cfg->rt_priority;
1120
	ifa->flags = cfg->ifa_flags;
1121
	/* No need to add the TENTATIVE flag for addresses with NODAD */
1122
	if (!(cfg->ifa_flags & IFA_F_NODAD))
1123
		ifa->flags |= IFA_F_TENTATIVE;
1124 1125
	ifa->valid_lft = cfg->valid_lft;
	ifa->prefered_lft = cfg->preferred_lft;
L
Linus Torvalds 已提交
1126
	ifa->cstamp = ifa->tstamp = jiffies;
1127
	ifa->tokenized = false;
L
Linus Torvalds 已提交
1128

1129
	ifa->rt = f6i;
1130

L
Linus Torvalds 已提交
1131
	ifa->idev = idev;
1132 1133
	in6_dev_hold(idev);

L
Linus Torvalds 已提交
1134
	/* For caller */
1135
	refcount_set(&ifa->refcnt, 1);
L
Linus Torvalds 已提交
1136

1137
	rcu_read_lock_bh();
L
Linus Torvalds 已提交
1138

1139 1140 1141 1142 1143
	err = ipv6_add_addr_hash(idev->dev, ifa);
	if (err < 0) {
		rcu_read_unlock_bh();
		goto out;
	}
L
Linus Torvalds 已提交
1144 1145

	write_lock(&idev->lock);
1146

L
Linus Torvalds 已提交
1147
	/* Add to inet6_dev unicast addr list. */
B
Brian Haley 已提交
1148
	ipv6_link_dev_addr(idev, ifa);
L
Linus Torvalds 已提交
1149 1150

	if (ifa->flags&IFA_F_TEMPORARY) {
1151
		list_add(&ifa->tmp_list, &idev->tempaddr_list);
L
Linus Torvalds 已提交
1152 1153 1154 1155 1156
		in6_ifa_hold(ifa);
	}

	in6_ifa_hold(ifa);
	write_unlock(&idev->lock);
1157

1158
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
1159

1160 1161 1162
	inet6addr_notifier_call_chain(NETDEV_UP, ifa);
out:
	if (unlikely(err < 0)) {
1163
		fib6_info_release(f6i);
1164

1165 1166 1167 1168 1169
		if (ifa) {
			if (ifa->idev)
				in6_dev_put(ifa->idev);
			kfree(ifa);
		}
L
Linus Torvalds 已提交
1170 1171 1172 1173 1174 1175
		ifa = ERR_PTR(err);
	}

	return ifa;
}

1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
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;
1213 1214
		if (ifa->prefix_len != ifp->prefix_len ||
		    !ipv6_prefix_equal(&ifa->addr, &ifp->addr,
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
				       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
1239 1240
cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long expires,
		     bool del_rt, bool del_peer)
1241
{
1242
	struct fib6_info *f6i;
1243

1244 1245
	f6i = addrconf_get_prefix_route(del_peer ? &ifp->peer_addr : &ifp->addr,
					ifp->prefix_len,
1246
					ifp->idev->dev, 0, RTF_DEFAULT, true);
1247
	if (f6i) {
1248
		if (del_rt)
1249
			ip6_del_rt(dev_net(ifp->idev->dev), f6i, false);
1250
		else {
1251 1252 1253
			if (!(f6i->fib6_flags & RTF_EXPIRES))
				fib6_set_expires(f6i, expires);
			fib6_info_release(f6i);
1254 1255 1256 1257 1258
		}
	}
}


L
Linus Torvalds 已提交
1259 1260 1261 1262
/* This function wants to get referenced ifp and releases it before return */

static void ipv6_del_addr(struct inet6_ifaddr *ifp)
{
1263
	int state;
1264 1265
	enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_NOP;
	unsigned long expires;
L
Linus Torvalds 已提交
1266

1267 1268
	ASSERT_RTNL();

1269
	spin_lock_bh(&ifp->lock);
1270
	state = ifp->state;
1271
	ifp->state = INET6_IFADDR_STATE_DEAD;
1272
	spin_unlock_bh(&ifp->lock);
1273 1274 1275

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

1277 1278 1279
	spin_lock_bh(&addrconf_hash_lock);
	hlist_del_init_rcu(&ifp->addr_lst);
	spin_unlock_bh(&addrconf_hash_lock);
L
Linus Torvalds 已提交
1280

1281
	write_lock_bh(&ifp->idev->lock);
1282

L
Linus Torvalds 已提交
1283
	if (ifp->flags&IFA_F_TEMPORARY) {
1284 1285 1286 1287
		list_del(&ifp->tmp_list);
		if (ifp->ifpub) {
			in6_ifa_put(ifp->ifpub);
			ifp->ifpub = NULL;
L
Linus Torvalds 已提交
1288
		}
1289
		__in6_ifa_put(ifp);
L
Linus Torvalds 已提交
1290 1291
	}

1292 1293
	if (ifp->flags & IFA_F_PERMANENT && !(ifp->flags & IFA_F_NOPREFIXROUTE))
		action = check_cleanup_prefix_route(ifp, &expires);
1294

1295
	list_del_rcu(&ifp->if_list);
1296 1297 1298
	__in6_ifa_put(ifp);

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

1300
	addrconf_del_dad_work(ifp);
1301

L
Linus Torvalds 已提交
1302 1303
	ipv6_ifa_notify(RTM_DELADDR, ifp);

1304
	inet6addr_notifier_call_chain(NETDEV_DOWN, ifp);
L
Linus Torvalds 已提交
1305

1306 1307
	if (action != CLEANUP_PREFIX_RT_NOP) {
		cleanup_prefix_route(ifp, expires,
1308
			action == CLEANUP_PREFIX_RT_DEL, false);
L
Linus Torvalds 已提交
1309 1310
	}

1311 1312
	/* clean up prefsrc entries */
	rt6_remove_prefsrc(ifp);
1313
out:
L
Linus Torvalds 已提交
1314 1315 1316
	in6_ifa_put(ifp);
}

1317
static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, bool block)
L
Linus Torvalds 已提交
1318 1319
{
	struct inet6_dev *idev = ifp->idev;
1320
	unsigned long tmp_tstamp, age;
1321
	unsigned long regen_advance;
1322
	unsigned long now = jiffies;
1323
	s32 cnf_temp_preferred_lft;
1324 1325 1326 1327 1328
	struct inet6_ifaddr *ift;
	struct ifa6_config cfg;
	long max_desync_factor;
	struct in6_addr addr;
	int ret = 0;
L
Linus Torvalds 已提交
1329

1330
	write_lock_bh(&idev->lock);
1331

L
Linus Torvalds 已提交
1332 1333 1334
retry:
	in6_dev_hold(idev);
	if (idev->cnf.use_tempaddr <= 0) {
1335
		write_unlock_bh(&idev->lock);
1336
		pr_info("%s: use_tempaddr is disabled\n", __func__);
L
Linus Torvalds 已提交
1337 1338 1339 1340 1341 1342 1343 1344
		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);
1345
		write_unlock_bh(&idev->lock);
1346 1347
		pr_warn("%s: regeneration time exceeded - disabled temporary address support\n",
			__func__);
L
Linus Torvalds 已提交
1348 1349 1350 1351 1352 1353
		in6_dev_put(idev);
		ret = -1;
		goto out;
	}
	in6_ifa_hold(ifp);
	memcpy(addr.s6_addr, ifp->addr.s6_addr, 8);
1354 1355
	ipv6_gen_rnd_iid(&addr);

1356
	age = (now - ifp->tstamp) / HZ;
J
Jiri Bohac 已提交
1357 1358 1359

	regen_advance = idev->cnf.regen_max_retry *
			idev->cnf.dad_transmits *
1360
			max(NEIGH_VAR(idev->nd_parms, RETRANS_TIME), HZ/100) / HZ;
J
Jiri Bohac 已提交
1361 1362 1363 1364

	/* recalculate max_desync_factor each time and update
	 * idev->desync_factor if it's larger
	 */
1365
	cnf_temp_preferred_lft = READ_ONCE(idev->cnf.temp_prefered_lft);
J
Jiri Bohac 已提交
1366 1367
	max_desync_factor = min_t(__u32,
				  idev->cnf.max_desync_factor,
1368
				  cnf_temp_preferred_lft - regen_advance);
J
Jiri Bohac 已提交
1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379

	if (unlikely(idev->desync_factor > max_desync_factor)) {
		if (max_desync_factor > 0) {
			get_random_bytes(&idev->desync_factor,
					 sizeof(idev->desync_factor));
			idev->desync_factor %= max_desync_factor;
		} else {
			idev->desync_factor = 0;
		}
	}

1380
	memset(&cfg, 0, sizeof(cfg));
1381
	cfg.valid_lft = min_t(__u32, ifp->valid_lft,
1382
			      idev->cnf.temp_valid_lft + age);
1383 1384 1385 1386
	cfg.preferred_lft = cnf_temp_preferred_lft + age - idev->desync_factor;
	cfg.preferred_lft = min_t(__u32, ifp->prefered_lft, cfg.preferred_lft);

	cfg.plen = ifp->prefix_len;
L
Linus Torvalds 已提交
1387 1388 1389
	tmp_tstamp = ifp->tstamp;
	spin_unlock_bh(&ifp->lock);

1390
	write_unlock_bh(&idev->lock);
1391

1392 1393 1394 1395
	/* 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.
1396 1397
	 * Use age calculation as in addrconf_verify to avoid unnecessary
	 * temporary addresses being generated.
1398
	 */
1399
	age = (now - tmp_tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
1400
	if (cfg.preferred_lft <= regen_advance + age) {
1401 1402 1403 1404 1405 1406
		in6_ifa_put(ifp);
		in6_dev_put(idev);
		ret = -1;
		goto out;
	}

1407
	cfg.ifa_flags = IFA_F_TEMPORARY;
1408 1409
	/* set in addrconf_prefix_rcv() */
	if (ifp->flags & IFA_F_OPTIMISTIC)
1410
		cfg.ifa_flags |= IFA_F_OPTIMISTIC;
1411

1412 1413
	cfg.pfx = &addr;
	cfg.scope = ipv6_addr_scope(cfg.pfx);
1414

1415
	ift = ipv6_add_addr(idev, &cfg, block, NULL);
1416
	if (IS_ERR(ift)) {
L
Linus Torvalds 已提交
1417 1418
		in6_ifa_put(ifp);
		in6_dev_put(idev);
1419
		pr_info("%s: retry temporary address regeneration\n", __func__);
1420
		write_lock_bh(&idev->lock);
L
Linus Torvalds 已提交
1421 1422 1423 1424 1425
		goto retry;
	}

	spin_lock_bh(&ift->lock);
	ift->ifpub = ifp;
1426
	ift->cstamp = now;
L
Linus Torvalds 已提交
1427 1428 1429
	ift->tstamp = tmp_tstamp;
	spin_unlock_bh(&ift->lock);

1430
	addrconf_dad_start(ift);
L
Linus Torvalds 已提交
1431 1432 1433 1434 1435 1436 1437
	in6_ifa_put(ift);
	in6_dev_put(idev);
out:
	return ret;
}

/*
1438
 *	Choose an appropriate source address (RFC3484)
L
Linus Torvalds 已提交
1439
 */
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
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,
1453 1454 1455
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
	IPV6_SADDR_RULE_NOT_OPTIMISTIC,
#endif
1456 1457 1458
	IPV6_SADDR_RULE_MAX
};

1459
struct ipv6_saddr_score {
1460 1461 1462 1463 1464 1465
	int			rule;
	int			addr_type;
	struct inet6_ifaddr	*ifa;
	DECLARE_BITMAP(scorebits, IPV6_SADDR_RULE_MAX);
	int			scopedist;
	int			matchlen;
1466 1467
};

1468
struct ipv6_saddr_dst {
1469
	const struct in6_addr *addr;
1470 1471 1472
	int ifindex;
	int scope;
	int label;
1473
	unsigned int prefs;
1474
};
1475

D
Dave Jones 已提交
1476
static inline int ipv6_saddr_preferred(int type)
L
Linus Torvalds 已提交
1477
{
U
Ulrich Weber 已提交
1478
	if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4|IPV6_ADDR_LOOPBACK))
1479 1480
		return 1;
	return 0;
L
Linus Torvalds 已提交
1481 1482
}

1483 1484
static bool ipv6_use_optimistic_addr(struct net *net,
				     struct inet6_dev *idev)
1485 1486
{
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1487 1488 1489 1490 1491 1492 1493 1494
	if (!idev)
		return false;
	if (!net->ipv6.devconf_all->optimistic_dad && !idev->cnf.optimistic_dad)
		return false;
	if (!net->ipv6.devconf_all->use_optimistic && !idev->cnf.use_optimistic)
		return false;

	return true;
1495 1496 1497 1498 1499
#else
	return false;
#endif
}

1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
static bool ipv6_allow_optimistic_dad(struct net *net,
				      struct inet6_dev *idev)
{
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
	if (!idev)
		return false;
	if (!net->ipv6.devconf_all->optimistic_dad && !idev->cnf.optimistic_dad)
		return false;

	return true;
#else
	return false;
#endif
}

1515 1516
static int ipv6_get_saddr_eval(struct net *net,
			       struct ipv6_saddr_score *score,
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
			       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
1556
		 *  B-15 |    \        if scope is enough for destination.
1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574
		 *       |             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:
1575
	    {
1576
		/* Rule 3: Avoid deprecated and optimistic addresses */
1577 1578
		u8 avoid = IFA_F_DEPRECATED;

1579
		if (!ipv6_use_optimistic_addr(net, score->ifa->idev))
1580
			avoid |= IFA_F_OPTIMISTIC;
1581
		ret = ipv6_saddr_preferred(score->addr_type) ||
1582
		      !(score->ifa->flags & avoid);
1583
		break;
1584
	    }
1585 1586
#ifdef CONFIG_IPV6_MIP6
	case IPV6_SADDR_RULE_HOA:
1587
	    {
1588
		/* Rule 4: Prefer home address */
1589 1590
		int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA);
		ret = !(score->ifa->flags & IFA_F_HOMEADDRESS) ^ prefhome;
1591
		break;
1592
	    }
1593 1594 1595 1596 1597 1598 1599 1600
#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 */
1601 1602
		ret = ipv6_addr_label(net,
				      &score->ifa->addr, score->addr_type,
1603 1604 1605
				      score->ifa->idev->dev->ifindex) == dst->label;
		break;
	case IPV6_SADDR_RULE_PRIVACY:
1606
	    {
1607
		/* Rule 7: Prefer public address
L
Lucas De Marchi 已提交
1608
		 * Note: prefer temporary address if use_tempaddr >= 2
1609
		 */
1610 1611 1612 1613
		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;
1614
		break;
1615
	    }
1616 1617 1618 1619 1620 1621 1622 1623 1624
	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 */
1625 1626 1627 1628
		ret = ipv6_addr_diff(&score->ifa->addr, dst->addr);
		if (ret > score->ifa->prefix_len)
			ret = score->ifa->prefix_len;
		score->matchlen = ret;
1629
		break;
1630 1631 1632 1633 1634 1635 1636 1637
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
	case IPV6_SADDR_RULE_NOT_OPTIMISTIC:
		/* Optimistic addresses still have lower precedence than other
		 * preferred addresses.
		 */
		ret = !(score->ifa->flags & IFA_F_OPTIMISTIC);
		break;
#endif
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648
	default:
		ret = 0;
	}

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

1649 1650 1651 1652 1653
static int __ipv6_dev_get_saddr(struct net *net,
				struct ipv6_saddr_dst *dst,
				struct inet6_dev *idev,
				struct ipv6_saddr_score *scores,
				int hiscore_idx)
1654
{
1655
	struct ipv6_saddr_score *score = &scores[1 - hiscore_idx], *hiscore = &scores[hiscore_idx];
1656

1657
	list_for_each_entry_rcu(score->ifa, &idev->addr_list, if_list) {
1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707
		int i;

		/*
		 * - Tentative Address (RFC2462 section 5.4)
		 *  - A tentative address is not considered
		 *    "assigned to an interface" in the traditional
		 *    sense, unless it is also flagged as optimistic.
		 * - Candidate Source Address (section 4)
		 *  - In any case, anycast addresses, multicast
		 *    addresses, and the unspecified address MUST
		 *    NOT be included in a candidate set.
		 */
		if ((score->ifa->flags & IFA_F_TENTATIVE) &&
		    (!(score->ifa->flags & IFA_F_OPTIMISTIC)))
			continue;

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

		if (unlikely(score->addr_type == IPV6_ADDR_ANY ||
			     score->addr_type & IPV6_ADDR_MULTICAST)) {
			net_dbg_ratelimited("ADDRCONF: unspecified / multicast address assigned as unicast address on %s",
					    idev->dev->name);
			continue;
		}

		score->rule = -1;
		bitmap_zero(score->scorebits, IPV6_SADDR_RULE_MAX);

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

			minihiscore = ipv6_get_saddr_eval(net, hiscore, dst, i);
			miniscore = ipv6_get_saddr_eval(net, score, dst, i);

			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 out;
				}
				break;
			} else if (minihiscore < miniscore) {
				swap(hiscore, score);
1708
				hiscore_idx = 1 - hiscore_idx;
1709 1710 1711 1712 1713 1714 1715 1716 1717

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

				break;
			}
		}
	}
out:
1718
	return hiscore_idx;
1719 1720
}

1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742
static int ipv6_get_saddr_master(struct net *net,
				 const struct net_device *dst_dev,
				 const struct net_device *master,
				 struct ipv6_saddr_dst *dst,
				 struct ipv6_saddr_score *scores,
				 int hiscore_idx)
{
	struct inet6_dev *idev;

	idev = __in6_dev_get(dst_dev);
	if (idev)
		hiscore_idx = __ipv6_dev_get_saddr(net, dst, idev,
						   scores, hiscore_idx);

	idev = __in6_dev_get(master);
	if (idev)
		hiscore_idx = __ipv6_dev_get_saddr(net, dst, idev,
						   scores, hiscore_idx);

	return hiscore_idx;
}

1743
int ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev,
1744
		       const struct in6_addr *daddr, unsigned int prefs,
1745
		       struct in6_addr *saddr)
L
Linus Torvalds 已提交
1746
{
1747
	struct ipv6_saddr_score scores[2], *hiscore;
1748
	struct ipv6_saddr_dst dst;
1749
	struct inet6_dev *idev;
1750
	struct net_device *dev;
1751
	int dst_type;
1752
	bool use_oif_addr = false;
1753
	int hiscore_idx = 0;
1754
	int ret = 0;
L
Linus Torvalds 已提交
1755

1756 1757 1758 1759
	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);
1760
	dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex);
1761
	dst.prefs = prefs;
1762

1763 1764
	scores[hiscore_idx].rule = -1;
	scores[hiscore_idx].ifa = NULL;
L
Linus Torvalds 已提交
1765

1766
	rcu_read_lock();
L
Linus Torvalds 已提交
1767

1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
	/* Candidate Source Address (section 4)
	 *  - 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.)
1779 1780 1781 1782
	 *  - "It is RECOMMENDED that the candidate source addresses
	 *    be the set of unicast addresses assigned to the
	 *    interface that will be used to send to the destination
	 *    (the 'outgoing' interface)." (RFC 6724)
1783 1784
	 */
	if (dst_dev) {
1785
		idev = __in6_dev_get(dst_dev);
1786
		if ((dst_type & IPV6_ADDR_MULTICAST) ||
1787 1788
		    dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL ||
		    (idev && idev->cnf.use_oif_addrs_only)) {
1789 1790 1791
			use_oif_addr = true;
		}
	}
1792

1793
	if (use_oif_addr) {
1794
		if (idev)
1795
			hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx);
1796
	} else {
1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815
		const struct net_device *master;
		int master_idx = 0;

		/* if dst_dev exists and is enslaved to an L3 device, then
		 * prefer addresses from dst_dev and then the master over
		 * any other enslaved devices in the L3 domain.
		 */
		master = l3mdev_master_dev_rcu(dst_dev);
		if (master) {
			master_idx = master->ifindex;

			hiscore_idx = ipv6_get_saddr_master(net, dst_dev,
							    master, &dst,
							    scores, hiscore_idx);

			if (scores[hiscore_idx].ifa)
				goto out;
		}

1816
		for_each_netdev_rcu(net, dev) {
1817 1818 1819 1820 1821
			/* only consider addresses on devices in the
			 * same L3 domain
			 */
			if (l3mdev_master_ifindex_rcu(dev) != master_idx)
				continue;
1822 1823
			idev = __in6_dev_get(dev);
			if (!idev)
1824
				continue;
1825
			hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx);
L
Linus Torvalds 已提交
1826 1827
		}
	}
1828 1829

out:
1830
	hiscore = &scores[hiscore_idx];
1831
	if (!hiscore->ifa)
1832 1833 1834
		ret = -EADDRNOTAVAIL;
	else
		*saddr = hiscore->ifa->addr;
1835

1836 1837
	rcu_read_unlock();
	return ret;
L
Linus Torvalds 已提交
1838
}
1839
EXPORT_SYMBOL(ipv6_dev_get_saddr);
L
Linus Torvalds 已提交
1840

1841
int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr,
1842
		      u32 banned_flags)
1843 1844 1845 1846
{
	struct inet6_ifaddr *ifp;
	int err = -EADDRNOTAVAIL;

1847 1848 1849
	list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
		if (ifp->scope > IFA_LINK)
			break;
1850 1851 1852 1853 1854 1855 1856 1857 1858 1859
		if (ifp->scope == IFA_LINK &&
		    !(ifp->flags & banned_flags)) {
			*addr = ifp->addr;
			err = 0;
			break;
		}
	}
	return err;
}

1860
int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
1861
		    u32 banned_flags)
L
Linus Torvalds 已提交
1862 1863 1864 1865
{
	struct inet6_dev *idev;
	int err = -EADDRNOTAVAIL;

1866
	rcu_read_lock();
S
Stephen Hemminger 已提交
1867 1868
	idev = __in6_dev_get(dev);
	if (idev) {
L
Linus Torvalds 已提交
1869
		read_lock_bh(&idev->lock);
1870
		err = __ipv6_get_lladdr(idev, addr, banned_flags);
L
Linus Torvalds 已提交
1871 1872
		read_unlock_bh(&idev->lock);
	}
1873
	rcu_read_unlock();
L
Linus Torvalds 已提交
1874 1875 1876
	return err;
}

1877
static int ipv6_count_addresses(const struct inet6_dev *idev)
L
Linus Torvalds 已提交
1878
{
1879
	const struct inet6_ifaddr *ifp;
L
Linus Torvalds 已提交
1880 1881
	int cnt = 0;

1882 1883
	rcu_read_lock();
	list_for_each_entry_rcu(ifp, &idev->addr_list, if_list)
L
Linus Torvalds 已提交
1884
		cnt++;
1885
	rcu_read_unlock();
L
Linus Torvalds 已提交
1886 1887 1888
	return cnt;
}

1889
int ipv6_chk_addr(struct net *net, const struct in6_addr *addr,
1890
		  const struct net_device *dev, int strict)
1891
{
1892 1893
	return ipv6_chk_addr_and_flags(net, addr, dev, !dev,
				       strict, IFA_F_TENTATIVE);
1894 1895 1896
}
EXPORT_SYMBOL(ipv6_chk_addr);

1897 1898 1899 1900 1901 1902 1903 1904 1905
/* device argument is used to find the L3 domain of interest. If
 * skip_dev_check is set, then the ifp device is not checked against
 * the passed in dev argument. So the 2 cases for addresses checks are:
 *   1. does the address exist in the L3 domain that dev is part of
 *      (skip_dev_check = true), or
 *
 *   2. does the address exist on the specific device
 *      (skip_dev_check = false)
 */
X
Xin Long 已提交
1906 1907 1908 1909
static struct net_device *
__ipv6_chk_addr_and_flags(struct net *net, const struct in6_addr *addr,
			  const struct net_device *dev, bool skip_dev_check,
			  int strict, u32 banned_flags)
L
Linus Torvalds 已提交
1910
{
1911
	unsigned int hash = inet6_addr_hash(net, addr);
X
Xin Long 已提交
1912
	struct net_device *l3mdev, *ndev;
1913
	struct inet6_ifaddr *ifp;
1914
	u32 ifp_flags;
L
Linus Torvalds 已提交
1915

1916
	rcu_read_lock();
1917

1918
	l3mdev = l3mdev_master_dev_rcu(dev);
1919 1920 1921
	if (skip_dev_check)
		dev = NULL;

1922
	hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
X
Xin Long 已提交
1923 1924
		ndev = ifp->idev->dev;
		if (!net_eq(dev_net(ndev), net))
1925
			continue;
1926

X
Xin Long 已提交
1927
		if (l3mdev_master_dev_rcu(ndev) != l3mdev)
1928 1929
			continue;

1930 1931 1932 1933 1934 1935
		/* Decouple optimistic from tentative for evaluation here.
		 * Ban optimistic addresses explicitly, when required.
		 */
		ifp_flags = (ifp->flags&IFA_F_OPTIMISTIC)
			    ? (ifp->flags&~IFA_F_TENTATIVE)
			    : ifp->flags;
L
Linus Torvalds 已提交
1936
		if (ipv6_addr_equal(&ifp->addr, addr) &&
1937
		    !(ifp_flags&banned_flags) &&
X
Xin Long 已提交
1938
		    (!dev || ndev == dev ||
1939
		     !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))) {
1940
			rcu_read_unlock();
X
Xin Long 已提交
1941
			return ndev;
L
Linus Torvalds 已提交
1942 1943
		}
	}
1944

1945
	rcu_read_unlock();
X
Xin Long 已提交
1946 1947 1948 1949 1950 1951 1952 1953 1954
	return NULL;
}

int ipv6_chk_addr_and_flags(struct net *net, const struct in6_addr *addr,
			    const struct net_device *dev, bool skip_dev_check,
			    int strict, u32 banned_flags)
{
	return __ipv6_chk_addr_and_flags(net, addr, dev, skip_dev_check,
					 strict, banned_flags) ? 1 : 0;
L
Linus Torvalds 已提交
1955
}
1956
EXPORT_SYMBOL(ipv6_chk_addr_and_flags);
1957

L
Linus Torvalds 已提交
1958

1959 1960 1961 1962 1963 1964
/* 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)
{
1965 1966
	const struct inet6_ifaddr *ifa;
	const struct inet6_dev *idev;
1967 1968 1969 1970 1971
	bool ret = false;

	rcu_read_lock();
	idev = __in6_dev_get(dev);
	if (idev) {
1972
		list_for_each_entry_rcu(ifa, &idev->addr_list, if_list) {
1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983
			ret = ipv6_prefix_equal(addr, &ifa->addr, prefix_len);
			if (ret)
				break;
		}
	}
	rcu_read_unlock();

	return ret;
}
EXPORT_SYMBOL(ipv6_chk_custom_prefix);

1984
int ipv6_chk_prefix(const struct in6_addr *addr, struct net_device *dev)
1985
{
1986 1987
	const struct inet6_ifaddr *ifa;
	const struct inet6_dev *idev;
1988 1989 1990 1991 1992 1993
	int	onlink;

	onlink = 0;
	rcu_read_lock();
	idev = __in6_dev_get(dev);
	if (idev) {
1994
		list_for_each_entry_rcu(ifa, &idev->addr_list, if_list) {
1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005
			onlink = ipv6_prefix_equal(addr, &ifa->addr,
						   ifa->prefix_len);
			if (onlink)
				break;
		}
	}
	rcu_read_unlock();
	return onlink;
}
EXPORT_SYMBOL(ipv6_chk_prefix);

X
Xin Long 已提交
2006 2007 2008 2009 2010 2011 2012
/**
 * ipv6_dev_find - find the first device with a given source address.
 * @net: the net namespace
 * @addr: the source address
 *
 * The caller should be protected by RCU, or RTNL.
 */
X
Xin Long 已提交
2013 2014
struct net_device *ipv6_dev_find(struct net *net, const struct in6_addr *addr,
				 struct net_device *dev)
X
Xin Long 已提交
2015
{
X
Xin Long 已提交
2016 2017
	return __ipv6_chk_addr_and_flags(net, addr, dev, !dev, 1,
					 IFA_F_TENTATIVE);
X
Xin Long 已提交
2018 2019 2020
}
EXPORT_SYMBOL(ipv6_dev_find);

2021
struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr,
2022
				     struct net_device *dev, int strict)
L
Linus Torvalds 已提交
2023
{
2024
	unsigned int hash = inet6_addr_hash(net, addr);
2025
	struct inet6_ifaddr *ifp, *result = NULL;
L
Linus Torvalds 已提交
2026

2027 2028
	rcu_read_lock();
	hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
2029
		if (!net_eq(dev_net(ifp->idev->dev), net))
2030
			continue;
L
Linus Torvalds 已提交
2031
		if (ipv6_addr_equal(&ifp->addr, addr)) {
2032
			if (!dev || ifp->idev->dev == dev ||
L
Linus Torvalds 已提交
2033
			    !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
2034
				result = ifp;
L
Linus Torvalds 已提交
2035 2036 2037 2038 2039
				in6_ifa_hold(ifp);
				break;
			}
		}
	}
2040
	rcu_read_unlock();
L
Linus Torvalds 已提交
2041

2042
	return result;
L
Linus Torvalds 已提交
2043 2044 2045 2046
}

/* Gets referenced address, destroys ifaddr */

B
Brian Haley 已提交
2047
static void addrconf_dad_stop(struct inet6_ifaddr *ifp, int dad_failed)
L
Linus Torvalds 已提交
2048
{
2049 2050 2051
	if (dad_failed)
		ifp->flags |= IFA_F_DADFAILED;

2052
	if (ifp->flags&IFA_F_TEMPORARY) {
L
Linus Torvalds 已提交
2053 2054 2055 2056 2057 2058
		struct inet6_ifaddr *ifpub;
		spin_lock_bh(&ifp->lock);
		ifpub = ifp->ifpub;
		if (ifpub) {
			in6_ifa_hold(ifpub);
			spin_unlock_bh(&ifp->lock);
2059
			ipv6_create_tempaddr(ifpub, true);
L
Linus Torvalds 已提交
2060 2061 2062 2063 2064
			in6_ifa_put(ifpub);
		} else {
			spin_unlock_bh(&ifp->lock);
		}
		ipv6_del_addr(ifp);
2065 2066 2067 2068
	} else if (ifp->flags&IFA_F_PERMANENT || !dad_failed) {
		spin_lock_bh(&ifp->lock);
		addrconf_del_dad_work(ifp);
		ifp->flags |= IFA_F_TENTATIVE;
2069 2070
		if (dad_failed)
			ifp->flags &= ~IFA_F_OPTIMISTIC;
2071 2072 2073 2074
		spin_unlock_bh(&ifp->lock);
		if (dad_failed)
			ipv6_ifa_notify(0, ifp);
		in6_ifa_put(ifp);
2075
	} else {
L
Linus Torvalds 已提交
2076
		ipv6_del_addr(ifp);
2077
	}
L
Linus Torvalds 已提交
2078 2079
}

H
Herbert Xu 已提交
2080 2081 2082 2083
static int addrconf_dad_end(struct inet6_ifaddr *ifp)
{
	int err = -ENOENT;

2084
	spin_lock_bh(&ifp->lock);
H
Herbert Xu 已提交
2085 2086 2087 2088
	if (ifp->state == INET6_IFADDR_STATE_DAD) {
		ifp->state = INET6_IFADDR_STATE_POSTDAD;
		err = 0;
	}
2089
	spin_unlock_bh(&ifp->lock);
H
Herbert Xu 已提交
2090 2091 2092 2093

	return err;
}

2094
void addrconf_dad_failure(struct sk_buff *skb, struct inet6_ifaddr *ifp)
2095
{
2096
	struct inet6_dev *idev = ifp->idev;
2097
	struct net *net = dev_net(ifp->idev->dev);
2098

2099 2100
	if (addrconf_dad_end(ifp)) {
		in6_ifa_put(ifp);
H
Herbert Xu 已提交
2101
		return;
2102
	}
H
Herbert Xu 已提交
2103

2104 2105
	net_info_ratelimited("%s: IPv6 duplicate address %pI6c used by %pM detected!\n",
			     ifp->idev->dev->name, &ifp->addr, eth_hdr(skb)->h_source);
2106

2107 2108 2109 2110 2111 2112
	spin_lock_bh(&ifp->lock);

	if (ifp->flags & IFA_F_STABLE_PRIVACY) {
		struct in6_addr new_addr;
		struct inet6_ifaddr *ifp2;
		int retries = ifp->stable_privacy_retry + 1;
2113 2114 2115 2116 2117 2118 2119 2120
		struct ifa6_config cfg = {
			.pfx = &new_addr,
			.plen = ifp->prefix_len,
			.ifa_flags = ifp->flags,
			.valid_lft = ifp->valid_lft,
			.preferred_lft = ifp->prefered_lft,
			.scope = ifp->scope,
		};
2121

2122
		if (retries > net->ipv6.sysctl.idgen_retries) {
2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133
			net_info_ratelimited("%s: privacy stable address generation failed because of DAD conflicts!\n",
					     ifp->idev->dev->name);
			goto errdad;
		}

		new_addr = ifp->addr;
		if (ipv6_generate_stable_address(&new_addr, retries,
						 idev))
			goto errdad;

		spin_unlock_bh(&ifp->lock);
2134

2135 2136 2137 2138 2139 2140 2141 2142
		if (idev->cnf.max_addresses &&
		    ipv6_count_addresses(idev) >=
		    idev->cnf.max_addresses)
			goto lock_errdad;

		net_info_ratelimited("%s: generating new stable privacy address because of DAD conflict\n",
				     ifp->idev->dev->name);

2143
		ifp2 = ipv6_add_addr(idev, &cfg, false, NULL);
2144 2145 2146 2147 2148 2149 2150 2151
		if (IS_ERR(ifp2))
			goto lock_errdad;

		spin_lock_bh(&ifp2->lock);
		ifp2->stable_privacy_retry = retries;
		ifp2->state = INET6_IFADDR_STATE_PREDAD;
		spin_unlock_bh(&ifp2->lock);

2152
		addrconf_mod_dad_work(ifp2, net->ipv6.sysctl.idgen_delay);
2153 2154 2155
		in6_ifa_put(ifp2);
lock_errdad:
		spin_lock_bh(&ifp->lock);
2156 2157
	}

2158
errdad:
2159 2160
	/* transition from _POSTDAD to _ERRDAD */
	ifp->state = INET6_IFADDR_STATE_ERRDAD;
2161
	spin_unlock_bh(&ifp->lock);
2162 2163

	addrconf_mod_dad_work(ifp, 0);
2164
	in6_ifa_put(ifp);
2165
}
L
Linus Torvalds 已提交
2166

2167 2168
/* Join to solicited addr multicast group.
 * caller must hold RTNL */
2169
void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr)
L
Linus Torvalds 已提交
2170 2171 2172 2173 2174 2175 2176 2177 2178 2179
{
	struct in6_addr maddr;

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

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

2180
/* caller must hold RTNL */
2181
void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr)
L
Linus Torvalds 已提交
2182 2183 2184 2185 2186 2187 2188 2189 2190 2191
{
	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);
}

2192
/* caller must hold RTNL */
2193
static void addrconf_join_anycast(struct inet6_ifaddr *ifp)
L
Linus Torvalds 已提交
2194 2195
{
	struct in6_addr addr;
2196

2197
	if (ifp->prefix_len >= 127) /* RFC 6164 */
2198
		return;
L
Linus Torvalds 已提交
2199 2200 2201
	ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
	if (ipv6_addr_any(&addr))
		return;
W
WANG Cong 已提交
2202
	__ipv6_dev_ac_inc(ifp->idev, &addr);
L
Linus Torvalds 已提交
2203 2204
}

2205
/* caller must hold RTNL */
2206
static void addrconf_leave_anycast(struct inet6_ifaddr *ifp)
L
Linus Torvalds 已提交
2207 2208
{
	struct in6_addr addr;
2209

2210
	if (ifp->prefix_len >= 127) /* RFC 6164 */
2211
		return;
L
Linus Torvalds 已提交
2212 2213 2214 2215 2216 2217
	ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
	if (ipv6_addr_any(&addr))
		return;
	__ipv6_dev_ac_dec(ifp->idev, &addr);
}

2218
static int addrconf_ifid_6lowpan(u8 *eui, struct net_device *dev)
2219
{
2220 2221
	switch (dev->addr_len) {
	case ETH_ALEN:
2222 2223 2224 2225 2226
		memcpy(eui, dev->dev_addr, 3);
		eui[3] = 0xFF;
		eui[4] = 0xFE;
		memcpy(eui + 5, dev->dev_addr + 3, 3);
		break;
2227 2228 2229 2230 2231
	case EUI64_ADDR_LEN:
		memcpy(eui, dev->dev_addr, EUI64_ADDR_LEN);
		eui[0] ^= 2;
		break;
	default:
2232
		return -1;
2233 2234
	}

2235 2236 2237
	return 0;
}

2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251
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;
}

2252 2253 2254 2255 2256 2257
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);
2258
	eui[7] = *(u8 *)dev->dev_addr;
2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270
	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;
}

2271
static int __ipv6_isatap_ifid(u8 *eui, __be32 addr)
2272
{
2273 2274
	if (addr == 0)
		return -1;
2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294
	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;
}

2295 2296 2297 2298 2299
static int addrconf_ifid_gre(u8 *eui, struct net_device *dev)
{
	return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
}

2300 2301 2302 2303 2304 2305 2306 2307 2308 2309
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 已提交
2310 2311 2312 2313 2314
static int ipv6_generate_eui64(u8 *eui, struct net_device *dev)
{
	switch (dev->type) {
	case ARPHRD_ETHER:
	case ARPHRD_FDDI:
2315
		return addrconf_ifid_eui48(eui, dev);
L
Linus Torvalds 已提交
2316
	case ARPHRD_ARCNET:
2317
		return addrconf_ifid_arcnet(eui, dev);
L
Linus Torvalds 已提交
2318
	case ARPHRD_INFINIBAND:
2319
		return addrconf_ifid_infiniband(eui, dev);
F
Fred L. Templin 已提交
2320
	case ARPHRD_SIT:
2321
		return addrconf_ifid_sit(eui, dev);
2322
	case ARPHRD_IPGRE:
2323
	case ARPHRD_TUNNEL:
2324
		return addrconf_ifid_gre(eui, dev);
2325
	case ARPHRD_6LOWPAN:
2326
		return addrconf_ifid_6lowpan(eui, dev);
2327 2328
	case ARPHRD_IEEE1394:
		return addrconf_ifid_ieee1394(eui, dev);
2329
	case ARPHRD_TUNNEL6:
2330
	case ARPHRD_IP6GRE:
2331
	case ARPHRD_RAWIP:
2332
		return addrconf_ifid_ip6tnl(eui, dev);
L
Linus Torvalds 已提交
2333 2334 2335 2336 2337 2338 2339 2340 2341 2342
	}
	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);
2343 2344 2345
	list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
		if (ifp->scope > IFA_LINK)
			break;
L
Linus Torvalds 已提交
2346 2347 2348 2349 2350 2351 2352 2353 2354 2355
		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;
}

2356 2357 2358 2359 2360
/* Generation of a randomized Interface Identifier
 * draft-ietf-6man-rfc4941bis, Section 3.3.1
 */

static void ipv6_gen_rnd_iid(struct in6_addr *addr)
L
Linus Torvalds 已提交
2361 2362
{
regen:
2363
	get_random_bytes(&addr->s6_addr[8], 8);
L
Linus Torvalds 已提交
2364

2365 2366
	/* <draft-ietf-6man-rfc4941bis-08.txt>, Section 3.3.1:
	 * check if generated address is not inappropriate:
L
Linus Torvalds 已提交
2367
	 *
2368 2369
	 * - Reserved IPv6 Interface Identifers
	 * - XXX: already assigned to an address on the device
L
Linus Torvalds 已提交
2370
	 */
2371 2372 2373

	/* Subnet-router anycast: 0000:0000:0000:0000 */
	if (!(addr->s6_addr32[2] | addr->s6_addr32[3]))
L
Linus Torvalds 已提交
2374 2375
		goto regen;

2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387
	/* IANA Ethernet block: 0200:5EFF:FE00:0000-0200:5EFF:FE00:5212
	 * Proxy Mobile IPv6:   0200:5EFF:FE00:5213
	 * IANA Ethernet block: 0200:5EFF:FE00:5214-0200:5EFF:FEFF:FFFF
	 */
	if (ntohl(addr->s6_addr32[2]) == 0x02005eff &&
	    (ntohl(addr->s6_addr32[3]) & 0Xff000000) == 0xfe000000)
		goto regen;

	/* Reserved subnet anycast addresses */
	if (ntohl(addr->s6_addr32[2]) == 0xfdffffff &&
	    ntohl(addr->s6_addr32[3]) >= 0Xffffff80)
		goto regen;
L
Linus Torvalds 已提交
2388 2389 2390 2391 2392 2393 2394
}

/*
 *	Add prefix route.
 */

static void
2395 2396 2397
addrconf_prefix_route(struct in6_addr *pfx, int plen, u32 metric,
		      struct net_device *dev, unsigned long expires,
		      u32 flags, gfp_t gfp_flags)
L
Linus Torvalds 已提交
2398
{
2399
	struct fib6_config cfg = {
D
David Ahern 已提交
2400
		.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX,
2401
		.fc_metric = metric ? : IP6_RT_PRIO_ADDRCONF,
2402 2403 2404 2405
		.fc_ifindex = dev->ifindex,
		.fc_expires = expires,
		.fc_dst_len = plen,
		.fc_flags = RTF_UP | flags,
2406
		.fc_nlinfo.nl_net = dev_net(dev),
2407
		.fc_protocol = RTPROT_KERNEL,
2408
		.fc_type = RTN_UNICAST,
2409
	};
L
Linus Torvalds 已提交
2410

A
Alexey Dobriyan 已提交
2411
	cfg.fc_dst = *pfx;
L
Linus Torvalds 已提交
2412 2413 2414 2415 2416

	/* 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 已提交
2417
#if IS_ENABLED(CONFIG_IPV6_SIT)
2418 2419
	if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT))
		cfg.fc_flags |= RTF_NONEXTHOP;
2420
#endif
L
Linus Torvalds 已提交
2421

2422
	ip6_route_add(&cfg, gfp_flags, NULL);
L
Linus Torvalds 已提交
2423 2424
}

2425

2426
static struct fib6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
2427 2428
						  int plen,
						  const struct net_device *dev,
2429 2430
						  u32 flags, u32 noflags,
						  bool no_gw)
2431 2432
{
	struct fib6_node *fn;
2433
	struct fib6_info *rt = NULL;
2434
	struct fib6_table *table;
D
David Ahern 已提交
2435
	u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX;
2436

D
David Ahern 已提交
2437
	table = fib6_get_table(dev_net(dev), tb_id);
2438
	if (!table)
2439 2440
		return NULL;

2441
	rcu_read_lock();
2442
	fn = fib6_locate(&table->tb6_root, pfx, plen, NULL, 0, true);
2443 2444
	if (!fn)
		goto out;
2445

2446
	for_each_fib6_node_rt_rcu(fn) {
2447 2448 2449 2450
		/* prefix routes only use builtin fib6_nh */
		if (rt->nh)
			continue;

2451
		if (rt->fib6_nh->fib_nh_dev->ifindex != dev->ifindex)
2452
			continue;
2453
		if (no_gw && rt->fib6_nh->fib_nh_gw_family)
2454
			continue;
2455
		if ((rt->fib6_flags & flags) != flags)
2456
			continue;
2457
		if ((rt->fib6_flags & noflags) != 0)
2458
			continue;
2459 2460
		if (!fib6_info_hold_safe(rt))
			continue;
2461 2462 2463
		break;
	}
out:
2464
	rcu_read_unlock();
2465 2466 2467 2468
	return rt;
}


L
Linus Torvalds 已提交
2469 2470 2471 2472
/* Create "default" multicast route to the interface */

static void addrconf_add_mroute(struct net_device *dev)
{
2473
	struct fib6_config cfg = {
D
David Ahern 已提交
2474
		.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_LOCAL,
2475 2476 2477 2478
		.fc_metric = IP6_RT_PRIO_ADDRCONF,
		.fc_ifindex = dev->ifindex,
		.fc_dst_len = 8,
		.fc_flags = RTF_UP,
2479
		.fc_type = RTN_MULTICAST,
2480
		.fc_nlinfo.nl_net = dev_net(dev),
2481
		.fc_protocol = RTPROT_KERNEL,
2482 2483 2484 2485
	};

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

2486
	ip6_route_add(&cfg, GFP_KERNEL, NULL);
L
Linus Torvalds 已提交
2487 2488 2489 2490 2491 2492 2493 2494
}

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

	ASSERT_RTNL();

S
Stephen Hemminger 已提交
2495
	idev = ipv6_find_idev(dev);
2496 2497
	if (IS_ERR(idev))
		return idev;
2498 2499 2500

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

	/* Add default multicast route */
2503
	if (!(dev->flags & IFF_LOOPBACK) && !netif_is_l3_master(dev))
2504
		addrconf_add_mroute(dev);
L
Linus Torvalds 已提交
2505 2506 2507 2508

	return idev;
}

2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538
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 -
J
Jiri Bohac 已提交
2539
			       idev->desync_factor - age;
2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569
		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);
2570
		ipv6_create_tempaddr(ifp, false);
2571 2572 2573 2574 2575
	} else {
		read_unlock_bh(&idev->lock);
	}
}

2576 2577
static bool is_addr_mode_generate_stable(struct inet6_dev *idev)
{
2578 2579
	return idev->cnf.addr_gen_mode == IN6_ADDR_GEN_MODE_STABLE_PRIVACY ||
	       idev->cnf.addr_gen_mode == IN6_ADDR_GEN_MODE_RANDOM;
2580 2581
}

A
Alexander Aring 已提交
2582 2583 2584 2585 2586 2587
int addrconf_prefix_rcv_add_addr(struct net *net, struct net_device *dev,
				 const struct prefix_info *pinfo,
				 struct inet6_dev *in6_dev,
				 const struct in6_addr *addr, int addr_type,
				 u32 addr_flags, bool sllao, bool tokenized,
				 __u32 valid_lft, u32 prefered_lft)
2588 2589
{
	struct inet6_ifaddr *ifp = ipv6_get_ifaddr(net, addr, dev, 1);
2590
	int create = 0, update_lft = 0;
2591 2592 2593

	if (!ifp && valid_lft) {
		int max_addresses = in6_dev->cnf.max_addresses;
2594 2595 2596 2597 2598 2599 2600 2601
		struct ifa6_config cfg = {
			.pfx = addr,
			.plen = pinfo->prefix_len,
			.ifa_flags = addr_flags,
			.valid_lft = valid_lft,
			.preferred_lft = prefered_lft,
			.scope = addr_type & IPV6_ADDR_SCOPE_MASK,
		};
2602 2603

#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
2604 2605
		if ((net->ipv6.devconf_all->optimistic_dad ||
		     in6_dev->cnf.optimistic_dad) &&
2606
		    !net->ipv6.devconf_all->forwarding && sllao)
2607
			cfg.ifa_flags |= IFA_F_OPTIMISTIC;
2608 2609 2610 2611 2612 2613 2614
#endif

		/* 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)
2615
			ifp = ipv6_add_addr(in6_dev, &cfg, false, NULL);
2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633

		if (IS_ERR_OR_NULL(ifp))
			return -1;

		create = 1;
		spin_lock_bh(&ifp->lock);
		ifp->flags |= IFA_F_MANAGETEMPADDR;
		ifp->cstamp = jiffies;
		ifp->tokenized = tokenized;
		spin_unlock_bh(&ifp->lock);
		addrconf_dad_start(ifp);
	}

	if (ifp) {
		u32 flags;
		unsigned long now;
		u32 stored_lft;

2634
		/* update lifetime (RFC2462 5.5.3 e) */
2635 2636 2637 2638 2639 2640
		spin_lock_bh(&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;
2641
		if (!create && stored_lft) {
2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659
			const u32 minimum_lft = min_t(u32,
				stored_lft, 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;
		}

		if (update_lft) {
2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680
			ifp->valid_lft = valid_lft;
			ifp->prefered_lft = prefered_lft;
			ifp->tstamp = now;
			flags = ifp->flags;
			ifp->flags &= ~IFA_F_DEPRECATED;
			spin_unlock_bh(&ifp->lock);

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

		manage_tempaddrs(in6_dev, ifp, valid_lft, prefered_lft,
				 create, now);

		in6_ifa_put(ifp);
		addrconf_verify();
	}

	return 0;
}
A
Alexander Aring 已提交
2681
EXPORT_SYMBOL_GPL(addrconf_prefix_rcv_add_addr);
2682

2683
void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len, bool sllao)
L
Linus Torvalds 已提交
2684 2685 2686 2687
{
	struct prefix_info *pinfo;
	__u32 valid_lft;
	__u32 prefered_lft;
2688
	int addr_type, err;
2689
	u32 addr_flags = 0;
L
Linus Torvalds 已提交
2690
	struct inet6_dev *in6_dev;
2691
	struct net *net = dev_net(dev);
L
Linus Torvalds 已提交
2692 2693

	pinfo = (struct prefix_info *) opt;
2694

L
Linus Torvalds 已提交
2695
	if (len < sizeof(struct prefix_info)) {
2696
		netdev_dbg(dev, "addrconf: prefix option too short\n");
L
Linus Torvalds 已提交
2697 2698
		return;
	}
2699

L
Linus Torvalds 已提交
2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712
	/*
	 *	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) {
2713
		net_warn_ratelimited("addrconf: prefix option has invalid lifetime\n");
L
Linus Torvalds 已提交
2714 2715 2716 2717 2718
		return;
	}

	in6_dev = in6_dev_get(dev);

2719
	if (!in6_dev) {
2720 2721
		net_dbg_ratelimited("addrconf: device %s not configured\n",
				    dev->name);
L
Linus Torvalds 已提交
2722 2723 2724 2725 2726 2727 2728 2729 2730
		return;
	}

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

2731
	if (pinfo->onlink) {
2732
		struct fib6_info *rt;
2733 2734
		unsigned long rt_expires;

2735 2736 2737 2738 2739
		/* 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.
		 */
2740 2741 2742 2743
		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 已提交
2744

2745 2746
		if (addrconf_finite_timeout(rt_expires))
			rt_expires *= HZ;
L
Linus Torvalds 已提交
2747

2748 2749 2750 2751
		rt = addrconf_get_prefix_route(&pinfo->prefix,
					       pinfo->prefix_len,
					       dev,
					       RTF_ADDRCONF | RTF_PREFIX_RT,
2752
					       RTF_DEFAULT, true);
L
Linus Torvalds 已提交
2753

2754
		if (rt) {
2755 2756
			/* Autoconf prefix route */
			if (valid_lft == 0) {
2757
				ip6_del_rt(net, rt, false);
2758
				rt = NULL;
2759
			} else if (addrconf_finite_timeout(rt_expires)) {
2760
				/* not infinity */
2761
				fib6_set_expires(rt, jiffies + rt_expires);
2762
			} else {
2763
				fib6_clean_expires(rt);
L
Linus Torvalds 已提交
2764 2765
			}
		} else if (valid_lft) {
2766
			clock_t expires = 0;
2767 2768
			int flags = RTF_ADDRCONF | RTF_PREFIX_RT;
			if (addrconf_finite_timeout(rt_expires)) {
2769 2770 2771 2772
				/* not infinity */
				flags |= RTF_EXPIRES;
				expires = jiffies_to_clock_t(rt_expires);
			}
L
Linus Torvalds 已提交
2773
			addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
2774 2775
					      0, dev, expires, flags,
					      GFP_ATOMIC);
L
Linus Torvalds 已提交
2776
		}
2777
		fib6_info_release(rt);
L
Linus Torvalds 已提交
2778 2779 2780 2781 2782 2783
	}

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

	if (pinfo->autoconf && in6_dev->cnf.autoconf) {
		struct in6_addr addr;
2784
		bool tokenized = false, dev_addr_generated = false;
L
Linus Torvalds 已提交
2785 2786 2787

		if (pinfo->prefix_len == 64) {
			memcpy(&addr, &pinfo->prefix, 8);
2788 2789 2790 2791 2792 2793

			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);
2794
				tokenized = true;
2795
			} else if (is_addr_mode_generate_stable(in6_dev) &&
2796 2797
				   !ipv6_generate_stable_address(&addr, 0,
								 in6_dev)) {
2798
				addr_flags |= IFA_F_STABLE_PRIVACY;
2799
				goto ok;
2800 2801
			} else if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
				   ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
2802
				goto put;
2803 2804
			} else {
				dev_addr_generated = true;
L
Linus Torvalds 已提交
2805 2806 2807
			}
			goto ok;
		}
2808 2809
		net_dbg_ratelimited("IPv6 addrconf: prefix with wrong length %d\n",
				    pinfo->prefix_len);
2810
		goto put;
L
Linus Torvalds 已提交
2811 2812

ok:
2813 2814 2815 2816 2817 2818 2819
		err = addrconf_prefix_rcv_add_addr(net, dev, pinfo, in6_dev,
						   &addr, addr_type,
						   addr_flags, sllao,
						   tokenized, valid_lft,
						   prefered_lft);
		if (err)
			goto put;
2820 2821 2822 2823 2824 2825 2826 2827 2828

		/* Ignore error case here because previous prefix add addr was
		 * successful which will be notified.
		 */
		ndisc_ops_prefix_rcv_add_addr(net, dev, pinfo, in6_dev, &addr,
					      addr_type, addr_flags, sllao,
					      tokenized, valid_lft,
					      prefered_lft,
					      dev_addr_generated);
L
Linus Torvalds 已提交
2829 2830
	}
	inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo);
2831
put:
L
Linus Torvalds 已提交
2832 2833 2834
	in6_dev_put(in6_dev);
}

2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849
static int addrconf_set_sit_dstaddr(struct net *net, struct net_device *dev,
		struct in6_ifreq *ireq)
{
	struct ip_tunnel_parm p = { };
	int err;

	if (!(ipv6_addr_type(&ireq->ifr6_addr) & IPV6_ADDR_COMPATv4))
		return -EADDRNOTAVAIL;

	p.iph.daddr = ireq->ifr6_addr.s6_addr32[3];
	p.iph.version = 4;
	p.iph.ihl = 5;
	p.iph.protocol = IPPROTO_IPV6;
	p.iph.ttl = 64;

2850
	if (!dev->netdev_ops->ndo_tunnel_ctl)
2851
		return -EOPNOTSUPP;
2852
	err = dev->netdev_ops->ndo_tunnel_ctl(dev, &p, SIOCADDTUNNEL);
2853 2854 2855 2856 2857 2858 2859 2860 2861
	if (err)
		return err;

	dev = __dev_get_by_name(net, p.name);
	if (!dev)
		return -ENOBUFS;
	return dev_open(dev, NULL);
}

L
Linus Torvalds 已提交
2862 2863 2864 2865 2866
/*
 *	Set destination address.
 *	Special case for SIT interfaces where we create a new "virtual"
 *	device.
 */
2867
int addrconf_set_dstaddr(struct net *net, void __user *arg)
L
Linus Torvalds 已提交
2868 2869
{
	struct net_device *dev;
2870 2871
	struct in6_ifreq ireq;
	int err = -ENODEV;
L
Linus Torvalds 已提交
2872

2873 2874
	if (!IS_ENABLED(CONFIG_IPV6_SIT))
		return -ENODEV;
L
Linus Torvalds 已提交
2875
	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2876
		return -EFAULT;
L
Linus Torvalds 已提交
2877

2878
	rtnl_lock();
2879
	dev = __dev_get_by_index(net, ireq.ifr6_ifindex);
2880 2881
	if (dev && dev->type == ARPHRD_SIT)
		err = addrconf_set_sit_dstaddr(net, dev, &ireq);
L
Linus Torvalds 已提交
2882 2883 2884 2885
	rtnl_unlock();
	return err;
}

2886 2887 2888 2889 2890 2891 2892 2893 2894
static int ipv6_mc_config(struct sock *sk, bool join,
			  const struct in6_addr *addr, int ifindex)
{
	int ret;

	ASSERT_RTNL();

	lock_sock(sk);
	if (join)
2895
		ret = ipv6_sock_mc_join(sk, ifindex, addr);
2896
	else
2897
		ret = ipv6_sock_mc_drop(sk, ifindex, addr);
2898 2899 2900 2901 2902
	release_sock(sk);

	return ret;
}

L
Linus Torvalds 已提交
2903 2904 2905
/*
 *	Manual configuration of address on an interface
 */
2906
static int inet6_addr_add(struct net *net, int ifindex,
2907
			  struct ifa6_config *cfg,
2908
			  struct netlink_ext_ack *extack)
L
Linus Torvalds 已提交
2909 2910 2911 2912
{
	struct inet6_ifaddr *ifp;
	struct inet6_dev *idev;
	struct net_device *dev;
2913 2914
	unsigned long timeout;
	clock_t expires;
2915
	u32 flags;
L
Linus Torvalds 已提交
2916 2917

	ASSERT_RTNL();
2918

2919
	if (cfg->plen > 128)
2920 2921
		return -EINVAL;

2922
	/* check the lifetime */
2923
	if (!cfg->valid_lft || cfg->preferred_lft > cfg->valid_lft)
2924 2925
		return -EINVAL;

2926
	if (cfg->ifa_flags & IFA_F_MANAGETEMPADDR && cfg->plen != 64)
2927 2928
		return -EINVAL;

2929 2930
	dev = __dev_get_by_index(net, ifindex);
	if (!dev)
L
Linus Torvalds 已提交
2931
		return -ENODEV;
2932

2933 2934 2935
	idev = addrconf_add_dev(dev);
	if (IS_ERR(idev))
		return PTR_ERR(idev);
L
Linus Torvalds 已提交
2936

2937
	if (cfg->ifa_flags & IFA_F_MCAUTOJOIN) {
2938
		int ret = ipv6_mc_config(net->ipv6.mc_autojoin_sk,
2939
					 true, cfg->pfx, ifindex);
2940 2941 2942 2943 2944

		if (ret < 0)
			return ret;
	}

2945
	cfg->scope = ipv6_addr_scope(cfg->pfx);
L
Linus Torvalds 已提交
2946

2947
	timeout = addrconf_timeout_fixup(cfg->valid_lft, HZ);
2948 2949
	if (addrconf_finite_timeout(timeout)) {
		expires = jiffies_to_clock_t(timeout * HZ);
2950
		cfg->valid_lft = timeout;
2951
		flags = RTF_EXPIRES;
2952 2953 2954
	} else {
		expires = 0;
		flags = 0;
2955
		cfg->ifa_flags |= IFA_F_PERMANENT;
2956
	}
2957

2958
	timeout = addrconf_timeout_fixup(cfg->preferred_lft, HZ);
2959 2960
	if (addrconf_finite_timeout(timeout)) {
		if (timeout == 0)
2961 2962
			cfg->ifa_flags |= IFA_F_DEPRECATED;
		cfg->preferred_lft = timeout;
2963
	}
2964

2965
	ifp = ipv6_add_addr(idev, cfg, true, extack);
L
Linus Torvalds 已提交
2966
	if (!IS_ERR(ifp)) {
2967
		if (!(cfg->ifa_flags & IFA_F_NOPREFIXROUTE)) {
2968 2969 2970
			addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
					      ifp->rt_priority, dev, expires,
					      flags, GFP_KERNEL);
2971 2972
		}

2973 2974 2975 2976 2977
		/* Send a netlink notification if DAD is enabled and
		 * optimistic flag is not set
		 */
		if (!(ifp->flags & (IFA_F_OPTIMISTIC | IFA_F_NODAD)))
			ipv6_ifa_notify(0, ifp);
2978 2979 2980 2981 2982
		/*
		 * Note that section 3.1 of RFC 4429 indicates
		 * that the Optimistic flag should not be set for
		 * manually configured addresses
		 */
2983
		addrconf_dad_start(ifp);
2984 2985 2986
		if (cfg->ifa_flags & IFA_F_MANAGETEMPADDR)
			manage_tempaddrs(idev, ifp, cfg->valid_lft,
					 cfg->preferred_lft, true, jiffies);
L
Linus Torvalds 已提交
2987
		in6_ifa_put(ifp);
2988
		addrconf_verify_rtnl();
L
Linus Torvalds 已提交
2989
		return 0;
2990 2991 2992
	} else if (cfg->ifa_flags & IFA_F_MCAUTOJOIN) {
		ipv6_mc_config(net->ipv6.mc_autojoin_sk, false,
			       cfg->pfx, ifindex);
L
Linus Torvalds 已提交
2993 2994 2995 2996 2997
	}

	return PTR_ERR(ifp);
}

2998 2999
static int inet6_addr_del(struct net *net, int ifindex, u32 ifa_flags,
			  const struct in6_addr *pfx, unsigned int plen)
L
Linus Torvalds 已提交
3000 3001 3002 3003
{
	struct inet6_ifaddr *ifp;
	struct inet6_dev *idev;
	struct net_device *dev;
3004

3005 3006 3007
	if (plen > 128)
		return -EINVAL;

3008 3009
	dev = __dev_get_by_index(net, ifindex);
	if (!dev)
L
Linus Torvalds 已提交
3010 3011
		return -ENODEV;

3012
	idev = __in6_dev_get(dev);
3013
	if (!idev)
L
Linus Torvalds 已提交
3014 3015 3016
		return -ENXIO;

	read_lock_bh(&idev->lock);
3017
	list_for_each_entry(ifp, &idev->addr_list, if_list) {
L
Linus Torvalds 已提交
3018 3019 3020 3021
		if (ifp->prefix_len == plen &&
		    ipv6_addr_equal(pfx, &ifp->addr)) {
			in6_ifa_hold(ifp);
			read_unlock_bh(&idev->lock);
3022

3023 3024 3025 3026
			if (!(ifp->flags & IFA_F_TEMPORARY) &&
			    (ifa_flags & IFA_F_MANAGETEMPADDR))
				manage_tempaddrs(idev, ifp, 0, 0, false,
						 jiffies);
L
Linus Torvalds 已提交
3027
			ipv6_del_addr(ifp);
3028
			addrconf_verify_rtnl();
3029 3030 3031 3032
			if (ipv6_addr_is_multicast(pfx)) {
				ipv6_mc_config(net->ipv6.mc_autojoin_sk,
					       false, pfx, dev->ifindex);
			}
L
Linus Torvalds 已提交
3033 3034 3035 3036 3037 3038 3039 3040
			return 0;
		}
	}
	read_unlock_bh(&idev->lock);
	return -EADDRNOTAVAIL;
}


3041
int addrconf_add_ifaddr(struct net *net, void __user *arg)
L
Linus Torvalds 已提交
3042
{
3043 3044 3045 3046 3047
	struct ifa6_config cfg = {
		.ifa_flags = IFA_F_PERMANENT,
		.preferred_lft = INFINITY_LIFE_TIME,
		.valid_lft = INFINITY_LIFE_TIME,
	};
L
Linus Torvalds 已提交
3048 3049
	struct in6_ifreq ireq;
	int err;
3050

3051
	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
3052
		return -EPERM;
3053

L
Linus Torvalds 已提交
3054 3055 3056
	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
		return -EFAULT;

3057 3058 3059
	cfg.pfx = &ireq.ifr6_addr;
	cfg.plen = ireq.ifr6_prefixlen;

L
Linus Torvalds 已提交
3060
	rtnl_lock();
3061
	err = inet6_addr_add(net, ireq.ifr6_ifindex, &cfg, NULL);
L
Linus Torvalds 已提交
3062 3063 3064 3065
	rtnl_unlock();
	return err;
}

3066
int addrconf_del_ifaddr(struct net *net, void __user *arg)
L
Linus Torvalds 已提交
3067 3068 3069
{
	struct in6_ifreq ireq;
	int err;
3070

3071
	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
3072 3073 3074 3075 3076 3077
		return -EPERM;

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

	rtnl_lock();
3078
	err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr,
3079
			     ireq.ifr6_prefixlen);
L
Linus Torvalds 已提交
3080 3081 3082 3083
	rtnl_unlock();
	return err;
}

3084 3085 3086 3087
static void add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
		     int plen, int scope)
{
	struct inet6_ifaddr *ifp;
3088 3089 3090 3091 3092 3093 3094 3095
	struct ifa6_config cfg = {
		.pfx = addr,
		.plen = plen,
		.ifa_flags = IFA_F_PERMANENT,
		.valid_lft = INFINITY_LIFE_TIME,
		.preferred_lft = INFINITY_LIFE_TIME,
		.scope = scope
	};
3096

3097
	ifp = ipv6_add_addr(idev, &cfg, true, NULL);
3098 3099 3100 3101
	if (!IS_ERR(ifp)) {
		spin_lock_bh(&ifp->lock);
		ifp->flags &= ~IFA_F_TENTATIVE;
		spin_unlock_bh(&ifp->lock);
3102
		rt_genid_bump_ipv6(dev_net(idev->dev));
3103 3104 3105 3106 3107
		ipv6_ifa_notify(RTM_NEWADDR, ifp);
		in6_ifa_put(ifp);
	}
}

A
Amerigo Wang 已提交
3108
#if IS_ENABLED(CONFIG_IPV6_SIT)
L
Linus Torvalds 已提交
3109 3110 3111 3112
static void sit_add_v4_addrs(struct inet6_dev *idev)
{
	struct in6_addr addr;
	struct net_device *dev;
3113
	struct net *net = dev_net(idev->dev);
3114
	int scope, plen;
3115
	u32 pflags = 0;
L
Linus Torvalds 已提交
3116 3117 3118 3119 3120 3121 3122

	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) {
3123 3124 3125
		if (idev->cnf.addr_gen_mode == IN6_ADDR_GEN_MODE_NONE)
			return;

L
Linus Torvalds 已提交
3126 3127
		addr.s6_addr32[0] = htonl(0xfe800000);
		scope = IFA_LINK;
3128
		plen = 64;
L
Linus Torvalds 已提交
3129 3130
	} else {
		scope = IPV6_ADDR_COMPATv4;
3131
		plen = 96;
3132
		pflags |= RTF_NONEXTHOP;
L
Linus Torvalds 已提交
3133 3134 3135
	}

	if (addr.s6_addr32[3]) {
3136
		add_addr(idev, &addr, plen, scope);
3137
		addrconf_prefix_route(&addr, plen, 0, idev->dev, 0, pflags,
3138
				      GFP_KERNEL);
L
Linus Torvalds 已提交
3139 3140 3141
		return;
	}

3142
	for_each_netdev(net, dev) {
3143
		struct in_device *in_dev = __in_dev_get_rtnl(dev);
L
Linus Torvalds 已提交
3144
		if (in_dev && (dev->flags & IFF_UP)) {
3145
			struct in_ifaddr *ifa;
L
Linus Torvalds 已提交
3146 3147
			int flag = scope;

3148
			in_dev_for_each_ifa_rtnl(ifa, in_dev) {
L
Linus Torvalds 已提交
3149 3150 3151 3152 3153 3154 3155 3156 3157 3158
				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;
				}

3159
				add_addr(idev, &addr, plen, flag);
3160
				addrconf_prefix_route(&addr, plen, 0, idev->dev,
3161
						      0, pflags, GFP_KERNEL);
L
Linus Torvalds 已提交
3162 3163
			}
		}
3164
	}
L
Linus Torvalds 已提交
3165
}
3166
#endif
L
Linus Torvalds 已提交
3167 3168 3169 3170 3171 3172 3173 3174 3175

static void init_loopback(struct net_device *dev)
{
	struct inet6_dev  *idev;

	/* ::1 */

	ASSERT_RTNL();

3176
	idev = ipv6_find_idev(dev);
3177
	if (IS_ERR(idev)) {
3178
		pr_debug("%s: add_dev failed\n", __func__);
L
Linus Torvalds 已提交
3179 3180 3181
		return;
	}

3182
	add_addr(idev, &in6addr_loopback, 128, IFA_HOST);
L
Linus Torvalds 已提交
3183 3184
}

3185 3186
void addrconf_add_linklocal(struct inet6_dev *idev,
			    const struct in6_addr *addr, u32 flags)
L
Linus Torvalds 已提交
3187
{
3188 3189 3190 3191 3192 3193 3194 3195
	struct ifa6_config cfg = {
		.pfx = addr,
		.plen = 64,
		.ifa_flags = flags | IFA_F_PERMANENT,
		.valid_lft = INFINITY_LIFE_TIME,
		.preferred_lft = INFINITY_LIFE_TIME,
		.scope = IFA_LINK
	};
3196
	struct inet6_ifaddr *ifp;
3197 3198

#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
3199 3200
	if ((dev_net(idev->dev)->ipv6.devconf_all->optimistic_dad ||
	     idev->cnf.optimistic_dad) &&
3201
	    !dev_net(idev->dev)->ipv6.devconf_all->forwarding)
3202
		cfg.ifa_flags |= IFA_F_OPTIMISTIC;
3203
#endif
L
Linus Torvalds 已提交
3204

3205
	ifp = ipv6_add_addr(idev, &cfg, true, NULL);
L
Linus Torvalds 已提交
3206
	if (!IS_ERR(ifp)) {
3207
		addrconf_prefix_route(&ifp->addr, ifp->prefix_len, 0, idev->dev,
3208
				      0, 0, GFP_ATOMIC);
3209
		addrconf_dad_start(ifp);
L
Linus Torvalds 已提交
3210 3211 3212
		in6_ifa_put(ifp);
	}
}
3213
EXPORT_SYMBOL_GPL(addrconf_add_linklocal);
L
Linus Torvalds 已提交
3214

3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235
static bool ipv6_reserved_interfaceid(struct in6_addr address)
{
	if ((address.s6_addr32[2] | address.s6_addr32[3]) == 0)
		return true;

	if (address.s6_addr32[2] == htonl(0x02005eff) &&
	    ((address.s6_addr32[3] & htonl(0xfe000000)) == htonl(0xfe000000)))
		return true;

	if (address.s6_addr32[2] == htonl(0xfdffffff) &&
	    ((address.s6_addr32[3] & htonl(0xffffff80)) == htonl(0xffffff80)))
		return true;

	return false;
}

static int ipv6_generate_stable_address(struct in6_addr *address,
					u8 dad_count,
					const struct inet6_dev *idev)
{
	static DEFINE_SPINLOCK(lock);
3236 3237
	static __u32 digest[SHA1_DIGEST_WORDS];
	static __u32 workspace[SHA1_WORKSPACE_WORDS];
3238 3239

	static union {
3240
		char __data[SHA1_BLOCK_SIZE];
3241 3242
		struct {
			struct in6_addr secret;
3243
			__be32 prefix[2];
3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264
			unsigned char hwaddr[MAX_ADDR_LEN];
			u8 dad_count;
		} __packed;
	} data;

	struct in6_addr secret;
	struct in6_addr temp;
	struct net *net = dev_net(idev->dev);

	BUILD_BUG_ON(sizeof(data.__data) != sizeof(data));

	if (idev->cnf.stable_secret.initialized)
		secret = idev->cnf.stable_secret.secret;
	else if (net->ipv6.devconf_dflt->stable_secret.initialized)
		secret = net->ipv6.devconf_dflt->stable_secret.secret;
	else
		return -1;

retry:
	spin_lock_bh(&lock);

3265
	sha1_init(digest);
3266 3267 3268
	memset(&data, 0, sizeof(data));
	memset(workspace, 0, sizeof(workspace));
	memcpy(data.hwaddr, idev->dev->perm_addr, idev->dev->addr_len);
3269 3270
	data.prefix[0] = address->s6_addr32[0];
	data.prefix[1] = address->s6_addr32[1];
3271 3272 3273
	data.secret = secret;
	data.dad_count = dad_count;

3274
	sha1_transform(digest, data.__data, workspace);
3275 3276

	temp = *address;
3277 3278
	temp.s6_addr32[2] = (__force __be32)digest[0];
	temp.s6_addr32[3] = (__force __be32)digest[1];
3279 3280 3281 3282 3283

	spin_unlock_bh(&lock);

	if (ipv6_reserved_interfaceid(temp)) {
		dad_count++;
3284
		if (dad_count > dev_net(idev->dev)->ipv6.sysctl.idgen_retries)
3285 3286 3287 3288 3289 3290 3291 3292
			return -1;
		goto retry;
	}

	*address = temp;
	return 0;
}

3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303
static void ipv6_gen_mode_random_init(struct inet6_dev *idev)
{
	struct ipv6_stable_secret *s = &idev->cnf.stable_secret;

	if (s->initialized)
		return;
	s = &idev->cnf.stable_secret;
	get_random_bytes(&s->secret, sizeof(s->secret));
	s->initialized = true;
}

3304 3305
static void addrconf_addr_gen(struct inet6_dev *idev, bool prefix_route)
{
3306 3307
	struct in6_addr addr;

D
David Ahern 已提交
3308 3309 3310 3311
	/* no link local addresses on L3 master devices */
	if (netif_is_l3_master(idev->dev))
		return;

3312 3313 3314 3315
	/* no link local addresses on devices flagged as slaves */
	if (idev->dev->flags & IFF_SLAVE)
		return;

3316
	ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0);
3317

3318
	switch (idev->cnf.addr_gen_mode) {
3319 3320
	case IN6_ADDR_GEN_MODE_RANDOM:
		ipv6_gen_mode_random_init(idev);
J
Joe Perches 已提交
3321
		fallthrough;
3322
	case IN6_ADDR_GEN_MODE_STABLE_PRIVACY:
3323
		if (!ipv6_generate_stable_address(&addr, 0, idev))
3324 3325
			addrconf_add_linklocal(idev, &addr,
					       IFA_F_STABLE_PRIVACY);
3326
		else if (prefix_route)
3327
			addrconf_prefix_route(&addr, 64, 0, idev->dev,
3328
					      0, 0, GFP_KERNEL);
3329 3330
		break;
	case IN6_ADDR_GEN_MODE_EUI64:
3331 3332 3333 3334 3335
		/* 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)
3336
			addrconf_add_linklocal(idev, &addr, 0);
3337
		else if (prefix_route)
3338
			addrconf_prefix_route(&addr, 64, 0, idev->dev,
3339
					      0, 0, GFP_KERNEL);
3340 3341 3342 3343 3344
		break;
	case IN6_ADDR_GEN_MODE_NONE:
	default:
		/* will not add any link local address */
		break;
3345 3346 3347
	}
}

L
Linus Torvalds 已提交
3348 3349
static void addrconf_dev_config(struct net_device *dev)
{
3350
	struct inet6_dev *idev;
L
Linus Torvalds 已提交
3351 3352 3353

	ASSERT_RTNL();

3354 3355 3356
	if ((dev->type != ARPHRD_ETHER) &&
	    (dev->type != ARPHRD_FDDI) &&
	    (dev->type != ARPHRD_ARCNET) &&
3357
	    (dev->type != ARPHRD_INFINIBAND) &&
3358
	    (dev->type != ARPHRD_IEEE1394) &&
3359
	    (dev->type != ARPHRD_TUNNEL6) &&
3360
	    (dev->type != ARPHRD_6LOWPAN) &&
3361 3362 3363
	    (dev->type != ARPHRD_IP6GRE) &&
	    (dev->type != ARPHRD_IPGRE) &&
	    (dev->type != ARPHRD_TUNNEL) &&
3364 3365
	    (dev->type != ARPHRD_NONE) &&
	    (dev->type != ARPHRD_RAWIP)) {
3366
		/* Alas, we support only Ethernet autoconfiguration. */
3367 3368 3369 3370
		idev = __in6_dev_get(dev);
		if (!IS_ERR_OR_NULL(idev) && dev->flags & IFF_UP &&
		    dev->flags & IFF_MULTICAST)
			ipv6_mc_up(idev);
3371 3372 3373
		return;
	}

L
Linus Torvalds 已提交
3374
	idev = addrconf_add_dev(dev);
3375
	if (IS_ERR(idev))
L
Linus Torvalds 已提交
3376 3377
		return;

3378 3379
	/* this device type has no EUI support */
	if (dev->type == ARPHRD_NONE &&
3380 3381
	    idev->cnf.addr_gen_mode == IN6_ADDR_GEN_MODE_EUI64)
		idev->cnf.addr_gen_mode = IN6_ADDR_GEN_MODE_RANDOM;
3382

3383
	addrconf_addr_gen(idev, false);
L
Linus Torvalds 已提交
3384 3385
}

A
Amerigo Wang 已提交
3386
#if IS_ENABLED(CONFIG_IPV6_SIT)
L
Linus Torvalds 已提交
3387 3388 3389 3390 3391 3392
static void addrconf_sit_config(struct net_device *dev)
{
	struct inet6_dev *idev;

	ASSERT_RTNL();

3393 3394 3395
	/*
	 * Configure the tunnel with one of our IPv4
	 * addresses... we should configure all of
L
Linus Torvalds 已提交
3396 3397 3398
	 * our v4 addrs in the tunnel
	 */

3399
	idev = ipv6_find_idev(dev);
3400
	if (IS_ERR(idev)) {
3401
		pr_debug("%s: add_dev failed\n", __func__);
L
Linus Torvalds 已提交
3402 3403 3404
		return;
	}

F
Fred L. Templin 已提交
3405
	if (dev->priv_flags & IFF_ISATAP) {
3406
		addrconf_addr_gen(idev, false);
F
Fred L. Templin 已提交
3407 3408 3409
		return;
	}

L
Linus Torvalds 已提交
3410 3411
	sit_add_v4_addrs(idev);

3412
	if (dev->flags&IFF_POINTOPOINT)
L
Linus Torvalds 已提交
3413 3414
		addrconf_add_mroute(dev);
}
3415
#endif
L
Linus Torvalds 已提交
3416

A
Amerigo Wang 已提交
3417
#if IS_ENABLED(CONFIG_NET_IPGRE)
3418 3419 3420 3421 3422 3423
static void addrconf_gre_config(struct net_device *dev)
{
	struct inet6_dev *idev;

	ASSERT_RTNL();

3424
	idev = ipv6_find_idev(dev);
3425
	if (IS_ERR(idev)) {
3426
		pr_debug("%s: add_dev failed\n", __func__);
3427 3428 3429
		return;
	}

3430
	addrconf_addr_gen(idev, true);
3431 3432
	if (dev->flags & IFF_POINTOPOINT)
		addrconf_add_mroute(dev);
3433 3434 3435
}
#endif

3436 3437
static int fixup_permanent_addr(struct net *net,
				struct inet6_dev *idev,
3438 3439
				struct inet6_ifaddr *ifp)
{
3440
	/* !fib6_node means the host route was removed from the
3441 3442 3443
	 * FIB, for example, if 'lo' device is taken down. In that
	 * case regenerate the host route.
	 */
3444
	if (!ifp->rt || !ifp->rt->fib6_node) {
3445
		struct fib6_info *f6i, *prev;
3446

3447 3448 3449 3450
		f6i = addrconf_f6i_alloc(net, idev, &ifp->addr, false,
					 GFP_ATOMIC);
		if (IS_ERR(f6i))
			return PTR_ERR(f6i);
3451

3452 3453 3454
		/* ifp->rt can be accessed outside of rtnl */
		spin_lock(&ifp->lock);
		prev = ifp->rt;
3455
		ifp->rt = f6i;
3456 3457
		spin_unlock(&ifp->lock);

3458
		fib6_info_release(prev);
3459 3460 3461 3462
	}

	if (!(ifp->flags & IFA_F_NOPREFIXROUTE)) {
		addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
3463 3464
				      ifp->rt_priority, idev->dev, 0, 0,
				      GFP_ATOMIC);
3465 3466
	}

3467 3468
	if (ifp->state == INET6_IFADDR_STATE_PREDAD)
		addrconf_dad_start(ifp);
3469 3470 3471 3472

	return 0;
}

3473
static void addrconf_permanent_addr(struct net *net, struct net_device *dev)
3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485
{
	struct inet6_ifaddr *ifp, *tmp;
	struct inet6_dev *idev;

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

	write_lock_bh(&idev->lock);

	list_for_each_entry_safe(ifp, tmp, &idev->addr_list, if_list) {
		if ((ifp->flags & IFA_F_PERMANENT) &&
3486
		    fixup_permanent_addr(net, idev, ifp) < 0) {
3487
			write_unlock_bh(&idev->lock);
3488
			in6_ifa_hold(ifp);
3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499
			ipv6_del_addr(ifp);
			write_lock_bh(&idev->lock);

			net_info_ratelimited("%s: Failed to add prefix route for address %pI6c; dropping\n",
					     idev->dev->name, &ifp->addr);
		}
	}

	write_unlock_bh(&idev->lock);
}

3500
static int addrconf_notify(struct notifier_block *this, unsigned long event,
3501
			   void *ptr)
L
Linus Torvalds 已提交
3502
{
3503
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3504
	struct netdev_notifier_change_info *change_info;
3505
	struct netdev_notifier_changeupper_info *info;
3506
	struct inet6_dev *idev = __in6_dev_get(dev);
3507
	struct net *net = dev_net(dev);
3508
	int run_pending = 0;
3509
	int err;
L
Linus Torvalds 已提交
3510

S
Stephen Hemminger 已提交
3511
	switch (event) {
3512
	case NETDEV_REGISTER:
3513
		if (!idev && dev->mtu >= IPV6_MIN_MTU) {
3514
			idev = ipv6_add_dev(dev);
3515 3516
			if (IS_ERR(idev))
				return notifier_from_errno(PTR_ERR(idev));
3517 3518
		}
		break;
S
Stephen Hemminger 已提交
3519

3520 3521 3522
	case NETDEV_CHANGEMTU:
		/* if MTU under IPV6_MIN_MTU stop IPv6 on this interface. */
		if (dev->mtu < IPV6_MIN_MTU) {
3523
			addrconf_ifdown(dev, dev != net->loopback_dev);
3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542
			break;
		}

		if (idev) {
			rt6_mtu_change(dev, dev->mtu);
			idev->cnf.mtu6 = dev->mtu;
			break;
		}

		/* allocate new idev */
		idev = ipv6_add_dev(dev);
		if (IS_ERR(idev))
			break;

		/* device is still not ready */
		if (!(idev->if_flags & IF_READY))
			break;

		run_pending = 1;
J
Joe Perches 已提交
3543
		fallthrough;
L
Linus Torvalds 已提交
3544
	case NETDEV_UP:
3545
	case NETDEV_CHANGE:
3546 3547 3548
		if (dev->flags & IFF_SLAVE)
			break;

3549 3550 3551
		if (idev && idev->cnf.disable_ipv6)
			break;

3552
		if (event == NETDEV_UP) {
3553
			/* restore routes for permanent addresses */
3554
			addrconf_permanent_addr(net, dev);
3555

3556
			if (!addrconf_link_ready(dev)) {
3557
				/* device is not ready yet. */
3558 3559
				pr_debug("ADDRCONF(NETDEV_UP): %s: link is not ready\n",
					 dev->name);
3560 3561
				break;
			}
3562

3563 3564 3565
			if (!idev && dev->mtu >= IPV6_MIN_MTU)
				idev = ipv6_add_dev(dev);

3566
			if (!IS_ERR_OR_NULL(idev)) {
3567
				idev->if_flags |= IF_READY;
3568 3569
				run_pending = 1;
			}
3570
		} else if (event == NETDEV_CHANGE) {
3571
			if (!addrconf_link_ready(dev)) {
3572
				/* device is still not ready. */
3573
				rt6_sync_down_dev(dev, event);
3574 3575 3576
				break;
			}

3577
			if (!IS_ERR_OR_NULL(idev)) {
3578 3579 3580 3581 3582 3583 3584
				if (idev->if_flags & IF_READY) {
					/* device is already configured -
					 * but resend MLD reports, we might
					 * have roamed and need to update
					 * multicast snooping switches
					 */
					ipv6_mc_up(idev);
3585 3586 3587
					change_info = ptr;
					if (change_info->flags_changed & IFF_NOARP)
						addrconf_dad_run(idev, true);
3588
					rt6_sync_up(dev, RTNH_F_LINKDOWN);
3589
					break;
3590
				}
3591 3592 3593
				idev->if_flags |= IF_READY;
			}

3594 3595
			pr_info("ADDRCONF(NETDEV_CHANGE): %s: link becomes ready\n",
				dev->name);
3596

3597
			run_pending = 1;
3598 3599
		}

S
Stephen Hemminger 已提交
3600
		switch (dev->type) {
A
Amerigo Wang 已提交
3601
#if IS_ENABLED(CONFIG_IPV6_SIT)
L
Linus Torvalds 已提交
3602 3603 3604
		case ARPHRD_SIT:
			addrconf_sit_config(dev);
			break;
3605
#endif
A
Amerigo Wang 已提交
3606
#if IS_ENABLED(CONFIG_NET_IPGRE)
3607 3608 3609
		case ARPHRD_IPGRE:
			addrconf_gre_config(dev);
			break;
3610
#endif
L
Linus Torvalds 已提交
3611 3612 3613 3614 3615 3616 3617
		case ARPHRD_LOOPBACK:
			init_loopback(dev);
			break;

		default:
			addrconf_dev_config(dev);
			break;
3618
		}
S
Stephen Hemminger 已提交
3619

3620
		if (!IS_ERR_OR_NULL(idev)) {
3621
			if (run_pending)
3622
				addrconf_dad_run(idev, false);
3623

3624 3625 3626
			/* Device has an address by now */
			rt6_sync_up(dev, RTNH_F_DEAD);

S
Stephen Hemminger 已提交
3627 3628 3629 3630
			/*
			 * 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 已提交
3631
			 */
S
Stephen Hemminger 已提交
3632 3633
			if (idev->cnf.mtu6 != dev->mtu &&
			    dev->mtu >= IPV6_MIN_MTU) {
L
Linus Torvalds 已提交
3634 3635 3636 3637 3638
				rt6_mtu_change(dev, dev->mtu);
				idev->cnf.mtu6 = dev->mtu;
			}
			idev->tstamp = jiffies;
			inet6_ifinfo_notify(RTM_NEWLINK, idev);
S
Stephen Hemminger 已提交
3639 3640 3641 3642

			/*
			 * If the changed mtu during down is lower than
			 * IPV6_MIN_MTU stop IPv6 on this interface.
L
Linus Torvalds 已提交
3643 3644
			 */
			if (dev->mtu < IPV6_MIN_MTU)
3645
				addrconf_ifdown(dev, dev != net->loopback_dev);
L
Linus Torvalds 已提交
3646 3647 3648 3649 3650 3651 3652 3653 3654 3655
		}
		break;

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

L
Linus Torvalds 已提交
3657 3658
	case NETDEV_CHANGENAME:
		if (idev) {
3659
			snmp6_unregister_dev(idev);
3660
			addrconf_sysctl_unregister(idev);
3661
			err = addrconf_sysctl_register(idev);
3662 3663
			if (err)
				return notifier_from_errno(err);
3664 3665 3666 3667 3668
			err = snmp6_register_dev(idev);
			if (err) {
				addrconf_sysctl_unregister(idev);
				return notifier_from_errno(err);
			}
3669
		}
L
Linus Torvalds 已提交
3670
		break;
S
Stephen Hemminger 已提交
3671

3672 3673
	case NETDEV_PRE_TYPE_CHANGE:
	case NETDEV_POST_TYPE_CHANGE:
3674 3675
		if (idev)
			addrconf_type_change(dev, event);
3676
		break;
3677 3678 3679 3680 3681 3682 3683 3684

	case NETDEV_CHANGEUPPER:
		info = ptr;

		/* flush all routes if dev is linked to or unlinked from
		 * an L3 master device (e.g., VRF)
		 */
		if (info->upper_dev && netif_is_l3_master(info->upper_dev))
3685
			addrconf_ifdown(dev, false);
3686
	}
L
Linus Torvalds 已提交
3687 3688 3689 3690 3691 3692 3693 3694 3695

	return NOTIFY_OK;
}

/*
 *	addrconf module should be notified of a device going up
 */
static struct notifier_block ipv6_dev_notf = {
	.notifier_call = addrconf_notify,
3696
	.priority = ADDRCONF_NOTIFY_PRIORITY,
L
Linus Torvalds 已提交
3697 3698
};

3699
static void addrconf_type_change(struct net_device *dev, unsigned long event)
3700 3701 3702 3703 3704 3705
{
	struct inet6_dev *idev;
	ASSERT_RTNL();

	idev = __in6_dev_get(dev);

3706
	if (event == NETDEV_POST_TYPE_CHANGE)
3707
		ipv6_mc_remap(idev);
3708
	else if (event == NETDEV_PRE_TYPE_CHANGE)
3709 3710 3711
		ipv6_mc_unmap(idev);
}

3712 3713 3714 3715 3716 3717
static bool addr_is_local(const struct in6_addr *addr)
{
	return ipv6_addr_type(addr) &
		(IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
}

3718
static int addrconf_ifdown(struct net_device *dev, bool unregister)
L
Linus Torvalds 已提交
3719
{
3720
	unsigned long event = unregister ? NETDEV_UNREGISTER : NETDEV_DOWN;
3721
	struct net *net = dev_net(dev);
3722
	struct inet6_dev *idev;
3723 3724
	struct inet6_ifaddr *ifa;
	LIST_HEAD(tmp_addr_list);
3725
	bool keep_addr = false;
3726
	bool was_ready;
3727
	int state, i;
L
Linus Torvalds 已提交
3728 3729 3730

	ASSERT_RTNL();

3731
	rt6_disable_ip(dev, event);
L
Linus Torvalds 已提交
3732 3733

	idev = __in6_dev_get(dev);
3734
	if (!idev)
L
Linus Torvalds 已提交
3735 3736
		return -ENODEV;

S
Stephen Hemminger 已提交
3737 3738 3739
	/*
	 * Step 1: remove reference to ipv6 device from parent device.
	 *	   Do not dev_put!
L
Linus Torvalds 已提交
3740
	 */
3741
	if (unregister) {
L
Linus Torvalds 已提交
3742
		idev->dead = 1;
3743 3744

		/* protected by rtnl_lock */
3745
		RCU_INIT_POINTER(dev->ip6_ptr, NULL);
L
Linus Torvalds 已提交
3746 3747 3748 3749 3750 3751

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

	}

3752 3753 3754
	/* combine the user config with event to determine if permanent
	 * addresses are to be removed from address hash table
	 */
3755
	if (!unregister && !idev->cnf.disable_ipv6) {
3756 3757 3758 3759 3760 3761 3762 3763
		/* aggregate the system setting and interface setting */
		int _keep_addr = net->ipv6.devconf_all->keep_addr_on_down;

		if (!_keep_addr)
			_keep_addr = idev->cnf.keep_addr_on_down;

		keep_addr = (_keep_addr > 0);
	}
3764

3765 3766 3767 3768 3769
	/* 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);
3770
restart:
3771
		hlist_for_each_entry_rcu(ifa, h, addr_lst) {
3772
			if (ifa->idev == idev) {
3773
				addrconf_del_dad_work(ifa);
3774 3775 3776 3777
				/* combined flag + permanent flag decide if
				 * address is retained on a down event
				 */
				if (!keep_addr ||
3778 3779
				    !(ifa->flags & IFA_F_PERMANENT) ||
				    addr_is_local(&ifa->addr)) {
3780 3781 3782
					hlist_del_init_rcu(&ifa->addr_lst);
					goto restart;
				}
3783 3784 3785 3786 3787
			}
		}
		spin_unlock_bh(&addrconf_hash_lock);
	}

L
Linus Torvalds 已提交
3788 3789
	write_lock_bh(&idev->lock);

3790 3791
	addrconf_del_rs_timer(idev);

3792 3793 3794 3795
	/* Step 2: clear flags for stateless addrconf, repeated down
	 *         detection
	 */
	was_ready = idev->if_flags & IF_READY;
3796
	if (!unregister)
3797
		idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY);
L
Linus Torvalds 已提交
3798

S
Stephen Hemminger 已提交
3799
	/* Step 3: clear tempaddr list */
3800 3801 3802 3803
	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 已提交
3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814
		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);
	}
3815

3816 3817 3818 3819 3820
	list_for_each_entry(ifa, &idev->addr_list, if_list)
		list_add_tail(&ifa->if_list_aux, &tmp_addr_list);
	write_unlock_bh(&idev->lock);

	while (!list_empty(&tmp_addr_list)) {
3821
		struct fib6_info *rt = NULL;
3822
		bool keep;
3823

3824 3825 3826 3827
		ifa = list_first_entry(&tmp_addr_list,
				       struct inet6_ifaddr, if_list_aux);
		list_del(&ifa->if_list_aux);

3828
		addrconf_del_dad_work(ifa);
3829

3830 3831 3832
		keep = keep_addr && (ifa->flags & IFA_F_PERMANENT) &&
			!addr_is_local(&ifa->addr);

3833
		spin_lock_bh(&ifa->lock);
3834

3835
		if (keep) {
3836 3837
			/* set state to skip the notifier below */
			state = INET6_IFADDR_STATE_DEAD;
3838
			ifa->state = INET6_IFADDR_STATE_PREDAD;
3839 3840
			if (!(ifa->flags & IFA_F_NODAD))
				ifa->flags |= IFA_F_TENTATIVE;
3841 3842 3843

			rt = ifa->rt;
			ifa->rt = NULL;
3844 3845 3846 3847 3848
		} else {
			state = ifa->state;
			ifa->state = INET6_IFADDR_STATE_DEAD;
		}

3849
		spin_unlock_bh(&ifa->lock);
3850

3851
		if (rt)
3852
			ip6_del_rt(net, rt, false);
3853

3854 3855
		if (state != INET6_IFADDR_STATE_DEAD) {
			__ipv6_ifa_notify(RTM_DELADDR, ifa);
3856
			inet6addr_notifier_call_chain(NETDEV_DOWN, ifa);
3857 3858 3859 3860
		} else {
			if (idev->cnf.forwarding)
				addrconf_leave_anycast(ifa);
			addrconf_leave_solict(ifa->idev, &ifa->addr);
3861
		}
3862

3863
		if (!keep) {
3864
			write_lock_bh(&idev->lock);
3865
			list_del_rcu(&ifa->if_list);
3866
			write_unlock_bh(&idev->lock);
3867 3868
			in6_ifa_put(ifa);
		}
3869
	}
3870

3871
	/* Step 5: Discard anycast and multicast list */
3872
	if (unregister) {
3873
		ipv6_ac_destroy_dev(idev);
L
Linus Torvalds 已提交
3874
		ipv6_mc_destroy_dev(idev);
3875
	} else if (was_ready) {
L
Linus Torvalds 已提交
3876
		ipv6_mc_down(idev);
3877
	}
L
Linus Torvalds 已提交
3878 3879

	idev->tstamp = jiffies;
3880

S
Stephen Hemminger 已提交
3881
	/* Last: Shot the device (if unregistered) */
3882
	if (unregister) {
3883
		addrconf_sysctl_unregister(idev);
L
Linus Torvalds 已提交
3884 3885 3886 3887 3888 3889 3890
		neigh_parms_release(&nd_tbl, idev->nd_parms);
		neigh_ifdown(&nd_tbl, dev);
		in6_dev_put(idev);
	}
	return 0;
}

3891
static void addrconf_rs_timer(struct timer_list *t)
L
Linus Torvalds 已提交
3892
{
3893
	struct inet6_dev *idev = from_timer(idev, t, rs_timer);
3894
	struct net_device *dev = idev->dev;
3895
	struct in6_addr lladdr;
L
Linus Torvalds 已提交
3896

3897
	write_lock(&idev->lock);
S
stephen hemminger 已提交
3898
	if (idev->dead || !(idev->if_flags & IF_READY))
L
Linus Torvalds 已提交
3899 3900
		goto out;

3901
	if (!ipv6_accept_ra(idev))
S
stephen hemminger 已提交
3902 3903 3904 3905
		goto out;

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

3908
	if (idev->rs_probes++ < idev->cnf.rtr_solicits || idev->cnf.rtr_solicits < 0) {
3909 3910 3911
		write_unlock(&idev->lock);
		if (!ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
			ndisc_send_rs(dev, &lladdr,
3912 3913
				      &in6addr_linklocal_allrouters);
		else
3914
			goto put;
L
Linus Torvalds 已提交
3915

3916
		write_lock(&idev->lock);
3917 3918
		idev->rs_interval = rfc3315_s14_backoff_update(
			idev->rs_interval, idev->cnf.rtr_solicit_max_interval);
3919 3920 3921 3922
		/* 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 :
3923
				      idev->rs_interval);
L
Linus Torvalds 已提交
3924 3925 3926 3927 3928
	} else {
		/*
		 * Note: we do not support deprecated "all on-link"
		 * assumption any longer.
		 */
3929
		pr_debug("%s: no IPv6 routers present\n", idev->dev->name);
L
Linus Torvalds 已提交
3930 3931 3932
	}

out:
3933
	write_unlock(&idev->lock);
3934
put:
3935
	in6_dev_put(idev);
L
Linus Torvalds 已提交
3936 3937 3938 3939 3940
}

/*
 *	Duplicate Address Detection
 */
3941 3942 3943 3944
static void addrconf_dad_kick(struct inet6_ifaddr *ifp)
{
	unsigned long rand_num;
	struct inet6_dev *idev = ifp->idev;
3945
	u64 nonce;
3946

3947 3948 3949
	if (ifp->flags & IFA_F_OPTIMISTIC)
		rand_num = 0;
	else
3950
		rand_num = prandom_u32() % (idev->cnf.rtr_solicit_delay ? : 1);
3951

3952 3953 3954 3955 3956 3957 3958 3959
	nonce = 0;
	if (idev->cnf.enhanced_dad ||
	    dev_net(idev->dev)->ipv6.devconf_all->enhanced_dad) {
		do
			get_random_bytes(&nonce, 6);
		while (nonce == 0);
	}
	ifp->dad_nonce = nonce;
3960
	ifp->dad_probes = idev->cnf.dad_transmits;
3961
	addrconf_mod_dad_work(ifp, rand_num);
3962 3963
}

3964
static void addrconf_dad_begin(struct inet6_ifaddr *ifp)
L
Linus Torvalds 已提交
3965 3966 3967
{
	struct inet6_dev *idev = ifp->idev;
	struct net_device *dev = idev->dev;
3968
	bool bump_id, notify = false;
3969
	struct net *net;
L
Linus Torvalds 已提交
3970 3971 3972

	addrconf_join_solict(dev, &ifp->addr);

3973
	prandom_seed((__force u32) ifp->addr.s6_addr32[3]);
L
Linus Torvalds 已提交
3974 3975

	read_lock_bh(&idev->lock);
3976
	spin_lock(&ifp->lock);
3977
	if (ifp->state == INET6_IFADDR_STATE_DEAD)
L
Linus Torvalds 已提交
3978 3979
		goto out;

3980
	net = dev_net(dev);
L
Linus Torvalds 已提交
3981
	if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) ||
3982
	    (net->ipv6.devconf_all->accept_dad < 1 &&
3983
	     idev->cnf.accept_dad < 1) ||
3984 3985
	    !(ifp->flags&IFA_F_TENTATIVE) ||
	    ifp->flags & IFA_F_NODAD) {
3986 3987 3988 3989 3990
		bool send_na = false;

		if (ifp->flags & IFA_F_TENTATIVE &&
		    !(ifp->flags & IFA_F_OPTIMISTIC))
			send_na = true;
3991
		bump_id = ifp->flags & IFA_F_TENTATIVE;
B
Brian Haley 已提交
3992
		ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
3993
		spin_unlock(&ifp->lock);
L
Linus Torvalds 已提交
3994 3995
		read_unlock_bh(&idev->lock);

3996
		addrconf_dad_completed(ifp, bump_id, send_na);
L
Linus Torvalds 已提交
3997 3998 3999
		return;
	}

4000
	if (!(idev->if_flags & IF_READY)) {
4001
		spin_unlock(&ifp->lock);
4002
		read_unlock_bh(&idev->lock);
4003
		/*
4004
		 * If the device is not ready:
4005 4006 4007 4008
		 * - keep it tentative if it is a permanent address.
		 * - otherwise, kill it.
		 */
		in6_ifa_hold(ifp);
B
Brian Haley 已提交
4009
		addrconf_dad_stop(ifp, 0);
4010
		return;
4011
	}
4012 4013 4014 4015 4016

	/*
	 * Optimistic nodes can start receiving
	 * Frames right away
	 */
4017
	if (ifp->flags & IFA_F_OPTIMISTIC) {
4018 4019
		ip6_ins_rt(net, ifp->rt);
		if (ipv6_use_optimistic_addr(net, idev)) {
4020 4021 4022
			/* Because optimistic nodes can use this address,
			 * notify listeners. If DAD fails, RTM_DELADDR is sent.
			 */
4023
			notify = true;
4024 4025
		}
	}
4026

4027
	addrconf_dad_kick(ifp);
L
Linus Torvalds 已提交
4028
out:
4029
	spin_unlock(&ifp->lock);
L
Linus Torvalds 已提交
4030
	read_unlock_bh(&idev->lock);
4031 4032
	if (notify)
		ipv6_ifa_notify(RTM_NEWADDR, ifp);
L
Linus Torvalds 已提交
4033 4034
}

4035
static void addrconf_dad_start(struct inet6_ifaddr *ifp)
L
Linus Torvalds 已提交
4036
{
4037 4038
	bool begin_dad = false;

4039
	spin_lock_bh(&ifp->lock);
4040 4041 4042 4043
	if (ifp->state != INET6_IFADDR_STATE_DEAD) {
		ifp->state = INET6_IFADDR_STATE_PREDAD;
		begin_dad = true;
	}
4044
	spin_unlock_bh(&ifp->lock);
4045 4046 4047 4048 4049 4050 4051 4052 4053 4054

	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 已提交
4055
	struct inet6_dev *idev = ifp->idev;
4056
	bool bump_id, disable_ipv6 = false;
L
Linus Torvalds 已提交
4057 4058
	struct in6_addr mcaddr;

4059 4060 4061 4062 4063 4064 4065 4066
	enum {
		DAD_PROCESS,
		DAD_BEGIN,
		DAD_ABORT,
	} action = DAD_PROCESS;

	rtnl_lock();

4067
	spin_lock_bh(&ifp->lock);
4068 4069 4070 4071 4072 4073
	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;
4074

4075 4076 4077
		if ((dev_net(idev->dev)->ipv6.devconf_all->accept_dad > 1 ||
		     idev->cnf.accept_dad > 1) &&
		    !idev->cnf.disable_ipv6 &&
4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093
		    !(ifp->flags & IFA_F_STABLE_PRIVACY)) {
			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 */
				idev->cnf.disable_ipv6 = 1;

				pr_info("%s: IPv6 being disabled!\n",
					ifp->idev->dev->name);
				disable_ipv6 = true;
			}
		}
4094
	}
4095
	spin_unlock_bh(&ifp->lock);
4096 4097 4098 4099 4100

	if (action == DAD_BEGIN) {
		addrconf_dad_begin(ifp);
		goto out;
	} else if (action == DAD_ABORT) {
4101
		in6_ifa_hold(ifp);
4102
		addrconf_dad_stop(ifp, 1);
4103
		if (disable_ipv6)
4104
			addrconf_ifdown(idev->dev, false);
4105 4106 4107
		goto out;
	}

4108
	if (!ifp->dad_probes && addrconf_dad_end(ifp))
H
Herbert Xu 已提交
4109 4110
		goto out;

4111
	write_lock_bh(&idev->lock);
4112
	if (idev->dead || !(idev->if_flags & IF_READY)) {
4113
		write_unlock_bh(&idev->lock);
L
Linus Torvalds 已提交
4114 4115
		goto out;
	}
4116 4117

	spin_lock(&ifp->lock);
4118 4119
	if (ifp->state == INET6_IFADDR_STATE_DEAD) {
		spin_unlock(&ifp->lock);
4120
		write_unlock_bh(&idev->lock);
4121 4122 4123
		goto out;
	}

4124
	if (ifp->dad_probes == 0) {
4125 4126
		bool send_na = false;

L
Linus Torvalds 已提交
4127 4128 4129 4130
		/*
		 * DAD was successful
		 */

4131 4132 4133
		if (ifp->flags & IFA_F_TENTATIVE &&
		    !(ifp->flags & IFA_F_OPTIMISTIC))
			send_na = true;
4134
		bump_id = ifp->flags & IFA_F_TENTATIVE;
B
Brian Haley 已提交
4135
		ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
4136
		spin_unlock(&ifp->lock);
4137
		write_unlock_bh(&idev->lock);
L
Linus Torvalds 已提交
4138

4139
		addrconf_dad_completed(ifp, bump_id, send_na);
L
Linus Torvalds 已提交
4140 4141 4142 4143

		goto out;
	}

4144
	ifp->dad_probes--;
4145
	addrconf_mod_dad_work(ifp,
4146 4147
			      max(NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME),
				  HZ/100));
4148
	spin_unlock(&ifp->lock);
4149
	write_unlock_bh(&idev->lock);
L
Linus Torvalds 已提交
4150 4151 4152

	/* send a neighbour solicitation for our addr */
	addrconf_addr_solict_mult(&ifp->addr, &mcaddr);
4153 4154
	ndisc_send_ns(ifp->idev->dev, &ifp->addr, &mcaddr, &in6addr_any,
		      ifp->dad_nonce);
L
Linus Torvalds 已提交
4155 4156
out:
	in6_ifa_put(ifp);
4157
	rtnl_unlock();
L
Linus Torvalds 已提交
4158 4159
}

4160 4161 4162 4163 4164 4165
/* 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;

4166 4167 4168
	list_for_each_entry_reverse(ifpiter, &idev->addr_list, if_list) {
		if (ifpiter->scope > IFA_LINK)
			break;
4169 4170 4171 4172 4173 4174 4175 4176 4177
		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;
}

4178 4179
static void addrconf_dad_completed(struct inet6_ifaddr *ifp, bool bump_id,
				   bool send_na)
L
Linus Torvalds 已提交
4180
{
S
Stephen Hemminger 已提交
4181
	struct net_device *dev = ifp->idev->dev;
4182
	struct in6_addr lladdr;
4183
	bool send_rs, send_mld;
4184

4185
	addrconf_del_dad_work(ifp);
L
Linus Torvalds 已提交
4186 4187 4188 4189 4190 4191 4192

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

	ipv6_ifa_notify(RTM_NEWADDR, ifp);

4193 4194
	/* If added prefix is link local and we are prepared to process
	   router advertisements, start sending router solicitations.
L
Linus Torvalds 已提交
4195 4196
	 */

4197
	read_lock_bh(&ifp->idev->lock);
4198
	send_mld = ifp->scope == IFA_LINK && ipv6_lonely_lladdr(ifp);
4199 4200
	send_rs = send_mld &&
		  ipv6_accept_ra(ifp->idev) &&
4201
		  ifp->idev->cnf.rtr_solicits != 0 &&
4202 4203
		  (dev->flags & IFF_LOOPBACK) == 0 &&
		  (dev->type != ARPHRD_TUNNEL);
4204 4205
	read_unlock_bh(&ifp->idev->lock);

4206 4207 4208 4209 4210 4211
	/* 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);

4212 4213 4214 4215 4216 4217 4218 4219 4220 4221
	/* send unsolicited NA if enabled */
	if (send_na &&
	    (ifp->idev->cnf.ndisc_notify ||
	     dev_net(dev)->ipv6.devconf_all->ndisc_notify)) {
		ndisc_send_na(dev, &in6addr_linklocal_allnodes, &ifp->addr,
			      /*router=*/ !!ifp->idev->cnf.forwarding,
			      /*solicited=*/ false, /*override=*/ true,
			      /*inc_opt=*/ true);
	}

4222
	if (send_rs) {
L
Linus Torvalds 已提交
4223 4224 4225 4226 4227
		/*
		 *	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
		 */
4228
		if (ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
4229
			return;
4230
		ndisc_send_rs(dev, &lladdr, &in6addr_linklocal_allrouters);
L
Linus Torvalds 已提交
4231

4232 4233
		write_lock_bh(&ifp->idev->lock);
		spin_lock(&ifp->lock);
4234 4235
		ifp->idev->rs_interval = rfc3315_s14_backoff_init(
			ifp->idev->cnf.rtr_solicit_interval);
4236
		ifp->idev->rs_probes = 1;
L
Linus Torvalds 已提交
4237
		ifp->idev->if_flags |= IF_RS_SENT;
4238
		addrconf_mod_rs_timer(ifp->idev, ifp->idev->rs_interval);
4239 4240
		spin_unlock(&ifp->lock);
		write_unlock_bh(&ifp->idev->lock);
L
Linus Torvalds 已提交
4241
	}
4242 4243 4244

	if (bump_id)
		rt_genid_bump_ipv6(dev_net(dev));
4245 4246 4247 4248 4249 4250

	/* Make sure that a new temporary address will be created
	 * before this temporary address becomes deprecated.
	 */
	if (ifp->flags & IFA_F_TEMPORARY)
		addrconf_verify_rtnl();
L
Linus Torvalds 已提交
4251 4252
}

4253
static void addrconf_dad_run(struct inet6_dev *idev, bool restart)
S
Stephen Hemminger 已提交
4254
{
4255 4256 4257
	struct inet6_ifaddr *ifp;

	read_lock_bh(&idev->lock);
4258
	list_for_each_entry(ifp, &idev->addr_list, if_list) {
4259
		spin_lock(&ifp->lock);
4260 4261 4262 4263
		if ((ifp->flags & IFA_F_TENTATIVE &&
		     ifp->state == INET6_IFADDR_STATE_DAD) || restart) {
			if (restart)
				ifp->state = INET6_IFADDR_STATE_PREDAD;
H
Herbert Xu 已提交
4264
			addrconf_dad_kick(ifp);
4265
		}
4266
		spin_unlock(&ifp->lock);
4267 4268 4269 4270
	}
	read_unlock_bh(&idev->lock);
}

L
Linus Torvalds 已提交
4271 4272
#ifdef CONFIG_PROC_FS
struct if6_iter_state {
4273
	struct seq_net_private p;
L
Linus Torvalds 已提交
4274
	int bucket;
4275
	int offset;
L
Linus Torvalds 已提交
4276 4277
};

4278
static struct inet6_ifaddr *if6_get_first(struct seq_file *seq, loff_t pos)
L
Linus Torvalds 已提交
4279 4280
{
	struct if6_iter_state *state = seq->private;
4281
	struct net *net = seq_file_net(seq);
4282
	struct inet6_ifaddr *ifa = NULL;
4283
	int p = 0;
L
Linus Torvalds 已提交
4284

4285 4286 4287 4288 4289 4290 4291
	/* initial bucket if pos is 0 */
	if (pos == 0) {
		state->bucket = 0;
		state->offset = 0;
	}

	for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {
4292
		hlist_for_each_entry_rcu(ifa, &inet6_addr_lst[state->bucket],
4293
					 addr_lst) {
4294 4295
			if (!net_eq(dev_net(ifa->idev->dev), net))
				continue;
4296 4297 4298 4299 4300
			/* sync with offset */
			if (p < state->offset) {
				p++;
				continue;
			}
4301
			return ifa;
4302 4303 4304 4305 4306
		}

		/* prepare for next bucket */
		state->offset = 0;
		p = 0;
L
Linus Torvalds 已提交
4307
	}
4308
	return NULL;
L
Linus Torvalds 已提交
4309 4310
}

4311 4312
static struct inet6_ifaddr *if6_get_next(struct seq_file *seq,
					 struct inet6_ifaddr *ifa)
L
Linus Torvalds 已提交
4313 4314
{
	struct if6_iter_state *state = seq->private;
4315
	struct net *net = seq_file_net(seq);
L
Linus Torvalds 已提交
4316

4317
	hlist_for_each_entry_continue_rcu(ifa, addr_lst) {
4318 4319
		if (!net_eq(dev_net(ifa->idev->dev), net))
			continue;
4320
		state->offset++;
4321
		return ifa;
4322
	}
4323

4324
	state->offset = 0;
4325
	while (++state->bucket < IN6_ADDR_HSIZE) {
4326
		hlist_for_each_entry_rcu(ifa,
4327
				     &inet6_addr_lst[state->bucket], addr_lst) {
4328 4329 4330
			if (!net_eq(dev_net(ifa->idev->dev), net))
				continue;
			return ifa;
4331
		}
L
Linus Torvalds 已提交
4332
	}
4333

4334
	return NULL;
L
Linus Torvalds 已提交
4335 4336 4337
}

static void *if6_seq_start(struct seq_file *seq, loff_t *pos)
4338
	__acquires(rcu)
L
Linus Torvalds 已提交
4339
{
4340
	rcu_read_lock();
4341
	return if6_get_first(seq, *pos);
L
Linus Torvalds 已提交
4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353
}

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)
4354
	__releases(rcu)
L
Linus Torvalds 已提交
4355
{
4356
	rcu_read_unlock();
L
Linus Torvalds 已提交
4357 4358 4359 4360 4361
}

static int if6_seq_show(struct seq_file *seq, void *v)
{
	struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v;
4362
	seq_printf(seq, "%pi6 %02x %02x %02x %02x %8s\n",
4363
		   &ifp->addr,
L
Linus Torvalds 已提交
4364 4365 4366
		   ifp->idev->dev->ifindex,
		   ifp->prefix_len,
		   ifp->scope,
4367
		   (u8) ifp->flags,
L
Linus Torvalds 已提交
4368 4369 4370 4371
		   ifp->idev->dev->name);
	return 0;
}

4372
static const struct seq_operations if6_seq_ops = {
L
Linus Torvalds 已提交
4373 4374 4375 4376 4377 4378
	.start	= if6_seq_start,
	.next	= if6_seq_next,
	.show	= if6_seq_show,
	.stop	= if6_seq_stop,
};

4379
static int __net_init if6_proc_net_init(struct net *net)
L
Linus Torvalds 已提交
4380
{
4381 4382
	if (!proc_create_net("if_inet6", 0444, net->proc_net, &if6_seq_ops,
			sizeof(struct if6_iter_state)))
L
Linus Torvalds 已提交
4383 4384 4385 4386
		return -ENOMEM;
	return 0;
}

4387
static void __net_exit if6_proc_net_exit(struct net *net)
4388
{
4389
	remove_proc_entry("if_inet6", net->proc_net);
4390 4391 4392
}

static struct pernet_operations if6_proc_net_ops = {
4393 4394
	.init = if6_proc_net_init,
	.exit = if6_proc_net_exit,
4395 4396 4397 4398 4399 4400 4401
};

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

L
Linus Torvalds 已提交
4402 4403
void if6_proc_exit(void)
{
4404
	unregister_pernet_subsys(&if6_proc_net_ops);
L
Linus Torvalds 已提交
4405 4406 4407
}
#endif	/* CONFIG_PROC_FS */

A
Amerigo Wang 已提交
4408
#if IS_ENABLED(CONFIG_IPV6_MIP6)
4409
/* Check if address is a home address configured on any interface. */
4410
int ipv6_chk_home_addr(struct net *net, const struct in6_addr *addr)
4411
{
4412
	unsigned int hash = inet6_addr_hash(net, addr);
4413
	struct inet6_ifaddr *ifp = NULL;
4414
	int ret = 0;
4415

4416 4417
	rcu_read_lock();
	hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
4418
		if (!net_eq(dev_net(ifp->idev->dev), net))
4419
			continue;
4420
		if (ipv6_addr_equal(&ifp->addr, addr) &&
4421 4422 4423 4424 4425
		    (ifp->flags & IFA_F_HOMEADDRESS)) {
			ret = 1;
			break;
		}
	}
4426
	rcu_read_unlock();
4427 4428 4429 4430
	return ret;
}
#endif

4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 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 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483
/* RFC6554 has some algorithm to avoid loops in segment routing by
 * checking if the segments contains any of a local interface address.
 *
 * Quote:
 *
 * To detect loops in the SRH, a router MUST determine if the SRH
 * includes multiple addresses assigned to any interface on that router.
 * If such addresses appear more than once and are separated by at least
 * one address not assigned to that router.
 */
int ipv6_chk_rpl_srh_loop(struct net *net, const struct in6_addr *segs,
			  unsigned char nsegs)
{
	const struct in6_addr *addr;
	int i, ret = 0, found = 0;
	struct inet6_ifaddr *ifp;
	bool separated = false;
	unsigned int hash;
	bool hash_found;

	rcu_read_lock();
	for (i = 0; i < nsegs; i++) {
		addr = &segs[i];
		hash = inet6_addr_hash(net, addr);

		hash_found = false;
		hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
			if (!net_eq(dev_net(ifp->idev->dev), net))
				continue;

			if (ipv6_addr_equal(&ifp->addr, addr)) {
				hash_found = true;
				break;
			}
		}

		if (hash_found) {
			if (found > 1 && separated) {
				ret = 1;
				break;
			}

			separated = false;
			found++;
		} else {
			separated = true;
		}
	}
	rcu_read_unlock();

	return ret;
}

L
Linus Torvalds 已提交
4484 4485 4486 4487
/*
 *	Periodic address status verification
 */

4488
static void addrconf_verify_rtnl(void)
L
Linus Torvalds 已提交
4489
{
4490
	unsigned long now, next, next_sec, next_sched;
L
Linus Torvalds 已提交
4491 4492 4493
	struct inet6_ifaddr *ifp;
	int i;

4494 4495
	ASSERT_RTNL();

4496
	rcu_read_lock_bh();
L
Linus Torvalds 已提交
4497
	now = jiffies;
4498
	next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
L
Linus Torvalds 已提交
4499

4500
	cancel_delayed_work(&addr_chk_work);
L
Linus Torvalds 已提交
4501

S
Stephen Hemminger 已提交
4502
	for (i = 0; i < IN6_ADDR_HSIZE; i++) {
L
Linus Torvalds 已提交
4503
restart:
4504
		hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[i], addr_lst) {
L
Linus Torvalds 已提交
4505 4506
			unsigned long age;

4507 4508 4509 4510 4511 4512
			/* 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 已提交
4513 4514 4515
				continue;

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

4519 4520
			if (ifp->valid_lft != INFINITY_LIFE_TIME &&
			    age >= ifp->valid_lft) {
L
Linus Torvalds 已提交
4521 4522 4523 4524
				spin_unlock(&ifp->lock);
				in6_ifa_hold(ifp);
				ipv6_del_addr(ifp);
				goto restart;
4525 4526 4527
			} else if (ifp->prefered_lft == INFINITY_LIFE_TIME) {
				spin_unlock(&ifp->lock);
				continue;
L
Linus Torvalds 已提交
4528
			} else if (age >= ifp->prefered_lft) {
4529
				/* jiffies - ifp->tstamp > age >= ifp->prefered_lft */
L
Linus Torvalds 已提交
4530 4531 4532 4533 4534 4535 4536
				int deprecate = 0;

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

4537 4538
				if ((ifp->valid_lft != INFINITY_LIFE_TIME) &&
				    (time_before(ifp->tstamp + ifp->valid_lft * HZ, next)))
L
Linus Torvalds 已提交
4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551
					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)) {
4552 4553
				unsigned long regen_advance = ifp->idev->cnf.regen_max_retry *
					ifp->idev->cnf.dad_transmits *
4554
					max(NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME), HZ/100) / HZ;
4555

L
Linus Torvalds 已提交
4556 4557 4558 4559 4560 4561 4562 4563 4564
				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);
4565

4566 4567 4568
						spin_lock(&ifpub->lock);
						ifpub->regen_count = 0;
						spin_unlock(&ifpub->lock);
4569
						rcu_read_unlock_bh();
4570
						ipv6_create_tempaddr(ifpub, true);
L
Linus Torvalds 已提交
4571 4572
						in6_ifa_put(ifpub);
						in6_ifa_put(ifp);
4573
						rcu_read_lock_bh();
L
Linus Torvalds 已提交
4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587
						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);
			}
		}
	}

4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598
	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;

4599 4600
	pr_debug("now = %lu, schedule = %lu, rounded schedule = %lu => %lu\n",
		 now, next, next_sec, next_sched);
4601
	mod_delayed_work(addrconf_wq, &addr_chk_work, next_sched - now);
4602
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
4603 4604
}

4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616
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);
}

4617 4618
static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local,
				     struct in6_addr **peer_pfx)
4619 4620 4621
{
	struct in6_addr *pfx = NULL;

4622 4623
	*peer_pfx = NULL;

4624 4625 4626 4627 4628
	if (addr)
		pfx = nla_data(addr);

	if (local) {
		if (pfx && nla_memcmp(local, pfx, sizeof(*pfx)))
4629 4630
			*peer_pfx = pfx;
		pfx = nla_data(local);
4631 4632 4633 4634 4635
	}

	return pfx;
}

4636
static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = {
4637 4638 4639
	[IFA_ADDRESS]		= { .len = sizeof(struct in6_addr) },
	[IFA_LOCAL]		= { .len = sizeof(struct in6_addr) },
	[IFA_CACHEINFO]		= { .len = sizeof(struct ifa_cacheinfo) },
4640
	[IFA_FLAGS]		= { .len = sizeof(u32) },
4641
	[IFA_RT_PRIORITY]	= { .len = sizeof(u32) },
4642
	[IFA_TARGET_NETNSID]	= { .type = NLA_S32 },
4643 4644
};

L
Linus Torvalds 已提交
4645
static int
4646 4647
inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh,
		  struct netlink_ext_ack *extack)
L
Linus Torvalds 已提交
4648
{
4649
	struct net *net = sock_net(skb->sk);
4650 4651
	struct ifaddrmsg *ifm;
	struct nlattr *tb[IFA_MAX+1];
4652
	struct in6_addr *pfx, *peer_pfx;
4653
	u32 ifa_flags;
4654
	int err;
L
Linus Torvalds 已提交
4655

4656 4657
	err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFA_MAX,
				     ifa_ipv6_policy, extack);
4658 4659 4660 4661
	if (err < 0)
		return err;

	ifm = nlmsg_data(nlh);
4662
	pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
4663
	if (!pfx)
L
Linus Torvalds 已提交
4664 4665
		return -EINVAL;

4666 4667 4668 4669 4670 4671 4672
	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 已提交
4673 4674
}

4675
static int modify_prefix_route(struct inet6_ifaddr *ifp,
4676 4677
			       unsigned long expires, u32 flags,
			       bool modify_peer)
4678 4679
{
	struct fib6_info *f6i;
4680
	u32 prio;
4681

4682 4683
	f6i = addrconf_get_prefix_route(modify_peer ? &ifp->peer_addr : &ifp->addr,
					ifp->prefix_len,
4684
					ifp->idev->dev, 0, RTF_DEFAULT, true);
4685 4686 4687
	if (!f6i)
		return -ENOENT;

4688 4689 4690
	prio = ifp->rt_priority ? : IP6_RT_PRIO_ADDRCONF;
	if (f6i->fib6_metric != prio) {
		/* delete old one */
4691
		ip6_del_rt(dev_net(ifp->idev->dev), f6i, false);
4692

4693
		/* add new one */
4694 4695
		addrconf_prefix_route(modify_peer ? &ifp->peer_addr : &ifp->addr,
				      ifp->prefix_len,
4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709
				      ifp->rt_priority, ifp->idev->dev,
				      expires, flags, GFP_KERNEL);
	} else {
		if (!expires)
			fib6_clean_expires(f6i);
		else
			fib6_set_expires(f6i, expires);

		fib6_info_release(f6i);
	}

	return 0;
}

4710
static int inet6_addr_modify(struct inet6_ifaddr *ifp, struct ifa6_config *cfg)
4711
{
4712 4713
	u32 flags;
	clock_t expires;
4714
	unsigned long timeout;
4715
	bool was_managetempaddr;
4716
	bool had_prefixroute;
4717
	bool new_peer = false;
4718

4719 4720
	ASSERT_RTNL();

4721
	if (!cfg->valid_lft || cfg->preferred_lft > cfg->valid_lft)
4722 4723
		return -EINVAL;

4724
	if (cfg->ifa_flags & IFA_F_MANAGETEMPADDR &&
4725 4726 4727
	    (ifp->flags & IFA_F_TEMPORARY || ifp->prefix_len != 64))
		return -EINVAL;

4728
	if (!(ifp->flags & IFA_F_TENTATIVE) || ifp->flags & IFA_F_DADFAILED)
4729
		cfg->ifa_flags &= ~IFA_F_OPTIMISTIC;
4730

4731
	timeout = addrconf_timeout_fixup(cfg->valid_lft, HZ);
4732 4733
	if (addrconf_finite_timeout(timeout)) {
		expires = jiffies_to_clock_t(timeout * HZ);
4734
		cfg->valid_lft = timeout;
4735
		flags = RTF_EXPIRES;
4736 4737 4738
	} else {
		expires = 0;
		flags = 0;
4739
		cfg->ifa_flags |= IFA_F_PERMANENT;
4740
	}
4741

4742
	timeout = addrconf_timeout_fixup(cfg->preferred_lft, HZ);
4743 4744
	if (addrconf_finite_timeout(timeout)) {
		if (timeout == 0)
4745 4746
			cfg->ifa_flags |= IFA_F_DEPRECATED;
		cfg->preferred_lft = timeout;
4747
	}
4748

4749 4750 4751 4752 4753 4754 4755
	if (cfg->peer_pfx &&
	    memcmp(&ifp->peer_addr, cfg->peer_pfx, sizeof(struct in6_addr))) {
		if (!ipv6_addr_any(&ifp->peer_addr))
			cleanup_prefix_route(ifp, expires, true, true);
		new_peer = true;
	}

4756
	spin_lock_bh(&ifp->lock);
4757
	was_managetempaddr = ifp->flags & IFA_F_MANAGETEMPADDR;
4758 4759
	had_prefixroute = ifp->flags & IFA_F_PERMANENT &&
			  !(ifp->flags & IFA_F_NOPREFIXROUTE);
4760
	ifp->flags &= ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD |
4761 4762
			IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR |
			IFA_F_NOPREFIXROUTE);
4763
	ifp->flags |= cfg->ifa_flags;
4764
	ifp->tstamp = jiffies;
4765 4766
	ifp->valid_lft = cfg->valid_lft;
	ifp->prefered_lft = cfg->preferred_lft;
4767

4768 4769
	if (cfg->rt_priority && cfg->rt_priority != ifp->rt_priority)
		ifp->rt_priority = cfg->rt_priority;
4770

4771 4772 4773
	if (new_peer)
		ifp->peer_addr = *cfg->peer_pfx;

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

4778
	if (!(cfg->ifa_flags & IFA_F_NOPREFIXROUTE)) {
4779 4780 4781
		int rc = -ENOENT;

		if (had_prefixroute)
4782
			rc = modify_prefix_route(ifp, expires, flags, false);
4783 4784 4785 4786 4787 4788 4789

		/* prefix route could have been deleted; if so restore it */
		if (rc == -ENOENT) {
			addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
					      ifp->rt_priority, ifp->idev->dev,
					      expires, flags, GFP_KERNEL);
		}
4790 4791 4792 4793 4794 4795 4796 4797 4798

		if (had_prefixroute && !ipv6_addr_any(&ifp->peer_addr))
			rc = modify_prefix_route(ifp, expires, flags, true);

		if (rc == -ENOENT && !ipv6_addr_any(&ifp->peer_addr)) {
			addrconf_prefix_route(&ifp->peer_addr, ifp->prefix_len,
					      ifp->rt_priority, ifp->idev->dev,
					      expires, flags, GFP_KERNEL);
		}
4799 4800 4801 4802 4803 4804 4805 4806 4807 4808
	} 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,
4809
				action == CLEANUP_PREFIX_RT_DEL, false);
4810
		}
4811
	}
4812 4813

	if (was_managetempaddr || ifp->flags & IFA_F_MANAGETEMPADDR) {
4814 4815 4816 4817 4818 4819 4820 4821
		if (was_managetempaddr &&
		    !(ifp->flags & IFA_F_MANAGETEMPADDR)) {
			cfg->valid_lft = 0;
			cfg->preferred_lft = 0;
		}
		manage_tempaddrs(ifp->idev, ifp, cfg->valid_lft,
				 cfg->preferred_lft, !was_managetempaddr,
				 jiffies);
4822 4823
	}

4824
	addrconf_verify_rtnl();
4825 4826 4827 4828

	return 0;
}

L
Linus Torvalds 已提交
4829
static int
4830 4831
inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh,
		  struct netlink_ext_ack *extack)
L
Linus Torvalds 已提交
4832
{
4833
	struct net *net = sock_net(skb->sk);
4834 4835
	struct ifaddrmsg *ifm;
	struct nlattr *tb[IFA_MAX+1];
4836
	struct in6_addr *peer_pfx;
4837 4838
	struct inet6_ifaddr *ifa;
	struct net_device *dev;
4839
	struct inet6_dev *idev;
4840
	struct ifa6_config cfg;
4841
	int err;
L
Linus Torvalds 已提交
4842

4843 4844
	err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFA_MAX,
				     ifa_ipv6_policy, extack);
4845 4846 4847
	if (err < 0)
		return err;

4848 4849
	memset(&cfg, 0, sizeof(cfg));

4850
	ifm = nlmsg_data(nlh);
4851 4852
	cfg.pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
	if (!cfg.pfx)
L
Linus Torvalds 已提交
4853 4854
		return -EINVAL;

4855 4856
	cfg.peer_pfx = peer_pfx;
	cfg.plen = ifm->ifa_prefixlen;
4857 4858 4859
	if (tb[IFA_RT_PRIORITY])
		cfg.rt_priority = nla_get_u32(tb[IFA_RT_PRIORITY]);

4860 4861 4862
	cfg.valid_lft = INFINITY_LIFE_TIME;
	cfg.preferred_lft = INFINITY_LIFE_TIME;

4863
	if (tb[IFA_CACHEINFO]) {
4864
		struct ifa_cacheinfo *ci;
4865 4866

		ci = nla_data(tb[IFA_CACHEINFO]);
4867 4868
		cfg.valid_lft = ci->ifa_valid;
		cfg.preferred_lft = ci->ifa_prefered;
4869 4870
	}

4871
	dev =  __dev_get_by_index(net, ifm->ifa_index);
4872
	if (!dev)
4873 4874
		return -ENODEV;

4875 4876 4877 4878
	if (tb[IFA_FLAGS])
		cfg.ifa_flags = nla_get_u32(tb[IFA_FLAGS]);
	else
		cfg.ifa_flags = ifm->ifa_flags;
4879

4880
	/* We ignore other flags so far. */
4881 4882 4883
	cfg.ifa_flags &= IFA_F_NODAD | IFA_F_HOMEADDRESS |
			 IFA_F_MANAGETEMPADDR | IFA_F_NOPREFIXROUTE |
			 IFA_F_MCAUTOJOIN | IFA_F_OPTIMISTIC;
4884 4885

	idev = ipv6_find_idev(dev);
4886 4887
	if (IS_ERR(idev))
		return PTR_ERR(idev);
4888 4889

	if (!ipv6_allow_optimistic_dad(net, idev))
4890
		cfg.ifa_flags &= ~IFA_F_OPTIMISTIC;
4891

4892 4893
	if (cfg.ifa_flags & IFA_F_NODAD &&
	    cfg.ifa_flags & IFA_F_OPTIMISTIC) {
4894 4895 4896
		NL_SET_ERR_MSG(extack, "IFA_F_NODAD and IFA_F_OPTIMISTIC are mutually exclusive");
		return -EINVAL;
	}
4897

4898
	ifa = ipv6_get_ifaddr(net, cfg.pfx, dev, 1);
4899
	if (!ifa) {
4900 4901
		/*
		 * It would be best to check for !NLM_F_CREATE here but
4902
		 * userspace already relies on not having to provide this.
4903
		 */
4904
		return inet6_addr_add(net, ifm->ifa_index, &cfg, extack);
4905 4906
	}

4907 4908 4909 4910
	if (nlh->nlmsg_flags & NLM_F_EXCL ||
	    !(nlh->nlmsg_flags & NLM_F_REPLACE))
		err = -EEXIST;
	else
4911
		err = inet6_addr_modify(ifa, &cfg);
4912 4913 4914 4915

	in6_ifa_put(ifa);

	return err;
L
Linus Torvalds 已提交
4916 4917
}

4918
static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u32 flags,
4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930
			  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;
}

4931 4932 4933 4934 4935
static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
			 unsigned long tstamp, u32 preferred, u32 valid)
{
	struct ifa_cacheinfo ci;

4936 4937
	ci.cstamp = cstamp_delta(cstamp);
	ci.tstamp = cstamp_delta(tstamp);
4938 4939 4940 4941 4942 4943
	ci.ifa_prefered = preferred;
	ci.ifa_valid = valid;

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

4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955
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;
}

4956 4957
static inline int inet6_ifaddr_msgsize(void)
{
4958
	return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
4959
	       + nla_total_size(16) /* IFA_LOCAL */
4960
	       + nla_total_size(16) /* IFA_ADDRESS */
4961
	       + nla_total_size(sizeof(struct ifa_cacheinfo))
4962 4963
	       + nla_total_size(4)  /* IFA_FLAGS */
	       + nla_total_size(4)  /* IFA_RT_PRIORITY */;
4964
}
4965

4966 4967 4968 4969 4970 4971
enum addr_type_t {
	UNICAST_ADDR,
	MULTICAST_ADDR,
	ANYCAST_ADDR,
};

C
Christian Brauner 已提交
4972 4973 4974 4975 4976 4977
struct inet6_fill_args {
	u32 portid;
	u32 seq;
	int event;
	unsigned int flags;
	int netnsid;
4978
	int ifindex;
4979
	enum addr_type_t type;
C
Christian Brauner 已提交
4980 4981
};

L
Linus Torvalds 已提交
4982
static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
C
Christian Brauner 已提交
4983
			     struct inet6_fill_args *args)
L
Linus Torvalds 已提交
4984 4985
{
	struct nlmsghdr  *nlh;
4986
	u32 preferred, valid;
L
Linus Torvalds 已提交
4987

C
Christian Brauner 已提交
4988 4989
	nlh = nlmsg_put(skb, args->portid, args->seq, args->event,
			sizeof(struct ifaddrmsg), args->flags);
4990
	if (!nlh)
4991
		return -EMSGSIZE;
4992

4993 4994 4995
	put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope),
		      ifa->idev->dev->ifindex);

C
Christian Brauner 已提交
4996 4997
	if (args->netnsid >= 0 &&
	    nla_put_s32(skb, IFA_TARGET_NETNSID, args->netnsid))
4998 4999
		goto error;

5000
	spin_lock_bh(&ifa->lock);
5001 5002
	if (!((ifa->flags&IFA_F_PERMANENT) &&
	      (ifa->prefered_lft == INFINITY_LIFE_TIME))) {
5003 5004 5005
		preferred = ifa->prefered_lft;
		valid = ifa->valid_lft;
		if (preferred != INFINITY_LIFE_TIME) {
L
Linus Torvalds 已提交
5006
			long tval = (jiffies - ifa->tstamp)/HZ;
5007 5008 5009 5010
			if (preferred > tval)
				preferred -= tval;
			else
				preferred = 0;
5011 5012 5013 5014 5015 5016
			if (valid != INFINITY_LIFE_TIME) {
				if (valid > tval)
					valid -= tval;
				else
					valid = 0;
			}
L
Linus Torvalds 已提交
5017 5018
		}
	} else {
5019 5020 5021
		preferred = INFINITY_LIFE_TIME;
		valid = INFINITY_LIFE_TIME;
	}
5022
	spin_unlock_bh(&ifa->lock);
5023

C
Cong Wang 已提交
5024
	if (!ipv6_addr_any(&ifa->peer_addr)) {
5025 5026
		if (nla_put_in6_addr(skb, IFA_LOCAL, &ifa->addr) < 0 ||
		    nla_put_in6_addr(skb, IFA_ADDRESS, &ifa->peer_addr) < 0)
5027 5028
			goto error;
	} else
5029
		if (nla_put_in6_addr(skb, IFA_ADDRESS, &ifa->addr) < 0)
5030 5031
			goto error;

5032 5033 5034 5035
	if (ifa->rt_priority &&
	    nla_put_u32(skb, IFA_RT_PRIORITY, ifa->rt_priority))
		goto error;

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

5039 5040 5041
	if (nla_put_u32(skb, IFA_FLAGS, ifa->flags) < 0)
		goto error;

5042 5043
	nlmsg_end(skb, nlh);
	return 0;
5044 5045 5046 5047

error:
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
5048 5049 5050
}

static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca,
C
Christian Brauner 已提交
5051
			       struct inet6_fill_args *args)
L
Linus Torvalds 已提交
5052 5053
{
	struct nlmsghdr  *nlh;
5054 5055 5056 5057 5058
	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 已提交
5059

C
Christian Brauner 已提交
5060 5061
	nlh = nlmsg_put(skb, args->portid, args->seq, args->event,
			sizeof(struct ifaddrmsg), args->flags);
5062
	if (!nlh)
5063
		return -EMSGSIZE;
5064

C
Christian Brauner 已提交
5065
	if (args->netnsid >= 0 &&
5066 5067
	    nla_put_s32(skb, IFA_TARGET_NETNSID, args->netnsid)) {
		nlmsg_cancel(skb, nlh);
5068
		return -EMSGSIZE;
5069
	}
5070

5071
	put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
5072
	if (nla_put_in6_addr(skb, IFA_MULTICAST, &ifmca->mca_addr) < 0 ||
5073
	    put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp,
5074 5075 5076 5077
			  INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
		nlmsg_cancel(skb, nlh);
		return -EMSGSIZE;
	}
5078

5079 5080
	nlmsg_end(skb, nlh);
	return 0;
L
Linus Torvalds 已提交
5081 5082 5083
}

static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
C
Christian Brauner 已提交
5084
			       struct inet6_fill_args *args)
L
Linus Torvalds 已提交
5085
{
D
David Ahern 已提交
5086 5087
	struct net_device *dev = fib6_info_nh_dev(ifaca->aca_rt);
	int ifindex = dev ? dev->ifindex : 1;
L
Linus Torvalds 已提交
5088
	struct nlmsghdr  *nlh;
5089 5090 5091 5092
	u8 scope = RT_SCOPE_UNIVERSE;

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

C
Christian Brauner 已提交
5094 5095
	nlh = nlmsg_put(skb, args->portid, args->seq, args->event,
			sizeof(struct ifaddrmsg), args->flags);
5096
	if (!nlh)
5097
		return -EMSGSIZE;
5098

C
Christian Brauner 已提交
5099
	if (args->netnsid >= 0 &&
5100 5101
	    nla_put_s32(skb, IFA_TARGET_NETNSID, args->netnsid)) {
		nlmsg_cancel(skb, nlh);
5102
		return -EMSGSIZE;
5103
	}
5104

5105
	put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
5106
	if (nla_put_in6_addr(skb, IFA_ANYCAST, &ifaca->aca_addr) < 0 ||
5107
	    put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp,
5108 5109 5110 5111
			  INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
		nlmsg_cancel(skb, nlh);
		return -EMSGSIZE;
	}
L
Linus Torvalds 已提交
5112

5113 5114
	nlmsg_end(skb, nlh);
	return 0;
L
Linus Torvalds 已提交
5115 5116
}

E
Eric Dumazet 已提交
5117 5118
/* called with rcu_read_lock() */
static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
5119
			  struct netlink_callback *cb, int s_ip_idx,
5120
			  struct inet6_fill_args *fillargs)
E
Eric Dumazet 已提交
5121 5122 5123
{
	struct ifmcaddr6 *ifmca;
	struct ifacaddr6 *ifaca;
5124
	int ip_idx = 0;
E
Eric Dumazet 已提交
5125 5126 5127
	int err = 1;

	read_lock_bh(&idev->lock);
5128
	switch (fillargs->type) {
5129 5130
	case UNICAST_ADDR: {
		struct inet6_ifaddr *ifa;
5131
		fillargs->event = RTM_NEWADDR;
5132

E
Eric Dumazet 已提交
5133
		/* unicast address incl. temp addr */
5134
		list_for_each_entry(ifa, &idev->addr_list, if_list) {
5135 5136
			if (ip_idx < s_ip_idx)
				goto next;
5137
			err = inet6_fill_ifaddr(skb, ifa, fillargs);
5138
			if (err < 0)
E
Eric Dumazet 已提交
5139
				break;
5140
			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
5141 5142
next:
			ip_idx++;
E
Eric Dumazet 已提交
5143 5144
		}
		break;
5145
	}
E
Eric Dumazet 已提交
5146
	case MULTICAST_ADDR:
5147
		fillargs->event = RTM_GETMULTICAST;
C
Christian Brauner 已提交
5148

E
Eric Dumazet 已提交
5149 5150 5151 5152 5153
		/* multicast address */
		for (ifmca = idev->mc_list; ifmca;
		     ifmca = ifmca->next, ip_idx++) {
			if (ip_idx < s_ip_idx)
				continue;
5154
			err = inet6_fill_ifmcaddr(skb, ifmca, fillargs);
5155
			if (err < 0)
E
Eric Dumazet 已提交
5156 5157 5158 5159
				break;
		}
		break;
	case ANYCAST_ADDR:
5160
		fillargs->event = RTM_GETANYCAST;
E
Eric Dumazet 已提交
5161 5162 5163 5164 5165
		/* anycast address */
		for (ifaca = idev->ac_list; ifaca;
		     ifaca = ifaca->aca_next, ip_idx++) {
			if (ip_idx < s_ip_idx)
				continue;
5166
			err = inet6_fill_ifacaddr(skb, ifaca, fillargs);
5167
			if (err < 0)
E
Eric Dumazet 已提交
5168 5169 5170 5171 5172 5173 5174
				break;
		}
		break;
	default:
		break;
	}
	read_unlock_bh(&idev->lock);
5175
	cb->args[2] = ip_idx;
E
Eric Dumazet 已提交
5176 5177 5178
	return err;
}

5179 5180 5181
static int inet6_valid_dump_ifaddr_req(const struct nlmsghdr *nlh,
				       struct inet6_fill_args *fillargs,
				       struct net **tgt_net, struct sock *sk,
5182
				       struct netlink_callback *cb)
5183
{
5184
	struct netlink_ext_ack *extack = cb->extack;
5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198
	struct nlattr *tb[IFA_MAX+1];
	struct ifaddrmsg *ifm;
	int err, i;

	if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
		NL_SET_ERR_MSG_MOD(extack, "Invalid header for address dump request");
		return -EINVAL;
	}

	ifm = nlmsg_data(nlh);
	if (ifm->ifa_prefixlen || ifm->ifa_flags || ifm->ifa_scope) {
		NL_SET_ERR_MSG_MOD(extack, "Invalid values in header for address dump request");
		return -EINVAL;
	}
5199 5200 5201 5202 5203

	fillargs->ifindex = ifm->ifa_index;
	if (fillargs->ifindex) {
		cb->answer_flags |= NLM_F_DUMP_FILTERED;
		fillargs->flags |= NLM_F_DUMP_FILTERED;
5204 5205
	}

5206 5207
	err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFA_MAX,
					    ifa_ipv6_policy, extack);
5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220
	if (err < 0)
		return err;

	for (i = 0; i <= IFA_MAX; ++i) {
		if (!tb[i])
			continue;

		if (i == IFA_TARGET_NETNSID) {
			struct net *net;

			fillargs->netnsid = nla_get_s32(tb[i]);
			net = rtnl_get_net_ns_capable(sk, fillargs->netnsid);
			if (IS_ERR(net)) {
5221
				fillargs->netnsid = -1;
5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234
				NL_SET_ERR_MSG_MOD(extack, "Invalid target network namespace id");
				return PTR_ERR(net);
			}
			*tgt_net = net;
		} else {
			NL_SET_ERR_MSG_MOD(extack, "Unsupported attribute in dump request");
			return -EINVAL;
		}
	}

	return 0;
}

L
Linus Torvalds 已提交
5235 5236 5237
static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
			   enum addr_type_t type)
{
5238
	const struct nlmsghdr *nlh = cb->nlh;
5239 5240 5241 5242 5243 5244 5245
	struct inet6_fill_args fillargs = {
		.portid = NETLINK_CB(cb->skb).portid,
		.seq = cb->nlh->nlmsg_seq,
		.flags = NLM_F_MULTI,
		.netnsid = -1,
		.type = type,
	};
E
Eric Dumazet 已提交
5246
	struct net *net = sock_net(skb->sk);
5247
	struct net *tgt_net = net;
5248
	int idx, s_idx, s_ip_idx;
E
Eric Dumazet 已提交
5249
	int h, s_h;
L
Linus Torvalds 已提交
5250
	struct net_device *dev;
E
Eric Dumazet 已提交
5251 5252
	struct inet6_dev *idev;
	struct hlist_head *head;
5253
	int err = 0;
5254

E
Eric Dumazet 已提交
5255 5256
	s_h = cb->args[0];
	s_idx = idx = cb->args[1];
5257
	s_ip_idx = cb->args[2];
5258

5259 5260
	if (cb->strict_check) {
		err = inet6_valid_dump_ifaddr_req(nlh, &fillargs, &tgt_net,
5261
						  skb->sk, cb);
5262
		if (err < 0)
5263
			goto put_tgt_net;
5264

5265
		err = 0;
5266 5267
		if (fillargs.ifindex) {
			dev = __dev_get_by_index(tgt_net, fillargs.ifindex);
5268 5269 5270 5271
			if (!dev) {
				err = -ENODEV;
				goto put_tgt_net;
			}
5272 5273 5274 5275
			idev = __in6_dev_get(dev);
			if (idev) {
				err = in6_dump_addrs(idev, skb, cb, s_ip_idx,
						     &fillargs);
5276 5277
				if (err > 0)
					err = 0;
5278 5279 5280
			}
			goto put_tgt_net;
		}
5281 5282
	}

E
Eric Dumazet 已提交
5283
	rcu_read_lock();
5284
	cb->seq = atomic_read(&tgt_net->ipv6.dev_addr_genid) ^ tgt_net->dev_base_seq;
E
Eric Dumazet 已提交
5285 5286
	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
5287
		head = &tgt_net->dev_index_head[h];
5288
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
E
Eric Dumazet 已提交
5289 5290
			if (idx < s_idx)
				goto cont;
5291
			if (h > s_h || idx > s_idx)
E
Eric Dumazet 已提交
5292
				s_ip_idx = 0;
S
Stephen Hemminger 已提交
5293 5294
			idev = __in6_dev_get(dev);
			if (!idev)
E
Eric Dumazet 已提交
5295 5296
				goto cont;

5297
			if (in6_dump_addrs(idev, skb, cb, s_ip_idx,
5298
					   &fillargs) < 0)
E
Eric Dumazet 已提交
5299
				goto done;
5300
cont:
E
Eric Dumazet 已提交
5301 5302
			idx++;
		}
L
Linus Torvalds 已提交
5303
	}
E
Eric Dumazet 已提交
5304 5305 5306 5307
done:
	rcu_read_unlock();
	cb->args[0] = h;
	cb->args[1] = idx;
5308
put_tgt_net:
5309
	if (fillargs.netnsid >= 0)
5310
		put_net(tgt_net);
E
Eric Dumazet 已提交
5311

5312
	return skb->len ? : err;
L
Linus Torvalds 已提交
5313 5314 5315 5316 5317
}

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

L
Linus Torvalds 已提交
5319 5320 5321 5322 5323 5324
	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;
5325

L
Linus Torvalds 已提交
5326 5327 5328 5329 5330 5331 5332
	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;
5333

L
Linus Torvalds 已提交
5334 5335 5336
	return inet6_dump_addr(skb, cb, type);
}

5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349
static int inet6_rtm_valid_getaddr_req(struct sk_buff *skb,
				       const struct nlmsghdr *nlh,
				       struct nlattr **tb,
				       struct netlink_ext_ack *extack)
{
	struct ifaddrmsg *ifm;
	int i, err;

	if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
		NL_SET_ERR_MSG_MOD(extack, "Invalid header for get address request");
		return -EINVAL;
	}

5350 5351 5352 5353
	if (!netlink_strict_get_check(skb))
		return nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFA_MAX,
					      ifa_ipv6_policy, extack);

5354 5355 5356 5357 5358 5359
	ifm = nlmsg_data(nlh);
	if (ifm->ifa_prefixlen || ifm->ifa_flags || ifm->ifa_scope) {
		NL_SET_ERR_MSG_MOD(extack, "Invalid values in header for get address request");
		return -EINVAL;
	}

5360 5361
	err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFA_MAX,
					    ifa_ipv6_policy, extack);
5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382
	if (err)
		return err;

	for (i = 0; i <= IFA_MAX; i++) {
		if (!tb[i])
			continue;

		switch (i) {
		case IFA_TARGET_NETNSID:
		case IFA_ADDRESS:
		case IFA_LOCAL:
			break;
		default:
			NL_SET_ERR_MSG_MOD(extack, "Unsupported attribute in get address request");
			return -EINVAL;
		}
	}

	return 0;
}

5383 5384
static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh,
			     struct netlink_ext_ack *extack)
5385
{
5386
	struct net *net = sock_net(in_skb->sk);
C
Christian Brauner 已提交
5387 5388 5389 5390 5391 5392 5393
	struct inet6_fill_args fillargs = {
		.portid = NETLINK_CB(in_skb).portid,
		.seq = nlh->nlmsg_seq,
		.event = RTM_NEWADDR,
		.flags = 0,
		.netnsid = -1,
	};
5394
	struct net *tgt_net = net;
5395 5396
	struct ifaddrmsg *ifm;
	struct nlattr *tb[IFA_MAX+1];
5397
	struct in6_addr *addr = NULL, *peer;
5398 5399 5400 5401 5402
	struct net_device *dev = NULL;
	struct inet6_ifaddr *ifa;
	struct sk_buff *skb;
	int err;

5403
	err = inet6_rtm_valid_getaddr_req(in_skb, nlh, tb, extack);
5404
	if (err < 0)
5405
		return err;
5406

5407
	if (tb[IFA_TARGET_NETNSID]) {
C
Christian Brauner 已提交
5408
		fillargs.netnsid = nla_get_s32(tb[IFA_TARGET_NETNSID]);
5409 5410

		tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(in_skb).sk,
C
Christian Brauner 已提交
5411
						  fillargs.netnsid);
5412 5413 5414 5415
		if (IS_ERR(tgt_net))
			return PTR_ERR(tgt_net);
	}

5416
	addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer);
5417 5418
	if (!addr)
		return -EINVAL;
5419

5420
	ifm = nlmsg_data(nlh);
5421
	if (ifm->ifa_index)
5422
		dev = dev_get_by_index(tgt_net, ifm->ifa_index);
5423

5424
	ifa = ipv6_get_ifaddr(tgt_net, addr, dev, 1);
S
Stephen Hemminger 已提交
5425
	if (!ifa) {
5426 5427 5428
		err = -EADDRNOTAVAIL;
		goto errout;
	}
5429

S
Stephen Hemminger 已提交
5430 5431
	skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL);
	if (!skb) {
5432
		err = -ENOBUFS;
5433
		goto errout_ifa;
5434 5435
	}

C
Christian Brauner 已提交
5436
	err = inet6_fill_ifaddr(skb, ifa, &fillargs);
5437 5438 5439 5440 5441 5442
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout_ifa;
	}
5443
	err = rtnl_unicast(skb, tgt_net, NETLINK_CB(in_skb).portid);
5444
errout_ifa:
5445
	in6_ifa_put(ifa);
5446
errout:
5447 5448
	if (dev)
		dev_put(dev);
C
Christian Brauner 已提交
5449
	if (fillargs.netnsid >= 0)
5450 5451
		put_net(tgt_net);

5452 5453 5454
	return err;
}

L
Linus Torvalds 已提交
5455 5456 5457
static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa)
{
	struct sk_buff *skb;
5458
	struct net *net = dev_net(ifa->idev->dev);
C
Christian Brauner 已提交
5459 5460 5461 5462 5463 5464 5465
	struct inet6_fill_args fillargs = {
		.portid = 0,
		.seq = 0,
		.event = event,
		.flags = 0,
		.netnsid = -1,
	};
5466
	int err = -ENOBUFS;
L
Linus Torvalds 已提交
5467

5468
	skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC);
5469
	if (!skb)
5470 5471
		goto errout;

C
Christian Brauner 已提交
5472
	err = inet6_fill_ifaddr(skb, ifa, &fillargs);
5473 5474 5475 5476 5477 5478
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
5479 5480
	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC);
	return;
5481 5482
errout:
	if (err < 0)
5483
		rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err);
L
Linus Torvalds 已提交
5484 5485
}

D
Dave Jones 已提交
5486
static inline void ipv6_store_devconf(struct ipv6_devconf *cnf,
L
Linus Torvalds 已提交
5487 5488
				__s32 *array, int bytes)
{
5489 5490
	BUG_ON(bytes < (DEVCONF_MAX * 4));

L
Linus Torvalds 已提交
5491 5492 5493 5494 5495 5496 5497 5498 5499
	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;
5500 5501
	array[DEVCONF_RTR_SOLICIT_INTERVAL] =
		jiffies_to_msecs(cnf->rtr_solicit_interval);
5502 5503
	array[DEVCONF_RTR_SOLICIT_MAX_INTERVAL] =
		jiffies_to_msecs(cnf->rtr_solicit_max_interval);
5504 5505
	array[DEVCONF_RTR_SOLICIT_DELAY] =
		jiffies_to_msecs(cnf->rtr_solicit_delay);
L
Linus Torvalds 已提交
5506
	array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version;
5507 5508 5509 5510
	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 已提交
5511 5512 5513 5514 5515 5516
	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;
5517
	array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr;
5518
	array[DEVCONF_ACCEPT_RA_MIN_HOP_LIMIT] = cnf->accept_ra_min_hop_limit;
5519
	array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo;
5520 5521
#ifdef CONFIG_IPV6_ROUTER_PREF
	array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref;
5522 5523
	array[DEVCONF_RTR_PROBE_INTERVAL] =
		jiffies_to_msecs(cnf->rtr_probe_interval);
N
Neil Horman 已提交
5524
#ifdef CONFIG_IPV6_ROUTE_INFO
5525
	array[DEVCONF_ACCEPT_RA_RT_INFO_MIN_PLEN] = cnf->accept_ra_rt_info_min_plen;
5526 5527
	array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen;
#endif
5528
#endif
5529
	array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp;
5530
	array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route;
5531 5532
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
	array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad;
5533
	array[DEVCONF_USE_OPTIMISTIC] = cnf->use_optimistic;
5534
#endif
5535
#ifdef CONFIG_IPV6_MROUTE
E
Eric Dumazet 已提交
5536
	array[DEVCONF_MC_FORWARDING] = atomic_read(&cnf->mc_forwarding);
5537
#endif
5538
	array[DEVCONF_DISABLE_IPV6] = cnf->disable_ipv6;
5539
	array[DEVCONF_ACCEPT_DAD] = cnf->accept_dad;
5540
	array[DEVCONF_FORCE_TLLAO] = cnf->force_tllao;
5541
	array[DEVCONF_NDISC_NOTIFY] = cnf->ndisc_notify;
5542
	array[DEVCONF_SUPPRESS_FRAG_NDISC] = cnf->suppress_frag_ndisc;
5543
	array[DEVCONF_ACCEPT_RA_FROM_LOCAL] = cnf->accept_ra_from_local;
5544
	array[DEVCONF_ACCEPT_RA_MTU] = cnf->accept_ra_mtu;
5545
	array[DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN] = cnf->ignore_routes_with_linkdown;
5546
	/* we omit DEVCONF_STABLE_SECRET for now */
5547
	array[DEVCONF_USE_OIF_ADDRS_ONLY] = cnf->use_oif_addrs_only;
5548
	array[DEVCONF_DROP_UNICAST_IN_L2_MULTICAST] = cnf->drop_unicast_in_l2_multicast;
5549
	array[DEVCONF_DROP_UNSOLICITED_NA] = cnf->drop_unsolicited_na;
5550
	array[DEVCONF_KEEP_ADDR_ON_DOWN] = cnf->keep_addr_on_down;
5551
	array[DEVCONF_SEG6_ENABLED] = cnf->seg6_enabled;
5552 5553 5554
#ifdef CONFIG_IPV6_SEG6_HMAC
	array[DEVCONF_SEG6_REQUIRE_HMAC] = cnf->seg6_require_hmac;
#endif
5555
	array[DEVCONF_ENHANCED_DAD] = cnf->enhanced_dad;
5556
	array[DEVCONF_ADDR_GEN_MODE] = cnf->addr_gen_mode;
5557
	array[DEVCONF_DISABLE_POLICY] = cnf->disable_policy;
5558
	array[DEVCONF_NDISC_TCLASS] = cnf->ndisc_tclass;
5559
	array[DEVCONF_RPL_SEG_ENABLED] = cnf->rpl_seg_enabled;
L
Linus Torvalds 已提交
5560 5561
}

T
Thomas Graf 已提交
5562 5563 5564 5565 5566 5567
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 */
5568
	     + nla_total_size(ICMP6_MIB_MAX * 8) /* IFLA_INET6_ICMP6STATS */
5569 5570 5571
	     + nla_total_size(sizeof(struct in6_addr)) /* IFLA_INET6_TOKEN */
	     + nla_total_size(1) /* IFLA_INET6_ADDR_GEN_MODE */
	     + 0;
T
Thomas Graf 已提交
5572 5573
}

5574 5575 5576 5577 5578 5579 5580
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 */
5581
	       + nla_total_size(1) /* IFLA_OPERSTATE */
T
Thomas Graf 已提交
5582
	       + nla_total_size(inet6_ifla6_size()); /* IFLA_PROTINFO */
5583
}
5584

5585
static inline void __snmp6_fill_statsdev(u64 *stats, atomic_long_t *mib,
5586
					int bytes)
5587 5588
{
	int i;
5589
	int pad = bytes - sizeof(u64) * ICMP6_MIB_MAX;
5590 5591 5592
	BUG_ON(pad < 0);

	/* Use put_unaligned() because stats may not be aligned for u64. */
5593 5594
	put_unaligned(ICMP6_MIB_MAX, &stats[0]);
	for (i = 1; i < ICMP6_MIB_MAX; i++)
5595
		put_unaligned(atomic_long_read(&mib[i]), &stats[i]);
5596

5597
	memset(&stats[ICMP6_MIB_MAX], 0, pad);
5598 5599
}

W
WANG Cong 已提交
5600
static inline void __snmp6_fill_stats64(u64 *stats, void __percpu *mib,
5601
					int bytes, size_t syncpoff)
5602
{
5603 5604 5605 5606
	int i, c;
	u64 buff[IPSTATS_MIB_MAX];
	int pad = bytes - sizeof(u64) * IPSTATS_MIB_MAX;

5607 5608
	BUG_ON(pad < 0);

5609 5610
	memset(buff, 0, sizeof(buff));
	buff[0] = IPSTATS_MIB_MAX;
5611

5612 5613 5614 5615 5616 5617 5618
	for_each_possible_cpu(c) {
		for (i = 1; i < IPSTATS_MIB_MAX; i++)
			buff[i] += snmp_get_cpu_field64(mib, c, i, syncpoff);
	}

	memcpy(stats, buff, IPSTATS_MIB_MAX * sizeof(u64));
	memset(&stats[IPSTATS_MIB_MAX], 0, pad);
5619 5620
}

5621 5622 5623
static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype,
			     int bytes)
{
S
Stephen Hemminger 已提交
5624
	switch (attrtype) {
5625
	case IFLA_INET6_STATS:
5626 5627
		__snmp6_fill_stats64(stats, idev->stats.ipv6, bytes,
				     offsetof(struct ipstats_mib, syncp));
5628 5629
		break;
	case IFLA_INET6_ICMP6STATS:
5630
		__snmp6_fill_statsdev(stats, idev->stats.icmpv6dev->mibs, bytes);
5631 5632 5633 5634
		break;
	}
}

5635 5636
static int inet6_fill_ifla6_attrs(struct sk_buff *skb, struct inet6_dev *idev,
				  u32 ext_filter_mask)
T
Thomas Graf 已提交
5637 5638 5639 5640
{
	struct nlattr *nla;
	struct ifla_cacheinfo ci;

D
David S. Miller 已提交
5641 5642
	if (nla_put_u32(skb, IFLA_INET6_FLAGS, idev->if_flags))
		goto nla_put_failure;
T
Thomas Graf 已提交
5643
	ci.max_reasm_len = IPV6_MAXPLEN;
5644 5645
	ci.tstamp = cstamp_delta(idev->tstamp);
	ci.reachable_time = jiffies_to_msecs(idev->nd_parms->reachable_time);
J
Jiri Pirko 已提交
5646
	ci.retrans_time = jiffies_to_msecs(NEIGH_VAR(idev->nd_parms, RETRANS_TIME));
D
David S. Miller 已提交
5647 5648
	if (nla_put(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci))
		goto nla_put_failure;
T
Thomas Graf 已提交
5649
	nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32));
5650
	if (!nla)
T
Thomas Graf 已提交
5651 5652 5653 5654 5655
		goto nla_put_failure;
	ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla));

	/* XXX - MC not implemented */

5656 5657 5658
	if (ext_filter_mask & RTEXT_FILTER_SKIP_STATS)
		return 0;

T
Thomas Graf 已提交
5659
	nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64));
5660
	if (!nla)
T
Thomas Graf 已提交
5661 5662 5663 5664
		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));
5665
	if (!nla)
T
Thomas Graf 已提交
5666 5667 5668
		goto nla_put_failure;
	snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla));

5669
	nla = nla_reserve(skb, IFLA_INET6_TOKEN, sizeof(struct in6_addr));
5670
	if (!nla)
5671 5672 5673 5674 5675
		goto nla_put_failure;
	read_lock_bh(&idev->lock);
	memcpy(nla_data(nla), idev->token.s6_addr, nla_len(nla));
	read_unlock_bh(&idev->lock);

5676 5677 5678
	if (nla_put_u8(skb, IFLA_INET6_ADDR_GEN_MODE, idev->cnf.addr_gen_mode))
		goto nla_put_failure;

T
Thomas Graf 已提交
5679 5680 5681 5682 5683 5684
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

5685 5686
static size_t inet6_get_link_af_size(const struct net_device *dev,
				     u32 ext_filter_mask)
T
Thomas Graf 已提交
5687 5688 5689 5690 5691 5692 5693
{
	if (!__in6_dev_get(dev))
		return 0;

	return inet6_ifla6_size();
}

5694 5695
static int inet6_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
			      u32 ext_filter_mask)
T
Thomas Graf 已提交
5696 5697 5698 5699 5700 5701
{
	struct inet6_dev *idev = __in6_dev_get(dev);

	if (!idev)
		return -ENODATA;

5702
	if (inet6_fill_ifla6_attrs(skb, idev, ext_filter_mask) < 0)
T
Thomas Graf 已提交
5703 5704 5705 5706 5707
		return -EMSGSIZE;

	return 0;
}

5708 5709 5710 5711
static int inet6_set_iftoken(struct inet6_dev *idev, struct in6_addr *token)
{
	struct inet6_ifaddr *ifp;
	struct net_device *dev = idev->dev;
5712
	bool clear_token, update_rs = false;
5713
	struct in6_addr ll_addr;
5714

5715 5716
	ASSERT_RTNL();

5717
	if (!token)
5718 5719 5720 5721 5722
		return -EINVAL;
	if (dev->flags & (IFF_LOOPBACK | IFF_NOARP))
		return -EINVAL;
	if (!ipv6_accept_ra(idev))
		return -EINVAL;
5723
	if (idev->cnf.rtr_solicits == 0)
5724 5725 5726 5727 5728 5729 5730 5731 5732
		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);

5733 5734 5735 5736
	clear_token = ipv6_addr_any(token);
	if (clear_token)
		goto update_lft;

5737 5738 5739
	if (!idev->dead && (idev->if_flags & IF_READY) &&
	    !ipv6_get_lladdr(dev, &ll_addr, IFA_F_TENTATIVE |
			     IFA_F_OPTIMISTIC)) {
5740 5741 5742 5743 5744 5745
		/* 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;
	}
5746

5747
update_lft:
5748
	write_lock_bh(&idev->lock);
5749

5750
	if (update_rs) {
5751
		idev->if_flags |= IF_RS_SENT;
5752 5753
		idev->rs_interval = rfc3315_s14_backoff_init(
			idev->cnf.rtr_solicit_interval);
5754
		idev->rs_probes = 1;
5755
		addrconf_mod_rs_timer(idev, idev->rs_interval);
5756
	}
5757 5758 5759 5760

	/* Well, that's kinda nasty ... */
	list_for_each_entry(ifp, &idev->addr_list, if_list) {
		spin_lock(&ifp->lock);
5761
		if (ifp->tokenized) {
5762 5763 5764 5765 5766 5767 5768
			ifp->valid_lft = 0;
			ifp->prefered_lft = 0;
		}
		spin_unlock(&ifp->lock);
	}

	write_unlock_bh(&idev->lock);
5769
	inet6_ifinfo_notify(RTM_NEWLINK, idev);
5770
	addrconf_verify_rtnl();
5771 5772 5773
	return 0;
}

5774 5775 5776 5777 5778
static const struct nla_policy inet6_af_policy[IFLA_INET6_MAX + 1] = {
	[IFLA_INET6_ADDR_GEN_MODE]	= { .type = NLA_U8 },
	[IFLA_INET6_TOKEN]		= { .len = sizeof(struct in6_addr) },
};

5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798
static int check_addr_gen_mode(int mode)
{
	if (mode != IN6_ADDR_GEN_MODE_EUI64 &&
	    mode != IN6_ADDR_GEN_MODE_NONE &&
	    mode != IN6_ADDR_GEN_MODE_STABLE_PRIVACY &&
	    mode != IN6_ADDR_GEN_MODE_RANDOM)
		return -EINVAL;
	return 1;
}

static int check_stable_privacy(struct inet6_dev *idev, struct net *net,
				int mode)
{
	if (mode == IN6_ADDR_GEN_MODE_STABLE_PRIVACY &&
	    !idev->cnf.stable_secret.initialized &&
	    !net->ipv6.devconf_dflt->stable_secret.initialized)
		return -EINVAL;
	return 1;
}

5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831
static int inet6_validate_link_af(const struct net_device *dev,
				  const struct nlattr *nla)
{
	struct nlattr *tb[IFLA_INET6_MAX + 1];
	struct inet6_dev *idev = NULL;
	int err;

	if (dev) {
		idev = __in6_dev_get(dev);
		if (!idev)
			return -EAFNOSUPPORT;
	}

	err = nla_parse_nested_deprecated(tb, IFLA_INET6_MAX, nla,
					  inet6_af_policy, NULL);
	if (err)
		return err;

	if (!tb[IFLA_INET6_TOKEN] && !tb[IFLA_INET6_ADDR_GEN_MODE])
		return -EINVAL;

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

		if (check_addr_gen_mode(mode) < 0)
			return -EINVAL;
		if (dev && check_stable_privacy(idev, dev_net(dev), mode) < 0)
			return -EINVAL;
	}

	return 0;
}

5832 5833 5834 5835
static int inet6_set_link_af(struct net_device *dev, const struct nlattr *nla)
{
	struct inet6_dev *idev = __in6_dev_get(dev);
	struct nlattr *tb[IFLA_INET6_MAX + 1];
5836
	int err;
5837

5838 5839 5840
	if (!idev)
		return -EAFNOSUPPORT;

5841
	if (nla_parse_nested_deprecated(tb, IFLA_INET6_MAX, nla, NULL, NULL) < 0)
5842
		return -EINVAL;
5843

5844
	if (tb[IFLA_INET6_TOKEN]) {
5845
		err = inet6_set_iftoken(idev, nla_data(tb[IFLA_INET6_TOKEN]));
5846 5847 5848 5849 5850 5851 5852
		if (err)
			return err;
	}

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

5853
		idev->cnf.addr_gen_mode = mode;
5854
	}
5855

5856
	return 0;
5857 5858
}

5859
static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev,
5860
			     u32 portid, u32 seq, int event, unsigned int flags)
L
Linus Torvalds 已提交
5861
{
5862 5863 5864 5865 5866
	struct net_device *dev = idev->dev;
	struct ifinfomsg *hdr;
	struct nlmsghdr *nlh;
	void *protoinfo;

5867
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags);
5868
	if (!nlh)
5869
		return -EMSGSIZE;
5870 5871 5872 5873 5874 5875 5876 5877 5878

	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 已提交
5879 5880 5881 5882
	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) ||
5883
	    (dev->ifindex != dev_get_iflink(dev) &&
5884 5885 5886
	     nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))) ||
	    nla_put_u8(skb, IFLA_OPERSTATE,
		       netif_running(dev) ? dev->operstate : IF_OPER_DOWN))
D
David S. Miller 已提交
5887
		goto nla_put_failure;
5888
	protoinfo = nla_nest_start_noflag(skb, IFLA_PROTINFO);
5889
	if (!protoinfo)
5890
		goto nla_put_failure;
L
Linus Torvalds 已提交
5891

5892
	if (inet6_fill_ifla6_attrs(skb, idev, 0) < 0)
5893
		goto nla_put_failure;
L
Linus Torvalds 已提交
5894

5895
	nla_nest_end(skb, protoinfo);
5896 5897
	nlmsg_end(skb, nlh);
	return 0;
L
Linus Torvalds 已提交
5898

5899
nla_put_failure:
5900 5901
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
5902 5903
}

5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928
static int inet6_valid_dump_ifinfo(const struct nlmsghdr *nlh,
				   struct netlink_ext_ack *extack)
{
	struct ifinfomsg *ifm;

	if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
		NL_SET_ERR_MSG_MOD(extack, "Invalid header for link dump request");
		return -EINVAL;
	}

	if (nlmsg_attrlen(nlh, sizeof(*ifm))) {
		NL_SET_ERR_MSG_MOD(extack, "Invalid data after header");
		return -EINVAL;
	}

	ifm = nlmsg_data(nlh);
	if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
	    ifm->ifi_change || ifm->ifi_index) {
		NL_SET_ERR_MSG_MOD(extack, "Invalid values in header for dump request");
		return -EINVAL;
	}

	return 0;
}

L
Linus Torvalds 已提交
5929 5930
static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
{
5931
	struct net *net = sock_net(skb->sk);
E
Eric Dumazet 已提交
5932
	int h, s_h;
5933
	int idx = 0, s_idx;
L
Linus Torvalds 已提交
5934 5935
	struct net_device *dev;
	struct inet6_dev *idev;
E
Eric Dumazet 已提交
5936
	struct hlist_head *head;
L
Linus Torvalds 已提交
5937

5938 5939 5940 5941 5942 5943 5944 5945 5946 5947
	/* only requests using strict checking can pass data to
	 * influence the dump
	 */
	if (cb->strict_check) {
		int err = inet6_valid_dump_ifinfo(cb->nlh, cb->extack);

		if (err < 0)
			return err;
	}

E
Eric Dumazet 已提交
5948 5949 5950 5951 5952 5953 5954
	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];
5955
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
E
Eric Dumazet 已提交
5956 5957 5958 5959 5960 5961
			if (idx < s_idx)
				goto cont;
			idev = __in6_dev_get(dev);
			if (!idev)
				goto cont;
			if (inet6_fill_ifinfo(skb, idev,
5962
					      NETLINK_CB(cb->skb).portid,
E
Eric Dumazet 已提交
5963
					      cb->nlh->nlmsg_seq,
5964
					      RTM_NEWLINK, NLM_F_MULTI) < 0)
E
Eric Dumazet 已提交
5965
				goto out;
5966
cont:
E
Eric Dumazet 已提交
5967 5968
			idx++;
		}
L
Linus Torvalds 已提交
5969
	}
E
Eric Dumazet 已提交
5970 5971 5972 5973
out:
	rcu_read_unlock();
	cb->args[1] = idx;
	cb->args[0] = h;
L
Linus Torvalds 已提交
5974 5975 5976 5977 5978 5979 5980

	return skb->len;
}

void inet6_ifinfo_notify(int event, struct inet6_dev *idev)
{
	struct sk_buff *skb;
5981
	struct net *net = dev_net(idev->dev);
5982
	int err = -ENOBUFS;
5983

5984
	skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC);
5985
	if (!skb)
5986 5987 5988
		goto errout;

	err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0);
5989 5990 5991 5992 5993 5994
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_if_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
5995
	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFINFO, NULL, GFP_ATOMIC);
5996
	return;
5997 5998
errout:
	if (err < 0)
5999
		rtnl_set_sk_err(net, RTNLGRP_IPV6_IFINFO, err);
L
Linus Torvalds 已提交
6000 6001
}

6002 6003 6004 6005 6006 6007
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));
}
6008

L
Linus Torvalds 已提交
6009
static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev,
6010
			     struct prefix_info *pinfo, u32 portid, u32 seq,
6011
			     int event, unsigned int flags)
L
Linus Torvalds 已提交
6012
{
6013 6014
	struct prefixmsg *pmsg;
	struct nlmsghdr *nlh;
L
Linus Torvalds 已提交
6015 6016
	struct prefix_cacheinfo	ci;

6017
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*pmsg), flags);
6018
	if (!nlh)
6019
		return -EMSGSIZE;
6020 6021

	pmsg = nlmsg_data(nlh);
L
Linus Torvalds 已提交
6022
	pmsg->prefix_family = AF_INET6;
6023 6024
	pmsg->prefix_pad1 = 0;
	pmsg->prefix_pad2 = 0;
L
Linus Torvalds 已提交
6025 6026 6027
	pmsg->prefix_ifindex = idev->dev->ifindex;
	pmsg->prefix_len = pinfo->prefix_len;
	pmsg->prefix_type = pinfo->type;
6028
	pmsg->prefix_pad3 = 0;
L
Linus Torvalds 已提交
6029 6030 6031 6032 6033 6034
	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 已提交
6035 6036
	if (nla_put(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix))
		goto nla_put_failure;
L
Linus Torvalds 已提交
6037 6038
	ci.preferred_time = ntohl(pinfo->prefered);
	ci.valid_time = ntohl(pinfo->valid);
D
David S. Miller 已提交
6039 6040
	if (nla_put(skb, PREFIX_CACHEINFO, sizeof(ci), &ci))
		goto nla_put_failure;
6041 6042
	nlmsg_end(skb, nlh);
	return 0;
L
Linus Torvalds 已提交
6043

6044
nla_put_failure:
6045 6046
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
6047 6048
}

6049
static void inet6_prefix_notify(int event, struct inet6_dev *idev,
L
Linus Torvalds 已提交
6050 6051 6052
			 struct prefix_info *pinfo)
{
	struct sk_buff *skb;
6053
	struct net *net = dev_net(idev->dev);
6054
	int err = -ENOBUFS;
L
Linus Torvalds 已提交
6055

6056
	skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC);
6057
	if (!skb)
6058 6059 6060
		goto errout;

	err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0);
6061 6062 6063 6064 6065 6066
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_prefix_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
6067 6068
	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC);
	return;
6069 6070
errout:
	if (err < 0)
6071
		rtnl_set_sk_err(net, RTNLGRP_IPV6_PREFIX, err);
L
Linus Torvalds 已提交
6072 6073 6074 6075
}

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

6078 6079 6080
	if (event)
		ASSERT_RTNL();

L
Linus Torvalds 已提交
6081 6082 6083 6084
	inet6_ifa_notify(event ? : RTM_NEWADDR, ifp);

	switch (event) {
	case RTM_NEWADDR:
6085
		/*
6086 6087 6088 6089 6090 6091
		 * 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 the device was taken down in the middle of the DAD
		 * cycle there is a race where we could get here without a
		 * host route, so nothing to insert. That will be fixed when
		 * the device is brought up.
6092
		 */
6093
		if (ifp->rt && !rcu_access_pointer(ifp->rt->fib6_node)) {
6094
			ip6_ins_rt(net, ifp->rt);
6095 6096 6097 6098 6099
		} else if (!ifp->rt && (ifp->idev->dev->flags & IFF_UP)) {
			pr_warn("BUG: Address %pI6c on device %s is missing its host route.\n",
				&ifp->addr, ifp->idev->dev->name);
		}

L
Linus Torvalds 已提交
6100 6101
		if (ifp->idev->cnf.forwarding)
			addrconf_join_anycast(ifp);
C
Cong Wang 已提交
6102
		if (!ipv6_addr_any(&ifp->peer_addr))
6103 6104 6105
			addrconf_prefix_route(&ifp->peer_addr, 128,
					      ifp->rt_priority, ifp->idev->dev,
					      0, 0, GFP_ATOMIC);
L
Linus Torvalds 已提交
6106 6107 6108 6109 6110
		break;
	case RTM_DELADDR:
		if (ifp->idev->cnf.forwarding)
			addrconf_leave_anycast(ifp);
		addrconf_leave_solict(ifp->idev, &ifp->addr);
C
Cong Wang 已提交
6111
		if (!ipv6_addr_any(&ifp->peer_addr)) {
6112
			struct fib6_info *rt;
6113

6114
			rt = addrconf_get_prefix_route(&ifp->peer_addr, 128,
6115 6116
						       ifp->idev->dev, 0, 0,
						       false);
M
Martin KaFai Lau 已提交
6117
			if (rt)
6118
				ip6_del_rt(net, rt, false);
6119
		}
6120
		if (ifp->rt) {
6121
			ip6_del_rt(net, ifp->rt, false);
6122
			ifp->rt = NULL;
6123
		}
H
Hannes Frederic Sowa 已提交
6124
		rt_genid_bump_ipv6(net);
L
Linus Torvalds 已提交
6125 6126
		break;
	}
6127
	atomic_inc(&net->ipv6.dev_addr_genid);
L
Linus Torvalds 已提交
6128 6129 6130 6131
}

static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
{
6132
	rcu_read_lock_bh();
L
Linus Torvalds 已提交
6133 6134
	if (likely(ifp->idev->dead == 0))
		__ipv6_ifa_notify(event, ifp);
6135
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
6136 6137 6138 6139
}

#ifdef CONFIG_SYSCTL

6140 6141
static int addrconf_sysctl_forward(struct ctl_table *ctl, int write,
		void *buffer, size_t *lenp, loff_t *ppos)
L
Linus Torvalds 已提交
6142 6143 6144
{
	int *valp = ctl->data;
	int val = *valp;
E
Eric W. Biederman 已提交
6145
	loff_t pos = *ppos;
6146
	struct ctl_table lctl;
L
Linus Torvalds 已提交
6147 6148
	int ret;

6149 6150 6151 6152 6153 6154 6155 6156
	/*
	 * 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 已提交
6157

6158
	if (write)
6159
		ret = addrconf_fixup_forwarding(ctl, valp, val);
E
Eric W. Biederman 已提交
6160 6161
	if (ret)
		*ppos = pos;
6162
	return ret;
L
Linus Torvalds 已提交
6163 6164
}

6165 6166
static int addrconf_sysctl_mtu(struct ctl_table *ctl, int write,
		void *buffer, size_t *lenp, loff_t *ppos)
6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178
{
	struct inet6_dev *idev = ctl->extra1;
	int min_mtu = IPV6_MIN_MTU;
	struct ctl_table lctl;

	lctl = *ctl;
	lctl.extra1 = &min_mtu;
	lctl.extra2 = idev ? &idev->dev->mtu : NULL;

	return proc_dointvec_minmax(&lctl, write, buffer, lenp, ppos);
}

6179 6180
static void dev_disable_change(struct inet6_dev *idev)
{
6181 6182
	struct netdev_notifier_info info;

6183 6184 6185
	if (!idev || !idev->dev)
		return;

6186
	netdev_notifier_info_init(&info, idev->dev);
6187
	if (idev->cnf.disable_ipv6)
6188
		addrconf_notify(NULL, NETDEV_DOWN, &info);
6189
	else
6190
		addrconf_notify(NULL, NETDEV_UP, &info);
6191 6192 6193 6194 6195 6196 6197
}

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

6198
	for_each_netdev(net, dev) {
6199 6200 6201 6202 6203 6204 6205 6206 6207 6208
		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);
		}
	}
}

6209
static int addrconf_disable_ipv6(struct ctl_table *table, int *p, int newf)
6210 6211
{
	struct net *net;
6212 6213 6214 6215
	int old;

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

	net = (struct net *)table->extra2;
6218 6219
	old = *p;
	*p = newf;
6220

6221 6222
	if (p == &net->ipv6.devconf_dflt->disable_ipv6) {
		rtnl_unlock();
6223
		return 0;
E
Eric W. Biederman 已提交
6224
	}
6225 6226 6227 6228

	if (p == &net->ipv6.devconf_all->disable_ipv6) {
		net->ipv6.devconf_dflt->disable_ipv6 = newf;
		addrconf_disable_change(net, newf);
6229
	} else if ((!newf) ^ (!old))
6230 6231 6232 6233 6234 6235
		dev_disable_change((struct inet6_dev *)table->extra1);

	rtnl_unlock();
	return 0;
}

6236 6237
static int addrconf_sysctl_disable(struct ctl_table *ctl, int write,
		void *buffer, size_t *lenp, loff_t *ppos)
6238 6239 6240
{
	int *valp = ctl->data;
	int val = *valp;
E
Eric W. Biederman 已提交
6241
	loff_t pos = *ppos;
6242
	struct ctl_table lctl;
6243 6244
	int ret;

6245 6246 6247 6248 6249 6250 6251 6252
	/*
	 * 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);
6253 6254 6255

	if (write)
		ret = addrconf_disable_ipv6(ctl, valp, val);
E
Eric W. Biederman 已提交
6256 6257
	if (ret)
		*ppos = pos;
6258 6259 6260
	return ret;
}

6261 6262
static int addrconf_sysctl_proxy_ndp(struct ctl_table *ctl, int write,
		void *buffer, size_t *lenp, loff_t *ppos)
6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278
{
	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)
6279 6280
			inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
						     NETCONFA_PROXY_NEIGH,
6281 6282 6283
						     NETCONFA_IFINDEX_DEFAULT,
						     net->ipv6.devconf_dflt);
		else if (valp == &net->ipv6.devconf_all->proxy_ndp)
6284 6285
			inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
						     NETCONFA_PROXY_NEIGH,
6286 6287 6288 6289 6290
						     NETCONFA_IFINDEX_ALL,
						     net->ipv6.devconf_all);
		else {
			struct inet6_dev *idev = ctl->extra1;

6291 6292
			inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
						     NETCONFA_PROXY_NEIGH,
6293 6294 6295 6296 6297 6298 6299 6300 6301
						     idev->dev->ifindex,
						     &idev->cnf);
		}
		rtnl_unlock();
	}

	return ret;
}

6302
static int addrconf_sysctl_addr_gen_mode(struct ctl_table *ctl, int write,
6303
					 void *buffer, size_t *lenp,
6304 6305 6306
					 loff_t *ppos)
{
	int ret = 0;
6307
	u32 new_val;
6308 6309
	struct inet6_dev *idev = (struct inet6_dev *)ctl->extra1;
	struct net *net = (struct net *)ctl->extra2;
6310 6311 6312 6313 6314
	struct ctl_table tmp = {
		.data = &new_val,
		.maxlen = sizeof(new_val),
		.mode = ctl->mode,
	};
6315

6316 6317 6318
	if (!rtnl_trylock())
		return restart_syscall();

6319
	new_val = *((u32 *)ctl->data);
6320

6321 6322 6323
	ret = proc_douintvec(&tmp, write, buffer, lenp, ppos);
	if (ret != 0)
		goto out;
6324

6325
	if (write) {
6326 6327 6328 6329
		if (check_addr_gen_mode(new_val) < 0) {
			ret = -EINVAL;
			goto out;
		}
6330

6331
		if (idev) {
6332 6333 6334 6335
			if (check_stable_privacy(idev, net, new_val) < 0) {
				ret = -EINVAL;
				goto out;
			}
6336 6337 6338 6339 6340

			if (idev->cnf.addr_gen_mode != new_val) {
				idev->cnf.addr_gen_mode = new_val;
				addrconf_dev_config(idev->dev);
			}
6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352
		} else if (&net->ipv6.devconf_all->addr_gen_mode == ctl->data) {
			struct net_device *dev;

			net->ipv6.devconf_dflt->addr_gen_mode = new_val;
			for_each_netdev(net, dev) {
				idev = __in6_dev_get(dev);
				if (idev &&
				    idev->cnf.addr_gen_mode != new_val) {
					idev->cnf.addr_gen_mode = new_val;
					addrconf_dev_config(idev->dev);
				}
			}
6353
		}
6354 6355

		*((u32 *)ctl->data) = new_val;
6356 6357
	}

6358 6359 6360
out:
	rtnl_unlock();

6361 6362 6363
	return ret;
}

6364
static int addrconf_sysctl_stable_secret(struct ctl_table *ctl, int write,
6365
					 void *buffer, size_t *lenp,
6366 6367 6368 6369 6370 6371
					 loff_t *ppos)
{
	int err;
	struct in6_addr addr;
	char str[IPV6_MAX_STRLEN];
	struct ctl_table lctl = *ctl;
6372
	struct net *net = ctl->extra2;
6373 6374
	struct ipv6_stable_secret *secret = ctl->data;

6375 6376 6377
	if (&net->ipv6.devconf_all->stable_secret == ctl->data)
		return -EIO;

6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388
	lctl.maxlen = IPV6_MAX_STRLEN;
	lctl.data = str;

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

	if (!write && !secret->initialized) {
		err = -EIO;
		goto out;
	}

6389 6390 6391 6392
	err = snprintf(str, sizeof(str), "%pI6", &secret->secret);
	if (err >= sizeof(str)) {
		err = -EIO;
		goto out;
6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406
	}

	err = proc_dostring(&lctl, write, buffer, lenp, ppos);
	if (err || !write)
		goto out;

	if (in6_pton(str, -1, addr.in6_u.u6_addr8, -1, NULL) != 1) {
		err = -EIO;
		goto out;
	}

	secret->initialized = true;
	secret->secret = addr;

6407 6408 6409 6410 6411 6412 6413
	if (&net->ipv6.devconf_dflt->stable_secret == ctl->data) {
		struct net_device *dev;

		for_each_netdev(net, dev) {
			struct inet6_dev *idev = __in6_dev_get(dev);

			if (idev) {
6414
				idev->cnf.addr_gen_mode =
6415 6416 6417 6418 6419 6420
					IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
			}
		}
	} else {
		struct inet6_dev *idev = ctl->extra1;

6421
		idev->cnf.addr_gen_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
6422 6423
	}

6424 6425 6426 6427 6428
out:
	rtnl_unlock();

	return err;
}
6429

6430 6431
static
int addrconf_sysctl_ignore_routes_with_linkdown(struct ctl_table *ctl,
6432
						int write, void *buffer,
6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456
						size_t *lenp,
						loff_t *ppos)
{
	int *valp = ctl->data;
	int val = *valp;
	loff_t pos = *ppos;
	struct ctl_table lctl;
	int ret;

	/* ctl->data points to idev->cnf.ignore_routes_when_linkdown
	 * we should not modify it until we get the rtnl lock.
	 */
	lctl = *ctl;
	lctl.data = &val;

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

	if (write)
		ret = addrconf_fixup_linkdown(ctl, valp, val);
	if (ret)
		*ppos = pos;
	return ret;
}

6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476
static
void addrconf_set_nopolicy(struct rt6_info *rt, int action)
{
	if (rt) {
		if (action)
			rt->dst.flags |= DST_NOPOLICY;
		else
			rt->dst.flags &= ~DST_NOPOLICY;
	}
}

static
void addrconf_disable_policy_idev(struct inet6_dev *idev, int val)
{
	struct inet6_ifaddr *ifa;

	read_lock_bh(&idev->lock);
	list_for_each_entry(ifa, &idev->addr_list, if_list) {
		spin_lock(&ifa->lock);
		if (ifa->rt) {
6477
			/* host routes only use builtin fib6_nh */
6478
			struct fib6_nh *nh = ifa->rt->fib6_nh;
6479 6480
			int cpu;

6481
			rcu_read_lock();
6482
			ifa->rt->dst_nopolicy = val ? true : false;
6483
			if (nh->rt6i_pcpu) {
6484 6485 6486
				for_each_possible_cpu(cpu) {
					struct rt6_info **rtp;

6487
					rtp = per_cpu_ptr(nh->rt6i_pcpu, cpu);
6488 6489 6490
					addrconf_set_nopolicy(*rtp, val);
				}
			}
6491
			rcu_read_unlock();
6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531
		}
		spin_unlock(&ifa->lock);
	}
	read_unlock_bh(&idev->lock);
}

static
int addrconf_disable_policy(struct ctl_table *ctl, int *valp, int val)
{
	struct inet6_dev *idev;
	struct net *net;

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

	*valp = val;

	net = (struct net *)ctl->extra2;
	if (valp == &net->ipv6.devconf_dflt->disable_policy) {
		rtnl_unlock();
		return 0;
	}

	if (valp == &net->ipv6.devconf_all->disable_policy)  {
		struct net_device *dev;

		for_each_netdev(net, dev) {
			idev = __in6_dev_get(dev);
			if (idev)
				addrconf_disable_policy_idev(idev, val);
		}
	} else {
		idev = (struct inet6_dev *)ctl->extra1;
		addrconf_disable_policy_idev(idev, val);
	}

	rtnl_unlock();
	return 0;
}

6532 6533
static int addrconf_sysctl_disable_policy(struct ctl_table *ctl, int write,
				   void *buffer, size_t *lenp, loff_t *ppos)
6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553
{
	int *valp = ctl->data;
	int val = *valp;
	loff_t pos = *ppos;
	struct ctl_table lctl;
	int ret;

	lctl = *ctl;
	lctl.data = &val;
	ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);

	if (write && (*valp != val))
		ret = addrconf_disable_policy(ctl, valp, val);

	if (ret)
		*ppos = pos;

	return ret;
}

6554
static int minus_one = -1;
6555 6556
static const int two_five_five = 255;

6557
static const struct ctl_table addrconf_sysctl[] = {
6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569
	{
		.procname	= "forwarding",
		.data		= &ipv6_devconf.forwarding,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= addrconf_sysctl_forward,
	},
	{
		.procname	= "hop_limit",
		.data		= &ipv6_devconf.hop_limit,
		.maxlen		= sizeof(int),
		.mode		= 0644,
6570
		.proc_handler	= proc_dointvec_minmax,
6571
		.extra1		= (void *)SYSCTL_ONE,
6572
		.extra2		= (void *)&two_five_five,
6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613
	},
	{
		.procname	= "mtu",
		.data		= &ipv6_devconf.mtu6,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= addrconf_sysctl_mtu,
	},
	{
		.procname	= "accept_ra",
		.data		= &ipv6_devconf.accept_ra,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "accept_redirects",
		.data		= &ipv6_devconf.accept_redirects,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "autoconf",
		.data		= &ipv6_devconf.autoconf,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "dad_transmits",
		.data		= &ipv6_devconf.dad_transmits,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "router_solicitations",
		.data		= &ipv6_devconf.rtr_solicits,
		.maxlen		= sizeof(int),
		.mode		= 0644,
6614 6615
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &minus_one,
6616 6617 6618 6619 6620 6621 6622 6623
	},
	{
		.procname	= "router_solicitation_interval",
		.data		= &ipv6_devconf.rtr_solicit_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_jiffies,
	},
6624 6625 6626 6627 6628 6629 6630
	{
		.procname	= "router_solicitation_max_interval",
		.data		= &ipv6_devconf.rtr_solicit_max_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_jiffies,
	},
6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723
	{
		.procname	= "router_solicitation_delay",
		.data		= &ipv6_devconf.rtr_solicit_delay,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_jiffies,
	},
	{
		.procname	= "force_mld_version",
		.data		= &ipv6_devconf.force_mld_version,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.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,
	},
	{
		.procname	= "use_tempaddr",
		.data		= &ipv6_devconf.use_tempaddr,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "temp_valid_lft",
		.data		= &ipv6_devconf.temp_valid_lft,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "temp_prefered_lft",
		.data		= &ipv6_devconf.temp_prefered_lft,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "regen_max_retry",
		.data		= &ipv6_devconf.regen_max_retry,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "max_desync_factor",
		.data		= &ipv6_devconf.max_desync_factor,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "max_addresses",
		.data		= &ipv6_devconf.max_addresses,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "accept_ra_defrtr",
		.data		= &ipv6_devconf.accept_ra_defrtr,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "accept_ra_min_hop_limit",
		.data		= &ipv6_devconf.accept_ra_min_hop_limit,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "accept_ra_pinfo",
		.data		= &ipv6_devconf.accept_ra_pinfo,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
6724
#ifdef CONFIG_IPV6_ROUTER_PREF
6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738
	{
		.procname	= "accept_ra_rtr_pref",
		.data		= &ipv6_devconf.accept_ra_rtr_pref,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "router_probe_interval",
		.data		= &ipv6_devconf.rtr_probe_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_jiffies,
	},
N
Neil Horman 已提交
6739
#ifdef CONFIG_IPV6_ROUTE_INFO
6740 6741 6742 6743 6744 6745 6746
	{
		.procname	= "accept_ra_rt_info_min_plen",
		.data		= &ipv6_devconf.accept_ra_rt_info_min_plen,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
6747 6748 6749 6750 6751 6752 6753
	{
		.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,
	},
6754
#endif
6755
#endif
6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769
	{
		.procname	= "proxy_ndp",
		.data		= &ipv6_devconf.proxy_ndp,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= addrconf_sysctl_proxy_ndp,
	},
	{
		.procname	= "accept_source_route",
		.data		= &ipv6_devconf.accept_source_route,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
6770
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784
	{
		.procname	= "optimistic_dad",
		.data		= &ipv6_devconf.optimistic_dad,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler   = proc_dointvec,
	},
	{
		.procname	= "use_optimistic",
		.data		= &ipv6_devconf.use_optimistic,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
6785 6786
#endif
#ifdef CONFIG_IPV6_MROUTE
6787 6788 6789 6790 6791 6792 6793
	{
		.procname	= "mc_forwarding",
		.data		= &ipv6_devconf.mc_forwarding,
		.maxlen		= sizeof(int),
		.mode		= 0444,
		.proc_handler	= proc_dointvec,
	},
6794
#endif
6795 6796 6797 6798 6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884 6885 6886
	{
		.procname	= "disable_ipv6",
		.data		= &ipv6_devconf.disable_ipv6,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= addrconf_sysctl_disable,
	},
	{
		.procname	= "accept_dad",
		.data		= &ipv6_devconf.accept_dad,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "force_tllao",
		.data		= &ipv6_devconf.force_tllao,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec
	},
	{
		.procname	= "ndisc_notify",
		.data		= &ipv6_devconf.ndisc_notify,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec
	},
	{
		.procname	= "suppress_frag_ndisc",
		.data		= &ipv6_devconf.suppress_frag_ndisc,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec
	},
	{
		.procname	= "accept_ra_from_local",
		.data		= &ipv6_devconf.accept_ra_from_local,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "accept_ra_mtu",
		.data		= &ipv6_devconf.accept_ra_mtu,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "stable_secret",
		.data		= &ipv6_devconf.stable_secret,
		.maxlen		= IPV6_MAX_STRLEN,
		.mode		= 0600,
		.proc_handler	= addrconf_sysctl_stable_secret,
	},
	{
		.procname	= "use_oif_addrs_only",
		.data		= &ipv6_devconf.use_oif_addrs_only,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "ignore_routes_with_linkdown",
		.data		= &ipv6_devconf.ignore_routes_with_linkdown,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= addrconf_sysctl_ignore_routes_with_linkdown,
	},
	{
		.procname	= "drop_unicast_in_l2_multicast",
		.data		= &ipv6_devconf.drop_unicast_in_l2_multicast,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "drop_unsolicited_na",
		.data		= &ipv6_devconf.drop_unsolicited_na,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "keep_addr_on_down",
		.data		= &ipv6_devconf.keep_addr_on_down,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,

	},
6887 6888 6889 6890 6891 6892 6893
	{
		.procname	= "seg6_enabled",
		.data		= &ipv6_devconf.seg6_enabled,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
6894 6895 6896 6897 6898 6899 6900 6901 6902
#ifdef CONFIG_IPV6_SEG6_HMAC
	{
		.procname	= "seg6_require_hmac",
		.data		= &ipv6_devconf.seg6_require_hmac,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
#endif
6903 6904 6905 6906 6907 6908 6909
	{
		.procname       = "enhanced_dad",
		.data           = &ipv6_devconf.enhanced_dad,
		.maxlen         = sizeof(int),
		.mode           = 0644,
		.proc_handler   = proc_dointvec,
	},
6910 6911 6912 6913 6914 6915 6916
	{
		.procname		= "addr_gen_mode",
		.data			= &ipv6_devconf.addr_gen_mode,
		.maxlen			= sizeof(int),
		.mode			= 0644,
		.proc_handler	= addrconf_sysctl_addr_gen_mode,
	},
6917 6918 6919 6920 6921 6922 6923
	{
		.procname       = "disable_policy",
		.data           = &ipv6_devconf.disable_policy,
		.maxlen         = sizeof(int),
		.mode           = 0644,
		.proc_handler   = addrconf_sysctl_disable_policy,
	},
6924 6925 6926 6927 6928 6929
	{
		.procname	= "ndisc_tclass",
		.data		= &ipv6_devconf.ndisc_tclass,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
6930
		.extra1		= (void *)SYSCTL_ZERO,
6931 6932
		.extra2		= (void *)&two_five_five,
	},
6933 6934 6935 6936 6937 6938 6939
	{
		.procname	= "rpl_seg_enabled",
		.data		= &ipv6_devconf.rpl_seg_enabled,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
6940 6941 6942
	{
		/* sentinel */
	}
L
Linus Torvalds 已提交
6943 6944
};

6945
static int __addrconf_sysctl_register(struct net *net, char *dev_name,
6946
		struct inet6_dev *idev, struct ipv6_devconf *p)
L
Linus Torvalds 已提交
6947
{
6948
	int i, ifindex;
6949
	struct ctl_table *table;
6950
	char path[sizeof("net/ipv6/conf/") + IFNAMSIZ];
6951

6952 6953
	table = kmemdup(addrconf_sysctl, sizeof(addrconf_sysctl), GFP_KERNEL);
	if (!table)
6954 6955
		goto out;

6956 6957
	for (i = 0; table[i].data; i++) {
		table[i].data += (char *)p - (char *)&ipv6_devconf;
6958 6959 6960 6961 6962 6963 6964 6965
		/* If one of these is already set, then it is not safe to
		 * overwrite either of them: this makes proc_dointvec_minmax
		 * usable.
		 */
		if (!table[i].extra1 && !table[i].extra2) {
			table[i].extra1 = idev; /* embedded; no ref */
			table[i].extra2 = net;
		}
L
Linus Torvalds 已提交
6966 6967
	}

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

6970 6971
	p->sysctl_header = register_net_sysctl(net, path, table);
	if (!p->sysctl_header)
6972
		goto free;
6973

6974 6975 6976 6977 6978 6979
	if (!strcmp(dev_name, "all"))
		ifindex = NETCONFA_IFINDEX_ALL;
	else if (!strcmp(dev_name, "default"))
		ifindex = NETCONFA_IFINDEX_DEFAULT;
	else
		ifindex = idev->dev->ifindex;
6980 6981
	inet6_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_ALL,
				     ifindex, p);
6982
	return 0;
L
Linus Torvalds 已提交
6983

6984
free:
6985
	kfree(table);
6986
out:
6987
	return -ENOBUFS;
L
Linus Torvalds 已提交
6988 6989
}

6990 6991
static void __addrconf_sysctl_unregister(struct net *net,
					 struct ipv6_devconf *p, int ifindex)
6992
{
6993
	struct ctl_table *table;
6994

6995
	if (!p->sysctl_header)
6996 6997
		return;

6998 6999 7000 7001
	table = p->sysctl_header->ctl_table_arg;
	unregister_net_sysctl_table(p->sysctl_header);
	p->sysctl_header = NULL;
	kfree(table);
7002 7003

	inet6_netconf_notify_devconf(net, RTM_DELNETCONF, 0, ifindex, NULL);
7004 7005
}

7006
static int addrconf_sysctl_register(struct inet6_dev *idev)
7007
{
7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022
	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;
7023 7024
}

7025
static void addrconf_sysctl_unregister(struct inet6_dev *idev)
L
Linus Torvalds 已提交
7026
{
7027 7028
	__addrconf_sysctl_unregister(dev_net(idev->dev), &idev->cnf,
				     idev->dev->ifindex);
7029
	neigh_sysctl_unregister(idev->nd_parms);
L
Linus Torvalds 已提交
7030 7031 7032 7033 7034
}


#endif

7035
static int __net_init addrconf_init_net(struct net *net)
7036
{
7037
	int err = -ENOMEM;
7038 7039
	struct ipv6_devconf *all, *dflt;

7040
	all = kmemdup(&ipv6_devconf, sizeof(ipv6_devconf), GFP_KERNEL);
7041
	if (!all)
7042
		goto err_alloc_all;
7043

7044
	dflt = kmemdup(&ipv6_devconf_dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
7045
	if (!dflt)
7046
		goto err_alloc_dflt;
7047

7048 7049
	if (!net_eq(net, &init_net)) {
		switch (net_inherit_devconf()) {
7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067
		case 1:  /* copy from init_net */
			memcpy(all, init_net.ipv6.devconf_all,
			       sizeof(ipv6_devconf));
			memcpy(dflt, init_net.ipv6.devconf_dflt,
			       sizeof(ipv6_devconf_dflt));
			break;
		case 3: /* copy from the current netns */
			memcpy(all, current->nsproxy->net_ns->ipv6.devconf_all,
			       sizeof(ipv6_devconf));
			memcpy(dflt,
			       current->nsproxy->net_ns->ipv6.devconf_dflt,
			       sizeof(ipv6_devconf_dflt));
			break;
		case 0:
		case 2:
			/* use compiled values */
			break;
		}
7068 7069
	}

7070 7071 7072
	/* these will be inherited by all namespaces */
	dflt->autoconf = ipv6_defaults.autoconf;
	dflt->disable_ipv6 = ipv6_defaults.disable_ipv6;
7073

7074 7075 7076
	dflt->stable_secret.initialized = false;
	all->stable_secret.initialized = false;

7077 7078 7079 7080
	net->ipv6.devconf_all = all;
	net->ipv6.devconf_dflt = dflt;

#ifdef CONFIG_SYSCTL
7081
	err = __addrconf_sysctl_register(net, "all", NULL, all);
7082 7083 7084
	if (err < 0)
		goto err_reg_all;

7085
	err = __addrconf_sysctl_register(net, "default", NULL, dflt);
7086 7087 7088 7089 7090 7091 7092
	if (err < 0)
		goto err_reg_dflt;
#endif
	return 0;

#ifdef CONFIG_SYSCTL
err_reg_dflt:
7093
	__addrconf_sysctl_unregister(net, all, NETCONFA_IFINDEX_ALL);
7094 7095 7096 7097 7098 7099 7100 7101 7102
err_reg_all:
	kfree(dflt);
#endif
err_alloc_dflt:
	kfree(all);
err_alloc_all:
	return err;
}

7103
static void __net_exit addrconf_exit_net(struct net *net)
7104 7105
{
#ifdef CONFIG_SYSCTL
7106 7107 7108 7109
	__addrconf_sysctl_unregister(net, net->ipv6.devconf_dflt,
				     NETCONFA_IFINDEX_DEFAULT);
	__addrconf_sysctl_unregister(net, net->ipv6.devconf_all,
				     NETCONFA_IFINDEX_ALL);
7110
#endif
Z
zhuyj 已提交
7111 7112
	kfree(net->ipv6.devconf_dflt);
	kfree(net->ipv6.devconf_all);
7113 7114 7115 7116 7117 7118 7119
}

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

7120
static struct rtnl_af_ops inet6_ops __read_mostly = {
T
Thomas Graf 已提交
7121 7122 7123
	.family		  = AF_INET6,
	.fill_link_af	  = inet6_fill_link_af,
	.get_link_af_size = inet6_get_link_af_size,
7124
	.validate_link_af = inet6_validate_link_af,
7125
	.set_link_af	  = inet6_set_link_af,
T
Thomas Graf 已提交
7126 7127
};

L
Linus Torvalds 已提交
7128 7129 7130 7131 7132 7133
/*
 *	Init / cleanup code
 */

int __init addrconf_init(void)
{
7134
	struct inet6_dev *idev;
7135
	int i, err;
7136

S
Stephen Hemminger 已提交
7137 7138
	err = ipv6_addr_label_init();
	if (err < 0) {
7139 7140
		pr_crit("%s: cannot initialize default policy table: %d\n",
			__func__, err);
7141
		goto out;
7142
	}
L
Linus Torvalds 已提交
7143

7144 7145 7146
	err = register_pernet_subsys(&addrconf_ops);
	if (err < 0)
		goto out_addrlabel;
7147

7148 7149 7150 7151 7152 7153
	addrconf_wq = create_workqueue("ipv6_addrconf");
	if (!addrconf_wq) {
		err = -ENOMEM;
		goto out_nowq;
	}

L
Linus Torvalds 已提交
7154
	rtnl_lock();
7155
	idev = ipv6_add_dev(blackhole_netdev);
L
Linus Torvalds 已提交
7156
	rtnl_unlock();
7157 7158
	if (IS_ERR(idev)) {
		err = PTR_ERR(idev);
7159
		goto errlo;
7160
	}
L
Linus Torvalds 已提交
7161

7162 7163
	ip6_route_init_special_entries();

7164 7165 7166
	for (i = 0; i < IN6_ADDR_HSIZE; i++)
		INIT_HLIST_HEAD(&inet6_addr_lst[i]);

L
Linus Torvalds 已提交
7167 7168
	register_netdevice_notifier(&ipv6_dev_notf);

7169
	addrconf_verify();
7170

7171
	rtnl_af_register(&inet6_ops);
T
Thomas Graf 已提交
7172

7173 7174
	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETLINK,
				   NULL, inet6_dump_ifinfo, 0);
7175 7176 7177
	if (err < 0)
		goto errout;

7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204
	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_NEWADDR,
				   inet6_rtm_newaddr, NULL, 0);
	if (err < 0)
		goto errout;
	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_DELADDR,
				   inet6_rtm_deladdr, NULL, 0);
	if (err < 0)
		goto errout;
	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETADDR,
				   inet6_rtm_getaddr, inet6_dump_ifaddr,
				   RTNL_FLAG_DOIT_UNLOCKED);
	if (err < 0)
		goto errout;
	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETMULTICAST,
				   NULL, inet6_dump_ifmcaddr, 0);
	if (err < 0)
		goto errout;
	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETANYCAST,
				   NULL, inet6_dump_ifacaddr, 0);
	if (err < 0)
		goto errout;
	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETNETCONF,
				   inet6_netconf_get_devconf,
				   inet6_netconf_dump_devconf,
				   RTNL_FLAG_DOIT_UNLOCKED);
	if (err < 0)
		goto errout;
7205 7206 7207
	err = ipv6_addr_label_rtnl_register();
	if (err < 0)
		goto errout;
7208

L
Linus Torvalds 已提交
7209
	return 0;
7210
errout:
7211
	rtnl_unregister_all(PF_INET6);
T
Thomas Graf 已提交
7212
	rtnl_af_unregister(&inet6_ops);
7213
	unregister_netdevice_notifier(&ipv6_dev_notf);
7214
errlo:
7215 7216
	destroy_workqueue(addrconf_wq);
out_nowq:
7217
	unregister_pernet_subsys(&addrconf_ops);
7218 7219 7220
out_addrlabel:
	ipv6_addr_label_cleanup();
out:
7221
	return err;
L
Linus Torvalds 已提交
7222 7223
}

7224
void addrconf_cleanup(void)
L
Linus Torvalds 已提交
7225
{
7226
	struct net_device *dev;
L
Linus Torvalds 已提交
7227 7228 7229
	int i;

	unregister_netdevice_notifier(&ipv6_dev_notf);
7230
	unregister_pernet_subsys(&addrconf_ops);
7231
	ipv6_addr_label_cleanup();
L
Linus Torvalds 已提交
7232

7233
	rtnl_af_unregister(&inet6_ops);
L
Linus Torvalds 已提交
7234

7235
	rtnl_lock();
T
Thomas Graf 已提交
7236

7237 7238 7239 7240
	/* clean dev list */
	for_each_netdev(&init_net, dev) {
		if (__in6_dev_get(dev) == NULL)
			continue;
7241
		addrconf_ifdown(dev, true);
7242
	}
7243
	addrconf_ifdown(init_net.loopback_dev, true);
7244

L
Linus Torvalds 已提交
7245 7246 7247
	/*
	 *	Check hash table.
	 */
7248
	spin_lock_bh(&addrconf_hash_lock);
7249 7250
	for (i = 0; i < IN6_ADDR_HSIZE; i++)
		WARN_ON(!hlist_empty(&inet6_addr_lst[i]));
7251
	spin_unlock_bh(&addrconf_hash_lock);
7252
	cancel_delayed_work(&addr_chk_work);
L
Linus Torvalds 已提交
7253
	rtnl_unlock();
7254 7255

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