xref: /openbmc/linux/net/ipv6/addrconf.c (revision 4f672235cb11c49d4be7ac7d505c65e3bd367322)
1 /*
2  *	IPv6 Address [auto]configuration
3  *	Linux INET6 implementation
4  *
5  *	Authors:
6  *	Pedro Roque		<roque@di.fc.ul.pt>
7  *	Alexey Kuznetsov	<kuznet@ms2.inr.ac.ru>
8  *
9  *	This program is free software; you can redistribute it and/or
10  *      modify it under the terms of the GNU General Public License
11  *      as published by the Free Software Foundation; either version
12  *      2 of the License, or (at your option) any later version.
13  */
14 
15 /*
16  *	Changes:
17  *
18  *	Janos Farkas			:	delete timer on ifdown
19  *	<chexum@bankinf.banki.hu>
20  *	Andi Kleen			:	kill double kfree on module
21  *						unload.
22  *	Maciej W. Rozycki		:	FDDI support
23  *	sekiya@USAGI			:	Don't send too many RS
24  *						packets.
25  *	yoshfuji@USAGI			:       Fixed interval between DAD
26  *						packets.
27  *	YOSHIFUJI Hideaki @USAGI	:	improved accuracy of
28  *						address validation timer.
29  *	YOSHIFUJI Hideaki @USAGI	:	Privacy Extensions (RFC3041)
30  *						support.
31  *	Yuji SEKIYA @USAGI		:	Don't assign a same IPv6
32  *						address on a same interface.
33  *	YOSHIFUJI Hideaki @USAGI	:	ARCnet support
34  *	YOSHIFUJI Hideaki @USAGI	:	convert /proc/net/if_inet6 to
35  *						seq_file.
36  *	YOSHIFUJI Hideaki @USAGI	:	improved source address
37  *						selection; consider scope,
38  *						status etc.
39  */
40 
41 #define pr_fmt(fmt) "IPv6: " fmt
42 
43 #include <linux/errno.h>
44 #include <linux/types.h>
45 #include <linux/kernel.h>
46 #include <linux/socket.h>
47 #include <linux/sockios.h>
48 #include <linux/net.h>
49 #include <linux/inet.h>
50 #include <linux/in6.h>
51 #include <linux/netdevice.h>
52 #include <linux/if_addr.h>
53 #include <linux/if_arp.h>
54 #include <linux/if_arcnet.h>
55 #include <linux/if_infiniband.h>
56 #include <linux/route.h>
57 #include <linux/inetdevice.h>
58 #include <linux/init.h>
59 #include <linux/slab.h>
60 #ifdef CONFIG_SYSCTL
61 #include <linux/sysctl.h>
62 #endif
63 #include <linux/capability.h>
64 #include <linux/delay.h>
65 #include <linux/notifier.h>
66 #include <linux/string.h>
67 #include <linux/hash.h>
68 
69 #include <net/net_namespace.h>
70 #include <net/sock.h>
71 #include <net/snmp.h>
72 
73 #include <net/6lowpan.h>
74 #include <net/firewire.h>
75 #include <net/ipv6.h>
76 #include <net/protocol.h>
77 #include <net/ndisc.h>
78 #include <net/ip6_route.h>
79 #include <net/addrconf.h>
80 #include <net/tcp.h>
81 #include <net/ip.h>
82 #include <net/netlink.h>
83 #include <net/pkt_sched.h>
84 #include <net/l3mdev.h>
85 #include <linux/if_tunnel.h>
86 #include <linux/rtnetlink.h>
87 #include <linux/netconf.h>
88 #include <linux/random.h>
89 #include <linux/uaccess.h>
90 #include <asm/unaligned.h>
91 
92 #include <linux/proc_fs.h>
93 #include <linux/seq_file.h>
94 #include <linux/export.h>
95 
96 /* Set to 3 to get tracing... */
97 #define ACONF_DEBUG 2
98 
99 #if ACONF_DEBUG >= 3
100 #define ADBG(fmt, ...) printk(fmt, ##__VA_ARGS__)
101 #else
102 #define ADBG(fmt, ...) do { if (0) printk(fmt, ##__VA_ARGS__); } while (0)
103 #endif
104 
105 #define	INFINITY_LIFE_TIME	0xFFFFFFFF
106 
107 #define IPV6_MAX_STRLEN \
108 	sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")
109 
110 static inline u32 cstamp_delta(unsigned long cstamp)
111 {
112 	return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
113 }
114 
115 #ifdef CONFIG_SYSCTL
116 static int addrconf_sysctl_register(struct inet6_dev *idev);
117 static void addrconf_sysctl_unregister(struct inet6_dev *idev);
118 #else
119 static inline int addrconf_sysctl_register(struct inet6_dev *idev)
120 {
121 	return 0;
122 }
123 
124 static inline void addrconf_sysctl_unregister(struct inet6_dev *idev)
125 {
126 }
127 #endif
128 
129 static void __ipv6_regen_rndid(struct inet6_dev *idev);
130 static void __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr);
131 static void ipv6_regen_rndid(unsigned long data);
132 
133 static int ipv6_generate_eui64(u8 *eui, struct net_device *dev);
134 static int ipv6_count_addresses(struct inet6_dev *idev);
135 static int ipv6_generate_stable_address(struct in6_addr *addr,
136 					u8 dad_count,
137 					const struct inet6_dev *idev);
138 
139 /*
140  *	Configured unicast address hash table
141  */
142 static struct hlist_head inet6_addr_lst[IN6_ADDR_HSIZE];
143 static DEFINE_SPINLOCK(addrconf_hash_lock);
144 
145 static void addrconf_verify(void);
146 static void addrconf_verify_rtnl(void);
147 static void addrconf_verify_work(struct work_struct *);
148 
149 static struct workqueue_struct *addrconf_wq;
150 static DECLARE_DELAYED_WORK(addr_chk_work, addrconf_verify_work);
151 
152 static void addrconf_join_anycast(struct inet6_ifaddr *ifp);
153 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp);
154 
155 static void addrconf_type_change(struct net_device *dev,
156 				 unsigned long event);
157 static int addrconf_ifdown(struct net_device *dev, int how);
158 
159 static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
160 						  int plen,
161 						  const struct net_device *dev,
162 						  u32 flags, u32 noflags);
163 
164 static void addrconf_dad_start(struct inet6_ifaddr *ifp);
165 static void addrconf_dad_work(struct work_struct *w);
166 static void addrconf_dad_completed(struct inet6_ifaddr *ifp);
167 static void addrconf_dad_run(struct inet6_dev *idev);
168 static void addrconf_rs_timer(unsigned long data);
169 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
170 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
171 
172 static void inet6_prefix_notify(int event, struct inet6_dev *idev,
173 				struct prefix_info *pinfo);
174 static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
175 			       struct net_device *dev);
176 
177 static struct ipv6_devconf ipv6_devconf __read_mostly = {
178 	.forwarding		= 0,
179 	.hop_limit		= IPV6_DEFAULT_HOPLIMIT,
180 	.mtu6			= IPV6_MIN_MTU,
181 	.accept_ra		= 1,
182 	.accept_redirects	= 1,
183 	.autoconf		= 1,
184 	.force_mld_version	= 0,
185 	.mldv1_unsolicited_report_interval = 10 * HZ,
186 	.mldv2_unsolicited_report_interval = HZ,
187 	.dad_transmits		= 1,
188 	.rtr_solicits		= MAX_RTR_SOLICITATIONS,
189 	.rtr_solicit_interval	= RTR_SOLICITATION_INTERVAL,
190 	.rtr_solicit_delay	= MAX_RTR_SOLICITATION_DELAY,
191 	.use_tempaddr		= 0,
192 	.temp_valid_lft		= TEMP_VALID_LIFETIME,
193 	.temp_prefered_lft	= TEMP_PREFERRED_LIFETIME,
194 	.regen_max_retry	= REGEN_MAX_RETRY,
195 	.max_desync_factor	= MAX_DESYNC_FACTOR,
196 	.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 #ifdef CONFIG_IPV6_ROUTER_PREF
202 	.accept_ra_rtr_pref	= 1,
203 	.rtr_probe_interval	= 60 * HZ,
204 #ifdef CONFIG_IPV6_ROUTE_INFO
205 	.accept_ra_rt_info_max_plen = 0,
206 #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 	.stable_secret		= {
215 		.initialized = false,
216 	},
217 	.use_oif_addrs_only	= 0,
218 	.ignore_routes_with_linkdown = 0,
219 	.keep_addr_on_down	= 0,
220 };
221 
222 static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = {
223 	.forwarding		= 0,
224 	.hop_limit		= IPV6_DEFAULT_HOPLIMIT,
225 	.mtu6			= IPV6_MIN_MTU,
226 	.accept_ra		= 1,
227 	.accept_redirects	= 1,
228 	.autoconf		= 1,
229 	.force_mld_version	= 0,
230 	.mldv1_unsolicited_report_interval = 10 * HZ,
231 	.mldv2_unsolicited_report_interval = HZ,
232 	.dad_transmits		= 1,
233 	.rtr_solicits		= MAX_RTR_SOLICITATIONS,
234 	.rtr_solicit_interval	= RTR_SOLICITATION_INTERVAL,
235 	.rtr_solicit_delay	= MAX_RTR_SOLICITATION_DELAY,
236 	.use_tempaddr		= 0,
237 	.temp_valid_lft		= TEMP_VALID_LIFETIME,
238 	.temp_prefered_lft	= TEMP_PREFERRED_LIFETIME,
239 	.regen_max_retry	= REGEN_MAX_RETRY,
240 	.max_desync_factor	= MAX_DESYNC_FACTOR,
241 	.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 #ifdef CONFIG_IPV6_ROUTER_PREF
247 	.accept_ra_rtr_pref	= 1,
248 	.rtr_probe_interval	= 60 * HZ,
249 #ifdef CONFIG_IPV6_ROUTE_INFO
250 	.accept_ra_rt_info_max_plen = 0,
251 #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 	.stable_secret		= {
260 		.initialized = false,
261 	},
262 	.use_oif_addrs_only	= 0,
263 	.ignore_routes_with_linkdown = 0,
264 	.keep_addr_on_down	= 0,
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)
274 {
275 	if (del_timer(&idev->rs_timer))
276 		__in6_dev_put(idev);
277 }
278 
279 static void addrconf_del_dad_work(struct inet6_ifaddr *ifp)
280 {
281 	if (cancel_delayed_work(&ifp->dad_work))
282 		__in6_ifa_put(ifp);
283 }
284 
285 static void addrconf_mod_rs_timer(struct inet6_dev *idev,
286 				  unsigned long when)
287 {
288 	if (!timer_pending(&idev->rs_timer))
289 		in6_dev_hold(idev);
290 	mod_timer(&idev->rs_timer, jiffies + when);
291 }
292 
293 static void addrconf_mod_dad_work(struct inet6_ifaddr *ifp,
294 				   unsigned long delay)
295 {
296 	if (!delayed_work_pending(&ifp->dad_work))
297 		in6_ifa_hold(ifp);
298 	mod_delayed_work(addrconf_wq, &ifp->dad_work, delay);
299 }
300 
301 static int snmp6_alloc_dev(struct inet6_dev *idev)
302 {
303 	int i;
304 
305 	idev->stats.ipv6 = alloc_percpu(struct ipstats_mib);
306 	if (!idev->stats.ipv6)
307 		goto err_ip;
308 
309 	for_each_possible_cpu(i) {
310 		struct ipstats_mib *addrconf_stats;
311 		addrconf_stats = per_cpu_ptr(idev->stats.ipv6, i);
312 		u64_stats_init(&addrconf_stats->syncp);
313 	}
314 
315 
316 	idev->stats.icmpv6dev = kzalloc(sizeof(struct icmpv6_mib_device),
317 					GFP_KERNEL);
318 	if (!idev->stats.icmpv6dev)
319 		goto err_icmp;
320 	idev->stats.icmpv6msgdev = kzalloc(sizeof(struct icmpv6msg_mib_device),
321 					   GFP_KERNEL);
322 	if (!idev->stats.icmpv6msgdev)
323 		goto err_icmpmsg;
324 
325 	return 0;
326 
327 err_icmpmsg:
328 	kfree(idev->stats.icmpv6dev);
329 err_icmp:
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)
336 {
337 	struct inet6_dev *ndev;
338 	int err = -ENOMEM;
339 
340 	ASSERT_RTNL();
341 
342 	if (dev->mtu < IPV6_MIN_MTU)
343 		return ERR_PTR(-EINVAL);
344 
345 	ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL);
346 	if (!ndev)
347 		return ERR_PTR(err);
348 
349 	rwlock_init(&ndev->lock);
350 	ndev->dev = dev;
351 	INIT_LIST_HEAD(&ndev->addr_list);
352 	setup_timer(&ndev->rs_timer, addrconf_rs_timer,
353 		    (unsigned long)ndev);
354 	memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf));
355 
356 	if (ndev->cnf.stable_secret.initialized)
357 		ndev->addr_gen_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
358 	else
359 		ndev->addr_gen_mode = IN6_ADDR_GEN_MODE_EUI64;
360 
361 	ndev->cnf.mtu6 = dev->mtu;
362 	ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
363 	if (!ndev->nd_parms) {
364 		kfree(ndev);
365 		return ERR_PTR(err);
366 	}
367 	if (ndev->cnf.forwarding)
368 		dev_disable_lro(dev);
369 	/* We refer to the device */
370 	dev_hold(dev);
371 
372 	if (snmp6_alloc_dev(ndev) < 0) {
373 		ADBG(KERN_WARNING
374 			"%s: cannot allocate memory for statistics; dev=%s.\n",
375 			__func__, dev->name);
376 		neigh_parms_release(&nd_tbl, ndev->nd_parms);
377 		dev_put(dev);
378 		kfree(ndev);
379 		return ERR_PTR(err);
380 	}
381 
382 	if (snmp6_register_dev(ndev) < 0) {
383 		ADBG(KERN_WARNING
384 			"%s: cannot create /proc/net/dev_snmp6/%s\n",
385 			__func__, dev->name);
386 		goto err_release;
387 	}
388 
389 	/* One reference from device.  We must do this before
390 	 * we invoke __ipv6_regen_rndid().
391 	 */
392 	in6_dev_hold(ndev);
393 
394 	if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
395 		ndev->cnf.accept_dad = -1;
396 
397 #if IS_ENABLED(CONFIG_IPV6_SIT)
398 	if (dev->type == ARPHRD_SIT && (dev->priv_flags & IFF_ISATAP)) {
399 		pr_info("%s: Disabled Multicast RS\n", dev->name);
400 		ndev->cnf.rtr_solicits = 0;
401 	}
402 #endif
403 
404 	INIT_LIST_HEAD(&ndev->tempaddr_list);
405 	setup_timer(&ndev->regen_timer, ipv6_regen_rndid, (unsigned long)ndev);
406 	if ((dev->flags&IFF_LOOPBACK) ||
407 	    dev->type == ARPHRD_TUNNEL ||
408 	    dev->type == ARPHRD_TUNNEL6 ||
409 	    dev->type == ARPHRD_SIT ||
410 	    dev->type == ARPHRD_NONE) {
411 		ndev->cnf.use_tempaddr = -1;
412 	} else {
413 		in6_dev_hold(ndev);
414 		ipv6_regen_rndid((unsigned long) ndev);
415 	}
416 
417 	ndev->token = in6addr_any;
418 
419 	if (netif_running(dev) && addrconf_qdisc_ok(dev))
420 		ndev->if_flags |= IF_READY;
421 
422 	ipv6_mc_init_dev(ndev);
423 	ndev->tstamp = jiffies;
424 	err = addrconf_sysctl_register(ndev);
425 	if (err) {
426 		ipv6_mc_destroy_dev(ndev);
427 		del_timer(&ndev->regen_timer);
428 		snmp6_unregister_dev(ndev);
429 		goto err_release;
430 	}
431 	/* protected by rtnl_lock */
432 	rcu_assign_pointer(dev->ip6_ptr, ndev);
433 
434 	/* Join interface-local all-node multicast group */
435 	ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allnodes);
436 
437 	/* Join all-node multicast group */
438 	ipv6_dev_mc_inc(dev, &in6addr_linklocal_allnodes);
439 
440 	/* Join all-router multicast group if forwarding is set */
441 	if (ndev->cnf.forwarding && (dev->flags & IFF_MULTICAST))
442 		ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
443 
444 	return ndev;
445 
446 err_release:
447 	neigh_parms_release(&nd_tbl, ndev->nd_parms);
448 	ndev->dead = 1;
449 	in6_dev_finish_destroy(ndev);
450 	return ERR_PTR(err);
451 }
452 
453 static struct inet6_dev *ipv6_find_idev(struct net_device *dev)
454 {
455 	struct inet6_dev *idev;
456 
457 	ASSERT_RTNL();
458 
459 	idev = __in6_dev_get(dev);
460 	if (!idev) {
461 		idev = ipv6_add_dev(dev);
462 		if (IS_ERR(idev))
463 			return NULL;
464 	}
465 
466 	if (dev->flags&IFF_UP)
467 		ipv6_mc_up(idev);
468 	return idev;
469 }
470 
471 static int inet6_netconf_msgsize_devconf(int type)
472 {
473 	int size =  NLMSG_ALIGN(sizeof(struct netconfmsg))
474 		    + nla_total_size(4);	/* NETCONFA_IFINDEX */
475 	bool all = false;
476 
477 	if (type == NETCONFA_ALL)
478 		all = true;
479 
480 	if (all || type == NETCONFA_FORWARDING)
481 		size += nla_total_size(4);
482 #ifdef CONFIG_IPV6_MROUTE
483 	if (all || type == NETCONFA_MC_FORWARDING)
484 		size += nla_total_size(4);
485 #endif
486 	if (all || type == NETCONFA_PROXY_NEIGH)
487 		size += nla_total_size(4);
488 
489 	if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
490 		size += nla_total_size(4);
491 
492 	return size;
493 }
494 
495 static int inet6_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
496 				      struct ipv6_devconf *devconf, u32 portid,
497 				      u32 seq, int event, unsigned int flags,
498 				      int type)
499 {
500 	struct nlmsghdr  *nlh;
501 	struct netconfmsg *ncm;
502 	bool all = false;
503 
504 	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
505 			flags);
506 	if (!nlh)
507 		return -EMSGSIZE;
508 
509 	if (type == NETCONFA_ALL)
510 		all = true;
511 
512 	ncm = nlmsg_data(nlh);
513 	ncm->ncm_family = AF_INET6;
514 
515 	if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
516 		goto nla_put_failure;
517 
518 	if ((all || type == NETCONFA_FORWARDING) &&
519 	    nla_put_s32(skb, NETCONFA_FORWARDING, devconf->forwarding) < 0)
520 		goto nla_put_failure;
521 #ifdef CONFIG_IPV6_MROUTE
522 	if ((all || type == NETCONFA_MC_FORWARDING) &&
523 	    nla_put_s32(skb, NETCONFA_MC_FORWARDING,
524 			devconf->mc_forwarding) < 0)
525 		goto nla_put_failure;
526 #endif
527 	if ((all || type == NETCONFA_PROXY_NEIGH) &&
528 	    nla_put_s32(skb, NETCONFA_PROXY_NEIGH, devconf->proxy_ndp) < 0)
529 		goto nla_put_failure;
530 
531 	if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
532 	    nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
533 			devconf->ignore_routes_with_linkdown) < 0)
534 		goto nla_put_failure;
535 
536 	nlmsg_end(skb, nlh);
537 	return 0;
538 
539 nla_put_failure:
540 	nlmsg_cancel(skb, nlh);
541 	return -EMSGSIZE;
542 }
543 
544 void inet6_netconf_notify_devconf(struct net *net, int type, int ifindex,
545 				  struct ipv6_devconf *devconf)
546 {
547 	struct sk_buff *skb;
548 	int err = -ENOBUFS;
549 
550 	skb = nlmsg_new(inet6_netconf_msgsize_devconf(type), GFP_ATOMIC);
551 	if (!skb)
552 		goto errout;
553 
554 	err = inet6_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
555 					 RTM_NEWNETCONF, 0, type);
556 	if (err < 0) {
557 		/* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */
558 		WARN_ON(err == -EMSGSIZE);
559 		kfree_skb(skb);
560 		goto errout;
561 	}
562 	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_NETCONF, NULL, GFP_ATOMIC);
563 	return;
564 errout:
565 	rtnl_set_sk_err(net, RTNLGRP_IPV6_NETCONF, err);
566 }
567 
568 static const struct nla_policy devconf_ipv6_policy[NETCONFA_MAX+1] = {
569 	[NETCONFA_IFINDEX]	= { .len = sizeof(int) },
570 	[NETCONFA_FORWARDING]	= { .len = sizeof(int) },
571 	[NETCONFA_PROXY_NEIGH]	= { .len = sizeof(int) },
572 	[NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN]	= { .len = sizeof(int) },
573 };
574 
575 static int inet6_netconf_get_devconf(struct sk_buff *in_skb,
576 				     struct nlmsghdr *nlh)
577 {
578 	struct net *net = sock_net(in_skb->sk);
579 	struct nlattr *tb[NETCONFA_MAX+1];
580 	struct netconfmsg *ncm;
581 	struct sk_buff *skb;
582 	struct ipv6_devconf *devconf;
583 	struct inet6_dev *in6_dev;
584 	struct net_device *dev;
585 	int ifindex;
586 	int err;
587 
588 	err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
589 			  devconf_ipv6_policy);
590 	if (err < 0)
591 		goto errout;
592 
593 	err = -EINVAL;
594 	if (!tb[NETCONFA_IFINDEX])
595 		goto errout;
596 
597 	ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
598 	switch (ifindex) {
599 	case NETCONFA_IFINDEX_ALL:
600 		devconf = net->ipv6.devconf_all;
601 		break;
602 	case NETCONFA_IFINDEX_DEFAULT:
603 		devconf = net->ipv6.devconf_dflt;
604 		break;
605 	default:
606 		dev = __dev_get_by_index(net, ifindex);
607 		if (!dev)
608 			goto errout;
609 		in6_dev = __in6_dev_get(dev);
610 		if (!in6_dev)
611 			goto errout;
612 		devconf = &in6_dev->cnf;
613 		break;
614 	}
615 
616 	err = -ENOBUFS;
617 	skb = nlmsg_new(inet6_netconf_msgsize_devconf(NETCONFA_ALL), GFP_ATOMIC);
618 	if (!skb)
619 		goto errout;
620 
621 	err = inet6_netconf_fill_devconf(skb, ifindex, devconf,
622 					 NETLINK_CB(in_skb).portid,
623 					 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
624 					 NETCONFA_ALL);
625 	if (err < 0) {
626 		/* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */
627 		WARN_ON(err == -EMSGSIZE);
628 		kfree_skb(skb);
629 		goto errout;
630 	}
631 	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
632 errout:
633 	return err;
634 }
635 
636 static int inet6_netconf_dump_devconf(struct sk_buff *skb,
637 				      struct netlink_callback *cb)
638 {
639 	struct net *net = sock_net(skb->sk);
640 	int h, s_h;
641 	int idx, s_idx;
642 	struct net_device *dev;
643 	struct inet6_dev *idev;
644 	struct hlist_head *head;
645 
646 	s_h = cb->args[0];
647 	s_idx = idx = cb->args[1];
648 
649 	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
650 		idx = 0;
651 		head = &net->dev_index_head[h];
652 		rcu_read_lock();
653 		cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^
654 			  net->dev_base_seq;
655 		hlist_for_each_entry_rcu(dev, head, index_hlist) {
656 			if (idx < s_idx)
657 				goto cont;
658 			idev = __in6_dev_get(dev);
659 			if (!idev)
660 				goto cont;
661 
662 			if (inet6_netconf_fill_devconf(skb, dev->ifindex,
663 						       &idev->cnf,
664 						       NETLINK_CB(cb->skb).portid,
665 						       cb->nlh->nlmsg_seq,
666 						       RTM_NEWNETCONF,
667 						       NLM_F_MULTI,
668 						       NETCONFA_ALL) < 0) {
669 				rcu_read_unlock();
670 				goto done;
671 			}
672 			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
673 cont:
674 			idx++;
675 		}
676 		rcu_read_unlock();
677 	}
678 	if (h == NETDEV_HASHENTRIES) {
679 		if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
680 					       net->ipv6.devconf_all,
681 					       NETLINK_CB(cb->skb).portid,
682 					       cb->nlh->nlmsg_seq,
683 					       RTM_NEWNETCONF, NLM_F_MULTI,
684 					       NETCONFA_ALL) < 0)
685 			goto done;
686 		else
687 			h++;
688 	}
689 	if (h == NETDEV_HASHENTRIES + 1) {
690 		if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
691 					       net->ipv6.devconf_dflt,
692 					       NETLINK_CB(cb->skb).portid,
693 					       cb->nlh->nlmsg_seq,
694 					       RTM_NEWNETCONF, NLM_F_MULTI,
695 					       NETCONFA_ALL) < 0)
696 			goto done;
697 		else
698 			h++;
699 	}
700 done:
701 	cb->args[0] = h;
702 	cb->args[1] = idx;
703 
704 	return skb->len;
705 }
706 
707 #ifdef CONFIG_SYSCTL
708 static void dev_forward_change(struct inet6_dev *idev)
709 {
710 	struct net_device *dev;
711 	struct inet6_ifaddr *ifa;
712 
713 	if (!idev)
714 		return;
715 	dev = idev->dev;
716 	if (idev->cnf.forwarding)
717 		dev_disable_lro(dev);
718 	if (dev->flags & IFF_MULTICAST) {
719 		if (idev->cnf.forwarding) {
720 			ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
721 			ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allrouters);
722 			ipv6_dev_mc_inc(dev, &in6addr_sitelocal_allrouters);
723 		} else {
724 			ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters);
725 			ipv6_dev_mc_dec(dev, &in6addr_interfacelocal_allrouters);
726 			ipv6_dev_mc_dec(dev, &in6addr_sitelocal_allrouters);
727 		}
728 	}
729 
730 	list_for_each_entry(ifa, &idev->addr_list, if_list) {
731 		if (ifa->flags&IFA_F_TENTATIVE)
732 			continue;
733 		if (idev->cnf.forwarding)
734 			addrconf_join_anycast(ifa);
735 		else
736 			addrconf_leave_anycast(ifa);
737 	}
738 	inet6_netconf_notify_devconf(dev_net(dev), NETCONFA_FORWARDING,
739 				     dev->ifindex, &idev->cnf);
740 }
741 
742 
743 static void addrconf_forward_change(struct net *net, __s32 newf)
744 {
745 	struct net_device *dev;
746 	struct inet6_dev *idev;
747 
748 	for_each_netdev(net, dev) {
749 		idev = __in6_dev_get(dev);
750 		if (idev) {
751 			int changed = (!idev->cnf.forwarding) ^ (!newf);
752 			idev->cnf.forwarding = newf;
753 			if (changed)
754 				dev_forward_change(idev);
755 		}
756 	}
757 }
758 
759 static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int newf)
760 {
761 	struct net *net;
762 	int old;
763 
764 	if (!rtnl_trylock())
765 		return restart_syscall();
766 
767 	net = (struct net *)table->extra2;
768 	old = *p;
769 	*p = newf;
770 
771 	if (p == &net->ipv6.devconf_dflt->forwarding) {
772 		if ((!newf) ^ (!old))
773 			inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING,
774 						     NETCONFA_IFINDEX_DEFAULT,
775 						     net->ipv6.devconf_dflt);
776 		rtnl_unlock();
777 		return 0;
778 	}
779 
780 	if (p == &net->ipv6.devconf_all->forwarding) {
781 		net->ipv6.devconf_dflt->forwarding = newf;
782 		addrconf_forward_change(net, newf);
783 		if ((!newf) ^ (!old))
784 			inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING,
785 						     NETCONFA_IFINDEX_ALL,
786 						     net->ipv6.devconf_all);
787 	} else if ((!newf) ^ (!old))
788 		dev_forward_change((struct inet6_dev *)table->extra1);
789 	rtnl_unlock();
790 
791 	if (newf)
792 		rt6_purge_dflt_routers(net);
793 	return 1;
794 }
795 
796 static void addrconf_linkdown_change(struct net *net, __s32 newf)
797 {
798 	struct net_device *dev;
799 	struct inet6_dev *idev;
800 
801 	for_each_netdev(net, dev) {
802 		idev = __in6_dev_get(dev);
803 		if (idev) {
804 			int changed = (!idev->cnf.ignore_routes_with_linkdown) ^ (!newf);
805 
806 			idev->cnf.ignore_routes_with_linkdown = newf;
807 			if (changed)
808 				inet6_netconf_notify_devconf(dev_net(dev),
809 							     NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
810 							     dev->ifindex,
811 							     &idev->cnf);
812 		}
813 	}
814 }
815 
816 static int addrconf_fixup_linkdown(struct ctl_table *table, int *p, int newf)
817 {
818 	struct net *net;
819 	int old;
820 
821 	if (!rtnl_trylock())
822 		return restart_syscall();
823 
824 	net = (struct net *)table->extra2;
825 	old = *p;
826 	*p = newf;
827 
828 	if (p == &net->ipv6.devconf_dflt->ignore_routes_with_linkdown) {
829 		if ((!newf) ^ (!old))
830 			inet6_netconf_notify_devconf(net,
831 						     NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
832 						     NETCONFA_IFINDEX_DEFAULT,
833 						     net->ipv6.devconf_dflt);
834 		rtnl_unlock();
835 		return 0;
836 	}
837 
838 	if (p == &net->ipv6.devconf_all->ignore_routes_with_linkdown) {
839 		net->ipv6.devconf_dflt->ignore_routes_with_linkdown = newf;
840 		addrconf_linkdown_change(net, newf);
841 		if ((!newf) ^ (!old))
842 			inet6_netconf_notify_devconf(net,
843 						     NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
844 						     NETCONFA_IFINDEX_ALL,
845 						     net->ipv6.devconf_all);
846 	}
847 	rtnl_unlock();
848 
849 	return 1;
850 }
851 
852 #endif
853 
854 /* Nobody refers to this ifaddr, destroy it */
855 void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
856 {
857 	WARN_ON(!hlist_unhashed(&ifp->addr_lst));
858 
859 #ifdef NET_REFCNT_DEBUG
860 	pr_debug("%s\n", __func__);
861 #endif
862 
863 	in6_dev_put(ifp->idev);
864 
865 	if (cancel_delayed_work(&ifp->dad_work))
866 		pr_notice("delayed DAD work was pending while freeing ifa=%p\n",
867 			  ifp);
868 
869 	if (ifp->state != INET6_IFADDR_STATE_DEAD) {
870 		pr_warn("Freeing alive inet6 address %p\n", ifp);
871 		return;
872 	}
873 	ip6_rt_put(ifp->rt);
874 
875 	kfree_rcu(ifp, rcu);
876 }
877 
878 static void
879 ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp)
880 {
881 	struct list_head *p;
882 	int ifp_scope = ipv6_addr_src_scope(&ifp->addr);
883 
884 	/*
885 	 * Each device address list is sorted in order of scope -
886 	 * global before linklocal.
887 	 */
888 	list_for_each(p, &idev->addr_list) {
889 		struct inet6_ifaddr *ifa
890 			= list_entry(p, struct inet6_ifaddr, if_list);
891 		if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr))
892 			break;
893 	}
894 
895 	list_add_tail(&ifp->if_list, p);
896 }
897 
898 static u32 inet6_addr_hash(const struct in6_addr *addr)
899 {
900 	return hash_32(ipv6_addr_hash(addr), IN6_ADDR_HSIZE_SHIFT);
901 }
902 
903 /* On success it returns ifp with increased reference count */
904 
905 static struct inet6_ifaddr *
906 ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
907 	      const struct in6_addr *peer_addr, int pfxlen,
908 	      int scope, u32 flags, u32 valid_lft, u32 prefered_lft)
909 {
910 	struct inet6_ifaddr *ifa = NULL;
911 	struct rt6_info *rt;
912 	unsigned int hash;
913 	int err = 0;
914 	int addr_type = ipv6_addr_type(addr);
915 
916 	if (addr_type == IPV6_ADDR_ANY ||
917 	    addr_type & IPV6_ADDR_MULTICAST ||
918 	    (!(idev->dev->flags & IFF_LOOPBACK) &&
919 	     addr_type & IPV6_ADDR_LOOPBACK))
920 		return ERR_PTR(-EADDRNOTAVAIL);
921 
922 	rcu_read_lock_bh();
923 	if (idev->dead) {
924 		err = -ENODEV;			/*XXX*/
925 		goto out2;
926 	}
927 
928 	if (idev->cnf.disable_ipv6) {
929 		err = -EACCES;
930 		goto out2;
931 	}
932 
933 	spin_lock(&addrconf_hash_lock);
934 
935 	/* Ignore adding duplicate addresses on an interface */
936 	if (ipv6_chk_same_addr(dev_net(idev->dev), addr, idev->dev)) {
937 		ADBG("ipv6_add_addr: already assigned\n");
938 		err = -EEXIST;
939 		goto out;
940 	}
941 
942 	ifa = kzalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC);
943 
944 	if (!ifa) {
945 		ADBG("ipv6_add_addr: malloc failed\n");
946 		err = -ENOBUFS;
947 		goto out;
948 	}
949 
950 	rt = addrconf_dst_alloc(idev, addr, false);
951 	if (IS_ERR(rt)) {
952 		err = PTR_ERR(rt);
953 		goto out;
954 	}
955 
956 	neigh_parms_data_state_setall(idev->nd_parms);
957 
958 	ifa->addr = *addr;
959 	if (peer_addr)
960 		ifa->peer_addr = *peer_addr;
961 
962 	spin_lock_init(&ifa->lock);
963 	INIT_DELAYED_WORK(&ifa->dad_work, addrconf_dad_work);
964 	INIT_HLIST_NODE(&ifa->addr_lst);
965 	ifa->scope = scope;
966 	ifa->prefix_len = pfxlen;
967 	ifa->flags = flags | IFA_F_TENTATIVE;
968 	ifa->valid_lft = valid_lft;
969 	ifa->prefered_lft = prefered_lft;
970 	ifa->cstamp = ifa->tstamp = jiffies;
971 	ifa->tokenized = false;
972 
973 	ifa->rt = rt;
974 
975 	ifa->idev = idev;
976 	in6_dev_hold(idev);
977 	/* For caller */
978 	in6_ifa_hold(ifa);
979 
980 	/* Add to big hash table */
981 	hash = inet6_addr_hash(addr);
982 
983 	hlist_add_head_rcu(&ifa->addr_lst, &inet6_addr_lst[hash]);
984 	spin_unlock(&addrconf_hash_lock);
985 
986 	write_lock(&idev->lock);
987 	/* Add to inet6_dev unicast addr list. */
988 	ipv6_link_dev_addr(idev, ifa);
989 
990 	if (ifa->flags&IFA_F_TEMPORARY) {
991 		list_add(&ifa->tmp_list, &idev->tempaddr_list);
992 		in6_ifa_hold(ifa);
993 	}
994 
995 	in6_ifa_hold(ifa);
996 	write_unlock(&idev->lock);
997 out2:
998 	rcu_read_unlock_bh();
999 
1000 	if (likely(err == 0))
1001 		inet6addr_notifier_call_chain(NETDEV_UP, ifa);
1002 	else {
1003 		kfree(ifa);
1004 		ifa = ERR_PTR(err);
1005 	}
1006 
1007 	return ifa;
1008 out:
1009 	spin_unlock(&addrconf_hash_lock);
1010 	goto out2;
1011 }
1012 
1013 enum cleanup_prefix_rt_t {
1014 	CLEANUP_PREFIX_RT_NOP,    /* no cleanup action for prefix route */
1015 	CLEANUP_PREFIX_RT_DEL,    /* delete the prefix route */
1016 	CLEANUP_PREFIX_RT_EXPIRE, /* update the lifetime of the prefix route */
1017 };
1018 
1019 /*
1020  * Check, whether the prefix for ifp would still need a prefix route
1021  * after deleting ifp. The function returns one of the CLEANUP_PREFIX_RT_*
1022  * constants.
1023  *
1024  * 1) we don't purge prefix if address was not permanent.
1025  *    prefix is managed by its own lifetime.
1026  * 2) we also don't purge, if the address was IFA_F_NOPREFIXROUTE.
1027  * 3) if there are no addresses, delete prefix.
1028  * 4) if there are still other permanent address(es),
1029  *    corresponding prefix is still permanent.
1030  * 5) if there are still other addresses with IFA_F_NOPREFIXROUTE,
1031  *    don't purge the prefix, assume user space is managing it.
1032  * 6) otherwise, update prefix lifetime to the
1033  *    longest valid lifetime among the corresponding
1034  *    addresses on the device.
1035  *    Note: subsequent RA will update lifetime.
1036  **/
1037 static enum cleanup_prefix_rt_t
1038 check_cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long *expires)
1039 {
1040 	struct inet6_ifaddr *ifa;
1041 	struct inet6_dev *idev = ifp->idev;
1042 	unsigned long lifetime;
1043 	enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_DEL;
1044 
1045 	*expires = jiffies;
1046 
1047 	list_for_each_entry(ifa, &idev->addr_list, if_list) {
1048 		if (ifa == ifp)
1049 			continue;
1050 		if (!ipv6_prefix_equal(&ifa->addr, &ifp->addr,
1051 				       ifp->prefix_len))
1052 			continue;
1053 		if (ifa->flags & (IFA_F_PERMANENT | IFA_F_NOPREFIXROUTE))
1054 			return CLEANUP_PREFIX_RT_NOP;
1055 
1056 		action = CLEANUP_PREFIX_RT_EXPIRE;
1057 
1058 		spin_lock(&ifa->lock);
1059 
1060 		lifetime = addrconf_timeout_fixup(ifa->valid_lft, HZ);
1061 		/*
1062 		 * Note: Because this address is
1063 		 * not permanent, lifetime <
1064 		 * LONG_MAX / HZ here.
1065 		 */
1066 		if (time_before(*expires, ifa->tstamp + lifetime * HZ))
1067 			*expires = ifa->tstamp + lifetime * HZ;
1068 		spin_unlock(&ifa->lock);
1069 	}
1070 
1071 	return action;
1072 }
1073 
1074 static void
1075 cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long expires, bool del_rt)
1076 {
1077 	struct rt6_info *rt;
1078 
1079 	rt = addrconf_get_prefix_route(&ifp->addr,
1080 				       ifp->prefix_len,
1081 				       ifp->idev->dev,
1082 				       0, RTF_GATEWAY | RTF_DEFAULT);
1083 	if (rt) {
1084 		if (del_rt)
1085 			ip6_del_rt(rt);
1086 		else {
1087 			if (!(rt->rt6i_flags & RTF_EXPIRES))
1088 				rt6_set_expires(rt, expires);
1089 			ip6_rt_put(rt);
1090 		}
1091 	}
1092 }
1093 
1094 
1095 /* This function wants to get referenced ifp and releases it before return */
1096 
1097 static void ipv6_del_addr(struct inet6_ifaddr *ifp)
1098 {
1099 	int state;
1100 	enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_NOP;
1101 	unsigned long expires;
1102 
1103 	ASSERT_RTNL();
1104 
1105 	spin_lock_bh(&ifp->lock);
1106 	state = ifp->state;
1107 	ifp->state = INET6_IFADDR_STATE_DEAD;
1108 	spin_unlock_bh(&ifp->lock);
1109 
1110 	if (state == INET6_IFADDR_STATE_DEAD)
1111 		goto out;
1112 
1113 	spin_lock_bh(&addrconf_hash_lock);
1114 	hlist_del_init_rcu(&ifp->addr_lst);
1115 	spin_unlock_bh(&addrconf_hash_lock);
1116 
1117 	write_lock_bh(&ifp->idev->lock);
1118 
1119 	if (ifp->flags&IFA_F_TEMPORARY) {
1120 		list_del(&ifp->tmp_list);
1121 		if (ifp->ifpub) {
1122 			in6_ifa_put(ifp->ifpub);
1123 			ifp->ifpub = NULL;
1124 		}
1125 		__in6_ifa_put(ifp);
1126 	}
1127 
1128 	if (ifp->flags & IFA_F_PERMANENT && !(ifp->flags & IFA_F_NOPREFIXROUTE))
1129 		action = check_cleanup_prefix_route(ifp, &expires);
1130 
1131 	list_del_init(&ifp->if_list);
1132 	__in6_ifa_put(ifp);
1133 
1134 	write_unlock_bh(&ifp->idev->lock);
1135 
1136 	addrconf_del_dad_work(ifp);
1137 
1138 	ipv6_ifa_notify(RTM_DELADDR, ifp);
1139 
1140 	inet6addr_notifier_call_chain(NETDEV_DOWN, ifp);
1141 
1142 	if (action != CLEANUP_PREFIX_RT_NOP) {
1143 		cleanup_prefix_route(ifp, expires,
1144 			action == CLEANUP_PREFIX_RT_DEL);
1145 	}
1146 
1147 	/* clean up prefsrc entries */
1148 	rt6_remove_prefsrc(ifp);
1149 out:
1150 	in6_ifa_put(ifp);
1151 }
1152 
1153 static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, struct inet6_ifaddr *ift)
1154 {
1155 	struct inet6_dev *idev = ifp->idev;
1156 	struct in6_addr addr, *tmpaddr;
1157 	unsigned long tmp_prefered_lft, tmp_valid_lft, tmp_tstamp, age;
1158 	unsigned long regen_advance;
1159 	int tmp_plen;
1160 	int ret = 0;
1161 	u32 addr_flags;
1162 	unsigned long now = jiffies;
1163 
1164 	write_lock_bh(&idev->lock);
1165 	if (ift) {
1166 		spin_lock_bh(&ift->lock);
1167 		memcpy(&addr.s6_addr[8], &ift->addr.s6_addr[8], 8);
1168 		spin_unlock_bh(&ift->lock);
1169 		tmpaddr = &addr;
1170 	} else {
1171 		tmpaddr = NULL;
1172 	}
1173 retry:
1174 	in6_dev_hold(idev);
1175 	if (idev->cnf.use_tempaddr <= 0) {
1176 		write_unlock_bh(&idev->lock);
1177 		pr_info("%s: use_tempaddr is disabled\n", __func__);
1178 		in6_dev_put(idev);
1179 		ret = -1;
1180 		goto out;
1181 	}
1182 	spin_lock_bh(&ifp->lock);
1183 	if (ifp->regen_count++ >= idev->cnf.regen_max_retry) {
1184 		idev->cnf.use_tempaddr = -1;	/*XXX*/
1185 		spin_unlock_bh(&ifp->lock);
1186 		write_unlock_bh(&idev->lock);
1187 		pr_warn("%s: regeneration time exceeded - disabled temporary address support\n",
1188 			__func__);
1189 		in6_dev_put(idev);
1190 		ret = -1;
1191 		goto out;
1192 	}
1193 	in6_ifa_hold(ifp);
1194 	memcpy(addr.s6_addr, ifp->addr.s6_addr, 8);
1195 	__ipv6_try_regen_rndid(idev, tmpaddr);
1196 	memcpy(&addr.s6_addr[8], idev->rndid, 8);
1197 	age = (now - ifp->tstamp) / HZ;
1198 	tmp_valid_lft = min_t(__u32,
1199 			      ifp->valid_lft,
1200 			      idev->cnf.temp_valid_lft + age);
1201 	tmp_prefered_lft = min_t(__u32,
1202 				 ifp->prefered_lft,
1203 				 idev->cnf.temp_prefered_lft + age -
1204 				 idev->cnf.max_desync_factor);
1205 	tmp_plen = ifp->prefix_len;
1206 	tmp_tstamp = ifp->tstamp;
1207 	spin_unlock_bh(&ifp->lock);
1208 
1209 	regen_advance = idev->cnf.regen_max_retry *
1210 			idev->cnf.dad_transmits *
1211 			NEIGH_VAR(idev->nd_parms, RETRANS_TIME) / HZ;
1212 	write_unlock_bh(&idev->lock);
1213 
1214 	/* A temporary address is created only if this calculated Preferred
1215 	 * Lifetime is greater than REGEN_ADVANCE time units.  In particular,
1216 	 * an implementation must not create a temporary address with a zero
1217 	 * Preferred Lifetime.
1218 	 * Use age calculation as in addrconf_verify to avoid unnecessary
1219 	 * temporary addresses being generated.
1220 	 */
1221 	age = (now - tmp_tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
1222 	if (tmp_prefered_lft <= regen_advance + age) {
1223 		in6_ifa_put(ifp);
1224 		in6_dev_put(idev);
1225 		ret = -1;
1226 		goto out;
1227 	}
1228 
1229 	addr_flags = IFA_F_TEMPORARY;
1230 	/* set in addrconf_prefix_rcv() */
1231 	if (ifp->flags & IFA_F_OPTIMISTIC)
1232 		addr_flags |= IFA_F_OPTIMISTIC;
1233 
1234 	ift = ipv6_add_addr(idev, &addr, NULL, tmp_plen,
1235 			    ipv6_addr_scope(&addr), addr_flags,
1236 			    tmp_valid_lft, tmp_prefered_lft);
1237 	if (IS_ERR(ift)) {
1238 		in6_ifa_put(ifp);
1239 		in6_dev_put(idev);
1240 		pr_info("%s: retry temporary address regeneration\n", __func__);
1241 		tmpaddr = &addr;
1242 		write_lock_bh(&idev->lock);
1243 		goto retry;
1244 	}
1245 
1246 	spin_lock_bh(&ift->lock);
1247 	ift->ifpub = ifp;
1248 	ift->cstamp = now;
1249 	ift->tstamp = tmp_tstamp;
1250 	spin_unlock_bh(&ift->lock);
1251 
1252 	addrconf_dad_start(ift);
1253 	in6_ifa_put(ift);
1254 	in6_dev_put(idev);
1255 out:
1256 	return ret;
1257 }
1258 
1259 /*
1260  *	Choose an appropriate source address (RFC3484)
1261  */
1262 enum {
1263 	IPV6_SADDR_RULE_INIT = 0,
1264 	IPV6_SADDR_RULE_LOCAL,
1265 	IPV6_SADDR_RULE_SCOPE,
1266 	IPV6_SADDR_RULE_PREFERRED,
1267 #ifdef CONFIG_IPV6_MIP6
1268 	IPV6_SADDR_RULE_HOA,
1269 #endif
1270 	IPV6_SADDR_RULE_OIF,
1271 	IPV6_SADDR_RULE_LABEL,
1272 	IPV6_SADDR_RULE_PRIVACY,
1273 	IPV6_SADDR_RULE_ORCHID,
1274 	IPV6_SADDR_RULE_PREFIX,
1275 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1276 	IPV6_SADDR_RULE_NOT_OPTIMISTIC,
1277 #endif
1278 	IPV6_SADDR_RULE_MAX
1279 };
1280 
1281 struct ipv6_saddr_score {
1282 	int			rule;
1283 	int			addr_type;
1284 	struct inet6_ifaddr	*ifa;
1285 	DECLARE_BITMAP(scorebits, IPV6_SADDR_RULE_MAX);
1286 	int			scopedist;
1287 	int			matchlen;
1288 };
1289 
1290 struct ipv6_saddr_dst {
1291 	const struct in6_addr *addr;
1292 	int ifindex;
1293 	int scope;
1294 	int label;
1295 	unsigned int prefs;
1296 };
1297 
1298 static inline int ipv6_saddr_preferred(int type)
1299 {
1300 	if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4|IPV6_ADDR_LOOPBACK))
1301 		return 1;
1302 	return 0;
1303 }
1304 
1305 static inline bool ipv6_use_optimistic_addr(struct inet6_dev *idev)
1306 {
1307 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1308 	return idev && idev->cnf.optimistic_dad && idev->cnf.use_optimistic;
1309 #else
1310 	return false;
1311 #endif
1312 }
1313 
1314 static int ipv6_get_saddr_eval(struct net *net,
1315 			       struct ipv6_saddr_score *score,
1316 			       struct ipv6_saddr_dst *dst,
1317 			       int i)
1318 {
1319 	int ret;
1320 
1321 	if (i <= score->rule) {
1322 		switch (i) {
1323 		case IPV6_SADDR_RULE_SCOPE:
1324 			ret = score->scopedist;
1325 			break;
1326 		case IPV6_SADDR_RULE_PREFIX:
1327 			ret = score->matchlen;
1328 			break;
1329 		default:
1330 			ret = !!test_bit(i, score->scorebits);
1331 		}
1332 		goto out;
1333 	}
1334 
1335 	switch (i) {
1336 	case IPV6_SADDR_RULE_INIT:
1337 		/* Rule 0: remember if hiscore is not ready yet */
1338 		ret = !!score->ifa;
1339 		break;
1340 	case IPV6_SADDR_RULE_LOCAL:
1341 		/* Rule 1: Prefer same address */
1342 		ret = ipv6_addr_equal(&score->ifa->addr, dst->addr);
1343 		break;
1344 	case IPV6_SADDR_RULE_SCOPE:
1345 		/* Rule 2: Prefer appropriate scope
1346 		 *
1347 		 *      ret
1348 		 *       ^
1349 		 *    -1 |  d 15
1350 		 *    ---+--+-+---> scope
1351 		 *       |
1352 		 *       |             d is scope of the destination.
1353 		 *  B-d  |  \
1354 		 *       |   \      <- smaller scope is better if
1355 		 *  B-15 |    \        if scope is enough for destination.
1356 		 *       |             ret = B - scope (-1 <= scope >= d <= 15).
1357 		 * d-C-1 | /
1358 		 *       |/         <- greater is better
1359 		 *   -C  /             if scope is not enough for destination.
1360 		 *      /|             ret = scope - C (-1 <= d < scope <= 15).
1361 		 *
1362 		 * d - C - 1 < B -15 (for all -1 <= d <= 15).
1363 		 * C > d + 14 - B >= 15 + 14 - B = 29 - B.
1364 		 * Assume B = 0 and we get C > 29.
1365 		 */
1366 		ret = __ipv6_addr_src_scope(score->addr_type);
1367 		if (ret >= dst->scope)
1368 			ret = -ret;
1369 		else
1370 			ret -= 128;	/* 30 is enough */
1371 		score->scopedist = ret;
1372 		break;
1373 	case IPV6_SADDR_RULE_PREFERRED:
1374 	    {
1375 		/* Rule 3: Avoid deprecated and optimistic addresses */
1376 		u8 avoid = IFA_F_DEPRECATED;
1377 
1378 		if (!ipv6_use_optimistic_addr(score->ifa->idev))
1379 			avoid |= IFA_F_OPTIMISTIC;
1380 		ret = ipv6_saddr_preferred(score->addr_type) ||
1381 		      !(score->ifa->flags & avoid);
1382 		break;
1383 	    }
1384 #ifdef CONFIG_IPV6_MIP6
1385 	case IPV6_SADDR_RULE_HOA:
1386 	    {
1387 		/* Rule 4: Prefer home address */
1388 		int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA);
1389 		ret = !(score->ifa->flags & IFA_F_HOMEADDRESS) ^ prefhome;
1390 		break;
1391 	    }
1392 #endif
1393 	case IPV6_SADDR_RULE_OIF:
1394 		/* Rule 5: Prefer outgoing interface */
1395 		ret = (!dst->ifindex ||
1396 		       dst->ifindex == score->ifa->idev->dev->ifindex);
1397 		break;
1398 	case IPV6_SADDR_RULE_LABEL:
1399 		/* Rule 6: Prefer matching label */
1400 		ret = ipv6_addr_label(net,
1401 				      &score->ifa->addr, score->addr_type,
1402 				      score->ifa->idev->dev->ifindex) == dst->label;
1403 		break;
1404 	case IPV6_SADDR_RULE_PRIVACY:
1405 	    {
1406 		/* Rule 7: Prefer public address
1407 		 * Note: prefer temporary address if use_tempaddr >= 2
1408 		 */
1409 		int preftmp = dst->prefs & (IPV6_PREFER_SRC_PUBLIC|IPV6_PREFER_SRC_TMP) ?
1410 				!!(dst->prefs & IPV6_PREFER_SRC_TMP) :
1411 				score->ifa->idev->cnf.use_tempaddr >= 2;
1412 		ret = (!(score->ifa->flags & IFA_F_TEMPORARY)) ^ preftmp;
1413 		break;
1414 	    }
1415 	case IPV6_SADDR_RULE_ORCHID:
1416 		/* Rule 8-: Prefer ORCHID vs ORCHID or
1417 		 *	    non-ORCHID vs non-ORCHID
1418 		 */
1419 		ret = !(ipv6_addr_orchid(&score->ifa->addr) ^
1420 			ipv6_addr_orchid(dst->addr));
1421 		break;
1422 	case IPV6_SADDR_RULE_PREFIX:
1423 		/* Rule 8: Use longest matching prefix */
1424 		ret = ipv6_addr_diff(&score->ifa->addr, dst->addr);
1425 		if (ret > score->ifa->prefix_len)
1426 			ret = score->ifa->prefix_len;
1427 		score->matchlen = ret;
1428 		break;
1429 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1430 	case IPV6_SADDR_RULE_NOT_OPTIMISTIC:
1431 		/* Optimistic addresses still have lower precedence than other
1432 		 * preferred addresses.
1433 		 */
1434 		ret = !(score->ifa->flags & IFA_F_OPTIMISTIC);
1435 		break;
1436 #endif
1437 	default:
1438 		ret = 0;
1439 	}
1440 
1441 	if (ret)
1442 		__set_bit(i, score->scorebits);
1443 	score->rule = i;
1444 out:
1445 	return ret;
1446 }
1447 
1448 static int __ipv6_dev_get_saddr(struct net *net,
1449 				struct ipv6_saddr_dst *dst,
1450 				struct inet6_dev *idev,
1451 				struct ipv6_saddr_score *scores,
1452 				int hiscore_idx)
1453 {
1454 	struct ipv6_saddr_score *score = &scores[1 - hiscore_idx], *hiscore = &scores[hiscore_idx];
1455 
1456 	read_lock_bh(&idev->lock);
1457 	list_for_each_entry(score->ifa, &idev->addr_list, if_list) {
1458 		int i;
1459 
1460 		/*
1461 		 * - Tentative Address (RFC2462 section 5.4)
1462 		 *  - A tentative address is not considered
1463 		 *    "assigned to an interface" in the traditional
1464 		 *    sense, unless it is also flagged as optimistic.
1465 		 * - Candidate Source Address (section 4)
1466 		 *  - In any case, anycast addresses, multicast
1467 		 *    addresses, and the unspecified address MUST
1468 		 *    NOT be included in a candidate set.
1469 		 */
1470 		if ((score->ifa->flags & IFA_F_TENTATIVE) &&
1471 		    (!(score->ifa->flags & IFA_F_OPTIMISTIC)))
1472 			continue;
1473 
1474 		score->addr_type = __ipv6_addr_type(&score->ifa->addr);
1475 
1476 		if (unlikely(score->addr_type == IPV6_ADDR_ANY ||
1477 			     score->addr_type & IPV6_ADDR_MULTICAST)) {
1478 			net_dbg_ratelimited("ADDRCONF: unspecified / multicast address assigned as unicast address on %s",
1479 					    idev->dev->name);
1480 			continue;
1481 		}
1482 
1483 		score->rule = -1;
1484 		bitmap_zero(score->scorebits, IPV6_SADDR_RULE_MAX);
1485 
1486 		for (i = 0; i < IPV6_SADDR_RULE_MAX; i++) {
1487 			int minihiscore, miniscore;
1488 
1489 			minihiscore = ipv6_get_saddr_eval(net, hiscore, dst, i);
1490 			miniscore = ipv6_get_saddr_eval(net, score, dst, i);
1491 
1492 			if (minihiscore > miniscore) {
1493 				if (i == IPV6_SADDR_RULE_SCOPE &&
1494 				    score->scopedist > 0) {
1495 					/*
1496 					 * special case:
1497 					 * each remaining entry
1498 					 * has too small (not enough)
1499 					 * scope, because ifa entries
1500 					 * are sorted by their scope
1501 					 * values.
1502 					 */
1503 					goto out;
1504 				}
1505 				break;
1506 			} else if (minihiscore < miniscore) {
1507 				if (hiscore->ifa)
1508 					in6_ifa_put(hiscore->ifa);
1509 
1510 				in6_ifa_hold(score->ifa);
1511 
1512 				swap(hiscore, score);
1513 				hiscore_idx = 1 - hiscore_idx;
1514 
1515 				/* restore our iterator */
1516 				score->ifa = hiscore->ifa;
1517 
1518 				break;
1519 			}
1520 		}
1521 	}
1522 out:
1523 	read_unlock_bh(&idev->lock);
1524 	return hiscore_idx;
1525 }
1526 
1527 int ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev,
1528 		       const struct in6_addr *daddr, unsigned int prefs,
1529 		       struct in6_addr *saddr)
1530 {
1531 	struct ipv6_saddr_score scores[2], *hiscore;
1532 	struct ipv6_saddr_dst dst;
1533 	struct inet6_dev *idev;
1534 	struct net_device *dev;
1535 	int dst_type;
1536 	bool use_oif_addr = false;
1537 	int hiscore_idx = 0;
1538 
1539 	dst_type = __ipv6_addr_type(daddr);
1540 	dst.addr = daddr;
1541 	dst.ifindex = dst_dev ? dst_dev->ifindex : 0;
1542 	dst.scope = __ipv6_addr_src_scope(dst_type);
1543 	dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex);
1544 	dst.prefs = prefs;
1545 
1546 	scores[hiscore_idx].rule = -1;
1547 	scores[hiscore_idx].ifa = NULL;
1548 
1549 	rcu_read_lock();
1550 
1551 	/* Candidate Source Address (section 4)
1552 	 *  - multicast and link-local destination address,
1553 	 *    the set of candidate source address MUST only
1554 	 *    include addresses assigned to interfaces
1555 	 *    belonging to the same link as the outgoing
1556 	 *    interface.
1557 	 * (- For site-local destination addresses, the
1558 	 *    set of candidate source addresses MUST only
1559 	 *    include addresses assigned to interfaces
1560 	 *    belonging to the same site as the outgoing
1561 	 *    interface.)
1562 	 *  - "It is RECOMMENDED that the candidate source addresses
1563 	 *    be the set of unicast addresses assigned to the
1564 	 *    interface that will be used to send to the destination
1565 	 *    (the 'outgoing' interface)." (RFC 6724)
1566 	 */
1567 	if (dst_dev) {
1568 		idev = __in6_dev_get(dst_dev);
1569 		if ((dst_type & IPV6_ADDR_MULTICAST) ||
1570 		    dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL ||
1571 		    (idev && idev->cnf.use_oif_addrs_only)) {
1572 			use_oif_addr = true;
1573 		}
1574 	}
1575 
1576 	if (use_oif_addr) {
1577 		if (idev)
1578 			hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx);
1579 	} else {
1580 		for_each_netdev_rcu(net, dev) {
1581 			idev = __in6_dev_get(dev);
1582 			if (!idev)
1583 				continue;
1584 			hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx);
1585 		}
1586 	}
1587 	rcu_read_unlock();
1588 
1589 	hiscore = &scores[hiscore_idx];
1590 	if (!hiscore->ifa)
1591 		return -EADDRNOTAVAIL;
1592 
1593 	*saddr = hiscore->ifa->addr;
1594 	in6_ifa_put(hiscore->ifa);
1595 	return 0;
1596 }
1597 EXPORT_SYMBOL(ipv6_dev_get_saddr);
1598 
1599 int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr,
1600 		      u32 banned_flags)
1601 {
1602 	struct inet6_ifaddr *ifp;
1603 	int err = -EADDRNOTAVAIL;
1604 
1605 	list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
1606 		if (ifp->scope > IFA_LINK)
1607 			break;
1608 		if (ifp->scope == IFA_LINK &&
1609 		    !(ifp->flags & banned_flags)) {
1610 			*addr = ifp->addr;
1611 			err = 0;
1612 			break;
1613 		}
1614 	}
1615 	return err;
1616 }
1617 
1618 int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
1619 		    u32 banned_flags)
1620 {
1621 	struct inet6_dev *idev;
1622 	int err = -EADDRNOTAVAIL;
1623 
1624 	rcu_read_lock();
1625 	idev = __in6_dev_get(dev);
1626 	if (idev) {
1627 		read_lock_bh(&idev->lock);
1628 		err = __ipv6_get_lladdr(idev, addr, banned_flags);
1629 		read_unlock_bh(&idev->lock);
1630 	}
1631 	rcu_read_unlock();
1632 	return err;
1633 }
1634 
1635 static int ipv6_count_addresses(struct inet6_dev *idev)
1636 {
1637 	int cnt = 0;
1638 	struct inet6_ifaddr *ifp;
1639 
1640 	read_lock_bh(&idev->lock);
1641 	list_for_each_entry(ifp, &idev->addr_list, if_list)
1642 		cnt++;
1643 	read_unlock_bh(&idev->lock);
1644 	return cnt;
1645 }
1646 
1647 int ipv6_chk_addr(struct net *net, const struct in6_addr *addr,
1648 		  const struct net_device *dev, int strict)
1649 {
1650 	return ipv6_chk_addr_and_flags(net, addr, dev, strict, IFA_F_TENTATIVE);
1651 }
1652 EXPORT_SYMBOL(ipv6_chk_addr);
1653 
1654 int ipv6_chk_addr_and_flags(struct net *net, const struct in6_addr *addr,
1655 			    const struct net_device *dev, int strict,
1656 			    u32 banned_flags)
1657 {
1658 	struct inet6_ifaddr *ifp;
1659 	unsigned int hash = inet6_addr_hash(addr);
1660 	u32 ifp_flags;
1661 
1662 	rcu_read_lock_bh();
1663 	hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
1664 		if (!net_eq(dev_net(ifp->idev->dev), net))
1665 			continue;
1666 		/* Decouple optimistic from tentative for evaluation here.
1667 		 * Ban optimistic addresses explicitly, when required.
1668 		 */
1669 		ifp_flags = (ifp->flags&IFA_F_OPTIMISTIC)
1670 			    ? (ifp->flags&~IFA_F_TENTATIVE)
1671 			    : ifp->flags;
1672 		if (ipv6_addr_equal(&ifp->addr, addr) &&
1673 		    !(ifp_flags&banned_flags) &&
1674 		    (!dev || ifp->idev->dev == dev ||
1675 		     !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))) {
1676 			rcu_read_unlock_bh();
1677 			return 1;
1678 		}
1679 	}
1680 
1681 	rcu_read_unlock_bh();
1682 	return 0;
1683 }
1684 EXPORT_SYMBOL(ipv6_chk_addr_and_flags);
1685 
1686 static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
1687 			       struct net_device *dev)
1688 {
1689 	unsigned int hash = inet6_addr_hash(addr);
1690 	struct inet6_ifaddr *ifp;
1691 
1692 	hlist_for_each_entry(ifp, &inet6_addr_lst[hash], addr_lst) {
1693 		if (!net_eq(dev_net(ifp->idev->dev), net))
1694 			continue;
1695 		if (ipv6_addr_equal(&ifp->addr, addr)) {
1696 			if (!dev || ifp->idev->dev == dev)
1697 				return true;
1698 		}
1699 	}
1700 	return false;
1701 }
1702 
1703 /* Compares an address/prefix_len with addresses on device @dev.
1704  * If one is found it returns true.
1705  */
1706 bool ipv6_chk_custom_prefix(const struct in6_addr *addr,
1707 	const unsigned int prefix_len, struct net_device *dev)
1708 {
1709 	struct inet6_dev *idev;
1710 	struct inet6_ifaddr *ifa;
1711 	bool ret = false;
1712 
1713 	rcu_read_lock();
1714 	idev = __in6_dev_get(dev);
1715 	if (idev) {
1716 		read_lock_bh(&idev->lock);
1717 		list_for_each_entry(ifa, &idev->addr_list, if_list) {
1718 			ret = ipv6_prefix_equal(addr, &ifa->addr, prefix_len);
1719 			if (ret)
1720 				break;
1721 		}
1722 		read_unlock_bh(&idev->lock);
1723 	}
1724 	rcu_read_unlock();
1725 
1726 	return ret;
1727 }
1728 EXPORT_SYMBOL(ipv6_chk_custom_prefix);
1729 
1730 int ipv6_chk_prefix(const struct in6_addr *addr, struct net_device *dev)
1731 {
1732 	struct inet6_dev *idev;
1733 	struct inet6_ifaddr *ifa;
1734 	int	onlink;
1735 
1736 	onlink = 0;
1737 	rcu_read_lock();
1738 	idev = __in6_dev_get(dev);
1739 	if (idev) {
1740 		read_lock_bh(&idev->lock);
1741 		list_for_each_entry(ifa, &idev->addr_list, if_list) {
1742 			onlink = ipv6_prefix_equal(addr, &ifa->addr,
1743 						   ifa->prefix_len);
1744 			if (onlink)
1745 				break;
1746 		}
1747 		read_unlock_bh(&idev->lock);
1748 	}
1749 	rcu_read_unlock();
1750 	return onlink;
1751 }
1752 EXPORT_SYMBOL(ipv6_chk_prefix);
1753 
1754 struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr,
1755 				     struct net_device *dev, int strict)
1756 {
1757 	struct inet6_ifaddr *ifp, *result = NULL;
1758 	unsigned int hash = inet6_addr_hash(addr);
1759 
1760 	rcu_read_lock_bh();
1761 	hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) {
1762 		if (!net_eq(dev_net(ifp->idev->dev), net))
1763 			continue;
1764 		if (ipv6_addr_equal(&ifp->addr, addr)) {
1765 			if (!dev || ifp->idev->dev == dev ||
1766 			    !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
1767 				result = ifp;
1768 				in6_ifa_hold(ifp);
1769 				break;
1770 			}
1771 		}
1772 	}
1773 	rcu_read_unlock_bh();
1774 
1775 	return result;
1776 }
1777 
1778 /* Gets referenced address, destroys ifaddr */
1779 
1780 static void addrconf_dad_stop(struct inet6_ifaddr *ifp, int dad_failed)
1781 {
1782 	if (dad_failed)
1783 		ifp->flags |= IFA_F_DADFAILED;
1784 
1785 	if (ifp->flags&IFA_F_PERMANENT) {
1786 		spin_lock_bh(&ifp->lock);
1787 		addrconf_del_dad_work(ifp);
1788 		ifp->flags |= IFA_F_TENTATIVE;
1789 		spin_unlock_bh(&ifp->lock);
1790 		if (dad_failed)
1791 			ipv6_ifa_notify(0, ifp);
1792 		in6_ifa_put(ifp);
1793 	} else if (ifp->flags&IFA_F_TEMPORARY) {
1794 		struct inet6_ifaddr *ifpub;
1795 		spin_lock_bh(&ifp->lock);
1796 		ifpub = ifp->ifpub;
1797 		if (ifpub) {
1798 			in6_ifa_hold(ifpub);
1799 			spin_unlock_bh(&ifp->lock);
1800 			ipv6_create_tempaddr(ifpub, ifp);
1801 			in6_ifa_put(ifpub);
1802 		} else {
1803 			spin_unlock_bh(&ifp->lock);
1804 		}
1805 		ipv6_del_addr(ifp);
1806 	} else {
1807 		ipv6_del_addr(ifp);
1808 	}
1809 }
1810 
1811 static int addrconf_dad_end(struct inet6_ifaddr *ifp)
1812 {
1813 	int err = -ENOENT;
1814 
1815 	spin_lock_bh(&ifp->lock);
1816 	if (ifp->state == INET6_IFADDR_STATE_DAD) {
1817 		ifp->state = INET6_IFADDR_STATE_POSTDAD;
1818 		err = 0;
1819 	}
1820 	spin_unlock_bh(&ifp->lock);
1821 
1822 	return err;
1823 }
1824 
1825 void addrconf_dad_failure(struct inet6_ifaddr *ifp)
1826 {
1827 	struct in6_addr addr;
1828 	struct inet6_dev *idev = ifp->idev;
1829 	struct net *net = dev_net(ifp->idev->dev);
1830 
1831 	if (addrconf_dad_end(ifp)) {
1832 		in6_ifa_put(ifp);
1833 		return;
1834 	}
1835 
1836 	net_info_ratelimited("%s: IPv6 duplicate address %pI6c detected!\n",
1837 			     ifp->idev->dev->name, &ifp->addr);
1838 
1839 	spin_lock_bh(&ifp->lock);
1840 
1841 	if (ifp->flags & IFA_F_STABLE_PRIVACY) {
1842 		int scope = ifp->scope;
1843 		u32 flags = ifp->flags;
1844 		struct in6_addr new_addr;
1845 		struct inet6_ifaddr *ifp2;
1846 		u32 valid_lft, preferred_lft;
1847 		int pfxlen = ifp->prefix_len;
1848 		int retries = ifp->stable_privacy_retry + 1;
1849 
1850 		if (retries > net->ipv6.sysctl.idgen_retries) {
1851 			net_info_ratelimited("%s: privacy stable address generation failed because of DAD conflicts!\n",
1852 					     ifp->idev->dev->name);
1853 			goto errdad;
1854 		}
1855 
1856 		new_addr = ifp->addr;
1857 		if (ipv6_generate_stable_address(&new_addr, retries,
1858 						 idev))
1859 			goto errdad;
1860 
1861 		valid_lft = ifp->valid_lft;
1862 		preferred_lft = ifp->prefered_lft;
1863 
1864 		spin_unlock_bh(&ifp->lock);
1865 
1866 		if (idev->cnf.max_addresses &&
1867 		    ipv6_count_addresses(idev) >=
1868 		    idev->cnf.max_addresses)
1869 			goto lock_errdad;
1870 
1871 		net_info_ratelimited("%s: generating new stable privacy address because of DAD conflict\n",
1872 				     ifp->idev->dev->name);
1873 
1874 		ifp2 = ipv6_add_addr(idev, &new_addr, NULL, pfxlen,
1875 				     scope, flags, valid_lft,
1876 				     preferred_lft);
1877 		if (IS_ERR(ifp2))
1878 			goto lock_errdad;
1879 
1880 		spin_lock_bh(&ifp2->lock);
1881 		ifp2->stable_privacy_retry = retries;
1882 		ifp2->state = INET6_IFADDR_STATE_PREDAD;
1883 		spin_unlock_bh(&ifp2->lock);
1884 
1885 		addrconf_mod_dad_work(ifp2, net->ipv6.sysctl.idgen_delay);
1886 		in6_ifa_put(ifp2);
1887 lock_errdad:
1888 		spin_lock_bh(&ifp->lock);
1889 	} else if (idev->cnf.accept_dad > 1 && !idev->cnf.disable_ipv6) {
1890 		addr.s6_addr32[0] = htonl(0xfe800000);
1891 		addr.s6_addr32[1] = 0;
1892 
1893 		if (!ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) &&
1894 		    ipv6_addr_equal(&ifp->addr, &addr)) {
1895 			/* DAD failed for link-local based on MAC address */
1896 			idev->cnf.disable_ipv6 = 1;
1897 
1898 			pr_info("%s: IPv6 being disabled!\n",
1899 				ifp->idev->dev->name);
1900 		}
1901 	}
1902 
1903 errdad:
1904 	/* transition from _POSTDAD to _ERRDAD */
1905 	ifp->state = INET6_IFADDR_STATE_ERRDAD;
1906 	spin_unlock_bh(&ifp->lock);
1907 
1908 	addrconf_mod_dad_work(ifp, 0);
1909 }
1910 
1911 /* Join to solicited addr multicast group.
1912  * caller must hold RTNL */
1913 void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr)
1914 {
1915 	struct in6_addr maddr;
1916 
1917 	if (dev->flags&(IFF_LOOPBACK|IFF_NOARP))
1918 		return;
1919 
1920 	addrconf_addr_solict_mult(addr, &maddr);
1921 	ipv6_dev_mc_inc(dev, &maddr);
1922 }
1923 
1924 /* caller must hold RTNL */
1925 void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr)
1926 {
1927 	struct in6_addr maddr;
1928 
1929 	if (idev->dev->flags&(IFF_LOOPBACK|IFF_NOARP))
1930 		return;
1931 
1932 	addrconf_addr_solict_mult(addr, &maddr);
1933 	__ipv6_dev_mc_dec(idev, &maddr);
1934 }
1935 
1936 /* caller must hold RTNL */
1937 static void addrconf_join_anycast(struct inet6_ifaddr *ifp)
1938 {
1939 	struct in6_addr addr;
1940 
1941 	if (ifp->prefix_len >= 127) /* RFC 6164 */
1942 		return;
1943 	ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
1944 	if (ipv6_addr_any(&addr))
1945 		return;
1946 	__ipv6_dev_ac_inc(ifp->idev, &addr);
1947 }
1948 
1949 /* caller must hold RTNL */
1950 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp)
1951 {
1952 	struct in6_addr addr;
1953 
1954 	if (ifp->prefix_len >= 127) /* RFC 6164 */
1955 		return;
1956 	ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
1957 	if (ipv6_addr_any(&addr))
1958 		return;
1959 	__ipv6_dev_ac_dec(ifp->idev, &addr);
1960 }
1961 
1962 static int addrconf_ifid_eui64(u8 *eui, struct net_device *dev)
1963 {
1964 	if (dev->addr_len != EUI64_ADDR_LEN)
1965 		return -1;
1966 	memcpy(eui, dev->dev_addr, EUI64_ADDR_LEN);
1967 	eui[0] ^= 2;
1968 	return 0;
1969 }
1970 
1971 static int addrconf_ifid_ieee1394(u8 *eui, struct net_device *dev)
1972 {
1973 	union fwnet_hwaddr *ha;
1974 
1975 	if (dev->addr_len != FWNET_ALEN)
1976 		return -1;
1977 
1978 	ha = (union fwnet_hwaddr *)dev->dev_addr;
1979 
1980 	memcpy(eui, &ha->uc.uniq_id, sizeof(ha->uc.uniq_id));
1981 	eui[0] ^= 2;
1982 	return 0;
1983 }
1984 
1985 static int addrconf_ifid_arcnet(u8 *eui, struct net_device *dev)
1986 {
1987 	/* XXX: inherit EUI-64 from other interface -- yoshfuji */
1988 	if (dev->addr_len != ARCNET_ALEN)
1989 		return -1;
1990 	memset(eui, 0, 7);
1991 	eui[7] = *(u8 *)dev->dev_addr;
1992 	return 0;
1993 }
1994 
1995 static int addrconf_ifid_infiniband(u8 *eui, struct net_device *dev)
1996 {
1997 	if (dev->addr_len != INFINIBAND_ALEN)
1998 		return -1;
1999 	memcpy(eui, dev->dev_addr + 12, 8);
2000 	eui[0] |= 2;
2001 	return 0;
2002 }
2003 
2004 static int __ipv6_isatap_ifid(u8 *eui, __be32 addr)
2005 {
2006 	if (addr == 0)
2007 		return -1;
2008 	eui[0] = (ipv4_is_zeronet(addr) || ipv4_is_private_10(addr) ||
2009 		  ipv4_is_loopback(addr) || ipv4_is_linklocal_169(addr) ||
2010 		  ipv4_is_private_172(addr) || ipv4_is_test_192(addr) ||
2011 		  ipv4_is_anycast_6to4(addr) || ipv4_is_private_192(addr) ||
2012 		  ipv4_is_test_198(addr) || ipv4_is_multicast(addr) ||
2013 		  ipv4_is_lbcast(addr)) ? 0x00 : 0x02;
2014 	eui[1] = 0;
2015 	eui[2] = 0x5E;
2016 	eui[3] = 0xFE;
2017 	memcpy(eui + 4, &addr, 4);
2018 	return 0;
2019 }
2020 
2021 static int addrconf_ifid_sit(u8 *eui, struct net_device *dev)
2022 {
2023 	if (dev->priv_flags & IFF_ISATAP)
2024 		return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
2025 	return -1;
2026 }
2027 
2028 static int addrconf_ifid_gre(u8 *eui, struct net_device *dev)
2029 {
2030 	return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
2031 }
2032 
2033 static int addrconf_ifid_ip6tnl(u8 *eui, struct net_device *dev)
2034 {
2035 	memcpy(eui, dev->perm_addr, 3);
2036 	memcpy(eui + 5, dev->perm_addr + 3, 3);
2037 	eui[3] = 0xFF;
2038 	eui[4] = 0xFE;
2039 	eui[0] ^= 2;
2040 	return 0;
2041 }
2042 
2043 static int ipv6_generate_eui64(u8 *eui, struct net_device *dev)
2044 {
2045 	switch (dev->type) {
2046 	case ARPHRD_ETHER:
2047 	case ARPHRD_FDDI:
2048 		return addrconf_ifid_eui48(eui, dev);
2049 	case ARPHRD_ARCNET:
2050 		return addrconf_ifid_arcnet(eui, dev);
2051 	case ARPHRD_INFINIBAND:
2052 		return addrconf_ifid_infiniband(eui, dev);
2053 	case ARPHRD_SIT:
2054 		return addrconf_ifid_sit(eui, dev);
2055 	case ARPHRD_IPGRE:
2056 		return addrconf_ifid_gre(eui, dev);
2057 	case ARPHRD_6LOWPAN:
2058 		return addrconf_ifid_eui64(eui, dev);
2059 	case ARPHRD_IEEE1394:
2060 		return addrconf_ifid_ieee1394(eui, dev);
2061 	case ARPHRD_TUNNEL6:
2062 		return addrconf_ifid_ip6tnl(eui, dev);
2063 	}
2064 	return -1;
2065 }
2066 
2067 static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev)
2068 {
2069 	int err = -1;
2070 	struct inet6_ifaddr *ifp;
2071 
2072 	read_lock_bh(&idev->lock);
2073 	list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
2074 		if (ifp->scope > IFA_LINK)
2075 			break;
2076 		if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
2077 			memcpy(eui, ifp->addr.s6_addr+8, 8);
2078 			err = 0;
2079 			break;
2080 		}
2081 	}
2082 	read_unlock_bh(&idev->lock);
2083 	return err;
2084 }
2085 
2086 /* (re)generation of randomized interface identifier (RFC 3041 3.2, 3.5) */
2087 static void __ipv6_regen_rndid(struct inet6_dev *idev)
2088 {
2089 regen:
2090 	get_random_bytes(idev->rndid, sizeof(idev->rndid));
2091 	idev->rndid[0] &= ~0x02;
2092 
2093 	/*
2094 	 * <draft-ietf-ipngwg-temp-addresses-v2-00.txt>:
2095 	 * check if generated address is not inappropriate
2096 	 *
2097 	 *  - Reserved subnet anycast (RFC 2526)
2098 	 *	11111101 11....11 1xxxxxxx
2099 	 *  - ISATAP (RFC4214) 6.1
2100 	 *	00-00-5E-FE-xx-xx-xx-xx
2101 	 *  - value 0
2102 	 *  - XXX: already assigned to an address on the device
2103 	 */
2104 	if (idev->rndid[0] == 0xfd &&
2105 	    (idev->rndid[1]&idev->rndid[2]&idev->rndid[3]&idev->rndid[4]&idev->rndid[5]&idev->rndid[6]) == 0xff &&
2106 	    (idev->rndid[7]&0x80))
2107 		goto regen;
2108 	if ((idev->rndid[0]|idev->rndid[1]) == 0) {
2109 		if (idev->rndid[2] == 0x5e && idev->rndid[3] == 0xfe)
2110 			goto regen;
2111 		if ((idev->rndid[2]|idev->rndid[3]|idev->rndid[4]|idev->rndid[5]|idev->rndid[6]|idev->rndid[7]) == 0x00)
2112 			goto regen;
2113 	}
2114 }
2115 
2116 static void ipv6_regen_rndid(unsigned long data)
2117 {
2118 	struct inet6_dev *idev = (struct inet6_dev *) data;
2119 	unsigned long expires;
2120 
2121 	rcu_read_lock_bh();
2122 	write_lock_bh(&idev->lock);
2123 
2124 	if (idev->dead)
2125 		goto out;
2126 
2127 	__ipv6_regen_rndid(idev);
2128 
2129 	expires = jiffies +
2130 		idev->cnf.temp_prefered_lft * HZ -
2131 		idev->cnf.regen_max_retry * idev->cnf.dad_transmits *
2132 		NEIGH_VAR(idev->nd_parms, RETRANS_TIME) -
2133 		idev->cnf.max_desync_factor * HZ;
2134 	if (time_before(expires, jiffies)) {
2135 		pr_warn("%s: too short regeneration interval; timer disabled for %s\n",
2136 			__func__, idev->dev->name);
2137 		goto out;
2138 	}
2139 
2140 	if (!mod_timer(&idev->regen_timer, expires))
2141 		in6_dev_hold(idev);
2142 
2143 out:
2144 	write_unlock_bh(&idev->lock);
2145 	rcu_read_unlock_bh();
2146 	in6_dev_put(idev);
2147 }
2148 
2149 static void  __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr)
2150 {
2151 	if (tmpaddr && memcmp(idev->rndid, &tmpaddr->s6_addr[8], 8) == 0)
2152 		__ipv6_regen_rndid(idev);
2153 }
2154 
2155 /*
2156  *	Add prefix route.
2157  */
2158 
2159 static void
2160 addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev,
2161 		      unsigned long expires, u32 flags)
2162 {
2163 	struct fib6_config cfg = {
2164 		.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX,
2165 		.fc_metric = IP6_RT_PRIO_ADDRCONF,
2166 		.fc_ifindex = dev->ifindex,
2167 		.fc_expires = expires,
2168 		.fc_dst_len = plen,
2169 		.fc_flags = RTF_UP | flags,
2170 		.fc_nlinfo.nl_net = dev_net(dev),
2171 		.fc_protocol = RTPROT_KERNEL,
2172 	};
2173 
2174 	cfg.fc_dst = *pfx;
2175 
2176 	/* Prevent useless cloning on PtP SIT.
2177 	   This thing is done here expecting that the whole
2178 	   class of non-broadcast devices need not cloning.
2179 	 */
2180 #if IS_ENABLED(CONFIG_IPV6_SIT)
2181 	if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT))
2182 		cfg.fc_flags |= RTF_NONEXTHOP;
2183 #endif
2184 
2185 	ip6_route_add(&cfg);
2186 }
2187 
2188 
2189 static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
2190 						  int plen,
2191 						  const struct net_device *dev,
2192 						  u32 flags, u32 noflags)
2193 {
2194 	struct fib6_node *fn;
2195 	struct rt6_info *rt = NULL;
2196 	struct fib6_table *table;
2197 	u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX;
2198 
2199 	table = fib6_get_table(dev_net(dev), tb_id);
2200 	if (!table)
2201 		return NULL;
2202 
2203 	read_lock_bh(&table->tb6_lock);
2204 	fn = fib6_locate(&table->tb6_root, pfx, plen, NULL, 0);
2205 	if (!fn)
2206 		goto out;
2207 
2208 	noflags |= RTF_CACHE;
2209 	for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
2210 		if (rt->dst.dev->ifindex != dev->ifindex)
2211 			continue;
2212 		if ((rt->rt6i_flags & flags) != flags)
2213 			continue;
2214 		if ((rt->rt6i_flags & noflags) != 0)
2215 			continue;
2216 		dst_hold(&rt->dst);
2217 		break;
2218 	}
2219 out:
2220 	read_unlock_bh(&table->tb6_lock);
2221 	return rt;
2222 }
2223 
2224 
2225 /* Create "default" multicast route to the interface */
2226 
2227 static void addrconf_add_mroute(struct net_device *dev)
2228 {
2229 	struct fib6_config cfg = {
2230 		.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_LOCAL,
2231 		.fc_metric = IP6_RT_PRIO_ADDRCONF,
2232 		.fc_ifindex = dev->ifindex,
2233 		.fc_dst_len = 8,
2234 		.fc_flags = RTF_UP,
2235 		.fc_nlinfo.nl_net = dev_net(dev),
2236 	};
2237 
2238 	ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0);
2239 
2240 	ip6_route_add(&cfg);
2241 }
2242 
2243 static struct inet6_dev *addrconf_add_dev(struct net_device *dev)
2244 {
2245 	struct inet6_dev *idev;
2246 
2247 	ASSERT_RTNL();
2248 
2249 	idev = ipv6_find_idev(dev);
2250 	if (!idev)
2251 		return ERR_PTR(-ENOBUFS);
2252 
2253 	if (idev->cnf.disable_ipv6)
2254 		return ERR_PTR(-EACCES);
2255 
2256 	/* Add default multicast route */
2257 	if (!(dev->flags & IFF_LOOPBACK) && !netif_is_l3_master(dev))
2258 		addrconf_add_mroute(dev);
2259 
2260 	return idev;
2261 }
2262 
2263 static void manage_tempaddrs(struct inet6_dev *idev,
2264 			     struct inet6_ifaddr *ifp,
2265 			     __u32 valid_lft, __u32 prefered_lft,
2266 			     bool create, unsigned long now)
2267 {
2268 	u32 flags;
2269 	struct inet6_ifaddr *ift;
2270 
2271 	read_lock_bh(&idev->lock);
2272 	/* update all temporary addresses in the list */
2273 	list_for_each_entry(ift, &idev->tempaddr_list, tmp_list) {
2274 		int age, max_valid, max_prefered;
2275 
2276 		if (ifp != ift->ifpub)
2277 			continue;
2278 
2279 		/* RFC 4941 section 3.3:
2280 		 * If a received option will extend the lifetime of a public
2281 		 * address, the lifetimes of temporary addresses should
2282 		 * be extended, subject to the overall constraint that no
2283 		 * temporary addresses should ever remain "valid" or "preferred"
2284 		 * for a time longer than (TEMP_VALID_LIFETIME) or
2285 		 * (TEMP_PREFERRED_LIFETIME - DESYNC_FACTOR), respectively.
2286 		 */
2287 		age = (now - ift->cstamp) / HZ;
2288 		max_valid = idev->cnf.temp_valid_lft - age;
2289 		if (max_valid < 0)
2290 			max_valid = 0;
2291 
2292 		max_prefered = idev->cnf.temp_prefered_lft -
2293 			       idev->cnf.max_desync_factor - age;
2294 		if (max_prefered < 0)
2295 			max_prefered = 0;
2296 
2297 		if (valid_lft > max_valid)
2298 			valid_lft = max_valid;
2299 
2300 		if (prefered_lft > max_prefered)
2301 			prefered_lft = max_prefered;
2302 
2303 		spin_lock(&ift->lock);
2304 		flags = ift->flags;
2305 		ift->valid_lft = valid_lft;
2306 		ift->prefered_lft = prefered_lft;
2307 		ift->tstamp = now;
2308 		if (prefered_lft > 0)
2309 			ift->flags &= ~IFA_F_DEPRECATED;
2310 
2311 		spin_unlock(&ift->lock);
2312 		if (!(flags&IFA_F_TENTATIVE))
2313 			ipv6_ifa_notify(0, ift);
2314 	}
2315 
2316 	if ((create || list_empty(&idev->tempaddr_list)) &&
2317 	    idev->cnf.use_tempaddr > 0) {
2318 		/* When a new public address is created as described
2319 		 * in [ADDRCONF], also create a new temporary address.
2320 		 * Also create a temporary address if it's enabled but
2321 		 * no temporary address currently exists.
2322 		 */
2323 		read_unlock_bh(&idev->lock);
2324 		ipv6_create_tempaddr(ifp, NULL);
2325 	} else {
2326 		read_unlock_bh(&idev->lock);
2327 	}
2328 }
2329 
2330 static bool is_addr_mode_generate_stable(struct inet6_dev *idev)
2331 {
2332 	return idev->addr_gen_mode == IN6_ADDR_GEN_MODE_STABLE_PRIVACY ||
2333 	       idev->addr_gen_mode == IN6_ADDR_GEN_MODE_RANDOM;
2334 }
2335 
2336 static int addrconf_prefix_rcv_add_addr(struct net *net,
2337 					struct net_device *dev,
2338 					const struct prefix_info *pinfo,
2339 					struct inet6_dev *in6_dev,
2340 					const struct in6_addr *addr,
2341 					int addr_type, u32 addr_flags,
2342 					bool sllao, bool tokenized,
2343 					__u32 valid_lft, u32 prefered_lft)
2344 {
2345 	struct inet6_ifaddr *ifp = ipv6_get_ifaddr(net, addr, dev, 1);
2346 	int create = 0, update_lft = 0;
2347 
2348 	if (!ifp && valid_lft) {
2349 		int max_addresses = in6_dev->cnf.max_addresses;
2350 
2351 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
2352 		if (in6_dev->cnf.optimistic_dad &&
2353 		    !net->ipv6.devconf_all->forwarding && sllao)
2354 			addr_flags |= IFA_F_OPTIMISTIC;
2355 #endif
2356 
2357 		/* Do not allow to create too much of autoconfigured
2358 		 * addresses; this would be too easy way to crash kernel.
2359 		 */
2360 		if (!max_addresses ||
2361 		    ipv6_count_addresses(in6_dev) < max_addresses)
2362 			ifp = ipv6_add_addr(in6_dev, addr, NULL,
2363 					    pinfo->prefix_len,
2364 					    addr_type&IPV6_ADDR_SCOPE_MASK,
2365 					    addr_flags, valid_lft,
2366 					    prefered_lft);
2367 
2368 		if (IS_ERR_OR_NULL(ifp))
2369 			return -1;
2370 
2371 		update_lft = 0;
2372 		create = 1;
2373 		spin_lock_bh(&ifp->lock);
2374 		ifp->flags |= IFA_F_MANAGETEMPADDR;
2375 		ifp->cstamp = jiffies;
2376 		ifp->tokenized = tokenized;
2377 		spin_unlock_bh(&ifp->lock);
2378 		addrconf_dad_start(ifp);
2379 	}
2380 
2381 	if (ifp) {
2382 		u32 flags;
2383 		unsigned long now;
2384 		u32 stored_lft;
2385 
2386 		/* update lifetime (RFC2462 5.5.3 e) */
2387 		spin_lock_bh(&ifp->lock);
2388 		now = jiffies;
2389 		if (ifp->valid_lft > (now - ifp->tstamp) / HZ)
2390 			stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ;
2391 		else
2392 			stored_lft = 0;
2393 		if (!update_lft && !create && stored_lft) {
2394 			const u32 minimum_lft = min_t(u32,
2395 				stored_lft, MIN_VALID_LIFETIME);
2396 			valid_lft = max(valid_lft, minimum_lft);
2397 
2398 			/* RFC4862 Section 5.5.3e:
2399 			 * "Note that the preferred lifetime of the
2400 			 *  corresponding address is always reset to
2401 			 *  the Preferred Lifetime in the received
2402 			 *  Prefix Information option, regardless of
2403 			 *  whether the valid lifetime is also reset or
2404 			 *  ignored."
2405 			 *
2406 			 * So we should always update prefered_lft here.
2407 			 */
2408 			update_lft = 1;
2409 		}
2410 
2411 		if (update_lft) {
2412 			ifp->valid_lft = valid_lft;
2413 			ifp->prefered_lft = prefered_lft;
2414 			ifp->tstamp = now;
2415 			flags = ifp->flags;
2416 			ifp->flags &= ~IFA_F_DEPRECATED;
2417 			spin_unlock_bh(&ifp->lock);
2418 
2419 			if (!(flags&IFA_F_TENTATIVE))
2420 				ipv6_ifa_notify(0, ifp);
2421 		} else
2422 			spin_unlock_bh(&ifp->lock);
2423 
2424 		manage_tempaddrs(in6_dev, ifp, valid_lft, prefered_lft,
2425 				 create, now);
2426 
2427 		in6_ifa_put(ifp);
2428 		addrconf_verify();
2429 	}
2430 
2431 	return 0;
2432 }
2433 
2434 void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len, bool sllao)
2435 {
2436 	struct prefix_info *pinfo;
2437 	__u32 valid_lft;
2438 	__u32 prefered_lft;
2439 	int addr_type, err;
2440 	u32 addr_flags = 0;
2441 	struct inet6_dev *in6_dev;
2442 	struct net *net = dev_net(dev);
2443 
2444 	pinfo = (struct prefix_info *) opt;
2445 
2446 	if (len < sizeof(struct prefix_info)) {
2447 		ADBG("addrconf: prefix option too short\n");
2448 		return;
2449 	}
2450 
2451 	/*
2452 	 *	Validation checks ([ADDRCONF], page 19)
2453 	 */
2454 
2455 	addr_type = ipv6_addr_type(&pinfo->prefix);
2456 
2457 	if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL))
2458 		return;
2459 
2460 	valid_lft = ntohl(pinfo->valid);
2461 	prefered_lft = ntohl(pinfo->prefered);
2462 
2463 	if (prefered_lft > valid_lft) {
2464 		net_warn_ratelimited("addrconf: prefix option has invalid lifetime\n");
2465 		return;
2466 	}
2467 
2468 	in6_dev = in6_dev_get(dev);
2469 
2470 	if (!in6_dev) {
2471 		net_dbg_ratelimited("addrconf: device %s not configured\n",
2472 				    dev->name);
2473 		return;
2474 	}
2475 
2476 	/*
2477 	 *	Two things going on here:
2478 	 *	1) Add routes for on-link prefixes
2479 	 *	2) Configure prefixes with the auto flag set
2480 	 */
2481 
2482 	if (pinfo->onlink) {
2483 		struct rt6_info *rt;
2484 		unsigned long rt_expires;
2485 
2486 		/* Avoid arithmetic overflow. Really, we could
2487 		 * save rt_expires in seconds, likely valid_lft,
2488 		 * but it would require division in fib gc, that it
2489 		 * not good.
2490 		 */
2491 		if (HZ > USER_HZ)
2492 			rt_expires = addrconf_timeout_fixup(valid_lft, HZ);
2493 		else
2494 			rt_expires = addrconf_timeout_fixup(valid_lft, USER_HZ);
2495 
2496 		if (addrconf_finite_timeout(rt_expires))
2497 			rt_expires *= HZ;
2498 
2499 		rt = addrconf_get_prefix_route(&pinfo->prefix,
2500 					       pinfo->prefix_len,
2501 					       dev,
2502 					       RTF_ADDRCONF | RTF_PREFIX_RT,
2503 					       RTF_GATEWAY | RTF_DEFAULT);
2504 
2505 		if (rt) {
2506 			/* Autoconf prefix route */
2507 			if (valid_lft == 0) {
2508 				ip6_del_rt(rt);
2509 				rt = NULL;
2510 			} else if (addrconf_finite_timeout(rt_expires)) {
2511 				/* not infinity */
2512 				rt6_set_expires(rt, jiffies + rt_expires);
2513 			} else {
2514 				rt6_clean_expires(rt);
2515 			}
2516 		} else if (valid_lft) {
2517 			clock_t expires = 0;
2518 			int flags = RTF_ADDRCONF | RTF_PREFIX_RT;
2519 			if (addrconf_finite_timeout(rt_expires)) {
2520 				/* not infinity */
2521 				flags |= RTF_EXPIRES;
2522 				expires = jiffies_to_clock_t(rt_expires);
2523 			}
2524 			addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
2525 					      dev, expires, flags);
2526 		}
2527 		ip6_rt_put(rt);
2528 	}
2529 
2530 	/* Try to figure out our local address for this prefix */
2531 
2532 	if (pinfo->autoconf && in6_dev->cnf.autoconf) {
2533 		struct in6_addr addr;
2534 		bool tokenized = false;
2535 
2536 		if (pinfo->prefix_len == 64) {
2537 			memcpy(&addr, &pinfo->prefix, 8);
2538 
2539 			if (!ipv6_addr_any(&in6_dev->token)) {
2540 				read_lock_bh(&in6_dev->lock);
2541 				memcpy(addr.s6_addr + 8,
2542 				       in6_dev->token.s6_addr + 8, 8);
2543 				read_unlock_bh(&in6_dev->lock);
2544 				tokenized = true;
2545 			} else if (is_addr_mode_generate_stable(in6_dev) &&
2546 				   !ipv6_generate_stable_address(&addr, 0,
2547 								 in6_dev)) {
2548 				addr_flags |= IFA_F_STABLE_PRIVACY;
2549 				goto ok;
2550 			} else if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
2551 				   ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
2552 				goto put;
2553 			}
2554 			goto ok;
2555 		}
2556 		net_dbg_ratelimited("IPv6 addrconf: prefix with wrong length %d\n",
2557 				    pinfo->prefix_len);
2558 		goto put;
2559 
2560 ok:
2561 		err = addrconf_prefix_rcv_add_addr(net, dev, pinfo, in6_dev,
2562 						   &addr, addr_type,
2563 						   addr_flags, sllao,
2564 						   tokenized, valid_lft,
2565 						   prefered_lft);
2566 		if (err)
2567 			goto put;
2568 	}
2569 	inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo);
2570 put:
2571 	in6_dev_put(in6_dev);
2572 }
2573 
2574 /*
2575  *	Set destination address.
2576  *	Special case for SIT interfaces where we create a new "virtual"
2577  *	device.
2578  */
2579 int addrconf_set_dstaddr(struct net *net, void __user *arg)
2580 {
2581 	struct in6_ifreq ireq;
2582 	struct net_device *dev;
2583 	int err = -EINVAL;
2584 
2585 	rtnl_lock();
2586 
2587 	err = -EFAULT;
2588 	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2589 		goto err_exit;
2590 
2591 	dev = __dev_get_by_index(net, ireq.ifr6_ifindex);
2592 
2593 	err = -ENODEV;
2594 	if (!dev)
2595 		goto err_exit;
2596 
2597 #if IS_ENABLED(CONFIG_IPV6_SIT)
2598 	if (dev->type == ARPHRD_SIT) {
2599 		const struct net_device_ops *ops = dev->netdev_ops;
2600 		struct ifreq ifr;
2601 		struct ip_tunnel_parm p;
2602 
2603 		err = -EADDRNOTAVAIL;
2604 		if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4))
2605 			goto err_exit;
2606 
2607 		memset(&p, 0, sizeof(p));
2608 		p.iph.daddr = ireq.ifr6_addr.s6_addr32[3];
2609 		p.iph.saddr = 0;
2610 		p.iph.version = 4;
2611 		p.iph.ihl = 5;
2612 		p.iph.protocol = IPPROTO_IPV6;
2613 		p.iph.ttl = 64;
2614 		ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
2615 
2616 		if (ops->ndo_do_ioctl) {
2617 			mm_segment_t oldfs = get_fs();
2618 
2619 			set_fs(KERNEL_DS);
2620 			err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
2621 			set_fs(oldfs);
2622 		} else
2623 			err = -EOPNOTSUPP;
2624 
2625 		if (err == 0) {
2626 			err = -ENOBUFS;
2627 			dev = __dev_get_by_name(net, p.name);
2628 			if (!dev)
2629 				goto err_exit;
2630 			err = dev_open(dev);
2631 		}
2632 	}
2633 #endif
2634 
2635 err_exit:
2636 	rtnl_unlock();
2637 	return err;
2638 }
2639 
2640 static int ipv6_mc_config(struct sock *sk, bool join,
2641 			  const struct in6_addr *addr, int ifindex)
2642 {
2643 	int ret;
2644 
2645 	ASSERT_RTNL();
2646 
2647 	lock_sock(sk);
2648 	if (join)
2649 		ret = ipv6_sock_mc_join(sk, ifindex, addr);
2650 	else
2651 		ret = ipv6_sock_mc_drop(sk, ifindex, addr);
2652 	release_sock(sk);
2653 
2654 	return ret;
2655 }
2656 
2657 /*
2658  *	Manual configuration of address on an interface
2659  */
2660 static int inet6_addr_add(struct net *net, int ifindex,
2661 			  const struct in6_addr *pfx,
2662 			  const struct in6_addr *peer_pfx,
2663 			  unsigned int plen, __u32 ifa_flags,
2664 			  __u32 prefered_lft, __u32 valid_lft)
2665 {
2666 	struct inet6_ifaddr *ifp;
2667 	struct inet6_dev *idev;
2668 	struct net_device *dev;
2669 	unsigned long timeout;
2670 	clock_t expires;
2671 	int scope;
2672 	u32 flags;
2673 
2674 	ASSERT_RTNL();
2675 
2676 	if (plen > 128)
2677 		return -EINVAL;
2678 
2679 	/* check the lifetime */
2680 	if (!valid_lft || prefered_lft > valid_lft)
2681 		return -EINVAL;
2682 
2683 	if (ifa_flags & IFA_F_MANAGETEMPADDR && plen != 64)
2684 		return -EINVAL;
2685 
2686 	dev = __dev_get_by_index(net, ifindex);
2687 	if (!dev)
2688 		return -ENODEV;
2689 
2690 	idev = addrconf_add_dev(dev);
2691 	if (IS_ERR(idev))
2692 		return PTR_ERR(idev);
2693 
2694 	if (ifa_flags & IFA_F_MCAUTOJOIN) {
2695 		int ret = ipv6_mc_config(net->ipv6.mc_autojoin_sk,
2696 					 true, pfx, ifindex);
2697 
2698 		if (ret < 0)
2699 			return ret;
2700 	}
2701 
2702 	scope = ipv6_addr_scope(pfx);
2703 
2704 	timeout = addrconf_timeout_fixup(valid_lft, HZ);
2705 	if (addrconf_finite_timeout(timeout)) {
2706 		expires = jiffies_to_clock_t(timeout * HZ);
2707 		valid_lft = timeout;
2708 		flags = RTF_EXPIRES;
2709 	} else {
2710 		expires = 0;
2711 		flags = 0;
2712 		ifa_flags |= IFA_F_PERMANENT;
2713 	}
2714 
2715 	timeout = addrconf_timeout_fixup(prefered_lft, HZ);
2716 	if (addrconf_finite_timeout(timeout)) {
2717 		if (timeout == 0)
2718 			ifa_flags |= IFA_F_DEPRECATED;
2719 		prefered_lft = timeout;
2720 	}
2721 
2722 	ifp = ipv6_add_addr(idev, pfx, peer_pfx, plen, scope, ifa_flags,
2723 			    valid_lft, prefered_lft);
2724 
2725 	if (!IS_ERR(ifp)) {
2726 		if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) {
2727 			addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev,
2728 					      expires, flags);
2729 		}
2730 
2731 		/*
2732 		 * Note that section 3.1 of RFC 4429 indicates
2733 		 * that the Optimistic flag should not be set for
2734 		 * manually configured addresses
2735 		 */
2736 		addrconf_dad_start(ifp);
2737 		if (ifa_flags & IFA_F_MANAGETEMPADDR)
2738 			manage_tempaddrs(idev, ifp, valid_lft, prefered_lft,
2739 					 true, jiffies);
2740 		in6_ifa_put(ifp);
2741 		addrconf_verify_rtnl();
2742 		return 0;
2743 	} else if (ifa_flags & IFA_F_MCAUTOJOIN) {
2744 		ipv6_mc_config(net->ipv6.mc_autojoin_sk,
2745 			       false, pfx, ifindex);
2746 	}
2747 
2748 	return PTR_ERR(ifp);
2749 }
2750 
2751 static int inet6_addr_del(struct net *net, int ifindex, u32 ifa_flags,
2752 			  const struct in6_addr *pfx, unsigned int plen)
2753 {
2754 	struct inet6_ifaddr *ifp;
2755 	struct inet6_dev *idev;
2756 	struct net_device *dev;
2757 
2758 	if (plen > 128)
2759 		return -EINVAL;
2760 
2761 	dev = __dev_get_by_index(net, ifindex);
2762 	if (!dev)
2763 		return -ENODEV;
2764 
2765 	idev = __in6_dev_get(dev);
2766 	if (!idev)
2767 		return -ENXIO;
2768 
2769 	read_lock_bh(&idev->lock);
2770 	list_for_each_entry(ifp, &idev->addr_list, if_list) {
2771 		if (ifp->prefix_len == plen &&
2772 		    ipv6_addr_equal(pfx, &ifp->addr)) {
2773 			in6_ifa_hold(ifp);
2774 			read_unlock_bh(&idev->lock);
2775 
2776 			if (!(ifp->flags & IFA_F_TEMPORARY) &&
2777 			    (ifa_flags & IFA_F_MANAGETEMPADDR))
2778 				manage_tempaddrs(idev, ifp, 0, 0, false,
2779 						 jiffies);
2780 			ipv6_del_addr(ifp);
2781 			addrconf_verify_rtnl();
2782 			if (ipv6_addr_is_multicast(pfx)) {
2783 				ipv6_mc_config(net->ipv6.mc_autojoin_sk,
2784 					       false, pfx, dev->ifindex);
2785 			}
2786 			return 0;
2787 		}
2788 	}
2789 	read_unlock_bh(&idev->lock);
2790 	return -EADDRNOTAVAIL;
2791 }
2792 
2793 
2794 int addrconf_add_ifaddr(struct net *net, void __user *arg)
2795 {
2796 	struct in6_ifreq ireq;
2797 	int err;
2798 
2799 	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2800 		return -EPERM;
2801 
2802 	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2803 		return -EFAULT;
2804 
2805 	rtnl_lock();
2806 	err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL,
2807 			     ireq.ifr6_prefixlen, IFA_F_PERMANENT,
2808 			     INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
2809 	rtnl_unlock();
2810 	return err;
2811 }
2812 
2813 int addrconf_del_ifaddr(struct net *net, void __user *arg)
2814 {
2815 	struct in6_ifreq ireq;
2816 	int err;
2817 
2818 	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2819 		return -EPERM;
2820 
2821 	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2822 		return -EFAULT;
2823 
2824 	rtnl_lock();
2825 	err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr,
2826 			     ireq.ifr6_prefixlen);
2827 	rtnl_unlock();
2828 	return err;
2829 }
2830 
2831 static void add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
2832 		     int plen, int scope)
2833 {
2834 	struct inet6_ifaddr *ifp;
2835 
2836 	ifp = ipv6_add_addr(idev, addr, NULL, plen,
2837 			    scope, IFA_F_PERMANENT,
2838 			    INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
2839 	if (!IS_ERR(ifp)) {
2840 		spin_lock_bh(&ifp->lock);
2841 		ifp->flags &= ~IFA_F_TENTATIVE;
2842 		spin_unlock_bh(&ifp->lock);
2843 		ipv6_ifa_notify(RTM_NEWADDR, ifp);
2844 		in6_ifa_put(ifp);
2845 	}
2846 }
2847 
2848 #if IS_ENABLED(CONFIG_IPV6_SIT)
2849 static void sit_add_v4_addrs(struct inet6_dev *idev)
2850 {
2851 	struct in6_addr addr;
2852 	struct net_device *dev;
2853 	struct net *net = dev_net(idev->dev);
2854 	int scope, plen;
2855 	u32 pflags = 0;
2856 
2857 	ASSERT_RTNL();
2858 
2859 	memset(&addr, 0, sizeof(struct in6_addr));
2860 	memcpy(&addr.s6_addr32[3], idev->dev->dev_addr, 4);
2861 
2862 	if (idev->dev->flags&IFF_POINTOPOINT) {
2863 		addr.s6_addr32[0] = htonl(0xfe800000);
2864 		scope = IFA_LINK;
2865 		plen = 64;
2866 	} else {
2867 		scope = IPV6_ADDR_COMPATv4;
2868 		plen = 96;
2869 		pflags |= RTF_NONEXTHOP;
2870 	}
2871 
2872 	if (addr.s6_addr32[3]) {
2873 		add_addr(idev, &addr, plen, scope);
2874 		addrconf_prefix_route(&addr, plen, idev->dev, 0, pflags);
2875 		return;
2876 	}
2877 
2878 	for_each_netdev(net, dev) {
2879 		struct in_device *in_dev = __in_dev_get_rtnl(dev);
2880 		if (in_dev && (dev->flags & IFF_UP)) {
2881 			struct in_ifaddr *ifa;
2882 
2883 			int flag = scope;
2884 
2885 			for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
2886 
2887 				addr.s6_addr32[3] = ifa->ifa_local;
2888 
2889 				if (ifa->ifa_scope == RT_SCOPE_LINK)
2890 					continue;
2891 				if (ifa->ifa_scope >= RT_SCOPE_HOST) {
2892 					if (idev->dev->flags&IFF_POINTOPOINT)
2893 						continue;
2894 					flag |= IFA_HOST;
2895 				}
2896 
2897 				add_addr(idev, &addr, plen, flag);
2898 				addrconf_prefix_route(&addr, plen, idev->dev, 0,
2899 						      pflags);
2900 			}
2901 		}
2902 	}
2903 }
2904 #endif
2905 
2906 static void init_loopback(struct net_device *dev)
2907 {
2908 	struct inet6_dev  *idev;
2909 	struct net_device *sp_dev;
2910 	struct inet6_ifaddr *sp_ifa;
2911 	struct rt6_info *sp_rt;
2912 
2913 	/* ::1 */
2914 
2915 	ASSERT_RTNL();
2916 
2917 	idev = ipv6_find_idev(dev);
2918 	if (!idev) {
2919 		pr_debug("%s: add_dev failed\n", __func__);
2920 		return;
2921 	}
2922 
2923 	add_addr(idev, &in6addr_loopback, 128, IFA_HOST);
2924 
2925 	/* Add routes to other interface's IPv6 addresses */
2926 	for_each_netdev(dev_net(dev), sp_dev) {
2927 		if (!strcmp(sp_dev->name, dev->name))
2928 			continue;
2929 
2930 		idev = __in6_dev_get(sp_dev);
2931 		if (!idev)
2932 			continue;
2933 
2934 		read_lock_bh(&idev->lock);
2935 		list_for_each_entry(sp_ifa, &idev->addr_list, if_list) {
2936 
2937 			if (sp_ifa->flags & (IFA_F_DADFAILED | IFA_F_TENTATIVE))
2938 				continue;
2939 
2940 			if (sp_ifa->rt) {
2941 				/* This dst has been added to garbage list when
2942 				 * lo device down, release this obsolete dst and
2943 				 * reallocate a new router for ifa.
2944 				 */
2945 				if (sp_ifa->rt->dst.obsolete > 0) {
2946 					ip6_rt_put(sp_ifa->rt);
2947 					sp_ifa->rt = NULL;
2948 				} else {
2949 					continue;
2950 				}
2951 			}
2952 
2953 			sp_rt = addrconf_dst_alloc(idev, &sp_ifa->addr, false);
2954 
2955 			/* Failure cases are ignored */
2956 			if (!IS_ERR(sp_rt)) {
2957 				sp_ifa->rt = sp_rt;
2958 				ip6_ins_rt(sp_rt);
2959 			}
2960 		}
2961 		read_unlock_bh(&idev->lock);
2962 	}
2963 }
2964 
2965 void addrconf_add_linklocal(struct inet6_dev *idev,
2966 			    const struct in6_addr *addr, u32 flags)
2967 {
2968 	struct inet6_ifaddr *ifp;
2969 	u32 addr_flags = flags | IFA_F_PERMANENT;
2970 
2971 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
2972 	if (idev->cnf.optimistic_dad &&
2973 	    !dev_net(idev->dev)->ipv6.devconf_all->forwarding)
2974 		addr_flags |= IFA_F_OPTIMISTIC;
2975 #endif
2976 
2977 	ifp = ipv6_add_addr(idev, addr, NULL, 64, IFA_LINK, addr_flags,
2978 			    INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
2979 	if (!IS_ERR(ifp)) {
2980 		addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev, 0, 0);
2981 		addrconf_dad_start(ifp);
2982 		in6_ifa_put(ifp);
2983 	}
2984 }
2985 EXPORT_SYMBOL_GPL(addrconf_add_linklocal);
2986 
2987 static bool ipv6_reserved_interfaceid(struct in6_addr address)
2988 {
2989 	if ((address.s6_addr32[2] | address.s6_addr32[3]) == 0)
2990 		return true;
2991 
2992 	if (address.s6_addr32[2] == htonl(0x02005eff) &&
2993 	    ((address.s6_addr32[3] & htonl(0xfe000000)) == htonl(0xfe000000)))
2994 		return true;
2995 
2996 	if (address.s6_addr32[2] == htonl(0xfdffffff) &&
2997 	    ((address.s6_addr32[3] & htonl(0xffffff80)) == htonl(0xffffff80)))
2998 		return true;
2999 
3000 	return false;
3001 }
3002 
3003 static int ipv6_generate_stable_address(struct in6_addr *address,
3004 					u8 dad_count,
3005 					const struct inet6_dev *idev)
3006 {
3007 	static DEFINE_SPINLOCK(lock);
3008 	static __u32 digest[SHA_DIGEST_WORDS];
3009 	static __u32 workspace[SHA_WORKSPACE_WORDS];
3010 
3011 	static union {
3012 		char __data[SHA_MESSAGE_BYTES];
3013 		struct {
3014 			struct in6_addr secret;
3015 			__be32 prefix[2];
3016 			unsigned char hwaddr[MAX_ADDR_LEN];
3017 			u8 dad_count;
3018 		} __packed;
3019 	} data;
3020 
3021 	struct in6_addr secret;
3022 	struct in6_addr temp;
3023 	struct net *net = dev_net(idev->dev);
3024 
3025 	BUILD_BUG_ON(sizeof(data.__data) != sizeof(data));
3026 
3027 	if (idev->cnf.stable_secret.initialized)
3028 		secret = idev->cnf.stable_secret.secret;
3029 	else if (net->ipv6.devconf_dflt->stable_secret.initialized)
3030 		secret = net->ipv6.devconf_dflt->stable_secret.secret;
3031 	else
3032 		return -1;
3033 
3034 retry:
3035 	spin_lock_bh(&lock);
3036 
3037 	sha_init(digest);
3038 	memset(&data, 0, sizeof(data));
3039 	memset(workspace, 0, sizeof(workspace));
3040 	memcpy(data.hwaddr, idev->dev->perm_addr, idev->dev->addr_len);
3041 	data.prefix[0] = address->s6_addr32[0];
3042 	data.prefix[1] = address->s6_addr32[1];
3043 	data.secret = secret;
3044 	data.dad_count = dad_count;
3045 
3046 	sha_transform(digest, data.__data, workspace);
3047 
3048 	temp = *address;
3049 	temp.s6_addr32[2] = (__force __be32)digest[0];
3050 	temp.s6_addr32[3] = (__force __be32)digest[1];
3051 
3052 	spin_unlock_bh(&lock);
3053 
3054 	if (ipv6_reserved_interfaceid(temp)) {
3055 		dad_count++;
3056 		if (dad_count > dev_net(idev->dev)->ipv6.sysctl.idgen_retries)
3057 			return -1;
3058 		goto retry;
3059 	}
3060 
3061 	*address = temp;
3062 	return 0;
3063 }
3064 
3065 static void ipv6_gen_mode_random_init(struct inet6_dev *idev)
3066 {
3067 	struct ipv6_stable_secret *s = &idev->cnf.stable_secret;
3068 
3069 	if (s->initialized)
3070 		return;
3071 	s = &idev->cnf.stable_secret;
3072 	get_random_bytes(&s->secret, sizeof(s->secret));
3073 	s->initialized = true;
3074 }
3075 
3076 static void addrconf_addr_gen(struct inet6_dev *idev, bool prefix_route)
3077 {
3078 	struct in6_addr addr;
3079 
3080 	/* no link local addresses on L3 master devices */
3081 	if (netif_is_l3_master(idev->dev))
3082 		return;
3083 
3084 	ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0);
3085 
3086 	switch (idev->addr_gen_mode) {
3087 	case IN6_ADDR_GEN_MODE_RANDOM:
3088 		ipv6_gen_mode_random_init(idev);
3089 		/* fallthrough */
3090 	case IN6_ADDR_GEN_MODE_STABLE_PRIVACY:
3091 		if (!ipv6_generate_stable_address(&addr, 0, idev))
3092 			addrconf_add_linklocal(idev, &addr,
3093 					       IFA_F_STABLE_PRIVACY);
3094 		else if (prefix_route)
3095 			addrconf_prefix_route(&addr, 64, idev->dev, 0, 0);
3096 		break;
3097 	case IN6_ADDR_GEN_MODE_EUI64:
3098 		/* addrconf_add_linklocal also adds a prefix_route and we
3099 		 * only need to care about prefix routes if ipv6_generate_eui64
3100 		 * couldn't generate one.
3101 		 */
3102 		if (ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) == 0)
3103 			addrconf_add_linklocal(idev, &addr, 0);
3104 		else if (prefix_route)
3105 			addrconf_prefix_route(&addr, 64, idev->dev, 0, 0);
3106 		break;
3107 	case IN6_ADDR_GEN_MODE_NONE:
3108 	default:
3109 		/* will not add any link local address */
3110 		break;
3111 	}
3112 }
3113 
3114 static void addrconf_dev_config(struct net_device *dev)
3115 {
3116 	struct inet6_dev *idev;
3117 
3118 	ASSERT_RTNL();
3119 
3120 	if ((dev->type != ARPHRD_ETHER) &&
3121 	    (dev->type != ARPHRD_FDDI) &&
3122 	    (dev->type != ARPHRD_ARCNET) &&
3123 	    (dev->type != ARPHRD_INFINIBAND) &&
3124 	    (dev->type != ARPHRD_IEEE1394) &&
3125 	    (dev->type != ARPHRD_TUNNEL6) &&
3126 	    (dev->type != ARPHRD_6LOWPAN) &&
3127 	    (dev->type != ARPHRD_NONE)) {
3128 		/* Alas, we support only Ethernet autoconfiguration. */
3129 		return;
3130 	}
3131 
3132 	idev = addrconf_add_dev(dev);
3133 	if (IS_ERR(idev))
3134 		return;
3135 
3136 	/* this device type has no EUI support */
3137 	if (dev->type == ARPHRD_NONE &&
3138 	    idev->addr_gen_mode == IN6_ADDR_GEN_MODE_EUI64)
3139 		idev->addr_gen_mode = IN6_ADDR_GEN_MODE_RANDOM;
3140 
3141 	addrconf_addr_gen(idev, false);
3142 }
3143 
3144 #if IS_ENABLED(CONFIG_IPV6_SIT)
3145 static void addrconf_sit_config(struct net_device *dev)
3146 {
3147 	struct inet6_dev *idev;
3148 
3149 	ASSERT_RTNL();
3150 
3151 	/*
3152 	 * Configure the tunnel with one of our IPv4
3153 	 * addresses... we should configure all of
3154 	 * our v4 addrs in the tunnel
3155 	 */
3156 
3157 	idev = ipv6_find_idev(dev);
3158 	if (!idev) {
3159 		pr_debug("%s: add_dev failed\n", __func__);
3160 		return;
3161 	}
3162 
3163 	if (dev->priv_flags & IFF_ISATAP) {
3164 		addrconf_addr_gen(idev, false);
3165 		return;
3166 	}
3167 
3168 	sit_add_v4_addrs(idev);
3169 
3170 	if (dev->flags&IFF_POINTOPOINT)
3171 		addrconf_add_mroute(dev);
3172 }
3173 #endif
3174 
3175 #if IS_ENABLED(CONFIG_NET_IPGRE)
3176 static void addrconf_gre_config(struct net_device *dev)
3177 {
3178 	struct inet6_dev *idev;
3179 
3180 	ASSERT_RTNL();
3181 
3182 	idev = ipv6_find_idev(dev);
3183 	if (!idev) {
3184 		pr_debug("%s: add_dev failed\n", __func__);
3185 		return;
3186 	}
3187 
3188 	addrconf_addr_gen(idev, true);
3189 	if (dev->flags & IFF_POINTOPOINT)
3190 		addrconf_add_mroute(dev);
3191 }
3192 #endif
3193 
3194 static int fixup_permanent_addr(struct inet6_dev *idev,
3195 				struct inet6_ifaddr *ifp)
3196 {
3197 	if (!ifp->rt) {
3198 		struct rt6_info *rt;
3199 
3200 		rt = addrconf_dst_alloc(idev, &ifp->addr, false);
3201 		if (unlikely(IS_ERR(rt)))
3202 			return PTR_ERR(rt);
3203 
3204 		ifp->rt = rt;
3205 	}
3206 
3207 	if (!(ifp->flags & IFA_F_NOPREFIXROUTE)) {
3208 		addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
3209 				      idev->dev, 0, 0);
3210 	}
3211 
3212 	addrconf_dad_start(ifp);
3213 
3214 	return 0;
3215 }
3216 
3217 static void addrconf_permanent_addr(struct net_device *dev)
3218 {
3219 	struct inet6_ifaddr *ifp, *tmp;
3220 	struct inet6_dev *idev;
3221 
3222 	idev = __in6_dev_get(dev);
3223 	if (!idev)
3224 		return;
3225 
3226 	write_lock_bh(&idev->lock);
3227 
3228 	list_for_each_entry_safe(ifp, tmp, &idev->addr_list, if_list) {
3229 		if ((ifp->flags & IFA_F_PERMANENT) &&
3230 		    fixup_permanent_addr(idev, ifp) < 0) {
3231 			write_unlock_bh(&idev->lock);
3232 			ipv6_del_addr(ifp);
3233 			write_lock_bh(&idev->lock);
3234 
3235 			net_info_ratelimited("%s: Failed to add prefix route for address %pI6c; dropping\n",
3236 					     idev->dev->name, &ifp->addr);
3237 		}
3238 	}
3239 
3240 	write_unlock_bh(&idev->lock);
3241 }
3242 
3243 static int addrconf_notify(struct notifier_block *this, unsigned long event,
3244 			   void *ptr)
3245 {
3246 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3247 	struct netdev_notifier_changeupper_info *info;
3248 	struct inet6_dev *idev = __in6_dev_get(dev);
3249 	int run_pending = 0;
3250 	int err;
3251 
3252 	switch (event) {
3253 	case NETDEV_REGISTER:
3254 		if (!idev && dev->mtu >= IPV6_MIN_MTU) {
3255 			idev = ipv6_add_dev(dev);
3256 			if (IS_ERR(idev))
3257 				return notifier_from_errno(PTR_ERR(idev));
3258 		}
3259 		break;
3260 
3261 	case NETDEV_CHANGEMTU:
3262 		/* if MTU under IPV6_MIN_MTU stop IPv6 on this interface. */
3263 		if (dev->mtu < IPV6_MIN_MTU) {
3264 			addrconf_ifdown(dev, 1);
3265 			break;
3266 		}
3267 
3268 		if (idev) {
3269 			rt6_mtu_change(dev, dev->mtu);
3270 			idev->cnf.mtu6 = dev->mtu;
3271 			break;
3272 		}
3273 
3274 		/* allocate new idev */
3275 		idev = ipv6_add_dev(dev);
3276 		if (IS_ERR(idev))
3277 			break;
3278 
3279 		/* device is still not ready */
3280 		if (!(idev->if_flags & IF_READY))
3281 			break;
3282 
3283 		run_pending = 1;
3284 
3285 		/* fall through */
3286 
3287 	case NETDEV_UP:
3288 	case NETDEV_CHANGE:
3289 		if (dev->flags & IFF_SLAVE)
3290 			break;
3291 
3292 		if (idev && idev->cnf.disable_ipv6)
3293 			break;
3294 
3295 		if (event == NETDEV_UP) {
3296 			/* restore routes for permanent addresses */
3297 			addrconf_permanent_addr(dev);
3298 
3299 			if (!addrconf_qdisc_ok(dev)) {
3300 				/* device is not ready yet. */
3301 				pr_info("ADDRCONF(NETDEV_UP): %s: link is not ready\n",
3302 					dev->name);
3303 				break;
3304 			}
3305 
3306 			if (!idev && dev->mtu >= IPV6_MIN_MTU)
3307 				idev = ipv6_add_dev(dev);
3308 
3309 			if (!IS_ERR_OR_NULL(idev)) {
3310 				idev->if_flags |= IF_READY;
3311 				run_pending = 1;
3312 			}
3313 		} else if (event == NETDEV_CHANGE) {
3314 			if (!addrconf_qdisc_ok(dev)) {
3315 				/* device is still not ready. */
3316 				break;
3317 			}
3318 
3319 			if (idev) {
3320 				if (idev->if_flags & IF_READY)
3321 					/* device is already configured. */
3322 					break;
3323 				idev->if_flags |= IF_READY;
3324 			}
3325 
3326 			pr_info("ADDRCONF(NETDEV_CHANGE): %s: link becomes ready\n",
3327 				dev->name);
3328 
3329 			run_pending = 1;
3330 		}
3331 
3332 		switch (dev->type) {
3333 #if IS_ENABLED(CONFIG_IPV6_SIT)
3334 		case ARPHRD_SIT:
3335 			addrconf_sit_config(dev);
3336 			break;
3337 #endif
3338 #if IS_ENABLED(CONFIG_NET_IPGRE)
3339 		case ARPHRD_IPGRE:
3340 			addrconf_gre_config(dev);
3341 			break;
3342 #endif
3343 		case ARPHRD_LOOPBACK:
3344 			init_loopback(dev);
3345 			break;
3346 
3347 		default:
3348 			addrconf_dev_config(dev);
3349 			break;
3350 		}
3351 
3352 		if (!IS_ERR_OR_NULL(idev)) {
3353 			if (run_pending)
3354 				addrconf_dad_run(idev);
3355 
3356 			/*
3357 			 * If the MTU changed during the interface down,
3358 			 * when the interface up, the changed MTU must be
3359 			 * reflected in the idev as well as routers.
3360 			 */
3361 			if (idev->cnf.mtu6 != dev->mtu &&
3362 			    dev->mtu >= IPV6_MIN_MTU) {
3363 				rt6_mtu_change(dev, dev->mtu);
3364 				idev->cnf.mtu6 = dev->mtu;
3365 			}
3366 			idev->tstamp = jiffies;
3367 			inet6_ifinfo_notify(RTM_NEWLINK, idev);
3368 
3369 			/*
3370 			 * If the changed mtu during down is lower than
3371 			 * IPV6_MIN_MTU stop IPv6 on this interface.
3372 			 */
3373 			if (dev->mtu < IPV6_MIN_MTU)
3374 				addrconf_ifdown(dev, 1);
3375 		}
3376 		break;
3377 
3378 	case NETDEV_DOWN:
3379 	case NETDEV_UNREGISTER:
3380 		/*
3381 		 *	Remove all addresses from this interface.
3382 		 */
3383 		addrconf_ifdown(dev, event != NETDEV_DOWN);
3384 		break;
3385 
3386 	case NETDEV_CHANGENAME:
3387 		if (idev) {
3388 			snmp6_unregister_dev(idev);
3389 			addrconf_sysctl_unregister(idev);
3390 			err = addrconf_sysctl_register(idev);
3391 			if (err)
3392 				return notifier_from_errno(err);
3393 			err = snmp6_register_dev(idev);
3394 			if (err) {
3395 				addrconf_sysctl_unregister(idev);
3396 				return notifier_from_errno(err);
3397 			}
3398 		}
3399 		break;
3400 
3401 	case NETDEV_PRE_TYPE_CHANGE:
3402 	case NETDEV_POST_TYPE_CHANGE:
3403 		if (idev)
3404 			addrconf_type_change(dev, event);
3405 		break;
3406 
3407 	case NETDEV_CHANGEUPPER:
3408 		info = ptr;
3409 
3410 		/* flush all routes if dev is linked to or unlinked from
3411 		 * an L3 master device (e.g., VRF)
3412 		 */
3413 		if (info->upper_dev && netif_is_l3_master(info->upper_dev))
3414 			addrconf_ifdown(dev, 0);
3415 	}
3416 
3417 	return NOTIFY_OK;
3418 }
3419 
3420 /*
3421  *	addrconf module should be notified of a device going up
3422  */
3423 static struct notifier_block ipv6_dev_notf = {
3424 	.notifier_call = addrconf_notify,
3425 };
3426 
3427 static void addrconf_type_change(struct net_device *dev, unsigned long event)
3428 {
3429 	struct inet6_dev *idev;
3430 	ASSERT_RTNL();
3431 
3432 	idev = __in6_dev_get(dev);
3433 
3434 	if (event == NETDEV_POST_TYPE_CHANGE)
3435 		ipv6_mc_remap(idev);
3436 	else if (event == NETDEV_PRE_TYPE_CHANGE)
3437 		ipv6_mc_unmap(idev);
3438 }
3439 
3440 static bool addr_is_local(const struct in6_addr *addr)
3441 {
3442 	return ipv6_addr_type(addr) &
3443 		(IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
3444 }
3445 
3446 static int addrconf_ifdown(struct net_device *dev, int how)
3447 {
3448 	struct net *net = dev_net(dev);
3449 	struct inet6_dev *idev;
3450 	struct inet6_ifaddr *ifa, *tmp;
3451 	struct list_head del_list;
3452 	int _keep_addr;
3453 	bool keep_addr;
3454 	int state, i;
3455 
3456 	ASSERT_RTNL();
3457 
3458 	rt6_ifdown(net, dev);
3459 	neigh_ifdown(&nd_tbl, dev);
3460 
3461 	idev = __in6_dev_get(dev);
3462 	if (!idev)
3463 		return -ENODEV;
3464 
3465 	/*
3466 	 * Step 1: remove reference to ipv6 device from parent device.
3467 	 *	   Do not dev_put!
3468 	 */
3469 	if (how) {
3470 		idev->dead = 1;
3471 
3472 		/* protected by rtnl_lock */
3473 		RCU_INIT_POINTER(dev->ip6_ptr, NULL);
3474 
3475 		/* Step 1.5: remove snmp6 entry */
3476 		snmp6_unregister_dev(idev);
3477 
3478 	}
3479 
3480 	/* aggregate the system setting and interface setting */
3481 	_keep_addr = net->ipv6.devconf_all->keep_addr_on_down;
3482 	if (!_keep_addr)
3483 		_keep_addr = idev->cnf.keep_addr_on_down;
3484 
3485 	/* combine the user config with event to determine if permanent
3486 	 * addresses are to be removed from address hash table
3487 	 */
3488 	keep_addr = !(how || _keep_addr <= 0);
3489 
3490 	/* Step 2: clear hash table */
3491 	for (i = 0; i < IN6_ADDR_HSIZE; i++) {
3492 		struct hlist_head *h = &inet6_addr_lst[i];
3493 
3494 		spin_lock_bh(&addrconf_hash_lock);
3495 restart:
3496 		hlist_for_each_entry_rcu(ifa, h, addr_lst) {
3497 			if (ifa->idev == idev) {
3498 				addrconf_del_dad_work(ifa);
3499 				/* combined flag + permanent flag decide if
3500 				 * address is retained on a down event
3501 				 */
3502 				if (!keep_addr ||
3503 				    !(ifa->flags & IFA_F_PERMANENT) ||
3504 				    addr_is_local(&ifa->addr)) {
3505 					hlist_del_init_rcu(&ifa->addr_lst);
3506 					goto restart;
3507 				}
3508 			}
3509 		}
3510 		spin_unlock_bh(&addrconf_hash_lock);
3511 	}
3512 
3513 	write_lock_bh(&idev->lock);
3514 
3515 	addrconf_del_rs_timer(idev);
3516 
3517 	/* Step 2: clear flags for stateless addrconf */
3518 	if (!how)
3519 		idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY);
3520 
3521 	if (how && del_timer(&idev->regen_timer))
3522 		in6_dev_put(idev);
3523 
3524 	/* Step 3: clear tempaddr list */
3525 	while (!list_empty(&idev->tempaddr_list)) {
3526 		ifa = list_first_entry(&idev->tempaddr_list,
3527 				       struct inet6_ifaddr, tmp_list);
3528 		list_del(&ifa->tmp_list);
3529 		write_unlock_bh(&idev->lock);
3530 		spin_lock_bh(&ifa->lock);
3531 
3532 		if (ifa->ifpub) {
3533 			in6_ifa_put(ifa->ifpub);
3534 			ifa->ifpub = NULL;
3535 		}
3536 		spin_unlock_bh(&ifa->lock);
3537 		in6_ifa_put(ifa);
3538 		write_lock_bh(&idev->lock);
3539 	}
3540 
3541 	/* re-combine the user config with event to determine if permanent
3542 	 * addresses are to be removed from the interface list
3543 	 */
3544 	keep_addr = (!how && _keep_addr > 0);
3545 
3546 	INIT_LIST_HEAD(&del_list);
3547 	list_for_each_entry_safe(ifa, tmp, &idev->addr_list, if_list) {
3548 		struct rt6_info *rt = NULL;
3549 
3550 		addrconf_del_dad_work(ifa);
3551 
3552 		write_unlock_bh(&idev->lock);
3553 		spin_lock_bh(&ifa->lock);
3554 
3555 		if (keep_addr && (ifa->flags & IFA_F_PERMANENT) &&
3556 		    !addr_is_local(&ifa->addr)) {
3557 			/* set state to skip the notifier below */
3558 			state = INET6_IFADDR_STATE_DEAD;
3559 			ifa->state = 0;
3560 			if (!(ifa->flags & IFA_F_NODAD))
3561 				ifa->flags |= IFA_F_TENTATIVE;
3562 
3563 			rt = ifa->rt;
3564 			ifa->rt = NULL;
3565 		} else {
3566 			state = ifa->state;
3567 			ifa->state = INET6_IFADDR_STATE_DEAD;
3568 
3569 			list_del(&ifa->if_list);
3570 			list_add(&ifa->if_list, &del_list);
3571 		}
3572 
3573 		spin_unlock_bh(&ifa->lock);
3574 
3575 		if (rt)
3576 			ip6_del_rt(rt);
3577 
3578 		if (state != INET6_IFADDR_STATE_DEAD) {
3579 			__ipv6_ifa_notify(RTM_DELADDR, ifa);
3580 			inet6addr_notifier_call_chain(NETDEV_DOWN, ifa);
3581 		}
3582 
3583 		write_lock_bh(&idev->lock);
3584 	}
3585 
3586 	write_unlock_bh(&idev->lock);
3587 
3588 	/* now clean up addresses to be removed */
3589 	while (!list_empty(&del_list)) {
3590 		ifa = list_first_entry(&del_list,
3591 				       struct inet6_ifaddr, if_list);
3592 		list_del(&ifa->if_list);
3593 
3594 		in6_ifa_put(ifa);
3595 	}
3596 
3597 	/* Step 5: Discard anycast and multicast list */
3598 	if (how) {
3599 		ipv6_ac_destroy_dev(idev);
3600 		ipv6_mc_destroy_dev(idev);
3601 	} else {
3602 		ipv6_mc_down(idev);
3603 	}
3604 
3605 	idev->tstamp = jiffies;
3606 
3607 	/* Last: Shot the device (if unregistered) */
3608 	if (how) {
3609 		addrconf_sysctl_unregister(idev);
3610 		neigh_parms_release(&nd_tbl, idev->nd_parms);
3611 		neigh_ifdown(&nd_tbl, dev);
3612 		in6_dev_put(idev);
3613 	}
3614 	return 0;
3615 }
3616 
3617 static void addrconf_rs_timer(unsigned long data)
3618 {
3619 	struct inet6_dev *idev = (struct inet6_dev *)data;
3620 	struct net_device *dev = idev->dev;
3621 	struct in6_addr lladdr;
3622 
3623 	write_lock(&idev->lock);
3624 	if (idev->dead || !(idev->if_flags & IF_READY))
3625 		goto out;
3626 
3627 	if (!ipv6_accept_ra(idev))
3628 		goto out;
3629 
3630 	/* Announcement received after solicitation was sent */
3631 	if (idev->if_flags & IF_RA_RCVD)
3632 		goto out;
3633 
3634 	if (idev->rs_probes++ < idev->cnf.rtr_solicits) {
3635 		write_unlock(&idev->lock);
3636 		if (!ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
3637 			ndisc_send_rs(dev, &lladdr,
3638 				      &in6addr_linklocal_allrouters);
3639 		else
3640 			goto put;
3641 
3642 		write_lock(&idev->lock);
3643 		/* The wait after the last probe can be shorter */
3644 		addrconf_mod_rs_timer(idev, (idev->rs_probes ==
3645 					     idev->cnf.rtr_solicits) ?
3646 				      idev->cnf.rtr_solicit_delay :
3647 				      idev->cnf.rtr_solicit_interval);
3648 	} else {
3649 		/*
3650 		 * Note: we do not support deprecated "all on-link"
3651 		 * assumption any longer.
3652 		 */
3653 		pr_debug("%s: no IPv6 routers present\n", idev->dev->name);
3654 	}
3655 
3656 out:
3657 	write_unlock(&idev->lock);
3658 put:
3659 	in6_dev_put(idev);
3660 }
3661 
3662 /*
3663  *	Duplicate Address Detection
3664  */
3665 static void addrconf_dad_kick(struct inet6_ifaddr *ifp)
3666 {
3667 	unsigned long rand_num;
3668 	struct inet6_dev *idev = ifp->idev;
3669 
3670 	if (ifp->flags & IFA_F_OPTIMISTIC)
3671 		rand_num = 0;
3672 	else
3673 		rand_num = prandom_u32() % (idev->cnf.rtr_solicit_delay ? : 1);
3674 
3675 	ifp->dad_probes = idev->cnf.dad_transmits;
3676 	addrconf_mod_dad_work(ifp, rand_num);
3677 }
3678 
3679 static void addrconf_dad_begin(struct inet6_ifaddr *ifp)
3680 {
3681 	struct inet6_dev *idev = ifp->idev;
3682 	struct net_device *dev = idev->dev;
3683 	bool notify = false;
3684 
3685 	addrconf_join_solict(dev, &ifp->addr);
3686 
3687 	prandom_seed((__force u32) ifp->addr.s6_addr32[3]);
3688 
3689 	read_lock_bh(&idev->lock);
3690 	spin_lock(&ifp->lock);
3691 	if (ifp->state == INET6_IFADDR_STATE_DEAD)
3692 		goto out;
3693 
3694 	if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) ||
3695 	    idev->cnf.accept_dad < 1 ||
3696 	    !(ifp->flags&IFA_F_TENTATIVE) ||
3697 	    ifp->flags & IFA_F_NODAD) {
3698 		ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
3699 		spin_unlock(&ifp->lock);
3700 		read_unlock_bh(&idev->lock);
3701 
3702 		addrconf_dad_completed(ifp);
3703 		return;
3704 	}
3705 
3706 	if (!(idev->if_flags & IF_READY)) {
3707 		spin_unlock(&ifp->lock);
3708 		read_unlock_bh(&idev->lock);
3709 		/*
3710 		 * If the device is not ready:
3711 		 * - keep it tentative if it is a permanent address.
3712 		 * - otherwise, kill it.
3713 		 */
3714 		in6_ifa_hold(ifp);
3715 		addrconf_dad_stop(ifp, 0);
3716 		return;
3717 	}
3718 
3719 	/*
3720 	 * Optimistic nodes can start receiving
3721 	 * Frames right away
3722 	 */
3723 	if (ifp->flags & IFA_F_OPTIMISTIC) {
3724 		ip6_ins_rt(ifp->rt);
3725 		if (ipv6_use_optimistic_addr(idev)) {
3726 			/* Because optimistic nodes can use this address,
3727 			 * notify listeners. If DAD fails, RTM_DELADDR is sent.
3728 			 */
3729 			notify = true;
3730 		}
3731 	}
3732 
3733 	addrconf_dad_kick(ifp);
3734 out:
3735 	spin_unlock(&ifp->lock);
3736 	read_unlock_bh(&idev->lock);
3737 	if (notify)
3738 		ipv6_ifa_notify(RTM_NEWADDR, ifp);
3739 }
3740 
3741 static void addrconf_dad_start(struct inet6_ifaddr *ifp)
3742 {
3743 	bool begin_dad = false;
3744 
3745 	spin_lock_bh(&ifp->lock);
3746 	if (ifp->state != INET6_IFADDR_STATE_DEAD) {
3747 		ifp->state = INET6_IFADDR_STATE_PREDAD;
3748 		begin_dad = true;
3749 	}
3750 	spin_unlock_bh(&ifp->lock);
3751 
3752 	if (begin_dad)
3753 		addrconf_mod_dad_work(ifp, 0);
3754 }
3755 
3756 static void addrconf_dad_work(struct work_struct *w)
3757 {
3758 	struct inet6_ifaddr *ifp = container_of(to_delayed_work(w),
3759 						struct inet6_ifaddr,
3760 						dad_work);
3761 	struct inet6_dev *idev = ifp->idev;
3762 	struct in6_addr mcaddr;
3763 
3764 	enum {
3765 		DAD_PROCESS,
3766 		DAD_BEGIN,
3767 		DAD_ABORT,
3768 	} action = DAD_PROCESS;
3769 
3770 	rtnl_lock();
3771 
3772 	spin_lock_bh(&ifp->lock);
3773 	if (ifp->state == INET6_IFADDR_STATE_PREDAD) {
3774 		action = DAD_BEGIN;
3775 		ifp->state = INET6_IFADDR_STATE_DAD;
3776 	} else if (ifp->state == INET6_IFADDR_STATE_ERRDAD) {
3777 		action = DAD_ABORT;
3778 		ifp->state = INET6_IFADDR_STATE_POSTDAD;
3779 	}
3780 	spin_unlock_bh(&ifp->lock);
3781 
3782 	if (action == DAD_BEGIN) {
3783 		addrconf_dad_begin(ifp);
3784 		goto out;
3785 	} else if (action == DAD_ABORT) {
3786 		addrconf_dad_stop(ifp, 1);
3787 		goto out;
3788 	}
3789 
3790 	if (!ifp->dad_probes && addrconf_dad_end(ifp))
3791 		goto out;
3792 
3793 	write_lock_bh(&idev->lock);
3794 	if (idev->dead || !(idev->if_flags & IF_READY)) {
3795 		write_unlock_bh(&idev->lock);
3796 		goto out;
3797 	}
3798 
3799 	spin_lock(&ifp->lock);
3800 	if (ifp->state == INET6_IFADDR_STATE_DEAD) {
3801 		spin_unlock(&ifp->lock);
3802 		write_unlock_bh(&idev->lock);
3803 		goto out;
3804 	}
3805 
3806 	if (ifp->dad_probes == 0) {
3807 		/*
3808 		 * DAD was successful
3809 		 */
3810 
3811 		ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
3812 		spin_unlock(&ifp->lock);
3813 		write_unlock_bh(&idev->lock);
3814 
3815 		addrconf_dad_completed(ifp);
3816 
3817 		goto out;
3818 	}
3819 
3820 	ifp->dad_probes--;
3821 	addrconf_mod_dad_work(ifp,
3822 			      NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME));
3823 	spin_unlock(&ifp->lock);
3824 	write_unlock_bh(&idev->lock);
3825 
3826 	/* send a neighbour solicitation for our addr */
3827 	addrconf_addr_solict_mult(&ifp->addr, &mcaddr);
3828 	ndisc_send_ns(ifp->idev->dev, &ifp->addr, &mcaddr, &in6addr_any);
3829 out:
3830 	in6_ifa_put(ifp);
3831 	rtnl_unlock();
3832 }
3833 
3834 /* ifp->idev must be at least read locked */
3835 static bool ipv6_lonely_lladdr(struct inet6_ifaddr *ifp)
3836 {
3837 	struct inet6_ifaddr *ifpiter;
3838 	struct inet6_dev *idev = ifp->idev;
3839 
3840 	list_for_each_entry_reverse(ifpiter, &idev->addr_list, if_list) {
3841 		if (ifpiter->scope > IFA_LINK)
3842 			break;
3843 		if (ifp != ifpiter && ifpiter->scope == IFA_LINK &&
3844 		    (ifpiter->flags & (IFA_F_PERMANENT|IFA_F_TENTATIVE|
3845 				       IFA_F_OPTIMISTIC|IFA_F_DADFAILED)) ==
3846 		    IFA_F_PERMANENT)
3847 			return false;
3848 	}
3849 	return true;
3850 }
3851 
3852 static void addrconf_dad_completed(struct inet6_ifaddr *ifp)
3853 {
3854 	struct net_device *dev = ifp->idev->dev;
3855 	struct in6_addr lladdr;
3856 	bool send_rs, send_mld;
3857 
3858 	addrconf_del_dad_work(ifp);
3859 
3860 	/*
3861 	 *	Configure the address for reception. Now it is valid.
3862 	 */
3863 
3864 	ipv6_ifa_notify(RTM_NEWADDR, ifp);
3865 
3866 	/* If added prefix is link local and we are prepared to process
3867 	   router advertisements, start sending router solicitations.
3868 	 */
3869 
3870 	read_lock_bh(&ifp->idev->lock);
3871 	send_mld = ifp->scope == IFA_LINK && ipv6_lonely_lladdr(ifp);
3872 	send_rs = send_mld &&
3873 		  ipv6_accept_ra(ifp->idev) &&
3874 		  ifp->idev->cnf.rtr_solicits > 0 &&
3875 		  (dev->flags&IFF_LOOPBACK) == 0;
3876 	read_unlock_bh(&ifp->idev->lock);
3877 
3878 	/* While dad is in progress mld report's source address is in6_addrany.
3879 	 * Resend with proper ll now.
3880 	 */
3881 	if (send_mld)
3882 		ipv6_mc_dad_complete(ifp->idev);
3883 
3884 	if (send_rs) {
3885 		/*
3886 		 *	If a host as already performed a random delay
3887 		 *	[...] as part of DAD [...] there is no need
3888 		 *	to delay again before sending the first RS
3889 		 */
3890 		if (ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
3891 			return;
3892 		ndisc_send_rs(dev, &lladdr, &in6addr_linklocal_allrouters);
3893 
3894 		write_lock_bh(&ifp->idev->lock);
3895 		spin_lock(&ifp->lock);
3896 		ifp->idev->rs_probes = 1;
3897 		ifp->idev->if_flags |= IF_RS_SENT;
3898 		addrconf_mod_rs_timer(ifp->idev,
3899 				      ifp->idev->cnf.rtr_solicit_interval);
3900 		spin_unlock(&ifp->lock);
3901 		write_unlock_bh(&ifp->idev->lock);
3902 	}
3903 }
3904 
3905 static void addrconf_dad_run(struct inet6_dev *idev)
3906 {
3907 	struct inet6_ifaddr *ifp;
3908 
3909 	read_lock_bh(&idev->lock);
3910 	list_for_each_entry(ifp, &idev->addr_list, if_list) {
3911 		spin_lock(&ifp->lock);
3912 		if (ifp->flags & IFA_F_TENTATIVE &&
3913 		    ifp->state == INET6_IFADDR_STATE_DAD)
3914 			addrconf_dad_kick(ifp);
3915 		spin_unlock(&ifp->lock);
3916 	}
3917 	read_unlock_bh(&idev->lock);
3918 }
3919 
3920 #ifdef CONFIG_PROC_FS
3921 struct if6_iter_state {
3922 	struct seq_net_private p;
3923 	int bucket;
3924 	int offset;
3925 };
3926 
3927 static struct inet6_ifaddr *if6_get_first(struct seq_file *seq, loff_t pos)
3928 {
3929 	struct inet6_ifaddr *ifa = NULL;
3930 	struct if6_iter_state *state = seq->private;
3931 	struct net *net = seq_file_net(seq);
3932 	int p = 0;
3933 
3934 	/* initial bucket if pos is 0 */
3935 	if (pos == 0) {
3936 		state->bucket = 0;
3937 		state->offset = 0;
3938 	}
3939 
3940 	for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {
3941 		hlist_for_each_entry_rcu_bh(ifa, &inet6_addr_lst[state->bucket],
3942 					 addr_lst) {
3943 			if (!net_eq(dev_net(ifa->idev->dev), net))
3944 				continue;
3945 			/* sync with offset */
3946 			if (p < state->offset) {
3947 				p++;
3948 				continue;
3949 			}
3950 			state->offset++;
3951 			return ifa;
3952 		}
3953 
3954 		/* prepare for next bucket */
3955 		state->offset = 0;
3956 		p = 0;
3957 	}
3958 	return NULL;
3959 }
3960 
3961 static struct inet6_ifaddr *if6_get_next(struct seq_file *seq,
3962 					 struct inet6_ifaddr *ifa)
3963 {
3964 	struct if6_iter_state *state = seq->private;
3965 	struct net *net = seq_file_net(seq);
3966 
3967 	hlist_for_each_entry_continue_rcu_bh(ifa, addr_lst) {
3968 		if (!net_eq(dev_net(ifa->idev->dev), net))
3969 			continue;
3970 		state->offset++;
3971 		return ifa;
3972 	}
3973 
3974 	while (++state->bucket < IN6_ADDR_HSIZE) {
3975 		state->offset = 0;
3976 		hlist_for_each_entry_rcu_bh(ifa,
3977 				     &inet6_addr_lst[state->bucket], addr_lst) {
3978 			if (!net_eq(dev_net(ifa->idev->dev), net))
3979 				continue;
3980 			state->offset++;
3981 			return ifa;
3982 		}
3983 	}
3984 
3985 	return NULL;
3986 }
3987 
3988 static void *if6_seq_start(struct seq_file *seq, loff_t *pos)
3989 	__acquires(rcu_bh)
3990 {
3991 	rcu_read_lock_bh();
3992 	return if6_get_first(seq, *pos);
3993 }
3994 
3995 static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3996 {
3997 	struct inet6_ifaddr *ifa;
3998 
3999 	ifa = if6_get_next(seq, v);
4000 	++*pos;
4001 	return ifa;
4002 }
4003 
4004 static void if6_seq_stop(struct seq_file *seq, void *v)
4005 	__releases(rcu_bh)
4006 {
4007 	rcu_read_unlock_bh();
4008 }
4009 
4010 static int if6_seq_show(struct seq_file *seq, void *v)
4011 {
4012 	struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v;
4013 	seq_printf(seq, "%pi6 %02x %02x %02x %02x %8s\n",
4014 		   &ifp->addr,
4015 		   ifp->idev->dev->ifindex,
4016 		   ifp->prefix_len,
4017 		   ifp->scope,
4018 		   (u8) ifp->flags,
4019 		   ifp->idev->dev->name);
4020 	return 0;
4021 }
4022 
4023 static const struct seq_operations if6_seq_ops = {
4024 	.start	= if6_seq_start,
4025 	.next	= if6_seq_next,
4026 	.show	= if6_seq_show,
4027 	.stop	= if6_seq_stop,
4028 };
4029 
4030 static int if6_seq_open(struct inode *inode, struct file *file)
4031 {
4032 	return seq_open_net(inode, file, &if6_seq_ops,
4033 			    sizeof(struct if6_iter_state));
4034 }
4035 
4036 static const struct file_operations if6_fops = {
4037 	.owner		= THIS_MODULE,
4038 	.open		= if6_seq_open,
4039 	.read		= seq_read,
4040 	.llseek		= seq_lseek,
4041 	.release	= seq_release_net,
4042 };
4043 
4044 static int __net_init if6_proc_net_init(struct net *net)
4045 {
4046 	if (!proc_create("if_inet6", S_IRUGO, net->proc_net, &if6_fops))
4047 		return -ENOMEM;
4048 	return 0;
4049 }
4050 
4051 static void __net_exit if6_proc_net_exit(struct net *net)
4052 {
4053 	remove_proc_entry("if_inet6", net->proc_net);
4054 }
4055 
4056 static struct pernet_operations if6_proc_net_ops = {
4057 	.init = if6_proc_net_init,
4058 	.exit = if6_proc_net_exit,
4059 };
4060 
4061 int __init if6_proc_init(void)
4062 {
4063 	return register_pernet_subsys(&if6_proc_net_ops);
4064 }
4065 
4066 void if6_proc_exit(void)
4067 {
4068 	unregister_pernet_subsys(&if6_proc_net_ops);
4069 }
4070 #endif	/* CONFIG_PROC_FS */
4071 
4072 #if IS_ENABLED(CONFIG_IPV6_MIP6)
4073 /* Check if address is a home address configured on any interface. */
4074 int ipv6_chk_home_addr(struct net *net, const struct in6_addr *addr)
4075 {
4076 	int ret = 0;
4077 	struct inet6_ifaddr *ifp = NULL;
4078 	unsigned int hash = inet6_addr_hash(addr);
4079 
4080 	rcu_read_lock_bh();
4081 	hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) {
4082 		if (!net_eq(dev_net(ifp->idev->dev), net))
4083 			continue;
4084 		if (ipv6_addr_equal(&ifp->addr, addr) &&
4085 		    (ifp->flags & IFA_F_HOMEADDRESS)) {
4086 			ret = 1;
4087 			break;
4088 		}
4089 	}
4090 	rcu_read_unlock_bh();
4091 	return ret;
4092 }
4093 #endif
4094 
4095 /*
4096  *	Periodic address status verification
4097  */
4098 
4099 static void addrconf_verify_rtnl(void)
4100 {
4101 	unsigned long now, next, next_sec, next_sched;
4102 	struct inet6_ifaddr *ifp;
4103 	int i;
4104 
4105 	ASSERT_RTNL();
4106 
4107 	rcu_read_lock_bh();
4108 	now = jiffies;
4109 	next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
4110 
4111 	cancel_delayed_work(&addr_chk_work);
4112 
4113 	for (i = 0; i < IN6_ADDR_HSIZE; i++) {
4114 restart:
4115 		hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[i], addr_lst) {
4116 			unsigned long age;
4117 
4118 			/* When setting preferred_lft to a value not zero or
4119 			 * infinity, while valid_lft is infinity
4120 			 * IFA_F_PERMANENT has a non-infinity life time.
4121 			 */
4122 			if ((ifp->flags & IFA_F_PERMANENT) &&
4123 			    (ifp->prefered_lft == INFINITY_LIFE_TIME))
4124 				continue;
4125 
4126 			spin_lock(&ifp->lock);
4127 			/* We try to batch several events at once. */
4128 			age = (now - ifp->tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
4129 
4130 			if (ifp->valid_lft != INFINITY_LIFE_TIME &&
4131 			    age >= ifp->valid_lft) {
4132 				spin_unlock(&ifp->lock);
4133 				in6_ifa_hold(ifp);
4134 				ipv6_del_addr(ifp);
4135 				goto restart;
4136 			} else if (ifp->prefered_lft == INFINITY_LIFE_TIME) {
4137 				spin_unlock(&ifp->lock);
4138 				continue;
4139 			} else if (age >= ifp->prefered_lft) {
4140 				/* jiffies - ifp->tstamp > age >= ifp->prefered_lft */
4141 				int deprecate = 0;
4142 
4143 				if (!(ifp->flags&IFA_F_DEPRECATED)) {
4144 					deprecate = 1;
4145 					ifp->flags |= IFA_F_DEPRECATED;
4146 				}
4147 
4148 				if ((ifp->valid_lft != INFINITY_LIFE_TIME) &&
4149 				    (time_before(ifp->tstamp + ifp->valid_lft * HZ, next)))
4150 					next = ifp->tstamp + ifp->valid_lft * HZ;
4151 
4152 				spin_unlock(&ifp->lock);
4153 
4154 				if (deprecate) {
4155 					in6_ifa_hold(ifp);
4156 
4157 					ipv6_ifa_notify(0, ifp);
4158 					in6_ifa_put(ifp);
4159 					goto restart;
4160 				}
4161 			} else if ((ifp->flags&IFA_F_TEMPORARY) &&
4162 				   !(ifp->flags&IFA_F_TENTATIVE)) {
4163 				unsigned long regen_advance = ifp->idev->cnf.regen_max_retry *
4164 					ifp->idev->cnf.dad_transmits *
4165 					NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME) / HZ;
4166 
4167 				if (age >= ifp->prefered_lft - regen_advance) {
4168 					struct inet6_ifaddr *ifpub = ifp->ifpub;
4169 					if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
4170 						next = ifp->tstamp + ifp->prefered_lft * HZ;
4171 					if (!ifp->regen_count && ifpub) {
4172 						ifp->regen_count++;
4173 						in6_ifa_hold(ifp);
4174 						in6_ifa_hold(ifpub);
4175 						spin_unlock(&ifp->lock);
4176 
4177 						spin_lock(&ifpub->lock);
4178 						ifpub->regen_count = 0;
4179 						spin_unlock(&ifpub->lock);
4180 						ipv6_create_tempaddr(ifpub, ifp);
4181 						in6_ifa_put(ifpub);
4182 						in6_ifa_put(ifp);
4183 						goto restart;
4184 					}
4185 				} else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next))
4186 					next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ;
4187 				spin_unlock(&ifp->lock);
4188 			} else {
4189 				/* ifp->prefered_lft <= ifp->valid_lft */
4190 				if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
4191 					next = ifp->tstamp + ifp->prefered_lft * HZ;
4192 				spin_unlock(&ifp->lock);
4193 			}
4194 		}
4195 	}
4196 
4197 	next_sec = round_jiffies_up(next);
4198 	next_sched = next;
4199 
4200 	/* If rounded timeout is accurate enough, accept it. */
4201 	if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
4202 		next_sched = next_sec;
4203 
4204 	/* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
4205 	if (time_before(next_sched, jiffies + ADDRCONF_TIMER_FUZZ_MAX))
4206 		next_sched = jiffies + ADDRCONF_TIMER_FUZZ_MAX;
4207 
4208 	ADBG(KERN_DEBUG "now = %lu, schedule = %lu, rounded schedule = %lu => %lu\n",
4209 	      now, next, next_sec, next_sched);
4210 	mod_delayed_work(addrconf_wq, &addr_chk_work, next_sched - now);
4211 	rcu_read_unlock_bh();
4212 }
4213 
4214 static void addrconf_verify_work(struct work_struct *w)
4215 {
4216 	rtnl_lock();
4217 	addrconf_verify_rtnl();
4218 	rtnl_unlock();
4219 }
4220 
4221 static void addrconf_verify(void)
4222 {
4223 	mod_delayed_work(addrconf_wq, &addr_chk_work, 0);
4224 }
4225 
4226 static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local,
4227 				     struct in6_addr **peer_pfx)
4228 {
4229 	struct in6_addr *pfx = NULL;
4230 
4231 	*peer_pfx = NULL;
4232 
4233 	if (addr)
4234 		pfx = nla_data(addr);
4235 
4236 	if (local) {
4237 		if (pfx && nla_memcmp(local, pfx, sizeof(*pfx)))
4238 			*peer_pfx = pfx;
4239 		pfx = nla_data(local);
4240 	}
4241 
4242 	return pfx;
4243 }
4244 
4245 static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = {
4246 	[IFA_ADDRESS]		= { .len = sizeof(struct in6_addr) },
4247 	[IFA_LOCAL]		= { .len = sizeof(struct in6_addr) },
4248 	[IFA_CACHEINFO]		= { .len = sizeof(struct ifa_cacheinfo) },
4249 	[IFA_FLAGS]		= { .len = sizeof(u32) },
4250 };
4251 
4252 static int
4253 inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
4254 {
4255 	struct net *net = sock_net(skb->sk);
4256 	struct ifaddrmsg *ifm;
4257 	struct nlattr *tb[IFA_MAX+1];
4258 	struct in6_addr *pfx, *peer_pfx;
4259 	u32 ifa_flags;
4260 	int err;
4261 
4262 	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
4263 	if (err < 0)
4264 		return err;
4265 
4266 	ifm = nlmsg_data(nlh);
4267 	pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
4268 	if (!pfx)
4269 		return -EINVAL;
4270 
4271 	ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;
4272 
4273 	/* We ignore other flags so far. */
4274 	ifa_flags &= IFA_F_MANAGETEMPADDR;
4275 
4276 	return inet6_addr_del(net, ifm->ifa_index, ifa_flags, pfx,
4277 			      ifm->ifa_prefixlen);
4278 }
4279 
4280 static int inet6_addr_modify(struct inet6_ifaddr *ifp, u32 ifa_flags,
4281 			     u32 prefered_lft, u32 valid_lft)
4282 {
4283 	u32 flags;
4284 	clock_t expires;
4285 	unsigned long timeout;
4286 	bool was_managetempaddr;
4287 	bool had_prefixroute;
4288 
4289 	ASSERT_RTNL();
4290 
4291 	if (!valid_lft || (prefered_lft > valid_lft))
4292 		return -EINVAL;
4293 
4294 	if (ifa_flags & IFA_F_MANAGETEMPADDR &&
4295 	    (ifp->flags & IFA_F_TEMPORARY || ifp->prefix_len != 64))
4296 		return -EINVAL;
4297 
4298 	timeout = addrconf_timeout_fixup(valid_lft, HZ);
4299 	if (addrconf_finite_timeout(timeout)) {
4300 		expires = jiffies_to_clock_t(timeout * HZ);
4301 		valid_lft = timeout;
4302 		flags = RTF_EXPIRES;
4303 	} else {
4304 		expires = 0;
4305 		flags = 0;
4306 		ifa_flags |= IFA_F_PERMANENT;
4307 	}
4308 
4309 	timeout = addrconf_timeout_fixup(prefered_lft, HZ);
4310 	if (addrconf_finite_timeout(timeout)) {
4311 		if (timeout == 0)
4312 			ifa_flags |= IFA_F_DEPRECATED;
4313 		prefered_lft = timeout;
4314 	}
4315 
4316 	spin_lock_bh(&ifp->lock);
4317 	was_managetempaddr = ifp->flags & IFA_F_MANAGETEMPADDR;
4318 	had_prefixroute = ifp->flags & IFA_F_PERMANENT &&
4319 			  !(ifp->flags & IFA_F_NOPREFIXROUTE);
4320 	ifp->flags &= ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD |
4321 			IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR |
4322 			IFA_F_NOPREFIXROUTE);
4323 	ifp->flags |= ifa_flags;
4324 	ifp->tstamp = jiffies;
4325 	ifp->valid_lft = valid_lft;
4326 	ifp->prefered_lft = prefered_lft;
4327 
4328 	spin_unlock_bh(&ifp->lock);
4329 	if (!(ifp->flags&IFA_F_TENTATIVE))
4330 		ipv6_ifa_notify(0, ifp);
4331 
4332 	if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) {
4333 		addrconf_prefix_route(&ifp->addr, ifp->prefix_len, ifp->idev->dev,
4334 				      expires, flags);
4335 	} else if (had_prefixroute) {
4336 		enum cleanup_prefix_rt_t action;
4337 		unsigned long rt_expires;
4338 
4339 		write_lock_bh(&ifp->idev->lock);
4340 		action = check_cleanup_prefix_route(ifp, &rt_expires);
4341 		write_unlock_bh(&ifp->idev->lock);
4342 
4343 		if (action != CLEANUP_PREFIX_RT_NOP) {
4344 			cleanup_prefix_route(ifp, rt_expires,
4345 				action == CLEANUP_PREFIX_RT_DEL);
4346 		}
4347 	}
4348 
4349 	if (was_managetempaddr || ifp->flags & IFA_F_MANAGETEMPADDR) {
4350 		if (was_managetempaddr && !(ifp->flags & IFA_F_MANAGETEMPADDR))
4351 			valid_lft = prefered_lft = 0;
4352 		manage_tempaddrs(ifp->idev, ifp, valid_lft, prefered_lft,
4353 				 !was_managetempaddr, jiffies);
4354 	}
4355 
4356 	addrconf_verify_rtnl();
4357 
4358 	return 0;
4359 }
4360 
4361 static int
4362 inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
4363 {
4364 	struct net *net = sock_net(skb->sk);
4365 	struct ifaddrmsg *ifm;
4366 	struct nlattr *tb[IFA_MAX+1];
4367 	struct in6_addr *pfx, *peer_pfx;
4368 	struct inet6_ifaddr *ifa;
4369 	struct net_device *dev;
4370 	u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME;
4371 	u32 ifa_flags;
4372 	int err;
4373 
4374 	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
4375 	if (err < 0)
4376 		return err;
4377 
4378 	ifm = nlmsg_data(nlh);
4379 	pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
4380 	if (!pfx)
4381 		return -EINVAL;
4382 
4383 	if (tb[IFA_CACHEINFO]) {
4384 		struct ifa_cacheinfo *ci;
4385 
4386 		ci = nla_data(tb[IFA_CACHEINFO]);
4387 		valid_lft = ci->ifa_valid;
4388 		preferred_lft = ci->ifa_prefered;
4389 	} else {
4390 		preferred_lft = INFINITY_LIFE_TIME;
4391 		valid_lft = INFINITY_LIFE_TIME;
4392 	}
4393 
4394 	dev =  __dev_get_by_index(net, ifm->ifa_index);
4395 	if (!dev)
4396 		return -ENODEV;
4397 
4398 	ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;
4399 
4400 	/* We ignore other flags so far. */
4401 	ifa_flags &= IFA_F_NODAD | IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR |
4402 		     IFA_F_NOPREFIXROUTE | IFA_F_MCAUTOJOIN;
4403 
4404 	ifa = ipv6_get_ifaddr(net, pfx, dev, 1);
4405 	if (!ifa) {
4406 		/*
4407 		 * It would be best to check for !NLM_F_CREATE here but
4408 		 * userspace already relies on not having to provide this.
4409 		 */
4410 		return inet6_addr_add(net, ifm->ifa_index, pfx, peer_pfx,
4411 				      ifm->ifa_prefixlen, ifa_flags,
4412 				      preferred_lft, valid_lft);
4413 	}
4414 
4415 	if (nlh->nlmsg_flags & NLM_F_EXCL ||
4416 	    !(nlh->nlmsg_flags & NLM_F_REPLACE))
4417 		err = -EEXIST;
4418 	else
4419 		err = inet6_addr_modify(ifa, ifa_flags, preferred_lft, valid_lft);
4420 
4421 	in6_ifa_put(ifa);
4422 
4423 	return err;
4424 }
4425 
4426 static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u32 flags,
4427 			  u8 scope, int ifindex)
4428 {
4429 	struct ifaddrmsg *ifm;
4430 
4431 	ifm = nlmsg_data(nlh);
4432 	ifm->ifa_family = AF_INET6;
4433 	ifm->ifa_prefixlen = prefixlen;
4434 	ifm->ifa_flags = flags;
4435 	ifm->ifa_scope = scope;
4436 	ifm->ifa_index = ifindex;
4437 }
4438 
4439 static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
4440 			 unsigned long tstamp, u32 preferred, u32 valid)
4441 {
4442 	struct ifa_cacheinfo ci;
4443 
4444 	ci.cstamp = cstamp_delta(cstamp);
4445 	ci.tstamp = cstamp_delta(tstamp);
4446 	ci.ifa_prefered = preferred;
4447 	ci.ifa_valid = valid;
4448 
4449 	return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
4450 }
4451 
4452 static inline int rt_scope(int ifa_scope)
4453 {
4454 	if (ifa_scope & IFA_HOST)
4455 		return RT_SCOPE_HOST;
4456 	else if (ifa_scope & IFA_LINK)
4457 		return RT_SCOPE_LINK;
4458 	else if (ifa_scope & IFA_SITE)
4459 		return RT_SCOPE_SITE;
4460 	else
4461 		return RT_SCOPE_UNIVERSE;
4462 }
4463 
4464 static inline int inet6_ifaddr_msgsize(void)
4465 {
4466 	return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
4467 	       + nla_total_size(16) /* IFA_LOCAL */
4468 	       + nla_total_size(16) /* IFA_ADDRESS */
4469 	       + nla_total_size(sizeof(struct ifa_cacheinfo))
4470 	       + nla_total_size(4)  /* IFA_FLAGS */;
4471 }
4472 
4473 static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
4474 			     u32 portid, u32 seq, int event, unsigned int flags)
4475 {
4476 	struct nlmsghdr  *nlh;
4477 	u32 preferred, valid;
4478 
4479 	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4480 	if (!nlh)
4481 		return -EMSGSIZE;
4482 
4483 	put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope),
4484 		      ifa->idev->dev->ifindex);
4485 
4486 	if (!((ifa->flags&IFA_F_PERMANENT) &&
4487 	      (ifa->prefered_lft == INFINITY_LIFE_TIME))) {
4488 		preferred = ifa->prefered_lft;
4489 		valid = ifa->valid_lft;
4490 		if (preferred != INFINITY_LIFE_TIME) {
4491 			long tval = (jiffies - ifa->tstamp)/HZ;
4492 			if (preferred > tval)
4493 				preferred -= tval;
4494 			else
4495 				preferred = 0;
4496 			if (valid != INFINITY_LIFE_TIME) {
4497 				if (valid > tval)
4498 					valid -= tval;
4499 				else
4500 					valid = 0;
4501 			}
4502 		}
4503 	} else {
4504 		preferred = INFINITY_LIFE_TIME;
4505 		valid = INFINITY_LIFE_TIME;
4506 	}
4507 
4508 	if (!ipv6_addr_any(&ifa->peer_addr)) {
4509 		if (nla_put_in6_addr(skb, IFA_LOCAL, &ifa->addr) < 0 ||
4510 		    nla_put_in6_addr(skb, IFA_ADDRESS, &ifa->peer_addr) < 0)
4511 			goto error;
4512 	} else
4513 		if (nla_put_in6_addr(skb, IFA_ADDRESS, &ifa->addr) < 0)
4514 			goto error;
4515 
4516 	if (put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0)
4517 		goto error;
4518 
4519 	if (nla_put_u32(skb, IFA_FLAGS, ifa->flags) < 0)
4520 		goto error;
4521 
4522 	nlmsg_end(skb, nlh);
4523 	return 0;
4524 
4525 error:
4526 	nlmsg_cancel(skb, nlh);
4527 	return -EMSGSIZE;
4528 }
4529 
4530 static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca,
4531 				u32 portid, u32 seq, int event, u16 flags)
4532 {
4533 	struct nlmsghdr  *nlh;
4534 	u8 scope = RT_SCOPE_UNIVERSE;
4535 	int ifindex = ifmca->idev->dev->ifindex;
4536 
4537 	if (ipv6_addr_scope(&ifmca->mca_addr) & IFA_SITE)
4538 		scope = RT_SCOPE_SITE;
4539 
4540 	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4541 	if (!nlh)
4542 		return -EMSGSIZE;
4543 
4544 	put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
4545 	if (nla_put_in6_addr(skb, IFA_MULTICAST, &ifmca->mca_addr) < 0 ||
4546 	    put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp,
4547 			  INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
4548 		nlmsg_cancel(skb, nlh);
4549 		return -EMSGSIZE;
4550 	}
4551 
4552 	nlmsg_end(skb, nlh);
4553 	return 0;
4554 }
4555 
4556 static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
4557 				u32 portid, u32 seq, int event, unsigned int flags)
4558 {
4559 	struct nlmsghdr  *nlh;
4560 	u8 scope = RT_SCOPE_UNIVERSE;
4561 	int ifindex = ifaca->aca_idev->dev->ifindex;
4562 
4563 	if (ipv6_addr_scope(&ifaca->aca_addr) & IFA_SITE)
4564 		scope = RT_SCOPE_SITE;
4565 
4566 	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4567 	if (!nlh)
4568 		return -EMSGSIZE;
4569 
4570 	put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
4571 	if (nla_put_in6_addr(skb, IFA_ANYCAST, &ifaca->aca_addr) < 0 ||
4572 	    put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp,
4573 			  INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
4574 		nlmsg_cancel(skb, nlh);
4575 		return -EMSGSIZE;
4576 	}
4577 
4578 	nlmsg_end(skb, nlh);
4579 	return 0;
4580 }
4581 
4582 enum addr_type_t {
4583 	UNICAST_ADDR,
4584 	MULTICAST_ADDR,
4585 	ANYCAST_ADDR,
4586 };
4587 
4588 /* called with rcu_read_lock() */
4589 static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
4590 			  struct netlink_callback *cb, enum addr_type_t type,
4591 			  int s_ip_idx, int *p_ip_idx)
4592 {
4593 	struct ifmcaddr6 *ifmca;
4594 	struct ifacaddr6 *ifaca;
4595 	int err = 1;
4596 	int ip_idx = *p_ip_idx;
4597 
4598 	read_lock_bh(&idev->lock);
4599 	switch (type) {
4600 	case UNICAST_ADDR: {
4601 		struct inet6_ifaddr *ifa;
4602 
4603 		/* unicast address incl. temp addr */
4604 		list_for_each_entry(ifa, &idev->addr_list, if_list) {
4605 			if (++ip_idx < s_ip_idx)
4606 				continue;
4607 			err = inet6_fill_ifaddr(skb, ifa,
4608 						NETLINK_CB(cb->skb).portid,
4609 						cb->nlh->nlmsg_seq,
4610 						RTM_NEWADDR,
4611 						NLM_F_MULTI);
4612 			if (err < 0)
4613 				break;
4614 			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
4615 		}
4616 		break;
4617 	}
4618 	case MULTICAST_ADDR:
4619 		/* multicast address */
4620 		for (ifmca = idev->mc_list; ifmca;
4621 		     ifmca = ifmca->next, ip_idx++) {
4622 			if (ip_idx < s_ip_idx)
4623 				continue;
4624 			err = inet6_fill_ifmcaddr(skb, ifmca,
4625 						  NETLINK_CB(cb->skb).portid,
4626 						  cb->nlh->nlmsg_seq,
4627 						  RTM_GETMULTICAST,
4628 						  NLM_F_MULTI);
4629 			if (err < 0)
4630 				break;
4631 		}
4632 		break;
4633 	case ANYCAST_ADDR:
4634 		/* anycast address */
4635 		for (ifaca = idev->ac_list; ifaca;
4636 		     ifaca = ifaca->aca_next, ip_idx++) {
4637 			if (ip_idx < s_ip_idx)
4638 				continue;
4639 			err = inet6_fill_ifacaddr(skb, ifaca,
4640 						  NETLINK_CB(cb->skb).portid,
4641 						  cb->nlh->nlmsg_seq,
4642 						  RTM_GETANYCAST,
4643 						  NLM_F_MULTI);
4644 			if (err < 0)
4645 				break;
4646 		}
4647 		break;
4648 	default:
4649 		break;
4650 	}
4651 	read_unlock_bh(&idev->lock);
4652 	*p_ip_idx = ip_idx;
4653 	return err;
4654 }
4655 
4656 static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
4657 			   enum addr_type_t type)
4658 {
4659 	struct net *net = sock_net(skb->sk);
4660 	int h, s_h;
4661 	int idx, ip_idx;
4662 	int s_idx, s_ip_idx;
4663 	struct net_device *dev;
4664 	struct inet6_dev *idev;
4665 	struct hlist_head *head;
4666 
4667 	s_h = cb->args[0];
4668 	s_idx = idx = cb->args[1];
4669 	s_ip_idx = ip_idx = cb->args[2];
4670 
4671 	rcu_read_lock();
4672 	cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ net->dev_base_seq;
4673 	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
4674 		idx = 0;
4675 		head = &net->dev_index_head[h];
4676 		hlist_for_each_entry_rcu(dev, head, index_hlist) {
4677 			if (idx < s_idx)
4678 				goto cont;
4679 			if (h > s_h || idx > s_idx)
4680 				s_ip_idx = 0;
4681 			ip_idx = 0;
4682 			idev = __in6_dev_get(dev);
4683 			if (!idev)
4684 				goto cont;
4685 
4686 			if (in6_dump_addrs(idev, skb, cb, type,
4687 					   s_ip_idx, &ip_idx) < 0)
4688 				goto done;
4689 cont:
4690 			idx++;
4691 		}
4692 	}
4693 done:
4694 	rcu_read_unlock();
4695 	cb->args[0] = h;
4696 	cb->args[1] = idx;
4697 	cb->args[2] = ip_idx;
4698 
4699 	return skb->len;
4700 }
4701 
4702 static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
4703 {
4704 	enum addr_type_t type = UNICAST_ADDR;
4705 
4706 	return inet6_dump_addr(skb, cb, type);
4707 }
4708 
4709 static int inet6_dump_ifmcaddr(struct sk_buff *skb, struct netlink_callback *cb)
4710 {
4711 	enum addr_type_t type = MULTICAST_ADDR;
4712 
4713 	return inet6_dump_addr(skb, cb, type);
4714 }
4715 
4716 
4717 static int inet6_dump_ifacaddr(struct sk_buff *skb, struct netlink_callback *cb)
4718 {
4719 	enum addr_type_t type = ANYCAST_ADDR;
4720 
4721 	return inet6_dump_addr(skb, cb, type);
4722 }
4723 
4724 static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh)
4725 {
4726 	struct net *net = sock_net(in_skb->sk);
4727 	struct ifaddrmsg *ifm;
4728 	struct nlattr *tb[IFA_MAX+1];
4729 	struct in6_addr *addr = NULL, *peer;
4730 	struct net_device *dev = NULL;
4731 	struct inet6_ifaddr *ifa;
4732 	struct sk_buff *skb;
4733 	int err;
4734 
4735 	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
4736 	if (err < 0)
4737 		goto errout;
4738 
4739 	addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer);
4740 	if (!addr) {
4741 		err = -EINVAL;
4742 		goto errout;
4743 	}
4744 
4745 	ifm = nlmsg_data(nlh);
4746 	if (ifm->ifa_index)
4747 		dev = __dev_get_by_index(net, ifm->ifa_index);
4748 
4749 	ifa = ipv6_get_ifaddr(net, addr, dev, 1);
4750 	if (!ifa) {
4751 		err = -EADDRNOTAVAIL;
4752 		goto errout;
4753 	}
4754 
4755 	skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL);
4756 	if (!skb) {
4757 		err = -ENOBUFS;
4758 		goto errout_ifa;
4759 	}
4760 
4761 	err = inet6_fill_ifaddr(skb, ifa, NETLINK_CB(in_skb).portid,
4762 				nlh->nlmsg_seq, RTM_NEWADDR, 0);
4763 	if (err < 0) {
4764 		/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
4765 		WARN_ON(err == -EMSGSIZE);
4766 		kfree_skb(skb);
4767 		goto errout_ifa;
4768 	}
4769 	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
4770 errout_ifa:
4771 	in6_ifa_put(ifa);
4772 errout:
4773 	return err;
4774 }
4775 
4776 static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa)
4777 {
4778 	struct sk_buff *skb;
4779 	struct net *net = dev_net(ifa->idev->dev);
4780 	int err = -ENOBUFS;
4781 
4782 	skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC);
4783 	if (!skb)
4784 		goto errout;
4785 
4786 	err = inet6_fill_ifaddr(skb, ifa, 0, 0, event, 0);
4787 	if (err < 0) {
4788 		/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
4789 		WARN_ON(err == -EMSGSIZE);
4790 		kfree_skb(skb);
4791 		goto errout;
4792 	}
4793 	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC);
4794 	return;
4795 errout:
4796 	if (err < 0)
4797 		rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err);
4798 }
4799 
4800 static inline void ipv6_store_devconf(struct ipv6_devconf *cnf,
4801 				__s32 *array, int bytes)
4802 {
4803 	BUG_ON(bytes < (DEVCONF_MAX * 4));
4804 
4805 	memset(array, 0, bytes);
4806 	array[DEVCONF_FORWARDING] = cnf->forwarding;
4807 	array[DEVCONF_HOPLIMIT] = cnf->hop_limit;
4808 	array[DEVCONF_MTU6] = cnf->mtu6;
4809 	array[DEVCONF_ACCEPT_RA] = cnf->accept_ra;
4810 	array[DEVCONF_ACCEPT_REDIRECTS] = cnf->accept_redirects;
4811 	array[DEVCONF_AUTOCONF] = cnf->autoconf;
4812 	array[DEVCONF_DAD_TRANSMITS] = cnf->dad_transmits;
4813 	array[DEVCONF_RTR_SOLICITS] = cnf->rtr_solicits;
4814 	array[DEVCONF_RTR_SOLICIT_INTERVAL] =
4815 		jiffies_to_msecs(cnf->rtr_solicit_interval);
4816 	array[DEVCONF_RTR_SOLICIT_DELAY] =
4817 		jiffies_to_msecs(cnf->rtr_solicit_delay);
4818 	array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version;
4819 	array[DEVCONF_MLDV1_UNSOLICITED_REPORT_INTERVAL] =
4820 		jiffies_to_msecs(cnf->mldv1_unsolicited_report_interval);
4821 	array[DEVCONF_MLDV2_UNSOLICITED_REPORT_INTERVAL] =
4822 		jiffies_to_msecs(cnf->mldv2_unsolicited_report_interval);
4823 	array[DEVCONF_USE_TEMPADDR] = cnf->use_tempaddr;
4824 	array[DEVCONF_TEMP_VALID_LFT] = cnf->temp_valid_lft;
4825 	array[DEVCONF_TEMP_PREFERED_LFT] = cnf->temp_prefered_lft;
4826 	array[DEVCONF_REGEN_MAX_RETRY] = cnf->regen_max_retry;
4827 	array[DEVCONF_MAX_DESYNC_FACTOR] = cnf->max_desync_factor;
4828 	array[DEVCONF_MAX_ADDRESSES] = cnf->max_addresses;
4829 	array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr;
4830 	array[DEVCONF_ACCEPT_RA_MIN_HOP_LIMIT] = cnf->accept_ra_min_hop_limit;
4831 	array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo;
4832 #ifdef CONFIG_IPV6_ROUTER_PREF
4833 	array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref;
4834 	array[DEVCONF_RTR_PROBE_INTERVAL] =
4835 		jiffies_to_msecs(cnf->rtr_probe_interval);
4836 #ifdef CONFIG_IPV6_ROUTE_INFO
4837 	array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen;
4838 #endif
4839 #endif
4840 	array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp;
4841 	array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route;
4842 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
4843 	array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad;
4844 	array[DEVCONF_USE_OPTIMISTIC] = cnf->use_optimistic;
4845 #endif
4846 #ifdef CONFIG_IPV6_MROUTE
4847 	array[DEVCONF_MC_FORWARDING] = cnf->mc_forwarding;
4848 #endif
4849 	array[DEVCONF_DISABLE_IPV6] = cnf->disable_ipv6;
4850 	array[DEVCONF_ACCEPT_DAD] = cnf->accept_dad;
4851 	array[DEVCONF_FORCE_TLLAO] = cnf->force_tllao;
4852 	array[DEVCONF_NDISC_NOTIFY] = cnf->ndisc_notify;
4853 	array[DEVCONF_SUPPRESS_FRAG_NDISC] = cnf->suppress_frag_ndisc;
4854 	array[DEVCONF_ACCEPT_RA_FROM_LOCAL] = cnf->accept_ra_from_local;
4855 	array[DEVCONF_ACCEPT_RA_MTU] = cnf->accept_ra_mtu;
4856 	array[DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN] = cnf->ignore_routes_with_linkdown;
4857 	/* we omit DEVCONF_STABLE_SECRET for now */
4858 	array[DEVCONF_USE_OIF_ADDRS_ONLY] = cnf->use_oif_addrs_only;
4859 	array[DEVCONF_DROP_UNICAST_IN_L2_MULTICAST] = cnf->drop_unicast_in_l2_multicast;
4860 	array[DEVCONF_DROP_UNSOLICITED_NA] = cnf->drop_unsolicited_na;
4861 	array[DEVCONF_KEEP_ADDR_ON_DOWN] = cnf->keep_addr_on_down;
4862 }
4863 
4864 static inline size_t inet6_ifla6_size(void)
4865 {
4866 	return nla_total_size(4) /* IFLA_INET6_FLAGS */
4867 	     + nla_total_size(sizeof(struct ifla_cacheinfo))
4868 	     + nla_total_size(DEVCONF_MAX * 4) /* IFLA_INET6_CONF */
4869 	     + nla_total_size(IPSTATS_MIB_MAX * 8) /* IFLA_INET6_STATS */
4870 	     + nla_total_size(ICMP6_MIB_MAX * 8) /* IFLA_INET6_ICMP6STATS */
4871 	     + nla_total_size(sizeof(struct in6_addr)); /* IFLA_INET6_TOKEN */
4872 }
4873 
4874 static inline size_t inet6_if_nlmsg_size(void)
4875 {
4876 	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
4877 	       + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
4878 	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
4879 	       + nla_total_size(4) /* IFLA_MTU */
4880 	       + nla_total_size(4) /* IFLA_LINK */
4881 	       + nla_total_size(1) /* IFLA_OPERSTATE */
4882 	       + nla_total_size(inet6_ifla6_size()); /* IFLA_PROTINFO */
4883 }
4884 
4885 static inline void __snmp6_fill_statsdev(u64 *stats, atomic_long_t *mib,
4886 				      int items, int bytes)
4887 {
4888 	int i;
4889 	int pad = bytes - sizeof(u64) * items;
4890 	BUG_ON(pad < 0);
4891 
4892 	/* Use put_unaligned() because stats may not be aligned for u64. */
4893 	put_unaligned(items, &stats[0]);
4894 	for (i = 1; i < items; i++)
4895 		put_unaligned(atomic_long_read(&mib[i]), &stats[i]);
4896 
4897 	memset(&stats[items], 0, pad);
4898 }
4899 
4900 static inline void __snmp6_fill_stats64(u64 *stats, void __percpu *mib,
4901 					int bytes, size_t syncpoff)
4902 {
4903 	int i, c;
4904 	u64 buff[IPSTATS_MIB_MAX];
4905 	int pad = bytes - sizeof(u64) * IPSTATS_MIB_MAX;
4906 
4907 	BUG_ON(pad < 0);
4908 
4909 	memset(buff, 0, sizeof(buff));
4910 	buff[0] = IPSTATS_MIB_MAX;
4911 
4912 	for_each_possible_cpu(c) {
4913 		for (i = 1; i < IPSTATS_MIB_MAX; i++)
4914 			buff[i] += snmp_get_cpu_field64(mib, c, i, syncpoff);
4915 	}
4916 
4917 	memcpy(stats, buff, IPSTATS_MIB_MAX * sizeof(u64));
4918 	memset(&stats[IPSTATS_MIB_MAX], 0, pad);
4919 }
4920 
4921 static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype,
4922 			     int bytes)
4923 {
4924 	switch (attrtype) {
4925 	case IFLA_INET6_STATS:
4926 		__snmp6_fill_stats64(stats, idev->stats.ipv6, bytes,
4927 				     offsetof(struct ipstats_mib, syncp));
4928 		break;
4929 	case IFLA_INET6_ICMP6STATS:
4930 		__snmp6_fill_statsdev(stats, idev->stats.icmpv6dev->mibs, ICMP6_MIB_MAX, bytes);
4931 		break;
4932 	}
4933 }
4934 
4935 static int inet6_fill_ifla6_attrs(struct sk_buff *skb, struct inet6_dev *idev,
4936 				  u32 ext_filter_mask)
4937 {
4938 	struct nlattr *nla;
4939 	struct ifla_cacheinfo ci;
4940 
4941 	if (nla_put_u32(skb, IFLA_INET6_FLAGS, idev->if_flags))
4942 		goto nla_put_failure;
4943 	ci.max_reasm_len = IPV6_MAXPLEN;
4944 	ci.tstamp = cstamp_delta(idev->tstamp);
4945 	ci.reachable_time = jiffies_to_msecs(idev->nd_parms->reachable_time);
4946 	ci.retrans_time = jiffies_to_msecs(NEIGH_VAR(idev->nd_parms, RETRANS_TIME));
4947 	if (nla_put(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci))
4948 		goto nla_put_failure;
4949 	nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32));
4950 	if (!nla)
4951 		goto nla_put_failure;
4952 	ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla));
4953 
4954 	/* XXX - MC not implemented */
4955 
4956 	if (ext_filter_mask & RTEXT_FILTER_SKIP_STATS)
4957 		return 0;
4958 
4959 	nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64));
4960 	if (!nla)
4961 		goto nla_put_failure;
4962 	snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_STATS, nla_len(nla));
4963 
4964 	nla = nla_reserve(skb, IFLA_INET6_ICMP6STATS, ICMP6_MIB_MAX * sizeof(u64));
4965 	if (!nla)
4966 		goto nla_put_failure;
4967 	snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla));
4968 
4969 	nla = nla_reserve(skb, IFLA_INET6_TOKEN, sizeof(struct in6_addr));
4970 	if (!nla)
4971 		goto nla_put_failure;
4972 
4973 	if (nla_put_u8(skb, IFLA_INET6_ADDR_GEN_MODE, idev->addr_gen_mode))
4974 		goto nla_put_failure;
4975 
4976 	read_lock_bh(&idev->lock);
4977 	memcpy(nla_data(nla), idev->token.s6_addr, nla_len(nla));
4978 	read_unlock_bh(&idev->lock);
4979 
4980 	return 0;
4981 
4982 nla_put_failure:
4983 	return -EMSGSIZE;
4984 }
4985 
4986 static size_t inet6_get_link_af_size(const struct net_device *dev,
4987 				     u32 ext_filter_mask)
4988 {
4989 	if (!__in6_dev_get(dev))
4990 		return 0;
4991 
4992 	return inet6_ifla6_size();
4993 }
4994 
4995 static int inet6_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
4996 			      u32 ext_filter_mask)
4997 {
4998 	struct inet6_dev *idev = __in6_dev_get(dev);
4999 
5000 	if (!idev)
5001 		return -ENODATA;
5002 
5003 	if (inet6_fill_ifla6_attrs(skb, idev, ext_filter_mask) < 0)
5004 		return -EMSGSIZE;
5005 
5006 	return 0;
5007 }
5008 
5009 static int inet6_set_iftoken(struct inet6_dev *idev, struct in6_addr *token)
5010 {
5011 	struct inet6_ifaddr *ifp;
5012 	struct net_device *dev = idev->dev;
5013 	bool clear_token, update_rs = false;
5014 	struct in6_addr ll_addr;
5015 
5016 	ASSERT_RTNL();
5017 
5018 	if (!token)
5019 		return -EINVAL;
5020 	if (dev->flags & (IFF_LOOPBACK | IFF_NOARP))
5021 		return -EINVAL;
5022 	if (!ipv6_accept_ra(idev))
5023 		return -EINVAL;
5024 	if (idev->cnf.rtr_solicits <= 0)
5025 		return -EINVAL;
5026 
5027 	write_lock_bh(&idev->lock);
5028 
5029 	BUILD_BUG_ON(sizeof(token->s6_addr) != 16);
5030 	memcpy(idev->token.s6_addr + 8, token->s6_addr + 8, 8);
5031 
5032 	write_unlock_bh(&idev->lock);
5033 
5034 	clear_token = ipv6_addr_any(token);
5035 	if (clear_token)
5036 		goto update_lft;
5037 
5038 	if (!idev->dead && (idev->if_flags & IF_READY) &&
5039 	    !ipv6_get_lladdr(dev, &ll_addr, IFA_F_TENTATIVE |
5040 			     IFA_F_OPTIMISTIC)) {
5041 		/* If we're not ready, then normal ifup will take care
5042 		 * of this. Otherwise, we need to request our rs here.
5043 		 */
5044 		ndisc_send_rs(dev, &ll_addr, &in6addr_linklocal_allrouters);
5045 		update_rs = true;
5046 	}
5047 
5048 update_lft:
5049 	write_lock_bh(&idev->lock);
5050 
5051 	if (update_rs) {
5052 		idev->if_flags |= IF_RS_SENT;
5053 		idev->rs_probes = 1;
5054 		addrconf_mod_rs_timer(idev, idev->cnf.rtr_solicit_interval);
5055 	}
5056 
5057 	/* Well, that's kinda nasty ... */
5058 	list_for_each_entry(ifp, &idev->addr_list, if_list) {
5059 		spin_lock(&ifp->lock);
5060 		if (ifp->tokenized) {
5061 			ifp->valid_lft = 0;
5062 			ifp->prefered_lft = 0;
5063 		}
5064 		spin_unlock(&ifp->lock);
5065 	}
5066 
5067 	write_unlock_bh(&idev->lock);
5068 	inet6_ifinfo_notify(RTM_NEWLINK, idev);
5069 	addrconf_verify_rtnl();
5070 	return 0;
5071 }
5072 
5073 static const struct nla_policy inet6_af_policy[IFLA_INET6_MAX + 1] = {
5074 	[IFLA_INET6_ADDR_GEN_MODE]	= { .type = NLA_U8 },
5075 	[IFLA_INET6_TOKEN]		= { .len = sizeof(struct in6_addr) },
5076 };
5077 
5078 static int inet6_validate_link_af(const struct net_device *dev,
5079 				  const struct nlattr *nla)
5080 {
5081 	struct nlattr *tb[IFLA_INET6_MAX + 1];
5082 
5083 	if (dev && !__in6_dev_get(dev))
5084 		return -EAFNOSUPPORT;
5085 
5086 	return nla_parse_nested(tb, IFLA_INET6_MAX, nla, inet6_af_policy);
5087 }
5088 
5089 static int inet6_set_link_af(struct net_device *dev, const struct nlattr *nla)
5090 {
5091 	int err = -EINVAL;
5092 	struct inet6_dev *idev = __in6_dev_get(dev);
5093 	struct nlattr *tb[IFLA_INET6_MAX + 1];
5094 
5095 	if (!idev)
5096 		return -EAFNOSUPPORT;
5097 
5098 	if (nla_parse_nested(tb, IFLA_INET6_MAX, nla, NULL) < 0)
5099 		BUG();
5100 
5101 	if (tb[IFLA_INET6_TOKEN]) {
5102 		err = inet6_set_iftoken(idev, nla_data(tb[IFLA_INET6_TOKEN]));
5103 		if (err)
5104 			return err;
5105 	}
5106 
5107 	if (tb[IFLA_INET6_ADDR_GEN_MODE]) {
5108 		u8 mode = nla_get_u8(tb[IFLA_INET6_ADDR_GEN_MODE]);
5109 
5110 		if (mode != IN6_ADDR_GEN_MODE_EUI64 &&
5111 		    mode != IN6_ADDR_GEN_MODE_NONE &&
5112 		    mode != IN6_ADDR_GEN_MODE_STABLE_PRIVACY &&
5113 		    mode != IN6_ADDR_GEN_MODE_RANDOM)
5114 			return -EINVAL;
5115 
5116 		if (mode == IN6_ADDR_GEN_MODE_STABLE_PRIVACY &&
5117 		    !idev->cnf.stable_secret.initialized &&
5118 		    !dev_net(dev)->ipv6.devconf_dflt->stable_secret.initialized)
5119 			return -EINVAL;
5120 
5121 		idev->addr_gen_mode = mode;
5122 		err = 0;
5123 	}
5124 
5125 	return err;
5126 }
5127 
5128 static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev,
5129 			     u32 portid, u32 seq, int event, unsigned int flags)
5130 {
5131 	struct net_device *dev = idev->dev;
5132 	struct ifinfomsg *hdr;
5133 	struct nlmsghdr *nlh;
5134 	void *protoinfo;
5135 
5136 	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags);
5137 	if (!nlh)
5138 		return -EMSGSIZE;
5139 
5140 	hdr = nlmsg_data(nlh);
5141 	hdr->ifi_family = AF_INET6;
5142 	hdr->__ifi_pad = 0;
5143 	hdr->ifi_type = dev->type;
5144 	hdr->ifi_index = dev->ifindex;
5145 	hdr->ifi_flags = dev_get_flags(dev);
5146 	hdr->ifi_change = 0;
5147 
5148 	if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
5149 	    (dev->addr_len &&
5150 	     nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
5151 	    nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
5152 	    (dev->ifindex != dev_get_iflink(dev) &&
5153 	     nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))) ||
5154 	    nla_put_u8(skb, IFLA_OPERSTATE,
5155 		       netif_running(dev) ? dev->operstate : IF_OPER_DOWN))
5156 		goto nla_put_failure;
5157 	protoinfo = nla_nest_start(skb, IFLA_PROTINFO);
5158 	if (!protoinfo)
5159 		goto nla_put_failure;
5160 
5161 	if (inet6_fill_ifla6_attrs(skb, idev, 0) < 0)
5162 		goto nla_put_failure;
5163 
5164 	nla_nest_end(skb, protoinfo);
5165 	nlmsg_end(skb, nlh);
5166 	return 0;
5167 
5168 nla_put_failure:
5169 	nlmsg_cancel(skb, nlh);
5170 	return -EMSGSIZE;
5171 }
5172 
5173 static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
5174 {
5175 	struct net *net = sock_net(skb->sk);
5176 	int h, s_h;
5177 	int idx = 0, s_idx;
5178 	struct net_device *dev;
5179 	struct inet6_dev *idev;
5180 	struct hlist_head *head;
5181 
5182 	s_h = cb->args[0];
5183 	s_idx = cb->args[1];
5184 
5185 	rcu_read_lock();
5186 	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
5187 		idx = 0;
5188 		head = &net->dev_index_head[h];
5189 		hlist_for_each_entry_rcu(dev, head, index_hlist) {
5190 			if (idx < s_idx)
5191 				goto cont;
5192 			idev = __in6_dev_get(dev);
5193 			if (!idev)
5194 				goto cont;
5195 			if (inet6_fill_ifinfo(skb, idev,
5196 					      NETLINK_CB(cb->skb).portid,
5197 					      cb->nlh->nlmsg_seq,
5198 					      RTM_NEWLINK, NLM_F_MULTI) < 0)
5199 				goto out;
5200 cont:
5201 			idx++;
5202 		}
5203 	}
5204 out:
5205 	rcu_read_unlock();
5206 	cb->args[1] = idx;
5207 	cb->args[0] = h;
5208 
5209 	return skb->len;
5210 }
5211 
5212 void inet6_ifinfo_notify(int event, struct inet6_dev *idev)
5213 {
5214 	struct sk_buff *skb;
5215 	struct net *net = dev_net(idev->dev);
5216 	int err = -ENOBUFS;
5217 
5218 	skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC);
5219 	if (!skb)
5220 		goto errout;
5221 
5222 	err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0);
5223 	if (err < 0) {
5224 		/* -EMSGSIZE implies BUG in inet6_if_nlmsg_size() */
5225 		WARN_ON(err == -EMSGSIZE);
5226 		kfree_skb(skb);
5227 		goto errout;
5228 	}
5229 	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFINFO, NULL, GFP_ATOMIC);
5230 	return;
5231 errout:
5232 	if (err < 0)
5233 		rtnl_set_sk_err(net, RTNLGRP_IPV6_IFINFO, err);
5234 }
5235 
5236 static inline size_t inet6_prefix_nlmsg_size(void)
5237 {
5238 	return NLMSG_ALIGN(sizeof(struct prefixmsg))
5239 	       + nla_total_size(sizeof(struct in6_addr))
5240 	       + nla_total_size(sizeof(struct prefix_cacheinfo));
5241 }
5242 
5243 static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev,
5244 			     struct prefix_info *pinfo, u32 portid, u32 seq,
5245 			     int event, unsigned int flags)
5246 {
5247 	struct prefixmsg *pmsg;
5248 	struct nlmsghdr *nlh;
5249 	struct prefix_cacheinfo	ci;
5250 
5251 	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*pmsg), flags);
5252 	if (!nlh)
5253 		return -EMSGSIZE;
5254 
5255 	pmsg = nlmsg_data(nlh);
5256 	pmsg->prefix_family = AF_INET6;
5257 	pmsg->prefix_pad1 = 0;
5258 	pmsg->prefix_pad2 = 0;
5259 	pmsg->prefix_ifindex = idev->dev->ifindex;
5260 	pmsg->prefix_len = pinfo->prefix_len;
5261 	pmsg->prefix_type = pinfo->type;
5262 	pmsg->prefix_pad3 = 0;
5263 	pmsg->prefix_flags = 0;
5264 	if (pinfo->onlink)
5265 		pmsg->prefix_flags |= IF_PREFIX_ONLINK;
5266 	if (pinfo->autoconf)
5267 		pmsg->prefix_flags |= IF_PREFIX_AUTOCONF;
5268 
5269 	if (nla_put(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix))
5270 		goto nla_put_failure;
5271 	ci.preferred_time = ntohl(pinfo->prefered);
5272 	ci.valid_time = ntohl(pinfo->valid);
5273 	if (nla_put(skb, PREFIX_CACHEINFO, sizeof(ci), &ci))
5274 		goto nla_put_failure;
5275 	nlmsg_end(skb, nlh);
5276 	return 0;
5277 
5278 nla_put_failure:
5279 	nlmsg_cancel(skb, nlh);
5280 	return -EMSGSIZE;
5281 }
5282 
5283 static void inet6_prefix_notify(int event, struct inet6_dev *idev,
5284 			 struct prefix_info *pinfo)
5285 {
5286 	struct sk_buff *skb;
5287 	struct net *net = dev_net(idev->dev);
5288 	int err = -ENOBUFS;
5289 
5290 	skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC);
5291 	if (!skb)
5292 		goto errout;
5293 
5294 	err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0);
5295 	if (err < 0) {
5296 		/* -EMSGSIZE implies BUG in inet6_prefix_nlmsg_size() */
5297 		WARN_ON(err == -EMSGSIZE);
5298 		kfree_skb(skb);
5299 		goto errout;
5300 	}
5301 	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC);
5302 	return;
5303 errout:
5304 	if (err < 0)
5305 		rtnl_set_sk_err(net, RTNLGRP_IPV6_PREFIX, err);
5306 }
5307 
5308 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
5309 {
5310 	struct net *net = dev_net(ifp->idev->dev);
5311 
5312 	if (event)
5313 		ASSERT_RTNL();
5314 
5315 	inet6_ifa_notify(event ? : RTM_NEWADDR, ifp);
5316 
5317 	switch (event) {
5318 	case RTM_NEWADDR:
5319 		/*
5320 		 * If the address was optimistic
5321 		 * we inserted the route at the start of
5322 		 * our DAD process, so we don't need
5323 		 * to do it again
5324 		 */
5325 		if (!(ifp->rt->rt6i_node))
5326 			ip6_ins_rt(ifp->rt);
5327 		if (ifp->idev->cnf.forwarding)
5328 			addrconf_join_anycast(ifp);
5329 		if (!ipv6_addr_any(&ifp->peer_addr))
5330 			addrconf_prefix_route(&ifp->peer_addr, 128,
5331 					      ifp->idev->dev, 0, 0);
5332 		break;
5333 	case RTM_DELADDR:
5334 		if (ifp->idev->cnf.forwarding)
5335 			addrconf_leave_anycast(ifp);
5336 		addrconf_leave_solict(ifp->idev, &ifp->addr);
5337 		if (!ipv6_addr_any(&ifp->peer_addr)) {
5338 			struct rt6_info *rt;
5339 
5340 			rt = addrconf_get_prefix_route(&ifp->peer_addr, 128,
5341 						       ifp->idev->dev, 0, 0);
5342 			if (rt)
5343 				ip6_del_rt(rt);
5344 		}
5345 		if (ifp->rt) {
5346 			dst_hold(&ifp->rt->dst);
5347 			ip6_del_rt(ifp->rt);
5348 		}
5349 		rt_genid_bump_ipv6(net);
5350 		break;
5351 	}
5352 	atomic_inc(&net->ipv6.dev_addr_genid);
5353 }
5354 
5355 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
5356 {
5357 	rcu_read_lock_bh();
5358 	if (likely(ifp->idev->dead == 0))
5359 		__ipv6_ifa_notify(event, ifp);
5360 	rcu_read_unlock_bh();
5361 }
5362 
5363 #ifdef CONFIG_SYSCTL
5364 
5365 static
5366 int addrconf_sysctl_forward(struct ctl_table *ctl, int write,
5367 			   void __user *buffer, size_t *lenp, loff_t *ppos)
5368 {
5369 	int *valp = ctl->data;
5370 	int val = *valp;
5371 	loff_t pos = *ppos;
5372 	struct ctl_table lctl;
5373 	int ret;
5374 
5375 	/*
5376 	 * ctl->data points to idev->cnf.forwarding, we should
5377 	 * not modify it until we get the rtnl lock.
5378 	 */
5379 	lctl = *ctl;
5380 	lctl.data = &val;
5381 
5382 	ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
5383 
5384 	if (write)
5385 		ret = addrconf_fixup_forwarding(ctl, valp, val);
5386 	if (ret)
5387 		*ppos = pos;
5388 	return ret;
5389 }
5390 
5391 static
5392 int addrconf_sysctl_hop_limit(struct ctl_table *ctl, int write,
5393                               void __user *buffer, size_t *lenp, loff_t *ppos)
5394 {
5395 	struct ctl_table lctl;
5396 	int min_hl = 1, max_hl = 255;
5397 
5398 	lctl = *ctl;
5399 	lctl.extra1 = &min_hl;
5400 	lctl.extra2 = &max_hl;
5401 
5402 	return proc_dointvec_minmax(&lctl, write, buffer, lenp, ppos);
5403 }
5404 
5405 static
5406 int addrconf_sysctl_mtu(struct ctl_table *ctl, int write,
5407 			void __user *buffer, size_t *lenp, loff_t *ppos)
5408 {
5409 	struct inet6_dev *idev = ctl->extra1;
5410 	int min_mtu = IPV6_MIN_MTU;
5411 	struct ctl_table lctl;
5412 
5413 	lctl = *ctl;
5414 	lctl.extra1 = &min_mtu;
5415 	lctl.extra2 = idev ? &idev->dev->mtu : NULL;
5416 
5417 	return proc_dointvec_minmax(&lctl, write, buffer, lenp, ppos);
5418 }
5419 
5420 static void dev_disable_change(struct inet6_dev *idev)
5421 {
5422 	struct netdev_notifier_info info;
5423 
5424 	if (!idev || !idev->dev)
5425 		return;
5426 
5427 	netdev_notifier_info_init(&info, idev->dev);
5428 	if (idev->cnf.disable_ipv6)
5429 		addrconf_notify(NULL, NETDEV_DOWN, &info);
5430 	else
5431 		addrconf_notify(NULL, NETDEV_UP, &info);
5432 }
5433 
5434 static void addrconf_disable_change(struct net *net, __s32 newf)
5435 {
5436 	struct net_device *dev;
5437 	struct inet6_dev *idev;
5438 
5439 	rcu_read_lock();
5440 	for_each_netdev_rcu(net, dev) {
5441 		idev = __in6_dev_get(dev);
5442 		if (idev) {
5443 			int changed = (!idev->cnf.disable_ipv6) ^ (!newf);
5444 			idev->cnf.disable_ipv6 = newf;
5445 			if (changed)
5446 				dev_disable_change(idev);
5447 		}
5448 	}
5449 	rcu_read_unlock();
5450 }
5451 
5452 static int addrconf_disable_ipv6(struct ctl_table *table, int *p, int newf)
5453 {
5454 	struct net *net;
5455 	int old;
5456 
5457 	if (!rtnl_trylock())
5458 		return restart_syscall();
5459 
5460 	net = (struct net *)table->extra2;
5461 	old = *p;
5462 	*p = newf;
5463 
5464 	if (p == &net->ipv6.devconf_dflt->disable_ipv6) {
5465 		rtnl_unlock();
5466 		return 0;
5467 	}
5468 
5469 	if (p == &net->ipv6.devconf_all->disable_ipv6) {
5470 		net->ipv6.devconf_dflt->disable_ipv6 = newf;
5471 		addrconf_disable_change(net, newf);
5472 	} else if ((!newf) ^ (!old))
5473 		dev_disable_change((struct inet6_dev *)table->extra1);
5474 
5475 	rtnl_unlock();
5476 	return 0;
5477 }
5478 
5479 static
5480 int addrconf_sysctl_disable(struct ctl_table *ctl, int write,
5481 			    void __user *buffer, size_t *lenp, loff_t *ppos)
5482 {
5483 	int *valp = ctl->data;
5484 	int val = *valp;
5485 	loff_t pos = *ppos;
5486 	struct ctl_table lctl;
5487 	int ret;
5488 
5489 	/*
5490 	 * ctl->data points to idev->cnf.disable_ipv6, we should
5491 	 * not modify it until we get the rtnl lock.
5492 	 */
5493 	lctl = *ctl;
5494 	lctl.data = &val;
5495 
5496 	ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
5497 
5498 	if (write)
5499 		ret = addrconf_disable_ipv6(ctl, valp, val);
5500 	if (ret)
5501 		*ppos = pos;
5502 	return ret;
5503 }
5504 
5505 static
5506 int addrconf_sysctl_proxy_ndp(struct ctl_table *ctl, int write,
5507 			      void __user *buffer, size_t *lenp, loff_t *ppos)
5508 {
5509 	int *valp = ctl->data;
5510 	int ret;
5511 	int old, new;
5512 
5513 	old = *valp;
5514 	ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
5515 	new = *valp;
5516 
5517 	if (write && old != new) {
5518 		struct net *net = ctl->extra2;
5519 
5520 		if (!rtnl_trylock())
5521 			return restart_syscall();
5522 
5523 		if (valp == &net->ipv6.devconf_dflt->proxy_ndp)
5524 			inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
5525 						     NETCONFA_IFINDEX_DEFAULT,
5526 						     net->ipv6.devconf_dflt);
5527 		else if (valp == &net->ipv6.devconf_all->proxy_ndp)
5528 			inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
5529 						     NETCONFA_IFINDEX_ALL,
5530 						     net->ipv6.devconf_all);
5531 		else {
5532 			struct inet6_dev *idev = ctl->extra1;
5533 
5534 			inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
5535 						     idev->dev->ifindex,
5536 						     &idev->cnf);
5537 		}
5538 		rtnl_unlock();
5539 	}
5540 
5541 	return ret;
5542 }
5543 
5544 static int addrconf_sysctl_stable_secret(struct ctl_table *ctl, int write,
5545 					 void __user *buffer, size_t *lenp,
5546 					 loff_t *ppos)
5547 {
5548 	int err;
5549 	struct in6_addr addr;
5550 	char str[IPV6_MAX_STRLEN];
5551 	struct ctl_table lctl = *ctl;
5552 	struct net *net = ctl->extra2;
5553 	struct ipv6_stable_secret *secret = ctl->data;
5554 
5555 	if (&net->ipv6.devconf_all->stable_secret == ctl->data)
5556 		return -EIO;
5557 
5558 	lctl.maxlen = IPV6_MAX_STRLEN;
5559 	lctl.data = str;
5560 
5561 	if (!rtnl_trylock())
5562 		return restart_syscall();
5563 
5564 	if (!write && !secret->initialized) {
5565 		err = -EIO;
5566 		goto out;
5567 	}
5568 
5569 	err = snprintf(str, sizeof(str), "%pI6", &secret->secret);
5570 	if (err >= sizeof(str)) {
5571 		err = -EIO;
5572 		goto out;
5573 	}
5574 
5575 	err = proc_dostring(&lctl, write, buffer, lenp, ppos);
5576 	if (err || !write)
5577 		goto out;
5578 
5579 	if (in6_pton(str, -1, addr.in6_u.u6_addr8, -1, NULL) != 1) {
5580 		err = -EIO;
5581 		goto out;
5582 	}
5583 
5584 	secret->initialized = true;
5585 	secret->secret = addr;
5586 
5587 	if (&net->ipv6.devconf_dflt->stable_secret == ctl->data) {
5588 		struct net_device *dev;
5589 
5590 		for_each_netdev(net, dev) {
5591 			struct inet6_dev *idev = __in6_dev_get(dev);
5592 
5593 			if (idev) {
5594 				idev->addr_gen_mode =
5595 					IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
5596 			}
5597 		}
5598 	} else {
5599 		struct inet6_dev *idev = ctl->extra1;
5600 
5601 		idev->addr_gen_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
5602 	}
5603 
5604 out:
5605 	rtnl_unlock();
5606 
5607 	return err;
5608 }
5609 
5610 static
5611 int addrconf_sysctl_ignore_routes_with_linkdown(struct ctl_table *ctl,
5612 						int write,
5613 						void __user *buffer,
5614 						size_t *lenp,
5615 						loff_t *ppos)
5616 {
5617 	int *valp = ctl->data;
5618 	int val = *valp;
5619 	loff_t pos = *ppos;
5620 	struct ctl_table lctl;
5621 	int ret;
5622 
5623 	/* ctl->data points to idev->cnf.ignore_routes_when_linkdown
5624 	 * we should not modify it until we get the rtnl lock.
5625 	 */
5626 	lctl = *ctl;
5627 	lctl.data = &val;
5628 
5629 	ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
5630 
5631 	if (write)
5632 		ret = addrconf_fixup_linkdown(ctl, valp, val);
5633 	if (ret)
5634 		*ppos = pos;
5635 	return ret;
5636 }
5637 
5638 static const struct ctl_table addrconf_sysctl[] = {
5639 	{
5640 		.procname	= "forwarding",
5641 		.data		= &ipv6_devconf.forwarding,
5642 		.maxlen		= sizeof(int),
5643 		.mode		= 0644,
5644 		.proc_handler	= addrconf_sysctl_forward,
5645 	},
5646 	{
5647 		.procname	= "hop_limit",
5648 		.data		= &ipv6_devconf.hop_limit,
5649 		.maxlen		= sizeof(int),
5650 		.mode		= 0644,
5651 		.proc_handler	= addrconf_sysctl_hop_limit,
5652 	},
5653 	{
5654 		.procname	= "mtu",
5655 		.data		= &ipv6_devconf.mtu6,
5656 		.maxlen		= sizeof(int),
5657 		.mode		= 0644,
5658 		.proc_handler	= addrconf_sysctl_mtu,
5659 	},
5660 	{
5661 		.procname	= "accept_ra",
5662 		.data		= &ipv6_devconf.accept_ra,
5663 		.maxlen		= sizeof(int),
5664 		.mode		= 0644,
5665 		.proc_handler	= proc_dointvec,
5666 	},
5667 	{
5668 		.procname	= "accept_redirects",
5669 		.data		= &ipv6_devconf.accept_redirects,
5670 		.maxlen		= sizeof(int),
5671 		.mode		= 0644,
5672 		.proc_handler	= proc_dointvec,
5673 	},
5674 	{
5675 		.procname	= "autoconf",
5676 		.data		= &ipv6_devconf.autoconf,
5677 		.maxlen		= sizeof(int),
5678 		.mode		= 0644,
5679 		.proc_handler	= proc_dointvec,
5680 	},
5681 	{
5682 		.procname	= "dad_transmits",
5683 		.data		= &ipv6_devconf.dad_transmits,
5684 		.maxlen		= sizeof(int),
5685 		.mode		= 0644,
5686 		.proc_handler	= proc_dointvec,
5687 	},
5688 	{
5689 		.procname	= "router_solicitations",
5690 		.data		= &ipv6_devconf.rtr_solicits,
5691 		.maxlen		= sizeof(int),
5692 		.mode		= 0644,
5693 		.proc_handler	= proc_dointvec,
5694 	},
5695 	{
5696 		.procname	= "router_solicitation_interval",
5697 		.data		= &ipv6_devconf.rtr_solicit_interval,
5698 		.maxlen		= sizeof(int),
5699 		.mode		= 0644,
5700 		.proc_handler	= proc_dointvec_jiffies,
5701 	},
5702 	{
5703 		.procname	= "router_solicitation_delay",
5704 		.data		= &ipv6_devconf.rtr_solicit_delay,
5705 		.maxlen		= sizeof(int),
5706 		.mode		= 0644,
5707 		.proc_handler	= proc_dointvec_jiffies,
5708 	},
5709 	{
5710 		.procname	= "force_mld_version",
5711 		.data		= &ipv6_devconf.force_mld_version,
5712 		.maxlen		= sizeof(int),
5713 		.mode		= 0644,
5714 		.proc_handler	= proc_dointvec,
5715 	},
5716 	{
5717 		.procname	= "mldv1_unsolicited_report_interval",
5718 		.data		=
5719 			&ipv6_devconf.mldv1_unsolicited_report_interval,
5720 		.maxlen		= sizeof(int),
5721 		.mode		= 0644,
5722 		.proc_handler	= proc_dointvec_ms_jiffies,
5723 	},
5724 	{
5725 		.procname	= "mldv2_unsolicited_report_interval",
5726 		.data		=
5727 			&ipv6_devconf.mldv2_unsolicited_report_interval,
5728 		.maxlen		= sizeof(int),
5729 		.mode		= 0644,
5730 		.proc_handler	= proc_dointvec_ms_jiffies,
5731 	},
5732 	{
5733 		.procname	= "use_tempaddr",
5734 		.data		= &ipv6_devconf.use_tempaddr,
5735 		.maxlen		= sizeof(int),
5736 		.mode		= 0644,
5737 		.proc_handler	= proc_dointvec,
5738 	},
5739 	{
5740 		.procname	= "temp_valid_lft",
5741 		.data		= &ipv6_devconf.temp_valid_lft,
5742 		.maxlen		= sizeof(int),
5743 		.mode		= 0644,
5744 		.proc_handler	= proc_dointvec,
5745 	},
5746 	{
5747 		.procname	= "temp_prefered_lft",
5748 		.data		= &ipv6_devconf.temp_prefered_lft,
5749 		.maxlen		= sizeof(int),
5750 		.mode		= 0644,
5751 		.proc_handler	= proc_dointvec,
5752 	},
5753 	{
5754 		.procname	= "regen_max_retry",
5755 		.data		= &ipv6_devconf.regen_max_retry,
5756 		.maxlen		= sizeof(int),
5757 		.mode		= 0644,
5758 		.proc_handler	= proc_dointvec,
5759 	},
5760 	{
5761 		.procname	= "max_desync_factor",
5762 		.data		= &ipv6_devconf.max_desync_factor,
5763 		.maxlen		= sizeof(int),
5764 		.mode		= 0644,
5765 		.proc_handler	= proc_dointvec,
5766 	},
5767 	{
5768 		.procname	= "max_addresses",
5769 		.data		= &ipv6_devconf.max_addresses,
5770 		.maxlen		= sizeof(int),
5771 		.mode		= 0644,
5772 		.proc_handler	= proc_dointvec,
5773 	},
5774 	{
5775 		.procname	= "accept_ra_defrtr",
5776 		.data		= &ipv6_devconf.accept_ra_defrtr,
5777 		.maxlen		= sizeof(int),
5778 		.mode		= 0644,
5779 		.proc_handler	= proc_dointvec,
5780 	},
5781 	{
5782 		.procname	= "accept_ra_min_hop_limit",
5783 		.data		= &ipv6_devconf.accept_ra_min_hop_limit,
5784 		.maxlen		= sizeof(int),
5785 		.mode		= 0644,
5786 		.proc_handler	= proc_dointvec,
5787 	},
5788 	{
5789 		.procname	= "accept_ra_pinfo",
5790 		.data		= &ipv6_devconf.accept_ra_pinfo,
5791 		.maxlen		= sizeof(int),
5792 		.mode		= 0644,
5793 		.proc_handler	= proc_dointvec,
5794 	},
5795 #ifdef CONFIG_IPV6_ROUTER_PREF
5796 	{
5797 		.procname	= "accept_ra_rtr_pref",
5798 		.data		= &ipv6_devconf.accept_ra_rtr_pref,
5799 		.maxlen		= sizeof(int),
5800 		.mode		= 0644,
5801 		.proc_handler	= proc_dointvec,
5802 	},
5803 	{
5804 		.procname	= "router_probe_interval",
5805 		.data		= &ipv6_devconf.rtr_probe_interval,
5806 		.maxlen		= sizeof(int),
5807 		.mode		= 0644,
5808 		.proc_handler	= proc_dointvec_jiffies,
5809 	},
5810 #ifdef CONFIG_IPV6_ROUTE_INFO
5811 	{
5812 		.procname	= "accept_ra_rt_info_max_plen",
5813 		.data		= &ipv6_devconf.accept_ra_rt_info_max_plen,
5814 		.maxlen		= sizeof(int),
5815 		.mode		= 0644,
5816 		.proc_handler	= proc_dointvec,
5817 	},
5818 #endif
5819 #endif
5820 	{
5821 		.procname	= "proxy_ndp",
5822 		.data		= &ipv6_devconf.proxy_ndp,
5823 		.maxlen		= sizeof(int),
5824 		.mode		= 0644,
5825 		.proc_handler	= addrconf_sysctl_proxy_ndp,
5826 	},
5827 	{
5828 		.procname	= "accept_source_route",
5829 		.data		= &ipv6_devconf.accept_source_route,
5830 		.maxlen		= sizeof(int),
5831 		.mode		= 0644,
5832 		.proc_handler	= proc_dointvec,
5833 	},
5834 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
5835 	{
5836 		.procname	= "optimistic_dad",
5837 		.data		= &ipv6_devconf.optimistic_dad,
5838 		.maxlen		= sizeof(int),
5839 		.mode		= 0644,
5840 		.proc_handler   = proc_dointvec,
5841 	},
5842 	{
5843 		.procname	= "use_optimistic",
5844 		.data		= &ipv6_devconf.use_optimistic,
5845 		.maxlen		= sizeof(int),
5846 		.mode		= 0644,
5847 		.proc_handler	= proc_dointvec,
5848 	},
5849 #endif
5850 #ifdef CONFIG_IPV6_MROUTE
5851 	{
5852 		.procname	= "mc_forwarding",
5853 		.data		= &ipv6_devconf.mc_forwarding,
5854 		.maxlen		= sizeof(int),
5855 		.mode		= 0444,
5856 		.proc_handler	= proc_dointvec,
5857 	},
5858 #endif
5859 	{
5860 		.procname	= "disable_ipv6",
5861 		.data		= &ipv6_devconf.disable_ipv6,
5862 		.maxlen		= sizeof(int),
5863 		.mode		= 0644,
5864 		.proc_handler	= addrconf_sysctl_disable,
5865 	},
5866 	{
5867 		.procname	= "accept_dad",
5868 		.data		= &ipv6_devconf.accept_dad,
5869 		.maxlen		= sizeof(int),
5870 		.mode		= 0644,
5871 		.proc_handler	= proc_dointvec,
5872 	},
5873 	{
5874 		.procname	= "force_tllao",
5875 		.data		= &ipv6_devconf.force_tllao,
5876 		.maxlen		= sizeof(int),
5877 		.mode		= 0644,
5878 		.proc_handler	= proc_dointvec
5879 	},
5880 	{
5881 		.procname	= "ndisc_notify",
5882 		.data		= &ipv6_devconf.ndisc_notify,
5883 		.maxlen		= sizeof(int),
5884 		.mode		= 0644,
5885 		.proc_handler	= proc_dointvec
5886 	},
5887 	{
5888 		.procname	= "suppress_frag_ndisc",
5889 		.data		= &ipv6_devconf.suppress_frag_ndisc,
5890 		.maxlen		= sizeof(int),
5891 		.mode		= 0644,
5892 		.proc_handler	= proc_dointvec
5893 	},
5894 	{
5895 		.procname	= "accept_ra_from_local",
5896 		.data		= &ipv6_devconf.accept_ra_from_local,
5897 		.maxlen		= sizeof(int),
5898 		.mode		= 0644,
5899 		.proc_handler	= proc_dointvec,
5900 	},
5901 	{
5902 		.procname	= "accept_ra_mtu",
5903 		.data		= &ipv6_devconf.accept_ra_mtu,
5904 		.maxlen		= sizeof(int),
5905 		.mode		= 0644,
5906 		.proc_handler	= proc_dointvec,
5907 	},
5908 	{
5909 		.procname	= "stable_secret",
5910 		.data		= &ipv6_devconf.stable_secret,
5911 		.maxlen		= IPV6_MAX_STRLEN,
5912 		.mode		= 0600,
5913 		.proc_handler	= addrconf_sysctl_stable_secret,
5914 	},
5915 	{
5916 		.procname	= "use_oif_addrs_only",
5917 		.data		= &ipv6_devconf.use_oif_addrs_only,
5918 		.maxlen		= sizeof(int),
5919 		.mode		= 0644,
5920 		.proc_handler	= proc_dointvec,
5921 	},
5922 	{
5923 		.procname	= "ignore_routes_with_linkdown",
5924 		.data		= &ipv6_devconf.ignore_routes_with_linkdown,
5925 		.maxlen		= sizeof(int),
5926 		.mode		= 0644,
5927 		.proc_handler	= addrconf_sysctl_ignore_routes_with_linkdown,
5928 	},
5929 	{
5930 		.procname	= "drop_unicast_in_l2_multicast",
5931 		.data		= &ipv6_devconf.drop_unicast_in_l2_multicast,
5932 		.maxlen		= sizeof(int),
5933 		.mode		= 0644,
5934 		.proc_handler	= proc_dointvec,
5935 	},
5936 	{
5937 		.procname	= "drop_unsolicited_na",
5938 		.data		= &ipv6_devconf.drop_unsolicited_na,
5939 		.maxlen		= sizeof(int),
5940 		.mode		= 0644,
5941 		.proc_handler	= proc_dointvec,
5942 	},
5943 	{
5944 		.procname	= "keep_addr_on_down",
5945 		.data		= &ipv6_devconf.keep_addr_on_down,
5946 		.maxlen		= sizeof(int),
5947 		.mode		= 0644,
5948 		.proc_handler	= proc_dointvec,
5949 
5950 	},
5951 	{
5952 		/* sentinel */
5953 	}
5954 };
5955 
5956 static int __addrconf_sysctl_register(struct net *net, char *dev_name,
5957 		struct inet6_dev *idev, struct ipv6_devconf *p)
5958 {
5959 	int i;
5960 	struct ctl_table *table;
5961 	char path[sizeof("net/ipv6/conf/") + IFNAMSIZ];
5962 
5963 	table = kmemdup(addrconf_sysctl, sizeof(addrconf_sysctl), GFP_KERNEL);
5964 	if (!table)
5965 		goto out;
5966 
5967 	for (i = 0; table[i].data; i++) {
5968 		table[i].data += (char *)p - (char *)&ipv6_devconf;
5969 		table[i].extra1 = idev; /* embedded; no ref */
5970 		table[i].extra2 = net;
5971 	}
5972 
5973 	snprintf(path, sizeof(path), "net/ipv6/conf/%s", dev_name);
5974 
5975 	p->sysctl_header = register_net_sysctl(net, path, table);
5976 	if (!p->sysctl_header)
5977 		goto free;
5978 
5979 	return 0;
5980 
5981 free:
5982 	kfree(table);
5983 out:
5984 	return -ENOBUFS;
5985 }
5986 
5987 static void __addrconf_sysctl_unregister(struct ipv6_devconf *p)
5988 {
5989 	struct ctl_table *table;
5990 
5991 	if (!p->sysctl_header)
5992 		return;
5993 
5994 	table = p->sysctl_header->ctl_table_arg;
5995 	unregister_net_sysctl_table(p->sysctl_header);
5996 	p->sysctl_header = NULL;
5997 	kfree(table);
5998 }
5999 
6000 static int addrconf_sysctl_register(struct inet6_dev *idev)
6001 {
6002 	int err;
6003 
6004 	if (!sysctl_dev_name_is_allowed(idev->dev->name))
6005 		return -EINVAL;
6006 
6007 	err = neigh_sysctl_register(idev->dev, idev->nd_parms,
6008 				    &ndisc_ifinfo_sysctl_change);
6009 	if (err)
6010 		return err;
6011 	err = __addrconf_sysctl_register(dev_net(idev->dev), idev->dev->name,
6012 					 idev, &idev->cnf);
6013 	if (err)
6014 		neigh_sysctl_unregister(idev->nd_parms);
6015 
6016 	return err;
6017 }
6018 
6019 static void addrconf_sysctl_unregister(struct inet6_dev *idev)
6020 {
6021 	__addrconf_sysctl_unregister(&idev->cnf);
6022 	neigh_sysctl_unregister(idev->nd_parms);
6023 }
6024 
6025 
6026 #endif
6027 
6028 static int __net_init addrconf_init_net(struct net *net)
6029 {
6030 	int err = -ENOMEM;
6031 	struct ipv6_devconf *all, *dflt;
6032 
6033 	all = kmemdup(&ipv6_devconf, sizeof(ipv6_devconf), GFP_KERNEL);
6034 	if (!all)
6035 		goto err_alloc_all;
6036 
6037 	dflt = kmemdup(&ipv6_devconf_dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
6038 	if (!dflt)
6039 		goto err_alloc_dflt;
6040 
6041 	/* these will be inherited by all namespaces */
6042 	dflt->autoconf = ipv6_defaults.autoconf;
6043 	dflt->disable_ipv6 = ipv6_defaults.disable_ipv6;
6044 
6045 	dflt->stable_secret.initialized = false;
6046 	all->stable_secret.initialized = false;
6047 
6048 	net->ipv6.devconf_all = all;
6049 	net->ipv6.devconf_dflt = dflt;
6050 
6051 #ifdef CONFIG_SYSCTL
6052 	err = __addrconf_sysctl_register(net, "all", NULL, all);
6053 	if (err < 0)
6054 		goto err_reg_all;
6055 
6056 	err = __addrconf_sysctl_register(net, "default", NULL, dflt);
6057 	if (err < 0)
6058 		goto err_reg_dflt;
6059 #endif
6060 	return 0;
6061 
6062 #ifdef CONFIG_SYSCTL
6063 err_reg_dflt:
6064 	__addrconf_sysctl_unregister(all);
6065 err_reg_all:
6066 	kfree(dflt);
6067 #endif
6068 err_alloc_dflt:
6069 	kfree(all);
6070 err_alloc_all:
6071 	return err;
6072 }
6073 
6074 static void __net_exit addrconf_exit_net(struct net *net)
6075 {
6076 #ifdef CONFIG_SYSCTL
6077 	__addrconf_sysctl_unregister(net->ipv6.devconf_dflt);
6078 	__addrconf_sysctl_unregister(net->ipv6.devconf_all);
6079 #endif
6080 	kfree(net->ipv6.devconf_dflt);
6081 	kfree(net->ipv6.devconf_all);
6082 }
6083 
6084 static struct pernet_operations addrconf_ops = {
6085 	.init = addrconf_init_net,
6086 	.exit = addrconf_exit_net,
6087 };
6088 
6089 static struct rtnl_af_ops inet6_ops __read_mostly = {
6090 	.family		  = AF_INET6,
6091 	.fill_link_af	  = inet6_fill_link_af,
6092 	.get_link_af_size = inet6_get_link_af_size,
6093 	.validate_link_af = inet6_validate_link_af,
6094 	.set_link_af	  = inet6_set_link_af,
6095 };
6096 
6097 /*
6098  *	Init / cleanup code
6099  */
6100 
6101 int __init addrconf_init(void)
6102 {
6103 	struct inet6_dev *idev;
6104 	int i, err;
6105 
6106 	err = ipv6_addr_label_init();
6107 	if (err < 0) {
6108 		pr_crit("%s: cannot initialize default policy table: %d\n",
6109 			__func__, err);
6110 		goto out;
6111 	}
6112 
6113 	err = register_pernet_subsys(&addrconf_ops);
6114 	if (err < 0)
6115 		goto out_addrlabel;
6116 
6117 	addrconf_wq = create_workqueue("ipv6_addrconf");
6118 	if (!addrconf_wq) {
6119 		err = -ENOMEM;
6120 		goto out_nowq;
6121 	}
6122 
6123 	/* The addrconf netdev notifier requires that loopback_dev
6124 	 * has it's ipv6 private information allocated and setup
6125 	 * before it can bring up and give link-local addresses
6126 	 * to other devices which are up.
6127 	 *
6128 	 * Unfortunately, loopback_dev is not necessarily the first
6129 	 * entry in the global dev_base list of net devices.  In fact,
6130 	 * it is likely to be the very last entry on that list.
6131 	 * So this causes the notifier registry below to try and
6132 	 * give link-local addresses to all devices besides loopback_dev
6133 	 * first, then loopback_dev, which cases all the non-loopback_dev
6134 	 * devices to fail to get a link-local address.
6135 	 *
6136 	 * So, as a temporary fix, allocate the ipv6 structure for
6137 	 * loopback_dev first by hand.
6138 	 * Longer term, all of the dependencies ipv6 has upon the loopback
6139 	 * device and it being up should be removed.
6140 	 */
6141 	rtnl_lock();
6142 	idev = ipv6_add_dev(init_net.loopback_dev);
6143 	rtnl_unlock();
6144 	if (IS_ERR(idev)) {
6145 		err = PTR_ERR(idev);
6146 		goto errlo;
6147 	}
6148 
6149 	for (i = 0; i < IN6_ADDR_HSIZE; i++)
6150 		INIT_HLIST_HEAD(&inet6_addr_lst[i]);
6151 
6152 	register_netdevice_notifier(&ipv6_dev_notf);
6153 
6154 	addrconf_verify();
6155 
6156 	rtnl_af_register(&inet6_ops);
6157 
6158 	err = __rtnl_register(PF_INET6, RTM_GETLINK, NULL, inet6_dump_ifinfo,
6159 			      NULL);
6160 	if (err < 0)
6161 		goto errout;
6162 
6163 	/* Only the first call to __rtnl_register can fail */
6164 	__rtnl_register(PF_INET6, RTM_NEWADDR, inet6_rtm_newaddr, NULL, NULL);
6165 	__rtnl_register(PF_INET6, RTM_DELADDR, inet6_rtm_deladdr, NULL, NULL);
6166 	__rtnl_register(PF_INET6, RTM_GETADDR, inet6_rtm_getaddr,
6167 			inet6_dump_ifaddr, NULL);
6168 	__rtnl_register(PF_INET6, RTM_GETMULTICAST, NULL,
6169 			inet6_dump_ifmcaddr, NULL);
6170 	__rtnl_register(PF_INET6, RTM_GETANYCAST, NULL,
6171 			inet6_dump_ifacaddr, NULL);
6172 	__rtnl_register(PF_INET6, RTM_GETNETCONF, inet6_netconf_get_devconf,
6173 			inet6_netconf_dump_devconf, NULL);
6174 
6175 	ipv6_addr_label_rtnl_register();
6176 
6177 	return 0;
6178 errout:
6179 	rtnl_af_unregister(&inet6_ops);
6180 	unregister_netdevice_notifier(&ipv6_dev_notf);
6181 errlo:
6182 	destroy_workqueue(addrconf_wq);
6183 out_nowq:
6184 	unregister_pernet_subsys(&addrconf_ops);
6185 out_addrlabel:
6186 	ipv6_addr_label_cleanup();
6187 out:
6188 	return err;
6189 }
6190 
6191 void addrconf_cleanup(void)
6192 {
6193 	struct net_device *dev;
6194 	int i;
6195 
6196 	unregister_netdevice_notifier(&ipv6_dev_notf);
6197 	unregister_pernet_subsys(&addrconf_ops);
6198 	ipv6_addr_label_cleanup();
6199 
6200 	rtnl_lock();
6201 
6202 	__rtnl_af_unregister(&inet6_ops);
6203 
6204 	/* clean dev list */
6205 	for_each_netdev(&init_net, dev) {
6206 		if (__in6_dev_get(dev) == NULL)
6207 			continue;
6208 		addrconf_ifdown(dev, 1);
6209 	}
6210 	addrconf_ifdown(init_net.loopback_dev, 2);
6211 
6212 	/*
6213 	 *	Check hash table.
6214 	 */
6215 	spin_lock_bh(&addrconf_hash_lock);
6216 	for (i = 0; i < IN6_ADDR_HSIZE; i++)
6217 		WARN_ON(!hlist_empty(&inet6_addr_lst[i]));
6218 	spin_unlock_bh(&addrconf_hash_lock);
6219 	cancel_delayed_work(&addr_chk_work);
6220 	rtnl_unlock();
6221 
6222 	destroy_workqueue(addrconf_wq);
6223 }
6224