xref: /openbmc/linux/net/ipv6/addrconf.c (revision 4800cd83)
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 #include <linux/errno.h>
42 #include <linux/types.h>
43 #include <linux/kernel.h>
44 #include <linux/socket.h>
45 #include <linux/sockios.h>
46 #include <linux/net.h>
47 #include <linux/in6.h>
48 #include <linux/netdevice.h>
49 #include <linux/if_addr.h>
50 #include <linux/if_arp.h>
51 #include <linux/if_arcnet.h>
52 #include <linux/if_infiniband.h>
53 #include <linux/route.h>
54 #include <linux/inetdevice.h>
55 #include <linux/init.h>
56 #include <linux/slab.h>
57 #ifdef CONFIG_SYSCTL
58 #include <linux/sysctl.h>
59 #endif
60 #include <linux/capability.h>
61 #include <linux/delay.h>
62 #include <linux/notifier.h>
63 #include <linux/string.h>
64 
65 #include <net/net_namespace.h>
66 #include <net/sock.h>
67 #include <net/snmp.h>
68 
69 #include <net/ipv6.h>
70 #include <net/protocol.h>
71 #include <net/ndisc.h>
72 #include <net/ip6_route.h>
73 #include <net/addrconf.h>
74 #include <net/tcp.h>
75 #include <net/ip.h>
76 #include <net/netlink.h>
77 #include <net/pkt_sched.h>
78 #include <linux/if_tunnel.h>
79 #include <linux/rtnetlink.h>
80 
81 #ifdef CONFIG_IPV6_PRIVACY
82 #include <linux/random.h>
83 #endif
84 
85 #include <linux/uaccess.h>
86 #include <asm/unaligned.h>
87 
88 #include <linux/proc_fs.h>
89 #include <linux/seq_file.h>
90 
91 /* Set to 3 to get tracing... */
92 #define ACONF_DEBUG 2
93 
94 #if ACONF_DEBUG >= 3
95 #define ADBG(x) printk x
96 #else
97 #define ADBG(x)
98 #endif
99 
100 #define	INFINITY_LIFE_TIME	0xFFFFFFFF
101 
102 static inline u32 cstamp_delta(unsigned long cstamp)
103 {
104 	return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
105 }
106 
107 #define ADDRCONF_TIMER_FUZZ_MINUS	(HZ > 50 ? HZ/50 : 1)
108 #define ADDRCONF_TIMER_FUZZ		(HZ / 4)
109 #define ADDRCONF_TIMER_FUZZ_MAX		(HZ)
110 
111 #ifdef CONFIG_SYSCTL
112 static void addrconf_sysctl_register(struct inet6_dev *idev);
113 static void addrconf_sysctl_unregister(struct inet6_dev *idev);
114 #else
115 static inline void addrconf_sysctl_register(struct inet6_dev *idev)
116 {
117 }
118 
119 static inline void addrconf_sysctl_unregister(struct inet6_dev *idev)
120 {
121 }
122 #endif
123 
124 #ifdef CONFIG_IPV6_PRIVACY
125 static int __ipv6_regen_rndid(struct inet6_dev *idev);
126 static int __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr);
127 static void ipv6_regen_rndid(unsigned long data);
128 #endif
129 
130 static int ipv6_generate_eui64(u8 *eui, struct net_device *dev);
131 static int ipv6_count_addresses(struct inet6_dev *idev);
132 
133 /*
134  *	Configured unicast address hash table
135  */
136 static struct hlist_head inet6_addr_lst[IN6_ADDR_HSIZE];
137 static DEFINE_SPINLOCK(addrconf_hash_lock);
138 
139 static void addrconf_verify(unsigned long);
140 
141 static DEFINE_TIMER(addr_chk_timer, addrconf_verify, 0, 0);
142 static DEFINE_SPINLOCK(addrconf_verify_lock);
143 
144 static void addrconf_join_anycast(struct inet6_ifaddr *ifp);
145 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp);
146 
147 static void addrconf_type_change(struct net_device *dev,
148 				 unsigned long event);
149 static int addrconf_ifdown(struct net_device *dev, int how);
150 
151 static void addrconf_dad_start(struct inet6_ifaddr *ifp, u32 flags);
152 static void addrconf_dad_timer(unsigned long data);
153 static void addrconf_dad_completed(struct inet6_ifaddr *ifp);
154 static void addrconf_dad_run(struct inet6_dev *idev);
155 static void addrconf_rs_timer(unsigned long data);
156 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
157 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
158 
159 static void inet6_prefix_notify(int event, struct inet6_dev *idev,
160 				struct prefix_info *pinfo);
161 static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
162 			       struct net_device *dev);
163 
164 static ATOMIC_NOTIFIER_HEAD(inet6addr_chain);
165 
166 static struct ipv6_devconf ipv6_devconf __read_mostly = {
167 	.forwarding		= 0,
168 	.hop_limit		= IPV6_DEFAULT_HOPLIMIT,
169 	.mtu6			= IPV6_MIN_MTU,
170 	.accept_ra		= 1,
171 	.accept_redirects	= 1,
172 	.autoconf		= 1,
173 	.force_mld_version	= 0,
174 	.dad_transmits		= 1,
175 	.rtr_solicits		= MAX_RTR_SOLICITATIONS,
176 	.rtr_solicit_interval	= RTR_SOLICITATION_INTERVAL,
177 	.rtr_solicit_delay	= MAX_RTR_SOLICITATION_DELAY,
178 #ifdef CONFIG_IPV6_PRIVACY
179 	.use_tempaddr 		= 0,
180 	.temp_valid_lft		= TEMP_VALID_LIFETIME,
181 	.temp_prefered_lft	= TEMP_PREFERRED_LIFETIME,
182 	.regen_max_retry	= REGEN_MAX_RETRY,
183 	.max_desync_factor	= MAX_DESYNC_FACTOR,
184 #endif
185 	.max_addresses		= IPV6_MAX_ADDRESSES,
186 	.accept_ra_defrtr	= 1,
187 	.accept_ra_pinfo	= 1,
188 #ifdef CONFIG_IPV6_ROUTER_PREF
189 	.accept_ra_rtr_pref	= 1,
190 	.rtr_probe_interval	= 60 * HZ,
191 #ifdef CONFIG_IPV6_ROUTE_INFO
192 	.accept_ra_rt_info_max_plen = 0,
193 #endif
194 #endif
195 	.proxy_ndp		= 0,
196 	.accept_source_route	= 0,	/* we do not accept RH0 by default. */
197 	.disable_ipv6		= 0,
198 	.accept_dad		= 1,
199 };
200 
201 static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = {
202 	.forwarding		= 0,
203 	.hop_limit		= IPV6_DEFAULT_HOPLIMIT,
204 	.mtu6			= IPV6_MIN_MTU,
205 	.accept_ra		= 1,
206 	.accept_redirects	= 1,
207 	.autoconf		= 1,
208 	.dad_transmits		= 1,
209 	.rtr_solicits		= MAX_RTR_SOLICITATIONS,
210 	.rtr_solicit_interval	= RTR_SOLICITATION_INTERVAL,
211 	.rtr_solicit_delay	= MAX_RTR_SOLICITATION_DELAY,
212 #ifdef CONFIG_IPV6_PRIVACY
213 	.use_tempaddr		= 0,
214 	.temp_valid_lft		= TEMP_VALID_LIFETIME,
215 	.temp_prefered_lft	= TEMP_PREFERRED_LIFETIME,
216 	.regen_max_retry	= REGEN_MAX_RETRY,
217 	.max_desync_factor	= MAX_DESYNC_FACTOR,
218 #endif
219 	.max_addresses		= IPV6_MAX_ADDRESSES,
220 	.accept_ra_defrtr	= 1,
221 	.accept_ra_pinfo	= 1,
222 #ifdef CONFIG_IPV6_ROUTER_PREF
223 	.accept_ra_rtr_pref	= 1,
224 	.rtr_probe_interval	= 60 * HZ,
225 #ifdef CONFIG_IPV6_ROUTE_INFO
226 	.accept_ra_rt_info_max_plen = 0,
227 #endif
228 #endif
229 	.proxy_ndp		= 0,
230 	.accept_source_route	= 0,	/* we do not accept RH0 by default. */
231 	.disable_ipv6		= 0,
232 	.accept_dad		= 1,
233 };
234 
235 /* IPv6 Wildcard Address and Loopback Address defined by RFC2553 */
236 const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
237 const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
238 const struct in6_addr in6addr_linklocal_allnodes = IN6ADDR_LINKLOCAL_ALLNODES_INIT;
239 const struct in6_addr in6addr_linklocal_allrouters = IN6ADDR_LINKLOCAL_ALLROUTERS_INIT;
240 
241 /* Check if a valid qdisc is available */
242 static inline bool addrconf_qdisc_ok(const struct net_device *dev)
243 {
244 	return !qdisc_tx_is_noop(dev);
245 }
246 
247 /* Check if a route is valid prefix route */
248 static inline int addrconf_is_prefix_route(const struct rt6_info *rt)
249 {
250 	return (rt->rt6i_flags & (RTF_GATEWAY | RTF_DEFAULT)) == 0;
251 }
252 
253 static void addrconf_del_timer(struct inet6_ifaddr *ifp)
254 {
255 	if (del_timer(&ifp->timer))
256 		__in6_ifa_put(ifp);
257 }
258 
259 enum addrconf_timer_t {
260 	AC_NONE,
261 	AC_DAD,
262 	AC_RS,
263 };
264 
265 static void addrconf_mod_timer(struct inet6_ifaddr *ifp,
266 			       enum addrconf_timer_t what,
267 			       unsigned long when)
268 {
269 	if (!del_timer(&ifp->timer))
270 		in6_ifa_hold(ifp);
271 
272 	switch (what) {
273 	case AC_DAD:
274 		ifp->timer.function = addrconf_dad_timer;
275 		break;
276 	case AC_RS:
277 		ifp->timer.function = addrconf_rs_timer;
278 		break;
279 	default:
280 		break;
281 	}
282 	ifp->timer.expires = jiffies + when;
283 	add_timer(&ifp->timer);
284 }
285 
286 static int snmp6_alloc_dev(struct inet6_dev *idev)
287 {
288 	if (snmp_mib_init((void __percpu **)idev->stats.ipv6,
289 			  sizeof(struct ipstats_mib),
290 			  __alignof__(struct ipstats_mib)) < 0)
291 		goto err_ip;
292 	if (snmp_mib_init((void __percpu **)idev->stats.icmpv6,
293 			  sizeof(struct icmpv6_mib),
294 			  __alignof__(struct icmpv6_mib)) < 0)
295 		goto err_icmp;
296 	if (snmp_mib_init((void __percpu **)idev->stats.icmpv6msg,
297 			  sizeof(struct icmpv6msg_mib),
298 			  __alignof__(struct icmpv6msg_mib)) < 0)
299 		goto err_icmpmsg;
300 
301 	return 0;
302 
303 err_icmpmsg:
304 	snmp_mib_free((void __percpu **)idev->stats.icmpv6);
305 err_icmp:
306 	snmp_mib_free((void __percpu **)idev->stats.ipv6);
307 err_ip:
308 	return -ENOMEM;
309 }
310 
311 static void snmp6_free_dev(struct inet6_dev *idev)
312 {
313 	snmp_mib_free((void __percpu **)idev->stats.icmpv6msg);
314 	snmp_mib_free((void __percpu **)idev->stats.icmpv6);
315 	snmp_mib_free((void __percpu **)idev->stats.ipv6);
316 }
317 
318 /* Nobody refers to this device, we may destroy it. */
319 
320 static void in6_dev_finish_destroy_rcu(struct rcu_head *head)
321 {
322 	struct inet6_dev *idev = container_of(head, struct inet6_dev, rcu);
323 	kfree(idev);
324 }
325 
326 void in6_dev_finish_destroy(struct inet6_dev *idev)
327 {
328 	struct net_device *dev = idev->dev;
329 
330 	WARN_ON(!list_empty(&idev->addr_list));
331 	WARN_ON(idev->mc_list != NULL);
332 
333 #ifdef NET_REFCNT_DEBUG
334 	printk(KERN_DEBUG "in6_dev_finish_destroy: %s\n", dev ? dev->name : "NIL");
335 #endif
336 	dev_put(dev);
337 	if (!idev->dead) {
338 		pr_warning("Freeing alive inet6 device %p\n", idev);
339 		return;
340 	}
341 	snmp6_free_dev(idev);
342 	call_rcu(&idev->rcu, in6_dev_finish_destroy_rcu);
343 }
344 
345 EXPORT_SYMBOL(in6_dev_finish_destroy);
346 
347 static struct inet6_dev * ipv6_add_dev(struct net_device *dev)
348 {
349 	struct inet6_dev *ndev;
350 
351 	ASSERT_RTNL();
352 
353 	if (dev->mtu < IPV6_MIN_MTU)
354 		return NULL;
355 
356 	ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL);
357 
358 	if (ndev == NULL)
359 		return NULL;
360 
361 	rwlock_init(&ndev->lock);
362 	ndev->dev = dev;
363 	INIT_LIST_HEAD(&ndev->addr_list);
364 
365 	memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf));
366 	ndev->cnf.mtu6 = dev->mtu;
367 	ndev->cnf.sysctl = NULL;
368 	ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
369 	if (ndev->nd_parms == NULL) {
370 		kfree(ndev);
371 		return NULL;
372 	}
373 	if (ndev->cnf.forwarding)
374 		dev_disable_lro(dev);
375 	/* We refer to the device */
376 	dev_hold(dev);
377 
378 	if (snmp6_alloc_dev(ndev) < 0) {
379 		ADBG((KERN_WARNING
380 			"%s(): cannot allocate memory for statistics; dev=%s.\n",
381 			__func__, dev->name));
382 		neigh_parms_release(&nd_tbl, ndev->nd_parms);
383 		ndev->dead = 1;
384 		in6_dev_finish_destroy(ndev);
385 		return NULL;
386 	}
387 
388 	if (snmp6_register_dev(ndev) < 0) {
389 		ADBG((KERN_WARNING
390 			"%s(): cannot create /proc/net/dev_snmp6/%s\n",
391 			__func__, dev->name));
392 		neigh_parms_release(&nd_tbl, ndev->nd_parms);
393 		ndev->dead = 1;
394 		in6_dev_finish_destroy(ndev);
395 		return NULL;
396 	}
397 
398 	/* One reference from device.  We must do this before
399 	 * we invoke __ipv6_regen_rndid().
400 	 */
401 	in6_dev_hold(ndev);
402 
403 	if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
404 		ndev->cnf.accept_dad = -1;
405 
406 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
407 	if (dev->type == ARPHRD_SIT && (dev->priv_flags & IFF_ISATAP)) {
408 		printk(KERN_INFO
409 		       "%s: Disabled Multicast RS\n",
410 		       dev->name);
411 		ndev->cnf.rtr_solicits = 0;
412 	}
413 #endif
414 
415 #ifdef CONFIG_IPV6_PRIVACY
416 	INIT_LIST_HEAD(&ndev->tempaddr_list);
417 	setup_timer(&ndev->regen_timer, ipv6_regen_rndid, (unsigned long)ndev);
418 	if ((dev->flags&IFF_LOOPBACK) ||
419 	    dev->type == ARPHRD_TUNNEL ||
420 	    dev->type == ARPHRD_TUNNEL6 ||
421 	    dev->type == ARPHRD_SIT ||
422 	    dev->type == ARPHRD_NONE) {
423 		ndev->cnf.use_tempaddr = -1;
424 	} else {
425 		in6_dev_hold(ndev);
426 		ipv6_regen_rndid((unsigned long) ndev);
427 	}
428 #endif
429 
430 	if (netif_running(dev) && addrconf_qdisc_ok(dev))
431 		ndev->if_flags |= IF_READY;
432 
433 	ipv6_mc_init_dev(ndev);
434 	ndev->tstamp = jiffies;
435 	addrconf_sysctl_register(ndev);
436 	/* protected by rtnl_lock */
437 	rcu_assign_pointer(dev->ip6_ptr, ndev);
438 
439 	/* Join all-node multicast group */
440 	ipv6_dev_mc_inc(dev, &in6addr_linklocal_allnodes);
441 
442 	return ndev;
443 }
444 
445 static struct inet6_dev * ipv6_find_idev(struct net_device *dev)
446 {
447 	struct inet6_dev *idev;
448 
449 	ASSERT_RTNL();
450 
451 	idev = __in6_dev_get(dev);
452 	if (!idev) {
453 		idev = ipv6_add_dev(dev);
454 		if (!idev)
455 			return NULL;
456 	}
457 
458 	if (dev->flags&IFF_UP)
459 		ipv6_mc_up(idev);
460 	return idev;
461 }
462 
463 #ifdef CONFIG_SYSCTL
464 static void dev_forward_change(struct inet6_dev *idev)
465 {
466 	struct net_device *dev;
467 	struct inet6_ifaddr *ifa;
468 
469 	if (!idev)
470 		return;
471 	dev = idev->dev;
472 	if (idev->cnf.forwarding)
473 		dev_disable_lro(dev);
474 	if (dev && (dev->flags & IFF_MULTICAST)) {
475 		if (idev->cnf.forwarding)
476 			ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
477 		else
478 			ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters);
479 	}
480 
481 	list_for_each_entry(ifa, &idev->addr_list, if_list) {
482 		if (ifa->flags&IFA_F_TENTATIVE)
483 			continue;
484 		if (idev->cnf.forwarding)
485 			addrconf_join_anycast(ifa);
486 		else
487 			addrconf_leave_anycast(ifa);
488 	}
489 }
490 
491 
492 static void addrconf_forward_change(struct net *net, __s32 newf)
493 {
494 	struct net_device *dev;
495 	struct inet6_dev *idev;
496 
497 	rcu_read_lock();
498 	for_each_netdev_rcu(net, dev) {
499 		idev = __in6_dev_get(dev);
500 		if (idev) {
501 			int changed = (!idev->cnf.forwarding) ^ (!newf);
502 			idev->cnf.forwarding = newf;
503 			if (changed)
504 				dev_forward_change(idev);
505 		}
506 	}
507 	rcu_read_unlock();
508 }
509 
510 static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int old)
511 {
512 	struct net *net;
513 
514 	net = (struct net *)table->extra2;
515 	if (p == &net->ipv6.devconf_dflt->forwarding)
516 		return 0;
517 
518 	if (!rtnl_trylock()) {
519 		/* Restore the original values before restarting */
520 		*p = old;
521 		return restart_syscall();
522 	}
523 
524 	if (p == &net->ipv6.devconf_all->forwarding) {
525 		__s32 newf = net->ipv6.devconf_all->forwarding;
526 		net->ipv6.devconf_dflt->forwarding = newf;
527 		addrconf_forward_change(net, newf);
528 	} else if ((!*p) ^ (!old))
529 		dev_forward_change((struct inet6_dev *)table->extra1);
530 	rtnl_unlock();
531 
532 	if (*p)
533 		rt6_purge_dflt_routers(net);
534 	return 1;
535 }
536 #endif
537 
538 static void inet6_ifa_finish_destroy_rcu(struct rcu_head *head)
539 {
540 	struct inet6_ifaddr *ifp = container_of(head, struct inet6_ifaddr, rcu);
541 	kfree(ifp);
542 }
543 
544 /* Nobody refers to this ifaddr, destroy it */
545 void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
546 {
547 	WARN_ON(!hlist_unhashed(&ifp->addr_lst));
548 
549 #ifdef NET_REFCNT_DEBUG
550 	printk(KERN_DEBUG "inet6_ifa_finish_destroy\n");
551 #endif
552 
553 	in6_dev_put(ifp->idev);
554 
555 	if (del_timer(&ifp->timer))
556 		pr_notice("Timer is still running, when freeing ifa=%p\n", ifp);
557 
558 	if (ifp->state != INET6_IFADDR_STATE_DEAD) {
559 		pr_warning("Freeing alive inet6 address %p\n", ifp);
560 		return;
561 	}
562 	dst_release(&ifp->rt->dst);
563 
564 	call_rcu(&ifp->rcu, inet6_ifa_finish_destroy_rcu);
565 }
566 
567 static void
568 ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp)
569 {
570 	struct list_head *p;
571 	int ifp_scope = ipv6_addr_src_scope(&ifp->addr);
572 
573 	/*
574 	 * Each device address list is sorted in order of scope -
575 	 * global before linklocal.
576 	 */
577 	list_for_each(p, &idev->addr_list) {
578 		struct inet6_ifaddr *ifa
579 			= list_entry(p, struct inet6_ifaddr, if_list);
580 		if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr))
581 			break;
582 	}
583 
584 	list_add_tail(&ifp->if_list, p);
585 }
586 
587 static u32 ipv6_addr_hash(const struct in6_addr *addr)
588 {
589 	/*
590 	 * We perform the hash function over the last 64 bits of the address
591 	 * This will include the IEEE address token on links that support it.
592 	 */
593 	return jhash_2words((__force u32)addr->s6_addr32[2],
594 			    (__force u32)addr->s6_addr32[3], 0)
595 		& (IN6_ADDR_HSIZE - 1);
596 }
597 
598 /* On success it returns ifp with increased reference count */
599 
600 static struct inet6_ifaddr *
601 ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, int pfxlen,
602 	      int scope, u32 flags)
603 {
604 	struct inet6_ifaddr *ifa = NULL;
605 	struct rt6_info *rt;
606 	unsigned int hash;
607 	int err = 0;
608 	int addr_type = ipv6_addr_type(addr);
609 
610 	if (addr_type == IPV6_ADDR_ANY ||
611 	    addr_type & IPV6_ADDR_MULTICAST ||
612 	    (!(idev->dev->flags & IFF_LOOPBACK) &&
613 	     addr_type & IPV6_ADDR_LOOPBACK))
614 		return ERR_PTR(-EADDRNOTAVAIL);
615 
616 	rcu_read_lock_bh();
617 	if (idev->dead) {
618 		err = -ENODEV;			/*XXX*/
619 		goto out2;
620 	}
621 
622 	if (idev->cnf.disable_ipv6) {
623 		err = -EACCES;
624 		goto out2;
625 	}
626 
627 	spin_lock(&addrconf_hash_lock);
628 
629 	/* Ignore adding duplicate addresses on an interface */
630 	if (ipv6_chk_same_addr(dev_net(idev->dev), addr, idev->dev)) {
631 		ADBG(("ipv6_add_addr: already assigned\n"));
632 		err = -EEXIST;
633 		goto out;
634 	}
635 
636 	ifa = kzalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC);
637 
638 	if (ifa == NULL) {
639 		ADBG(("ipv6_add_addr: malloc failed\n"));
640 		err = -ENOBUFS;
641 		goto out;
642 	}
643 
644 	rt = addrconf_dst_alloc(idev, addr, 0);
645 	if (IS_ERR(rt)) {
646 		err = PTR_ERR(rt);
647 		goto out;
648 	}
649 
650 	ipv6_addr_copy(&ifa->addr, addr);
651 
652 	spin_lock_init(&ifa->lock);
653 	spin_lock_init(&ifa->state_lock);
654 	init_timer(&ifa->timer);
655 	INIT_HLIST_NODE(&ifa->addr_lst);
656 	ifa->timer.data = (unsigned long) ifa;
657 	ifa->scope = scope;
658 	ifa->prefix_len = pfxlen;
659 	ifa->flags = flags | IFA_F_TENTATIVE;
660 	ifa->cstamp = ifa->tstamp = jiffies;
661 
662 	ifa->rt = rt;
663 
664 	/*
665 	 * part one of RFC 4429, section 3.3
666 	 * We should not configure an address as
667 	 * optimistic if we do not yet know the link
668 	 * layer address of our nexhop router
669 	 */
670 
671 	if (rt->rt6i_nexthop == NULL)
672 		ifa->flags &= ~IFA_F_OPTIMISTIC;
673 
674 	ifa->idev = idev;
675 	in6_dev_hold(idev);
676 	/* For caller */
677 	in6_ifa_hold(ifa);
678 
679 	/* Add to big hash table */
680 	hash = ipv6_addr_hash(addr);
681 
682 	hlist_add_head_rcu(&ifa->addr_lst, &inet6_addr_lst[hash]);
683 	spin_unlock(&addrconf_hash_lock);
684 
685 	write_lock(&idev->lock);
686 	/* Add to inet6_dev unicast addr list. */
687 	ipv6_link_dev_addr(idev, ifa);
688 
689 #ifdef CONFIG_IPV6_PRIVACY
690 	if (ifa->flags&IFA_F_TEMPORARY) {
691 		list_add(&ifa->tmp_list, &idev->tempaddr_list);
692 		in6_ifa_hold(ifa);
693 	}
694 #endif
695 
696 	in6_ifa_hold(ifa);
697 	write_unlock(&idev->lock);
698 out2:
699 	rcu_read_unlock_bh();
700 
701 	if (likely(err == 0))
702 		atomic_notifier_call_chain(&inet6addr_chain, NETDEV_UP, ifa);
703 	else {
704 		kfree(ifa);
705 		ifa = ERR_PTR(err);
706 	}
707 
708 	return ifa;
709 out:
710 	spin_unlock(&addrconf_hash_lock);
711 	goto out2;
712 }
713 
714 /* This function wants to get referenced ifp and releases it before return */
715 
716 static void ipv6_del_addr(struct inet6_ifaddr *ifp)
717 {
718 	struct inet6_ifaddr *ifa, *ifn;
719 	struct inet6_dev *idev = ifp->idev;
720 	int state;
721 	int hash;
722 	int deleted = 0, onlink = 0;
723 	unsigned long expires = jiffies;
724 
725 	hash = ipv6_addr_hash(&ifp->addr);
726 
727 	spin_lock_bh(&ifp->state_lock);
728 	state = ifp->state;
729 	ifp->state = INET6_IFADDR_STATE_DEAD;
730 	spin_unlock_bh(&ifp->state_lock);
731 
732 	if (state == INET6_IFADDR_STATE_DEAD)
733 		goto out;
734 
735 	spin_lock_bh(&addrconf_hash_lock);
736 	hlist_del_init_rcu(&ifp->addr_lst);
737 	spin_unlock_bh(&addrconf_hash_lock);
738 
739 	write_lock_bh(&idev->lock);
740 #ifdef CONFIG_IPV6_PRIVACY
741 	if (ifp->flags&IFA_F_TEMPORARY) {
742 		list_del(&ifp->tmp_list);
743 		if (ifp->ifpub) {
744 			in6_ifa_put(ifp->ifpub);
745 			ifp->ifpub = NULL;
746 		}
747 		__in6_ifa_put(ifp);
748 	}
749 #endif
750 
751 	list_for_each_entry_safe(ifa, ifn, &idev->addr_list, if_list) {
752 		if (ifa == ifp) {
753 			list_del_init(&ifp->if_list);
754 			__in6_ifa_put(ifp);
755 
756 			if (!(ifp->flags & IFA_F_PERMANENT) || onlink > 0)
757 				break;
758 			deleted = 1;
759 			continue;
760 		} else if (ifp->flags & IFA_F_PERMANENT) {
761 			if (ipv6_prefix_equal(&ifa->addr, &ifp->addr,
762 					      ifp->prefix_len)) {
763 				if (ifa->flags & IFA_F_PERMANENT) {
764 					onlink = 1;
765 					if (deleted)
766 						break;
767 				} else {
768 					unsigned long lifetime;
769 
770 					if (!onlink)
771 						onlink = -1;
772 
773 					spin_lock(&ifa->lock);
774 
775 					lifetime = addrconf_timeout_fixup(ifa->valid_lft, HZ);
776 					/*
777 					 * Note: Because this address is
778 					 * not permanent, lifetime <
779 					 * LONG_MAX / HZ here.
780 					 */
781 					if (time_before(expires,
782 							ifa->tstamp + lifetime * HZ))
783 						expires = ifa->tstamp + lifetime * HZ;
784 					spin_unlock(&ifa->lock);
785 				}
786 			}
787 		}
788 	}
789 	write_unlock_bh(&idev->lock);
790 
791 	addrconf_del_timer(ifp);
792 
793 	ipv6_ifa_notify(RTM_DELADDR, ifp);
794 
795 	atomic_notifier_call_chain(&inet6addr_chain, NETDEV_DOWN, ifp);
796 
797 	/*
798 	 * Purge or update corresponding prefix
799 	 *
800 	 * 1) we don't purge prefix here if address was not permanent.
801 	 *    prefix is managed by its own lifetime.
802 	 * 2) if there're no addresses, delete prefix.
803 	 * 3) if there're still other permanent address(es),
804 	 *    corresponding prefix is still permanent.
805 	 * 4) otherwise, update prefix lifetime to the
806 	 *    longest valid lifetime among the corresponding
807 	 *    addresses on the device.
808 	 *    Note: subsequent RA will update lifetime.
809 	 *
810 	 * --yoshfuji
811 	 */
812 	if ((ifp->flags & IFA_F_PERMANENT) && onlink < 1) {
813 		struct in6_addr prefix;
814 		struct rt6_info *rt;
815 		struct net *net = dev_net(ifp->idev->dev);
816 		ipv6_addr_prefix(&prefix, &ifp->addr, ifp->prefix_len);
817 		rt = rt6_lookup(net, &prefix, NULL, ifp->idev->dev->ifindex, 1);
818 
819 		if (rt && addrconf_is_prefix_route(rt)) {
820 			if (onlink == 0) {
821 				ip6_del_rt(rt);
822 				rt = NULL;
823 			} else if (!(rt->rt6i_flags & RTF_EXPIRES)) {
824 				rt->rt6i_expires = expires;
825 				rt->rt6i_flags |= RTF_EXPIRES;
826 			}
827 		}
828 		dst_release(&rt->dst);
829 	}
830 
831 out:
832 	in6_ifa_put(ifp);
833 }
834 
835 #ifdef CONFIG_IPV6_PRIVACY
836 static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, struct inet6_ifaddr *ift)
837 {
838 	struct inet6_dev *idev = ifp->idev;
839 	struct in6_addr addr, *tmpaddr;
840 	unsigned long tmp_prefered_lft, tmp_valid_lft, tmp_cstamp, tmp_tstamp, age;
841 	unsigned long regen_advance;
842 	int tmp_plen;
843 	int ret = 0;
844 	int max_addresses;
845 	u32 addr_flags;
846 
847 	write_lock(&idev->lock);
848 	if (ift) {
849 		spin_lock_bh(&ift->lock);
850 		memcpy(&addr.s6_addr[8], &ift->addr.s6_addr[8], 8);
851 		spin_unlock_bh(&ift->lock);
852 		tmpaddr = &addr;
853 	} else {
854 		tmpaddr = NULL;
855 	}
856 retry:
857 	in6_dev_hold(idev);
858 	if (idev->cnf.use_tempaddr <= 0) {
859 		write_unlock(&idev->lock);
860 		printk(KERN_INFO
861 			"ipv6_create_tempaddr(): use_tempaddr is disabled.\n");
862 		in6_dev_put(idev);
863 		ret = -1;
864 		goto out;
865 	}
866 	spin_lock_bh(&ifp->lock);
867 	if (ifp->regen_count++ >= idev->cnf.regen_max_retry) {
868 		idev->cnf.use_tempaddr = -1;	/*XXX*/
869 		spin_unlock_bh(&ifp->lock);
870 		write_unlock(&idev->lock);
871 		printk(KERN_WARNING
872 			"ipv6_create_tempaddr(): regeneration time exceeded. disabled temporary address support.\n");
873 		in6_dev_put(idev);
874 		ret = -1;
875 		goto out;
876 	}
877 	in6_ifa_hold(ifp);
878 	memcpy(addr.s6_addr, ifp->addr.s6_addr, 8);
879 	if (__ipv6_try_regen_rndid(idev, tmpaddr) < 0) {
880 		spin_unlock_bh(&ifp->lock);
881 		write_unlock(&idev->lock);
882 		printk(KERN_WARNING
883 			"ipv6_create_tempaddr(): regeneration of randomized interface id failed.\n");
884 		in6_ifa_put(ifp);
885 		in6_dev_put(idev);
886 		ret = -1;
887 		goto out;
888 	}
889 	memcpy(&addr.s6_addr[8], idev->rndid, 8);
890 	age = (jiffies - ifp->tstamp) / HZ;
891 	tmp_valid_lft = min_t(__u32,
892 			      ifp->valid_lft,
893 			      idev->cnf.temp_valid_lft + age);
894 	tmp_prefered_lft = min_t(__u32,
895 				 ifp->prefered_lft,
896 				 idev->cnf.temp_prefered_lft + age -
897 				 idev->cnf.max_desync_factor);
898 	tmp_plen = ifp->prefix_len;
899 	max_addresses = idev->cnf.max_addresses;
900 	tmp_cstamp = ifp->cstamp;
901 	tmp_tstamp = ifp->tstamp;
902 	spin_unlock_bh(&ifp->lock);
903 
904 	regen_advance = idev->cnf.regen_max_retry *
905 	                idev->cnf.dad_transmits *
906 	                idev->nd_parms->retrans_time / HZ;
907 	write_unlock(&idev->lock);
908 
909 	/* A temporary address is created only if this calculated Preferred
910 	 * Lifetime is greater than REGEN_ADVANCE time units.  In particular,
911 	 * an implementation must not create a temporary address with a zero
912 	 * Preferred Lifetime.
913 	 */
914 	if (tmp_prefered_lft <= regen_advance) {
915 		in6_ifa_put(ifp);
916 		in6_dev_put(idev);
917 		ret = -1;
918 		goto out;
919 	}
920 
921 	addr_flags = IFA_F_TEMPORARY;
922 	/* set in addrconf_prefix_rcv() */
923 	if (ifp->flags & IFA_F_OPTIMISTIC)
924 		addr_flags |= IFA_F_OPTIMISTIC;
925 
926 	ift = !max_addresses ||
927 	      ipv6_count_addresses(idev) < max_addresses ?
928 		ipv6_add_addr(idev, &addr, tmp_plen,
929 			      ipv6_addr_type(&addr)&IPV6_ADDR_SCOPE_MASK,
930 			      addr_flags) : NULL;
931 	if (!ift || IS_ERR(ift)) {
932 		in6_ifa_put(ifp);
933 		in6_dev_put(idev);
934 		printk(KERN_INFO
935 			"ipv6_create_tempaddr(): retry temporary address regeneration.\n");
936 		tmpaddr = &addr;
937 		write_lock(&idev->lock);
938 		goto retry;
939 	}
940 
941 	spin_lock_bh(&ift->lock);
942 	ift->ifpub = ifp;
943 	ift->valid_lft = tmp_valid_lft;
944 	ift->prefered_lft = tmp_prefered_lft;
945 	ift->cstamp = tmp_cstamp;
946 	ift->tstamp = tmp_tstamp;
947 	spin_unlock_bh(&ift->lock);
948 
949 	addrconf_dad_start(ift, 0);
950 	in6_ifa_put(ift);
951 	in6_dev_put(idev);
952 out:
953 	return ret;
954 }
955 #endif
956 
957 /*
958  *	Choose an appropriate source address (RFC3484)
959  */
960 enum {
961 	IPV6_SADDR_RULE_INIT = 0,
962 	IPV6_SADDR_RULE_LOCAL,
963 	IPV6_SADDR_RULE_SCOPE,
964 	IPV6_SADDR_RULE_PREFERRED,
965 #ifdef CONFIG_IPV6_MIP6
966 	IPV6_SADDR_RULE_HOA,
967 #endif
968 	IPV6_SADDR_RULE_OIF,
969 	IPV6_SADDR_RULE_LABEL,
970 #ifdef CONFIG_IPV6_PRIVACY
971 	IPV6_SADDR_RULE_PRIVACY,
972 #endif
973 	IPV6_SADDR_RULE_ORCHID,
974 	IPV6_SADDR_RULE_PREFIX,
975 	IPV6_SADDR_RULE_MAX
976 };
977 
978 struct ipv6_saddr_score {
979 	int			rule;
980 	int			addr_type;
981 	struct inet6_ifaddr	*ifa;
982 	DECLARE_BITMAP(scorebits, IPV6_SADDR_RULE_MAX);
983 	int			scopedist;
984 	int			matchlen;
985 };
986 
987 struct ipv6_saddr_dst {
988 	const struct in6_addr *addr;
989 	int ifindex;
990 	int scope;
991 	int label;
992 	unsigned int prefs;
993 };
994 
995 static inline int ipv6_saddr_preferred(int type)
996 {
997 	if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4|IPV6_ADDR_LOOPBACK))
998 		return 1;
999 	return 0;
1000 }
1001 
1002 static int ipv6_get_saddr_eval(struct net *net,
1003 			       struct ipv6_saddr_score *score,
1004 			       struct ipv6_saddr_dst *dst,
1005 			       int i)
1006 {
1007 	int ret;
1008 
1009 	if (i <= score->rule) {
1010 		switch (i) {
1011 		case IPV6_SADDR_RULE_SCOPE:
1012 			ret = score->scopedist;
1013 			break;
1014 		case IPV6_SADDR_RULE_PREFIX:
1015 			ret = score->matchlen;
1016 			break;
1017 		default:
1018 			ret = !!test_bit(i, score->scorebits);
1019 		}
1020 		goto out;
1021 	}
1022 
1023 	switch (i) {
1024 	case IPV6_SADDR_RULE_INIT:
1025 		/* Rule 0: remember if hiscore is not ready yet */
1026 		ret = !!score->ifa;
1027 		break;
1028 	case IPV6_SADDR_RULE_LOCAL:
1029 		/* Rule 1: Prefer same address */
1030 		ret = ipv6_addr_equal(&score->ifa->addr, dst->addr);
1031 		break;
1032 	case IPV6_SADDR_RULE_SCOPE:
1033 		/* Rule 2: Prefer appropriate scope
1034 		 *
1035 		 *      ret
1036 		 *       ^
1037 		 *    -1 |  d 15
1038 		 *    ---+--+-+---> scope
1039 		 *       |
1040 		 *       |             d is scope of the destination.
1041 		 *  B-d  |  \
1042 		 *       |   \      <- smaller scope is better if
1043 		 *  B-15 |    \        if scope is enough for destinaion.
1044 		 *       |             ret = B - scope (-1 <= scope >= d <= 15).
1045 		 * d-C-1 | /
1046 		 *       |/         <- greater is better
1047 		 *   -C  /             if scope is not enough for destination.
1048 		 *      /|             ret = scope - C (-1 <= d < scope <= 15).
1049 		 *
1050 		 * d - C - 1 < B -15 (for all -1 <= d <= 15).
1051 		 * C > d + 14 - B >= 15 + 14 - B = 29 - B.
1052 		 * Assume B = 0 and we get C > 29.
1053 		 */
1054 		ret = __ipv6_addr_src_scope(score->addr_type);
1055 		if (ret >= dst->scope)
1056 			ret = -ret;
1057 		else
1058 			ret -= 128;	/* 30 is enough */
1059 		score->scopedist = ret;
1060 		break;
1061 	case IPV6_SADDR_RULE_PREFERRED:
1062 		/* Rule 3: Avoid deprecated and optimistic addresses */
1063 		ret = ipv6_saddr_preferred(score->addr_type) ||
1064 		      !(score->ifa->flags & (IFA_F_DEPRECATED|IFA_F_OPTIMISTIC));
1065 		break;
1066 #ifdef CONFIG_IPV6_MIP6
1067 	case IPV6_SADDR_RULE_HOA:
1068 	    {
1069 		/* Rule 4: Prefer home address */
1070 		int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA);
1071 		ret = !(score->ifa->flags & IFA_F_HOMEADDRESS) ^ prefhome;
1072 		break;
1073 	    }
1074 #endif
1075 	case IPV6_SADDR_RULE_OIF:
1076 		/* Rule 5: Prefer outgoing interface */
1077 		ret = (!dst->ifindex ||
1078 		       dst->ifindex == score->ifa->idev->dev->ifindex);
1079 		break;
1080 	case IPV6_SADDR_RULE_LABEL:
1081 		/* Rule 6: Prefer matching label */
1082 		ret = ipv6_addr_label(net,
1083 				      &score->ifa->addr, score->addr_type,
1084 				      score->ifa->idev->dev->ifindex) == dst->label;
1085 		break;
1086 #ifdef CONFIG_IPV6_PRIVACY
1087 	case IPV6_SADDR_RULE_PRIVACY:
1088 	    {
1089 		/* Rule 7: Prefer public address
1090 		 * Note: prefer temprary address if use_tempaddr >= 2
1091 		 */
1092 		int preftmp = dst->prefs & (IPV6_PREFER_SRC_PUBLIC|IPV6_PREFER_SRC_TMP) ?
1093 				!!(dst->prefs & IPV6_PREFER_SRC_TMP) :
1094 				score->ifa->idev->cnf.use_tempaddr >= 2;
1095 		ret = (!(score->ifa->flags & IFA_F_TEMPORARY)) ^ preftmp;
1096 		break;
1097 	    }
1098 #endif
1099 	case IPV6_SADDR_RULE_ORCHID:
1100 		/* Rule 8-: Prefer ORCHID vs ORCHID or
1101 		 *	    non-ORCHID vs non-ORCHID
1102 		 */
1103 		ret = !(ipv6_addr_orchid(&score->ifa->addr) ^
1104 			ipv6_addr_orchid(dst->addr));
1105 		break;
1106 	case IPV6_SADDR_RULE_PREFIX:
1107 		/* Rule 8: Use longest matching prefix */
1108 		score->matchlen = ret = ipv6_addr_diff(&score->ifa->addr,
1109 						       dst->addr);
1110 		break;
1111 	default:
1112 		ret = 0;
1113 	}
1114 
1115 	if (ret)
1116 		__set_bit(i, score->scorebits);
1117 	score->rule = i;
1118 out:
1119 	return ret;
1120 }
1121 
1122 int ipv6_dev_get_saddr(struct net *net, struct net_device *dst_dev,
1123 		       const struct in6_addr *daddr, unsigned int prefs,
1124 		       struct in6_addr *saddr)
1125 {
1126 	struct ipv6_saddr_score scores[2],
1127 				*score = &scores[0], *hiscore = &scores[1];
1128 	struct ipv6_saddr_dst dst;
1129 	struct net_device *dev;
1130 	int dst_type;
1131 
1132 	dst_type = __ipv6_addr_type(daddr);
1133 	dst.addr = daddr;
1134 	dst.ifindex = dst_dev ? dst_dev->ifindex : 0;
1135 	dst.scope = __ipv6_addr_src_scope(dst_type);
1136 	dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex);
1137 	dst.prefs = prefs;
1138 
1139 	hiscore->rule = -1;
1140 	hiscore->ifa = NULL;
1141 
1142 	rcu_read_lock();
1143 
1144 	for_each_netdev_rcu(net, dev) {
1145 		struct inet6_dev *idev;
1146 
1147 		/* Candidate Source Address (section 4)
1148 		 *  - multicast and link-local destination address,
1149 		 *    the set of candidate source address MUST only
1150 		 *    include addresses assigned to interfaces
1151 		 *    belonging to the same link as the outgoing
1152 		 *    interface.
1153 		 * (- For site-local destination addresses, the
1154 		 *    set of candidate source addresses MUST only
1155 		 *    include addresses assigned to interfaces
1156 		 *    belonging to the same site as the outgoing
1157 		 *    interface.)
1158 		 */
1159 		if (((dst_type & IPV6_ADDR_MULTICAST) ||
1160 		     dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL) &&
1161 		    dst.ifindex && dev->ifindex != dst.ifindex)
1162 			continue;
1163 
1164 		idev = __in6_dev_get(dev);
1165 		if (!idev)
1166 			continue;
1167 
1168 		read_lock_bh(&idev->lock);
1169 		list_for_each_entry(score->ifa, &idev->addr_list, if_list) {
1170 			int i;
1171 
1172 			/*
1173 			 * - Tentative Address (RFC2462 section 5.4)
1174 			 *  - A tentative address is not considered
1175 			 *    "assigned to an interface" in the traditional
1176 			 *    sense, unless it is also flagged as optimistic.
1177 			 * - Candidate Source Address (section 4)
1178 			 *  - In any case, anycast addresses, multicast
1179 			 *    addresses, and the unspecified address MUST
1180 			 *    NOT be included in a candidate set.
1181 			 */
1182 			if ((score->ifa->flags & IFA_F_TENTATIVE) &&
1183 			    (!(score->ifa->flags & IFA_F_OPTIMISTIC)))
1184 				continue;
1185 
1186 			score->addr_type = __ipv6_addr_type(&score->ifa->addr);
1187 
1188 			if (unlikely(score->addr_type == IPV6_ADDR_ANY ||
1189 				     score->addr_type & IPV6_ADDR_MULTICAST)) {
1190 				LIMIT_NETDEBUG(KERN_DEBUG
1191 					       "ADDRCONF: unspecified / multicast address "
1192 					       "assigned as unicast address on %s",
1193 					       dev->name);
1194 				continue;
1195 			}
1196 
1197 			score->rule = -1;
1198 			bitmap_zero(score->scorebits, IPV6_SADDR_RULE_MAX);
1199 
1200 			for (i = 0; i < IPV6_SADDR_RULE_MAX; i++) {
1201 				int minihiscore, miniscore;
1202 
1203 				minihiscore = ipv6_get_saddr_eval(net, hiscore, &dst, i);
1204 				miniscore = ipv6_get_saddr_eval(net, score, &dst, i);
1205 
1206 				if (minihiscore > miniscore) {
1207 					if (i == IPV6_SADDR_RULE_SCOPE &&
1208 					    score->scopedist > 0) {
1209 						/*
1210 						 * special case:
1211 						 * each remaining entry
1212 						 * has too small (not enough)
1213 						 * scope, because ifa entries
1214 						 * are sorted by their scope
1215 						 * values.
1216 						 */
1217 						goto try_nextdev;
1218 					}
1219 					break;
1220 				} else if (minihiscore < miniscore) {
1221 					if (hiscore->ifa)
1222 						in6_ifa_put(hiscore->ifa);
1223 
1224 					in6_ifa_hold(score->ifa);
1225 
1226 					swap(hiscore, score);
1227 
1228 					/* restore our iterator */
1229 					score->ifa = hiscore->ifa;
1230 
1231 					break;
1232 				}
1233 			}
1234 		}
1235 try_nextdev:
1236 		read_unlock_bh(&idev->lock);
1237 	}
1238 	rcu_read_unlock();
1239 
1240 	if (!hiscore->ifa)
1241 		return -EADDRNOTAVAIL;
1242 
1243 	ipv6_addr_copy(saddr, &hiscore->ifa->addr);
1244 	in6_ifa_put(hiscore->ifa);
1245 	return 0;
1246 }
1247 EXPORT_SYMBOL(ipv6_dev_get_saddr);
1248 
1249 int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
1250 		    unsigned char banned_flags)
1251 {
1252 	struct inet6_dev *idev;
1253 	int err = -EADDRNOTAVAIL;
1254 
1255 	rcu_read_lock();
1256 	idev = __in6_dev_get(dev);
1257 	if (idev) {
1258 		struct inet6_ifaddr *ifp;
1259 
1260 		read_lock_bh(&idev->lock);
1261 		list_for_each_entry(ifp, &idev->addr_list, if_list) {
1262 			if (ifp->scope == IFA_LINK &&
1263 			    !(ifp->flags & banned_flags)) {
1264 				ipv6_addr_copy(addr, &ifp->addr);
1265 				err = 0;
1266 				break;
1267 			}
1268 		}
1269 		read_unlock_bh(&idev->lock);
1270 	}
1271 	rcu_read_unlock();
1272 	return err;
1273 }
1274 
1275 static int ipv6_count_addresses(struct inet6_dev *idev)
1276 {
1277 	int cnt = 0;
1278 	struct inet6_ifaddr *ifp;
1279 
1280 	read_lock_bh(&idev->lock);
1281 	list_for_each_entry(ifp, &idev->addr_list, if_list)
1282 		cnt++;
1283 	read_unlock_bh(&idev->lock);
1284 	return cnt;
1285 }
1286 
1287 int ipv6_chk_addr(struct net *net, struct in6_addr *addr,
1288 		  struct net_device *dev, int strict)
1289 {
1290 	struct inet6_ifaddr *ifp;
1291 	struct hlist_node *node;
1292 	unsigned int hash = ipv6_addr_hash(addr);
1293 
1294 	rcu_read_lock_bh();
1295 	hlist_for_each_entry_rcu(ifp, node, &inet6_addr_lst[hash], addr_lst) {
1296 		if (!net_eq(dev_net(ifp->idev->dev), net))
1297 			continue;
1298 		if (ipv6_addr_equal(&ifp->addr, addr) &&
1299 		    !(ifp->flags&IFA_F_TENTATIVE) &&
1300 		    (dev == NULL || ifp->idev->dev == dev ||
1301 		     !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))) {
1302 			rcu_read_unlock_bh();
1303 			return 1;
1304 		}
1305 	}
1306 
1307 	rcu_read_unlock_bh();
1308 	return 0;
1309 }
1310 EXPORT_SYMBOL(ipv6_chk_addr);
1311 
1312 static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
1313 			       struct net_device *dev)
1314 {
1315 	unsigned int hash = ipv6_addr_hash(addr);
1316 	struct inet6_ifaddr *ifp;
1317 	struct hlist_node *node;
1318 
1319 	hlist_for_each_entry(ifp, node, &inet6_addr_lst[hash], addr_lst) {
1320 		if (!net_eq(dev_net(ifp->idev->dev), net))
1321 			continue;
1322 		if (ipv6_addr_equal(&ifp->addr, addr)) {
1323 			if (dev == NULL || ifp->idev->dev == dev)
1324 				return true;
1325 		}
1326 	}
1327 	return false;
1328 }
1329 
1330 int ipv6_chk_prefix(struct in6_addr *addr, struct net_device *dev)
1331 {
1332 	struct inet6_dev *idev;
1333 	struct inet6_ifaddr *ifa;
1334 	int	onlink;
1335 
1336 	onlink = 0;
1337 	rcu_read_lock();
1338 	idev = __in6_dev_get(dev);
1339 	if (idev) {
1340 		read_lock_bh(&idev->lock);
1341 		list_for_each_entry(ifa, &idev->addr_list, if_list) {
1342 			onlink = ipv6_prefix_equal(addr, &ifa->addr,
1343 						   ifa->prefix_len);
1344 			if (onlink)
1345 				break;
1346 		}
1347 		read_unlock_bh(&idev->lock);
1348 	}
1349 	rcu_read_unlock();
1350 	return onlink;
1351 }
1352 
1353 EXPORT_SYMBOL(ipv6_chk_prefix);
1354 
1355 struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr,
1356 				     struct net_device *dev, int strict)
1357 {
1358 	struct inet6_ifaddr *ifp, *result = NULL;
1359 	unsigned int hash = ipv6_addr_hash(addr);
1360 	struct hlist_node *node;
1361 
1362 	rcu_read_lock_bh();
1363 	hlist_for_each_entry_rcu_bh(ifp, node, &inet6_addr_lst[hash], addr_lst) {
1364 		if (!net_eq(dev_net(ifp->idev->dev), net))
1365 			continue;
1366 		if (ipv6_addr_equal(&ifp->addr, addr)) {
1367 			if (dev == NULL || ifp->idev->dev == dev ||
1368 			    !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
1369 				result = ifp;
1370 				in6_ifa_hold(ifp);
1371 				break;
1372 			}
1373 		}
1374 	}
1375 	rcu_read_unlock_bh();
1376 
1377 	return result;
1378 }
1379 
1380 /* Gets referenced address, destroys ifaddr */
1381 
1382 static void addrconf_dad_stop(struct inet6_ifaddr *ifp, int dad_failed)
1383 {
1384 	if (ifp->flags&IFA_F_PERMANENT) {
1385 		spin_lock_bh(&ifp->lock);
1386 		addrconf_del_timer(ifp);
1387 		ifp->flags |= IFA_F_TENTATIVE;
1388 		if (dad_failed)
1389 			ifp->flags |= IFA_F_DADFAILED;
1390 		spin_unlock_bh(&ifp->lock);
1391 		if (dad_failed)
1392 			ipv6_ifa_notify(0, ifp);
1393 		in6_ifa_put(ifp);
1394 #ifdef CONFIG_IPV6_PRIVACY
1395 	} else if (ifp->flags&IFA_F_TEMPORARY) {
1396 		struct inet6_ifaddr *ifpub;
1397 		spin_lock_bh(&ifp->lock);
1398 		ifpub = ifp->ifpub;
1399 		if (ifpub) {
1400 			in6_ifa_hold(ifpub);
1401 			spin_unlock_bh(&ifp->lock);
1402 			ipv6_create_tempaddr(ifpub, ifp);
1403 			in6_ifa_put(ifpub);
1404 		} else {
1405 			spin_unlock_bh(&ifp->lock);
1406 		}
1407 		ipv6_del_addr(ifp);
1408 #endif
1409 	} else
1410 		ipv6_del_addr(ifp);
1411 }
1412 
1413 static int addrconf_dad_end(struct inet6_ifaddr *ifp)
1414 {
1415 	int err = -ENOENT;
1416 
1417 	spin_lock(&ifp->state_lock);
1418 	if (ifp->state == INET6_IFADDR_STATE_DAD) {
1419 		ifp->state = INET6_IFADDR_STATE_POSTDAD;
1420 		err = 0;
1421 	}
1422 	spin_unlock(&ifp->state_lock);
1423 
1424 	return err;
1425 }
1426 
1427 void addrconf_dad_failure(struct inet6_ifaddr *ifp)
1428 {
1429 	struct inet6_dev *idev = ifp->idev;
1430 
1431 	if (addrconf_dad_end(ifp)) {
1432 		in6_ifa_put(ifp);
1433 		return;
1434 	}
1435 
1436 	if (net_ratelimit())
1437 		printk(KERN_INFO "%s: IPv6 duplicate address %pI6c detected!\n",
1438 			ifp->idev->dev->name, &ifp->addr);
1439 
1440 	if (idev->cnf.accept_dad > 1 && !idev->cnf.disable_ipv6) {
1441 		struct in6_addr addr;
1442 
1443 		addr.s6_addr32[0] = htonl(0xfe800000);
1444 		addr.s6_addr32[1] = 0;
1445 
1446 		if (!ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) &&
1447 		    ipv6_addr_equal(&ifp->addr, &addr)) {
1448 			/* DAD failed for link-local based on MAC address */
1449 			idev->cnf.disable_ipv6 = 1;
1450 
1451 			printk(KERN_INFO "%s: IPv6 being disabled!\n",
1452 				ifp->idev->dev->name);
1453 		}
1454 	}
1455 
1456 	addrconf_dad_stop(ifp, 1);
1457 }
1458 
1459 /* Join to solicited addr multicast group. */
1460 
1461 void addrconf_join_solict(struct net_device *dev, struct in6_addr *addr)
1462 {
1463 	struct in6_addr maddr;
1464 
1465 	if (dev->flags&(IFF_LOOPBACK|IFF_NOARP))
1466 		return;
1467 
1468 	addrconf_addr_solict_mult(addr, &maddr);
1469 	ipv6_dev_mc_inc(dev, &maddr);
1470 }
1471 
1472 void addrconf_leave_solict(struct inet6_dev *idev, struct in6_addr *addr)
1473 {
1474 	struct in6_addr maddr;
1475 
1476 	if (idev->dev->flags&(IFF_LOOPBACK|IFF_NOARP))
1477 		return;
1478 
1479 	addrconf_addr_solict_mult(addr, &maddr);
1480 	__ipv6_dev_mc_dec(idev, &maddr);
1481 }
1482 
1483 static void addrconf_join_anycast(struct inet6_ifaddr *ifp)
1484 {
1485 	struct in6_addr addr;
1486 	ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
1487 	if (ipv6_addr_any(&addr))
1488 		return;
1489 	ipv6_dev_ac_inc(ifp->idev->dev, &addr);
1490 }
1491 
1492 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp)
1493 {
1494 	struct in6_addr addr;
1495 	ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
1496 	if (ipv6_addr_any(&addr))
1497 		return;
1498 	__ipv6_dev_ac_dec(ifp->idev, &addr);
1499 }
1500 
1501 static int addrconf_ifid_eui48(u8 *eui, struct net_device *dev)
1502 {
1503 	if (dev->addr_len != ETH_ALEN)
1504 		return -1;
1505 	memcpy(eui, dev->dev_addr, 3);
1506 	memcpy(eui + 5, dev->dev_addr + 3, 3);
1507 
1508 	/*
1509 	 * The zSeries OSA network cards can be shared among various
1510 	 * OS instances, but the OSA cards have only one MAC address.
1511 	 * This leads to duplicate address conflicts in conjunction
1512 	 * with IPv6 if more than one instance uses the same card.
1513 	 *
1514 	 * The driver for these cards can deliver a unique 16-bit
1515 	 * identifier for each instance sharing the same card.  It is
1516 	 * placed instead of 0xFFFE in the interface identifier.  The
1517 	 * "u" bit of the interface identifier is not inverted in this
1518 	 * case.  Hence the resulting interface identifier has local
1519 	 * scope according to RFC2373.
1520 	 */
1521 	if (dev->dev_id) {
1522 		eui[3] = (dev->dev_id >> 8) & 0xFF;
1523 		eui[4] = dev->dev_id & 0xFF;
1524 	} else {
1525 		eui[3] = 0xFF;
1526 		eui[4] = 0xFE;
1527 		eui[0] ^= 2;
1528 	}
1529 	return 0;
1530 }
1531 
1532 static int addrconf_ifid_arcnet(u8 *eui, struct net_device *dev)
1533 {
1534 	/* XXX: inherit EUI-64 from other interface -- yoshfuji */
1535 	if (dev->addr_len != ARCNET_ALEN)
1536 		return -1;
1537 	memset(eui, 0, 7);
1538 	eui[7] = *(u8*)dev->dev_addr;
1539 	return 0;
1540 }
1541 
1542 static int addrconf_ifid_infiniband(u8 *eui, struct net_device *dev)
1543 {
1544 	if (dev->addr_len != INFINIBAND_ALEN)
1545 		return -1;
1546 	memcpy(eui, dev->dev_addr + 12, 8);
1547 	eui[0] |= 2;
1548 	return 0;
1549 }
1550 
1551 static int __ipv6_isatap_ifid(u8 *eui, __be32 addr)
1552 {
1553 	if (addr == 0)
1554 		return -1;
1555 	eui[0] = (ipv4_is_zeronet(addr) || ipv4_is_private_10(addr) ||
1556 		  ipv4_is_loopback(addr) || ipv4_is_linklocal_169(addr) ||
1557 		  ipv4_is_private_172(addr) || ipv4_is_test_192(addr) ||
1558 		  ipv4_is_anycast_6to4(addr) || ipv4_is_private_192(addr) ||
1559 		  ipv4_is_test_198(addr) || ipv4_is_multicast(addr) ||
1560 		  ipv4_is_lbcast(addr)) ? 0x00 : 0x02;
1561 	eui[1] = 0;
1562 	eui[2] = 0x5E;
1563 	eui[3] = 0xFE;
1564 	memcpy(eui + 4, &addr, 4);
1565 	return 0;
1566 }
1567 
1568 static int addrconf_ifid_sit(u8 *eui, struct net_device *dev)
1569 {
1570 	if (dev->priv_flags & IFF_ISATAP)
1571 		return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
1572 	return -1;
1573 }
1574 
1575 static int ipv6_generate_eui64(u8 *eui, struct net_device *dev)
1576 {
1577 	switch (dev->type) {
1578 	case ARPHRD_ETHER:
1579 	case ARPHRD_FDDI:
1580 	case ARPHRD_IEEE802_TR:
1581 		return addrconf_ifid_eui48(eui, dev);
1582 	case ARPHRD_ARCNET:
1583 		return addrconf_ifid_arcnet(eui, dev);
1584 	case ARPHRD_INFINIBAND:
1585 		return addrconf_ifid_infiniband(eui, dev);
1586 	case ARPHRD_SIT:
1587 		return addrconf_ifid_sit(eui, dev);
1588 	}
1589 	return -1;
1590 }
1591 
1592 static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev)
1593 {
1594 	int err = -1;
1595 	struct inet6_ifaddr *ifp;
1596 
1597 	read_lock_bh(&idev->lock);
1598 	list_for_each_entry(ifp, &idev->addr_list, if_list) {
1599 		if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
1600 			memcpy(eui, ifp->addr.s6_addr+8, 8);
1601 			err = 0;
1602 			break;
1603 		}
1604 	}
1605 	read_unlock_bh(&idev->lock);
1606 	return err;
1607 }
1608 
1609 #ifdef CONFIG_IPV6_PRIVACY
1610 /* (re)generation of randomized interface identifier (RFC 3041 3.2, 3.5) */
1611 static int __ipv6_regen_rndid(struct inet6_dev *idev)
1612 {
1613 regen:
1614 	get_random_bytes(idev->rndid, sizeof(idev->rndid));
1615 	idev->rndid[0] &= ~0x02;
1616 
1617 	/*
1618 	 * <draft-ietf-ipngwg-temp-addresses-v2-00.txt>:
1619 	 * check if generated address is not inappropriate
1620 	 *
1621 	 *  - Reserved subnet anycast (RFC 2526)
1622 	 *	11111101 11....11 1xxxxxxx
1623 	 *  - ISATAP (RFC4214) 6.1
1624 	 *	00-00-5E-FE-xx-xx-xx-xx
1625 	 *  - value 0
1626 	 *  - XXX: already assigned to an address on the device
1627 	 */
1628 	if (idev->rndid[0] == 0xfd &&
1629 	    (idev->rndid[1]&idev->rndid[2]&idev->rndid[3]&idev->rndid[4]&idev->rndid[5]&idev->rndid[6]) == 0xff &&
1630 	    (idev->rndid[7]&0x80))
1631 		goto regen;
1632 	if ((idev->rndid[0]|idev->rndid[1]) == 0) {
1633 		if (idev->rndid[2] == 0x5e && idev->rndid[3] == 0xfe)
1634 			goto regen;
1635 		if ((idev->rndid[2]|idev->rndid[3]|idev->rndid[4]|idev->rndid[5]|idev->rndid[6]|idev->rndid[7]) == 0x00)
1636 			goto regen;
1637 	}
1638 
1639 	return 0;
1640 }
1641 
1642 static void ipv6_regen_rndid(unsigned long data)
1643 {
1644 	struct inet6_dev *idev = (struct inet6_dev *) data;
1645 	unsigned long expires;
1646 
1647 	rcu_read_lock_bh();
1648 	write_lock_bh(&idev->lock);
1649 
1650 	if (idev->dead)
1651 		goto out;
1652 
1653 	if (__ipv6_regen_rndid(idev) < 0)
1654 		goto out;
1655 
1656 	expires = jiffies +
1657 		idev->cnf.temp_prefered_lft * HZ -
1658 		idev->cnf.regen_max_retry * idev->cnf.dad_transmits * idev->nd_parms->retrans_time -
1659 		idev->cnf.max_desync_factor * HZ;
1660 	if (time_before(expires, jiffies)) {
1661 		printk(KERN_WARNING
1662 			"ipv6_regen_rndid(): too short regeneration interval; timer disabled for %s.\n",
1663 			idev->dev->name);
1664 		goto out;
1665 	}
1666 
1667 	if (!mod_timer(&idev->regen_timer, expires))
1668 		in6_dev_hold(idev);
1669 
1670 out:
1671 	write_unlock_bh(&idev->lock);
1672 	rcu_read_unlock_bh();
1673 	in6_dev_put(idev);
1674 }
1675 
1676 static int __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr) {
1677 	int ret = 0;
1678 
1679 	if (tmpaddr && memcmp(idev->rndid, &tmpaddr->s6_addr[8], 8) == 0)
1680 		ret = __ipv6_regen_rndid(idev);
1681 	return ret;
1682 }
1683 #endif
1684 
1685 /*
1686  *	Add prefix route.
1687  */
1688 
1689 static void
1690 addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev,
1691 		      unsigned long expires, u32 flags)
1692 {
1693 	struct fib6_config cfg = {
1694 		.fc_table = RT6_TABLE_PREFIX,
1695 		.fc_metric = IP6_RT_PRIO_ADDRCONF,
1696 		.fc_ifindex = dev->ifindex,
1697 		.fc_expires = expires,
1698 		.fc_dst_len = plen,
1699 		.fc_flags = RTF_UP | flags,
1700 		.fc_nlinfo.nl_net = dev_net(dev),
1701 		.fc_protocol = RTPROT_KERNEL,
1702 	};
1703 
1704 	ipv6_addr_copy(&cfg.fc_dst, pfx);
1705 
1706 	/* Prevent useless cloning on PtP SIT.
1707 	   This thing is done here expecting that the whole
1708 	   class of non-broadcast devices need not cloning.
1709 	 */
1710 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
1711 	if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT))
1712 		cfg.fc_flags |= RTF_NONEXTHOP;
1713 #endif
1714 
1715 	ip6_route_add(&cfg);
1716 }
1717 
1718 /* Create "default" multicast route to the interface */
1719 
1720 static void addrconf_add_mroute(struct net_device *dev)
1721 {
1722 	struct fib6_config cfg = {
1723 		.fc_table = RT6_TABLE_LOCAL,
1724 		.fc_metric = IP6_RT_PRIO_ADDRCONF,
1725 		.fc_ifindex = dev->ifindex,
1726 		.fc_dst_len = 8,
1727 		.fc_flags = RTF_UP,
1728 		.fc_nlinfo.nl_net = dev_net(dev),
1729 	};
1730 
1731 	ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0);
1732 
1733 	ip6_route_add(&cfg);
1734 }
1735 
1736 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
1737 static void sit_route_add(struct net_device *dev)
1738 {
1739 	struct fib6_config cfg = {
1740 		.fc_table = RT6_TABLE_MAIN,
1741 		.fc_metric = IP6_RT_PRIO_ADDRCONF,
1742 		.fc_ifindex = dev->ifindex,
1743 		.fc_dst_len = 96,
1744 		.fc_flags = RTF_UP | RTF_NONEXTHOP,
1745 		.fc_nlinfo.nl_net = dev_net(dev),
1746 	};
1747 
1748 	/* prefix length - 96 bits "::d.d.d.d" */
1749 	ip6_route_add(&cfg);
1750 }
1751 #endif
1752 
1753 static void addrconf_add_lroute(struct net_device *dev)
1754 {
1755 	struct in6_addr addr;
1756 
1757 	ipv6_addr_set(&addr,  htonl(0xFE800000), 0, 0, 0);
1758 	addrconf_prefix_route(&addr, 64, dev, 0, 0);
1759 }
1760 
1761 static struct inet6_dev *addrconf_add_dev(struct net_device *dev)
1762 {
1763 	struct inet6_dev *idev;
1764 
1765 	ASSERT_RTNL();
1766 
1767 	idev = ipv6_find_idev(dev);
1768 	if (!idev)
1769 		return ERR_PTR(-ENOBUFS);
1770 
1771 	if (idev->cnf.disable_ipv6)
1772 		return ERR_PTR(-EACCES);
1773 
1774 	/* Add default multicast route */
1775 	addrconf_add_mroute(dev);
1776 
1777 	/* Add link local route */
1778 	addrconf_add_lroute(dev);
1779 	return idev;
1780 }
1781 
1782 void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len)
1783 {
1784 	struct prefix_info *pinfo;
1785 	__u32 valid_lft;
1786 	__u32 prefered_lft;
1787 	int addr_type;
1788 	struct inet6_dev *in6_dev;
1789 	struct net *net = dev_net(dev);
1790 
1791 	pinfo = (struct prefix_info *) opt;
1792 
1793 	if (len < sizeof(struct prefix_info)) {
1794 		ADBG(("addrconf: prefix option too short\n"));
1795 		return;
1796 	}
1797 
1798 	/*
1799 	 *	Validation checks ([ADDRCONF], page 19)
1800 	 */
1801 
1802 	addr_type = ipv6_addr_type(&pinfo->prefix);
1803 
1804 	if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL))
1805 		return;
1806 
1807 	valid_lft = ntohl(pinfo->valid);
1808 	prefered_lft = ntohl(pinfo->prefered);
1809 
1810 	if (prefered_lft > valid_lft) {
1811 		if (net_ratelimit())
1812 			printk(KERN_WARNING "addrconf: prefix option has invalid lifetime\n");
1813 		return;
1814 	}
1815 
1816 	in6_dev = in6_dev_get(dev);
1817 
1818 	if (in6_dev == NULL) {
1819 		if (net_ratelimit())
1820 			printk(KERN_DEBUG "addrconf: device %s not configured\n", dev->name);
1821 		return;
1822 	}
1823 
1824 	/*
1825 	 *	Two things going on here:
1826 	 *	1) Add routes for on-link prefixes
1827 	 *	2) Configure prefixes with the auto flag set
1828 	 */
1829 
1830 	if (pinfo->onlink) {
1831 		struct rt6_info *rt;
1832 		unsigned long rt_expires;
1833 
1834 		/* Avoid arithmetic overflow. Really, we could
1835 		 * save rt_expires in seconds, likely valid_lft,
1836 		 * but it would require division in fib gc, that it
1837 		 * not good.
1838 		 */
1839 		if (HZ > USER_HZ)
1840 			rt_expires = addrconf_timeout_fixup(valid_lft, HZ);
1841 		else
1842 			rt_expires = addrconf_timeout_fixup(valid_lft, USER_HZ);
1843 
1844 		if (addrconf_finite_timeout(rt_expires))
1845 			rt_expires *= HZ;
1846 
1847 		rt = rt6_lookup(net, &pinfo->prefix, NULL,
1848 				dev->ifindex, 1);
1849 
1850 		if (rt && addrconf_is_prefix_route(rt)) {
1851 			/* Autoconf prefix route */
1852 			if (valid_lft == 0) {
1853 				ip6_del_rt(rt);
1854 				rt = NULL;
1855 			} else if (addrconf_finite_timeout(rt_expires)) {
1856 				/* not infinity */
1857 				rt->rt6i_expires = jiffies + rt_expires;
1858 				rt->rt6i_flags |= RTF_EXPIRES;
1859 			} else {
1860 				rt->rt6i_flags &= ~RTF_EXPIRES;
1861 				rt->rt6i_expires = 0;
1862 			}
1863 		} else if (valid_lft) {
1864 			clock_t expires = 0;
1865 			int flags = RTF_ADDRCONF | RTF_PREFIX_RT;
1866 			if (addrconf_finite_timeout(rt_expires)) {
1867 				/* not infinity */
1868 				flags |= RTF_EXPIRES;
1869 				expires = jiffies_to_clock_t(rt_expires);
1870 			}
1871 			addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
1872 					      dev, expires, flags);
1873 		}
1874 		if (rt)
1875 			dst_release(&rt->dst);
1876 	}
1877 
1878 	/* Try to figure out our local address for this prefix */
1879 
1880 	if (pinfo->autoconf && in6_dev->cnf.autoconf) {
1881 		struct inet6_ifaddr * ifp;
1882 		struct in6_addr addr;
1883 		int create = 0, update_lft = 0;
1884 
1885 		if (pinfo->prefix_len == 64) {
1886 			memcpy(&addr, &pinfo->prefix, 8);
1887 			if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
1888 			    ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
1889 				in6_dev_put(in6_dev);
1890 				return;
1891 			}
1892 			goto ok;
1893 		}
1894 		if (net_ratelimit())
1895 			printk(KERN_DEBUG "IPv6 addrconf: prefix with wrong length %d\n",
1896 			       pinfo->prefix_len);
1897 		in6_dev_put(in6_dev);
1898 		return;
1899 
1900 ok:
1901 
1902 		ifp = ipv6_get_ifaddr(net, &addr, dev, 1);
1903 
1904 		if (ifp == NULL && valid_lft) {
1905 			int max_addresses = in6_dev->cnf.max_addresses;
1906 			u32 addr_flags = 0;
1907 
1908 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1909 			if (in6_dev->cnf.optimistic_dad &&
1910 			    !net->ipv6.devconf_all->forwarding)
1911 				addr_flags = IFA_F_OPTIMISTIC;
1912 #endif
1913 
1914 			/* Do not allow to create too much of autoconfigured
1915 			 * addresses; this would be too easy way to crash kernel.
1916 			 */
1917 			if (!max_addresses ||
1918 			    ipv6_count_addresses(in6_dev) < max_addresses)
1919 				ifp = ipv6_add_addr(in6_dev, &addr, pinfo->prefix_len,
1920 						    addr_type&IPV6_ADDR_SCOPE_MASK,
1921 						    addr_flags);
1922 
1923 			if (!ifp || IS_ERR(ifp)) {
1924 				in6_dev_put(in6_dev);
1925 				return;
1926 			}
1927 
1928 			update_lft = create = 1;
1929 			ifp->cstamp = jiffies;
1930 			addrconf_dad_start(ifp, RTF_ADDRCONF|RTF_PREFIX_RT);
1931 		}
1932 
1933 		if (ifp) {
1934 			int flags;
1935 			unsigned long now;
1936 #ifdef CONFIG_IPV6_PRIVACY
1937 			struct inet6_ifaddr *ift;
1938 #endif
1939 			u32 stored_lft;
1940 
1941 			/* update lifetime (RFC2462 5.5.3 e) */
1942 			spin_lock(&ifp->lock);
1943 			now = jiffies;
1944 			if (ifp->valid_lft > (now - ifp->tstamp) / HZ)
1945 				stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ;
1946 			else
1947 				stored_lft = 0;
1948 			if (!update_lft && stored_lft) {
1949 				if (valid_lft > MIN_VALID_LIFETIME ||
1950 				    valid_lft > stored_lft)
1951 					update_lft = 1;
1952 				else if (stored_lft <= MIN_VALID_LIFETIME) {
1953 					/* valid_lft <= stored_lft is always true */
1954 					/*
1955 					 * RFC 4862 Section 5.5.3e:
1956 					 * "Note that the preferred lifetime of
1957 					 *  the corresponding address is always
1958 					 *  reset to the Preferred Lifetime in
1959 					 *  the received Prefix Information
1960 					 *  option, regardless of whether the
1961 					 *  valid lifetime is also reset or
1962 					 *  ignored."
1963 					 *
1964 					 *  So if the preferred lifetime in
1965 					 *  this advertisement is different
1966 					 *  than what we have stored, but the
1967 					 *  valid lifetime is invalid, just
1968 					 *  reset prefered_lft.
1969 					 *
1970 					 *  We must set the valid lifetime
1971 					 *  to the stored lifetime since we'll
1972 					 *  be updating the timestamp below,
1973 					 *  else we'll set it back to the
1974 					 *  minumum.
1975 					 */
1976 					if (prefered_lft != ifp->prefered_lft) {
1977 						valid_lft = stored_lft;
1978 						update_lft = 1;
1979 					}
1980 				} else {
1981 					valid_lft = MIN_VALID_LIFETIME;
1982 					if (valid_lft < prefered_lft)
1983 						prefered_lft = valid_lft;
1984 					update_lft = 1;
1985 				}
1986 			}
1987 
1988 			if (update_lft) {
1989 				ifp->valid_lft = valid_lft;
1990 				ifp->prefered_lft = prefered_lft;
1991 				ifp->tstamp = now;
1992 				flags = ifp->flags;
1993 				ifp->flags &= ~IFA_F_DEPRECATED;
1994 				spin_unlock(&ifp->lock);
1995 
1996 				if (!(flags&IFA_F_TENTATIVE))
1997 					ipv6_ifa_notify(0, ifp);
1998 			} else
1999 				spin_unlock(&ifp->lock);
2000 
2001 #ifdef CONFIG_IPV6_PRIVACY
2002 			read_lock_bh(&in6_dev->lock);
2003 			/* update all temporary addresses in the list */
2004 			list_for_each_entry(ift, &in6_dev->tempaddr_list, tmp_list) {
2005 				/*
2006 				 * When adjusting the lifetimes of an existing
2007 				 * temporary address, only lower the lifetimes.
2008 				 * Implementations must not increase the
2009 				 * lifetimes of an existing temporary address
2010 				 * when processing a Prefix Information Option.
2011 				 */
2012 				if (ifp != ift->ifpub)
2013 					continue;
2014 
2015 				spin_lock(&ift->lock);
2016 				flags = ift->flags;
2017 				if (ift->valid_lft > valid_lft &&
2018 				    ift->valid_lft - valid_lft > (jiffies - ift->tstamp) / HZ)
2019 					ift->valid_lft = valid_lft + (jiffies - ift->tstamp) / HZ;
2020 				if (ift->prefered_lft > prefered_lft &&
2021 				    ift->prefered_lft - prefered_lft > (jiffies - ift->tstamp) / HZ)
2022 					ift->prefered_lft = prefered_lft + (jiffies - ift->tstamp) / HZ;
2023 				spin_unlock(&ift->lock);
2024 				if (!(flags&IFA_F_TENTATIVE))
2025 					ipv6_ifa_notify(0, ift);
2026 			}
2027 
2028 			if ((create || list_empty(&in6_dev->tempaddr_list)) && in6_dev->cnf.use_tempaddr > 0) {
2029 				/*
2030 				 * When a new public address is created as described in [ADDRCONF],
2031 				 * also create a new temporary address. Also create a temporary
2032 				 * address if it's enabled but no temporary address currently exists.
2033 				 */
2034 				read_unlock_bh(&in6_dev->lock);
2035 				ipv6_create_tempaddr(ifp, NULL);
2036 			} else {
2037 				read_unlock_bh(&in6_dev->lock);
2038 			}
2039 #endif
2040 			in6_ifa_put(ifp);
2041 			addrconf_verify(0);
2042 		}
2043 	}
2044 	inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo);
2045 	in6_dev_put(in6_dev);
2046 }
2047 
2048 /*
2049  *	Set destination address.
2050  *	Special case for SIT interfaces where we create a new "virtual"
2051  *	device.
2052  */
2053 int addrconf_set_dstaddr(struct net *net, void __user *arg)
2054 {
2055 	struct in6_ifreq ireq;
2056 	struct net_device *dev;
2057 	int err = -EINVAL;
2058 
2059 	rtnl_lock();
2060 
2061 	err = -EFAULT;
2062 	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2063 		goto err_exit;
2064 
2065 	dev = __dev_get_by_index(net, ireq.ifr6_ifindex);
2066 
2067 	err = -ENODEV;
2068 	if (dev == NULL)
2069 		goto err_exit;
2070 
2071 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
2072 	if (dev->type == ARPHRD_SIT) {
2073 		const struct net_device_ops *ops = dev->netdev_ops;
2074 		struct ifreq ifr;
2075 		struct ip_tunnel_parm p;
2076 
2077 		err = -EADDRNOTAVAIL;
2078 		if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4))
2079 			goto err_exit;
2080 
2081 		memset(&p, 0, sizeof(p));
2082 		p.iph.daddr = ireq.ifr6_addr.s6_addr32[3];
2083 		p.iph.saddr = 0;
2084 		p.iph.version = 4;
2085 		p.iph.ihl = 5;
2086 		p.iph.protocol = IPPROTO_IPV6;
2087 		p.iph.ttl = 64;
2088 		ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
2089 
2090 		if (ops->ndo_do_ioctl) {
2091 			mm_segment_t oldfs = get_fs();
2092 
2093 			set_fs(KERNEL_DS);
2094 			err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
2095 			set_fs(oldfs);
2096 		} else
2097 			err = -EOPNOTSUPP;
2098 
2099 		if (err == 0) {
2100 			err = -ENOBUFS;
2101 			dev = __dev_get_by_name(net, p.name);
2102 			if (!dev)
2103 				goto err_exit;
2104 			err = dev_open(dev);
2105 		}
2106 	}
2107 #endif
2108 
2109 err_exit:
2110 	rtnl_unlock();
2111 	return err;
2112 }
2113 
2114 /*
2115  *	Manual configuration of address on an interface
2116  */
2117 static int inet6_addr_add(struct net *net, int ifindex, struct in6_addr *pfx,
2118 			  unsigned int plen, __u8 ifa_flags, __u32 prefered_lft,
2119 			  __u32 valid_lft)
2120 {
2121 	struct inet6_ifaddr *ifp;
2122 	struct inet6_dev *idev;
2123 	struct net_device *dev;
2124 	int scope;
2125 	u32 flags;
2126 	clock_t expires;
2127 	unsigned long timeout;
2128 
2129 	ASSERT_RTNL();
2130 
2131 	if (plen > 128)
2132 		return -EINVAL;
2133 
2134 	/* check the lifetime */
2135 	if (!valid_lft || prefered_lft > valid_lft)
2136 		return -EINVAL;
2137 
2138 	dev = __dev_get_by_index(net, ifindex);
2139 	if (!dev)
2140 		return -ENODEV;
2141 
2142 	idev = addrconf_add_dev(dev);
2143 	if (IS_ERR(idev))
2144 		return PTR_ERR(idev);
2145 
2146 	scope = ipv6_addr_scope(pfx);
2147 
2148 	timeout = addrconf_timeout_fixup(valid_lft, HZ);
2149 	if (addrconf_finite_timeout(timeout)) {
2150 		expires = jiffies_to_clock_t(timeout * HZ);
2151 		valid_lft = timeout;
2152 		flags = RTF_EXPIRES;
2153 	} else {
2154 		expires = 0;
2155 		flags = 0;
2156 		ifa_flags |= IFA_F_PERMANENT;
2157 	}
2158 
2159 	timeout = addrconf_timeout_fixup(prefered_lft, HZ);
2160 	if (addrconf_finite_timeout(timeout)) {
2161 		if (timeout == 0)
2162 			ifa_flags |= IFA_F_DEPRECATED;
2163 		prefered_lft = timeout;
2164 	}
2165 
2166 	ifp = ipv6_add_addr(idev, pfx, plen, scope, ifa_flags);
2167 
2168 	if (!IS_ERR(ifp)) {
2169 		spin_lock_bh(&ifp->lock);
2170 		ifp->valid_lft = valid_lft;
2171 		ifp->prefered_lft = prefered_lft;
2172 		ifp->tstamp = jiffies;
2173 		spin_unlock_bh(&ifp->lock);
2174 
2175 		addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev,
2176 				      expires, flags);
2177 		/*
2178 		 * Note that section 3.1 of RFC 4429 indicates
2179 		 * that the Optimistic flag should not be set for
2180 		 * manually configured addresses
2181 		 */
2182 		addrconf_dad_start(ifp, 0);
2183 		in6_ifa_put(ifp);
2184 		addrconf_verify(0);
2185 		return 0;
2186 	}
2187 
2188 	return PTR_ERR(ifp);
2189 }
2190 
2191 static int inet6_addr_del(struct net *net, int ifindex, struct in6_addr *pfx,
2192 			  unsigned int plen)
2193 {
2194 	struct inet6_ifaddr *ifp;
2195 	struct inet6_dev *idev;
2196 	struct net_device *dev;
2197 
2198 	if (plen > 128)
2199 		return -EINVAL;
2200 
2201 	dev = __dev_get_by_index(net, ifindex);
2202 	if (!dev)
2203 		return -ENODEV;
2204 
2205 	if ((idev = __in6_dev_get(dev)) == NULL)
2206 		return -ENXIO;
2207 
2208 	read_lock_bh(&idev->lock);
2209 	list_for_each_entry(ifp, &idev->addr_list, if_list) {
2210 		if (ifp->prefix_len == plen &&
2211 		    ipv6_addr_equal(pfx, &ifp->addr)) {
2212 			in6_ifa_hold(ifp);
2213 			read_unlock_bh(&idev->lock);
2214 
2215 			ipv6_del_addr(ifp);
2216 
2217 			/* If the last address is deleted administratively,
2218 			   disable IPv6 on this interface.
2219 			 */
2220 			if (list_empty(&idev->addr_list))
2221 				addrconf_ifdown(idev->dev, 1);
2222 			return 0;
2223 		}
2224 	}
2225 	read_unlock_bh(&idev->lock);
2226 	return -EADDRNOTAVAIL;
2227 }
2228 
2229 
2230 int addrconf_add_ifaddr(struct net *net, void __user *arg)
2231 {
2232 	struct in6_ifreq ireq;
2233 	int err;
2234 
2235 	if (!capable(CAP_NET_ADMIN))
2236 		return -EPERM;
2237 
2238 	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2239 		return -EFAULT;
2240 
2241 	rtnl_lock();
2242 	err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr,
2243 			     ireq.ifr6_prefixlen, IFA_F_PERMANENT,
2244 			     INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
2245 	rtnl_unlock();
2246 	return err;
2247 }
2248 
2249 int addrconf_del_ifaddr(struct net *net, void __user *arg)
2250 {
2251 	struct in6_ifreq ireq;
2252 	int err;
2253 
2254 	if (!capable(CAP_NET_ADMIN))
2255 		return -EPERM;
2256 
2257 	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2258 		return -EFAULT;
2259 
2260 	rtnl_lock();
2261 	err = inet6_addr_del(net, ireq.ifr6_ifindex, &ireq.ifr6_addr,
2262 			     ireq.ifr6_prefixlen);
2263 	rtnl_unlock();
2264 	return err;
2265 }
2266 
2267 static void add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
2268 		     int plen, int scope)
2269 {
2270 	struct inet6_ifaddr *ifp;
2271 
2272 	ifp = ipv6_add_addr(idev, addr, plen, scope, IFA_F_PERMANENT);
2273 	if (!IS_ERR(ifp)) {
2274 		spin_lock_bh(&ifp->lock);
2275 		ifp->flags &= ~IFA_F_TENTATIVE;
2276 		spin_unlock_bh(&ifp->lock);
2277 		ipv6_ifa_notify(RTM_NEWADDR, ifp);
2278 		in6_ifa_put(ifp);
2279 	}
2280 }
2281 
2282 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
2283 static void sit_add_v4_addrs(struct inet6_dev *idev)
2284 {
2285 	struct in6_addr addr;
2286 	struct net_device *dev;
2287 	struct net *net = dev_net(idev->dev);
2288 	int scope;
2289 
2290 	ASSERT_RTNL();
2291 
2292 	memset(&addr, 0, sizeof(struct in6_addr));
2293 	memcpy(&addr.s6_addr32[3], idev->dev->dev_addr, 4);
2294 
2295 	if (idev->dev->flags&IFF_POINTOPOINT) {
2296 		addr.s6_addr32[0] = htonl(0xfe800000);
2297 		scope = IFA_LINK;
2298 	} else {
2299 		scope = IPV6_ADDR_COMPATv4;
2300 	}
2301 
2302 	if (addr.s6_addr32[3]) {
2303 		add_addr(idev, &addr, 128, scope);
2304 		return;
2305 	}
2306 
2307 	for_each_netdev(net, dev) {
2308 		struct in_device * in_dev = __in_dev_get_rtnl(dev);
2309 		if (in_dev && (dev->flags & IFF_UP)) {
2310 			struct in_ifaddr * ifa;
2311 
2312 			int flag = scope;
2313 
2314 			for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
2315 				int plen;
2316 
2317 				addr.s6_addr32[3] = ifa->ifa_local;
2318 
2319 				if (ifa->ifa_scope == RT_SCOPE_LINK)
2320 					continue;
2321 				if (ifa->ifa_scope >= RT_SCOPE_HOST) {
2322 					if (idev->dev->flags&IFF_POINTOPOINT)
2323 						continue;
2324 					flag |= IFA_HOST;
2325 				}
2326 				if (idev->dev->flags&IFF_POINTOPOINT)
2327 					plen = 64;
2328 				else
2329 					plen = 96;
2330 
2331 				add_addr(idev, &addr, plen, flag);
2332 			}
2333 		}
2334 	}
2335 }
2336 #endif
2337 
2338 static void init_loopback(struct net_device *dev)
2339 {
2340 	struct inet6_dev  *idev;
2341 
2342 	/* ::1 */
2343 
2344 	ASSERT_RTNL();
2345 
2346 	if ((idev = ipv6_find_idev(dev)) == NULL) {
2347 		printk(KERN_DEBUG "init loopback: add_dev failed\n");
2348 		return;
2349 	}
2350 
2351 	add_addr(idev, &in6addr_loopback, 128, IFA_HOST);
2352 }
2353 
2354 static void addrconf_add_linklocal(struct inet6_dev *idev, struct in6_addr *addr)
2355 {
2356 	struct inet6_ifaddr * ifp;
2357 	u32 addr_flags = IFA_F_PERMANENT;
2358 
2359 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
2360 	if (idev->cnf.optimistic_dad &&
2361 	    !dev_net(idev->dev)->ipv6.devconf_all->forwarding)
2362 		addr_flags |= IFA_F_OPTIMISTIC;
2363 #endif
2364 
2365 
2366 	ifp = ipv6_add_addr(idev, addr, 64, IFA_LINK, addr_flags);
2367 	if (!IS_ERR(ifp)) {
2368 		addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev, 0, 0);
2369 		addrconf_dad_start(ifp, 0);
2370 		in6_ifa_put(ifp);
2371 	}
2372 }
2373 
2374 static void addrconf_dev_config(struct net_device *dev)
2375 {
2376 	struct in6_addr addr;
2377 	struct inet6_dev    * idev;
2378 
2379 	ASSERT_RTNL();
2380 
2381 	if ((dev->type != ARPHRD_ETHER) &&
2382 	    (dev->type != ARPHRD_FDDI) &&
2383 	    (dev->type != ARPHRD_IEEE802_TR) &&
2384 	    (dev->type != ARPHRD_ARCNET) &&
2385 	    (dev->type != ARPHRD_INFINIBAND)) {
2386 		/* Alas, we support only Ethernet autoconfiguration. */
2387 		return;
2388 	}
2389 
2390 	idev = addrconf_add_dev(dev);
2391 	if (IS_ERR(idev))
2392 		return;
2393 
2394 	memset(&addr, 0, sizeof(struct in6_addr));
2395 	addr.s6_addr32[0] = htonl(0xFE800000);
2396 
2397 	if (ipv6_generate_eui64(addr.s6_addr + 8, dev) == 0)
2398 		addrconf_add_linklocal(idev, &addr);
2399 }
2400 
2401 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
2402 static void addrconf_sit_config(struct net_device *dev)
2403 {
2404 	struct inet6_dev *idev;
2405 
2406 	ASSERT_RTNL();
2407 
2408 	/*
2409 	 * Configure the tunnel with one of our IPv4
2410 	 * addresses... we should configure all of
2411 	 * our v4 addrs in the tunnel
2412 	 */
2413 
2414 	if ((idev = ipv6_find_idev(dev)) == NULL) {
2415 		printk(KERN_DEBUG "init sit: add_dev failed\n");
2416 		return;
2417 	}
2418 
2419 	if (dev->priv_flags & IFF_ISATAP) {
2420 		struct in6_addr addr;
2421 
2422 		ipv6_addr_set(&addr,  htonl(0xFE800000), 0, 0, 0);
2423 		addrconf_prefix_route(&addr, 64, dev, 0, 0);
2424 		if (!ipv6_generate_eui64(addr.s6_addr + 8, dev))
2425 			addrconf_add_linklocal(idev, &addr);
2426 		return;
2427 	}
2428 
2429 	sit_add_v4_addrs(idev);
2430 
2431 	if (dev->flags&IFF_POINTOPOINT) {
2432 		addrconf_add_mroute(dev);
2433 		addrconf_add_lroute(dev);
2434 	} else
2435 		sit_route_add(dev);
2436 }
2437 #endif
2438 
2439 static inline int
2440 ipv6_inherit_linklocal(struct inet6_dev *idev, struct net_device *link_dev)
2441 {
2442 	struct in6_addr lladdr;
2443 
2444 	if (!ipv6_get_lladdr(link_dev, &lladdr, IFA_F_TENTATIVE)) {
2445 		addrconf_add_linklocal(idev, &lladdr);
2446 		return 0;
2447 	}
2448 	return -1;
2449 }
2450 
2451 static void ip6_tnl_add_linklocal(struct inet6_dev *idev)
2452 {
2453 	struct net_device *link_dev;
2454 	struct net *net = dev_net(idev->dev);
2455 
2456 	/* first try to inherit the link-local address from the link device */
2457 	if (idev->dev->iflink &&
2458 	    (link_dev = __dev_get_by_index(net, idev->dev->iflink))) {
2459 		if (!ipv6_inherit_linklocal(idev, link_dev))
2460 			return;
2461 	}
2462 	/* then try to inherit it from any device */
2463 	for_each_netdev(net, link_dev) {
2464 		if (!ipv6_inherit_linklocal(idev, link_dev))
2465 			return;
2466 	}
2467 	printk(KERN_DEBUG "init ip6-ip6: add_linklocal failed\n");
2468 }
2469 
2470 /*
2471  * Autoconfigure tunnel with a link-local address so routing protocols,
2472  * DHCPv6, MLD etc. can be run over the virtual link
2473  */
2474 
2475 static void addrconf_ip6_tnl_config(struct net_device *dev)
2476 {
2477 	struct inet6_dev *idev;
2478 
2479 	ASSERT_RTNL();
2480 
2481 	idev = addrconf_add_dev(dev);
2482 	if (IS_ERR(idev)) {
2483 		printk(KERN_DEBUG "init ip6-ip6: add_dev failed\n");
2484 		return;
2485 	}
2486 	ip6_tnl_add_linklocal(idev);
2487 }
2488 
2489 static int addrconf_notify(struct notifier_block *this, unsigned long event,
2490 			   void * data)
2491 {
2492 	struct net_device *dev = (struct net_device *) data;
2493 	struct inet6_dev *idev = __in6_dev_get(dev);
2494 	int run_pending = 0;
2495 	int err;
2496 
2497 	switch (event) {
2498 	case NETDEV_REGISTER:
2499 		if (!idev && dev->mtu >= IPV6_MIN_MTU) {
2500 			idev = ipv6_add_dev(dev);
2501 			if (!idev)
2502 				return notifier_from_errno(-ENOMEM);
2503 		}
2504 		break;
2505 
2506 	case NETDEV_UP:
2507 	case NETDEV_CHANGE:
2508 		if (dev->flags & IFF_SLAVE)
2509 			break;
2510 
2511 		if (event == NETDEV_UP) {
2512 			if (!addrconf_qdisc_ok(dev)) {
2513 				/* device is not ready yet. */
2514 				printk(KERN_INFO
2515 					"ADDRCONF(NETDEV_UP): %s: "
2516 					"link is not ready\n",
2517 					dev->name);
2518 				break;
2519 			}
2520 
2521 			if (!idev && dev->mtu >= IPV6_MIN_MTU)
2522 				idev = ipv6_add_dev(dev);
2523 
2524 			if (idev) {
2525 				idev->if_flags |= IF_READY;
2526 				run_pending = 1;
2527 			}
2528 		} else {
2529 			if (!addrconf_qdisc_ok(dev)) {
2530 				/* device is still not ready. */
2531 				break;
2532 			}
2533 
2534 			if (idev) {
2535 				if (idev->if_flags & IF_READY)
2536 					/* device is already configured. */
2537 					break;
2538 				idev->if_flags |= IF_READY;
2539 			}
2540 
2541 			printk(KERN_INFO
2542 					"ADDRCONF(NETDEV_CHANGE): %s: "
2543 					"link becomes ready\n",
2544 					dev->name);
2545 
2546 			run_pending = 1;
2547 		}
2548 
2549 		switch (dev->type) {
2550 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
2551 		case ARPHRD_SIT:
2552 			addrconf_sit_config(dev);
2553 			break;
2554 #endif
2555 		case ARPHRD_TUNNEL6:
2556 			addrconf_ip6_tnl_config(dev);
2557 			break;
2558 		case ARPHRD_LOOPBACK:
2559 			init_loopback(dev);
2560 			break;
2561 
2562 		default:
2563 			addrconf_dev_config(dev);
2564 			break;
2565 		}
2566 
2567 		if (idev) {
2568 			if (run_pending)
2569 				addrconf_dad_run(idev);
2570 
2571 			/*
2572 			 * If the MTU changed during the interface down,
2573 			 * when the interface up, the changed MTU must be
2574 			 * reflected in the idev as well as routers.
2575 			 */
2576 			if (idev->cnf.mtu6 != dev->mtu &&
2577 			    dev->mtu >= IPV6_MIN_MTU) {
2578 				rt6_mtu_change(dev, dev->mtu);
2579 				idev->cnf.mtu6 = dev->mtu;
2580 			}
2581 			idev->tstamp = jiffies;
2582 			inet6_ifinfo_notify(RTM_NEWLINK, idev);
2583 
2584 			/*
2585 			 * If the changed mtu during down is lower than
2586 			 * IPV6_MIN_MTU stop IPv6 on this interface.
2587 			 */
2588 			if (dev->mtu < IPV6_MIN_MTU)
2589 				addrconf_ifdown(dev, 1);
2590 		}
2591 		break;
2592 
2593 	case NETDEV_CHANGEMTU:
2594 		if (idev && dev->mtu >= IPV6_MIN_MTU) {
2595 			rt6_mtu_change(dev, dev->mtu);
2596 			idev->cnf.mtu6 = dev->mtu;
2597 			break;
2598 		}
2599 
2600 		if (!idev && dev->mtu >= IPV6_MIN_MTU) {
2601 			idev = ipv6_add_dev(dev);
2602 			if (idev)
2603 				break;
2604 		}
2605 
2606 		/*
2607 		 * MTU falled under IPV6_MIN_MTU.
2608 		 * Stop IPv6 on this interface.
2609 		 */
2610 
2611 	case NETDEV_DOWN:
2612 	case NETDEV_UNREGISTER:
2613 		/*
2614 		 *	Remove all addresses from this interface.
2615 		 */
2616 		addrconf_ifdown(dev, event != NETDEV_DOWN);
2617 		break;
2618 
2619 	case NETDEV_CHANGENAME:
2620 		if (idev) {
2621 			snmp6_unregister_dev(idev);
2622 			addrconf_sysctl_unregister(idev);
2623 			addrconf_sysctl_register(idev);
2624 			err = snmp6_register_dev(idev);
2625 			if (err)
2626 				return notifier_from_errno(err);
2627 		}
2628 		break;
2629 
2630 	case NETDEV_PRE_TYPE_CHANGE:
2631 	case NETDEV_POST_TYPE_CHANGE:
2632 		addrconf_type_change(dev, event);
2633 		break;
2634 	}
2635 
2636 	return NOTIFY_OK;
2637 }
2638 
2639 /*
2640  *	addrconf module should be notified of a device going up
2641  */
2642 static struct notifier_block ipv6_dev_notf = {
2643 	.notifier_call = addrconf_notify,
2644 };
2645 
2646 static void addrconf_type_change(struct net_device *dev, unsigned long event)
2647 {
2648 	struct inet6_dev *idev;
2649 	ASSERT_RTNL();
2650 
2651 	idev = __in6_dev_get(dev);
2652 
2653 	if (event == NETDEV_POST_TYPE_CHANGE)
2654 		ipv6_mc_remap(idev);
2655 	else if (event == NETDEV_PRE_TYPE_CHANGE)
2656 		ipv6_mc_unmap(idev);
2657 }
2658 
2659 static int addrconf_ifdown(struct net_device *dev, int how)
2660 {
2661 	struct net *net = dev_net(dev);
2662 	struct inet6_dev *idev;
2663 	struct inet6_ifaddr *ifa;
2664 	int state, i;
2665 
2666 	ASSERT_RTNL();
2667 
2668 	rt6_ifdown(net, dev);
2669 	neigh_ifdown(&nd_tbl, dev);
2670 
2671 	idev = __in6_dev_get(dev);
2672 	if (idev == NULL)
2673 		return -ENODEV;
2674 
2675 	/*
2676 	 * Step 1: remove reference to ipv6 device from parent device.
2677 	 *	   Do not dev_put!
2678 	 */
2679 	if (how) {
2680 		idev->dead = 1;
2681 
2682 		/* protected by rtnl_lock */
2683 		rcu_assign_pointer(dev->ip6_ptr, NULL);
2684 
2685 		/* Step 1.5: remove snmp6 entry */
2686 		snmp6_unregister_dev(idev);
2687 
2688 	}
2689 
2690 	/* Step 2: clear hash table */
2691 	for (i = 0; i < IN6_ADDR_HSIZE; i++) {
2692 		struct hlist_head *h = &inet6_addr_lst[i];
2693 		struct hlist_node *n;
2694 
2695 		spin_lock_bh(&addrconf_hash_lock);
2696 	restart:
2697 		hlist_for_each_entry_rcu(ifa, n, h, addr_lst) {
2698 			if (ifa->idev == idev) {
2699 				hlist_del_init_rcu(&ifa->addr_lst);
2700 				addrconf_del_timer(ifa);
2701 				goto restart;
2702 			}
2703 		}
2704 		spin_unlock_bh(&addrconf_hash_lock);
2705 	}
2706 
2707 	write_lock_bh(&idev->lock);
2708 
2709 	/* Step 2: clear flags for stateless addrconf */
2710 	if (!how)
2711 		idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY);
2712 
2713 #ifdef CONFIG_IPV6_PRIVACY
2714 	if (how && del_timer(&idev->regen_timer))
2715 		in6_dev_put(idev);
2716 
2717 	/* Step 3: clear tempaddr list */
2718 	while (!list_empty(&idev->tempaddr_list)) {
2719 		ifa = list_first_entry(&idev->tempaddr_list,
2720 				       struct inet6_ifaddr, tmp_list);
2721 		list_del(&ifa->tmp_list);
2722 		write_unlock_bh(&idev->lock);
2723 		spin_lock_bh(&ifa->lock);
2724 
2725 		if (ifa->ifpub) {
2726 			in6_ifa_put(ifa->ifpub);
2727 			ifa->ifpub = NULL;
2728 		}
2729 		spin_unlock_bh(&ifa->lock);
2730 		in6_ifa_put(ifa);
2731 		write_lock_bh(&idev->lock);
2732 	}
2733 #endif
2734 
2735 	while (!list_empty(&idev->addr_list)) {
2736 		ifa = list_first_entry(&idev->addr_list,
2737 				       struct inet6_ifaddr, if_list);
2738 		addrconf_del_timer(ifa);
2739 
2740 		list_del(&ifa->if_list);
2741 
2742 		write_unlock_bh(&idev->lock);
2743 
2744 		spin_lock_bh(&ifa->state_lock);
2745 		state = ifa->state;
2746 		ifa->state = INET6_IFADDR_STATE_DEAD;
2747 		spin_unlock_bh(&ifa->state_lock);
2748 
2749 		if (state != INET6_IFADDR_STATE_DEAD) {
2750 			__ipv6_ifa_notify(RTM_DELADDR, ifa);
2751 			atomic_notifier_call_chain(&inet6addr_chain, NETDEV_DOWN, ifa);
2752 		}
2753 		in6_ifa_put(ifa);
2754 
2755 		write_lock_bh(&idev->lock);
2756 	}
2757 
2758 	write_unlock_bh(&idev->lock);
2759 
2760 	/* Step 5: Discard multicast list */
2761 	if (how)
2762 		ipv6_mc_destroy_dev(idev);
2763 	else
2764 		ipv6_mc_down(idev);
2765 
2766 	idev->tstamp = jiffies;
2767 
2768 	/* Last: Shot the device (if unregistered) */
2769 	if (how) {
2770 		addrconf_sysctl_unregister(idev);
2771 		neigh_parms_release(&nd_tbl, idev->nd_parms);
2772 		neigh_ifdown(&nd_tbl, dev);
2773 		in6_dev_put(idev);
2774 	}
2775 	return 0;
2776 }
2777 
2778 static void addrconf_rs_timer(unsigned long data)
2779 {
2780 	struct inet6_ifaddr *ifp = (struct inet6_ifaddr *) data;
2781 	struct inet6_dev *idev = ifp->idev;
2782 
2783 	read_lock(&idev->lock);
2784 	if (idev->dead || !(idev->if_flags & IF_READY))
2785 		goto out;
2786 
2787 	if (idev->cnf.forwarding)
2788 		goto out;
2789 
2790 	/* Announcement received after solicitation was sent */
2791 	if (idev->if_flags & IF_RA_RCVD)
2792 		goto out;
2793 
2794 	spin_lock(&ifp->lock);
2795 	if (ifp->probes++ < idev->cnf.rtr_solicits) {
2796 		/* The wait after the last probe can be shorter */
2797 		addrconf_mod_timer(ifp, AC_RS,
2798 				   (ifp->probes == idev->cnf.rtr_solicits) ?
2799 				   idev->cnf.rtr_solicit_delay :
2800 				   idev->cnf.rtr_solicit_interval);
2801 		spin_unlock(&ifp->lock);
2802 
2803 		ndisc_send_rs(idev->dev, &ifp->addr, &in6addr_linklocal_allrouters);
2804 	} else {
2805 		spin_unlock(&ifp->lock);
2806 		/*
2807 		 * Note: we do not support deprecated "all on-link"
2808 		 * assumption any longer.
2809 		 */
2810 		printk(KERN_DEBUG "%s: no IPv6 routers present\n",
2811 		       idev->dev->name);
2812 	}
2813 
2814 out:
2815 	read_unlock(&idev->lock);
2816 	in6_ifa_put(ifp);
2817 }
2818 
2819 /*
2820  *	Duplicate Address Detection
2821  */
2822 static void addrconf_dad_kick(struct inet6_ifaddr *ifp)
2823 {
2824 	unsigned long rand_num;
2825 	struct inet6_dev *idev = ifp->idev;
2826 
2827 	if (ifp->flags & IFA_F_OPTIMISTIC)
2828 		rand_num = 0;
2829 	else
2830 		rand_num = net_random() % (idev->cnf.rtr_solicit_delay ? : 1);
2831 
2832 	ifp->probes = idev->cnf.dad_transmits;
2833 	addrconf_mod_timer(ifp, AC_DAD, rand_num);
2834 }
2835 
2836 static void addrconf_dad_start(struct inet6_ifaddr *ifp, u32 flags)
2837 {
2838 	struct inet6_dev *idev = ifp->idev;
2839 	struct net_device *dev = idev->dev;
2840 
2841 	addrconf_join_solict(dev, &ifp->addr);
2842 
2843 	net_srandom(ifp->addr.s6_addr32[3]);
2844 
2845 	read_lock_bh(&idev->lock);
2846 	spin_lock(&ifp->lock);
2847 	if (ifp->state == INET6_IFADDR_STATE_DEAD)
2848 		goto out;
2849 
2850 	if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) ||
2851 	    idev->cnf.accept_dad < 1 ||
2852 	    !(ifp->flags&IFA_F_TENTATIVE) ||
2853 	    ifp->flags & IFA_F_NODAD) {
2854 		ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
2855 		spin_unlock(&ifp->lock);
2856 		read_unlock_bh(&idev->lock);
2857 
2858 		addrconf_dad_completed(ifp);
2859 		return;
2860 	}
2861 
2862 	if (!(idev->if_flags & IF_READY)) {
2863 		spin_unlock(&ifp->lock);
2864 		read_unlock_bh(&idev->lock);
2865 		/*
2866 		 * If the device is not ready:
2867 		 * - keep it tentative if it is a permanent address.
2868 		 * - otherwise, kill it.
2869 		 */
2870 		in6_ifa_hold(ifp);
2871 		addrconf_dad_stop(ifp, 0);
2872 		return;
2873 	}
2874 
2875 	/*
2876 	 * Optimistic nodes can start receiving
2877 	 * Frames right away
2878 	 */
2879 	if (ifp->flags & IFA_F_OPTIMISTIC)
2880 		ip6_ins_rt(ifp->rt);
2881 
2882 	addrconf_dad_kick(ifp);
2883 out:
2884 	spin_unlock(&ifp->lock);
2885 	read_unlock_bh(&idev->lock);
2886 }
2887 
2888 static void addrconf_dad_timer(unsigned long data)
2889 {
2890 	struct inet6_ifaddr *ifp = (struct inet6_ifaddr *) data;
2891 	struct inet6_dev *idev = ifp->idev;
2892 	struct in6_addr mcaddr;
2893 
2894 	if (!ifp->probes && addrconf_dad_end(ifp))
2895 		goto out;
2896 
2897 	read_lock(&idev->lock);
2898 	if (idev->dead || !(idev->if_flags & IF_READY)) {
2899 		read_unlock(&idev->lock);
2900 		goto out;
2901 	}
2902 
2903 	spin_lock(&ifp->lock);
2904 	if (ifp->state == INET6_IFADDR_STATE_DEAD) {
2905 		spin_unlock(&ifp->lock);
2906 		read_unlock(&idev->lock);
2907 		goto out;
2908 	}
2909 
2910 	if (ifp->probes == 0) {
2911 		/*
2912 		 * DAD was successful
2913 		 */
2914 
2915 		ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
2916 		spin_unlock(&ifp->lock);
2917 		read_unlock(&idev->lock);
2918 
2919 		addrconf_dad_completed(ifp);
2920 
2921 		goto out;
2922 	}
2923 
2924 	ifp->probes--;
2925 	addrconf_mod_timer(ifp, AC_DAD, ifp->idev->nd_parms->retrans_time);
2926 	spin_unlock(&ifp->lock);
2927 	read_unlock(&idev->lock);
2928 
2929 	/* send a neighbour solicitation for our addr */
2930 	addrconf_addr_solict_mult(&ifp->addr, &mcaddr);
2931 	ndisc_send_ns(ifp->idev->dev, NULL, &ifp->addr, &mcaddr, &in6addr_any);
2932 out:
2933 	in6_ifa_put(ifp);
2934 }
2935 
2936 static void addrconf_dad_completed(struct inet6_ifaddr *ifp)
2937 {
2938 	struct net_device *dev = ifp->idev->dev;
2939 
2940 	/*
2941 	 *	Configure the address for reception. Now it is valid.
2942 	 */
2943 
2944 	ipv6_ifa_notify(RTM_NEWADDR, ifp);
2945 
2946 	/* If added prefix is link local and forwarding is off,
2947 	   start sending router solicitations.
2948 	 */
2949 
2950 	if ((ifp->idev->cnf.forwarding == 0 ||
2951 	     ifp->idev->cnf.forwarding == 2) &&
2952 	    ifp->idev->cnf.rtr_solicits > 0 &&
2953 	    (dev->flags&IFF_LOOPBACK) == 0 &&
2954 	    (ipv6_addr_type(&ifp->addr) & IPV6_ADDR_LINKLOCAL)) {
2955 		/*
2956 		 *	If a host as already performed a random delay
2957 		 *	[...] as part of DAD [...] there is no need
2958 		 *	to delay again before sending the first RS
2959 		 */
2960 		ndisc_send_rs(ifp->idev->dev, &ifp->addr, &in6addr_linklocal_allrouters);
2961 
2962 		spin_lock_bh(&ifp->lock);
2963 		ifp->probes = 1;
2964 		ifp->idev->if_flags |= IF_RS_SENT;
2965 		addrconf_mod_timer(ifp, AC_RS, ifp->idev->cnf.rtr_solicit_interval);
2966 		spin_unlock_bh(&ifp->lock);
2967 	}
2968 }
2969 
2970 static void addrconf_dad_run(struct inet6_dev *idev)
2971 {
2972 	struct inet6_ifaddr *ifp;
2973 
2974 	read_lock_bh(&idev->lock);
2975 	list_for_each_entry(ifp, &idev->addr_list, if_list) {
2976 		spin_lock(&ifp->lock);
2977 		if (ifp->flags & IFA_F_TENTATIVE &&
2978 		    ifp->state == INET6_IFADDR_STATE_DAD)
2979 			addrconf_dad_kick(ifp);
2980 		spin_unlock(&ifp->lock);
2981 	}
2982 	read_unlock_bh(&idev->lock);
2983 }
2984 
2985 #ifdef CONFIG_PROC_FS
2986 struct if6_iter_state {
2987 	struct seq_net_private p;
2988 	int bucket;
2989 };
2990 
2991 static struct inet6_ifaddr *if6_get_first(struct seq_file *seq)
2992 {
2993 	struct inet6_ifaddr *ifa = NULL;
2994 	struct if6_iter_state *state = seq->private;
2995 	struct net *net = seq_file_net(seq);
2996 
2997 	for (state->bucket = 0; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {
2998 		struct hlist_node *n;
2999 		hlist_for_each_entry_rcu_bh(ifa, n, &inet6_addr_lst[state->bucket],
3000 					 addr_lst)
3001 			if (net_eq(dev_net(ifa->idev->dev), net))
3002 				return ifa;
3003 	}
3004 	return NULL;
3005 }
3006 
3007 static struct inet6_ifaddr *if6_get_next(struct seq_file *seq,
3008 					 struct inet6_ifaddr *ifa)
3009 {
3010 	struct if6_iter_state *state = seq->private;
3011 	struct net *net = seq_file_net(seq);
3012 	struct hlist_node *n = &ifa->addr_lst;
3013 
3014 	hlist_for_each_entry_continue_rcu_bh(ifa, n, addr_lst)
3015 		if (net_eq(dev_net(ifa->idev->dev), net))
3016 			return ifa;
3017 
3018 	while (++state->bucket < IN6_ADDR_HSIZE) {
3019 		hlist_for_each_entry_rcu_bh(ifa, n,
3020 				     &inet6_addr_lst[state->bucket], addr_lst) {
3021 			if (net_eq(dev_net(ifa->idev->dev), net))
3022 				return ifa;
3023 		}
3024 	}
3025 
3026 	return NULL;
3027 }
3028 
3029 static struct inet6_ifaddr *if6_get_idx(struct seq_file *seq, loff_t pos)
3030 {
3031 	struct inet6_ifaddr *ifa = if6_get_first(seq);
3032 
3033 	if (ifa)
3034 		while (pos && (ifa = if6_get_next(seq, ifa)) != NULL)
3035 			--pos;
3036 	return pos ? NULL : ifa;
3037 }
3038 
3039 static void *if6_seq_start(struct seq_file *seq, loff_t *pos)
3040 	__acquires(rcu_bh)
3041 {
3042 	rcu_read_lock_bh();
3043 	return if6_get_idx(seq, *pos);
3044 }
3045 
3046 static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3047 {
3048 	struct inet6_ifaddr *ifa;
3049 
3050 	ifa = if6_get_next(seq, v);
3051 	++*pos;
3052 	return ifa;
3053 }
3054 
3055 static void if6_seq_stop(struct seq_file *seq, void *v)
3056 	__releases(rcu_bh)
3057 {
3058 	rcu_read_unlock_bh();
3059 }
3060 
3061 static int if6_seq_show(struct seq_file *seq, void *v)
3062 {
3063 	struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v;
3064 	seq_printf(seq, "%pi6 %02x %02x %02x %02x %8s\n",
3065 		   &ifp->addr,
3066 		   ifp->idev->dev->ifindex,
3067 		   ifp->prefix_len,
3068 		   ifp->scope,
3069 		   ifp->flags,
3070 		   ifp->idev->dev->name);
3071 	return 0;
3072 }
3073 
3074 static const struct seq_operations if6_seq_ops = {
3075 	.start	= if6_seq_start,
3076 	.next	= if6_seq_next,
3077 	.show	= if6_seq_show,
3078 	.stop	= if6_seq_stop,
3079 };
3080 
3081 static int if6_seq_open(struct inode *inode, struct file *file)
3082 {
3083 	return seq_open_net(inode, file, &if6_seq_ops,
3084 			    sizeof(struct if6_iter_state));
3085 }
3086 
3087 static const struct file_operations if6_fops = {
3088 	.owner		= THIS_MODULE,
3089 	.open		= if6_seq_open,
3090 	.read		= seq_read,
3091 	.llseek		= seq_lseek,
3092 	.release	= seq_release_net,
3093 };
3094 
3095 static int __net_init if6_proc_net_init(struct net *net)
3096 {
3097 	if (!proc_net_fops_create(net, "if_inet6", S_IRUGO, &if6_fops))
3098 		return -ENOMEM;
3099 	return 0;
3100 }
3101 
3102 static void __net_exit if6_proc_net_exit(struct net *net)
3103 {
3104        proc_net_remove(net, "if_inet6");
3105 }
3106 
3107 static struct pernet_operations if6_proc_net_ops = {
3108        .init = if6_proc_net_init,
3109        .exit = if6_proc_net_exit,
3110 };
3111 
3112 int __init if6_proc_init(void)
3113 {
3114 	return register_pernet_subsys(&if6_proc_net_ops);
3115 }
3116 
3117 void if6_proc_exit(void)
3118 {
3119 	unregister_pernet_subsys(&if6_proc_net_ops);
3120 }
3121 #endif	/* CONFIG_PROC_FS */
3122 
3123 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
3124 /* Check if address is a home address configured on any interface. */
3125 int ipv6_chk_home_addr(struct net *net, struct in6_addr *addr)
3126 {
3127 	int ret = 0;
3128 	struct inet6_ifaddr *ifp = NULL;
3129 	struct hlist_node *n;
3130 	unsigned int hash = ipv6_addr_hash(addr);
3131 
3132 	rcu_read_lock_bh();
3133 	hlist_for_each_entry_rcu_bh(ifp, n, &inet6_addr_lst[hash], addr_lst) {
3134 		if (!net_eq(dev_net(ifp->idev->dev), net))
3135 			continue;
3136 		if (ipv6_addr_equal(&ifp->addr, addr) &&
3137 		    (ifp->flags & IFA_F_HOMEADDRESS)) {
3138 			ret = 1;
3139 			break;
3140 		}
3141 	}
3142 	rcu_read_unlock_bh();
3143 	return ret;
3144 }
3145 #endif
3146 
3147 /*
3148  *	Periodic address status verification
3149  */
3150 
3151 static void addrconf_verify(unsigned long foo)
3152 {
3153 	unsigned long now, next, next_sec, next_sched;
3154 	struct inet6_ifaddr *ifp;
3155 	struct hlist_node *node;
3156 	int i;
3157 
3158 	rcu_read_lock_bh();
3159 	spin_lock(&addrconf_verify_lock);
3160 	now = jiffies;
3161 	next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
3162 
3163 	del_timer(&addr_chk_timer);
3164 
3165 	for (i = 0; i < IN6_ADDR_HSIZE; i++) {
3166 restart:
3167 		hlist_for_each_entry_rcu_bh(ifp, node,
3168 					 &inet6_addr_lst[i], addr_lst) {
3169 			unsigned long age;
3170 
3171 			if (ifp->flags & IFA_F_PERMANENT)
3172 				continue;
3173 
3174 			spin_lock(&ifp->lock);
3175 			/* We try to batch several events at once. */
3176 			age = (now - ifp->tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
3177 
3178 			if (ifp->valid_lft != INFINITY_LIFE_TIME &&
3179 			    age >= ifp->valid_lft) {
3180 				spin_unlock(&ifp->lock);
3181 				in6_ifa_hold(ifp);
3182 				ipv6_del_addr(ifp);
3183 				goto restart;
3184 			} else if (ifp->prefered_lft == INFINITY_LIFE_TIME) {
3185 				spin_unlock(&ifp->lock);
3186 				continue;
3187 			} else if (age >= ifp->prefered_lft) {
3188 				/* jiffies - ifp->tstamp > age >= ifp->prefered_lft */
3189 				int deprecate = 0;
3190 
3191 				if (!(ifp->flags&IFA_F_DEPRECATED)) {
3192 					deprecate = 1;
3193 					ifp->flags |= IFA_F_DEPRECATED;
3194 				}
3195 
3196 				if (time_before(ifp->tstamp + ifp->valid_lft * HZ, next))
3197 					next = ifp->tstamp + ifp->valid_lft * HZ;
3198 
3199 				spin_unlock(&ifp->lock);
3200 
3201 				if (deprecate) {
3202 					in6_ifa_hold(ifp);
3203 
3204 					ipv6_ifa_notify(0, ifp);
3205 					in6_ifa_put(ifp);
3206 					goto restart;
3207 				}
3208 #ifdef CONFIG_IPV6_PRIVACY
3209 			} else if ((ifp->flags&IFA_F_TEMPORARY) &&
3210 				   !(ifp->flags&IFA_F_TENTATIVE)) {
3211 				unsigned long regen_advance = ifp->idev->cnf.regen_max_retry *
3212 					ifp->idev->cnf.dad_transmits *
3213 					ifp->idev->nd_parms->retrans_time / HZ;
3214 
3215 				if (age >= ifp->prefered_lft - regen_advance) {
3216 					struct inet6_ifaddr *ifpub = ifp->ifpub;
3217 					if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
3218 						next = ifp->tstamp + ifp->prefered_lft * HZ;
3219 					if (!ifp->regen_count && ifpub) {
3220 						ifp->regen_count++;
3221 						in6_ifa_hold(ifp);
3222 						in6_ifa_hold(ifpub);
3223 						spin_unlock(&ifp->lock);
3224 
3225 						spin_lock(&ifpub->lock);
3226 						ifpub->regen_count = 0;
3227 						spin_unlock(&ifpub->lock);
3228 						ipv6_create_tempaddr(ifpub, ifp);
3229 						in6_ifa_put(ifpub);
3230 						in6_ifa_put(ifp);
3231 						goto restart;
3232 					}
3233 				} else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next))
3234 					next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ;
3235 				spin_unlock(&ifp->lock);
3236 #endif
3237 			} else {
3238 				/* ifp->prefered_lft <= ifp->valid_lft */
3239 				if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
3240 					next = ifp->tstamp + ifp->prefered_lft * HZ;
3241 				spin_unlock(&ifp->lock);
3242 			}
3243 		}
3244 	}
3245 
3246 	next_sec = round_jiffies_up(next);
3247 	next_sched = next;
3248 
3249 	/* If rounded timeout is accurate enough, accept it. */
3250 	if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
3251 		next_sched = next_sec;
3252 
3253 	/* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
3254 	if (time_before(next_sched, jiffies + ADDRCONF_TIMER_FUZZ_MAX))
3255 		next_sched = jiffies + ADDRCONF_TIMER_FUZZ_MAX;
3256 
3257 	ADBG((KERN_DEBUG "now = %lu, schedule = %lu, rounded schedule = %lu => %lu\n",
3258 	      now, next, next_sec, next_sched));
3259 
3260 	addr_chk_timer.expires = next_sched;
3261 	add_timer(&addr_chk_timer);
3262 	spin_unlock(&addrconf_verify_lock);
3263 	rcu_read_unlock_bh();
3264 }
3265 
3266 static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local)
3267 {
3268 	struct in6_addr *pfx = NULL;
3269 
3270 	if (addr)
3271 		pfx = nla_data(addr);
3272 
3273 	if (local) {
3274 		if (pfx && nla_memcmp(local, pfx, sizeof(*pfx)))
3275 			pfx = NULL;
3276 		else
3277 			pfx = nla_data(local);
3278 	}
3279 
3280 	return pfx;
3281 }
3282 
3283 static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = {
3284 	[IFA_ADDRESS]		= { .len = sizeof(struct in6_addr) },
3285 	[IFA_LOCAL]		= { .len = sizeof(struct in6_addr) },
3286 	[IFA_CACHEINFO]		= { .len = sizeof(struct ifa_cacheinfo) },
3287 };
3288 
3289 static int
3290 inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
3291 {
3292 	struct net *net = sock_net(skb->sk);
3293 	struct ifaddrmsg *ifm;
3294 	struct nlattr *tb[IFA_MAX+1];
3295 	struct in6_addr *pfx;
3296 	int err;
3297 
3298 	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
3299 	if (err < 0)
3300 		return err;
3301 
3302 	ifm = nlmsg_data(nlh);
3303 	pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL]);
3304 	if (pfx == NULL)
3305 		return -EINVAL;
3306 
3307 	return inet6_addr_del(net, ifm->ifa_index, pfx, ifm->ifa_prefixlen);
3308 }
3309 
3310 static int inet6_addr_modify(struct inet6_ifaddr *ifp, u8 ifa_flags,
3311 			     u32 prefered_lft, u32 valid_lft)
3312 {
3313 	u32 flags;
3314 	clock_t expires;
3315 	unsigned long timeout;
3316 
3317 	if (!valid_lft || (prefered_lft > valid_lft))
3318 		return -EINVAL;
3319 
3320 	timeout = addrconf_timeout_fixup(valid_lft, HZ);
3321 	if (addrconf_finite_timeout(timeout)) {
3322 		expires = jiffies_to_clock_t(timeout * HZ);
3323 		valid_lft = timeout;
3324 		flags = RTF_EXPIRES;
3325 	} else {
3326 		expires = 0;
3327 		flags = 0;
3328 		ifa_flags |= IFA_F_PERMANENT;
3329 	}
3330 
3331 	timeout = addrconf_timeout_fixup(prefered_lft, HZ);
3332 	if (addrconf_finite_timeout(timeout)) {
3333 		if (timeout == 0)
3334 			ifa_flags |= IFA_F_DEPRECATED;
3335 		prefered_lft = timeout;
3336 	}
3337 
3338 	spin_lock_bh(&ifp->lock);
3339 	ifp->flags = (ifp->flags & ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD | IFA_F_HOMEADDRESS)) | ifa_flags;
3340 	ifp->tstamp = jiffies;
3341 	ifp->valid_lft = valid_lft;
3342 	ifp->prefered_lft = prefered_lft;
3343 
3344 	spin_unlock_bh(&ifp->lock);
3345 	if (!(ifp->flags&IFA_F_TENTATIVE))
3346 		ipv6_ifa_notify(0, ifp);
3347 
3348 	addrconf_prefix_route(&ifp->addr, ifp->prefix_len, ifp->idev->dev,
3349 			      expires, flags);
3350 	addrconf_verify(0);
3351 
3352 	return 0;
3353 }
3354 
3355 static int
3356 inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
3357 {
3358 	struct net *net = sock_net(skb->sk);
3359 	struct ifaddrmsg *ifm;
3360 	struct nlattr *tb[IFA_MAX+1];
3361 	struct in6_addr *pfx;
3362 	struct inet6_ifaddr *ifa;
3363 	struct net_device *dev;
3364 	u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME;
3365 	u8 ifa_flags;
3366 	int err;
3367 
3368 	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
3369 	if (err < 0)
3370 		return err;
3371 
3372 	ifm = nlmsg_data(nlh);
3373 	pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL]);
3374 	if (pfx == NULL)
3375 		return -EINVAL;
3376 
3377 	if (tb[IFA_CACHEINFO]) {
3378 		struct ifa_cacheinfo *ci;
3379 
3380 		ci = nla_data(tb[IFA_CACHEINFO]);
3381 		valid_lft = ci->ifa_valid;
3382 		preferred_lft = ci->ifa_prefered;
3383 	} else {
3384 		preferred_lft = INFINITY_LIFE_TIME;
3385 		valid_lft = INFINITY_LIFE_TIME;
3386 	}
3387 
3388 	dev =  __dev_get_by_index(net, ifm->ifa_index);
3389 	if (dev == NULL)
3390 		return -ENODEV;
3391 
3392 	/* We ignore other flags so far. */
3393 	ifa_flags = ifm->ifa_flags & (IFA_F_NODAD | IFA_F_HOMEADDRESS);
3394 
3395 	ifa = ipv6_get_ifaddr(net, pfx, dev, 1);
3396 	if (ifa == NULL) {
3397 		/*
3398 		 * It would be best to check for !NLM_F_CREATE here but
3399 		 * userspace alreay relies on not having to provide this.
3400 		 */
3401 		return inet6_addr_add(net, ifm->ifa_index, pfx,
3402 				      ifm->ifa_prefixlen, ifa_flags,
3403 				      preferred_lft, valid_lft);
3404 	}
3405 
3406 	if (nlh->nlmsg_flags & NLM_F_EXCL ||
3407 	    !(nlh->nlmsg_flags & NLM_F_REPLACE))
3408 		err = -EEXIST;
3409 	else
3410 		err = inet6_addr_modify(ifa, ifa_flags, preferred_lft, valid_lft);
3411 
3412 	in6_ifa_put(ifa);
3413 
3414 	return err;
3415 }
3416 
3417 static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u8 flags,
3418 			  u8 scope, int ifindex)
3419 {
3420 	struct ifaddrmsg *ifm;
3421 
3422 	ifm = nlmsg_data(nlh);
3423 	ifm->ifa_family = AF_INET6;
3424 	ifm->ifa_prefixlen = prefixlen;
3425 	ifm->ifa_flags = flags;
3426 	ifm->ifa_scope = scope;
3427 	ifm->ifa_index = ifindex;
3428 }
3429 
3430 static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
3431 			 unsigned long tstamp, u32 preferred, u32 valid)
3432 {
3433 	struct ifa_cacheinfo ci;
3434 
3435 	ci.cstamp = cstamp_delta(cstamp);
3436 	ci.tstamp = cstamp_delta(tstamp);
3437 	ci.ifa_prefered = preferred;
3438 	ci.ifa_valid = valid;
3439 
3440 	return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
3441 }
3442 
3443 static inline int rt_scope(int ifa_scope)
3444 {
3445 	if (ifa_scope & IFA_HOST)
3446 		return RT_SCOPE_HOST;
3447 	else if (ifa_scope & IFA_LINK)
3448 		return RT_SCOPE_LINK;
3449 	else if (ifa_scope & IFA_SITE)
3450 		return RT_SCOPE_SITE;
3451 	else
3452 		return RT_SCOPE_UNIVERSE;
3453 }
3454 
3455 static inline int inet6_ifaddr_msgsize(void)
3456 {
3457 	return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
3458 	       + nla_total_size(16) /* IFA_ADDRESS */
3459 	       + nla_total_size(sizeof(struct ifa_cacheinfo));
3460 }
3461 
3462 static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
3463 			     u32 pid, u32 seq, int event, unsigned int flags)
3464 {
3465 	struct nlmsghdr  *nlh;
3466 	u32 preferred, valid;
3467 
3468 	nlh = nlmsg_put(skb, pid, seq, event, sizeof(struct ifaddrmsg), flags);
3469 	if (nlh == NULL)
3470 		return -EMSGSIZE;
3471 
3472 	put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope),
3473 		      ifa->idev->dev->ifindex);
3474 
3475 	if (!(ifa->flags&IFA_F_PERMANENT)) {
3476 		preferred = ifa->prefered_lft;
3477 		valid = ifa->valid_lft;
3478 		if (preferred != INFINITY_LIFE_TIME) {
3479 			long tval = (jiffies - ifa->tstamp)/HZ;
3480 			if (preferred > tval)
3481 				preferred -= tval;
3482 			else
3483 				preferred = 0;
3484 			if (valid != INFINITY_LIFE_TIME) {
3485 				if (valid > tval)
3486 					valid -= tval;
3487 				else
3488 					valid = 0;
3489 			}
3490 		}
3491 	} else {
3492 		preferred = INFINITY_LIFE_TIME;
3493 		valid = INFINITY_LIFE_TIME;
3494 	}
3495 
3496 	if (nla_put(skb, IFA_ADDRESS, 16, &ifa->addr) < 0 ||
3497 	    put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0) {
3498 		nlmsg_cancel(skb, nlh);
3499 		return -EMSGSIZE;
3500 	}
3501 
3502 	return nlmsg_end(skb, nlh);
3503 }
3504 
3505 static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca,
3506 				u32 pid, u32 seq, int event, u16 flags)
3507 {
3508 	struct nlmsghdr  *nlh;
3509 	u8 scope = RT_SCOPE_UNIVERSE;
3510 	int ifindex = ifmca->idev->dev->ifindex;
3511 
3512 	if (ipv6_addr_scope(&ifmca->mca_addr) & IFA_SITE)
3513 		scope = RT_SCOPE_SITE;
3514 
3515 	nlh = nlmsg_put(skb, pid, seq, event, sizeof(struct ifaddrmsg), flags);
3516 	if (nlh == NULL)
3517 		return -EMSGSIZE;
3518 
3519 	put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
3520 	if (nla_put(skb, IFA_MULTICAST, 16, &ifmca->mca_addr) < 0 ||
3521 	    put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp,
3522 			  INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
3523 		nlmsg_cancel(skb, nlh);
3524 		return -EMSGSIZE;
3525 	}
3526 
3527 	return nlmsg_end(skb, nlh);
3528 }
3529 
3530 static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
3531 				u32 pid, u32 seq, int event, unsigned int flags)
3532 {
3533 	struct nlmsghdr  *nlh;
3534 	u8 scope = RT_SCOPE_UNIVERSE;
3535 	int ifindex = ifaca->aca_idev->dev->ifindex;
3536 
3537 	if (ipv6_addr_scope(&ifaca->aca_addr) & IFA_SITE)
3538 		scope = RT_SCOPE_SITE;
3539 
3540 	nlh = nlmsg_put(skb, pid, seq, event, sizeof(struct ifaddrmsg), flags);
3541 	if (nlh == NULL)
3542 		return -EMSGSIZE;
3543 
3544 	put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
3545 	if (nla_put(skb, IFA_ANYCAST, 16, &ifaca->aca_addr) < 0 ||
3546 	    put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp,
3547 			  INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
3548 		nlmsg_cancel(skb, nlh);
3549 		return -EMSGSIZE;
3550 	}
3551 
3552 	return nlmsg_end(skb, nlh);
3553 }
3554 
3555 enum addr_type_t {
3556 	UNICAST_ADDR,
3557 	MULTICAST_ADDR,
3558 	ANYCAST_ADDR,
3559 };
3560 
3561 /* called with rcu_read_lock() */
3562 static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
3563 			  struct netlink_callback *cb, enum addr_type_t type,
3564 			  int s_ip_idx, int *p_ip_idx)
3565 {
3566 	struct ifmcaddr6 *ifmca;
3567 	struct ifacaddr6 *ifaca;
3568 	int err = 1;
3569 	int ip_idx = *p_ip_idx;
3570 
3571 	read_lock_bh(&idev->lock);
3572 	switch (type) {
3573 	case UNICAST_ADDR: {
3574 		struct inet6_ifaddr *ifa;
3575 
3576 		/* unicast address incl. temp addr */
3577 		list_for_each_entry(ifa, &idev->addr_list, if_list) {
3578 			if (++ip_idx < s_ip_idx)
3579 				continue;
3580 			err = inet6_fill_ifaddr(skb, ifa,
3581 						NETLINK_CB(cb->skb).pid,
3582 						cb->nlh->nlmsg_seq,
3583 						RTM_NEWADDR,
3584 						NLM_F_MULTI);
3585 			if (err <= 0)
3586 				break;
3587 		}
3588 		break;
3589 	}
3590 	case MULTICAST_ADDR:
3591 		/* multicast address */
3592 		for (ifmca = idev->mc_list; ifmca;
3593 		     ifmca = ifmca->next, ip_idx++) {
3594 			if (ip_idx < s_ip_idx)
3595 				continue;
3596 			err = inet6_fill_ifmcaddr(skb, ifmca,
3597 						  NETLINK_CB(cb->skb).pid,
3598 						  cb->nlh->nlmsg_seq,
3599 						  RTM_GETMULTICAST,
3600 						  NLM_F_MULTI);
3601 			if (err <= 0)
3602 				break;
3603 		}
3604 		break;
3605 	case ANYCAST_ADDR:
3606 		/* anycast address */
3607 		for (ifaca = idev->ac_list; ifaca;
3608 		     ifaca = ifaca->aca_next, ip_idx++) {
3609 			if (ip_idx < s_ip_idx)
3610 				continue;
3611 			err = inet6_fill_ifacaddr(skb, ifaca,
3612 						  NETLINK_CB(cb->skb).pid,
3613 						  cb->nlh->nlmsg_seq,
3614 						  RTM_GETANYCAST,
3615 						  NLM_F_MULTI);
3616 			if (err <= 0)
3617 				break;
3618 		}
3619 		break;
3620 	default:
3621 		break;
3622 	}
3623 	read_unlock_bh(&idev->lock);
3624 	*p_ip_idx = ip_idx;
3625 	return err;
3626 }
3627 
3628 static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
3629 			   enum addr_type_t type)
3630 {
3631 	struct net *net = sock_net(skb->sk);
3632 	int h, s_h;
3633 	int idx, ip_idx;
3634 	int s_idx, s_ip_idx;
3635 	struct net_device *dev;
3636 	struct inet6_dev *idev;
3637 	struct hlist_head *head;
3638 	struct hlist_node *node;
3639 
3640 	s_h = cb->args[0];
3641 	s_idx = idx = cb->args[1];
3642 	s_ip_idx = ip_idx = cb->args[2];
3643 
3644 	rcu_read_lock();
3645 	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
3646 		idx = 0;
3647 		head = &net->dev_index_head[h];
3648 		hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
3649 			if (idx < s_idx)
3650 				goto cont;
3651 			if (h > s_h || idx > s_idx)
3652 				s_ip_idx = 0;
3653 			ip_idx = 0;
3654 			idev = __in6_dev_get(dev);
3655 			if (!idev)
3656 				goto cont;
3657 
3658 			if (in6_dump_addrs(idev, skb, cb, type,
3659 					   s_ip_idx, &ip_idx) <= 0)
3660 				goto done;
3661 cont:
3662 			idx++;
3663 		}
3664 	}
3665 done:
3666 	rcu_read_unlock();
3667 	cb->args[0] = h;
3668 	cb->args[1] = idx;
3669 	cb->args[2] = ip_idx;
3670 
3671 	return skb->len;
3672 }
3673 
3674 static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
3675 {
3676 	enum addr_type_t type = UNICAST_ADDR;
3677 
3678 	return inet6_dump_addr(skb, cb, type);
3679 }
3680 
3681 static int inet6_dump_ifmcaddr(struct sk_buff *skb, struct netlink_callback *cb)
3682 {
3683 	enum addr_type_t type = MULTICAST_ADDR;
3684 
3685 	return inet6_dump_addr(skb, cb, type);
3686 }
3687 
3688 
3689 static int inet6_dump_ifacaddr(struct sk_buff *skb, struct netlink_callback *cb)
3690 {
3691 	enum addr_type_t type = ANYCAST_ADDR;
3692 
3693 	return inet6_dump_addr(skb, cb, type);
3694 }
3695 
3696 static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr* nlh,
3697 			     void *arg)
3698 {
3699 	struct net *net = sock_net(in_skb->sk);
3700 	struct ifaddrmsg *ifm;
3701 	struct nlattr *tb[IFA_MAX+1];
3702 	struct in6_addr *addr = NULL;
3703 	struct net_device *dev = NULL;
3704 	struct inet6_ifaddr *ifa;
3705 	struct sk_buff *skb;
3706 	int err;
3707 
3708 	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
3709 	if (err < 0)
3710 		goto errout;
3711 
3712 	addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL]);
3713 	if (addr == NULL) {
3714 		err = -EINVAL;
3715 		goto errout;
3716 	}
3717 
3718 	ifm = nlmsg_data(nlh);
3719 	if (ifm->ifa_index)
3720 		dev = __dev_get_by_index(net, ifm->ifa_index);
3721 
3722 	ifa = ipv6_get_ifaddr(net, addr, dev, 1);
3723 	if (!ifa) {
3724 		err = -EADDRNOTAVAIL;
3725 		goto errout;
3726 	}
3727 
3728 	skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL);
3729 	if (!skb) {
3730 		err = -ENOBUFS;
3731 		goto errout_ifa;
3732 	}
3733 
3734 	err = inet6_fill_ifaddr(skb, ifa, NETLINK_CB(in_skb).pid,
3735 				nlh->nlmsg_seq, RTM_NEWADDR, 0);
3736 	if (err < 0) {
3737 		/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
3738 		WARN_ON(err == -EMSGSIZE);
3739 		kfree_skb(skb);
3740 		goto errout_ifa;
3741 	}
3742 	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
3743 errout_ifa:
3744 	in6_ifa_put(ifa);
3745 errout:
3746 	return err;
3747 }
3748 
3749 static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa)
3750 {
3751 	struct sk_buff *skb;
3752 	struct net *net = dev_net(ifa->idev->dev);
3753 	int err = -ENOBUFS;
3754 
3755 	skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC);
3756 	if (skb == NULL)
3757 		goto errout;
3758 
3759 	err = inet6_fill_ifaddr(skb, ifa, 0, 0, event, 0);
3760 	if (err < 0) {
3761 		/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
3762 		WARN_ON(err == -EMSGSIZE);
3763 		kfree_skb(skb);
3764 		goto errout;
3765 	}
3766 	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC);
3767 	return;
3768 errout:
3769 	if (err < 0)
3770 		rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err);
3771 }
3772 
3773 static inline void ipv6_store_devconf(struct ipv6_devconf *cnf,
3774 				__s32 *array, int bytes)
3775 {
3776 	BUG_ON(bytes < (DEVCONF_MAX * 4));
3777 
3778 	memset(array, 0, bytes);
3779 	array[DEVCONF_FORWARDING] = cnf->forwarding;
3780 	array[DEVCONF_HOPLIMIT] = cnf->hop_limit;
3781 	array[DEVCONF_MTU6] = cnf->mtu6;
3782 	array[DEVCONF_ACCEPT_RA] = cnf->accept_ra;
3783 	array[DEVCONF_ACCEPT_REDIRECTS] = cnf->accept_redirects;
3784 	array[DEVCONF_AUTOCONF] = cnf->autoconf;
3785 	array[DEVCONF_DAD_TRANSMITS] = cnf->dad_transmits;
3786 	array[DEVCONF_RTR_SOLICITS] = cnf->rtr_solicits;
3787 	array[DEVCONF_RTR_SOLICIT_INTERVAL] =
3788 		jiffies_to_msecs(cnf->rtr_solicit_interval);
3789 	array[DEVCONF_RTR_SOLICIT_DELAY] =
3790 		jiffies_to_msecs(cnf->rtr_solicit_delay);
3791 	array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version;
3792 #ifdef CONFIG_IPV6_PRIVACY
3793 	array[DEVCONF_USE_TEMPADDR] = cnf->use_tempaddr;
3794 	array[DEVCONF_TEMP_VALID_LFT] = cnf->temp_valid_lft;
3795 	array[DEVCONF_TEMP_PREFERED_LFT] = cnf->temp_prefered_lft;
3796 	array[DEVCONF_REGEN_MAX_RETRY] = cnf->regen_max_retry;
3797 	array[DEVCONF_MAX_DESYNC_FACTOR] = cnf->max_desync_factor;
3798 #endif
3799 	array[DEVCONF_MAX_ADDRESSES] = cnf->max_addresses;
3800 	array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr;
3801 	array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo;
3802 #ifdef CONFIG_IPV6_ROUTER_PREF
3803 	array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref;
3804 	array[DEVCONF_RTR_PROBE_INTERVAL] =
3805 		jiffies_to_msecs(cnf->rtr_probe_interval);
3806 #ifdef CONFIG_IPV6_ROUTE_INFO
3807 	array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen;
3808 #endif
3809 #endif
3810 	array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp;
3811 	array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route;
3812 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
3813 	array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad;
3814 #endif
3815 #ifdef CONFIG_IPV6_MROUTE
3816 	array[DEVCONF_MC_FORWARDING] = cnf->mc_forwarding;
3817 #endif
3818 	array[DEVCONF_DISABLE_IPV6] = cnf->disable_ipv6;
3819 	array[DEVCONF_ACCEPT_DAD] = cnf->accept_dad;
3820 	array[DEVCONF_FORCE_TLLAO] = cnf->force_tllao;
3821 }
3822 
3823 static inline size_t inet6_ifla6_size(void)
3824 {
3825 	return nla_total_size(4) /* IFLA_INET6_FLAGS */
3826 	     + nla_total_size(sizeof(struct ifla_cacheinfo))
3827 	     + nla_total_size(DEVCONF_MAX * 4) /* IFLA_INET6_CONF */
3828 	     + nla_total_size(IPSTATS_MIB_MAX * 8) /* IFLA_INET6_STATS */
3829 	     + nla_total_size(ICMP6_MIB_MAX * 8); /* IFLA_INET6_ICMP6STATS */
3830 }
3831 
3832 static inline size_t inet6_if_nlmsg_size(void)
3833 {
3834 	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
3835 	       + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
3836 	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
3837 	       + nla_total_size(4) /* IFLA_MTU */
3838 	       + nla_total_size(4) /* IFLA_LINK */
3839 	       + nla_total_size(inet6_ifla6_size()); /* IFLA_PROTINFO */
3840 }
3841 
3842 static inline void __snmp6_fill_stats(u64 *stats, void __percpu **mib,
3843 				      int items, int bytes)
3844 {
3845 	int i;
3846 	int pad = bytes - sizeof(u64) * items;
3847 	BUG_ON(pad < 0);
3848 
3849 	/* Use put_unaligned() because stats may not be aligned for u64. */
3850 	put_unaligned(items, &stats[0]);
3851 	for (i = 1; i < items; i++)
3852 		put_unaligned(snmp_fold_field(mib, i), &stats[i]);
3853 
3854 	memset(&stats[items], 0, pad);
3855 }
3856 
3857 static inline void __snmp6_fill_stats64(u64 *stats, void __percpu **mib,
3858 				      int items, int bytes, size_t syncpoff)
3859 {
3860 	int i;
3861 	int pad = bytes - sizeof(u64) * items;
3862 	BUG_ON(pad < 0);
3863 
3864 	/* Use put_unaligned() because stats may not be aligned for u64. */
3865 	put_unaligned(items, &stats[0]);
3866 	for (i = 1; i < items; i++)
3867 		put_unaligned(snmp_fold_field64(mib, i, syncpoff), &stats[i]);
3868 
3869 	memset(&stats[items], 0, pad);
3870 }
3871 
3872 static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype,
3873 			     int bytes)
3874 {
3875 	switch (attrtype) {
3876 	case IFLA_INET6_STATS:
3877 		__snmp6_fill_stats64(stats, (void __percpu **)idev->stats.ipv6,
3878 				     IPSTATS_MIB_MAX, bytes, offsetof(struct ipstats_mib, syncp));
3879 		break;
3880 	case IFLA_INET6_ICMP6STATS:
3881 		__snmp6_fill_stats(stats, (void __percpu **)idev->stats.icmpv6, ICMP6_MIB_MAX, bytes);
3882 		break;
3883 	}
3884 }
3885 
3886 static int inet6_fill_ifla6_attrs(struct sk_buff *skb, struct inet6_dev *idev)
3887 {
3888 	struct nlattr *nla;
3889 	struct ifla_cacheinfo ci;
3890 
3891 	NLA_PUT_U32(skb, IFLA_INET6_FLAGS, idev->if_flags);
3892 
3893 	ci.max_reasm_len = IPV6_MAXPLEN;
3894 	ci.tstamp = cstamp_delta(idev->tstamp);
3895 	ci.reachable_time = jiffies_to_msecs(idev->nd_parms->reachable_time);
3896 	ci.retrans_time = jiffies_to_msecs(idev->nd_parms->retrans_time);
3897 	NLA_PUT(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci);
3898 
3899 	nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32));
3900 	if (nla == NULL)
3901 		goto nla_put_failure;
3902 	ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla));
3903 
3904 	/* XXX - MC not implemented */
3905 
3906 	nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64));
3907 	if (nla == NULL)
3908 		goto nla_put_failure;
3909 	snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_STATS, nla_len(nla));
3910 
3911 	nla = nla_reserve(skb, IFLA_INET6_ICMP6STATS, ICMP6_MIB_MAX * sizeof(u64));
3912 	if (nla == NULL)
3913 		goto nla_put_failure;
3914 	snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla));
3915 
3916 	return 0;
3917 
3918 nla_put_failure:
3919 	return -EMSGSIZE;
3920 }
3921 
3922 static size_t inet6_get_link_af_size(const struct net_device *dev)
3923 {
3924 	if (!__in6_dev_get(dev))
3925 		return 0;
3926 
3927 	return inet6_ifla6_size();
3928 }
3929 
3930 static int inet6_fill_link_af(struct sk_buff *skb, const struct net_device *dev)
3931 {
3932 	struct inet6_dev *idev = __in6_dev_get(dev);
3933 
3934 	if (!idev)
3935 		return -ENODATA;
3936 
3937 	if (inet6_fill_ifla6_attrs(skb, idev) < 0)
3938 		return -EMSGSIZE;
3939 
3940 	return 0;
3941 }
3942 
3943 static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev,
3944 			     u32 pid, u32 seq, int event, unsigned int flags)
3945 {
3946 	struct net_device *dev = idev->dev;
3947 	struct ifinfomsg *hdr;
3948 	struct nlmsghdr *nlh;
3949 	void *protoinfo;
3950 
3951 	nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags);
3952 	if (nlh == NULL)
3953 		return -EMSGSIZE;
3954 
3955 	hdr = nlmsg_data(nlh);
3956 	hdr->ifi_family = AF_INET6;
3957 	hdr->__ifi_pad = 0;
3958 	hdr->ifi_type = dev->type;
3959 	hdr->ifi_index = dev->ifindex;
3960 	hdr->ifi_flags = dev_get_flags(dev);
3961 	hdr->ifi_change = 0;
3962 
3963 	NLA_PUT_STRING(skb, IFLA_IFNAME, dev->name);
3964 
3965 	if (dev->addr_len)
3966 		NLA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr);
3967 
3968 	NLA_PUT_U32(skb, IFLA_MTU, dev->mtu);
3969 	if (dev->ifindex != dev->iflink)
3970 		NLA_PUT_U32(skb, IFLA_LINK, dev->iflink);
3971 
3972 	protoinfo = nla_nest_start(skb, IFLA_PROTINFO);
3973 	if (protoinfo == NULL)
3974 		goto nla_put_failure;
3975 
3976 	if (inet6_fill_ifla6_attrs(skb, idev) < 0)
3977 		goto nla_put_failure;
3978 
3979 	nla_nest_end(skb, protoinfo);
3980 	return nlmsg_end(skb, nlh);
3981 
3982 nla_put_failure:
3983 	nlmsg_cancel(skb, nlh);
3984 	return -EMSGSIZE;
3985 }
3986 
3987 static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
3988 {
3989 	struct net *net = sock_net(skb->sk);
3990 	int h, s_h;
3991 	int idx = 0, s_idx;
3992 	struct net_device *dev;
3993 	struct inet6_dev *idev;
3994 	struct hlist_head *head;
3995 	struct hlist_node *node;
3996 
3997 	s_h = cb->args[0];
3998 	s_idx = cb->args[1];
3999 
4000 	rcu_read_lock();
4001 	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
4002 		idx = 0;
4003 		head = &net->dev_index_head[h];
4004 		hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
4005 			if (idx < s_idx)
4006 				goto cont;
4007 			idev = __in6_dev_get(dev);
4008 			if (!idev)
4009 				goto cont;
4010 			if (inet6_fill_ifinfo(skb, idev,
4011 					      NETLINK_CB(cb->skb).pid,
4012 					      cb->nlh->nlmsg_seq,
4013 					      RTM_NEWLINK, NLM_F_MULTI) <= 0)
4014 				goto out;
4015 cont:
4016 			idx++;
4017 		}
4018 	}
4019 out:
4020 	rcu_read_unlock();
4021 	cb->args[1] = idx;
4022 	cb->args[0] = h;
4023 
4024 	return skb->len;
4025 }
4026 
4027 void inet6_ifinfo_notify(int event, struct inet6_dev *idev)
4028 {
4029 	struct sk_buff *skb;
4030 	struct net *net = dev_net(idev->dev);
4031 	int err = -ENOBUFS;
4032 
4033 	skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC);
4034 	if (skb == NULL)
4035 		goto errout;
4036 
4037 	err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0);
4038 	if (err < 0) {
4039 		/* -EMSGSIZE implies BUG in inet6_if_nlmsg_size() */
4040 		WARN_ON(err == -EMSGSIZE);
4041 		kfree_skb(skb);
4042 		goto errout;
4043 	}
4044 	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFINFO, NULL, GFP_ATOMIC);
4045 	return;
4046 errout:
4047 	if (err < 0)
4048 		rtnl_set_sk_err(net, RTNLGRP_IPV6_IFINFO, err);
4049 }
4050 
4051 static inline size_t inet6_prefix_nlmsg_size(void)
4052 {
4053 	return NLMSG_ALIGN(sizeof(struct prefixmsg))
4054 	       + nla_total_size(sizeof(struct in6_addr))
4055 	       + nla_total_size(sizeof(struct prefix_cacheinfo));
4056 }
4057 
4058 static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev,
4059 			     struct prefix_info *pinfo, u32 pid, u32 seq,
4060 			     int event, unsigned int flags)
4061 {
4062 	struct prefixmsg *pmsg;
4063 	struct nlmsghdr *nlh;
4064 	struct prefix_cacheinfo	ci;
4065 
4066 	nlh = nlmsg_put(skb, pid, seq, event, sizeof(*pmsg), flags);
4067 	if (nlh == NULL)
4068 		return -EMSGSIZE;
4069 
4070 	pmsg = nlmsg_data(nlh);
4071 	pmsg->prefix_family = AF_INET6;
4072 	pmsg->prefix_pad1 = 0;
4073 	pmsg->prefix_pad2 = 0;
4074 	pmsg->prefix_ifindex = idev->dev->ifindex;
4075 	pmsg->prefix_len = pinfo->prefix_len;
4076 	pmsg->prefix_type = pinfo->type;
4077 	pmsg->prefix_pad3 = 0;
4078 	pmsg->prefix_flags = 0;
4079 	if (pinfo->onlink)
4080 		pmsg->prefix_flags |= IF_PREFIX_ONLINK;
4081 	if (pinfo->autoconf)
4082 		pmsg->prefix_flags |= IF_PREFIX_AUTOCONF;
4083 
4084 	NLA_PUT(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix);
4085 
4086 	ci.preferred_time = ntohl(pinfo->prefered);
4087 	ci.valid_time = ntohl(pinfo->valid);
4088 	NLA_PUT(skb, PREFIX_CACHEINFO, sizeof(ci), &ci);
4089 
4090 	return nlmsg_end(skb, nlh);
4091 
4092 nla_put_failure:
4093 	nlmsg_cancel(skb, nlh);
4094 	return -EMSGSIZE;
4095 }
4096 
4097 static void inet6_prefix_notify(int event, struct inet6_dev *idev,
4098 			 struct prefix_info *pinfo)
4099 {
4100 	struct sk_buff *skb;
4101 	struct net *net = dev_net(idev->dev);
4102 	int err = -ENOBUFS;
4103 
4104 	skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC);
4105 	if (skb == NULL)
4106 		goto errout;
4107 
4108 	err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0);
4109 	if (err < 0) {
4110 		/* -EMSGSIZE implies BUG in inet6_prefix_nlmsg_size() */
4111 		WARN_ON(err == -EMSGSIZE);
4112 		kfree_skb(skb);
4113 		goto errout;
4114 	}
4115 	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC);
4116 	return;
4117 errout:
4118 	if (err < 0)
4119 		rtnl_set_sk_err(net, RTNLGRP_IPV6_PREFIX, err);
4120 }
4121 
4122 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
4123 {
4124 	inet6_ifa_notify(event ? : RTM_NEWADDR, ifp);
4125 
4126 	switch (event) {
4127 	case RTM_NEWADDR:
4128 		/*
4129 		 * If the address was optimistic
4130 		 * we inserted the route at the start of
4131 		 * our DAD process, so we don't need
4132 		 * to do it again
4133 		 */
4134 		if (!(ifp->rt->rt6i_node))
4135 			ip6_ins_rt(ifp->rt);
4136 		if (ifp->idev->cnf.forwarding)
4137 			addrconf_join_anycast(ifp);
4138 		break;
4139 	case RTM_DELADDR:
4140 		if (ifp->idev->cnf.forwarding)
4141 			addrconf_leave_anycast(ifp);
4142 		addrconf_leave_solict(ifp->idev, &ifp->addr);
4143 		dst_hold(&ifp->rt->dst);
4144 
4145 		if (ip6_del_rt(ifp->rt))
4146 			dst_free(&ifp->rt->dst);
4147 		break;
4148 	}
4149 }
4150 
4151 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
4152 {
4153 	rcu_read_lock_bh();
4154 	if (likely(ifp->idev->dead == 0))
4155 		__ipv6_ifa_notify(event, ifp);
4156 	rcu_read_unlock_bh();
4157 }
4158 
4159 #ifdef CONFIG_SYSCTL
4160 
4161 static
4162 int addrconf_sysctl_forward(ctl_table *ctl, int write,
4163 			   void __user *buffer, size_t *lenp, loff_t *ppos)
4164 {
4165 	int *valp = ctl->data;
4166 	int val = *valp;
4167 	loff_t pos = *ppos;
4168 	int ret;
4169 
4170 	ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
4171 
4172 	if (write)
4173 		ret = addrconf_fixup_forwarding(ctl, valp, val);
4174 	if (ret)
4175 		*ppos = pos;
4176 	return ret;
4177 }
4178 
4179 static void dev_disable_change(struct inet6_dev *idev)
4180 {
4181 	if (!idev || !idev->dev)
4182 		return;
4183 
4184 	if (idev->cnf.disable_ipv6)
4185 		addrconf_notify(NULL, NETDEV_DOWN, idev->dev);
4186 	else
4187 		addrconf_notify(NULL, NETDEV_UP, idev->dev);
4188 }
4189 
4190 static void addrconf_disable_change(struct net *net, __s32 newf)
4191 {
4192 	struct net_device *dev;
4193 	struct inet6_dev *idev;
4194 
4195 	rcu_read_lock();
4196 	for_each_netdev_rcu(net, dev) {
4197 		idev = __in6_dev_get(dev);
4198 		if (idev) {
4199 			int changed = (!idev->cnf.disable_ipv6) ^ (!newf);
4200 			idev->cnf.disable_ipv6 = newf;
4201 			if (changed)
4202 				dev_disable_change(idev);
4203 		}
4204 	}
4205 	rcu_read_unlock();
4206 }
4207 
4208 static int addrconf_disable_ipv6(struct ctl_table *table, int *p, int old)
4209 {
4210 	struct net *net;
4211 
4212 	net = (struct net *)table->extra2;
4213 
4214 	if (p == &net->ipv6.devconf_dflt->disable_ipv6)
4215 		return 0;
4216 
4217 	if (!rtnl_trylock()) {
4218 		/* Restore the original values before restarting */
4219 		*p = old;
4220 		return restart_syscall();
4221 	}
4222 
4223 	if (p == &net->ipv6.devconf_all->disable_ipv6) {
4224 		__s32 newf = net->ipv6.devconf_all->disable_ipv6;
4225 		net->ipv6.devconf_dflt->disable_ipv6 = newf;
4226 		addrconf_disable_change(net, newf);
4227 	} else if ((!*p) ^ (!old))
4228 		dev_disable_change((struct inet6_dev *)table->extra1);
4229 
4230 	rtnl_unlock();
4231 	return 0;
4232 }
4233 
4234 static
4235 int addrconf_sysctl_disable(ctl_table *ctl, int write,
4236 			    void __user *buffer, size_t *lenp, loff_t *ppos)
4237 {
4238 	int *valp = ctl->data;
4239 	int val = *valp;
4240 	loff_t pos = *ppos;
4241 	int ret;
4242 
4243 	ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
4244 
4245 	if (write)
4246 		ret = addrconf_disable_ipv6(ctl, valp, val);
4247 	if (ret)
4248 		*ppos = pos;
4249 	return ret;
4250 }
4251 
4252 static struct addrconf_sysctl_table
4253 {
4254 	struct ctl_table_header *sysctl_header;
4255 	ctl_table addrconf_vars[DEVCONF_MAX+1];
4256 	char *dev_name;
4257 } addrconf_sysctl __read_mostly = {
4258 	.sysctl_header = NULL,
4259 	.addrconf_vars = {
4260 		{
4261 			.procname	= "forwarding",
4262 			.data		= &ipv6_devconf.forwarding,
4263 			.maxlen		= sizeof(int),
4264 			.mode		= 0644,
4265 			.proc_handler	= addrconf_sysctl_forward,
4266 		},
4267 		{
4268 			.procname	= "hop_limit",
4269 			.data		= &ipv6_devconf.hop_limit,
4270 			.maxlen		= sizeof(int),
4271 			.mode		= 0644,
4272 			.proc_handler	= proc_dointvec,
4273 		},
4274 		{
4275 			.procname	= "mtu",
4276 			.data		= &ipv6_devconf.mtu6,
4277 			.maxlen		= sizeof(int),
4278 			.mode		= 0644,
4279 			.proc_handler	= proc_dointvec,
4280 		},
4281 		{
4282 			.procname	= "accept_ra",
4283 			.data		= &ipv6_devconf.accept_ra,
4284 			.maxlen		= sizeof(int),
4285 			.mode		= 0644,
4286 			.proc_handler	= proc_dointvec,
4287 		},
4288 		{
4289 			.procname	= "accept_redirects",
4290 			.data		= &ipv6_devconf.accept_redirects,
4291 			.maxlen		= sizeof(int),
4292 			.mode		= 0644,
4293 			.proc_handler	= proc_dointvec,
4294 		},
4295 		{
4296 			.procname	= "autoconf",
4297 			.data		= &ipv6_devconf.autoconf,
4298 			.maxlen		= sizeof(int),
4299 			.mode		= 0644,
4300 			.proc_handler	= proc_dointvec,
4301 		},
4302 		{
4303 			.procname	= "dad_transmits",
4304 			.data		= &ipv6_devconf.dad_transmits,
4305 			.maxlen		= sizeof(int),
4306 			.mode		= 0644,
4307 			.proc_handler	= proc_dointvec,
4308 		},
4309 		{
4310 			.procname	= "router_solicitations",
4311 			.data		= &ipv6_devconf.rtr_solicits,
4312 			.maxlen		= sizeof(int),
4313 			.mode		= 0644,
4314 			.proc_handler	= proc_dointvec,
4315 		},
4316 		{
4317 			.procname	= "router_solicitation_interval",
4318 			.data		= &ipv6_devconf.rtr_solicit_interval,
4319 			.maxlen		= sizeof(int),
4320 			.mode		= 0644,
4321 			.proc_handler	= proc_dointvec_jiffies,
4322 		},
4323 		{
4324 			.procname	= "router_solicitation_delay",
4325 			.data		= &ipv6_devconf.rtr_solicit_delay,
4326 			.maxlen		= sizeof(int),
4327 			.mode		= 0644,
4328 			.proc_handler	= proc_dointvec_jiffies,
4329 		},
4330 		{
4331 			.procname	= "force_mld_version",
4332 			.data		= &ipv6_devconf.force_mld_version,
4333 			.maxlen		= sizeof(int),
4334 			.mode		= 0644,
4335 			.proc_handler	= proc_dointvec,
4336 		},
4337 #ifdef CONFIG_IPV6_PRIVACY
4338 		{
4339 			.procname	= "use_tempaddr",
4340 			.data		= &ipv6_devconf.use_tempaddr,
4341 			.maxlen		= sizeof(int),
4342 			.mode		= 0644,
4343 			.proc_handler	= proc_dointvec,
4344 		},
4345 		{
4346 			.procname	= "temp_valid_lft",
4347 			.data		= &ipv6_devconf.temp_valid_lft,
4348 			.maxlen		= sizeof(int),
4349 			.mode		= 0644,
4350 			.proc_handler	= proc_dointvec,
4351 		},
4352 		{
4353 			.procname	= "temp_prefered_lft",
4354 			.data		= &ipv6_devconf.temp_prefered_lft,
4355 			.maxlen		= sizeof(int),
4356 			.mode		= 0644,
4357 			.proc_handler	= proc_dointvec,
4358 		},
4359 		{
4360 			.procname	= "regen_max_retry",
4361 			.data		= &ipv6_devconf.regen_max_retry,
4362 			.maxlen		= sizeof(int),
4363 			.mode		= 0644,
4364 			.proc_handler	= proc_dointvec,
4365 		},
4366 		{
4367 			.procname	= "max_desync_factor",
4368 			.data		= &ipv6_devconf.max_desync_factor,
4369 			.maxlen		= sizeof(int),
4370 			.mode		= 0644,
4371 			.proc_handler	= proc_dointvec,
4372 		},
4373 #endif
4374 		{
4375 			.procname	= "max_addresses",
4376 			.data		= &ipv6_devconf.max_addresses,
4377 			.maxlen		= sizeof(int),
4378 			.mode		= 0644,
4379 			.proc_handler	= proc_dointvec,
4380 		},
4381 		{
4382 			.procname	= "accept_ra_defrtr",
4383 			.data		= &ipv6_devconf.accept_ra_defrtr,
4384 			.maxlen		= sizeof(int),
4385 			.mode		= 0644,
4386 			.proc_handler	= proc_dointvec,
4387 		},
4388 		{
4389 			.procname	= "accept_ra_pinfo",
4390 			.data		= &ipv6_devconf.accept_ra_pinfo,
4391 			.maxlen		= sizeof(int),
4392 			.mode		= 0644,
4393 			.proc_handler	= proc_dointvec,
4394 		},
4395 #ifdef CONFIG_IPV6_ROUTER_PREF
4396 		{
4397 			.procname	= "accept_ra_rtr_pref",
4398 			.data		= &ipv6_devconf.accept_ra_rtr_pref,
4399 			.maxlen		= sizeof(int),
4400 			.mode		= 0644,
4401 			.proc_handler	= proc_dointvec,
4402 		},
4403 		{
4404 			.procname	= "router_probe_interval",
4405 			.data		= &ipv6_devconf.rtr_probe_interval,
4406 			.maxlen		= sizeof(int),
4407 			.mode		= 0644,
4408 			.proc_handler	= proc_dointvec_jiffies,
4409 		},
4410 #ifdef CONFIG_IPV6_ROUTE_INFO
4411 		{
4412 			.procname	= "accept_ra_rt_info_max_plen",
4413 			.data		= &ipv6_devconf.accept_ra_rt_info_max_plen,
4414 			.maxlen		= sizeof(int),
4415 			.mode		= 0644,
4416 			.proc_handler	= proc_dointvec,
4417 		},
4418 #endif
4419 #endif
4420 		{
4421 			.procname	= "proxy_ndp",
4422 			.data		= &ipv6_devconf.proxy_ndp,
4423 			.maxlen		= sizeof(int),
4424 			.mode		= 0644,
4425 			.proc_handler	= proc_dointvec,
4426 		},
4427 		{
4428 			.procname	= "accept_source_route",
4429 			.data		= &ipv6_devconf.accept_source_route,
4430 			.maxlen		= sizeof(int),
4431 			.mode		= 0644,
4432 			.proc_handler	= proc_dointvec,
4433 		},
4434 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
4435 		{
4436 			.procname       = "optimistic_dad",
4437 			.data           = &ipv6_devconf.optimistic_dad,
4438 			.maxlen         = sizeof(int),
4439 			.mode           = 0644,
4440 			.proc_handler   = proc_dointvec,
4441 
4442 		},
4443 #endif
4444 #ifdef CONFIG_IPV6_MROUTE
4445 		{
4446 			.procname	= "mc_forwarding",
4447 			.data		= &ipv6_devconf.mc_forwarding,
4448 			.maxlen		= sizeof(int),
4449 			.mode		= 0444,
4450 			.proc_handler	= proc_dointvec,
4451 		},
4452 #endif
4453 		{
4454 			.procname	= "disable_ipv6",
4455 			.data		= &ipv6_devconf.disable_ipv6,
4456 			.maxlen		= sizeof(int),
4457 			.mode		= 0644,
4458 			.proc_handler	= addrconf_sysctl_disable,
4459 		},
4460 		{
4461 			.procname	= "accept_dad",
4462 			.data		= &ipv6_devconf.accept_dad,
4463 			.maxlen		= sizeof(int),
4464 			.mode		= 0644,
4465 			.proc_handler	= proc_dointvec,
4466 		},
4467 		{
4468 			.procname       = "force_tllao",
4469 			.data           = &ipv6_devconf.force_tllao,
4470 			.maxlen         = sizeof(int),
4471 			.mode           = 0644,
4472 			.proc_handler   = proc_dointvec
4473 		},
4474 		{
4475 			/* sentinel */
4476 		}
4477 	},
4478 };
4479 
4480 static int __addrconf_sysctl_register(struct net *net, char *dev_name,
4481 		struct inet6_dev *idev, struct ipv6_devconf *p)
4482 {
4483 	int i;
4484 	struct addrconf_sysctl_table *t;
4485 
4486 #define ADDRCONF_CTL_PATH_DEV	3
4487 
4488 	struct ctl_path addrconf_ctl_path[] = {
4489 		{ .procname = "net", },
4490 		{ .procname = "ipv6", },
4491 		{ .procname = "conf", },
4492 		{ /* to be set */ },
4493 		{ },
4494 	};
4495 
4496 
4497 	t = kmemdup(&addrconf_sysctl, sizeof(*t), GFP_KERNEL);
4498 	if (t == NULL)
4499 		goto out;
4500 
4501 	for (i = 0; t->addrconf_vars[i].data; i++) {
4502 		t->addrconf_vars[i].data += (char *)p - (char *)&ipv6_devconf;
4503 		t->addrconf_vars[i].extra1 = idev; /* embedded; no ref */
4504 		t->addrconf_vars[i].extra2 = net;
4505 	}
4506 
4507 	/*
4508 	 * Make a copy of dev_name, because '.procname' is regarded as const
4509 	 * by sysctl and we wouldn't want anyone to change it under our feet
4510 	 * (see SIOCSIFNAME).
4511 	 */
4512 	t->dev_name = kstrdup(dev_name, GFP_KERNEL);
4513 	if (!t->dev_name)
4514 		goto free;
4515 
4516 	addrconf_ctl_path[ADDRCONF_CTL_PATH_DEV].procname = t->dev_name;
4517 
4518 	t->sysctl_header = register_net_sysctl_table(net, addrconf_ctl_path,
4519 			t->addrconf_vars);
4520 	if (t->sysctl_header == NULL)
4521 		goto free_procname;
4522 
4523 	p->sysctl = t;
4524 	return 0;
4525 
4526 free_procname:
4527 	kfree(t->dev_name);
4528 free:
4529 	kfree(t);
4530 out:
4531 	return -ENOBUFS;
4532 }
4533 
4534 static void __addrconf_sysctl_unregister(struct ipv6_devconf *p)
4535 {
4536 	struct addrconf_sysctl_table *t;
4537 
4538 	if (p->sysctl == NULL)
4539 		return;
4540 
4541 	t = p->sysctl;
4542 	p->sysctl = NULL;
4543 	unregister_sysctl_table(t->sysctl_header);
4544 	kfree(t->dev_name);
4545 	kfree(t);
4546 }
4547 
4548 static void addrconf_sysctl_register(struct inet6_dev *idev)
4549 {
4550 	neigh_sysctl_register(idev->dev, idev->nd_parms, "ipv6",
4551 			      &ndisc_ifinfo_sysctl_change);
4552 	__addrconf_sysctl_register(dev_net(idev->dev), idev->dev->name,
4553 					idev, &idev->cnf);
4554 }
4555 
4556 static void addrconf_sysctl_unregister(struct inet6_dev *idev)
4557 {
4558 	__addrconf_sysctl_unregister(&idev->cnf);
4559 	neigh_sysctl_unregister(idev->nd_parms);
4560 }
4561 
4562 
4563 #endif
4564 
4565 static int __net_init addrconf_init_net(struct net *net)
4566 {
4567 	int err;
4568 	struct ipv6_devconf *all, *dflt;
4569 
4570 	err = -ENOMEM;
4571 	all = &ipv6_devconf;
4572 	dflt = &ipv6_devconf_dflt;
4573 
4574 	if (!net_eq(net, &init_net)) {
4575 		all = kmemdup(all, sizeof(ipv6_devconf), GFP_KERNEL);
4576 		if (all == NULL)
4577 			goto err_alloc_all;
4578 
4579 		dflt = kmemdup(dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
4580 		if (dflt == NULL)
4581 			goto err_alloc_dflt;
4582 	} else {
4583 		/* these will be inherited by all namespaces */
4584 		dflt->autoconf = ipv6_defaults.autoconf;
4585 		dflt->disable_ipv6 = ipv6_defaults.disable_ipv6;
4586 	}
4587 
4588 	net->ipv6.devconf_all = all;
4589 	net->ipv6.devconf_dflt = dflt;
4590 
4591 #ifdef CONFIG_SYSCTL
4592 	err = __addrconf_sysctl_register(net, "all", NULL, all);
4593 	if (err < 0)
4594 		goto err_reg_all;
4595 
4596 	err = __addrconf_sysctl_register(net, "default", NULL, dflt);
4597 	if (err < 0)
4598 		goto err_reg_dflt;
4599 #endif
4600 	return 0;
4601 
4602 #ifdef CONFIG_SYSCTL
4603 err_reg_dflt:
4604 	__addrconf_sysctl_unregister(all);
4605 err_reg_all:
4606 	kfree(dflt);
4607 #endif
4608 err_alloc_dflt:
4609 	kfree(all);
4610 err_alloc_all:
4611 	return err;
4612 }
4613 
4614 static void __net_exit addrconf_exit_net(struct net *net)
4615 {
4616 #ifdef CONFIG_SYSCTL
4617 	__addrconf_sysctl_unregister(net->ipv6.devconf_dflt);
4618 	__addrconf_sysctl_unregister(net->ipv6.devconf_all);
4619 #endif
4620 	if (!net_eq(net, &init_net)) {
4621 		kfree(net->ipv6.devconf_dflt);
4622 		kfree(net->ipv6.devconf_all);
4623 	}
4624 }
4625 
4626 static struct pernet_operations addrconf_ops = {
4627 	.init = addrconf_init_net,
4628 	.exit = addrconf_exit_net,
4629 };
4630 
4631 /*
4632  *      Device notifier
4633  */
4634 
4635 int register_inet6addr_notifier(struct notifier_block *nb)
4636 {
4637 	return atomic_notifier_chain_register(&inet6addr_chain, nb);
4638 }
4639 EXPORT_SYMBOL(register_inet6addr_notifier);
4640 
4641 int unregister_inet6addr_notifier(struct notifier_block *nb)
4642 {
4643 	return atomic_notifier_chain_unregister(&inet6addr_chain, nb);
4644 }
4645 EXPORT_SYMBOL(unregister_inet6addr_notifier);
4646 
4647 static struct rtnl_af_ops inet6_ops = {
4648 	.family		  = AF_INET6,
4649 	.fill_link_af	  = inet6_fill_link_af,
4650 	.get_link_af_size = inet6_get_link_af_size,
4651 };
4652 
4653 /*
4654  *	Init / cleanup code
4655  */
4656 
4657 int __init addrconf_init(void)
4658 {
4659 	int i, err;
4660 
4661 	err = ipv6_addr_label_init();
4662 	if (err < 0) {
4663 		printk(KERN_CRIT "IPv6 Addrconf:"
4664 		       " cannot initialize default policy table: %d.\n", err);
4665 		goto out;
4666 	}
4667 
4668 	err = register_pernet_subsys(&addrconf_ops);
4669 	if (err < 0)
4670 		goto out_addrlabel;
4671 
4672 	/* The addrconf netdev notifier requires that loopback_dev
4673 	 * has it's ipv6 private information allocated and setup
4674 	 * before it can bring up and give link-local addresses
4675 	 * to other devices which are up.
4676 	 *
4677 	 * Unfortunately, loopback_dev is not necessarily the first
4678 	 * entry in the global dev_base list of net devices.  In fact,
4679 	 * it is likely to be the very last entry on that list.
4680 	 * So this causes the notifier registry below to try and
4681 	 * give link-local addresses to all devices besides loopback_dev
4682 	 * first, then loopback_dev, which cases all the non-loopback_dev
4683 	 * devices to fail to get a link-local address.
4684 	 *
4685 	 * So, as a temporary fix, allocate the ipv6 structure for
4686 	 * loopback_dev first by hand.
4687 	 * Longer term, all of the dependencies ipv6 has upon the loopback
4688 	 * device and it being up should be removed.
4689 	 */
4690 	rtnl_lock();
4691 	if (!ipv6_add_dev(init_net.loopback_dev))
4692 		err = -ENOMEM;
4693 	rtnl_unlock();
4694 	if (err)
4695 		goto errlo;
4696 
4697 	for (i = 0; i < IN6_ADDR_HSIZE; i++)
4698 		INIT_HLIST_HEAD(&inet6_addr_lst[i]);
4699 
4700 	register_netdevice_notifier(&ipv6_dev_notf);
4701 
4702 	addrconf_verify(0);
4703 
4704 	err = rtnl_af_register(&inet6_ops);
4705 	if (err < 0)
4706 		goto errout_af;
4707 
4708 	err = __rtnl_register(PF_INET6, RTM_GETLINK, NULL, inet6_dump_ifinfo);
4709 	if (err < 0)
4710 		goto errout;
4711 
4712 	/* Only the first call to __rtnl_register can fail */
4713 	__rtnl_register(PF_INET6, RTM_NEWADDR, inet6_rtm_newaddr, NULL);
4714 	__rtnl_register(PF_INET6, RTM_DELADDR, inet6_rtm_deladdr, NULL);
4715 	__rtnl_register(PF_INET6, RTM_GETADDR, inet6_rtm_getaddr, inet6_dump_ifaddr);
4716 	__rtnl_register(PF_INET6, RTM_GETMULTICAST, NULL, inet6_dump_ifmcaddr);
4717 	__rtnl_register(PF_INET6, RTM_GETANYCAST, NULL, inet6_dump_ifacaddr);
4718 
4719 	ipv6_addr_label_rtnl_register();
4720 
4721 	return 0;
4722 errout:
4723 	rtnl_af_unregister(&inet6_ops);
4724 errout_af:
4725 	unregister_netdevice_notifier(&ipv6_dev_notf);
4726 errlo:
4727 	unregister_pernet_subsys(&addrconf_ops);
4728 out_addrlabel:
4729 	ipv6_addr_label_cleanup();
4730 out:
4731 	return err;
4732 }
4733 
4734 void addrconf_cleanup(void)
4735 {
4736 	struct net_device *dev;
4737 	int i;
4738 
4739 	unregister_netdevice_notifier(&ipv6_dev_notf);
4740 	unregister_pernet_subsys(&addrconf_ops);
4741 	ipv6_addr_label_cleanup();
4742 
4743 	rtnl_lock();
4744 
4745 	__rtnl_af_unregister(&inet6_ops);
4746 
4747 	/* clean dev list */
4748 	for_each_netdev(&init_net, dev) {
4749 		if (__in6_dev_get(dev) == NULL)
4750 			continue;
4751 		addrconf_ifdown(dev, 1);
4752 	}
4753 	addrconf_ifdown(init_net.loopback_dev, 2);
4754 
4755 	/*
4756 	 *	Check hash table.
4757 	 */
4758 	spin_lock_bh(&addrconf_hash_lock);
4759 	for (i = 0; i < IN6_ADDR_HSIZE; i++)
4760 		WARN_ON(!hlist_empty(&inet6_addr_lst[i]));
4761 	spin_unlock_bh(&addrconf_hash_lock);
4762 
4763 	del_timer(&addr_chk_timer);
4764 	rtnl_unlock();
4765 }
4766