UnivNautes

+#undef N

+}

diff --git a/sys/net/if_stf.c b/sys/net/if_stf.c

--- a/sys/net/if_stf.c

+++ b/sys/net/if_stf.c

@@ -3,6 +3,8 @@

 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 *);

 static void stf_rtrequest(int, struct rtentry *, struct rt_addrinfo *);

 static int stf_ioctl(struct ifnet *, u_long, caddr_t);

-static int stf_clone_match(struct if_clone *, const char *);

+#define	STF_GETIN4_USE_CACHE  1

+static struct sockaddr_in *stf_getin4addr(struct stf_softc *, struct sockaddr_in *,

+	struct ifaddr *, int);

+	struct ifaddr *, const struct in6_addr *);

+static struct sockaddr_in *stf_getin4addr_sin6(struct stf_softc *, struct sockaddr_in *,

+	struct ifaddr *, struct sockaddr_in6 *);

-	int i;

-	for(i = 0; stfnames[i] != NULL; i++) {

-		if (strcmp(stfnames[i], name) == 0)

-			return (1);

-	}

-	return (0);

 static int

 {

-	int err, unit;

 	struct stf_softc *sc;

 	struct ifnet *ifp;

-	/*

-	 * We can only have one unit, but since unit allocation is

-	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);

-	strlcpy(ifp->if_xname, name, IFNAMSIZ);

-	ifp->if_dname = stfname;

-	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);

 	}

 	ifp->if_snd.ifq_maxlen = ifqmaxlen;

 	if_attach(ifp);

 	bpfattach(ifp, DLT_NULL, sizeof(u_int32_t));

 	return (0);

 }

 {

 	struct stf_softc *sc = ifp->if_softc;

 	int err;

+	mtx_lock(&stf_mtx);

+	STF_LOCK_DESTROY(sc);

 	free(sc, M_STF);

-	ifc_free_unit(ifc, STFUNIT);

+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;

 	switch (type) {

 	case MOD_LOAD:

+		mtx_init(&stf_mtx, "stf_mtx", NULL, MTX_DEF);

 		break;

 	case MOD_UNLOAD:

 		if_clone_detach(stf_cloner);

 		break;

 	default:

 		return (EOPNOTSUPP);

 };

 DECLARE_MODULE(if_stf, stf_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);

 		return 0;

 	if (proto != IPPROTO_IPV6)

 	if (ip.ip_v != 4)

 		return 0;

 }

 static int

 	struct stf_softc *sc;

 	const struct sockaddr_in6 *dst6;

 	struct route *cached_route;

 	struct sockaddr_in *dst4;

 	u_int8_t tos;

 	struct ip *ip;

 	/*

 	 * 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.

 	if (bpf_peers_present(ifp->if_bpf)) {

 		/*

 		 * We need to prepend the address family as

 	ip = mtod(m, struct ip *);

 	bzero(ip, sizeof(*ip));

 	ip->ip_p = IPPROTO_IPV6;

 	ip->ip_ttl = ip_stf_ttl;

 	ip->ip_len = htons(m->m_pkthdr.len);

 	else

 		ip_ecn_ingress(ECN_NOCARE, &ip->ip_tos, &tos);

 		cached_route = NULL;

 		goto sendit;

 	}

 	/*

 	 * Do we have a cached route?

 	 */

 	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) {

 		rtalloc_fib(&sc->sc_ro, sc->sc_fibnum);

 		if (sc->sc_ro.ro_rt == NULL) {

 			m_freem(m);

 			return ENETUNREACH;

 		}

 	}

 sendit:

 	M_SETFIB(m, sc->sc_fibnum);

 	ifp->if_opackets++;

 {

 	struct in_ifaddr *ia4;

 	}

 	/*

 	 * reject packets with broadcast

 	 */

 	IN_IFADDR_RLOCK();

 		bzero(&sin, sizeof(sin));

 		sin.sin_family = AF_INET;

 		sin.sin_addr = *in;

 		rt = rtalloc1_fib((struct sockaddr *)&sin, 0,

 		    0UL, sc->sc_fibnum);

 }

 static int

 {

 	/*

 	 * check 6to4 addresses

 }

 void

 {

 	int proto;

 	struct stf_softc *sc;

 	struct ip6_hdr *ip6;

 	u_int8_t otos, itos;

 	struct ifnet *ifp;

 	proto = mtod(m, struct ip *)->ip_p;

 	mac_ifnet_create_mbuf(ifp, m);

 #endif

 	/*

 	 * perform sanity check against outer src/dst.

 	 * for source, perform ingress filter as well.

 	}

 	ip6 = mtod(m, struct ip6_hdr *);

 	/*

 	 * perform sanity check against inner src/dst.

 	 * for source, perform ingress filter as well.

 		return;

 	}

 	itos = (ntohl(ip6->ip6_flow) >> 20) & 0xff;

 	if ((ifp->if_flags & IFF_LINK1) != 0)

 		ip_ecn_egress(ECN_ALLOWED, &otos, &itos);

 	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

 		bpf_mtap2(ifp->if_bpf, &af, sizeof(af), m);

 	}

 	/*

 	 * Put the packet to the network layer input queue according to the

 	 * specified address family.

 /* ARGSUSED */

 static void

 		ifa->ifa_rtrequest = stf_rtrequest;

 		ifp->if_flags |= IFF_UP;

 		break;

 	}

 	return error;