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