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

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

Linux/Unix编程

开发平台：

Unix_Linux

ndisc.c：源码内容
  1. /*
  2.  * Neighbour Discovery for IPv6
  3.  * Linux INET6 implementation 
  4.  *
  5.  * Authors:
  6.  * Pedro Roque <roque@di.fc.ul.pt>
  7.  * Mike Shaver <shaver@ingenia.com>
  8.  *
  9.  * This program is free software; you can redistribute it and/or
  10.  *      modify it under the terms of the GNU General Public License
  11.  *      as published by the Free Software Foundation; either version
  12.  *      2 of the License, or (at your option) any later version.
  13.  */
  15. /*
  16.  * Changes:
  17.  *
  18.  * Lars Fenneberg : fixed MTU setting on receipt
  19.  * of an RA.
  20.  *
  21.  * Janos Farkas : kmalloc failure checks
  22.  * Alexey Kuznetsov : state machine reworked
  23.  * and moved to net/core.
  24.  * Pekka Savola : RFC2461 validation
  25.  * YOSHIFUJI Hideaki @USAGI : Verify ND options properly
  26.  */
  28. /* Set to 3 to get tracing... */
  29. #define ND_DEBUG 1
  31. #define ND_PRINTK(x...) printk(KERN_DEBUG x)
  32. #define ND_NOPRINTK(x...) do { ; } while(0)
  33. #define ND_PRINTK0 ND_PRINTK
  34. #define ND_PRINTK1 ND_NOPRINTK
  35. #define ND_PRINTK2 ND_NOPRINTK
  36. #if ND_DEBUG >= 1
  37. #undef ND_PRINTK1
  38. #define ND_PRINTK1 ND_PRINTK
  39. #endif
  40. #if ND_DEBUG >= 2
  41. #undef ND_PRINTK2
  42. #define ND_PRINTK2 ND_PRINTK
  43. #endif
  45. #define __NO_VERSION__
  46. #include <linux/module.h>
  47. #include <linux/config.h>
  48. #include <linux/errno.h>
  49. #include <linux/types.h>
  50. #include <linux/socket.h>
  51. #include <linux/sockios.h>
  52. #include <linux/sched.h>
  53. #include <linux/net.h>
  54. #include <linux/in6.h>
  55. #include <linux/route.h>
  56. #include <linux/init.h>
  57. #ifdef CONFIG_SYSCTL
  58. #include <linux/sysctl.h>
  59. #endif
  61. #include <linux/if_arp.h>
  62. #include <linux/ipv6.h>
  63. #include <linux/icmpv6.h>
  65. #include <net/sock.h>
  66. #include <net/snmp.h>
  68. #include <net/ipv6.h>
  69. #include <net/protocol.h>
  70. #include <net/ndisc.h>
  71. #include <net/ip6_route.h>
  72. #include <net/addrconf.h>
  73. #include <net/icmp.h>
  75. #include <net/checksum.h>
  76. #include <linux/proc_fs.h>
  78. static struct socket *ndisc_socket;
  80. static u32 ndisc_hash(const void *pkey, const struct net_device *dev);
  81. static int ndisc_constructor(struct neighbour *neigh);
  82. static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
  83. static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
  84. static int pndisc_constructor(struct pneigh_entry *n);
  85. static void pndisc_destructor(struct pneigh_entry *n);
  86. static void pndisc_redo(struct sk_buff *skb);
  88. static struct neigh_ops ndisc_generic_ops =
  89. {
  90. AF_INET6,
  91. NULL,
  92. ndisc_solicit,
  93. ndisc_error_report,
  94. neigh_resolve_output,
  95. neigh_connected_output,
  96. dev_queue_xmit,
  97. dev_queue_xmit
  98. };
  100. static struct neigh_ops ndisc_hh_ops =
  101. {
  102. AF_INET6,
  103. NULL,
  104. ndisc_solicit,
  105. ndisc_error_report,
  106. neigh_resolve_output,
  107. neigh_resolve_output,
  108. dev_queue_xmit,
  109. dev_queue_xmit
  110. };
  113. static struct neigh_ops ndisc_direct_ops =
  114. {
  115. AF_INET6,
  116. NULL,
  117. NULL,
  118. NULL,
  119. dev_queue_xmit,
  120. dev_queue_xmit,
  121. dev_queue_xmit,
  122. dev_queue_xmit
  123. };
  125. struct neigh_table nd_tbl =
  126. {
  127. NULL,
  128. AF_INET6,
  129. sizeof(struct neighbour) + sizeof(struct in6_addr),
  130. sizeof(struct in6_addr),
  131. ndisc_hash,
  132. ndisc_constructor,
  133. pndisc_constructor,
  134. pndisc_destructor,
  135. pndisc_redo,
  136. "ndisc_cache",
  137.         { NULL, NULL, &nd_tbl, 0, NULL, NULL,
  138.   30*HZ, 1*HZ, 60*HZ, 30*HZ, 5*HZ, 3, 3, 0, 3, 1*HZ, (8*HZ)/10, 64, 0 },
  139. 30*HZ, 128, 512, 1024,
  140. };
  142. #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
  144. static u8 *ndisc_fill_option(u8 *opt, int type, void *data, int data_len)
  145. {
  146. int space = NDISC_OPT_SPACE(data_len);
  148. opt[0] = type;
  149. opt[1] = space>>3;
  150. memcpy(opt+2, data, data_len);
  151. data_len += 2;
  152. opt += data_len;
  153. if ((space -= data_len) > 0)
  154. memset(opt, 0, space);
  155. return opt + space;
  156. }
  158. struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
  159.      struct nd_opt_hdr *end)
  160. {
  161. int type;
  162. if (!cur || !end || cur >= end)
  163. return NULL;
  164. type = cur->nd_opt_type;
  165. do {
  166. cur = ((void *)cur) + (cur->nd_opt_len << 3);
  167. } while(cur < end && cur->nd_opt_type != type);
  168. return (cur <= end && cur->nd_opt_type == type ? cur : NULL);
  169. }
  171. struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
  172.   struct ndisc_options *ndopts)
  173. {
  174. struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
  176. if (!nd_opt || opt_len < 0 || !ndopts)
  177. return NULL;
  178. memset(ndopts, 0, sizeof(*ndopts));
  179. while (opt_len) {
  180. int l;
  181. if (opt_len < sizeof(struct nd_opt_hdr))
  182. return NULL;
  183. l = nd_opt->nd_opt_len << 3;
  184. if (opt_len < l || l == 0)
  185. return NULL;
  186. switch (nd_opt->nd_opt_type) {
  187. case ND_OPT_SOURCE_LL_ADDR:
  188. case ND_OPT_TARGET_LL_ADDR:
  189. case ND_OPT_MTU:
  190. case ND_OPT_REDIRECT_HDR:
  191. if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
  192. ND_PRINTK2((KERN_WARNING
  193.     "ndisc_parse_options(): duplicated ND6 option found: type=%dn",
  194.     nd_opt->nd_opt_type));
  195. } else {
  196. ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
  197. }
  198. break;
  199. case ND_OPT_PREFIX_INFO:
  200. ndopts->nd_opts_pi_end = nd_opt;
  201. if (ndopts->nd_opt_array[nd_opt->nd_opt_type] == 0)
  202. ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
  203. break;
  204. default:
  205. /*
  206.  * Unknown options must be silently ignored,
  207.  * to accomodate future extension to the protocol.
  208.  */
  209. ND_PRINTK2(KERN_WARNING
  210.    "ndisc_parse_options(): ignored unsupported option; type=%d, len=%dn",
  211.    nd_opt->nd_opt_type, nd_opt->nd_opt_len);
  212. }
  213. opt_len -= l;
  214. nd_opt = ((void *)nd_opt) + l;
  215. }
  216. return ndopts;
  217. }
  219. int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
  220. {
  221. switch (dev->type) {
  222. case ARPHRD_ETHER:
  223. case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
  224. case ARPHRD_FDDI:
  225. ipv6_eth_mc_map(addr, buf);
  226. return 0;
  227. case ARPHRD_IEEE802_TR:
  228. ipv6_tr_mc_map(addr,buf);
  229. return 0;
  230. default:
  231. if (dir) {
  232. memcpy(buf, dev->broadcast, dev->addr_len);
  233. return 0;
  234. }
  235. }
  236. return -EINVAL;
  237. }
  239. static u32 ndisc_hash(const void *pkey, const struct net_device *dev)
  240. {
  241. u32 hash_val;
  243. hash_val = *(u32*)(pkey + sizeof(struct in6_addr) - 4);
  244. hash_val ^= (hash_val>>16);
  245. hash_val ^= hash_val>>8;
  246. hash_val ^= hash_val>>3;
  247. hash_val = (hash_val^dev->ifindex)&NEIGH_HASHMASK;
  249. return hash_val;
  250. }
  252. static int ndisc_constructor(struct neighbour *neigh)
  253. {
  254. struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
  255. struct net_device *dev = neigh->dev;
  256. struct inet6_dev *in6_dev = in6_dev_get(dev);
  257. int addr_type;
  259. if (in6_dev == NULL)
  260. return -EINVAL;
  262. addr_type = ipv6_addr_type(addr);
  263. if (in6_dev->nd_parms)
  264. neigh->parms = in6_dev->nd_parms;
  266. if (addr_type&IPV6_ADDR_MULTICAST)
  267. neigh->type = RTN_MULTICAST;
  268. else
  269. neigh->type = RTN_UNICAST;
  270. if (dev->hard_header == NULL) {
  271. neigh->nud_state = NUD_NOARP;
  272. neigh->ops = &ndisc_direct_ops;
  273. neigh->output = neigh->ops->queue_xmit;
  274. } else {
  275. if (addr_type&IPV6_ADDR_MULTICAST) {
  276. neigh->nud_state = NUD_NOARP;
  277. ndisc_mc_map(addr, neigh->ha, dev, 1);
  278. } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
  279. neigh->nud_state = NUD_NOARP;
  280. memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
  281. if (dev->flags&IFF_LOOPBACK)
  282. neigh->type = RTN_LOCAL;
  283. } else if (dev->flags&IFF_POINTOPOINT) {
  284. neigh->nud_state = NUD_NOARP;
  285. memcpy(neigh->ha, dev->broadcast, dev->addr_len);
  286. }
  287. if (dev->hard_header_cache)
  288. neigh->ops = &ndisc_hh_ops;
  289. else
  290. neigh->ops = &ndisc_generic_ops;
  291. if (neigh->nud_state&NUD_VALID)
  292. neigh->output = neigh->ops->connected_output;
  293. else
  294. neigh->output = neigh->ops->output;
  295. }
  296. in6_dev_put(in6_dev);
  297. return 0;
  298. }
  300. static int pndisc_constructor(struct pneigh_entry *n)
  301. {
  302. struct in6_addr *addr = (struct in6_addr*)&n->key;
  303. struct in6_addr maddr;
  304. struct net_device *dev = n->dev;
  306. if (dev == NULL || __in6_dev_get(dev) == NULL)
  307. return -EINVAL;
  308. addrconf_addr_solict_mult(addr, &maddr);
  309. ipv6_dev_mc_inc(dev, &maddr);
  310. return 0;
  311. }
  313. static void pndisc_destructor(struct pneigh_entry *n)
  314. {
  315. struct in6_addr *addr = (struct in6_addr*)&n->key;
  316. struct in6_addr maddr;
  317. struct net_device *dev = n->dev;
  319. if (dev == NULL || __in6_dev_get(dev) == NULL)
  320. return;
  321. addrconf_addr_solict_mult(addr, &maddr);
  322. ipv6_dev_mc_dec(dev, &maddr);
  323. }
  327. static int
  328. ndisc_build_ll_hdr(struct sk_buff *skb, struct net_device *dev,
  329.    struct in6_addr *daddr, struct neighbour *neigh, int len)
  330. {
  331. unsigned char ha[MAX_ADDR_LEN];
  332. unsigned char *h_dest = NULL;
  334. skb_reserve(skb, (dev->hard_header_len + 15) & ~15);
  336. if (dev->hard_header) {
  337. if (ipv6_addr_type(daddr) & IPV6_ADDR_MULTICAST) {
  338. ndisc_mc_map(daddr, ha, dev, 1);
  339. h_dest = ha;
  340. } else if (neigh) {
  341. read_lock_bh(&neigh->lock);
  342. if (neigh->nud_state&NUD_VALID) {
  343. memcpy(ha, neigh->ha, dev->addr_len);
  344. h_dest = ha;
  345. }
  346. read_unlock_bh(&neigh->lock);
  347. } else {
  348. neigh = neigh_lookup(&nd_tbl, daddr, dev);
  349. if (neigh) {
  350. read_lock_bh(&neigh->lock);
  351. if (neigh->nud_state&NUD_VALID) {
  352. memcpy(ha, neigh->ha, dev->addr_len);
  353. h_dest = ha;
  354. }
  355. read_unlock_bh(&neigh->lock);
  356. neigh_release(neigh);
  357. }
  358. }
  360. if (dev->hard_header(skb, dev, ETH_P_IPV6, h_dest, NULL, len) < 0)
  361. return 0;
  362. }
  364. return 1;
  365. }
  368. /*
  369.  * Send a Neighbour Advertisement
  370.  */
  372. void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
  373.    struct in6_addr *daddr, struct in6_addr *solicited_addr,
  374.    int router, int solicited, int override, int inc_opt) 
  375. {
  376.         struct sock *sk = ndisc_socket->sk;
  377.         struct nd_msg *msg;
  378.         int len;
  379.         struct sk_buff *skb;
  380. int err;
  382. len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);
  384. if (inc_opt) {
  385. if (dev->addr_len)
  386. len += NDISC_OPT_SPACE(dev->addr_len);
  387. else
  388. inc_opt = 0;
  389. }
  391. skb = sock_alloc_send_skb(sk, MAX_HEADER + len + dev->hard_header_len + 15,
  392.   0, &err);
  394. if (skb == NULL) {
  395. ND_PRINTK1("send_na: alloc skb failedn");
  396. return;
  397. }
  399. if (ndisc_build_ll_hdr(skb, dev, daddr, neigh, len) == 0) {
  400. kfree_skb(skb);
  401. return;
  402. }
  404. ip6_nd_hdr(sk, skb, dev, solicited_addr, daddr, IPPROTO_ICMPV6, len);
  406. msg = (struct nd_msg *) skb_put(skb, len);
  408.         msg->icmph.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT;
  409.         msg->icmph.icmp6_code = 0;
  410.         msg->icmph.icmp6_cksum = 0;
  412.         msg->icmph.icmp6_unused = 0;
  413.         msg->icmph.icmp6_router    = router;
  414.         msg->icmph.icmp6_solicited = solicited;
  415.         msg->icmph.icmp6_override  = !!override;
  417.         /* Set the target address. */
  418. ipv6_addr_copy(&msg->target, solicited_addr);
  420. if (inc_opt)
  421. ndisc_fill_option(msg->opt, ND_OPT_TARGET_LL_ADDR, dev->dev_addr, dev->addr_len);
  423. /* checksum */
  424. msg->icmph.icmp6_cksum = csum_ipv6_magic(solicited_addr, daddr, len, 
  425.  IPPROTO_ICMPV6,
  426.  csum_partial((__u8 *) msg, 
  427.       len, 0));
  429. dev_queue_xmit(skb);
  431. ICMP6_INC_STATS(Icmp6OutNeighborAdvertisements);
  432. ICMP6_INC_STATS(Icmp6OutMsgs);
  433. }        
  435. void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
  436.    struct in6_addr *solicit,
  437.    struct in6_addr *daddr, struct in6_addr *saddr) 
  438. {
  439.         struct sock *sk = ndisc_socket->sk;
  440.         struct sk_buff *skb;
  441.         struct nd_msg *msg;
  442. struct in6_addr addr_buf;
  443.         int len;
  444. int err;
  445. int send_llinfo;
  447. if (saddr == NULL) {
  448. if (ipv6_get_lladdr(dev, &addr_buf))
  449. return;
  450. saddr = &addr_buf;
  451. }
  453. len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);
  454. send_llinfo = dev->addr_len && ipv6_addr_type(saddr) != IPV6_ADDR_ANY;
  455. if (send_llinfo)
  456. len += NDISC_OPT_SPACE(dev->addr_len);
  458. skb = sock_alloc_send_skb(sk, MAX_HEADER + len + dev->hard_header_len + 15,
  459.   0, &err);
  460. if (skb == NULL) {
  461. ND_PRINTK1("send_ns: alloc skb failedn");
  462. return;
  463. }
  465. if (ndisc_build_ll_hdr(skb, dev, daddr, neigh, len) == 0) {
  466. kfree_skb(skb);
  467. return;
  468. }
  470. ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
  472. msg = (struct nd_msg *)skb_put(skb, len);
  473. msg->icmph.icmp6_type = NDISC_NEIGHBOUR_SOLICITATION;
  474. msg->icmph.icmp6_code = 0;
  475. msg->icmph.icmp6_cksum = 0;
  476. msg->icmph.icmp6_unused = 0;
  478. /* Set the target address. */
  479. ipv6_addr_copy(&msg->target, solicit);
  481. if (send_llinfo)
  482. ndisc_fill_option(msg->opt, ND_OPT_SOURCE_LL_ADDR, dev->dev_addr, dev->addr_len);
  484. /* checksum */
  485. msg->icmph.icmp6_cksum = csum_ipv6_magic(&skb->nh.ipv6h->saddr,
  486.  daddr, len, 
  487.  IPPROTO_ICMPV6,
  488.  csum_partial((__u8 *) msg, 
  489.       len, 0));
  490. /* send it! */
  491. dev_queue_xmit(skb);
  493. ICMP6_INC_STATS(Icmp6OutNeighborSolicits);
  494. ICMP6_INC_STATS(Icmp6OutMsgs);
  495. }
  497. void ndisc_send_rs(struct net_device *dev, struct in6_addr *saddr,
  498.    struct in6_addr *daddr)
  499. {
  500. struct sock *sk = ndisc_socket->sk;
  501.         struct sk_buff *skb;
  502.         struct icmp6hdr *hdr;
  503. __u8 * opt;
  504.         int len;
  505. int err;
  507. len = sizeof(struct icmp6hdr);
  508. if (dev->addr_len)
  509. len += NDISC_OPT_SPACE(dev->addr_len);
  511.         skb = sock_alloc_send_skb(sk, MAX_HEADER + len + dev->hard_header_len + 15,
  512.   0, &err);
  513. if (skb == NULL) {
  514. ND_PRINTK1("send_ns: alloc skb failedn");
  515. return;
  516. }
  518. if (ndisc_build_ll_hdr(skb, dev, daddr, NULL, len) == 0) {
  519. kfree_skb(skb);
  520. return;
  521. }
  523. ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
  525.         hdr = (struct icmp6hdr *) skb_put(skb, len);
  526.         hdr->icmp6_type = NDISC_ROUTER_SOLICITATION;
  527.         hdr->icmp6_code = 0;
  528.         hdr->icmp6_cksum = 0;
  529.         hdr->icmp6_unused = 0;
  531. opt = (u8*) (hdr + 1);
  533. if (dev->addr_len)
  534. ndisc_fill_option(opt, ND_OPT_SOURCE_LL_ADDR, dev->dev_addr, dev->addr_len);
  536. /* checksum */
  537. hdr->icmp6_cksum = csum_ipv6_magic(&skb->nh.ipv6h->saddr, daddr, len,
  538.    IPPROTO_ICMPV6,
  539.    csum_partial((__u8 *) hdr, len, 0));
  541. /* send it! */
  542. dev_queue_xmit(skb);
  544. ICMP6_INC_STATS(Icmp6OutRouterSolicits);
  545. ICMP6_INC_STATS(Icmp6OutMsgs);
  546. }
  547.    
  549. static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
  550. {
  551. /*
  552.  * "The sender MUST return an ICMP
  553.  *  destination unreachable"
  554.  */
  555. dst_link_failure(skb);
  556. kfree_skb(skb);
  557. }
  559. /* Called with locked neigh: either read or both */
  561. static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
  562. {
  563. struct in6_addr *saddr = NULL;
  564. struct in6_addr mcaddr;
  565. struct net_device *dev = neigh->dev;
  566. struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
  567. int probes = atomic_read(&neigh->probes);
  569. if (skb && ipv6_chk_addr(&skb->nh.ipv6h->saddr, dev))
  570. saddr = &skb->nh.ipv6h->saddr;
  572. if ((probes -= neigh->parms->ucast_probes) < 0) {
  573. if (!(neigh->nud_state&NUD_VALID))
  574. ND_PRINTK1("trying to ucast probe in NUD_INVALIDn");
  575. ndisc_send_ns(dev, neigh, target, target, saddr);
  576. } else if ((probes -= neigh->parms->app_probes) < 0) {
  577. #ifdef CONFIG_ARPD
  578. neigh_app_ns(neigh);
  579. #endif
  580. } else {
  581. addrconf_addr_solict_mult(target, &mcaddr);
  582. ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
  583. }
  584. }
  586. static void ndisc_router_discovery(struct sk_buff *skb)
  587. {
  588.         struct ra_msg *ra_msg = (struct ra_msg *) skb->h.raw;
  589. struct neighbour *neigh;
  590. struct inet6_dev *in6_dev;
  591. struct rt6_info *rt;
  592. int lifetime;
  593. struct ndisc_options ndopts;
  594. int optlen;
  596. __u8 * opt = (__u8 *)(ra_msg + 1);
  598. optlen = (skb->tail - skb->h.raw) - sizeof(struct ra_msg);
  600. if (!(ipv6_addr_type(&skb->nh.ipv6h->saddr) & IPV6_ADDR_LINKLOCAL)) {
  601. if (net_ratelimit())
  602. printk(KERN_WARNING "ICMP RA: source address is not linklocaln");
  603. return;
  604. }
  605. if (optlen < 0) {
  606. if (net_ratelimit())
  607. printk(KERN_WARNING "ICMP RA: packet too shortn");
  608. return;
  609. }
  611. /*
  612.  * set the RA_RECV flag in the interface
  613.  */
  615. in6_dev = in6_dev_get(skb->dev);
  616. if (in6_dev == NULL) {
  617. ND_PRINTK1("RA: can't find in6 devicen");
  618. return;
  619. }
  620. if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
  621. in6_dev_put(in6_dev);
  622. return;
  623. }
  625. if (!ndisc_parse_options(opt, optlen, &ndopts)) {
  626. if (net_ratelimit())
  627. ND_PRINTK2(KERN_WARNING
  628.    "ICMP6 RA: invalid ND option, ignored.n");
  629. return;
  630. }
  632. if (in6_dev->if_flags & IF_RS_SENT) {
  633. /*
  634.  * flag that an RA was received after an RS was sent
  635.  * out on this interface.
  636.  */
  637. in6_dev->if_flags |= IF_RA_RCVD;
  638. }
  640. lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
  642. rt = rt6_get_dflt_router(&skb->nh.ipv6h->saddr, skb->dev);
  644. if (rt && lifetime == 0) {
  645. ip6_del_rt(rt);
  646. rt = NULL;
  647. }
  649. if (rt == NULL && lifetime) {
  650. ND_PRINTK2("ndisc_rdisc: adding default routern");
  652. rt = rt6_add_dflt_router(&skb->nh.ipv6h->saddr, skb->dev);
  653. if (rt == NULL) {
  654. ND_PRINTK1("route_add failedn");
  655. in6_dev_put(in6_dev);
  656. return;
  657. }
  659. neigh = rt->rt6i_nexthop;
  660. if (neigh == NULL) {
  661. ND_PRINTK1("nd: add default router: null neighbourn");
  662. dst_release(&rt->u.dst);
  663. in6_dev_put(in6_dev);
  664. return;
  665. }
  666. neigh->flags |= NTF_ROUTER;
  668. /*
  669.  * If we where using an "all destinations on link" route
  670.  * delete it
  671.  */
  673. rt6_purge_dflt_routers(RTF_ALLONLINK);
  674. }
  676. if (rt)
  677. rt->rt6i_expires = jiffies + (HZ * lifetime);
  679. if (ra_msg->icmph.icmp6_hop_limit)
  680. in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
  682. /*
  683.  * Update Reachable Time and Retrans Timer
  684.  */
  686. if (in6_dev->nd_parms) {
  687. __u32 rtime = ntohl(ra_msg->retrans_timer);
  689. if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
  690. rtime = (rtime*HZ)/1000;
  691. if (rtime < HZ/10)
  692. rtime = HZ/10;
  693. in6_dev->nd_parms->retrans_time = rtime;
  694. }
  696. rtime = ntohl(ra_msg->reachable_time);
  697. if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
  698. rtime = (rtime*HZ)/1000;
  700. if (rtime < HZ/10)
  701. rtime = HZ/10;
  703. if (rtime != in6_dev->nd_parms->base_reachable_time) {
  704. in6_dev->nd_parms->base_reachable_time = rtime;
  705. in6_dev->nd_parms->gc_staletime = 3 * rtime;
  706. in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
  707. }
  708. }
  709. }
  711. /*
  712.  * Process options.
  713.  */
  715. if (rt && (neigh = rt->rt6i_nexthop) != NULL) {
  716. u8 *lladdr = NULL;
  717. int lladdrlen;
  718. if (ndopts.nd_opts_src_lladdr) {
  719. lladdr = (u8*)((ndopts.nd_opts_src_lladdr)+1);
  720. lladdrlen = ndopts.nd_opts_src_lladdr->nd_opt_len << 3;
  721. if (lladdrlen != NDISC_OPT_SPACE(skb->dev->addr_len)) {
  722. if (net_ratelimit())
  723. ND_PRINTK2(KERN_WARNING
  724.    "ICMP6 RA: Invalid lladdr length.n");
  725. goto out;
  726. }
  727. }
  728. neigh_update(neigh, lladdr, NUD_STALE, 1, 1);
  729. }
  731. if (ndopts.nd_opts_pi) {
  732. struct nd_opt_hdr *p;
  733. for (p = ndopts.nd_opts_pi;
  734.      p;
  735.      p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
  736. addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
  737. }
  738. }
  740. if (ndopts.nd_opts_mtu) {
  741. u32 mtu;
  743. memcpy(&mtu, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
  744. mtu = ntohl(mtu);
  746. if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
  747. if (net_ratelimit()) {
  748. ND_PRINTK0("NDISC: router announcement with mtu = %dn",
  749.    mtu);
  750. }
  751. }
  753. if (in6_dev->cnf.mtu6 != mtu) {
  754. in6_dev->cnf.mtu6 = mtu;
  756. if (rt)
  757. rt->u.dst.pmtu = mtu;
  759. rt6_mtu_change(skb->dev, mtu);
  760. }
  761. }
  763. if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
  764. if (net_ratelimit())
  765. ND_PRINTK0(KERN_WARNING
  766.    "ICMP6 RA: got illegal option with RA");
  767. }
  768. out:
  769. if (rt)
  770. dst_release(&rt->u.dst);
  771. in6_dev_put(in6_dev);
  772. }
  774. static void ndisc_redirect_rcv(struct sk_buff *skb)
  775. {
  776. struct inet6_dev *in6_dev;
  777. struct icmp6hdr *icmph;
  778. struct in6_addr *dest;
  779. struct in6_addr *target; /* new first hop to destination */
  780. struct neighbour *neigh;
  781. int on_link = 0;
  782. struct ndisc_options ndopts;
  783. int optlen;
  784. u8 *lladdr = NULL;
  785. int lladdrlen;
  787. if (!(ipv6_addr_type(&skb->nh.ipv6h->saddr) & IPV6_ADDR_LINKLOCAL)) {
  788. if (net_ratelimit())
  789. printk(KERN_WARNING "ICMP redirect: source address is not linklocaln");
  790. return;
  791. }
  793. optlen = skb->tail - skb->h.raw;
  794. optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
  796. if (optlen < 0) {
  797. if (net_ratelimit())
  798. printk(KERN_WARNING "ICMP redirect: packet too smalln");
  799. return;
  800. }
  802. icmph = (struct icmp6hdr *) skb->h.raw;
  803. target = (struct in6_addr *) (icmph + 1);
  804. dest = target + 1;
  806. if (ipv6_addr_type(dest) & IPV6_ADDR_MULTICAST) {
  807. if (net_ratelimit())
  808. printk(KERN_WARNING "ICMP redirect for multicast addrn");
  809. return;
  810. }
  812. if (ipv6_addr_cmp(dest, target) == 0) {
  813. on_link = 1;
  814. } else if (!(ipv6_addr_type(target) & IPV6_ADDR_LINKLOCAL)) {
  815. if (net_ratelimit())
  816. printk(KERN_WARNING "ICMP redirect: target address is not linklocaln");
  817. return;
  818. }
  820. in6_dev = in6_dev_get(skb->dev);
  821. if (!in6_dev)
  822. return;
  823. if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
  824. in6_dev_put(in6_dev);
  825. return;
  826. }
  828. /* XXX: RFC2461 8.1: 
  829.  * The IP source address of the Redirect MUST be the same as the current
  830.  * first-hop router for the specified ICMP Destination Address.
  831.  */
  833. if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
  834. if (net_ratelimit())
  835. ND_PRINTK2(KERN_WARNING
  836.    "ICMP6 Redirect: invalid ND options, rejected.n");
  837. in6_dev_put(in6_dev);
  838. return;
  839. }
  840. if (ndopts.nd_opts_tgt_lladdr) {
  841. lladdr = (u8*)(ndopts.nd_opts_tgt_lladdr + 1);
  842. lladdrlen = ndopts.nd_opts_tgt_lladdr->nd_opt_len << 3;
  843. if (lladdrlen != NDISC_OPT_SPACE(skb->dev->addr_len)) {
  844. if (net_ratelimit())
  845. ND_PRINTK2(KERN_WARNING
  846.    "ICMP6 Redirect: invalid lladdr length.n");
  847. in6_dev_put(in6_dev);
  848. return;
  849. }
  850. }
  851. /* passed validation tests */
  853. /*
  854.    We install redirect only if nexthop state is valid.
  855.  */
  857. neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
  858. if (neigh) {
  859. neigh_update(neigh, lladdr, NUD_STALE, 1, 1);
  860. if (neigh->nud_state&NUD_VALID)
  861. rt6_redirect(dest, &skb->nh.ipv6h->saddr, neigh, on_link);
  862. else
  863. __neigh_event_send(neigh, NULL);
  864. neigh_release(neigh);
  865. }
  866. in6_dev_put(in6_dev);
  867. }
  869. void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
  870.  struct in6_addr *target)
  871. {
  872. struct sock *sk = ndisc_socket->sk;
  873. int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
  874. struct sk_buff *buff;
  875. struct icmp6hdr *icmph;
  876. struct in6_addr saddr_buf;
  877. struct in6_addr *addrp;
  878. struct net_device *dev;
  879. struct rt6_info *rt;
  880. u8 *opt;
  881. int rd_len;
  882. int err;
  883. int hlen;
  885. dev = skb->dev;
  886. rt = rt6_lookup(&skb->nh.ipv6h->saddr, NULL, dev->ifindex, 1);
  888. if (rt == NULL)
  889. return;
  891. if (rt->rt6i_flags & RTF_GATEWAY) {
  892. ND_PRINTK1("ndisc_send_redirect: not a neighbourn");
  893. dst_release(&rt->u.dst);
  894. return;
  895. }
  896. if (!xrlim_allow(&rt->u.dst, 1*HZ)) {
  897. dst_release(&rt->u.dst);
  898. return;
  899. }
  900. dst_release(&rt->u.dst);
  902. if (dev->addr_len) {
  903. if (neigh->nud_state&NUD_VALID) {
  904. len  += NDISC_OPT_SPACE(dev->addr_len);
  905. } else {
  906. /* If nexthop is not valid, do not redirect!
  907.    We will make it later, when will be sure,
  908.    that it is alive.
  909.  */
  910. return;
  911. }
  912. }
  914. rd_len = min_t(unsigned int,
  915.      IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
  916. rd_len &= ~0x7;
  917. len += rd_len;
  919. if (ipv6_get_lladdr(dev, &saddr_buf)) {
  920.   ND_PRINTK1("redirect: no link_local addr for devn");
  921.   return;
  922.   }
  924. buff = sock_alloc_send_skb(sk, MAX_HEADER + len + dev->hard_header_len + 15,
  925.    0, &err);
  926. if (buff == NULL) {
  927. ND_PRINTK1("ndisc_send_redirect: alloc_skb failedn");
  928. return;
  929. }
  931. hlen = 0;
  933. if (ndisc_build_ll_hdr(buff, dev, &skb->nh.ipv6h->saddr, NULL, len) == 0) {
  934. kfree_skb(buff);
  935. return;
  936. }
  938. ip6_nd_hdr(sk, buff, dev, &saddr_buf, &skb->nh.ipv6h->saddr,
  939.    IPPROTO_ICMPV6, len);
  941. icmph = (struct icmp6hdr *) skb_put(buff, len);
  943. memset(icmph, 0, sizeof(struct icmp6hdr));
  944. icmph->icmp6_type = NDISC_REDIRECT;
  946. /*
  947.  * copy target and destination addresses
  948.  */
  950. addrp = (struct in6_addr *)(icmph + 1);
  951. ipv6_addr_copy(addrp, target);
  952. addrp++;
  953. ipv6_addr_copy(addrp, &skb->nh.ipv6h->daddr);
  955. opt = (u8*) (addrp + 1);
  957. /*
  958.  * include target_address option
  959.  */
  961. if (dev->addr_len)
  962. opt = ndisc_fill_option(opt, ND_OPT_TARGET_LL_ADDR, neigh->ha, dev->addr_len);
  964. /*
  965.  * build redirect option and copy skb over to the new packet.
  966.  */
  968. memset(opt, 0, 8);
  969. *(opt++) = ND_OPT_REDIRECT_HDR;
  970. *(opt++) = (rd_len >> 3);
  971. opt += 6;
  973. memcpy(opt, skb->nh.ipv6h, rd_len - 8);
  975. icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &skb->nh.ipv6h->saddr,
  976.      len, IPPROTO_ICMPV6,
  977.      csum_partial((u8 *) icmph, len, 0));
  979. dev_queue_xmit(buff);
  981. ICMP6_INC_STATS(Icmp6OutRedirects);
  982. ICMP6_INC_STATS(Icmp6OutMsgs);
  983. }
  985. static void pndisc_redo(struct sk_buff *skb)
  986. {
  987. ndisc_rcv(skb);
  988. kfree_skb(skb);
  989. }
  991. int ndisc_rcv(struct sk_buff *skb)
  992. {
  993. struct net_device *dev = skb->dev;
  994. struct in6_addr *saddr = &skb->nh.ipv6h->saddr;
  995. struct in6_addr *daddr = &skb->nh.ipv6h->daddr;
  996. struct nd_msg *msg = (struct nd_msg *) skb->h.raw;
  997. struct neighbour *neigh;
  998. struct inet6_ifaddr *ifp;
  1000. __skb_push(skb, skb->data-skb->h.raw);
  1002. if (skb->nh.ipv6h->hop_limit != 255) {
  1003. if (net_ratelimit())
  1004. printk(KERN_WARNING
  1005.        "ICMP NDISC: fake message with non-255 Hop Limit received: %dn",
  1006.         skb->nh.ipv6h->hop_limit);
  1007. return 0;
  1008. }
  1010. if (msg->icmph.icmp6_code != 0) {
  1011. if (net_ratelimit())
  1012. printk(KERN_WARNING "ICMP NDISC: code is not zeron");
  1013. return 0;
  1014. }
  1016. switch (msg->icmph.icmp6_type) {
  1017. case NDISC_NEIGHBOUR_SOLICITATION:
  1018.     {
  1019. struct nd_msg *msg = (struct nd_msg *)skb->h.raw;
  1020. u8 *lladdr = NULL;
  1021. int lladdrlen = 0;
  1022. u32 ndoptlen = skb->tail - msg->opt;
  1023. struct ndisc_options ndopts;
  1025. if (skb->len < sizeof(struct nd_msg)) {
  1026. if (net_ratelimit())
  1027. printk(KERN_WARNING "ICMP NS: packet too shortn");
  1028. return 0;
  1029. }
  1031. if (ipv6_addr_type(&msg->target)&IPV6_ADDR_MULTICAST) {
  1032. if (net_ratelimit())
  1033. printk(KERN_WARNING "ICMP NS: target address is multicastn");
  1034. return 0;
  1035. }
  1037. if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
  1038. if (net_ratelimit())
  1039. printk(KERN_WARNING "ICMP NS: invalid ND option, ignored.n");
  1040. return 0;
  1041. }
  1043. if (ndopts.nd_opts_src_lladdr) {
  1044. lladdr = (u8*)(ndopts.nd_opts_src_lladdr + 1);
  1045. lladdrlen = ndopts.nd_opts_src_lladdr->nd_opt_len << 3;
  1046. if (lladdrlen != NDISC_OPT_SPACE(skb->dev->addr_len)) {
  1047. if (net_ratelimit())
  1048. printk(KERN_WARNING "ICMP NS: bad lladdr length.n");
  1049. return 0;
  1050. }
  1051. }
  1053. /* XXX: RFC2461 7.1.1:
  1054.  *  If the IP source address is the unspecified address, there
  1055.  * MUST NOT be source link-layer address option in the message.
  1056.  *
  1057.  * NOTE! Linux kernel < 2.4.4 broke this rule.
  1058.  */
  1059.  
  1060. /* XXX: RFC2461 7.1.1:
  1061.  * If the IP source address is the unspecified address, the IP
  1062.         * destination address MUST be a solicited-node multicast address.
  1063.  */
  1065. if ((ifp = ipv6_get_ifaddr(&msg->target, dev)) != NULL) {
  1066. int addr_type = ipv6_addr_type(saddr);
  1068. if (ifp->flags & IFA_F_TENTATIVE) {
  1069. /* Address is tentative. If the source
  1070.    is unspecified address, it is someone
  1071.    does DAD, otherwise we ignore solicitations
  1072.    until DAD timer expires.
  1073.  */
  1074. if (addr_type == IPV6_ADDR_ANY) {
  1075. if (dev->type == ARPHRD_IEEE802_TR) { 
  1076. unsigned char *sadr = skb->mac.raw ;
  1077. if (((sadr[8] &0x7f) != (dev->dev_addr[0] & 0x7f)) ||
  1078. (sadr[9] != dev->dev_addr[1]) ||
  1079. (sadr[10] != dev->dev_addr[2]) ||
  1080. (sadr[11] != dev->dev_addr[3]) ||
  1081. (sadr[12] != dev->dev_addr[4]) ||
  1082. (sadr[13] != dev->dev_addr[5])) 
  1083. {
  1084. addrconf_dad_failure(ifp) ; 
  1085. }
  1086. } else {
  1087. addrconf_dad_failure(ifp);
  1088. }
  1089. } else
  1090. in6_ifa_put(ifp);
  1091. return 0;
  1092. }
  1094. if (addr_type == IPV6_ADDR_ANY) {
  1095. struct in6_addr maddr;
  1097. ipv6_addr_all_nodes(&maddr);
  1098. ndisc_send_na(dev, NULL, &maddr, &ifp->addr, 
  1099.       ifp->idev->cnf.forwarding, 0, 
  1100.       ipv6_addr_type(&ifp->addr)&IPV6_ADDR_ANYCAST ? 0 : 1, 
  1101.       1);
  1102. in6_ifa_put(ifp);
  1103. return 0;
  1104. }
  1106. if (addr_type & IPV6_ADDR_UNICAST) {
  1107. int inc = ipv6_addr_type(daddr)&IPV6_ADDR_MULTICAST;
  1109. if (inc)
  1110. nd_tbl.stats.rcv_probes_mcast++;
  1111. else
  1112. nd_tbl.stats.rcv_probes_ucast++;
  1114. /* 
  1115.  * update / create cache entry
  1116.  * for the source adddress
  1117.  */
  1119. neigh = neigh_event_ns(&nd_tbl, lladdr, saddr, skb->dev);
  1121. if (neigh || !dev->hard_header) {
  1122. ndisc_send_na(dev, neigh, saddr, &ifp->addr, 
  1123.       ifp->idev->cnf.forwarding, 1, 
  1124.       ipv6_addr_type(&ifp->addr)&IPV6_ADDR_ANYCAST ? 0 : 1, 
  1125.       1);
  1126. if (neigh)
  1127. neigh_release(neigh);
  1128. }
  1129. }
  1130. in6_ifa_put(ifp);
  1131. } else {
  1132. struct inet6_dev *in6_dev = in6_dev_get(dev);
  1133. int addr_type = ipv6_addr_type(saddr);
  1135. if (in6_dev && in6_dev->cnf.forwarding &&
  1136.     (addr_type & IPV6_ADDR_UNICAST) &&
  1137.     pneigh_lookup(&nd_tbl, &msg->target, dev, 0)) {
  1138. int inc = ipv6_addr_type(daddr)&IPV6_ADDR_MULTICAST;
  1140. if (skb->stamp.tv_sec == 0 ||
  1141.     skb->pkt_type == PACKET_HOST ||
  1142.     inc == 0 ||
  1143.     in6_dev->nd_parms->proxy_delay == 0) {
  1144. if (inc)
  1145. nd_tbl.stats.rcv_probes_mcast++;
  1146. else
  1147. nd_tbl.stats.rcv_probes_ucast++;
  1150. neigh = neigh_event_ns(&nd_tbl, lladdr, saddr, skb->dev);
  1152. if (neigh) {
  1153. ndisc_send_na(dev, neigh, saddr, &msg->target,
  1154.       0, 1, 0, 1);
  1155. neigh_release(neigh);
  1156. }
  1157. } else {
  1158. struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
  1159. if (n)
  1160. pneigh_enqueue(&nd_tbl, in6_dev->nd_parms, n);
  1161. in6_dev_put(in6_dev);
  1162. return 0;
  1163. }
  1164. }
  1165. if (in6_dev)
  1166. in6_dev_put(in6_dev);
  1168. }
  1169. return 0;
  1170.     }
  1172. case NDISC_NEIGHBOUR_ADVERTISEMENT:
  1173.     {
  1174. struct nd_msg *msg = (struct nd_msg *)skb->h.raw;
  1175. u8 *lladdr = NULL;
  1176. int lladdrlen = 0;
  1177. u32 ndoptlen = skb->tail - msg->opt;
  1178. struct ndisc_options ndopts;
  1180. if (skb->len < sizeof(struct nd_msg)) {
  1181. if (net_ratelimit())
  1182. printk(KERN_WARNING "ICMP NA: packet too shortn");
  1183. return 0;
  1184. }
  1186. if (ipv6_addr_type(&msg->target)&IPV6_ADDR_MULTICAST) {
  1187. if (net_ratelimit())
  1188. printk(KERN_WARNING "NDISC NA: target address is multicastn");
  1189. return 0;
  1190. }
  1192. if ((ipv6_addr_type(daddr)&IPV6_ADDR_MULTICAST) &&
  1193.     msg->icmph.icmp6_solicited) {
  1194. ND_PRINTK0("NDISC: solicited NA is multicastedn");
  1195. return 0;
  1196. }
  1198. if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
  1199. if (net_ratelimit())
  1200. printk(KERN_WARNING "ICMP NS: invalid ND option, ignored.n");
  1201. return 0;
  1202. }
  1203. if (ndopts.nd_opts_tgt_lladdr) {
  1204. lladdr = (u8*)(ndopts.nd_opts_tgt_lladdr + 1);
  1205. lladdrlen = ndopts.nd_opts_tgt_lladdr->nd_opt_len << 3;
  1206. if (lladdrlen != NDISC_OPT_SPACE(skb->dev->addr_len)) {
  1207. if (net_ratelimit())
  1208. printk(KERN_WARNING "NDISC NA: invalid lladdr length.n");
  1209. return 0;
  1210. }
  1211. }
  1212. if ((ifp = ipv6_get_ifaddr(&msg->target, dev))) {
  1213. if (ifp->flags & IFA_F_TENTATIVE) {
  1214. addrconf_dad_failure(ifp);
  1215. return 0;
  1216. }
  1217. /* What should we make now? The advertisement
  1218.    is invalid, but ndisc specs say nothing
  1219.    about it. It could be misconfiguration, or
  1220.    an smart proxy agent tries to help us :-)
  1221.  */
  1222. ND_PRINTK0("%s: someone advertises our address!n",
  1223.    ifp->idev->dev->name);
  1224. in6_ifa_put(ifp);
  1225. return 0;
  1226. }
  1227. neigh = neigh_lookup(&nd_tbl, &msg->target, skb->dev);
  1229. if (neigh) {
  1230. if (neigh->flags & NTF_ROUTER) {
  1231. if (msg->icmph.icmp6_router == 0) {
  1232. /*
  1233.  * Change: router to host
  1234.  */
  1235. struct rt6_info *rt;
  1236. rt = rt6_get_dflt_router(saddr, skb->dev);
  1237. if (rt) {
  1238. ip6_del_rt(rt);
  1239. }
  1240. }
  1241. } else {
  1242. if (msg->icmph.icmp6_router)
  1243. neigh->flags |= NTF_ROUTER;
  1244. }
  1246. neigh_update(neigh, lladdr,
  1247.      msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
  1248.      msg->icmph.icmp6_override, 1);
  1249. neigh_release(neigh);
  1250. }
  1251. break;
  1252.     }
  1254. case NDISC_ROUTER_ADVERTISEMENT:
  1255. ndisc_router_discovery(skb);
  1256. break;
  1258. case NDISC_REDIRECT:
  1259. ndisc_redirect_rcv(skb);
  1260. break;
  1261. };
  1263. return 0;
  1264. }
  1266. int __init ndisc_init(struct net_proto_family *ops)
  1267. {
  1268. struct sock *sk;
  1269.         int err;
  1271. ndisc_socket = sock_alloc();
  1272. if (ndisc_socket == NULL) {
  1273. printk(KERN_ERR
  1274.        "Failed to create the NDISC control socket.n");
  1275. return -1;
  1276. }
  1277. ndisc_socket->inode->i_uid = 0;
  1278. ndisc_socket->inode->i_gid = 0;
  1279. ndisc_socket->type = SOCK_RAW;
  1281. if((err = ops->create(ndisc_socket, IPPROTO_ICMPV6)) < 0) {
  1282. printk(KERN_DEBUG 
  1283.        "Failed to initialize the NDISC control socket (err %d).n",
  1284.        err);
  1285. sock_release(ndisc_socket);
  1286. ndisc_socket = NULL; /* For safety. */
  1287. return err;
  1288. }
  1290. sk = ndisc_socket->sk;
  1291. sk->allocation = GFP_ATOMIC;
  1292. sk->net_pinfo.af_inet6.hop_limit = 255;
  1293. /* Do not loopback ndisc messages */
  1294. sk->net_pinfo.af_inet6.mc_loop = 0;
  1295. sk->prot->unhash(sk);
  1297.         /*
  1298.          * Initialize the neighbour table
  1299.          */
  1301. neigh_table_init(&nd_tbl);
  1303. #ifdef CONFIG_SYSCTL
  1304. neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6, NET_IPV6_NEIGH, "ipv6");
  1305. #endif
  1307. return 0;
  1308. }
  1310. void ndisc_cleanup(void)
  1311. {
  1312. neigh_table_clear(&nd_tbl);
  1313. sock_release(ndisc_socket);
  1314. ndisc_socket = NULL; /* For safety. */
  1315. }