[apple/xnu.git] / bsd / netinet6 / natpt_dispatch.c

/*	$KAME: natpt_dispatch.c,v 1.9 2000/03/25 07:23:54 sumikawa Exp $	*/

/*
 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the project nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/param.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/syslog.h>
#include <sys/systm.h>

#ifdef __FreeBSD__
# include <sys/kernel.h>
#endif

#include <net/if.h>
#include <net/net_osdep.h>

#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>

#include <netinet/ip6.h>
#include <netinet6/ip6_var.h>
#include <netinet/icmp6.h>

#include <netinet6/natpt_defs.h>
#include <netinet6/natpt_list.h>
#include <netinet6/natpt_log.h>
#include <netinet6/natpt_var.h>


/*
 *
 */

u_int		natpt_debug;
u_int		natpt_dump;

static	struct _cell	*ifBox;

struct ifnet	*natpt_ip6src;

struct in6_addr	 faith_prefix
			= {{{0x00000000, 0x00000000, 0x00000000, 0x00000000}}};
struct in6_addr	 faith_prefixmask
			= {{{0x00000000, 0x00000000, 0x00000000, 0x00000000}}};
struct in6_addr	 natpt_prefix
			= {{{0x00000000, 0x00000000, 0x00000000, 0x00000000}}};
struct in6_addr	 natpt_prefixmask
			= {{{0x00000000, 0x00000000, 0x00000000, 0x00000000}}};

int		 natpt_in4			__P((struct mbuf *, struct mbuf **));
int		 natpt_in6			__P((struct mbuf *, struct mbuf **));
int		 natpt_out4			__P((struct mbuf *, struct mbuf **));
int		 natpt_out6			__P((struct mbuf *, struct mbuf **));
int		 natpt_incomingIPv4		__P((int, struct mbuf *, struct mbuf **));
int		 natpt_outgoingIPv4		__P((int, struct mbuf *, struct mbuf **));
int		 natpt_incomingIPv6		__P((int, struct mbuf *, struct mbuf **));
int		 natpt_outgoingIPv6		__P((int, struct mbuf *, struct mbuf **));

int		 configCv4			__P((int, struct mbuf *, struct _cv *));
int		 configCv6			__P((int, struct mbuf *, struct _cv *));
caddr_t		 foundFinalPayload		__P((struct mbuf *, int *, int *));
int		 sanityCheckIn4			__P((struct _cv *));
int		 sanityCheckOut6		__P((struct _cv *));
int		 checkMTU			__P((struct _cv *));


#if defined(__FreeBSD__) && __FreeBSD__ >= 3
static	MALLOC_DEFINE(M_NATPT, "NATPT", "Network Address Translation - Protocol Translation");
#endif


/*
 *
 */

int
natpt_in4(struct mbuf *m4, struct mbuf **m6)
{
    Cell	    *p;
    struct ifnet    *ifnet;
    struct ifBox    *ifb;
    int		     rv = IPPROTO_IP;

    if (natpt_initialized == 0)
	return (IPPROTO_IP);			/* goto ours		*/

    if (isDump(D_DIVEIN4))
	natpt_logMBuf(LOG_DEBUG, m4, "dive into natpt_in4.");

    ifnet = m4->m_pkthdr.rcvif;
    for (p = ifBox; p; p = CDR(p))
    {
	ifb = (struct ifBox *)CAR(p);
	if (ifb->ifnet == ifnet)
	{
	    if (ifb->side == outSide)
		rv = natpt_incomingIPv4(NATPT_INBOUND,	m4, m6);
	    else
		rv = natpt_outgoingIPv4(NATPT_OUTBOUND, m4, m6);
	    goto    exit;
	}
    }

  exit:;
    return (rv);
}


int
natpt_in6(struct mbuf *m6, struct mbuf **m4)
{
    Cell	    *p;
    struct ifnet    *ifnet;
    struct ifBox    *ifb;
    struct ip6_hdr  *ip6;
    struct in6_addr  cand;
    int		     rv = IPPROTO_IP;

    if (natpt_initialized == 0)
	return (IPPROTO_IP);			/* goto mcastcheck	*/

    if (isDump(D_DIVEIN6))
	natpt_logMBuf(LOG_DEBUG, m6, "dive into natpt_in6.");

    ip6 = mtod(m6, struct ip6_hdr *);

    cand.s6_addr32[0] = ip6->ip6_dst.s6_addr32[0] & natpt_prefixmask.s6_addr32[0];
    cand.s6_addr32[1] = ip6->ip6_dst.s6_addr32[1] & natpt_prefixmask.s6_addr32[1];
    cand.s6_addr32[2] = ip6->ip6_dst.s6_addr32[2] & natpt_prefixmask.s6_addr32[2];
    cand.s6_addr32[3] = ip6->ip6_dst.s6_addr32[3] & natpt_prefixmask.s6_addr32[3];

    if ((cand.s6_addr32[0] != natpt_prefix.s6_addr32[0])
	|| (cand.s6_addr32[1] != natpt_prefix.s6_addr32[1])
	|| (cand.s6_addr32[2] != natpt_prefix.s6_addr32[2])
	|| (cand.s6_addr32[3] != natpt_prefix.s6_addr32[3]))
    {
	if (isDump(D_IN6REJECT))
	    natpt_logMBuf(LOG_DEBUG, m6, "v6 translation rejected.");

	return (IPPROTO_IP);			/* goto mcastcheck	*/
    }

    if (isDump(D_IN6ACCEPT))
	natpt_logMBuf(LOG_DEBUG, m6, "v6 translation start.");

    ifnet = m6->m_pkthdr.rcvif;
    for (p = ifBox; p; p = CDR(p))
    {
	ifb = (struct ifBox *)CAR(p);
	if (ifb->ifnet == ifnet)
	{
	    if (ifb->side == outSide)
		rv = natpt_incomingIPv6(NATPT_INBOUND,	m6, m4);
	    else
		rv = natpt_outgoingIPv6(NATPT_OUTBOUND, m6, m4);
	    goto    exit;
	}
    }

  exit:;
    return (rv);
}


int
natpt_out4(struct mbuf *m4, struct mbuf **m6)
{
    Cell	    *p;
    struct ifnet    *ifnet;
    struct ifBox    *ifb;
    int		     rv = IPPROTO_IP;

    ifnet = m4->m_pkthdr.rcvif;
    for (p = ifBox; p; p = CDR(p))
    {
	ifb = (struct ifBox *)CAR(p);
	if (ifb->ifnet == ifnet)
	{
	    if (ifb->side == outSide)
		rv = natpt_outgoingIPv4(NATPT_OUTBOUND, m4, m6);
	    else
		rv = natpt_incomingIPv4(NATPT_INBOUND,	m4, m6);
	    goto    exit;
	}
    }

  exit:;
    return (rv);
}


int
natpt_out6(struct mbuf *m6, struct mbuf **m4)
{
    Cell	    *p;
    struct ifnet    *ifnet;
    struct ifBox    *ifb;
    int		     rv = IPPROTO_IP;

    ifnet = m6->m_pkthdr.rcvif;
    for (p = ifBox; p; p = CDR(p))
    {
	ifb = (struct ifBox *)CAR(p);
	if (ifb->ifnet == ifnet)
	{
	    if (ifb->side == outSide)
		rv = natpt_outgoingIPv6(NATPT_OUTBOUND, m6, m4);
	    else
		rv = natpt_incomingIPv6(NATPT_INBOUND,	m6, m4);
	    goto    exit;
	}
    }

  exit:;
    return (rv);
}


int
natpt_incomingIPv4(int sess, struct mbuf *m4, struct mbuf **m6)
{
    int			 rv;
    struct _cv		 cv;
    struct _cSlot	*acs;
    struct _tSlot	*ats;

    if ((rv = configCv4(sess, m4, &cv)) == IPPROTO_MAX)
	return (IPPROTO_MAX);				/* discard this packet	*/

    if ((rv = sanityCheckIn4(&cv)) != IPPROTO_IPV4)
	return (IPPROTO_DONE);		/* discard this packet without free	*/

    cv.ats = lookingForIncomingV4Hash(&cv);
    if ((ats = checkTraceroute6Return(&cv)) != NULL)
	cv.ats = ats;

    if (cv.ats == NULL)
    {
	if ((acs = lookingForIncomingV4Rule(&cv)) == NULL)
	    return (IPPROTO_IP);			/* goto ours		*/

	if ((cv.ats = internIncomingV4Hash(sess, acs, &cv)) == NULL)
	    return (IPPROTO_IP);			/* goto ours		*/
    }

    if (checkMTU(&cv) != IPPROTO_IPV4)
	return (IPPROTO_DONE);		/* discard this packet without free	*/

#ifdef NATPT_NAT
    if (cv.ats->local.sa_family == AF_INET)
    {
	if ((*m6 = translatingIPv4To4(&cv, &cv.ats->local)) != NULL)
	    return (IPPROTO_IPV4);
    }
    else
#endif
    {
	if ((*m6 = translatingIPv4To6(&cv, &cv.ats->local)) != NULL)
	    return (IPPROTO_IPV6);
    }

    return (IPPROTO_MAX);				/* discard this packet	*/
}


int
natpt_outgoingIPv4(int sess, struct mbuf *m4, struct mbuf **m6)
{
    int			 rv;
    struct _cv		 cv;
    struct _cSlot	*acs;
    struct ip		*ip4;

    if ((rv = configCv4(sess, m4, &cv)) == IPPROTO_MAX)
	return (IPPROTO_MAX);				/* discard this packet	*/

    if ((cv.ats = lookingForOutgoingV4Hash(&cv)) == NULL)
    {
	if ((acs = lookingForOutgoingV4Rule(&cv)) == NULL)
	    return (IPPROTO_IP);			/* goto ours		*/

	ip4 = mtod(m4, struct ip *);
	if (ip4->ip_ttl <= IPTTLDEC)
	{
	    n_long	dest = 0;

	    icmp_error(m4, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest, 0);
	    return (IPPROTO_MAX);			/* discard this packet	*/
	}
	
	if ((cv.ats = internOutgoingV4Hash(sess, acs, &cv)) == NULL)
	    return (IPPROTO_IP);			/* goto ours		*/
    }

#ifdef NATPT_NAT
    if (cv.ats->remote.sa_family == AF_INET)
    {
	if ((*m6 = translatingIPv4To4(&cv, &cv.ats->remote)) != NULL)
	    return (IPPROTO_IPV4);
    }
    else
#endif
    {
	if ((*m6 = translatingIPv4To6(&cv, &cv.ats->remote)) != NULL)
	    return (IPPROTO_IPV6);
    }

    return (IPPROTO_MAX);				/* discard this packet	*/
}


int
natpt_incomingIPv6(int sess, struct mbuf *m6, struct mbuf **m4)
{
    int			 rv;
    struct _cv		 cv;
    struct _cSlot	*acs;
    struct ip6_hdr	*ip6;

    rv = configCv6(sess, m6, &cv);
    if ((rv == IPPROTO_IP) || (rv == IPPROTO_MAX) || (rv == IPPROTO_DONE))
	return (rv);

    if ((cv.ats = lookingForIncomingV6Hash(&cv)) == NULL)
    {
	if ((acs = lookingForIncomingV6Rule(&cv)) == NULL)
	    return (IPPROTO_IP);			/* goto mcastcheck	*/

	ip6 = mtod(m6, struct ip6_hdr *);
	if (ip6->ip6_hlim <= IPV6_HLIMDEC)
	{
	    icmp6_error(m6, ICMP6_TIME_EXCEEDED, ICMP6_TIME_EXCEED_TRANSIT, 0);
	    return (IPPROTO_MAX);			/* discard this packet	*/
	}

	if ((cv.ats = internIncomingV6Hash(sess, acs, &cv)) == NULL)
	    return (IPPROTO_IP);			/* goto mcastcheck	*/
    }

    if ((*m4 = translatingIPv6To4(&cv, &cv.ats->local)) != NULL)
	return (IPPROTO_IPV4);

    return (IPPROTO_MAX);				/* discard this packet	*/
}


int
natpt_outgoingIPv6(int sess, struct mbuf *m6, struct mbuf **m4)
{
    int			 rv;
    struct _cv		 cv6;
    struct _cSlot	*acs;

    rv = configCv6(sess, m6, &cv6);
    if ((rv == IPPROTO_IP) || (rv == IPPROTO_MAX) || (rv == IPPROTO_DONE))
	return (rv);

    if ((rv = sanityCheckOut6(&cv6)) != IPPROTO_IPV6)
	return (IPPROTO_DONE);				/* discard this packet	*/

    if (isDump(D_PEEKOUTGOINGV6))
	natpt_logIp6(LOG_DEBUG, cv6._ip._ip6);

    if ((cv6.ats = lookingForOutgoingV6Hash(&cv6)) == NULL)
    {
	if ((acs = lookingForOutgoingV6Rule(&cv6)) == NULL)
	    return (IPPROTO_IP);			/* goto mcastcheck	*/

	if ((cv6.ats = internOutgoingV6Hash(sess, acs, &cv6)) == NULL)
	    return (IPPROTO_IP);			/* goto mcastcheck	*/
    }

    if ((*m4 = translatingIPv6To4(&cv6, &cv6.ats->remote)) != NULL)
	return (IPPROTO_IPV4);

    return (IPPROTO_MAX);				/* discard this packet	*/
}


int
configCv4(int sess, struct mbuf *m, struct _cv *cv)
{
    struct ip	*ip = mtod(m, struct ip *);

    bzero(cv, sizeof(struct _cv));
    cv->ip_p = ip->ip_p;
    cv->m = m;
    cv->_ip._ip4 = ip;
    cv->inout  = sess;

    switch (ip->ip_p)
    {
      case IPPROTO_ICMP:
      case IPPROTO_TCP:
      case IPPROTO_UDP:
	cv->ip_payload = ip->ip_p;
	cv->_payload._caddr = (caddr_t)((u_long *)ip + ip->ip_hl);
	cv->poff = cv->_payload._caddr - (caddr_t)cv->_ip._ip4;
	cv->plen = (caddr_t)m->m_data + m->m_len - cv->_payload._caddr;
	return (ip->ip_p);
    }

    return (IPPROTO_MAX);
}


int
configCv6(int sess, struct mbuf *m, struct _cv *cv)
{
    int			 proto;
    int			 offset;
    caddr_t		 tcpudp;

    bzero(cv, sizeof(struct _cv));
    cv->m = m;
    cv->_ip._ip6 = mtod(m, struct ip6_hdr *);
    cv->inout  = sess;

    if ((tcpudp = foundFinalPayload(m, &proto, &offset)))
    {
	switch (proto)
	{
	  case IPPROTO_ICMP:
	  case IPPROTO_ICMPV6:
	  case IPPROTO_TCP:
	  case IPPROTO_UDP:
	    cv->ip_p = proto;
	    cv->ip_payload = proto;
	    if (proto == IPPROTO_ICMPV6)
		cv->ip_payload = IPPROTO_ICMP;
	    cv->_payload._caddr = tcpudp;	
	    cv->poff = offset;
	    cv->plen = (caddr_t)m->m_data + m->m_len - cv->_payload._caddr;
	    return (proto);
	}
    }

    return (proto);
}


caddr_t
foundFinalPayload(struct mbuf *m, int *proto, int *offset)
{
    int			 nxt;
    int			 off;
    struct ip6_hdr	*ip6;
    struct ip6_ext	*ip6ext;

    ip6 = mtod(m, struct ip6_hdr *);
    nxt = ip6->ip6_nxt;
    off = sizeof(struct ip6_hdr);
    ip6ext = (struct ip6_ext *)((struct ip6_hdr *)(ip6 + 1));
    while (nxt != IPPROTO_NONE && off + sizeof(*ip6ext) < m->m_len)
    {
	switch (nxt)
	{
	  case IPPROTO_HOPOPTS:
	  case IPPROTO_ROUTING:
#if 0
	  case IPPROTO_FRAGMENT:
#endif
	  case IPPROTO_DSTOPTS:
	    nxt = ip6ext->ip6e_nxt;
	    off += ip6ext->ip6e_len;
	    ip6ext = (struct ip6_ext *)(((caddr_t)ip6ext) + ip6ext->ip6e_len);
	    break;

	  case IPPROTO_ICMPV6:
	  case IPPROTO_TCP:
	  case IPPROTO_UDP:
	    *proto = nxt;
	    *offset = off;
	    return ((caddr_t)ip6ext);

	  default:
	    *proto = IPPROTO_IP;			/* goto mcastcheck	*/
	    *offset = off;
	    return (NULL);
	}
    }

    *proto = IPPROTO_IP;				/* goto mcastcheck	*/
    *offset = off;
    return (NULL);
}


int
sanityCheckIn4(struct _cv *cv4)
{
    struct mbuf	*m4  = cv4->m;
    struct ip	*ip4 = mtod(m4, struct ip *);

    if (ip4->ip_ttl <= IPTTLDEC)
    {
	n_long	dest = 0;

	icmp_error(m4, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest, 0);
	return (IPPROTO_DONE);		/* discard this packet without free	*/
    }

    return (IPPROTO_IPV4);
}


int
sanityCheckOut6(struct _cv *cv6)
{
    struct mbuf		*m6 = cv6->m;
    struct ip6_hdr	*ip6 = mtod(m6, struct ip6_hdr *);

    if (ip6->ip6_hlim <= IPV6_HLIMDEC)
    {
	icmp6_error(m6, ICMP6_TIME_EXCEEDED, ICMP6_TIME_EXCEED_TRANSIT, 0);
	return (IPPROTO_DONE);			/* discard this packet	*/
    }

    return (IPPROTO_IPV6);
}


int
checkMTU(struct _cv *cv4)
{
    int		 mmtu;
    struct mbuf	*m4  = cv4->m;
    struct ip	*ip4 = mtod(m4, struct ip *);

    mmtu = IPV6_MMTU - sizeof(struct ip6_hdr) - sizeof(struct ip6_frag);
						/* This should be 1232[byte]	*/

    if ((m4->m_flags & M_PKTHDR)
	&& (m4->m_pkthdr.len >= mmtu))
    {
	if (ip4->ip_off & IP_DF)
	{
	    n_long		dest = 0;
	    struct ifnet	destif;

	    bzero(&destif, sizeof(struct ifnet));
	    destif.if_mtu = mmtu;

#ifdef fixSuMiReICMPBug
	    ip4->ip_dst.s_addr = IPDST;					/* XXX	*/
#endif

	    icmp_error(m4, ICMP_UNREACH, ICMP_UNREACH_NEEDFRAG, dest, &destif);
	    return (IPPROTO_DONE);	/* discard this packet without free	*/
	}
	
	cv4->flags |= NATPT_NEEDFRAGMENT;	/* fragment, then translate	*/
    }

    return (IPPROTO_IPV4);
}


/*
 *
 */


struct ifBox *
natpt_asIfBox(char *ifName)
{
    Cell	*p;

    for (p = ifBox; p; p = CDR(p))
    {
      if (strcmp(ifName, ((struct ifBox *)CAR(p))->ifName) == SAME)
	return ((struct ifBox *)CAR(p));
    }

    return (NULL);
}


struct ifBox *
natpt_setIfBox(char *ifName)
{
    struct ifnet	*p;
    struct ifBox	*q;
    char		 Wow[IFNAMSIZ];

#if defined(__bsdi__) || (defined(__FreeBSD__) && __FreeBSD__ < 3)
    for (p = ifnet; p; p = p->if_next)
#else
    for (p = TAILQ_FIRST(&ifnet); p; p = TAILQ_NEXT(p, if_list))
#endif
    {
#ifdef __NetBSD__
	sprintf(Wow, "%s%c",  p->if_xname, '\0');
#else
	sprintf(Wow, "%s%d%c", p->if_name, p->if_unit, '\0');
#endif
	if (strcmp(ifName, Wow) != SAME)
	    continue;

	natpt_ip6src = p;

	MALLOC(q, struct ifBox *, sizeof(struct ifBox), M_NATPT, M_WAITOK);
	bzero(q, sizeof(struct ifBox));

	q->ifnet = p;
#ifdef __NetBSD__
	sprintf(q->ifName, "%s%c",  p->if_xname, '\0');
#else
	sprintf(q->ifName, "%s%d%c", p->if_name, p->if_unit, '\0');
#endif

	LST_hookup_list((Cell**)&ifBox, q);
	return (q);
    }
    return (NULL);
}


/*
 *
 */

void
natpt_debugProbe()
{
    printf("DebugProbe");
}


void
natpt_assert(const char *file, int line, const char *failedexpr)
{
    (void)printf("natpt assertion \"%s\" failed: file \"%s\", line %d\n",
		 failedexpr, file, line);
    panic("natpt assertion");
    /* NOTREACHED */
}


/*
 *
 */

void
natpt_initialize()
{
    struct ifnet	*ifn;
    struct ifaddr	*ifa;
    struct ifBox	*ibox;

    if (natpt_initialized)
	return;

    natpt_initialized = 1;

#if defined(__bsdi__) || (defined(__FreeBSD__) && __FreeBSD__ < 3)
    for (ifn = ifnet; ifn; ifn = ifn->if_next)
#else
    for (ifn = TAILQ_FIRST(&ifnet); ifn; ifn = TAILQ_NEXT(ifn, if_list))
#endif
    {
#if defined(__bsdi__) || (defined(__FreeBSD__) && __FreeBSD__ < 3)
	for (ifa = ifn->if_addrlist; ifa; ifa = ifa->ifa_next)
#else
	for (ifa = ifn->if_addrlist.tqh_first; ifa;
	     ifa = ifa->ifa_list.tqe_next)
#endif
	{
	    if (((ifa->ifa_addr->sa_family) == AF_INET)
		|| ((ifa->ifa_addr->sa_family) == AF_INET6))
	    {
		MALLOC(ibox, struct ifBox *, sizeof(struct ifBox), M_TEMP, M_WAITOK);
#ifdef __NetBSD__
		sprintf(ibox->ifName, "%s",  ifn->if_xname);
#else
		sprintf(ibox->ifName, "%s%d", ifn->if_name, ifn->if_unit);
#endif
		ibox->ifnet = ifn;
		ibox->side = NULL;
		LST_hookup_list(&ifBox, ibox);
		goto nextif;
	    }
	}
      nextif:
    }
}
Commit	Line	Data
1c79356b A	1	/* $KAME: natpt_dispatch.c,v 1.9 2000/03/25 07:23:54 sumikawa Exp $ */
	2
	3	/*
	4	* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
	5	* All rights reserved.
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	* 1. Redistributions of source code must retain the above copyright
	11	* notice, this list of conditions and the following disclaimer.
	12	* 2. Redistributions in binary form must reproduce the above copyright
	13	* notice, this list of conditions and the following disclaimer in the
	14	* documentation and/or other materials provided with the distribution.
	15	* 3. Neither the name of the project nor the names of its contributors
	16	* may be used to endorse or promote products derived from this software
	17	* without specific prior written permission.
	18	*
	19	* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
	20	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	21	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	22	* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
	23	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	24	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	25	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	26	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	27	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	28	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	29	* SUCH DAMAGE.
	30	*/
	31
	32	#include <sys/param.h>
	33	#include <sys/malloc.h>
	34	#include <sys/mbuf.h>
	35	#include <sys/socket.h>
	36	#include <sys/syslog.h>
	37	#include <sys/systm.h>
	38
	39	#ifdef __FreeBSD__
	40	# include <sys/kernel.h>
	41	#endif
	42
	43	#include <net/if.h>
	44	#include <net/net_osdep.h>
	45
	46	#include <netinet/in.h>
	47	#include <netinet/in_systm.h>
	48	#include <netinet/ip.h>
	49	#include <netinet/ip_icmp.h>
	50
	51	#include <netinet/ip6.h>
	52	#include <netinet6/ip6_var.h>
	53	#include <netinet/icmp6.h>
	54
	55	#include <netinet6/natpt_defs.h>
	56	#include <netinet6/natpt_list.h>
	57	#include <netinet6/natpt_log.h>
	58	#include <netinet6/natpt_var.h>
	59
	60
	61	/*
	62	*
	63	*/
	64
65	u_int natpt_debug;
66	u_int natpt_dump;
67
68	static struct _cell *ifBox;
69
70	struct ifnet *natpt_ip6src;
71
72	struct in6_addr faith_prefix
73	= {{{0x00000000, 0x00000000, 0x00000000, 0x00000000}}};
74	struct in6_addr faith_prefixmask
75	= {{{0x00000000, 0x00000000, 0x00000000, 0x00000000}}};
76	struct in6_addr natpt_prefix
77	= {{{0x00000000, 0x00000000, 0x00000000, 0x00000000}}};
78	struct in6_addr natpt_prefixmask
79	= {{{0x00000000, 0x00000000, 0x00000000, 0x00000000}}};
80
81	int natpt_in4 __P((struct mbuf , struct mbuf *));
82	int natpt_in6 __P((struct mbuf , struct mbuf *));
83	int natpt_out4 __P((struct mbuf , struct mbuf *));
84	int natpt_out6 __P((struct mbuf , struct mbuf *));
85	int natpt_incomingIPv4 __P((int, struct mbuf , struct mbuf *));
86	int natpt_outgoingIPv4 __P((int, struct mbuf , struct mbuf *));
87	int natpt_incomingIPv6 __P((int, struct mbuf , struct mbuf *));
88	int natpt_outgoingIPv6 __P((int, struct mbuf , struct mbuf *));
89
90	int configCv4 __P((int, struct mbuf , struct _cv ));
91	int configCv6 __P((int, struct mbuf , struct _cv ));
92	caddr_t foundFinalPayload __P((struct mbuf , int , int *));
93	int sanityCheckIn4 __P((struct _cv *));
94	int sanityCheckOut6 __P((struct _cv *));
95	int checkMTU __P((struct _cv *));
96
97
98	#if defined(__FreeBSD__) && __FreeBSD__ >= 3
99	static MALLOC_DEFINE(M_NATPT, "NATPT", "Network Address Translation - Protocol Translation");
100	#endif
101
102
103	/*
104	*
105	*/
106
107	int
108	natpt_in4(struct mbuf m4, struct mbuf *m6)
109	{
110	Cell *p;
111	struct ifnet *ifnet;
112	struct ifBox *ifb;
113	int rv = IPPROTO_IP;
114
115	if (natpt_initialized == 0)
116	return (IPPROTO_IP); /* goto ours */
117
118	if (isDump(D_DIVEIN4))
119	natpt_logMBuf(LOG_DEBUG, m4, "dive into natpt_in4.");
120
121	ifnet = m4->m_pkthdr.rcvif;
122	for (p = ifBox; p; p = CDR(p))
123	{
124	ifb = (struct ifBox *)CAR(p);
125	if (ifb->ifnet == ifnet)
126	{
127	if (ifb->side == outSide)
128	rv = natpt_incomingIPv4(NATPT_INBOUND, m4, m6);
129	else
130	rv = natpt_outgoingIPv4(NATPT_OUTBOUND, m4, m6);
131	goto exit;
132	}
133	}
134
135	exit:;
136	return (rv);
137	}
138
139
140	int
141	natpt_in6(struct mbuf m6, struct mbuf *m4)
142	{
143	Cell *p;
144	struct ifnet *ifnet;
145	struct ifBox *ifb;
146	struct ip6_hdr *ip6;
147	struct in6_addr cand;
148	int rv = IPPROTO_IP;
149
150	if (natpt_initialized == 0)
151	return (IPPROTO_IP); /* goto mcastcheck */
152
153	if (isDump(D_DIVEIN6))
154	natpt_logMBuf(LOG_DEBUG, m6, "dive into natpt_in6.");
155
156	ip6 = mtod(m6, struct ip6_hdr *);
157
158	cand.s6_addr32[0] = ip6->ip6_dst.s6_addr32[0] & natpt_prefixmask.s6_addr32[0];
159	cand.s6_addr32[1] = ip6->ip6_dst.s6_addr32[1] & natpt_prefixmask.s6_addr32[1];
160	cand.s6_addr32[2] = ip6->ip6_dst.s6_addr32[2] & natpt_prefixmask.s6_addr32[2];
161	cand.s6_addr32[3] = ip6->ip6_dst.s6_addr32[3] & natpt_prefixmask.s6_addr32[3];
162
163	if ((cand.s6_addr32[0] != natpt_prefix.s6_addr32[0])
164	\|\| (cand.s6_addr32[1] != natpt_prefix.s6_addr32[1])
165	\|\| (cand.s6_addr32[2] != natpt_prefix.s6_addr32[2])
166	\|\| (cand.s6_addr32[3] != natpt_prefix.s6_addr32[3]))
167	{
168	if (isDump(D_IN6REJECT))
169	natpt_logMBuf(LOG_DEBUG, m6, "v6 translation rejected.");
170
171	return (IPPROTO_IP); /* goto mcastcheck */
172	}
173
174	if (isDump(D_IN6ACCEPT))
175	natpt_logMBuf(LOG_DEBUG, m6, "v6 translation start.");
176
177	ifnet = m6->m_pkthdr.rcvif;
178	for (p = ifBox; p; p = CDR(p))
179	{
180	ifb = (struct ifBox *)CAR(p);
181	if (ifb->ifnet == ifnet)
182	{
183	if (ifb->side == outSide)
184	rv = natpt_incomingIPv6(NATPT_INBOUND, m6, m4);
185	else
186	rv = natpt_outgoingIPv6(NATPT_OUTBOUND, m6, m4);
187	goto exit;
188	}
189	}
190
191	exit:;
192	return (rv);
193	}
194
195
196	int
197	natpt_out4(struct mbuf m4, struct mbuf *m6)
198	{
199	Cell *p;
200	struct ifnet *ifnet;
201	struct ifBox *ifb;
202	int rv = IPPROTO_IP;
203
204	ifnet = m4->m_pkthdr.rcvif;
205	for (p = ifBox; p; p = CDR(p))
206	{
207	ifb = (struct ifBox *)CAR(p);
208	if (ifb->ifnet == ifnet)
209	{
210	if (ifb->side == outSide)
211	rv = natpt_outgoingIPv4(NATPT_OUTBOUND, m4, m6);
212	else
213	rv = natpt_incomingIPv4(NATPT_INBOUND, m4, m6);
214	goto exit;
215	}
216	}
217
218	exit:;
219	return (rv);
220	}
221
222
223
224	int
225	natpt_out6(struct mbuf m6, struct mbuf *m4)
226	{
227	Cell *p;
228	struct ifnet *ifnet;
229	struct ifBox *ifb;
230	int rv = IPPROTO_IP;
231
232	ifnet = m6->m_pkthdr.rcvif;
233	for (p = ifBox; p; p = CDR(p))
234	{
235	ifb = (struct ifBox *)CAR(p);
236	if (ifb->ifnet == ifnet)
237	{
238	if (ifb->side == outSide)
239	rv = natpt_outgoingIPv6(NATPT_OUTBOUND, m6, m4);
240	else
241	rv = natpt_incomingIPv6(NATPT_INBOUND, m6, m4);
242	goto exit;
243	}
244	}
245
246	exit:;
247	return (rv);
248	}
249
250
251	int
252	natpt_incomingIPv4(int sess, struct mbuf m4, struct mbuf *m6)
253	{
254	int rv;
255	struct _cv cv;
256	struct _cSlot *acs;
257	struct _tSlot *ats;
258
259	if ((rv = configCv4(sess, m4, &cv)) == IPPROTO_MAX)
260	return (IPPROTO_MAX); /* discard this packet */
261
262	if ((rv = sanityCheckIn4(&cv)) != IPPROTO_IPV4)
263	return (IPPROTO_DONE); /* discard this packet without free */
264
265	cv.ats = lookingForIncomingV4Hash(&cv);
266	if ((ats = checkTraceroute6Return(&cv)) != NULL)
267	cv.ats = ats;
268
269	if (cv.ats == NULL)
270	{
271	if ((acs = lookingForIncomingV4Rule(&cv)) == NULL)
272	return (IPPROTO_IP); /* goto ours */
273
274	if ((cv.ats = internIncomingV4Hash(sess, acs, &cv)) == NULL)
275	return (IPPROTO_IP); /* goto ours */
276	}
277
278	if (checkMTU(&cv) != IPPROTO_IPV4)
279	return (IPPROTO_DONE); /* discard this packet without free */
280
281	#ifdef NATPT_NAT
282	if (cv.ats->local.sa_family == AF_INET)
283	{
284	if ((*m6 = translatingIPv4To4(&cv, &cv.ats->local)) != NULL)
285	return (IPPROTO_IPV4);
286	}
287	else
288	#endif
289	{
290	if ((*m6 = translatingIPv4To6(&cv, &cv.ats->local)) != NULL)
291	return (IPPROTO_IPV6);
292	}
293
294	return (IPPROTO_MAX); /* discard this packet */
295	}
296
297
298	int
299	natpt_outgoingIPv4(int sess, struct mbuf m4, struct mbuf *m6)
300	{
301	int rv;
302	struct _cv cv;
303	struct _cSlot *acs;
304	struct ip *ip4;
305
306	if ((rv = configCv4(sess, m4, &cv)) == IPPROTO_MAX)
307	return (IPPROTO_MAX); /* discard this packet */
308
309	if ((cv.ats = lookingForOutgoingV4Hash(&cv)) == NULL)
310	{
311	if ((acs = lookingForOutgoingV4Rule(&cv)) == NULL)
312	return (IPPROTO_IP); /* goto ours */
313
314	ip4 = mtod(m4, struct ip *);
315	if (ip4->ip_ttl <= IPTTLDEC)
316	{
317	n_long dest = 0;
318
319	icmp_error(m4, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest, 0);
320	return (IPPROTO_MAX); /* discard this packet */
321	}
322
323	if ((cv.ats = internOutgoingV4Hash(sess, acs, &cv)) == NULL)
324	return (IPPROTO_IP); /* goto ours */
325	}
326
327	#ifdef NATPT_NAT
328	if (cv.ats->remote.sa_family == AF_INET)
329	{
330	if ((*m6 = translatingIPv4To4(&cv, &cv.ats->remote)) != NULL)
331	return (IPPROTO_IPV4);
332	}
333	else
334	#endif
335	{
336	if ((*m6 = translatingIPv4To6(&cv, &cv.ats->remote)) != NULL)
337	return (IPPROTO_IPV6);
338	}
339
340	return (IPPROTO_MAX); /* discard this packet */
341	}
342
343
344	int
345	natpt_incomingIPv6(int sess, struct mbuf m6, struct mbuf *m4)
346	{
347	int rv;
348	struct _cv cv;
349	struct _cSlot *acs;
350	struct ip6_hdr *ip6;
351
352	rv = configCv6(sess, m6, &cv);
353	if ((rv == IPPROTO_IP) \|\| (rv == IPPROTO_MAX) \|\| (rv == IPPROTO_DONE))
354	return (rv);
355
356	if ((cv.ats = lookingForIncomingV6Hash(&cv)) == NULL)
357	{
358	if ((acs = lookingForIncomingV6Rule(&cv)) == NULL)
359	return (IPPROTO_IP); /* goto mcastcheck */
360
361	ip6 = mtod(m6, struct ip6_hdr *);
362	if (ip6->ip6_hlim <= IPV6_HLIMDEC)
363	{
364	icmp6_error(m6, ICMP6_TIME_EXCEEDED, ICMP6_TIME_EXCEED_TRANSIT, 0);
365	return (IPPROTO_MAX); /* discard this packet */
366	}
367
368	if ((cv.ats = internIncomingV6Hash(sess, acs, &cv)) == NULL)
369	return (IPPROTO_IP); /* goto mcastcheck */
370	}
371
372	if ((*m4 = translatingIPv6To4(&cv, &cv.ats->local)) != NULL)
373	return (IPPROTO_IPV4);
374
375	return (IPPROTO_MAX); /* discard this packet */
376	}
377
378
379	int
380	natpt_outgoingIPv6(int sess, struct mbuf m6, struct mbuf *m4)
381	{
382	int rv;
383	struct _cv cv6;
384	struct _cSlot *acs;
385
386	rv = configCv6(sess, m6, &cv6);
387	if ((rv == IPPROTO_IP) \|\| (rv == IPPROTO_MAX) \|\| (rv == IPPROTO_DONE))
388	return (rv);
389
390	if ((rv = sanityCheckOut6(&cv6)) != IPPROTO_IPV6)
391	return (IPPROTO_DONE); /* discard this packet */
392
393	if (isDump(D_PEEKOUTGOINGV6))
394	natpt_logIp6(LOG_DEBUG, cv6._ip._ip6);
395
396	if ((cv6.ats = lookingForOutgoingV6Hash(&cv6)) == NULL)
397	{
398	if ((acs = lookingForOutgoingV6Rule(&cv6)) == NULL)
399	return (IPPROTO_IP); /* goto mcastcheck */
400
401	if ((cv6.ats = internOutgoingV6Hash(sess, acs, &cv6)) == NULL)
402	return (IPPROTO_IP); /* goto mcastcheck */
403	}
404
405	if ((*m4 = translatingIPv6To4(&cv6, &cv6.ats->remote)) != NULL)
406	return (IPPROTO_IPV4);
407
408	return (IPPROTO_MAX); /* discard this packet */
409	}
410
411
412	int
413	configCv4(int sess, struct mbuf m, struct _cv cv)
414	{
415	struct ip ip = mtod(m, struct ip );
416
417	bzero(cv, sizeof(struct _cv));
418	cv->ip_p = ip->ip_p;
419	cv->m = m;
420	cv->_ip._ip4 = ip;
421	cv->inout = sess;
422
423	switch (ip->ip_p)
424	{
425	case IPPROTO_ICMP:
426	case IPPROTO_TCP:
427	case IPPROTO_UDP:
428	cv->ip_payload = ip->ip_p;
429	cv->_payload._caddr = (caddr_t)((u_long *)ip + ip->ip_hl);
430	cv->poff = cv->_payload._caddr - (caddr_t)cv->_ip._ip4;
431	cv->plen = (caddr_t)m->m_data + m->m_len - cv->_payload._caddr;
432	return (ip->ip_p);
433	}
434
435	return (IPPROTO_MAX);
436	}
437
438
439	int
440	configCv6(int sess, struct mbuf m, struct _cv cv)
441	{
442	int proto;
443	int offset;
444	caddr_t tcpudp;
445
446	bzero(cv, sizeof(struct _cv));
447	cv->m = m;
448	cv->_ip._ip6 = mtod(m, struct ip6_hdr *);
449	cv->inout = sess;
450
451	if ((tcpudp = foundFinalPayload(m, &proto, &offset)))
452	{
453	switch (proto)
454	{
455	case IPPROTO_ICMP:
456	case IPPROTO_ICMPV6:
457	case IPPROTO_TCP:
458	case IPPROTO_UDP:
459	cv->ip_p = proto;
460	cv->ip_payload = proto;
461	if (proto == IPPROTO_ICMPV6)
462	cv->ip_payload = IPPROTO_ICMP;
463	cv->_payload._caddr = tcpudp;
464	cv->poff = offset;
465	cv->plen = (caddr_t)m->m_data + m->m_len - cv->_payload._caddr;
466	return (proto);
467	}
468	}
469
470	return (proto);
471	}
472
473
474	caddr_t
475	foundFinalPayload(struct mbuf m, int proto, int *offset)
476	{
477	int nxt;
478	int off;
479	struct ip6_hdr *ip6;
480	struct ip6_ext *ip6ext;
481
482	ip6 = mtod(m, struct ip6_hdr *);
483	nxt = ip6->ip6_nxt;
484	off = sizeof(struct ip6_hdr);
485	ip6ext = (struct ip6_ext )((struct ip6_hdr )(ip6 + 1));
486	while (nxt != IPPROTO_NONE && off + sizeof(*ip6ext) < m->m_len)
487	{
488	switch (nxt)
489	{
490	case IPPROTO_HOPOPTS:
491	case IPPROTO_ROUTING:
492	#if 0
493	case IPPROTO_FRAGMENT:
494	#endif
495	case IPPROTO_DSTOPTS:
496	nxt = ip6ext->ip6e_nxt;
497	off += ip6ext->ip6e_len;
498	ip6ext = (struct ip6_ext *)(((caddr_t)ip6ext) + ip6ext->ip6e_len);
499	break;
500
501	case IPPROTO_ICMPV6:
502	case IPPROTO_TCP:
503	case IPPROTO_UDP:
504	*proto = nxt;
505	*offset = off;
506	return ((caddr_t)ip6ext);
507
508	default:
509	proto = IPPROTO_IP; / goto mcastcheck */
510	*offset = off;
511	return (NULL);
512	}
513	}
514
515	proto = IPPROTO_IP; / goto mcastcheck */
516	*offset = off;
517	return (NULL);
518	}
519
520
521	int
522	sanityCheckIn4(struct _cv *cv4)
523	{
524	struct mbuf *m4 = cv4->m;
525	struct ip ip4 = mtod(m4, struct ip );
526
527	if (ip4->ip_ttl <= IPTTLDEC)
528	{
529	n_long dest = 0;
530
531	icmp_error(m4, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest, 0);
532	return (IPPROTO_DONE); /* discard this packet without free */
533	}
534
535	return (IPPROTO_IPV4);
536	}
537
538
539	int
540	sanityCheckOut6(struct _cv *cv6)
541	{
542	struct mbuf *m6 = cv6->m;
543	struct ip6_hdr ip6 = mtod(m6, struct ip6_hdr );
544
545	if (ip6->ip6_hlim <= IPV6_HLIMDEC)
546	{
547	icmp6_error(m6, ICMP6_TIME_EXCEEDED, ICMP6_TIME_EXCEED_TRANSIT, 0);
548	return (IPPROTO_DONE); /* discard this packet */
549	}
550
551	return (IPPROTO_IPV6);
552	}
553
554
555	int
556	checkMTU(struct _cv *cv4)
557	{
558	int mmtu;
559	struct mbuf *m4 = cv4->m;
560	struct ip ip4 = mtod(m4, struct ip );
561
562	mmtu = IPV6_MMTU - sizeof(struct ip6_hdr) - sizeof(struct ip6_frag);
563	/* This should be 1232[byte] */
564
565	if ((m4->m_flags & M_PKTHDR)
566	&& (m4->m_pkthdr.len >= mmtu))
567	{
568	if (ip4->ip_off & IP_DF)
569	{
570	n_long dest = 0;
571	struct ifnet destif;
572
573	bzero(&destif, sizeof(struct ifnet));
574	destif.if_mtu = mmtu;
575
576	#ifdef fixSuMiReICMPBug
577	ip4->ip_dst.s_addr = IPDST; /* XXX */
578	#endif
579
580	icmp_error(m4, ICMP_UNREACH, ICMP_UNREACH_NEEDFRAG, dest, &destif);
581	return (IPPROTO_DONE); /* discard this packet without free */
582	}
583
584	cv4->flags \|= NATPT_NEEDFRAGMENT; /* fragment, then translate */
585	}
586
587	return (IPPROTO_IPV4);
588	}
589
590
591	/*
592	*
593	*/
594
595
596	struct ifBox *
597	natpt_asIfBox(char *ifName)
598	{
599	Cell *p;
600
601	for (p = ifBox; p; p = CDR(p))
602	{
603	if (strcmp(ifName, ((struct ifBox *)CAR(p))->ifName) == SAME)
604	return ((struct ifBox *)CAR(p));
605	}
606
607	return (NULL);
608	}
609
610
611	struct ifBox *
612	natpt_setIfBox(char *ifName)
613	{
614	struct ifnet *p;
615	struct ifBox *q;
616	char Wow[IFNAMSIZ];
617
618	#if defined(__bsdi__) \|\| (defined(__FreeBSD__) && __FreeBSD__ < 3)
619	for (p = ifnet; p; p = p->if_next)
620	#else
621	for (p = TAILQ_FIRST(&ifnet); p; p = TAILQ_NEXT(p, if_list))
622	#endif
623	{
624	#ifdef __NetBSD__
625	sprintf(Wow, "%s%c", p->if_xname, '\0');
626	#else
627	sprintf(Wow, "%s%d%c", p->if_name, p->if_unit, '\0');
628	#endif
629	if (strcmp(ifName, Wow) != SAME)
630	continue;
631
632	natpt_ip6src = p;
633
634	MALLOC(q, struct ifBox *, sizeof(struct ifBox), M_NATPT, M_WAITOK);
635	bzero(q, sizeof(struct ifBox));
636
637	q->ifnet = p;
638	#ifdef __NetBSD__
639	sprintf(q->ifName, "%s%c", p->if_xname, '\0');
640	#else
641	sprintf(q->ifName, "%s%d%c", p->if_name, p->if_unit, '\0');
642	#endif
643
644	LST_hookup_list((Cell**)&ifBox, q);
645	return (q);
646	}
647	return (NULL);
648	}
649
650
651	/*
652	*
653	*/
654
655	void
656	natpt_debugProbe()
657	{
658	printf("DebugProbe");
659	}
660
661
662	void
663	natpt_assert(const char file, int line, const char failedexpr)
664	{
665	(void)printf("natpt assertion \"%s\" failed: file \"%s\", line %d\n",
666	failedexpr, file, line);
667	panic("natpt assertion");
668	/* NOTREACHED */
669	}
670
671
672	/*
673	*
674	*/
675
676	void
677	natpt_initialize()
678	{
679	struct ifnet *ifn;
680	struct ifaddr *ifa;
681	struct ifBox *ibox;
682
683	if (natpt_initialized)
684	return;
685
686	natpt_initialized = 1;
687
688	#if defined(__bsdi__) \|\| (defined(__FreeBSD__) && __FreeBSD__ < 3)
689	for (ifn = ifnet; ifn; ifn = ifn->if_next)
690	#else
691	for (ifn = TAILQ_FIRST(&ifnet); ifn; ifn = TAILQ_NEXT(ifn, if_list))
692	#endif
693	{
694	#if defined(__bsdi__) \|\| (defined(__FreeBSD__) && __FreeBSD__ < 3)
695	for (ifa = ifn->if_addrlist; ifa; ifa = ifa->ifa_next)
696	#else
697	for (ifa = ifn->if_addrlist.tqh_first; ifa;
698	ifa = ifa->ifa_list.tqe_next)
699	#endif
700	{
701	if (((ifa->ifa_addr->sa_family) == AF_INET)
702	\|\| ((ifa->ifa_addr->sa_family) == AF_INET6))
703	{
704	MALLOC(ibox, struct ifBox *, sizeof(struct ifBox), M_TEMP, M_WAITOK);
705	#ifdef __NetBSD__
706	sprintf(ibox->ifName, "%s", ifn->if_xname);
707	#else
708	sprintf(ibox->ifName, "%s%d", ifn->if_name, ifn->if_unit);
709	#endif
710	ibox->ifnet = ifn;
711	ibox->side = NULL;
712	LST_hookup_list(&ifBox, ibox);
713	goto nextif;
714	}
715	}
716	nextif:
717	}
718	}