开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
addrconf.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：47k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

addrconf.c：源码内容
  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.  */
  17. /*
  18.  * Changes:
  19.  *
  20.  * Janos Farkas : delete timer on ifdown
  21.  * <chexum@bankinf.banki.hu>
  22.  * Andi Kleen : kill doube 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.  */
  33. #include <linux/config.h>
  34. #include <linux/errno.h>
  35. #include <linux/types.h>
  36. #include <linux/socket.h>
  37. #include <linux/sockios.h>
  38. #include <linux/sched.h>
  39. #include <linux/net.h>
  40. #include <linux/in6.h>
  41. #include <linux/netdevice.h>
  42. #include <linux/if_arp.h>
  43. #include <linux/route.h>
  44. #include <linux/inetdevice.h>
  45. #include <linux/init.h>
  46. #ifdef CONFIG_SYSCTL
  47. #include <linux/sysctl.h>
  48. #endif
  49. #include <linux/delay.h>
  50. #include <linux/notifier.h>
  52. #include <linux/proc_fs.h>
  53. #include <net/sock.h>
  54. #include <net/snmp.h>
  56. #include <net/ipv6.h>
  57. #include <net/protocol.h>
  58. #include <net/ndisc.h>
  59. #include <net/ip6_route.h>
  60. #include <net/addrconf.h>
  61. #include <net/ip.h>
  62. #include <linux/if_tunnel.h>
  63. #include <linux/rtnetlink.h>
  65. #include <asm/uaccess.h>
  67. #define IPV6_MAX_ADDRESSES 16
  69. /* Set to 3 to get tracing... */
  70. #define ACONF_DEBUG 2
  72. #if ACONF_DEBUG >= 3
  73. #define ADBG(x) printk x
  74. #else
  75. #define ADBG(x)
  76. #endif
  78. #ifdef CONFIG_SYSCTL
  79. static void addrconf_sysctl_register(struct inet6_dev *idev, struct ipv6_devconf *p);
  80. static void addrconf_sysctl_unregister(struct ipv6_devconf *p);
  81. #endif
  83. int inet6_dev_count;
  84. int inet6_ifa_count;
  86. /*
  87.  * Configured unicast address hash table
  88.  */
  89. static struct inet6_ifaddr *inet6_addr_lst[IN6_ADDR_HSIZE];
  90. static rwlock_t addrconf_hash_lock = RW_LOCK_UNLOCKED;
  92. /* Protects inet6 devices */
  93. rwlock_t addrconf_lock = RW_LOCK_UNLOCKED;
  95. void addrconf_verify(unsigned long);
  97. static struct timer_list addr_chk_timer = { function: addrconf_verify };
  98. static spinlock_t addrconf_verify_lock = SPIN_LOCK_UNLOCKED;
  100. static int addrconf_ifdown(struct net_device *dev, int how);
  102. static void addrconf_dad_start(struct inet6_ifaddr *ifp);
  103. static void addrconf_dad_timer(unsigned long data);
  104. static void addrconf_dad_completed(struct inet6_ifaddr *ifp);
  105. static void addrconf_rs_timer(unsigned long data);
  106. static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
  108. static struct notifier_block *inet6addr_chain;
  110. struct ipv6_devconf ipv6_devconf =
  111. {
  112. 0, /* forwarding */
  113. IPV6_DEFAULT_HOPLIMIT, /* hop limit */
  114. IPV6_MIN_MTU, /* mtu */
  115. 1, /* accept RAs */
  116. 1, /* accept redirects */
  117. 1, /* autoconfiguration */
  118. 1, /* dad transmits */
  119. MAX_RTR_SOLICITATIONS, /* router solicits */
  120. RTR_SOLICITATION_INTERVAL, /* rtr solicit interval */
  121. MAX_RTR_SOLICITATION_DELAY, /* rtr solicit delay */
  122. };
  124. static struct ipv6_devconf ipv6_devconf_dflt =
  125. {
  126. 0, /* forwarding */
  127. IPV6_DEFAULT_HOPLIMIT, /* hop limit */
  128. IPV6_MIN_MTU, /* mtu */
  129. 1, /* accept RAs */
  130. 1, /* accept redirects */
  131. 1, /* autoconfiguration */
  132. 1, /* dad transmits */
  133. MAX_RTR_SOLICITATIONS, /* router solicits */
  134. RTR_SOLICITATION_INTERVAL, /* rtr solicit interval */
  135. MAX_RTR_SOLICITATION_DELAY, /* rtr solicit delay */
  136. };
  138. int ipv6_addr_type(struct in6_addr *addr)
  139. {
  140. u32 st;
  142. st = addr->s6_addr32[0];
  144. /* Consider all addresses with the first three bits different of
  145.    000 and 111 as unicasts.
  146.  */
  147. if ((st & htonl(0xE0000000)) != htonl(0x00000000) &&
  148.     (st & htonl(0xE0000000)) != htonl(0xE0000000))
  149. return IPV6_ADDR_UNICAST;
  151. if ((st & htonl(0xFF000000)) == htonl(0xFF000000)) {
  152. int type = IPV6_ADDR_MULTICAST;
  154. switch((st & htonl(0x00FF0000))) {
  155. case __constant_htonl(0x00010000):
  156. type |= IPV6_ADDR_LOOPBACK;
  157. break;
  159. case __constant_htonl(0x00020000):
  160. type |= IPV6_ADDR_LINKLOCAL;
  161. break;
  163. case __constant_htonl(0x00050000):
  164. type |= IPV6_ADDR_SITELOCAL;
  165. break;
  166. };
  167. return type;
  168. }
  170. if ((st & htonl(0xFFC00000)) == htonl(0xFE800000))
  171. return (IPV6_ADDR_LINKLOCAL | IPV6_ADDR_UNICAST);
  173. if ((st & htonl(0xFFC00000)) == htonl(0xFEC00000))
  174. return (IPV6_ADDR_SITELOCAL | IPV6_ADDR_UNICAST);
  176. if ((addr->s6_addr32[0] | addr->s6_addr32[1]) == 0) {
  177. if (addr->s6_addr32[2] == 0) {
  178. if (addr->s6_addr32[3] == 0)
  179. return IPV6_ADDR_ANY;
  181. if (addr->s6_addr32[3] == htonl(0x00000001))
  182. return (IPV6_ADDR_LOOPBACK | IPV6_ADDR_UNICAST);
  184. return (IPV6_ADDR_COMPATv4 | IPV6_ADDR_UNICAST);
  185. }
  187. if (addr->s6_addr32[2] == htonl(0x0000ffff))
  188. return IPV6_ADDR_MAPPED;
  189. }
  191. return IPV6_ADDR_RESERVED;
  192. }
  194. static void addrconf_del_timer(struct inet6_ifaddr *ifp)
  195. {
  196. if (del_timer(&ifp->timer))
  197. __in6_ifa_put(ifp);
  198. }
  200. enum addrconf_timer_t
  201. {
  202. AC_NONE,
  203. AC_DAD,
  204. AC_RS,
  205. };
  207. static void addrconf_mod_timer(struct inet6_ifaddr *ifp,
  208.        enum addrconf_timer_t what,
  209.        unsigned long when)
  210. {
  211. if (!del_timer(&ifp->timer))
  212. in6_ifa_hold(ifp);
  214. switch (what) {
  215. case AC_DAD:
  216. ifp->timer.function = addrconf_dad_timer;
  217. break;
  218. case AC_RS:
  219. ifp->timer.function = addrconf_rs_timer;
  220. break;
  221. default:;
  222. }
  223. ifp->timer.expires = jiffies + when;
  224. add_timer(&ifp->timer);
  225. }
  228. /* Nobody refers to this device, we may destroy it. */
  230. void in6_dev_finish_destroy(struct inet6_dev *idev)
  231. {
  232. struct net_device *dev = idev->dev;
  233. BUG_TRAP(idev->addr_list==NULL);
  234. BUG_TRAP(idev->mc_list==NULL);
  235. #ifdef NET_REFCNT_DEBUG
  236. printk(KERN_DEBUG "in6_dev_finish_destroy: %sn", dev ? dev->name : "NIL");
  237. #endif
  238. dev_put(dev);
  239. if (!idev->dead) {
  240. printk("Freeing alive inet6 device %pn", idev);
  241. return;
  242. }
  243. inet6_dev_count--;
  244. kfree(idev);
  245. }
  247. static struct inet6_dev * ipv6_add_dev(struct net_device *dev)
  248. {
  249. struct inet6_dev *ndev;
  251. ASSERT_RTNL();
  253. if (dev->mtu < IPV6_MIN_MTU)
  254. return NULL;
  256. ndev = kmalloc(sizeof(struct inet6_dev), GFP_KERNEL);
  258. if (ndev) {
  259. memset(ndev, 0, sizeof(struct inet6_dev));
  261. ndev->lock = RW_LOCK_UNLOCKED;
  262. ndev->dev = dev;
  263. memcpy(&ndev->cnf, &ipv6_devconf_dflt, sizeof(ndev->cnf));
  264. ndev->cnf.mtu6 = dev->mtu;
  265. ndev->cnf.sysctl = NULL;
  266. ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
  267. if (ndev->nd_parms == NULL) {
  268. kfree(ndev);
  269. return NULL;
  270. }
  271. inet6_dev_count++;
  272. /* We refer to the device */
  273. dev_hold(dev);
  275. write_lock_bh(&addrconf_lock);
  276. dev->ip6_ptr = ndev;
  277. /* One reference from device */
  278. in6_dev_hold(ndev);
  279. write_unlock_bh(&addrconf_lock);
  281. ipv6_mc_init_dev(ndev);
  283. #ifdef CONFIG_SYSCTL
  284. neigh_sysctl_register(dev, ndev->nd_parms, NET_IPV6, NET_IPV6_NEIGH, "ipv6");
  285. addrconf_sysctl_register(ndev, &ndev->cnf);
  286. #endif
  287. }
  288. return ndev;
  289. }
  291. static struct inet6_dev * ipv6_find_idev(struct net_device *dev)
  292. {
  293. struct inet6_dev *idev;
  295. ASSERT_RTNL();
  297. if ((idev = __in6_dev_get(dev)) == NULL) {
  298. if ((idev = ipv6_add_dev(dev)) == NULL)
  299. return NULL;
  300. }
  301. if (dev->flags&IFF_UP)
  302. ipv6_mc_up(idev);
  303. return idev;
  304. }
  306. static void addrconf_forward_change(struct inet6_dev *idev)
  307. {
  308. struct net_device *dev;
  310. if (idev)
  311. return;
  313. read_lock(&dev_base_lock);
  314. for (dev=dev_base; dev; dev=dev->next) {
  315. read_lock(&addrconf_lock);
  316. idev = __in6_dev_get(dev);
  317. if (idev)
  318. idev->cnf.forwarding = ipv6_devconf.forwarding;
  319. read_unlock(&addrconf_lock);
  320. }
  321. read_unlock(&dev_base_lock);
  322. }
  324. /* Nobody refers to this ifaddr, destroy it */
  326. void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
  327. {
  328. BUG_TRAP(ifp->if_next==NULL);
  329. BUG_TRAP(ifp->lst_next==NULL);
  330. #ifdef NET_REFCNT_DEBUG
  331. printk(KERN_DEBUG "inet6_ifa_finish_destroyn");
  332. #endif
  334. in6_dev_put(ifp->idev);
  336. if (del_timer(&ifp->timer))
  337. printk("Timer is still running, when freeing ifa=%pn", ifp);
  339. if (!ifp->dead) {
  340. printk("Freeing alive inet6 address %pn", ifp);
  341. return;
  342. }
  343. inet6_ifa_count--;
  344. kfree(ifp);
  345. }
  347. /* On success it returns ifp with increased reference count */
  349. static struct inet6_ifaddr *
  350. ipv6_add_addr(struct inet6_dev *idev, struct in6_addr *addr, int pfxlen,
  351.       int scope, unsigned flags)
  352. {
  353. struct inet6_ifaddr *ifa;
  354. int hash;
  356. ifa = kmalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC);
  358. if (ifa == NULL) {
  359. ADBG(("ipv6_add_addr: malloc failedn"));
  360. return NULL;
  361. }
  363. memset(ifa, 0, sizeof(struct inet6_ifaddr));
  364. ipv6_addr_copy(&ifa->addr, addr);
  366. spin_lock_init(&ifa->lock);
  367. init_timer(&ifa->timer);
  368. ifa->timer.data = (unsigned long) ifa;
  369. ifa->scope = scope;
  370. ifa->prefix_len = pfxlen;
  371. ifa->flags = flags | IFA_F_TENTATIVE;
  373. read_lock(&addrconf_lock);
  374. if (idev->dead) {
  375. read_unlock(&addrconf_lock);
  376. kfree(ifa);
  377. return NULL;
  378. }
  380. inet6_ifa_count++;
  381. ifa->idev = idev;
  382. in6_dev_hold(idev);
  383. /* For caller */
  384. in6_ifa_hold(ifa);
  386. /* Add to big hash table */
  387. hash = ipv6_addr_hash(addr);
  389. write_lock_bh(&addrconf_hash_lock);
  390. ifa->lst_next = inet6_addr_lst[hash];
  391. inet6_addr_lst[hash] = ifa;
  392. in6_ifa_hold(ifa);
  393. write_unlock_bh(&addrconf_hash_lock);
  395. write_lock_bh(&idev->lock);
  396. /* Add to inet6_dev unicast addr list. */
  397. ifa->if_next = idev->addr_list;
  398. idev->addr_list = ifa;
  399. in6_ifa_hold(ifa);
  400. write_unlock_bh(&idev->lock);
  401. read_unlock(&addrconf_lock);
  403. notifier_call_chain(&inet6addr_chain,NETDEV_UP,ifa);
  405. return ifa;
  406. }
  408. /* This function wants to get referenced ifp and releases it before return */
  410. static void ipv6_del_addr(struct inet6_ifaddr *ifp)
  411. {
  412. struct inet6_ifaddr *ifa, **ifap;
  413. struct inet6_dev *idev = ifp->idev;
  414. int hash;
  416. hash = ipv6_addr_hash(&ifp->addr);
  418. ifp->dead = 1;
  420. write_lock_bh(&addrconf_hash_lock);
  421. for (ifap = &inet6_addr_lst[hash]; (ifa=*ifap) != NULL;
  422.      ifap = &ifa->lst_next) {
  423. if (ifa == ifp) {
  424. *ifap = ifa->lst_next;
  425. __in6_ifa_put(ifp);
  426. ifa->lst_next = NULL;
  427. break;
  428. }
  429. }
  430. write_unlock_bh(&addrconf_hash_lock);
  432. write_lock_bh(&idev->lock);
  433. for (ifap = &idev->addr_list; (ifa=*ifap) != NULL;
  434.      ifap = &ifa->if_next) {
  435. if (ifa == ifp) {
  436. *ifap = ifa->if_next;
  437. __in6_ifa_put(ifp);
  438. ifa->if_next = NULL;
  439. break;
  440. }
  441. }
  442. write_unlock_bh(&idev->lock);
  444. ipv6_ifa_notify(RTM_DELADDR, ifp);
  446. notifier_call_chain(&inet6addr_chain,NETDEV_DOWN,ifp);
  448. addrconf_del_timer(ifp);
  450. in6_ifa_put(ifp);
  451. }
  453. /*
  454.  * Choose an apropriate source address
  455.  * should do:
  456.  * i) get an address with an apropriate scope
  457.  * ii) see if there is a specific route for the destination and use
  458.  * an address of the attached interface 
  459.  * iii) don't use deprecated addresses
  460.  */
  461. int ipv6_get_saddr(struct dst_entry *dst,
  462.    struct in6_addr *daddr, struct in6_addr *saddr)
  463. {
  464. int scope;
  465. struct inet6_ifaddr *ifp = NULL;
  466. struct inet6_ifaddr *match = NULL;
  467. struct net_device *dev = NULL;
  468. struct inet6_dev *idev;
  469. struct rt6_info *rt;
  470. int err;
  472. rt = (struct rt6_info *) dst;
  473. if (rt)
  474. dev = rt->rt6i_dev;
  476. scope = ipv6_addr_scope(daddr);
  477. if (rt && (rt->rt6i_flags & RTF_ALLONLINK)) {
  478. /*
  479.  * route for the "all destinations on link" rule
  480.  * when no routers are present
  481.  */
  482. scope = IFA_LINK;
  483. }
  485. /*
  486.  * known dev
  487.  * search dev and walk through dev addresses
  488.  */
  490. if (dev) {
  491. if (dev->flags & IFF_LOOPBACK)
  492. scope = IFA_HOST;
  494. read_lock(&addrconf_lock);
  495. idev = __in6_dev_get(dev);
  496. if (idev) {
  497. read_lock_bh(&idev->lock);
  498. for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) {
  499. if (ifp->scope == scope) {
  500. if (!(ifp->flags & (IFA_F_DEPRECATED|IFA_F_TENTATIVE))) {
  501. in6_ifa_hold(ifp);
  502. read_unlock_bh(&idev->lock);
  503. read_unlock(&addrconf_lock);
  504. goto out;
  505. }
  507. if (!match && !(ifp->flags & IFA_F_TENTATIVE)) {
  508. match = ifp;
  509. in6_ifa_hold(ifp);
  510. }
  511. }
  512. }
  513. read_unlock_bh(&idev->lock);
  514. }
  515. read_unlock(&addrconf_lock);
  516. }
  518. if (scope == IFA_LINK)
  519. goto out;
  521. /*
  522.  * dev == NULL or search failed for specified dev
  523.  */
  525. read_lock(&dev_base_lock);
  526. read_lock(&addrconf_lock);
  527. for (dev = dev_base; dev; dev=dev->next) {
  528. idev = __in6_dev_get(dev);
  529. if (idev) {
  530. read_lock_bh(&idev->lock);
  531. for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) {
  532. if (ifp->scope == scope) {
  533. if (!(ifp->flags&(IFA_F_DEPRECATED|IFA_F_TENTATIVE))) {
  534. in6_ifa_hold(ifp);
  535. read_unlock_bh(&idev->lock);
  536. goto out_unlock_base;
  537. }
  539. if (!match && !(ifp->flags&IFA_F_TENTATIVE)) {
  540. match = ifp;
  541. in6_ifa_hold(ifp);
  542. }
  543. }
  544. }
  545. read_unlock_bh(&idev->lock);
  546. }
  547. }
  549. out_unlock_base:
  550. read_unlock(&addrconf_lock);
  551. read_unlock(&dev_base_lock);
  553. out:
  554. if (ifp == NULL) {
  555. ifp = match;
  556. match = NULL;
  557. }
  559. err = -EADDRNOTAVAIL;
  560. if (ifp) {
  561. ipv6_addr_copy(saddr, &ifp->addr);
  562. err = 0;
  563. in6_ifa_put(ifp);
  564. }
  565. if (match)
  566. in6_ifa_put(match);
  568. return err;
  569. }
  571. int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr)
  572. {
  573. struct inet6_dev *idev;
  574. int err = -EADDRNOTAVAIL;
  576. read_lock(&addrconf_lock);
  577. if ((idev = __in6_dev_get(dev)) != NULL) {
  578. struct inet6_ifaddr *ifp;
  580. read_lock_bh(&idev->lock);
  581. for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) {
  582. if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
  583. ipv6_addr_copy(addr, &ifp->addr);
  584. err = 0;
  585. break;
  586. }
  587. }
  588. read_unlock_bh(&idev->lock);
  589. }
  590. read_unlock(&addrconf_lock);
  591. return err;
  592. }
  594. int ipv6_count_addresses(struct inet6_dev *idev)
  595. {
  596. int cnt = 0;
  597. struct inet6_ifaddr *ifp;
  599. read_lock_bh(&idev->lock);
  600. for (ifp=idev->addr_list; ifp; ifp=ifp->if_next)
  601. cnt++;
  602. read_unlock_bh(&idev->lock);
  603. return cnt;
  604. }
  606. int ipv6_chk_addr(struct in6_addr *addr, struct net_device *dev)
  607. {
  608. struct inet6_ifaddr * ifp;
  609. u8 hash = ipv6_addr_hash(addr);
  611. read_lock_bh(&addrconf_hash_lock);
  612. for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) {
  613. if (ipv6_addr_cmp(&ifp->addr, addr) == 0 &&
  614.     !(ifp->flags&IFA_F_TENTATIVE)) {
  615. if (dev == NULL || ifp->idev->dev == dev ||
  616.     !(ifp->scope&(IFA_LINK|IFA_HOST)))
  617. break;
  618. }
  619. }
  620. read_unlock_bh(&addrconf_hash_lock);
  621. return ifp != NULL;
  622. }
  624. struct inet6_ifaddr * ipv6_get_ifaddr(struct in6_addr *addr, struct net_device *dev)
  625. {
  626. struct inet6_ifaddr * ifp;
  627. u8 hash = ipv6_addr_hash(addr);
  629. read_lock_bh(&addrconf_hash_lock);
  630. for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) {
  631. if (ipv6_addr_cmp(&ifp->addr, addr) == 0) {
  632. if (dev == NULL || ifp->idev->dev == dev ||
  633.     !(ifp->scope&(IFA_LINK|IFA_HOST))) {
  634. in6_ifa_hold(ifp);
  635. break;
  636. }
  637. }
  638. }
  639. read_unlock_bh(&addrconf_hash_lock);
  641. return ifp;
  642. }
  644. /* Gets referenced address, destroys ifaddr */
  646. void addrconf_dad_failure(struct inet6_ifaddr *ifp)
  647. {
  648. if (net_ratelimit())
  649. printk(KERN_INFO "%s: duplicate address detected!n", ifp->idev->dev->name);
  650. if (ifp->flags&IFA_F_PERMANENT) {
  651. spin_lock_bh(&ifp->lock);
  652. addrconf_del_timer(ifp);
  653. ifp->flags |= IFA_F_TENTATIVE;
  654. spin_unlock_bh(&ifp->lock);
  655. in6_ifa_put(ifp);
  656. } else
  657. ipv6_del_addr(ifp);
  658. }
  661. /* Join to solicited addr multicast group. */
  663. static void addrconf_join_solict(struct net_device *dev, struct in6_addr *addr)
  664. {
  665. struct in6_addr maddr;
  667. if (dev->flags&(IFF_LOOPBACK|IFF_NOARP))
  668. return;
  670. addrconf_addr_solict_mult(addr, &maddr);
  671. ipv6_dev_mc_inc(dev, &maddr);
  672. }
  674. static void addrconf_leave_solict(struct net_device *dev, struct in6_addr *addr)
  675. {
  676. struct in6_addr maddr;
  678. if (dev->flags&(IFF_LOOPBACK|IFF_NOARP))
  679. return;
  681. addrconf_addr_solict_mult(addr, &maddr);
  682. ipv6_dev_mc_dec(dev, &maddr);
  683. }
  686. static int ipv6_generate_eui64(u8 *eui, struct net_device *dev)
  687. {
  688. switch (dev->type) {
  689. case ARPHRD_ETHER:
  690. case ARPHRD_FDDI:
  691. case ARPHRD_IEEE802_TR:
  692. if (dev->addr_len != ETH_ALEN)
  693. return -1;
  694. memcpy(eui, dev->dev_addr, 3);
  695. memcpy(eui + 5, dev->dev_addr+3, 3);
  696. eui[3] = 0xFF;
  697. eui[4] = 0xFE;
  698. eui[0] ^= 2;
  699. return 0;
  700. }
  701. return -1;
  702. }
  704. static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev)
  705. {
  706. int err = -1;
  707. struct inet6_ifaddr *ifp;
  709. read_lock_bh(&idev->lock);
  710. for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) {
  711. if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
  712. memcpy(eui, ifp->addr.s6_addr+8, 8);
  713. err = 0;
  714. break;
  715. }
  716. }
  717. read_unlock_bh(&idev->lock);
  718. return err;
  719. }
  721. /*
  722.  * Add prefix route.
  723.  */
  725. static void
  726. addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev,
  727.       unsigned long expires, unsigned flags)
  728. {
  729. struct in6_rtmsg rtmsg;
  731. memset(&rtmsg, 0, sizeof(rtmsg));
  732. memcpy(&rtmsg.rtmsg_dst, pfx, sizeof(struct in6_addr));
  733. rtmsg.rtmsg_dst_len = plen;
  734. rtmsg.rtmsg_metric = IP6_RT_PRIO_ADDRCONF;
  735. rtmsg.rtmsg_ifindex = dev->ifindex;
  736. rtmsg.rtmsg_info = expires;
  737. rtmsg.rtmsg_flags = RTF_UP|flags;
  738. rtmsg.rtmsg_type = RTMSG_NEWROUTE;
  740. /* Prevent useless cloning on PtP SIT.
  741.    This thing is done here expecting that the whole
  742.    class of non-broadcast devices need not cloning.
  743.  */
  744. if (dev->type == ARPHRD_SIT && (dev->flags&IFF_POINTOPOINT))
  745. rtmsg.rtmsg_flags |= RTF_NONEXTHOP;
  747. ip6_route_add(&rtmsg);
  748. }
  750. /* Create "default" multicast route to the interface */
  752. static void addrconf_add_mroute(struct net_device *dev)
  753. {
  754. struct in6_rtmsg rtmsg;
  756. memset(&rtmsg, 0, sizeof(rtmsg));
  757. ipv6_addr_set(&rtmsg.rtmsg_dst,
  758.       htonl(0xFF000000), 0, 0, 0);
  759. rtmsg.rtmsg_dst_len = 8;
  760. rtmsg.rtmsg_metric = IP6_RT_PRIO_ADDRCONF;
  761. rtmsg.rtmsg_ifindex = dev->ifindex;
  762. rtmsg.rtmsg_flags = RTF_UP|RTF_ADDRCONF;
  763. rtmsg.rtmsg_type = RTMSG_NEWROUTE;
  764. ip6_route_add(&rtmsg);
  765. }
  767. static void sit_route_add(struct net_device *dev)
  768. {
  769. struct in6_rtmsg rtmsg;
  771. memset(&rtmsg, 0, sizeof(rtmsg));
  773. rtmsg.rtmsg_type = RTMSG_NEWROUTE;
  774. rtmsg.rtmsg_metric = IP6_RT_PRIO_ADDRCONF;
  776. /* prefix length - 96 bytes "::d.d.d.d" */
  777. rtmsg.rtmsg_dst_len = 96;
  778. rtmsg.rtmsg_flags = RTF_UP|RTF_NONEXTHOP;
  779. rtmsg.rtmsg_ifindex = dev->ifindex;
  781. ip6_route_add(&rtmsg);
  782. }
  784. static void addrconf_add_lroute(struct net_device *dev)
  785. {
  786. struct in6_addr addr;
  788. ipv6_addr_set(&addr,  htonl(0xFE800000), 0, 0, 0);
  789. addrconf_prefix_route(&addr, 10, dev, 0, RTF_ADDRCONF);
  790. }
  792. static struct inet6_dev *addrconf_add_dev(struct net_device *dev)
  793. {
  794. struct inet6_dev *idev;
  796. ASSERT_RTNL();
  798. if ((idev = ipv6_find_idev(dev)) == NULL)
  799. return NULL;
  801. /* Add default multicast route */
  802. addrconf_add_mroute(dev);
  804. /* Add link local route */
  805. addrconf_add_lroute(dev);
  806. return idev;
  807. }
  809. void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len)
  810. {
  811. struct prefix_info *pinfo;
  812. struct rt6_info *rt;
  813. __u32 valid_lft;
  814. __u32 prefered_lft;
  815. int addr_type;
  816. unsigned long rt_expires;
  817. struct inet6_dev *in6_dev;
  819. pinfo = (struct prefix_info *) opt;
  821. if (len < sizeof(struct prefix_info)) {
  822. ADBG(("addrconf: prefix option too shortn"));
  823. return;
  824. }
  826. /*
  827.  * Validation checks ([ADDRCONF], page 19)
  828.  */
  830. addr_type = ipv6_addr_type(&pinfo->prefix);
  832. if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL))
  833. return;
  835. valid_lft = ntohl(pinfo->valid);
  836. prefered_lft = ntohl(pinfo->prefered);
  838. if (prefered_lft > valid_lft) {
  839. if (net_ratelimit())
  840. printk(KERN_WARNING "addrconf: prefix option has invalid lifetimen");
  841. return;
  842. }
  844. in6_dev = in6_dev_get(dev);
  846. if (in6_dev == NULL) {
  847. if (net_ratelimit())
  848. printk(KERN_DEBUG "addrconf: device %s not configuredn", dev->name);
  849. return;
  850. }
  852. /*
  853.  * Two things going on here:
  854.  * 1) Add routes for on-link prefixes
  855.  * 2) Configure prefixes with the auto flag set
  856.  */
  858. /* Avoid arithemtic overflow. Really, we could
  859.    save rt_expires in seconds, likely valid_lft,
  860.    but it would require division in fib gc, that it
  861.    not good.
  862.  */
  863. if (valid_lft >= 0x7FFFFFFF/HZ)
  864. rt_expires = 0;
  865. else
  866. rt_expires = jiffies + valid_lft * HZ;
  868. rt = rt6_lookup(&pinfo->prefix, NULL, dev->ifindex, 1);
  870. if (rt && ((rt->rt6i_flags & (RTF_GATEWAY | RTF_DEFAULT)) == 0)) {
  871. if (rt->rt6i_flags&RTF_EXPIRES) {
  872. if (pinfo->onlink == 0 || valid_lft == 0) {
  873. ip6_del_rt(rt);
  874. rt = NULL;
  875. } else {
  876. rt->rt6i_expires = rt_expires;
  877. }
  878. }
  879. } else if (pinfo->onlink && valid_lft) {
  880. addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
  881.       dev, rt_expires, RTF_ADDRCONF|RTF_EXPIRES);
  882. }
  883. if (rt)
  884. dst_release(&rt->u.dst);
  886. /* Try to figure out our local address for this prefix */
  888. if (pinfo->autoconf && in6_dev->cnf.autoconf) {
  889. struct inet6_ifaddr * ifp;
  890. struct in6_addr addr;
  891. int plen;
  893. plen = pinfo->prefix_len >> 3;
  895. if (pinfo->prefix_len == 64) {
  896. memcpy(&addr, &pinfo->prefix, 8);
  897. if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
  898.     ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
  899. in6_dev_put(in6_dev);
  900. return;
  901. }
  902. goto ok;
  903. }
  904. if (net_ratelimit())
  905. printk(KERN_DEBUG "IPv6 addrconf: prefix with wrong length %dn",
  906.        pinfo->prefix_len);
  907. in6_dev_put(in6_dev);
  908. return;
  910. ok:
  912. ifp = ipv6_get_ifaddr(&addr, dev);
  914. if (ifp == NULL && valid_lft) {
  915. /* Do not allow to create too much of autoconfigured
  916.  * addresses; this would be too easy way to crash kernel.
  917.  */
  918. if (ipv6_count_addresses(in6_dev) < IPV6_MAX_ADDRESSES)
  919. ifp = ipv6_add_addr(in6_dev, &addr, pinfo->prefix_len,
  920.     addr_type&IPV6_ADDR_SCOPE_MASK, 0);
  922. if (ifp == NULL) {
  923. in6_dev_put(in6_dev);
  924. return;
  925. }
  927. addrconf_dad_start(ifp);
  928. }
  930. if (ifp && valid_lft == 0) {
  931. ipv6_del_addr(ifp);
  932. ifp = NULL;
  933. }
  935. if (ifp) {
  936. int flags;
  938. spin_lock(&ifp->lock);
  939. ifp->valid_lft = valid_lft;
  940. ifp->prefered_lft = prefered_lft;
  941. ifp->tstamp = jiffies;
  942. flags = ifp->flags;
  943. ifp->flags &= ~IFA_F_DEPRECATED;
  944. spin_unlock(&ifp->lock);
  946. if (!(flags&IFA_F_TENTATIVE))
  947. ipv6_ifa_notify((flags&IFA_F_DEPRECATED) ?
  948. 0 : RTM_NEWADDR, ifp);
  949. in6_ifa_put(ifp);
  950. }
  951. }
  952. in6_dev_put(in6_dev);
  953. }
  955. /*
  956.  * Set destination address.
  957.  * Special case for SIT interfaces where we create a new "virtual"
  958.  * device.
  959.  */
  960. int addrconf_set_dstaddr(void *arg)
  961. {
  962. struct in6_ifreq ireq;
  963. struct net_device *dev;
  964. int err = -EINVAL;
  966. rtnl_lock();
  968. err = -EFAULT;
  969. if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
  970. goto err_exit;
  972. dev = __dev_get_by_index(ireq.ifr6_ifindex);
  974. err = -ENODEV;
  975. if (dev == NULL)
  976. goto err_exit;
  978. if (dev->type == ARPHRD_SIT) {
  979. struct ifreq ifr;
  980. mm_segment_t oldfs;
  981. struct ip_tunnel_parm p;
  983. err = -EADDRNOTAVAIL;
  984. if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4))
  985. goto err_exit;
  987. memset(&p, 0, sizeof(p));
  988. p.iph.daddr = ireq.ifr6_addr.s6_addr32[3];
  989. p.iph.saddr = 0;
  990. p.iph.version = 4;
  991. p.iph.ihl = 5;
  992. p.iph.protocol = IPPROTO_IPV6;
  993. p.iph.ttl = 64;
  994. ifr.ifr_ifru.ifru_data = (void*)&p;
  996. oldfs = get_fs(); set_fs(KERNEL_DS);
  997. err = dev->do_ioctl(dev, &ifr, SIOCADDTUNNEL);
  998. set_fs(oldfs);
  1000. if (err == 0) {
  1001. err = -ENOBUFS;
  1002. if ((dev = __dev_get_by_name(p.name)) == NULL)
  1003. goto err_exit;
  1004. err = dev_open(dev);
  1005. }
  1006. }
  1008. err_exit:
  1009. rtnl_unlock();
  1010. return err;
  1011. }
  1013. /*
  1014.  * Manual configuration of address on an interface
  1015.  */
  1016. static int inet6_addr_add(int ifindex, struct in6_addr *pfx, int plen)
  1017. {
  1018. struct inet6_ifaddr *ifp;
  1019. struct inet6_dev *idev;
  1020. struct net_device *dev;
  1021. int scope;
  1023. ASSERT_RTNL();
  1025. if ((dev = __dev_get_by_index(ifindex)) == NULL)
  1026. return -ENODEV;
  1028. if (!(dev->flags&IFF_UP))
  1029. return -ENETDOWN;
  1031. if ((idev = addrconf_add_dev(dev)) == NULL)
  1032. return -ENOBUFS;
  1034. scope = ipv6_addr_scope(pfx);
  1036. if ((ifp = ipv6_add_addr(idev, pfx, plen, scope, IFA_F_PERMANENT)) != NULL) {
  1037. addrconf_dad_start(ifp);
  1038. in6_ifa_put(ifp);
  1039. return 0;
  1040. }
  1042. return -ENOBUFS;
  1043. }
  1045. static int inet6_addr_del(int ifindex, struct in6_addr *pfx, int plen)
  1046. {
  1047. struct inet6_ifaddr *ifp;
  1048. struct inet6_dev *idev;
  1049. struct net_device *dev;
  1051. if ((dev = __dev_get_by_index(ifindex)) == NULL)
  1052. return -ENODEV;
  1054. if ((idev = __in6_dev_get(dev)) == NULL)
  1055. return -ENXIO;
  1057. read_lock_bh(&idev->lock);
  1058. for (ifp = idev->addr_list; ifp; ifp=ifp->if_next) {
  1059. if (ifp->prefix_len == plen &&
  1060.     (!memcmp(pfx, &ifp->addr, sizeof(struct in6_addr)))) {
  1061. in6_ifa_hold(ifp);
  1062. read_unlock_bh(&idev->lock);
  1064. ipv6_del_addr(ifp);
  1066. /* If the last address is deleted administratively,
  1067.    disable IPv6 on this interface.
  1068.  */
  1069. if (idev->addr_list == NULL)
  1070. addrconf_ifdown(idev->dev, 1);
  1071. return 0;
  1072. }
  1073. }
  1074. read_unlock_bh(&idev->lock);
  1075. return -EADDRNOTAVAIL;
  1076. }
  1079. int addrconf_add_ifaddr(void *arg)
  1080. {
  1081. struct in6_ifreq ireq;
  1082. int err;
  1084. if (!capable(CAP_NET_ADMIN))
  1085. return -EPERM;
  1087. if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
  1088. return -EFAULT;
  1090. rtnl_lock();
  1091. err = inet6_addr_add(ireq.ifr6_ifindex, &ireq.ifr6_addr, ireq.ifr6_prefixlen);
  1092. rtnl_unlock();
  1093. return err;
  1094. }
  1096. int addrconf_del_ifaddr(void *arg)
  1097. {
  1098. struct in6_ifreq ireq;
  1099. int err;
  1101. if (!capable(CAP_NET_ADMIN))
  1102. return -EPERM;
  1104. if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
  1105. return -EFAULT;
  1107. rtnl_lock();
  1108. err = inet6_addr_del(ireq.ifr6_ifindex, &ireq.ifr6_addr, ireq.ifr6_prefixlen);
  1109. rtnl_unlock();
  1110. return err;
  1111. }
  1113. static void sit_add_v4_addrs(struct inet6_dev *idev)
  1114. {
  1115. struct inet6_ifaddr * ifp;
  1116. struct in6_addr addr;
  1117. struct net_device *dev;
  1118. int scope;
  1120. ASSERT_RTNL();
  1122. memset(&addr, 0, sizeof(struct in6_addr));
  1123. memcpy(&addr.s6_addr32[3], idev->dev->dev_addr, 4);
  1125. if (idev->dev->flags&IFF_POINTOPOINT) {
  1126. addr.s6_addr32[0] = htonl(0xfe800000);
  1127. scope = IFA_LINK;
  1128. } else {
  1129. scope = IPV6_ADDR_COMPATv4;
  1130. }
  1132. if (addr.s6_addr32[3]) {
  1133. ifp = ipv6_add_addr(idev, &addr, 128, scope, IFA_F_PERMANENT);
  1134. if (ifp) {
  1135. spin_lock_bh(&ifp->lock);
  1136. ifp->flags &= ~IFA_F_TENTATIVE;
  1137. spin_unlock_bh(&ifp->lock);
  1138. ipv6_ifa_notify(RTM_NEWADDR, ifp);
  1139. in6_ifa_put(ifp);
  1140. }
  1141. return;
  1142. }
  1144.         for (dev = dev_base; dev != NULL; dev = dev->next) {
  1145. struct in_device * in_dev = __in_dev_get(dev);
  1146. if (in_dev && (dev->flags & IFF_UP)) {
  1147. struct in_ifaddr * ifa;
  1149. int flag = scope;
  1151. for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
  1152. int plen;
  1154. addr.s6_addr32[3] = ifa->ifa_local;
  1156. if (ifa->ifa_scope == RT_SCOPE_LINK)
  1157. continue;
  1158. if (ifa->ifa_scope >= RT_SCOPE_HOST) {
  1159. if (idev->dev->flags&IFF_POINTOPOINT)
  1160. continue;
  1161. flag |= IFA_HOST;
  1162. }
  1163. if (idev->dev->flags&IFF_POINTOPOINT)
  1164. plen = 10;
  1165. else
  1166. plen = 96;
  1168. ifp = ipv6_add_addr(idev, &addr, plen, flag,
  1169.     IFA_F_PERMANENT);
  1170. if (ifp) {
  1171. spin_lock_bh(&ifp->lock);
  1172. ifp->flags &= ~IFA_F_TENTATIVE;
  1173. spin_unlock_bh(&ifp->lock);
  1174. ipv6_ifa_notify(RTM_NEWADDR, ifp);
  1175. in6_ifa_put(ifp);
  1176. }
  1177. }
  1178. }
  1179.         }
  1180. }
  1182. static void init_loopback(struct net_device *dev)
  1183. {
  1184. struct in6_addr addr;
  1185. struct inet6_dev  *idev;
  1186. struct inet6_ifaddr * ifp;
  1188. /* ::1 */
  1190. ASSERT_RTNL();
  1192. memset(&addr, 0, sizeof(struct in6_addr));
  1193. addr.s6_addr32[3] = htonl(0x00000001);
  1195. if ((idev = ipv6_find_idev(dev)) == NULL) {
  1196. printk(KERN_DEBUG "init loopback: add_dev failedn");
  1197. return;
  1198. }
  1200. ifp = ipv6_add_addr(idev, &addr, 128, IFA_HOST, IFA_F_PERMANENT);
  1201. if (ifp) {
  1202. spin_lock_bh(&ifp->lock);
  1203. ifp->flags &= ~IFA_F_TENTATIVE;
  1204. spin_unlock_bh(&ifp->lock);
  1205. ipv6_ifa_notify(RTM_NEWADDR, ifp);
  1206. in6_ifa_put(ifp);
  1207. }
  1208. }
  1210. static void addrconf_add_linklocal(struct inet6_dev *idev, struct in6_addr *addr)
  1211. {
  1212. struct inet6_ifaddr * ifp;
  1214. ifp = ipv6_add_addr(idev, addr, 10, IFA_LINK, IFA_F_PERMANENT);
  1215. if (ifp) {
  1216. addrconf_dad_start(ifp);
  1217. in6_ifa_put(ifp);
  1218. }
  1219. }
  1221. static void addrconf_dev_config(struct net_device *dev)
  1222. {
  1223. struct in6_addr addr;
  1224. struct inet6_dev    * idev;
  1226. ASSERT_RTNL();
  1228. if ((dev->type != ARPHRD_ETHER) && 
  1229.     (dev->type != ARPHRD_FDDI) &&
  1230.     (dev->type != ARPHRD_IEEE802_TR)) {
  1231. /* Alas, we support only Ethernet autoconfiguration. */
  1232. return;
  1233. }
  1235. idev = addrconf_add_dev(dev);
  1236. if (idev == NULL)
  1237. return;
  1239. memset(&addr, 0, sizeof(struct in6_addr));
  1240. addr.s6_addr32[0] = htonl(0xFE800000);
  1242. if (ipv6_generate_eui64(addr.s6_addr + 8, dev) == 0)
  1243. addrconf_add_linklocal(idev, &addr);
  1244. }
  1246. static void addrconf_sit_config(struct net_device *dev)
  1247. {
  1248. struct inet6_dev *idev;
  1250. ASSERT_RTNL();
  1252. /* 
  1253.  * Configure the tunnel with one of our IPv4 
  1254.  * addresses... we should configure all of 
  1255.  * our v4 addrs in the tunnel
  1256.  */
  1258. if ((idev = ipv6_find_idev(dev)) == NULL) {
  1259. printk(KERN_DEBUG "init sit: add_dev failedn");
  1260. return;
  1261. }
  1263. sit_add_v4_addrs(idev);
  1265. if (dev->flags&IFF_POINTOPOINT) {
  1266. addrconf_add_mroute(dev);
  1267. addrconf_add_lroute(dev);
  1268. } else
  1269. sit_route_add(dev);
  1270. }
  1273. int addrconf_notify(struct notifier_block *this, unsigned long event, 
  1274.     void * data)
  1275. {
  1276. struct net_device *dev = (struct net_device *) data;
  1277. struct inet6_dev *idev = __in6_dev_get(dev);
  1279. switch(event) {
  1280. case NETDEV_UP:
  1281. switch(dev->type) {
  1282. case ARPHRD_SIT:
  1283. addrconf_sit_config(dev);
  1284. break;
  1286. case ARPHRD_LOOPBACK:
  1287. init_loopback(dev);
  1288. break;
  1290. default:
  1291. addrconf_dev_config(dev);
  1292. break;
  1293. };
  1294. if (idev) {
  1295. /* If the MTU changed during the interface down, when the 
  1296.    interface up, the changed MTU must be reflected in the 
  1297.    idev as well as routers.
  1298.  */
  1299. if (idev->cnf.mtu6 != dev->mtu && dev->mtu >= IPV6_MIN_MTU) {
  1300. rt6_mtu_change(dev, dev->mtu);
  1301. idev->cnf.mtu6 = dev->mtu;
  1302. }
  1303. /* If the changed mtu during down is lower than IPV6_MIN_MTU
  1304.    stop IPv6 on this interface.
  1305.  */
  1306. if (dev->mtu < IPV6_MIN_MTU)
  1307. addrconf_ifdown(dev, event != NETDEV_DOWN);
  1308. }
  1309. break;
  1311. case NETDEV_CHANGEMTU:
  1312. if ( idev && dev->mtu >= IPV6_MIN_MTU) {
  1313. rt6_mtu_change(dev, dev->mtu);
  1314. idev->cnf.mtu6 = dev->mtu;
  1315. break;
  1316. }
  1318. /* MTU falled under IPV6_MIN_MTU. Stop IPv6 on this interface. */
  1320. case NETDEV_DOWN:
  1321. case NETDEV_UNREGISTER:
  1322. /*
  1323.  * Remove all addresses from this interface.
  1324.  */
  1325. addrconf_ifdown(dev, event != NETDEV_DOWN);
  1326. break;
  1327. case NETDEV_CHANGE:
  1328. break;
  1329. };
  1331. return NOTIFY_OK;
  1332. }
  1334. static int addrconf_ifdown(struct net_device *dev, int how)
  1335. {
  1336. struct inet6_dev *idev;
  1337. struct inet6_ifaddr *ifa, **bifa;
  1338. int i;
  1340. ASSERT_RTNL();
  1342. rt6_ifdown(dev);
  1343. neigh_ifdown(&nd_tbl, dev);
  1345. idev = __in6_dev_get(dev);
  1346. if (idev == NULL)
  1347. return -ENODEV;
  1349. /* Step 1: remove reference to ipv6 device from parent device.
  1350.            Do not dev_put!
  1351.  */
  1352. if (how == 1) {
  1353. write_lock_bh(&addrconf_lock);
  1354. dev->ip6_ptr = NULL;
  1355. idev->dead = 1;
  1356. write_unlock_bh(&addrconf_lock);
  1357. }
  1359. /* Step 2: clear hash table */
  1360. for (i=0; i<IN6_ADDR_HSIZE; i++) {
  1361. bifa = &inet6_addr_lst[i];
  1363. write_lock_bh(&addrconf_hash_lock);
  1364. while ((ifa = *bifa) != NULL) {
  1365. if (ifa->idev == idev) {
  1366. *bifa = ifa->lst_next;
  1367. ifa->lst_next = NULL;
  1368. addrconf_del_timer(ifa);
  1369. in6_ifa_put(ifa);
  1370. continue;
  1371. }
  1372. bifa = &ifa->lst_next;
  1373. }
  1374. write_unlock_bh(&addrconf_hash_lock);
  1375. }
  1377. /* Step 3: clear address list */
  1379. write_lock_bh(&idev->lock);
  1380. while ((ifa = idev->addr_list) != NULL) {
  1381. idev->addr_list = ifa->if_next;
  1382. ifa->if_next = NULL;
  1383. ifa->dead = 1;
  1384. addrconf_del_timer(ifa);
  1385. write_unlock_bh(&idev->lock);
  1387. ipv6_ifa_notify(RTM_DELADDR, ifa);
  1388. in6_ifa_put(ifa);
  1390. write_lock_bh(&idev->lock);
  1391. }
  1392. write_unlock_bh(&idev->lock);
  1394. /* Step 4: Discard multicast list */
  1396. if (how == 1)
  1397. ipv6_mc_destroy_dev(idev);
  1398. else
  1399. ipv6_mc_down(idev);
  1401. /* Shot the device (if unregistered) */
  1403. if (how == 1) {
  1404. neigh_parms_release(&nd_tbl, idev->nd_parms);
  1405. #ifdef CONFIG_SYSCTL
  1406. addrconf_sysctl_unregister(&idev->cnf);
  1407. #endif
  1408. in6_dev_put(idev);
  1409. }
  1410. return 0;
  1411. }
  1413. static void addrconf_rs_timer(unsigned long data)
  1414. {
  1415. struct inet6_ifaddr *ifp = (struct inet6_ifaddr *) data;
  1417. if (ifp->idev->cnf.forwarding)
  1418. goto out;
  1420. if (ifp->idev->if_flags & IF_RA_RCVD) {
  1421. /*
  1422.  * Announcement received after solicitation
  1423.  * was sent
  1424.  */
  1425. goto out;
  1426. }
  1428. spin_lock(&ifp->lock);
  1429. if (ifp->probes++ < ifp->idev->cnf.rtr_solicits) {
  1430. struct in6_addr all_routers;
  1432. /* The wait after the last probe can be shorter */
  1433. addrconf_mod_timer(ifp, AC_RS,
  1434.    (ifp->probes == ifp->idev->cnf.rtr_solicits) ?
  1435.    ifp->idev->cnf.rtr_solicit_delay :
  1436.    ifp->idev->cnf.rtr_solicit_interval);
  1437. spin_unlock(&ifp->lock);
  1439. ipv6_addr_all_routers(&all_routers);
  1441. ndisc_send_rs(ifp->idev->dev, &ifp->addr, &all_routers);
  1442. } else {
  1443. struct in6_rtmsg rtmsg;
  1445. spin_unlock(&ifp->lock);
  1447. printk(KERN_DEBUG "%s: no IPv6 routers presentn",
  1448.        ifp->idev->dev->name);
  1450. memset(&rtmsg, 0, sizeof(struct in6_rtmsg));
  1451. rtmsg.rtmsg_type = RTMSG_NEWROUTE;
  1452. rtmsg.rtmsg_metric = IP6_RT_PRIO_ADDRCONF;
  1453. rtmsg.rtmsg_flags = (RTF_ALLONLINK | RTF_ADDRCONF | 
  1454.      RTF_DEFAULT | RTF_UP);
  1456. rtmsg.rtmsg_ifindex = ifp->idev->dev->ifindex;
  1458. ip6_route_add(&rtmsg);
  1459. }
  1461. out:
  1462. in6_ifa_put(ifp);
  1463. }
  1465. /*
  1466.  * Duplicate Address Detection
  1467.  */
  1468. static void addrconf_dad_start(struct inet6_ifaddr *ifp)
  1469. {
  1470. struct net_device *dev;
  1471. unsigned long rand_num;
  1473. dev = ifp->idev->dev;
  1475. addrconf_join_solict(dev, &ifp->addr);
  1477. if (ifp->prefix_len != 128 && (ifp->flags&IFA_F_PERMANENT))
  1478. addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev, 0, RTF_ADDRCONF);
  1480. net_srandom(ifp->addr.s6_addr32[3]);
  1481. rand_num = net_random() % (ifp->idev->cnf.rtr_solicit_delay ? : 1);
  1483. spin_lock_bh(&ifp->lock);
  1485. if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) ||
  1486.     !(ifp->flags&IFA_F_TENTATIVE)) {
  1487. ifp->flags &= ~IFA_F_TENTATIVE;
  1488. spin_unlock_bh(&ifp->lock);
  1490. addrconf_dad_completed(ifp);
  1491. return;
  1492. }
  1494. ifp->probes = ifp->idev->cnf.dad_transmits;
  1495. addrconf_mod_timer(ifp, AC_DAD, rand_num);
  1497. spin_unlock_bh(&ifp->lock);
  1498. }
  1500. static void addrconf_dad_timer(unsigned long data)
  1501. {
  1502. struct inet6_ifaddr *ifp = (struct inet6_ifaddr *) data;
  1503. struct in6_addr unspec;
  1504. struct in6_addr mcaddr;
  1506. spin_lock_bh(&ifp->lock);
  1507. if (ifp->probes == 0) {
  1508. /*
  1509.  * DAD was successful
  1510.  */
  1512. ifp->flags &= ~IFA_F_TENTATIVE;
  1513. spin_unlock_bh(&ifp->lock);
  1515. addrconf_dad_completed(ifp);
  1517. in6_ifa_put(ifp);
  1518. return;
  1519. }
  1521. ifp->probes--;
  1522. addrconf_mod_timer(ifp, AC_DAD, ifp->idev->nd_parms->retrans_time);
  1523. spin_unlock_bh(&ifp->lock);
  1525. /* send a neighbour solicitation for our addr */
  1526. memset(&unspec, 0, sizeof(unspec));
  1527. addrconf_addr_solict_mult(&ifp->addr, &mcaddr);
  1528. ndisc_send_ns(ifp->idev->dev, NULL, &ifp->addr, &mcaddr, &unspec);
  1530. in6_ifa_put(ifp);
  1531. }
  1533. static void addrconf_dad_completed(struct inet6_ifaddr *ifp)
  1534. {
  1535. struct net_device * dev = ifp->idev->dev;
  1537. /*
  1538.  * Configure the address for reception. Now it is valid.
  1539.  */
  1541. ipv6_ifa_notify(RTM_NEWADDR, ifp);
  1543. /* If added prefix is link local and forwarding is off,
  1544.    start sending router solicitations.
  1545.  */
  1547. if (ifp->idev->cnf.forwarding == 0 &&
  1548.     (dev->flags&IFF_LOOPBACK) == 0 &&
  1549.     (ipv6_addr_type(&ifp->addr) & IPV6_ADDR_LINKLOCAL)) {
  1550. struct in6_addr all_routers;
  1552. ipv6_addr_all_routers(&all_routers);
  1554. /*
  1555.  * If a host as already performed a random delay
  1556.  * [...] as part of DAD [...] there is no need
  1557.  * to delay again before sending the first RS
  1558.  */
  1559. ndisc_send_rs(ifp->idev->dev, &ifp->addr, &all_routers);
  1561. spin_lock_bh(&ifp->lock);
  1562. ifp->probes = 1;
  1563. ifp->idev->if_flags |= IF_RS_SENT;
  1564. addrconf_mod_timer(ifp, AC_RS, ifp->idev->cnf.rtr_solicit_interval);
  1565. spin_unlock_bh(&ifp->lock);
  1566. }
  1567. }
  1569. #ifdef CONFIG_PROC_FS
  1570. static int iface_proc_info(char *buffer, char **start, off_t offset,
  1571.    int length)
  1572. {
  1573. struct inet6_ifaddr *ifp;
  1574. int i;
  1575. int len = 0;
  1576. off_t pos=0;
  1577. off_t begin=0;
  1579. for (i=0; i < IN6_ADDR_HSIZE; i++) {
  1580. read_lock_bh(&addrconf_hash_lock);
  1581. for (ifp=inet6_addr_lst[i]; ifp; ifp=ifp->lst_next) {
  1582. int j;
  1584. for (j=0; j<16; j++) {
  1585. sprintf(buffer + len, "%02x",
  1586. ifp->addr.s6_addr[j]);
  1587. len += 2;
  1588. }
  1590. len += sprintf(buffer + len,
  1591.        " %02x %02x %02x %02x %8sn",
  1592.        ifp->idev->dev->ifindex,
  1593.        ifp->prefix_len,
  1594.        ifp->scope,
  1595.        ifp->flags,
  1596.        ifp->idev->dev->name);
  1597. pos=begin+len;
  1598. if(pos<offset) {
  1599. len=0;
  1600. begin=pos;
  1601. }
  1602. if(pos>offset+length) {
  1603. read_unlock_bh(&addrconf_hash_lock);
  1604. goto done;
  1605. }
  1606. }
  1607. read_unlock_bh(&addrconf_hash_lock);
  1608. }
  1610. done:
  1612. *start=buffer+(offset-begin);
  1613. len-=(offset-begin);
  1614. if(len>length)
  1615. len=length;
  1616. if(len<0)
  1617. len=0;
  1618. return len;
  1619. }
  1621. #endif /* CONFIG_PROC_FS */
  1623. /*
  1624.  * Periodic address status verification
  1625.  */
  1627. void addrconf_verify(unsigned long foo)
  1628. {
  1629. struct inet6_ifaddr *ifp;
  1630. unsigned long now, next;
  1631. int i;
  1633. spin_lock_bh(&addrconf_verify_lock);
  1634. now = jiffies;
  1635. next = now + ADDR_CHECK_FREQUENCY;
  1637. del_timer(&addr_chk_timer);
  1639. for (i=0; i < IN6_ADDR_HSIZE; i++) {
  1641. restart:
  1642. write_lock(&addrconf_hash_lock);
  1643. for (ifp=inet6_addr_lst[i]; ifp; ifp=ifp->lst_next) {
  1644. unsigned long age;
  1646. if (ifp->flags & IFA_F_PERMANENT)
  1647. continue;
  1649. spin_lock(&ifp->lock);
  1650. age = (now - ifp->tstamp) / HZ;
  1652. if (age >= ifp->valid_lft) {
  1653. spin_unlock(&ifp->lock);
  1654. in6_ifa_hold(ifp);
  1655. write_unlock(&addrconf_hash_lock);
  1656. ipv6_del_addr(ifp);
  1657. goto restart;
  1658. } else if (age >= ifp->prefered_lft) {
  1659. /* jiffies - ifp->tsamp > age >= ifp->prefered_lft */
  1660. int deprecate = 0;
  1662. if (!(ifp->flags&IFA_F_DEPRECATED)) {
  1663. deprecate = 1;
  1664. ifp->flags |= IFA_F_DEPRECATED;
  1665. }
  1667. if (time_before(ifp->tstamp + ifp->valid_lft * HZ, next))
  1668. next = ifp->tstamp + ifp->valid_lft * HZ;
  1670. spin_unlock(&ifp->lock);
  1672. if (deprecate) {
  1673. in6_ifa_hold(ifp);
  1674. write_unlock(&addrconf_hash_lock);
  1676. ipv6_ifa_notify(0, ifp);
  1677. in6_ifa_put(ifp);
  1678. goto restart;
  1679. }
  1680. } else {
  1681. /* ifp->prefered_lft <= ifp->valid_lft */
  1682. if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
  1683. next = ifp->tstamp + ifp->prefered_lft * HZ;
  1684. spin_unlock(&ifp->lock);
  1685. }
  1686. }
  1687. write_unlock(&addrconf_hash_lock);
  1688. }
  1690. addr_chk_timer.expires = time_before(next, jiffies + HZ) ? jiffies + HZ : next;
  1691. add_timer(&addr_chk_timer);
  1692. spin_unlock_bh(&addrconf_verify_lock);
  1693. }
  1695. static int
  1696. inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
  1697. {
  1698. struct rtattr **rta = arg;
  1699. struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
  1700. struct in6_addr *pfx;
  1702. pfx = NULL;
  1703. if (rta[IFA_ADDRESS-1]) {
  1704. if (RTA_PAYLOAD(rta[IFA_ADDRESS-1]) < sizeof(*pfx))
  1705. return -EINVAL;
  1706. pfx = RTA_DATA(rta[IFA_ADDRESS-1]);
  1707. }
  1708. if (rta[IFA_LOCAL-1]) {
  1709. if (pfx && memcmp(pfx, RTA_DATA(rta[IFA_LOCAL-1]), sizeof(*pfx)))
  1710. return -EINVAL;
  1711. pfx = RTA_DATA(rta[IFA_LOCAL-1]);
  1712. }
  1713. if (pfx == NULL)
  1714. return -EINVAL;
  1716. return inet6_addr_del(ifm->ifa_index, pfx, ifm->ifa_prefixlen);
  1717. }
  1719. static int
  1720. inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
  1721. {
  1722. struct rtattr  **rta = arg;
  1723. struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
  1724. struct in6_addr *pfx;
  1726. pfx = NULL;
  1727. if (rta[IFA_ADDRESS-1]) {
  1728. if (RTA_PAYLOAD(rta[IFA_ADDRESS-1]) < sizeof(*pfx))
  1729. return -EINVAL;
  1730. pfx = RTA_DATA(rta[IFA_ADDRESS-1]);
  1731. }
  1732. if (rta[IFA_LOCAL-1]) {
  1733. if (pfx && memcmp(pfx, RTA_DATA(rta[IFA_LOCAL-1]), sizeof(*pfx)))
  1734. return -EINVAL;
  1735. pfx = RTA_DATA(rta[IFA_LOCAL-1]);
  1736. }
  1737. if (pfx == NULL)
  1738. return -EINVAL;
  1740. return inet6_addr_add(ifm->ifa_index, pfx, ifm->ifa_prefixlen);
  1741. }
  1743. static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
  1744.      u32 pid, u32 seq, int event)
  1745. {
  1746. struct ifaddrmsg *ifm;
  1747. struct nlmsghdr  *nlh;
  1748. struct ifa_cacheinfo ci;
  1749. unsigned char  *b = skb->tail;
  1751. nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(*ifm));
  1752. ifm = NLMSG_DATA(nlh);
  1753. ifm->ifa_family = AF_INET6;
  1754. ifm->ifa_prefixlen = ifa->prefix_len;
  1755. ifm->ifa_flags = ifa->flags;
  1756. ifm->ifa_scope = RT_SCOPE_UNIVERSE;
  1757. if (ifa->scope&IFA_HOST)
  1758. ifm->ifa_scope = RT_SCOPE_HOST;
  1759. else if (ifa->scope&IFA_LINK)
  1760. ifm->ifa_scope = RT_SCOPE_LINK;
  1761. else if (ifa->scope&IFA_SITE)
  1762. ifm->ifa_scope = RT_SCOPE_SITE;
  1763. ifm->ifa_index = ifa->idev->dev->ifindex;
  1764. RTA_PUT(skb, IFA_ADDRESS, 16, &ifa->addr);
  1765. if (!(ifa->flags&IFA_F_PERMANENT)) {
  1766. ci.ifa_prefered = ifa->prefered_lft;
  1767. ci.ifa_valid = ifa->valid_lft;
  1768. if (ci.ifa_prefered != 0xFFFFFFFF) {
  1769. long tval = (jiffies - ifa->tstamp)/HZ;
  1770. ci.ifa_prefered -= tval;
  1771. if (ci.ifa_valid != 0xFFFFFFFF)
  1772. ci.ifa_valid -= tval;
  1773. }
  1774. RTA_PUT(skb, IFA_CACHEINFO, sizeof(ci), &ci);
  1775. }
  1776. nlh->nlmsg_len = skb->tail - b;
  1777. return skb->len;
  1779. nlmsg_failure:
  1780. rtattr_failure:
  1781. skb_trim(skb, b - skb->data);
  1782. return -1;
  1783. }
  1785. static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
  1786. {
  1787. int idx, ip_idx;
  1788. int s_idx, s_ip_idx;
  1789.   struct inet6_ifaddr *ifa;
  1791. s_idx = cb->args[0];
  1792. s_ip_idx = ip_idx = cb->args[1];
  1794. for (idx=0; idx < IN6_ADDR_HSIZE; idx++) {
  1795. if (idx < s_idx)
  1796. continue;
  1797. if (idx > s_idx)
  1798. s_ip_idx = 0;
  1799. read_lock_bh(&addrconf_hash_lock);
  1800. for (ifa=inet6_addr_lst[idx], ip_idx = 0; ifa;
  1801.      ifa = ifa->lst_next, ip_idx++) {
  1802. if (ip_idx < s_ip_idx)
  1803. continue;
  1804. if (inet6_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
  1805.       cb->nlh->nlmsg_seq, RTM_NEWADDR) <= 0) {
  1806. read_unlock_bh(&addrconf_hash_lock);
  1807. goto done;
  1808. }
  1809. }
  1810. read_unlock_bh(&addrconf_hash_lock);
  1811. }
  1812. done:
  1813. cb->args[0] = idx;
  1814. cb->args[1] = ip_idx;
  1816. return skb->len;
  1817. }
  1819. static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa)
  1820. {
  1821. struct sk_buff *skb;
  1822. int size = NLMSG_SPACE(sizeof(struct ifaddrmsg)+128);
  1824. skb = alloc_skb(size, GFP_ATOMIC);
  1825. if (!skb) {
  1826. netlink_set_err(rtnl, 0, RTMGRP_IPV6_IFADDR, ENOBUFS);
  1827. return;
  1828. }
  1829. if (inet6_fill_ifaddr(skb, ifa, 0, 0, event) < 0) {
  1830. kfree_skb(skb);
  1831. netlink_set_err(rtnl, 0, RTMGRP_IPV6_IFADDR, EINVAL);
  1832. return;
  1833. }
  1834. NETLINK_CB(skb).dst_groups = RTMGRP_IPV6_IFADDR;
  1835. netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV6_IFADDR, GFP_ATOMIC);
  1836. }
  1838. static struct rtnetlink_link inet6_rtnetlink_table[RTM_MAX-RTM_BASE+1] =
  1839. {
  1840. { NULL, NULL, },
  1841. { NULL, NULL, },
  1842. { NULL, NULL, },
  1843. { NULL, NULL, },
  1845. { inet6_rtm_newaddr, NULL, },
  1846. { inet6_rtm_deladdr, NULL, },
  1847. { NULL, inet6_dump_ifaddr, },
  1848. { NULL, NULL, },
  1850. { inet6_rtm_newroute, NULL, },
  1851. { inet6_rtm_delroute, NULL, },
  1852. { inet6_rtm_getroute, inet6_dump_fib, },
  1853. { NULL, NULL, },
  1854. };
  1856. static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
  1857. {
  1858. inet6_ifa_notify(event ? : RTM_NEWADDR, ifp);
  1860. switch (event) {
  1861. case RTM_NEWADDR:
  1862. ip6_rt_addr_add(&ifp->addr, ifp->idev->dev);
  1863. break;
  1864. case RTM_DELADDR:
  1865. addrconf_leave_solict(ifp->idev->dev, &ifp->addr);
  1866. if (!ipv6_chk_addr(&ifp->addr, NULL))
  1867. ip6_rt_addr_del(&ifp->addr, ifp->idev->dev);
  1868. break;
  1869. }
  1870. }
  1872. #ifdef CONFIG_SYSCTL
  1874. static
  1875. int addrconf_sysctl_forward(ctl_table *ctl, int write, struct file * filp,
  1876.    void *buffer, size_t *lenp)
  1877. {
  1878. int *valp = ctl->data;
  1879. int val = *valp;
  1880. int ret;
  1882. ret = proc_dointvec(ctl, write, filp, buffer, lenp);
  1884. if (write && *valp != val && valp != &ipv6_devconf_dflt.forwarding) {
  1885. struct inet6_dev *idev = NULL;
  1887. if (valp != &ipv6_devconf.forwarding) {
  1888. struct net_device *dev = dev_get_by_index(ctl->ctl_name);
  1889. if (dev) {
  1890. idev = in6_dev_get(dev);
  1891. dev_put(dev);
  1892. }
  1893. if (idev == NULL)
  1894. return ret;
  1895. } else
  1896. ipv6_devconf_dflt.forwarding = ipv6_devconf.forwarding;
  1898. addrconf_forward_change(idev);
  1900. if (*valp)
  1901. rt6_purge_dflt_routers(0);
  1902. if (idev)
  1903. in6_dev_put(idev);
  1904. }
  1906.         return ret;
  1907. }
  1909. static struct addrconf_sysctl_table
  1910. {
  1911. struct ctl_table_header *sysctl_header;
  1912. ctl_table addrconf_vars[11];
  1913. ctl_table addrconf_dev[2];
  1914. ctl_table addrconf_conf_dir[2];
  1915. ctl_table addrconf_proto_dir[2];
  1916. ctl_table addrconf_root_dir[2];
  1917. } addrconf_sysctl = {
  1918. NULL,
  1919.         {{NET_IPV6_FORWARDING, "forwarding",
  1920.          &ipv6_devconf.forwarding, sizeof(int), 0644, NULL,
  1921.          &addrconf_sysctl_forward},
  1923. {NET_IPV6_HOP_LIMIT, "hop_limit",
  1924.          &ipv6_devconf.hop_limit, sizeof(int), 0644, NULL,
  1925.          &proc_dointvec},
  1927. {NET_IPV6_MTU, "mtu",
  1928.          &ipv6_devconf.mtu6, sizeof(int), 0644, NULL,
  1929.          &proc_dointvec},
  1931. {NET_IPV6_ACCEPT_RA, "accept_ra",
  1932.          &ipv6_devconf.accept_ra, sizeof(int), 0644, NULL,
  1933.          &proc_dointvec},
  1935. {NET_IPV6_ACCEPT_REDIRECTS, "accept_redirects",
  1936.          &ipv6_devconf.accept_redirects, sizeof(int), 0644, NULL,
  1937.          &proc_dointvec},
  1939. {NET_IPV6_AUTOCONF, "autoconf",
  1940.          &ipv6_devconf.autoconf, sizeof(int), 0644, NULL,
  1941.          &proc_dointvec},
  1943. {NET_IPV6_DAD_TRANSMITS, "dad_transmits",
  1944.          &ipv6_devconf.dad_transmits, sizeof(int), 0644, NULL,
  1945.          &proc_dointvec},
  1947. {NET_IPV6_RTR_SOLICITS, "router_solicitations",
  1948.          &ipv6_devconf.rtr_solicits, sizeof(int), 0644, NULL,
  1949.          &proc_dointvec},
  1951. {NET_IPV6_RTR_SOLICIT_INTERVAL, "router_solicitation_interval",
  1952.          &ipv6_devconf.rtr_solicit_interval, sizeof(int), 0644, NULL,
  1953.          &proc_dointvec_jiffies},
  1955. {NET_IPV6_RTR_SOLICIT_DELAY, "router_solicitation_delay",
  1956.          &ipv6_devconf.rtr_solicit_delay, sizeof(int), 0644, NULL,
  1957.          &proc_dointvec_jiffies},
  1959. {0}},
  1961. {{NET_PROTO_CONF_ALL, "all", NULL, 0, 0555, addrconf_sysctl.addrconf_vars},{0}},
  1962. {{NET_IPV6_CONF, "conf", NULL, 0, 0555, addrconf_sysctl.addrconf_dev},{0}},
  1963. {{NET_IPV6, "ipv6", NULL, 0, 0555, addrconf_sysctl.addrconf_conf_dir},{0}},
  1964. {{CTL_NET, "net", NULL, 0, 0555, addrconf_sysctl.addrconf_proto_dir},{0}}
  1965. };
  1967. static void addrconf_sysctl_register(struct inet6_dev *idev, struct ipv6_devconf *p)
  1968. {
  1969. int i;
  1970. struct net_device *dev = idev ? idev->dev : NULL;
  1971. struct addrconf_sysctl_table *t;
  1973. t = kmalloc(sizeof(*t), GFP_KERNEL);
  1974. if (t == NULL)
  1975. return;
  1976. memcpy(t, &addrconf_sysctl, sizeof(*t));
  1977. for (i=0; i<sizeof(t->addrconf_vars)/sizeof(t->addrconf_vars[0])-1; i++) {
  1978. t->addrconf_vars[i].data += (char*)p - (char*)&ipv6_devconf;
  1979. t->addrconf_vars[i].de = NULL;
  1980. }
  1981. if (dev) {
  1982. t->addrconf_dev[0].procname = dev->name;
  1983. t->addrconf_dev[0].ctl_name = dev->ifindex;
  1984. } else {
  1985. t->addrconf_dev[0].procname = "default";
  1986. t->addrconf_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
  1987. }
  1988. t->addrconf_dev[0].child = t->addrconf_vars;
  1989. t->addrconf_dev[0].de = NULL;
  1990. t->addrconf_conf_dir[0].child = t->addrconf_dev;
  1991. t->addrconf_conf_dir[0].de = NULL;
  1992. t->addrconf_proto_dir[0].child = t->addrconf_conf_dir;
  1993. t->addrconf_proto_dir[0].de = NULL;
  1994. t->addrconf_root_dir[0].child = t->addrconf_proto_dir;
  1995. t->addrconf_root_dir[0].de = NULL;
  1997. t->sysctl_header = register_sysctl_table(t->addrconf_root_dir, 0);
  1998. if (t->sysctl_header == NULL)
  1999. kfree(t);
  2000. else
  2001. p->sysctl = t;
  2002. }
  2004. static void addrconf_sysctl_unregister(struct ipv6_devconf *p)
  2005. {
  2006. if (p->sysctl) {
  2007. struct addrconf_sysctl_table *t = p->sysctl;
  2008. p->sysctl = NULL;
  2009. unregister_sysctl_table(t->sysctl_header);
  2010. kfree(t);
  2011. }
  2012. }
  2015. #endif
  2017. /*
  2018.  *      Device notifier
  2019.  */
  2021. int register_inet6addr_notifier(struct notifier_block *nb)
  2022. {
  2023.         return notifier_chain_register(&inet6addr_chain, nb);
  2024. }
  2026. int unregister_inet6addr_notifier(struct notifier_block *nb)
  2027. {
  2028.         return notifier_chain_unregister(&inet6addr_chain,nb);
  2029. }
  2031. /*
  2032.  * Init / cleanup code
  2033.  */
  2035. void __init addrconf_init(void)
  2036. {
  2037. #ifdef MODULE
  2038. struct net_device *dev;
  2040. /* This takes sense only during module load. */
  2041. rtnl_lock();
  2042. for (dev = dev_base; dev; dev = dev->next) {
  2043. if (!(dev->flags&IFF_UP))
  2044. continue;
  2046. switch (dev->type) {
  2047. case ARPHRD_LOOPBACK:
  2048. init_loopback(dev);
  2049. break;
  2050. case ARPHRD_ETHER:
  2051. case ARPHRD_FDDI:
  2052. case ARPHRD_IEEE802_TR:
  2053. addrconf_dev_config(dev);
  2054. break;
  2055. default:;
  2056. /* Ignore all other */
  2057. }
  2058. }
  2059. rtnl_unlock();
  2060. #endif
  2062. #ifdef CONFIG_PROC_FS
  2063. proc_net_create("if_inet6", 0, iface_proc_info);
  2064. #endif
  2066. addrconf_verify(0);
  2067. rtnetlink_links[PF_INET6] = inet6_rtnetlink_table;
  2068. #ifdef CONFIG_SYSCTL
  2069. addrconf_sysctl.sysctl_header =
  2070. register_sysctl_table(addrconf_sysctl.addrconf_root_dir, 0);
  2071. addrconf_sysctl_register(NULL, &ipv6_devconf_dflt);
  2072. #endif
  2073. }
  2075. #ifdef MODULE
  2076. void addrconf_cleanup(void)
  2077. {
  2078.   struct net_device *dev;
  2079.   struct inet6_dev *idev;
  2080.   struct inet6_ifaddr *ifa;
  2081. int i;
  2083. rtnetlink_links[PF_INET6] = NULL;
  2084. #ifdef CONFIG_SYSCTL
  2085. addrconf_sysctl_unregister(&ipv6_devconf_dflt);
  2086. addrconf_sysctl_unregister(&ipv6_devconf);
  2087. #endif
  2089. rtnl_lock();
  2091. /*
  2092.  * clean dev list.
  2093.  */
  2095. for (dev=dev_base; dev; dev=dev->next) {
  2096. if ((idev = __in6_dev_get(dev)) == NULL)
  2097. continue;
  2098. addrconf_ifdown(dev, 1);
  2099. }
  2101. /*
  2102.  * Check hash table.
  2103.  */
  2105. write_lock_bh(&addrconf_hash_lock);
  2106. for (i=0; i < IN6_ADDR_HSIZE; i++) {
  2107. for (ifa=inet6_addr_lst[i]; ifa; ) {
  2108. struct inet6_ifaddr *bifa;
  2110. bifa = ifa;
  2111. ifa = ifa->lst_next;
  2112. printk(KERN_DEBUG "bug: IPv6 address leakage detected: ifa=%pn", bifa);
  2113. /* Do not free it; something is wrong.
  2114.    Now we can investigate it with debugger.
  2115.  */
  2116. }
  2117. }
  2118. write_unlock_bh(&addrconf_hash_lock);
  2120. del_timer(&addr_chk_timer);
  2122. rtnl_unlock();
  2124. #ifdef CONFIG_PROC_FS
  2125. proc_net_remove("if_inet6");
  2126. #endif
  2127. }
  2128. #endif /* MODULE */