1 /* $FreeBSD$ */ 2 /* $KAME: if_stf.c,v 1.62 2001/06/07 22:32:16 itojun Exp $ */ 3 4 /* 5 * Copyright (C) 2000 WIDE Project. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of the project nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33 /* 34 * 6to4 interface, based on RFC3056. 35 * 36 * 6to4 interface is NOT capable of link-layer (I mean, IPv4) multicasting. 37 * There is no address mapping defined from IPv6 multicast address to IPv4 38 * address. Therefore, we do not have IFF_MULTICAST on the interface. 39 * 40 * Due to the lack of address mapping for link-local addresses, we cannot 41 * throw packets toward link-local addresses (fe80::x). Also, we cannot throw 42 * packets to link-local multicast addresses (ff02::x). 43 * 44 * Here are interesting symptoms due to the lack of link-local address: 45 * 46 * Unicast routing exchange: 47 * - RIPng: Impossible. Uses link-local multicast packet toward ff02::9, 48 * and link-local addresses as nexthop. 49 * - OSPFv6: Impossible. OSPFv6 assumes that there's link-local address 50 * assigned to the link, and makes use of them. Also, HELLO packets use 51 * link-local multicast addresses (ff02::5 and ff02::6). 52 * - BGP4+: Maybe. You can only use global address as nexthop, and global 53 * address as TCP endpoint address. 54 * 55 * Multicast routing protocols: 56 * - PIM: Hello packet cannot be used to discover adjacent PIM routers. 57 * Adjacent PIM routers must be configured manually (is it really spec-wise 58 * correct thing to do?). 59 * 60 * ICMPv6: 61 * - Redirects cannot be used due to the lack of link-local address. 62 * 63 * stf interface does not have, and will not need, a link-local address. 64 * It seems to have no real benefit and does not help the above symptoms much. 65 * Even if we assign link-locals to interface, we cannot really 66 * use link-local unicast/multicast on top of 6to4 cloud (since there's no 67 * encapsulation defined for link-local address), and the above analysis does 68 * not change. RFC3056 does not mandate the assignment of link-local address 69 * either. 70 * 71 * 6to4 interface has security issues. Refer to 72 * http://playground.iijlab.net/i-d/draft-itojun-ipv6-transition-abuse-00.txt 73 * for details. The code tries to filter out some of malicious packets. 74 * Note that there is no way to be 100% secure. 75 */ 76 77 #include "opt_inet.h" 78 #include "opt_inet6.h" 79 80 #include <sys/param.h> 81 #include <sys/systm.h> 82 #include <sys/socket.h> 83 #include <sys/sockio.h> 84 #include <sys/mbuf.h> 85 #include <sys/errno.h> 86 #include <sys/kernel.h> 87 #include <sys/protosw.h> 88 #include <sys/queue.h> 89 #include <machine/bus.h> /* XXX: Shouldn't really be required! */ 90 #include <sys/rman.h> 91 #include <machine/cpu.h> 92 93 #include <sys/malloc.h> 94 95 #include <net/if.h> 96 #include <net/route.h> 97 #include <net/netisr.h> 98 #include <net/if_types.h> 99 #include <net/if_stf.h> 100 101 #include <netinet/in.h> 102 #include <netinet/in_systm.h> 103 #include <netinet/ip.h> 104 #include <netinet/ip_var.h> 105 #include <netinet/in_var.h> 106 107 #include <netinet/ip6.h> 108 #include <netinet6/ip6_var.h> 109 #include <netinet6/in6_var.h> 110 #include <netinet/ip_ecn.h> 111 112 #include <netinet/ip_encap.h> 113 114 #include <machine/stdarg.h> 115 116 #include <net/net_osdep.h> 117 118 #include <net/bpf.h> 119 120 #define STFNAME "stf" 121 #define STF_MAXUNIT 0 /* only one is currently allowed */ 122 123 #define IN6_IS_ADDR_6TO4(x) (ntohs((x)->s6_addr16[0]) == 0x2002) 124 #define GET_V4(x) ((struct in_addr *)(&(x)->s6_addr16[1])) 125 126 struct stf_softc { 127 struct ifnet sc_if; /* common area */ 128 union { 129 struct route __sc_ro4; 130 struct route_in6 __sc_ro6; /* just for safety */ 131 } __sc_ro46; 132 #define sc_ro __sc_ro46.__sc_ro4 133 const struct encaptab *encap_cookie; 134 struct resource *r_unit; /* resource allocated for this unit */ 135 LIST_ENTRY(stf_softc) sc_list; /* all stf's are linked */ 136 }; 137 138 static LIST_HEAD(, stf_softc) stf_softc_list; 139 140 static MALLOC_DEFINE(M_STF, STFNAME, "6to4 Tunnel Interface"); 141 static struct rman stfunits[1]; 142 static int ip_stf_ttl = 40; 143 144 extern struct domain inetdomain; 145 struct protosw in_stf_protosw = 146 { SOCK_RAW, &inetdomain, IPPROTO_IPV6, PR_ATOMIC|PR_ADDR, 147 in_stf_input, rip_output, 0, rip_ctloutput, 148 0, 149 0, 0, 0, 0, 150 &rip_usrreqs 151 }; 152 153 static int stfmodevent __P((module_t, int, void *)); 154 static int stf_encapcheck __P((const struct mbuf *, int, int, void *)); 155 static struct in6_ifaddr *stf_getsrcifa6 __P((struct ifnet *)); 156 static int stf_output __P((struct ifnet *, struct mbuf *, struct sockaddr *, 157 struct rtentry *)); 158 static int stf_checkaddr4 __P((struct stf_softc *, struct in_addr *, 159 struct ifnet *)); 160 static int stf_checkaddr6 __P((struct stf_softc *, struct in6_addr *, 161 struct ifnet *)); 162 static void stf_rtrequest __P((int, struct rtentry *, struct rt_addrinfo *)); 163 static int stf_ioctl __P((struct ifnet *, u_long, caddr_t)); 164 165 int stf_clone_create __P((struct if_clone *, int *)); 166 void stf_clone_destroy __P((struct ifnet *)); 167 168 struct if_clone stf_cloner = 169 IF_CLONE_INITIALIZER(STFNAME, stf_clone_create, stf_clone_destroy); 170 171 int 172 stf_clone_create(ifc, unit) 173 struct if_clone *ifc; 174 int *unit; 175 { 176 struct resource *r; 177 struct stf_softc *sc; 178 179 if (*unit > STF_MAXUNIT) 180 return (ENXIO); 181 182 if (*unit < 0) { 183 r = rman_reserve_resource(stfunits, 0, STF_MAXUNIT, 1, 184 RF_ALLOCATED | RF_ACTIVE, NULL); 185 if (r == NULL) 186 return (ENOSPC); 187 *unit = rman_get_start(r); 188 } else { 189 r = rman_reserve_resource(stfunits, *unit, *unit, 1, 190 RF_ALLOCATED | RF_ACTIVE, NULL); 191 if (r == NULL) 192 return (EEXIST); 193 } 194 195 sc = malloc(sizeof(struct stf_softc), M_STF, M_WAITOK | M_ZERO); 196 sc->sc_if.if_name = STFNAME; 197 sc->sc_if.if_unit = *unit; 198 sc->r_unit = r; 199 200 sc->encap_cookie = encap_attach_func(AF_INET, IPPROTO_IPV6, 201 stf_encapcheck, &in_stf_protosw, sc); 202 if (sc->encap_cookie == NULL) { 203 printf("%s: attach failed\n", if_name(&sc->sc_if)); 204 free(sc, M_STF); 205 return (ENOMEM); 206 } 207 208 sc->sc_if.if_mtu = IPV6_MMTU; 209 sc->sc_if.if_ioctl = stf_ioctl; 210 sc->sc_if.if_output = stf_output; 211 sc->sc_if.if_type = IFT_STF; 212 sc->sc_if.if_snd.ifq_maxlen = IFQ_MAXLEN; 213 if_attach(&sc->sc_if); 214 bpfattach(&sc->sc_if, DLT_NULL, sizeof(u_int)); 215 LIST_INSERT_HEAD(&stf_softc_list, sc, sc_list); 216 return (0); 217 } 218 219 void 220 stf_clone_destroy(ifp) 221 struct ifnet *ifp; 222 { 223 int err; 224 struct stf_softc *sc = (void *) ifp; 225 226 LIST_REMOVE(sc, sc_list); 227 err = encap_detach(sc->encap_cookie); 228 KASSERT(err == 0, ("Unexpected error detaching encap_cookie")); 229 bpfdetach(ifp); 230 if_detach(ifp); 231 232 err = rman_release_resource(sc->r_unit); 233 KASSERT(err == 0, ("Unexpected error freeing resource")); 234 235 free(sc, M_STF); 236 } 237 238 static int 239 stfmodevent(mod, type, data) 240 module_t mod; 241 int type; 242 void *data; 243 { 244 int err; 245 246 switch (type) { 247 case MOD_LOAD: 248 stfunits->rm_type = RMAN_ARRAY; 249 stfunits->rm_descr = "configurable if_stf units"; 250 err = rman_init(stfunits); 251 if (err != 0) 252 return (err); 253 err = rman_manage_region(stfunits, 0, STF_MAXUNIT); 254 if (err != 0) { 255 printf("%s: stfunits: rman_manage_region: Failed %d\n", 256 STFNAME, err); 257 rman_fini(stfunits); 258 return (err); 259 } 260 LIST_INIT(&stf_softc_list); 261 if_clone_attach(&stf_cloner); 262 263 break; 264 case MOD_UNLOAD: 265 if_clone_detach(&stf_cloner); 266 267 while (!LIST_EMPTY(&stf_softc_list)) 268 stf_clone_destroy(&LIST_FIRST(&stf_softc_list)->sc_if); 269 270 err = rman_fini(stfunits); 271 KASSERT(err == 0, ("Unexpected error freeing resource")); 272 273 break; 274 } 275 276 return (0); 277 } 278 279 static moduledata_t stf_mod = { 280 "if_stf", 281 stfmodevent, 282 0 283 }; 284 285 DECLARE_MODULE(if_stf, stf_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); 286 287 static int 288 stf_encapcheck(m, off, proto, arg) 289 const struct mbuf *m; 290 int off; 291 int proto; 292 void *arg; 293 { 294 struct ip ip; 295 struct in6_ifaddr *ia6; 296 struct stf_softc *sc; 297 struct in_addr a, b; 298 299 sc = (struct stf_softc *)arg; 300 if (sc == NULL) 301 return 0; 302 303 if ((sc->sc_if.if_flags & IFF_UP) == 0) 304 return 0; 305 306 /* IFF_LINK0 means "no decapsulation" */ 307 if ((sc->sc_if.if_flags & IFF_LINK0) != 0) 308 return 0; 309 310 if (proto != IPPROTO_IPV6) 311 return 0; 312 313 /* LINTED const cast */ 314 m_copydata((struct mbuf *)m, 0, sizeof(ip), (caddr_t)&ip); 315 316 if (ip.ip_v != 4) 317 return 0; 318 319 ia6 = stf_getsrcifa6(&sc->sc_if); 320 if (ia6 == NULL) 321 return 0; 322 323 /* 324 * check if IPv4 dst matches the IPv4 address derived from the 325 * local 6to4 address. 326 * success on: dst = 10.1.1.1, ia6->ia_addr = 2002:0a01:0101:... 327 */ 328 if (bcmp(GET_V4(&ia6->ia_addr.sin6_addr), &ip.ip_dst, 329 sizeof(ip.ip_dst)) != 0) 330 return 0; 331 332 /* 333 * check if IPv4 src matches the IPv4 address derived from the 334 * local 6to4 address masked by prefixmask. 335 * success on: src = 10.1.1.1, ia6->ia_addr = 2002:0a00:.../24 336 * fail on: src = 10.1.1.1, ia6->ia_addr = 2002:0b00:.../24 337 */ 338 bzero(&a, sizeof(a)); 339 a.s_addr = GET_V4(&ia6->ia_addr.sin6_addr)->s_addr; 340 a.s_addr &= GET_V4(&ia6->ia_prefixmask.sin6_addr)->s_addr; 341 b = ip.ip_src; 342 b.s_addr &= GET_V4(&ia6->ia_prefixmask.sin6_addr)->s_addr; 343 if (a.s_addr != b.s_addr) 344 return 0; 345 346 /* stf interface makes single side match only */ 347 return 32; 348 } 349 350 static struct in6_ifaddr * 351 stf_getsrcifa6(ifp) 352 struct ifnet *ifp; 353 { 354 struct ifaddr *ia; 355 struct in_ifaddr *ia4; 356 struct sockaddr_in6 *sin6; 357 struct in_addr in; 358 359 for (ia = TAILQ_FIRST(&ifp->if_addrlist); 360 ia; 361 ia = TAILQ_NEXT(ia, ifa_list)) 362 { 363 if (ia->ifa_addr == NULL) 364 continue; 365 if (ia->ifa_addr->sa_family != AF_INET6) 366 continue; 367 sin6 = (struct sockaddr_in6 *)ia->ifa_addr; 368 if (!IN6_IS_ADDR_6TO4(&sin6->sin6_addr)) 369 continue; 370 371 bcopy(GET_V4(&sin6->sin6_addr), &in, sizeof(in)); 372 LIST_FOREACH(ia4, INADDR_HASH(in.s_addr), ia_hash) 373 if (ia4->ia_addr.sin_addr.s_addr == in.s_addr) 374 break; 375 if (ia4 == NULL) 376 continue; 377 378 return (struct in6_ifaddr *)ia; 379 } 380 381 return NULL; 382 } 383 384 static int 385 stf_output(ifp, m, dst, rt) 386 struct ifnet *ifp; 387 struct mbuf *m; 388 struct sockaddr *dst; 389 struct rtentry *rt; 390 { 391 struct stf_softc *sc; 392 struct sockaddr_in6 *dst6; 393 struct in_addr *in4; 394 struct sockaddr_in *dst4; 395 u_int8_t tos; 396 struct ip *ip; 397 struct ip6_hdr *ip6; 398 struct in6_ifaddr *ia6; 399 400 sc = (struct stf_softc*)ifp; 401 dst6 = (struct sockaddr_in6 *)dst; 402 403 /* just in case */ 404 if ((ifp->if_flags & IFF_UP) == 0) { 405 m_freem(m); 406 return ENETDOWN; 407 } 408 409 /* 410 * If we don't have an ip4 address that match my inner ip6 address, 411 * we shouldn't generate output. Without this check, we'll end up 412 * using wrong IPv4 source. 413 */ 414 ia6 = stf_getsrcifa6(ifp); 415 if (ia6 == NULL) { 416 m_freem(m); 417 return ENETDOWN; 418 } 419 420 if (m->m_len < sizeof(*ip6)) { 421 m = m_pullup(m, sizeof(*ip6)); 422 if (!m) 423 return ENOBUFS; 424 } 425 ip6 = mtod(m, struct ip6_hdr *); 426 tos = (ntohl(ip6->ip6_flow) >> 20) & 0xff; 427 428 /* 429 * Pickup the right outer dst addr from the list of candidates. 430 * ip6_dst has priority as it may be able to give us shorter IPv4 hops. 431 */ 432 if (IN6_IS_ADDR_6TO4(&ip6->ip6_dst)) 433 in4 = GET_V4(&ip6->ip6_dst); 434 else if (IN6_IS_ADDR_6TO4(&dst6->sin6_addr)) 435 in4 = GET_V4(&dst6->sin6_addr); 436 else { 437 m_freem(m); 438 return ENETUNREACH; 439 } 440 441 #if NBPFILTER > 0 442 if (ifp->if_bpf) { 443 /* 444 * We need to prepend the address family as 445 * a four byte field. Cons up a dummy header 446 * to pacify bpf. This is safe because bpf 447 * will only read from the mbuf (i.e., it won't 448 * try to free it or keep a pointer a to it). 449 */ 450 struct mbuf m0; 451 u_int32_t af = AF_INET6; 452 453 m0.m_next = m; 454 m0.m_len = 4; 455 m0.m_data = (char *)⁡ 456 457 #ifdef HAVE_OLD_BPF 458 bpf_mtap(ifp, &m0); 459 #else 460 bpf_mtap(ifp->if_bpf, &m0); 461 #endif 462 } 463 #endif /*NBPFILTER > 0*/ 464 465 M_PREPEND(m, sizeof(struct ip), M_DONTWAIT); 466 if (m && m->m_len < sizeof(struct ip)) 467 m = m_pullup(m, sizeof(struct ip)); 468 if (m == NULL) 469 return ENOBUFS; 470 ip = mtod(m, struct ip *); 471 472 bzero(ip, sizeof(*ip)); 473 474 bcopy(GET_V4(&((struct sockaddr_in6 *)&ia6->ia_addr)->sin6_addr), 475 &ip->ip_src, sizeof(ip->ip_src)); 476 bcopy(in4, &ip->ip_dst, sizeof(ip->ip_dst)); 477 ip->ip_p = IPPROTO_IPV6; 478 ip->ip_ttl = ip_stf_ttl; 479 ip->ip_len = m->m_pkthdr.len; /*host order*/ 480 if (ifp->if_flags & IFF_LINK1) 481 ip_ecn_ingress(ECN_ALLOWED, &ip->ip_tos, &tos); 482 else 483 ip_ecn_ingress(ECN_NOCARE, &ip->ip_tos, &tos); 484 485 dst4 = (struct sockaddr_in *)&sc->sc_ro.ro_dst; 486 if (dst4->sin_family != AF_INET || 487 bcmp(&dst4->sin_addr, &ip->ip_dst, sizeof(ip->ip_dst)) != 0) { 488 /* cache route doesn't match */ 489 dst4->sin_family = AF_INET; 490 dst4->sin_len = sizeof(struct sockaddr_in); 491 bcopy(&ip->ip_dst, &dst4->sin_addr, sizeof(dst4->sin_addr)); 492 if (sc->sc_ro.ro_rt) { 493 RTFREE(sc->sc_ro.ro_rt); 494 sc->sc_ro.ro_rt = NULL; 495 } 496 } 497 498 if (sc->sc_ro.ro_rt == NULL) { 499 rtalloc(&sc->sc_ro); 500 if (sc->sc_ro.ro_rt == NULL) { 501 m_freem(m); 502 return ENETUNREACH; 503 } 504 } 505 506 return ip_output(m, NULL, &sc->sc_ro, 0, NULL); 507 } 508 509 static int 510 stf_checkaddr4(sc, in, inifp) 511 struct stf_softc *sc; 512 struct in_addr *in; 513 struct ifnet *inifp; /* incoming interface */ 514 { 515 struct in_ifaddr *ia4; 516 517 /* 518 * reject packets with the following address: 519 * 224.0.0.0/4 0.0.0.0/8 127.0.0.0/8 255.0.0.0/8 520 */ 521 if (IN_MULTICAST(ntohl(in->s_addr))) 522 return -1; 523 switch ((ntohl(in->s_addr) & 0xff000000) >> 24) { 524 case 0: case 127: case 255: 525 return -1; 526 } 527 528 /* 529 * reject packets with broadcast 530 */ 531 for (ia4 = TAILQ_FIRST(&in_ifaddrhead); 532 ia4; 533 ia4 = TAILQ_NEXT(ia4, ia_link)) 534 { 535 if ((ia4->ia_ifa.ifa_ifp->if_flags & IFF_BROADCAST) == 0) 536 continue; 537 if (in->s_addr == ia4->ia_broadaddr.sin_addr.s_addr) 538 return -1; 539 } 540 541 /* 542 * perform ingress filter 543 */ 544 if (sc && (sc->sc_if.if_flags & IFF_LINK2) == 0 && inifp) { 545 struct sockaddr_in sin; 546 struct rtentry *rt; 547 548 bzero(&sin, sizeof(sin)); 549 sin.sin_family = AF_INET; 550 sin.sin_len = sizeof(struct sockaddr_in); 551 sin.sin_addr = *in; 552 rt = rtalloc1((struct sockaddr *)&sin, 0, 0UL); 553 if (!rt || rt->rt_ifp != inifp) { 554 #if 0 555 log(LOG_WARNING, "%s: packet from 0x%x dropped " 556 "due to ingress filter\n", if_name(&sc->sc_if), 557 (u_int32_t)ntohl(sin.sin_addr.s_addr)); 558 #endif 559 if (rt) 560 rtfree(rt); 561 return -1; 562 } 563 rtfree(rt); 564 } 565 566 return 0; 567 } 568 569 static int 570 stf_checkaddr6(sc, in6, inifp) 571 struct stf_softc *sc; 572 struct in6_addr *in6; 573 struct ifnet *inifp; /* incoming interface */ 574 { 575 /* 576 * check 6to4 addresses 577 */ 578 if (IN6_IS_ADDR_6TO4(in6)) 579 return stf_checkaddr4(sc, GET_V4(in6), inifp); 580 581 /* 582 * reject anything that look suspicious. the test is implemented 583 * in ip6_input too, but we check here as well to 584 * (1) reject bad packets earlier, and 585 * (2) to be safe against future ip6_input change. 586 */ 587 if (IN6_IS_ADDR_V4COMPAT(in6) || IN6_IS_ADDR_V4MAPPED(in6)) 588 return -1; 589 590 return 0; 591 } 592 593 void 594 in_stf_input(m, off) 595 struct mbuf *m; 596 int off; 597 { 598 int proto; 599 struct stf_softc *sc; 600 struct ip *ip; 601 struct ip6_hdr *ip6; 602 u_int8_t otos, itos; 603 int len, isr; 604 struct ifqueue *ifq = NULL; 605 struct ifnet *ifp; 606 607 proto = mtod(m, struct ip *)->ip_p; 608 609 if (proto != IPPROTO_IPV6) { 610 m_freem(m); 611 return; 612 } 613 614 ip = mtod(m, struct ip *); 615 616 sc = (struct stf_softc *)encap_getarg(m); 617 618 if (sc == NULL || (sc->sc_if.if_flags & IFF_UP) == 0) { 619 m_freem(m); 620 return; 621 } 622 623 ifp = &sc->sc_if; 624 625 /* 626 * perform sanity check against outer src/dst. 627 * for source, perform ingress filter as well. 628 */ 629 if (stf_checkaddr4(sc, &ip->ip_dst, NULL) < 0 || 630 stf_checkaddr4(sc, &ip->ip_src, m->m_pkthdr.rcvif) < 0) { 631 m_freem(m); 632 return; 633 } 634 635 otos = ip->ip_tos; 636 m_adj(m, off); 637 638 if (m->m_len < sizeof(*ip6)) { 639 m = m_pullup(m, sizeof(*ip6)); 640 if (!m) 641 return; 642 } 643 ip6 = mtod(m, struct ip6_hdr *); 644 645 /* 646 * perform sanity check against inner src/dst. 647 * for source, perform ingress filter as well. 648 */ 649 if (stf_checkaddr6(sc, &ip6->ip6_dst, NULL) < 0 || 650 stf_checkaddr6(sc, &ip6->ip6_src, m->m_pkthdr.rcvif) < 0) { 651 m_freem(m); 652 return; 653 } 654 655 itos = (ntohl(ip6->ip6_flow) >> 20) & 0xff; 656 if ((ifp->if_flags & IFF_LINK1) != 0) 657 ip_ecn_egress(ECN_ALLOWED, &otos, &itos); 658 else 659 ip_ecn_egress(ECN_NOCARE, &otos, &itos); 660 ip6->ip6_flow &= ~htonl(0xff << 20); 661 ip6->ip6_flow |= htonl((u_int32_t)itos << 20); 662 663 m->m_pkthdr.rcvif = ifp; 664 665 if (ifp->if_bpf) { 666 /* 667 * We need to prepend the address family as 668 * a four byte field. Cons up a dummy header 669 * to pacify bpf. This is safe because bpf 670 * will only read from the mbuf (i.e., it won't 671 * try to free it or keep a pointer a to it). 672 */ 673 struct mbuf m0; 674 u_int32_t af = AF_INET6; 675 676 m0.m_next = m; 677 m0.m_len = 4; 678 m0.m_data = (char *)⁡ 679 680 #ifdef HAVE_OLD_BPF 681 bpf_mtap(ifp, &m0); 682 #else 683 bpf_mtap(ifp->if_bpf, &m0); 684 #endif 685 } 686 687 /* 688 * Put the packet to the network layer input queue according to the 689 * specified address family. 690 * See net/if_gif.c for possible issues with packet processing 691 * reorder due to extra queueing. 692 */ 693 ifq = &ip6intrq; 694 isr = NETISR_IPV6; 695 696 len = m->m_pkthdr.len; 697 if (! IF_HANDOFF(ifq, m, NULL)) 698 return; 699 schednetisr(isr); 700 ifp->if_ipackets++; 701 ifp->if_ibytes += len; 702 } 703 704 /* ARGSUSED */ 705 static void 706 stf_rtrequest(cmd, rt, info) 707 int cmd; 708 struct rtentry *rt; 709 struct rt_addrinfo *info; 710 { 711 712 if (rt) 713 rt->rt_rmx.rmx_mtu = IPV6_MMTU; 714 } 715 716 static int 717 stf_ioctl(ifp, cmd, data) 718 struct ifnet *ifp; 719 u_long cmd; 720 caddr_t data; 721 { 722 struct ifaddr *ifa; 723 struct ifreq *ifr; 724 struct sockaddr_in6 *sin6; 725 int error; 726 727 error = 0; 728 switch (cmd) { 729 case SIOCSIFADDR: 730 ifa = (struct ifaddr *)data; 731 if (ifa == NULL || ifa->ifa_addr->sa_family != AF_INET6) { 732 error = EAFNOSUPPORT; 733 break; 734 } 735 sin6 = (struct sockaddr_in6 *)ifa->ifa_addr; 736 if (IN6_IS_ADDR_6TO4(&sin6->sin6_addr)) { 737 ifa->ifa_rtrequest = stf_rtrequest; 738 ifp->if_flags |= IFF_UP; 739 } else 740 error = EINVAL; 741 break; 742 743 case SIOCADDMULTI: 744 case SIOCDELMULTI: 745 ifr = (struct ifreq *)data; 746 if (ifr && ifr->ifr_addr.sa_family == AF_INET6) 747 ; 748 else 749 error = EAFNOSUPPORT; 750 break; 751 752 default: 753 error = EINVAL; 754 break; 755 } 756 757 return error; 758 } 759