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