addrconf.c 149.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 *	IPv6 Address [auto]configuration
 *	Linux INET6 implementation
 *
 *	Authors:
6
 *	Pedro Roque		<roque@di.fc.ul.pt>
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 *	Alexey Kuznetsov	<kuznet@ms2.inr.ac.ru>
 *
 *	This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */

/*
 *	Changes:
 *
 *	Janos Farkas			:	delete timer on ifdown
 *	<chexum@bankinf.banki.hu>
 *	Andi Kleen			:	kill double kfree on module
 *						unload.
 *	Maciej W. Rozycki		:	FDDI support
 *	sekiya@USAGI			:	Don't send too many RS
 *						packets.
 *	yoshfuji@USAGI			:       Fixed interval between DAD
 *						packets.
 *	YOSHIFUJI Hideaki @USAGI	:	improved accuracy of
 *						address validation timer.
 *	YOSHIFUJI Hideaki @USAGI	:	Privacy Extensions (RFC3041)
 *						support.
 *	Yuji SEKIYA @USAGI		:	Don't assign a same IPv6
 *						address on a same interface.
 *	YOSHIFUJI Hideaki @USAGI	:	ARCnet support
 *	YOSHIFUJI Hideaki @USAGI	:	convert /proc/net/if_inet6 to
 *						seq_file.
36 37 38
 *	YOSHIFUJI Hideaki @USAGI	:	improved source address
 *						selection; consider scope,
 *						status etc.
L
Linus Torvalds 已提交
39 40
 */

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

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

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

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

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

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

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

#define	INFINITY_LIFE_TIME	0xFFFFFFFF
106

107 108 109
#define IPV6_MAX_STRLEN \
	sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")

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

#ifdef CONFIG_SYSCTL
116
static int addrconf_sysctl_register(struct inet6_dev *idev);
117 118
static void addrconf_sysctl_unregister(struct inet6_dev *idev);
#else
119
static inline int addrconf_sysctl_register(struct inet6_dev *idev)
120
{
121
	return 0;
122 123 124 125 126
}

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

S
Sorin Dumitru 已提交
129 130
static void __ipv6_regen_rndid(struct inet6_dev *idev);
static void __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr);
L
Linus Torvalds 已提交
131 132
static void ipv6_regen_rndid(unsigned long data);

133
static int ipv6_generate_eui64(u8 *eui, struct net_device *dev);
L
Linus Torvalds 已提交
134
static int ipv6_count_addresses(struct inet6_dev *idev);
135 136 137
static int ipv6_generate_stable_address(struct in6_addr *addr,
					u8 dad_count,
					const struct inet6_dev *idev);
L
Linus Torvalds 已提交
138 139 140 141

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

145 146 147
static void addrconf_verify(void);
static void addrconf_verify_rtnl(void);
static void addrconf_verify_work(struct work_struct *);
L
Linus Torvalds 已提交
148

149 150
static struct workqueue_struct *addrconf_wq;
static DECLARE_DELAYED_WORK(addr_chk_work, addrconf_verify_work);
L
Linus Torvalds 已提交
151 152 153 154

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

155 156
static void addrconf_type_change(struct net_device *dev,
				 unsigned long event);
L
Linus Torvalds 已提交
157 158
static int addrconf_ifdown(struct net_device *dev, int how);

159 160 161 162 163
static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
						  int plen,
						  const struct net_device *dev,
						  u32 flags, u32 noflags);

164
static void addrconf_dad_start(struct inet6_ifaddr *ifp);
165
static void addrconf_dad_work(struct work_struct *w);
L
Linus Torvalds 已提交
166
static void addrconf_dad_completed(struct inet6_ifaddr *ifp);
167
static void addrconf_dad_run(struct inet6_dev *idev);
L
Linus Torvalds 已提交
168 169 170 171
static void addrconf_rs_timer(unsigned long data);
static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);

172
static void inet6_prefix_notify(int event, struct inet6_dev *idev,
L
Linus Torvalds 已提交
173
				struct prefix_info *pinfo);
174 175
static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
			       struct net_device *dev);
L
Linus Torvalds 已提交
176

177
static struct ipv6_devconf ipv6_devconf __read_mostly = {
L
Linus Torvalds 已提交
178 179 180 181 182 183 184
	.forwarding		= 0,
	.hop_limit		= IPV6_DEFAULT_HOPLIMIT,
	.mtu6			= IPV6_MIN_MTU,
	.accept_ra		= 1,
	.accept_redirects	= 1,
	.autoconf		= 1,
	.force_mld_version	= 0,
185 186
	.mldv1_unsolicited_report_interval = 10 * HZ,
	.mldv2_unsolicited_report_interval = HZ,
L
Linus Torvalds 已提交
187 188 189 190
	.dad_transmits		= 1,
	.rtr_solicits		= MAX_RTR_SOLICITATIONS,
	.rtr_solicit_interval	= RTR_SOLICITATION_INTERVAL,
	.rtr_solicit_delay	= MAX_RTR_SOLICITATION_DELAY,
191
	.use_tempaddr		= 0,
L
Linus Torvalds 已提交
192 193 194 195 196
	.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,
197
	.accept_ra_defrtr	= 1,
198
	.accept_ra_from_local	= 0,
199
	.accept_ra_min_hop_limit= 1,
200
	.accept_ra_pinfo	= 1,
201 202
#ifdef CONFIG_IPV6_ROUTER_PREF
	.accept_ra_rtr_pref	= 1,
203
	.rtr_probe_interval	= 60 * HZ,
204 205 206
#ifdef CONFIG_IPV6_ROUTE_INFO
	.accept_ra_rt_info_max_plen = 0,
#endif
207
#endif
208
	.proxy_ndp		= 0,
209
	.accept_source_route	= 0,	/* we do not accept RH0 by default. */
210
	.disable_ipv6		= 0,
211
	.accept_dad		= 1,
212
	.suppress_frag_ndisc	= 1,
213
	.accept_ra_mtu		= 1,
214 215
	.stable_secret		= {
		.initialized = false,
216 217
	},
	.use_oif_addrs_only	= 0,
218
	.ignore_routes_with_linkdown = 0,
219
	.keep_addr_on_down	= 0,
L
Linus Torvalds 已提交
220 221
};

222
static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = {
L
Linus Torvalds 已提交
223 224 225 226 227 228
	.forwarding		= 0,
	.hop_limit		= IPV6_DEFAULT_HOPLIMIT,
	.mtu6			= IPV6_MIN_MTU,
	.accept_ra		= 1,
	.accept_redirects	= 1,
	.autoconf		= 1,
229 230 231
	.force_mld_version	= 0,
	.mldv1_unsolicited_report_interval = 10 * HZ,
	.mldv2_unsolicited_report_interval = HZ,
L
Linus Torvalds 已提交
232 233 234 235 236 237 238 239 240 241
	.dad_transmits		= 1,
	.rtr_solicits		= MAX_RTR_SOLICITATIONS,
	.rtr_solicit_interval	= RTR_SOLICITATION_INTERVAL,
	.rtr_solicit_delay	= MAX_RTR_SOLICITATION_DELAY,
	.use_tempaddr		= 0,
	.temp_valid_lft		= TEMP_VALID_LIFETIME,
	.temp_prefered_lft	= TEMP_PREFERRED_LIFETIME,
	.regen_max_retry	= REGEN_MAX_RETRY,
	.max_desync_factor	= MAX_DESYNC_FACTOR,
	.max_addresses		= IPV6_MAX_ADDRESSES,
242
	.accept_ra_defrtr	= 1,
243
	.accept_ra_from_local	= 0,
244
	.accept_ra_min_hop_limit= 1,
245
	.accept_ra_pinfo	= 1,
246 247
#ifdef CONFIG_IPV6_ROUTER_PREF
	.accept_ra_rtr_pref	= 1,
248
	.rtr_probe_interval	= 60 * HZ,
249 250 251
#ifdef CONFIG_IPV6_ROUTE_INFO
	.accept_ra_rt_info_max_plen = 0,
#endif
252
#endif
253
	.proxy_ndp		= 0,
254
	.accept_source_route	= 0,	/* we do not accept RH0 by default. */
255
	.disable_ipv6		= 0,
256
	.accept_dad		= 1,
257
	.suppress_frag_ndisc	= 1,
258
	.accept_ra_mtu		= 1,
259 260 261
	.stable_secret		= {
		.initialized = false,
	},
262
	.use_oif_addrs_only	= 0,
263
	.ignore_routes_with_linkdown = 0,
264
	.keep_addr_on_down	= 0,
L
Linus Torvalds 已提交
265 266
};

267
/* Check if a valid qdisc is available */
268
static inline bool addrconf_qdisc_ok(const struct net_device *dev)
269
{
270
	return !qdisc_tx_is_noop(dev);
271 272
}

273
static void addrconf_del_rs_timer(struct inet6_dev *idev)
L
Linus Torvalds 已提交
274
{
275 276 277 278
	if (del_timer(&idev->rs_timer))
		__in6_dev_put(idev);
}

279
static void addrconf_del_dad_work(struct inet6_ifaddr *ifp)
280
{
281
	if (cancel_delayed_work(&ifp->dad_work))
L
Linus Torvalds 已提交
282 283 284
		__in6_ifa_put(ifp);
}

285 286 287 288 289 290 291
static void addrconf_mod_rs_timer(struct inet6_dev *idev,
				  unsigned long when)
{
	if (!timer_pending(&idev->rs_timer))
		in6_dev_hold(idev);
	mod_timer(&idev->rs_timer, jiffies + when);
}
L
Linus Torvalds 已提交
292

293 294
static void addrconf_mod_dad_work(struct inet6_ifaddr *ifp,
				   unsigned long delay)
L
Linus Torvalds 已提交
295
{
296
	if (!delayed_work_pending(&ifp->dad_work))
L
Linus Torvalds 已提交
297
		in6_ifa_hold(ifp);
298
	mod_delayed_work(addrconf_wq, &ifp->dad_work, delay);
L
Linus Torvalds 已提交
299 300
}

301 302
static int snmp6_alloc_dev(struct inet6_dev *idev)
{
303 304
	int i;

W
WANG Cong 已提交
305 306
	idev->stats.ipv6 = alloc_percpu(struct ipstats_mib);
	if (!idev->stats.ipv6)
307
		goto err_ip;
308 309 310

	for_each_possible_cpu(i) {
		struct ipstats_mib *addrconf_stats;
W
WANG Cong 已提交
311
		addrconf_stats = per_cpu_ptr(idev->stats.ipv6, i);
312 313 314 315
		u64_stats_init(&addrconf_stats->syncp);
	}


316 317 318
	idev->stats.icmpv6dev = kzalloc(sizeof(struct icmpv6_mib_device),
					GFP_KERNEL);
	if (!idev->stats.icmpv6dev)
319
		goto err_icmp;
320 321 322
	idev->stats.icmpv6msgdev = kzalloc(sizeof(struct icmpv6msg_mib_device),
					   GFP_KERNEL);
	if (!idev->stats.icmpv6msgdev)
323
		goto err_icmpmsg;
324 325 326

	return 0;

327
err_icmpmsg:
328
	kfree(idev->stats.icmpv6dev);
329
err_icmp:
W
WANG Cong 已提交
330
	free_percpu(idev->stats.ipv6);
331
err_ip:
332
	return -ENOMEM;
333 334
}

335
static struct inet6_dev *ipv6_add_dev(struct net_device *dev)
L
Linus Torvalds 已提交
336 337
{
	struct inet6_dev *ndev;
338
	int err = -ENOMEM;
L
Linus Torvalds 已提交
339 340 341 342

	ASSERT_RTNL();

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

345
	ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL);
346
	if (!ndev)
347
		return ERR_PTR(err);
348 349 350

	rwlock_init(&ndev->lock);
	ndev->dev = dev;
351
	INIT_LIST_HEAD(&ndev->addr_list);
352 353
	setup_timer(&ndev->rs_timer, addrconf_rs_timer,
		    (unsigned long)ndev);
354
	memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf));
355 356 357 358 359 360

	if (ndev->cnf.stable_secret.initialized)
		ndev->addr_gen_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
	else
		ndev->addr_gen_mode = IN6_ADDR_GEN_MODE_EUI64;

361 362 363
	ndev->cnf.mtu6 = dev->mtu;
	ndev->cnf.sysctl = NULL;
	ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
364
	if (!ndev->nd_parms) {
365
		kfree(ndev);
366
		return ERR_PTR(err);
367
	}
368 369
	if (ndev->cnf.forwarding)
		dev_disable_lro(dev);
370 371
	/* We refer to the device */
	dev_hold(dev);
L
Linus Torvalds 已提交
372

373
	if (snmp6_alloc_dev(ndev) < 0) {
374
		ADBG(KERN_WARNING
375
			"%s: cannot allocate memory for statistics; dev=%s.\n",
376
			__func__, dev->name);
377
		neigh_parms_release(&nd_tbl, ndev->nd_parms);
R
Roy Li 已提交
378 379
		dev_put(dev);
		kfree(ndev);
380
		return ERR_PTR(err);
381
	}
L
Linus Torvalds 已提交
382

383
	if (snmp6_register_dev(ndev) < 0) {
384
		ADBG(KERN_WARNING
385
			"%s: cannot create /proc/net/dev_snmp6/%s\n",
386
			__func__, dev->name);
387
		goto err_release;
388 389 390 391 392 393
	}

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

395 396 397
	if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
		ndev->cnf.accept_dad = -1;

A
Amerigo Wang 已提交
398
#if IS_ENABLED(CONFIG_IPV6_SIT)
399
	if (dev->type == ARPHRD_SIT && (dev->priv_flags & IFF_ISATAP)) {
400
		pr_info("%s: Disabled Multicast RS\n", dev->name);
401 402 403 404
		ndev->cnf.rtr_solicits = 0;
	}
#endif

405
	INIT_LIST_HEAD(&ndev->tempaddr_list);
406
	setup_timer(&ndev->regen_timer, ipv6_regen_rndid, (unsigned long)ndev);
407 408
	if ((dev->flags&IFF_LOOPBACK) ||
	    dev->type == ARPHRD_TUNNEL ||
409
	    dev->type == ARPHRD_TUNNEL6 ||
410 411
	    dev->type == ARPHRD_SIT ||
	    dev->type == ARPHRD_NONE) {
412 413 414 415 416
		ndev->cnf.use_tempaddr = -1;
	} else {
		in6_dev_hold(ndev);
		ipv6_regen_rndid((unsigned long) ndev);
	}
417

418
	ndev->token = in6addr_any;
L
Linus Torvalds 已提交
419

420
	if (netif_running(dev) && addrconf_qdisc_ok(dev))
421 422
		ndev->if_flags |= IF_READY;

423 424
	ipv6_mc_init_dev(ndev);
	ndev->tstamp = jiffies;
425 426 427 428
	err = addrconf_sysctl_register(ndev);
	if (err) {
		ipv6_mc_destroy_dev(ndev);
		del_timer(&ndev->regen_timer);
429
		snmp6_unregister_dev(ndev);
430 431
		goto err_release;
	}
432
	/* protected by rtnl_lock */
433
	rcu_assign_pointer(dev->ip6_ptr, ndev);
434

435 436 437
	/* Join interface-local all-node multicast group */
	ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allnodes);

438
	/* Join all-node multicast group */
439
	ipv6_dev_mc_inc(dev, &in6addr_linklocal_allnodes);
440

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

L
Linus Torvalds 已提交
445
	return ndev;
446 447 448 449 450 451

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 已提交
452 453
}

454
static struct inet6_dev *ipv6_find_idev(struct net_device *dev)
L
Linus Torvalds 已提交
455 456 457 458 459
{
	struct inet6_dev *idev;

	ASSERT_RTNL();

S
Stephen Hemminger 已提交
460 461 462
	idev = __in6_dev_get(dev);
	if (!idev) {
		idev = ipv6_add_dev(dev);
463
		if (IS_ERR(idev))
L
Linus Torvalds 已提交
464 465
			return NULL;
	}
466

L
Linus Torvalds 已提交
467 468 469 470 471
	if (dev->flags&IFF_UP)
		ipv6_mc_up(idev);
	return idev;
}

472 473 474 475
static int inet6_netconf_msgsize_devconf(int type)
{
	int size =  NLMSG_ALIGN(sizeof(struct netconfmsg))
		    + nla_total_size(4);	/* NETCONFA_IFINDEX */
476
	bool all = false;
477

478 479 480 481
	if (type == NETCONFA_ALL)
		all = true;

	if (all || type == NETCONFA_FORWARDING)
482
		size += nla_total_size(4);
483
#ifdef CONFIG_IPV6_MROUTE
484
	if (all || type == NETCONFA_MC_FORWARDING)
485
		size += nla_total_size(4);
486
#endif
487
	if (all || type == NETCONFA_PROXY_NEIGH)
488
		size += nla_total_size(4);
489

490
	if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
491 492
		size += nla_total_size(4);

493 494 495 496 497 498 499 500 501 502
	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;
503
	bool all = false;
504 505 506

	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
			flags);
507
	if (!nlh)
508 509
		return -EMSGSIZE;

510 511 512
	if (type == NETCONFA_ALL)
		all = true;

513 514 515 516 517 518
	ncm = nlmsg_data(nlh);
	ncm->ncm_family = AF_INET6;

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

519
	if ((all || type == NETCONFA_FORWARDING) &&
520 521
	    nla_put_s32(skb, NETCONFA_FORWARDING, devconf->forwarding) < 0)
		goto nla_put_failure;
522
#ifdef CONFIG_IPV6_MROUTE
523
	if ((all || type == NETCONFA_MC_FORWARDING) &&
524 525 526
	    nla_put_s32(skb, NETCONFA_MC_FORWARDING,
			devconf->mc_forwarding) < 0)
		goto nla_put_failure;
527
#endif
528
	if ((all || type == NETCONFA_PROXY_NEIGH) &&
529 530 531
	    nla_put_s32(skb, NETCONFA_PROXY_NEIGH, devconf->proxy_ndp) < 0)
		goto nla_put_failure;

532
	if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
533 534 535 536
	    nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
			devconf->ignore_routes_with_linkdown) < 0)
		goto nla_put_failure;

537 538
	nlmsg_end(skb, nlh);
	return 0;
539 540 541 542 543 544

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

545 546
void inet6_netconf_notify_devconf(struct net *net, int type, int ifindex,
				  struct ipv6_devconf *devconf)
547 548 549 550 551
{
	struct sk_buff *skb;
	int err = -ENOBUFS;

	skb = nlmsg_new(inet6_netconf_msgsize_devconf(type), GFP_ATOMIC);
552
	if (!skb)
553 554 555 556 557 558 559 560 561 562 563 564 565
		goto errout;

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

569 570 571
static const struct nla_policy devconf_ipv6_policy[NETCONFA_MAX+1] = {
	[NETCONFA_IFINDEX]	= { .len = sizeof(int) },
	[NETCONFA_FORWARDING]	= { .len = sizeof(int) },
572
	[NETCONFA_PROXY_NEIGH]	= { .len = sizeof(int) },
573
	[NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN]	= { .len = sizeof(int) },
574 575 576
};

static int inet6_netconf_get_devconf(struct sk_buff *in_skb,
577
				     struct nlmsghdr *nlh)
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
{
	struct net *net = sock_net(in_skb->sk);
	struct nlattr *tb[NETCONFA_MAX+1];
	struct netconfmsg *ncm;
	struct sk_buff *skb;
	struct ipv6_devconf *devconf;
	struct inet6_dev *in6_dev;
	struct net_device *dev;
	int ifindex;
	int err;

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

594
	err = -EINVAL;
595 596 597 598 599 600 601 602 603 604 605 606 607
	if (!tb[NETCONFA_IFINDEX])
		goto errout;

	ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
	switch (ifindex) {
	case NETCONFA_IFINDEX_ALL:
		devconf = net->ipv6.devconf_all;
		break;
	case NETCONFA_IFINDEX_DEFAULT:
		devconf = net->ipv6.devconf_dflt;
		break;
	default:
		dev = __dev_get_by_index(net, ifindex);
608
		if (!dev)
609 610
			goto errout;
		in6_dev = __in6_dev_get(dev);
611
		if (!in6_dev)
612 613 614 615 616 617
			goto errout;
		devconf = &in6_dev->cnf;
		break;
	}

	err = -ENOBUFS;
618
	skb = nlmsg_new(inet6_netconf_msgsize_devconf(NETCONFA_ALL), GFP_ATOMIC);
619
	if (!skb)
620 621 622 623 624
		goto errout;

	err = inet6_netconf_fill_devconf(skb, ifindex, devconf,
					 NETLINK_CB(in_skb).portid,
					 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
625
					 NETCONFA_ALL);
626 627 628 629 630 631 632 633 634 635 636
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
errout:
	return err;
}

637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653
static int inet6_netconf_dump_devconf(struct sk_buff *skb,
				      struct netlink_callback *cb)
{
	struct net *net = sock_net(skb->sk);
	int h, s_h;
	int idx, s_idx;
	struct net_device *dev;
	struct inet6_dev *idev;
	struct hlist_head *head;

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

	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
		head = &net->dev_index_head[h];
		rcu_read_lock();
654 655
		cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^
			  net->dev_base_seq;
656 657 658 659 660 661 662 663 664 665 666 667 668
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
			if (idx < s_idx)
				goto cont;
			idev = __in6_dev_get(dev);
			if (!idev)
				goto cont;

			if (inet6_netconf_fill_devconf(skb, dev->ifindex,
						       &idev->cnf,
						       NETLINK_CB(cb->skb).portid,
						       cb->nlh->nlmsg_seq,
						       RTM_NEWNETCONF,
						       NLM_F_MULTI,
669
						       NETCONFA_ALL) < 0) {
670 671 672
				rcu_read_unlock();
				goto done;
			}
673
			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
674 675 676 677 678 679 680 681 682 683 684
cont:
			idx++;
		}
		rcu_read_unlock();
	}
	if (h == NETDEV_HASHENTRIES) {
		if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
					       net->ipv6.devconf_all,
					       NETLINK_CB(cb->skb).portid,
					       cb->nlh->nlmsg_seq,
					       RTM_NEWNETCONF, NLM_F_MULTI,
685
					       NETCONFA_ALL) < 0)
686 687 688 689 690 691 692 693 694 695
			goto done;
		else
			h++;
	}
	if (h == NETDEV_HASHENTRIES + 1) {
		if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
					       net->ipv6.devconf_dflt,
					       NETLINK_CB(cb->skb).portid,
					       cb->nlh->nlmsg_seq,
					       RTM_NEWNETCONF, NLM_F_MULTI,
696
					       NETCONFA_ALL) < 0)
697 698 699 700 701 702 703 704 705 706 707
			goto done;
		else
			h++;
	}
done:
	cb->args[0] = h;
	cb->args[1] = idx;

	return skb->len;
}

L
Linus Torvalds 已提交
708 709 710 711 712 713 714 715 716
#ifdef CONFIG_SYSCTL
static void dev_forward_change(struct inet6_dev *idev)
{
	struct net_device *dev;
	struct inet6_ifaddr *ifa;

	if (!idev)
		return;
	dev = idev->dev;
717 718
	if (idev->cnf.forwarding)
		dev_disable_lro(dev);
A
Amerigo Wang 已提交
719
	if (dev->flags & IFF_MULTICAST) {
720
		if (idev->cnf.forwarding) {
721
			ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
722 723 724
			ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allrouters);
			ipv6_dev_mc_inc(dev, &in6addr_sitelocal_allrouters);
		} else {
725
			ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters);
726 727 728
			ipv6_dev_mc_dec(dev, &in6addr_interfacelocal_allrouters);
			ipv6_dev_mc_dec(dev, &in6addr_sitelocal_allrouters);
		}
L
Linus Torvalds 已提交
729
	}
730 731

	list_for_each_entry(ifa, &idev->addr_list, if_list) {
M
Michal Wrobel 已提交
732 733
		if (ifa->flags&IFA_F_TENTATIVE)
			continue;
L
Linus Torvalds 已提交
734 735 736 737 738
		if (idev->cnf.forwarding)
			addrconf_join_anycast(ifa);
		else
			addrconf_leave_anycast(ifa);
	}
739 740
	inet6_netconf_notify_devconf(dev_net(dev), NETCONFA_FORWARDING,
				     dev->ifindex, &idev->cnf);
L
Linus Torvalds 已提交
741 742 743
}


744
static void addrconf_forward_change(struct net *net, __s32 newf)
L
Linus Torvalds 已提交
745 746 747 748
{
	struct net_device *dev;
	struct inet6_dev *idev;

749
	for_each_netdev(net, dev) {
L
Linus Torvalds 已提交
750 751
		idev = __in6_dev_get(dev);
		if (idev) {
752 753
			int changed = (!idev->cnf.forwarding) ^ (!newf);
			idev->cnf.forwarding = newf;
L
Linus Torvalds 已提交
754 755 756 757 758
			if (changed)
				dev_forward_change(idev);
		}
	}
}
759

760
static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int newf)
761
{
762
	struct net *net;
763 764 765 766
	int old;

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

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

772
	if (p == &net->ipv6.devconf_dflt->forwarding) {
773 774 775 776
		if ((!newf) ^ (!old))
			inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING,
						     NETCONFA_IFINDEX_DEFAULT,
						     net->ipv6.devconf_dflt);
777 778
		rtnl_unlock();
		return 0;
E
Eric W. Biederman 已提交
779
	}
780

781 782 783
	if (p == &net->ipv6.devconf_all->forwarding) {
		net->ipv6.devconf_dflt->forwarding = newf;
		addrconf_forward_change(net, newf);
784 785 786 787
		if ((!newf) ^ (!old))
			inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING,
						     NETCONFA_IFINDEX_ALL,
						     net->ipv6.devconf_all);
788
	} else if ((!newf) ^ (!old))
789
		dev_forward_change((struct inet6_dev *)table->extra1);
790
	rtnl_unlock();
791

792
	if (newf)
793
		rt6_purge_dflt_routers(net);
794
	return 1;
795
}
796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852

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),
							     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,
						     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,
						     NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
						     NETCONFA_IFINDEX_ALL,
						     net->ipv6.devconf_all);
	}
	rtnl_unlock();

	return 1;
}

L
Linus Torvalds 已提交
853 854
#endif

855
/* Nobody refers to this ifaddr, destroy it */
L
Linus Torvalds 已提交
856 857
void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
{
858
	WARN_ON(!hlist_unhashed(&ifp->addr_lst));
859

L
Linus Torvalds 已提交
860
#ifdef NET_REFCNT_DEBUG
861
	pr_debug("%s\n", __func__);
L
Linus Torvalds 已提交
862 863 864 865
#endif

	in6_dev_put(ifp->idev);

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

870
	if (ifp->state != INET6_IFADDR_STATE_DEAD) {
871
		pr_warn("Freeing alive inet6 address %p\n", ifp);
L
Linus Torvalds 已提交
872 873
		return;
	}
A
Amerigo Wang 已提交
874
	ip6_rt_put(ifp->rt);
L
Linus Torvalds 已提交
875

876
	kfree_rcu(ifp, rcu);
L
Linus Torvalds 已提交
877 878
}

B
Brian Haley 已提交
879 880 881
static void
ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp)
{
882
	struct list_head *p;
883
	int ifp_scope = ipv6_addr_src_scope(&ifp->addr);
B
Brian Haley 已提交
884 885 886 887 888

	/*
	 * Each device address list is sorted in order of scope -
	 * global before linklocal.
	 */
889 890 891
	list_for_each(p, &idev->addr_list) {
		struct inet6_ifaddr *ifa
			= list_entry(p, struct inet6_ifaddr, if_list);
892
		if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr))
B
Brian Haley 已提交
893 894 895
			break;
	}

896
	list_add_tail(&ifp->if_list, p);
B
Brian Haley 已提交
897 898
}

E
Eric Dumazet 已提交
899
static u32 inet6_addr_hash(const struct in6_addr *addr)
900
{
E
Eric Dumazet 已提交
901
	return hash_32(ipv6_addr_hash(addr), IN6_ADDR_HSIZE_SHIFT);
902 903
}

L
Linus Torvalds 已提交
904 905 906
/* On success it returns ifp with increased reference count */

static struct inet6_ifaddr *
907 908
ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
	      const struct in6_addr *peer_addr, int pfxlen,
909
	      int scope, u32 flags, u32 valid_lft, u32 prefered_lft)
L
Linus Torvalds 已提交
910 911 912
{
	struct inet6_ifaddr *ifa = NULL;
	struct rt6_info *rt;
913
	unsigned int hash;
L
Linus Torvalds 已提交
914
	int err = 0;
915 916 917 918 919 920 921
	int addr_type = ipv6_addr_type(addr);

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

923
	rcu_read_lock_bh();
L
Linus Torvalds 已提交
924 925 926 927 928
	if (idev->dead) {
		err = -ENODEV;			/*XXX*/
		goto out2;
	}

929
	if (idev->cnf.disable_ipv6) {
930 931 932 933
		err = -EACCES;
		goto out2;
	}

934
	spin_lock(&addrconf_hash_lock);
L
Linus Torvalds 已提交
935 936

	/* Ignore adding duplicate addresses on an interface */
937
	if (ipv6_chk_same_addr(dev_net(idev->dev), addr, idev->dev)) {
938
		ADBG("ipv6_add_addr: already assigned\n");
L
Linus Torvalds 已提交
939 940 941 942
		err = -EEXIST;
		goto out;
	}

943
	ifa = kzalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC);
L
Linus Torvalds 已提交
944

945
	if (!ifa) {
946
		ADBG("ipv6_add_addr: malloc failed\n");
L
Linus Torvalds 已提交
947 948 949 950
		err = -ENOBUFS;
		goto out;
	}

951
	rt = addrconf_dst_alloc(idev, addr, false);
L
Linus Torvalds 已提交
952 953 954 955 956
	if (IS_ERR(rt)) {
		err = PTR_ERR(rt);
		goto out;
	}

957 958
	neigh_parms_data_state_setall(idev->nd_parms);

A
Alexey Dobriyan 已提交
959
	ifa->addr = *addr;
960 961
	if (peer_addr)
		ifa->peer_addr = *peer_addr;
L
Linus Torvalds 已提交
962 963

	spin_lock_init(&ifa->lock);
964
	INIT_DELAYED_WORK(&ifa->dad_work, addrconf_dad_work);
965
	INIT_HLIST_NODE(&ifa->addr_lst);
L
Linus Torvalds 已提交
966 967 968
	ifa->scope = scope;
	ifa->prefix_len = pfxlen;
	ifa->flags = flags | IFA_F_TENTATIVE;
969 970
	ifa->valid_lft = valid_lft;
	ifa->prefered_lft = prefered_lft;
L
Linus Torvalds 已提交
971
	ifa->cstamp = ifa->tstamp = jiffies;
972
	ifa->tokenized = false;
L
Linus Torvalds 已提交
973

974 975
	ifa->rt = rt;

L
Linus Torvalds 已提交
976 977 978 979 980 981
	ifa->idev = idev;
	in6_dev_hold(idev);
	/* For caller */
	in6_ifa_hold(ifa);

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

984 985
	hlist_add_head_rcu(&ifa->addr_lst, &inet6_addr_lst[hash]);
	spin_unlock(&addrconf_hash_lock);
L
Linus Torvalds 已提交
986 987 988

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

	if (ifa->flags&IFA_F_TEMPORARY) {
992
		list_add(&ifa->tmp_list, &idev->tempaddr_list);
L
Linus Torvalds 已提交
993 994 995 996 997 998
		in6_ifa_hold(ifa);
	}

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

1001
	if (likely(err == 0))
1002
		inet6addr_notifier_call_chain(NETDEV_UP, ifa);
L
Linus Torvalds 已提交
1003 1004 1005 1006 1007 1008 1009
	else {
		kfree(ifa);
		ifa = ERR_PTR(err);
	}

	return ifa;
out:
1010
	spin_unlock(&addrconf_hash_lock);
L
Linus Torvalds 已提交
1011 1012 1013
	goto out2;
}

1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095
enum cleanup_prefix_rt_t {
	CLEANUP_PREFIX_RT_NOP,    /* no cleanup action for prefix route */
	CLEANUP_PREFIX_RT_DEL,    /* delete the prefix route */
	CLEANUP_PREFIX_RT_EXPIRE, /* update the lifetime of the prefix route */
};

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

	*expires = jiffies;

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

		action = CLEANUP_PREFIX_RT_EXPIRE;

		spin_lock(&ifa->lock);

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

	return action;
}

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

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


L
Linus Torvalds 已提交
1096 1097 1098 1099
/* This function wants to get referenced ifp and releases it before return */

static void ipv6_del_addr(struct inet6_ifaddr *ifp)
{
1100
	int state;
1101 1102
	enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_NOP;
	unsigned long expires;
L
Linus Torvalds 已提交
1103

1104 1105
	ASSERT_RTNL();

1106
	spin_lock_bh(&ifp->lock);
1107
	state = ifp->state;
1108
	ifp->state = INET6_IFADDR_STATE_DEAD;
1109
	spin_unlock_bh(&ifp->lock);
1110 1111 1112

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

1114 1115 1116
	spin_lock_bh(&addrconf_hash_lock);
	hlist_del_init_rcu(&ifp->addr_lst);
	spin_unlock_bh(&addrconf_hash_lock);
L
Linus Torvalds 已提交
1117

1118
	write_lock_bh(&ifp->idev->lock);
1119

L
Linus Torvalds 已提交
1120
	if (ifp->flags&IFA_F_TEMPORARY) {
1121 1122 1123 1124
		list_del(&ifp->tmp_list);
		if (ifp->ifpub) {
			in6_ifa_put(ifp->ifpub);
			ifp->ifpub = NULL;
L
Linus Torvalds 已提交
1125
		}
1126
		__in6_ifa_put(ifp);
L
Linus Torvalds 已提交
1127 1128
	}

1129 1130
	if (ifp->flags & IFA_F_PERMANENT && !(ifp->flags & IFA_F_NOPREFIXROUTE))
		action = check_cleanup_prefix_route(ifp, &expires);
1131

1132 1133 1134 1135
	list_del_init(&ifp->if_list);
	__in6_ifa_put(ifp);

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

1137
	addrconf_del_dad_work(ifp);
1138

L
Linus Torvalds 已提交
1139 1140
	ipv6_ifa_notify(RTM_DELADDR, ifp);

1141
	inet6addr_notifier_call_chain(NETDEV_DOWN, ifp);
L
Linus Torvalds 已提交
1142

1143 1144 1145
	if (action != CLEANUP_PREFIX_RT_NOP) {
		cleanup_prefix_route(ifp, expires,
			action == CLEANUP_PREFIX_RT_DEL);
L
Linus Torvalds 已提交
1146 1147
	}

1148 1149
	/* clean up prefsrc entries */
	rt6_remove_prefsrc(ifp);
1150
out:
L
Linus Torvalds 已提交
1151 1152 1153 1154 1155 1156 1157
	in6_ifa_put(ifp);
}

static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, struct inet6_ifaddr *ift)
{
	struct inet6_dev *idev = ifp->idev;
	struct in6_addr addr, *tmpaddr;
1158
	unsigned long tmp_prefered_lft, tmp_valid_lft, tmp_tstamp, age;
1159
	unsigned long regen_advance;
L
Linus Torvalds 已提交
1160 1161
	int tmp_plen;
	int ret = 0;
1162
	u32 addr_flags;
1163
	unsigned long now = jiffies;
L
Linus Torvalds 已提交
1164

1165
	write_lock_bh(&idev->lock);
L
Linus Torvalds 已提交
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
	if (ift) {
		spin_lock_bh(&ift->lock);
		memcpy(&addr.s6_addr[8], &ift->addr.s6_addr[8], 8);
		spin_unlock_bh(&ift->lock);
		tmpaddr = &addr;
	} else {
		tmpaddr = NULL;
	}
retry:
	in6_dev_hold(idev);
	if (idev->cnf.use_tempaddr <= 0) {
1177
		write_unlock_bh(&idev->lock);
1178
		pr_info("%s: use_tempaddr is disabled\n", __func__);
L
Linus Torvalds 已提交
1179 1180 1181 1182 1183 1184 1185 1186
		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);
1187
		write_unlock_bh(&idev->lock);
1188 1189
		pr_warn("%s: regeneration time exceeded - disabled temporary address support\n",
			__func__);
L
Linus Torvalds 已提交
1190 1191 1192 1193 1194 1195
		in6_dev_put(idev);
		ret = -1;
		goto out;
	}
	in6_ifa_hold(ifp);
	memcpy(addr.s6_addr, ifp->addr.s6_addr, 8);
S
Sorin Dumitru 已提交
1196
	__ipv6_try_regen_rndid(idev, tmpaddr);
L
Linus Torvalds 已提交
1197
	memcpy(&addr.s6_addr[8], idev->rndid, 8);
1198
	age = (now - ifp->tstamp) / HZ;
L
Linus Torvalds 已提交
1199 1200
	tmp_valid_lft = min_t(__u32,
			      ifp->valid_lft,
1201
			      idev->cnf.temp_valid_lft + age);
1202 1203
	tmp_prefered_lft = min_t(__u32,
				 ifp->prefered_lft,
1204
				 idev->cnf.temp_prefered_lft + age -
1205
				 idev->cnf.max_desync_factor);
L
Linus Torvalds 已提交
1206 1207 1208 1209
	tmp_plen = ifp->prefix_len;
	tmp_tstamp = ifp->tstamp;
	spin_unlock_bh(&ifp->lock);

1210
	regen_advance = idev->cnf.regen_max_retry *
1211 1212
			idev->cnf.dad_transmits *
			NEIGH_VAR(idev->nd_parms, RETRANS_TIME) / HZ;
1213
	write_unlock_bh(&idev->lock);
1214

1215 1216 1217 1218
	/* 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.
1219 1220
	 * Use age calculation as in addrconf_verify to avoid unnecessary
	 * temporary addresses being generated.
1221
	 */
1222 1223
	age = (now - tmp_tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
	if (tmp_prefered_lft <= regen_advance + age) {
1224 1225 1226 1227 1228 1229
		in6_ifa_put(ifp);
		in6_dev_put(idev);
		ret = -1;
		goto out;
	}

1230 1231 1232 1233 1234
	addr_flags = IFA_F_TEMPORARY;
	/* set in addrconf_prefix_rcv() */
	if (ifp->flags & IFA_F_OPTIMISTIC)
		addr_flags |= IFA_F_OPTIMISTIC;

1235 1236 1237 1238
	ift = ipv6_add_addr(idev, &addr, NULL, tmp_plen,
			    ipv6_addr_scope(&addr), addr_flags,
			    tmp_valid_lft, tmp_prefered_lft);
	if (IS_ERR(ift)) {
L
Linus Torvalds 已提交
1239 1240
		in6_ifa_put(ifp);
		in6_dev_put(idev);
1241
		pr_info("%s: retry temporary address regeneration\n", __func__);
L
Linus Torvalds 已提交
1242
		tmpaddr = &addr;
1243
		write_lock_bh(&idev->lock);
L
Linus Torvalds 已提交
1244 1245 1246 1247 1248
		goto retry;
	}

	spin_lock_bh(&ift->lock);
	ift->ifpub = ifp;
1249
	ift->cstamp = now;
L
Linus Torvalds 已提交
1250 1251 1252
	ift->tstamp = tmp_tstamp;
	spin_unlock_bh(&ift->lock);

1253
	addrconf_dad_start(ift);
L
Linus Torvalds 已提交
1254 1255 1256 1257 1258 1259 1260
	in6_ifa_put(ift);
	in6_dev_put(idev);
out:
	return ret;
}

/*
1261
 *	Choose an appropriate source address (RFC3484)
L
Linus Torvalds 已提交
1262
 */
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275
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,
1276 1277 1278
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
	IPV6_SADDR_RULE_NOT_OPTIMISTIC,
#endif
1279 1280 1281
	IPV6_SADDR_RULE_MAX
};

1282
struct ipv6_saddr_score {
1283 1284 1285 1286 1287 1288
	int			rule;
	int			addr_type;
	struct inet6_ifaddr	*ifa;
	DECLARE_BITMAP(scorebits, IPV6_SADDR_RULE_MAX);
	int			scopedist;
	int			matchlen;
1289 1290
};

1291
struct ipv6_saddr_dst {
1292
	const struct in6_addr *addr;
1293 1294 1295
	int ifindex;
	int scope;
	int label;
1296
	unsigned int prefs;
1297
};
1298

D
Dave Jones 已提交
1299
static inline int ipv6_saddr_preferred(int type)
L
Linus Torvalds 已提交
1300
{
U
Ulrich Weber 已提交
1301
	if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4|IPV6_ADDR_LOOPBACK))
1302 1303
		return 1;
	return 0;
L
Linus Torvalds 已提交
1304 1305
}

1306 1307 1308 1309 1310 1311 1312 1313 1314
static inline bool ipv6_use_optimistic_addr(struct inet6_dev *idev)
{
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
	return idev && idev->cnf.optimistic_dad && idev->cnf.use_optimistic;
#else
	return false;
#endif
}

1315 1316
static int ipv6_get_saddr_eval(struct net *net,
			       struct ipv6_saddr_score *score,
1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355
			       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
1356
		 *  B-15 |    \        if scope is enough for destination.
1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374
		 *       |             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:
1375
	    {
1376
		/* Rule 3: Avoid deprecated and optimistic addresses */
1377 1378 1379 1380
		u8 avoid = IFA_F_DEPRECATED;

		if (!ipv6_use_optimistic_addr(score->ifa->idev))
			avoid |= IFA_F_OPTIMISTIC;
1381
		ret = ipv6_saddr_preferred(score->addr_type) ||
1382
		      !(score->ifa->flags & avoid);
1383
		break;
1384
	    }
1385 1386
#ifdef CONFIG_IPV6_MIP6
	case IPV6_SADDR_RULE_HOA:
1387
	    {
1388
		/* Rule 4: Prefer home address */
1389 1390
		int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA);
		ret = !(score->ifa->flags & IFA_F_HOMEADDRESS) ^ prefhome;
1391
		break;
1392
	    }
1393 1394 1395 1396 1397 1398 1399 1400
#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 */
1401 1402
		ret = ipv6_addr_label(net,
				      &score->ifa->addr, score->addr_type,
1403 1404 1405
				      score->ifa->idev->dev->ifindex) == dst->label;
		break;
	case IPV6_SADDR_RULE_PRIVACY:
1406
	    {
1407
		/* Rule 7: Prefer public address
L
Lucas De Marchi 已提交
1408
		 * Note: prefer temporary address if use_tempaddr >= 2
1409
		 */
1410 1411 1412 1413
		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;
1414
		break;
1415
	    }
1416 1417 1418 1419 1420 1421 1422 1423 1424
	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 */
1425 1426 1427 1428
		ret = ipv6_addr_diff(&score->ifa->addr, dst->addr);
		if (ret > score->ifa->prefix_len)
			ret = score->ifa->prefix_len;
		score->matchlen = ret;
1429
		break;
1430 1431 1432 1433 1434 1435 1436 1437
#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
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
	default:
		ret = 0;
	}

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

1449 1450 1451 1452 1453
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)
1454
{
1455
	struct ipv6_saddr_score *score = &scores[1 - hiscore_idx], *hiscore = &scores[hiscore_idx];
1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513

	read_lock_bh(&idev->lock);
	list_for_each_entry(score->ifa, &idev->addr_list, if_list) {
		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) {
				if (hiscore->ifa)
					in6_ifa_put(hiscore->ifa);

				in6_ifa_hold(score->ifa);

				swap(hiscore, score);
1514
				hiscore_idx = 1 - hiscore_idx;
1515 1516 1517 1518 1519 1520 1521 1522 1523 1524

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

				break;
			}
		}
	}
out:
	read_unlock_bh(&idev->lock);
1525
	return hiscore_idx;
1526 1527
}

1528
int ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev,
1529
		       const struct in6_addr *daddr, unsigned int prefs,
1530
		       struct in6_addr *saddr)
L
Linus Torvalds 已提交
1531
{
1532
	struct ipv6_saddr_score scores[2], *hiscore;
1533
	struct ipv6_saddr_dst dst;
1534
	struct inet6_dev *idev;
1535
	struct net_device *dev;
1536
	int dst_type;
1537
	bool use_oif_addr = false;
1538
	int hiscore_idx = 0;
L
Linus Torvalds 已提交
1539

1540 1541 1542 1543
	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);
1544
	dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex);
1545
	dst.prefs = prefs;
1546

1547 1548
	scores[hiscore_idx].rule = -1;
	scores[hiscore_idx].ifa = NULL;
L
Linus Torvalds 已提交
1549

1550
	rcu_read_lock();
L
Linus Torvalds 已提交
1551

1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
	/* 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.)
1563 1564 1565 1566
	 *  - "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)
1567 1568
	 */
	if (dst_dev) {
1569
		idev = __in6_dev_get(dst_dev);
1570
		if ((dst_type & IPV6_ADDR_MULTICAST) ||
1571 1572
		    dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL ||
		    (idev && idev->cnf.use_oif_addrs_only)) {
1573 1574 1575
			use_oif_addr = true;
		}
	}
1576

1577
	if (use_oif_addr) {
1578
		if (idev)
1579
			hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx);
1580 1581 1582 1583
	} else {
		for_each_netdev_rcu(net, dev) {
			idev = __in6_dev_get(dev);
			if (!idev)
1584
				continue;
1585
			hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx);
L
Linus Torvalds 已提交
1586 1587
		}
	}
1588
	rcu_read_unlock();
L
Linus Torvalds 已提交
1589

1590
	hiscore = &scores[hiscore_idx];
1591
	if (!hiscore->ifa)
1592
		return -EADDRNOTAVAIL;
1593

A
Alexey Dobriyan 已提交
1594
	*saddr = hiscore->ifa->addr;
1595
	in6_ifa_put(hiscore->ifa);
1596
	return 0;
L
Linus Torvalds 已提交
1597
}
1598
EXPORT_SYMBOL(ipv6_dev_get_saddr);
L
Linus Torvalds 已提交
1599

1600
int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr,
1601
		      u32 banned_flags)
1602 1603 1604 1605
{
	struct inet6_ifaddr *ifp;
	int err = -EADDRNOTAVAIL;

1606 1607 1608
	list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
		if (ifp->scope > IFA_LINK)
			break;
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
		if (ifp->scope == IFA_LINK &&
		    !(ifp->flags & banned_flags)) {
			*addr = ifp->addr;
			err = 0;
			break;
		}
	}
	return err;
}

1619
int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
1620
		    u32 banned_flags)
L
Linus Torvalds 已提交
1621 1622 1623 1624
{
	struct inet6_dev *idev;
	int err = -EADDRNOTAVAIL;

1625
	rcu_read_lock();
S
Stephen Hemminger 已提交
1626 1627
	idev = __in6_dev_get(dev);
	if (idev) {
L
Linus Torvalds 已提交
1628
		read_lock_bh(&idev->lock);
1629
		err = __ipv6_get_lladdr(idev, addr, banned_flags);
L
Linus Torvalds 已提交
1630 1631
		read_unlock_bh(&idev->lock);
	}
1632
	rcu_read_unlock();
L
Linus Torvalds 已提交
1633 1634 1635 1636 1637 1638 1639 1640 1641
	return err;
}

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

	read_lock_bh(&idev->lock);
1642
	list_for_each_entry(ifp, &idev->addr_list, if_list)
L
Linus Torvalds 已提交
1643 1644 1645 1646 1647
		cnt++;
	read_unlock_bh(&idev->lock);
	return cnt;
}

1648
int ipv6_chk_addr(struct net *net, const struct in6_addr *addr,
1649
		  const struct net_device *dev, int strict)
1650 1651 1652 1653 1654 1655 1656 1657
{
	return ipv6_chk_addr_and_flags(net, addr, dev, strict, IFA_F_TENTATIVE);
}
EXPORT_SYMBOL(ipv6_chk_addr);

int ipv6_chk_addr_and_flags(struct net *net, const struct in6_addr *addr,
			    const struct net_device *dev, int strict,
			    u32 banned_flags)
L
Linus Torvalds 已提交
1658
{
1659
	struct inet6_ifaddr *ifp;
E
Eric Dumazet 已提交
1660
	unsigned int hash = inet6_addr_hash(addr);
1661
	u32 ifp_flags;
L
Linus Torvalds 已提交
1662

1663
	rcu_read_lock_bh();
1664
	hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
1665
		if (!net_eq(dev_net(ifp->idev->dev), net))
1666
			continue;
1667 1668 1669 1670 1671 1672
		/* 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 已提交
1673
		if (ipv6_addr_equal(&ifp->addr, addr) &&
1674
		    !(ifp_flags&banned_flags) &&
1675
		    (!dev || ifp->idev->dev == dev ||
1676 1677 1678
		     !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))) {
			rcu_read_unlock_bh();
			return 1;
L
Linus Torvalds 已提交
1679 1680
		}
	}
1681

1682 1683
	rcu_read_unlock_bh();
	return 0;
L
Linus Torvalds 已提交
1684
}
1685
EXPORT_SYMBOL(ipv6_chk_addr_and_flags);
1686

1687 1688
static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
			       struct net_device *dev)
L
Linus Torvalds 已提交
1689
{
E
Eric Dumazet 已提交
1690
	unsigned int hash = inet6_addr_hash(addr);
1691
	struct inet6_ifaddr *ifp;
L
Linus Torvalds 已提交
1692

1693
	hlist_for_each_entry(ifp, &inet6_addr_lst[hash], addr_lst) {
1694
		if (!net_eq(dev_net(ifp->idev->dev), net))
1695
			continue;
L
Linus Torvalds 已提交
1696
		if (ipv6_addr_equal(&ifp->addr, addr)) {
1697
			if (!dev || ifp->idev->dev == dev)
1698
				return true;
L
Linus Torvalds 已提交
1699 1700
		}
	}
1701
	return false;
L
Linus Torvalds 已提交
1702 1703
}

1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730
/* Compares an address/prefix_len with addresses on device @dev.
 * If one is found it returns true.
 */
bool ipv6_chk_custom_prefix(const struct in6_addr *addr,
	const unsigned int prefix_len, struct net_device *dev)
{
	struct inet6_dev *idev;
	struct inet6_ifaddr *ifa;
	bool ret = false;

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

	return ret;
}
EXPORT_SYMBOL(ipv6_chk_custom_prefix);

1731
int ipv6_chk_prefix(const struct in6_addr *addr, struct net_device *dev)
1732 1733 1734 1735 1736 1737 1738 1739 1740 1741
{
	struct inet6_dev *idev;
	struct inet6_ifaddr *ifa;
	int	onlink;

	onlink = 0;
	rcu_read_lock();
	idev = __in6_dev_get(dev);
	if (idev) {
		read_lock_bh(&idev->lock);
1742
		list_for_each_entry(ifa, &idev->addr_list, if_list) {
1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754
			onlink = ipv6_prefix_equal(addr, &ifa->addr,
						   ifa->prefix_len);
			if (onlink)
				break;
		}
		read_unlock_bh(&idev->lock);
	}
	rcu_read_unlock();
	return onlink;
}
EXPORT_SYMBOL(ipv6_chk_prefix);

1755
struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr,
1756
				     struct net_device *dev, int strict)
L
Linus Torvalds 已提交
1757
{
1758
	struct inet6_ifaddr *ifp, *result = NULL;
E
Eric Dumazet 已提交
1759
	unsigned int hash = inet6_addr_hash(addr);
L
Linus Torvalds 已提交
1760

1761
	rcu_read_lock_bh();
1762
	hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) {
1763
		if (!net_eq(dev_net(ifp->idev->dev), net))
1764
			continue;
L
Linus Torvalds 已提交
1765
		if (ipv6_addr_equal(&ifp->addr, addr)) {
1766
			if (!dev || ifp->idev->dev == dev ||
L
Linus Torvalds 已提交
1767
			    !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
1768
				result = ifp;
L
Linus Torvalds 已提交
1769 1770 1771 1772 1773
				in6_ifa_hold(ifp);
				break;
			}
		}
	}
1774
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
1775

1776
	return result;
L
Linus Torvalds 已提交
1777 1778 1779 1780
}

/* Gets referenced address, destroys ifaddr */

B
Brian Haley 已提交
1781
static void addrconf_dad_stop(struct inet6_ifaddr *ifp, int dad_failed)
L
Linus Torvalds 已提交
1782
{
1783 1784 1785
	if (dad_failed)
		ifp->flags |= IFA_F_DADFAILED;

L
Linus Torvalds 已提交
1786 1787
	if (ifp->flags&IFA_F_PERMANENT) {
		spin_lock_bh(&ifp->lock);
1788
		addrconf_del_dad_work(ifp);
L
Linus Torvalds 已提交
1789 1790
		ifp->flags |= IFA_F_TENTATIVE;
		spin_unlock_bh(&ifp->lock);
1791 1792
		if (dad_failed)
			ipv6_ifa_notify(0, ifp);
L
Linus Torvalds 已提交
1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806
		in6_ifa_put(ifp);
	} else if (ifp->flags&IFA_F_TEMPORARY) {
		struct inet6_ifaddr *ifpub;
		spin_lock_bh(&ifp->lock);
		ifpub = ifp->ifpub;
		if (ifpub) {
			in6_ifa_hold(ifpub);
			spin_unlock_bh(&ifp->lock);
			ipv6_create_tempaddr(ifpub, ifp);
			in6_ifa_put(ifpub);
		} else {
			spin_unlock_bh(&ifp->lock);
		}
		ipv6_del_addr(ifp);
1807
	} else {
L
Linus Torvalds 已提交
1808
		ipv6_del_addr(ifp);
1809
	}
L
Linus Torvalds 已提交
1810 1811
}

H
Herbert Xu 已提交
1812 1813 1814 1815
static int addrconf_dad_end(struct inet6_ifaddr *ifp)
{
	int err = -ENOENT;

1816
	spin_lock_bh(&ifp->lock);
H
Herbert Xu 已提交
1817 1818 1819 1820
	if (ifp->state == INET6_IFADDR_STATE_DAD) {
		ifp->state = INET6_IFADDR_STATE_POSTDAD;
		err = 0;
	}
1821
	spin_unlock_bh(&ifp->lock);
H
Herbert Xu 已提交
1822 1823 1824 1825

	return err;
}

1826 1827
void addrconf_dad_failure(struct inet6_ifaddr *ifp)
{
1828
	struct in6_addr addr;
1829
	struct inet6_dev *idev = ifp->idev;
1830
	struct net *net = dev_net(ifp->idev->dev);
1831

1832 1833
	if (addrconf_dad_end(ifp)) {
		in6_ifa_put(ifp);
H
Herbert Xu 已提交
1834
		return;
1835
	}
H
Herbert Xu 已提交
1836

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

1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850
	spin_lock_bh(&ifp->lock);

	if (ifp->flags & IFA_F_STABLE_PRIVACY) {
		int scope = ifp->scope;
		u32 flags = ifp->flags;
		struct in6_addr new_addr;
		struct inet6_ifaddr *ifp2;
		u32 valid_lft, preferred_lft;
		int pfxlen = ifp->prefix_len;
		int retries = ifp->stable_privacy_retry + 1;

1851
		if (retries > net->ipv6.sysctl.idgen_retries) {
1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865
			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;

		valid_lft = ifp->valid_lft;
		preferred_lft = ifp->prefered_lft;

		spin_unlock_bh(&ifp->lock);
1866

1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885
		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);

		ifp2 = ipv6_add_addr(idev, &new_addr, NULL, pfxlen,
				     scope, flags, valid_lft,
				     preferred_lft);
		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);

1886
		addrconf_mod_dad_work(ifp2, net->ipv6.sysctl.idgen_delay);
1887 1888 1889 1890
		in6_ifa_put(ifp2);
lock_errdad:
		spin_lock_bh(&ifp->lock);
	} else if (idev->cnf.accept_dad > 1 && !idev->cnf.disable_ipv6) {
1891 1892 1893 1894 1895 1896 1897
		addr.s6_addr32[0] = htonl(0xfe800000);
		addr.s6_addr32[1] = 0;

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

1899
			pr_info("%s: IPv6 being disabled!\n",
1900
				ifp->idev->dev->name);
1901 1902 1903
		}
	}

1904
errdad:
1905 1906
	/* transition from _POSTDAD to _ERRDAD */
	ifp->state = INET6_IFADDR_STATE_ERRDAD;
1907
	spin_unlock_bh(&ifp->lock);
1908 1909

	addrconf_mod_dad_work(ifp, 0);
1910
}
L
Linus Torvalds 已提交
1911

1912 1913
/* Join to solicited addr multicast group.
 * caller must hold RTNL */
1914
void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr)
L
Linus Torvalds 已提交
1915 1916 1917 1918 1919 1920 1921 1922 1923 1924
{
	struct in6_addr maddr;

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

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

1925
/* caller must hold RTNL */
1926
void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr)
L
Linus Torvalds 已提交
1927 1928 1929 1930 1931 1932 1933 1934 1935 1936
{
	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);
}

1937
/* caller must hold RTNL */
1938
static void addrconf_join_anycast(struct inet6_ifaddr *ifp)
L
Linus Torvalds 已提交
1939 1940
{
	struct in6_addr addr;
1941

1942
	if (ifp->prefix_len >= 127) /* RFC 6164 */
1943
		return;
L
Linus Torvalds 已提交
1944 1945 1946
	ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
	if (ipv6_addr_any(&addr))
		return;
W
WANG Cong 已提交
1947
	__ipv6_dev_ac_inc(ifp->idev, &addr);
L
Linus Torvalds 已提交
1948 1949
}

1950
/* caller must hold RTNL */
1951
static void addrconf_leave_anycast(struct inet6_ifaddr *ifp)
L
Linus Torvalds 已提交
1952 1953
{
	struct in6_addr addr;
1954

1955
	if (ifp->prefix_len >= 127) /* RFC 6164 */
1956
		return;
L
Linus Torvalds 已提交
1957 1958 1959 1960 1961 1962
	ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
	if (ipv6_addr_any(&addr))
		return;
	__ipv6_dev_ac_dec(ifp->idev, &addr);
}

1963 1964
static int addrconf_ifid_eui64(u8 *eui, struct net_device *dev)
{
1965
	if (dev->addr_len != EUI64_ADDR_LEN)
1966
		return -1;
1967
	memcpy(eui, dev->dev_addr, EUI64_ADDR_LEN);
1968
	eui[0] ^= 2;
1969 1970 1971
	return 0;
}

1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985
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;
}

1986 1987 1988 1989 1990 1991
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);
1992
	eui[7] = *(u8 *)dev->dev_addr;
1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
	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;
}

2005
static int __ipv6_isatap_ifid(u8 *eui, __be32 addr)
2006
{
2007 2008
	if (addr == 0)
		return -1;
2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
	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;
}

2029 2030 2031 2032 2033
static int addrconf_ifid_gre(u8 *eui, struct net_device *dev)
{
	return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
}

2034 2035 2036 2037 2038 2039 2040 2041 2042 2043
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 已提交
2044 2045 2046 2047 2048
static int ipv6_generate_eui64(u8 *eui, struct net_device *dev)
{
	switch (dev->type) {
	case ARPHRD_ETHER:
	case ARPHRD_FDDI:
2049
		return addrconf_ifid_eui48(eui, dev);
L
Linus Torvalds 已提交
2050
	case ARPHRD_ARCNET:
2051
		return addrconf_ifid_arcnet(eui, dev);
L
Linus Torvalds 已提交
2052
	case ARPHRD_INFINIBAND:
2053
		return addrconf_ifid_infiniband(eui, dev);
F
Fred L. Templin 已提交
2054
	case ARPHRD_SIT:
2055
		return addrconf_ifid_sit(eui, dev);
2056 2057
	case ARPHRD_IPGRE:
		return addrconf_ifid_gre(eui, dev);
2058
	case ARPHRD_6LOWPAN:
2059
		return addrconf_ifid_eui64(eui, dev);
2060 2061
	case ARPHRD_IEEE1394:
		return addrconf_ifid_ieee1394(eui, dev);
2062 2063
	case ARPHRD_TUNNEL6:
		return addrconf_ifid_ip6tnl(eui, dev);
L
Linus Torvalds 已提交
2064 2065 2066 2067 2068 2069 2070 2071 2072 2073
	}
	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);
2074 2075 2076
	list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
		if (ifp->scope > IFA_LINK)
			break;
L
Linus Torvalds 已提交
2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087
		if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
			memcpy(eui, ifp->addr.s6_addr+8, 8);
			err = 0;
			break;
		}
	}
	read_unlock_bh(&idev->lock);
	return err;
}

/* (re)generation of randomized interface identifier (RFC 3041 3.2, 3.5) */
S
Sorin Dumitru 已提交
2088
static void __ipv6_regen_rndid(struct inet6_dev *idev)
L
Linus Torvalds 已提交
2089 2090
{
regen:
2091
	get_random_bytes(idev->rndid, sizeof(idev->rndid));
L
Linus Torvalds 已提交
2092 2093 2094 2095 2096 2097 2098 2099
	idev->rndid[0] &= ~0x02;

	/*
	 * <draft-ietf-ipngwg-temp-addresses-v2-00.txt>:
	 * check if generated address is not inappropriate
	 *
	 *  - Reserved subnet anycast (RFC 2526)
	 *	11111101 11....11 1xxxxxxx
F
Fred L. Templin 已提交
2100
	 *  - ISATAP (RFC4214) 6.1
L
Linus Torvalds 已提交
2101 2102 2103 2104
	 *	00-00-5E-FE-xx-xx-xx-xx
	 *  - value 0
	 *  - XXX: already assigned to an address on the device
	 */
2105
	if (idev->rndid[0] == 0xfd &&
L
Linus Torvalds 已提交
2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121
	    (idev->rndid[1]&idev->rndid[2]&idev->rndid[3]&idev->rndid[4]&idev->rndid[5]&idev->rndid[6]) == 0xff &&
	    (idev->rndid[7]&0x80))
		goto regen;
	if ((idev->rndid[0]|idev->rndid[1]) == 0) {
		if (idev->rndid[2] == 0x5e && idev->rndid[3] == 0xfe)
			goto regen;
		if ((idev->rndid[2]|idev->rndid[3]|idev->rndid[4]|idev->rndid[5]|idev->rndid[6]|idev->rndid[7]) == 0x00)
			goto regen;
	}
}

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

2122
	rcu_read_lock_bh();
L
Linus Torvalds 已提交
2123 2124 2125 2126 2127
	write_lock_bh(&idev->lock);

	if (idev->dead)
		goto out;

S
Sorin Dumitru 已提交
2128
	__ipv6_regen_rndid(idev);
2129

L
Linus Torvalds 已提交
2130
	expires = jiffies +
2131
		idev->cnf.temp_prefered_lft * HZ -
J
Jiri Pirko 已提交
2132 2133
		idev->cnf.regen_max_retry * idev->cnf.dad_transmits *
		NEIGH_VAR(idev->nd_parms, RETRANS_TIME) -
2134
		idev->cnf.max_desync_factor * HZ;
L
Linus Torvalds 已提交
2135
	if (time_before(expires, jiffies)) {
2136 2137
		pr_warn("%s: too short regeneration interval; timer disabled for %s\n",
			__func__, idev->dev->name);
L
Linus Torvalds 已提交
2138 2139 2140 2141 2142 2143 2144 2145
		goto out;
	}

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

out:
	write_unlock_bh(&idev->lock);
2146
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
2147 2148 2149
	in6_dev_put(idev);
}

S
Sorin Dumitru 已提交
2150
static void  __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr)
2151
{
L
Linus Torvalds 已提交
2152
	if (tmpaddr && memcmp(idev->rndid, &tmpaddr->s6_addr[8], 8) == 0)
S
Sorin Dumitru 已提交
2153
		__ipv6_regen_rndid(idev);
L
Linus Torvalds 已提交
2154 2155 2156 2157 2158 2159 2160 2161
}

/*
 *	Add prefix route.
 */

static void
addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev,
J
Jamal Hadi Salim 已提交
2162
		      unsigned long expires, u32 flags)
L
Linus Torvalds 已提交
2163
{
2164
	struct fib6_config cfg = {
D
David Ahern 已提交
2165
		.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX,
2166 2167 2168 2169 2170
		.fc_metric = IP6_RT_PRIO_ADDRCONF,
		.fc_ifindex = dev->ifindex,
		.fc_expires = expires,
		.fc_dst_len = plen,
		.fc_flags = RTF_UP | flags,
2171
		.fc_nlinfo.nl_net = dev_net(dev),
2172
		.fc_protocol = RTPROT_KERNEL,
2173
	};
L
Linus Torvalds 已提交
2174

A
Alexey Dobriyan 已提交
2175
	cfg.fc_dst = *pfx;
L
Linus Torvalds 已提交
2176 2177 2178 2179 2180

	/* 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 已提交
2181
#if IS_ENABLED(CONFIG_IPV6_SIT)
2182 2183
	if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT))
		cfg.fc_flags |= RTF_NONEXTHOP;
2184
#endif
L
Linus Torvalds 已提交
2185

2186
	ip6_route_add(&cfg);
L
Linus Torvalds 已提交
2187 2188
}

2189 2190 2191 2192 2193 2194 2195 2196 2197

static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
						  int plen,
						  const struct net_device *dev,
						  u32 flags, u32 noflags)
{
	struct fib6_node *fn;
	struct rt6_info *rt = NULL;
	struct fib6_table *table;
D
David Ahern 已提交
2198
	u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX;
2199

D
David Ahern 已提交
2200
	table = fib6_get_table(dev_net(dev), tb_id);
2201
	if (!table)
2202 2203
		return NULL;

2204
	read_lock_bh(&table->tb6_lock);
2205 2206 2207
	fn = fib6_locate(&table->tb6_root, pfx, plen, NULL, 0);
	if (!fn)
		goto out;
2208 2209

	noflags |= RTF_CACHE;
2210
	for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
2211
		if (rt->dst.dev->ifindex != dev->ifindex)
2212 2213 2214
			continue;
		if ((rt->rt6i_flags & flags) != flags)
			continue;
2215
		if ((rt->rt6i_flags & noflags) != 0)
2216 2217 2218 2219 2220
			continue;
		dst_hold(&rt->dst);
		break;
	}
out:
2221
	read_unlock_bh(&table->tb6_lock);
2222 2223 2224 2225
	return rt;
}


L
Linus Torvalds 已提交
2226 2227 2228 2229
/* Create "default" multicast route to the interface */

static void addrconf_add_mroute(struct net_device *dev)
{
2230
	struct fib6_config cfg = {
D
David Ahern 已提交
2231
		.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_LOCAL,
2232 2233 2234 2235
		.fc_metric = IP6_RT_PRIO_ADDRCONF,
		.fc_ifindex = dev->ifindex,
		.fc_dst_len = 8,
		.fc_flags = RTF_UP,
2236
		.fc_nlinfo.nl_net = dev_net(dev),
2237 2238 2239 2240 2241
	};

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

	ip6_route_add(&cfg);
L
Linus Torvalds 已提交
2242 2243 2244 2245 2246 2247 2248 2249
}

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

	ASSERT_RTNL();

S
Stephen Hemminger 已提交
2250 2251
	idev = ipv6_find_idev(dev);
	if (!idev)
2252 2253 2254 2255
		return ERR_PTR(-ENOBUFS);

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

	/* Add default multicast route */
2258 2259
	if (!(dev->flags & IFF_LOOPBACK))
		addrconf_add_mroute(dev);
L
Linus Torvalds 已提交
2260 2261 2262 2263

	return idev;
}

2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330
static void manage_tempaddrs(struct inet6_dev *idev,
			     struct inet6_ifaddr *ifp,
			     __u32 valid_lft, __u32 prefered_lft,
			     bool create, unsigned long now)
{
	u32 flags;
	struct inet6_ifaddr *ift;

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

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

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

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

		if (valid_lft > max_valid)
			valid_lft = max_valid;

		if (prefered_lft > max_prefered)
			prefered_lft = max_prefered;

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

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

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

2331 2332 2333 2334 2335 2336
static bool is_addr_mode_generate_stable(struct inet6_dev *idev)
{
	return idev->addr_gen_mode == IN6_ADDR_GEN_MODE_STABLE_PRIVACY ||
	       idev->addr_gen_mode == IN6_ADDR_GEN_MODE_RANDOM;
}

2337
void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len, bool sllao)
L
Linus Torvalds 已提交
2338 2339 2340 2341 2342
{
	struct prefix_info *pinfo;
	__u32 valid_lft;
	__u32 prefered_lft;
	int addr_type;
2343
	u32 addr_flags = 0;
L
Linus Torvalds 已提交
2344
	struct inet6_dev *in6_dev;
2345
	struct net *net = dev_net(dev);
L
Linus Torvalds 已提交
2346 2347

	pinfo = (struct prefix_info *) opt;
2348

L
Linus Torvalds 已提交
2349
	if (len < sizeof(struct prefix_info)) {
2350
		ADBG("addrconf: prefix option too short\n");
L
Linus Torvalds 已提交
2351 2352
		return;
	}
2353

L
Linus Torvalds 已提交
2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366
	/*
	 *	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) {
2367
		net_warn_ratelimited("addrconf: prefix option has invalid lifetime\n");
L
Linus Torvalds 已提交
2368 2369 2370 2371 2372
		return;
	}

	in6_dev = in6_dev_get(dev);

2373
	if (!in6_dev) {
2374 2375
		net_dbg_ratelimited("addrconf: device %s not configured\n",
				    dev->name);
L
Linus Torvalds 已提交
2376 2377 2378 2379 2380 2381 2382 2383 2384
		return;
	}

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

2385 2386 2387 2388
	if (pinfo->onlink) {
		struct rt6_info *rt;
		unsigned long rt_expires;

2389 2390 2391 2392 2393
		/* 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.
		 */
2394 2395 2396 2397
		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 已提交
2398

2399 2400
		if (addrconf_finite_timeout(rt_expires))
			rt_expires *= HZ;
L
Linus Torvalds 已提交
2401

2402 2403 2404 2405 2406
		rt = addrconf_get_prefix_route(&pinfo->prefix,
					       pinfo->prefix_len,
					       dev,
					       RTF_ADDRCONF | RTF_PREFIX_RT,
					       RTF_GATEWAY | RTF_DEFAULT);
L
Linus Torvalds 已提交
2407

2408
		if (rt) {
2409 2410 2411 2412
			/* Autoconf prefix route */
			if (valid_lft == 0) {
				ip6_del_rt(rt);
				rt = NULL;
2413
			} else if (addrconf_finite_timeout(rt_expires)) {
2414
				/* not infinity */
2415
				rt6_set_expires(rt, jiffies + rt_expires);
2416
			} else {
2417
				rt6_clean_expires(rt);
L
Linus Torvalds 已提交
2418 2419
			}
		} else if (valid_lft) {
2420
			clock_t expires = 0;
2421 2422
			int flags = RTF_ADDRCONF | RTF_PREFIX_RT;
			if (addrconf_finite_timeout(rt_expires)) {
2423 2424 2425 2426
				/* not infinity */
				flags |= RTF_EXPIRES;
				expires = jiffies_to_clock_t(rt_expires);
			}
L
Linus Torvalds 已提交
2427
			addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
2428
					      dev, expires, flags);
L
Linus Torvalds 已提交
2429
		}
A
Amerigo Wang 已提交
2430
		ip6_rt_put(rt);
L
Linus Torvalds 已提交
2431 2432 2433 2434 2435
	}

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

	if (pinfo->autoconf && in6_dev->cnf.autoconf) {
2436
		struct inet6_ifaddr *ifp;
L
Linus Torvalds 已提交
2437 2438
		struct in6_addr addr;
		int create = 0, update_lft = 0;
2439
		bool tokenized = false;
L
Linus Torvalds 已提交
2440 2441 2442

		if (pinfo->prefix_len == 64) {
			memcpy(&addr, &pinfo->prefix, 8);
2443 2444 2445 2446 2447 2448

			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);
2449
				tokenized = true;
2450
			} else if (is_addr_mode_generate_stable(in6_dev) &&
2451 2452
				   !ipv6_generate_stable_address(&addr, 0,
								 in6_dev)) {
2453
				addr_flags |= IFA_F_STABLE_PRIVACY;
2454
				goto ok;
2455 2456
			} else if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
				   ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
L
Linus Torvalds 已提交
2457 2458 2459 2460 2461
				in6_dev_put(in6_dev);
				return;
			}
			goto ok;
		}
2462 2463
		net_dbg_ratelimited("IPv6 addrconf: prefix with wrong length %d\n",
				    pinfo->prefix_len);
L
Linus Torvalds 已提交
2464 2465 2466 2467 2468
		in6_dev_put(in6_dev);
		return;

ok:

2469
		ifp = ipv6_get_ifaddr(net, &addr, dev, 1);
L
Linus Torvalds 已提交
2470

2471
		if (!ifp && valid_lft) {
L
Linus Torvalds 已提交
2472
			int max_addresses = in6_dev->cnf.max_addresses;
2473 2474 2475

#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
			if (in6_dev->cnf.optimistic_dad &&
2476
			    !net->ipv6.devconf_all->forwarding && sllao)
2477
				addr_flags |= IFA_F_OPTIMISTIC;
2478
#endif
L
Linus Torvalds 已提交
2479 2480 2481 2482 2483 2484

			/* 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)
2485 2486
				ifp = ipv6_add_addr(in6_dev, &addr, NULL,
						    pinfo->prefix_len,
2487
						    addr_type&IPV6_ADDR_SCOPE_MASK,
2488 2489
						    addr_flags, valid_lft,
						    prefered_lft);
L
Linus Torvalds 已提交
2490

2491
			if (IS_ERR_OR_NULL(ifp)) {
L
Linus Torvalds 已提交
2492 2493 2494 2495
				in6_dev_put(in6_dev);
				return;
			}

2496 2497
			update_lft = 0;
			create = 1;
2498 2499
			spin_lock_bh(&ifp->lock);
			ifp->flags |= IFA_F_MANAGETEMPADDR;
L
Linus Torvalds 已提交
2500
			ifp->cstamp = jiffies;
2501
			ifp->tokenized = tokenized;
2502
			spin_unlock_bh(&ifp->lock);
2503
			addrconf_dad_start(ifp);
L
Linus Torvalds 已提交
2504 2505 2506
		}

		if (ifp) {
2507
			u32 flags;
L
Linus Torvalds 已提交
2508 2509 2510 2511
			unsigned long now;
			u32 stored_lft;

			/* update lifetime (RFC2462 5.5.3 e) */
2512
			spin_lock_bh(&ifp->lock);
L
Linus Torvalds 已提交
2513 2514 2515 2516 2517
			now = jiffies;
			if (ifp->valid_lft > (now - ifp->tstamp) / HZ)
				stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ;
			else
				stored_lft = 0;
2518
			if (!update_lft && !create && stored_lft) {
2519 2520
				const u32 minimum_lft = min_t(u32,
					stored_lft, MIN_VALID_LIFETIME);
2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533
				valid_lft = max(valid_lft, minimum_lft);

				/* RFC4862 Section 5.5.3e:
				 * "Note that the preferred lifetime of the
				 *  corresponding address is always reset to
				 *  the Preferred Lifetime in the received
				 *  Prefix Information option, regardless of
				 *  whether the valid lifetime is also reset or
				 *  ignored."
				 *
				 * So we should always update prefered_lft here.
				 */
				update_lft = 1;
L
Linus Torvalds 已提交
2534 2535 2536 2537 2538 2539 2540 2541
			}

			if (update_lft) {
				ifp->valid_lft = valid_lft;
				ifp->prefered_lft = prefered_lft;
				ifp->tstamp = now;
				flags = ifp->flags;
				ifp->flags &= ~IFA_F_DEPRECATED;
2542
				spin_unlock_bh(&ifp->lock);
L
Linus Torvalds 已提交
2543 2544 2545 2546

				if (!(flags&IFA_F_TENTATIVE))
					ipv6_ifa_notify(0, ifp);
			} else
2547
				spin_unlock_bh(&ifp->lock);
L
Linus Torvalds 已提交
2548

2549 2550
			manage_tempaddrs(in6_dev, ifp, valid_lft, prefered_lft,
					 create, now);
2551

L
Linus Torvalds 已提交
2552
			in6_ifa_put(ifp);
2553
			addrconf_verify();
L
Linus Torvalds 已提交
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564
		}
	}
	inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo);
	in6_dev_put(in6_dev);
}

/*
 *	Set destination address.
 *	Special case for SIT interfaces where we create a new "virtual"
 *	device.
 */
2565
int addrconf_set_dstaddr(struct net *net, void __user *arg)
L
Linus Torvalds 已提交
2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576
{
	struct in6_ifreq ireq;
	struct net_device *dev;
	int err = -EINVAL;

	rtnl_lock();

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

2577
	dev = __dev_get_by_index(net, ireq.ifr6_ifindex);
L
Linus Torvalds 已提交
2578 2579

	err = -ENODEV;
2580
	if (!dev)
L
Linus Torvalds 已提交
2581 2582
		goto err_exit;

A
Amerigo Wang 已提交
2583
#if IS_ENABLED(CONFIG_IPV6_SIT)
L
Linus Torvalds 已提交
2584
	if (dev->type == ARPHRD_SIT) {
2585
		const struct net_device_ops *ops = dev->netdev_ops;
L
Linus Torvalds 已提交
2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599
		struct ifreq ifr;
		struct ip_tunnel_parm p;

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

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

2602 2603 2604 2605 2606 2607 2608 2609
		if (ops->ndo_do_ioctl) {
			mm_segment_t oldfs = get_fs();

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

		if (err == 0) {
			err = -ENOBUFS;
2613 2614
			dev = __dev_get_by_name(net, p.name);
			if (!dev)
L
Linus Torvalds 已提交
2615 2616 2617 2618
				goto err_exit;
			err = dev_open(dev);
		}
	}
2619
#endif
L
Linus Torvalds 已提交
2620 2621 2622 2623 2624 2625

err_exit:
	rtnl_unlock();
	return err;
}

2626 2627 2628 2629 2630 2631 2632 2633 2634
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)
2635
		ret = ipv6_sock_mc_join(sk, ifindex, addr);
2636
	else
2637
		ret = ipv6_sock_mc_drop(sk, ifindex, addr);
2638 2639 2640 2641 2642
	release_sock(sk);

	return ret;
}

L
Linus Torvalds 已提交
2643 2644 2645
/*
 *	Manual configuration of address on an interface
 */
2646 2647
static int inet6_addr_add(struct net *net, int ifindex,
			  const struct in6_addr *pfx,
2648
			  const struct in6_addr *peer_pfx,
2649 2650
			  unsigned int plen, __u32 ifa_flags,
			  __u32 prefered_lft, __u32 valid_lft)
L
Linus Torvalds 已提交
2651 2652 2653 2654
{
	struct inet6_ifaddr *ifp;
	struct inet6_dev *idev;
	struct net_device *dev;
2655 2656
	unsigned long timeout;
	clock_t expires;
L
Linus Torvalds 已提交
2657
	int scope;
2658
	u32 flags;
L
Linus Torvalds 已提交
2659 2660

	ASSERT_RTNL();
2661

2662 2663 2664
	if (plen > 128)
		return -EINVAL;

2665 2666 2667 2668
	/* check the lifetime */
	if (!valid_lft || prefered_lft > valid_lft)
		return -EINVAL;

2669 2670 2671
	if (ifa_flags & IFA_F_MANAGETEMPADDR && plen != 64)
		return -EINVAL;

2672 2673
	dev = __dev_get_by_index(net, ifindex);
	if (!dev)
L
Linus Torvalds 已提交
2674
		return -ENODEV;
2675

2676 2677 2678
	idev = addrconf_add_dev(dev);
	if (IS_ERR(idev))
		return PTR_ERR(idev);
L
Linus Torvalds 已提交
2679

2680 2681 2682 2683 2684 2685 2686 2687
	if (ifa_flags & IFA_F_MCAUTOJOIN) {
		int ret = ipv6_mc_config(net->ipv6.mc_autojoin_sk,
					 true, pfx, ifindex);

		if (ret < 0)
			return ret;
	}

L
Linus Torvalds 已提交
2688 2689
	scope = ipv6_addr_scope(pfx);

2690 2691 2692 2693
	timeout = addrconf_timeout_fixup(valid_lft, HZ);
	if (addrconf_finite_timeout(timeout)) {
		expires = jiffies_to_clock_t(timeout * HZ);
		valid_lft = timeout;
2694
		flags = RTF_EXPIRES;
2695 2696 2697 2698
	} else {
		expires = 0;
		flags = 0;
		ifa_flags |= IFA_F_PERMANENT;
2699
	}
2700

2701 2702 2703 2704 2705 2706
	timeout = addrconf_timeout_fixup(prefered_lft, HZ);
	if (addrconf_finite_timeout(timeout)) {
		if (timeout == 0)
			ifa_flags |= IFA_F_DEPRECATED;
		prefered_lft = timeout;
	}
2707

2708 2709
	ifp = ipv6_add_addr(idev, pfx, peer_pfx, plen, scope, ifa_flags,
			    valid_lft, prefered_lft);
2710

L
Linus Torvalds 已提交
2711
	if (!IS_ERR(ifp)) {
2712 2713 2714 2715 2716
		if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) {
			addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev,
					      expires, flags);
		}

2717 2718 2719 2720 2721
		/*
		 * Note that section 3.1 of RFC 4429 indicates
		 * that the Optimistic flag should not be set for
		 * manually configured addresses
		 */
2722
		addrconf_dad_start(ifp);
2723 2724 2725
		if (ifa_flags & IFA_F_MANAGETEMPADDR)
			manage_tempaddrs(idev, ifp, valid_lft, prefered_lft,
					 true, jiffies);
L
Linus Torvalds 已提交
2726
		in6_ifa_put(ifp);
2727
		addrconf_verify_rtnl();
L
Linus Torvalds 已提交
2728
		return 0;
2729 2730 2731
	} else if (ifa_flags & IFA_F_MCAUTOJOIN) {
		ipv6_mc_config(net->ipv6.mc_autojoin_sk,
			       false, pfx, ifindex);
L
Linus Torvalds 已提交
2732 2733 2734 2735 2736
	}

	return PTR_ERR(ifp);
}

2737 2738
static int inet6_addr_del(struct net *net, int ifindex, u32 ifa_flags,
			  const struct in6_addr *pfx, unsigned int plen)
L
Linus Torvalds 已提交
2739 2740 2741 2742
{
	struct inet6_ifaddr *ifp;
	struct inet6_dev *idev;
	struct net_device *dev;
2743

2744 2745 2746
	if (plen > 128)
		return -EINVAL;

2747 2748
	dev = __dev_get_by_index(net, ifindex);
	if (!dev)
L
Linus Torvalds 已提交
2749 2750
		return -ENODEV;

2751
	idev = __in6_dev_get(dev);
2752
	if (!idev)
L
Linus Torvalds 已提交
2753 2754 2755
		return -ENXIO;

	read_lock_bh(&idev->lock);
2756
	list_for_each_entry(ifp, &idev->addr_list, if_list) {
L
Linus Torvalds 已提交
2757 2758 2759 2760
		if (ifp->prefix_len == plen &&
		    ipv6_addr_equal(pfx, &ifp->addr)) {
			in6_ifa_hold(ifp);
			read_unlock_bh(&idev->lock);
2761

2762 2763 2764 2765
			if (!(ifp->flags & IFA_F_TEMPORARY) &&
			    (ifa_flags & IFA_F_MANAGETEMPADDR))
				manage_tempaddrs(idev, ifp, 0, 0, false,
						 jiffies);
L
Linus Torvalds 已提交
2766
			ipv6_del_addr(ifp);
2767
			addrconf_verify_rtnl();
2768 2769 2770 2771
			if (ipv6_addr_is_multicast(pfx)) {
				ipv6_mc_config(net->ipv6.mc_autojoin_sk,
					       false, pfx, dev->ifindex);
			}
L
Linus Torvalds 已提交
2772 2773 2774 2775 2776 2777 2778 2779
			return 0;
		}
	}
	read_unlock_bh(&idev->lock);
	return -EADDRNOTAVAIL;
}


2780
int addrconf_add_ifaddr(struct net *net, void __user *arg)
L
Linus Torvalds 已提交
2781 2782 2783
{
	struct in6_ifreq ireq;
	int err;
2784

2785
	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
2786
		return -EPERM;
2787

L
Linus Torvalds 已提交
2788 2789 2790 2791
	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
		return -EFAULT;

	rtnl_lock();
2792
	err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL,
2793 2794
			     ireq.ifr6_prefixlen, IFA_F_PERMANENT,
			     INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
L
Linus Torvalds 已提交
2795 2796 2797 2798
	rtnl_unlock();
	return err;
}

2799
int addrconf_del_ifaddr(struct net *net, void __user *arg)
L
Linus Torvalds 已提交
2800 2801 2802
{
	struct in6_ifreq ireq;
	int err;
2803

2804
	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
2805 2806 2807 2808 2809 2810
		return -EPERM;

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

	rtnl_lock();
2811
	err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr,
2812
			     ireq.ifr6_prefixlen);
L
Linus Torvalds 已提交
2813 2814 2815 2816
	rtnl_unlock();
	return err;
}

2817 2818 2819 2820 2821
static void add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
		     int plen, int scope)
{
	struct inet6_ifaddr *ifp;

2822
	ifp = ipv6_add_addr(idev, addr, NULL, plen,
2823 2824
			    scope, IFA_F_PERMANENT,
			    INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
2825 2826 2827 2828 2829 2830 2831 2832 2833
	if (!IS_ERR(ifp)) {
		spin_lock_bh(&ifp->lock);
		ifp->flags &= ~IFA_F_TENTATIVE;
		spin_unlock_bh(&ifp->lock);
		ipv6_ifa_notify(RTM_NEWADDR, ifp);
		in6_ifa_put(ifp);
	}
}

A
Amerigo Wang 已提交
2834
#if IS_ENABLED(CONFIG_IPV6_SIT)
L
Linus Torvalds 已提交
2835 2836 2837 2838
static void sit_add_v4_addrs(struct inet6_dev *idev)
{
	struct in6_addr addr;
	struct net_device *dev;
2839
	struct net *net = dev_net(idev->dev);
2840
	int scope, plen;
2841
	u32 pflags = 0;
L
Linus Torvalds 已提交
2842 2843 2844 2845 2846 2847 2848 2849 2850

	ASSERT_RTNL();

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

	if (idev->dev->flags&IFF_POINTOPOINT) {
		addr.s6_addr32[0] = htonl(0xfe800000);
		scope = IFA_LINK;
2851
		plen = 64;
L
Linus Torvalds 已提交
2852 2853
	} else {
		scope = IPV6_ADDR_COMPATv4;
2854
		plen = 96;
2855
		pflags |= RTF_NONEXTHOP;
L
Linus Torvalds 已提交
2856 2857 2858
	}

	if (addr.s6_addr32[3]) {
2859
		add_addr(idev, &addr, plen, scope);
2860
		addrconf_prefix_route(&addr, plen, idev->dev, 0, pflags);
L
Linus Torvalds 已提交
2861 2862 2863
		return;
	}

2864
	for_each_netdev(net, dev) {
2865
		struct in_device *in_dev = __in_dev_get_rtnl(dev);
L
Linus Torvalds 已提交
2866
		if (in_dev && (dev->flags & IFF_UP)) {
2867
			struct in_ifaddr *ifa;
L
Linus Torvalds 已提交
2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882

			int flag = scope;

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

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

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

2883
				add_addr(idev, &addr, plen, flag);
2884 2885
				addrconf_prefix_route(&addr, plen, idev->dev, 0,
						      pflags);
L
Linus Torvalds 已提交
2886 2887
			}
		}
2888
	}
L
Linus Torvalds 已提交
2889
}
2890
#endif
L
Linus Torvalds 已提交
2891 2892 2893 2894

static void init_loopback(struct net_device *dev)
{
	struct inet6_dev  *idev;
2895 2896 2897
	struct net_device *sp_dev;
	struct inet6_ifaddr *sp_ifa;
	struct rt6_info *sp_rt;
L
Linus Torvalds 已提交
2898 2899 2900 2901 2902

	/* ::1 */

	ASSERT_RTNL();

2903
	idev = ipv6_find_idev(dev);
2904
	if (!idev) {
2905
		pr_debug("%s: add_dev failed\n", __func__);
L
Linus Torvalds 已提交
2906 2907 2908
		return;
	}

2909
	add_addr(idev, &in6addr_loopback, 128, IFA_HOST);
2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925

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

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

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

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

2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937
			if (sp_ifa->rt) {
				/* This dst has been added to garbage list when
				 * lo device down, release this obsolete dst and
				 * reallocate a new router for ifa.
				 */
				if (sp_ifa->rt->dst.obsolete > 0) {
					ip6_rt_put(sp_ifa->rt);
					sp_ifa->rt = NULL;
				} else {
					continue;
				}
			}
2938

2939
			sp_rt = addrconf_dst_alloc(idev, &sp_ifa->addr, false);
2940 2941

			/* Failure cases are ignored */
2942 2943
			if (!IS_ERR(sp_rt)) {
				sp_ifa->rt = sp_rt;
2944
				ip6_ins_rt(sp_rt);
2945
			}
2946 2947 2948
		}
		read_unlock_bh(&idev->lock);
	}
L
Linus Torvalds 已提交
2949 2950
}

2951 2952
static void addrconf_add_linklocal(struct inet6_dev *idev,
				   const struct in6_addr *addr, u32 flags)
L
Linus Torvalds 已提交
2953
{
2954
	struct inet6_ifaddr *ifp;
2955
	u32 addr_flags = flags | IFA_F_PERMANENT;
2956 2957 2958

#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
	if (idev->cnf.optimistic_dad &&
2959
	    !dev_net(idev->dev)->ipv6.devconf_all->forwarding)
2960 2961
		addr_flags |= IFA_F_OPTIMISTIC;
#endif
L
Linus Torvalds 已提交
2962

2963 2964
	ifp = ipv6_add_addr(idev, addr, NULL, 64, IFA_LINK, addr_flags,
			    INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
L
Linus Torvalds 已提交
2965
	if (!IS_ERR(ifp)) {
2966
		addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev, 0, 0);
2967
		addrconf_dad_start(ifp);
L
Linus Torvalds 已提交
2968 2969 2970 2971
		in6_ifa_put(ifp);
	}
}

2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999
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);
	static __u32 digest[SHA_DIGEST_WORDS];
	static __u32 workspace[SHA_WORKSPACE_WORDS];

	static union {
		char __data[SHA_MESSAGE_BYTES];
		struct {
			struct in6_addr secret;
3000
			__be32 prefix[2];
3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025
			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);

	sha_init(digest);
	memset(&data, 0, sizeof(data));
	memset(workspace, 0, sizeof(workspace));
	memcpy(data.hwaddr, idev->dev->perm_addr, idev->dev->addr_len);
3026 3027
	data.prefix[0] = address->s6_addr32[0];
	data.prefix[1] = address->s6_addr32[1];
3028 3029 3030 3031 3032 3033
	data.secret = secret;
	data.dad_count = dad_count;

	sha_transform(digest, data.__data, workspace);

	temp = *address;
3034 3035
	temp.s6_addr32[2] = (__force __be32)digest[0];
	temp.s6_addr32[3] = (__force __be32)digest[1];
3036 3037 3038 3039 3040

	spin_unlock_bh(&lock);

	if (ipv6_reserved_interfaceid(temp)) {
		dad_count++;
3041
		if (dad_count > dev_net(idev->dev)->ipv6.sysctl.idgen_retries)
3042 3043 3044 3045 3046 3047 3048 3049
			return -1;
		goto retry;
	}

	*address = temp;
	return 0;
}

3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060
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;
}

3061 3062
static void addrconf_addr_gen(struct inet6_dev *idev, bool prefix_route)
{
3063 3064
	struct in6_addr addr;

D
David Ahern 已提交
3065 3066 3067 3068
	/* no link local addresses on L3 master devices */
	if (netif_is_l3_master(idev->dev))
		return;

3069
	ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0);
3070

3071 3072 3073 3074 3075
	switch (idev->addr_gen_mode) {
	case IN6_ADDR_GEN_MODE_RANDOM:
		ipv6_gen_mode_random_init(idev);
		/* fallthrough */
	case IN6_ADDR_GEN_MODE_STABLE_PRIVACY:
3076
		if (!ipv6_generate_stable_address(&addr, 0, idev))
3077 3078
			addrconf_add_linklocal(idev, &addr,
					       IFA_F_STABLE_PRIVACY);
3079 3080
		else if (prefix_route)
			addrconf_prefix_route(&addr, 64, idev->dev, 0, 0);
3081 3082
		break;
	case IN6_ADDR_GEN_MODE_EUI64:
3083 3084 3085 3086 3087
		/* 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)
3088
			addrconf_add_linklocal(idev, &addr, 0);
3089 3090
		else if (prefix_route)
			addrconf_prefix_route(&addr, 64, idev->dev, 0, 0);
3091 3092 3093 3094 3095
		break;
	case IN6_ADDR_GEN_MODE_NONE:
	default:
		/* will not add any link local address */
		break;
3096 3097 3098
	}
}

L
Linus Torvalds 已提交
3099 3100
static void addrconf_dev_config(struct net_device *dev)
{
3101
	struct inet6_dev *idev;
L
Linus Torvalds 已提交
3102 3103 3104

	ASSERT_RTNL();

3105 3106 3107
	if ((dev->type != ARPHRD_ETHER) &&
	    (dev->type != ARPHRD_FDDI) &&
	    (dev->type != ARPHRD_ARCNET) &&
3108
	    (dev->type != ARPHRD_INFINIBAND) &&
3109
	    (dev->type != ARPHRD_IEEE1394) &&
3110
	    (dev->type != ARPHRD_TUNNEL6) &&
3111 3112
	    (dev->type != ARPHRD_6LOWPAN) &&
	    (dev->type != ARPHRD_NONE)) {
3113 3114 3115 3116
		/* Alas, we support only Ethernet autoconfiguration. */
		return;
	}

L
Linus Torvalds 已提交
3117
	idev = addrconf_add_dev(dev);
3118
	if (IS_ERR(idev))
L
Linus Torvalds 已提交
3119 3120
		return;

3121 3122 3123 3124 3125
	/* this device type has no EUI support */
	if (dev->type == ARPHRD_NONE &&
	    idev->addr_gen_mode == IN6_ADDR_GEN_MODE_EUI64)
		idev->addr_gen_mode = IN6_ADDR_GEN_MODE_RANDOM;

3126
	addrconf_addr_gen(idev, false);
L
Linus Torvalds 已提交
3127 3128
}

A
Amerigo Wang 已提交
3129
#if IS_ENABLED(CONFIG_IPV6_SIT)
L
Linus Torvalds 已提交
3130 3131 3132 3133 3134 3135
static void addrconf_sit_config(struct net_device *dev)
{
	struct inet6_dev *idev;

	ASSERT_RTNL();

3136 3137 3138
	/*
	 * Configure the tunnel with one of our IPv4
	 * addresses... we should configure all of
L
Linus Torvalds 已提交
3139 3140 3141
	 * our v4 addrs in the tunnel
	 */

3142
	idev = ipv6_find_idev(dev);
3143
	if (!idev) {
3144
		pr_debug("%s: add_dev failed\n", __func__);
L
Linus Torvalds 已提交
3145 3146 3147
		return;
	}

F
Fred L. Templin 已提交
3148
	if (dev->priv_flags & IFF_ISATAP) {
3149
		addrconf_addr_gen(idev, false);
F
Fred L. Templin 已提交
3150 3151 3152
		return;
	}

L
Linus Torvalds 已提交
3153 3154
	sit_add_v4_addrs(idev);

3155
	if (dev->flags&IFF_POINTOPOINT)
L
Linus Torvalds 已提交
3156 3157
		addrconf_add_mroute(dev);
}
3158
#endif
L
Linus Torvalds 已提交
3159

A
Amerigo Wang 已提交
3160
#if IS_ENABLED(CONFIG_NET_IPGRE)
3161 3162 3163 3164 3165 3166
static void addrconf_gre_config(struct net_device *dev)
{
	struct inet6_dev *idev;

	ASSERT_RTNL();

3167
	idev = ipv6_find_idev(dev);
3168
	if (!idev) {
3169
		pr_debug("%s: add_dev failed\n", __func__);
3170 3171 3172
		return;
	}

3173
	addrconf_addr_gen(idev, true);
3174 3175
	if (dev->flags & IFF_POINTOPOINT)
		addrconf_add_mroute(dev);
3176 3177 3178
}
#endif

3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253
#if IS_ENABLED(CONFIG_NET_L3_MASTER_DEV)
/* If the host route is cached on the addr struct make sure it is associated
 * with the proper table. e.g., enslavement can change and if so the cached
 * host route needs to move to the new table.
 */
static void l3mdev_check_host_rt(struct inet6_dev *idev,
				  struct inet6_ifaddr *ifp)
{
	if (ifp->rt) {
		u32 tb_id = l3mdev_fib_table(idev->dev) ? : RT6_TABLE_LOCAL;

		if (tb_id != ifp->rt->rt6i_table->tb6_id) {
			ip6_del_rt(ifp->rt);
			ifp->rt = NULL;
		}
	}
}
#else
static void l3mdev_check_host_rt(struct inet6_dev *idev,
				  struct inet6_ifaddr *ifp)
{
}
#endif

static int fixup_permanent_addr(struct inet6_dev *idev,
				struct inet6_ifaddr *ifp)
{
	l3mdev_check_host_rt(idev, ifp);

	if (!ifp->rt) {
		struct rt6_info *rt;

		rt = addrconf_dst_alloc(idev, &ifp->addr, false);
		if (unlikely(IS_ERR(rt)))
			return PTR_ERR(rt);

		ifp->rt = rt;
	}

	if (!(ifp->flags & IFA_F_NOPREFIXROUTE)) {
		addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
				      idev->dev, 0, 0);
	}

	addrconf_dad_start(ifp);

	return 0;
}

static void addrconf_permanent_addr(struct net_device *dev)
{
	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) &&
		    fixup_permanent_addr(idev, ifp) < 0) {
			write_unlock_bh(&idev->lock);
			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);
}

3254
static int addrconf_notify(struct notifier_block *this, unsigned long event,
3255
			   void *ptr)
L
Linus Torvalds 已提交
3256
{
3257
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3258
	struct netdev_notifier_changeupper_info *info;
3259
	struct inet6_dev *idev = __in6_dev_get(dev);
3260
	int run_pending = 0;
3261
	int err;
L
Linus Torvalds 已提交
3262

S
Stephen Hemminger 已提交
3263
	switch (event) {
3264
	case NETDEV_REGISTER:
3265
		if (!idev && dev->mtu >= IPV6_MIN_MTU) {
3266
			idev = ipv6_add_dev(dev);
3267 3268
			if (IS_ERR(idev))
				return notifier_from_errno(PTR_ERR(idev));
3269 3270
		}
		break;
S
Stephen Hemminger 已提交
3271

3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297
	case NETDEV_CHANGEMTU:
		/* if MTU under IPV6_MIN_MTU stop IPv6 on this interface. */
		if (dev->mtu < IPV6_MIN_MTU) {
			addrconf_ifdown(dev, 1);
			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;

		/* fall through */

L
Linus Torvalds 已提交
3298
	case NETDEV_UP:
3299
	case NETDEV_CHANGE:
3300 3301 3302
		if (dev->flags & IFF_SLAVE)
			break;

3303 3304 3305
		if (idev && idev->cnf.disable_ipv6)
			break;

3306
		if (event == NETDEV_UP) {
3307
			if (!addrconf_qdisc_ok(dev)) {
3308
				/* device is not ready yet. */
3309
				pr_info("ADDRCONF(NETDEV_UP): %s: link is not ready\n",
3310 3311 3312
					dev->name);
				break;
			}
3313

3314 3315 3316
			if (!idev && dev->mtu >= IPV6_MIN_MTU)
				idev = ipv6_add_dev(dev);

3317
			if (!IS_ERR_OR_NULL(idev)) {
3318
				idev->if_flags |= IF_READY;
3319 3320
				run_pending = 1;
			}
3321
		} else if (event == NETDEV_CHANGE) {
3322
			if (!addrconf_qdisc_ok(dev)) {
3323 3324 3325 3326 3327
				/* device is still not ready. */
				break;
			}

			if (idev) {
S
Stephen Hemminger 已提交
3328
				if (idev->if_flags & IF_READY)
3329 3330 3331 3332 3333
					/* device is already configured. */
					break;
				idev->if_flags |= IF_READY;
			}

3334 3335
			pr_info("ADDRCONF(NETDEV_CHANGE): %s: link becomes ready\n",
				dev->name);
3336

3337
			run_pending = 1;
3338 3339
		}

3340 3341 3342
		/* restore routes for permanent addresses */
		addrconf_permanent_addr(dev);

S
Stephen Hemminger 已提交
3343
		switch (dev->type) {
A
Amerigo Wang 已提交
3344
#if IS_ENABLED(CONFIG_IPV6_SIT)
L
Linus Torvalds 已提交
3345 3346 3347
		case ARPHRD_SIT:
			addrconf_sit_config(dev);
			break;
3348
#endif
A
Amerigo Wang 已提交
3349
#if IS_ENABLED(CONFIG_NET_IPGRE)
3350 3351 3352
		case ARPHRD_IPGRE:
			addrconf_gre_config(dev);
			break;
3353
#endif
L
Linus Torvalds 已提交
3354 3355 3356 3357 3358 3359 3360
		case ARPHRD_LOOPBACK:
			init_loopback(dev);
			break;

		default:
			addrconf_dev_config(dev);
			break;
3361
		}
S
Stephen Hemminger 已提交
3362

3363
		if (!IS_ERR_OR_NULL(idev)) {
3364 3365 3366
			if (run_pending)
				addrconf_dad_run(idev);

S
Stephen Hemminger 已提交
3367 3368 3369 3370
			/*
			 * 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 已提交
3371
			 */
S
Stephen Hemminger 已提交
3372 3373
			if (idev->cnf.mtu6 != dev->mtu &&
			    dev->mtu >= IPV6_MIN_MTU) {
L
Linus Torvalds 已提交
3374 3375 3376 3377 3378
				rt6_mtu_change(dev, dev->mtu);
				idev->cnf.mtu6 = dev->mtu;
			}
			idev->tstamp = jiffies;
			inet6_ifinfo_notify(RTM_NEWLINK, idev);
S
Stephen Hemminger 已提交
3379 3380 3381 3382

			/*
			 * If the changed mtu during down is lower than
			 * IPV6_MIN_MTU stop IPv6 on this interface.
L
Linus Torvalds 已提交
3383 3384
			 */
			if (dev->mtu < IPV6_MIN_MTU)
S
Stephen Hemminger 已提交
3385
				addrconf_ifdown(dev, 1);
L
Linus Torvalds 已提交
3386 3387 3388 3389 3390 3391 3392 3393 3394 3395
		}
		break;

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

L
Linus Torvalds 已提交
3397 3398
	case NETDEV_CHANGENAME:
		if (idev) {
3399
			snmp6_unregister_dev(idev);
3400
			addrconf_sysctl_unregister(idev);
3401
			err = addrconf_sysctl_register(idev);
3402 3403
			if (err)
				return notifier_from_errno(err);
3404 3405 3406 3407 3408
			err = snmp6_register_dev(idev);
			if (err) {
				addrconf_sysctl_unregister(idev);
				return notifier_from_errno(err);
			}
3409
		}
L
Linus Torvalds 已提交
3410
		break;
S
Stephen Hemminger 已提交
3411

3412 3413
	case NETDEV_PRE_TYPE_CHANGE:
	case NETDEV_POST_TYPE_CHANGE:
3414 3415
		if (idev)
			addrconf_type_change(dev, event);
3416
		break;
3417 3418 3419 3420 3421 3422 3423 3424 3425

	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))
			addrconf_ifdown(dev, 0);
3426
	}
L
Linus Torvalds 已提交
3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437

	return NOTIFY_OK;
}

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

3438
static void addrconf_type_change(struct net_device *dev, unsigned long event)
3439 3440 3441 3442 3443 3444
{
	struct inet6_dev *idev;
	ASSERT_RTNL();

	idev = __in6_dev_get(dev);

3445
	if (event == NETDEV_POST_TYPE_CHANGE)
3446
		ipv6_mc_remap(idev);
3447
	else if (event == NETDEV_PRE_TYPE_CHANGE)
3448 3449 3450
		ipv6_mc_unmap(idev);
}

3451 3452 3453 3454 3455 3456
static bool addr_is_local(const struct in6_addr *addr)
{
	return ipv6_addr_type(addr) &
		(IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
}

L
Linus Torvalds 已提交
3457 3458
static int addrconf_ifdown(struct net_device *dev, int how)
{
3459
	struct net *net = dev_net(dev);
3460
	struct inet6_dev *idev;
3461 3462 3463 3464
	struct inet6_ifaddr *ifa, *tmp;
	struct list_head del_list;
	int _keep_addr;
	bool keep_addr;
3465
	int state, i;
L
Linus Torvalds 已提交
3466 3467 3468

	ASSERT_RTNL();

3469 3470
	rt6_ifdown(net, dev);
	neigh_ifdown(&nd_tbl, dev);
L
Linus Torvalds 已提交
3471 3472

	idev = __in6_dev_get(dev);
3473
	if (!idev)
L
Linus Torvalds 已提交
3474 3475
		return -ENODEV;

S
Stephen Hemminger 已提交
3476 3477 3478
	/*
	 * Step 1: remove reference to ipv6 device from parent device.
	 *	   Do not dev_put!
L
Linus Torvalds 已提交
3479
	 */
3480
	if (how) {
L
Linus Torvalds 已提交
3481
		idev->dead = 1;
3482 3483

		/* protected by rtnl_lock */
3484
		RCU_INIT_POINTER(dev->ip6_ptr, NULL);
L
Linus Torvalds 已提交
3485 3486 3487 3488 3489 3490

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

	}

3491 3492 3493 3494 3495 3496 3497 3498 3499 3500
	/* aggregate the system setting and interface setting */
	_keep_addr = net->ipv6.devconf_all->keep_addr_on_down;
	if (!_keep_addr)
		_keep_addr = idev->cnf.keep_addr_on_down;

	/* combine the user config with event to determine if permanent
	 * addresses are to be removed from address hash table
	 */
	keep_addr = !(how || _keep_addr <= 0);

3501 3502 3503 3504 3505
	/* 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);
3506
restart:
3507
		hlist_for_each_entry_rcu(ifa, h, addr_lst) {
3508
			if (ifa->idev == idev) {
3509
				addrconf_del_dad_work(ifa);
3510 3511 3512 3513 3514 3515 3516 3517 3518
				/* combined flag + permanent flag decide if
				 * address is retained on a down event
				 */
				if (!keep_addr ||
				    !(ifa->flags & IFA_F_PERMANENT) ||
				    addr_is_local(&ifa->addr)) {
					hlist_del_init_rcu(&ifa->addr_lst);
					goto restart;
				}
3519 3520 3521 3522 3523
			}
		}
		spin_unlock_bh(&addrconf_hash_lock);
	}

L
Linus Torvalds 已提交
3524 3525
	write_lock_bh(&idev->lock);

3526 3527
	addrconf_del_rs_timer(idev);

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

3532
	if (how && del_timer(&idev->regen_timer))
L
Linus Torvalds 已提交
3533 3534
		in6_dev_put(idev);

S
Stephen Hemminger 已提交
3535
	/* Step 3: clear tempaddr list */
3536 3537 3538 3539
	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 已提交
3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550
		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);
	}
3551

3552 3553 3554 3555
	/* re-combine the user config with event to determine if permanent
	 * addresses are to be removed from the interface list
	 */
	keep_addr = (!how && _keep_addr > 0);
3556

3557 3558 3559
	INIT_LIST_HEAD(&del_list);
	list_for_each_entry_safe(ifa, tmp, &idev->addr_list, if_list) {
		addrconf_del_dad_work(ifa);
3560

3561 3562
		write_unlock_bh(&idev->lock);
		spin_lock_bh(&ifa->lock);
3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578

		if (keep_addr && (ifa->flags & IFA_F_PERMANENT) &&
		    !addr_is_local(&ifa->addr)) {
			/* set state to skip the notifier below */
			state = INET6_IFADDR_STATE_DEAD;
			ifa->state = 0;
			if (!(ifa->flags & IFA_F_NODAD))
				ifa->flags |= IFA_F_TENTATIVE;
		} else {
			state = ifa->state;
			ifa->state = INET6_IFADDR_STATE_DEAD;

			list_del(&ifa->if_list);
			list_add(&ifa->if_list, &del_list);
		}

3579
		spin_unlock_bh(&ifa->lock);
3580

3581 3582
		if (state != INET6_IFADDR_STATE_DEAD) {
			__ipv6_ifa_notify(RTM_DELADDR, ifa);
3583
			inet6addr_notifier_call_chain(NETDEV_DOWN, ifa);
3584
		}
3585

3586 3587
		write_lock_bh(&idev->lock);
	}
3588

L
Linus Torvalds 已提交
3589 3590
	write_unlock_bh(&idev->lock);

3591 3592 3593 3594 3595 3596 3597 3598 3599
	/* now clean up addresses to be removed */
	while (!list_empty(&del_list)) {
		ifa = list_first_entry(&del_list,
				       struct inet6_ifaddr, if_list);
		list_del(&ifa->if_list);

		in6_ifa_put(ifa);
	}

3600 3601 3602
	/* Step 5: Discard anycast and multicast list */
	if (how) {
		ipv6_ac_destroy_dev(idev);
L
Linus Torvalds 已提交
3603
		ipv6_mc_destroy_dev(idev);
3604
	} else {
L
Linus Torvalds 已提交
3605
		ipv6_mc_down(idev);
3606
	}
L
Linus Torvalds 已提交
3607 3608

	idev->tstamp = jiffies;
3609

S
Stephen Hemminger 已提交
3610
	/* Last: Shot the device (if unregistered) */
3611
	if (how) {
3612
		addrconf_sysctl_unregister(idev);
L
Linus Torvalds 已提交
3613 3614 3615 3616 3617 3618 3619 3620 3621
		neigh_parms_release(&nd_tbl, idev->nd_parms);
		neigh_ifdown(&nd_tbl, dev);
		in6_dev_put(idev);
	}
	return 0;
}

static void addrconf_rs_timer(unsigned long data)
{
3622
	struct inet6_dev *idev = (struct inet6_dev *)data;
3623
	struct net_device *dev = idev->dev;
3624
	struct in6_addr lladdr;
L
Linus Torvalds 已提交
3625

3626
	write_lock(&idev->lock);
S
stephen hemminger 已提交
3627
	if (idev->dead || !(idev->if_flags & IF_READY))
L
Linus Torvalds 已提交
3628 3629
		goto out;

3630
	if (!ipv6_accept_ra(idev))
S
stephen hemminger 已提交
3631 3632 3633 3634
		goto out;

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

3637
	if (idev->rs_probes++ < idev->cnf.rtr_solicits) {
3638 3639 3640
		write_unlock(&idev->lock);
		if (!ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
			ndisc_send_rs(dev, &lladdr,
3641 3642
				      &in6addr_linklocal_allrouters);
		else
3643
			goto put;
L
Linus Torvalds 已提交
3644

3645
		write_lock(&idev->lock);
3646 3647 3648 3649 3650
		/* The wait after the last probe can be shorter */
		addrconf_mod_rs_timer(idev, (idev->rs_probes ==
					     idev->cnf.rtr_solicits) ?
				      idev->cnf.rtr_solicit_delay :
				      idev->cnf.rtr_solicit_interval);
L
Linus Torvalds 已提交
3651 3652 3653 3654 3655
	} else {
		/*
		 * Note: we do not support deprecated "all on-link"
		 * assumption any longer.
		 */
3656
		pr_debug("%s: no IPv6 routers present\n", idev->dev->name);
L
Linus Torvalds 已提交
3657 3658 3659
	}

out:
3660
	write_unlock(&idev->lock);
3661
put:
3662
	in6_dev_put(idev);
L
Linus Torvalds 已提交
3663 3664 3665 3666 3667
}

/*
 *	Duplicate Address Detection
 */
3668 3669 3670 3671 3672
static void addrconf_dad_kick(struct inet6_ifaddr *ifp)
{
	unsigned long rand_num;
	struct inet6_dev *idev = ifp->idev;

3673 3674 3675
	if (ifp->flags & IFA_F_OPTIMISTIC)
		rand_num = 0;
	else
3676
		rand_num = prandom_u32() % (idev->cnf.rtr_solicit_delay ? : 1);
3677

3678
	ifp->dad_probes = idev->cnf.dad_transmits;
3679
	addrconf_mod_dad_work(ifp, rand_num);
3680 3681
}

3682
static void addrconf_dad_begin(struct inet6_ifaddr *ifp)
L
Linus Torvalds 已提交
3683 3684 3685
{
	struct inet6_dev *idev = ifp->idev;
	struct net_device *dev = idev->dev;
3686
	bool notify = false;
L
Linus Torvalds 已提交
3687 3688 3689

	addrconf_join_solict(dev, &ifp->addr);

3690
	prandom_seed((__force u32) ifp->addr.s6_addr32[3]);
L
Linus Torvalds 已提交
3691 3692

	read_lock_bh(&idev->lock);
3693
	spin_lock(&ifp->lock);
3694
	if (ifp->state == INET6_IFADDR_STATE_DEAD)
L
Linus Torvalds 已提交
3695 3696 3697
		goto out;

	if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) ||
3698
	    idev->cnf.accept_dad < 1 ||
3699 3700
	    !(ifp->flags&IFA_F_TENTATIVE) ||
	    ifp->flags & IFA_F_NODAD) {
B
Brian Haley 已提交
3701
		ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
3702
		spin_unlock(&ifp->lock);
L
Linus Torvalds 已提交
3703 3704 3705 3706 3707 3708
		read_unlock_bh(&idev->lock);

		addrconf_dad_completed(ifp);
		return;
	}

3709
	if (!(idev->if_flags & IF_READY)) {
3710
		spin_unlock(&ifp->lock);
3711
		read_unlock_bh(&idev->lock);
3712
		/*
3713
		 * If the device is not ready:
3714 3715 3716 3717
		 * - keep it tentative if it is a permanent address.
		 * - otherwise, kill it.
		 */
		in6_ifa_hold(ifp);
B
Brian Haley 已提交
3718
		addrconf_dad_stop(ifp, 0);
3719
		return;
3720
	}
3721 3722 3723 3724 3725

	/*
	 * Optimistic nodes can start receiving
	 * Frames right away
	 */
3726
	if (ifp->flags & IFA_F_OPTIMISTIC) {
3727
		ip6_ins_rt(ifp->rt);
3728 3729 3730 3731
		if (ipv6_use_optimistic_addr(idev)) {
			/* Because optimistic nodes can use this address,
			 * notify listeners. If DAD fails, RTM_DELADDR is sent.
			 */
3732
			notify = true;
3733 3734
		}
	}
3735

3736
	addrconf_dad_kick(ifp);
L
Linus Torvalds 已提交
3737
out:
3738
	spin_unlock(&ifp->lock);
L
Linus Torvalds 已提交
3739
	read_unlock_bh(&idev->lock);
3740 3741
	if (notify)
		ipv6_ifa_notify(RTM_NEWADDR, ifp);
L
Linus Torvalds 已提交
3742 3743
}

3744
static void addrconf_dad_start(struct inet6_ifaddr *ifp)
L
Linus Torvalds 已提交
3745
{
3746 3747
	bool begin_dad = false;

3748
	spin_lock_bh(&ifp->lock);
3749 3750 3751 3752
	if (ifp->state != INET6_IFADDR_STATE_DEAD) {
		ifp->state = INET6_IFADDR_STATE_PREDAD;
		begin_dad = true;
	}
3753
	spin_unlock_bh(&ifp->lock);
3754 3755 3756 3757 3758 3759 3760 3761 3762 3763

	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 已提交
3764 3765 3766
	struct inet6_dev *idev = ifp->idev;
	struct in6_addr mcaddr;

3767 3768 3769 3770 3771 3772 3773 3774
	enum {
		DAD_PROCESS,
		DAD_BEGIN,
		DAD_ABORT,
	} action = DAD_PROCESS;

	rtnl_lock();

3775
	spin_lock_bh(&ifp->lock);
3776 3777 3778 3779 3780 3781 3782
	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;
	}
3783
	spin_unlock_bh(&ifp->lock);
3784 3785 3786 3787 3788 3789 3790 3791 3792

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

3793
	if (!ifp->dad_probes && addrconf_dad_end(ifp))
H
Herbert Xu 已提交
3794 3795
		goto out;

3796
	write_lock_bh(&idev->lock);
3797
	if (idev->dead || !(idev->if_flags & IF_READY)) {
3798
		write_unlock_bh(&idev->lock);
L
Linus Torvalds 已提交
3799 3800
		goto out;
	}
3801 3802

	spin_lock(&ifp->lock);
3803 3804
	if (ifp->state == INET6_IFADDR_STATE_DEAD) {
		spin_unlock(&ifp->lock);
3805
		write_unlock_bh(&idev->lock);
3806 3807 3808
		goto out;
	}

3809
	if (ifp->dad_probes == 0) {
L
Linus Torvalds 已提交
3810 3811 3812 3813
		/*
		 * DAD was successful
		 */

B
Brian Haley 已提交
3814
		ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
3815
		spin_unlock(&ifp->lock);
3816
		write_unlock_bh(&idev->lock);
L
Linus Torvalds 已提交
3817 3818 3819 3820 3821 3822

		addrconf_dad_completed(ifp);

		goto out;
	}

3823
	ifp->dad_probes--;
3824 3825
	addrconf_mod_dad_work(ifp,
			      NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME));
3826
	spin_unlock(&ifp->lock);
3827
	write_unlock_bh(&idev->lock);
L
Linus Torvalds 已提交
3828 3829 3830

	/* send a neighbour solicitation for our addr */
	addrconf_addr_solict_mult(&ifp->addr, &mcaddr);
3831
	ndisc_send_ns(ifp->idev->dev, &ifp->addr, &mcaddr, &in6addr_any);
L
Linus Torvalds 已提交
3832 3833
out:
	in6_ifa_put(ifp);
3834
	rtnl_unlock();
L
Linus Torvalds 已提交
3835 3836
}

3837 3838 3839 3840 3841 3842
/* 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;

3843 3844 3845
	list_for_each_entry_reverse(ifpiter, &idev->addr_list, if_list) {
		if (ifpiter->scope > IFA_LINK)
			break;
3846 3847 3848 3849 3850 3851 3852 3853 3854
		if (ifp != ifpiter && ifpiter->scope == IFA_LINK &&
		    (ifpiter->flags & (IFA_F_PERMANENT|IFA_F_TENTATIVE|
				       IFA_F_OPTIMISTIC|IFA_F_DADFAILED)) ==
		    IFA_F_PERMANENT)
			return false;
	}
	return true;
}

L
Linus Torvalds 已提交
3855 3856
static void addrconf_dad_completed(struct inet6_ifaddr *ifp)
{
S
Stephen Hemminger 已提交
3857
	struct net_device *dev = ifp->idev->dev;
3858
	struct in6_addr lladdr;
3859
	bool send_rs, send_mld;
3860

3861
	addrconf_del_dad_work(ifp);
L
Linus Torvalds 已提交
3862 3863 3864 3865 3866 3867 3868

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

	ipv6_ifa_notify(RTM_NEWADDR, ifp);

3869 3870
	/* If added prefix is link local and we are prepared to process
	   router advertisements, start sending router solicitations.
L
Linus Torvalds 已提交
3871 3872
	 */

3873
	read_lock_bh(&ifp->idev->lock);
3874
	send_mld = ifp->scope == IFA_LINK && ipv6_lonely_lladdr(ifp);
3875 3876
	send_rs = send_mld &&
		  ipv6_accept_ra(ifp->idev) &&
3877
		  ifp->idev->cnf.rtr_solicits > 0 &&
3878
		  (dev->flags&IFF_LOOPBACK) == 0;
3879 3880
	read_unlock_bh(&ifp->idev->lock);

3881 3882 3883 3884 3885 3886
	/* 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);

3887
	if (send_rs) {
L
Linus Torvalds 已提交
3888 3889 3890 3891 3892
		/*
		 *	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
		 */
3893
		if (ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
3894
			return;
3895
		ndisc_send_rs(dev, &lladdr, &in6addr_linklocal_allrouters);
L
Linus Torvalds 已提交
3896

3897 3898 3899
		write_lock_bh(&ifp->idev->lock);
		spin_lock(&ifp->lock);
		ifp->idev->rs_probes = 1;
L
Linus Torvalds 已提交
3900
		ifp->idev->if_flags |= IF_RS_SENT;
3901 3902 3903 3904
		addrconf_mod_rs_timer(ifp->idev,
				      ifp->idev->cnf.rtr_solicit_interval);
		spin_unlock(&ifp->lock);
		write_unlock_bh(&ifp->idev->lock);
L
Linus Torvalds 已提交
3905 3906 3907
	}
}

S
Stephen Hemminger 已提交
3908 3909
static void addrconf_dad_run(struct inet6_dev *idev)
{
3910 3911 3912
	struct inet6_ifaddr *ifp;

	read_lock_bh(&idev->lock);
3913
	list_for_each_entry(ifp, &idev->addr_list, if_list) {
3914
		spin_lock(&ifp->lock);
H
Herbert Xu 已提交
3915 3916 3917
		if (ifp->flags & IFA_F_TENTATIVE &&
		    ifp->state == INET6_IFADDR_STATE_DAD)
			addrconf_dad_kick(ifp);
3918
		spin_unlock(&ifp->lock);
3919 3920 3921 3922
	}
	read_unlock_bh(&idev->lock);
}

L
Linus Torvalds 已提交
3923 3924
#ifdef CONFIG_PROC_FS
struct if6_iter_state {
3925
	struct seq_net_private p;
L
Linus Torvalds 已提交
3926
	int bucket;
3927
	int offset;
L
Linus Torvalds 已提交
3928 3929
};

3930
static struct inet6_ifaddr *if6_get_first(struct seq_file *seq, loff_t pos)
L
Linus Torvalds 已提交
3931 3932 3933
{
	struct inet6_ifaddr *ifa = NULL;
	struct if6_iter_state *state = seq->private;
3934
	struct net *net = seq_file_net(seq);
3935
	int p = 0;
L
Linus Torvalds 已提交
3936

3937 3938 3939 3940 3941 3942 3943
	/* initial bucket if pos is 0 */
	if (pos == 0) {
		state->bucket = 0;
		state->offset = 0;
	}

	for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {
3944
		hlist_for_each_entry_rcu_bh(ifa, &inet6_addr_lst[state->bucket],
3945
					 addr_lst) {
3946 3947
			if (!net_eq(dev_net(ifa->idev->dev), net))
				continue;
3948 3949 3950 3951 3952 3953
			/* sync with offset */
			if (p < state->offset) {
				p++;
				continue;
			}
			state->offset++;
3954
			return ifa;
3955 3956 3957 3958 3959
		}

		/* prepare for next bucket */
		state->offset = 0;
		p = 0;
L
Linus Torvalds 已提交
3960
	}
3961
	return NULL;
L
Linus Torvalds 已提交
3962 3963
}

3964 3965
static struct inet6_ifaddr *if6_get_next(struct seq_file *seq,
					 struct inet6_ifaddr *ifa)
L
Linus Torvalds 已提交
3966 3967
{
	struct if6_iter_state *state = seq->private;
3968
	struct net *net = seq_file_net(seq);
L
Linus Torvalds 已提交
3969

3970
	hlist_for_each_entry_continue_rcu_bh(ifa, addr_lst) {
3971 3972
		if (!net_eq(dev_net(ifa->idev->dev), net))
			continue;
3973
		state->offset++;
3974
		return ifa;
3975
	}
3976

3977
	while (++state->bucket < IN6_ADDR_HSIZE) {
3978
		state->offset = 0;
3979
		hlist_for_each_entry_rcu_bh(ifa,
3980
				     &inet6_addr_lst[state->bucket], addr_lst) {
3981 3982
			if (!net_eq(dev_net(ifa->idev->dev), net))
				continue;
3983
			state->offset++;
3984
			return ifa;
3985
		}
L
Linus Torvalds 已提交
3986
	}
3987

3988
	return NULL;
L
Linus Torvalds 已提交
3989 3990 3991
}

static void *if6_seq_start(struct seq_file *seq, loff_t *pos)
E
Eric Dumazet 已提交
3992
	__acquires(rcu_bh)
L
Linus Torvalds 已提交
3993
{
3994
	rcu_read_lock_bh();
3995
	return if6_get_first(seq, *pos);
L
Linus Torvalds 已提交
3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007
}

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

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

static void if6_seq_stop(struct seq_file *seq, void *v)
E
Eric Dumazet 已提交
4008
	__releases(rcu_bh)
L
Linus Torvalds 已提交
4009
{
4010
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
4011 4012 4013 4014 4015
}

static int if6_seq_show(struct seq_file *seq, void *v)
{
	struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v;
4016
	seq_printf(seq, "%pi6 %02x %02x %02x %02x %8s\n",
4017
		   &ifp->addr,
L
Linus Torvalds 已提交
4018 4019 4020
		   ifp->idev->dev->ifindex,
		   ifp->prefix_len,
		   ifp->scope,
4021
		   (u8) ifp->flags,
L
Linus Torvalds 已提交
4022 4023 4024 4025
		   ifp->idev->dev->name);
	return 0;
}

4026
static const struct seq_operations if6_seq_ops = {
L
Linus Torvalds 已提交
4027 4028 4029 4030 4031 4032 4033 4034
	.start	= if6_seq_start,
	.next	= if6_seq_next,
	.show	= if6_seq_show,
	.stop	= if6_seq_stop,
};

static int if6_seq_open(struct inode *inode, struct file *file)
{
4035 4036
	return seq_open_net(inode, file, &if6_seq_ops,
			    sizeof(struct if6_iter_state));
L
Linus Torvalds 已提交
4037 4038
}

4039
static const struct file_operations if6_fops = {
L
Linus Torvalds 已提交
4040 4041 4042 4043
	.owner		= THIS_MODULE,
	.open		= if6_seq_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
4044
	.release	= seq_release_net,
L
Linus Torvalds 已提交
4045 4046
};

4047
static int __net_init if6_proc_net_init(struct net *net)
L
Linus Torvalds 已提交
4048
{
4049
	if (!proc_create("if_inet6", S_IRUGO, net->proc_net, &if6_fops))
L
Linus Torvalds 已提交
4050 4051 4052 4053
		return -ENOMEM;
	return 0;
}

4054
static void __net_exit if6_proc_net_exit(struct net *net)
4055
{
4056
	remove_proc_entry("if_inet6", net->proc_net);
4057 4058 4059
}

static struct pernet_operations if6_proc_net_ops = {
4060 4061
	.init = if6_proc_net_init,
	.exit = if6_proc_net_exit,
4062 4063 4064 4065 4066 4067 4068
};

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

L
Linus Torvalds 已提交
4069 4070
void if6_proc_exit(void)
{
4071
	unregister_pernet_subsys(&if6_proc_net_ops);
L
Linus Torvalds 已提交
4072 4073 4074
}
#endif	/* CONFIG_PROC_FS */

A
Amerigo Wang 已提交
4075
#if IS_ENABLED(CONFIG_IPV6_MIP6)
4076
/* Check if address is a home address configured on any interface. */
4077
int ipv6_chk_home_addr(struct net *net, const struct in6_addr *addr)
4078 4079
{
	int ret = 0;
4080
	struct inet6_ifaddr *ifp = NULL;
E
Eric Dumazet 已提交
4081
	unsigned int hash = inet6_addr_hash(addr);
4082

4083
	rcu_read_lock_bh();
4084
	hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) {
4085
		if (!net_eq(dev_net(ifp->idev->dev), net))
4086
			continue;
4087
		if (ipv6_addr_equal(&ifp->addr, addr) &&
4088 4089 4090 4091 4092
		    (ifp->flags & IFA_F_HOMEADDRESS)) {
			ret = 1;
			break;
		}
	}
4093
	rcu_read_unlock_bh();
4094 4095 4096 4097
	return ret;
}
#endif

L
Linus Torvalds 已提交
4098 4099 4100 4101
/*
 *	Periodic address status verification
 */

4102
static void addrconf_verify_rtnl(void)
L
Linus Torvalds 已提交
4103
{
4104
	unsigned long now, next, next_sec, next_sched;
L
Linus Torvalds 已提交
4105 4106 4107
	struct inet6_ifaddr *ifp;
	int i;

4108 4109
	ASSERT_RTNL();

4110
	rcu_read_lock_bh();
L
Linus Torvalds 已提交
4111
	now = jiffies;
4112
	next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
L
Linus Torvalds 已提交
4113

4114
	cancel_delayed_work(&addr_chk_work);
L
Linus Torvalds 已提交
4115

S
Stephen Hemminger 已提交
4116
	for (i = 0; i < IN6_ADDR_HSIZE; i++) {
L
Linus Torvalds 已提交
4117
restart:
4118
		hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[i], addr_lst) {
L
Linus Torvalds 已提交
4119 4120
			unsigned long age;

4121 4122 4123 4124 4125 4126
			/* 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 已提交
4127 4128 4129
				continue;

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

4133 4134
			if (ifp->valid_lft != INFINITY_LIFE_TIME &&
			    age >= ifp->valid_lft) {
L
Linus Torvalds 已提交
4135 4136 4137 4138
				spin_unlock(&ifp->lock);
				in6_ifa_hold(ifp);
				ipv6_del_addr(ifp);
				goto restart;
4139 4140 4141
			} else if (ifp->prefered_lft == INFINITY_LIFE_TIME) {
				spin_unlock(&ifp->lock);
				continue;
L
Linus Torvalds 已提交
4142
			} else if (age >= ifp->prefered_lft) {
4143
				/* jiffies - ifp->tstamp > age >= ifp->prefered_lft */
L
Linus Torvalds 已提交
4144 4145 4146 4147 4148 4149 4150
				int deprecate = 0;

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

4151 4152
				if ((ifp->valid_lft != INFINITY_LIFE_TIME) &&
				    (time_before(ifp->tstamp + ifp->valid_lft * HZ, next)))
L
Linus Torvalds 已提交
4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165
					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)) {
4166 4167
				unsigned long regen_advance = ifp->idev->cnf.regen_max_retry *
					ifp->idev->cnf.dad_transmits *
J
Jiri Pirko 已提交
4168
					NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME) / HZ;
4169

L
Linus Torvalds 已提交
4170 4171 4172 4173 4174 4175 4176 4177 4178
				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);
4179

4180 4181 4182
						spin_lock(&ifpub->lock);
						ifpub->regen_count = 0;
						spin_unlock(&ifpub->lock);
L
Linus Torvalds 已提交
4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199
						ipv6_create_tempaddr(ifpub, ifp);
						in6_ifa_put(ifpub);
						in6_ifa_put(ifp);
						goto restart;
					}
				} else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next))
					next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ;
				spin_unlock(&ifp->lock);
			} else {
				/* ifp->prefered_lft <= ifp->valid_lft */
				if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
					next = ifp->tstamp + ifp->prefered_lft * HZ;
				spin_unlock(&ifp->lock);
			}
		}
	}

4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210
	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;

4211 4212
	ADBG(KERN_DEBUG "now = %lu, schedule = %lu, rounded schedule = %lu => %lu\n",
	      now, next, next_sec, next_sched);
4213
	mod_delayed_work(addrconf_wq, &addr_chk_work, next_sched - now);
4214
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
4215 4216
}

4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228
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);
}

4229 4230
static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local,
				     struct in6_addr **peer_pfx)
4231 4232 4233
{
	struct in6_addr *pfx = NULL;

4234 4235
	*peer_pfx = NULL;

4236 4237 4238 4239 4240
	if (addr)
		pfx = nla_data(addr);

	if (local) {
		if (pfx && nla_memcmp(local, pfx, sizeof(*pfx)))
4241 4242
			*peer_pfx = pfx;
		pfx = nla_data(local);
4243 4244 4245 4246 4247
	}

	return pfx;
}

4248
static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = {
4249 4250 4251
	[IFA_ADDRESS]		= { .len = sizeof(struct in6_addr) },
	[IFA_LOCAL]		= { .len = sizeof(struct in6_addr) },
	[IFA_CACHEINFO]		= { .len = sizeof(struct ifa_cacheinfo) },
4252
	[IFA_FLAGS]		= { .len = sizeof(u32) },
4253 4254
};

L
Linus Torvalds 已提交
4255
static int
4256
inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
L
Linus Torvalds 已提交
4257
{
4258
	struct net *net = sock_net(skb->sk);
4259 4260
	struct ifaddrmsg *ifm;
	struct nlattr *tb[IFA_MAX+1];
4261
	struct in6_addr *pfx, *peer_pfx;
4262
	u32 ifa_flags;
4263
	int err;
L
Linus Torvalds 已提交
4264

4265 4266 4267 4268 4269
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
	if (err < 0)
		return err;

	ifm = nlmsg_data(nlh);
4270
	pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
4271
	if (!pfx)
L
Linus Torvalds 已提交
4272 4273
		return -EINVAL;

4274 4275 4276 4277 4278 4279 4280
	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 已提交
4281 4282
}

4283
static int inet6_addr_modify(struct inet6_ifaddr *ifp, u32 ifa_flags,
4284
			     u32 prefered_lft, u32 valid_lft)
4285
{
4286 4287
	u32 flags;
	clock_t expires;
4288
	unsigned long timeout;
4289
	bool was_managetempaddr;
4290
	bool had_prefixroute;
4291

4292 4293
	ASSERT_RTNL();

4294 4295 4296
	if (!valid_lft || (prefered_lft > valid_lft))
		return -EINVAL;

4297 4298 4299 4300
	if (ifa_flags & IFA_F_MANAGETEMPADDR &&
	    (ifp->flags & IFA_F_TEMPORARY || ifp->prefix_len != 64))
		return -EINVAL;

4301 4302 4303 4304
	timeout = addrconf_timeout_fixup(valid_lft, HZ);
	if (addrconf_finite_timeout(timeout)) {
		expires = jiffies_to_clock_t(timeout * HZ);
		valid_lft = timeout;
4305
		flags = RTF_EXPIRES;
4306 4307 4308 4309
	} else {
		expires = 0;
		flags = 0;
		ifa_flags |= IFA_F_PERMANENT;
4310
	}
4311

4312 4313 4314 4315 4316 4317
	timeout = addrconf_timeout_fixup(prefered_lft, HZ);
	if (addrconf_finite_timeout(timeout)) {
		if (timeout == 0)
			ifa_flags |= IFA_F_DEPRECATED;
		prefered_lft = timeout;
	}
4318 4319

	spin_lock_bh(&ifp->lock);
4320
	was_managetempaddr = ifp->flags & IFA_F_MANAGETEMPADDR;
4321 4322
	had_prefixroute = ifp->flags & IFA_F_PERMANENT &&
			  !(ifp->flags & IFA_F_NOPREFIXROUTE);
4323
	ifp->flags &= ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD |
4324 4325
			IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR |
			IFA_F_NOPREFIXROUTE);
4326
	ifp->flags |= ifa_flags;
4327 4328 4329 4330 4331 4332 4333 4334
	ifp->tstamp = jiffies;
	ifp->valid_lft = valid_lft;
	ifp->prefered_lft = prefered_lft;

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

4335 4336 4337
	if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) {
		addrconf_prefix_route(&ifp->addr, ifp->prefix_len, ifp->idev->dev,
				      expires, flags);
4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349
	} else if (had_prefixroute) {
		enum cleanup_prefix_rt_t action;
		unsigned long rt_expires;

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

		if (action != CLEANUP_PREFIX_RT_NOP) {
			cleanup_prefix_route(ifp, rt_expires,
				action == CLEANUP_PREFIX_RT_DEL);
		}
4350
	}
4351 4352 4353 4354 4355 4356 4357 4358

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

4359
	addrconf_verify_rtnl();
4360 4361 4362 4363

	return 0;
}

L
Linus Torvalds 已提交
4364
static int
4365
inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
L
Linus Torvalds 已提交
4366
{
4367
	struct net *net = sock_net(skb->sk);
4368 4369
	struct ifaddrmsg *ifm;
	struct nlattr *tb[IFA_MAX+1];
4370
	struct in6_addr *pfx, *peer_pfx;
4371 4372
	struct inet6_ifaddr *ifa;
	struct net_device *dev;
4373
	u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME;
4374
	u32 ifa_flags;
4375
	int err;
L
Linus Torvalds 已提交
4376

4377 4378 4379 4380 4381
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
	if (err < 0)
		return err;

	ifm = nlmsg_data(nlh);
4382
	pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
4383
	if (!pfx)
L
Linus Torvalds 已提交
4384 4385
		return -EINVAL;

4386
	if (tb[IFA_CACHEINFO]) {
4387
		struct ifa_cacheinfo *ci;
4388 4389

		ci = nla_data(tb[IFA_CACHEINFO]);
4390
		valid_lft = ci->ifa_valid;
4391 4392 4393 4394
		preferred_lft = ci->ifa_prefered;
	} else {
		preferred_lft = INFINITY_LIFE_TIME;
		valid_lft = INFINITY_LIFE_TIME;
4395 4396
	}

4397
	dev =  __dev_get_by_index(net, ifm->ifa_index);
4398
	if (!dev)
4399 4400
		return -ENODEV;

4401 4402
	ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;

4403
	/* We ignore other flags so far. */
4404
	ifa_flags &= IFA_F_NODAD | IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR |
4405
		     IFA_F_NOPREFIXROUTE | IFA_F_MCAUTOJOIN;
4406

4407
	ifa = ipv6_get_ifaddr(net, pfx, dev, 1);
4408
	if (!ifa) {
4409 4410
		/*
		 * It would be best to check for !NLM_F_CREATE here but
4411
		 * userspace already relies on not having to provide this.
4412
		 */
4413
		return inet6_addr_add(net, ifm->ifa_index, pfx, peer_pfx,
4414 4415
				      ifm->ifa_prefixlen, ifa_flags,
				      preferred_lft, valid_lft);
4416 4417
	}

4418 4419 4420 4421
	if (nlh->nlmsg_flags & NLM_F_EXCL ||
	    !(nlh->nlmsg_flags & NLM_F_REPLACE))
		err = -EEXIST;
	else
4422
		err = inet6_addr_modify(ifa, ifa_flags, preferred_lft, valid_lft);
4423 4424 4425 4426

	in6_ifa_put(ifa);

	return err;
L
Linus Torvalds 已提交
4427 4428
}

4429
static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u32 flags,
4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441
			  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;
}

4442 4443 4444 4445 4446
static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
			 unsigned long tstamp, u32 preferred, u32 valid)
{
	struct ifa_cacheinfo ci;

4447 4448
	ci.cstamp = cstamp_delta(cstamp);
	ci.tstamp = cstamp_delta(tstamp);
4449 4450 4451 4452 4453 4454
	ci.ifa_prefered = preferred;
	ci.ifa_valid = valid;

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

4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466
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;
}

4467 4468
static inline int inet6_ifaddr_msgsize(void)
{
4469
	return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
4470
	       + nla_total_size(16) /* IFA_LOCAL */
4471
	       + nla_total_size(16) /* IFA_ADDRESS */
4472 4473
	       + nla_total_size(sizeof(struct ifa_cacheinfo))
	       + nla_total_size(4)  /* IFA_FLAGS */;
4474
}
4475

L
Linus Torvalds 已提交
4476
static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
4477
			     u32 portid, u32 seq, int event, unsigned int flags)
L
Linus Torvalds 已提交
4478 4479
{
	struct nlmsghdr  *nlh;
4480
	u32 preferred, valid;
L
Linus Torvalds 已提交
4481

4482
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4483
	if (!nlh)
4484
		return -EMSGSIZE;
4485

4486 4487 4488
	put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope),
		      ifa->idev->dev->ifindex);

4489 4490
	if (!((ifa->flags&IFA_F_PERMANENT) &&
	      (ifa->prefered_lft == INFINITY_LIFE_TIME))) {
4491 4492 4493
		preferred = ifa->prefered_lft;
		valid = ifa->valid_lft;
		if (preferred != INFINITY_LIFE_TIME) {
L
Linus Torvalds 已提交
4494
			long tval = (jiffies - ifa->tstamp)/HZ;
4495 4496 4497 4498
			if (preferred > tval)
				preferred -= tval;
			else
				preferred = 0;
4499 4500 4501 4502 4503 4504
			if (valid != INFINITY_LIFE_TIME) {
				if (valid > tval)
					valid -= tval;
				else
					valid = 0;
			}
L
Linus Torvalds 已提交
4505 4506
		}
	} else {
4507 4508 4509 4510
		preferred = INFINITY_LIFE_TIME;
		valid = INFINITY_LIFE_TIME;
	}

C
Cong Wang 已提交
4511
	if (!ipv6_addr_any(&ifa->peer_addr)) {
4512 4513
		if (nla_put_in6_addr(skb, IFA_LOCAL, &ifa->addr) < 0 ||
		    nla_put_in6_addr(skb, IFA_ADDRESS, &ifa->peer_addr) < 0)
4514 4515
			goto error;
	} else
4516
		if (nla_put_in6_addr(skb, IFA_ADDRESS, &ifa->addr) < 0)
4517 4518 4519 4520
			goto error;

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

4522 4523 4524
	if (nla_put_u32(skb, IFA_FLAGS, ifa->flags) < 0)
		goto error;

4525 4526
	nlmsg_end(skb, nlh);
	return 0;
4527 4528 4529 4530

error:
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
4531 4532 4533
}

static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca,
4534
				u32 portid, u32 seq, int event, u16 flags)
L
Linus Torvalds 已提交
4535 4536
{
	struct nlmsghdr  *nlh;
4537 4538 4539 4540 4541
	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 已提交
4542

4543
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4544
	if (!nlh)
4545
		return -EMSGSIZE;
4546

4547
	put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
4548
	if (nla_put_in6_addr(skb, IFA_MULTICAST, &ifmca->mca_addr) < 0 ||
4549
	    put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp,
4550 4551 4552 4553
			  INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
		nlmsg_cancel(skb, nlh);
		return -EMSGSIZE;
	}
4554

4555 4556
	nlmsg_end(skb, nlh);
	return 0;
L
Linus Torvalds 已提交
4557 4558 4559
}

static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
4560
				u32 portid, u32 seq, int event, unsigned int flags)
L
Linus Torvalds 已提交
4561 4562
{
	struct nlmsghdr  *nlh;
4563 4564 4565 4566 4567
	u8 scope = RT_SCOPE_UNIVERSE;
	int ifindex = ifaca->aca_idev->dev->ifindex;

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

4569
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4570
	if (!nlh)
4571
		return -EMSGSIZE;
4572

4573
	put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
4574
	if (nla_put_in6_addr(skb, IFA_ANYCAST, &ifaca->aca_addr) < 0 ||
4575
	    put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp,
4576 4577 4578 4579
			  INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
		nlmsg_cancel(skb, nlh);
		return -EMSGSIZE;
	}
L
Linus Torvalds 已提交
4580

4581 4582
	nlmsg_end(skb, nlh);
	return 0;
L
Linus Torvalds 已提交
4583 4584
}

S
Stephen Hemminger 已提交
4585
enum addr_type_t {
L
Linus Torvalds 已提交
4586 4587 4588 4589 4590
	UNICAST_ADDR,
	MULTICAST_ADDR,
	ANYCAST_ADDR,
};

E
Eric Dumazet 已提交
4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602
/* called with rcu_read_lock() */
static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
			  struct netlink_callback *cb, enum addr_type_t type,
			  int s_ip_idx, int *p_ip_idx)
{
	struct ifmcaddr6 *ifmca;
	struct ifacaddr6 *ifaca;
	int err = 1;
	int ip_idx = *p_ip_idx;

	read_lock_bh(&idev->lock);
	switch (type) {
4603 4604 4605
	case UNICAST_ADDR: {
		struct inet6_ifaddr *ifa;

E
Eric Dumazet 已提交
4606
		/* unicast address incl. temp addr */
4607 4608
		list_for_each_entry(ifa, &idev->addr_list, if_list) {
			if (++ip_idx < s_ip_idx)
E
Eric Dumazet 已提交
4609 4610
				continue;
			err = inet6_fill_ifaddr(skb, ifa,
4611
						NETLINK_CB(cb->skb).portid,
E
Eric Dumazet 已提交
4612 4613 4614
						cb->nlh->nlmsg_seq,
						RTM_NEWADDR,
						NLM_F_MULTI);
4615
			if (err < 0)
E
Eric Dumazet 已提交
4616
				break;
4617
			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
E
Eric Dumazet 已提交
4618 4619
		}
		break;
4620
	}
E
Eric Dumazet 已提交
4621 4622 4623 4624 4625 4626 4627
	case MULTICAST_ADDR:
		/* multicast address */
		for (ifmca = idev->mc_list; ifmca;
		     ifmca = ifmca->next, ip_idx++) {
			if (ip_idx < s_ip_idx)
				continue;
			err = inet6_fill_ifmcaddr(skb, ifmca,
4628
						  NETLINK_CB(cb->skb).portid,
E
Eric Dumazet 已提交
4629 4630 4631
						  cb->nlh->nlmsg_seq,
						  RTM_GETMULTICAST,
						  NLM_F_MULTI);
4632
			if (err < 0)
E
Eric Dumazet 已提交
4633 4634 4635 4636 4637 4638 4639 4640 4641 4642
				break;
		}
		break;
	case ANYCAST_ADDR:
		/* anycast address */
		for (ifaca = idev->ac_list; ifaca;
		     ifaca = ifaca->aca_next, ip_idx++) {
			if (ip_idx < s_ip_idx)
				continue;
			err = inet6_fill_ifacaddr(skb, ifaca,
4643
						  NETLINK_CB(cb->skb).portid,
E
Eric Dumazet 已提交
4644 4645 4646
						  cb->nlh->nlmsg_seq,
						  RTM_GETANYCAST,
						  NLM_F_MULTI);
4647
			if (err < 0)
E
Eric Dumazet 已提交
4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658
				break;
		}
		break;
	default:
		break;
	}
	read_unlock_bh(&idev->lock);
	*p_ip_idx = ip_idx;
	return err;
}

L
Linus Torvalds 已提交
4659 4660 4661
static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
			   enum addr_type_t type)
{
E
Eric Dumazet 已提交
4662 4663
	struct net *net = sock_net(skb->sk);
	int h, s_h;
L
Linus Torvalds 已提交
4664 4665 4666
	int idx, ip_idx;
	int s_idx, s_ip_idx;
	struct net_device *dev;
E
Eric Dumazet 已提交
4667 4668
	struct inet6_dev *idev;
	struct hlist_head *head;
4669

E
Eric Dumazet 已提交
4670 4671 4672
	s_h = cb->args[0];
	s_idx = idx = cb->args[1];
	s_ip_idx = ip_idx = cb->args[2];
4673

E
Eric Dumazet 已提交
4674
	rcu_read_lock();
4675
	cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ net->dev_base_seq;
E
Eric Dumazet 已提交
4676 4677 4678
	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
		head = &net->dev_index_head[h];
4679
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
E
Eric Dumazet 已提交
4680 4681
			if (idx < s_idx)
				goto cont;
4682
			if (h > s_h || idx > s_idx)
E
Eric Dumazet 已提交
4683 4684
				s_ip_idx = 0;
			ip_idx = 0;
S
Stephen Hemminger 已提交
4685 4686
			idev = __in6_dev_get(dev);
			if (!idev)
E
Eric Dumazet 已提交
4687 4688 4689
				goto cont;

			if (in6_dump_addrs(idev, skb, cb, type,
4690
					   s_ip_idx, &ip_idx) < 0)
E
Eric Dumazet 已提交
4691
				goto done;
4692
cont:
E
Eric Dumazet 已提交
4693 4694
			idx++;
		}
L
Linus Torvalds 已提交
4695
	}
E
Eric Dumazet 已提交
4696 4697 4698 4699 4700 4701
done:
	rcu_read_unlock();
	cb->args[0] = h;
	cb->args[1] = idx;
	cb->args[2] = ip_idx;

L
Linus Torvalds 已提交
4702 4703 4704 4705 4706 4707
	return skb->len;
}

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

L
Linus Torvalds 已提交
4709 4710 4711 4712 4713 4714
	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;
4715

L
Linus Torvalds 已提交
4716 4717 4718 4719 4720 4721 4722
	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;
4723

L
Linus Torvalds 已提交
4724 4725 4726
	return inet6_dump_addr(skb, cb, type);
}

4727
static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh)
4728
{
4729
	struct net *net = sock_net(in_skb->sk);
4730 4731
	struct ifaddrmsg *ifm;
	struct nlattr *tb[IFA_MAX+1];
4732
	struct in6_addr *addr = NULL, *peer;
4733 4734 4735 4736 4737
	struct net_device *dev = NULL;
	struct inet6_ifaddr *ifa;
	struct sk_buff *skb;
	int err;

4738 4739 4740 4741
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
	if (err < 0)
		goto errout;

4742
	addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer);
4743
	if (!addr) {
4744 4745
		err = -EINVAL;
		goto errout;
4746 4747
	}

4748
	ifm = nlmsg_data(nlh);
4749
	if (ifm->ifa_index)
4750
		dev = __dev_get_by_index(net, ifm->ifa_index);
4751

S
Stephen Hemminger 已提交
4752 4753
	ifa = ipv6_get_ifaddr(net, addr, dev, 1);
	if (!ifa) {
4754 4755 4756
		err = -EADDRNOTAVAIL;
		goto errout;
	}
4757

S
Stephen Hemminger 已提交
4758 4759
	skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL);
	if (!skb) {
4760
		err = -ENOBUFS;
4761
		goto errout_ifa;
4762 4763
	}

4764
	err = inet6_fill_ifaddr(skb, ifa, NETLINK_CB(in_skb).portid,
4765
				nlh->nlmsg_seq, RTM_NEWADDR, 0);
4766 4767 4768 4769 4770 4771
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout_ifa;
	}
4772
	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
4773
errout_ifa:
4774
	in6_ifa_put(ifa);
4775
errout:
4776 4777 4778
	return err;
}

L
Linus Torvalds 已提交
4779 4780 4781
static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa)
{
	struct sk_buff *skb;
4782
	struct net *net = dev_net(ifa->idev->dev);
4783
	int err = -ENOBUFS;
L
Linus Torvalds 已提交
4784

4785
	skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC);
4786
	if (!skb)
4787 4788 4789
		goto errout;

	err = inet6_fill_ifaddr(skb, ifa, 0, 0, event, 0);
4790 4791 4792 4793 4794 4795
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
4796 4797
	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC);
	return;
4798 4799
errout:
	if (err < 0)
4800
		rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err);
L
Linus Torvalds 已提交
4801 4802
}

D
Dave Jones 已提交
4803
static inline void ipv6_store_devconf(struct ipv6_devconf *cnf,
L
Linus Torvalds 已提交
4804 4805
				__s32 *array, int bytes)
{
4806 4807
	BUG_ON(bytes < (DEVCONF_MAX * 4));

L
Linus Torvalds 已提交
4808 4809 4810 4811 4812 4813 4814 4815 4816
	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;
4817 4818 4819 4820
	array[DEVCONF_RTR_SOLICIT_INTERVAL] =
		jiffies_to_msecs(cnf->rtr_solicit_interval);
	array[DEVCONF_RTR_SOLICIT_DELAY] =
		jiffies_to_msecs(cnf->rtr_solicit_delay);
L
Linus Torvalds 已提交
4821
	array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version;
4822 4823 4824 4825
	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 已提交
4826 4827 4828 4829 4830 4831
	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;
4832
	array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr;
4833
	array[DEVCONF_ACCEPT_RA_MIN_HOP_LIMIT] = cnf->accept_ra_min_hop_limit;
4834
	array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo;
4835 4836
#ifdef CONFIG_IPV6_ROUTER_PREF
	array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref;
4837 4838
	array[DEVCONF_RTR_PROBE_INTERVAL] =
		jiffies_to_msecs(cnf->rtr_probe_interval);
N
Neil Horman 已提交
4839
#ifdef CONFIG_IPV6_ROUTE_INFO
4840 4841
	array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen;
#endif
4842
#endif
4843
	array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp;
4844
	array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route;
4845 4846
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
	array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad;
4847
	array[DEVCONF_USE_OPTIMISTIC] = cnf->use_optimistic;
4848
#endif
4849 4850 4851
#ifdef CONFIG_IPV6_MROUTE
	array[DEVCONF_MC_FORWARDING] = cnf->mc_forwarding;
#endif
4852
	array[DEVCONF_DISABLE_IPV6] = cnf->disable_ipv6;
4853
	array[DEVCONF_ACCEPT_DAD] = cnf->accept_dad;
4854
	array[DEVCONF_FORCE_TLLAO] = cnf->force_tllao;
4855
	array[DEVCONF_NDISC_NOTIFY] = cnf->ndisc_notify;
4856
	array[DEVCONF_SUPPRESS_FRAG_NDISC] = cnf->suppress_frag_ndisc;
4857
	array[DEVCONF_ACCEPT_RA_FROM_LOCAL] = cnf->accept_ra_from_local;
4858
	array[DEVCONF_ACCEPT_RA_MTU] = cnf->accept_ra_mtu;
4859
	array[DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN] = cnf->ignore_routes_with_linkdown;
4860
	/* we omit DEVCONF_STABLE_SECRET for now */
4861
	array[DEVCONF_USE_OIF_ADDRS_ONLY] = cnf->use_oif_addrs_only;
4862
	array[DEVCONF_DROP_UNICAST_IN_L2_MULTICAST] = cnf->drop_unicast_in_l2_multicast;
4863
	array[DEVCONF_DROP_UNSOLICITED_NA] = cnf->drop_unsolicited_na;
4864
	array[DEVCONF_KEEP_ADDR_ON_DOWN] = cnf->keep_addr_on_down;
L
Linus Torvalds 已提交
4865 4866
}

T
Thomas Graf 已提交
4867 4868 4869 4870 4871 4872
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 */
4873 4874
	     + nla_total_size(ICMP6_MIB_MAX * 8) /* IFLA_INET6_ICMP6STATS */
	     + nla_total_size(sizeof(struct in6_addr)); /* IFLA_INET6_TOKEN */
T
Thomas Graf 已提交
4875 4876
}

4877 4878 4879 4880 4881 4882 4883
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 */
4884
	       + nla_total_size(1) /* IFLA_OPERSTATE */
T
Thomas Graf 已提交
4885
	       + nla_total_size(inet6_ifla6_size()); /* IFLA_PROTINFO */
4886
}
4887

4888
static inline void __snmp6_fill_statsdev(u64 *stats, atomic_long_t *mib,
4889
				      int items, int bytes)
4890 4891 4892 4893 4894 4895 4896 4897
{
	int i;
	int pad = bytes - sizeof(u64) * items;
	BUG_ON(pad < 0);

	/* Use put_unaligned() because stats may not be aligned for u64. */
	put_unaligned(items, &stats[0]);
	for (i = 1; i < items; i++)
4898
		put_unaligned(atomic_long_read(&mib[i]), &stats[i]);
4899 4900 4901 4902

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

W
WANG Cong 已提交
4903
static inline void __snmp6_fill_stats64(u64 *stats, void __percpu *mib,
4904
					int bytes, size_t syncpoff)
4905
{
4906 4907 4908 4909
	int i, c;
	u64 buff[IPSTATS_MIB_MAX];
	int pad = bytes - sizeof(u64) * IPSTATS_MIB_MAX;

4910 4911
	BUG_ON(pad < 0);

4912 4913
	memset(buff, 0, sizeof(buff));
	buff[0] = IPSTATS_MIB_MAX;
4914

4915 4916 4917 4918 4919 4920 4921
	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);
4922 4923
}

4924 4925 4926
static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype,
			     int bytes)
{
S
Stephen Hemminger 已提交
4927
	switch (attrtype) {
4928
	case IFLA_INET6_STATS:
4929 4930
		__snmp6_fill_stats64(stats, idev->stats.ipv6, bytes,
				     offsetof(struct ipstats_mib, syncp));
4931 4932
		break;
	case IFLA_INET6_ICMP6STATS:
4933
		__snmp6_fill_statsdev(stats, idev->stats.icmpv6dev->mibs, ICMP6_MIB_MAX, bytes);
4934 4935 4936 4937
		break;
	}
}

4938 4939
static int inet6_fill_ifla6_attrs(struct sk_buff *skb, struct inet6_dev *idev,
				  u32 ext_filter_mask)
T
Thomas Graf 已提交
4940 4941 4942 4943
{
	struct nlattr *nla;
	struct ifla_cacheinfo ci;

D
David S. Miller 已提交
4944 4945
	if (nla_put_u32(skb, IFLA_INET6_FLAGS, idev->if_flags))
		goto nla_put_failure;
T
Thomas Graf 已提交
4946
	ci.max_reasm_len = IPV6_MAXPLEN;
4947 4948
	ci.tstamp = cstamp_delta(idev->tstamp);
	ci.reachable_time = jiffies_to_msecs(idev->nd_parms->reachable_time);
J
Jiri Pirko 已提交
4949
	ci.retrans_time = jiffies_to_msecs(NEIGH_VAR(idev->nd_parms, RETRANS_TIME));
D
David S. Miller 已提交
4950 4951
	if (nla_put(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci))
		goto nla_put_failure;
T
Thomas Graf 已提交
4952
	nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32));
4953
	if (!nla)
T
Thomas Graf 已提交
4954 4955 4956 4957 4958
		goto nla_put_failure;
	ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla));

	/* XXX - MC not implemented */

4959 4960 4961
	if (ext_filter_mask & RTEXT_FILTER_SKIP_STATS)
		return 0;

T
Thomas Graf 已提交
4962
	nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64));
4963
	if (!nla)
T
Thomas Graf 已提交
4964 4965 4966 4967
		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));
4968
	if (!nla)
T
Thomas Graf 已提交
4969 4970 4971
		goto nla_put_failure;
	snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla));

4972
	nla = nla_reserve(skb, IFLA_INET6_TOKEN, sizeof(struct in6_addr));
4973
	if (!nla)
4974
		goto nla_put_failure;
4975 4976 4977 4978

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

4979 4980 4981 4982
	read_lock_bh(&idev->lock);
	memcpy(nla_data(nla), idev->token.s6_addr, nla_len(nla));
	read_unlock_bh(&idev->lock);

T
Thomas Graf 已提交
4983 4984 4985 4986 4987 4988
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

4989 4990
static size_t inet6_get_link_af_size(const struct net_device *dev,
				     u32 ext_filter_mask)
T
Thomas Graf 已提交
4991 4992 4993 4994 4995 4996 4997
{
	if (!__in6_dev_get(dev))
		return 0;

	return inet6_ifla6_size();
}

4998 4999
static int inet6_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
			      u32 ext_filter_mask)
T
Thomas Graf 已提交
5000 5001 5002 5003 5004 5005
{
	struct inet6_dev *idev = __in6_dev_get(dev);

	if (!idev)
		return -ENODATA;

5006
	if (inet6_fill_ifla6_attrs(skb, idev, ext_filter_mask) < 0)
T
Thomas Graf 已提交
5007 5008 5009 5010 5011
		return -EMSGSIZE;

	return 0;
}

5012 5013 5014 5015
static int inet6_set_iftoken(struct inet6_dev *idev, struct in6_addr *token)
{
	struct inet6_ifaddr *ifp;
	struct net_device *dev = idev->dev;
5016
	bool update_rs = false;
5017
	struct in6_addr ll_addr;
5018

5019 5020
	ASSERT_RTNL();

5021
	if (!token)
5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038
		return -EINVAL;
	if (ipv6_addr_any(token))
		return -EINVAL;
	if (dev->flags & (IFF_LOOPBACK | IFF_NOARP))
		return -EINVAL;
	if (!ipv6_accept_ra(idev))
		return -EINVAL;
	if (idev->cnf.rtr_solicits <= 0)
		return -EINVAL;

	write_lock_bh(&idev->lock);

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

	write_unlock_bh(&idev->lock);

5039 5040 5041
	if (!idev->dead && (idev->if_flags & IF_READY) &&
	    !ipv6_get_lladdr(dev, &ll_addr, IFA_F_TENTATIVE |
			     IFA_F_OPTIMISTIC)) {
5042 5043 5044 5045 5046 5047 5048

		/* 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;
	}
5049 5050

	write_lock_bh(&idev->lock);
5051

5052
	if (update_rs) {
5053
		idev->if_flags |= IF_RS_SENT;
5054 5055 5056
		idev->rs_probes = 1;
		addrconf_mod_rs_timer(idev, idev->cnf.rtr_solicit_interval);
	}
5057 5058 5059 5060

	/* Well, that's kinda nasty ... */
	list_for_each_entry(ifp, &idev->addr_list, if_list) {
		spin_lock(&ifp->lock);
5061
		if (ifp->tokenized) {
5062 5063 5064 5065 5066 5067 5068
			ifp->valid_lft = 0;
			ifp->prefered_lft = 0;
		}
		spin_unlock(&ifp->lock);
	}

	write_unlock_bh(&idev->lock);
5069
	inet6_ifinfo_notify(RTM_NEWLINK, idev);
5070
	addrconf_verify_rtnl();
5071 5072 5073
	return 0;
}

5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089
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) },
};

static int inet6_validate_link_af(const struct net_device *dev,
				  const struct nlattr *nla)
{
	struct nlattr *tb[IFLA_INET6_MAX + 1];

	if (dev && !__in6_dev_get(dev))
		return -EAFNOSUPPORT;

	return nla_parse_nested(tb, IFLA_INET6_MAX, nla, inet6_af_policy);
}

5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101
static int inet6_set_link_af(struct net_device *dev, const struct nlattr *nla)
{
	int err = -EINVAL;
	struct inet6_dev *idev = __in6_dev_get(dev);
	struct nlattr *tb[IFLA_INET6_MAX + 1];

	if (!idev)
		return -EAFNOSUPPORT;

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

5102
	if (tb[IFLA_INET6_TOKEN]) {
5103
		err = inet6_set_iftoken(idev, nla_data(tb[IFLA_INET6_TOKEN]));
5104 5105 5106 5107 5108 5109 5110 5111
		if (err)
			return err;
	}

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

		if (mode != IN6_ADDR_GEN_MODE_EUI64 &&
5112
		    mode != IN6_ADDR_GEN_MODE_NONE &&
5113 5114
		    mode != IN6_ADDR_GEN_MODE_STABLE_PRIVACY &&
		    mode != IN6_ADDR_GEN_MODE_RANDOM)
5115 5116 5117 5118 5119
			return -EINVAL;

		if (mode == IN6_ADDR_GEN_MODE_STABLE_PRIVACY &&
		    !idev->cnf.stable_secret.initialized &&
		    !dev_net(dev)->ipv6.devconf_dflt->stable_secret.initialized)
5120
			return -EINVAL;
5121

5122 5123 5124
		idev->addr_gen_mode = mode;
		err = 0;
	}
5125 5126 5127 5128

	return err;
}

5129
static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev,
5130
			     u32 portid, u32 seq, int event, unsigned int flags)
L
Linus Torvalds 已提交
5131
{
5132 5133 5134 5135 5136
	struct net_device *dev = idev->dev;
	struct ifinfomsg *hdr;
	struct nlmsghdr *nlh;
	void *protoinfo;

5137
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags);
5138
	if (!nlh)
5139
		return -EMSGSIZE;
5140 5141 5142 5143 5144 5145 5146 5147 5148

	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 已提交
5149 5150 5151 5152
	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) ||
5153
	    (dev->ifindex != dev_get_iflink(dev) &&
5154 5155 5156
	     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 已提交
5157
		goto nla_put_failure;
5158
	protoinfo = nla_nest_start(skb, IFLA_PROTINFO);
5159
	if (!protoinfo)
5160
		goto nla_put_failure;
L
Linus Torvalds 已提交
5161

5162
	if (inet6_fill_ifla6_attrs(skb, idev, 0) < 0)
5163
		goto nla_put_failure;
L
Linus Torvalds 已提交
5164

5165
	nla_nest_end(skb, protoinfo);
5166 5167
	nlmsg_end(skb, nlh);
	return 0;
L
Linus Torvalds 已提交
5168

5169
nla_put_failure:
5170 5171
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
5172 5173 5174 5175
}

static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
{
5176
	struct net *net = sock_net(skb->sk);
E
Eric Dumazet 已提交
5177
	int h, s_h;
5178
	int idx = 0, s_idx;
L
Linus Torvalds 已提交
5179 5180
	struct net_device *dev;
	struct inet6_dev *idev;
E
Eric Dumazet 已提交
5181
	struct hlist_head *head;
L
Linus Torvalds 已提交
5182

E
Eric Dumazet 已提交
5183 5184 5185 5186 5187 5188 5189
	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];
5190
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
E
Eric Dumazet 已提交
5191 5192 5193 5194 5195 5196
			if (idx < s_idx)
				goto cont;
			idev = __in6_dev_get(dev);
			if (!idev)
				goto cont;
			if (inet6_fill_ifinfo(skb, idev,
5197
					      NETLINK_CB(cb->skb).portid,
E
Eric Dumazet 已提交
5198
					      cb->nlh->nlmsg_seq,
5199
					      RTM_NEWLINK, NLM_F_MULTI) < 0)
E
Eric Dumazet 已提交
5200
				goto out;
5201
cont:
E
Eric Dumazet 已提交
5202 5203
			idx++;
		}
L
Linus Torvalds 已提交
5204
	}
E
Eric Dumazet 已提交
5205 5206 5207 5208
out:
	rcu_read_unlock();
	cb->args[1] = idx;
	cb->args[0] = h;
L
Linus Torvalds 已提交
5209 5210 5211 5212 5213 5214 5215

	return skb->len;
}

void inet6_ifinfo_notify(int event, struct inet6_dev *idev)
{
	struct sk_buff *skb;
5216
	struct net *net = dev_net(idev->dev);
5217
	int err = -ENOBUFS;
5218

5219
	skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC);
5220
	if (!skb)
5221 5222 5223
		goto errout;

	err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0);
5224 5225 5226 5227 5228 5229
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_if_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
5230
	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFINFO, NULL, GFP_ATOMIC);
5231
	return;
5232 5233
errout:
	if (err < 0)
5234
		rtnl_set_sk_err(net, RTNLGRP_IPV6_IFINFO, err);
L
Linus Torvalds 已提交
5235 5236
}

5237 5238 5239 5240 5241 5242
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));
}
5243

L
Linus Torvalds 已提交
5244
static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev,
5245
			     struct prefix_info *pinfo, u32 portid, u32 seq,
5246
			     int event, unsigned int flags)
L
Linus Torvalds 已提交
5247
{
5248 5249
	struct prefixmsg *pmsg;
	struct nlmsghdr *nlh;
L
Linus Torvalds 已提交
5250 5251
	struct prefix_cacheinfo	ci;

5252
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*pmsg), flags);
5253
	if (!nlh)
5254
		return -EMSGSIZE;
5255 5256

	pmsg = nlmsg_data(nlh);
L
Linus Torvalds 已提交
5257
	pmsg->prefix_family = AF_INET6;
5258 5259
	pmsg->prefix_pad1 = 0;
	pmsg->prefix_pad2 = 0;
L
Linus Torvalds 已提交
5260 5261 5262
	pmsg->prefix_ifindex = idev->dev->ifindex;
	pmsg->prefix_len = pinfo->prefix_len;
	pmsg->prefix_type = pinfo->type;
5263
	pmsg->prefix_pad3 = 0;
L
Linus Torvalds 已提交
5264 5265 5266 5267 5268 5269
	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 已提交
5270 5271
	if (nla_put(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix))
		goto nla_put_failure;
L
Linus Torvalds 已提交
5272 5273
	ci.preferred_time = ntohl(pinfo->prefered);
	ci.valid_time = ntohl(pinfo->valid);
D
David S. Miller 已提交
5274 5275
	if (nla_put(skb, PREFIX_CACHEINFO, sizeof(ci), &ci))
		goto nla_put_failure;
5276 5277
	nlmsg_end(skb, nlh);
	return 0;
L
Linus Torvalds 已提交
5278

5279
nla_put_failure:
5280 5281
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
5282 5283
}

5284
static void inet6_prefix_notify(int event, struct inet6_dev *idev,
L
Linus Torvalds 已提交
5285 5286 5287
			 struct prefix_info *pinfo)
{
	struct sk_buff *skb;
5288
	struct net *net = dev_net(idev->dev);
5289
	int err = -ENOBUFS;
L
Linus Torvalds 已提交
5290

5291
	skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC);
5292
	if (!skb)
5293 5294 5295
		goto errout;

	err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0);
5296 5297 5298 5299 5300 5301
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet6_prefix_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
5302 5303
	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC);
	return;
5304 5305
errout:
	if (err < 0)
5306
		rtnl_set_sk_err(net, RTNLGRP_IPV6_PREFIX, err);
L
Linus Torvalds 已提交
5307 5308 5309 5310
}

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

5313 5314 5315
	if (event)
		ASSERT_RTNL();

L
Linus Torvalds 已提交
5316 5317 5318 5319
	inet6_ifa_notify(event ? : RTM_NEWADDR, ifp);

	switch (event) {
	case RTM_NEWADDR:
5320 5321 5322 5323 5324 5325 5326 5327
		/*
		 * If the address was optimistic
		 * we inserted the route at the start of
		 * our DAD process, so we don't need
		 * to do it again
		 */
		if (!(ifp->rt->rt6i_node))
			ip6_ins_rt(ifp->rt);
L
Linus Torvalds 已提交
5328 5329
		if (ifp->idev->cnf.forwarding)
			addrconf_join_anycast(ifp);
C
Cong Wang 已提交
5330
		if (!ipv6_addr_any(&ifp->peer_addr))
5331 5332
			addrconf_prefix_route(&ifp->peer_addr, 128,
					      ifp->idev->dev, 0, 0);
L
Linus Torvalds 已提交
5333 5334 5335 5336 5337
		break;
	case RTM_DELADDR:
		if (ifp->idev->cnf.forwarding)
			addrconf_leave_anycast(ifp);
		addrconf_leave_solict(ifp->idev, &ifp->addr);
C
Cong Wang 已提交
5338
		if (!ipv6_addr_any(&ifp->peer_addr)) {
5339 5340
			struct rt6_info *rt;

5341 5342
			rt = addrconf_get_prefix_route(&ifp->peer_addr, 128,
						       ifp->idev->dev, 0, 0);
M
Martin KaFai Lau 已提交
5343 5344
			if (rt)
				ip6_del_rt(rt);
5345
		}
5346 5347 5348
		dst_hold(&ifp->rt->dst);

		ip6_del_rt(ifp->rt);
H
Hannes Frederic Sowa 已提交
5349 5350

		rt_genid_bump_ipv6(net);
L
Linus Torvalds 已提交
5351 5352
		break;
	}
5353
	atomic_inc(&net->ipv6.dev_addr_genid);
L
Linus Torvalds 已提交
5354 5355 5356 5357
}

static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
{
5358
	rcu_read_lock_bh();
L
Linus Torvalds 已提交
5359 5360
	if (likely(ifp->idev->dead == 0))
		__ipv6_ifa_notify(event, ifp);
5361
	rcu_read_unlock_bh();
L
Linus Torvalds 已提交
5362 5363 5364 5365 5366
}

#ifdef CONFIG_SYSCTL

static
5367
int addrconf_sysctl_forward(struct ctl_table *ctl, int write,
L
Linus Torvalds 已提交
5368 5369 5370 5371
			   void __user *buffer, size_t *lenp, loff_t *ppos)
{
	int *valp = ctl->data;
	int val = *valp;
E
Eric W. Biederman 已提交
5372
	loff_t pos = *ppos;
5373
	struct ctl_table lctl;
L
Linus Torvalds 已提交
5374 5375
	int ret;

5376 5377 5378 5379 5380 5381 5382 5383
	/*
	 * 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 已提交
5384

5385
	if (write)
5386
		ret = addrconf_fixup_forwarding(ctl, valp, val);
E
Eric W. Biederman 已提交
5387 5388
	if (ret)
		*ppos = pos;
5389
	return ret;
L
Linus Torvalds 已提交
5390 5391
}

5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405
static
int addrconf_sysctl_hop_limit(struct ctl_table *ctl, int write,
                              void __user *buffer, size_t *lenp, loff_t *ppos)
{
	struct ctl_table lctl;
	int min_hl = 1, max_hl = 255;

	lctl = *ctl;
	lctl.extra1 = &min_hl;
	lctl.extra2 = &max_hl;

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

5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420
static
int addrconf_sysctl_mtu(struct ctl_table *ctl, int write,
			void __user *buffer, size_t *lenp, loff_t *ppos)
{
	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);
}

5421 5422
static void dev_disable_change(struct inet6_dev *idev)
{
5423 5424
	struct netdev_notifier_info info;

5425 5426 5427
	if (!idev || !idev->dev)
		return;

5428
	netdev_notifier_info_init(&info, idev->dev);
5429
	if (idev->cnf.disable_ipv6)
5430
		addrconf_notify(NULL, NETDEV_DOWN, &info);
5431
	else
5432
		addrconf_notify(NULL, NETDEV_UP, &info);
5433 5434 5435 5436 5437 5438 5439
}

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

5440 5441
	rcu_read_lock();
	for_each_netdev_rcu(net, dev) {
5442 5443 5444 5445 5446 5447 5448 5449
		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);
		}
	}
5450
	rcu_read_unlock();
5451 5452
}

5453
static int addrconf_disable_ipv6(struct ctl_table *table, int *p, int newf)
5454 5455
{
	struct net *net;
5456 5457 5458 5459
	int old;

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

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

5465 5466
	if (p == &net->ipv6.devconf_dflt->disable_ipv6) {
		rtnl_unlock();
5467
		return 0;
E
Eric W. Biederman 已提交
5468
	}
5469 5470 5471 5472

	if (p == &net->ipv6.devconf_all->disable_ipv6) {
		net->ipv6.devconf_dflt->disable_ipv6 = newf;
		addrconf_disable_change(net, newf);
5473
	} else if ((!newf) ^ (!old))
5474 5475 5476 5477 5478 5479 5480
		dev_disable_change((struct inet6_dev *)table->extra1);

	rtnl_unlock();
	return 0;
}

static
5481
int addrconf_sysctl_disable(struct ctl_table *ctl, int write,
5482 5483 5484 5485
			    void __user *buffer, size_t *lenp, loff_t *ppos)
{
	int *valp = ctl->data;
	int val = *valp;
E
Eric W. Biederman 已提交
5486
	loff_t pos = *ppos;
5487
	struct ctl_table lctl;
5488 5489
	int ret;

5490 5491 5492 5493 5494 5495 5496 5497
	/*
	 * 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);
5498 5499 5500

	if (write)
		ret = addrconf_disable_ipv6(ctl, valp, val);
E
Eric W. Biederman 已提交
5501 5502
	if (ret)
		*ppos = pos;
5503 5504 5505
	return ret;
}

5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544
static
int addrconf_sysctl_proxy_ndp(struct ctl_table *ctl, int write,
			      void __user *buffer, size_t *lenp, loff_t *ppos)
{
	int *valp = ctl->data;
	int ret;
	int old, new;

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

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

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

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

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

	return ret;
}

5545 5546 5547 5548 5549 5550 5551 5552
static int addrconf_sysctl_stable_secret(struct ctl_table *ctl, int write,
					 void __user *buffer, size_t *lenp,
					 loff_t *ppos)
{
	int err;
	struct in6_addr addr;
	char str[IPV6_MAX_STRLEN];
	struct ctl_table lctl = *ctl;
5553
	struct net *net = ctl->extra2;
5554 5555
	struct ipv6_stable_secret *secret = ctl->data;

5556 5557 5558
	if (&net->ipv6.devconf_all->stable_secret == ctl->data)
		return -EIO;

5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569
	lctl.maxlen = IPV6_MAX_STRLEN;
	lctl.data = str;

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

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

5570 5571 5572 5573
	err = snprintf(str, sizeof(str), "%pI6", &secret->secret);
	if (err >= sizeof(str)) {
		err = -EIO;
		goto out;
5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587
	}

	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;

5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604
	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) {
				idev->addr_gen_mode =
					IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
			}
		}
	} else {
		struct inet6_dev *idev = ctl->extra1;

		idev->addr_gen_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
	}

5605 5606 5607 5608 5609
out:
	rtnl_unlock();

	return err;
}
5610

5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638
static
int addrconf_sysctl_ignore_routes_with_linkdown(struct ctl_table *ctl,
						int write,
						void __user *buffer,
						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;
}

L
Linus Torvalds 已提交
5639 5640 5641
static struct addrconf_sysctl_table
{
	struct ctl_table_header *sysctl_header;
5642
	struct ctl_table addrconf_vars[DEVCONF_MAX+1];
5643
} addrconf_sysctl __read_mostly = {
L
Linus Torvalds 已提交
5644 5645
	.sysctl_header = NULL,
	.addrconf_vars = {
5646
		{
S
Stephen Hemminger 已提交
5647 5648 5649 5650 5651
			.procname	= "forwarding",
			.data		= &ipv6_devconf.forwarding,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= addrconf_sysctl_forward,
L
Linus Torvalds 已提交
5652 5653
		},
		{
S
Stephen Hemminger 已提交
5654 5655 5656 5657
			.procname	= "hop_limit",
			.data		= &ipv6_devconf.hop_limit,
			.maxlen		= sizeof(int),
			.mode		= 0644,
5658
			.proc_handler	= addrconf_sysctl_hop_limit,
L
Linus Torvalds 已提交
5659 5660
		},
		{
S
Stephen Hemminger 已提交
5661 5662 5663 5664
			.procname	= "mtu",
			.data		= &ipv6_devconf.mtu6,
			.maxlen		= sizeof(int),
			.mode		= 0644,
5665
			.proc_handler	= addrconf_sysctl_mtu,
L
Linus Torvalds 已提交
5666 5667
		},
		{
S
Stephen Hemminger 已提交
5668 5669 5670 5671 5672
			.procname	= "accept_ra",
			.data		= &ipv6_devconf.accept_ra,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5673 5674
		},
		{
S
Stephen Hemminger 已提交
5675 5676 5677 5678 5679
			.procname	= "accept_redirects",
			.data		= &ipv6_devconf.accept_redirects,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5680 5681
		},
		{
S
Stephen Hemminger 已提交
5682 5683 5684 5685 5686
			.procname	= "autoconf",
			.data		= &ipv6_devconf.autoconf,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5687 5688
		},
		{
S
Stephen Hemminger 已提交
5689 5690 5691 5692 5693
			.procname	= "dad_transmits",
			.data		= &ipv6_devconf.dad_transmits,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5694 5695
		},
		{
S
Stephen Hemminger 已提交
5696 5697 5698 5699 5700
			.procname	= "router_solicitations",
			.data		= &ipv6_devconf.rtr_solicits,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5701 5702
		},
		{
S
Stephen Hemminger 已提交
5703 5704 5705 5706 5707
			.procname	= "router_solicitation_interval",
			.data		= &ipv6_devconf.rtr_solicit_interval,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec_jiffies,
L
Linus Torvalds 已提交
5708 5709
		},
		{
S
Stephen Hemminger 已提交
5710 5711 5712 5713 5714
			.procname	= "router_solicitation_delay",
			.data		= &ipv6_devconf.rtr_solicit_delay,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec_jiffies,
L
Linus Torvalds 已提交
5715 5716
		},
		{
S
Stephen Hemminger 已提交
5717 5718 5719 5720 5721
			.procname	= "force_mld_version",
			.data		= &ipv6_devconf.force_mld_version,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5722
		},
5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738
		{
			.procname	= "mldv1_unsolicited_report_interval",
			.data		=
				&ipv6_devconf.mldv1_unsolicited_report_interval,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec_ms_jiffies,
		},
		{
			.procname	= "mldv2_unsolicited_report_interval",
			.data		=
				&ipv6_devconf.mldv2_unsolicited_report_interval,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec_ms_jiffies,
		},
L
Linus Torvalds 已提交
5739
		{
S
Stephen Hemminger 已提交
5740 5741 5742 5743 5744
			.procname	= "use_tempaddr",
			.data		= &ipv6_devconf.use_tempaddr,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5745 5746
		},
		{
S
Stephen Hemminger 已提交
5747 5748 5749 5750 5751
			.procname	= "temp_valid_lft",
			.data		= &ipv6_devconf.temp_valid_lft,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5752 5753
		},
		{
S
Stephen Hemminger 已提交
5754 5755 5756 5757 5758
			.procname	= "temp_prefered_lft",
			.data		= &ipv6_devconf.temp_prefered_lft,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5759 5760
		},
		{
S
Stephen Hemminger 已提交
5761 5762 5763 5764 5765
			.procname	= "regen_max_retry",
			.data		= &ipv6_devconf.regen_max_retry,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5766 5767
		},
		{
S
Stephen Hemminger 已提交
5768 5769 5770 5771 5772
			.procname	= "max_desync_factor",
			.data		= &ipv6_devconf.max_desync_factor,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5773 5774
		},
		{
S
Stephen Hemminger 已提交
5775 5776 5777 5778 5779
			.procname	= "max_addresses",
			.data		= &ipv6_devconf.max_addresses,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
5780
		},
5781
		{
S
Stephen Hemminger 已提交
5782 5783 5784 5785 5786
			.procname	= "accept_ra_defrtr",
			.data		= &ipv6_devconf.accept_ra_defrtr,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
5787
		},
5788 5789 5790 5791 5792 5793 5794
		{
			.procname	= "accept_ra_min_hop_limit",
			.data		= &ipv6_devconf.accept_ra_min_hop_limit,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
		},
5795
		{
S
Stephen Hemminger 已提交
5796 5797 5798 5799 5800
			.procname	= "accept_ra_pinfo",
			.data		= &ipv6_devconf.accept_ra_pinfo,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
5801
		},
5802 5803
#ifdef CONFIG_IPV6_ROUTER_PREF
		{
S
Stephen Hemminger 已提交
5804 5805 5806 5807 5808
			.procname	= "accept_ra_rtr_pref",
			.data		= &ipv6_devconf.accept_ra_rtr_pref,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
5809
		},
5810
		{
S
Stephen Hemminger 已提交
5811 5812 5813 5814 5815
			.procname	= "router_probe_interval",
			.data		= &ipv6_devconf.rtr_probe_interval,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec_jiffies,
5816
		},
N
Neil Horman 已提交
5817
#ifdef CONFIG_IPV6_ROUTE_INFO
5818
		{
S
Stephen Hemminger 已提交
5819 5820 5821 5822 5823
			.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,
5824 5825
		},
#endif
5826
#endif
5827
		{
S
Stephen Hemminger 已提交
5828 5829 5830 5831
			.procname	= "proxy_ndp",
			.data		= &ipv6_devconf.proxy_ndp,
			.maxlen		= sizeof(int),
			.mode		= 0644,
5832
			.proc_handler	= addrconf_sysctl_proxy_ndp,
5833
		},
5834
		{
S
Stephen Hemminger 已提交
5835 5836 5837 5838 5839
			.procname	= "accept_source_route",
			.data		= &ipv6_devconf.accept_source_route,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
5840
		},
5841 5842
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
		{
S
Stephen Hemminger 已提交
5843 5844 5845 5846 5847
			.procname       = "optimistic_dad",
			.data           = &ipv6_devconf.optimistic_dad,
			.maxlen         = sizeof(int),
			.mode           = 0644,
			.proc_handler   = proc_dointvec,
5848 5849

		},
5850 5851 5852 5853 5854 5855 5856 5857
		{
			.procname       = "use_optimistic",
			.data           = &ipv6_devconf.use_optimistic,
			.maxlen         = sizeof(int),
			.mode           = 0644,
			.proc_handler   = proc_dointvec,

		},
5858 5859 5860
#endif
#ifdef CONFIG_IPV6_MROUTE
		{
S
Stephen Hemminger 已提交
5861 5862 5863 5864 5865
			.procname	= "mc_forwarding",
			.data		= &ipv6_devconf.mc_forwarding,
			.maxlen		= sizeof(int),
			.mode		= 0444,
			.proc_handler	= proc_dointvec,
5866
		},
5867
#endif
5868
		{
S
Stephen Hemminger 已提交
5869 5870 5871 5872 5873
			.procname	= "disable_ipv6",
			.data		= &ipv6_devconf.disable_ipv6,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= addrconf_sysctl_disable,
5874
		},
5875
		{
S
Stephen Hemminger 已提交
5876 5877 5878 5879 5880
			.procname	= "accept_dad",
			.data		= &ipv6_devconf.accept_dad,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
5881
		},
5882 5883 5884 5885 5886 5887 5888
		{
			.procname       = "force_tllao",
			.data           = &ipv6_devconf.force_tllao,
			.maxlen         = sizeof(int),
			.mode           = 0644,
			.proc_handler   = proc_dointvec
		},
5889 5890 5891 5892 5893 5894 5895
		{
			.procname       = "ndisc_notify",
			.data           = &ipv6_devconf.ndisc_notify,
			.maxlen         = sizeof(int),
			.mode           = 0644,
			.proc_handler   = proc_dointvec
		},
5896 5897 5898 5899 5900 5901 5902
		{
			.procname	= "suppress_frag_ndisc",
			.data		= &ipv6_devconf.suppress_frag_ndisc,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec
		},
5903 5904 5905 5906 5907 5908 5909
		{
			.procname	= "accept_ra_from_local",
			.data		= &ipv6_devconf.accept_ra_from_local,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
		},
5910 5911 5912 5913 5914 5915 5916
		{
			.procname	= "accept_ra_mtu",
			.data		= &ipv6_devconf.accept_ra_mtu,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
		},
5917 5918 5919 5920 5921 5922 5923
		{
			.procname	= "stable_secret",
			.data		= &ipv6_devconf.stable_secret,
			.maxlen		= IPV6_MAX_STRLEN,
			.mode		= 0600,
			.proc_handler	= addrconf_sysctl_stable_secret,
		},
5924 5925 5926 5927 5928 5929
		{
			.procname       = "use_oif_addrs_only",
			.data           = &ipv6_devconf.use_oif_addrs_only,
			.maxlen         = sizeof(int),
			.mode           = 0644,
			.proc_handler   = proc_dointvec,
5930 5931 5932 5933 5934 5935 5936
		},
		{
			.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,
5937
		},
5938 5939 5940 5941 5942 5943 5944
		{
			.procname	= "drop_unicast_in_l2_multicast",
			.data		= &ipv6_devconf.drop_unicast_in_l2_multicast,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
		},
5945 5946 5947 5948 5949 5950 5951
		{
			.procname	= "drop_unsolicited_na",
			.data		= &ipv6_devconf.drop_unsolicited_na,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec,
		},
5952 5953 5954 5955 5956 5957 5958 5959
		{
			.procname       = "keep_addr_on_down",
			.data           = &ipv6_devconf.keep_addr_on_down,
			.maxlen         = sizeof(int),
			.mode           = 0644,
			.proc_handler   = proc_dointvec,

		},
L
Linus Torvalds 已提交
5960
		{
5961
			/* sentinel */
L
Linus Torvalds 已提交
5962 5963 5964 5965
		}
	},
};

5966
static int __addrconf_sysctl_register(struct net *net, char *dev_name,
5967
		struct inet6_dev *idev, struct ipv6_devconf *p)
L
Linus Torvalds 已提交
5968 5969 5970
{
	int i;
	struct addrconf_sysctl_table *t;
5971
	char path[sizeof("net/ipv6/conf/") + IFNAMSIZ];
5972

A
Arnaldo Carvalho de Melo 已提交
5973
	t = kmemdup(&addrconf_sysctl, sizeof(*t), GFP_KERNEL);
5974
	if (!t)
5975 5976
		goto out;

S
Stephen Hemminger 已提交
5977
	for (i = 0; t->addrconf_vars[i].data; i++) {
S
Stephen Hemminger 已提交
5978
		t->addrconf_vars[i].data += (char *)p - (char *)&ipv6_devconf;
L
Linus Torvalds 已提交
5979
		t->addrconf_vars[i].extra1 = idev; /* embedded; no ref */
5980
		t->addrconf_vars[i].extra2 = net;
L
Linus Torvalds 已提交
5981 5982
	}

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

5985
	t->sysctl_header = register_net_sysctl(net, path, t->addrconf_vars);
5986
	if (!t->sysctl_header)
5987
		goto free;
5988 5989

	p->sysctl = t;
5990
	return 0;
L
Linus Torvalds 已提交
5991

5992
free:
L
Linus Torvalds 已提交
5993
	kfree(t);
5994
out:
5995
	return -ENOBUFS;
L
Linus Torvalds 已提交
5996 5997
}

5998 5999 6000 6001
static void __addrconf_sysctl_unregister(struct ipv6_devconf *p)
{
	struct addrconf_sysctl_table *t;

6002
	if (!p->sysctl)
6003 6004 6005 6006
		return;

	t = p->sysctl;
	p->sysctl = NULL;
6007
	unregister_net_sysctl_table(t->sysctl_header);
6008 6009 6010
	kfree(t);
}

6011
static int addrconf_sysctl_register(struct inet6_dev *idev)
6012
{
6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027
	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;
6028 6029
}

6030
static void addrconf_sysctl_unregister(struct inet6_dev *idev)
L
Linus Torvalds 已提交
6031
{
6032 6033
	__addrconf_sysctl_unregister(&idev->cnf);
	neigh_sysctl_unregister(idev->nd_parms);
L
Linus Torvalds 已提交
6034 6035 6036 6037 6038
}


#endif

6039
static int __net_init addrconf_init_net(struct net *net)
6040
{
6041
	int err = -ENOMEM;
6042 6043
	struct ipv6_devconf *all, *dflt;

6044
	all = kmemdup(&ipv6_devconf, sizeof(ipv6_devconf), GFP_KERNEL);
6045
	if (!all)
6046
		goto err_alloc_all;
6047

6048
	dflt = kmemdup(&ipv6_devconf_dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
6049
	if (!dflt)
6050
		goto err_alloc_dflt;
6051

6052 6053 6054
	/* these will be inherited by all namespaces */
	dflt->autoconf = ipv6_defaults.autoconf;
	dflt->disable_ipv6 = ipv6_defaults.disable_ipv6;
6055

6056 6057 6058
	dflt->stable_secret.initialized = false;
	all->stable_secret.initialized = false;

6059 6060 6061 6062
	net->ipv6.devconf_all = all;
	net->ipv6.devconf_dflt = dflt;

#ifdef CONFIG_SYSCTL
6063
	err = __addrconf_sysctl_register(net, "all", NULL, all);
6064 6065 6066
	if (err < 0)
		goto err_reg_all;

6067
	err = __addrconf_sysctl_register(net, "default", NULL, dflt);
6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084
	if (err < 0)
		goto err_reg_dflt;
#endif
	return 0;

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

6085
static void __net_exit addrconf_exit_net(struct net *net)
6086 6087 6088 6089 6090
{
#ifdef CONFIG_SYSCTL
	__addrconf_sysctl_unregister(net->ipv6.devconf_dflt);
	__addrconf_sysctl_unregister(net->ipv6.devconf_all);
#endif
Z
zhuyj 已提交
6091 6092
	kfree(net->ipv6.devconf_dflt);
	kfree(net->ipv6.devconf_all);
6093 6094 6095 6096 6097 6098 6099
}

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

6100
static struct rtnl_af_ops inet6_ops __read_mostly = {
T
Thomas Graf 已提交
6101 6102 6103
	.family		  = AF_INET6,
	.fill_link_af	  = inet6_fill_link_af,
	.get_link_af_size = inet6_get_link_af_size,
6104
	.validate_link_af = inet6_validate_link_af,
6105
	.set_link_af	  = inet6_set_link_af,
T
Thomas Graf 已提交
6106 6107
};

L
Linus Torvalds 已提交
6108 6109 6110 6111 6112 6113
/*
 *	Init / cleanup code
 */

int __init addrconf_init(void)
{
6114
	struct inet6_dev *idev;
6115
	int i, err;
6116

S
Stephen Hemminger 已提交
6117 6118
	err = ipv6_addr_label_init();
	if (err < 0) {
6119 6120
		pr_crit("%s: cannot initialize default policy table: %d\n",
			__func__, err);
6121
		goto out;
6122
	}
L
Linus Torvalds 已提交
6123

6124 6125 6126
	err = register_pernet_subsys(&addrconf_ops);
	if (err < 0)
		goto out_addrlabel;
6127

6128 6129 6130 6131 6132 6133
	addrconf_wq = create_workqueue("ipv6_addrconf");
	if (!addrconf_wq) {
		err = -ENOMEM;
		goto out_nowq;
	}

L
Linus Torvalds 已提交
6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152
	/* The addrconf netdev notifier requires that loopback_dev
	 * has it's ipv6 private information allocated and setup
	 * before it can bring up and give link-local addresses
	 * to other devices which are up.
	 *
	 * Unfortunately, loopback_dev is not necessarily the first
	 * entry in the global dev_base list of net devices.  In fact,
	 * it is likely to be the very last entry on that list.
	 * So this causes the notifier registry below to try and
	 * give link-local addresses to all devices besides loopback_dev
	 * first, then loopback_dev, which cases all the non-loopback_dev
	 * devices to fail to get a link-local address.
	 *
	 * So, as a temporary fix, allocate the ipv6 structure for
	 * loopback_dev first by hand.
	 * Longer term, all of the dependencies ipv6 has upon the loopback
	 * device and it being up should be removed.
	 */
	rtnl_lock();
6153
	idev = ipv6_add_dev(init_net.loopback_dev);
L
Linus Torvalds 已提交
6154
	rtnl_unlock();
6155 6156
	if (IS_ERR(idev)) {
		err = PTR_ERR(idev);
6157
		goto errlo;
6158
	}
L
Linus Torvalds 已提交
6159

6160 6161 6162
	for (i = 0; i < IN6_ADDR_HSIZE; i++)
		INIT_HLIST_HEAD(&inet6_addr_lst[i]);

L
Linus Torvalds 已提交
6163 6164
	register_netdevice_notifier(&ipv6_dev_notf);

6165
	addrconf_verify();
6166

6167
	rtnl_af_register(&inet6_ops);
T
Thomas Graf 已提交
6168

6169 6170
	err = __rtnl_register(PF_INET6, RTM_GETLINK, NULL, inet6_dump_ifinfo,
			      NULL);
6171 6172 6173 6174
	if (err < 0)
		goto errout;

	/* Only the first call to __rtnl_register can fail */
6175 6176 6177 6178 6179 6180 6181 6182
	__rtnl_register(PF_INET6, RTM_NEWADDR, inet6_rtm_newaddr, NULL, NULL);
	__rtnl_register(PF_INET6, RTM_DELADDR, inet6_rtm_deladdr, NULL, NULL);
	__rtnl_register(PF_INET6, RTM_GETADDR, inet6_rtm_getaddr,
			inet6_dump_ifaddr, NULL);
	__rtnl_register(PF_INET6, RTM_GETMULTICAST, NULL,
			inet6_dump_ifmcaddr, NULL);
	__rtnl_register(PF_INET6, RTM_GETANYCAST, NULL,
			inet6_dump_ifacaddr, NULL);
6183
	__rtnl_register(PF_INET6, RTM_GETNETCONF, inet6_netconf_get_devconf,
6184
			inet6_netconf_dump_devconf, NULL);
6185

6186 6187
	ipv6_addr_label_rtnl_register();

L
Linus Torvalds 已提交
6188
	return 0;
6189
errout:
T
Thomas Graf 已提交
6190
	rtnl_af_unregister(&inet6_ops);
6191
	unregister_netdevice_notifier(&ipv6_dev_notf);
6192
errlo:
6193 6194
	destroy_workqueue(addrconf_wq);
out_nowq:
6195
	unregister_pernet_subsys(&addrconf_ops);
6196 6197 6198
out_addrlabel:
	ipv6_addr_label_cleanup();
out:
6199
	return err;
L
Linus Torvalds 已提交
6200 6201
}

6202
void addrconf_cleanup(void)
L
Linus Torvalds 已提交
6203
{
6204
	struct net_device *dev;
L
Linus Torvalds 已提交
6205 6206 6207
	int i;

	unregister_netdevice_notifier(&ipv6_dev_notf);
6208
	unregister_pernet_subsys(&addrconf_ops);
6209
	ipv6_addr_label_cleanup();
L
Linus Torvalds 已提交
6210 6211 6212

	rtnl_lock();

T
Thomas Graf 已提交
6213 6214
	__rtnl_af_unregister(&inet6_ops);

6215 6216 6217 6218 6219 6220 6221 6222
	/* clean dev list */
	for_each_netdev(&init_net, dev) {
		if (__in6_dev_get(dev) == NULL)
			continue;
		addrconf_ifdown(dev, 1);
	}
	addrconf_ifdown(init_net.loopback_dev, 2);

L
Linus Torvalds 已提交
6223 6224 6225
	/*
	 *	Check hash table.
	 */
6226
	spin_lock_bh(&addrconf_hash_lock);
6227 6228
	for (i = 0; i < IN6_ADDR_HSIZE; i++)
		WARN_ON(!hlist_empty(&inet6_addr_lst[i]));
6229
	spin_unlock_bh(&addrconf_hash_lock);
6230
	cancel_delayed_work(&addr_chk_work);
L
Linus Torvalds 已提交
6231
	rtnl_unlock();
6232 6233

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