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