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 */
14
15 /*
16 * Changes:
17 *
18 * Pierre Ynard : export userland ND options
19 * through netlink (RDNSS support)
20 * Lars Fenneberg : fixed MTU setting on receipt
21 * of an RA.
22 * Janos Farkas : kmalloc failure checks
23 * Alexey Kuznetsov : state machine reworked
24 * and moved to net/core.
25 * Pekka Savola : RFC2461 validation
26 * YOSHIFUJI Hideaki @USAGI : Verify ND options properly
27 */
28
29 /* Set to 3 to get tracing... */
30 #define ND_DEBUG 1
31
32 #define ND_PRINTK(fmt, args...) do { if (net_ratelimit()) { printk(fmt, ## args); } } while(0)
33 #define ND_NOPRINTK(x...) do { ; } while(0)
34 #define ND_PRINTK0 ND_PRINTK
35 #define ND_PRINTK1 ND_NOPRINTK
36 #define ND_PRINTK2 ND_NOPRINTK
37 #define ND_PRINTK3 ND_NOPRINTK
38 #if ND_DEBUG >= 1
39 #undef ND_PRINTK1
40 #define ND_PRINTK1 ND_PRINTK
41 #endif
42 #if ND_DEBUG >= 2
43 #undef ND_PRINTK2
44 #define ND_PRINTK2 ND_PRINTK
45 #endif
46 #if ND_DEBUG >= 3
47 #undef ND_PRINTK3
48 #define ND_PRINTK3 ND_PRINTK
49 #endif
50
51 #include <linux/module.h>
52 #include <linux/errno.h>
53 #include <linux/types.h>
54 #include <linux/socket.h>
55 #include <linux/sockios.h>
56 #include <linux/sched.h>
57 #include <linux/net.h>
58 #include <linux/in6.h>
59 #include <linux/route.h>
60 #include <linux/init.h>
61 #include <linux/rcupdate.h>
62 #include <linux/slab.h>
63 #ifdef CONFIG_SYSCTL
64 #include <linux/sysctl.h>
65 #endif
66
67 #include <linux/if_addr.h>
68 #include <linux/if_arp.h>
69 #include <linux/ipv6.h>
70 #include <linux/icmpv6.h>
71 #include <linux/jhash.h>
72
73 #include <net/sock.h>
74 #include <net/snmp.h>
75
76 #include <net/ipv6.h>
77 #include <net/protocol.h>
78 #include <net/ndisc.h>
79 #include <net/ip6_route.h>
80 #include <net/addrconf.h>
81 #include <net/icmp.h>
82
83 #include <net/netlink.h>
84 #include <linux/rtnetlink.h>
85
86 #include <net/flow.h>
87 #include <net/ip6_checksum.h>
88 #include <net/inet_common.h>
89 #include <linux/proc_fs.h>
90
91 #include <linux/netfilter.h>
92 #include <linux/netfilter_ipv6.h>
93
94 static u32 ndisc_hash(const void *pkey,
95 const struct net_device *dev,
96 __u32 *hash_rnd);
97 static int ndisc_constructor(struct neighbour *neigh);
98 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
99 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
100 static int pndisc_constructor(struct pneigh_entry *n);
101 static void pndisc_destructor(struct pneigh_entry *n);
102 static void pndisc_redo(struct sk_buff *skb);
103
104 static const struct neigh_ops ndisc_generic_ops = {
105 .family = AF_INET6,
106 .solicit = ndisc_solicit,
107 .error_report = ndisc_error_report,
108 .output = neigh_resolve_output,
109 .connected_output = neigh_connected_output,
110 };
111
112 static const struct neigh_ops ndisc_hh_ops = {
113 .family = AF_INET6,
114 .solicit = ndisc_solicit,
115 .error_report = ndisc_error_report,
116 .output = neigh_resolve_output,
117 .connected_output = neigh_resolve_output,
118 };
119
120
121 static const struct neigh_ops ndisc_direct_ops = {
122 .family = AF_INET6,
123 .output = neigh_direct_output,
124 .connected_output = neigh_direct_output,
125 };
126
127 struct neigh_table nd_tbl = {
128 .family = AF_INET6,
129 .key_len = sizeof(struct in6_addr),
130 .hash = ndisc_hash,
131 .constructor = ndisc_constructor,
132 .pconstructor = pndisc_constructor,
133 .pdestructor = pndisc_destructor,
134 .proxy_redo = pndisc_redo,
135 .id = "ndisc_cache",
136 .parms = {
137 .tbl = &nd_tbl,
138 .base_reachable_time = ND_REACHABLE_TIME,
139 .retrans_time = ND_RETRANS_TIMER,
140 .gc_staletime = 60 * HZ,
141 .reachable_time = ND_REACHABLE_TIME,
142 .delay_probe_time = 5 * HZ,
143 .queue_len_bytes = 64*1024,
144 .ucast_probes = 3,
145 .mcast_probes = 3,
146 .anycast_delay = 1 * HZ,
147 .proxy_delay = (8 * HZ) / 10,
148 .proxy_qlen = 64,
149 },
150 .gc_interval = 30 * HZ,
151 .gc_thresh1 = 128,
152 .gc_thresh2 = 512,
153 .gc_thresh3 = 1024,
154 };
155
156 /* ND options */
157 struct ndisc_options {
158 struct nd_opt_hdr *nd_opt_array[__ND_OPT_ARRAY_MAX];
159 #ifdef CONFIG_IPV6_ROUTE_INFO
160 struct nd_opt_hdr *nd_opts_ri;
161 struct nd_opt_hdr *nd_opts_ri_end;
162 #endif
163 struct nd_opt_hdr *nd_useropts;
164 struct nd_opt_hdr *nd_useropts_end;
165 };
166
167 #define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
168 #define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]
169 #define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]
170 #define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]
171 #define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]
172 #define nd_opts_mtu nd_opt_array[ND_OPT_MTU]
173
174 #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
175
176 /*
177 * Return the padding between the option length and the start of the
178 * link addr. Currently only IP-over-InfiniBand needs this, although
179 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
180 * also need a pad of 2.
181 */
ndisc_addr_option_pad(unsigned short type)182 static int ndisc_addr_option_pad(unsigned short type)
183 {
184 switch (type) {
185 case ARPHRD_INFINIBAND: return 2;
186 default: return 0;
187 }
188 }
189
ndisc_opt_addr_space(struct net_device * dev)190 static inline int ndisc_opt_addr_space(struct net_device *dev)
191 {
192 return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
193 }
194
ndisc_fill_addr_option(u8 * opt,int type,void * data,int data_len,unsigned short addr_type)195 static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
196 unsigned short addr_type)
197 {
198 int space = NDISC_OPT_SPACE(data_len);
199 int pad = ndisc_addr_option_pad(addr_type);
200
201 opt[0] = type;
202 opt[1] = space>>3;
203
204 memset(opt + 2, 0, pad);
205 opt += pad;
206 space -= pad;
207
208 memcpy(opt+2, data, data_len);
209 data_len += 2;
210 opt += data_len;
211 if ((space -= data_len) > 0)
212 memset(opt, 0, space);
213 return opt + space;
214 }
215
ndisc_next_option(struct nd_opt_hdr * cur,struct nd_opt_hdr * end)216 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
217 struct nd_opt_hdr *end)
218 {
219 int type;
220 if (!cur || !end || cur >= end)
221 return NULL;
222 type = cur->nd_opt_type;
223 do {
224 cur = ((void *)cur) + (cur->nd_opt_len << 3);
225 } while(cur < end && cur->nd_opt_type != type);
226 return cur <= end && cur->nd_opt_type == type ? cur : NULL;
227 }
228
ndisc_is_useropt(struct nd_opt_hdr * opt)229 static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
230 {
231 return opt->nd_opt_type == ND_OPT_RDNSS;
232 }
233
ndisc_next_useropt(struct nd_opt_hdr * cur,struct nd_opt_hdr * end)234 static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
235 struct nd_opt_hdr *end)
236 {
237 if (!cur || !end || cur >= end)
238 return NULL;
239 do {
240 cur = ((void *)cur) + (cur->nd_opt_len << 3);
241 } while(cur < end && !ndisc_is_useropt(cur));
242 return cur <= end && ndisc_is_useropt(cur) ? cur : NULL;
243 }
244
ndisc_parse_options(u8 * opt,int opt_len,struct ndisc_options * ndopts)245 static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
246 struct ndisc_options *ndopts)
247 {
248 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
249
250 if (!nd_opt || opt_len < 0 || !ndopts)
251 return NULL;
252 memset(ndopts, 0, sizeof(*ndopts));
253 while (opt_len) {
254 int l;
255 if (opt_len < sizeof(struct nd_opt_hdr))
256 return NULL;
257 l = nd_opt->nd_opt_len << 3;
258 if (opt_len < l || l == 0)
259 return NULL;
260 switch (nd_opt->nd_opt_type) {
261 case ND_OPT_SOURCE_LL_ADDR:
262 case ND_OPT_TARGET_LL_ADDR:
263 case ND_OPT_MTU:
264 case ND_OPT_REDIRECT_HDR:
265 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
266 ND_PRINTK2(KERN_WARNING
267 "%s(): duplicated ND6 option found: type=%d\n",
268 __func__,
269 nd_opt->nd_opt_type);
270 } else {
271 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
272 }
273 break;
274 case ND_OPT_PREFIX_INFO:
275 ndopts->nd_opts_pi_end = nd_opt;
276 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
277 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
278 break;
279 #ifdef CONFIG_IPV6_ROUTE_INFO
280 case ND_OPT_ROUTE_INFO:
281 ndopts->nd_opts_ri_end = nd_opt;
282 if (!ndopts->nd_opts_ri)
283 ndopts->nd_opts_ri = nd_opt;
284 break;
285 #endif
286 default:
287 if (ndisc_is_useropt(nd_opt)) {
288 ndopts->nd_useropts_end = nd_opt;
289 if (!ndopts->nd_useropts)
290 ndopts->nd_useropts = nd_opt;
291 } else {
292 /*
293 * Unknown options must be silently ignored,
294 * to accommodate future extension to the
295 * protocol.
296 */
297 ND_PRINTK2(KERN_NOTICE
298 "%s(): ignored unsupported option; type=%d, len=%d\n",
299 __func__,
300 nd_opt->nd_opt_type, nd_opt->nd_opt_len);
301 }
302 }
303 opt_len -= l;
304 nd_opt = ((void *)nd_opt) + l;
305 }
306 return ndopts;
307 }
308
ndisc_opt_addr_data(struct nd_opt_hdr * p,struct net_device * dev)309 static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,
310 struct net_device *dev)
311 {
312 u8 *lladdr = (u8 *)(p + 1);
313 int lladdrlen = p->nd_opt_len << 3;
314 int prepad = ndisc_addr_option_pad(dev->type);
315 if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad))
316 return NULL;
317 return lladdr + prepad;
318 }
319
ndisc_mc_map(const struct in6_addr * addr,char * buf,struct net_device * dev,int dir)320 int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
321 {
322 switch (dev->type) {
323 case ARPHRD_ETHER:
324 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
325 case ARPHRD_FDDI:
326 ipv6_eth_mc_map(addr, buf);
327 return 0;
328 case ARPHRD_IEEE802_TR:
329 ipv6_tr_mc_map(addr,buf);
330 return 0;
331 case ARPHRD_ARCNET:
332 ipv6_arcnet_mc_map(addr, buf);
333 return 0;
334 case ARPHRD_INFINIBAND:
335 ipv6_ib_mc_map(addr, dev->broadcast, buf);
336 return 0;
337 case ARPHRD_IPGRE:
338 return ipv6_ipgre_mc_map(addr, dev->broadcast, buf);
339 default:
340 if (dir) {
341 memcpy(buf, dev->broadcast, dev->addr_len);
342 return 0;
343 }
344 }
345 return -EINVAL;
346 }
347
348 EXPORT_SYMBOL(ndisc_mc_map);
349
ndisc_hash(const void * pkey,const struct net_device * dev,__u32 * hash_rnd)350 static u32 ndisc_hash(const void *pkey,
351 const struct net_device *dev,
352 __u32 *hash_rnd)
353 {
354 return ndisc_hashfn(pkey, dev, hash_rnd);
355 }
356
ndisc_constructor(struct neighbour * neigh)357 static int ndisc_constructor(struct neighbour *neigh)
358 {
359 struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
360 struct net_device *dev = neigh->dev;
361 struct inet6_dev *in6_dev;
362 struct neigh_parms *parms;
363 int is_multicast = ipv6_addr_is_multicast(addr);
364
365 in6_dev = in6_dev_get(dev);
366 if (in6_dev == NULL) {
367 return -EINVAL;
368 }
369
370 parms = in6_dev->nd_parms;
371 __neigh_parms_put(neigh->parms);
372 neigh->parms = neigh_parms_clone(parms);
373
374 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
375 if (!dev->header_ops) {
376 neigh->nud_state = NUD_NOARP;
377 neigh->ops = &ndisc_direct_ops;
378 neigh->output = neigh_direct_output;
379 } else {
380 if (is_multicast) {
381 neigh->nud_state = NUD_NOARP;
382 ndisc_mc_map(addr, neigh->ha, dev, 1);
383 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
384 neigh->nud_state = NUD_NOARP;
385 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
386 if (dev->flags&IFF_LOOPBACK)
387 neigh->type = RTN_LOCAL;
388 } else if (dev->flags&IFF_POINTOPOINT) {
389 neigh->nud_state = NUD_NOARP;
390 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
391 }
392 if (dev->header_ops->cache)
393 neigh->ops = &ndisc_hh_ops;
394 else
395 neigh->ops = &ndisc_generic_ops;
396 if (neigh->nud_state&NUD_VALID)
397 neigh->output = neigh->ops->connected_output;
398 else
399 neigh->output = neigh->ops->output;
400 }
401 in6_dev_put(in6_dev);
402 return 0;
403 }
404
pndisc_constructor(struct pneigh_entry * n)405 static int pndisc_constructor(struct pneigh_entry *n)
406 {
407 struct in6_addr *addr = (struct in6_addr*)&n->key;
408 struct in6_addr maddr;
409 struct net_device *dev = n->dev;
410
411 if (dev == NULL || __in6_dev_get(dev) == NULL)
412 return -EINVAL;
413 addrconf_addr_solict_mult(addr, &maddr);
414 ipv6_dev_mc_inc(dev, &maddr);
415 return 0;
416 }
417
pndisc_destructor(struct pneigh_entry * n)418 static void pndisc_destructor(struct pneigh_entry *n)
419 {
420 struct in6_addr *addr = (struct in6_addr*)&n->key;
421 struct in6_addr maddr;
422 struct net_device *dev = n->dev;
423
424 if (dev == NULL || __in6_dev_get(dev) == NULL)
425 return;
426 addrconf_addr_solict_mult(addr, &maddr);
427 ipv6_dev_mc_dec(dev, &maddr);
428 }
429
ndisc_build_skb(struct net_device * dev,const struct in6_addr * daddr,const struct in6_addr * saddr,struct icmp6hdr * icmp6h,const struct in6_addr * target,int llinfo)430 struct sk_buff *ndisc_build_skb(struct net_device *dev,
431 const struct in6_addr *daddr,
432 const struct in6_addr *saddr,
433 struct icmp6hdr *icmp6h,
434 const struct in6_addr *target,
435 int llinfo)
436 {
437 struct net *net = dev_net(dev);
438 struct sock *sk = net->ipv6.ndisc_sk;
439 struct sk_buff *skb;
440 struct icmp6hdr *hdr;
441 int hlen = LL_RESERVED_SPACE(dev);
442 int tlen = dev->needed_tailroom;
443 int len;
444 u8 *opt;
445
446 if (!dev->addr_len)
447 llinfo = 0;
448
449 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
450 if (llinfo)
451 len += ndisc_opt_addr_space(dev);
452
453 skb = alloc_skb((MAX_HEADER + sizeof(struct ipv6hdr) +
454 len + hlen + tlen), GFP_ATOMIC);
455 if (!skb) {
456 ND_PRINTK0(KERN_ERR
457 "ICMPv6 ND: %s() failed to allocate an skb.\n",
458 __func__);
459 return NULL;
460 }
461
462 skb_reserve(skb, hlen);
463 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
464
465 skb->transport_header = skb->tail;
466 skb_put(skb, len);
467
468 hdr = (struct icmp6hdr *)skb_transport_header(skb);
469 memcpy(hdr, icmp6h, sizeof(*hdr));
470
471 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
472 if (target) {
473 *(struct in6_addr *)opt = *target;
474 opt += sizeof(*target);
475 }
476
477 if (llinfo)
478 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
479 dev->addr_len, dev->type);
480
481 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
482 IPPROTO_ICMPV6,
483 csum_partial(hdr,
484 len, 0));
485
486 /* Manually assign socket ownership as we avoid calling
487 * sock_alloc_send_pskb() to bypass wmem buffer limits
488 */
489 skb_set_owner_w(skb, sk);
490
491 return skb;
492 }
493
494 EXPORT_SYMBOL(ndisc_build_skb);
495
ndisc_send_skb(struct sk_buff * skb,struct net_device * dev,struct neighbour * neigh,const struct in6_addr * daddr,const struct in6_addr * saddr,struct icmp6hdr * icmp6h)496 void ndisc_send_skb(struct sk_buff *skb,
497 struct net_device *dev,
498 struct neighbour *neigh,
499 const struct in6_addr *daddr,
500 const struct in6_addr *saddr,
501 struct icmp6hdr *icmp6h)
502 {
503 struct flowi6 fl6;
504 struct dst_entry *dst;
505 struct net *net = dev_net(dev);
506 struct sock *sk = net->ipv6.ndisc_sk;
507 struct inet6_dev *idev;
508 int err;
509 u8 type;
510
511 type = icmp6h->icmp6_type;
512
513 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, dev->ifindex);
514 dst = icmp6_dst_alloc(dev, neigh, &fl6);
515 if (IS_ERR(dst)) {
516 kfree_skb(skb);
517 return;
518 }
519
520 skb_dst_set(skb, dst);
521
522 rcu_read_lock();
523 idev = __in6_dev_get(dst->dev);
524 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
525
526 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
527 dst_output);
528 if (!err) {
529 ICMP6MSGOUT_INC_STATS(net, idev, type);
530 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
531 }
532
533 rcu_read_unlock();
534 }
535
536 EXPORT_SYMBOL(ndisc_send_skb);
537
538 /*
539 * Send a Neighbour Discover packet
540 */
__ndisc_send(struct net_device * dev,struct neighbour * neigh,const struct in6_addr * daddr,const struct in6_addr * saddr,struct icmp6hdr * icmp6h,const struct in6_addr * target,int llinfo)541 static void __ndisc_send(struct net_device *dev,
542 struct neighbour *neigh,
543 const struct in6_addr *daddr,
544 const struct in6_addr *saddr,
545 struct icmp6hdr *icmp6h, const struct in6_addr *target,
546 int llinfo)
547 {
548 struct sk_buff *skb;
549
550 skb = ndisc_build_skb(dev, daddr, saddr, icmp6h, target, llinfo);
551 if (!skb)
552 return;
553
554 ndisc_send_skb(skb, dev, neigh, daddr, saddr, icmp6h);
555 }
556
ndisc_send_na(struct net_device * dev,struct neighbour * neigh,const struct in6_addr * daddr,const struct in6_addr * solicited_addr,int router,int solicited,int override,int inc_opt)557 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
558 const struct in6_addr *daddr,
559 const struct in6_addr *solicited_addr,
560 int router, int solicited, int override, int inc_opt)
561 {
562 struct in6_addr tmpaddr;
563 struct inet6_ifaddr *ifp;
564 const struct in6_addr *src_addr;
565 struct icmp6hdr icmp6h = {
566 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
567 };
568
569 /* for anycast or proxy, solicited_addr != src_addr */
570 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
571 if (ifp) {
572 src_addr = solicited_addr;
573 if (ifp->flags & IFA_F_OPTIMISTIC)
574 override = 0;
575 inc_opt |= ifp->idev->cnf.force_tllao;
576 in6_ifa_put(ifp);
577 } else {
578 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
579 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
580 &tmpaddr))
581 return;
582 src_addr = &tmpaddr;
583 }
584
585 icmp6h.icmp6_router = router;
586 icmp6h.icmp6_solicited = solicited;
587 icmp6h.icmp6_override = override;
588
589 __ndisc_send(dev, neigh, daddr, src_addr,
590 &icmp6h, solicited_addr,
591 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
592 }
593
ndisc_send_unsol_na(struct net_device * dev)594 static void ndisc_send_unsol_na(struct net_device *dev)
595 {
596 struct inet6_dev *idev;
597 struct inet6_ifaddr *ifa;
598 struct in6_addr mcaddr = IN6ADDR_LINKLOCAL_ALLNODES_INIT;
599
600 idev = in6_dev_get(dev);
601 if (!idev)
602 return;
603
604 read_lock_bh(&idev->lock);
605 list_for_each_entry(ifa, &idev->addr_list, if_list) {
606 ndisc_send_na(dev, NULL, &mcaddr, &ifa->addr,
607 /*router=*/ !!idev->cnf.forwarding,
608 /*solicited=*/ false, /*override=*/ true,
609 /*inc_opt=*/ true);
610 }
611 read_unlock_bh(&idev->lock);
612
613 in6_dev_put(idev);
614 }
615
ndisc_send_ns(struct net_device * dev,struct neighbour * neigh,const struct in6_addr * solicit,const struct in6_addr * daddr,const struct in6_addr * saddr)616 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
617 const struct in6_addr *solicit,
618 const struct in6_addr *daddr, const struct in6_addr *saddr)
619 {
620 struct in6_addr addr_buf;
621 struct icmp6hdr icmp6h = {
622 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
623 };
624
625 if (saddr == NULL) {
626 if (ipv6_get_lladdr(dev, &addr_buf,
627 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
628 return;
629 saddr = &addr_buf;
630 }
631
632 __ndisc_send(dev, neigh, daddr, saddr,
633 &icmp6h, solicit,
634 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
635 }
636
ndisc_send_rs(struct net_device * dev,const struct in6_addr * saddr,const struct in6_addr * daddr)637 void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
638 const struct in6_addr *daddr)
639 {
640 struct icmp6hdr icmp6h = {
641 .icmp6_type = NDISC_ROUTER_SOLICITATION,
642 };
643 int send_sllao = dev->addr_len;
644
645 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
646 /*
647 * According to section 2.2 of RFC 4429, we must not
648 * send router solicitations with a sllao from
649 * optimistic addresses, but we may send the solicitation
650 * if we don't include the sllao. So here we check
651 * if our address is optimistic, and if so, we
652 * suppress the inclusion of the sllao.
653 */
654 if (send_sllao) {
655 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
656 dev, 1);
657 if (ifp) {
658 if (ifp->flags & IFA_F_OPTIMISTIC) {
659 send_sllao = 0;
660 }
661 in6_ifa_put(ifp);
662 } else {
663 send_sllao = 0;
664 }
665 }
666 #endif
667 __ndisc_send(dev, NULL, daddr, saddr,
668 &icmp6h, NULL,
669 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
670 }
671
672
ndisc_error_report(struct neighbour * neigh,struct sk_buff * skb)673 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
674 {
675 /*
676 * "The sender MUST return an ICMP
677 * destination unreachable"
678 */
679 dst_link_failure(skb);
680 kfree_skb(skb);
681 }
682
683 /* Called with locked neigh: either read or both */
684
ndisc_solicit(struct neighbour * neigh,struct sk_buff * skb)685 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
686 {
687 struct in6_addr *saddr = NULL;
688 struct in6_addr mcaddr;
689 struct net_device *dev = neigh->dev;
690 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
691 int probes = atomic_read(&neigh->probes);
692
693 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
694 saddr = &ipv6_hdr(skb)->saddr;
695
696 if ((probes -= neigh->parms->ucast_probes) < 0) {
697 if (!(neigh->nud_state & NUD_VALID)) {
698 ND_PRINTK1(KERN_DEBUG "%s(): trying to ucast probe in NUD_INVALID: %pI6\n",
699 __func__, target);
700 }
701 ndisc_send_ns(dev, neigh, target, target, saddr);
702 } else if ((probes -= neigh->parms->app_probes) < 0) {
703 #ifdef CONFIG_ARPD
704 neigh_app_ns(neigh);
705 #endif
706 } else {
707 addrconf_addr_solict_mult(target, &mcaddr);
708 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
709 }
710 }
711
pndisc_is_router(const void * pkey,struct net_device * dev)712 static int pndisc_is_router(const void *pkey,
713 struct net_device *dev)
714 {
715 struct pneigh_entry *n;
716 int ret = -1;
717
718 read_lock_bh(&nd_tbl.lock);
719 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
720 if (n)
721 ret = !!(n->flags & NTF_ROUTER);
722 read_unlock_bh(&nd_tbl.lock);
723
724 return ret;
725 }
726
ndisc_recv_ns(struct sk_buff * skb)727 static void ndisc_recv_ns(struct sk_buff *skb)
728 {
729 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
730 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
731 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
732 u8 *lladdr = NULL;
733 u32 ndoptlen = skb->tail - (skb->transport_header +
734 offsetof(struct nd_msg, opt));
735 struct ndisc_options ndopts;
736 struct net_device *dev = skb->dev;
737 struct inet6_ifaddr *ifp;
738 struct inet6_dev *idev = NULL;
739 struct neighbour *neigh;
740 int dad = ipv6_addr_any(saddr);
741 int inc;
742 int is_router = -1;
743
744 if (ipv6_addr_is_multicast(&msg->target)) {
745 ND_PRINTK2(KERN_WARNING
746 "ICMPv6 NS: multicast target address");
747 return;
748 }
749
750 /*
751 * RFC2461 7.1.1:
752 * DAD has to be destined for solicited node multicast address.
753 */
754 if (dad &&
755 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
756 daddr->s6_addr32[1] == htonl(0x00000000) &&
757 daddr->s6_addr32[2] == htonl(0x00000001) &&
758 daddr->s6_addr [12] == 0xff )) {
759 ND_PRINTK2(KERN_WARNING
760 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
761 return;
762 }
763
764 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
765 ND_PRINTK2(KERN_WARNING
766 "ICMPv6 NS: invalid ND options\n");
767 return;
768 }
769
770 if (ndopts.nd_opts_src_lladdr) {
771 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
772 if (!lladdr) {
773 ND_PRINTK2(KERN_WARNING
774 "ICMPv6 NS: invalid link-layer address length\n");
775 return;
776 }
777
778 /* RFC2461 7.1.1:
779 * If the IP source address is the unspecified address,
780 * there MUST NOT be source link-layer address option
781 * in the message.
782 */
783 if (dad) {
784 ND_PRINTK2(KERN_WARNING
785 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
786 return;
787 }
788 }
789
790 inc = ipv6_addr_is_multicast(daddr);
791
792 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
793 if (ifp) {
794
795 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
796 if (dad) {
797 if (dev->type == ARPHRD_IEEE802_TR) {
798 const unsigned char *sadr;
799 sadr = skb_mac_header(skb);
800 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
801 sadr[9] == dev->dev_addr[1] &&
802 sadr[10] == dev->dev_addr[2] &&
803 sadr[11] == dev->dev_addr[3] &&
804 sadr[12] == dev->dev_addr[4] &&
805 sadr[13] == dev->dev_addr[5]) {
806 /* looped-back to us */
807 goto out;
808 }
809 }
810
811 /*
812 * We are colliding with another node
813 * who is doing DAD
814 * so fail our DAD process
815 */
816 addrconf_dad_failure(ifp);
817 return;
818 } else {
819 /*
820 * This is not a dad solicitation.
821 * If we are an optimistic node,
822 * we should respond.
823 * Otherwise, we should ignore it.
824 */
825 if (!(ifp->flags & IFA_F_OPTIMISTIC))
826 goto out;
827 }
828 }
829
830 idev = ifp->idev;
831 } else {
832 struct net *net = dev_net(dev);
833
834 idev = in6_dev_get(dev);
835 if (!idev) {
836 /* XXX: count this drop? */
837 return;
838 }
839
840 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
841 (idev->cnf.forwarding &&
842 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
843 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
844 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
845 skb->pkt_type != PACKET_HOST &&
846 inc != 0 &&
847 idev->nd_parms->proxy_delay != 0) {
848 /*
849 * for anycast or proxy,
850 * sender should delay its response
851 * by a random time between 0 and
852 * MAX_ANYCAST_DELAY_TIME seconds.
853 * (RFC2461) -- yoshfuji
854 */
855 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
856 if (n)
857 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
858 goto out;
859 }
860 } else
861 goto out;
862 }
863
864 if (is_router < 0)
865 is_router = !!idev->cnf.forwarding;
866
867 if (dad) {
868 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
869 is_router, 0, (ifp != NULL), 1);
870 goto out;
871 }
872
873 if (inc)
874 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
875 else
876 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
877
878 /*
879 * update / create cache entry
880 * for the source address
881 */
882 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
883 !inc || lladdr || !dev->addr_len);
884 if (neigh)
885 neigh_update(neigh, lladdr, NUD_STALE,
886 NEIGH_UPDATE_F_WEAK_OVERRIDE|
887 NEIGH_UPDATE_F_OVERRIDE);
888 if (neigh || !dev->header_ops) {
889 ndisc_send_na(dev, neigh, saddr, &msg->target,
890 is_router,
891 1, (ifp != NULL && inc), inc);
892 if (neigh)
893 neigh_release(neigh);
894 }
895
896 out:
897 if (ifp)
898 in6_ifa_put(ifp);
899 else
900 in6_dev_put(idev);
901 }
902
ndisc_recv_na(struct sk_buff * skb)903 static void ndisc_recv_na(struct sk_buff *skb)
904 {
905 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
906 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
907 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
908 u8 *lladdr = NULL;
909 u32 ndoptlen = skb->tail - (skb->transport_header +
910 offsetof(struct nd_msg, opt));
911 struct ndisc_options ndopts;
912 struct net_device *dev = skb->dev;
913 struct inet6_ifaddr *ifp;
914 struct neighbour *neigh;
915
916 if (skb->len < sizeof(struct nd_msg)) {
917 ND_PRINTK2(KERN_WARNING
918 "ICMPv6 NA: packet too short\n");
919 return;
920 }
921
922 if (ipv6_addr_is_multicast(&msg->target)) {
923 ND_PRINTK2(KERN_WARNING
924 "ICMPv6 NA: target address is multicast.\n");
925 return;
926 }
927
928 if (ipv6_addr_is_multicast(daddr) &&
929 msg->icmph.icmp6_solicited) {
930 ND_PRINTK2(KERN_WARNING
931 "ICMPv6 NA: solicited NA is multicasted.\n");
932 return;
933 }
934
935 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
936 ND_PRINTK2(KERN_WARNING
937 "ICMPv6 NS: invalid ND option\n");
938 return;
939 }
940 if (ndopts.nd_opts_tgt_lladdr) {
941 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
942 if (!lladdr) {
943 ND_PRINTK2(KERN_WARNING
944 "ICMPv6 NA: invalid link-layer address length\n");
945 return;
946 }
947 }
948 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
949 if (ifp) {
950 if (skb->pkt_type != PACKET_LOOPBACK
951 && (ifp->flags & IFA_F_TENTATIVE)) {
952 addrconf_dad_failure(ifp);
953 return;
954 }
955 /* What should we make now? The advertisement
956 is invalid, but ndisc specs say nothing
957 about it. It could be misconfiguration, or
958 an smart proxy agent tries to help us :-)
959
960 We should not print the error if NA has been
961 received from loopback - it is just our own
962 unsolicited advertisement.
963 */
964 if (skb->pkt_type != PACKET_LOOPBACK)
965 ND_PRINTK1(KERN_WARNING
966 "ICMPv6 NA: someone advertises our address %pI6 on %s!\n",
967 &ifp->addr, ifp->idev->dev->name);
968 in6_ifa_put(ifp);
969 return;
970 }
971 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
972
973 if (neigh) {
974 u8 old_flags = neigh->flags;
975 struct net *net = dev_net(dev);
976
977 if (neigh->nud_state & NUD_FAILED)
978 goto out;
979
980 /*
981 * Don't update the neighbor cache entry on a proxy NA from
982 * ourselves because either the proxied node is off link or it
983 * has already sent a NA to us.
984 */
985 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
986 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
987 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
988 /* XXX: idev->cnf.prixy_ndp */
989 goto out;
990 }
991
992 neigh_update(neigh, lladdr,
993 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
994 NEIGH_UPDATE_F_WEAK_OVERRIDE|
995 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
996 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
997 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
998
999 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
1000 /*
1001 * Change: router to host
1002 */
1003 struct rt6_info *rt;
1004 rt = rt6_get_dflt_router(saddr, dev);
1005 if (rt)
1006 ip6_del_rt(rt);
1007 }
1008
1009 out:
1010 neigh_release(neigh);
1011 }
1012 }
1013
ndisc_recv_rs(struct sk_buff * skb)1014 static void ndisc_recv_rs(struct sk_buff *skb)
1015 {
1016 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
1017 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1018 struct neighbour *neigh;
1019 struct inet6_dev *idev;
1020 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
1021 struct ndisc_options ndopts;
1022 u8 *lladdr = NULL;
1023
1024 if (skb->len < sizeof(*rs_msg))
1025 return;
1026
1027 idev = __in6_dev_get(skb->dev);
1028 if (!idev) {
1029 if (net_ratelimit())
1030 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1031 return;
1032 }
1033
1034 /* Don't accept RS if we're not in router mode */
1035 if (!idev->cnf.forwarding)
1036 goto out;
1037
1038 /*
1039 * Don't update NCE if src = ::;
1040 * this implies that the source node has no ip address assigned yet.
1041 */
1042 if (ipv6_addr_any(saddr))
1043 goto out;
1044
1045 /* Parse ND options */
1046 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1047 if (net_ratelimit())
1048 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1049 goto out;
1050 }
1051
1052 if (ndopts.nd_opts_src_lladdr) {
1053 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1054 skb->dev);
1055 if (!lladdr)
1056 goto out;
1057 }
1058
1059 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1060 if (neigh) {
1061 neigh_update(neigh, lladdr, NUD_STALE,
1062 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1063 NEIGH_UPDATE_F_OVERRIDE|
1064 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1065 neigh_release(neigh);
1066 }
1067 out:
1068 return;
1069 }
1070
ndisc_ra_useropt(struct sk_buff * ra,struct nd_opt_hdr * opt)1071 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1072 {
1073 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1074 struct sk_buff *skb;
1075 struct nlmsghdr *nlh;
1076 struct nduseroptmsg *ndmsg;
1077 struct net *net = dev_net(ra->dev);
1078 int err;
1079 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1080 + (opt->nd_opt_len << 3));
1081 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1082
1083 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1084 if (skb == NULL) {
1085 err = -ENOBUFS;
1086 goto errout;
1087 }
1088
1089 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1090 if (nlh == NULL) {
1091 goto nla_put_failure;
1092 }
1093
1094 ndmsg = nlmsg_data(nlh);
1095 ndmsg->nduseropt_family = AF_INET6;
1096 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1097 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1098 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1099 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1100
1101 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1102
1103 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1104 &ipv6_hdr(ra)->saddr);
1105 nlmsg_end(skb, nlh);
1106
1107 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
1108 return;
1109
1110 nla_put_failure:
1111 nlmsg_free(skb);
1112 err = -EMSGSIZE;
1113 errout:
1114 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1115 }
1116
accept_ra(struct inet6_dev * in6_dev)1117 static inline int accept_ra(struct inet6_dev *in6_dev)
1118 {
1119 /*
1120 * If forwarding is enabled, RA are not accepted unless the special
1121 * hybrid mode (accept_ra=2) is enabled.
1122 */
1123 if (in6_dev->cnf.forwarding && in6_dev->cnf.accept_ra < 2)
1124 return 0;
1125
1126 return in6_dev->cnf.accept_ra;
1127 }
1128
ndisc_router_discovery(struct sk_buff * skb)1129 static void ndisc_router_discovery(struct sk_buff *skb)
1130 {
1131 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1132 struct neighbour *neigh = NULL;
1133 struct inet6_dev *in6_dev;
1134 struct rt6_info *rt = NULL;
1135 int lifetime;
1136 struct ndisc_options ndopts;
1137 int optlen;
1138 unsigned int pref = 0;
1139
1140 __u8 * opt = (__u8 *)(ra_msg + 1);
1141
1142 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1143
1144 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1145 ND_PRINTK2(KERN_WARNING
1146 "ICMPv6 RA: source address is not link-local.\n");
1147 return;
1148 }
1149 if (optlen < 0) {
1150 ND_PRINTK2(KERN_WARNING
1151 "ICMPv6 RA: packet too short\n");
1152 return;
1153 }
1154
1155 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1156 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1157 ND_PRINTK2(KERN_WARNING
1158 "ICMPv6 RA: from host or unauthorized router\n");
1159 return;
1160 }
1161 #endif
1162
1163 /*
1164 * set the RA_RECV flag in the interface
1165 */
1166
1167 in6_dev = __in6_dev_get(skb->dev);
1168 if (in6_dev == NULL) {
1169 ND_PRINTK0(KERN_ERR
1170 "ICMPv6 RA: can't find inet6 device for %s.\n",
1171 skb->dev->name);
1172 return;
1173 }
1174
1175 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1176 ND_PRINTK2(KERN_WARNING
1177 "ICMP6 RA: invalid ND options\n");
1178 return;
1179 }
1180
1181 if (!accept_ra(in6_dev))
1182 goto skip_linkparms;
1183
1184 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1185 /* skip link-specific parameters from interior routers */
1186 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1187 goto skip_linkparms;
1188 #endif
1189
1190 if (in6_dev->if_flags & IF_RS_SENT) {
1191 /*
1192 * flag that an RA was received after an RS was sent
1193 * out on this interface.
1194 */
1195 in6_dev->if_flags |= IF_RA_RCVD;
1196 }
1197
1198 /*
1199 * Remember the managed/otherconf flags from most recently
1200 * received RA message (RFC 2462) -- yoshfuji
1201 */
1202 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1203 IF_RA_OTHERCONF)) |
1204 (ra_msg->icmph.icmp6_addrconf_managed ?
1205 IF_RA_MANAGED : 0) |
1206 (ra_msg->icmph.icmp6_addrconf_other ?
1207 IF_RA_OTHERCONF : 0);
1208
1209 if (!in6_dev->cnf.accept_ra_defrtr)
1210 goto skip_defrtr;
1211
1212 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1213 goto skip_defrtr;
1214
1215 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1216
1217 #ifdef CONFIG_IPV6_ROUTER_PREF
1218 pref = ra_msg->icmph.icmp6_router_pref;
1219 /* 10b is handled as if it were 00b (medium) */
1220 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1221 !in6_dev->cnf.accept_ra_rtr_pref)
1222 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1223 #endif
1224
1225 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1226
1227 if (rt) {
1228 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1229 if (!neigh) {
1230 ND_PRINTK0(KERN_ERR
1231 "ICMPv6 RA: %s() got default router without neighbour.\n",
1232 __func__);
1233 dst_release(&rt->dst);
1234 return;
1235 }
1236 }
1237 if (rt && lifetime == 0) {
1238 ip6_del_rt(rt);
1239 rt = NULL;
1240 }
1241
1242 if (rt == NULL && lifetime) {
1243 ND_PRINTK3(KERN_DEBUG
1244 "ICMPv6 RA: adding default router.\n");
1245
1246 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1247 if (rt == NULL) {
1248 ND_PRINTK0(KERN_ERR
1249 "ICMPv6 RA: %s() failed to add default route.\n",
1250 __func__);
1251 return;
1252 }
1253
1254 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1255 if (neigh == NULL) {
1256 ND_PRINTK0(KERN_ERR
1257 "ICMPv6 RA: %s() got default router without neighbour.\n",
1258 __func__);
1259 dst_release(&rt->dst);
1260 return;
1261 }
1262 neigh->flags |= NTF_ROUTER;
1263 } else if (rt) {
1264 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1265 }
1266
1267 if (rt)
1268 rt6_set_expires(rt, jiffies + (HZ * lifetime));
1269 if (ra_msg->icmph.icmp6_hop_limit) {
1270 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1271 if (rt)
1272 dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1273 ra_msg->icmph.icmp6_hop_limit);
1274 }
1275
1276 skip_defrtr:
1277
1278 /*
1279 * Update Reachable Time and Retrans Timer
1280 */
1281
1282 if (in6_dev->nd_parms) {
1283 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1284
1285 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1286 rtime = (rtime*HZ)/1000;
1287 if (rtime < HZ/10)
1288 rtime = HZ/10;
1289 in6_dev->nd_parms->retrans_time = rtime;
1290 in6_dev->tstamp = jiffies;
1291 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1292 }
1293
1294 rtime = ntohl(ra_msg->reachable_time);
1295 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1296 rtime = (rtime*HZ)/1000;
1297
1298 if (rtime < HZ/10)
1299 rtime = HZ/10;
1300
1301 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1302 in6_dev->nd_parms->base_reachable_time = rtime;
1303 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1304 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1305 in6_dev->tstamp = jiffies;
1306 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1307 }
1308 }
1309 }
1310
1311 skip_linkparms:
1312
1313 /*
1314 * Process options.
1315 */
1316
1317 if (!neigh)
1318 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1319 skb->dev, 1);
1320 if (neigh) {
1321 u8 *lladdr = NULL;
1322 if (ndopts.nd_opts_src_lladdr) {
1323 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1324 skb->dev);
1325 if (!lladdr) {
1326 ND_PRINTK2(KERN_WARNING
1327 "ICMPv6 RA: invalid link-layer address length\n");
1328 goto out;
1329 }
1330 }
1331 neigh_update(neigh, lladdr, NUD_STALE,
1332 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1333 NEIGH_UPDATE_F_OVERRIDE|
1334 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1335 NEIGH_UPDATE_F_ISROUTER);
1336 }
1337
1338 if (!accept_ra(in6_dev))
1339 goto out;
1340
1341 #ifdef CONFIG_IPV6_ROUTE_INFO
1342 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1343 goto skip_routeinfo;
1344
1345 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1346 struct nd_opt_hdr *p;
1347 for (p = ndopts.nd_opts_ri;
1348 p;
1349 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1350 struct route_info *ri = (struct route_info *)p;
1351 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1352 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1353 ri->prefix_len == 0)
1354 continue;
1355 #endif
1356 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1357 continue;
1358 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1359 &ipv6_hdr(skb)->saddr);
1360 }
1361 }
1362
1363 skip_routeinfo:
1364 #endif
1365
1366 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1367 /* skip link-specific ndopts from interior routers */
1368 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1369 goto out;
1370 #endif
1371
1372 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1373 struct nd_opt_hdr *p;
1374 for (p = ndopts.nd_opts_pi;
1375 p;
1376 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1377 addrconf_prefix_rcv(skb->dev, (u8 *)p,
1378 (p->nd_opt_len) << 3,
1379 ndopts.nd_opts_src_lladdr != NULL);
1380 }
1381 }
1382
1383 if (ndopts.nd_opts_mtu) {
1384 __be32 n;
1385 u32 mtu;
1386
1387 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1388 mtu = ntohl(n);
1389
1390 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1391 ND_PRINTK2(KERN_WARNING
1392 "ICMPv6 RA: invalid mtu: %d\n",
1393 mtu);
1394 } else if (in6_dev->cnf.mtu6 != mtu) {
1395 in6_dev->cnf.mtu6 = mtu;
1396
1397 if (rt)
1398 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
1399
1400 rt6_mtu_change(skb->dev, mtu);
1401 }
1402 }
1403
1404 if (ndopts.nd_useropts) {
1405 struct nd_opt_hdr *p;
1406 for (p = ndopts.nd_useropts;
1407 p;
1408 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1409 ndisc_ra_useropt(skb, p);
1410 }
1411 }
1412
1413 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1414 ND_PRINTK2(KERN_WARNING
1415 "ICMPv6 RA: invalid RA options");
1416 }
1417 out:
1418 if (rt)
1419 dst_release(&rt->dst);
1420 if (neigh)
1421 neigh_release(neigh);
1422 }
1423
ndisc_redirect_rcv(struct sk_buff * skb)1424 static void ndisc_redirect_rcv(struct sk_buff *skb)
1425 {
1426 struct inet6_dev *in6_dev;
1427 struct icmp6hdr *icmph;
1428 const struct in6_addr *dest;
1429 const struct in6_addr *target; /* new first hop to destination */
1430 struct neighbour *neigh;
1431 int on_link = 0;
1432 struct ndisc_options ndopts;
1433 int optlen;
1434 u8 *lladdr = NULL;
1435
1436 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1437 switch (skb->ndisc_nodetype) {
1438 case NDISC_NODETYPE_HOST:
1439 case NDISC_NODETYPE_NODEFAULT:
1440 ND_PRINTK2(KERN_WARNING
1441 "ICMPv6 Redirect: from host or unauthorized router\n");
1442 return;
1443 }
1444 #endif
1445
1446 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1447 ND_PRINTK2(KERN_WARNING
1448 "ICMPv6 Redirect: source address is not link-local.\n");
1449 return;
1450 }
1451
1452 optlen = skb->tail - skb->transport_header;
1453 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1454
1455 if (optlen < 0) {
1456 ND_PRINTK2(KERN_WARNING
1457 "ICMPv6 Redirect: packet too short\n");
1458 return;
1459 }
1460
1461 icmph = icmp6_hdr(skb);
1462 target = (const struct in6_addr *) (icmph + 1);
1463 dest = target + 1;
1464
1465 if (ipv6_addr_is_multicast(dest)) {
1466 ND_PRINTK2(KERN_WARNING
1467 "ICMPv6 Redirect: destination address is multicast.\n");
1468 return;
1469 }
1470
1471 if (ipv6_addr_equal(dest, target)) {
1472 on_link = 1;
1473 } else if (ipv6_addr_type(target) !=
1474 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1475 ND_PRINTK2(KERN_WARNING
1476 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1477 return;
1478 }
1479
1480 in6_dev = __in6_dev_get(skb->dev);
1481 if (!in6_dev)
1482 return;
1483 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1484 return;
1485
1486 /* RFC2461 8.1:
1487 * The IP source address of the Redirect MUST be the same as the current
1488 * first-hop router for the specified ICMP Destination Address.
1489 */
1490
1491 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1492 ND_PRINTK2(KERN_WARNING
1493 "ICMPv6 Redirect: invalid ND options\n");
1494 return;
1495 }
1496 if (ndopts.nd_opts_tgt_lladdr) {
1497 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1498 skb->dev);
1499 if (!lladdr) {
1500 ND_PRINTK2(KERN_WARNING
1501 "ICMPv6 Redirect: invalid link-layer address length\n");
1502 return;
1503 }
1504 }
1505
1506 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1507 if (neigh) {
1508 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1509 &ipv6_hdr(skb)->saddr, neigh, lladdr,
1510 on_link);
1511 neigh_release(neigh);
1512 }
1513 }
1514
ndisc_send_redirect(struct sk_buff * skb,const struct in6_addr * target)1515 void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target)
1516 {
1517 struct net_device *dev = skb->dev;
1518 struct net *net = dev_net(dev);
1519 struct sock *sk = net->ipv6.ndisc_sk;
1520 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1521 struct sk_buff *buff;
1522 struct icmp6hdr *icmph;
1523 struct in6_addr saddr_buf;
1524 struct in6_addr *addrp;
1525 struct rt6_info *rt;
1526 struct dst_entry *dst;
1527 struct inet6_dev *idev;
1528 struct flowi6 fl6;
1529 u8 *opt;
1530 int hlen, tlen;
1531 int rd_len;
1532 int err;
1533 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1534
1535 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1536 ND_PRINTK2(KERN_WARNING
1537 "ICMPv6 Redirect: no link-local address on %s\n",
1538 dev->name);
1539 return;
1540 }
1541
1542 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1543 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1544 ND_PRINTK2(KERN_WARNING
1545 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1546 return;
1547 }
1548
1549 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
1550 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1551
1552 dst = ip6_route_output(net, NULL, &fl6);
1553 if (dst->error) {
1554 dst_release(dst);
1555 return;
1556 }
1557 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
1558 if (IS_ERR(dst))
1559 return;
1560
1561 rt = (struct rt6_info *) dst;
1562
1563 if (rt->rt6i_flags & RTF_GATEWAY) {
1564 ND_PRINTK2(KERN_WARNING
1565 "ICMPv6 Redirect: destination is not a neighbour.\n");
1566 goto release;
1567 }
1568 if (!rt->rt6i_peer)
1569 rt6_bind_peer(rt, 1);
1570 if (!inet_peer_xrlim_allow(rt->rt6i_peer, 1*HZ))
1571 goto release;
1572
1573 if (dev->addr_len) {
1574 struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target);
1575 if (!neigh) {
1576 ND_PRINTK2(KERN_WARNING
1577 "ICMPv6 Redirect: no neigh for target address\n");
1578 goto release;
1579 }
1580
1581 read_lock_bh(&neigh->lock);
1582 if (neigh->nud_state & NUD_VALID) {
1583 memcpy(ha_buf, neigh->ha, dev->addr_len);
1584 read_unlock_bh(&neigh->lock);
1585 ha = ha_buf;
1586 len += ndisc_opt_addr_space(dev);
1587 } else
1588 read_unlock_bh(&neigh->lock);
1589
1590 neigh_release(neigh);
1591 }
1592
1593 rd_len = min_t(unsigned int,
1594 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1595 rd_len &= ~0x7;
1596 len += rd_len;
1597
1598 hlen = LL_RESERVED_SPACE(dev);
1599 tlen = dev->needed_tailroom;
1600 buff = sock_alloc_send_skb(sk,
1601 (MAX_HEADER + sizeof(struct ipv6hdr) +
1602 len + hlen + tlen),
1603 1, &err);
1604 if (buff == NULL) {
1605 ND_PRINTK0(KERN_ERR
1606 "ICMPv6 Redirect: %s() failed to allocate an skb, err=%d.\n",
1607 __func__, err);
1608 goto release;
1609 }
1610
1611 skb_reserve(buff, hlen);
1612 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1613 IPPROTO_ICMPV6, len);
1614
1615 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
1616 skb_put(buff, len);
1617 icmph = icmp6_hdr(buff);
1618
1619 memset(icmph, 0, sizeof(struct icmp6hdr));
1620 icmph->icmp6_type = NDISC_REDIRECT;
1621
1622 /*
1623 * copy target and destination addresses
1624 */
1625
1626 addrp = (struct in6_addr *)(icmph + 1);
1627 *addrp = *target;
1628 addrp++;
1629 *addrp = ipv6_hdr(skb)->daddr;
1630
1631 opt = (u8*) (addrp + 1);
1632
1633 /*
1634 * include target_address option
1635 */
1636
1637 if (ha)
1638 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1639 dev->addr_len, dev->type);
1640
1641 /*
1642 * build redirect option and copy skb over to the new packet.
1643 */
1644
1645 memset(opt, 0, 8);
1646 *(opt++) = ND_OPT_REDIRECT_HDR;
1647 *(opt++) = (rd_len >> 3);
1648 opt += 6;
1649
1650 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1651
1652 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1653 len, IPPROTO_ICMPV6,
1654 csum_partial(icmph, len, 0));
1655
1656 skb_dst_set(buff, dst);
1657 rcu_read_lock();
1658 idev = __in6_dev_get(dst->dev);
1659 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
1660 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1661 dst_output);
1662 if (!err) {
1663 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
1664 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1665 }
1666
1667 rcu_read_unlock();
1668 return;
1669
1670 release:
1671 dst_release(dst);
1672 }
1673
pndisc_redo(struct sk_buff * skb)1674 static void pndisc_redo(struct sk_buff *skb)
1675 {
1676 ndisc_recv_ns(skb);
1677 kfree_skb(skb);
1678 }
1679
ndisc_rcv(struct sk_buff * skb)1680 int ndisc_rcv(struct sk_buff *skb)
1681 {
1682 struct nd_msg *msg;
1683
1684 if (!pskb_may_pull(skb, skb->len))
1685 return 0;
1686
1687 msg = (struct nd_msg *)skb_transport_header(skb);
1688
1689 __skb_push(skb, skb->data - skb_transport_header(skb));
1690
1691 if (ipv6_hdr(skb)->hop_limit != 255) {
1692 ND_PRINTK2(KERN_WARNING
1693 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1694 ipv6_hdr(skb)->hop_limit);
1695 return 0;
1696 }
1697
1698 if (msg->icmph.icmp6_code != 0) {
1699 ND_PRINTK2(KERN_WARNING
1700 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1701 msg->icmph.icmp6_code);
1702 return 0;
1703 }
1704
1705 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1706
1707 switch (msg->icmph.icmp6_type) {
1708 case NDISC_NEIGHBOUR_SOLICITATION:
1709 ndisc_recv_ns(skb);
1710 break;
1711
1712 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1713 ndisc_recv_na(skb);
1714 break;
1715
1716 case NDISC_ROUTER_SOLICITATION:
1717 ndisc_recv_rs(skb);
1718 break;
1719
1720 case NDISC_ROUTER_ADVERTISEMENT:
1721 ndisc_router_discovery(skb);
1722 break;
1723
1724 case NDISC_REDIRECT:
1725 ndisc_redirect_rcv(skb);
1726 break;
1727 }
1728
1729 return 0;
1730 }
1731
ndisc_netdev_event(struct notifier_block * this,unsigned long event,void * ptr)1732 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1733 {
1734 struct net_device *dev = ptr;
1735 struct net *net = dev_net(dev);
1736
1737 switch (event) {
1738 case NETDEV_CHANGEADDR:
1739 neigh_changeaddr(&nd_tbl, dev);
1740 fib6_run_gc(~0UL, net);
1741 break;
1742 case NETDEV_DOWN:
1743 neigh_ifdown(&nd_tbl, dev);
1744 fib6_run_gc(~0UL, net);
1745 break;
1746 case NETDEV_NOTIFY_PEERS:
1747 ndisc_send_unsol_na(dev);
1748 break;
1749 default:
1750 break;
1751 }
1752
1753 return NOTIFY_DONE;
1754 }
1755
1756 static struct notifier_block ndisc_netdev_notifier = {
1757 .notifier_call = ndisc_netdev_event,
1758 };
1759
1760 #ifdef CONFIG_SYSCTL
ndisc_warn_deprecated_sysctl(struct ctl_table * ctl,const char * func,const char * dev_name)1761 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1762 const char *func, const char *dev_name)
1763 {
1764 static char warncomm[TASK_COMM_LEN];
1765 static int warned;
1766 if (strcmp(warncomm, current->comm) && warned < 5) {
1767 strcpy(warncomm, current->comm);
1768 printk(KERN_WARNING
1769 "process `%s' is using deprecated sysctl (%s) "
1770 "net.ipv6.neigh.%s.%s; "
1771 "Use net.ipv6.neigh.%s.%s_ms "
1772 "instead.\n",
1773 warncomm, func,
1774 dev_name, ctl->procname,
1775 dev_name, ctl->procname);
1776 warned++;
1777 }
1778 }
1779
ndisc_ifinfo_sysctl_change(struct ctl_table * ctl,int write,void __user * buffer,size_t * lenp,loff_t * ppos)1780 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
1781 {
1782 struct net_device *dev = ctl->extra1;
1783 struct inet6_dev *idev;
1784 int ret;
1785
1786 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1787 (strcmp(ctl->procname, "base_reachable_time") == 0))
1788 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1789
1790 if (strcmp(ctl->procname, "retrans_time") == 0)
1791 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1792
1793 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1794 ret = proc_dointvec_jiffies(ctl, write,
1795 buffer, lenp, ppos);
1796
1797 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1798 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1799 ret = proc_dointvec_ms_jiffies(ctl, write,
1800 buffer, lenp, ppos);
1801 else
1802 ret = -1;
1803
1804 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1805 if (ctl->data == &idev->nd_parms->base_reachable_time)
1806 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1807 idev->tstamp = jiffies;
1808 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1809 in6_dev_put(idev);
1810 }
1811 return ret;
1812 }
1813
1814
1815 #endif
1816
ndisc_net_init(struct net * net)1817 static int __net_init ndisc_net_init(struct net *net)
1818 {
1819 struct ipv6_pinfo *np;
1820 struct sock *sk;
1821 int err;
1822
1823 err = inet_ctl_sock_create(&sk, PF_INET6,
1824 SOCK_RAW, IPPROTO_ICMPV6, net);
1825 if (err < 0) {
1826 ND_PRINTK0(KERN_ERR
1827 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1828 err);
1829 return err;
1830 }
1831
1832 net->ipv6.ndisc_sk = sk;
1833
1834 np = inet6_sk(sk);
1835 np->hop_limit = 255;
1836 /* Do not loopback ndisc messages */
1837 np->mc_loop = 0;
1838
1839 return 0;
1840 }
1841
ndisc_net_exit(struct net * net)1842 static void __net_exit ndisc_net_exit(struct net *net)
1843 {
1844 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1845 }
1846
1847 static struct pernet_operations ndisc_net_ops = {
1848 .init = ndisc_net_init,
1849 .exit = ndisc_net_exit,
1850 };
1851
ndisc_init(void)1852 int __init ndisc_init(void)
1853 {
1854 int err;
1855
1856 err = register_pernet_subsys(&ndisc_net_ops);
1857 if (err)
1858 return err;
1859 /*
1860 * Initialize the neighbour table
1861 */
1862 neigh_table_init(&nd_tbl);
1863
1864 #ifdef CONFIG_SYSCTL
1865 err = neigh_sysctl_register(NULL, &nd_tbl.parms, "ipv6",
1866 &ndisc_ifinfo_sysctl_change);
1867 if (err)
1868 goto out_unregister_pernet;
1869 #endif
1870 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1871 if (err)
1872 goto out_unregister_sysctl;
1873 out:
1874 return err;
1875
1876 out_unregister_sysctl:
1877 #ifdef CONFIG_SYSCTL
1878 neigh_sysctl_unregister(&nd_tbl.parms);
1879 out_unregister_pernet:
1880 #endif
1881 unregister_pernet_subsys(&ndisc_net_ops);
1882 goto out;
1883 }
1884
ndisc_cleanup(void)1885 void ndisc_cleanup(void)
1886 {
1887 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1888 #ifdef CONFIG_SYSCTL
1889 neigh_sysctl_unregister(&nd_tbl.parms);
1890 #endif
1891 neigh_table_clear(&nd_tbl);
1892 unregister_pernet_subsys(&ndisc_net_ops);
1893 }
1894