Parallelize in_ifaddrhead operation
[dragonfly.git] / sys / net / stf / if_stf.c
CommitLineData
984263bc 1/* $FreeBSD: src/sys/net/if_stf.c,v 1.1.2.11 2003/01/23 21:06:44 sam Exp $ */
1b562c24 2/* $DragonFly: src/sys/net/stf/if_stf.c,v 1.23 2008/06/08 08:38:05 sephe Exp $ */
984263bc
MD
3/* $KAME: if_stf.c,v 1.73 2001/12/03 11:08:30 keiichi Exp $ */
4
5/*
6 * Copyright (C) 2000 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 * 6to4 interface, based on RFC3056.
36 *
37 * 6to4 interface is NOT capable of link-layer (I mean, IPv4) multicasting.
38 * There is no address mapping defined from IPv6 multicast address to IPv4
39 * address. Therefore, we do not have IFF_MULTICAST on the interface.
40 *
41 * Due to the lack of address mapping for link-local addresses, we cannot
42 * throw packets toward link-local addresses (fe80::x). Also, we cannot throw
43 * packets to link-local multicast addresses (ff02::x).
44 *
45 * Here are interesting symptoms due to the lack of link-local address:
46 *
47 * Unicast routing exchange:
48 * - RIPng: Impossible. Uses link-local multicast packet toward ff02::9,
49 * and link-local addresses as nexthop.
50 * - OSPFv6: Impossible. OSPFv6 assumes that there's link-local address
51 * assigned to the link, and makes use of them. Also, HELLO packets use
52 * link-local multicast addresses (ff02::5 and ff02::6).
53 * - BGP4+: Maybe. You can only use global address as nexthop, and global
54 * address as TCP endpoint address.
55 *
56 * Multicast routing protocols:
57 * - PIM: Hello packet cannot be used to discover adjacent PIM routers.
58 * Adjacent PIM routers must be configured manually (is it really spec-wise
59 * correct thing to do?).
60 *
61 * ICMPv6:
62 * - Redirects cannot be used due to the lack of link-local address.
63 *
64 * stf interface does not have, and will not need, a link-local address.
65 * It seems to have no real benefit and does not help the above symptoms much.
66 * Even if we assign link-locals to interface, we cannot really
67 * use link-local unicast/multicast on top of 6to4 cloud (since there's no
68 * encapsulation defined for link-local address), and the above analysis does
69 * not change. RFC3056 does not mandate the assignment of link-local address
70 * either.
71 *
72 * 6to4 interface has security issues. Refer to
73 * http://playground.iijlab.net/i-d/draft-itojun-ipv6-transition-abuse-00.txt
74 * for details. The code tries to filter out some of malicious packets.
75 * Note that there is no way to be 100% secure.
76 */
77
78#include "opt_inet.h"
79#include "opt_inet6.h"
80
81#include <sys/param.h>
82#include <sys/systm.h>
83#include <sys/socket.h>
84#include <sys/sockio.h>
85#include <sys/mbuf.h>
86#include <sys/errno.h>
87#include <sys/protosw.h>
88#include <sys/kernel.h>
89#include <machine/cpu.h>
90
91#include <sys/malloc.h>
92
93#include <net/if.h>
94#include <net/route.h>
95#include <net/netisr.h>
96#include <net/if_types.h>
1f2de5d4 97#include "if_stf.h"
984263bc
MD
98
99#include <netinet/in.h>
100#include <netinet/in_systm.h>
101#include <netinet/ip.h>
984263bc
MD
102#include <netinet/ip_var.h>
103#include <netinet/in_var.h>
104
105#include <netinet/ip6.h>
106#include <netinet6/ip6_var.h>
107#include <netinet6/in6_var.h>
108#include <netinet/ip_ecn.h>
109
110#include <netinet/ip_encap.h>
111
112#include <machine/stdarg.h>
113
114#include <net/net_osdep.h>
115
116#include <net/bpf.h>
117
118#define IN6_IS_ADDR_6TO4(x) (ntohs((x)->s6_addr16[0]) == 0x2002)
119#define GET_V4(x) ((struct in_addr *)(&(x)->s6_addr16[1]))
120
121struct stf_softc {
122 struct ifnet sc_if; /* common area */
123 union {
124 struct route __sc_ro4;
125 struct route_in6 __sc_ro6; /* just for safety */
126 } __sc_ro46;
127#define sc_ro __sc_ro46.__sc_ro4
128 const struct encaptab *encap_cookie;
129};
130
131static struct stf_softc *stf;
132
133static MALLOC_DEFINE(M_STF, "stf", "6to4 Tunnel Interface");
134static int ip_stf_ttl = 40;
135
136extern struct domain inetdomain;
4468b0b4 137struct protosw in_stf_protosw =
984263bc
MD
138{ SOCK_RAW, &inetdomain, IPPROTO_IPV6, PR_ATOMIC|PR_ADDR,
139 in_stf_input, rip_output, 0, rip_ctloutput,
140 0,
141 0, 0, 0, 0,
142 &rip_usrreqs
143};
144
158abb01
RG
145static int stfmodevent (module_t, int, void *);
146static int stf_encapcheck (const struct mbuf *, int, int, void *);
147static struct in6_ifaddr *stf_getsrcifa6 (struct ifnet *);
148static int stf_output (struct ifnet *, struct mbuf *, struct sockaddr *,
149 struct rtentry *);
150static int stf_checkaddr4 (struct stf_softc *, struct in_addr *,
151 struct ifnet *);
152static int stf_checkaddr6 (struct stf_softc *, struct in6_addr *,
153 struct ifnet *);
154static void stf_rtrequest (int, struct rtentry *, struct rt_addrinfo *);
bd4539cc 155static int stf_ioctl (struct ifnet *, u_long, caddr_t, struct ucred *);
984263bc
MD
156
157static int
bf8c57c6 158stfmodevent(module_t mod, int type, void *data)
984263bc
MD
159{
160 struct stf_softc *sc;
161 int err;
162 const struct encaptab *p;
163
164 switch (type) {
165 case MOD_LOAD:
e7b4468c
SW
166 stf = kmalloc(sizeof(struct stf_softc), M_STF,
167 M_WAITOK | M_ZERO);
984263bc
MD
168 sc = stf;
169
170 bzero(sc, sizeof(*sc));
cdb7d804 171 if_initname(&(sc->sc_if), "stf", 0);
984263bc
MD
172
173 p = encap_attach_func(AF_INET, IPPROTO_IPV6, stf_encapcheck,
f15db79e 174 (void *)&in_stf_protosw, sc);
984263bc 175 if (p == NULL) {
4b1cf444 176 kprintf("%s: attach failed\n", if_name(&sc->sc_if));
984263bc
MD
177 return (ENOMEM);
178 }
179 sc->encap_cookie = p;
180
181 sc->sc_if.if_mtu = IPV6_MMTU;
182 sc->sc_if.if_flags = 0;
183 sc->sc_if.if_ioctl = stf_ioctl;
184 sc->sc_if.if_output = stf_output;
185 sc->sc_if.if_type = IFT_STF;
186#if 0
187 /* turn off ingress filter */
188 sc->sc_if.if_flags |= IFF_LINK2;
189#endif
190 sc->sc_if.if_snd.ifq_maxlen = IFQ_MAXLEN;
78195a76 191 if_attach(&sc->sc_if, NULL);
984263bc 192 bpfattach(&sc->sc_if, DLT_NULL, sizeof(u_int));
984263bc
MD
193 break;
194 case MOD_UNLOAD:
195 sc = stf;
196 bpfdetach(&sc->sc_if);
197 if_detach(&sc->sc_if);
198 err = encap_detach(sc->encap_cookie);
199 KASSERT(err == 0, ("Unexpected error detaching encap_cookie"));
efda3bd0 200 kfree(sc, M_STF);
984263bc
MD
201 break;
202 }
203
204 return (0);
205}
206
207static moduledata_t stf_mod = {
208 "if_stf",
209 stfmodevent,
210 0
211};
212
213DECLARE_MODULE(if_stf, stf_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
214
215static int
bf8c57c6 216stf_encapcheck(const struct mbuf *m, int off, int proto, void *arg)
984263bc
MD
217{
218 struct ip ip;
219 struct in6_ifaddr *ia6;
220 struct stf_softc *sc;
221 struct in_addr a, b;
222
223 sc = (struct stf_softc *)arg;
224 if (sc == NULL)
225 return 0;
226
227 if ((sc->sc_if.if_flags & IFF_UP) == 0)
228 return 0;
229
230 /* IFF_LINK0 means "no decapsulation" */
231 if ((sc->sc_if.if_flags & IFF_LINK0) != 0)
232 return 0;
233
234 if (proto != IPPROTO_IPV6)
235 return 0;
236
f15db79e 237 m_copydata(m, 0, sizeof(ip), (caddr_t)&ip);
984263bc
MD
238
239 if (ip.ip_v != 4)
240 return 0;
241
242 ia6 = stf_getsrcifa6(&sc->sc_if);
243 if (ia6 == NULL)
244 return 0;
245
246 /*
247 * check if IPv4 dst matches the IPv4 address derived from the
248 * local 6to4 address.
249 * success on: dst = 10.1.1.1, ia6->ia_addr = 2002:0a01:0101:...
250 */
251 if (bcmp(GET_V4(&ia6->ia_addr.sin6_addr), &ip.ip_dst,
252 sizeof(ip.ip_dst)) != 0)
253 return 0;
254
255 /*
256 * check if IPv4 src matches the IPv4 address derived from the
257 * local 6to4 address masked by prefixmask.
258 * success on: src = 10.1.1.1, ia6->ia_addr = 2002:0a00:.../24
259 * fail on: src = 10.1.1.1, ia6->ia_addr = 2002:0b00:.../24
260 */
261 bzero(&a, sizeof(a));
262 a.s_addr = GET_V4(&ia6->ia_addr.sin6_addr)->s_addr;
263 a.s_addr &= GET_V4(&ia6->ia_prefixmask.sin6_addr)->s_addr;
264 b = ip.ip_src;
265 b.s_addr &= GET_V4(&ia6->ia_prefixmask.sin6_addr)->s_addr;
266 if (a.s_addr != b.s_addr)
267 return 0;
268
269 /* stf interface makes single side match only */
270 return 32;
271}
272
273static struct in6_ifaddr *
bf8c57c6 274stf_getsrcifa6(struct ifnet *ifp)
984263bc 275{
b2632176 276 struct ifaddr_container *ifac;
984263bc
MD
277 struct in_ifaddr *ia4;
278 struct sockaddr_in6 *sin6;
279 struct in_addr in;
280
b2632176
SZ
281 TAILQ_FOREACH(ifac, &ifp->if_addrheads[mycpuid], ifa_link) {
282 struct ifaddr *ia = ifac->ifa;
283
984263bc
MD
284 if (ia->ifa_addr == NULL)
285 continue;
286 if (ia->ifa_addr->sa_family != AF_INET6)
287 continue;
288 sin6 = (struct sockaddr_in6 *)ia->ifa_addr;
289 if (!IN6_IS_ADDR_6TO4(&sin6->sin6_addr))
290 continue;
291
292 bcopy(GET_V4(&sin6->sin6_addr), &in, sizeof(in));
293 LIST_FOREACH(ia4, INADDR_HASH(in.s_addr), ia_hash)
294 if (ia4->ia_addr.sin_addr.s_addr == in.s_addr)
295 break;
296 if (ia4 == NULL)
297 continue;
298
299 return (struct in6_ifaddr *)ia;
300 }
301
302 return NULL;
303}
304
305static int
9db4b353
SZ
306stf_output_serialized(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
307 struct rtentry *rt)
984263bc
MD
308{
309 struct stf_softc *sc;
310 struct sockaddr_in6 *dst6;
311 struct in_addr *in4;
312 struct sockaddr_in *dst4;
313 u_int8_t tos;
314 struct ip *ip;
315 struct ip6_hdr *ip6;
316 struct in6_ifaddr *ia6;
1f8e62c9 317 static const uint32_t af = AF_INET6;
984263bc
MD
318
319 sc = (struct stf_softc*)ifp;
320 dst6 = (struct sockaddr_in6 *)dst;
321
322 /* just in case */
323 if ((ifp->if_flags & IFF_UP) == 0) {
324 m_freem(m);
325 return ENETDOWN;
326 }
327
328 /*
329 * If we don't have an ip4 address that match my inner ip6 address,
330 * we shouldn't generate output. Without this check, we'll end up
331 * using wrong IPv4 source.
332 */
333 ia6 = stf_getsrcifa6(ifp);
334 if (ia6 == NULL) {
335 m_freem(m);
336 return ENETDOWN;
337 }
338
339 if (m->m_len < sizeof(*ip6)) {
340 m = m_pullup(m, sizeof(*ip6));
341 if (!m)
342 return ENOBUFS;
343 }
344 ip6 = mtod(m, struct ip6_hdr *);
345 tos = (ntohl(ip6->ip6_flow) >> 20) & 0xff;
346
347 /*
348 * Pickup the right outer dst addr from the list of candidates.
349 * ip6_dst has priority as it may be able to give us shorter IPv4 hops.
350 */
351 if (IN6_IS_ADDR_6TO4(&ip6->ip6_dst))
352 in4 = GET_V4(&ip6->ip6_dst);
353 else if (IN6_IS_ADDR_6TO4(&dst6->sin6_addr))
354 in4 = GET_V4(&dst6->sin6_addr);
355 else {
356 m_freem(m);
357 return ENETUNREACH;
358 }
359
1f8e62c9
JS
360 if (ifp->if_bpf)
361 bpf_ptap(ifp->if_bpf, m, &af, sizeof(af));
984263bc 362
74f1caca 363 M_PREPEND(m, sizeof(struct ip), MB_DONTWAIT);
984263bc
MD
364 if (m && m->m_len < sizeof(struct ip))
365 m = m_pullup(m, sizeof(struct ip));
366 if (m == NULL)
367 return ENOBUFS;
368 ip = mtod(m, struct ip *);
369
370 bzero(ip, sizeof(*ip));
371
372 bcopy(GET_V4(&((struct sockaddr_in6 *)&ia6->ia_addr)->sin6_addr),
373 &ip->ip_src, sizeof(ip->ip_src));
374 bcopy(in4, &ip->ip_dst, sizeof(ip->ip_dst));
375 ip->ip_p = IPPROTO_IPV6;
376 ip->ip_ttl = ip_stf_ttl;
377 ip->ip_len = m->m_pkthdr.len; /*host order*/
378 if (ifp->if_flags & IFF_LINK1)
379 ip_ecn_ingress(ECN_ALLOWED, &ip->ip_tos, &tos);
380 else
381 ip_ecn_ingress(ECN_NOCARE, &ip->ip_tos, &tos);
382
383 dst4 = (struct sockaddr_in *)&sc->sc_ro.ro_dst;
384 if (dst4->sin_family != AF_INET ||
385 bcmp(&dst4->sin_addr, &ip->ip_dst, sizeof(ip->ip_dst)) != 0) {
386 /* cache route doesn't match */
387 dst4->sin_family = AF_INET;
388 dst4->sin_len = sizeof(struct sockaddr_in);
389 bcopy(&ip->ip_dst, &dst4->sin_addr, sizeof(dst4->sin_addr));
390 if (sc->sc_ro.ro_rt) {
391 RTFREE(sc->sc_ro.ro_rt);
392 sc->sc_ro.ro_rt = NULL;
393 }
394 }
395
396 if (sc->sc_ro.ro_rt == NULL) {
397 rtalloc(&sc->sc_ro);
398 if (sc->sc_ro.ro_rt == NULL) {
399 m_freem(m);
400 return ENETUNREACH;
401 }
402 }
403
404 return ip_output(m, NULL, &sc->sc_ro, 0, NULL, NULL);
405}
406
9db4b353
SZ
407static int
408stf_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
409 struct rtentry *rt)
410{
411 int error;
412
413 lwkt_serialize_enter(ifp->if_serializer);
414 error = stf_output_serialized(ifp, m, dst, rt);
415 lwkt_serialize_exit(ifp->if_serializer);
416
417 return error;
418}
419
bf8c57c6
SW
420/*
421 * Parameters:
422 * inifp: incoming interface
423 */
984263bc 424static int
bf8c57c6 425stf_checkaddr4(struct stf_softc *sc, struct in_addr *in, struct ifnet *inifp)
984263bc 426{
1b562c24 427 struct in_ifaddr_container *iac;
984263bc
MD
428
429 /*
430 * reject packets with the following address:
431 * 224.0.0.0/4 0.0.0.0/8 127.0.0.0/8 255.0.0.0/8
432 */
433 if (IN_MULTICAST(ntohl(in->s_addr)))
434 return -1;
435 switch ((ntohl(in->s_addr) & 0xff000000) >> 24) {
436 case 0: case 127: case 255:
437 return -1;
438 }
439
440 /*
441 * reject packets with broadcast
442 */
1b562c24
SZ
443 TAILQ_FOREACH(iac, &in_ifaddrheads[mycpuid], ia_link) {
444 struct in_ifaddr *ia4 = iac->ia;
445
984263bc
MD
446 if ((ia4->ia_ifa.ifa_ifp->if_flags & IFF_BROADCAST) == 0)
447 continue;
448 if (in->s_addr == ia4->ia_broadaddr.sin_addr.s_addr)
449 return -1;
450 }
451
452 /*
453 * perform ingress filter
454 */
455 if (sc && (sc->sc_if.if_flags & IFF_LINK2) == 0 && inifp) {
456 struct sockaddr_in sin;
457 struct rtentry *rt;
458
459 bzero(&sin, sizeof(sin));
460 sin.sin_family = AF_INET;
461 sin.sin_len = sizeof(struct sockaddr_in);
462 sin.sin_addr = *in;
a0720452 463 rt = rtpurelookup((struct sockaddr *)&sin);
984263bc
MD
464 if (!rt || rt->rt_ifp != inifp) {
465#if 0
466 log(LOG_WARNING, "%s: packet from 0x%x dropped "
467 "due to ingress filter\n", if_name(&sc->sc_if),
468 (u_int32_t)ntohl(sin.sin_addr.s_addr));
469#endif
470 if (rt)
471 rtfree(rt);
472 return -1;
473 }
474 rtfree(rt);
475 }
476
477 return 0;
478}
479
bf8c57c6
SW
480/*
481 * Parameters:
482 * inifp: incoming interface
483 */
984263bc 484static int
bf8c57c6 485stf_checkaddr6(struct stf_softc *sc, struct in6_addr *in6, struct ifnet *inifp)
984263bc
MD
486{
487 /*
488 * check 6to4 addresses
489 */
490 if (IN6_IS_ADDR_6TO4(in6))
491 return stf_checkaddr4(sc, GET_V4(in6), inifp);
492
493 /*
494 * reject anything that look suspicious. the test is implemented
495 * in ip6_input too, but we check here as well to
496 * (1) reject bad packets earlier, and
497 * (2) to be safe against future ip6_input change.
498 */
499 if (IN6_IS_ADDR_V4COMPAT(in6) || IN6_IS_ADDR_V4MAPPED(in6))
500 return -1;
501
502 return 0;
503}
504
505void
a00138cb 506in_stf_input(struct mbuf *m, ...)
984263bc 507{
984263bc
MD
508 struct stf_softc *sc;
509 struct ip *ip;
510 struct ip6_hdr *ip6;
511 u_int8_t otos, itos;
984263bc 512 struct ifnet *ifp;
a00138cb 513 int off, proto;
1f8e62c9 514 static const uint32_t af = AF_INET6;
a00138cb
JS
515 __va_list ap;
516
517 __va_start(ap, m);
518 off = __va_arg(ap, int);
519 proto = __va_arg(ap, int);
520 __va_end(ap);
984263bc
MD
521
522 if (proto != IPPROTO_IPV6) {
523 m_freem(m);
524 return;
525 }
526
527 ip = mtod(m, struct ip *);
528
529 sc = (struct stf_softc *)encap_getarg(m);
530
531 if (sc == NULL || (sc->sc_if.if_flags & IFF_UP) == 0) {
532 m_freem(m);
533 return;
534 }
535
536 ifp = &sc->sc_if;
537
538 /*
539 * perform sanity check against outer src/dst.
540 * for source, perform ingress filter as well.
541 */
542 if (stf_checkaddr4(sc, &ip->ip_dst, NULL) < 0 ||
543 stf_checkaddr4(sc, &ip->ip_src, m->m_pkthdr.rcvif) < 0) {
544 m_freem(m);
545 return;
546 }
547
548 otos = ip->ip_tos;
549 m_adj(m, off);
550
551 if (m->m_len < sizeof(*ip6)) {
552 m = m_pullup(m, sizeof(*ip6));
553 if (!m)
554 return;
555 }
556 ip6 = mtod(m, struct ip6_hdr *);
557
558 /*
559 * perform sanity check against inner src/dst.
560 * for source, perform ingress filter as well.
561 */
562 if (stf_checkaddr6(sc, &ip6->ip6_dst, NULL) < 0 ||
563 stf_checkaddr6(sc, &ip6->ip6_src, m->m_pkthdr.rcvif) < 0) {
564 m_freem(m);
565 return;
566 }
567
568 itos = (ntohl(ip6->ip6_flow) >> 20) & 0xff;
569 if ((ifp->if_flags & IFF_LINK1) != 0)
570 ip_ecn_egress(ECN_ALLOWED, &otos, &itos);
571 else
572 ip_ecn_egress(ECN_NOCARE, &otos, &itos);
573 ip6->ip6_flow &= ~htonl(0xff << 20);
574 ip6->ip6_flow |= htonl((u_int32_t)itos << 20);
575
576 m->m_pkthdr.rcvif = ifp;
1f8e62c9
JS
577
578 if (ifp->if_bpf)
579 bpf_ptap(ifp->if_bpf, m, &af, sizeof(af));
984263bc
MD
580
581 /*
582 * Put the packet to the network layer input queue according to the
583 * specified address family.
584 * See net/if_gif.c for possible issues with packet processing
585 * reorder due to extra queueing.
586 */
984263bc
MD
587 ifp->if_ipackets++;
588 ifp->if_ibytes += m->m_pkthdr.len;
f45600ee 589 netisr_dispatch(NETISR_IPV6, m);
984263bc
MD
590}
591
592/* ARGSUSED */
593static void
bf8c57c6 594stf_rtrequest(int cmd, struct rtentry *rt, struct rt_addrinfo *info)
984263bc
MD
595{
596
597 if (rt)
598 rt->rt_rmx.rmx_mtu = IPV6_MMTU;
599}
600
601static int
bf8c57c6 602stf_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
984263bc
MD
603{
604 struct ifaddr *ifa;
605 struct ifreq *ifr;
606 struct sockaddr_in6 *sin6;
607 int error;
608
609 error = 0;
610 switch (cmd) {
611 case SIOCSIFADDR:
612 ifa = (struct ifaddr *)data;
613 if (ifa == NULL || ifa->ifa_addr->sa_family != AF_INET6) {
614 error = EAFNOSUPPORT;
615 break;
616 }
617 sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
618 if (IN6_IS_ADDR_6TO4(&sin6->sin6_addr)) {
619 ifa->ifa_rtrequest = stf_rtrequest;
620 ifp->if_flags |= IFF_UP;
621 } else
622 error = EINVAL;
623 break;
624
625 case SIOCADDMULTI:
626 case SIOCDELMULTI:
627 ifr = (struct ifreq *)data;
628 if (ifr && ifr->ifr_addr.sa_family == AF_INET6)
629 ;
630 else
631 error = EAFNOSUPPORT;
632 break;
633
634 default:
635 error = EINVAL;
636 break;
637 }
638
639 return error;
640}