Date: Mon, 21 Jul 2014 22:59:10 +0000 (UTC) From: Jun Kuriyama <kuriyama@FreeBSD.org> To: ports-committers@freebsd.org, svn-ports-all@freebsd.org, svn-ports-head@freebsd.org Subject: svn commit: r362513 - in head/net/stf-6rd-kmod: . files-9.2 Message-ID: <201407212259.s6LMxAra095899@svn.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: kuriyama Date: Mon Jul 21 22:59:10 2014 New Revision: 362513 URL: http://svnweb.freebsd.org/changeset/ports/362513 QAT: https://qat.redports.org/buildarchive/r362513/ Log: Add support for 9.3-RELEASE. Added: head/net/stf-6rd-kmod/files-9.2/ head/net/stf-6rd-kmod/files-9.2/patch-if_stf.c (contents, props changed) Modified: head/net/stf-6rd-kmod/Makefile head/net/stf-6rd-kmod/distinfo head/net/stf-6rd-kmod/pkg-descr Modified: head/net/stf-6rd-kmod/Makefile ============================================================================== --- head/net/stf-6rd-kmod/Makefile Mon Jul 21 22:53:25 2014 (r362512) +++ head/net/stf-6rd-kmod/Makefile Mon Jul 21 22:59:10 2014 (r362513) @@ -9,17 +9,31 @@ PKGNAMESUFFIX= -6rd-kmod DISTNAME= freebsd-stf-${OSREL}-${PORTVERSION} MAINTAINER= kuriyama@FreeBSD.org -COMMENT= 6rd patched stf(4) kernel modules port for 8.3+ +COMMENT= 6rd patched stf(4) kernel modules port for 8.4+ ONLY_FOR_ARCHS= amd64 i386 WRKSRC= ${WRKDIR} -SVN_REV= 239080 # 8.1=r209773, 8.2=r216741, 8.3=r232314 +SVN_REV= 267655 USES= kmod + .include <bsd.port.pre.mk> -.if ${OSREL} != "8.1" && ${OSREL} != "8.2" && ${OSREL} != "8.3" && ${OSREL} != "8.4" && ${OSREL} != "9.1" +.if ${OSREL} == "8.4" +#SVN_REV= 255447 +.elif ${OSREL} == "9.1" +#SVN_REV= 255448 +.elif ${OSREL} == "9.2" +#SVN_REV= 255444 +PATCHDIR= ${MASTERDIR}/files-9.2 +.elif ${OSREL} == "9.3" +#SVN_REV= 267655 +PATCHDIR= ${MASTERDIR}/files-9.2 +#.elif ${OSREL} == "10.0" +##SVN_REV= 258913 +#PATCHDIR= ${MASTERDIR}/files-10.0 +.else IGNORE= not supported $${OSREL} (${OSREL}) .endif @@ -46,10 +60,13 @@ do-install: SVN_MIRROR?= http://svn.freebsd.org/base EXPDIR= ${WRKSRC}/src/sys maintainer-tar: +.for _osrel in 8.4 9.1 9.2 9.3 10.0 + -${RM} -rf ${EXPDIR} ${MKDIR} ${EXPDIR} - cd ${EXPDIR} && svn export -r ${SVN_REV} ${SVN_MIRROR}/releng/${OSREL}/sys/net net - cd ${EXPDIR} && svn export -r ${SVN_REV} ${SVN_MIRROR}/releng/${OSREL}/sys/modules/if_stf modules/if_stf - cd ${EXPDIR} && ${TAR} cfvz ${DISTDIR}/${DISTFILES} net modules + cd ${EXPDIR} && svn export -r ${SVN_REV} ${SVN_MIRROR}/releng/${_osrel}/sys/net net + cd ${EXPDIR} && svn export -r ${SVN_REV} ${SVN_MIRROR}/releng/${_osrel}/sys/modules/if_stf modules/if_stf + cd ${EXPDIR} && ${TAR} cfz ${DISTDIR}/freebsd-stf-${_osrel}-${PORTVERSION}${EXTRACT_SUFX} net modules +.endfor maintainer-check: @new=`svn log -ql 1 ${SVN_MIRROR}@HEAD releng/${OSREL}/sys/net/if_stf.c | ${GREP} -v ^- | ${SED} -e 's| .*||'`;\ @@ -58,7 +75,7 @@ maintainer-check: make-distinfo: ${RM} -f distinfo.tmp.* -.for r in 8.1 8.2 8.3 8.4 9.1 +.for r in 8.4 9.1 9.2 9.3 10.0 ${MAKE} OSREL=${r} DISTINFO_FILE=${MASTERDIR}/distinfo.tmp.${r} makesum .endfor ${CAT} ${MASTERDIR}/distinfo.tmp.* > ${MASTERDIR}/distinfo Modified: head/net/stf-6rd-kmod/distinfo ============================================================================== --- head/net/stf-6rd-kmod/distinfo Mon Jul 21 22:53:25 2014 (r362512) +++ head/net/stf-6rd-kmod/distinfo Mon Jul 21 22:59:10 2014 (r362513) @@ -1,10 +1,10 @@ -SHA256 (freebsd-stf-8.1-0.239080.tar.gz) = 0d38be83250fd81041c6b1972183d0e740f740070fd8471ccce12ed98f853cdb -SIZE (freebsd-stf-8.1-0.239080.tar.gz) = 484583 -SHA256 (freebsd-stf-8.2-0.239080.tar.gz) = 826e5a1b532feb1cf239903a650c3819c3f6a65dd3182fdec209c288b5f2ab86 -SIZE (freebsd-stf-8.2-0.239080.tar.gz) = 487964 -SHA256 (freebsd-stf-8.3-0.239080.tar.gz) = 52240cd75e2a610e2873e78845f6f19b3e6a1c838157b124dbfc73e879e689f4 -SIZE (freebsd-stf-8.3-0.239080.tar.gz) = 498737 -SHA256 (freebsd-stf-8.4-0.239080.tar.gz) = be42537b8e3e862b439739c995a983697a3f6f9dea809a3fe295fa332482d371 -SIZE (freebsd-stf-8.4-0.239080.tar.gz) = 500989 -SHA256 (freebsd-stf-9.1-0.239080.tar.gz) = b8a9541b06d7402d1350fcaf678ad85dc1b02ca23a99ebae725bc2bd7a659136 -SIZE (freebsd-stf-9.1-0.239080.tar.gz) = 510230 +SHA256 (freebsd-stf-10.0-0.267655.tar.gz) = 492bc45cf0b9651dde008199920435c782bad71616398e0c52814a381578adae +SIZE (freebsd-stf-10.0-0.267655.tar.gz) = 535733 +SHA256 (freebsd-stf-8.4-0.267655.tar.gz) = 0c4dc42d0bbf8946cbde58f7047cd293a7de647f88db100ffe5db37125c635c0 +SIZE (freebsd-stf-8.4-0.267655.tar.gz) = 504670 +SHA256 (freebsd-stf-9.1-0.267655.tar.gz) = 239f90a4ac81d4b6f3ceb82a59e3d9a9152b08f611c9d7557dbca17877bb0ab9 +SIZE (freebsd-stf-9.1-0.267655.tar.gz) = 510463 +SHA256 (freebsd-stf-9.2-0.267655.tar.gz) = 7acfa2a90d6abf87302008a5357411b0732217d10b1e1c0b4cce292626a2024b +SIZE (freebsd-stf-9.2-0.267655.tar.gz) = 514295 +SHA256 (freebsd-stf-9.3-0.267655.tar.gz) = 2ffb08ff5abcbed586623237e9e4a3891492ac592557eef250b67fd74c3749de +SIZE (freebsd-stf-9.3-0.267655.tar.gz) = 529933 Added: head/net/stf-6rd-kmod/files-9.2/patch-if_stf.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/net/stf-6rd-kmod/files-9.2/patch-if_stf.c Mon Jul 21 22:59:10 2014 (r362513) @@ -0,0 +1,1149 @@ +--- sys/net/if_stf.c.orig 2013-03-27 03:57:25.000000000 +0900 ++++ sys/net/if_stf.c 2014-07-22 00:08:07.662461319 +0900 +@@ -3,6 +3,7 @@ + + /*- + * Copyright (C) 2000 WIDE Project. ++ * Copyright (c) 2010 Hiroki Sato <hrs@FreeBSD.org> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without +@@ -31,7 +32,7 @@ + */ + + /* +- * 6to4 interface, based on RFC3056. ++ * 6to4 interface, based on RFC3056 + 6rd (RFC5569) support. + * + * 6to4 interface is NOT capable of link-layer (I mean, IPv4) multicasting. + * There is no address mapping defined from IPv6 multicast address to IPv4 +@@ -60,7 +61,7 @@ + * ICMPv6: + * - Redirects cannot be used due to the lack of link-local address. + * +- * stf interface does not have, and will not need, a link-local address. ++ * stf interface does not have, and will not need, a link-local address. + * It seems to have no real benefit and does not help the above symptoms much. + * Even if we assign link-locals to interface, we cannot really + * use link-local unicast/multicast on top of 6to4 cloud (since there's no +@@ -72,6 +73,12 @@ + * http://playground.iijlab.net/i-d/draft-itojun-ipv6-transition-abuse-00.txt + * for details. The code tries to filter out some of malicious packets. + * Note that there is no way to be 100% secure. ++ * ++ * 6rd (RFC5569) extension is enabled when an IPv6 GUA other than ++ * 2002::/16 is assigned. The stf(4) recognizes a 32-bit just after ++ * prefixlen as the IPv4 address of the 6rd customer site. The ++ * prefixlen must be shorter than 32. ++ * + */ + + #include "opt_inet.h" +@@ -120,12 +127,39 @@ + + #include <security/mac/mac_framework.h> + ++#define STF_DEBUG 1 ++#define ip_sprintf(buf, a) \ ++ sprintf(buf, "%d.%d.%d.%d", \ ++ (ntohl((a)->s_addr)>>24)&0xFF, \ ++ (ntohl((a)->s_addr)>>16)&0xFF, \ ++ (ntohl((a)->s_addr)>>8)&0xFF, \ ++ (ntohl((a)->s_addr))&0xFF); ++#if STF_DEBUG ++#define DEBUG_PRINTF(a, ...) \ ++ do { \ ++ if (V_stf_debug >= a) \ ++ printf(__VA_ARGS__); \ ++ } while (0) ++#else ++#define DEBUG_PRINTF(a, ...) ++#endif ++ + SYSCTL_DECL(_net_link); + static SYSCTL_NODE(_net_link, IFT_STF, stf, CTLFLAG_RW, 0, "6to4 Interface"); + +-static int stf_route_cache = 1; +-SYSCTL_INT(_net_link_stf, OID_AUTO, route_cache, CTLFLAG_RW, +- &stf_route_cache, 0, "Caching of IPv4 routes for 6to4 Output"); ++static VNET_DEFINE(int, stf_route_cache) = 1; ++#define V_stf_route_cache VNET(stf_route_cache) ++SYSCTL_VNET_INT(_net_link_stf, OID_AUTO, route_cache, CTLFLAG_RW, ++ &VNET_NAME(stf_route_cache), 0, ++ "Enable caching of IPv4 routes for 6to4 output."); ++ ++#if STF_DEBUG ++static VNET_DEFINE(int, stf_debug) = 0; ++#define V_stf_debug VNET(stf_debug) ++SYSCTL_VNET_INT(_net_link_stf, OID_AUTO, stf_debug, CTLFLAG_RW, ++ &VNET_NAME(stf_debug), 0, ++ "Enable displaying verbose debug message of stf interfaces"); ++#endif + + static int stf_permit_rfc1918 = 0; + TUNABLE_INT("net.link.stf.permit_rfc1918", &stf_permit_rfc1918); +@@ -133,7 +167,6 @@ + &stf_permit_rfc1918, 0, "Permit the use of private IPv4 addresses"); + + #define STFNAME "stf" +-#define STFUNIT 0 + + #define IN6_IS_ADDR_6TO4(x) (ntohs((x)->s6_addr16[0]) == 0x2002) + +@@ -150,17 +183,26 @@ + struct route_in6 __sc_ro6; /* just for safety */ + } __sc_ro46; + #define sc_ro __sc_ro46.__sc_ro4 +- struct mtx sc_ro_mtx; ++ struct mtx sc_mtx; + u_int sc_fibnum; + const struct encaptab *encap_cookie; ++ u_int sc_flags; ++ LIST_ENTRY(stf_softc) stf_list; + }; + #define STF2IFP(sc) ((sc)->sc_ifp) + +-/* +- * Note that mutable fields in the softc are not currently locked. +- * We do lock sc_ro in stf_output though. +- */ ++static struct mtx stf_mtx; + static MALLOC_DEFINE(M_STF, STFNAME, "6to4 Tunnel Interface"); ++static VNET_DEFINE(LIST_HEAD(, stf_softc), stf_softc_list); ++#define V_stf_softc_list VNET(stf_softc_list) ++ ++#define STF_LOCK_INIT(sc) mtx_init(&(sc)->sc_mtx, "stf softc", \ ++ NULL, MTX_DEF); ++#define STF_LOCK_DESTROY(sc) mtx_destroy(&(sc)->sc_mtx) ++#define STF_LOCK(sc) mtx_lock(&(sc)->sc_mtx) ++#define STF_UNLOCK(sc) mtx_unlock(&(sc)->sc_mtx) ++#define STF_LOCK_ASSERT(sc) mtx_assert(&(sc)->sc_mtx, MA_OWNED) ++ + static const int ip_stf_ttl = 40; + + extern struct domain inetdomain; +@@ -175,8 +217,6 @@ + .pr_usrreqs = &rip_usrreqs + }; + +-static char *stfnames[] = {"stf0", "stf", "6to4", NULL}; +- + static int stfmodevent(module_t, int, void *); + static int stf_encapcheck(const struct mbuf *, int, int, void *); + static struct in6_ifaddr *stf_getsrcifa6(struct ifnet *); +@@ -189,68 +229,45 @@ + struct ifnet *); + static void stf_rtrequest(int, struct rtentry *, struct rt_addrinfo *); + static int stf_ioctl(struct ifnet *, u_long, caddr_t); ++static int stf_is_up(struct ifnet *); + +-static int stf_clone_match(struct if_clone *, const char *); +-static int stf_clone_create(struct if_clone *, char *, size_t, caddr_t); +-static int stf_clone_destroy(struct if_clone *, struct ifnet *); +-struct if_clone stf_cloner = IFC_CLONE_INITIALIZER(STFNAME, NULL, 0, +- NULL, stf_clone_match, stf_clone_create, stf_clone_destroy); +- +-static int +-stf_clone_match(struct if_clone *ifc, const char *name) +-{ +- int i; +- +- for(i = 0; stfnames[i] != NULL; i++) { +- if (strcmp(stfnames[i], name) == 0) +- return (1); +- } ++#define STF_GETIN4_USE_CACHE 1 ++static struct sockaddr_in *stf_getin4addr(struct sockaddr_in *, ++ struct ifaddr *, ++ int); ++static struct sockaddr_in *stf_getin4addr_in6(struct sockaddr_in *, ++ struct ifaddr *, ++ struct in6_addr *); ++static struct sockaddr_in *stf_getin4addr_sin6(struct sockaddr_in *, ++ struct ifaddr *, ++ struct sockaddr_in6 *); ++static int stf_clone_create(struct if_clone *, int, caddr_t); ++static void stf_clone_destroy(struct ifnet *); + +- return (0); +-} ++IFC_SIMPLE_DECLARE(stf, 0); + + static int +-stf_clone_create(struct if_clone *ifc, char *name, size_t len, caddr_t params) ++stf_clone_create(struct if_clone *ifc, int unit, caddr_t params) + { +- int err, unit; + struct stf_softc *sc; + struct ifnet *ifp; + +- /* +- * We can only have one unit, but since unit allocation is +- * already locked, we use it to keep from allocating extra +- * interfaces. +- */ +- unit = STFUNIT; +- err = ifc_alloc_unit(ifc, &unit); +- if (err != 0) +- return (err); +- + sc = malloc(sizeof(struct stf_softc), M_STF, M_WAITOK | M_ZERO); ++ sc->sc_fibnum = curthread->td_proc->p_fibnum; + ifp = STF2IFP(sc) = if_alloc(IFT_STF); +- if (ifp == NULL) { ++ if (sc->sc_ifp == NULL) { + free(sc, M_STF); +- ifc_free_unit(ifc, unit); +- return (ENOSPC); ++ return (ENOMEM); + } ++ STF_LOCK_INIT(sc); + ifp->if_softc = sc; +- sc->sc_fibnum = curthread->td_proc->p_fibnum; ++ if_initname(ifp, ifc->ifc_name, unit); + +- /* +- * Set the name manually rather then using if_initname because +- * we don't conform to the default naming convention for interfaces. +- */ +- strlcpy(ifp->if_xname, name, IFNAMSIZ); +- ifp->if_dname = ifc->ifc_name; +- ifp->if_dunit = IF_DUNIT_NONE; +- +- mtx_init(&(sc)->sc_ro_mtx, "stf ro", NULL, MTX_DEF); + sc->encap_cookie = encap_attach_func(AF_INET, IPPROTO_IPV6, + stf_encapcheck, &in_stf_protosw, sc); + if (sc->encap_cookie == NULL) { + if_printf(ifp, "attach failed\n"); + free(sc, M_STF); +- ifc_free_unit(ifc, unit); + return (ENOMEM); + } + +@@ -260,41 +277,57 @@ + ifp->if_snd.ifq_maxlen = ifqmaxlen; + if_attach(ifp); + bpfattach(ifp, DLT_NULL, sizeof(u_int32_t)); ++ ++ mtx_lock(&stf_mtx); ++ LIST_INSERT_HEAD(&V_stf_softc_list, sc, stf_list); ++ mtx_unlock(&stf_mtx); ++ + return (0); + } + +-static int +-stf_clone_destroy(struct if_clone *ifc, struct ifnet *ifp) ++static void ++stf_clone_destroy(struct ifnet *ifp) + { + struct stf_softc *sc = ifp->if_softc; + int err; + ++ mtx_lock(&stf_mtx); ++ LIST_REMOVE(sc, stf_list); ++ mtx_unlock(&stf_mtx); ++ + err = encap_detach(sc->encap_cookie); + KASSERT(err == 0, ("Unexpected error detaching encap_cookie")); +- mtx_destroy(&(sc)->sc_ro_mtx); + bpfdetach(ifp); + if_detach(ifp); + if_free(ifp); + ++ STF_LOCK_DESTROY(sc); + free(sc, M_STF); +- ifc_free_unit(ifc, STFUNIT); + +- return (0); ++ return; + } + ++static void ++vnet_stf_init(const void *unused __unused) ++{ ++ ++ LIST_INIT(&V_stf_softc_list); ++} ++VNET_SYSINIT(vnet_stf_init, SI_SUB_PSEUDO, SI_ORDER_MIDDLE, vnet_stf_init, ++ NULL); ++ + static int +-stfmodevent(mod, type, data) +- module_t mod; +- int type; +- void *data; ++stfmodevent(module_t mod, int type, void *data) + { + + switch (type) { + case MOD_LOAD: ++ mtx_init(&stf_mtx, "stf_mtx", NULL, MTX_DEF); + if_clone_attach(&stf_cloner); + break; + case MOD_UNLOAD: + if_clone_detach(&stf_cloner); ++ mtx_destroy(&stf_mtx); + break; + default: + return (EOPNOTSUPP); +@@ -310,28 +343,31 @@ + }; + + DECLARE_MODULE(if_stf, stf_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); ++MODULE_VERSION(if_stf, 1); + + static int +-stf_encapcheck(m, off, proto, arg) +- const struct mbuf *m; +- int off; +- int proto; +- void *arg; ++stf_encapcheck(const struct mbuf *m, int off, int proto, void *arg) + { + struct ip ip; + struct in6_ifaddr *ia6; ++ struct sockaddr_in ia6_in4addr; ++ struct sockaddr_in ia6_in4mask; ++ struct sockaddr_in *sin; + struct stf_softc *sc; +- struct in_addr a, b, mask; ++ struct ifnet *ifp; ++ int ret = 0; + ++ DEBUG_PRINTF(1, "%s: enter\n", __func__); + sc = (struct stf_softc *)arg; + if (sc == NULL) + return 0; ++ ifp = STF2IFP(sc); + +- if ((STF2IFP(sc)->if_flags & IFF_UP) == 0) ++ if ((ifp->if_flags & IFF_UP) == 0) + return 0; + + /* IFF_LINK0 means "no decapsulation" */ +- if ((STF2IFP(sc)->if_flags & IFF_LINK0) != 0) ++ if ((ifp->if_flags & IFF_LINK0) != 0) + return 0; + + if (proto != IPPROTO_IPV6) +@@ -343,86 +379,162 @@ + if (ip.ip_v != 4) + return 0; + +- ia6 = stf_getsrcifa6(STF2IFP(sc)); ++ /* Lookup an ia6 whose IPv4 addr encoded in the IPv6 addr is valid. */ ++ ia6 = stf_getsrcifa6(ifp); + if (ia6 == NULL) + return 0; ++ sin = stf_getin4addr(&ia6_in4addr, &ia6->ia_ifa, STF_GETIN4_USE_CACHE); ++ if (sin == NULL) ++ return 0; ++ ++#if STF_DEBUG ++ { ++ char buf[INET6_ADDRSTRLEN + 1]; ++ memset(&buf, 0, sizeof(buf)); + ++ ip6_sprintf(buf, &satosin6(ia6->ia_ifa.ifa_addr)->sin6_addr); ++ DEBUG_PRINTF(1, "%s: ia6->ia_ifa.ifa_addr = %s\n", __func__, buf); ++ ip6_sprintf(buf, &ia6->ia_addr.sin6_addr); ++ DEBUG_PRINTF(1, "%s: ia6->ia_addr = %s\n", __func__, buf); ++ ip6_sprintf(buf, &satosin6(ia6->ia_ifa.ifa_netmask)->sin6_addr); ++ DEBUG_PRINTF(1, "%s: ia6->ia_ifa.ifa_netmask = %s\n", __func__, buf); ++ ip6_sprintf(buf, &ia6->ia_prefixmask.sin6_addr); ++ DEBUG_PRINTF(1, "%s: ia6->ia_prefixmask = %s\n", __func__, buf); ++ ++ ip_sprintf(buf, &ia6_in4addr.sin_addr); ++ DEBUG_PRINTF(1, "%s: ia6_in4addr.sin_addr = %s\n", __func__, buf); ++ ip_sprintf(buf, &ip.ip_src); ++ DEBUG_PRINTF(1, "%s: ip.ip_src = %s\n", __func__, buf); ++ ip_sprintf(buf, &ip.ip_dst); ++ DEBUG_PRINTF(1, "%s: ip.ip_dst = %s\n", __func__, buf); ++ } ++#endif + /* + * check if IPv4 dst matches the IPv4 address derived from the + * local 6to4 address. + * success on: dst = 10.1.1.1, ia6->ia_addr = 2002:0a01:0101:... + */ +- if (bcmp(GET_V4(&ia6->ia_addr.sin6_addr), &ip.ip_dst, +- sizeof(ip.ip_dst)) != 0) { +- ifa_free(&ia6->ia_ifa); +- return 0; ++ DEBUG_PRINTF(1, "%s: check1: ia6_in4addr.sin_addr == ip.ip_dst?\n", __func__); ++ if (ia6_in4addr.sin_addr.s_addr != ip.ip_dst.s_addr) { ++ DEBUG_PRINTF(1, "%s: check1: false. Ignore this packet.\n", __func__); ++ goto freeit; + } + +- /* +- * check if IPv4 src matches the IPv4 address derived from the +- * local 6to4 address masked by prefixmask. +- * success on: src = 10.1.1.1, ia6->ia_addr = 2002:0a00:.../24 +- * fail on: src = 10.1.1.1, ia6->ia_addr = 2002:0b00:.../24 +- */ +- bzero(&a, sizeof(a)); +- bcopy(GET_V4(&ia6->ia_addr.sin6_addr), &a, sizeof(a)); +- bcopy(GET_V4(&ia6->ia_prefixmask.sin6_addr), &mask, sizeof(mask)); +- ifa_free(&ia6->ia_ifa); +- a.s_addr &= mask.s_addr; +- b = ip.ip_src; +- b.s_addr &= mask.s_addr; +- if (a.s_addr != b.s_addr) +- return 0; ++ DEBUG_PRINTF(1, "%s: check2: ia6->ia_addr is 2002::/16?\n", __func__); ++ if (IN6_IS_ADDR_6TO4(&ia6->ia_addr.sin6_addr)) { ++ /* 6to4 (RFC 3056) */ ++ /* ++ * check if IPv4 src matches the IPv4 address derived ++ * from the local 6to4 address masked by prefixmask. ++ * success on: src = 10.1.1.1, ia6->ia_addr = 2002:0a00:.../24 ++ * fail on: src = 10.1.1.1, ia6->ia_addr = 2002:0b00:.../24 ++ */ ++ DEBUG_PRINTF(1, "%s: check2: true.\n", __func__); ++ ++ memcpy(&ia6_in4mask.sin_addr, ++ GET_V4(&ia6->ia_prefixmask.sin6_addr), ++ sizeof(ia6_in4mask)); ++#if STF_DEBUG ++ { ++ char buf[INET6_ADDRSTRLEN + 1]; ++ memset(&buf, 0, sizeof(buf)); ++ ++ ip_sprintf(buf, &ia6_in4addr.sin_addr); ++ DEBUG_PRINTF(1, "%s: ia6->ia_addr = %s\n", ++ __func__, buf); ++ ip_sprintf(buf, &ip.ip_src); ++ DEBUG_PRINTF(1, "%s: ip.ip_src = %s\n", ++ __func__, buf); ++ ip_sprintf(buf, &ia6_in4mask.sin_addr); ++ DEBUG_PRINTF(1, "%s: ia6->ia_prefixmask = %s\n", ++ __func__, buf); ++ ++ DEBUG_PRINTF(1, "%s: check3: ia6_in4addr.sin_addr & mask == ip.ip_src & mask\n", ++ __func__); ++ } ++#endif + ++ if ((ia6_in4addr.sin_addr.s_addr & ia6_in4mask.sin_addr.s_addr) != ++ (ip.ip_src.s_addr & ia6_in4mask.sin_addr.s_addr)) { ++ DEBUG_PRINTF(1, "%s: check3: false. Ignore this packet.\n", ++ __func__); ++ goto freeit; ++ } ++ } else { ++ /* 6rd (RFC 5569) */ ++ DEBUG_PRINTF(1, "%s: check2: false. 6rd.\n", __func__); ++ /* ++ * No restriction on the src address in the case of ++ * 6rd because the stf(4) interface always has a ++ * prefix which covers whole of IPv4 src address ++ * range. So, stf_output() will catch all of ++ * 6rd-capsuled IPv4 traffic with suspicious inner dst ++ * IPv4 address (i.e. the IPv6 destination address is ++ * one the admin does not like to route to outside), ++ * and then it discard them silently. ++ */ ++ } ++ DEBUG_PRINTF(1, "%s: all clear!\n", __func__); + /* stf interface makes single side match only */ +- return 32; ++ ret = 32; ++freeit: ++ ifa_free(&ia6->ia_ifa); ++ ++ return (ret); + } + + static struct in6_ifaddr * +-stf_getsrcifa6(ifp) +- struct ifnet *ifp; ++stf_getsrcifa6(struct ifnet *ifp) + { +- struct ifaddr *ia; ++ struct ifaddr *ifa; + struct in_ifaddr *ia4; +- struct sockaddr_in6 *sin6; +- struct in_addr in; ++ struct sockaddr_in *sin; ++ struct sockaddr_in in4; + + if_addr_rlock(ifp); +- TAILQ_FOREACH(ia, &ifp->if_addrhead, ifa_link) { +- if (ia->ifa_addr->sa_family != AF_INET6) ++ TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { ++ if (ifa->ifa_addr->sa_family != AF_INET6) + continue; +- sin6 = (struct sockaddr_in6 *)ia->ifa_addr; +- if (!IN6_IS_ADDR_6TO4(&sin6->sin6_addr)) ++ if ((sin = stf_getin4addr(&in4, ifa, ++ STF_GETIN4_USE_CACHE)) == NULL) + continue; +- +- bcopy(GET_V4(&sin6->sin6_addr), &in, sizeof(in)); +- LIST_FOREACH(ia4, INADDR_HASH(in.s_addr), ia_hash) +- if (ia4->ia_addr.sin_addr.s_addr == in.s_addr) ++ LIST_FOREACH(ia4, INADDR_HASH(sin->sin_addr.s_addr), ia_hash) ++ if (ia4->ia_addr.sin_addr.s_addr == sin->sin_addr.s_addr) + break; + if (ia4 == NULL) + continue; + +- ifa_ref(ia); ++#if STF_DEBUG ++ { ++ char buf[INET6_ADDRSTRLEN + 1]; ++ memset(&buf, 0, sizeof(buf)); ++ ++ ip6_sprintf(buf, &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr); ++ DEBUG_PRINTF(1, "%s: ifa->ifa_addr->sin6_addr = %s\n", ++ __func__, buf); ++ ip_sprintf(buf, &ia4->ia_addr.sin_addr); ++ DEBUG_PRINTF(1, "%s: ia4->ia_addr.sin_addr = %s\n", ++ __func__, buf); ++ } ++#endif ++ ifa_ref(ifa); + if_addr_runlock(ifp); +- return (struct in6_ifaddr *)ia; ++ return (ifatoia6(ifa)); + } + if_addr_runlock(ifp); + ++ + return NULL; + } + + static int +-stf_output(ifp, m, dst, ro) +- struct ifnet *ifp; +- struct mbuf *m; +- struct sockaddr *dst; +- struct route *ro; ++stf_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst, struct route *ro) + { + struct stf_softc *sc; + struct sockaddr_in6 *dst6; + struct route *cached_route; +- struct in_addr in4; +- caddr_t ptr; ++ struct sockaddr_in *sin; ++ struct sockaddr_in in4; + struct sockaddr_in *dst4; + u_int8_t tos; + struct ip *ip; +@@ -484,20 +596,28 @@ + /* + * Pickup the right outer dst addr from the list of candidates. + * ip6_dst has priority as it may be able to give us shorter IPv4 hops. ++ * ip6_dst: destination addr in the packet header. ++ * dst6: destination addr specified in function argument. + */ +- ptr = NULL; +- if (IN6_IS_ADDR_6TO4(&ip6->ip6_dst)) +- ptr = GET_V4(&ip6->ip6_dst); +- else if (IN6_IS_ADDR_6TO4(&dst6->sin6_addr)) +- ptr = GET_V4(&dst6->sin6_addr); +- else { ++ DEBUG_PRINTF(1, "%s: dst addr selection\n", __func__); ++ sin = stf_getin4addr_in6(&in4, &ia6->ia_ifa, &ip6->ip6_dst); ++ if (sin == NULL) ++ sin = stf_getin4addr_in6(&in4, &ia6->ia_ifa, &dst6->sin6_addr); ++ if (sin == NULL) { + ifa_free(&ia6->ia_ifa); + m_freem(m); + ifp->if_oerrors++; + return ENETUNREACH; + } +- bcopy(ptr, &in4, sizeof(in4)); ++#if STF_DEBUG ++ { ++ char buf[INET6_ADDRSTRLEN + 1]; ++ memset(&buf, 0, sizeof(buf)); + ++ ip_sprintf(buf, &sin->sin_addr); ++ DEBUG_PRINTF(1, "%s: ip_dst = %s\n", __func__, buf); ++ } ++#endif + if (bpf_peers_present(ifp->if_bpf)) { + /* + * We need to prepend the address family as +@@ -521,11 +641,26 @@ + ip = mtod(m, struct ip *); + + bzero(ip, sizeof(*ip)); ++ bcopy(&in4.sin_addr, &ip->ip_dst, sizeof(ip->ip_dst)); + +- bcopy(GET_V4(&((struct sockaddr_in6 *)&ia6->ia_addr)->sin6_addr), +- &ip->ip_src, sizeof(ip->ip_src)); ++ sin = stf_getin4addr_sin6(&in4, &ia6->ia_ifa, &ia6->ia_addr); ++ if (sin == NULL) { ++ ifa_free(&ia6->ia_ifa); ++ m_freem(m); ++ ifp->if_oerrors++; ++ return ENETUNREACH; ++ } ++ bcopy(&in4.sin_addr, &ip->ip_src, sizeof(ip->ip_src)); ++#if STF_DEBUG ++ { ++ char buf[INET6_ADDRSTRLEN + 1]; ++ memset(&buf, 0, sizeof(buf)); ++ ++ ip_sprintf(buf, &ip->ip_src); ++ DEBUG_PRINTF(1, "%s: ip_src = %s\n", __func__, buf); ++ } ++#endif + ifa_free(&ia6->ia_ifa); +- bcopy(&in4, &ip->ip_dst, sizeof(ip->ip_dst)); + ip->ip_p = IPPROTO_IPV6; + ip->ip_ttl = ip_stf_ttl; + ip->ip_len = m->m_pkthdr.len; /*host order*/ +@@ -534,7 +669,7 @@ + else + ip_ecn_ingress(ECN_NOCARE, &ip->ip_tos, &tos); + +- if (!stf_route_cache) { ++ if (!V_stf_route_cache) { + cached_route = NULL; + goto sendit; + } +@@ -542,7 +677,7 @@ + /* + * Do we have a cached route? + */ +- mtx_lock(&(sc)->sc_ro_mtx); ++ STF_LOCK(sc); + dst4 = (struct sockaddr_in *)&sc->sc_ro.ro_dst; + if (dst4->sin_family != AF_INET || + bcmp(&dst4->sin_addr, &ip->ip_dst, sizeof(ip->ip_dst)) != 0) { +@@ -560,8 +695,15 @@ + rtalloc_fib(&sc->sc_ro, sc->sc_fibnum); + if (sc->sc_ro.ro_rt == NULL) { + m_freem(m); +- mtx_unlock(&(sc)->sc_ro_mtx); + ifp->if_oerrors++; ++ STF_UNLOCK(sc); ++ return ENETUNREACH; ++ } ++ if (sc->sc_ro.ro_rt->rt_ifp == ifp) { ++ /* infinite loop detection */ ++ m_free(m); ++ ifp->if_oerrors++; ++ STF_UNLOCK(sc); + return ENETUNREACH; + } + } +@@ -570,35 +712,32 @@ + sendit: + M_SETFIB(m, sc->sc_fibnum); + ifp->if_opackets++; ++ DEBUG_PRINTF(1, "%s: ip_output dispatch.\n", __func__); + error = ip_output(m, NULL, cached_route, 0, NULL, NULL); + + if (cached_route != NULL) +- mtx_unlock(&(sc)->sc_ro_mtx); ++ STF_UNLOCK(sc); + return error; + } + + static int +-isrfc1918addr(in) +- struct in_addr *in; ++isrfc1918addr(struct in_addr *in) + { + /* + * returns 1 if private address range: + * 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 + */ + if (stf_permit_rfc1918 == 0 && ( +- (ntohl(in->s_addr) & 0xff000000) >> 24 == 10 || +- (ntohl(in->s_addr) & 0xfff00000) >> 16 == 172 * 256 + 16 || +- (ntohl(in->s_addr) & 0xffff0000) >> 16 == 192 * 256 + 168)) ++ (ntohl(in->s_addr) & 0xff000000) == 10 << 24 || ++ (ntohl(in->s_addr) & 0xfff00000) == (172 * 256 + 16) << 16 || ++ (ntohl(in->s_addr) & 0xffff0000) == (192 * 256 + 168) << 16 )) + return 1; + + return 0; + } + + static int +-stf_checkaddr4(sc, in, inifp) +- struct stf_softc *sc; +- struct in_addr *in; +- struct ifnet *inifp; /* incoming interface */ ++stf_checkaddr4(struct stf_softc *sc, struct in_addr *in, struct ifnet *inifp) + { + struct in_ifaddr *ia4; + +@@ -614,20 +753,10 @@ + } + + /* +- * reject packets with private address range. +- * (requirement from RFC3056 section 2 1st paragraph) +- */ +- if (isrfc1918addr(in)) +- return -1; +- +- /* + * reject packets with broadcast + */ + IN_IFADDR_RLOCK(); +- for (ia4 = TAILQ_FIRST(&V_in_ifaddrhead); +- ia4; +- ia4 = TAILQ_NEXT(ia4, ia_link)) +- { ++ TAILQ_FOREACH(ia4, &V_in_ifaddrhead, ia_link) { + if ((ia4->ia_ifa.ifa_ifp->if_flags & IFF_BROADCAST) == 0) + continue; + if (in->s_addr == ia4->ia_broadaddr.sin_addr.s_addr) { +@@ -646,7 +775,7 @@ + + bzero(&sin, sizeof(sin)); + sin.sin_family = AF_INET; +- sin.sin_len = sizeof(struct sockaddr_in); ++ sin.sin_len = sizeof(sin); + sin.sin_addr = *in; + rt = rtalloc1_fib((struct sockaddr *)&sin, 0, + 0UL, sc->sc_fibnum); +@@ -667,10 +796,7 @@ + } + + static int +-stf_checkaddr6(sc, in6, inifp) +- struct stf_softc *sc; +- struct in6_addr *in6; +- struct ifnet *inifp; /* incoming interface */ ++stf_checkaddr6(struct stf_softc *sc, struct in6_addr *in6, struct ifnet *inifp) + { + /* + * check 6to4 addresses +@@ -694,9 +820,7 @@ + } + + void +-in_stf_input(m, off) +- struct mbuf *m; +- int off; ++in_stf_input(struct mbuf *m, int off) + { + int proto; + struct stf_softc *sc; +@@ -704,6 +828,7 @@ + struct ip6_hdr *ip6; + u_int8_t otos, itos; + struct ifnet *ifp; ++ struct route_in6 rin6; + + proto = mtod(m, struct ip *)->ip_p; + +@@ -727,6 +852,17 @@ + mac_ifnet_create_mbuf(ifp, m); + #endif + ++#if STF_DEBUG ++ { ++ char buf[INET6_ADDRSTRLEN + 1]; ++ memset(&buf, 0, sizeof(buf)); ++ ++ ip_sprintf(buf, &ip->ip_dst); ++ DEBUG_PRINTF(1, "%s: ip->ip_dst = %s\n", __func__, buf); ++ ip_sprintf(buf, &ip->ip_src); ++ DEBUG_PRINTF(1, "%s: ip->ip_src = %s\n", __func__, buf); ++ } ++#endif + /* + * perform sanity check against outer src/dst. + * for source, perform ingress filter as well. +@@ -747,6 +883,17 @@ + } + ip6 = mtod(m, struct ip6_hdr *); + ++#if STF_DEBUG ++ { ++ char buf[INET6_ADDRSTRLEN + 1]; ++ memset(&buf, 0, sizeof(buf)); ++ ++ ip6_sprintf(buf, &ip6->ip6_dst); ++ DEBUG_PRINTF(1, "%s: ip6->ip6_dst = %s\n", __func__, buf); ++ ip6_sprintf(buf, &ip6->ip6_src); ++ DEBUG_PRINTF(1, "%s: ip6->ip6_src = %s\n", __func__, buf); ++ } ++#endif + /* + * perform sanity check against inner src/dst. + * for source, perform ingress filter as well. +@@ -757,6 +904,41 @@ + return; + } + ++ /* ++ * reject packets with private address range. ++ * (requirement from RFC3056 section 2 1st paragraph) ++ */ ++ if ((IN6_IS_ADDR_6TO4(&ip6->ip6_src) && isrfc1918addr(&ip->ip_src)) || ++ (IN6_IS_ADDR_6TO4(&ip6->ip6_dst) && isrfc1918addr(&ip->ip_dst))) { ++ m_freem(m); ++ return; ++ } ++ ++ /* ++ * Ignore if the destination is the same stf interface because ++ * all of valid IPv6 outgoing traffic should go interfaces ++ * except for it. ++ */ ++ memset(&rin6, 0, sizeof(rin6)); ++ rin6.ro_dst.sin6_len = sizeof(rin6.ro_dst); ++ rin6.ro_dst.sin6_family = AF_INET6; ++ memcpy(&rin6.ro_dst.sin6_addr, &ip6->ip6_dst, ++ sizeof(rin6.ro_dst.sin6_addr)); ++ rtalloc((struct route *)&rin6); ++ if (rin6.ro_rt == NULL) { ++ DEBUG_PRINTF(1, "%s: no IPv6 dst. Ignored.\n", __func__); ++ m_free(m); ++ return; ++ } ++ if ((rin6.ro_rt->rt_ifp == ifp) && ++ (!IN6_ARE_ADDR_EQUAL(&ip6->ip6_src, &rin6.ro_dst.sin6_addr))) { ++ DEBUG_PRINTF(1, "%s: IPv6 dst is the same stf. Ignored.\n", __func__); ++ RTFREE(rin6.ro_rt); ++ m_free(m); ++ return; ++ } ++ RTFREE(rin6.ro_rt); ++ + itos = (ntohl(ip6->ip6_flow) >> 20) & 0xff; + if ((ifp->if_flags & IFF_LINK1) != 0) + ip_ecn_egress(ECN_ALLOWED, &otos, &itos); +@@ -766,7 +948,7 @@ + ip6->ip6_flow |= htonl((u_int32_t)itos << 20); + + m->m_pkthdr.rcvif = ifp; +- ++ + if (bpf_peers_present(ifp->if_bpf)) { + /* + * We need to prepend the address family as +@@ -779,6 +961,7 @@ + bpf_mtap2(ifp->if_bpf, &af, sizeof(af), m); + } + ++ DEBUG_PRINTF(1, "%s: netisr_dispatch(NETISR_IPV6)\n", __func__); + /* + * Put the packet to the network layer input queue according to the + * specified address family. +@@ -793,27 +976,277 @@ + + /* ARGSUSED */ + static void +-stf_rtrequest(cmd, rt, info) +- int cmd; +- struct rtentry *rt; +- struct rt_addrinfo *info; ++stf_rtrequest(int cmd, struct rtentry *rt, struct rt_addrinfo *info) + { ++ + RT_LOCK_ASSERT(rt); + rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu; + } + ++/* Check whether we have at least one instance with IFF_UP. */ + static int +-stf_ioctl(ifp, cmd, data) +- struct ifnet *ifp; +- u_long cmd; +- caddr_t data; ++stf_is_up(struct ifnet *ifp) ++{ ++ struct stf_softc *scp; ++ struct stf_softc *sc_cur; ++ struct stf_softc *sc_is_up; ++ ++ sc_is_up = NULL; ++ if ((sc_cur = ifp->if_softc) == NULL) ++ return (EINVAL); ++ ++ mtx_lock(&stf_mtx); ++ LIST_FOREACH(scp, &V_stf_softc_list, stf_list) { ++ if (scp == sc_cur) ++ continue; ++ if ((STF2IFP(scp)->if_flags & IFF_UP) != 0) { ++ sc_is_up = scp; ++ break; ++ } ++ } ++ mtx_unlock(&stf_mtx); ++ ++ /* We already has at least one instance with IFF_UP. */ ++ if (stf_is_up != NULL) ++ return (ENOSPC); ++ ++ return (0); ++} ++ ++static struct sockaddr_in * ++stf_getin4addr_in6(struct sockaddr_in *sin, ++ struct ifaddr *ifa, ++ struct in6_addr *in6) ++{ ++ struct sockaddr_in6 sin6; ++ ++ DEBUG_PRINTF(1, "%s: enter.\n", __func__); ++ if (ifa == NULL || in6 == NULL) ++ return NULL; ++ ++ memset(&sin6, 0, sizeof(sin6)); ++ memcpy(&sin6.sin6_addr, in6, sizeof(sin6.sin6_addr)); ++ sin6.sin6_len = sizeof(sin6); ++ sin6.sin6_family = AF_INET6; ++ ++ return(stf_getin4addr_sin6(sin, ifa, &sin6)); ++} ++ ++static struct sockaddr_in * ++stf_getin4addr_sin6(struct sockaddr_in *sin, ++ struct ifaddr *ifa, ++ struct sockaddr_in6 *sin6) ++{ ++ struct in6_ifaddr ia6; ++ int i; *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201407212259.s6LMxAra095899>