?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / net / ipv6 / addrconf.c
blob7744a2592693ff9562f14b4fa0b0cb614f71fdd7
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 * $Id: addrconf.c,v 1.69 2001/10/31 21:55:54 davem Exp $
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
15 */
16
17 /*
18 * Changes:
19 *
20 * Janos Farkas : delete timer on ifdown
21 * <chexum@bankinf.banki.hu>
22 * Andi Kleen : kill double kfree on module
23 * unload.
24 * Maciej W. Rozycki : FDDI support
25 * sekiya@USAGI : Don't send too many RS
26 * packets.
27 * yoshfuji@USAGI : Fixed interval between DAD
28 * packets.
29 * YOSHIFUJI Hideaki @USAGI : improved accuracy of
30 * address validation timer.
31 * YOSHIFUJI Hideaki @USAGI : Privacy Extensions (RFC3041)
32 * support.
33 * Yuji SEKIYA @USAGI : Don't assign a same IPv6
34 * address on a same interface.
35 * YOSHIFUJI Hideaki @USAGI : ARCnet support
36 * YOSHIFUJI Hideaki @USAGI : convert /proc/net/if_inet6 to
37 * seq_file.
38 */
39
40 #include <linux/config.h>
41 #include <linux/errno.h>
42 #include <linux/types.h>
43 #include <linux/socket.h>
44 #include <linux/sockios.h>
45 #include <linux/sched.h>
46 #include <linux/net.h>
47 #include <linux/in6.h>
48 #include <linux/netdevice.h>
49 #include <linux/if_arp.h>
50 #include <linux/if_arcnet.h>
51 #include <linux/if_infiniband.h>
52 #include <linux/route.h>
53 #include <linux/inetdevice.h>
54 #include <linux/init.h>
55 #ifdef CONFIG_SYSCTL
56 #include <linux/sysctl.h>
57 #endif
58 #include <linux/delay.h>
59 #include <linux/notifier.h>
60
61 #include <net/sock.h>
62 #include <net/snmp.h>
63
64 #include <net/ipv6.h>
65 #include <net/protocol.h>
66 #include <net/ndisc.h>
67 #include <net/ip6_route.h>
68 #include <net/addrconf.h>
69 #include <net/tcp.h>
70 #include <net/ip.h>
71 #include <linux/if_tunnel.h>
72 #include <linux/rtnetlink.h>
73
74 #ifdef CONFIG_IPV6_PRIVACY
75 #include <linux/random.h>
76 #include <linux/crypto.h>
77 #include <asm/scatterlist.h>
78 #endif
79
80 #include <asm/uaccess.h>
81
82 #include <linux/proc_fs.h>
83 #include <linux/seq_file.h>
84
85 /* Set to 3 to get tracing... */
86 #define ACONF_DEBUG 2
87
88 #if ACONF_DEBUG >= 3
89 #define ADBG(x) printk x
90 #else
91 #define ADBG(x)
92 #endif
93
94 #define INFINITY_LIFE_TIME 0xFFFFFFFF
95 #define TIME_DELTA(a,b) ((unsigned long)((long)(a) - (long)(b)))
96
97 #ifdef CONFIG_SYSCTL
98 static void addrconf_sysctl_register(struct inet6_dev *idev, struct ipv6_devconf *p);
99 static void addrconf_sysctl_unregister(struct ipv6_devconf *p);
100 #endif
101
102 #ifdef CONFIG_IPV6_PRIVACY
103 static int __ipv6_regen_rndid(struct inet6_dev *idev);
104 static int __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr);
105 static void ipv6_regen_rndid(unsigned long data);
106
107 static int desync_factor = MAX_DESYNC_FACTOR * HZ;
108 static struct crypto_tfm *md5_tfm;
109 static DEFINE_SPINLOCK(md5_tfm_lock);
110 #endif
111
112 static int ipv6_count_addresses(struct inet6_dev *idev);
113
114 /*
115 * Configured unicast address hash table
116 */
117 static struct inet6_ifaddr *inet6_addr_lst[IN6_ADDR_HSIZE];
118 static DEFINE_RWLOCK(addrconf_hash_lock);
119
120 /* Protects inet6 devices */
121 DEFINE_RWLOCK(addrconf_lock);
122
123 static void addrconf_verify(unsigned long);
124
125 static struct timer_list addr_chk_timer =
126 TIMER_INITIALIZER(addrconf_verify, 0, 0);
127 static DEFINE_SPINLOCK(addrconf_verify_lock);
128
129 static void addrconf_join_anycast(struct inet6_ifaddr *ifp);
130 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp);
131
132 static int addrconf_ifdown(struct net_device *dev, int how);
133
134 static void addrconf_dad_start(struct inet6_ifaddr *ifp, int flags);
135 static void addrconf_dad_timer(unsigned long data);
136 static void addrconf_dad_completed(struct inet6_ifaddr *ifp);
137 static void addrconf_rs_timer(unsigned long data);
138 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
139 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
140
141 static void inet6_prefix_notify(int event, struct inet6_dev *idev,
142 struct prefix_info *pinfo);
143 static int ipv6_chk_same_addr(const struct in6_addr *addr, struct net_device *dev);
144
145 static struct notifier_block *inet6addr_chain;
146
147 struct ipv6_devconf ipv6_devconf = {
148 .forwarding = 0,
149 .hop_limit = IPV6_DEFAULT_HOPLIMIT,
150 .mtu6 = IPV6_MIN_MTU,
151 .accept_ra = 1,
152 .accept_redirects = 1,
153 .autoconf = 1,
154 .force_mld_version = 0,
155 .dad_transmits = 1,
156 .rtr_solicits = MAX_RTR_SOLICITATIONS,
157 .rtr_solicit_interval = RTR_SOLICITATION_INTERVAL,
158 .rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY,
159 #ifdef CONFIG_IPV6_PRIVACY
160 .use_tempaddr = 0,
161 .temp_valid_lft = TEMP_VALID_LIFETIME,
162 .temp_prefered_lft = TEMP_PREFERRED_LIFETIME,
163 .regen_max_retry = REGEN_MAX_RETRY,
164 .max_desync_factor = MAX_DESYNC_FACTOR,
165 #endif
166 .max_addresses = IPV6_MAX_ADDRESSES,
167 };
168
169 static struct ipv6_devconf ipv6_devconf_dflt = {
170 .forwarding = 0,
171 .hop_limit = IPV6_DEFAULT_HOPLIMIT,
172 .mtu6 = IPV6_MIN_MTU,
173 .accept_ra = 1,
174 .accept_redirects = 1,
175 .autoconf = 1,
176 .dad_transmits = 1,
177 .rtr_solicits = MAX_RTR_SOLICITATIONS,
178 .rtr_solicit_interval = RTR_SOLICITATION_INTERVAL,
179 .rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY,
180 #ifdef CONFIG_IPV6_PRIVACY
181 .use_tempaddr = 0,
182 .temp_valid_lft = TEMP_VALID_LIFETIME,
183 .temp_prefered_lft = TEMP_PREFERRED_LIFETIME,
184 .regen_max_retry = REGEN_MAX_RETRY,
185 .max_desync_factor = MAX_DESYNC_FACTOR,
186 #endif
187 .max_addresses = IPV6_MAX_ADDRESSES,
188 };
189
190 /* IPv6 Wildcard Address and Loopback Address defined by RFC2553 */
191 #if 0
192 const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
193 #endif
194 const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
195
196 int ipv6_addr_type(const struct in6_addr *addr)
197 {
198 int type;
199 u32 st;
200
201 st = addr->s6_addr32[0];
202
203 if ((st & htonl(0xFF000000)) == htonl(0xFF000000)) {
204 type = IPV6_ADDR_MULTICAST;
205
206 switch((st & htonl(0x00FF0000))) {
207 case __constant_htonl(0x00010000):
208 type |= IPV6_ADDR_LOOPBACK;
209 break;
210
211 case __constant_htonl(0x00020000):
212 type |= IPV6_ADDR_LINKLOCAL;
213 break;
214
215 case __constant_htonl(0x00050000):
216 type |= IPV6_ADDR_SITELOCAL;
217 break;
218 };
219 return type;
220 }
221
222 type = IPV6_ADDR_UNICAST;
223
224 /* Consider all addresses with the first three bits different of
225 000 and 111 as finished.
226 */
227 if ((st & htonl(0xE0000000)) != htonl(0x00000000) &&
228 (st & htonl(0xE0000000)) != htonl(0xE0000000))
229 return type;
230
231 if ((st & htonl(0xFFC00000)) == htonl(0xFE800000))
232 return (IPV6_ADDR_LINKLOCAL | type);
233
234 if ((st & htonl(0xFFC00000)) == htonl(0xFEC00000))
235 return (IPV6_ADDR_SITELOCAL | type);
236
237 if ((addr->s6_addr32[0] | addr->s6_addr32[1]) == 0) {
238 if (addr->s6_addr32[2] == 0) {
239 if (addr->s6_addr32[3] == 0)
240 return IPV6_ADDR_ANY;
241
242 if (addr->s6_addr32[3] == htonl(0x00000001))
243 return (IPV6_ADDR_LOOPBACK | type);
244
245 return (IPV6_ADDR_COMPATv4 | type);
246 }
247
248 if (addr->s6_addr32[2] == htonl(0x0000ffff))
249 return IPV6_ADDR_MAPPED;
250 }
251
252 st &= htonl(0xFF000000);
253 if (st == 0)
254 return IPV6_ADDR_RESERVED;
255 st &= htonl(0xFE000000);
256 if (st == htonl(0x02000000))
257 return IPV6_ADDR_RESERVED; /* for NSAP */
258 if (st == htonl(0x04000000))
259 return IPV6_ADDR_RESERVED; /* for IPX */
260 return type;
261 }
262
263 static void addrconf_del_timer(struct inet6_ifaddr *ifp)
264 {
265 if (del_timer(&ifp->timer))
266 __in6_ifa_put(ifp);
267 }
268
269 enum addrconf_timer_t
270 {
271 AC_NONE,
272 AC_DAD,
273 AC_RS,
274 };
275
276 static void addrconf_mod_timer(struct inet6_ifaddr *ifp,
277 enum addrconf_timer_t what,
278 unsigned long when)
279 {
280 if (!del_timer(&ifp->timer))
281 in6_ifa_hold(ifp);
282
283 switch (what) {
284 case AC_DAD:
285 ifp->timer.function = addrconf_dad_timer;
286 break;
287 case AC_RS:
288 ifp->timer.function = addrconf_rs_timer;
289 break;
290 default:;
291 }
292 ifp->timer.expires = jiffies + when;
293 add_timer(&ifp->timer);
294 }
295
296 /* Nobody refers to this device, we may destroy it. */
297
298 void in6_dev_finish_destroy(struct inet6_dev *idev)
299 {
300 struct net_device *dev = idev->dev;
301 BUG_TRAP(idev->addr_list==NULL);
302 BUG_TRAP(idev->mc_list==NULL);
303 #ifdef NET_REFCNT_DEBUG
304 printk(KERN_DEBUG "in6_dev_finish_destroy: %s\n", dev ? dev->name : "NIL");
305 #endif
306 dev_put(dev);
307 if (!idev->dead) {
308 printk("Freeing alive inet6 device %p\n", idev);
309 return;
310 }
311 snmp6_free_dev(idev);
312 kfree(idev);
313 }
314
315 static struct inet6_dev * ipv6_add_dev(struct net_device *dev)
316 {
317 struct inet6_dev *ndev;
318
319 ASSERT_RTNL();
320
321 if (dev->mtu < IPV6_MIN_MTU)
322 return NULL;
323
324 ndev = kmalloc(sizeof(struct inet6_dev), GFP_KERNEL);
325
326 if (ndev) {
327 memset(ndev, 0, sizeof(struct inet6_dev));
328
329 rwlock_init(&ndev->lock);
330 ndev->dev = dev;
331 memcpy(&ndev->cnf, &ipv6_devconf_dflt, sizeof(ndev->cnf));
332 ndev->cnf.mtu6 = dev->mtu;
333 ndev->cnf.sysctl = NULL;
334 ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
335 if (ndev->nd_parms == NULL) {
336 kfree(ndev);
337 return NULL;
338 }
339 /* We refer to the device */
340 dev_hold(dev);
341
342 if (snmp6_alloc_dev(ndev) < 0) {
343 ADBG((KERN_WARNING
344 "%s(): cannot allocate memory for statistics; dev=%s.\n",
345 __FUNCTION__, dev->name));
346 neigh_parms_release(&nd_tbl, ndev->nd_parms);
347 ndev->dead = 1;
348 in6_dev_finish_destroy(ndev);
349 return NULL;
350 }
351
352 if (snmp6_register_dev(ndev) < 0) {
353 ADBG((KERN_WARNING
354 "%s(): cannot create /proc/net/dev_snmp6/%s\n",
355 __FUNCTION__, dev->name));
356 neigh_parms_release(&nd_tbl, ndev->nd_parms);
357 ndev->dead = 1;
358 in6_dev_finish_destroy(ndev);
359 return NULL;
360 }
361
362 /* One reference from device. We must do this before
363 * we invoke __ipv6_regen_rndid().
364 */
365 in6_dev_hold(ndev);
366
367 #ifdef CONFIG_IPV6_PRIVACY
368 get_random_bytes(ndev->rndid, sizeof(ndev->rndid));
369 get_random_bytes(ndev->entropy, sizeof(ndev->entropy));
370 init_timer(&ndev->regen_timer);
371 ndev->regen_timer.function = ipv6_regen_rndid;
372 ndev->regen_timer.data = (unsigned long) ndev;
373 if ((dev->flags&IFF_LOOPBACK) ||
374 dev->type == ARPHRD_TUNNEL ||
375 dev->type == ARPHRD_SIT) {
376 printk(KERN_INFO
377 "Disabled Privacy Extensions on device %p(%s)\n",
378 dev, dev->name);
379 ndev->cnf.use_tempaddr = -1;
380 } else {
381 in6_dev_hold(ndev);
382 ipv6_regen_rndid((unsigned long) ndev);
383 }
384 #endif
385
386 write_lock_bh(&addrconf_lock);
387 dev->ip6_ptr = ndev;
388 write_unlock_bh(&addrconf_lock);
389
390 ipv6_mc_init_dev(ndev);
391 ndev->tstamp = jiffies;
392 #ifdef CONFIG_SYSCTL
393 neigh_sysctl_register(dev, ndev->nd_parms, NET_IPV6,
394 NET_IPV6_NEIGH, "ipv6",
395 &ndisc_ifinfo_sysctl_change,
396 NULL);
397 addrconf_sysctl_register(ndev, &ndev->cnf);
398 #endif
399 }
400 return ndev;
401 }
402
403 static struct inet6_dev * ipv6_find_idev(struct net_device *dev)
404 {
405 struct inet6_dev *idev;
406
407 ASSERT_RTNL();
408
409 if ((idev = __in6_dev_get(dev)) == NULL) {
410 if ((idev = ipv6_add_dev(dev)) == NULL)
411 return NULL;
412 }
413 if (dev->flags&IFF_UP)
414 ipv6_mc_up(idev);
415 return idev;
416 }
417
418 #ifdef CONFIG_SYSCTL
419 static void dev_forward_change(struct inet6_dev *idev)
420 {
421 struct net_device *dev;
422 struct inet6_ifaddr *ifa;
423 struct in6_addr addr;
424
425 if (!idev)
426 return;
427 dev = idev->dev;
428 if (dev && (dev->flags & IFF_MULTICAST)) {
429 ipv6_addr_all_routers(&addr);
430
431 if (idev->cnf.forwarding)
432 ipv6_dev_mc_inc(dev, &addr);
433 else
434 ipv6_dev_mc_dec(dev, &addr);
435 }
436 for (ifa=idev->addr_list; ifa; ifa=ifa->if_next) {
437 if (idev->cnf.forwarding)
438 addrconf_join_anycast(ifa);
439 else
440 addrconf_leave_anycast(ifa);
441 }
442 }
443
444
445 static void addrconf_forward_change(void)
446 {
447 struct net_device *dev;
448 struct inet6_dev *idev;
449
450 read_lock(&dev_base_lock);
451 for (dev=dev_base; dev; dev=dev->next) {
452 read_lock(&addrconf_lock);
453 idev = __in6_dev_get(dev);
454 if (idev) {
455 int changed = (!idev->cnf.forwarding) ^ (!ipv6_devconf.forwarding);
456 idev->cnf.forwarding = ipv6_devconf.forwarding;
457 if (changed)
458 dev_forward_change(idev);
459 }
460 read_unlock(&addrconf_lock);
461 }
462 read_unlock(&dev_base_lock);
463 }
464 #endif
465
466 /* Nobody refers to this ifaddr, destroy it */
467
468 void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
469 {
470 BUG_TRAP(ifp->if_next==NULL);
471 BUG_TRAP(ifp->lst_next==NULL);
472 #ifdef NET_REFCNT_DEBUG
473 printk(KERN_DEBUG "inet6_ifa_finish_destroy\n");
474 #endif
475
476 in6_dev_put(ifp->idev);
477
478 if (del_timer(&ifp->timer))
479 printk("Timer is still running, when freeing ifa=%p\n", ifp);
480
481 if (!ifp->dead) {
482 printk("Freeing alive inet6 address %p\n", ifp);
483 return;
484 }
485 dst_release(&ifp->rt->u.dst);
486
487 kfree(ifp);
488 }
489
490 /* On success it returns ifp with increased reference count */
491
492 static struct inet6_ifaddr *
493 ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, int pfxlen,
494 int scope, unsigned flags)
495 {
496 struct inet6_ifaddr *ifa = NULL;
497 struct rt6_info *rt;
498 int hash;
499 int err = 0;
500
501 read_lock_bh(&addrconf_lock);
502 if (idev->dead) {
503 err = -ENODEV; /*XXX*/
504 goto out2;
505 }
506
507 write_lock(&addrconf_hash_lock);
508
509 /* Ignore adding duplicate addresses on an interface */
510 if (ipv6_chk_same_addr(addr, idev->dev)) {
511 ADBG(("ipv6_add_addr: already assigned\n"));
512 err = -EEXIST;
513 goto out;
514 }
515
516 ifa = kmalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC);
517
518 if (ifa == NULL) {
519 ADBG(("ipv6_add_addr: malloc failed\n"));
520 err = -ENOBUFS;
521 goto out;
522 }
523
524 rt = addrconf_dst_alloc(idev, addr, 0);
525 if (IS_ERR(rt)) {
526 err = PTR_ERR(rt);
527 goto out;
528 }
529
530 memset(ifa, 0, sizeof(struct inet6_ifaddr));
531 ipv6_addr_copy(&ifa->addr, addr);
532
533 spin_lock_init(&ifa->lock);
534 init_timer(&ifa->timer);
535 ifa->timer.data = (unsigned long) ifa;
536 ifa->scope = scope;
537 ifa->prefix_len = pfxlen;
538 ifa->flags = flags | IFA_F_TENTATIVE;
539 ifa->cstamp = ifa->tstamp = jiffies;
540
541 ifa->idev = idev;
542 in6_dev_hold(idev);
543 /* For caller */
544 in6_ifa_hold(ifa);
545
546 /* Add to big hash table */
547 hash = ipv6_addr_hash(addr);
548
549 ifa->lst_next = inet6_addr_lst[hash];
550 inet6_addr_lst[hash] = ifa;
551 in6_ifa_hold(ifa);
552 write_unlock(&addrconf_hash_lock);
553
554 write_lock(&idev->lock);
555 /* Add to inet6_dev unicast addr list. */
556 ifa->if_next = idev->addr_list;
557 idev->addr_list = ifa;
558
559 #ifdef CONFIG_IPV6_PRIVACY
560 if (ifa->flags&IFA_F_TEMPORARY) {
561 ifa->tmp_next = idev->tempaddr_list;
562 idev->tempaddr_list = ifa;
563 in6_ifa_hold(ifa);
564 }
565 #endif
566
567 ifa->rt = rt;
568
569 in6_ifa_hold(ifa);
570 write_unlock(&idev->lock);
571 out2:
572 read_unlock_bh(&addrconf_lock);
573
574 if (likely(err == 0))
575 notifier_call_chain(&inet6addr_chain, NETDEV_UP, ifa);
576 else {
577 kfree(ifa);
578 ifa = ERR_PTR(err);
579 }
580
581 return ifa;
582 out:
583 write_unlock(&addrconf_hash_lock);
584 goto out2;
585 }
586
587 /* This function wants to get referenced ifp and releases it before return */
588
589 static void ipv6_del_addr(struct inet6_ifaddr *ifp)
590 {
591 struct inet6_ifaddr *ifa, **ifap;
592 struct inet6_dev *idev = ifp->idev;
593 int hash;
594 int deleted = 0, onlink = 0;
595 unsigned long expires = jiffies;
596
597 hash = ipv6_addr_hash(&ifp->addr);
598
599 ifp->dead = 1;
600
601 write_lock_bh(&addrconf_hash_lock);
602 for (ifap = &inet6_addr_lst[hash]; (ifa=*ifap) != NULL;
603 ifap = &ifa->lst_next) {
604 if (ifa == ifp) {
605 *ifap = ifa->lst_next;
606 __in6_ifa_put(ifp);
607 ifa->lst_next = NULL;
608 break;
609 }
610 }
611 write_unlock_bh(&addrconf_hash_lock);
612
613 write_lock_bh(&idev->lock);
614 #ifdef CONFIG_IPV6_PRIVACY
615 if (ifp->flags&IFA_F_TEMPORARY) {
616 for (ifap = &idev->tempaddr_list; (ifa=*ifap) != NULL;
617 ifap = &ifa->tmp_next) {
618 if (ifa == ifp) {
619 *ifap = ifa->tmp_next;
620 if (ifp->ifpub) {
621 in6_ifa_put(ifp->ifpub);
622 ifp->ifpub = NULL;
623 }
624 __in6_ifa_put(ifp);
625 ifa->tmp_next = NULL;
626 break;
627 }
628 }
629 }
630 #endif
631
632 for (ifap = &idev->addr_list; (ifa=*ifap) != NULL;
633 ifap = &ifa->if_next) {
634 if (ifa == ifp) {
635 *ifap = ifa->if_next;
636 __in6_ifa_put(ifp);
637 ifa->if_next = NULL;
638 if (!(ifp->flags & IFA_F_PERMANENT) || onlink > 0)
639 break;
640 deleted = 1;
641 } else if (ifp->flags & IFA_F_PERMANENT) {
642 if (ipv6_prefix_equal(&ifa->addr, &ifp->addr,
643 ifp->prefix_len)) {
644 if (ifa->flags & IFA_F_PERMANENT) {
645 onlink = 1;
646 if (deleted)
647 break;
648 } else {
649 unsigned long lifetime;
650
651 if (!onlink)
652 onlink = -1;
653
654 spin_lock(&ifa->lock);
655 lifetime = min_t(unsigned long,
656 ifa->valid_lft, 0x7fffffffUL/HZ);
657 if (time_before(expires,
658 ifa->tstamp + lifetime * HZ))
659 expires = ifa->tstamp + lifetime * HZ;
660 spin_unlock(&ifa->lock);
661 }
662 }
663 }
664 }
665 write_unlock_bh(&idev->lock);
666
667 ipv6_ifa_notify(RTM_DELADDR, ifp);
668
669 notifier_call_chain(&inet6addr_chain,NETDEV_DOWN,ifp);
670
671 addrconf_del_timer(ifp);
672
673 /*
674 * Purge or update corresponding prefix
675 *
676 * 1) we don't purge prefix here if address was not permanent.
677 * prefix is managed by its own lifetime.
678 * 2) if there're no addresses, delete prefix.
679 * 3) if there're still other permanent address(es),
680 * corresponding prefix is still permanent.
681 * 4) otherwise, update prefix lifetime to the
682 * longest valid lifetime among the corresponding
683 * addresses on the device.
684 * Note: subsequent RA will update lifetime.
685 *
686 * --yoshfuji
687 */
688 if ((ifp->flags & IFA_F_PERMANENT) && onlink < 1) {
689 struct in6_addr prefix;
690 struct rt6_info *rt;
691
692 ipv6_addr_prefix(&prefix, &ifp->addr, ifp->prefix_len);
693 rt = rt6_lookup(&prefix, NULL, ifp->idev->dev->ifindex, 1);
694
695 if (rt && ((rt->rt6i_flags & (RTF_GATEWAY | RTF_DEFAULT)) == 0)) {
696 if (onlink == 0) {
697 ip6_del_rt(rt, NULL, NULL);
698 rt = NULL;
699 } else if (!(rt->rt6i_flags & RTF_EXPIRES)) {
700 rt->rt6i_expires = expires;
701 rt->rt6i_flags |= RTF_EXPIRES;
702 }
703 }
704 dst_release(&rt->u.dst);
705 }
706
707 in6_ifa_put(ifp);
708 }
709
710 #ifdef CONFIG_IPV6_PRIVACY
711 static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, struct inet6_ifaddr *ift)
712 {
713 struct inet6_dev *idev = ifp->idev;
714 struct in6_addr addr, *tmpaddr;
715 unsigned long tmp_prefered_lft, tmp_valid_lft, tmp_cstamp, tmp_tstamp;
716 int tmp_plen;
717 int ret = 0;
718 int max_addresses;
719
720 write_lock(&idev->lock);
721 if (ift) {
722 spin_lock_bh(&ift->lock);
723 memcpy(&addr.s6_addr[8], &ift->addr.s6_addr[8], 8);
724 spin_unlock_bh(&ift->lock);
725 tmpaddr = &addr;
726 } else {
727 tmpaddr = NULL;
728 }
729 retry:
730 in6_dev_hold(idev);
731 if (idev->cnf.use_tempaddr <= 0) {
732 write_unlock(&idev->lock);
733 printk(KERN_INFO
734 "ipv6_create_tempaddr(): use_tempaddr is disabled.\n");
735 in6_dev_put(idev);
736 ret = -1;
737 goto out;
738 }
739 spin_lock_bh(&ifp->lock);
740 if (ifp->regen_count++ >= idev->cnf.regen_max_retry) {
741 idev->cnf.use_tempaddr = -1; /*XXX*/
742 spin_unlock_bh(&ifp->lock);
743 write_unlock(&idev->lock);
744 printk(KERN_WARNING
745 "ipv6_create_tempaddr(): regeneration time exceeded. disabled temporary address support.\n");
746 in6_dev_put(idev);
747 ret = -1;
748 goto out;
749 }
750 in6_ifa_hold(ifp);
751 memcpy(addr.s6_addr, ifp->addr.s6_addr, 8);
752 if (__ipv6_try_regen_rndid(idev, tmpaddr) < 0) {
753 spin_unlock_bh(&ifp->lock);
754 write_unlock(&idev->lock);
755 printk(KERN_WARNING
756 "ipv6_create_tempaddr(): regeneration of randomized interface id failed.\n");
757 in6_ifa_put(ifp);
758 in6_dev_put(idev);
759 ret = -1;
760 goto out;
761 }
762 memcpy(&addr.s6_addr[8], idev->rndid, 8);
763 tmp_valid_lft = min_t(__u32,
764 ifp->valid_lft,
765 idev->cnf.temp_valid_lft);
766 tmp_prefered_lft = min_t(__u32,
767 ifp->prefered_lft,
768 idev->cnf.temp_prefered_lft - desync_factor / HZ);
769 tmp_plen = ifp->prefix_len;
770 max_addresses = idev->cnf.max_addresses;
771 tmp_cstamp = ifp->cstamp;
772 tmp_tstamp = ifp->tstamp;
773 spin_unlock_bh(&ifp->lock);
774
775 write_unlock(&idev->lock);
776 ift = !max_addresses ||
777 ipv6_count_addresses(idev) < max_addresses ?
778 ipv6_add_addr(idev, &addr, tmp_plen,
779 ipv6_addr_type(&addr)&IPV6_ADDR_SCOPE_MASK, IFA_F_TEMPORARY) : NULL;
780 if (!ift || IS_ERR(ift)) {
781 in6_ifa_put(ifp);
782 in6_dev_put(idev);
783 printk(KERN_INFO
784 "ipv6_create_tempaddr(): retry temporary address regeneration.\n");
785 tmpaddr = &addr;
786 write_lock(&idev->lock);
787 goto retry;
788 }
789
790 spin_lock_bh(&ift->lock);
791 ift->ifpub = ifp;
792 ift->valid_lft = tmp_valid_lft;
793 ift->prefered_lft = tmp_prefered_lft;
794 ift->cstamp = tmp_cstamp;
795 ift->tstamp = tmp_tstamp;
796 spin_unlock_bh(&ift->lock);
797
798 addrconf_dad_start(ift, 0);
799 in6_ifa_put(ift);
800 in6_dev_put(idev);
801 out:
802 return ret;
803 }
804 #endif
805
806 /*
807 * Choose an appropriate source address
808 * should do:
809 * i) get an address with an appropriate scope
810 * ii) see if there is a specific route for the destination and use
811 * an address of the attached interface
812 * iii) don't use deprecated addresses
813 */
814 static int inline ipv6_saddr_pref(const struct inet6_ifaddr *ifp, u8 invpref)
815 {
816 int pref;
817 pref = ifp->flags&IFA_F_DEPRECATED ? 0 : 2;
818 #ifdef CONFIG_IPV6_PRIVACY
819 pref |= (ifp->flags^invpref)&IFA_F_TEMPORARY ? 0 : 1;
820 #endif
821 return pref;
822 }
823
824 #ifdef CONFIG_IPV6_PRIVACY
825 #define IPV6_GET_SADDR_MAXSCORE(score) ((score) == 3)
826 #else
827 #define IPV6_GET_SADDR_MAXSCORE(score) (score)
828 #endif
829
830 int ipv6_dev_get_saddr(struct net_device *dev,
831 struct in6_addr *daddr, struct in6_addr *saddr)
832 {
833 struct inet6_ifaddr *ifp = NULL;
834 struct inet6_ifaddr *match = NULL;
835 struct inet6_dev *idev;
836 int scope;
837 int err;
838 int hiscore = -1, score;
839
840 scope = ipv6_addr_scope(daddr);
841
842 /*
843 * known dev
844 * search dev and walk through dev addresses
845 */
846
847 if (dev) {
848 if (dev->flags & IFF_LOOPBACK)
849 scope = IFA_HOST;
850
851 read_lock(&addrconf_lock);
852 idev = __in6_dev_get(dev);
853 if (idev) {
854 read_lock_bh(&idev->lock);
855 for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) {
856 if (ifp->scope == scope) {
857 if (ifp->flags&IFA_F_TENTATIVE)
858 continue;
859 #ifdef CONFIG_IPV6_PRIVACY
860 score = ipv6_saddr_pref(ifp, idev->cnf.use_tempaddr > 1 ? IFA_F_TEMPORARY : 0);
861 #else
862 score = ipv6_saddr_pref(ifp, 0);
863 #endif
864 if (score <= hiscore)
865 continue;
866
867 if (match)
868 in6_ifa_put(match);
869 match = ifp;
870 hiscore = score;
871 in6_ifa_hold(ifp);
872
873 if (IPV6_GET_SADDR_MAXSCORE(score)) {
874 read_unlock_bh(&idev->lock);
875 read_unlock(&addrconf_lock);
876 goto out;
877 }
878 }
879 }
880 read_unlock_bh(&idev->lock);
881 }
882 read_unlock(&addrconf_lock);
883 }
884
885 if (scope == IFA_LINK)
886 goto out;
887
888 /*
889 * dev == NULL or search failed for specified dev
890 */
891
892 read_lock(&dev_base_lock);
893 read_lock(&addrconf_lock);
894 for (dev = dev_base; dev; dev=dev->next) {
895 idev = __in6_dev_get(dev);
896 if (idev) {
897 read_lock_bh(&idev->lock);
898 for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) {
899 if (ifp->scope == scope) {
900 if (ifp->flags&IFA_F_TENTATIVE)
901 continue;
902 #ifdef CONFIG_IPV6_PRIVACY
903 score = ipv6_saddr_pref(ifp, idev->cnf.use_tempaddr > 1 ? IFA_F_TEMPORARY : 0);
904 #else
905 score = ipv6_saddr_pref(ifp, 0);
906 #endif
907 if (score <= hiscore)
908 continue;
909
910 if (match)
911 in6_ifa_put(match);
912 match = ifp;
913 hiscore = score;
914 in6_ifa_hold(ifp);
915
916 if (IPV6_GET_SADDR_MAXSCORE(score)) {
917 read_unlock_bh(&idev->lock);
918 goto out_unlock_base;
919 }
920 }
921 }
922 read_unlock_bh(&idev->lock);
923 }
924 }
925
926 out_unlock_base:
927 read_unlock(&addrconf_lock);
928 read_unlock(&dev_base_lock);
929
930 out:
931 err = -EADDRNOTAVAIL;
932 if (match) {
933 ipv6_addr_copy(saddr, &match->addr);
934 err = 0;
935 in6_ifa_put(match);
936 }
937
938 return err;
939 }
940
941
942 int ipv6_get_saddr(struct dst_entry *dst,
943 struct in6_addr *daddr, struct in6_addr *saddr)
944 {
945 return ipv6_dev_get_saddr(dst ? ((struct rt6_info *)dst)->rt6i_idev->dev : NULL, daddr, saddr);
946 }
947
948
949 int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr)
950 {
951 struct inet6_dev *idev;
952 int err = -EADDRNOTAVAIL;
953
954 read_lock(&addrconf_lock);
955 if ((idev = __in6_dev_get(dev)) != NULL) {
956 struct inet6_ifaddr *ifp;
957
958 read_lock_bh(&idev->lock);
959 for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) {
960 if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
961 ipv6_addr_copy(addr, &ifp->addr);
962 err = 0;
963 break;
964 }
965 }
966 read_unlock_bh(&idev->lock);
967 }
968 read_unlock(&addrconf_lock);
969 return err;
970 }
971
972 static int ipv6_count_addresses(struct inet6_dev *idev)
973 {
974 int cnt = 0;
975 struct inet6_ifaddr *ifp;
976
977 read_lock_bh(&idev->lock);
978 for (ifp=idev->addr_list; ifp; ifp=ifp->if_next)
979 cnt++;
980 read_unlock_bh(&idev->lock);
981 return cnt;
982 }
983
984 int ipv6_chk_addr(struct in6_addr *addr, struct net_device *dev, int strict)
985 {
986 struct inet6_ifaddr * ifp;
987 u8 hash = ipv6_addr_hash(addr);
988
989 read_lock_bh(&addrconf_hash_lock);
990 for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) {
991 if (ipv6_addr_equal(&ifp->addr, addr) &&
992 !(ifp->flags&IFA_F_TENTATIVE)) {
993 if (dev == NULL || ifp->idev->dev == dev ||
994 !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))
995 break;
996 }
997 }
998 read_unlock_bh(&addrconf_hash_lock);
999 return ifp != NULL;
1000 }
1001
1002 static
1003 int ipv6_chk_same_addr(const struct in6_addr *addr, struct net_device *dev)
1004 {
1005 struct inet6_ifaddr * ifp;
1006 u8 hash = ipv6_addr_hash(addr);
1007
1008 for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) {
1009 if (ipv6_addr_equal(&ifp->addr, addr)) {
1010 if (dev == NULL || ifp->idev->dev == dev)
1011 break;
1012 }
1013 }
1014 return ifp != NULL;
1015 }
1016
1017 struct inet6_ifaddr * ipv6_get_ifaddr(struct in6_addr *addr, struct net_device *dev, int strict)
1018 {
1019 struct inet6_ifaddr * ifp;
1020 u8 hash = ipv6_addr_hash(addr);
1021
1022 read_lock_bh(&addrconf_hash_lock);
1023 for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) {
1024 if (ipv6_addr_equal(&ifp->addr, addr)) {
1025 if (dev == NULL || ifp->idev->dev == dev ||
1026 !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
1027 in6_ifa_hold(ifp);
1028 break;
1029 }
1030 }
1031 }
1032 read_unlock_bh(&addrconf_hash_lock);
1033
1034 return ifp;
1035 }
1036
1037 int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2)
1038 {
1039 const struct in6_addr *sk_rcv_saddr6 = &inet6_sk(sk)->rcv_saddr;
1040 const struct in6_addr *sk2_rcv_saddr6 = tcp_v6_rcv_saddr(sk2);
1041 u32 sk_rcv_saddr = inet_sk(sk)->rcv_saddr;
1042 u32 sk2_rcv_saddr = tcp_v4_rcv_saddr(sk2);
1043 int sk_ipv6only = ipv6_only_sock(sk);
1044 int sk2_ipv6only = tcp_v6_ipv6only(sk2);
1045 int addr_type = ipv6_addr_type(sk_rcv_saddr6);
1046 int addr_type2 = sk2_rcv_saddr6 ? ipv6_addr_type(sk2_rcv_saddr6) : IPV6_ADDR_MAPPED;
1047
1048 if (!sk2_rcv_saddr && !sk_ipv6only)
1049 return 1;
1050
1051 if (addr_type2 == IPV6_ADDR_ANY &&
1052 !(sk2_ipv6only && addr_type == IPV6_ADDR_MAPPED))
1053 return 1;
1054
1055 if (addr_type == IPV6_ADDR_ANY &&
1056 !(sk_ipv6only && addr_type2 == IPV6_ADDR_MAPPED))
1057 return 1;
1058
1059 if (sk2_rcv_saddr6 &&
1060 ipv6_addr_equal(sk_rcv_saddr6, sk2_rcv_saddr6))
1061 return 1;
1062
1063 if (addr_type == IPV6_ADDR_MAPPED &&
1064 !sk2_ipv6only &&
1065 (!sk2_rcv_saddr || !sk_rcv_saddr || sk_rcv_saddr == sk2_rcv_saddr))
1066 return 1;
1067
1068 return 0;
1069 }
1070
1071 /* Gets referenced address, destroys ifaddr */
1072
1073 void addrconf_dad_failure(struct inet6_ifaddr *ifp)
1074 {
1075 if (net_ratelimit())
1076 printk(KERN_INFO "%s: duplicate address detected!\n", ifp->idev->dev->name);
1077 if (ifp->flags&IFA_F_PERMANENT) {
1078 spin_lock_bh(&ifp->lock);
1079 addrconf_del_timer(ifp);
1080 ifp->flags |= IFA_F_TENTATIVE;
1081 spin_unlock_bh(&ifp->lock);
1082 in6_ifa_put(ifp);
1083 #ifdef CONFIG_IPV6_PRIVACY
1084 } else if (ifp->flags&IFA_F_TEMPORARY) {
1085 struct inet6_ifaddr *ifpub;
1086 spin_lock_bh(&ifp->lock);
1087 ifpub = ifp->ifpub;
1088 if (ifpub) {
1089 in6_ifa_hold(ifpub);
1090 spin_unlock_bh(&ifp->lock);
1091 ipv6_create_tempaddr(ifpub, ifp);
1092 in6_ifa_put(ifpub);
1093 } else {
1094 spin_unlock_bh(&ifp->lock);
1095 }
1096 ipv6_del_addr(ifp);
1097 #endif
1098 } else
1099 ipv6_del_addr(ifp);
1100 }
1101
1102
1103 /* Join to solicited addr multicast group. */
1104
1105 void addrconf_join_solict(struct net_device *dev, struct in6_addr *addr)
1106 {
1107 struct in6_addr maddr;
1108
1109 if (dev->flags&(IFF_LOOPBACK|IFF_NOARP))
1110 return;
1111
1112 addrconf_addr_solict_mult(addr, &maddr);
1113 ipv6_dev_mc_inc(dev, &maddr);
1114 }
1115
1116 void addrconf_leave_solict(struct inet6_dev *idev, struct in6_addr *addr)
1117 {
1118 struct in6_addr maddr;
1119
1120 if (idev->dev->flags&(IFF_LOOPBACK|IFF_NOARP))
1121 return;
1122
1123 addrconf_addr_solict_mult(addr, &maddr);
1124 __ipv6_dev_mc_dec(idev, &maddr);
1125 }
1126
1127 void addrconf_join_anycast(struct inet6_ifaddr *ifp)
1128 {
1129 struct in6_addr addr;
1130 ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
1131 if (ipv6_addr_any(&addr))
1132 return;
1133 ipv6_dev_ac_inc(ifp->idev->dev, &addr);
1134 }
1135
1136 void addrconf_leave_anycast(struct inet6_ifaddr *ifp)
1137 {
1138 struct in6_addr addr;
1139 ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
1140 if (ipv6_addr_any(&addr))
1141 return;
1142 __ipv6_dev_ac_dec(ifp->idev, &addr);
1143 }
1144
1145 static int ipv6_generate_eui64(u8 *eui, struct net_device *dev)
1146 {
1147 switch (dev->type) {
1148 case ARPHRD_ETHER:
1149 case ARPHRD_FDDI:
1150 case ARPHRD_IEEE802_TR:
1151 if (dev->addr_len != ETH_ALEN)
1152 return -1;
1153 memcpy(eui, dev->dev_addr, 3);
1154 memcpy(eui + 5, dev->dev_addr + 3, 3);
1155
1156 /*
1157 * The zSeries OSA network cards can be shared among various
1158 * OS instances, but the OSA cards have only one MAC address.
1159 * This leads to duplicate address conflicts in conjunction
1160 * with IPv6 if more than one instance uses the same card.
1161 *
1162 * The driver for these cards can deliver a unique 16-bit
1163 * identifier for each instance sharing the same card. It is
1164 * placed instead of 0xFFFE in the interface identifier. The
1165 * "u" bit of the interface identifier is not inverted in this
1166 * case. Hence the resulting interface identifier has local
1167 * scope according to RFC2373.
1168 */
1169 if (dev->dev_id) {
1170 eui[3] = (dev->dev_id >> 8) & 0xFF;
1171 eui[4] = dev->dev_id & 0xFF;
1172 } else {
1173 eui[3] = 0xFF;
1174 eui[4] = 0xFE;
1175 eui[0] ^= 2;
1176 }
1177 return 0;
1178 case ARPHRD_ARCNET:
1179 /* XXX: inherit EUI-64 from other interface -- yoshfuji */
1180 if (dev->addr_len != ARCNET_ALEN)
1181 return -1;
1182 memset(eui, 0, 7);
1183 eui[7] = *(u8*)dev->dev_addr;
1184 return 0;
1185 case ARPHRD_INFINIBAND:
1186 if (dev->addr_len != INFINIBAND_ALEN)
1187 return -1;
1188 memcpy(eui, dev->dev_addr + 12, 8);
1189 eui[0] |= 2;
1190 return 0;
1191 }
1192 return -1;
1193 }
1194
1195 static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev)
1196 {
1197 int err = -1;
1198 struct inet6_ifaddr *ifp;
1199
1200 read_lock_bh(&idev->lock);
1201 for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) {
1202 if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
1203 memcpy(eui, ifp->addr.s6_addr+8, 8);
1204 err = 0;
1205 break;
1206 }
1207 }
1208 read_unlock_bh(&idev->lock);
1209 return err;
1210 }
1211
1212 #ifdef CONFIG_IPV6_PRIVACY
1213 /* (re)generation of randomized interface identifier (RFC 3041 3.2, 3.5) */
1214 static int __ipv6_regen_rndid(struct inet6_dev *idev)
1215 {
1216 struct net_device *dev;
1217 struct scatterlist sg[2];
1218
1219 sg[0].page = virt_to_page(idev->entropy);
1220 sg[0].offset = offset_in_page(idev->entropy);
1221 sg[0].length = 8;
1222 sg[1].page = virt_to_page(idev->work_eui64);
1223 sg[1].offset = offset_in_page(idev->work_eui64);
1224 sg[1].length = 8;
1225
1226 dev = idev->dev;
1227
1228 if (ipv6_generate_eui64(idev->work_eui64, dev)) {
1229 printk(KERN_INFO
1230 "__ipv6_regen_rndid(idev=%p): cannot get EUI64 identifier; use random bytes.\n",
1231 idev);
1232 get_random_bytes(idev->work_eui64, sizeof(idev->work_eui64));
1233 }
1234 regen:
1235 spin_lock(&md5_tfm_lock);
1236 if (unlikely(md5_tfm == NULL)) {
1237 spin_unlock(&md5_tfm_lock);
1238 return -1;
1239 }
1240 crypto_digest_init(md5_tfm);
1241 crypto_digest_update(md5_tfm, sg, 2);
1242 crypto_digest_final(md5_tfm, idev->work_digest);
1243 spin_unlock(&md5_tfm_lock);
1244
1245 memcpy(idev->rndid, &idev->work_digest[0], 8);
1246 idev->rndid[0] &= ~0x02;
1247 memcpy(idev->entropy, &idev->work_digest[8], 8);
1248
1249 /*
1250 * <draft-ietf-ipngwg-temp-addresses-v2-00.txt>:
1251 * check if generated address is not inappropriate
1252 *
1253 * - Reserved subnet anycast (RFC 2526)
1254 * 11111101 11....11 1xxxxxxx
1255 * - ISATAP (draft-ietf-ngtrans-isatap-13.txt) 5.1
1256 * 00-00-5E-FE-xx-xx-xx-xx
1257 * - value 0
1258 * - XXX: already assigned to an address on the device
1259 */
1260 if (idev->rndid[0] == 0xfd &&
1261 (idev->rndid[1]&idev->rndid[2]&idev->rndid[3]&idev->rndid[4]&idev->rndid[5]&idev->rndid[6]) == 0xff &&
1262 (idev->rndid[7]&0x80))
1263 goto regen;
1264 if ((idev->rndid[0]|idev->rndid[1]) == 0) {
1265 if (idev->rndid[2] == 0x5e && idev->rndid[3] == 0xfe)
1266 goto regen;
1267 if ((idev->rndid[2]|idev->rndid[3]|idev->rndid[4]|idev->rndid[5]|idev->rndid[6]|idev->rndid[7]) == 0x00)
1268 goto regen;
1269 }
1270
1271 return 0;
1272 }
1273
1274 static void ipv6_regen_rndid(unsigned long data)
1275 {
1276 struct inet6_dev *idev = (struct inet6_dev *) data;
1277 unsigned long expires;
1278
1279 read_lock_bh(&addrconf_lock);
1280 write_lock_bh(&idev->lock);
1281
1282 if (idev->dead)
1283 goto out;
1284
1285 if (__ipv6_regen_rndid(idev) < 0)
1286 goto out;
1287
1288 expires = jiffies +
1289 idev->cnf.temp_prefered_lft * HZ -
1290 idev->cnf.regen_max_retry * idev->cnf.dad_transmits * idev->nd_parms->retrans_time - desync_factor;
1291 if (time_before(expires, jiffies)) {
1292 printk(KERN_WARNING
1293 "ipv6_regen_rndid(): too short regeneration interval; timer disabled for %s.\n",
1294 idev->dev->name);
1295 goto out;
1296 }
1297
1298 if (!mod_timer(&idev->regen_timer, expires))
1299 in6_dev_hold(idev);
1300
1301 out:
1302 write_unlock_bh(&idev->lock);
1303 read_unlock_bh(&addrconf_lock);
1304 in6_dev_put(idev);
1305 }
1306
1307 static int __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr) {
1308 int ret = 0;
1309
1310 if (tmpaddr && memcmp(idev->rndid, &tmpaddr->s6_addr[8], 8) == 0)
1311 ret = __ipv6_regen_rndid(idev);
1312 return ret;
1313 }
1314 #endif
1315
1316 /*
1317 * Add prefix route.
1318 */
1319
1320 static void
1321 addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev,
1322 unsigned long expires, unsigned flags)
1323 {
1324 struct in6_rtmsg rtmsg;
1325
1326 memset(&rtmsg, 0, sizeof(rtmsg));
1327 ipv6_addr_copy(&rtmsg.rtmsg_dst, pfx);
1328 rtmsg.rtmsg_dst_len = plen;
1329 rtmsg.rtmsg_metric = IP6_RT_PRIO_ADDRCONF;
1330 rtmsg.rtmsg_ifindex = dev->ifindex;
1331 rtmsg.rtmsg_info = expires;
1332 rtmsg.rtmsg_flags = RTF_UP|flags;
1333 rtmsg.rtmsg_type = RTMSG_NEWROUTE;
1334
1335 /* Prevent useless cloning on PtP SIT.
1336 This thing is done here expecting that the whole
1337 class of non-broadcast devices need not cloning.
1338 */
1339 if (dev->type == ARPHRD_SIT && (dev->flags&IFF_POINTOPOINT))
1340 rtmsg.rtmsg_flags |= RTF_NONEXTHOP;
1341
1342 ip6_route_add(&rtmsg, NULL, NULL);
1343 }
1344
1345 /* Create "default" multicast route to the interface */
1346
1347 static void addrconf_add_mroute(struct net_device *dev)
1348 {
1349 struct in6_rtmsg rtmsg;
1350
1351 memset(&rtmsg, 0, sizeof(rtmsg));
1352 ipv6_addr_set(&rtmsg.rtmsg_dst,
1353 htonl(0xFF000000), 0, 0, 0);
1354 rtmsg.rtmsg_dst_len = 8;
1355 rtmsg.rtmsg_metric = IP6_RT_PRIO_ADDRCONF;
1356 rtmsg.rtmsg_ifindex = dev->ifindex;
1357 rtmsg.rtmsg_flags = RTF_UP;
1358 rtmsg.rtmsg_type = RTMSG_NEWROUTE;
1359 ip6_route_add(&rtmsg, NULL, NULL);
1360 }
1361
1362 static void sit_route_add(struct net_device *dev)
1363 {
1364 struct in6_rtmsg rtmsg;
1365
1366 memset(&rtmsg, 0, sizeof(rtmsg));
1367
1368 rtmsg.rtmsg_type = RTMSG_NEWROUTE;
1369 rtmsg.rtmsg_metric = IP6_RT_PRIO_ADDRCONF;
1370
1371 /* prefix length - 96 bits "::d.d.d.d" */
1372 rtmsg.rtmsg_dst_len = 96;
1373 rtmsg.rtmsg_flags = RTF_UP|RTF_NONEXTHOP;
1374 rtmsg.rtmsg_ifindex = dev->ifindex;
1375
1376 ip6_route_add(&rtmsg, NULL, NULL);
1377 }
1378
1379 static void addrconf_add_lroute(struct net_device *dev)
1380 {
1381 struct in6_addr addr;
1382
1383 ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0);
1384 addrconf_prefix_route(&addr, 64, dev, 0, 0);
1385 }
1386
1387 static struct inet6_dev *addrconf_add_dev(struct net_device *dev)
1388 {
1389 struct inet6_dev *idev;
1390
1391 ASSERT_RTNL();
1392
1393 if ((idev = ipv6_find_idev(dev)) == NULL)
1394 return NULL;
1395
1396 /* Add default multicast route */
1397 addrconf_add_mroute(dev);
1398
1399 /* Add link local route */
1400 addrconf_add_lroute(dev);
1401 return idev;
1402 }
1403
1404 void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len)
1405 {
1406 struct prefix_info *pinfo;
1407 __u32 valid_lft;
1408 __u32 prefered_lft;
1409 int addr_type;
1410 unsigned long rt_expires;
1411 struct inet6_dev *in6_dev;
1412
1413 pinfo = (struct prefix_info *) opt;
1414
1415 if (len < sizeof(struct prefix_info)) {
1416 ADBG(("addrconf: prefix option too short\n"));
1417 return;
1418 }
1419
1420 /*
1421 * Validation checks ([ADDRCONF], page 19)
1422 */
1423
1424 addr_type = ipv6_addr_type(&pinfo->prefix);
1425
1426 if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL))
1427 return;
1428
1429 valid_lft = ntohl(pinfo->valid);
1430 prefered_lft = ntohl(pinfo->prefered);
1431
1432 if (prefered_lft > valid_lft) {
1433 if (net_ratelimit())
1434 printk(KERN_WARNING "addrconf: prefix option has invalid lifetime\n");
1435 return;
1436 }
1437
1438 in6_dev = in6_dev_get(dev);
1439
1440 if (in6_dev == NULL) {
1441 if (net_ratelimit())
1442 printk(KERN_DEBUG "addrconf: device %s not configured\n", dev->name);
1443 return;
1444 }
1445
1446 /*
1447 * Two things going on here:
1448 * 1) Add routes for on-link prefixes
1449 * 2) Configure prefixes with the auto flag set
1450 */
1451
1452 /* Avoid arithmetic overflow. Really, we could
1453 save rt_expires in seconds, likely valid_lft,
1454 but it would require division in fib gc, that it
1455 not good.
1456 */
1457 if (valid_lft >= 0x7FFFFFFF/HZ)
1458 rt_expires = 0;
1459 else
1460 rt_expires = jiffies + valid_lft * HZ;
1461
1462 if (pinfo->onlink) {
1463 struct rt6_info *rt;
1464 rt = rt6_lookup(&pinfo->prefix, NULL, dev->ifindex, 1);
1465
1466 if (rt && ((rt->rt6i_flags & (RTF_GATEWAY | RTF_DEFAULT)) == 0)) {
1467 if (rt->rt6i_flags&RTF_EXPIRES) {
1468 if (valid_lft == 0) {
1469 ip6_del_rt(rt, NULL, NULL);
1470 rt = NULL;
1471 } else {
1472 rt->rt6i_expires = rt_expires;
1473 }
1474 }
1475 } else if (valid_lft) {
1476 addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
1477 dev, rt_expires, RTF_ADDRCONF|RTF_EXPIRES|RTF_PREFIX_RT);
1478 }
1479 if (rt)
1480 dst_release(&rt->u.dst);
1481 }
1482
1483 /* Try to figure out our local address for this prefix */
1484
1485 if (pinfo->autoconf && in6_dev->cnf.autoconf) {
1486 struct inet6_ifaddr * ifp;
1487 struct in6_addr addr;
1488 int create = 0, update_lft = 0;
1489
1490 if (pinfo->prefix_len == 64) {
1491 memcpy(&addr, &pinfo->prefix, 8);
1492 if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
1493 ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
1494 in6_dev_put(in6_dev);
1495 return;
1496 }
1497 goto ok;
1498 }
1499 if (net_ratelimit())
1500 printk(KERN_DEBUG "IPv6 addrconf: prefix with wrong length %d\n",
1501 pinfo->prefix_len);
1502 in6_dev_put(in6_dev);
1503 return;
1504
1505 ok:
1506
1507 ifp = ipv6_get_ifaddr(&addr, dev, 1);
1508
1509 if (ifp == NULL && valid_lft) {
1510 int max_addresses = in6_dev->cnf.max_addresses;
1511
1512 /* Do not allow to create too much of autoconfigured
1513 * addresses; this would be too easy way to crash kernel.
1514 */
1515 if (!max_addresses ||
1516 ipv6_count_addresses(in6_dev) < max_addresses)
1517 ifp = ipv6_add_addr(in6_dev, &addr, pinfo->prefix_len,
1518 addr_type&IPV6_ADDR_SCOPE_MASK, 0);
1519
1520 if (!ifp || IS_ERR(ifp)) {
1521 in6_dev_put(in6_dev);
1522 return;
1523 }
1524
1525 update_lft = create = 1;
1526 ifp->cstamp = jiffies;
1527 addrconf_dad_start(ifp, RTF_ADDRCONF|RTF_PREFIX_RT);
1528 }
1529
1530 if (ifp) {
1531 int flags;
1532 unsigned long now;
1533 #ifdef CONFIG_IPV6_PRIVACY
1534 struct inet6_ifaddr *ift;
1535 #endif
1536 u32 stored_lft;
1537
1538 /* update lifetime (RFC2462 5.5.3 e) */
1539 spin_lock(&ifp->lock);
1540 now = jiffies;
1541 if (ifp->valid_lft > (now - ifp->tstamp) / HZ)
1542 stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ;
1543 else
1544 stored_lft = 0;
1545 if (!update_lft && stored_lft) {
1546 if (valid_lft > MIN_VALID_LIFETIME ||
1547 valid_lft > stored_lft)
1548 update_lft = 1;
1549 else if (stored_lft <= MIN_VALID_LIFETIME) {
1550 /* valid_lft <= stored_lft is always true */
1551 /* XXX: IPsec */
1552 update_lft = 0;
1553 } else {
1554 valid_lft = MIN_VALID_LIFETIME;
1555 if (valid_lft < prefered_lft)
1556 prefered_lft = valid_lft;
1557 update_lft = 1;
1558 }
1559 }
1560
1561 if (update_lft) {
1562 ifp->valid_lft = valid_lft;
1563 ifp->prefered_lft = prefered_lft;
1564 ifp->tstamp = now;
1565 flags = ifp->flags;
1566 ifp->flags &= ~IFA_F_DEPRECATED;
1567 spin_unlock(&ifp->lock);
1568
1569 if (!(flags&IFA_F_TENTATIVE))
1570 ipv6_ifa_notify(0, ifp);
1571 } else
1572 spin_unlock(&ifp->lock);
1573
1574 #ifdef CONFIG_IPV6_PRIVACY
1575 read_lock_bh(&in6_dev->lock);
1576 /* update all temporary addresses in the list */
1577 for (ift=in6_dev->tempaddr_list; ift; ift=ift->tmp_next) {
1578 /*
1579 * When adjusting the lifetimes of an existing
1580 * temporary address, only lower the lifetimes.
1581 * Implementations must not increase the
1582 * lifetimes of an existing temporary address
1583 * when processing a Prefix Information Option.
1584 */
1585 spin_lock(&ift->lock);
1586 flags = ift->flags;
1587 if (ift->valid_lft > valid_lft &&
1588 ift->valid_lft - valid_lft > (jiffies - ift->tstamp) / HZ)
1589 ift->valid_lft = valid_lft + (jiffies - ift->tstamp) / HZ;
1590 if (ift->prefered_lft > prefered_lft &&
1591 ift->prefered_lft - prefered_lft > (jiffies - ift->tstamp) / HZ)
1592 ift->prefered_lft = prefered_lft + (jiffies - ift->tstamp) / HZ;
1593 spin_unlock(&ift->lock);
1594 if (!(flags&IFA_F_TENTATIVE))
1595 ipv6_ifa_notify(0, ift);
1596 }
1597
1598 if (create && in6_dev->cnf.use_tempaddr > 0) {
1599 /*
1600 * When a new public address is created as described in [ADDRCONF],
1601 * also create a new temporary address.
1602 */
1603 read_unlock_bh(&in6_dev->lock);
1604 ipv6_create_tempaddr(ifp, NULL);
1605 } else {
1606 read_unlock_bh(&in6_dev->lock);
1607 }
1608 #endif
1609 in6_ifa_put(ifp);
1610 addrconf_verify(0);
1611 }
1612 }
1613 inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo);
1614 in6_dev_put(in6_dev);
1615 }
1616
1617 /*
1618 * Set destination address.
1619 * Special case for SIT interfaces where we create a new "virtual"
1620 * device.
1621 */
1622 int addrconf_set_dstaddr(void __user *arg)
1623 {
1624 struct in6_ifreq ireq;
1625 struct net_device *dev;
1626 int err = -EINVAL;
1627
1628 rtnl_lock();
1629
1630 err = -EFAULT;
1631 if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
1632 goto err_exit;
1633
1634 dev = __dev_get_by_index(ireq.ifr6_ifindex);
1635
1636 err = -ENODEV;
1637 if (dev == NULL)
1638 goto err_exit;
1639
1640 if (dev->type == ARPHRD_SIT) {
1641 struct ifreq ifr;
1642 mm_segment_t oldfs;
1643 struct ip_tunnel_parm p;
1644
1645 err = -EADDRNOTAVAIL;
1646 if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4))
1647 goto err_exit;
1648
1649 memset(&p, 0, sizeof(p));
1650 p.iph.daddr = ireq.ifr6_addr.s6_addr32[3];
1651 p.iph.saddr = 0;
1652 p.iph.version = 4;
1653 p.iph.ihl = 5;
1654 p.iph.protocol = IPPROTO_IPV6;
1655 p.iph.ttl = 64;
1656 ifr.ifr_ifru.ifru_data = (void __user *)&p;
1657
1658 oldfs = get_fs(); set_fs(KERNEL_DS);
1659 err = dev->do_ioctl(dev, &ifr, SIOCADDTUNNEL);
1660 set_fs(oldfs);
1661
1662 if (err == 0) {
1663 err = -ENOBUFS;
1664 if ((dev = __dev_get_by_name(p.name)) == NULL)
1665 goto err_exit;
1666 err = dev_open(dev);
1667 }
1668 }
1669
1670 err_exit:
1671 rtnl_unlock();
1672 return err;
1673 }
1674
1675 /*
1676 * Manual configuration of address on an interface
1677 */
1678 static int inet6_addr_add(int ifindex, struct in6_addr *pfx, int plen)
1679 {
1680 struct inet6_ifaddr *ifp;
1681 struct inet6_dev *idev;
1682 struct net_device *dev;
1683 int scope;
1684
1685 ASSERT_RTNL();
1686
1687 if ((dev = __dev_get_by_index(ifindex)) == NULL)
1688 return -ENODEV;
1689
1690 if (!(dev->flags&IFF_UP))
1691 return -ENETDOWN;
1692
1693 if ((idev = addrconf_add_dev(dev)) == NULL)
1694 return -ENOBUFS;
1695
1696 scope = ipv6_addr_scope(pfx);
1697
1698 ifp = ipv6_add_addr(idev, pfx, plen, scope, IFA_F_PERMANENT);
1699 if (!IS_ERR(ifp)) {
1700 addrconf_dad_start(ifp, 0);
1701 in6_ifa_put(ifp);
1702 return 0;
1703 }
1704
1705 return PTR_ERR(ifp);
1706 }
1707
1708 static int inet6_addr_del(int ifindex, struct in6_addr *pfx, int plen)
1709 {
1710 struct inet6_ifaddr *ifp;
1711 struct inet6_dev *idev;
1712 struct net_device *dev;
1713
1714 if ((dev = __dev_get_by_index(ifindex)) == NULL)
1715 return -ENODEV;
1716
1717 if ((idev = __in6_dev_get(dev)) == NULL)
1718 return -ENXIO;
1719
1720 read_lock_bh(&idev->lock);
1721 for (ifp = idev->addr_list; ifp; ifp=ifp->if_next) {
1722 if (ifp->prefix_len == plen &&
1723 ipv6_addr_equal(pfx, &ifp->addr)) {
1724 in6_ifa_hold(ifp);
1725 read_unlock_bh(&idev->lock);
1726
1727 ipv6_del_addr(ifp);
1728
1729 /* If the last address is deleted administratively,
1730 disable IPv6 on this interface.
1731 */
1732 if (idev->addr_list == NULL)
1733 addrconf_ifdown(idev->dev, 1);
1734 return 0;
1735 }
1736 }
1737 read_unlock_bh(&idev->lock);
1738 return -EADDRNOTAVAIL;
1739 }
1740
1741
1742 int addrconf_add_ifaddr(void __user *arg)
1743 {
1744 struct in6_ifreq ireq;
1745 int err;
1746
1747 if (!capable(CAP_NET_ADMIN))
1748 return -EPERM;
1749
1750 if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
1751 return -EFAULT;
1752
1753 rtnl_lock();
1754 err = inet6_addr_add(ireq.ifr6_ifindex, &ireq.ifr6_addr, ireq.ifr6_prefixlen);
1755 rtnl_unlock();
1756 return err;
1757 }
1758
1759 int addrconf_del_ifaddr(void __user *arg)
1760 {
1761 struct in6_ifreq ireq;
1762 int err;
1763
1764 if (!capable(CAP_NET_ADMIN))
1765 return -EPERM;
1766
1767 if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
1768 return -EFAULT;
1769
1770 rtnl_lock();
1771 err = inet6_addr_del(ireq.ifr6_ifindex, &ireq.ifr6_addr, ireq.ifr6_prefixlen);
1772 rtnl_unlock();
1773 return err;
1774 }
1775
1776 static void sit_add_v4_addrs(struct inet6_dev *idev)
1777 {
1778 struct inet6_ifaddr * ifp;
1779 struct in6_addr addr;
1780 struct net_device *dev;
1781 int scope;
1782
1783 ASSERT_RTNL();
1784
1785 memset(&addr, 0, sizeof(struct in6_addr));
1786 memcpy(&addr.s6_addr32[3], idev->dev->dev_addr, 4);
1787
1788 if (idev->dev->flags&IFF_POINTOPOINT) {
1789 addr.s6_addr32[0] = htonl(0xfe800000);
1790 scope = IFA_LINK;
1791 } else {
1792 scope = IPV6_ADDR_COMPATv4;
1793 }
1794
1795 if (addr.s6_addr32[3]) {
1796 ifp = ipv6_add_addr(idev, &addr, 128, scope, IFA_F_PERMANENT);
1797 if (!IS_ERR(ifp)) {
1798 spin_lock_bh(&ifp->lock);
1799 ifp->flags &= ~IFA_F_TENTATIVE;
1800 spin_unlock_bh(&ifp->lock);
1801 ipv6_ifa_notify(RTM_NEWADDR, ifp);
1802 in6_ifa_put(ifp);
1803 }
1804 return;
1805 }
1806
1807 for (dev = dev_base; dev != NULL; dev = dev->next) {
1808 struct in_device * in_dev = __in_dev_get(dev);
1809 if (in_dev && (dev->flags & IFF_UP)) {
1810 struct in_ifaddr * ifa;
1811
1812 int flag = scope;
1813
1814 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1815 int plen;
1816
1817 addr.s6_addr32[3] = ifa->ifa_local;
1818
1819 if (ifa->ifa_scope == RT_SCOPE_LINK)
1820 continue;
1821 if (ifa->ifa_scope >= RT_SCOPE_HOST) {
1822 if (idev->dev->flags&IFF_POINTOPOINT)
1823 continue;
1824 flag |= IFA_HOST;
1825 }
1826 if (idev->dev->flags&IFF_POINTOPOINT)
1827 plen = 64;
1828 else
1829 plen = 96;
1830
1831 ifp = ipv6_add_addr(idev, &addr, plen, flag,
1832 IFA_F_PERMANENT);
1833 if (!IS_ERR(ifp)) {
1834 spin_lock_bh(&ifp->lock);
1835 ifp->flags &= ~IFA_F_TENTATIVE;
1836 spin_unlock_bh(&ifp->lock);
1837 ipv6_ifa_notify(RTM_NEWADDR, ifp);
1838 in6_ifa_put(ifp);
1839 }
1840 }
1841 }
1842 }
1843 }
1844
1845 static void init_loopback(struct net_device *dev)
1846 {
1847 struct inet6_dev *idev;
1848 struct inet6_ifaddr * ifp;
1849
1850 /* ::1 */
1851
1852 ASSERT_RTNL();
1853
1854 if ((idev = ipv6_find_idev(dev)) == NULL) {
1855 printk(KERN_DEBUG "init loopback: add_dev failed\n");
1856 return;
1857 }
1858
1859 ifp = ipv6_add_addr(idev, &in6addr_loopback, 128, IFA_HOST, IFA_F_PERMANENT);
1860 if (!IS_ERR(ifp)) {
1861 spin_lock_bh(&ifp->lock);
1862 ifp->flags &= ~IFA_F_TENTATIVE;
1863 spin_unlock_bh(&ifp->lock);
1864 ipv6_ifa_notify(RTM_NEWADDR, ifp);
1865 in6_ifa_put(ifp);
1866 }
1867 }
1868
1869 static void addrconf_add_linklocal(struct inet6_dev *idev, struct in6_addr *addr)
1870 {
1871 struct inet6_ifaddr * ifp;
1872
1873 ifp = ipv6_add_addr(idev, addr, 64, IFA_LINK, IFA_F_PERMANENT);
1874 if (!IS_ERR(ifp)) {
1875 addrconf_dad_start(ifp, 0);
1876 in6_ifa_put(ifp);
1877 }
1878 }
1879
1880 static void addrconf_dev_config(struct net_device *dev)
1881 {
1882 struct in6_addr addr;
1883 struct inet6_dev * idev;
1884
1885 ASSERT_RTNL();
1886
1887 if ((dev->type != ARPHRD_ETHER) &&
1888 (dev->type != ARPHRD_FDDI) &&
1889 (dev->type != ARPHRD_IEEE802_TR) &&
1890 (dev->type != ARPHRD_ARCNET) &&
1891 (dev->type != ARPHRD_INFINIBAND)) {
1892 /* Alas, we support only Ethernet autoconfiguration. */
1893 return;
1894 }
1895
1896 idev = addrconf_add_dev(dev);
1897 if (idev == NULL)
1898 return;
1899
1900 memset(&addr, 0, sizeof(struct in6_addr));
1901 addr.s6_addr32[0] = htonl(0xFE800000);
1902
1903 if (ipv6_generate_eui64(addr.s6_addr + 8, dev) == 0)
1904 addrconf_add_linklocal(idev, &addr);
1905 }
1906
1907 static void addrconf_sit_config(struct net_device *dev)
1908 {
1909 struct inet6_dev *idev;
1910
1911 ASSERT_RTNL();
1912
1913 /*
1914 * Configure the tunnel with one of our IPv4
1915 * addresses... we should configure all of
1916 * our v4 addrs in the tunnel
1917 */
1918
1919 if ((idev = ipv6_find_idev(dev)) == NULL) {
1920 printk(KERN_DEBUG "init sit: add_dev failed\n");
1921 return;
1922 }
1923
1924 sit_add_v4_addrs(idev);
1925
1926 if (dev->flags&IFF_POINTOPOINT) {
1927 addrconf_add_mroute(dev);
1928 addrconf_add_lroute(dev);
1929 } else
1930 sit_route_add(dev);
1931 }
1932
1933 static inline int
1934 ipv6_inherit_linklocal(struct inet6_dev *idev, struct net_device *link_dev)
1935 {
1936 struct in6_addr lladdr;
1937
1938 if (!ipv6_get_lladdr(link_dev, &lladdr)) {
1939 addrconf_add_linklocal(idev, &lladdr);
1940 return 0;
1941 }
1942 return -1;
1943 }
1944
1945 static void ip6_tnl_add_linklocal(struct inet6_dev *idev)
1946 {
1947 struct net_device *link_dev;
1948
1949 /* first try to inherit the link-local address from the link device */
1950 if (idev->dev->iflink &&
1951 (link_dev = __dev_get_by_index(idev->dev->iflink))) {
1952 if (!ipv6_inherit_linklocal(idev, link_dev))
1953 return;
1954 }
1955 /* then try to inherit it from any device */
1956 for (link_dev = dev_base; link_dev; link_dev = link_dev->next) {
1957 if (!ipv6_inherit_linklocal(idev, link_dev))
1958 return;
1959 }
1960 printk(KERN_DEBUG "init ip6-ip6: add_linklocal failed\n");
1961 }
1962
1963 /*
1964 * Autoconfigure tunnel with a link-local address so routing protocols,
1965 * DHCPv6, MLD etc. can be run over the virtual link
1966 */
1967
1968 static void addrconf_ip6_tnl_config(struct net_device *dev)
1969 {
1970 struct inet6_dev *idev;
1971
1972 ASSERT_RTNL();
1973
1974 if ((idev = addrconf_add_dev(dev)) == NULL) {
1975 printk(KERN_DEBUG "init ip6-ip6: add_dev failed\n");
1976 return;
1977 }
1978 ip6_tnl_add_linklocal(idev);
1979 addrconf_add_mroute(dev);
1980 }
1981
1982 static int addrconf_notify(struct notifier_block *this, unsigned long event,
1983 void * data)
1984 {
1985 struct net_device *dev = (struct net_device *) data;
1986 struct inet6_dev *idev = __in6_dev_get(dev);
1987
1988 switch(event) {
1989 case NETDEV_UP:
1990 switch(dev->type) {
1991 case ARPHRD_SIT:
1992 addrconf_sit_config(dev);
1993 break;
1994 case ARPHRD_TUNNEL6:
1995 addrconf_ip6_tnl_config(dev);
1996 break;
1997 case ARPHRD_LOOPBACK:
1998 init_loopback(dev);
1999 break;
2000
2001 default:
2002 addrconf_dev_config(dev);
2003 break;
2004 };
2005 if (idev) {
2006 /* If the MTU changed during the interface down, when the
2007 interface up, the changed MTU must be reflected in the
2008 idev as well as routers.
2009 */
2010 if (idev->cnf.mtu6 != dev->mtu && dev->mtu >= IPV6_MIN_MTU) {
2011 rt6_mtu_change(dev, dev->mtu);
2012 idev->cnf.mtu6 = dev->mtu;
2013 }
2014 idev->tstamp = jiffies;
2015 inet6_ifinfo_notify(RTM_NEWLINK, idev);
2016 /* If the changed mtu during down is lower than IPV6_MIN_MTU
2017 stop IPv6 on this interface.
2018 */
2019 if (dev->mtu < IPV6_MIN_MTU)
2020 addrconf_ifdown(dev, event != NETDEV_DOWN);
2021 }
2022 break;
2023
2024 case NETDEV_CHANGEMTU:
2025 if ( idev && dev->mtu >= IPV6_MIN_MTU) {
2026 rt6_mtu_change(dev, dev->mtu);
2027 idev->cnf.mtu6 = dev->mtu;
2028 break;
2029 }
2030
2031 /* MTU falled under IPV6_MIN_MTU. Stop IPv6 on this interface. */
2032
2033 case NETDEV_DOWN:
2034 case NETDEV_UNREGISTER:
2035 /*
2036 * Remove all addresses from this interface.
2037 */
2038 addrconf_ifdown(dev, event != NETDEV_DOWN);
2039 break;
2040 case NETDEV_CHANGE:
2041 break;
2042 case NETDEV_CHANGENAME:
2043 #ifdef CONFIG_SYSCTL
2044 if (idev) {
2045 addrconf_sysctl_unregister(&idev->cnf);
2046 neigh_sysctl_unregister(idev->nd_parms);
2047 neigh_sysctl_register(dev, idev->nd_parms,
2048 NET_IPV6, NET_IPV6_NEIGH, "ipv6",
2049 &ndisc_ifinfo_sysctl_change,
2050 NULL);
2051 addrconf_sysctl_register(idev, &idev->cnf);
2052 }
2053 #endif
2054 break;
2055 };
2056
2057 return NOTIFY_OK;
2058 }
2059
2060 /*
2061 * addrconf module should be notified of a device going up
2062 */
2063 static struct notifier_block ipv6_dev_notf = {
2064 .notifier_call = addrconf_notify,
2065 .priority = 0
2066 };
2067
2068 static int addrconf_ifdown(struct net_device *dev, int how)
2069 {
2070 struct inet6_dev *idev;
2071 struct inet6_ifaddr *ifa, **bifa;
2072 int i;
2073
2074 ASSERT_RTNL();
2075
2076 if (dev == &loopback_dev && how == 1)
2077 how = 0;
2078
2079 rt6_ifdown(dev);
2080 neigh_ifdown(&nd_tbl, dev);
2081
2082 idev = __in6_dev_get(dev);
2083 if (idev == NULL)
2084 return -ENODEV;
2085
2086 /* Step 1: remove reference to ipv6 device from parent device.
2087 Do not dev_put!
2088 */
2089 if (how == 1) {
2090 write_lock_bh(&addrconf_lock);
2091 dev->ip6_ptr = NULL;
2092 idev->dead = 1;
2093 write_unlock_bh(&addrconf_lock);
2094
2095 /* Step 1.5: remove snmp6 entry */
2096 snmp6_unregister_dev(idev);
2097
2098 }
2099
2100 /* Step 2: clear hash table */
2101 for (i=0; i<IN6_ADDR_HSIZE; i++) {
2102 bifa = &inet6_addr_lst[i];
2103
2104 write_lock_bh(&addrconf_hash_lock);
2105 while ((ifa = *bifa) != NULL) {
2106 if (ifa->idev == idev) {
2107 *bifa = ifa->lst_next;
2108 ifa->lst_next = NULL;
2109 addrconf_del_timer(ifa);
2110 in6_ifa_put(ifa);
2111 continue;
2112 }
2113 bifa = &ifa->lst_next;
2114 }
2115 write_unlock_bh(&addrconf_hash_lock);
2116 }
2117
2118 write_lock_bh(&idev->lock);
2119
2120 /* Step 3: clear flags for stateless addrconf */
2121 if (how != 1)
2122 idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD);
2123
2124 /* Step 4: clear address list */
2125 #ifdef CONFIG_IPV6_PRIVACY
2126 if (how == 1 && del_timer(&idev->regen_timer))
2127 in6_dev_put(idev);
2128
2129 /* clear tempaddr list */
2130 while ((ifa = idev->tempaddr_list) != NULL) {
2131 idev->tempaddr_list = ifa->tmp_next;
2132 ifa->tmp_next = NULL;
2133 ifa->dead = 1;
2134 write_unlock_bh(&idev->lock);
2135 spin_lock_bh(&ifa->lock);
2136
2137 if (ifa->ifpub) {
2138 in6_ifa_put(ifa->ifpub);
2139 ifa->ifpub = NULL;
2140 }
2141 spin_unlock_bh(&ifa->lock);
2142 in6_ifa_put(ifa);
2143 write_lock_bh(&idev->lock);
2144 }
2145 #endif
2146 while ((ifa = idev->addr_list) != NULL) {
2147 idev->addr_list = ifa->if_next;
2148 ifa->if_next = NULL;
2149 ifa->dead = 1;
2150 addrconf_del_timer(ifa);
2151 write_unlock_bh(&idev->lock);
2152
2153 __ipv6_ifa_notify(RTM_DELADDR, ifa);
2154 in6_ifa_put(ifa);
2155
2156 write_lock_bh(&idev->lock);
2157 }
2158 write_unlock_bh(&idev->lock);
2159
2160 /* Step 5: Discard multicast list */
2161
2162 if (how == 1)
2163 ipv6_mc_destroy_dev(idev);
2164 else
2165 ipv6_mc_down(idev);
2166
2167 /* Step 5: netlink notification of this interface */
2168 idev->tstamp = jiffies;
2169 inet6_ifinfo_notify(RTM_NEWLINK, idev);
2170
2171 /* Shot the device (if unregistered) */
2172
2173 if (how == 1) {
2174 #ifdef CONFIG_SYSCTL
2175 addrconf_sysctl_unregister(&idev->cnf);
2176 neigh_sysctl_unregister(idev->nd_parms);
2177 #endif
2178 neigh_parms_release(&nd_tbl, idev->nd_parms);
2179 neigh_ifdown(&nd_tbl, dev);
2180 in6_dev_put(idev);
2181 }
2182 return 0;
2183 }
2184
2185 static void addrconf_rs_timer(unsigned long data)
2186 {
2187 struct inet6_ifaddr *ifp = (struct inet6_ifaddr *) data;
2188
2189 if (ifp->idev->cnf.forwarding)
2190 goto out;
2191
2192 if (ifp->idev->if_flags & IF_RA_RCVD) {
2193 /*
2194 * Announcement received after solicitation
2195 * was sent
2196 */
2197 goto out;
2198 }
2199
2200 spin_lock(&ifp->lock);
2201 if (ifp->probes++ < ifp->idev->cnf.rtr_solicits) {
2202 struct in6_addr all_routers;
2203
2204 /* The wait after the last probe can be shorter */
2205 addrconf_mod_timer(ifp, AC_RS,
2206 (ifp->probes == ifp->idev->cnf.rtr_solicits) ?
2207 ifp->idev->cnf.rtr_solicit_delay :
2208 ifp->idev->cnf.rtr_solicit_interval);
2209 spin_unlock(&ifp->lock);
2210
2211 ipv6_addr_all_routers(&all_routers);
2212
2213 ndisc_send_rs(ifp->idev->dev, &ifp->addr, &all_routers);
2214 } else {
2215 spin_unlock(&ifp->lock);
2216 /*
2217 * Note: we do not support deprecated "all on-link"
2218 * assumption any longer.
2219 */
2220 printk(KERN_DEBUG "%s: no IPv6 routers present\n",
2221 ifp->idev->dev->name);
2222 }
2223
2224 out:
2225 in6_ifa_put(ifp);
2226 }
2227
2228 /*
2229 * Duplicate Address Detection
2230 */
2231 static void addrconf_dad_start(struct inet6_ifaddr *ifp, int flags)
2232 {
2233 struct inet6_dev *idev = ifp->idev;
2234 struct net_device *dev = idev->dev;
2235 unsigned long rand_num;
2236
2237 addrconf_join_solict(dev, &ifp->addr);
2238
2239 if (ifp->prefix_len != 128 && (ifp->flags&IFA_F_PERMANENT))
2240 addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev, 0,
2241 flags);
2242
2243 net_srandom(ifp->addr.s6_addr32[3]);
2244 rand_num = net_random() % (idev->cnf.rtr_solicit_delay ? : 1);
2245
2246 read_lock_bh(&idev->lock);
2247 if (ifp->dead)
2248 goto out;
2249 spin_lock_bh(&ifp->lock);
2250
2251 if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) ||
2252 !(ifp->flags&IFA_F_TENTATIVE)) {
2253 ifp->flags &= ~IFA_F_TENTATIVE;
2254 spin_unlock_bh(&ifp->lock);
2255 read_unlock_bh(&idev->lock);
2256
2257 addrconf_dad_completed(ifp);
2258 return;
2259 }
2260
2261 ifp->probes = idev->cnf.dad_transmits;
2262 addrconf_mod_timer(ifp, AC_DAD, rand_num);
2263
2264 spin_unlock_bh(&ifp->lock);
2265 out:
2266 read_unlock_bh(&idev->lock);
2267 }
2268
2269 static void addrconf_dad_timer(unsigned long data)
2270 {
2271 struct inet6_ifaddr *ifp = (struct inet6_ifaddr *) data;
2272 struct inet6_dev *idev = ifp->idev;
2273 struct in6_addr unspec;
2274 struct in6_addr mcaddr;
2275
2276 read_lock_bh(&idev->lock);
2277 if (idev->dead) {
2278 read_unlock_bh(&idev->lock);
2279 goto out;
2280 }
2281 spin_lock_bh(&ifp->lock);
2282 if (ifp->probes == 0) {
2283 /*
2284 * DAD was successful
2285 */
2286
2287 ifp->flags &= ~IFA_F_TENTATIVE;
2288 spin_unlock_bh(&ifp->lock);
2289 read_unlock_bh(&idev->lock);
2290
2291 addrconf_dad_completed(ifp);
2292
2293 goto out;
2294 }
2295
2296 ifp->probes--;
2297 addrconf_mod_timer(ifp, AC_DAD, ifp->idev->nd_parms->retrans_time);
2298 spin_unlock_bh(&ifp->lock);
2299 read_unlock_bh(&idev->lock);
2300
2301 /* send a neighbour solicitation for our addr */
2302 memset(&unspec, 0, sizeof(unspec));
2303 addrconf_addr_solict_mult(&ifp->addr, &mcaddr);
2304 ndisc_send_ns(ifp->idev->dev, NULL, &ifp->addr, &mcaddr, &unspec);
2305 out:
2306 in6_ifa_put(ifp);
2307 }
2308
2309 static void addrconf_dad_completed(struct inet6_ifaddr *ifp)
2310 {
2311 struct net_device * dev = ifp->idev->dev;
2312
2313 /*
2314 * Configure the address for reception. Now it is valid.
2315 */
2316
2317 ipv6_ifa_notify(RTM_NEWADDR, ifp);
2318
2319 /* If added prefix is link local and forwarding is off,
2320 start sending router solicitations.
2321 */
2322
2323 if (ifp->idev->cnf.forwarding == 0 &&
2324 ifp->idev->cnf.rtr_solicits > 0 &&
2325 (dev->flags&IFF_LOOPBACK) == 0 &&
2326 (ipv6_addr_type(&ifp->addr) & IPV6_ADDR_LINKLOCAL)) {
2327 struct in6_addr all_routers;
2328
2329 ipv6_addr_all_routers(&all_routers);
2330
2331 /*
2332 * If a host as already performed a random delay
2333 * [...] as part of DAD [...] there is no need
2334 * to delay again before sending the first RS
2335 */
2336 ndisc_send_rs(ifp->idev->dev, &ifp->addr, &all_routers);
2337
2338 spin_lock_bh(&ifp->lock);
2339 ifp->probes = 1;
2340 ifp->idev->if_flags |= IF_RS_SENT;
2341 addrconf_mod_timer(ifp, AC_RS, ifp->idev->cnf.rtr_solicit_interval);
2342 spin_unlock_bh(&ifp->lock);
2343 }
2344 }
2345
2346 #ifdef CONFIG_PROC_FS
2347 struct if6_iter_state {
2348 int bucket;
2349 };
2350
2351 static struct inet6_ifaddr *if6_get_first(struct seq_file *seq)
2352 {
2353 struct inet6_ifaddr *ifa = NULL;
2354 struct if6_iter_state *state = seq->private;
2355
2356 for (state->bucket = 0; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {
2357 ifa = inet6_addr_lst[state->bucket];
2358 if (ifa)
2359 break;
2360 }
2361 return ifa;
2362 }
2363
2364 static struct inet6_ifaddr *if6_get_next(struct seq_file *seq, struct inet6_ifaddr *ifa)
2365 {
2366 struct if6_iter_state *state = seq->private;
2367
2368 ifa = ifa->lst_next;
2369 try_again:
2370 if (!ifa && ++state->bucket < IN6_ADDR_HSIZE) {
2371 ifa = inet6_addr_lst[state->bucket];
2372 goto try_again;
2373 }
2374 return ifa;
2375 }
2376
2377 static struct inet6_ifaddr *if6_get_idx(struct seq_file *seq, loff_t pos)
2378 {
2379 struct inet6_ifaddr *ifa = if6_get_first(seq);
2380
2381 if (ifa)
2382 while(pos && (ifa = if6_get_next(seq, ifa)) != NULL)
2383 --pos;
2384 return pos ? NULL : ifa;
2385 }
2386
2387 static void *if6_seq_start(struct seq_file *seq, loff_t *pos)
2388 {
2389 read_lock_bh(&addrconf_hash_lock);
2390 return if6_get_idx(seq, *pos);
2391 }
2392
2393 static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2394 {
2395 struct inet6_ifaddr *ifa;
2396
2397 ifa = if6_get_next(seq, v);
2398 ++*pos;
2399 return ifa;
2400 }
2401
2402 static void if6_seq_stop(struct seq_file *seq, void *v)
2403 {
2404 read_unlock_bh(&addrconf_hash_lock);
2405 }
2406
2407 static int if6_seq_show(struct seq_file *seq, void *v)
2408 {
2409 struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v;
2410 seq_printf(seq,
2411 "%04x%04x%04x%04x%04x%04x%04x%04x %02x %02x %02x %02x %8s\n",
2412 NIP6(ifp->addr),
2413 ifp->idev->dev->ifindex,
2414 ifp->prefix_len,
2415 ifp->scope,
2416 ifp->flags,
2417 ifp->idev->dev->name);
2418 return 0;
2419 }
2420
2421 static struct seq_operations if6_seq_ops = {
2422 .start = if6_seq_start,
2423 .next = if6_seq_next,
2424 .show = if6_seq_show,
2425 .stop = if6_seq_stop,
2426 };
2427
2428 static int if6_seq_open(struct inode *inode, struct file *file)
2429 {
2430 struct seq_file *seq;
2431 int rc = -ENOMEM;
2432 struct if6_iter_state *s = kmalloc(sizeof(*s), GFP_KERNEL);
2433
2434 if (!s)
2435 goto out;
2436 memset(s, 0, sizeof(*s));
2437
2438 rc = seq_open(file, &if6_seq_ops);
2439 if (rc)
2440 goto out_kfree;
2441
2442 seq = file->private_data;
2443 seq->private = s;
2444 out:
2445 return rc;
2446 out_kfree:
2447 kfree(s);
2448 goto out;
2449 }
2450
2451 static struct file_operations if6_fops = {
2452 .owner = THIS_MODULE,
2453 .open = if6_seq_open,
2454 .read = seq_read,
2455 .llseek = seq_lseek,
2456 .release = seq_release_private,
2457 };
2458
2459 int __init if6_proc_init(void)
2460 {
2461 if (!proc_net_fops_create("if_inet6", S_IRUGO, &if6_fops))
2462 return -ENOMEM;
2463 return 0;
2464 }
2465
2466 void if6_proc_exit(void)
2467 {
2468 proc_net_remove("if_inet6");
2469 }
2470 #endif /* CONFIG_PROC_FS */
2471
2472 /*
2473 * Periodic address status verification
2474 */
2475
2476 static void addrconf_verify(unsigned long foo)
2477 {
2478 struct inet6_ifaddr *ifp;
2479 unsigned long now, next;
2480 int i;
2481
2482 spin_lock_bh(&addrconf_verify_lock);
2483 now = jiffies;
2484 next = now + ADDR_CHECK_FREQUENCY;
2485
2486 del_timer(&addr_chk_timer);
2487
2488 for (i=0; i < IN6_ADDR_HSIZE; i++) {
2489
2490 restart:
2491 write_lock(&addrconf_hash_lock);
2492 for (ifp=inet6_addr_lst[i]; ifp; ifp=ifp->lst_next) {
2493 unsigned long age;
2494 #ifdef CONFIG_IPV6_PRIVACY
2495 unsigned long regen_advance;
2496 #endif
2497
2498 if (ifp->flags & IFA_F_PERMANENT)
2499 continue;
2500
2501 spin_lock(&ifp->lock);
2502 age = (now - ifp->tstamp) / HZ;
2503
2504 #ifdef CONFIG_IPV6_PRIVACY
2505 regen_advance = ifp->idev->cnf.regen_max_retry *
2506 ifp->idev->cnf.dad_transmits *
2507 ifp->idev->nd_parms->retrans_time / HZ;
2508 #endif
2509
2510 if (age >= ifp->valid_lft) {
2511 spin_unlock(&ifp->lock);
2512 in6_ifa_hold(ifp);
2513 write_unlock(&addrconf_hash_lock);
2514 ipv6_del_addr(ifp);
2515 goto restart;
2516 } else if (age >= ifp->prefered_lft) {
2517 /* jiffies - ifp->tsamp > age >= ifp->prefered_lft */
2518 int deprecate = 0;
2519
2520 if (!(ifp->flags&IFA_F_DEPRECATED)) {
2521 deprecate = 1;
2522 ifp->flags |= IFA_F_DEPRECATED;
2523 }
2524
2525 if (time_before(ifp->tstamp + ifp->valid_lft * HZ, next))
2526 next = ifp->tstamp + ifp->valid_lft * HZ;
2527
2528 spin_unlock(&ifp->lock);
2529
2530 if (deprecate) {
2531 in6_ifa_hold(ifp);
2532 write_unlock(&addrconf_hash_lock);
2533
2534 ipv6_ifa_notify(0, ifp);
2535 in6_ifa_put(ifp);
2536 goto restart;
2537 }
2538 #ifdef CONFIG_IPV6_PRIVACY
2539 } else if ((ifp->flags&IFA_F_TEMPORARY) &&
2540 !(ifp->flags&IFA_F_TENTATIVE)) {
2541 if (age >= ifp->prefered_lft - regen_advance) {
2542 struct inet6_ifaddr *ifpub = ifp->ifpub;
2543 if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
2544 next = ifp->tstamp + ifp->prefered_lft * HZ;
2545 if (!ifp->regen_count && ifpub) {
2546 ifp->regen_count++;
2547 in6_ifa_hold(ifp);
2548 in6_ifa_hold(ifpub);
2549 spin_unlock(&ifp->lock);
2550 write_unlock(&addrconf_hash_lock);
2551 ipv6_create_tempaddr(ifpub, ifp);
2552 in6_ifa_put(ifpub);
2553 in6_ifa_put(ifp);
2554 goto restart;
2555 }
2556 } else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next))
2557 next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ;
2558 spin_unlock(&ifp->lock);
2559 #endif
2560 } else {
2561 /* ifp->prefered_lft <= ifp->valid_lft */
2562 if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
2563 next = ifp->tstamp + ifp->prefered_lft * HZ;
2564 spin_unlock(&ifp->lock);
2565 }
2566 }
2567 write_unlock(&addrconf_hash_lock);
2568 }
2569
2570 addr_chk_timer.expires = time_before(next, jiffies + HZ) ? jiffies + HZ : next;
2571 add_timer(&addr_chk_timer);
2572 spin_unlock_bh(&addrconf_verify_lock);
2573 }
2574
2575 static int
2576 inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
2577 {
2578 struct rtattr **rta = arg;
2579 struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
2580 struct in6_addr *pfx;
2581
2582 pfx = NULL;
2583 if (rta[IFA_ADDRESS-1]) {
2584 if (RTA_PAYLOAD(rta[IFA_ADDRESS-1]) < sizeof(*pfx))
2585 return -EINVAL;
2586 pfx = RTA_DATA(rta[IFA_ADDRESS-1]);
2587 }
2588 if (rta[IFA_LOCAL-1]) {
2589 if (pfx && memcmp(pfx, RTA_DATA(rta[IFA_LOCAL-1]), sizeof(*pfx)))
2590 return -EINVAL;
2591 pfx = RTA_DATA(rta[IFA_LOCAL-1]);
2592 }
2593 if (pfx == NULL)
2594 return -EINVAL;
2595
2596 return inet6_addr_del(ifm->ifa_index, pfx, ifm->ifa_prefixlen);
2597 }
2598
2599 static int
2600 inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
2601 {
2602 struct rtattr **rta = arg;
2603 struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
2604 struct in6_addr *pfx;
2605
2606 pfx = NULL;
2607 if (rta[IFA_ADDRESS-1]) {
2608 if (RTA_PAYLOAD(rta[IFA_ADDRESS-1]) < sizeof(*pfx))
2609 return -EINVAL;
2610 pfx = RTA_DATA(rta[IFA_ADDRESS-1]);
2611 }
2612 if (rta[IFA_LOCAL-1]) {
2613 if (pfx && memcmp(pfx, RTA_DATA(rta[IFA_LOCAL-1]), sizeof(*pfx)))
2614 return -EINVAL;
2615 pfx = RTA_DATA(rta[IFA_LOCAL-1]);
2616 }
2617 if (pfx == NULL)
2618 return -EINVAL;
2619
2620 return inet6_addr_add(ifm->ifa_index, pfx, ifm->ifa_prefixlen);
2621 }
2622
2623 static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
2624 u32 pid, u32 seq, int event)
2625 {
2626 struct ifaddrmsg *ifm;
2627 struct nlmsghdr *nlh;
2628 struct ifa_cacheinfo ci;
2629 unsigned char *b = skb->tail;
2630
2631 nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(*ifm));
2632 if (pid) nlh->nlmsg_flags |= NLM_F_MULTI;
2633 ifm = NLMSG_DATA(nlh);
2634 ifm->ifa_family = AF_INET6;
2635 ifm->ifa_prefixlen = ifa->prefix_len;
2636 ifm->ifa_flags = ifa->flags;
2637 ifm->ifa_scope = RT_SCOPE_UNIVERSE;
2638 if (ifa->scope&IFA_HOST)
2639 ifm->ifa_scope = RT_SCOPE_HOST;
2640 else if (ifa->scope&IFA_LINK)
2641 ifm->ifa_scope = RT_SCOPE_LINK;
2642 else if (ifa->scope&IFA_SITE)
2643 ifm->ifa_scope = RT_SCOPE_SITE;
2644 ifm->ifa_index = ifa->idev->dev->ifindex;
2645 RTA_PUT(skb, IFA_ADDRESS, 16, &ifa->addr);
2646 if (!(ifa->flags&IFA_F_PERMANENT)) {
2647 ci.ifa_prefered = ifa->prefered_lft;
2648 ci.ifa_valid = ifa->valid_lft;
2649 if (ci.ifa_prefered != INFINITY_LIFE_TIME) {
2650 long tval = (jiffies - ifa->tstamp)/HZ;
2651 ci.ifa_prefered -= tval;
2652 if (ci.ifa_valid != INFINITY_LIFE_TIME)
2653 ci.ifa_valid -= tval;
2654 }
2655 } else {
2656 ci.ifa_prefered = INFINITY_LIFE_TIME;
2657 ci.ifa_valid = INFINITY_LIFE_TIME;
2658 }
2659 ci.cstamp = (__u32)(TIME_DELTA(ifa->cstamp, INITIAL_JIFFIES) / HZ * 100
2660 + TIME_DELTA(ifa->cstamp, INITIAL_JIFFIES) % HZ * 100 / HZ);
2661 ci.tstamp = (__u32)(TIME_DELTA(ifa->tstamp, INITIAL_JIFFIES) / HZ * 100
2662 + TIME_DELTA(ifa->tstamp, INITIAL_JIFFIES) % HZ * 100 / HZ);
2663 RTA_PUT(skb, IFA_CACHEINFO, sizeof(ci), &ci);
2664 nlh->nlmsg_len = skb->tail - b;
2665 return skb->len;
2666
2667 nlmsg_failure:
2668 rtattr_failure:
2669 skb_trim(skb, b - skb->data);
2670 return -1;
2671 }
2672
2673 static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca,
2674 u32 pid, u32 seq, int event)
2675 {
2676 struct ifaddrmsg *ifm;
2677 struct nlmsghdr *nlh;
2678 struct ifa_cacheinfo ci;
2679 unsigned char *b = skb->tail;
2680
2681 nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(*ifm));
2682 if (pid) nlh->nlmsg_flags |= NLM_F_MULTI;
2683 ifm = NLMSG_DATA(nlh);
2684 ifm->ifa_family = AF_INET6;
2685 ifm->ifa_prefixlen = 128;
2686 ifm->ifa_flags = IFA_F_PERMANENT;
2687 ifm->ifa_scope = RT_SCOPE_UNIVERSE;
2688 if (ipv6_addr_scope(&ifmca->mca_addr)&IFA_SITE)
2689 ifm->ifa_scope = RT_SCOPE_SITE;
2690 ifm->ifa_index = ifmca->idev->dev->ifindex;
2691 RTA_PUT(skb, IFA_MULTICAST, 16, &ifmca->mca_addr);
2692 ci.cstamp = (__u32)(TIME_DELTA(ifmca->mca_cstamp, INITIAL_JIFFIES) / HZ
2693 * 100 + TIME_DELTA(ifmca->mca_cstamp, INITIAL_JIFFIES) % HZ
2694 * 100 / HZ);
2695 ci.tstamp = (__u32)(TIME_DELTA(ifmca->mca_tstamp, INITIAL_JIFFIES) / HZ
2696 * 100 + TIME_DELTA(ifmca->mca_tstamp, INITIAL_JIFFIES) % HZ
2697 * 100 / HZ);
2698 ci.ifa_prefered = INFINITY_LIFE_TIME;
2699 ci.ifa_valid = INFINITY_LIFE_TIME;
2700 RTA_PUT(skb, IFA_CACHEINFO, sizeof(ci), &ci);
2701 nlh->nlmsg_len = skb->tail - b;
2702 return skb->len;
2703
2704 nlmsg_failure:
2705 rtattr_failure:
2706 skb_trim(skb, b - skb->data);
2707 return -1;
2708 }
2709
2710 static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
2711 u32 pid, u32 seq, int event)
2712 {
2713 struct ifaddrmsg *ifm;
2714 struct nlmsghdr *nlh;
2715 struct ifa_cacheinfo ci;
2716 unsigned char *b = skb->tail;
2717
2718 nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(*ifm));
2719 if (pid) nlh->nlmsg_flags |= NLM_F_MULTI;
2720 ifm = NLMSG_DATA(nlh);
2721 ifm->ifa_family = AF_INET6;
2722 ifm->ifa_prefixlen = 128;
2723 ifm->ifa_flags = IFA_F_PERMANENT;
2724 ifm->ifa_scope = RT_SCOPE_UNIVERSE;
2725 if (ipv6_addr_scope(&ifaca->aca_addr)&IFA_SITE)
2726 ifm->ifa_scope = RT_SCOPE_SITE;
2727 ifm->ifa_index = ifaca->aca_idev->dev->ifindex;
2728 RTA_PUT(skb, IFA_ANYCAST, 16, &ifaca->aca_addr);
2729 ci.cstamp = (__u32)(TIME_DELTA(ifaca->aca_cstamp, INITIAL_JIFFIES) / HZ
2730 * 100 + TIME_DELTA(ifaca->aca_cstamp, INITIAL_JIFFIES) % HZ
2731 * 100 / HZ);
2732 ci.tstamp = (__u32)(TIME_DELTA(ifaca->aca_tstamp, INITIAL_JIFFIES) / HZ
2733 * 100 + TIME_DELTA(ifaca->aca_tstamp, INITIAL_JIFFIES) % HZ
2734 * 100 / HZ);
2735 ci.ifa_prefered = INFINITY_LIFE_TIME;
2736 ci.ifa_valid = INFINITY_LIFE_TIME;
2737 RTA_PUT(skb, IFA_CACHEINFO, sizeof(ci), &ci);
2738 nlh->nlmsg_len = skb->tail - b;
2739 return skb->len;
2740
2741 nlmsg_failure:
2742 rtattr_failure:
2743 skb_trim(skb, b - skb->data);
2744 return -1;
2745 }
2746
2747 enum addr_type_t
2748 {
2749 UNICAST_ADDR,
2750 MULTICAST_ADDR,
2751 ANYCAST_ADDR,
2752 };
2753
2754 static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
2755 enum addr_type_t type)
2756 {
2757 int idx, ip_idx;
2758 int s_idx, s_ip_idx;
2759 int err = 1;
2760 struct net_device *dev;
2761 struct inet6_dev *idev = NULL;
2762 struct inet6_ifaddr *ifa;
2763 struct ifmcaddr6 *ifmca;
2764 struct ifacaddr6 *ifaca;
2765
2766 s_idx = cb->args[0];
2767 s_ip_idx = ip_idx = cb->args[1];
2768 read_lock(&dev_base_lock);
2769
2770 for (dev = dev_base, idx = 0; dev; dev = dev->next, idx++) {
2771 if (idx < s_idx)
2772 continue;
2773 if (idx > s_idx)
2774 s_ip_idx = 0;
2775 ip_idx = 0;
2776 if ((idev = in6_dev_get(dev)) == NULL)
2777 continue;
2778 read_lock_bh(&idev->lock);
2779 switch (type) {
2780 case UNICAST_ADDR:
2781 /* unicast address */
2782 for (ifa = idev->addr_list; ifa;
2783 ifa = ifa->if_next, ip_idx++) {
2784 if (ip_idx < s_ip_idx)
2785 continue;
2786 if ((err = inet6_fill_ifaddr(skb, ifa,
2787 NETLINK_CB(cb->skb).pid,
2788 cb->nlh->nlmsg_seq, RTM_NEWADDR)) <= 0)
2789 goto done;
2790 }
2791 /* temp addr */
2792 #ifdef CONFIG_IPV6_PRIVACY
2793 for (ifa = idev->tempaddr_list; ifa;
2794 ifa = ifa->tmp_next, ip_idx++) {
2795 if (ip_idx < s_ip_idx)
2796 continue;
2797 if ((err = inet6_fill_ifaddr(skb, ifa,
2798 NETLINK_CB(cb->skb).pid,
2799 cb->nlh->nlmsg_seq, RTM_NEWADDR)) <= 0)
2800 goto done;
2801 }
2802 #endif
2803 break;
2804 case MULTICAST_ADDR:
2805 /* multicast address */
2806 for (ifmca = idev->mc_list; ifmca;
2807 ifmca = ifmca->next, ip_idx++) {
2808 if (ip_idx < s_ip_idx)
2809 continue;
2810 if ((err = inet6_fill_ifmcaddr(skb, ifmca,
2811 NETLINK_CB(cb->skb).pid,
2812 cb->nlh->nlmsg_seq, RTM_GETMULTICAST)) <= 0)
2813 goto done;
2814 }
2815 break;
2816 case ANYCAST_ADDR:
2817 /* anycast address */
2818 for (ifaca = idev->ac_list; ifaca;
2819 ifaca = ifaca->aca_next, ip_idx++) {
2820 if (ip_idx < s_ip_idx)
2821 continue;
2822 if ((err = inet6_fill_ifacaddr(skb, ifaca,
2823 NETLINK_CB(cb->skb).pid,
2824 cb->nlh->nlmsg_seq, RTM_GETANYCAST)) <= 0)
2825 goto done;
2826 }
2827 break;
2828 default:
2829 break;
2830 }
2831 read_unlock_bh(&idev->lock);
2832 in6_dev_put(idev);
2833 }
2834 done:
2835 if (err <= 0) {
2836 read_unlock_bh(&idev->lock);
2837 in6_dev_put(idev);
2838 }
2839 read_unlock(&dev_base_lock);
2840 cb->args[0] = idx;
2841 cb->args[1] = ip_idx;
2842 return skb->len;
2843 }
2844
2845 static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
2846 {
2847 enum addr_type_t type = UNICAST_ADDR;
2848 return inet6_dump_addr(skb, cb, type);
2849 }
2850
2851 static int inet6_dump_ifmcaddr(struct sk_buff *skb, struct netlink_callback *cb)
2852 {
2853 enum addr_type_t type = MULTICAST_ADDR;
2854 return inet6_dump_addr(skb, cb, type);
2855 }
2856
2857
2858 static int inet6_dump_ifacaddr(struct sk_buff *skb, struct netlink_callback *cb)
2859 {
2860 enum addr_type_t type = ANYCAST_ADDR;
2861 return inet6_dump_addr(skb, cb, type);
2862 }
2863
2864 static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa)
2865 {
2866 struct sk_buff *skb;
2867 int size = NLMSG_SPACE(sizeof(struct ifaddrmsg)+128);
2868
2869 skb = alloc_skb(size, GFP_ATOMIC);
2870 if (!skb) {
2871 netlink_set_err(rtnl, 0, RTMGRP_IPV6_IFADDR, ENOBUFS);
2872 return;
2873 }
2874 if (inet6_fill_ifaddr(skb, ifa, 0, 0, event) < 0) {
2875 kfree_skb(skb);
2876 netlink_set_err(rtnl, 0, RTMGRP_IPV6_IFADDR, EINVAL);
2877 return;
2878 }
2879 NETLINK_CB(skb).dst_groups = RTMGRP_IPV6_IFADDR;
2880 netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV6_IFADDR, GFP_ATOMIC);
2881 }
2882
2883 static void inline ipv6_store_devconf(struct ipv6_devconf *cnf,
2884 __s32 *array, int bytes)
2885 {
2886 memset(array, 0, bytes);
2887 array[DEVCONF_FORWARDING] = cnf->forwarding;
2888 array[DEVCONF_HOPLIMIT] = cnf->hop_limit;
2889 array[DEVCONF_MTU6] = cnf->mtu6;
2890 array[DEVCONF_ACCEPT_RA] = cnf->accept_ra;
2891 array[DEVCONF_ACCEPT_REDIRECTS] = cnf->accept_redirects;
2892 array[DEVCONF_AUTOCONF] = cnf->autoconf;
2893 array[DEVCONF_DAD_TRANSMITS] = cnf->dad_transmits;
2894 array[DEVCONF_RTR_SOLICITS] = cnf->rtr_solicits;
2895 array[DEVCONF_RTR_SOLICIT_INTERVAL] = cnf->rtr_solicit_interval;
2896 array[DEVCONF_RTR_SOLICIT_DELAY] = cnf->rtr_solicit_delay;
2897 array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version;
2898 #ifdef CONFIG_IPV6_PRIVACY
2899 array[DEVCONF_USE_TEMPADDR] = cnf->use_tempaddr;
2900 array[DEVCONF_TEMP_VALID_LFT] = cnf->temp_valid_lft;
2901 array[DEVCONF_TEMP_PREFERED_LFT] = cnf->temp_prefered_lft;
2902 array[DEVCONF_REGEN_MAX_RETRY] = cnf->regen_max_retry;
2903 array[DEVCONF_MAX_DESYNC_FACTOR] = cnf->max_desync_factor;
2904 #endif
2905 array[DEVCONF_MAX_ADDRESSES] = cnf->max_addresses;
2906 }
2907
2908 static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev,
2909 u32 pid, u32 seq, int event)
2910 {
2911 struct net_device *dev = idev->dev;
2912 __s32 *array = NULL;
2913 struct ifinfomsg *r;
2914 struct nlmsghdr *nlh;
2915 unsigned char *b = skb->tail;
2916 struct rtattr *subattr;
2917 __u32 mtu = dev->mtu;
2918 struct ifla_cacheinfo ci;
2919
2920 nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(*r));
2921 if (pid) nlh->nlmsg_flags |= NLM_F_MULTI;
2922 r = NLMSG_DATA(nlh);
2923 r->ifi_family = AF_INET6;
2924 r->ifi_type = dev->type;
2925 r->ifi_index = dev->ifindex;
2926 r->ifi_flags = dev_get_flags(dev);
2927 r->ifi_change = 0;
2928
2929 RTA_PUT(skb, IFLA_IFNAME, strlen(dev->name)+1, dev->name);
2930
2931 if (dev->addr_len)
2932 RTA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr);
2933
2934 RTA_PUT(skb, IFLA_MTU, sizeof(mtu), &mtu);
2935 if (dev->ifindex != dev->iflink)
2936 RTA_PUT(skb, IFLA_LINK, sizeof(int), &dev->iflink);
2937
2938 subattr = (struct rtattr*)skb->tail;
2939
2940 RTA_PUT(skb, IFLA_PROTINFO, 0, NULL);
2941
2942 /* return the device flags */
2943 RTA_PUT(skb, IFLA_INET6_FLAGS, sizeof(__u32), &idev->if_flags);
2944
2945 /* return interface cacheinfo */
2946 ci.max_reasm_len = IPV6_MAXPLEN;
2947 ci.tstamp = (__u32)(TIME_DELTA(idev->tstamp, INITIAL_JIFFIES) / HZ * 100
2948 + TIME_DELTA(idev->tstamp, INITIAL_JIFFIES) % HZ * 100 / HZ);
2949 ci.reachable_time = idev->nd_parms->reachable_time;
2950 ci.retrans_time = idev->nd_parms->retrans_time;
2951 RTA_PUT(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci);
2952
2953 /* return the device sysctl params */
2954 if ((array = kmalloc(DEVCONF_MAX * sizeof(*array), GFP_ATOMIC)) == NULL)
2955 goto rtattr_failure;
2956 ipv6_store_devconf(&idev->cnf, array, DEVCONF_MAX * sizeof(*array));
2957 RTA_PUT(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(*array), array);
2958
2959 /* XXX - Statistics/MC not implemented */
2960 subattr->rta_len = skb->tail - (u8*)subattr;
2961
2962 nlh->nlmsg_len = skb->tail - b;
2963 kfree(array);
2964 return skb->len;
2965
2966 nlmsg_failure:
2967 rtattr_failure:
2968 if (array)
2969 kfree(array);
2970 skb_trim(skb, b - skb->data);
2971 return -1;
2972 }
2973
2974 static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
2975 {
2976 int idx, err;
2977 int s_idx = cb->args[0];
2978 struct net_device *dev;
2979 struct inet6_dev *idev;
2980
2981 read_lock(&dev_base_lock);
2982 for (dev=dev_base, idx=0; dev; dev = dev->next, idx++) {
2983 if (idx < s_idx)
2984 continue;
2985 if ((idev = in6_dev_get(dev)) == NULL)
2986 continue;
2987 err = inet6_fill_ifinfo(skb, idev, NETLINK_CB(cb->skb).pid,
2988 cb->nlh->nlmsg_seq, RTM_NEWLINK);
2989 in6_dev_put(idev);
2990 if (err <= 0)
2991 break;
2992 }
2993 read_unlock(&dev_base_lock);
2994 cb->args[0] = idx;
2995
2996 return skb->len;
2997 }
2998
2999 void inet6_ifinfo_notify(int event, struct inet6_dev *idev)
3000 {
3001 struct sk_buff *skb;
3002 /* 128 bytes ?? */
3003 int size = NLMSG_SPACE(sizeof(struct ifinfomsg)+128);
3004
3005 skb = alloc_skb(size, GFP_ATOMIC);
3006 if (!skb) {
3007 netlink_set_err(rtnl, 0, RTMGRP_IPV6_IFINFO, ENOBUFS);
3008 return;
3009 }
3010 if (inet6_fill_ifinfo(skb, idev, 0, 0, event) < 0) {
3011 kfree_skb(skb);
3012 netlink_set_err(rtnl, 0, RTMGRP_IPV6_IFINFO, EINVAL);
3013 return;
3014 }
3015 NETLINK_CB(skb).dst_groups = RTMGRP_IPV6_IFINFO;
3016 netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV6_IFINFO, GFP_ATOMIC);
3017 }
3018
3019 static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev,
3020 struct prefix_info *pinfo, u32 pid, u32 seq, int event)
3021 {
3022 struct prefixmsg *pmsg;
3023 struct nlmsghdr *nlh;
3024 unsigned char *b = skb->tail;
3025 struct prefix_cacheinfo ci;
3026
3027 nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(*pmsg));
3028
3029 if (pid)
3030 nlh->nlmsg_flags |= NLM_F_MULTI;
3031
3032 pmsg = NLMSG_DATA(nlh);
3033 pmsg->prefix_family = AF_INET6;
3034 pmsg->prefix_ifindex = idev->dev->ifindex;
3035 pmsg->prefix_len = pinfo->prefix_len;
3036 pmsg->prefix_type = pinfo->type;
3037
3038 pmsg->prefix_flags = 0;
3039 if (pinfo->onlink)
3040 pmsg->prefix_flags |= IF_PREFIX_ONLINK;
3041 if (pinfo->autoconf)
3042 pmsg->prefix_flags |= IF_PREFIX_AUTOCONF;
3043
3044 RTA_PUT(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix);
3045
3046 ci.preferred_time = ntohl(pinfo->prefered);
3047 ci.valid_time = ntohl(pinfo->valid);
3048 RTA_PUT(skb, PREFIX_CACHEINFO, sizeof(ci), &ci);
3049
3050 nlh->nlmsg_len = skb->tail - b;
3051 return skb->len;
3052
3053 nlmsg_failure:
3054 rtattr_failure:
3055 skb_trim(skb, b - skb->data);
3056 return -1;
3057 }
3058
3059 static void inet6_prefix_notify(int event, struct inet6_dev *idev,
3060 struct prefix_info *pinfo)
3061 {
3062 struct sk_buff *skb;
3063 int size = NLMSG_SPACE(sizeof(struct prefixmsg)+128);
3064
3065 skb = alloc_skb(size, GFP_ATOMIC);
3066 if (!skb) {
3067 netlink_set_err(rtnl, 0, RTMGRP_IPV6_PREFIX, ENOBUFS);
3068 return;
3069 }
3070 if (inet6_fill_prefix(skb, idev, pinfo, 0, 0, event) < 0) {
3071 kfree_skb(skb);
3072 netlink_set_err(rtnl, 0, RTMGRP_IPV6_PREFIX, EINVAL);
3073 return;
3074 }
3075 NETLINK_CB(skb).dst_groups = RTMGRP_IPV6_PREFIX;
3076 netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV6_PREFIX, GFP_ATOMIC);
3077 }
3078
3079 static struct rtnetlink_link inet6_rtnetlink_table[RTM_NR_MSGTYPES] = {
3080 [RTM_GETLINK - RTM_BASE] = { .dumpit = inet6_dump_ifinfo, },
3081 [RTM_NEWADDR - RTM_BASE] = { .doit = inet6_rtm_newaddr, },
3082 [RTM_DELADDR - RTM_BASE] = { .doit = inet6_rtm_deladdr, },
3083 [RTM_GETADDR - RTM_BASE] = { .dumpit = inet6_dump_ifaddr, },
3084 [RTM_GETMULTICAST - RTM_BASE] = { .dumpit = inet6_dump_ifmcaddr, },
3085 [RTM_GETANYCAST - RTM_BASE] = { .dumpit = inet6_dump_ifacaddr, },
3086 [RTM_NEWROUTE - RTM_BASE] = { .doit = inet6_rtm_newroute, },
3087 [RTM_DELROUTE - RTM_BASE] = { .doit = inet6_rtm_delroute, },
3088 [RTM_GETROUTE - RTM_BASE] = { .doit = inet6_rtm_getroute,
3089 .dumpit = inet6_dump_fib, },
3090 };
3091
3092 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
3093 {
3094 inet6_ifa_notify(event ? : RTM_NEWADDR, ifp);
3095
3096 switch (event) {
3097 case RTM_NEWADDR:
3098 dst_hold(&ifp->rt->u.dst);
3099 if (ip6_ins_rt(ifp->rt, NULL, NULL))
3100 dst_release(&ifp->rt->u.dst);
3101 if (ifp->idev->cnf.forwarding)
3102 addrconf_join_anycast(ifp);
3103 break;
3104 case RTM_DELADDR:
3105 if (ifp->idev->cnf.forwarding)
3106 addrconf_leave_anycast(ifp);
3107 addrconf_leave_solict(ifp->idev, &ifp->addr);
3108 dst_hold(&ifp->rt->u.dst);
3109 if (ip6_del_rt(ifp->rt, NULL, NULL))
3110 dst_free(&ifp->rt->u.dst);
3111 else
3112 dst_release(&ifp->rt->u.dst);
3113 break;
3114 }
3115 }
3116
3117 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
3118 {
3119 read_lock_bh(&addrconf_lock);
3120 if (likely(ifp->idev->dead == 0))
3121 __ipv6_ifa_notify(event, ifp);
3122 read_unlock_bh(&addrconf_lock);
3123 }
3124
3125 #ifdef CONFIG_SYSCTL
3126
3127 static
3128 int addrconf_sysctl_forward(ctl_table *ctl, int write, struct file * filp,
3129 void __user *buffer, size_t *lenp, loff_t *ppos)
3130 {
3131 int *valp = ctl->data;
3132 int val = *valp;
3133 int ret;
3134
3135 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
3136
3137 if (write && valp != &ipv6_devconf_dflt.forwarding) {
3138 if (valp != &ipv6_devconf.forwarding) {
3139 if ((!*valp) ^ (!val)) {
3140 struct inet6_dev *idev = (struct inet6_dev *)ctl->extra1;
3141 if (idev == NULL)
3142 return ret;
3143 dev_forward_change(idev);
3144 }
3145 } else {
3146 ipv6_devconf_dflt.forwarding = ipv6_devconf.forwarding;
3147 addrconf_forward_change();
3148 }
3149 if (*valp)
3150 rt6_purge_dflt_routers();
3151 }
3152
3153 return ret;
3154 }
3155
3156 static int addrconf_sysctl_forward_strategy(ctl_table *table,
3157 int __user *name, int nlen,
3158 void __user *oldval,
3159 size_t __user *oldlenp,
3160 void __user *newval, size_t newlen,
3161 void **context)
3162 {
3163 int *valp = table->data;
3164 int new;
3165
3166 if (!newval || !newlen)
3167 return 0;
3168 if (newlen != sizeof(int))
3169 return -EINVAL;
3170 if (get_user(new, (int __user *)newval))
3171 return -EFAULT;
3172 if (new == *valp)
3173 return 0;
3174 if (oldval && oldlenp) {
3175 size_t len;
3176 if (get_user(len, oldlenp))
3177 return -EFAULT;
3178 if (len) {
3179 if (len > table->maxlen)
3180 len = table->maxlen;
3181 if (copy_to_user(oldval, valp, len))
3182 return -EFAULT;
3183 if (put_user(len, oldlenp))
3184 return -EFAULT;
3185 }
3186 }
3187
3188 if (valp != &ipv6_devconf_dflt.forwarding) {
3189 if (valp != &ipv6_devconf.forwarding) {
3190 struct inet6_dev *idev = (struct inet6_dev *)table->extra1;
3191 int changed;
3192 if (unlikely(idev == NULL))
3193 return -ENODEV;
3194 changed = (!*valp) ^ (!new);
3195 *valp = new;
3196 if (changed)
3197 dev_forward_change(idev);
3198 } else {
3199 *valp = new;
3200 addrconf_forward_change();
3201 }
3202
3203 if (*valp)
3204 rt6_purge_dflt_routers();
3205 } else
3206 *valp = new;
3207
3208 return 1;
3209 }
3210
3211 static struct addrconf_sysctl_table
3212 {
3213 struct ctl_table_header *sysctl_header;
3214 ctl_table addrconf_vars[__NET_IPV6_MAX];
3215 ctl_table addrconf_dev[2];
3216 ctl_table addrconf_conf_dir[2];
3217 ctl_table addrconf_proto_dir[2];
3218 ctl_table addrconf_root_dir[2];
3219 } addrconf_sysctl = {
3220 .sysctl_header = NULL,
3221 .addrconf_vars = {
3222 {
3223 .ctl_name = NET_IPV6_FORWARDING,
3224 .procname = "forwarding",
3225 .data = &ipv6_devconf.forwarding,
3226 .maxlen = sizeof(int),
3227 .mode = 0644,
3228 .proc_handler = &addrconf_sysctl_forward,
3229 .strategy = &addrconf_sysctl_forward_strategy,
3230 },
3231 {
3232 .ctl_name = NET_IPV6_HOP_LIMIT,
3233 .procname = "hop_limit",
3234 .data = &ipv6_devconf.hop_limit,
3235 .maxlen = sizeof(int),
3236 .mode = 0644,
3237 .proc_handler = proc_dointvec,
3238 },
3239 {
3240 .ctl_name = NET_IPV6_MTU,
3241 .procname = "mtu",
3242 .data = &ipv6_devconf.mtu6,
3243 .maxlen = sizeof(int),
3244 .mode = 0644,
3245 .proc_handler = &proc_dointvec,
3246 },
3247 {
3248 .ctl_name = NET_IPV6_ACCEPT_RA,
3249 .procname = "accept_ra",
3250 .data = &ipv6_devconf.accept_ra,
3251 .maxlen = sizeof(int),
3252 .mode = 0644,
3253 .proc_handler = &proc_dointvec,
3254 },
3255 {
3256 .ctl_name = NET_IPV6_ACCEPT_REDIRECTS,
3257 .procname = "accept_redirects",
3258 .data = &ipv6_devconf.accept_redirects,
3259 .maxlen = sizeof(int),
3260 .mode = 0644,
3261 .proc_handler = &proc_dointvec,
3262 },
3263 {
3264 .ctl_name = NET_IPV6_AUTOCONF,
3265 .procname = "autoconf",
3266 .data = &ipv6_devconf.autoconf,
3267 .maxlen = sizeof(int),
3268 .mode = 0644,
3269 .proc_handler = &proc_dointvec,
3270 },
3271 {
3272 .ctl_name = NET_IPV6_DAD_TRANSMITS,
3273 .procname = "dad_transmits",
3274 .data = &ipv6_devconf.dad_transmits,
3275 .maxlen = sizeof(int),
3276 .mode = 0644,
3277 .proc_handler = &proc_dointvec,
3278 },
3279 {
3280 .ctl_name = NET_IPV6_RTR_SOLICITS,
3281 .procname = "router_solicitations",
3282 .data = &ipv6_devconf.rtr_solicits,
3283 .maxlen = sizeof(int),
3284 .mode = 0644,
3285 .proc_handler = &proc_dointvec,
3286 },
3287 {
3288 .ctl_name = NET_IPV6_RTR_SOLICIT_INTERVAL,
3289 .procname = "router_solicitation_interval",
3290 .data = &ipv6_devconf.rtr_solicit_interval,
3291 .maxlen = sizeof(int),
3292 .mode = 0644,
3293 .proc_handler = &proc_dointvec_jiffies,
3294 .strategy = &sysctl_jiffies,
3295 },
3296 {
3297 .ctl_name = NET_IPV6_RTR_SOLICIT_DELAY,
3298 .procname = "router_solicitation_delay",
3299 .data = &ipv6_devconf.rtr_solicit_delay,
3300 .maxlen = sizeof(int),
3301 .mode = 0644,
3302 .proc_handler = &proc_dointvec_jiffies,
3303 .strategy = &sysctl_jiffies,
3304 },
3305 {
3306 .ctl_name = NET_IPV6_FORCE_MLD_VERSION,
3307 .procname = "force_mld_version",
3308 .data = &ipv6_devconf.force_mld_version,
3309 .maxlen = sizeof(int),
3310 .mode = 0644,
3311 .proc_handler = &proc_dointvec,
3312 },
3313 #ifdef CONFIG_IPV6_PRIVACY
3314 {
3315 .ctl_name = NET_IPV6_USE_TEMPADDR,
3316 .procname = "use_tempaddr",
3317 .data = &ipv6_devconf.use_tempaddr,
3318 .maxlen = sizeof(int),
3319 .mode = 0644,
3320 .proc_handler = &proc_dointvec,
3321 },
3322 {
3323 .ctl_name = NET_IPV6_TEMP_VALID_LFT,
3324 .procname = "temp_valid_lft",
3325 .data = &ipv6_devconf.temp_valid_lft,
3326 .maxlen = sizeof(int),
3327 .mode = 0644,
3328 .proc_handler = &proc_dointvec,
3329 },
3330 {
3331 .ctl_name = NET_IPV6_TEMP_PREFERED_LFT,
3332 .procname = "temp_prefered_lft",
3333 .data = &ipv6_devconf.temp_prefered_lft,
3334 .maxlen = sizeof(int),
3335 .mode = 0644,
3336 .proc_handler = &proc_dointvec,
3337 },
3338 {
3339 .ctl_name = NET_IPV6_REGEN_MAX_RETRY,
3340 .procname = "regen_max_retry",
3341 .data = &ipv6_devconf.regen_max_retry,
3342 .maxlen = sizeof(int),
3343 .mode = 0644,
3344 .proc_handler = &proc_dointvec,
3345 },
3346 {
3347 .ctl_name = NET_IPV6_MAX_DESYNC_FACTOR,
3348 .procname = "max_desync_factor",
3349 .data = &ipv6_devconf.max_desync_factor,
3350 .maxlen = sizeof(int),
3351 .mode = 0644,
3352 .proc_handler = &proc_dointvec,
3353 },
3354 #endif
3355 {
3356 .ctl_name = NET_IPV6_MAX_ADDRESSES,
3357 .procname = "max_addresses",
3358 .data = &ipv6_devconf.max_addresses,
3359 .maxlen = sizeof(int),
3360 .mode = 0644,
3361 .proc_handler = &proc_dointvec,
3362 },
3363 {
3364 .ctl_name = 0, /* sentinel */
3365 }
3366 },
3367 .addrconf_dev = {
3368 {
3369 .ctl_name = NET_PROTO_CONF_ALL,
3370 .procname = "all",
3371 .mode = 0555,
3372 .child = addrconf_sysctl.addrconf_vars,
3373 },
3374 {
3375 .ctl_name = 0, /* sentinel */
3376 }
3377 },
3378 .addrconf_conf_dir = {
3379 {
3380 .ctl_name = NET_IPV6_CONF,
3381 .procname = "conf",
3382 .mode = 0555,
3383 .child = addrconf_sysctl.addrconf_dev,
3384 },
3385 {
3386 .ctl_name = 0, /* sentinel */
3387 }
3388 },
3389 .addrconf_proto_dir = {
3390 {
3391 .ctl_name = NET_IPV6,
3392 .procname = "ipv6",
3393 .mode = 0555,
3394 .child = addrconf_sysctl.addrconf_conf_dir,
3395 },
3396 {
3397 .ctl_name = 0, /* sentinel */
3398 }
3399 },
3400 .addrconf_root_dir = {
3401 {
3402 .ctl_name = CTL_NET,
3403 .procname = "net",
3404 .mode = 0555,
3405 .child = addrconf_sysctl.addrconf_proto_dir,
3406 },
3407 {
3408 .ctl_name = 0, /* sentinel */
3409 }
3410 },
3411 };
3412
3413 static void addrconf_sysctl_register(struct inet6_dev *idev, struct ipv6_devconf *p)
3414 {
3415 int i;
3416 struct net_device *dev = idev ? idev->dev : NULL;
3417 struct addrconf_sysctl_table *t;
3418 char *dev_name = NULL;
3419
3420 t = kmalloc(sizeof(*t), GFP_KERNEL);
3421 if (t == NULL)
3422 return;
3423 memcpy(t, &addrconf_sysctl, sizeof(*t));
3424 for (i=0; t->addrconf_vars[i].data; i++) {
3425 t->addrconf_vars[i].data += (char*)p - (char*)&ipv6_devconf;
3426 t->addrconf_vars[i].de = NULL;
3427 t->addrconf_vars[i].extra1 = idev; /* embedded; no ref */
3428 }
3429 if (dev) {
3430 dev_name = dev->name;
3431 t->addrconf_dev[0].ctl_name = dev->ifindex;
3432 } else {
3433 dev_name = "default";
3434 t->addrconf_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
3435 }
3436
3437 /*
3438 * Make a copy of dev_name, because '.procname' is regarded as const
3439 * by sysctl and we wouldn't want anyone to change it under our feet
3440 * (see SIOCSIFNAME).
3441 */
3442 dev_name = net_sysctl_strdup(dev_name);
3443 if (!dev_name)
3444 goto free;
3445
3446 t->addrconf_dev[0].procname = dev_name;
3447
3448 t->addrconf_dev[0].child = t->addrconf_vars;
3449 t->addrconf_dev[0].de = NULL;
3450 t->addrconf_conf_dir[0].child = t->addrconf_dev;
3451 t->addrconf_conf_dir[0].de = NULL;
3452 t->addrconf_proto_dir[0].child = t->addrconf_conf_dir;
3453 t->addrconf_proto_dir[0].de = NULL;
3454 t->addrconf_root_dir[0].child = t->addrconf_proto_dir;
3455 t->addrconf_root_dir[0].de = NULL;
3456
3457 t->sysctl_header = register_sysctl_table(t->addrconf_root_dir, 0);
3458 if (t->sysctl_header == NULL)
3459 goto free_procname;
3460 else
3461 p->sysctl = t;
3462 return;
3463
3464 /* error path */
3465 free_procname:
3466 kfree(dev_name);
3467 free:
3468 kfree(t);
3469
3470 return;
3471 }
3472
3473 static void addrconf_sysctl_unregister(struct ipv6_devconf *p)
3474 {
3475 if (p->sysctl) {
3476 struct addrconf_sysctl_table *t = p->sysctl;
3477 p->sysctl = NULL;
3478 unregister_sysctl_table(t->sysctl_header);
3479 kfree(t->addrconf_dev[0].procname);
3480 kfree(t);
3481 }
3482 }
3483
3484
3485 #endif
3486
3487 /*
3488 * Device notifier
3489 */
3490
3491 int register_inet6addr_notifier(struct notifier_block *nb)
3492 {
3493 return notifier_chain_register(&inet6addr_chain, nb);
3494 }
3495
3496 int unregister_inet6addr_notifier(struct notifier_block *nb)
3497 {
3498 return notifier_chain_unregister(&inet6addr_chain,nb);
3499 }
3500
3501 /*
3502 * Init / cleanup code
3503 */
3504
3505 int __init addrconf_init(void)
3506 {
3507 int err = 0;
3508
3509 /* The addrconf netdev notifier requires that loopback_dev
3510 * has it's ipv6 private information allocated and setup
3511 * before it can bring up and give link-local addresses
3512 * to other devices which are up.
3513 *
3514 * Unfortunately, loopback_dev is not necessarily the first
3515 * entry in the global dev_base list of net devices. In fact,
3516 * it is likely to be the very last entry on that list.
3517 * So this causes the notifier registry below to try and
3518 * give link-local addresses to all devices besides loopback_dev
3519 * first, then loopback_dev, which cases all the non-loopback_dev
3520 * devices to fail to get a link-local address.
3521 *
3522 * So, as a temporary fix, allocate the ipv6 structure for
3523 * loopback_dev first by hand.
3524 * Longer term, all of the dependencies ipv6 has upon the loopback
3525 * device and it being up should be removed.
3526 */
3527 rtnl_lock();
3528 if (!ipv6_add_dev(&loopback_dev))
3529 err = -ENOMEM;
3530 rtnl_unlock();
3531 if (err)
3532 return err;
3533
3534 register_netdevice_notifier(&ipv6_dev_notf);
3535
3536 #ifdef CONFIG_IPV6_PRIVACY
3537 md5_tfm = crypto_alloc_tfm("md5", 0);
3538 if (unlikely(md5_tfm == NULL))
3539 printk(KERN_WARNING
3540 "failed to load transform for md5\n");
3541 #endif
3542
3543 addrconf_verify(0);
3544 rtnetlink_links[PF_INET6] = inet6_rtnetlink_table;
3545 #ifdef CONFIG_SYSCTL
3546 addrconf_sysctl.sysctl_header =
3547 register_sysctl_table(addrconf_sysctl.addrconf_root_dir, 0);
3548 addrconf_sysctl_register(NULL, &ipv6_devconf_dflt);
3549 #endif
3550
3551 return 0;
3552 }
3553
3554 void __exit addrconf_cleanup(void)
3555 {
3556 struct net_device *dev;
3557 struct inet6_dev *idev;
3558 struct inet6_ifaddr *ifa;
3559 int i;
3560
3561 unregister_netdevice_notifier(&ipv6_dev_notf);
3562
3563 rtnetlink_links[PF_INET6] = NULL;
3564 #ifdef CONFIG_SYSCTL
3565 addrconf_sysctl_unregister(&ipv6_devconf_dflt);
3566 addrconf_sysctl_unregister(&ipv6_devconf);
3567 #endif
3568
3569 rtnl_lock();
3570
3571 /*
3572 * clean dev list.
3573 */
3574
3575 for (dev=dev_base; dev; dev=dev->next) {
3576 if ((idev = __in6_dev_get(dev)) == NULL)
3577 continue;
3578 addrconf_ifdown(dev, 1);
3579 }
3580 addrconf_ifdown(&loopback_dev, 2);
3581
3582 /*
3583 * Check hash table.
3584 */
3585
3586 write_lock_bh(&addrconf_hash_lock);
3587 for (i=0; i < IN6_ADDR_HSIZE; i++) {
3588 for (ifa=inet6_addr_lst[i]; ifa; ) {
3589 struct inet6_ifaddr *bifa;
3590
3591 bifa = ifa;
3592 ifa = ifa->lst_next;
3593 printk(KERN_DEBUG "bug: IPv6 address leakage detected: ifa=%p\n", bifa);
3594 /* Do not free it; something is wrong.
3595 Now we can investigate it with debugger.
3596 */
3597 }
3598 }
3599 write_unlock_bh(&addrconf_hash_lock);
3600
3601 del_timer(&addr_chk_timer);
3602
3603 rtnl_unlock();
3604
3605 #ifdef CONFIG_IPV6_PRIVACY
3606 if (likely(md5_tfm != NULL)) {
3607 crypto_free_tfm(md5_tfm);
3608 md5_tfm = NULL;
3609 }
3610 #endif
3611
3612 #ifdef CONFIG_PROC_FS
3613 proc_net_remove("if_inet6");
3614 #endif
3615 }
Verdex Pro support