Bring CARP into the tree. CARP = Common Address Redundancy Protocol, which
[dragonfly.git] / sys / netinet6 / in6.c
CommitLineData
984263bc 1/* $FreeBSD: src/sys/netinet6/in6.c,v 1.7.2.9 2002/04/28 05:40:26 suz Exp $ */
0d16ba1d 2/* $DragonFly: src/sys/netinet6/in6.c,v 1.25 2007/08/16 20:03:58 dillon Exp $ */
984263bc
MD
3/* $KAME: in6.c,v 1.259 2002/01/21 11:37:50 keiichi Exp $ */
4
5/*
6 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the project nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34/*
35 * Copyright (c) 1982, 1986, 1991, 1993
36 * The Regents of the University of California. All rights reserved.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. All advertising materials mentioning features or use of this software
47 * must display the following acknowledgement:
48 * This product includes software developed by the University of
49 * California, Berkeley and its contributors.
50 * 4. Neither the name of the University nor the names of its contributors
51 * may be used to endorse or promote products derived from this software
52 * without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64 * SUCH DAMAGE.
65 *
66 * @(#)in.c 8.2 (Berkeley) 11/15/93
67 */
68
69#include "opt_inet.h"
70#include "opt_inet6.h"
71
72#include <sys/param.h>
73#include <sys/errno.h>
74#include <sys/malloc.h>
75#include <sys/socket.h>
76#include <sys/socketvar.h>
77#include <sys/sockio.h>
78#include <sys/systm.h>
79#include <sys/proc.h>
80#include <sys/time.h>
81#include <sys/kernel.h>
82#include <sys/syslog.h>
abf782b3 83#include <sys/thread2.h>
984263bc
MD
84
85#include <net/if.h>
86#include <net/if_types.h>
87#include <net/route.h>
88#include <net/if_dl.h>
89
90#include <netinet/in.h>
91#include <netinet/in_var.h>
92#include <netinet/if_ether.h>
984263bc
MD
93#include <netinet/in_systm.h>
94#include <netinet/ip.h>
95#include <netinet/in_pcb.h>
984263bc
MD
96
97#include <netinet/ip6.h>
98#include <netinet6/ip6_var.h>
99#include <netinet6/nd6.h>
100#include <netinet6/mld6_var.h>
101#include <netinet6/ip6_mroute.h>
102#include <netinet6/in6_ifattach.h>
103#include <netinet6/scope6_var.h>
984263bc 104#include <netinet6/in6_pcb.h>
c66faf37 105#include <netinet6/in6_var.h>
984263bc
MD
106
107#include <net/net_osdep.h>
108
984263bc
MD
109/*
110 * Definitions of some costant IP6 addresses.
111 */
84204577
MD
112const struct in6_addr kin6addr_any = IN6ADDR_ANY_INIT;
113const struct in6_addr kin6addr_loopback = IN6ADDR_LOOPBACK_INIT;
114const struct in6_addr kin6addr_nodelocal_allnodes =
984263bc 115 IN6ADDR_NODELOCAL_ALLNODES_INIT;
84204577 116const struct in6_addr kin6addr_linklocal_allnodes =
984263bc 117 IN6ADDR_LINKLOCAL_ALLNODES_INIT;
84204577 118const struct in6_addr kin6addr_linklocal_allrouters =
984263bc
MD
119 IN6ADDR_LINKLOCAL_ALLROUTERS_INIT;
120
121const struct in6_addr in6mask0 = IN6MASK0;
122const struct in6_addr in6mask32 = IN6MASK32;
123const struct in6_addr in6mask64 = IN6MASK64;
124const struct in6_addr in6mask96 = IN6MASK96;
125const struct in6_addr in6mask128 = IN6MASK128;
126
127const struct sockaddr_in6 sa6_any = {sizeof(sa6_any), AF_INET6,
128 0, 0, IN6ADDR_ANY_INIT, 0};
129
56d702cc
RG
130static int in6_lifaddr_ioctl (struct socket *, u_long, caddr_t,
131 struct ifnet *, struct thread *);
132static int in6_ifinit (struct ifnet *, struct in6_ifaddr *,
133 struct sockaddr_in6 *, int);
134static void in6_unlink_ifa (struct in6_ifaddr *, struct ifnet *);
ecdefdda 135static void in6_ifloop_request_callback(int, int, struct rt_addrinfo *, struct rtentry *, void *);
984263bc
MD
136
137struct in6_multihead in6_multihead; /* XXX BSS initialization */
138
139int (*faithprefix_p)(struct in6_addr *);
140
141/*
142 * Subroutine for in6_ifaddloop() and in6_ifremloop().
143 * This routine does actual work.
144 */
145static void
146in6_ifloop_request(int cmd, struct ifaddr *ifa)
147{
148 struct sockaddr_in6 all1_sa;
ecdefdda
MD
149 struct rt_addrinfo rtinfo;
150 int error;
bde3511a 151
984263bc
MD
152 bzero(&all1_sa, sizeof(all1_sa));
153 all1_sa.sin6_family = AF_INET6;
154 all1_sa.sin6_len = sizeof(struct sockaddr_in6);
155 all1_sa.sin6_addr = in6mask128;
bde3511a 156
984263bc
MD
157 /*
158 * We specify the address itself as the gateway, and set the
159 * RTF_LLINFO flag, so that the corresponding host route would have
160 * the flag, and thus applications that assume traditional behavior
161 * would be happy. Note that we assume the caller of the function
162 * (probably implicitly) set nd6_rtrequest() to ifa->ifa_rtrequest,
163 * which changes the outgoing interface to the loopback interface.
164 */
ecdefdda
MD
165 bzero(&rtinfo, sizeof(struct rt_addrinfo));
166 rtinfo.rti_info[RTAX_DST] = ifa->ifa_addr;
167 rtinfo.rti_info[RTAX_GATEWAY] = ifa->ifa_addr;
168 rtinfo.rti_info[RTAX_NETMASK] = (struct sockaddr *)&all1_sa;
169 rtinfo.rti_flags = RTF_UP|RTF_HOST|RTF_LLINFO;
170
bde3511a 171 error = rtrequest1_global(cmd, &rtinfo,
ecdefdda
MD
172 in6_ifloop_request_callback, ifa);
173 if (error != 0) {
984263bc
MD
174 log(LOG_ERR, "in6_ifloop_request: "
175 "%s operation failed for %s (errno=%d)\n",
176 cmd == RTM_ADD ? "ADD" : "DELETE",
177 ip6_sprintf(&((struct in6_ifaddr *)ifa)->ia_addr.sin6_addr),
ecdefdda 178 error);
984263bc 179 }
ecdefdda
MD
180}
181
182static void
183in6_ifloop_request_callback(int cmd, int error, struct rt_addrinfo *rtinfo,
184 struct rtentry *rt, void *arg)
185{
186 struct ifaddr *ifa = arg;
187
188 if (error)
189 goto done;
984263bc
MD
190
191 /*
192 * Make sure rt_ifa be equal to IFA, the second argument of the
193 * function.
194 * We need this because when we refer to rt_ifa->ia6_flags in
195 * ip6_input, we assume that the rt_ifa points to the address instead
196 * of the loopback address.
197 */
ecdefdda
MD
198 if (cmd == RTM_ADD && rt && ifa != rt->rt_ifa) {
199 ++rt->rt_refcnt;
200 IFAFREE(rt->rt_ifa);
984263bc 201 IFAREF(ifa);
ecdefdda
MD
202 rt->rt_ifa = ifa;
203 --rt->rt_refcnt;
984263bc
MD
204 }
205
206 /*
207 * Report the addition/removal of the address to the routing socket.
208 * XXX: since we called rtinit for a p2p interface with a destination,
209 * we end up reporting twice in such a case. Should we rather
210 * omit the second report?
211 */
ecdefdda
MD
212 if (rt) {
213 if (mycpuid == 0)
214 rt_newaddrmsg(cmd, ifa, error, rt);
984263bc 215 if (cmd == RTM_DELETE) {
ecdefdda
MD
216 if (rt->rt_refcnt == 0) {
217 ++rt->rt_refcnt;
218 rtfree(rt);
984263bc 219 }
984263bc
MD
220 }
221 }
ecdefdda
MD
222done:
223 /* no way to return any new error */
224 ;
984263bc
MD
225}
226
227/*
228 * Add ownaddr as loopback rtentry. We previously add the route only if
229 * necessary (ex. on a p2p link). However, since we now manage addresses
230 * separately from prefixes, we should always add the route. We can't
231 * rely on the cloning mechanism from the corresponding interface route
232 * any more.
233 */
0d16ba1d 234void
984263bc
MD
235in6_ifaddloop(struct ifaddr *ifa)
236{
237 struct rtentry *rt;
238
239 /* If there is no loopback entry, allocate one. */
f3ed2586 240 rt = rtpurelookup(ifa->ifa_addr);
f23061d4
JH
241 if (rt == NULL || !(rt->rt_flags & RTF_HOST) ||
242 !(rt->rt_ifp->if_flags & IFF_LOOPBACK))
984263bc 243 in6_ifloop_request(RTM_ADD, ifa);
0c3c561c 244 if (rt != NULL)
984263bc
MD
245 rt->rt_refcnt--;
246}
247
248/*
249 * Remove loopback rtentry of ownaddr generated by in6_ifaddloop(),
250 * if it exists.
251 */
0d16ba1d 252void
984263bc
MD
253in6_ifremloop(struct ifaddr *ifa)
254{
255 struct in6_ifaddr *ia;
256 struct rtentry *rt;
257 int ia_count = 0;
258
259 /*
260 * Some of BSD variants do not remove cloned routes
261 * from an interface direct route, when removing the direct route
262 * (see comments in net/net_osdep.h). Even for variants that do remove
263 * cloned routes, they could fail to remove the cloned routes when
264 * we handle multple addresses that share a common prefix.
265 * So, we should remove the route corresponding to the deleted address
266 * regardless of the result of in6_is_ifloop_auto().
267 */
268
269 /*
270 * Delete the entry only if exact one ifa exists. More than one ifa
271 * can exist if we assign a same single address to multiple
272 * (probably p2p) interfaces.
273 * XXX: we should avoid such a configuration in IPv6...
274 */
275 for (ia = in6_ifaddr; ia; ia = ia->ia_next) {
276 if (IN6_ARE_ADDR_EQUAL(IFA_IN6(ifa), &ia->ia_addr.sin6_addr)) {
277 ia_count++;
278 if (ia_count > 1)
279 break;
280 }
281 }
282
283 if (ia_count == 1) {
284 /*
285 * Before deleting, check if a corresponding loopbacked host
286 * route surely exists. With this check, we can avoid to
287 * delete an interface direct route whose destination is same
288 * as the address being removed. This can happen when remofing
289 * a subnet-router anycast address on an interface attahced
290 * to a shared medium.
291 */
f3ed2586 292 rt = rtpurelookup(ifa->ifa_addr);
f23061d4
JH
293 if (rt != NULL && (rt->rt_flags & RTF_HOST) &&
294 (rt->rt_ifp->if_flags & IFF_LOOPBACK)) {
984263bc
MD
295 rt->rt_refcnt--;
296 in6_ifloop_request(RTM_DELETE, ifa);
297 }
298 }
299}
300
301int
122ebd49 302in6_ifindex2scopeid(int idx)
984263bc
MD
303{
304 struct ifnet *ifp;
305 struct ifaddr *ifa;
306 struct sockaddr_in6 *sin6;
307
308 if (idx < 0 || if_index < idx)
309 return -1;
310 ifp = ifindex2ifnet[idx];
311
312 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)
313 {
314 if (ifa->ifa_addr->sa_family != AF_INET6)
315 continue;
316 sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
317 if (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))
318 return sin6->sin6_scope_id & 0xffff;
319 }
320
321 return -1;
322}
323
324int
122ebd49 325in6_mask2len(struct in6_addr *mask, u_char *lim0)
984263bc
MD
326{
327 int x = 0, y;
328 u_char *lim = lim0, *p;
329
330 if (lim0 == NULL ||
331 lim0 - (u_char *)mask > sizeof(*mask)) /* ignore the scope_id part */
332 lim = (u_char *)mask + sizeof(*mask);
333 for (p = (u_char *)mask; p < lim; x++, p++) {
334 if (*p != 0xff)
335 break;
336 }
337 y = 0;
338 if (p < lim) {
339 for (y = 0; y < 8; y++) {
340 if ((*p & (0x80 >> y)) == 0)
341 break;
342 }
343 }
344
345 /*
346 * when the limit pointer is given, do a stricter check on the
347 * remaining bits.
348 */
349 if (p < lim) {
350 if (y != 0 && (*p & (0x00ff >> y)) != 0)
bde3511a 351 return (-1);
984263bc
MD
352 for (p = p + 1; p < lim; p++)
353 if (*p != 0)
bde3511a 354 return (-1);
984263bc 355 }
bde3511a 356
984263bc
MD
357 return x * 8 + y;
358}
359
360void
122ebd49 361in6_len2mask(struct in6_addr *mask, int len)
984263bc
MD
362{
363 int i;
364
365 bzero(mask, sizeof(*mask));
366 for (i = 0; i < len / 8; i++)
367 mask->s6_addr8[i] = 0xff;
368 if (len % 8)
369 mask->s6_addr8[i] = (0xff00 >> (len % 8)) & 0xff;
370}
371
372#define ifa2ia6(ifa) ((struct in6_ifaddr *)(ifa))
373#define ia62ifa(ia6) (&((ia6)->ia_ifa))
374
375int
dadab5e9 376in6_control(struct socket *so, u_long cmd, caddr_t data,
122ebd49 377 struct ifnet *ifp, struct thread *td)
984263bc
MD
378{
379 struct in6_ifreq *ifr = (struct in6_ifreq *)data;
380 struct in6_ifaddr *ia = NULL;
381 struct in6_aliasreq *ifra = (struct in6_aliasreq *)data;
382 int privileged;
78195a76 383 int error;
984263bc
MD
384
385 privileged = 0;
dadab5e9 386 if (suser(td) == 0)
984263bc
MD
387 privileged++;
388
389 switch (cmd) {
390 case SIOCGETSGCNT_IN6:
391 case SIOCGETMIFCNT_IN6:
392 return (mrt6_ioctl(cmd, data));
393 }
394
395 if (ifp == NULL)
bde3511a 396 return (EOPNOTSUPP);
984263bc
MD
397
398 switch (cmd) {
399 case SIOCSNDFLUSH_IN6:
400 case SIOCSPFXFLUSH_IN6:
401 case SIOCSRTRFLUSH_IN6:
402 case SIOCSDEFIFACE_IN6:
403 case SIOCSIFINFO_FLAGS:
404 if (!privileged)
bde3511a 405 return (EPERM);
984263bc
MD
406 /* fall through */
407 case OSIOCGIFINFO_IN6:
408 case SIOCGIFINFO_IN6:
409 case SIOCGDRLST_IN6:
410 case SIOCGPRLST_IN6:
411 case SIOCGNBRINFO_IN6:
412 case SIOCGDEFIFACE_IN6:
bde3511a 413 return (nd6_ioctl(cmd, data, ifp));
984263bc
MD
414 }
415
416 switch (cmd) {
417 case SIOCSIFPREFIX_IN6:
418 case SIOCDIFPREFIX_IN6:
419 case SIOCAIFPREFIX_IN6:
420 case SIOCCIFPREFIX_IN6:
421 case SIOCSGIFPREFIX_IN6:
422 case SIOCGIFPREFIX_IN6:
423 log(LOG_NOTICE,
424 "prefix ioctls are now invalidated. "
425 "please use ifconfig.\n");
bde3511a 426 return (EOPNOTSUPP);
984263bc
MD
427 }
428
429 switch (cmd) {
430 case SIOCSSCOPE6:
431 if (!privileged)
bde3511a
JH
432 return (EPERM);
433 return (scope6_set(ifp,
698ac46c 434 (struct scope6_id *)ifr->ifr_ifru.ifru_scope_id));
984263bc
MD
435 break;
436 case SIOCGSCOPE6:
bde3511a 437 return (scope6_get(ifp,
698ac46c 438 (struct scope6_id *)ifr->ifr_ifru.ifru_scope_id));
984263bc
MD
439 break;
440 case SIOCGSCOPE6DEF:
bde3511a 441 return (scope6_get_default((struct scope6_id *)
698ac46c 442 ifr->ifr_ifru.ifru_scope_id));
984263bc
MD
443 break;
444 }
445
446 switch (cmd) {
447 case SIOCALIFADDR:
448 case SIOCDLIFADDR:
449 if (!privileged)
bde3511a 450 return (EPERM);
984263bc
MD
451 /* fall through */
452 case SIOCGLIFADDR:
ab1c1714 453 return in6_lifaddr_ioctl(so, cmd, data, ifp, td);
984263bc
MD
454 }
455
456 /*
457 * Find address for this interface, if it exists.
458 */
459 if (ifra->ifra_addr.sin6_family == AF_INET6) { /* XXX */
460 struct sockaddr_in6 *sa6 =
461 (struct sockaddr_in6 *)&ifra->ifra_addr;
462
463 if (IN6_IS_ADDR_LINKLOCAL(&sa6->sin6_addr)) {
464 if (sa6->sin6_addr.s6_addr16[1] == 0) {
465 /* link ID is not embedded by the user */
466 sa6->sin6_addr.s6_addr16[1] =
467 htons(ifp->if_index);
468 } else if (sa6->sin6_addr.s6_addr16[1] !=
469 htons(ifp->if_index)) {
bde3511a 470 return (EINVAL); /* link ID contradicts */
984263bc
MD
471 }
472 if (sa6->sin6_scope_id) {
473 if (sa6->sin6_scope_id !=
474 (u_int32_t)ifp->if_index)
bde3511a 475 return (EINVAL);
984263bc
MD
476 sa6->sin6_scope_id = 0; /* XXX: good way? */
477 }
478 }
479 ia = in6ifa_ifpwithaddr(ifp, &ifra->ifra_addr.sin6_addr);
480 }
481
482 switch (cmd) {
483 case SIOCSIFADDR_IN6:
484 case SIOCSIFDSTADDR_IN6:
485 case SIOCSIFNETMASK_IN6:
486 /*
487 * Since IPv6 allows a node to assign multiple addresses
488 * on a single interface, SIOCSIFxxx ioctls are not suitable
489 * and should be unused.
490 */
491 /* we decided to obsolete this command (20000704) */
bde3511a 492 return (EINVAL);
984263bc
MD
493
494 case SIOCDIFADDR_IN6:
495 /*
496 * for IPv4, we look for existing in_ifaddr here to allow
497 * "ifconfig if0 delete" to remove first IPv4 address on the
498 * interface. For IPv6, as the spec allow multiple interface
499 * address from the day one, we consider "remove the first one"
500 * semantics to be not preferable.
501 */
502 if (ia == NULL)
bde3511a 503 return (EADDRNOTAVAIL);
984263bc
MD
504 /* FALLTHROUGH */
505 case SIOCAIFADDR_IN6:
506 /*
507 * We always require users to specify a valid IPv6 address for
508 * the corresponding operation.
509 */
510 if (ifra->ifra_addr.sin6_family != AF_INET6 ||
511 ifra->ifra_addr.sin6_len != sizeof(struct sockaddr_in6))
bde3511a 512 return (EAFNOSUPPORT);
984263bc 513 if (!privileged)
bde3511a 514 return (EPERM);
984263bc
MD
515
516 break;
517
518 case SIOCGIFADDR_IN6:
519 /* This interface is basically deprecated. use SIOCGIFCONF. */
520 /* fall through */
521 case SIOCGIFAFLAG_IN6:
522 case SIOCGIFNETMASK_IN6:
523 case SIOCGIFDSTADDR_IN6:
524 case SIOCGIFALIFETIME_IN6:
525 /* must think again about its semantics */
526 if (ia == NULL)
bde3511a 527 return (EADDRNOTAVAIL);
984263bc
MD
528 break;
529 case SIOCSIFALIFETIME_IN6:
530 {
531 struct in6_addrlifetime *lt;
532
533 if (!privileged)
bde3511a 534 return (EPERM);
984263bc 535 if (ia == NULL)
bde3511a 536 return (EADDRNOTAVAIL);
984263bc
MD
537 /* sanity for overflow - beware unsigned */
538 lt = &ifr->ifr_ifru.ifru_lifetime;
539 if (lt->ia6t_vltime != ND6_INFINITE_LIFETIME
540 && lt->ia6t_vltime + time_second < time_second) {
541 return EINVAL;
542 }
543 if (lt->ia6t_pltime != ND6_INFINITE_LIFETIME
544 && lt->ia6t_pltime + time_second < time_second) {
545 return EINVAL;
546 }
547 break;
548 }
549 }
550
551 switch (cmd) {
552
553 case SIOCGIFADDR_IN6:
554 ifr->ifr_addr = ia->ia_addr;
555 break;
556
557 case SIOCGIFDSTADDR_IN6:
bde3511a
JH
558 if (!(ifp->if_flags & IFF_POINTOPOINT))
559 return (EINVAL);
984263bc
MD
560 /*
561 * XXX: should we check if ifa_dstaddr is NULL and return
562 * an error?
563 */
564 ifr->ifr_dstaddr = ia->ia_dstaddr;
565 break;
566
567 case SIOCGIFNETMASK_IN6:
568 ifr->ifr_addr = ia->ia_prefixmask;
569 break;
570
571 case SIOCGIFAFLAG_IN6:
572 ifr->ifr_ifru.ifru_flags6 = ia->ia6_flags;
573 break;
574
575 case SIOCGIFSTAT_IN6:
576 if (ifp == NULL)
577 return EINVAL;
698ac46c
HS
578 bzero(&ifr->ifr_ifru.ifru_stat,
579 sizeof(ifr->ifr_ifru.ifru_stat));
580 ifr->ifr_ifru.ifru_stat =
581 *((struct in6_ifextra *)ifp->if_afdata[AF_INET6])->in6_ifstat;
984263bc
MD
582 break;
583
584 case SIOCGIFSTAT_ICMP6:
698ac46c
HS
585 bzero(&ifr->ifr_ifru.ifru_stat,
586 sizeof(ifr->ifr_ifru.ifru_icmp6stat));
587 ifr->ifr_ifru.ifru_icmp6stat =
588 *((struct in6_ifextra *)ifp->if_afdata[AF_INET6])->icmp6_ifstat;
984263bc
MD
589 break;
590
591 case SIOCGIFALIFETIME_IN6:
592 ifr->ifr_ifru.ifru_lifetime = ia->ia6_lifetime;
593 break;
594
595 case SIOCSIFALIFETIME_IN6:
596 ia->ia6_lifetime = ifr->ifr_ifru.ifru_lifetime;
597 /* for sanity */
598 if (ia->ia6_lifetime.ia6t_vltime != ND6_INFINITE_LIFETIME) {
599 ia->ia6_lifetime.ia6t_expire =
600 time_second + ia->ia6_lifetime.ia6t_vltime;
601 } else
602 ia->ia6_lifetime.ia6t_expire = 0;
603 if (ia->ia6_lifetime.ia6t_pltime != ND6_INFINITE_LIFETIME) {
604 ia->ia6_lifetime.ia6t_preferred =
605 time_second + ia->ia6_lifetime.ia6t_pltime;
606 } else
607 ia->ia6_lifetime.ia6t_preferred = 0;
608 break;
609
610 case SIOCAIFADDR_IN6:
611 {
612 int i, error = 0;
613 struct nd_prefix pr0, *pr;
614
615 /*
616 * first, make or update the interface address structure,
617 * and link it to the list.
618 */
619 if ((error = in6_update_ifa(ifp, ifra, ia)) != 0)
bde3511a 620 return (error);
984263bc
MD
621
622 /*
623 * then, make the prefix on-link on the interface.
624 * XXX: we'd rather create the prefix before the address, but
625 * we need at least one address to install the corresponding
626 * interface route, so we configure the address first.
627 */
628
629 /*
630 * convert mask to prefix length (prefixmask has already
631 * been validated in in6_update_ifa().
632 */
633 bzero(&pr0, sizeof(pr0));
634 pr0.ndpr_ifp = ifp;
635 pr0.ndpr_plen = in6_mask2len(&ifra->ifra_prefixmask.sin6_addr,
636 NULL);
637 if (pr0.ndpr_plen == 128)
638 break; /* we don't need to install a host route. */
639 pr0.ndpr_prefix = ifra->ifra_addr;
640 pr0.ndpr_mask = ifra->ifra_prefixmask.sin6_addr;
641 /* apply the mask for safety. */
642 for (i = 0; i < 4; i++) {
643 pr0.ndpr_prefix.sin6_addr.s6_addr32[i] &=
644 ifra->ifra_prefixmask.sin6_addr.s6_addr32[i];
645 }
646 /*
647 * XXX: since we don't have an API to set prefix (not address)
648 * lifetimes, we just use the same lifetimes as addresses.
649 * The (temporarily) installed lifetimes can be overridden by
650 * later advertised RAs (when accept_rtadv is non 0), which is
651 * an intended behavior.
652 */
653 pr0.ndpr_raf_onlink = 1; /* should be configurable? */
654 pr0.ndpr_raf_auto =
655 ((ifra->ifra_flags & IN6_IFF_AUTOCONF) != 0);
656 pr0.ndpr_vltime = ifra->ifra_lifetime.ia6t_vltime;
657 pr0.ndpr_pltime = ifra->ifra_lifetime.ia6t_pltime;
658
659 /* add the prefix if there's one. */
660 if ((pr = nd6_prefix_lookup(&pr0)) == NULL) {
661 /*
662 * nd6_prelist_add will install the corresponding
663 * interface route.
664 */
665 if ((error = nd6_prelist_add(&pr0, NULL, &pr)) != 0)
bde3511a 666 return (error);
984263bc
MD
667 if (pr == NULL) {
668 log(LOG_ERR, "nd6_prelist_add succedded but "
669 "no prefix\n");
bde3511a 670 return (EINVAL); /* XXX panic here? */
984263bc
MD
671 }
672 }
673 if ((ia = in6ifa_ifpwithaddr(ifp, &ifra->ifra_addr.sin6_addr))
674 == NULL) {
675 /* XXX: this should not happen! */
676 log(LOG_ERR, "in6_control: addition succeeded, but"
677 " no ifaddr\n");
678 } else {
bde3511a 679 if ((ia->ia6_flags & IN6_IFF_AUTOCONF) &&
984263bc
MD
680 ia->ia6_ndpr == NULL) { /* new autoconfed addr */
681 ia->ia6_ndpr = pr;
682 pr->ndpr_refcnt++;
683
684 /*
685 * If this is the first autoconf address from
686 * the prefix, create a temporary address
687 * as well (when specified).
688 */
689 if (ip6_use_tempaddr &&
690 pr->ndpr_refcnt == 1) {
691 int e;
692 if ((e = in6_tmpifadd(ia, 1)) != 0) {
693 log(LOG_NOTICE, "in6_control: "
694 "failed to create a "
695 "temporary address, "
696 "errno=%d\n",
697 e);
698 }
699 }
700 }
701
702 /*
703 * this might affect the status of autoconfigured
704 * addresses, that is, this address might make
705 * other addresses detached.
706 */
707 pfxlist_onlink_check();
708 }
f2bd8b67
JS
709 if (error == 0 && ia)
710 EVENTHANDLER_INVOKE(ifaddr_event, ifp);
984263bc
MD
711 break;
712 }
713
714 case SIOCDIFADDR_IN6:
715 {
716 int i = 0;
717 struct nd_prefix pr0, *pr;
718
719 /*
720 * If the address being deleted is the only one that owns
721 * the corresponding prefix, expire the prefix as well.
722 * XXX: theoretically, we don't have to warry about such
723 * relationship, since we separate the address management
724 * and the prefix management. We do this, however, to provide
725 * as much backward compatibility as possible in terms of
726 * the ioctl operation.
727 */
728 bzero(&pr0, sizeof(pr0));
729 pr0.ndpr_ifp = ifp;
730 pr0.ndpr_plen = in6_mask2len(&ia->ia_prefixmask.sin6_addr,
731 NULL);
732 if (pr0.ndpr_plen == 128)
733 goto purgeaddr;
734 pr0.ndpr_prefix = ia->ia_addr;
735 pr0.ndpr_mask = ia->ia_prefixmask.sin6_addr;
736 for (i = 0; i < 4; i++) {
737 pr0.ndpr_prefix.sin6_addr.s6_addr32[i] &=
738 ia->ia_prefixmask.sin6_addr.s6_addr32[i];
739 }
740 /*
741 * The logic of the following condition is a bit complicated.
742 * We expire the prefix when
743 * 1. the address obeys autoconfiguration and it is the
744 * only owner of the associated prefix, or
745 * 2. the address does not obey autoconf and there is no
746 * other owner of the prefix.
747 */
748 if ((pr = nd6_prefix_lookup(&pr0)) != NULL &&
bde3511a
JH
749 (((ia->ia6_flags & IN6_IFF_AUTOCONF) &&
750 pr->ndpr_refcnt == 1) ||
751 (!(ia->ia6_flags & IN6_IFF_AUTOCONF) &&
984263bc
MD
752 pr->ndpr_refcnt == 0))) {
753 pr->ndpr_expire = 1; /* XXX: just for expiration */
754 }
755
756 purgeaddr:
757 in6_purgeaddr(&ia->ia_ifa);
f2bd8b67 758 EVENTHANDLER_INVOKE(ifaddr_event, ifp);
984263bc
MD
759 break;
760 }
761
762 default:
763 if (ifp == NULL || ifp->if_ioctl == 0)
bde3511a 764 return (EOPNOTSUPP);
78195a76
MD
765 lwkt_serialize_enter(ifp->if_serializer);
766 error = ifp->if_ioctl(ifp, cmd, data, td->td_proc->p_ucred);
767 lwkt_serialize_exit(ifp->if_serializer);
768 return (error);
984263bc
MD
769 }
770
bde3511a 771 return (0);
984263bc
MD
772}
773
774/*
775 * Update parameters of an IPv6 interface address.
776 * If necessary, a new entry is created and linked into address chains.
777 * This function is separated from in6_control().
778 * XXX: should this be performed under splnet()?
779 */
780int
122ebd49
CP
781in6_update_ifa(struct ifnet *ifp, struct in6_aliasreq *ifra,
782 struct in6_ifaddr *ia)
984263bc
MD
783{
784 int error = 0, hostIsNew = 0, plen = -1;
785 struct in6_ifaddr *oia;
786 struct sockaddr_in6 dst6;
787 struct in6_addrlifetime *lt;
788
789 /* Validate parameters */
790 if (ifp == NULL || ifra == NULL) /* this maybe redundant */
bde3511a 791 return (EINVAL);
984263bc
MD
792
793 /*
794 * The destination address for a p2p link must have a family
795 * of AF_UNSPEC or AF_INET6.
796 */
bde3511a 797 if ((ifp->if_flags & IFF_POINTOPOINT) &&
984263bc
MD
798 ifra->ifra_dstaddr.sin6_family != AF_INET6 &&
799 ifra->ifra_dstaddr.sin6_family != AF_UNSPEC)
bde3511a 800 return (EAFNOSUPPORT);
984263bc
MD
801 /*
802 * validate ifra_prefixmask. don't check sin6_family, netmask
803 * does not carry fields other than sin6_len.
804 */
805 if (ifra->ifra_prefixmask.sin6_len > sizeof(struct sockaddr_in6))
bde3511a 806 return (EINVAL);
984263bc
MD
807 /*
808 * Because the IPv6 address architecture is classless, we require
809 * users to specify a (non 0) prefix length (mask) for a new address.
810 * We also require the prefix (when specified) mask is valid, and thus
811 * reject a non-consecutive mask.
812 */
813 if (ia == NULL && ifra->ifra_prefixmask.sin6_len == 0)
bde3511a 814 return (EINVAL);
984263bc
MD
815 if (ifra->ifra_prefixmask.sin6_len != 0) {
816 plen = in6_mask2len(&ifra->ifra_prefixmask.sin6_addr,
817 (u_char *)&ifra->ifra_prefixmask +
818 ifra->ifra_prefixmask.sin6_len);
819 if (plen <= 0)
bde3511a 820 return (EINVAL);
984263bc
MD
821 }
822 else {
823 /*
824 * In this case, ia must not be NULL. We just use its prefix
825 * length.
826 */
827 plen = in6_mask2len(&ia->ia_prefixmask.sin6_addr, NULL);
828 }
829 /*
830 * If the destination address on a p2p interface is specified,
831 * and the address is a scoped one, validate/set the scope
832 * zone identifier.
833 */
834 dst6 = ifra->ifra_dstaddr;
835 if ((ifp->if_flags & (IFF_POINTOPOINT|IFF_LOOPBACK)) &&
836 (dst6.sin6_family == AF_INET6)) {
837 int scopeid;
838
984263bc
MD
839 if ((error = in6_recoverscope(&dst6,
840 &ifra->ifra_dstaddr.sin6_addr,
841 ifp)) != 0)
bde3511a 842 return (error);
984263bc
MD
843 scopeid = in6_addr2scopeid(ifp, &dst6.sin6_addr);
844 if (dst6.sin6_scope_id == 0) /* user omit to specify the ID. */
845 dst6.sin6_scope_id = scopeid;
846 else if (dst6.sin6_scope_id != scopeid)
bde3511a 847 return (EINVAL); /* scope ID mismatch. */
984263bc
MD
848 if ((error = in6_embedscope(&dst6.sin6_addr, &dst6, NULL, NULL))
849 != 0)
bde3511a 850 return (error);
984263bc 851 dst6.sin6_scope_id = 0; /* XXX */
984263bc
MD
852 }
853 /*
854 * The destination address can be specified only for a p2p or a
855 * loopback interface. If specified, the corresponding prefix length
856 * must be 128.
857 */
858 if (ifra->ifra_dstaddr.sin6_family == AF_INET6) {
bde3511a 859 if ((ifp->if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK)) == 0) {
984263bc
MD
860 /* XXX: noisy message */
861 log(LOG_INFO, "in6_update_ifa: a destination can be "
862 "specified for a p2p or a loopback IF only\n");
bde3511a 863 return (EINVAL);
984263bc
MD
864 }
865 if (plen != 128) {
866 /*
867 * The following message seems noisy, but we dare to
868 * add it for diagnosis.
869 */
870 log(LOG_INFO, "in6_update_ifa: prefixlen must be 128 "
871 "when dstaddr is specified\n");
bde3511a 872 return (EINVAL);
984263bc
MD
873 }
874 }
875 /* lifetime consistency check */
876 lt = &ifra->ifra_lifetime;
877 if (lt->ia6t_vltime != ND6_INFINITE_LIFETIME
878 && lt->ia6t_vltime + time_second < time_second) {
879 return EINVAL;
880 }
881 if (lt->ia6t_vltime == 0) {
882 /*
883 * the following log might be noisy, but this is a typical
884 * configuration mistake or a tool's bug.
885 */
886 log(LOG_INFO,
887 "in6_update_ifa: valid lifetime is 0 for %s\n",
888 ip6_sprintf(&ifra->ifra_addr.sin6_addr));
889 }
890 if (lt->ia6t_pltime != ND6_INFINITE_LIFETIME
891 && lt->ia6t_pltime + time_second < time_second) {
892 return EINVAL;
893 }
894
895 /*
896 * If this is a new address, allocate a new ifaddr and link it
897 * into chains.
898 */
899 if (ia == NULL) {
900 hostIsNew = 1;
901 /*
902 * When in6_update_ifa() is called in a process of a received
903 * RA, it is called under splnet(). So, we should call malloc
904 * with M_NOWAIT.
905 */
906 ia = (struct in6_ifaddr *)
efda3bd0 907 kmalloc(sizeof(*ia), M_IFADDR, M_NOWAIT);
984263bc
MD
908 if (ia == NULL)
909 return (ENOBUFS);
910 bzero((caddr_t)ia, sizeof(*ia));
911 /* Initialize the address and masks */
912 ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
913 ia->ia_addr.sin6_family = AF_INET6;
914 ia->ia_addr.sin6_len = sizeof(ia->ia_addr);
915 if ((ifp->if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK)) != 0) {
916 /*
917 * XXX: some functions expect that ifa_dstaddr is not
918 * NULL for p2p interfaces.
919 */
920 ia->ia_ifa.ifa_dstaddr
921 = (struct sockaddr *)&ia->ia_dstaddr;
922 } else {
923 ia->ia_ifa.ifa_dstaddr = NULL;
924 }
925 ia->ia_ifa.ifa_netmask
926 = (struct sockaddr *)&ia->ia_prefixmask;
927
928 ia->ia_ifp = ifp;
929 if ((oia = in6_ifaddr) != NULL) {
930 for ( ; oia->ia_next; oia = oia->ia_next)
931 continue;
932 oia->ia_next = ia;
933 } else
934 in6_ifaddr = ia;
935
936 TAILQ_INSERT_TAIL(&ifp->if_addrlist, &ia->ia_ifa,
937 ifa_list);
938 }
939
940 /* set prefix mask */
941 if (ifra->ifra_prefixmask.sin6_len) {
942 /*
943 * We prohibit changing the prefix length of an existing
944 * address, because
945 * + such an operation should be rare in IPv6, and
946 * + the operation would confuse prefix management.
947 */
948 if (ia->ia_prefixmask.sin6_len &&
949 in6_mask2len(&ia->ia_prefixmask.sin6_addr, NULL) != plen) {
950 log(LOG_INFO, "in6_update_ifa: the prefix length of an"
951 " existing (%s) address should not be changed\n",
952 ip6_sprintf(&ia->ia_addr.sin6_addr));
953 error = EINVAL;
954 goto unlink;
955 }
956 ia->ia_prefixmask = ifra->ifra_prefixmask;
957 }
958
959 /*
960 * If a new destination address is specified, scrub the old one and
961 * install the new destination. Note that the interface must be
bde3511a 962 * p2p or loopback (see the check above.)
984263bc
MD
963 */
964 if (dst6.sin6_family == AF_INET6 &&
965 !IN6_ARE_ADDR_EQUAL(&dst6.sin6_addr,
966 &ia->ia_dstaddr.sin6_addr)) {
967 int e;
968
bde3511a 969 if ((ia->ia_flags & IFA_ROUTE) &&
984263bc
MD
970 (e = rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST))
971 != 0) {
972 log(LOG_ERR, "in6_update_ifa: failed to remove "
973 "a route to the old destination: %s\n",
974 ip6_sprintf(&ia->ia_addr.sin6_addr));
975 /* proceed anyway... */
976 }
977 else
978 ia->ia_flags &= ~IFA_ROUTE;
979 ia->ia_dstaddr = dst6;
980 }
981
982 /* reset the interface and routing table appropriately. */
983 if ((error = in6_ifinit(ifp, ia, &ifra->ifra_addr, hostIsNew)) != 0)
984 goto unlink;
985
986 /*
987 * Beyond this point, we should call in6_purgeaddr upon an error,
bde3511a 988 * not just go to unlink.
984263bc
MD
989 */
990
991#if 0 /* disable this mechanism for now */
992 /* update prefix list */
993 if (hostIsNew &&
994 (ifra->ifra_flags & IN6_IFF_NOPFX) == 0) { /* XXX */
995 int iilen;
996
997 iilen = (sizeof(ia->ia_prefixmask.sin6_addr) << 3) - plen;
998 if ((error = in6_prefix_add_ifid(iilen, ia)) != 0) {
999 in6_purgeaddr((struct ifaddr *)ia);
bde3511a 1000 return (error);
984263bc
MD
1001 }
1002 }
1003#endif
1004
bde3511a 1005 if (ifp->if_flags & IFF_MULTICAST) {
984263bc
MD
1006 struct sockaddr_in6 mltaddr, mltmask;
1007 struct in6_multi *in6m;
1008
1009 if (hostIsNew) {
1010 /*
1011 * join solicited multicast addr for new host id
1012 */
1013 struct in6_addr llsol;
1014 bzero(&llsol, sizeof(struct in6_addr));
1015 llsol.s6_addr16[0] = htons(0xff02);
1016 llsol.s6_addr16[1] = htons(ifp->if_index);
1017 llsol.s6_addr32[1] = 0;
1018 llsol.s6_addr32[2] = htonl(1);
1019 llsol.s6_addr32[3] =
1020 ifra->ifra_addr.sin6_addr.s6_addr32[3];
1021 llsol.s6_addr8[12] = 0xff;
0bdb1448 1022 in6_addmulti(&llsol, ifp, &error);
984263bc
MD
1023 if (error != 0) {
1024 log(LOG_WARNING,
1025 "in6_update_ifa: addmulti failed for "
1026 "%s on %s (errno=%d)\n",
1027 ip6_sprintf(&llsol), if_name(ifp),
1028 error);
1029 in6_purgeaddr((struct ifaddr *)ia);
bde3511a 1030 return (error);
984263bc
MD
1031 }
1032 }
1033
1034 bzero(&mltmask, sizeof(mltmask));
1035 mltmask.sin6_len = sizeof(struct sockaddr_in6);
1036 mltmask.sin6_family = AF_INET6;
1037 mltmask.sin6_addr = in6mask32;
1038
1039 /*
1040 * join link-local all-nodes address
1041 */
1042 bzero(&mltaddr, sizeof(mltaddr));
1043 mltaddr.sin6_len = sizeof(struct sockaddr_in6);
1044 mltaddr.sin6_family = AF_INET6;
84204577 1045 mltaddr.sin6_addr = kin6addr_linklocal_allnodes;
984263bc
MD
1046 mltaddr.sin6_addr.s6_addr16[1] = htons(ifp->if_index);
1047
1048 IN6_LOOKUP_MULTI(mltaddr.sin6_addr, ifp, in6m);
1049 if (in6m == NULL) {
ecdefdda 1050 rtrequest_global(RTM_ADD,
984263bc
MD
1051 (struct sockaddr *)&mltaddr,
1052 (struct sockaddr *)&ia->ia_addr,
1053 (struct sockaddr *)&mltmask,
ecdefdda 1054 RTF_UP|RTF_CLONING); /* xxx */
0bdb1448 1055 in6_addmulti(&mltaddr.sin6_addr, ifp, &error);
984263bc
MD
1056 if (error != 0) {
1057 log(LOG_WARNING,
1058 "in6_update_ifa: addmulti failed for "
1059 "%s on %s (errno=%d)\n",
bde3511a 1060 ip6_sprintf(&mltaddr.sin6_addr),
984263bc
MD
1061 if_name(ifp), error);
1062 }
1063 }
1064
1065 /*
1066 * join node information group address
1067 */
1068#define hostnamelen strlen(hostname)
1069 if (in6_nigroup(ifp, hostname, hostnamelen, &mltaddr.sin6_addr)
1070 == 0) {
1071 IN6_LOOKUP_MULTI(mltaddr.sin6_addr, ifp, in6m);
1072 if (in6m == NULL && ia != NULL) {
0bdb1448 1073 in6_addmulti(&mltaddr.sin6_addr, ifp, &error);
984263bc
MD
1074 if (error != 0) {
1075 log(LOG_WARNING, "in6_update_ifa: "
1076 "addmulti failed for "
1077 "%s on %s (errno=%d)\n",
bde3511a 1078 ip6_sprintf(&mltaddr.sin6_addr),
984263bc
MD
1079 if_name(ifp), error);
1080 }
1081 }
1082 }
1083#undef hostnamelen
1084
1085 /*
1086 * join node-local all-nodes address, on loopback.
1087 * XXX: since "node-local" is obsoleted by interface-local,
1088 * we have to join the group on every interface with
1089 * some interface-boundary restriction.
1090 */
1091 if (ifp->if_flags & IFF_LOOPBACK) {
1092 struct in6_ifaddr *ia_loop;
1093
84204577 1094 struct in6_addr loop6 = kin6addr_loopback;
984263bc
MD
1095 ia_loop = in6ifa_ifpwithaddr(ifp, &loop6);
1096
84204577 1097 mltaddr.sin6_addr = kin6addr_nodelocal_allnodes;
984263bc
MD
1098
1099 IN6_LOOKUP_MULTI(mltaddr.sin6_addr, ifp, in6m);
1100 if (in6m == NULL && ia_loop != NULL) {
ecdefdda 1101 rtrequest_global(RTM_ADD,
984263bc
MD
1102 (struct sockaddr *)&mltaddr,
1103 (struct sockaddr *)&ia_loop->ia_addr,
1104 (struct sockaddr *)&mltmask,
ecdefdda 1105 RTF_UP);
0bdb1448 1106 in6_addmulti(&mltaddr.sin6_addr, ifp, &error);
984263bc
MD
1107 if (error != 0) {
1108 log(LOG_WARNING, "in6_update_ifa: "
1109 "addmulti failed for %s on %s "
1110 "(errno=%d)\n",
bde3511a 1111 ip6_sprintf(&mltaddr.sin6_addr),
984263bc
MD
1112 if_name(ifp), error);
1113 }
1114 }
1115 }
1116 }
1117
1118 ia->ia6_flags = ifra->ifra_flags;
1119 ia->ia6_flags &= ~IN6_IFF_DUPLICATED; /*safety*/
1120 ia->ia6_flags &= ~IN6_IFF_NODAD; /* Mobile IPv6 */
1121
1122 ia->ia6_lifetime = ifra->ifra_lifetime;
1123 /* for sanity */
1124 if (ia->ia6_lifetime.ia6t_vltime != ND6_INFINITE_LIFETIME) {
1125 ia->ia6_lifetime.ia6t_expire =
1126 time_second + ia->ia6_lifetime.ia6t_vltime;
1127 } else
1128 ia->ia6_lifetime.ia6t_expire = 0;
1129 if (ia->ia6_lifetime.ia6t_pltime != ND6_INFINITE_LIFETIME) {
1130 ia->ia6_lifetime.ia6t_preferred =
1131 time_second + ia->ia6_lifetime.ia6t_pltime;
1132 } else
1133 ia->ia6_lifetime.ia6t_preferred = 0;
1134
984263bc
MD
1135 /*
1136 * Perform DAD, if needed.
1137 * XXX It may be of use, if we can administratively
1138 * disable DAD.
1139 */
bde3511a 1140 if (in6if_do_dad(ifp) && !(ifra->ifra_flags & IN6_IFF_NODAD)) {
984263bc
MD
1141 ia->ia6_flags |= IN6_IFF_TENTATIVE;
1142 nd6_dad_start((struct ifaddr *)ia, NULL);
1143 }
1144
bde3511a 1145 return (error);
984263bc 1146
bde3511a 1147unlink:
984263bc
MD
1148 /*
1149 * XXX: if a change of an existing address failed, keep the entry
1150 * anyway.
1151 */
1152 if (hostIsNew)
1153 in6_unlink_ifa(ia, ifp);
bde3511a 1154 return (error);
984263bc
MD
1155}
1156
1157void
122ebd49 1158in6_purgeaddr(struct ifaddr *ifa)
984263bc
MD
1159{
1160 struct ifnet *ifp = ifa->ifa_ifp;
1161 struct in6_ifaddr *ia = (struct in6_ifaddr *) ifa;
1162
1163 /* stop DAD processing */
1164 nd6_dad_stop(ifa);
1165
1166 /*
1167 * delete route to the destination of the address being purged.
1168 * The interface must be p2p or loopback in this case.
1169 */
bde3511a 1170 if ((ia->ia_flags & IFA_ROUTE) && ia->ia_dstaddr.sin6_len != 0) {
984263bc
MD
1171 int e;
1172
1173 if ((e = rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST))
1174 != 0) {
1175 log(LOG_ERR, "in6_purgeaddr: failed to remove "
1176 "a route to the p2p destination: %s on %s, "
1177 "errno=%d\n",
1178 ip6_sprintf(&ia->ia_addr.sin6_addr), if_name(ifp),
1179 e);
1180 /* proceed anyway... */
1181 }
1182 else
1183 ia->ia_flags &= ~IFA_ROUTE;
1184 }
1185
1186 /* Remove ownaddr's loopback rtentry, if it exists. */
1187 in6_ifremloop(&(ia->ia_ifa));
1188
1189 if (ifp->if_flags & IFF_MULTICAST) {
1190 /*
1191 * delete solicited multicast addr for deleting host id
1192 */
1193 struct in6_multi *in6m;
1194 struct in6_addr llsol;
1195 bzero(&llsol, sizeof(struct in6_addr));
1196 llsol.s6_addr16[0] = htons(0xff02);
1197 llsol.s6_addr16[1] = htons(ifp->if_index);
1198 llsol.s6_addr32[1] = 0;
1199 llsol.s6_addr32[2] = htonl(1);
1200 llsol.s6_addr32[3] =
1201 ia->ia_addr.sin6_addr.s6_addr32[3];
1202 llsol.s6_addr8[12] = 0xff;
1203
1204 IN6_LOOKUP_MULTI(llsol, ifp, in6m);
1205 if (in6m)
1206 in6_delmulti(in6m);
1207 }
1208
1209 in6_unlink_ifa(ia, ifp);
1210}
1211
1212static void
122ebd49 1213in6_unlink_ifa(struct in6_ifaddr *ia, struct ifnet *ifp)
984263bc
MD
1214{
1215 int plen, iilen;
1216 struct in6_ifaddr *oia;
abf782b3
EN
1217
1218 crit_enter();
984263bc
MD
1219
1220 TAILQ_REMOVE(&ifp->if_addrlist, &ia->ia_ifa, ifa_list);
1221
1222 oia = ia;
1223 if (oia == (ia = in6_ifaddr))
1224 in6_ifaddr = ia->ia_next;
1225 else {
1226 while (ia->ia_next && (ia->ia_next != oia))
1227 ia = ia->ia_next;
1228 if (ia->ia_next)
1229 ia->ia_next = oia->ia_next;
1230 else {
1231 /* search failed */
a6ec04bc 1232 kprintf("Couldn't unlink in6_ifaddr from in6_ifaddr\n");
984263bc
MD
1233 }
1234 }
1235
1236 if (oia->ia6_ifpr) { /* check for safety */
1237 plen = in6_mask2len(&oia->ia_prefixmask.sin6_addr, NULL);
1238 iilen = (sizeof(oia->ia_prefixmask.sin6_addr) << 3) - plen;
1239 in6_prefix_remove_ifid(iilen, oia);
1240 }
1241
1242 /*
1243 * When an autoconfigured address is being removed, release the
1244 * reference to the base prefix. Also, since the release might
1245 * affect the status of other (detached) addresses, call
1246 * pfxlist_onlink_check().
1247 */
bde3511a 1248 if (oia->ia6_flags & IN6_IFF_AUTOCONF) {
984263bc
MD
1249 if (oia->ia6_ndpr == NULL) {
1250 log(LOG_NOTICE, "in6_unlink_ifa: autoconf'ed address "
1251 "%p has no prefix\n", oia);
1252 } else {
1253 oia->ia6_ndpr->ndpr_refcnt--;
1254 oia->ia6_flags &= ~IN6_IFF_AUTOCONF;
1255 oia->ia6_ndpr = NULL;
1256 }
1257
1258 pfxlist_onlink_check();
1259 }
1260
1261 /*
1262 * release another refcnt for the link from in6_ifaddr.
1263 * Note that we should decrement the refcnt at least once for all *BSD.
1264 */
1265 IFAFREE(&oia->ia_ifa);
1266
abf782b3 1267 crit_exit();
984263bc
MD
1268}
1269
1270void
122ebd49 1271in6_purgeif(struct ifnet *ifp)
984263bc
MD
1272{
1273 struct ifaddr *ifa, *nifa;
1274
1275 for (ifa = TAILQ_FIRST(&ifp->if_addrlist); ifa != NULL; ifa = nifa)
1276 {
1277 nifa = TAILQ_NEXT(ifa, ifa_list);
1278 if (ifa->ifa_addr->sa_family != AF_INET6)
1279 continue;
1280 in6_purgeaddr(ifa);
1281 }
1282
1283 in6_ifdetach(ifp);
1284}
1285
1286/*
1287 * SIOC[GAD]LIFADDR.
1288 * SIOCGLIFADDR: get first address. (?)
1289 * SIOCGLIFADDR with IFLR_PREFIX:
1290 * get first address that matches the specified prefix.
1291 * SIOCALIFADDR: add the specified address.
1292 * SIOCALIFADDR with IFLR_PREFIX:
1293 * add the specified prefix, filling hostid part from
1294 * the first link-local address. prefixlen must be <= 64.
1295 * SIOCDLIFADDR: delete the specified address.
1296 * SIOCDLIFADDR with IFLR_PREFIX:
1297 * delete the first address that matches the specified prefix.
1298 * return values:
1299 * EINVAL on invalid parameters
1300 * EADDRNOTAVAIL on prefix match failed/specified address not found
1301 * other values may be returned from in6_ioctl()
1302 *
1303 * NOTE: SIOCALIFADDR(with IFLR_PREFIX set) allows prefixlen less than 64.
1304 * this is to accomodate address naming scheme other than RFC2374,
1305 * in the future.
1306 * RFC2373 defines interface id to be 64bit, but it allows non-RFC2374
1307 * address encoding scheme. (see figure on page 8)
1308 */
1309static int
dadab5e9 1310in6_lifaddr_ioctl(struct socket *so, u_long cmd, caddr_t data,
122ebd49 1311 struct ifnet *ifp, struct thread *td)
984263bc
MD
1312{
1313 struct if_laddrreq *iflr = (struct if_laddrreq *)data;
1314 struct ifaddr *ifa;
1315 struct sockaddr *sa;
1316
1317 /* sanity checks */
1318 if (!data || !ifp) {
1319 panic("invalid argument to in6_lifaddr_ioctl");
1320 /*NOTRECHED*/
1321 }
1322
1323 switch (cmd) {
1324 case SIOCGLIFADDR:
1325 /* address must be specified on GET with IFLR_PREFIX */
bde3511a 1326 if (!(iflr->flags & IFLR_PREFIX))
984263bc
MD
1327 break;
1328 /* FALLTHROUGH */
1329 case SIOCALIFADDR:
1330 case SIOCDLIFADDR:
1331 /* address must be specified on ADD and DELETE */
1332 sa = (struct sockaddr *)&iflr->addr;
1333 if (sa->sa_family != AF_INET6)
1334 return EINVAL;
1335 if (sa->sa_len != sizeof(struct sockaddr_in6))
1336 return EINVAL;
1337 /* XXX need improvement */
1338 sa = (struct sockaddr *)&iflr->dstaddr;
1339 if (sa->sa_family && sa->sa_family != AF_INET6)
1340 return EINVAL;
1341 if (sa->sa_len && sa->sa_len != sizeof(struct sockaddr_in6))
1342 return EINVAL;
1343 break;
1344 default: /* shouldn't happen */
1345#if 0
1346 panic("invalid cmd to in6_lifaddr_ioctl");
1347 /* NOTREACHED */
1348#else
1349 return EOPNOTSUPP;
1350#endif
1351 }
1352 if (sizeof(struct in6_addr) * 8 < iflr->prefixlen)
1353 return EINVAL;
1354
1355 switch (cmd) {
1356 case SIOCALIFADDR:
1357 {
1358 struct in6_aliasreq ifra;
1359 struct in6_addr *hostid = NULL;
1360 int prefixlen;
1361
bde3511a 1362 if (iflr->flags & IFLR_PREFIX) {
984263bc
MD
1363 struct sockaddr_in6 *sin6;
1364
1365 /*
1366 * hostid is to fill in the hostid part of the
1367 * address. hostid points to the first link-local
1368 * address attached to the interface.
1369 */
1370 ifa = (struct ifaddr *)in6ifa_ifpforlinklocal(ifp, 0);
1371 if (!ifa)
1372 return EADDRNOTAVAIL;
1373 hostid = IFA_IN6(ifa);
1374
1375 /* prefixlen must be <= 64. */
1376 if (64 < iflr->prefixlen)
1377 return EINVAL;
1378 prefixlen = iflr->prefixlen;
1379
1380 /* hostid part must be zero. */
1381 sin6 = (struct sockaddr_in6 *)&iflr->addr;
1382 if (sin6->sin6_addr.s6_addr32[2] != 0
1383 || sin6->sin6_addr.s6_addr32[3] != 0) {
1384 return EINVAL;
1385 }
1386 } else
1387 prefixlen = iflr->prefixlen;
1388
1389 /* copy args to in6_aliasreq, perform ioctl(SIOCAIFADDR_IN6). */
1390 bzero(&ifra, sizeof(ifra));
1391 bcopy(iflr->iflr_name, ifra.ifra_name,
1392 sizeof(ifra.ifra_name));
1393
1394 bcopy(&iflr->addr, &ifra.ifra_addr,
1395 ((struct sockaddr *)&iflr->addr)->sa_len);
1396 if (hostid) {
1397 /* fill in hostid part */
1398 ifra.ifra_addr.sin6_addr.s6_addr32[2] =
1399 hostid->s6_addr32[2];
1400 ifra.ifra_addr.sin6_addr.s6_addr32[3] =
1401 hostid->s6_addr32[3];
1402 }
1403
1404 if (((struct sockaddr *)&iflr->dstaddr)->sa_family) { /*XXX*/
1405 bcopy(&iflr->dstaddr, &ifra.ifra_dstaddr,
1406 ((struct sockaddr *)&iflr->dstaddr)->sa_len);
1407 if (hostid) {
1408 ifra.ifra_dstaddr.sin6_addr.s6_addr32[2] =
1409 hostid->s6_addr32[2];
1410 ifra.ifra_dstaddr.sin6_addr.s6_addr32[3] =
1411 hostid->s6_addr32[3];
1412 }
1413 }
1414
1415 ifra.ifra_prefixmask.sin6_len = sizeof(struct sockaddr_in6);
1416 in6_len2mask(&ifra.ifra_prefixmask.sin6_addr, prefixlen);
1417
1418 ifra.ifra_flags = iflr->flags & ~IFLR_PREFIX;
ab1c1714 1419 return in6_control(so, SIOCAIFADDR_IN6, (caddr_t)&ifra, ifp, td);
984263bc
MD
1420 }
1421 case SIOCGLIFADDR:
1422 case SIOCDLIFADDR:
1423 {
1424 struct in6_ifaddr *ia;
1425 struct in6_addr mask, candidate, match;
1426 struct sockaddr_in6 *sin6;
1427 int cmp;
1428
1429 bzero(&mask, sizeof(mask));
1430 if (iflr->flags & IFLR_PREFIX) {
1431 /* lookup a prefix rather than address. */
1432 in6_len2mask(&mask, iflr->prefixlen);
1433
1434 sin6 = (struct sockaddr_in6 *)&iflr->addr;
1435 bcopy(&sin6->sin6_addr, &match, sizeof(match));
1436 match.s6_addr32[0] &= mask.s6_addr32[0];
1437 match.s6_addr32[1] &= mask.s6_addr32[1];
1438 match.s6_addr32[2] &= mask.s6_addr32[2];
1439 match.s6_addr32[3] &= mask.s6_addr32[3];
1440
1441 /* if you set extra bits, that's wrong */
1442 if (bcmp(&match, &sin6->sin6_addr, sizeof(match)))
1443 return EINVAL;
1444
1445 cmp = 1;
1446 } else {
1447 if (cmd == SIOCGLIFADDR) {
1448 /* on getting an address, take the 1st match */
1449 cmp = 0; /* XXX */
1450 } else {
1451 /* on deleting an address, do exact match */
1452 in6_len2mask(&mask, 128);
1453 sin6 = (struct sockaddr_in6 *)&iflr->addr;
1454 bcopy(&sin6->sin6_addr, &match, sizeof(match));
1455
1456 cmp = 1;
1457 }
1458 }
1459
1460 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)
1461 {
1462 if (ifa->ifa_addr->sa_family != AF_INET6)
1463 continue;
1464 if (!cmp)
1465 break;
1466
1467 bcopy(IFA_IN6(ifa), &candidate, sizeof(candidate));
984263bc
MD
1468 /*
1469 * XXX: this is adhoc, but is necessary to allow
1470 * a user to specify fe80::/64 (not /10) for a
1471 * link-local address.
1472 */
1473 if (IN6_IS_ADDR_LINKLOCAL(&candidate))
1474 candidate.s6_addr16[1] = 0;
984263bc
MD
1475 candidate.s6_addr32[0] &= mask.s6_addr32[0];
1476 candidate.s6_addr32[1] &= mask.s6_addr32[1];
1477 candidate.s6_addr32[2] &= mask.s6_addr32[2];
1478 candidate.s6_addr32[3] &= mask.s6_addr32[3];
1479 if (IN6_ARE_ADDR_EQUAL(&candidate, &match))
1480 break;
1481 }
1482 if (!ifa)
1483 return EADDRNOTAVAIL;
1484 ia = ifa2ia6(ifa);
1485
1486 if (cmd == SIOCGLIFADDR) {
984263bc 1487 struct sockaddr_in6 *s6;
984263bc
MD
1488
1489 /* fill in the if_laddrreq structure */
1490 bcopy(&ia->ia_addr, &iflr->addr, ia->ia_addr.sin6_len);
984263bc
MD
1491 s6 = (struct sockaddr_in6 *)&iflr->addr;
1492 if (IN6_IS_ADDR_LINKLOCAL(&s6->sin6_addr)) {
1493 s6->sin6_addr.s6_addr16[1] = 0;
1494 s6->sin6_scope_id =
1495 in6_addr2scopeid(ifp, &s6->sin6_addr);
1496 }
bde3511a 1497 if (ifp->if_flags & IFF_POINTOPOINT) {
984263bc
MD
1498 bcopy(&ia->ia_dstaddr, &iflr->dstaddr,
1499 ia->ia_dstaddr.sin6_len);
984263bc
MD
1500 s6 = (struct sockaddr_in6 *)&iflr->dstaddr;
1501 if (IN6_IS_ADDR_LINKLOCAL(&s6->sin6_addr)) {
1502 s6->sin6_addr.s6_addr16[1] = 0;
1503 s6->sin6_scope_id =
1504 in6_addr2scopeid(ifp,
1505 &s6->sin6_addr);
1506 }
984263bc
MD
1507 } else
1508 bzero(&iflr->dstaddr, sizeof(iflr->dstaddr));
1509
1510 iflr->prefixlen =
1511 in6_mask2len(&ia->ia_prefixmask.sin6_addr,
1512 NULL);
1513
1514 iflr->flags = ia->ia6_flags; /* XXX */
1515
1516 return 0;
1517 } else {
1518 struct in6_aliasreq ifra;
1519
1520 /* fill in6_aliasreq and do ioctl(SIOCDIFADDR_IN6) */
1521 bzero(&ifra, sizeof(ifra));
1522 bcopy(iflr->iflr_name, ifra.ifra_name,
bde3511a 1523 sizeof(ifra.ifra_name));
984263bc
MD
1524
1525 bcopy(&ia->ia_addr, &ifra.ifra_addr,
bde3511a
JH
1526 ia->ia_addr.sin6_len);
1527 if (ifp->if_flags & IFF_POINTOPOINT)
984263bc 1528 bcopy(&ia->ia_dstaddr, &ifra.ifra_dstaddr,
bde3511a
JH
1529 ia->ia_dstaddr.sin6_len);
1530 else
984263bc 1531 bzero(&ifra.ifra_dstaddr,
bde3511a 1532 sizeof(ifra.ifra_dstaddr));
984263bc 1533 bcopy(&ia->ia_prefixmask, &ifra.ifra_dstaddr,
bde3511a 1534 ia->ia_prefixmask.sin6_len);
984263bc
MD
1535
1536 ifra.ifra_flags = ia->ia6_flags;
1537 return in6_control(so, SIOCDIFADDR_IN6, (caddr_t)&ifra,
ab1c1714 1538 ifp, td);
984263bc
MD
1539 }
1540 }
1541 }
1542
1543 return EOPNOTSUPP; /* just for safety */
1544}
1545
1546/*
1547 * Initialize an interface's intetnet6 address
1548 * and routing table entry.
1549 */
1550static int
122ebd49
CP
1551in6_ifinit(struct ifnet *ifp, struct in6_ifaddr *ia, struct sockaddr_in6 *sin6,
1552 int newhost)
984263bc
MD
1553{
1554 int error = 0, plen, ifacount = 0;
984263bc
MD
1555 struct ifaddr *ifa;
1556
78195a76 1557 lwkt_serialize_enter(ifp->if_serializer);
abf782b3 1558
984263bc
MD
1559 /*
1560 * Give the interface a chance to initialize
1561 * if this is its first address,
1562 * and to validate the address if necessary.
1563 */
1564 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)
1565 {
1566 if (ifa->ifa_addr == NULL)
1567 continue; /* just for safety */
1568 if (ifa->ifa_addr->sa_family != AF_INET6)
1569 continue;
1570 ifacount++;
1571 }
1572
1573 ia->ia_addr = *sin6;
1574
1575 if (ifacount <= 1 && ifp->if_ioctl &&
78195a76 1576 (error = ifp->if_ioctl(ifp, SIOCSIFADDR, (caddr_t)ia,
bd4539cc 1577 (struct ucred *)NULL))) {
78195a76 1578 lwkt_serialize_exit(ifp->if_serializer);
bde3511a 1579 return (error);
984263bc 1580 }
78195a76 1581 lwkt_serialize_exit(ifp->if_serializer);
984263bc
MD
1582
1583 ia->ia_ifa.ifa_metric = ifp->if_metric;
1584
1585 /* we could do in(6)_socktrim here, but just omit it at this moment. */
1586
1587 /*
1588 * Special case:
1589 * If the destination address is specified for a point-to-point
1590 * interface, install a route to the destination as an interface
1591 * direct route.
1592 */
1593 plen = in6_mask2len(&ia->ia_prefixmask.sin6_addr, NULL); /* XXX */
1594 if (plen == 128 && ia->ia_dstaddr.sin6_family == AF_INET6) {
1595 if ((error = rtinit(&(ia->ia_ifa), (int)RTM_ADD,
1596 RTF_UP | RTF_HOST)) != 0)
bde3511a 1597 return (error);
984263bc
MD
1598 ia->ia_flags |= IFA_ROUTE;
1599 }
1600 if (plen < 128) {
1601 /*
1602 * The RTF_CLONING flag is necessary for in6_is_ifloop_auto().
1603 */
1604 ia->ia_ifa.ifa_flags |= RTF_CLONING;
1605 }
1606
1607 /* Add ownaddr as loopback rtentry, if necessary (ex. on p2p link). */
1608 if (newhost) {
1609 /* set the rtrequest function to create llinfo */
1610 ia->ia_ifa.ifa_rtrequest = nd6_rtrequest;
1611 in6_ifaddloop(&(ia->ia_ifa));
1612 }
1613
bde3511a 1614 return (error);
984263bc
MD
1615}
1616
0d16ba1d
MD
1617struct in6_multi_mship *
1618in6_joingroup(ifp, addr, errorp)
1619 struct ifnet *ifp;
1620 struct in6_addr *addr;
1621 int *errorp;
1622{
1623 struct in6_multi_mship *imm;
1624
1625 imm = kmalloc(sizeof(*imm), M_IPMADDR, M_NOWAIT);
1626 if (!imm) {
1627 *errorp = ENOBUFS;
1628 return NULL;
1629 }
1630 imm->i6mm_maddr = in6_addmulti(addr, ifp, errorp);
1631 if (!imm->i6mm_maddr) {
1632 /* *errorp is alrady set */
1633 kfree(imm, M_IPMADDR);
1634 return NULL;
1635 }
1636 return imm;
1637}
1638
1639int
1640in6_leavegroup(imm)
1641 struct in6_multi_mship *imm;
1642{
1643
1644 if (imm->i6mm_maddr)
1645 in6_delmulti(imm->i6mm_maddr);
1646 kfree(imm, M_IPMADDR);
1647 return 0;
1648}
1649
984263bc
MD
1650/*
1651 * Add an address to the list of IP6 multicast addresses for a
1652 * given interface.
1653 */
1654struct in6_multi *
122ebd49 1655in6_addmulti(struct in6_addr *maddr6, struct ifnet *ifp, int *errorp)
984263bc
MD
1656{
1657 struct in6_multi *in6m;
1658 struct sockaddr_in6 sin6;
1659 struct ifmultiaddr *ifma;
984263bc
MD
1660
1661 *errorp = 0;
1662
abf782b3
EN
1663 crit_enter();
1664
984263bc
MD
1665 /*
1666 * Call generic routine to add membership or increment
1667 * refcount. It wants addresses in the form of a sockaddr,
1668 * so we build one here (being careful to zero the unused bytes).
1669 */
1670 bzero(&sin6, sizeof sin6);
1671 sin6.sin6_family = AF_INET6;
1672 sin6.sin6_len = sizeof sin6;
1673 sin6.sin6_addr = *maddr6;
1674 *errorp = if_addmulti(ifp, (struct sockaddr *)&sin6, &ifma);
1675 if (*errorp) {
abf782b3 1676 crit_exit();
984263bc
MD
1677 return 0;
1678 }
1679
1680 /*
1681 * If ifma->ifma_protospec is null, then if_addmulti() created
1682 * a new record. Otherwise, we are done.
1683 */
edbd2e19
MD
1684 if (ifma->ifma_protospec != 0) {
1685 crit_exit();
984263bc 1686 return ifma->ifma_protospec;
edbd2e19 1687 }
984263bc
MD
1688
1689 /* XXX - if_addmulti uses M_WAITOK. Can this really be called
1690 at interrupt time? If so, need to fix if_addmulti. XXX */
efda3bd0 1691 in6m = (struct in6_multi *)kmalloc(sizeof(*in6m), M_IPMADDR, M_NOWAIT);
984263bc 1692 if (in6m == NULL) {
abf782b3 1693 crit_exit();
984263bc
MD
1694 return (NULL);
1695 }
1696
1697 bzero(in6m, sizeof *in6m);
1698 in6m->in6m_addr = *maddr6;
1699 in6m->in6m_ifp = ifp;
1700 in6m->in6m_ifma = ifma;
1701 ifma->ifma_protospec = in6m;
1702 LIST_INSERT_HEAD(&in6_multihead, in6m, in6m_entry);
1703
1704 /*
1705 * Let MLD6 know that we have joined a new IP6 multicast
1706 * group.
1707 */
1708 mld6_start_listening(in6m);
abf782b3 1709 crit_exit();
bde3511a 1710 return (in6m);
984263bc
MD
1711}
1712
1713/*
1714 * Delete a multicast address record.
1715 */
1716void
122ebd49 1717in6_delmulti(struct in6_multi *in6m)
984263bc
MD
1718{
1719 struct ifmultiaddr *ifma = in6m->in6m_ifma;
abf782b3
EN
1720
1721 crit_enter();
984263bc
MD
1722
1723 if (ifma->ifma_refcount == 1) {
1724 /*
1725 * No remaining claims to this record; let MLD6 know
1726 * that we are leaving the multicast group.
1727 */
1728 mld6_stop_listening(in6m);
1729 ifma->ifma_protospec = 0;
1730 LIST_REMOVE(in6m, in6m_entry);
efda3bd0 1731 kfree(in6m, M_IPMADDR);
984263bc
MD
1732 }
1733 /* XXX - should be separate API for when we have an ifma? */
1734 if_delmulti(ifma->ifma_ifp, ifma->ifma_addr);
abf782b3 1735 crit_exit();
984263bc
MD
1736}
1737
1738/*
1739 * Find an IPv6 interface link-local address specific to an interface.
1740 */
1741struct in6_ifaddr *
122ebd49 1742in6ifa_ifpforlinklocal(struct ifnet *ifp, int ignoreflags)
984263bc
MD
1743{
1744 struct ifaddr *ifa;
1745
1746 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)
1747 {
1748 if (ifa->ifa_addr == NULL)
1749 continue; /* just for safety */
1750 if (ifa->ifa_addr->sa_family != AF_INET6)
1751 continue;
1752 if (IN6_IS_ADDR_LINKLOCAL(IFA_IN6(ifa))) {
1753 if ((((struct in6_ifaddr *)ifa)->ia6_flags &
1754 ignoreflags) != 0)
1755 continue;
1756 break;
1757 }
1758 }
1759
bde3511a 1760 return ((struct in6_ifaddr *)ifa);
984263bc
MD
1761}
1762
1763
1764/*
1765 * find the internet address corresponding to a given interface and address.
1766 */
1767struct in6_ifaddr *
122ebd49 1768in6ifa_ifpwithaddr(struct ifnet *ifp, struct in6_addr *addr)
984263bc
MD
1769{
1770 struct ifaddr *ifa;
1771
1772 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)
1773 {
1774 if (ifa->ifa_addr == NULL)
1775 continue; /* just for safety */
1776 if (ifa->ifa_addr->sa_family != AF_INET6)
1777 continue;
1778 if (IN6_ARE_ADDR_EQUAL(addr, IFA_IN6(ifa)))
1779 break;
1780 }
1781
bde3511a 1782 return ((struct in6_ifaddr *)ifa);
984263bc
MD
1783}
1784
1785/*
1786 * Convert IP6 address to printable (loggable) representation.
1787 */
1788static char digits[] = "0123456789abcdef";
1789static int ip6round = 0;
1790char *
122ebd49 1791ip6_sprintf(const struct in6_addr *addr)
984263bc
MD
1792{
1793 static char ip6buf[8][48];
1794 int i;
1795 char *cp;
ab1c1714
MD
1796 const u_short *a = (const u_short *)addr;
1797 const u_char *d;
984263bc
MD
1798 int dcolon = 0;
1799
1800 ip6round = (ip6round + 1) & 7;
1801 cp = ip6buf[ip6round];
1802
1803 for (i = 0; i < 8; i++) {
1804 if (dcolon == 1) {
1805 if (*a == 0) {
1806 if (i == 7)
1807 *cp++ = ':';
1808 a++;
1809 continue;
1810 } else
1811 dcolon = 2;
1812 }
1813 if (*a == 0) {
1814 if (dcolon == 0 && *(a + 1) == 0) {
1815 if (i == 0)
1816 *cp++ = ':';
1817 *cp++ = ':';
1818 dcolon = 1;
1819 } else {
1820 *cp++ = '0';
1821 *cp++ = ':';
1822 }
1823 a++;
1824 continue;
1825 }
ab1c1714 1826 d = (const u_char *)a;
984263bc
MD
1827 *cp++ = digits[*d >> 4];
1828 *cp++ = digits[*d++ & 0xf];
1829 *cp++ = digits[*d >> 4];
1830 *cp++ = digits[*d & 0xf];
1831 *cp++ = ':';
1832 a++;
1833 }
1834 *--cp = 0;
bde3511a 1835 return (ip6buf[ip6round]);
984263bc
MD
1836}
1837
1838int
122ebd49 1839in6_localaddr(struct in6_addr *in6)
984263bc
MD
1840{
1841 struct in6_ifaddr *ia;
1842
1843 if (IN6_IS_ADDR_LOOPBACK(in6) || IN6_IS_ADDR_LINKLOCAL(in6))
1844 return 1;
1845
1846 for (ia = in6_ifaddr; ia; ia = ia->ia_next)
1847 if (IN6_ARE_MASKED_ADDR_EQUAL(in6, &ia->ia_addr.sin6_addr,
1848 &ia->ia_prefixmask.sin6_addr))
1849 return 1;
1850
1851 return (0);
1852}
1853
1854int
122ebd49 1855in6_is_addr_deprecated(struct sockaddr_in6 *sa6)
984263bc
MD
1856{
1857 struct in6_ifaddr *ia;
1858
1859 for (ia = in6_ifaddr; ia; ia = ia->ia_next) {
1860 if (IN6_ARE_ADDR_EQUAL(&ia->ia_addr.sin6_addr,
1861 &sa6->sin6_addr) &&
bde3511a
JH
1862 (ia->ia6_flags & IN6_IFF_DEPRECATED))
1863 return (1); /* true */
984263bc
MD
1864
1865 /* XXX: do we still have to go thru the rest of the list? */
1866 }
1867
bde3511a 1868 return (0); /* false */
984263bc
MD
1869}
1870
1871/*
1872 * return length of part which dst and src are equal
1873 * hard coding...
1874 */
1875int
122ebd49 1876in6_matchlen(struct in6_addr *src, struct in6_addr *dst)
984263bc
MD
1877{
1878 int match = 0;
1879 u_char *s = (u_char *)src, *d = (u_char *)dst;
1880 u_char *lim = s + 16, r;
1881
1882 while (s < lim)
1883 if ((r = (*d++ ^ *s++)) != 0) {
1884 while (r < 128) {
1885 match++;
1886 r <<= 1;
1887 }
1888 break;
1889 } else
1890 match += 8;
1891 return match;
1892}
1893
1894/* XXX: to be scope conscious */
1895int
122ebd49 1896in6_are_prefix_equal(struct in6_addr *p1, struct in6_addr *p2, int len)
984263bc
MD
1897{
1898 int bytelen, bitlen;
1899
1900 /* sanity check */
1901 if (0 > len || len > 128) {
1902 log(LOG_ERR, "in6_are_prefix_equal: invalid prefix length(%d)\n",
1903 len);
bde3511a 1904 return (0);
984263bc
MD
1905 }
1906
1907 bytelen = len / 8;
1908 bitlen = len % 8;
1909
1910 if (bcmp(&p1->s6_addr, &p2->s6_addr, bytelen))
bde3511a 1911 return (0);
984263bc
MD
1912 if (p1->s6_addr[bytelen] >> (8 - bitlen) !=
1913 p2->s6_addr[bytelen] >> (8 - bitlen))
bde3511a 1914 return (0);
984263bc 1915
bde3511a 1916 return (1);
984263bc
MD
1917}
1918
1919void
122ebd49 1920in6_prefixlen2mask(struct in6_addr *maskp, int len)
984263bc
MD
1921{
1922 u_char maskarray[8] = {0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff};
1923 int bytelen, bitlen, i;
1924
1925 /* sanity check */
1926 if (0 > len || len > 128) {
1927 log(LOG_ERR, "in6_prefixlen2mask: invalid prefix length(%d)\n",
1928 len);
1929 return;
1930 }
1931
1932 bzero(maskp, sizeof(*maskp));
1933 bytelen = len / 8;
1934 bitlen = len % 8;
1935 for (i = 0; i < bytelen; i++)
1936 maskp->s6_addr[i] = 0xff;
1937 if (bitlen)
1938 maskp->s6_addr[bytelen] = maskarray[bitlen - 1];
1939}
1940
1941/*
1942 * return the best address out of the same scope
1943 */
1944struct in6_ifaddr *
122ebd49 1945in6_ifawithscope(struct ifnet *oifp, struct in6_addr *dst)
984263bc
MD
1946{
1947 int dst_scope = in6_addrscope(dst), src_scope, best_scope = 0;
1948 int blen = -1;
1949 struct ifaddr *ifa;
1950 struct ifnet *ifp;
1951 struct in6_ifaddr *ifa_best = NULL;
bde3511a 1952
984263bc
MD
1953 if (oifp == NULL) {
1954#if 0
a6ec04bc 1955 kprintf("in6_ifawithscope: output interface is not specified\n");
984263bc 1956#endif
bde3511a 1957 return (NULL);
984263bc
MD
1958 }
1959
1960 /*
1961 * We search for all addresses on all interfaces from the beginning.
1962 * Comparing an interface with the outgoing interface will be done
1963 * only at the final stage of tiebreaking.
1964 */
1965 for (ifp = TAILQ_FIRST(&ifnet); ifp; ifp = TAILQ_NEXT(ifp, if_list))
1966 {
1967 /*
1968 * We can never take an address that breaks the scope zone
1969 * of the destination.
1970 */
1971 if (in6_addr2scopeid(ifp, dst) != in6_addr2scopeid(oifp, dst))
1972 continue;
1973
1974 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)
1975 {
1976 int tlen = -1, dscopecmp, bscopecmp, matchcmp;
1977
1978 if (ifa->ifa_addr->sa_family != AF_INET6)
1979 continue;
1980
1981 src_scope = in6_addrscope(IFA_IN6(ifa));
1982
1983 /*
1984 * Don't use an address before completing DAD
1985 * nor a duplicated address.
1986 */
1987 if (((struct in6_ifaddr *)ifa)->ia6_flags &
1988 IN6_IFF_NOTREADY)
1989 continue;
1990
1991 /* XXX: is there any case to allow anycasts? */
1992 if (((struct in6_ifaddr *)ifa)->ia6_flags &
1993 IN6_IFF_ANYCAST)
1994 continue;
1995
1996 if (((struct in6_ifaddr *)ifa)->ia6_flags &
1997 IN6_IFF_DETACHED)
1998 continue;
1999
2000 /*
2001 * If this is the first address we find,
2002 * keep it anyway.
2003 */
2004 if (ifa_best == NULL)
2005 goto replace;
2006
2007 /*
2008 * ifa_best is never NULL beyond this line except
2009 * within the block labeled "replace".
2010 */
2011
2012 /*
2013 * If ifa_best has a smaller scope than dst and
2014 * the current address has a larger one than
2015 * (or equal to) dst, always replace ifa_best.
2016 * Also, if the current address has a smaller scope
2017 * than dst, ignore it unless ifa_best also has a
2018 * smaller scope.
2019 * Consequently, after the two if-clause below,
2020 * the followings must be satisfied:
2021 * (scope(src) < scope(dst) &&
2022 * scope(best) < scope(dst))
2023 * OR
2024 * (scope(best) >= scope(dst) &&
2025 * scope(src) >= scope(dst))
2026 */
2027 if (IN6_ARE_SCOPE_CMP(best_scope, dst_scope) < 0 &&
2028 IN6_ARE_SCOPE_CMP(src_scope, dst_scope) >= 0)
2029 goto replace; /* (A) */
2030 if (IN6_ARE_SCOPE_CMP(src_scope, dst_scope) < 0 &&
2031 IN6_ARE_SCOPE_CMP(best_scope, dst_scope) >= 0)
2032 continue; /* (B) */
2033
2034 /*
2035 * A deprecated address SHOULD NOT be used in new
2036 * communications if an alternate (non-deprecated)
2037 * address is available and has sufficient scope.
2038 * RFC 2462, Section 5.5.4.
2039 */
2040 if (((struct in6_ifaddr *)ifa)->ia6_flags &
2041 IN6_IFF_DEPRECATED) {
2042 /*
2043 * Ignore any deprecated addresses if
2044 * specified by configuration.
2045 */
2046 if (!ip6_use_deprecated)
2047 continue;
2048
2049 /*
2050 * If we have already found a non-deprecated
2051 * candidate, just ignore deprecated addresses.
2052 */
bde3511a 2053 if (!(ifa_best->ia6_flags & IN6_IFF_DEPRECATED))
984263bc
MD
2054 continue;
2055 }
2056
2057 /*
2058 * A non-deprecated address is always preferred
2059 * to a deprecated one regardless of scopes and
2060 * address matching (Note invariants ensured by the
2061 * conditions (A) and (B) above.)
2062 */
2063 if ((ifa_best->ia6_flags & IN6_IFF_DEPRECATED) &&
bde3511a
JH
2064 !(((struct in6_ifaddr *)ifa)->ia6_flags &
2065 IN6_IFF_DEPRECATED))
984263bc
MD
2066 goto replace;
2067
2068 /*
2069 * When we use temporary addresses described in
2070 * RFC 3041, we prefer temporary addresses to
2071 * public autoconf addresses. Again, note the
2072 * invariants from (A) and (B). Also note that we
2073 * don't have any preference between static addresses
2074 * and autoconf addresses (despite of whether or not
2075 * the latter is temporary or public.)
2076 */
2077 if (ip6_use_tempaddr) {
2078 struct in6_ifaddr *ifat;
2079
2080 ifat = (struct in6_ifaddr *)ifa;
2081 if ((ifa_best->ia6_flags &
2082 (IN6_IFF_AUTOCONF|IN6_IFF_TEMPORARY))
2083 == IN6_IFF_AUTOCONF &&
2084 (ifat->ia6_flags &
2085 (IN6_IFF_AUTOCONF|IN6_IFF_TEMPORARY))
2086 == (IN6_IFF_AUTOCONF|IN6_IFF_TEMPORARY)) {
2087 goto replace;
2088 }
2089 if ((ifa_best->ia6_flags &
2090 (IN6_IFF_AUTOCONF|IN6_IFF_TEMPORARY))
2091 == (IN6_IFF_AUTOCONF|IN6_IFF_TEMPORARY) &&
2092 (ifat->ia6_flags &
2093 (IN6_IFF_AUTOCONF|IN6_IFF_TEMPORARY))
2094 == IN6_IFF_AUTOCONF) {
2095 continue;
2096 }
2097 }
2098
2099 /*
2100 * At this point, we have two cases:
2101 * 1. we are looking at a non-deprecated address,
2102 * and ifa_best is also non-deprecated.
2103 * 2. we are looking at a deprecated address,
2104 * and ifa_best is also deprecated.
2105 * Also, we do not have to consider a case where
2106 * the scope of if_best is larger(smaller) than dst and
2107 * the scope of the current address is smaller(larger)
2108 * than dst. Such a case has already been covered.
2109 * Tiebreaking is done according to the following
2110 * items:
2111 * - the scope comparison between the address and
2112 * dst (dscopecmp)
2113 * - the scope comparison between the address and
2114 * ifa_best (bscopecmp)
2115 * - if the address match dst longer than ifa_best
2116 * (matchcmp)
2117 * - if the address is on the outgoing I/F (outI/F)
2118 *
2119 * Roughly speaking, the selection policy is
2120 * - the most important item is scope. The same scope
2121 * is best. Then search for a larger scope.
2122 * Smaller scopes are the last resort.
2123 * - A deprecated address is chosen only when we have
2124 * no address that has an enough scope, but is
2125 * prefered to any addresses of smaller scopes
2126 * (this must be already done above.)
2127 * - addresses on the outgoing I/F are preferred to
2128 * ones on other interfaces if none of above
2129 * tiebreaks. In the table below, the column "bI"
2130 * means if the best_ifa is on the outgoing
2131 * interface, and the column "sI" means if the ifa
2132 * is on the outgoing interface.
2133 * - If there is no other reasons to choose one,
2134 * longest address match against dst is considered.
2135 *
2136 * The precise decision table is as follows:
2137 * dscopecmp bscopecmp match bI oI | replace?
2138 * N/A equal N/A Y N | No (1)
2139 * N/A equal N/A N Y | Yes (2)
2140 * N/A equal larger N/A | Yes (3)
2141 * N/A equal !larger N/A | No (4)
2142 * larger larger N/A N/A | No (5)
2143 * larger smaller N/A N/A | Yes (6)
2144 * smaller larger N/A N/A | Yes (7)
2145 * smaller smaller N/A N/A | No (8)
2146 * equal smaller N/A N/A | Yes (9)
2147 * equal larger (already done at A above)
2148 */
2149 dscopecmp = IN6_ARE_SCOPE_CMP(src_scope, dst_scope);
2150 bscopecmp = IN6_ARE_SCOPE_CMP(src_scope, best_scope);
2151
2152 if (bscopecmp == 0) {
2153 struct ifnet *bifp = ifa_best->ia_ifp;
2154
2155 if (bifp == oifp && ifp != oifp) /* (1) */
2156 continue;
2157 if (bifp != oifp && ifp == oifp) /* (2) */
2158 goto replace;
2159
2160 /*
2161 * Both bifp and ifp are on the outgoing
2162 * interface, or both two are on a different
2163 * interface from the outgoing I/F.
2164 * now we need address matching against dst
2165 * for tiebreaking.
2166 */
2167 tlen = in6_matchlen(IFA_IN6(ifa), dst);
2168 matchcmp = tlen - blen;
2169 if (matchcmp > 0) /* (3) */
2170 goto replace;
2171 continue; /* (4) */
2172 }
2173 if (dscopecmp > 0) {
2174 if (bscopecmp > 0) /* (5) */
2175 continue;
2176 goto replace; /* (6) */
2177 }
2178 if (dscopecmp < 0) {
2179 if (bscopecmp > 0) /* (7) */
2180 goto replace;
2181 continue; /* (8) */
2182 }
2183
2184 /* now dscopecmp must be 0 */
2185 if (bscopecmp < 0)
2186 goto replace; /* (9) */
2187
2188 replace:
2189 ifa_best = (struct in6_ifaddr *)ifa;
2190 blen = tlen >= 0 ? tlen :
2191 in6_matchlen(IFA_IN6(ifa), dst);
2192 best_scope = in6_addrscope(&ifa_best->ia_addr.sin6_addr);
2193 }
2194 }
2195
2196 /* count statistics for future improvements */
2197 if (ifa_best == NULL)
2198 ip6stat.ip6s_sources_none++;
2199 else {
2200 if (oifp == ifa_best->ia_ifp)
2201 ip6stat.ip6s_sources_sameif[best_scope]++;
2202 else
2203 ip6stat.ip6s_sources_otherif[best_scope]++;
2204
2205 if (best_scope == dst_scope)
2206 ip6stat.ip6s_sources_samescope[best_scope]++;
2207 else
2208 ip6stat.ip6s_sources_otherscope[best_scope]++;
2209
bde3511a 2210 if (ifa_best->ia6_flags & IN6_IFF_DEPRECATED)
984263bc
MD
2211 ip6stat.ip6s_sources_deprecated[best_scope]++;
2212 }
2213
bde3511a 2214 return (ifa_best);
984263bc
MD
2215}
2216
2217/*
2218 * return the best address out of the same scope. if no address was
2219 * found, return the first valid address from designated IF.
2220 */
2221struct in6_ifaddr *
122ebd49 2222in6_ifawithifp(struct ifnet *ifp, struct in6_addr *dst)
984263bc
MD
2223{
2224 int dst_scope = in6_addrscope(dst), blen = -1, tlen;
2225 struct ifaddr *ifa;
2226 struct in6_ifaddr *besta = 0;
2227 struct in6_ifaddr *dep[2]; /* last-resort: deprecated */
2228
2229 dep[0] = dep[1] = NULL;
2230
2231 /*
2232 * We first look for addresses in the same scope.
2233 * If there is one, return it.
2234 * If two or more, return one which matches the dst longest.
2235 * If none, return one of global addresses assigned other ifs.
2236 */
2237 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)
2238 {
2239 if (ifa->ifa_addr->sa_family != AF_INET6)
2240 continue;
2241 if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_ANYCAST)
2242 continue; /* XXX: is there any case to allow anycast? */
2243 if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_NOTREADY)
2244 continue; /* don't use this interface */
2245 if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DETACHED)
2246 continue;
2247 if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DEPRECATED) {
2248 if (ip6_use_deprecated)
2249 dep[0] = (struct in6_ifaddr *)ifa;
2250 continue;
2251 }
2252
2253 if (dst_scope == in6_addrscope(IFA_IN6(ifa))) {
2254 /*
2255 * call in6_matchlen() as few as possible
2256 */
2257 if (besta) {
2258 if (blen == -1)
2259 blen = in6_matchlen(&besta->ia_addr.sin6_addr, dst);
2260 tlen = in6_matchlen(IFA_IN6(ifa), dst);
2261 if (tlen > blen) {
2262 blen = tlen;
2263 besta = (struct in6_ifaddr *)ifa;
2264 }
2265 } else
2266 besta = (struct in6_ifaddr *)ifa;
2267 }
2268 }
2269 if (besta)
bde3511a 2270 return (besta);
984263bc
MD
2271
2272 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)
2273 {
2274 if (ifa->ifa_addr->sa_family != AF_INET6)
2275 continue;
2276 if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_ANYCAST)
2277 continue; /* XXX: is there any case to allow anycast? */
2278 if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_NOTREADY)
2279 continue; /* don't use this interface */
2280 if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DETACHED)
2281 continue;
2282 if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DEPRECATED) {
2283 if (ip6_use_deprecated)
2284 dep[1] = (struct in6_ifaddr *)ifa;
2285 continue;
2286 }
2287
2288 return (struct in6_ifaddr *)ifa;
2289 }
2290
2291 /* use the last-resort values, that are, deprecated addresses */
2292 if (dep[0])
2293 return dep[0];
2294 if (dep[1])
2295 return dep[1];
2296
2297 return NULL;
2298}
2299
2300/*
2301 * perform DAD when interface becomes IFF_UP.
2302 */
2303void
122ebd49 2304in6_if_up(struct ifnet *ifp)
984263bc
MD
2305{
2306 struct ifaddr *ifa;
2307 struct in6_ifaddr *ia;
2308 int dad_delay; /* delay ticks before DAD output */
2309
2310 /*
2311 * special cases, like 6to4, are handled in in6_ifattach
2312 */
2313 in6_ifattach(ifp, NULL);
2314
2315 dad_delay = 0;
2316 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)
2317 {
2318 if (ifa->ifa_addr->sa_family != AF_INET6)
2319 continue;
2320 ia = (struct in6_ifaddr *)ifa;
2321 if (ia->ia6_flags & IN6_IFF_TENTATIVE)
2322 nd6_dad_start(ifa, &dad_delay);
2323 }
2324}
2325
2326int
122ebd49 2327in6if_do_dad(struct ifnet *ifp)
984263bc 2328{
bde3511a
JH
2329 if (ifp->if_flags & IFF_LOOPBACK)
2330 return (0);
984263bc
MD
2331
2332 switch (ifp->if_type) {
2333#ifdef IFT_DUMMY
2334 case IFT_DUMMY:
2335#endif
2336 case IFT_FAITH:
2337 /*
2338 * These interfaces do not have the IFF_LOOPBACK flag,
2339 * but loop packets back. We do not have to do DAD on such
2340 * interfaces. We should even omit it, because loop-backed
2341 * NS would confuse the DAD procedure.
2342 */
bde3511a 2343 return (0);
984263bc
MD
2344 default:
2345 /*
2346 * Our DAD routine requires the interface up and running.
2347 * However, some interfaces can be up before the RUNNING
2348 * status. Additionaly, users may try to assign addresses
2349 * before the interface becomes up (or running).
2350 * We simply skip DAD in such a case as a work around.
2351 * XXX: we should rather mark "tentative" on such addresses,
2352 * and do DAD after the interface becomes ready.
2353 */
2354 if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) !=
2355 (IFF_UP|IFF_RUNNING))
bde3511a 2356 return (0);
984263bc 2357
bde3511a 2358 return (1);
984263bc
MD
2359 }
2360}
2361
2362/*
2363 * Calculate max IPv6 MTU through all the interfaces and store it
2364 * to in6_maxmtu.
2365 */
2366void
122ebd49 2367in6_setmaxmtu(void)
984263bc
MD
2368{
2369 unsigned long maxmtu = 0;
2370 struct ifnet *ifp;
2371
2372 for (ifp = TAILQ_FIRST(&ifnet); ifp; ifp = TAILQ_NEXT(ifp, if_list))
2373 {
bde3511a 2374 if (!(ifp->if_flags & IFF_LOOPBACK) &&
698ac46c
HS
2375 ND_IFINFO(ifp)->linkmtu > maxmtu)
2376 maxmtu = ND_IFINFO(ifp)->linkmtu;
984263bc
MD
2377 }
2378 if (maxmtu) /* update only when maxmtu is positive */
2379 in6_maxmtu = maxmtu;
2380}
2381
698ac46c
HS
2382void *
2383in6_domifattach(struct ifnet *ifp)
2384{
2385 struct in6_ifextra *ext;
2386
efda3bd0 2387 ext = (struct in6_ifextra *)kmalloc(sizeof(*ext), M_IFADDR, M_WAITOK);
698ac46c
HS
2388 bzero(ext, sizeof(*ext));
2389
77652cad 2390 ext->in6_ifstat = (struct in6_ifstat *)kmalloc(sizeof(struct in6_ifstat),
698ac46c
HS
2391 M_IFADDR, M_WAITOK);
2392 bzero(ext->in6_ifstat, sizeof(*ext->in6_ifstat));
2393
2394 ext->icmp6_ifstat =
77652cad 2395 (struct icmp6_ifstat *)kmalloc(sizeof(struct icmp6_ifstat),
698ac46c
HS
2396 M_IFADDR, M_WAITOK);
2397 bzero(ext->icmp6_ifstat, sizeof(*ext->icmp6_ifstat));
2398
2399 ext->nd_ifinfo = nd6_ifattach(ifp);
2400 ext->scope6_id = scope6_ifattach(ifp);
2401 return ext;
2402}
2403
2404void
2405in6_domifdetach(struct ifnet *ifp, void *aux)
2406{
2407 struct in6_ifextra *ext = (struct in6_ifextra *)aux;
2408 scope6_ifdetach(ext->scope6_id);
2409 nd6_ifdetach(ext->nd_ifinfo);
efda3bd0
MD
2410 kfree(ext->in6_ifstat, M_IFADDR);
2411 kfree(ext->icmp6_ifstat, M_IFADDR);
2412 kfree(ext, M_IFADDR);
698ac46c
HS
2413}
2414
984263bc
MD
2415/*
2416 * Convert sockaddr_in6 to sockaddr_in. Original sockaddr_in6 must be
2417 * v4 mapped addr or v4 compat addr
2418 */
2419void
2420in6_sin6_2_sin(struct sockaddr_in *sin, struct sockaddr_in6 *sin6)
2421{
2422 bzero(sin, sizeof(*sin));
2423 sin->sin_len = sizeof(struct sockaddr_in);
2424 sin->sin_family = AF_INET;
2425 sin->sin_port = sin6->sin6_port;
bde3511a 2426 sin->sin_addr.s_addr = sin6->sin6_addr.s6_addr32[3];
984263bc
MD
2427}
2428
2429/* Convert sockaddr_in to sockaddr_in6 in v4 mapped addr format. */
2430void
2431in6_sin_2_v4mapsin6(struct sockaddr_in *sin, struct sockaddr_in6 *sin6)
2432{
2433 bzero(sin6, sizeof(*sin6));
2434 sin6->sin6_len = sizeof(struct sockaddr_in6);
2435 sin6->sin6_family = AF_INET6;
2436 sin6->sin6_port = sin->sin_port;
2437 sin6->sin6_addr.s6_addr32[0] = 0;
2438 sin6->sin6_addr.s6_addr32[1] = 0;
2439 sin6->sin6_addr.s6_addr32[2] = IPV6_ADDR_INT32_SMP;
2440 sin6->sin6_addr.s6_addr32[3] = sin->sin_addr.s_addr;
2441}
2442
2443/* Convert sockaddr_in6 into sockaddr_in. */
2444void
2445in6_sin6_2_sin_in_sock(struct sockaddr *nam)
2446{
2447 struct sockaddr_in *sin_p;
2448 struct sockaddr_in6 sin6;
2449
2450 /*
2451 * Save original sockaddr_in6 addr and convert it
2452 * to sockaddr_in.
2453 */
2454 sin6 = *(struct sockaddr_in6 *)nam;
2455 sin_p = (struct sockaddr_in *)nam;
2456 in6_sin6_2_sin(sin_p, &sin6);
2457}
2458
2459/* Convert sockaddr_in into sockaddr_in6 in v4 mapped addr format. */
2460void
2461in6_sin_2_v4mapsin6_in_sock(struct sockaddr **nam)
2462{
2463 struct sockaddr_in *sin_p;
2464 struct sockaddr_in6 *sin6_p;
2465
2466 MALLOC(sin6_p, struct sockaddr_in6 *, sizeof *sin6_p, M_SONAME,
2467 M_WAITOK);
2468 sin_p = (struct sockaddr_in *)*nam;
2469 in6_sin_2_v4mapsin6(sin_p, sin6_p);
2470 FREE(*nam, M_SONAME);
2471 *nam = (struct sockaddr *)sin6_p;
2472}