Annotation of src/sys/netinet6/nd6_nbr.c, Revision 1.53
1.53 ! itojun 1: /* $NetBSD: nd6_nbr.c,v 1.52 2003/10/30 01:43:10 simonb Exp $ */
1.28 itojun 2: /* $KAME: nd6_nbr.c,v 1.61 2001/02/10 16:06:14 jinmei Exp $ */
1.3 thorpej 3:
1.2 itojun 4: /*
5: * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
6: * All rights reserved.
1.22 itojun 7: *
1.2 itojun 8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. Neither the name of the project nor the names of its contributors
17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
1.22 itojun 19: *
1.2 itojun 20: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: */
1.33 lukem 32:
33: #include <sys/cdefs.h>
1.53 ! itojun 34: __KERNEL_RCSID(0, "$NetBSD: nd6_nbr.c,v 1.52 2003/10/30 01:43:10 simonb Exp $");
1.2 itojun 35:
36: #include "opt_inet.h"
1.5 thorpej 37: #include "opt_ipsec.h"
1.2 itojun 38:
39: #include <sys/param.h>
40: #include <sys/systm.h>
41: #include <sys/malloc.h>
42: #include <sys/mbuf.h>
43: #include <sys/socket.h>
44: #include <sys/sockio.h>
45: #include <sys/time.h>
46: #include <sys/kernel.h>
47: #include <sys/errno.h>
48: #include <sys/ioctl.h>
49: #include <sys/syslog.h>
50: #include <sys/queue.h>
1.21 itojun 51: #include <sys/callout.h>
1.2 itojun 52:
53: #include <net/if.h>
54: #include <net/if_types.h>
55: #include <net/if_dl.h>
56: #include <net/route.h>
57:
58: #include <netinet/in.h>
59: #include <netinet/in_var.h>
60: #include <netinet6/in6_var.h>
1.14 itojun 61: #include <netinet/ip6.h>
1.2 itojun 62: #include <netinet6/ip6_var.h>
63: #include <netinet6/nd6.h>
1.14 itojun 64: #include <netinet/icmp6.h>
1.2 itojun 65:
1.18 itojun 66: #ifdef IPSEC
67: #include <netinet6/ipsec.h>
68: #endif
69:
1.9 itojun 70: #include <net/net_osdep.h>
71:
1.2 itojun 72: #define SDL(s) ((struct sockaddr_dl *)s)
73:
74: struct dadq;
75: static struct dadq *nd6_dad_find __P((struct ifaddr *));
1.26 itojun 76: static void nd6_dad_starttimer __P((struct dadq *, int));
77: static void nd6_dad_stoptimer __P((struct dadq *));
1.2 itojun 78: static void nd6_dad_timer __P((struct ifaddr *));
1.9 itojun 79: static void nd6_dad_ns_output __P((struct dadq *, struct ifaddr *));
1.2 itojun 80: static void nd6_dad_ns_input __P((struct ifaddr *));
81: static void nd6_dad_na_input __P((struct ifaddr *));
82:
1.9 itojun 83: static int dad_ignore_ns = 0; /* ignore NS in DAD - specwise incorrect*/
84: static int dad_maxtry = 15; /* max # of *tries* to transmit DAD packet */
1.2 itojun 85:
86: /*
87: * Input an Neighbor Solicitation Message.
88: *
89: * Based on RFC 2461
90: * Based on RFC 2462 (duplicated address detection)
91: */
92: void
93: nd6_ns_input(m, off, icmp6len)
94: struct mbuf *m;
95: int off, icmp6len;
96: {
97: struct ifnet *ifp = m->m_pkthdr.rcvif;
98: struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
1.16 itojun 99: struct nd_neighbor_solicit *nd_ns;
1.2 itojun 100: struct in6_addr saddr6 = ip6->ip6_src;
101: struct in6_addr daddr6 = ip6->ip6_dst;
1.16 itojun 102: struct in6_addr taddr6;
1.2 itojun 103: struct in6_addr myaddr6;
104: char *lladdr = NULL;
105: struct ifaddr *ifa;
106: int lladdrlen = 0;
107: int anycast = 0, proxy = 0, tentative = 0;
1.39 itojun 108: int router = ip6_forwarding;
1.2 itojun 109: int tlladdr;
110: union nd_opts ndopts;
1.16 itojun 111: struct sockaddr_dl *proxydl = NULL;
1.2 itojun 112:
1.26 itojun 113: IP6_EXTHDR_GET(nd_ns, struct nd_neighbor_solicit *, m, off, icmp6len);
114: if (nd_ns == NULL) {
115: icmp6stat.icp6s_tooshort++;
116: return;
117: }
118: ip6 = mtod(m, struct ip6_hdr *); /* adjust pointer for safety */
119: taddr6 = nd_ns->nd_ns_target;
120:
1.2 itojun 121: if (ip6->ip6_hlim != 255) {
1.26 itojun 122: nd6log((LOG_ERR,
123: "nd6_ns_input: invalid hlim (%d) from %s to %s on %s\n",
124: ip6->ip6_hlim, ip6_sprintf(&ip6->ip6_src),
125: ip6_sprintf(&ip6->ip6_dst), if_name(ifp)));
126: goto bad;
1.2 itojun 127: }
128:
129: if (IN6_IS_ADDR_UNSPECIFIED(&saddr6)) {
130: /* dst has to be solicited node multicast address. */
1.39 itojun 131: /* don't check ifindex portion */
132: if (daddr6.s6_addr16[0] == IPV6_ADDR_INT16_MLL &&
133: daddr6.s6_addr32[1] == 0 &&
134: daddr6.s6_addr32[2] == IPV6_ADDR_INT32_ONE &&
135: daddr6.s6_addr8[12] == 0xff) {
1.31 itojun 136: ; /* good */
1.2 itojun 137: } else {
1.26 itojun 138: nd6log((LOG_INFO, "nd6_ns_input: bad DAD packet "
1.39 itojun 139: "(wrong ip6 dst)\n"));
1.2 itojun 140: goto bad;
141: }
142: }
143:
144: if (IN6_IS_ADDR_MULTICAST(&taddr6)) {
1.26 itojun 145: nd6log((LOG_INFO, "nd6_ns_input: bad NS target (multicast)\n"));
1.2 itojun 146: goto bad;
147: }
148:
149: if (IN6_IS_SCOPE_LINKLOCAL(&taddr6))
150: taddr6.s6_addr16[1] = htons(ifp->if_index);
151:
152: icmp6len -= sizeof(*nd_ns);
153: nd6_option_init(nd_ns + 1, icmp6len, &ndopts);
154: if (nd6_options(&ndopts) < 0) {
1.26 itojun 155: nd6log((LOG_INFO,
156: "nd6_ns_input: invalid ND option, ignored\n"));
157: /* nd6_options have incremented stats */
158: goto freeit;
1.2 itojun 159: }
160:
161: if (ndopts.nd_opts_src_lladdr) {
1.31 itojun 162: lladdr = (char *)(ndopts.nd_opts_src_lladdr + 1);
1.2 itojun 163: lladdrlen = ndopts.nd_opts_src_lladdr->nd_opt_len << 3;
164: }
1.42 itojun 165:
1.2 itojun 166: if (IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src) && lladdr) {
1.26 itojun 167: nd6log((LOG_INFO, "nd6_ns_input: bad DAD packet "
168: "(link-layer address option)\n"));
1.2 itojun 169: goto bad;
170: }
171:
172: /*
173: * Attaching target link-layer address to the NA?
174: * (RFC 2461 7.2.4)
175: *
176: * NS IP dst is unicast/anycast MUST NOT add
177: * NS IP dst is solicited-node multicast MUST add
178: *
179: * In implementation, we add target link-layer address by default.
180: * We do not add one in MUST NOT cases.
181: */
182: #if 0 /* too much! */
183: ifa = (struct ifaddr *)in6ifa_ifpwithaddr(ifp, &daddr6);
184: if (ifa && (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_ANYCAST))
185: tlladdr = 0;
186: else
187: #endif
188: if (!IN6_IS_ADDR_MULTICAST(&daddr6))
189: tlladdr = 0;
190: else
191: tlladdr = 1;
192:
193: /*
194: * Target address (taddr6) must be either:
195: * (1) Valid unicast/anycast address for my receiving interface,
196: * (2) Unicast address for which I'm offering proxy service, or
197: * (3) "tentative" address on which DAD is being performed.
198: */
199: /* (1) and (3) check. */
200: ifa = (struct ifaddr *)in6ifa_ifpwithaddr(ifp, &taddr6);
201:
202: /* (2) check. */
1.16 itojun 203: if (!ifa) {
1.2 itojun 204: struct rtentry *rt;
205: struct sockaddr_in6 tsin6;
206:
1.42 itojun 207: bzero(&tsin6, sizeof tsin6);
1.2 itojun 208: tsin6.sin6_len = sizeof(struct sockaddr_in6);
209: tsin6.sin6_family = AF_INET6;
210: tsin6.sin6_addr = taddr6;
211:
1.17 itojun 212: rt = rtalloc1((struct sockaddr *)&tsin6, 0);
1.16 itojun 213: if (rt && (rt->rt_flags & RTF_ANNOUNCE) != 0 &&
214: rt->rt_gateway->sa_family == AF_LINK) {
1.2 itojun 215: /*
1.16 itojun 216: * proxy NDP for single entry
1.2 itojun 217: */
1.16 itojun 218: ifa = (struct ifaddr *)in6ifa_ifpforlinklocal(ifp,
219: IN6_IFF_NOTREADY|IN6_IFF_ANYCAST);
220: if (ifa) {
1.2 itojun 221: proxy = 1;
1.16 itojun 222: proxydl = SDL(rt->rt_gateway);
1.39 itojun 223: router = 0; /* XXX */
1.16 itojun 224: }
1.2 itojun 225: }
1.16 itojun 226: if (rt)
227: rtfree(rt);
1.2 itojun 228: }
229: if (!ifa) {
230: /*
1.26 itojun 231: * We've got an NS packet, and we don't have that adddress
1.2 itojun 232: * assigned for us. We MUST silently ignore it.
233: * See RFC2461 7.2.3.
234: */
1.16 itojun 235: goto freeit;
1.2 itojun 236: }
1.9 itojun 237: myaddr6 = *IFA_IN6(ifa);
1.2 itojun 238: anycast = ((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_ANYCAST;
239: tentative = ((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_TENTATIVE;
240: if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DUPLICATED)
1.16 itojun 241: goto freeit;
1.2 itojun 242:
243: if (lladdr && ((ifp->if_addrlen + 2 + 7) & ~7) != lladdrlen) {
1.39 itojun 244: nd6log((LOG_INFO, "nd6_ns_input: lladdrlen mismatch for %s "
1.2 itojun 245: "(if %d, NS packet %d)\n",
1.39 itojun 246: ip6_sprintf(&taddr6), ifp->if_addrlen, lladdrlen - 2));
1.26 itojun 247: goto bad;
1.2 itojun 248: }
249:
250: if (IN6_ARE_ADDR_EQUAL(&myaddr6, &saddr6)) {
1.39 itojun 251: nd6log((LOG_INFO, "nd6_ns_input: duplicate IP6 address %s\n",
1.31 itojun 252: ip6_sprintf(&saddr6)));
1.16 itojun 253: goto freeit;
1.2 itojun 254: }
255:
256: /*
257: * We have neighbor solicitation packet, with target address equals to
258: * one of my tentative address.
259: *
260: * src addr how to process?
261: * --- ---
262: * multicast of course, invalid (rejected in ip6_input)
263: * unicast somebody is doing address resolution -> ignore
264: * unspec dup address detection
265: *
266: * The processing is defined in RFC 2462.
267: */
268: if (tentative) {
269: /*
270: * If source address is unspecified address, it is for
271: * duplicated address detection.
272: *
273: * If not, the packet is for addess resolution;
274: * silently ignore it.
275: */
276: if (IN6_IS_ADDR_UNSPECIFIED(&saddr6))
277: nd6_dad_ns_input(ifa);
278:
1.16 itojun 279: goto freeit;
1.2 itojun 280: }
281:
282: /*
283: * If the source address is unspecified address, entries must not
284: * be created or updated.
285: * It looks that sender is performing DAD. Output NA toward
286: * all-node multicast address, to tell the sender that I'm using
287: * the address.
288: * S bit ("solicited") must be zero.
289: */
290: if (IN6_IS_ADDR_UNSPECIFIED(&saddr6)) {
291: saddr6 = in6addr_linklocal_allnodes;
292: saddr6.s6_addr16[1] = htons(ifp->if_index);
293: nd6_na_output(ifp, &saddr6, &taddr6,
1.39 itojun 294: ((anycast || proxy || !tlladdr) ? 0 : ND_NA_FLAG_OVERRIDE) |
295: (router ? ND_NA_FLAG_ROUTER : 0),
296: tlladdr, (struct sockaddr *)proxydl);
1.16 itojun 297: goto freeit;
1.2 itojun 298: }
299:
1.7 itojun 300: nd6_cache_lladdr(ifp, &saddr6, lladdr, lladdrlen, ND_NEIGHBOR_SOLICIT, 0);
1.2 itojun 301:
302: nd6_na_output(ifp, &saddr6, &taddr6,
1.39 itojun 303: ((anycast || proxy || !tlladdr) ? 0 : ND_NA_FLAG_OVERRIDE) |
304: (router ? ND_NA_FLAG_ROUTER : 0) | ND_NA_FLAG_SOLICITED,
305: tlladdr, (struct sockaddr *)proxydl);
1.16 itojun 306: freeit:
307: m_freem(m);
1.2 itojun 308: return;
309:
310: bad:
1.26 itojun 311: nd6log((LOG_ERR, "nd6_ns_input: src=%s\n", ip6_sprintf(&saddr6)));
312: nd6log((LOG_ERR, "nd6_ns_input: dst=%s\n", ip6_sprintf(&daddr6)));
313: nd6log((LOG_ERR, "nd6_ns_input: tgt=%s\n", ip6_sprintf(&taddr6)));
314: icmp6stat.icp6s_badns++;
1.16 itojun 315: m_freem(m);
1.2 itojun 316: }
317:
318: /*
319: * Output an Neighbor Solicitation Message. Caller specifies:
320: * - ICMP6 header source IP6 address
321: * - ND6 header target IP6 address
322: * - ND6 header source datalink address
323: *
324: * Based on RFC 2461
325: * Based on RFC 2462 (duplicated address detection)
326: */
327: void
328: nd6_ns_output(ifp, daddr6, taddr6, ln, dad)
329: struct ifnet *ifp;
1.32 itojun 330: const struct in6_addr *daddr6, *taddr6;
1.2 itojun 331: struct llinfo_nd6 *ln; /* for source address determination */
332: int dad; /* duplicated address detection */
333: {
334: struct mbuf *m;
335: struct ip6_hdr *ip6;
336: struct nd_neighbor_solicit *nd_ns;
1.39 itojun 337: struct sockaddr_in6 src_sa, dst_sa;
1.2 itojun 338: struct ip6_moptions im6o;
339: int icmp6len;
1.15 itojun 340: int maxlen;
1.2 itojun 341: caddr_t mac;
1.39 itojun 342: struct route_in6 ro;
343:
344: bzero(&ro, sizeof(ro));
1.42 itojun 345:
1.2 itojun 346: if (IN6_IS_ADDR_MULTICAST(taddr6))
347: return;
348:
1.15 itojun 349: /* estimate the size of message */
350: maxlen = sizeof(*ip6) + sizeof(*nd_ns);
351: maxlen += (sizeof(struct nd_opt_hdr) + ifp->if_addrlen + 7) & ~7;
1.29 itojun 352: #ifdef DIAGNOSTIC
1.15 itojun 353: if (max_linkhdr + maxlen >= MCLBYTES) {
354: printf("nd6_ns_output: max_linkhdr + maxlen >= MCLBYTES "
355: "(%d + %d > %d)\n", max_linkhdr, maxlen, MCLBYTES);
1.29 itojun 356: panic("nd6_ns_output: insufficient MCLBYTES");
357: /* NOTREACHED */
358: }
1.15 itojun 359: #endif
360:
361: MGETHDR(m, M_DONTWAIT, MT_DATA);
362: if (m && max_linkhdr + maxlen >= MHLEN) {
363: MCLGET(m, M_DONTWAIT);
364: if ((m->m_flags & M_EXT) == 0) {
365: m_free(m);
366: m = NULL;
367: }
368: }
369: if (m == NULL)
1.2 itojun 370: return;
1.31 itojun 371: m->m_pkthdr.rcvif = NULL;
1.2 itojun 372:
373: if (daddr6 == NULL || IN6_IS_ADDR_MULTICAST(daddr6)) {
374: m->m_flags |= M_MCAST;
375: im6o.im6o_multicast_ifp = ifp;
376: im6o.im6o_multicast_hlim = 255;
377: im6o.im6o_multicast_loop = 0;
378: }
379:
380: icmp6len = sizeof(*nd_ns);
381: m->m_pkthdr.len = m->m_len = sizeof(*ip6) + icmp6len;
1.31 itojun 382: m->m_data += max_linkhdr; /* or MH_ALIGN() equivalent? */
1.2 itojun 383:
384: /* fill neighbor solicitation packet */
385: ip6 = mtod(m, struct ip6_hdr *);
386: ip6->ip6_flow = 0;
1.10 itojun 387: ip6->ip6_vfc &= ~IPV6_VERSION_MASK;
388: ip6->ip6_vfc |= IPV6_VERSION;
1.2 itojun 389: /* ip6->ip6_plen will be set later */
390: ip6->ip6_nxt = IPPROTO_ICMPV6;
391: ip6->ip6_hlim = 255;
1.39 itojun 392: /* determine the source and destination addresses */
393: bzero(&src_sa, sizeof(src_sa));
394: bzero(&dst_sa, sizeof(dst_sa));
395: src_sa.sin6_family = dst_sa.sin6_family = AF_INET6;
396: src_sa.sin6_len = dst_sa.sin6_len = sizeof(struct sockaddr_in6);
1.2 itojun 397: if (daddr6)
1.39 itojun 398: dst_sa.sin6_addr = *daddr6;
1.2 itojun 399: else {
1.39 itojun 400: dst_sa.sin6_addr.s6_addr16[0] = IPV6_ADDR_INT16_MLL;
401: dst_sa.sin6_addr.s6_addr16[1] = htons(ifp->if_index);
402: dst_sa.sin6_addr.s6_addr32[1] = 0;
403: dst_sa.sin6_addr.s6_addr32[2] = IPV6_ADDR_INT32_ONE;
404: dst_sa.sin6_addr.s6_addr32[3] = taddr6->s6_addr32[3];
405: dst_sa.sin6_addr.s6_addr8[12] = 0xff;
1.2 itojun 406: }
1.39 itojun 407: ip6->ip6_dst = dst_sa.sin6_addr;
1.2 itojun 408: if (!dad) {
409: /*
410: * RFC2461 7.2.2:
411: * "If the source address of the packet prompting the
412: * solicitation is the same as one of the addresses assigned
413: * to the outgoing interface, that address SHOULD be placed
414: * in the IP Source Address of the outgoing solicitation.
415: * Otherwise, any one of the addresses assigned to the
416: * interface should be used."
417: *
418: * We use the source address for the prompting packet
419: * (saddr6), if:
420: * - saddr6 is given from the caller (by giving "ln"), and
421: * - saddr6 belongs to the outgoing interface.
1.39 itojun 422: * Otherwise, we perform the source address selection as usual.
1.2 itojun 423: */
1.31 itojun 424: struct ip6_hdr *hip6; /* hold ip6 */
1.2 itojun 425: struct in6_addr *saddr6;
426:
427: if (ln && ln->ln_hold) {
428: hip6 = mtod(ln->ln_hold, struct ip6_hdr *);
429: /* XXX pullup? */
430: if (sizeof(*hip6) < ln->ln_hold->m_len)
431: saddr6 = &hip6->ip6_src;
432: else
433: saddr6 = NULL;
434: } else
435: saddr6 = NULL;
436: if (saddr6 && in6ifa_ifpwithaddr(ifp, saddr6))
1.39 itojun 437: src_sa.sin6_addr = *saddr6;
1.2 itojun 438: else {
1.39 itojun 439: struct in6_addr *src0;
440: int error;
441:
442: bcopy(&dst_sa, &ro.ro_dst, sizeof(dst_sa));
443: src0 = in6_selectsrc(&dst_sa, NULL, NULL, &ro, NULL,
444: &error);
445: if (src0 == NULL) {
446: nd6log((LOG_DEBUG,
447: "nd6_ns_output: source can't be "
448: "determined: dst=%s, error=%d\n",
449: ip6_sprintf(&dst_sa.sin6_addr), error));
450: goto bad;
1.2 itojun 451: }
1.39 itojun 452: src_sa.sin6_addr = *src0;
1.2 itojun 453: }
454: } else {
455: /*
456: * Source address for DAD packet must always be IPv6
457: * unspecified address. (0::0)
1.39 itojun 458: * We actually don't have to 0-clear the address (we did it
459: * above), but we do so here explicitly to make the intention
460: * clearer.
1.2 itojun 461: */
1.39 itojun 462: bzero(&src_sa.sin6_addr, sizeof(src_sa.sin6_addr));
1.2 itojun 463: }
1.39 itojun 464: ip6->ip6_src = src_sa.sin6_addr;
1.2 itojun 465: nd_ns = (struct nd_neighbor_solicit *)(ip6 + 1);
466: nd_ns->nd_ns_type = ND_NEIGHBOR_SOLICIT;
467: nd_ns->nd_ns_code = 0;
468: nd_ns->nd_ns_reserved = 0;
469: nd_ns->nd_ns_target = *taddr6;
470:
471: if (IN6_IS_SCOPE_LINKLOCAL(&nd_ns->nd_ns_target))
472: nd_ns->nd_ns_target.s6_addr16[1] = 0;
473:
474: /*
475: * Add source link-layer address option.
476: *
477: * spec implementation
478: * --- ---
479: * DAD packet MUST NOT do not add the option
480: * there's no link layer address:
481: * impossible do not add the option
482: * there's link layer address:
483: * Multicast NS MUST add one add the option
484: * Unicast NS SHOULD add one add the option
485: */
486: if (!dad && (mac = nd6_ifptomac(ifp))) {
487: int optlen = sizeof(struct nd_opt_hdr) + ifp->if_addrlen;
488: struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)(nd_ns + 1);
1.8 is 489: /* 8 byte alignments... */
490: optlen = (optlen + 7) & ~7;
1.42 itojun 491:
1.2 itojun 492: m->m_pkthdr.len += optlen;
493: m->m_len += optlen;
494: icmp6len += optlen;
1.8 is 495: bzero((caddr_t)nd_opt, optlen);
1.2 itojun 496: nd_opt->nd_opt_type = ND_OPT_SOURCE_LINKADDR;
497: nd_opt->nd_opt_len = optlen >> 3;
498: bcopy(mac, (caddr_t)(nd_opt + 1), ifp->if_addrlen);
499: }
500:
1.51 itojun 501: ip6->ip6_plen = htons((u_int16_t)icmp6len);
1.2 itojun 502: nd_ns->nd_ns_cksum = 0;
1.39 itojun 503: nd_ns->nd_ns_cksum =
504: in6_cksum(m, IPPROTO_ICMPV6, sizeof(*ip6), icmp6len);
1.2 itojun 505:
1.48 jonathan 506: ip6_output(m, NULL, &ro, dad ? IPV6_UNSPECSRC : 0,
1.49 itojun 507: &im6o, (struct socket *)NULL, NULL);
1.32 itojun 508: icmp6_ifstat_inc(ifp, ifs6_out_msg);
509: icmp6_ifstat_inc(ifp, ifs6_out_neighborsolicit);
1.2 itojun 510: icmp6stat.icp6s_outhist[ND_NEIGHBOR_SOLICIT]++;
1.32 itojun 511:
1.39 itojun 512: if (ro.ro_rt) { /* we don't cache this route. */
513: RTFREE(ro.ro_rt);
514: }
1.32 itojun 515: return;
516:
517: bad:
1.39 itojun 518: if (ro.ro_rt) {
519: RTFREE(ro.ro_rt);
520: }
1.32 itojun 521: m_freem(m);
522: return;
1.2 itojun 523: }
524:
525: /*
526: * Neighbor advertisement input handling.
527: *
528: * Based on RFC 2461
529: * Based on RFC 2462 (duplicated address detection)
1.16 itojun 530: *
531: * the following items are not implemented yet:
532: * - proxy advertisement delay rule (RFC2461 7.2.8, last paragraph, SHOULD)
533: * - anycast advertisement delay rule (RFC2461 7.2.7, SHOULD)
1.2 itojun 534: */
535: void
536: nd6_na_input(m, off, icmp6len)
537: struct mbuf *m;
538: int off, icmp6len;
539: {
540: struct ifnet *ifp = m->m_pkthdr.rcvif;
541: struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
1.16 itojun 542: struct nd_neighbor_advert *nd_na;
1.2 itojun 543: #if 0
544: struct in6_addr saddr6 = ip6->ip6_src;
545: #endif
546: struct in6_addr daddr6 = ip6->ip6_dst;
1.16 itojun 547: struct in6_addr taddr6;
548: int flags;
549: int is_router;
550: int is_solicited;
551: int is_override;
1.2 itojun 552: char *lladdr = NULL;
553: int lladdrlen = 0;
554: struct ifaddr *ifa;
555: struct llinfo_nd6 *ln;
556: struct rtentry *rt;
557: struct sockaddr_dl *sdl;
558: union nd_opts ndopts;
559:
560: if (ip6->ip6_hlim != 255) {
1.26 itojun 561: nd6log((LOG_ERR,
562: "nd6_na_input: invalid hlim (%d) from %s to %s on %s\n",
563: ip6->ip6_hlim, ip6_sprintf(&ip6->ip6_src),
564: ip6_sprintf(&ip6->ip6_dst), if_name(ifp)));
565: goto bad;
1.16 itojun 566: }
567:
568: IP6_EXTHDR_GET(nd_na, struct nd_neighbor_advert *, m, off, icmp6len);
569: if (nd_na == NULL) {
570: icmp6stat.icp6s_tooshort++;
1.2 itojun 571: return;
572: }
1.16 itojun 573: taddr6 = nd_na->nd_na_target;
574: flags = nd_na->nd_na_flags_reserved;
575: is_router = ((flags & ND_NA_FLAG_ROUTER) != 0);
576: is_solicited = ((flags & ND_NA_FLAG_SOLICITED) != 0);
577: is_override = ((flags & ND_NA_FLAG_OVERRIDE) != 0);
1.2 itojun 578:
579: if (IN6_IS_SCOPE_LINKLOCAL(&taddr6))
580: taddr6.s6_addr16[1] = htons(ifp->if_index);
581:
582: if (IN6_IS_ADDR_MULTICAST(&taddr6)) {
1.26 itojun 583: nd6log((LOG_ERR,
1.2 itojun 584: "nd6_na_input: invalid target address %s\n",
1.26 itojun 585: ip6_sprintf(&taddr6)));
586: goto bad;
1.2 itojun 587: }
1.39 itojun 588: if (is_solicited && IN6_IS_ADDR_MULTICAST(&daddr6)) {
589: nd6log((LOG_ERR,
590: "nd6_na_input: a solicited adv is multicasted\n"));
591: goto bad;
592: }
1.2 itojun 593:
594: icmp6len -= sizeof(*nd_na);
595: nd6_option_init(nd_na + 1, icmp6len, &ndopts);
596: if (nd6_options(&ndopts) < 0) {
1.26 itojun 597: nd6log((LOG_INFO,
598: "nd6_na_input: invalid ND option, ignored\n"));
599: /* nd6_options have incremented stats */
1.16 itojun 600: goto freeit;
1.2 itojun 601: }
602:
603: if (ndopts.nd_opts_tgt_lladdr) {
604: lladdr = (char *)(ndopts.nd_opts_tgt_lladdr + 1);
605: lladdrlen = ndopts.nd_opts_tgt_lladdr->nd_opt_len << 3;
606: }
607:
608: ifa = (struct ifaddr *)in6ifa_ifpwithaddr(ifp, &taddr6);
609:
610: /*
611: * Target address matches one of my interface address.
612: *
613: * If my address is tentative, this means that there's somebody
614: * already using the same address as mine. This indicates DAD failure.
615: * This is defined in RFC 2462.
616: *
617: * Otherwise, process as defined in RFC 2461.
618: */
619: if (ifa
620: && (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_TENTATIVE)) {
621: nd6_dad_na_input(ifa);
1.16 itojun 622: goto freeit;
1.2 itojun 623: }
624:
1.31 itojun 625: /* Just for safety, maybe unnecessary. */
1.2 itojun 626: if (ifa) {
627: log(LOG_ERR,
628: "nd6_na_input: duplicate IP6 address %s\n",
629: ip6_sprintf(&taddr6));
1.16 itojun 630: goto freeit;
1.2 itojun 631: }
632:
633: if (lladdr && ((ifp->if_addrlen + 2 + 7) & ~7) != lladdrlen) {
1.39 itojun 634: nd6log((LOG_INFO, "nd6_na_input: lladdrlen mismatch for %s "
635: "(if %d, NA packet %d)\n", ip6_sprintf(&taddr6),
636: ifp->if_addrlen, lladdrlen - 2));
1.26 itojun 637: goto bad;
1.2 itojun 638: }
639:
640: /*
1.39 itojun 641: * If no neighbor cache entry is found, NA SHOULD silently be
642: * discarded.
1.2 itojun 643: */
644: rt = nd6_lookup(&taddr6, 0, ifp);
645: if ((rt == NULL) ||
646: ((ln = (struct llinfo_nd6 *)rt->rt_llinfo) == NULL) ||
647: ((sdl = SDL(rt->rt_gateway)) == NULL))
1.16 itojun 648: goto freeit;
1.2 itojun 649:
650: if (ln->ln_state == ND6_LLINFO_INCOMPLETE) {
651: /*
652: * If the link-layer has address, and no lladdr option came,
653: * discard the packet.
654: */
655: if (ifp->if_addrlen && !lladdr)
1.16 itojun 656: goto freeit;
1.2 itojun 657:
658: /*
659: * Record link-layer address, and update the state.
660: */
661: sdl->sdl_alen = ifp->if_addrlen;
662: bcopy(lladdr, LLADDR(sdl), ifp->if_addrlen);
663: if (is_solicited) {
664: ln->ln_state = ND6_LLINFO_REACHABLE;
1.27 itojun 665: ln->ln_byhint = 0;
1.47 itojun 666: if (!ND6_LLINFO_PERMANENT(ln)) {
667: nd6_llinfo_settimer(ln,
668: (long)ND_IFINFO(rt->rt_ifp)->reachable * hz);
669: }
1.28 itojun 670: } else {
1.2 itojun 671: ln->ln_state = ND6_LLINFO_STALE;
1.47 itojun 672: nd6_llinfo_settimer(ln, (long)nd6_gctimer * hz);
1.31 itojun 673: }
674: if ((ln->ln_router = is_router) != 0) {
675: /*
676: * This means a router's state has changed from
677: * non-reachable to probably reachable, and might
678: * affect the status of associated prefixes..
679: */
680: pfxlist_onlink_check();
1.28 itojun 681: }
1.2 itojun 682: } else {
683: int llchange;
684:
685: /*
686: * Check if the link-layer address has changed or not.
687: */
688: if (!lladdr)
689: llchange = 0;
690: else {
691: if (sdl->sdl_alen) {
692: if (bcmp(lladdr, LLADDR(sdl), ifp->if_addrlen))
693: llchange = 1;
694: else
695: llchange = 0;
696: } else
697: llchange = 1;
698: }
699:
700: /*
701: * This is VERY complex. Look at it with care.
702: *
703: * override solicit lladdr llchange action
704: * (L: record lladdr)
705: *
706: * 0 0 n -- (2c)
707: * 0 0 y n (2b) L
708: * 0 0 y y (1) REACHABLE->STALE
709: * 0 1 n -- (2c) *->REACHABLE
710: * 0 1 y n (2b) L *->REACHABLE
711: * 0 1 y y (1) REACHABLE->STALE
712: * 1 0 n -- (2a)
713: * 1 0 y n (2a) L
714: * 1 0 y y (2a) L *->STALE
715: * 1 1 n -- (2a) *->REACHABLE
716: * 1 1 y n (2a) L *->REACHABLE
717: * 1 1 y y (2a) L *->REACHABLE
718: */
719: if (!is_override && (lladdr && llchange)) { /* (1) */
720: /*
721: * If state is REACHABLE, make it STALE.
722: * no other updates should be done.
723: */
1.28 itojun 724: if (ln->ln_state == ND6_LLINFO_REACHABLE) {
1.2 itojun 725: ln->ln_state = ND6_LLINFO_STALE;
1.47 itojun 726: nd6_llinfo_settimer(ln, (long)nd6_gctimer * hz);
1.28 itojun 727: }
1.16 itojun 728: goto freeit;
1.2 itojun 729: } else if (is_override /* (2a) */
730: || (!is_override && (lladdr && !llchange)) /* (2b) */
731: || !lladdr) { /* (2c) */
732: /*
733: * Update link-local address, if any.
734: */
735: if (lladdr) {
736: sdl->sdl_alen = ifp->if_addrlen;
737: bcopy(lladdr, LLADDR(sdl), ifp->if_addrlen);
738: }
739:
740: /*
741: * If solicited, make the state REACHABLE.
742: * If not solicited and the link-layer address was
743: * changed, make it STALE.
744: */
745: if (is_solicited) {
746: ln->ln_state = ND6_LLINFO_REACHABLE;
1.27 itojun 747: ln->ln_byhint = 0;
1.47 itojun 748: if (!ND6_LLINFO_PERMANENT(ln)) {
749: nd6_llinfo_settimer(ln,
750: (long)ND_IFINFO(ifp)->reachable * hz);
1.2 itojun 751: }
752: } else {
1.28 itojun 753: if (lladdr && llchange) {
1.2 itojun 754: ln->ln_state = ND6_LLINFO_STALE;
1.47 itojun 755: nd6_llinfo_settimer(ln,
756: (long)nd6_gctimer * hz);
1.28 itojun 757: }
1.2 itojun 758: }
759: }
760:
761: if (ln->ln_router && !is_router) {
762: /*
763: * The peer dropped the router flag.
764: * Remove the sender from the Default Router List and
765: * update the Destination Cache entries.
766: */
767: struct nd_defrouter *dr;
768: struct in6_addr *in6;
769: int s;
770:
771: in6 = &((struct sockaddr_in6 *)rt_key(rt))->sin6_addr;
1.29 itojun 772:
773: /*
774: * Lock to protect the default router list.
775: * XXX: this might be unnecessary, since this function
776: * is only called under the network software interrupt
1.37 itojun 777: * context. However, we keep it just for safety.
1.29 itojun 778: */
1.4 itojun 779: s = splsoftnet();
1.2 itojun 780: dr = defrouter_lookup(in6, rt->rt_ifp);
781: if (dr)
782: defrtrlist_del(dr);
1.46 itojun 783: else if (!ip6_forwarding) {
1.2 itojun 784: /*
785: * Even if the neighbor is not in the default
786: * router list, the neighbor may be used
787: * as a next hop for some destinations
788: * (e.g. redirect case). So we must
789: * call rt6_flush explicitly.
790: */
791: rt6_flush(&ip6->ip6_src, rt->rt_ifp);
792: }
793: splx(s);
794: }
795: ln->ln_router = is_router;
796: }
797: rt->rt_flags &= ~RTF_REJECT;
798: ln->ln_asked = 0;
799: if (ln->ln_hold) {
1.22 itojun 800: /*
1.39 itojun 801: * we assume ifp is not a loopback here, so just set the 2nd
1.22 itojun 802: * argument as the 1st one.
803: */
804: nd6_output(ifp, ifp, ln->ln_hold,
1.53 ! itojun 805: (struct sockaddr_in6 *)rt_key(rt), rt);
1.34 itojun 806: ln->ln_hold = NULL;
1.2 itojun 807: }
1.16 itojun 808:
809: freeit:
810: m_freem(m);
1.26 itojun 811: return;
812:
813: bad:
814: icmp6stat.icp6s_badna++;
815: m_freem(m);
1.2 itojun 816: }
817:
818: /*
819: * Neighbor advertisement output handling.
820: *
821: * Based on RFC 2461
822: *
1.16 itojun 823: * the following items are not implemented yet:
824: * - proxy advertisement delay rule (RFC2461 7.2.8, last paragraph, SHOULD)
825: * - anycast advertisement delay rule (RFC2461 7.2.7, SHOULD)
1.2 itojun 826: */
827: void
1.16 itojun 828: nd6_na_output(ifp, daddr6, taddr6, flags, tlladdr, sdl0)
1.2 itojun 829: struct ifnet *ifp;
1.32 itojun 830: const struct in6_addr *daddr6, *taddr6;
1.2 itojun 831: u_long flags;
1.16 itojun 832: int tlladdr; /* 1 if include target link-layer address */
833: struct sockaddr *sdl0; /* sockaddr_dl (= proxy NA) or NULL */
1.2 itojun 834: {
835: struct mbuf *m;
836: struct ip6_hdr *ip6;
837: struct nd_neighbor_advert *nd_na;
838: struct ip6_moptions im6o;
1.53 ! itojun 839: struct sockaddr_in6 dst_sa;
1.39 itojun 840: struct in6_addr *src0;
841: int icmp6len, maxlen, error;
1.2 itojun 842: caddr_t mac;
1.39 itojun 843: struct route_in6 ro;
844:
845: mac = NULL;
846: bzero(&ro, sizeof(ro));
1.15 itojun 847:
848: /* estimate the size of message */
849: maxlen = sizeof(*ip6) + sizeof(*nd_na);
850: maxlen += (sizeof(struct nd_opt_hdr) + ifp->if_addrlen + 7) & ~7;
1.29 itojun 851: #ifdef DIAGNOSTIC
1.15 itojun 852: if (max_linkhdr + maxlen >= MCLBYTES) {
853: printf("nd6_na_output: max_linkhdr + maxlen >= MCLBYTES "
854: "(%d + %d > %d)\n", max_linkhdr, maxlen, MCLBYTES);
1.29 itojun 855: panic("nd6_na_output: insufficient MCLBYTES");
856: /* NOTREACHED */
857: }
1.15 itojun 858: #endif
859:
860: MGETHDR(m, M_DONTWAIT, MT_DATA);
861: if (m && max_linkhdr + maxlen >= MHLEN) {
862: MCLGET(m, M_DONTWAIT);
863: if ((m->m_flags & M_EXT) == 0) {
864: m_free(m);
865: m = NULL;
866: }
867: }
868: if (m == NULL)
1.2 itojun 869: return;
1.31 itojun 870: m->m_pkthdr.rcvif = NULL;
1.2 itojun 871:
872: if (IN6_IS_ADDR_MULTICAST(daddr6)) {
873: m->m_flags |= M_MCAST;
874: im6o.im6o_multicast_ifp = ifp;
875: im6o.im6o_multicast_hlim = 255;
876: im6o.im6o_multicast_loop = 0;
877: }
878:
879: icmp6len = sizeof(*nd_na);
880: m->m_pkthdr.len = m->m_len = sizeof(struct ip6_hdr) + icmp6len;
1.31 itojun 881: m->m_data += max_linkhdr; /* or MH_ALIGN() equivalent? */
1.2 itojun 882:
883: /* fill neighbor advertisement packet */
884: ip6 = mtod(m, struct ip6_hdr *);
885: ip6->ip6_flow = 0;
1.10 itojun 886: ip6->ip6_vfc &= ~IPV6_VERSION_MASK;
887: ip6->ip6_vfc |= IPV6_VERSION;
1.2 itojun 888: ip6->ip6_nxt = IPPROTO_ICMPV6;
889: ip6->ip6_hlim = 255;
1.39 itojun 890: bzero(&dst_sa, sizeof(dst_sa));
1.53 ! itojun 891: dst_sa.sin6_len = sizeof(struct sockaddr_in6);
! 892: dst_sa.sin6_family = AF_INET6;
1.39 itojun 893: dst_sa.sin6_addr = *daddr6;
1.2 itojun 894: if (IN6_IS_ADDR_UNSPECIFIED(daddr6)) {
895: /* reply to DAD */
1.39 itojun 896: dst_sa.sin6_addr.s6_addr16[0] = IPV6_ADDR_INT16_MLL;
897: dst_sa.sin6_addr.s6_addr16[1] = htons(ifp->if_index);
898: dst_sa.sin6_addr.s6_addr32[1] = 0;
899: dst_sa.sin6_addr.s6_addr32[2] = 0;
900: dst_sa.sin6_addr.s6_addr32[3] = IPV6_ADDR_INT32_ONE;
901:
1.2 itojun 902: flags &= ~ND_NA_FLAG_SOLICITED;
1.39 itojun 903: }
904: ip6->ip6_dst = dst_sa.sin6_addr;
1.2 itojun 905:
906: /*
907: * Select a source whose scope is the same as that of the dest.
908: */
1.39 itojun 909: bcopy(&dst_sa, &ro.ro_dst, sizeof(dst_sa));
910: src0 = in6_selectsrc(&dst_sa, NULL, NULL, &ro, NULL, &error);
911: if (src0 == NULL) {
912: nd6log((LOG_DEBUG, "nd6_na_output: source can't be "
913: "determined: dst=%s, error=%d\n",
914: ip6_sprintf(&dst_sa.sin6_addr), error));
915: goto bad;
1.2 itojun 916: }
1.53 ! itojun 917: ip6->ip6_src = *src0;
1.2 itojun 918: nd_na = (struct nd_neighbor_advert *)(ip6 + 1);
919: nd_na->nd_na_type = ND_NEIGHBOR_ADVERT;
920: nd_na->nd_na_code = 0;
921: nd_na->nd_na_target = *taddr6;
922: if (IN6_IS_SCOPE_LINKLOCAL(&nd_na->nd_na_target))
923: nd_na->nd_na_target.s6_addr16[1] = 0;
924:
925: /*
926: * "tlladdr" indicates NS's condition for adding tlladdr or not.
927: * see nd6_ns_input() for details.
928: * Basically, if NS packet is sent to unicast/anycast addr,
929: * target lladdr option SHOULD NOT be included.
930: */
1.16 itojun 931: if (tlladdr) {
932: /*
933: * sdl0 != NULL indicates proxy NA. If we do proxy, use
934: * lladdr in sdl0. If we are not proxying (sending NA for
935: * my address) use lladdr configured for the interface.
936: */
937: if (sdl0 == NULL)
938: mac = nd6_ifptomac(ifp);
939: else if (sdl0->sa_family == AF_LINK) {
940: struct sockaddr_dl *sdl;
941: sdl = (struct sockaddr_dl *)sdl0;
942: if (sdl->sdl_alen == ifp->if_addrlen)
943: mac = LLADDR(sdl);
944: }
945: }
946: if (tlladdr && mac) {
1.2 itojun 947: int optlen = sizeof(struct nd_opt_hdr) + ifp->if_addrlen;
948: struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)(nd_na + 1);
1.42 itojun 949:
1.8 is 950: /* roundup to 8 bytes alignment! */
951: optlen = (optlen + 7) & ~7;
952:
1.2 itojun 953: m->m_pkthdr.len += optlen;
954: m->m_len += optlen;
955: icmp6len += optlen;
1.8 is 956: bzero((caddr_t)nd_opt, optlen);
1.2 itojun 957: nd_opt->nd_opt_type = ND_OPT_TARGET_LINKADDR;
958: nd_opt->nd_opt_len = optlen >> 3;
959: bcopy(mac, (caddr_t)(nd_opt + 1), ifp->if_addrlen);
960: } else
961: flags &= ~ND_NA_FLAG_OVERRIDE;
962:
1.51 itojun 963: ip6->ip6_plen = htons((u_int16_t)icmp6len);
1.2 itojun 964: nd_na->nd_na_flags_reserved = flags;
965: nd_na->nd_na_cksum = 0;
966: nd_na->nd_na_cksum =
1.39 itojun 967: in6_cksum(m, IPPROTO_ICMPV6, sizeof(struct ip6_hdr), icmp6len);
1.2 itojun 968:
1.49 itojun 969: ip6_output(m, NULL, NULL, 0, &im6o, (struct socket *)NULL, NULL);
1.32 itojun 970:
971: icmp6_ifstat_inc(ifp, ifs6_out_msg);
972: icmp6_ifstat_inc(ifp, ifs6_out_neighboradvert);
1.2 itojun 973: icmp6stat.icp6s_outhist[ND_NEIGHBOR_ADVERT]++;
1.39 itojun 974:
975: if (ro.ro_rt) { /* we don't cache this route. */
976: RTFREE(ro.ro_rt);
977: }
978: return;
979:
980: bad:
981: if (ro.ro_rt) {
982: RTFREE(ro.ro_rt);
983: }
984: m_freem(m);
985: return;
1.2 itojun 986: }
987:
988: caddr_t
989: nd6_ifptomac(ifp)
990: struct ifnet *ifp;
991: {
992: switch (ifp->if_type) {
1.8 is 993: case IFT_ARCNET:
1.2 itojun 994: case IFT_ETHER:
995: case IFT_FDDI:
1.23 onoe 996: case IFT_IEEE1394:
1.39 itojun 997: case IFT_PROPVIRTUAL:
998: case IFT_L2VLAN:
999: case IFT_IEEE80211:
1.2 itojun 1000: return LLADDR(ifp->if_sadl);
1001: default:
1002: return NULL;
1003: }
1004: }
1005:
1006: TAILQ_HEAD(dadq_head, dadq);
1007: struct dadq {
1008: TAILQ_ENTRY(dadq) dad_list;
1009: struct ifaddr *dad_ifa;
1010: int dad_count; /* max NS to send */
1.9 itojun 1011: int dad_ns_tcount; /* # of trials to send NS */
1.2 itojun 1012: int dad_ns_ocount; /* NS sent so far */
1013: int dad_ns_icount;
1014: int dad_na_icount;
1.21 itojun 1015: struct callout dad_timer_ch;
1.2 itojun 1016: };
1017:
1018: static struct dadq_head dadq;
1.26 itojun 1019: static int dad_init = 0;
1.2 itojun 1020:
1021: static struct dadq *
1022: nd6_dad_find(ifa)
1023: struct ifaddr *ifa;
1024: {
1025: struct dadq *dp;
1026:
1027: for (dp = dadq.tqh_first; dp; dp = dp->dad_list.tqe_next) {
1028: if (dp->dad_ifa == ifa)
1029: return dp;
1030: }
1031: return NULL;
1032: }
1033:
1.26 itojun 1034: static void
1035: nd6_dad_starttimer(dp, ticks)
1036: struct dadq *dp;
1037: int ticks;
1038: {
1039:
1040: callout_reset(&dp->dad_timer_ch, ticks,
1041: (void (*) __P((void *)))nd6_dad_timer, (void *)dp->dad_ifa);
1042: }
1043:
1044: static void
1045: nd6_dad_stoptimer(dp)
1046: struct dadq *dp;
1047: {
1048:
1049: callout_stop(&dp->dad_timer_ch);
1050: }
1051:
1.2 itojun 1052: /*
1053: * Start Duplicated Address Detection (DAD) for specified interface address.
1054: */
1055: void
1056: nd6_dad_start(ifa, tick)
1057: struct ifaddr *ifa;
1058: int *tick; /* minimum delay ticks for IFF_UP event */
1059: {
1060: struct in6_ifaddr *ia = (struct in6_ifaddr *)ifa;
1061: struct dadq *dp;
1062:
1063: if (!dad_init) {
1064: TAILQ_INIT(&dadq);
1065: dad_init++;
1066: }
1067:
1068: /*
1069: * If we don't need DAD, don't do it.
1070: * There are several cases:
1071: * - DAD is disabled (ip6_dad_count == 0)
1072: * - the interface address is anycast
1073: */
1074: if (!(ia->ia6_flags & IN6_IFF_TENTATIVE)) {
1.15 itojun 1075: log(LOG_DEBUG,
1076: "nd6_dad_start: called with non-tentative address "
1.2 itojun 1077: "%s(%s)\n",
1078: ip6_sprintf(&ia->ia_addr.sin6_addr),
1.9 itojun 1079: ifa->ifa_ifp ? if_name(ifa->ifa_ifp) : "???");
1.2 itojun 1080: return;
1081: }
1082: if (ia->ia6_flags & IN6_IFF_ANYCAST) {
1083: ia->ia6_flags &= ~IN6_IFF_TENTATIVE;
1084: return;
1085: }
1086: if (!ip6_dad_count) {
1087: ia->ia6_flags &= ~IN6_IFF_TENTATIVE;
1088: return;
1089: }
1090: if (!ifa->ifa_ifp)
1091: panic("nd6_dad_start: ifa->ifa_ifp == NULL");
1092: if (!(ifa->ifa_ifp->if_flags & IFF_UP))
1093: return;
1094: if (nd6_dad_find(ifa) != NULL) {
1095: /* DAD already in progress */
1096: return;
1097: }
1098:
1099: dp = malloc(sizeof(*dp), M_IP6NDP, M_NOWAIT);
1100: if (dp == NULL) {
1.15 itojun 1101: log(LOG_ERR, "nd6_dad_start: memory allocation failed for "
1.2 itojun 1102: "%s(%s)\n",
1103: ip6_sprintf(&ia->ia_addr.sin6_addr),
1.9 itojun 1104: ifa->ifa_ifp ? if_name(ifa->ifa_ifp) : "???");
1.2 itojun 1105: return;
1106: }
1107: bzero(dp, sizeof(*dp));
1.21 itojun 1108: callout_init(&dp->dad_timer_ch);
1.2 itojun 1109: TAILQ_INSERT_TAIL(&dadq, (struct dadq *)dp, dad_list);
1110:
1.26 itojun 1111: nd6log((LOG_DEBUG, "%s: starting DAD for %s\n", if_name(ifa->ifa_ifp),
1112: ip6_sprintf(&ia->ia_addr.sin6_addr)));
1.2 itojun 1113:
1114: /*
1115: * Send NS packet for DAD, ip6_dad_count times.
1116: * Note that we must delay the first transmission, if this is the
1117: * first packet to be sent from the interface after interface
1118: * (re)initialization.
1119: */
1120: dp->dad_ifa = ifa;
1.31 itojun 1121: IFAREF(ifa); /* just for safety */
1.2 itojun 1122: dp->dad_count = ip6_dad_count;
1123: dp->dad_ns_icount = dp->dad_na_icount = 0;
1.9 itojun 1124: dp->dad_ns_ocount = dp->dad_ns_tcount = 0;
1.31 itojun 1125: if (tick == NULL) {
1.9 itojun 1126: nd6_dad_ns_output(dp, ifa);
1.38 itojun 1127: nd6_dad_starttimer(dp,
1.47 itojun 1128: (long)ND_IFINFO(ifa->ifa_ifp)->retrans * hz / 1000);
1.2 itojun 1129: } else {
1130: int ntick;
1131:
1132: if (*tick == 0)
1.35 itojun 1133: ntick = arc4random() % (MAX_RTR_SOLICITATION_DELAY * hz);
1.2 itojun 1134: else
1.35 itojun 1135: ntick = *tick + arc4random() % (hz / 2);
1.2 itojun 1136: *tick = ntick;
1.26 itojun 1137: nd6_dad_starttimer(dp, ntick);
1.2 itojun 1138: }
1139: }
1140:
1.26 itojun 1141: /*
1142: * terminate DAD unconditionally. used for address removals.
1143: */
1144: void
1145: nd6_dad_stop(ifa)
1146: struct ifaddr *ifa;
1147: {
1148: struct dadq *dp;
1149:
1150: if (!dad_init)
1151: return;
1152: dp = nd6_dad_find(ifa);
1153: if (!dp) {
1154: /* DAD wasn't started yet */
1155: return;
1156: }
1157:
1158: nd6_dad_stoptimer(dp);
1159:
1160: TAILQ_REMOVE(&dadq, (struct dadq *)dp, dad_list);
1161: free(dp, M_IP6NDP);
1162: dp = NULL;
1163: IFAFREE(ifa);
1164: }
1165:
1.2 itojun 1166: static void
1167: nd6_dad_timer(ifa)
1168: struct ifaddr *ifa;
1169: {
1170: int s;
1171: struct in6_ifaddr *ia = (struct in6_ifaddr *)ifa;
1172: struct dadq *dp;
1173:
1.31 itojun 1174: s = splsoftnet(); /* XXX */
1.2 itojun 1175:
1176: /* Sanity check */
1177: if (ia == NULL) {
1.15 itojun 1178: log(LOG_ERR, "nd6_dad_timer: called with null parameter\n");
1.2 itojun 1179: goto done;
1180: }
1181: dp = nd6_dad_find(ifa);
1182: if (dp == NULL) {
1.15 itojun 1183: log(LOG_ERR, "nd6_dad_timer: DAD structure not found\n");
1.2 itojun 1184: goto done;
1185: }
1186: if (ia->ia6_flags & IN6_IFF_DUPLICATED) {
1.15 itojun 1187: log(LOG_ERR, "nd6_dad_timer: called with duplicated address "
1.2 itojun 1188: "%s(%s)\n",
1189: ip6_sprintf(&ia->ia_addr.sin6_addr),
1.9 itojun 1190: ifa->ifa_ifp ? if_name(ifa->ifa_ifp) : "???");
1.2 itojun 1191: goto done;
1192: }
1193: if ((ia->ia6_flags & IN6_IFF_TENTATIVE) == 0) {
1.15 itojun 1194: log(LOG_ERR, "nd6_dad_timer: called with non-tentative address "
1.2 itojun 1195: "%s(%s)\n",
1196: ip6_sprintf(&ia->ia_addr.sin6_addr),
1.9 itojun 1197: ifa->ifa_ifp ? if_name(ifa->ifa_ifp) : "???");
1198: goto done;
1199: }
1200:
1201: /* timeouted with IFF_{RUNNING,UP} check */
1202: if (dp->dad_ns_tcount > dad_maxtry) {
1.26 itojun 1203: nd6log((LOG_INFO, "%s: could not run DAD, driver problem?\n",
1204: if_name(ifa->ifa_ifp)));
1.9 itojun 1205:
1206: TAILQ_REMOVE(&dadq, (struct dadq *)dp, dad_list);
1207: free(dp, M_IP6NDP);
1208: dp = NULL;
1.13 thorpej 1209: IFAFREE(ifa);
1.2 itojun 1210: goto done;
1211: }
1212:
1213: /* Need more checks? */
1214: if (dp->dad_ns_ocount < dp->dad_count) {
1215: /*
1216: * We have more NS to go. Send NS packet for DAD.
1217: */
1.9 itojun 1218: nd6_dad_ns_output(dp, ifa);
1.38 itojun 1219: nd6_dad_starttimer(dp,
1.47 itojun 1220: (long)ND_IFINFO(ifa->ifa_ifp)->retrans * hz / 1000);
1.2 itojun 1221: } else {
1222: /*
1223: * We have transmitted sufficient number of DAD packets.
1224: * See what we've got.
1225: */
1226: int duplicate;
1227:
1228: duplicate = 0;
1229:
1230: if (dp->dad_na_icount) {
1231: /*
1232: * the check is in nd6_dad_na_input(),
1233: * but just in case
1234: */
1235: duplicate++;
1236: }
1237:
1238: if (dp->dad_ns_icount) {
1.31 itojun 1239: #if 0 /* heuristics */
1.2 itojun 1240: /*
1241: * if
1242: * - we have sent many(?) DAD NS, and
1243: * - the number of NS we sent equals to the
1244: * number of NS we've got, and
1245: * - we've got no NA
1246: * we may have a faulty network card/driver which
1247: * loops back multicasts to myself.
1248: */
1249: if (3 < dp->dad_count
1250: && dp->dad_ns_icount == dp->dad_count
1251: && dp->dad_na_icount == 0) {
1252: log(LOG_INFO, "DAD questionable for %s(%s): "
1.41 itojun 1253: "network card loops back multicast?\n",
1254: ip6_sprintf(&ia->ia_addr.sin6_addr),
1255: if_name(ifa->ifa_ifp));
1.2 itojun 1256: /* XXX consider it a duplicate or not? */
1257: /* duplicate++; */
1258: } else {
1259: /* We've seen NS, means DAD has failed. */
1260: duplicate++;
1261: }
1262: #else
1263: /* We've seen NS, means DAD has failed. */
1264: duplicate++;
1265: #endif
1266: }
1267:
1268: if (duplicate) {
1269: /* (*dp) will be freed in nd6_dad_duplicated() */
1270: dp = NULL;
1271: nd6_dad_duplicated(ifa);
1272: } else {
1273: /*
1274: * We are done with DAD. No NA came, no NS came.
1275: * duplicated address found.
1276: */
1277: ia->ia6_flags &= ~IN6_IFF_TENTATIVE;
1278:
1.26 itojun 1279: nd6log((LOG_DEBUG,
1.15 itojun 1280: "%s: DAD complete for %s - no duplicates found\n",
1281: if_name(ifa->ifa_ifp),
1.26 itojun 1282: ip6_sprintf(&ia->ia_addr.sin6_addr)));
1.6 thorpej 1283:
1.2 itojun 1284: TAILQ_REMOVE(&dadq, (struct dadq *)dp, dad_list);
1285: free(dp, M_IP6NDP);
1286: dp = NULL;
1.13 thorpej 1287: IFAFREE(ifa);
1.2 itojun 1288: }
1289: }
1290:
1291: done:
1292: splx(s);
1293: }
1294:
1295: void
1296: nd6_dad_duplicated(ifa)
1297: struct ifaddr *ifa;
1298: {
1299: struct in6_ifaddr *ia = (struct in6_ifaddr *)ifa;
1300: struct dadq *dp;
1301:
1302: dp = nd6_dad_find(ifa);
1303: if (dp == NULL) {
1.15 itojun 1304: log(LOG_ERR, "nd6_dad_duplicated: DAD structure not found\n");
1.2 itojun 1305: return;
1306: }
1307:
1.31 itojun 1308: log(LOG_ERR, "%s: DAD detected duplicate IPv6 address %s: "
1309: "NS in/out=%d/%d, NA in=%d\n",
1310: if_name(ifa->ifa_ifp), ip6_sprintf(&ia->ia_addr.sin6_addr),
1311: dp->dad_ns_icount, dp->dad_ns_ocount, dp->dad_na_icount);
1.2 itojun 1312:
1313: ia->ia6_flags &= ~IN6_IFF_TENTATIVE;
1314: ia->ia6_flags |= IN6_IFF_DUPLICATED;
1315:
1316: /* We are done with DAD, with duplicated address found. (failure) */
1.26 itojun 1317: nd6_dad_stoptimer(dp);
1.2 itojun 1318:
1.15 itojun 1319: log(LOG_ERR, "%s: DAD complete for %s - duplicate found\n",
1.9 itojun 1320: if_name(ifa->ifa_ifp), ip6_sprintf(&ia->ia_addr.sin6_addr));
1.15 itojun 1321: log(LOG_ERR, "%s: manual intervention required\n",
1322: if_name(ifa->ifa_ifp));
1.6 thorpej 1323:
1.2 itojun 1324: TAILQ_REMOVE(&dadq, (struct dadq *)dp, dad_list);
1325: free(dp, M_IP6NDP);
1326: dp = NULL;
1.13 thorpej 1327: IFAFREE(ifa);
1.2 itojun 1328: }
1329:
1.9 itojun 1330: static void
1331: nd6_dad_ns_output(dp, ifa)
1332: struct dadq *dp;
1333: struct ifaddr *ifa;
1334: {
1335: struct in6_ifaddr *ia = (struct in6_ifaddr *)ifa;
1336: struct ifnet *ifp = ifa->ifa_ifp;
1337:
1338: dp->dad_ns_tcount++;
1339: if ((ifp->if_flags & IFF_UP) == 0) {
1340: #if 0
1341: printf("%s: interface down?\n", if_name(ifp));
1342: #endif
1343: return;
1344: }
1345: if ((ifp->if_flags & IFF_RUNNING) == 0) {
1346: #if 0
1347: printf("%s: interface not running?\n", if_name(ifp));
1348: #endif
1349: return;
1350: }
1351:
1352: dp->dad_ns_ocount++;
1353: nd6_ns_output(ifp, NULL, &ia->ia_addr.sin6_addr, NULL, 1);
1354: }
1355:
1356: static void
1.2 itojun 1357: nd6_dad_ns_input(ifa)
1358: struct ifaddr *ifa;
1359: {
1360: struct in6_ifaddr *ia;
1.32 itojun 1361: const struct in6_addr *taddr6;
1.2 itojun 1362: struct dadq *dp;
1363: int duplicate;
1364:
1365: if (!ifa)
1366: panic("ifa == NULL in nd6_dad_ns_input");
1367:
1368: ia = (struct in6_ifaddr *)ifa;
1369: taddr6 = &ia->ia_addr.sin6_addr;
1370: duplicate = 0;
1371: dp = nd6_dad_find(ifa);
1372:
1373: /* Quickhack - completely ignore DAD NS packets */
1374: if (dad_ignore_ns) {
1.26 itojun 1375: nd6log((LOG_INFO,
1376: "nd6_dad_ns_input: ignoring DAD NS packet for "
1.2 itojun 1377: "address %s(%s)\n", ip6_sprintf(taddr6),
1.26 itojun 1378: if_name(ifa->ifa_ifp)));
1.2 itojun 1379: return;
1380: }
1381:
1382: /*
1383: * if I'm yet to start DAD, someone else started using this address
1384: * first. I have a duplicate and you win.
1385: */
1386: if (!dp || dp->dad_ns_ocount == 0)
1387: duplicate++;
1388:
1389: /* XXX more checks for loopback situation - see nd6_dad_timer too */
1390:
1391: if (duplicate) {
1392: dp = NULL; /* will be freed in nd6_dad_duplicated() */
1393: nd6_dad_duplicated(ifa);
1394: } else {
1395: /*
1396: * not sure if I got a duplicate.
1397: * increment ns count and see what happens.
1398: */
1399: if (dp)
1400: dp->dad_ns_icount++;
1401: }
1402: }
1403:
1.9 itojun 1404: static void
1.2 itojun 1405: nd6_dad_na_input(ifa)
1406: struct ifaddr *ifa;
1407: {
1408: struct dadq *dp;
1409:
1410: if (!ifa)
1411: panic("ifa == NULL in nd6_dad_na_input");
1412:
1413: dp = nd6_dad_find(ifa);
1414: if (dp)
1415: dp->dad_na_icount++;
1416:
1417: /* remove the address. */
1418: nd6_dad_duplicated(ifa);
1419: }
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to nd6_nbr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / netinet6