fix conflicts

2 files changed, 746 insertions, 258 deletions

diff --git a/sys/contrib/ipfilter/netinet/ip_state.c b/sys/contrib/ipfilter/netinet/ip_state.c
index 253f998..8309afe 100644
--- a/sys/contrib/ipfilter/netinet/ip_state.c
+++ b/sys/contrib/ipfilter/netinet/ip_state.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-1998 by Darren Reed.
+ * Copyright (C) 1995-2000 by Darren Reed.
  *
  * Redistribution and use in source and binary forms are permitted
  * provided that this notice is preserved and due credit is given
@@ -9,6 +9,8 @@
 static const char sccsid[] = "@(#)ip_state.c	1.8 6/5/96 (C) 1993-1995 Darren Reed";
 /*static const char rcsid[] = "@(#)$Id: ip_state.c,v 2.3.2.18 2000/01/27 08:51:30 darrenr Exp $";*/
 static const char rcsid[] = "@(#)$FreeBSD$";
+static const char sccsid[] = "@(#)ip_state.c	1.8 6/5/96 (C) 1993-2000 Darren Reed";
+static const char rcsid[] = "@(#)$Id: ip_state.c,v 2.30.2.9 2000/05/22 10:26:15 darrenr Exp $";
 #endif
 
 #include <sys/errno.h>
@@ -19,6 +21,10 @@ static const char rcsid[] = "@(#)$FreeBSD$";
     defined(_KERNEL)
 # include "opt_ipfilter_log.h"
 #endif
+#if defined(_KERNEL) && defined(__FreeBSD_version) && \
+    (__FreeBSD_version >= 400000) && !defined(KLD_MODULE)
+#include "opt_inet6.h"
+#endif
 #if !defined(_KERNEL) && !defined(KERNEL) && !defined(__KERNEL__)
 # include <stdio.h>
 # include <stdlib.h>
@@ -29,7 +35,7 @@ static const char rcsid[] = "@(#)$FreeBSD$";
 #  include <linux/module.h>
 # endif
 #endif
-#if defined(_KERNEL) && (__FreeBSD_version >= 220000)
+#if (defined(KERNEL) || defined(_KERNEL)) && (__FreeBSD_version >= 220000)
 # include <sys/filio.h>
 # include <sys/fcntl.h>
 # if (__FreeBSD_version >= 300000) && !defined(IPFILTER_LKM)
@@ -83,6 +89,9 @@ static const char rcsid[] = "@(#)$FreeBSD$";
 #include "netinet/ip_frag.h"
 #include "netinet/ip_proxy.h"
 #include "netinet/ip_state.h"
+#ifdef	USE_INET6
+#include <netinet/icmp6.h>
+#endif
 #if (__FreeBSD_version >= 300000)
 # include <sys/malloc.h>
 # if (defined(_KERNEL) || defined(KERNEL)) && !defined(IPFILTER_LKM)
@@ -97,20 +106,29 @@ static const char rcsid[] = "@(#)$FreeBSD$";
 
 #define	TCP_CLOSE	(TH_FIN|TH_RST)
 
-ipstate_t **ips_table = NULL;
-int	ips_num = 0;
-ips_stat_t ips_stats;
+static ipstate_t **ips_table = NULL;
+static ipstate_t *ips_list = NULL;
+static int	ips_num = 0;
+static ips_stat_t ips_stats;
 #if	(SOLARIS || defined(__sgi)) && defined(_KERNEL)
 extern	KRWLOCK_T	ipf_state, ipf_mutex;
 extern	kmutex_t	ipf_rw;
 #endif
 
-static int fr_matchsrcdst __P((ipstate_t *, struct in_addr, struct in_addr,
+#ifdef	USE_INET6
+static frentry_t *fr_checkicmp6matchingstate __P((ip6_t *, fr_info_t *));
+#endif
+static int fr_matchsrcdst __P((ipstate_t *, union i6addr, union i6addr,
 			       fr_info_t *, tcphdr_t *));
 static frentry_t *fr_checkicmpmatchingstate __P((ip_t *, fr_info_t *));
+static int fr_matchicmpqueryreply __P((int, ipstate_t *, icmphdr_t *));
 static int fr_state_flush __P((int));
 static ips_stat_t *fr_statetstats __P((void));
 static void fr_delstate __P((ipstate_t *));
+static int fr_state_remove __P((caddr_t));
+int fr_stputent __P((caddr_t));
+int fr_stgetent __P((caddr_t));
+void fr_stinsert __P((ipstate_t *));
 
 
 #define	FIVE_DAYS	(2 * 5 * 86400)	/* 5 days: half closed session */
@@ -125,16 +143,29 @@ u_long	fr_tcpidletimeout = FIVE_DAYS,
 	fr_icmptimeout = 120;
 int	fr_statemax = IPSTATE_MAX,
 	fr_statesize = IPSTATE_SIZE;
-int	fr_state_doflush = 0;
+int	fr_state_doflush = 0,
+	fr_state_lock = 0;
 
+static 	int icmpreplytype4[ICMP_MAXTYPE + 1];
 
 int fr_stateinit()
 {
+	int i;
+
 	KMALLOCS(ips_table, ipstate_t **, fr_statesize * sizeof(ipstate_t *));
 	if (ips_table != NULL)
 		bzero((char *)ips_table, fr_statesize * sizeof(ipstate_t *));
 	else
 		return -1;
+
+	/* fill icmp reply type table */
+	for (i = 0; i <= ICMP_MAXTYPE; i++)
+		icmpreplytype4[i] = -1;
+	icmpreplytype4[ICMP_ECHO] = ICMP_ECHOREPLY;
+	icmpreplytype4[ICMP_TSTAMP] = ICMP_TSTAMPREPLY;
+	icmpreplytype4[ICMP_IREQ] = ICMP_IREQREPLY;
+	icmpreplytype4[ICMP_MASKREQ] = ICMP_MASKREPLY;
+
 	return 0;
 }
 
@@ -143,6 +174,7 @@ static ips_stat_t *fr_statetstats()
 {
 	ips_stats.iss_active = ips_num;
 	ips_stats.iss_table = ips_table;
+	ips_stats.iss_list = ips_list;
 	return &ips_stats;
 }
 
@@ -156,7 +188,6 @@ static ips_stat_t *fr_statetstats()
 static int fr_state_flush(which)
 int which;
 {
-	register int i;
 	register ipstate_t *is, **isp;
 #if defined(_KERNEL) && !SOLARIS
 	int s;
@@ -164,48 +195,69 @@ int which;
 	int delete, removed = 0;
 
 	SPL_NET(s);
-	WRITE_ENTER(&ipf_state);
-	for (i = fr_statesize - 1; i >= 0; i--)
-		for (isp = &ips_table[i]; (is = *isp); ) {
-			delete = 0;
+	for (isp = &ips_list; (is = *isp); ) {
+		delete = 0;
 
-			switch (which)
-			{
-			case 0 :
-				delete = 1;
-				break;
-			case 1 :
-				if (is->is_p != IPPROTO_TCP)
-					break;
-				if ((is->is_state[0] != TCPS_ESTABLISHED) ||
-				    (is->is_state[1] != TCPS_ESTABLISHED))
-					delete = 1;
+		switch (which)
+		{
+		case 0 :
+			delete = 1;
+			break;
+		case 1 :
+			if (is->is_p != IPPROTO_TCP)
 				break;
-			}
+			if ((is->is_state[0] != TCPS_ESTABLISHED) ||
+			    (is->is_state[1] != TCPS_ESTABLISHED))
+				delete = 1;
+			break;
+		}
 
-			if (delete) {
-				*isp = is->is_next;
-				if (is->is_p == IPPROTO_TCP)
-					ips_stats.iss_fin++;
-				else
-					ips_stats.iss_expire++;
-				if (ips_table[i] == NULL)
-					ips_stats.iss_inuse--;
+		if (delete) {
+			if (is->is_p == IPPROTO_TCP)
+				ips_stats.iss_fin++;
+			else
+				ips_stats.iss_expire++;
 #ifdef	IPFILTER_LOG
-				ipstate_log(is, ISL_FLUSH);
+			ipstate_log(is, ISL_FLUSH);
 #endif
-				fr_delstate(is);
-				ips_num--;
-				removed++;
-			} else
-				isp = &is->is_next;
-		}
-	RWLOCK_EXIT(&ipf_state);
+			fr_delstate(is);
+			removed++;
+		} else
+			isp = &is->is_next;
+	}
 	SPL_X(s);
 	return removed;
 }
 
 
+static int fr_state_remove(data)
+caddr_t data;
+{
+	ipstate_t *sp, st;
+	int error;
+
+	sp = &st;
+	error = IRCOPYPTR(data, (caddr_t)&st, sizeof(st));
+	if (error)
+		return EFAULT;
+
+	for (sp = ips_list; sp; sp = sp->is_next)
+		if ((sp->is_p == st.is_p) && (sp->is_v == st.is_v) &&
+		    !bcmp(&sp->is_src, &st.is_src, sizeof(st.is_src)) &&
+		    !bcmp(&sp->is_dst, &st.is_src, sizeof(st.is_dst)) &&
+		    !bcmp(&sp->is_ps, &st.is_ps, sizeof(st.is_ps))) {
+			WRITE_ENTER(&ipf_state);
+#ifdef	IPFILTER_LOG
+			ipstate_log(sp, ISL_REMOVE);
+#endif
+			fr_delstate(sp);
+			RWLOCK_EXIT(&ipf_state);
+			return 0;
+		}
+	return ESRCH;
+}
+
+
 int fr_state_ioctl(data, cmd, mode)
 caddr_t data;
 #if defined(__NetBSD__) || defined(__OpenBSD__)
@@ -215,15 +267,22 @@ int cmd;
 #endif
 int mode;
 {
-	int	arg, ret, error = 0;
+	int arg, ret, error = 0;
 
 	switch (cmd)
 	{
+	case SIOCDELST :
+		error = fr_state_remove(data);
+		break;
 	case SIOCIPFFL :
-		IRCOPY(data, (caddr_t)&arg, sizeof(arg));
+		error = IRCOPY(data, (caddr_t)&arg, sizeof(arg));
+		if (error)
+			break;
 		if (arg == 0 || arg == 1) {
+			WRITE_ENTER(&ipf_state);
 			ret = fr_state_flush(arg);
-			IWCOPY((caddr_t)&ret, data, sizeof(ret));
+			RWLOCK_EXIT(&ipf_state);
+			error = IWCOPY((caddr_t)&ret, data, sizeof(ret));
 		} else
 			error = EINVAL;
 		break;
@@ -231,19 +290,41 @@ int mode;
 	case SIOCIPFFB :
 		if (!(mode & FWRITE))
 			error = EPERM;
-		else
-			*(int *)data = ipflog_clear(IPL_LOGSTATE);
+		else {
+			int tmp;
+
+			tmp = ipflog_clear(IPL_LOGSTATE);
+			IWCOPY((char *)&tmp, data, sizeof(tmp));
+		}
 		break;
 #endif
-	case SIOCGIPST :
-		IWCOPY((caddr_t)fr_statetstats(), data, sizeof(ips_stat_t));
+	case SIOCGETFS :
+		error = IWCOPYPTR((caddr_t)fr_statetstats(), data,
+				  sizeof(ips_stat_t));
 		break;
 	case FIONREAD :
 #ifdef	IPFILTER_LOG
-		IWCOPY((caddr_t)&iplused[IPL_LOGSTATE], (caddr_t)data,
-		       sizeof(iplused[IPL_LOGSTATE]));
+		error = IWCOPY((caddr_t)&iplused[IPL_LOGSTATE], (caddr_t)data,
+			       sizeof(iplused[IPL_LOGSTATE]));
 #endif
 		break;
+	case SIOCSTLCK :
+		error = fr_lock(data, &fr_state_lock);
+		break;
+	case SIOCSTPUT :
+		if (!fr_state_lock) {
+			error = EACCES;
+			break;
+		}
+		error = fr_stputent(data);
+		break;
+	case SIOCSTGET :
+		if (!fr_state_lock) {
+			error = EACCES;
+			break;
+		}
+		error = fr_stgetent(data);
+		break;
 	default :
 		error = EINVAL;
 		break;
@@ -252,6 +333,138 @@ int mode;
 }
 
 
+int fr_stgetent(data)
+caddr_t data;
+{
+	register ipstate_t *is, *isn;
+	ipstate_save_t ips, *ipsp;
+	int error;
+
+	error = IRCOPY(data, (caddr_t)&ipsp, sizeof(ipsp));
+	if (error)
+		return EFAULT;
+	error = IRCOPY((caddr_t)ipsp, (caddr_t)&ips, sizeof(ips));
+	if (error)
+		return EFAULT;
+
+	isn = ips.ips_next;
+	if (!isn) {
+		isn = ips_list;
+		if (isn == NULL) {
+			if (ips.ips_next == NULL)
+				return ENOENT;
+			return 0;
+		}
+	} else {
+		/*
+		 * Make sure the pointer we're copying from exists in the
+		 * current list of entries.  Security precaution to prevent
+		 * copying of random kernel data.
+		 */
+		for (is = ips_list; is; is = is->is_next)
+			if (is == isn)
+				break;
+		if (!is)
+			return ESRCH;
+	}
+	ips.ips_next = isn->is_next;
+	bcopy((char *)isn, (char *)&ips.ips_is, sizeof(ips.ips_is));
+	if (isn->is_rule)
+		bcopy((char *)isn->is_rule, (char *)&ips.ips_fr,
+		      sizeof(ips.ips_fr));
+	error = IWCOPY((caddr_t)&ips, ipsp, sizeof(ips));
+	if (error)
+		return EFAULT;
+	return 0;
+}
+
+
+int fr_stputent(data)
+caddr_t data;
+{
+	register ipstate_t *is, *isn;
+	ipstate_save_t ips, *ipsp;
+	frentry_t *fr;
+	int error;
+
+	error = IRCOPY(data, (caddr_t)&ipsp, sizeof(ipsp));
+	if (error)
+		return EFAULT;
+	error = IRCOPY((caddr_t)ipsp, (caddr_t)&ips, sizeof(ips));
+	if (error)
+		return EFAULT;
+
+	KMALLOC(isn, ipstate_t *);
+	if (isn == NULL)
+		return ENOMEM;
+
+	bcopy((char *)&ips.ips_is, (char *)isn, sizeof(*isn));
+	fr = isn->is_rule;
+	if (fr != NULL) {
+		if (isn->is_flags & FI_NEWFR) {
+			KMALLOC(fr, frentry_t *);
+			if (fr == NULL) {
+				KFREE(isn);
+				return ENOMEM;
+			}
+			bcopy((char *)&ips.ips_fr, (char *)fr, sizeof(*fr));
+			isn->is_rule = fr;
+			ips.ips_is.is_rule = fr;
+			error = IWCOPY((caddr_t)&ips, ipsp, sizeof(ips));
+			if (error) {
+				KFREE(isn);
+				KFREE(fr);
+				return EFAULT;
+			}
+		} else {
+			for (is = ips_list; is; is = is->is_next)
+				if (is->is_rule == fr)
+					break;
+			if (!is) {
+				KFREE(isn);
+				return ESRCH;
+			}
+		}
+	}
+	fr_stinsert(isn);
+	return 0;
+}
+
+
+void fr_stinsert(is)
+register ipstate_t *is;
+{
+	register u_int hv = is->is_hv;
+
+	MUTEX_INIT(&is->is_lock, "ipf state entry", NULL);
+
+	is->is_ifname[0][sizeof(is->is_ifname[0]) - 1] = '\0';
+	if (is->is_ifname[0][0] != '\0') {
+		is->is_ifp[0] = GETUNIT(is->is_ifname[0], is->is_v);
+	}
+	is->is_ifname[1][sizeof(is->is_ifname[0]) - 1] = '\0';
+	if (is->is_ifname[1][0] != '\0') {
+		is->is_ifp[1] = GETUNIT(is->is_ifname[1], is->is_v);
+	}
+
+	/*
+	 * add into list table.
+	 */
+	if (ips_list)
+		ips_list->is_pnext = &is->is_next;
+	is->is_pnext = &ips_list;
+	is->is_next = ips_list;
+	ips_list = is;
+	if (ips_table[hv])
+		ips_table[hv]->is_phnext = &is->is_hnext;
+	else
+		ips_stats.iss_inuse++;
+	is->is_phnext = ips_table + hv;
+	is->is_hnext = ips_table[hv];
+	ips_table[hv] = is;
+}
+
+
 /*
  * Create a new ipstate structure and hang it off the hash table.
  */
@@ -260,18 +473,22 @@ ip_t *ip;
 fr_info_t *fin;
 u_int flags;
 {
+	register tcphdr_t *tcp = NULL;
 	register ipstate_t *is;
 	register u_int hv;
 	ipstate_t ips;
 	u_int pass;
+	int out;
 
-	if ((ip->ip_off & IP_OFFMASK) || (fin->fin_fi.fi_fl & FI_SHORT))
+	if (fr_state_lock || (fin->fin_off & IP_OFFMASK) ||
+	    (fin->fin_fi.fi_fl & FI_SHORT))
 		return NULL;
 	if (ips_num == fr_statemax) {
 		ips_stats.iss_max++;
 		fr_state_doflush = 1;
 		return NULL;
 	}
+	out = fin->fin_out;
 	is = &ips;
 	bzero((char *)is, sizeof(*is));
 	ips.is_age = 1;
@@ -280,39 +497,74 @@ u_int flags;
 	/*
 	 * Copy and calculate...
 	 */
-	hv = (is->is_p = ip->ip_p);
-	hv += (is->is_src.s_addr = ip->ip_src.s_addr);
-	hv += (is->is_dst.s_addr = ip->ip_dst.s_addr);
+	hv = (is->is_p = fin->fin_fi.fi_p);
+	is->is_src = fin->fin_fi.fi_src;
+	hv += is->is_saddr;
+	is->is_dst = fin->fin_fi.fi_dst;
+	hv += is->is_daddr;
+#ifdef	USE_INET6
+	if (fin->fin_v == 6) {
+		if (is->is_p == IPPROTO_ICMPV6) {
+			if (IN6_IS_ADDR_MULTICAST(&is->is_dst.in6))
+				flags |= FI_W_DADDR;
+			if (out)
+				hv -= is->is_daddr;
+			else
+				hv -= is->is_saddr;
+		}
+	}
+#endif
 
-	switch (ip->ip_p)
+	switch (is->is_p)
 	{
+#ifdef	USE_INET6
+	case IPPROTO_ICMPV6 :
+#endif
 	case IPPROTO_ICMP :
 	    {
 		struct icmp *ic = (struct icmp *)fin->fin_dp;
 
+#ifdef	USE_INET6
+		if ((is->is_p == IPPROTO_ICMPV6) &&
+		    ((ic->icmp_type & ICMP6_INFOMSG_MASK) == 0))
+			return NULL;
+#endif
 		switch (ic->icmp_type)
 		{
-		case ICMP_ECHO :
-			is->is_icmp.ics_type = ICMP_ECHOREPLY;	/* XXX */
+#ifdef	USE_INET6
+		case ICMP6_ECHO_REQUEST :
+			is->is_icmp.ics_type = ICMP6_ECHO_REPLY;
 			hv += (is->is_icmp.ics_id = ic->icmp_id);
 			hv += (is->is_icmp.ics_seq = ic->icmp_seq);
 			break;
+		case ICMP6_MEMBERSHIP_QUERY :
+		case ND_ROUTER_SOLICIT :
+		case ND_NEIGHBOR_SOLICIT :
+			is->is_icmp.ics_type = ic->icmp_type + 1;
+			break;
+			break;
+#endif
+		case ICMP_ECHO :
 		case ICMP_TSTAMP :
 		case ICMP_IREQ :
 		case ICMP_MASKREQ :
-			is->is_icmp.ics_type = ic->icmp_type + 1;
+			is->is_icmp.ics_type = ic->icmp_type;
+			hv += (is->is_icmp.ics_id = ic->icmp_id);
+			hv += (is->is_icmp.ics_seq = ic->icmp_seq);
 			break;
 		default :
 			return NULL;
 		}
-		ATOMIC_INC(ips_stats.iss_icmp);
+		ATOMIC_INCL(ips_stats.iss_icmp);
 		is->is_age = fr_icmptimeout;
 		break;
 	    }
 	case IPPROTO_TCP :
 	    {
-		register tcphdr_t *tcp = (tcphdr_t *)fin->fin_dp;
+		tcp = (tcphdr_t *)fin->fin_dp;
 
+		if (tcp->th_flags & TH_RST)
+			return NULL;
 		/*
 		 * The endian of the ports doesn't matter, but the ack and
 		 * sequence numbers do as we do mathematics on them later.
@@ -323,14 +575,13 @@ u_int flags;
 			hv += tcp->th_dport;
 			hv += tcp->th_sport;
 		}
-		if (tcp->th_seq != 0) {
-			is->is_send = ntohl(tcp->th_seq) + ip->ip_len -
-				      fin->fin_hlen - (tcp->th_off << 2) +
-				      ((tcp->th_flags & TH_SYN) ? 1 : 0) +
-				      ((tcp->th_flags & TH_FIN) ? 1 : 0);
-			is->is_maxsend = is->is_send + 1;
-		}
+		is->is_send = ntohl(tcp->th_seq) + ip->ip_len -
+			      fin->fin_hlen - (tcp->th_off << 2) +
+			      ((tcp->th_flags & TH_SYN) ? 1 : 0) +
+			      ((tcp->th_flags & TH_FIN) ? 1 : 0);
+		is->is_maxsend = is->is_send;
 		is->is_dend = 0;
+		is->is_maxdwin = 1;
 		is->is_maxswin = ntohs(tcp->th_win);
 		if (is->is_maxswin == 0)
 			is->is_maxswin = 1;
@@ -339,16 +590,12 @@ u_int flags;
 		 * timer on it as we'll never see an error if it fails to
 		 * connect.
 		 */
-		MUTEX_ENTER(&ipf_rw);
-		ips_stats.iss_tcp++;
-		fr_tcp_age(&is->is_age, is->is_state, ip, fin,
-			   tcp->th_sport == is->is_sport);
-		MUTEX_EXIT(&ipf_rw);
+		ATOMIC_INCL(ips_stats.iss_tcp);
 		break;
 	    }
 	case IPPROTO_UDP :
 	    {
-		register tcphdr_t *tcp = (tcphdr_t *)fin->fin_dp;
+		tcp = (tcphdr_t *)fin->fin_dp;
 
 		is->is_dport = tcp->th_dport;
 		is->is_sport = tcp->th_sport;
@@ -356,7 +603,7 @@ u_int flags;
 			hv += tcp->th_dport;
 			hv += tcp->th_sport;
 		}
-		ATOMIC_INC(ips_stats.iss_udp);
+		ATOMIC_INCL(ips_stats.iss_udp);
 		is->is_age = fr_udptimeout;
 		break;
 	    }
@@ -366,30 +613,29 @@ u_int flags;
 
 	KMALLOC(is, ipstate_t *);
 	if (is == NULL) {
-		ATOMIC_INC(ips_stats.iss_nomem);
+		ATOMIC_INCL(ips_stats.iss_nomem);
 		return NULL;
 	}
 	bcopy((char *)&ips, (char *)is, sizeof(*is));
 	hv %= fr_statesize;
-	RW_UPGRADE(&ipf_mutex);
+	is->is_hv = hv;
 	is->is_rule = fin->fin_fr;
 	if (is->is_rule != NULL) {
-		is->is_rule->fr_ref++;
+		ATOMIC_INC32(is->is_rule->fr_ref);
 		pass = is->is_rule->fr_flags;
 	} else
 		pass = fr_flags;
-	MUTEX_DOWNGRADE(&ipf_mutex);
 	WRITE_ENTER(&ipf_state);
 
-	is->is_rout = pass & FR_OUTQUE ? 1 : 0;
 	is->is_pass = pass;
 	is->is_pkts = 1;
-	is->is_bytes = ip->ip_len;
+	is->is_bytes = fin->fin_dlen + fin->fin_hlen;
 	/*
 	 * We want to check everything that is a property of this packet,
 	 * but we don't (automatically) care about it's fragment status as
 	 * this may change.
 	 */
+	is->is_v = fin->fin_fi.fi_v;
 	is->is_opt = fin->fin_fi.fi_optmsk;
 	is->is_optmsk = 0xffffffff;
 	is->is_sec = fin->fin_fi.fi_secmsk;
@@ -398,29 +644,28 @@ u_int flags;
 	is->is_authmsk = 0xffff;
 	is->is_flags = fin->fin_fi.fi_fl & FI_CMP;
 	is->is_flags |= FI_CMP << 4;
-	is->is_flags |= flags & (FI_W_DPORT|FI_W_SPORT);
-	/*
-	 * add into table.
-	 */
-	is->is_next = ips_table[hv];
-	ips_table[hv] = is;
-	if (is->is_next == NULL)
-		ips_stats.iss_inuse++;
-	if (fin->fin_out) {
-		is->is_ifpin = NULL;
-		is->is_ifpout = fin->fin_ifp;
-	} else {
-		is->is_ifpin = fin->fin_ifp;
-		is->is_ifpout = NULL;
-	}
+	is->is_flags |= flags & (FI_WILDP|FI_WILDA);
+	is->is_ifp[1 - out] = NULL;
+	is->is_ifp[out] = fin->fin_ifp;
+#ifdef	_KERNEL
+	strncpy(is->is_ifname[out], IFNAME(fin->fin_ifp), IFNAMSIZ);
+#endif
+	is->is_ifname[1 - out][0] = '\0';
 	if (pass & FR_LOGFIRST)
 		is->is_pass &= ~(FR_LOGFIRST|FR_LOG);
-	ATOMIC_INC(ips_num);
+	fr_stinsert(is);
+	ips_num++;
+	if (is->is_p == IPPROTO_TCP) {
+		MUTEX_ENTER(&is->is_lock);
+		fr_tcp_age(&is->is_age, is->is_state, fin,
+			   tcp->th_sport == is->is_sport);
+		MUTEX_EXIT(&is->is_lock);
+	}
 #ifdef	IPFILTER_LOG
 	ipstate_log(is, ISL_NEW);
 #endif
 	RWLOCK_EXIT(&ipf_state);
-	fin->fin_rev = (is->is_dst.s_addr != ip->ip_dst.s_addr);
+	fin->fin_rev = IP6NEQ(is->is_dst, fin->fin_fi.fi_dst);
 	if (fin->fin_fi.fi_fl & FI_FRAG)
 		ipfr_newfrag(ip, fin, pass ^ FR_KEEPSTATE);
 	return is;
@@ -449,13 +694,13 @@ tcphdr_t *tcp;
 	/*
 	 * Find difference between last checked packet and this packet.
 	 */
-	source = (ip->ip_src.s_addr == is->is_src.s_addr);
+	source = IP6EQ(fin->fin_fi.fi_src, is->is_src);
 	fdata = &is->is_tcp.ts_data[!source];
 	tdata = &is->is_tcp.ts_data[source];
 	seq = ntohl(tcp->th_seq);
 	ack = ntohl(tcp->th_ack);
 	win = ntohs(tcp->th_win);
-	end = seq + ip->ip_len - fin->fin_hlen - (tcp->th_off << 2) +
+	end = seq + fin->fin_dlen - (tcp->th_off << 2) +
 	       ((tcp->th_flags & TH_SYN) ? 1 : 0) +
 	       ((tcp->th_flags & TH_FIN) ? 1 : 0);
 
@@ -470,9 +715,6 @@ tcphdr_t *tcp;
 
 	if (!(tcp->th_flags & TH_ACK)) {  /* Pretend an ack was sent */
 		ack = tdata->td_end;
-		win = 1;
-		if ((tcp->th_flags == TH_SYN) && (tdata->td_maxwin == 0))
-			 tdata->td_maxwin = 1;
 	} else if (((tcp->th_flags & (TH_ACK|TH_RST)) == (TH_ACK|TH_RST)) &&
 		   (ack == 0)) {
 		/* gross hack to get around certain broken tcp stacks */
@@ -521,15 +763,15 @@ tcphdr_t *tcp;
 				tdata->td_maxend++;
 		}
 
-		ATOMIC_INC(ips_stats.iss_hits);
+		ATOMIC_INCL(ips_stats.iss_hits);
 		is->is_pkts++;
-		is->is_bytes += ip->ip_len;
+		is->is_bytes += fin->fin_dlen + fin->fin_hlen;
 		/*
 		 * Nearing end of connection, start timeout.
 		 */
-		MUTEX_ENTER(&ipf_rw);
-		fr_tcp_age(&is->is_age, is->is_state, ip, fin, source);
-		MUTEX_EXIT(&ipf_rw);
+		MUTEX_ENTER(&is->is_lock);
+		fr_tcp_age(&is->is_age, is->is_state, fin, source);
+		MUTEX_EXIT(&is->is_lock);
 		ret = 1;
 	}
 	return ret;
@@ -538,7 +780,7 @@ tcphdr_t *tcp;
 
 static int fr_matchsrcdst(is, src, dst, fin, tcp)
 ipstate_t *is;
-struct in_addr src, dst;
+union i6addr src, dst;
 fr_info_t *fin;
 tcphdr_t *tcp;
 {
@@ -546,7 +788,7 @@ tcphdr_t *tcp;
 	u_short sp, dp;
 	void *ifp;
 
-	rev = fin->fin_rev = (is->is_dst.s_addr != dst.s_addr);
+	rev = fin->fin_rev = IP6NEQ(is->is_dst, dst);
 	ifp = fin->fin_ifp;
 	out = fin->fin_out;
 
@@ -555,14 +797,14 @@ tcphdr_t *tcp;
 		sp = tcp->th_sport;
 		dp = tcp->th_dport;
 	} else {
-		flags = 0;
+		flags = is->is_flags & FI_WILDA;
 		sp = 0;
 		dp = 0;
 	}
 
 	if (rev == 0) {
 		if (!out) {
-			if (is->is_ifpin == ifp)
+			if (is->is_ifpin == NULL || is->is_ifpin == ifp)
 				ret = 1;
 		} else {
 			if (is->is_ifpout == NULL || is->is_ifpout == ifp)
@@ -570,7 +812,7 @@ tcphdr_t *tcp;
 		}
 	} else {
 		if (out) {
-			if (is->is_ifpin == ifp)
+			if (is->is_ifpin == NULL || is->is_ifpin == ifp)
 				ret = 1;
 		} else {
 			if (is->is_ifpout == NULL || is->is_ifpout == ifp)
@@ -582,15 +824,17 @@ tcphdr_t *tcp;
 	ret = 0;
 
 	if (rev == 0) {
-		if ((is->is_dst.s_addr == dst.s_addr) &&
-		    (is->is_src.s_addr == src.s_addr) &&
+		if (
+		    (IP6EQ(is->is_dst, dst) || (flags & FI_W_DADDR)) &&
+		    (IP6EQ(is->is_src, src) || (flags & FI_W_SADDR)) &&
 		    (!tcp || ((sp == is->is_sport || flags & FI_W_SPORT) &&
 		     (dp == is->is_dport || flags & FI_W_DPORT)))) {
 			ret = 1;
 		}
 	} else {
-		if ((is->is_dst.s_addr == src.s_addr) &&
-		    (is->is_src.s_addr == dst.s_addr) &&
+		if (
+		    (IP6EQ(is->is_dst, src) || (flags & FI_W_DADDR)) &&
+		    (IP6EQ(is->is_src, dst) || (flags & FI_W_SADDR)) &&
 		    (!tcp || ((sp == is->is_dport || flags & FI_W_DPORT) &&
 		     (dp == is->is_sport || flags & FI_W_SPORT)))) {
 			ret = 1;
@@ -635,34 +879,80 @@ tcphdr_t *tcp;
 		is->is_flags &= ~(FI_W_SPORT|FI_W_DPORT);
 	}
 
+	ret = -1;
+
 	if (!rev) {
-		if (out && (out == is->is_rout)) {
+		if (out) {
 			if (!is->is_ifpout)
-				is->is_ifpout = ifp;
+				ret = 1;
 		} else {
 			if (!is->is_ifpin)
-				is->is_ifpin = ifp;
+				ret = 0;
 		}
 	} else {
-		if (!out && (out != is->is_rout)) {
+		if (out) {
 			if (!is->is_ifpin)
-				is->is_ifpin = ifp;
+				ret = 0;
 		} else {
 			if (!is->is_ifpout)
-				is->is_ifpout = ifp;
+				ret = 1;
 		}
 	}
+
+	if (ret >= 0) {
+		is->is_ifp[ret] = ifp;
+#ifdef	_KERNEL
+		strncpy(is->is_ifname[out], IFNAME(fin->fin_ifp),
+			sizeof(is->is_ifname[1]));
+#endif
+	}
+#ifdef  _KERNEL
+	if (ret >= 0) {
+		strncpy(is->is_ifname[out], IFNAME(fin->fin_ifp),
+			sizeof(is->is_ifname[1]));
+	}
+#endif
 	return 1;
 }
 
-frentry_t *fr_checkicmpmatchingstate(ip, fin)
+static int fr_matchicmpqueryreply(v, is, icmp)
+int v;
+ipstate_t *is;
+icmphdr_t *icmp;
+{
+	if (v == 4) {
+		/*
+		 * If we matched its type on the way in, then when going out
+		 * it will still be the same type.
+		 */
+		if (((icmp->icmp_type == is->is_type) ||
+		     (icmpreplytype4[is->is_type] == icmp->icmp_type)) &&
+		    (icmp->icmp_id == is->is_icmp.ics_id) &&
+		    (icmp->icmp_seq == is->is_icmp.ics_seq)) {
+			return 1;
+		};
+	}
+#ifdef	USE_INET6
+	else if (is->is_v == 6) {
+		if ((is->is_type == ICMP6_ECHO_REPLY) &&
+		    (icmp->icmp_type == ICMP6_ECHO_REQUEST) &&
+		    (icmp->icmp_id == is->is_icmp.ics_id) &&
+		    (icmp->icmp_seq == is->is_icmp.ics_seq)) {
+			return 1;
+		};
+	}
+#endif
+	return 0;
+}
+
+static frentry_t *fr_checkicmpmatchingstate(ip, fin)
 ip_t *ip;
 fr_info_t *fin;
 {
-	register struct in_addr	dst, src;
 	register ipstate_t *is, **isp;
 	register u_short sport, dport;
 	register u_char	pr;
+	union i6addr dst, src;
 	struct icmp *ic;
 	u_short savelen;
 	fr_info_t ofin;
@@ -678,9 +968,10 @@ fr_info_t *fin;
 	 * Only a basic IP header (no options) should be with
 	 * an ICMP error header.
 	 */
-	if ((ip->ip_hl != 5) || (ip->ip_len < ICMPERR_MINPKTLEN))
+	if (((ip->ip_v != 4) && (ip->ip_hl != 5)) ||
+	    (fin->fin_plen < ICMPERR_MINPKTLEN))
 		return NULL;
-	ic = (struct icmp *)((char *)ip + fin->fin_hlen);
+	ic = (struct icmp *)fin->fin_dp;
 	type = ic->icmp_type;
 	/*
 	 * If it's not an error type, then return
@@ -690,12 +981,11 @@ fr_info_t *fin;
     	    (type != ICMP_PARAMPROB))
 		return NULL;
 
-	oip = (ip_t *)((char *)fin->fin_dp + ICMPERR_ICMPHLEN);
-	if (ip->ip_len < ICMPERR_MAXPKTLEN + ((oip->ip_hl - 5) << 2))
+	oip = (ip_t *)((char *)ic + ICMPERR_ICMPHLEN);
+	if (fin->fin_plen < ICMPERR_MAXPKTLEN + ((oip->ip_hl - 5) << 2))
 		return NULL;
 
 	if (oip->ip_p == IPPROTO_ICMP) {
-
 		icmp = (icmphdr_t *)((char *)oip + (oip->ip_hl << 2));
 
 		/*
@@ -714,14 +1004,13 @@ fr_info_t *fin;
 		/*
 		 * perform a lookup of the ICMP packet in the state table
 		 */
-
 		hv = (pr = oip->ip_p);
-		hv += (src.s_addr = oip->ip_src.s_addr);
-		hv += (dst.s_addr = oip->ip_dst.s_addr);
-		if (icmp->icmp_type == ICMP_ECHO) {
-			hv += icmp->icmp_id;
-			hv += icmp->icmp_seq;
-		}
+		src.in4 = oip->ip_src;
+		hv += src.in4.s_addr;
+		dst.in4 = oip->ip_dst;
+		hv += dst.in4.s_addr;
+		hv += icmp->icmp_id;
+		hv += icmp->icmp_seq;
 		hv %= fr_statesize;
 
 		oip->ip_len = ntohs(oip->ip_len);
@@ -732,26 +1021,16 @@ fr_info_t *fin;
 		ofin.fin_mp = NULL; /* if dereferenced, panic XXX */
 
 		READ_ENTER(&ipf_state);
-		for (isp = &ips_table[hv]; (is = *isp); isp = &is->is_next)
-			if ((is->is_p == pr) &&
-			    fr_matchsrcdst(is, src, dst, &ofin, NULL)) {
-			    	/*
-			    	 * in the state table ICMP query's are stored
-			    	 * with the type of the corresponding ICMP
-			    	 * response. Correct here
-			    	 */
-				if (((is->is_type == ICMP_ECHOREPLY) &&
-				     (icmp->icmp_id == is->is_icmp.ics_id) &&
-				     (icmp->icmp_seq == is->is_icmp.ics_seq) &&
-				     (icmp->icmp_type == ICMP_ECHO)) ||
-				    (is->is_type - 1 == ic->icmp_type)) {
-				    	ips_stats.iss_hits++;
-    		                        is->is_pkts++;
-                	                is->is_bytes += ip->ip_len;
-					fr = is->is_rule;
-					RWLOCK_EXIT(&ipf_state);
-					return fr;
-				}
+		for (isp = &ips_table[hv]; (is = *isp); isp = &is->is_hnext)
+			if ((is->is_p == pr) && (is->is_v == 4) &&
+			    fr_matchsrcdst(is, src, dst, &ofin, NULL) &&
+			    fr_matchicmpqueryreply(is->is_v, is, icmp)) {
+				ips_stats.iss_hits++;
+				is->is_pkts++;
+				is->is_bytes += ip->ip_len;
+				fr = is->is_rule;
+				RWLOCK_EXIT(&ipf_state);
+				return fr;
 			}
 		RWLOCK_EXIT(&ipf_state);
 		return NULL;
@@ -765,8 +1044,10 @@ fr_info_t *fin;
 	sport = tcp->th_sport;
 
 	hv = (pr = oip->ip_p);
-	hv += (src.s_addr = oip->ip_src.s_addr);
-	hv += (dst.s_addr = oip->ip_dst.s_addr);
+	src.in4 = oip->ip_src;
+	hv += src.in4.s_addr;
+	dst.in4 = oip->ip_dst;
+	hv += dst.in4.s_addr;
 	hv += dport;
 	hv += sport;
 	hv %= fr_statesize;
@@ -788,7 +1069,7 @@ fr_info_t *fin;
 	ofin.fin_out = !fin->fin_out;
 	ofin.fin_mp = NULL; /* if dereferenced, panic XXX */
 	READ_ENTER(&ipf_state);
-	for (isp = &ips_table[hv]; (is = *isp); isp = &is->is_next) {
+	for (isp = &ips_table[hv]; (is = *isp); isp = &is->is_hnext) {
 		/*
 		 * Only allow this icmp though if the
 		 * encapsulated packet was allowed through the
@@ -796,7 +1077,7 @@ fr_info_t *fin;
 		 * of info present does not allow for checking against
 		 * tcp internals such as seq and ack numbers.
 		 */
-		if ((is->is_p == pr) &&
+		if ((is->is_p == pr) && (is->is_v == 4) &&
 		    fr_matchsrcdst(is, src, dst, &ofin, tcp)) {
 			fr = is->is_rule;
 			ips_stats.iss_hits++;
@@ -805,7 +1086,7 @@ fr_info_t *fin;
 			 * comes the other way around
 			 */
 			is->is_pkts++;
-			is->is_bytes += ip->ip_len;
+			is->is_bytes += fin->fin_plen;
 			/*
 			 * we deliberately do not touch the timeouts
 			 * for the accompanying state table entry.
@@ -826,51 +1107,63 @@ frentry_t *fr_checkstate(ip, fin)
 ip_t *ip;
 fr_info_t *fin;
 {
-	register struct in_addr dst, src;
+	union i6addr dst, src;
 	register ipstate_t *is, **isp;
 	register u_char pr;
-	u_int hv, hvm, hlen, tryagain, pass;
+	u_int hv, hvm, hlen, tryagain, pass, v;
 	struct icmp *ic;
 	frentry_t *fr;
 	tcphdr_t *tcp;
 
-	if ((ip->ip_off & IP_OFFMASK) || (fin->fin_fi.fi_fl & FI_SHORT))
+	if (fr_state_lock || (fin->fin_off & IP_OFFMASK) ||
+	    (fin->fin_fi.fi_fl & FI_SHORT))
 		return NULL;
 
 	is = NULL;
 	hlen = fin->fin_hlen;
 	tcp = (tcphdr_t *)((char *)ip + hlen);
 	ic = (struct icmp *)tcp;
-	hv = (pr = ip->ip_p);
-	hv += (src.s_addr = ip->ip_src.s_addr);
-	hv += (dst.s_addr = ip->ip_dst.s_addr);
+	hv = (pr = fin->fin_fi.fi_p);
+	src = fin->fin_fi.fi_src;
+	dst = fin->fin_fi.fi_dst;
+	hv += src.in4.s_addr;
+	hv += dst.in4.s_addr;
 
 	/*
 	 * Search the hash table for matching packet header info.
 	 */
-	switch (ip->ip_p)
+	v = fin->fin_fi.fi_v;
+	switch (fin->fin_fi.fi_p)
 	{
+#ifdef	USE_INET6
+	case IPPROTO_ICMPV6 :
+		if (v == 6) {
+			if (fin->fin_out)
+				hv -= dst.in4.s_addr;
+			else
+				hv -= src.in4.s_addr;
+			if ((ic->icmp_type == ICMP6_ECHO_REQUEST) ||
+			    (ic->icmp_type == ICMP6_ECHO_REPLY)) {
+				hv += ic->icmp_id;
+				hv += ic->icmp_seq;
+			}
+		}
+#endif
 	case IPPROTO_ICMP :
-		if ((ic->icmp_type == ICMP_ECHO) ||
-		    (ic->icmp_type == ICMP_ECHOREPLY)) {
+		if (v == 4) {
 			hv += ic->icmp_id;
 			hv += ic->icmp_seq;
 		}
 		hv %= fr_statesize;
 		READ_ENTER(&ipf_state);
-		for (isp = &ips_table[hv]; (is = *isp); isp = &is->is_next)
-			if ((is->is_p == pr) &&
-			    fr_matchsrcdst(is, src, dst, fin, NULL)) {
-				if ((is->is_type == ICMP_ECHOREPLY) &&
-				    (ic->icmp_type == ICMP_ECHO) &&
-				    (ic->icmp_id == is->is_icmp.ics_id) &&
-				    (ic->icmp_seq == is->is_icmp.ics_seq))
-					;
-				else if (is->is_type != ic->icmp_type)
-					continue;
+		for (isp = &ips_table[hv]; (is = *isp); isp = &is->is_hnext) {
+			if ((is->is_p == pr) && (is->is_v == v) &&
+			    fr_matchsrcdst(is, src, dst, fin, NULL) &&
+			    fr_matchicmpqueryreply(v, is, ic)) {
 				is->is_age = fr_icmptimeout;
 				break;
 			}
+		}
 		if (is != NULL)
 			break;
 		RWLOCK_EXIT(&ipf_state);
@@ -878,7 +1171,12 @@ fr_info_t *fin;
 		 * No matching icmp state entry. Perhaps this is a
 		 * response to another state entry.
 		 */
-		fr = fr_checkicmpmatchingstate(ip, fin);
+#ifdef	USE_INET6
+		if (v == 6)
+			fr = fr_checkicmp6matchingstate((ip6_t *)ip, fin);
+		else
+#endif
+			fr = fr_checkicmpmatchingstate(ip, fin);
 		if (fr)
 			return fr;
 		break;
@@ -891,22 +1189,13 @@ retry_tcp:
 		hvm = hv % fr_statesize;
 		WRITE_ENTER(&ipf_state);
 		for (isp = &ips_table[hvm]; (is = *isp);
-		     isp = &is->is_next)
-			if ((is->is_p == pr) &&
+		     isp = &is->is_hnext)
+
+
+			if ((is->is_p == pr) && (is->is_v == v) &&
 			    fr_matchsrcdst(is, src, dst, fin, tcp)) {
-				if (fr_tcpstate(is, fin, ip, tcp)) {
-#ifndef	_KERNEL
-					if (tcp->th_flags & TCP_CLOSE) {
-						*isp = is->is_next;
-						isp = &ips_table[hvm];
-						if (ips_table[hvm] == NULL)
-							ips_stats.iss_inuse--;
-						fr_delstate(is);
-						ips_num--;
-					}
-#endif
+				if (fr_tcpstate(is, fin, ip, tcp))
 					break;
-				}
 				is = NULL;
 				break;
 			}
@@ -932,8 +1221,8 @@ retry_udp:
 		 * Nothing else to match on but ports. and IP#'s
 		 */
 		READ_ENTER(&ipf_state);
-		for (is = ips_table[hvm]; is; is = is->is_next)
-			if ((is->is_p == pr) &&
+		for (is = ips_table[hvm]; is; is = is->is_hnext)
+			if ((is->is_p == pr) && (is->is_v == v) &&
 			    fr_matchsrcdst(is, src, dst, fin, tcp)) {
 				is->is_age = fr_udptimeout;
 				break;
@@ -953,17 +1242,21 @@ retry_udp:
 		break;
 	}
 	if (is == NULL) {
-		ATOMIC_INC(ips_stats.iss_miss);
+		ATOMIC_INCL(ips_stats.iss_miss);
 		return NULL;
 	}
-	MUTEX_ENTER(&ipf_rw);
-	is->is_bytes += ip->ip_len;
+	MUTEX_ENTER(&is->is_lock);
+	is->is_bytes += fin->fin_plen;
 	ips_stats.iss_hits++;
 	is->is_pkts++;
-	MUTEX_EXIT(&ipf_rw);
+	MUTEX_EXIT(&is->is_lock);
 	fr = is->is_rule;
 	fin->fin_fr = fr;
 	pass = is->is_pass;
+#ifndef	_KERNEL
+	if (tcp->th_flags & TCP_CLOSE)
+		fr_delstate(is);
+#endif
 	RWLOCK_EXIT(&ipf_state);
 	if (fin->fin_fi.fi_fl & FI_FRAG)
 		ipfr_newfrag(ip, fin, pass ^ FR_KEEPSTATE);
@@ -971,18 +1264,53 @@ retry_udp:
 }
 
 
+void ip_statesync(ifp)
+void *ifp;
+{
+	register ipstate_t *is;
+
+	WRITE_ENTER(&ipf_state);
+	for (is = ips_list; is; is = is->is_next) {
+		if (is->is_ifpin == ifp) {
+			is->is_ifpin = GETUNIT(is->is_ifname[0], is->is_v);
+			if (!is->is_ifpin)
+				is->is_ifpin = (void *)-1;
+		}
+		if (is->is_ifpout == ifp) {
+			is->is_ifpout = GETUNIT(is->is_ifname[1], is->is_v);
+			if (!is->is_ifpout)
+				is->is_ifpout = (void *)-1;
+		}
+	}
+	RWLOCK_EXIT(&ipf_state);
+}
+
+
 static void fr_delstate(is)
 ipstate_t *is;
 {
 	frentry_t *fr;
 
+	if (is->is_next)
+		is->is_next->is_pnext = is->is_pnext;
+	*is->is_pnext = is->is_next;
+	if (is->is_hnext)
+		is->is_hnext->is_phnext = is->is_phnext;
+	*is->is_phnext = is->is_hnext;
+	if (ips_table[is->is_hv] == NULL)
+		ips_stats.iss_inuse--;
+
 	fr = is->is_rule;
 	if (fr != NULL) {
-		ATOMIC_DEC(fr->fr_ref);
+		ATOMIC_DEC32(fr->fr_ref);
 		if (fr->fr_ref == 0)
 			KFREE(fr);
 	}
+#ifdef	_KERNEL
+	MUTEX_DESTROY(&is->is_lock);
+#endif
 	KFREE(is);
+	ips_num--;
 }
 
 
@@ -991,16 +1319,11 @@ ipstate_t *is;
  */
 void fr_stateunload()
 {
-	register int i;
-	register ipstate_t *is, **isp;
+	register ipstate_t *is;
 
 	WRITE_ENTER(&ipf_state);
-	for (i = fr_statesize - 1; i >= 0; i--)
-		for (isp = &ips_table[i]; (is = *isp); ) {
-			*isp = is->is_next;
-			fr_delstate(is);
-			ips_num--;
-		}
+	while ((is = ips_list))
+		fr_delstate(is);
 	ips_stats.iss_inuse = 0;
 	ips_num = 0;
 	RWLOCK_EXIT(&ipf_state);
@@ -1015,7 +1338,6 @@ void fr_stateunload()
  */
 void fr_timeoutstate()
 {
-	register int i;
 	register ipstate_t *is, **isp;
 #if defined(_KERNEL) && !SOLARIS
 	int s;
@@ -1023,23 +1345,18 @@ void fr_timeoutstate()
 
 	SPL_NET(s);
 	WRITE_ENTER(&ipf_state);
-	for (i = fr_statesize - 1; i >= 0; i--)
-		for (isp = &ips_table[i]; (is = *isp); )
-			if (is->is_age && !--is->is_age) {
-				*isp = is->is_next;
-				if (is->is_p == IPPROTO_TCP)
-					ips_stats.iss_fin++;
-				else
-					ips_stats.iss_expire++;
-				if (ips_table[i] == NULL)
-					ips_stats.iss_inuse--;
+	for (isp = &ips_list; (is = *isp); )
+		if (is->is_age && !--is->is_age) {
+			if (is->is_p == IPPROTO_TCP)
+				ips_stats.iss_fin++;
+			else
+				ips_stats.iss_expire++;
 #ifdef	IPFILTER_LOG
-				ipstate_log(is, ISL_EXPIRE);
+			ipstate_log(is, ISL_EXPIRE);
 #endif
-				fr_delstate(is);
-				ips_num--;
-			} else
-				isp = &is->is_next;
+			fr_delstate(is);
+		} else
+			isp = &is->is_next;
 	RWLOCK_EXIT(&ipf_state);
 	SPL_X(s);
 	if (fr_state_doflush) {
@@ -1053,10 +1370,9 @@ void fr_timeoutstate()
  * Original idea freom Pradeep Krishnan for use primarily with NAT code.
  * (pkrishna@netcom.com)
  */
-void fr_tcp_age(age, state, ip, fin, dir)
+void fr_tcp_age(age, state, fin, dir)
 u_long *age;
 u_char *state;
-ip_t *ip;
 fr_info_t *fin;
 int dir;
 {
@@ -1066,7 +1382,7 @@ int dir;
 
 	ostate = state[1 - dir];
 
-	dlen = ip->ip_len - fin->fin_hlen - (tcp->th_off << 2);
+	dlen = fin->fin_plen - fin->fin_hlen - (tcp->th_off << 2);
 
 	if (flags & TH_RST) {
 		if (!(tcp->th_flags & TH_PUSH) && !dlen) {
@@ -1161,6 +1477,7 @@ u_int type;
 	ipsl.isl_src = is->is_src;
 	ipsl.isl_dst = is->is_dst;
 	ipsl.isl_p = is->is_p;
+	ipsl.isl_v = is->is_v;
 	ipsl.isl_flags = is->is_flags;
 	if (ipsl.isl_p == IPPROTO_TCP || ipsl.isl_p == IPPROTO_UDP) {
 		ipsl.isl_sport = is->is_sport;
@@ -1184,19 +1501,161 @@ u_int type;
 #endif
 
 
-void ip_statesync(ifp)
-void *ifp;
+#ifdef	USE_INET6
+frentry_t *fr_checkicmp6matchingstate(ip, fin)
+ip6_t *ip;
+fr_info_t *fin;
 {
-	register ipstate_t *is;
-	register int i;
+	register ipstate_t *is, **isp;
+	register u_short sport, dport;
+	register u_char	pr;
+	struct icmp6_hdr *ic, *oic;
+	union i6addr dst, src;
+	u_short savelen;
+	fr_info_t ofin;
+	tcphdr_t *tcp;
+	frentry_t *fr;
+	ip6_t *oip;
+	int type;
+	u_int hv;
 
-	WRITE_ENTER(&ipf_state);
-	for (i = fr_statesize - 1; i >= 0; i--)
-		for (is = ips_table[i]; is != NULL; is = is->is_next) {
-			if (is->is_ifpin == ifp)
-				is->is_ifpin = NULL;
-			if (is->is_ifpout == ifp)
-				is->is_ifpout = NULL;
+	/*
+	 * Does it at least have the return (basic) IP header ?
+	 * Only a basic IP header (no options) should be with
+	 * an ICMP error header.
+	 */
+	if ((fin->fin_v != 6) || (fin->fin_plen < ICMP6ERR_MINPKTLEN))
+		return NULL;
+	ic = (struct icmp6_hdr *)fin->fin_dp;
+	type = ic->icmp6_type;
+	/*
+	 * If it's not an error type, then return
+	 */
+	if ((type != ICMP6_DST_UNREACH) && (type != ICMP6_PACKET_TOO_BIG) &&
+	    (type != ICMP6_TIME_EXCEEDED) && (type != ICMP6_PARAM_PROB))
+		return NULL;
+
+	oip = (ip6_t *)((char *)ic + ICMPERR_ICMPHLEN);
+	if (fin->fin_plen < sizeof(*oip))
+		return NULL;
+
+	if (oip->ip6_nxt == IPPROTO_ICMPV6) {
+		oic = (struct icmp6_hdr *)(oip + 1);
+		/*
+		 * a ICMP error can only be generated as a result of an
+		 * ICMP query, not as the response on an ICMP error
+		 *
+		 * XXX theoretically ICMP_ECHOREP and the other reply's are
+		 * ICMP query's as well, but adding them here seems strange XXX
+		 */
+		 if (!(oic->icmp6_type & ICMP6_INFOMSG_MASK))
+		    	return NULL;
+
+		/*
+		 * perform a lookup of the ICMP packet in the state table
+		 */
+		hv = (pr = oip->ip6_nxt);
+		src.in6 = oip->ip6_src;
+		hv += src.in4.s_addr;
+		dst.in6 = oip->ip6_dst;
+		hv += dst.in4.s_addr;
+		hv += oic->icmp6_id;
+		hv += oic->icmp6_seq;
+		hv %= fr_statesize;
+
+		oip->ip6_plen = ntohs(oip->ip6_plen);
+		fr_makefrip(sizeof(*oip), (ip_t *)oip, &ofin);
+		oip->ip6_plen = htons(oip->ip6_plen);
+		ofin.fin_ifp = fin->fin_ifp;
+		ofin.fin_out = !fin->fin_out;
+		ofin.fin_mp = NULL; /* if dereferenced, panic XXX */
+
+		READ_ENTER(&ipf_state);
+		for (isp = &ips_table[hv]; (is = *isp); isp = &is->is_hnext)
+			if ((is->is_p == pr) &&
+			    (oic->icmp6_id == is->is_icmp.ics_id) &&
+			    (oic->icmp6_seq == is->is_icmp.ics_seq) &&
+			    fr_matchsrcdst(is, src, dst, &ofin, NULL)) {
+			    	/*
+			    	 * in the state table ICMP query's are stored
+			    	 * with the type of the corresponding ICMP
+			    	 * response. Correct here
+			    	 */
+				if (((is->is_type == ICMP6_ECHO_REPLY) &&
+				     (oic->icmp6_type == ICMP6_ECHO_REQUEST)) ||
+				     (is->is_type - 1 == oic->icmp6_type )) {
+				    	ips_stats.iss_hits++;
+    		                        is->is_pkts++;
+                	                is->is_bytes += fin->fin_plen;
+					return is->is_rule;
+				}
+			}
+		RWLOCK_EXIT(&ipf_state);
+
+		return NULL;
+	};
+
+	if ((oip->ip6_nxt != IPPROTO_TCP) && (oip->ip6_nxt != IPPROTO_UDP))
+		return NULL;
+	tcp = (tcphdr_t *)(oip + 1);
+	dport = tcp->th_dport;
+	sport = tcp->th_sport;
+
+	hv = (pr = oip->ip6_nxt);
+	src.in6 = oip->ip6_src;
+	hv += src.in4.s_addr;
+	dst.in6 = oip->ip6_dst;
+	hv += dst.in4.s_addr;
+	hv += dport;
+	hv += sport;
+	hv %= fr_statesize;
+	/*
+	 * we make an fin entry to be able to feed it to
+	 * matchsrcdst note that not all fields are encessary
+	 * but this is the cleanest way. Note further we fill
+	 * in fin_mp such that if someone uses it we'll get
+	 * a kernel panic. fr_matchsrcdst does not use this.
+	 *
+	 * watch out here, as ip is in host order and oip in network
+	 * order. Any change we make must be undone afterwards.
+	 */
+	savelen = oip->ip6_plen;
+	oip->ip6_plen = ip->ip6_plen - sizeof(*ip) - ICMPERR_ICMPHLEN;
+	ofin.fin_v = 6;
+	fr_makefrip(sizeof(*oip), (ip_t *)oip, &ofin);
+	oip->ip6_plen = savelen;
+	ofin.fin_ifp = fin->fin_ifp;
+	ofin.fin_out = !fin->fin_out;
+	ofin.fin_mp = NULL; /* if dereferenced, panic XXX */
+	READ_ENTER(&ipf_state);
+	for (isp = &ips_table[hv]; (is = *isp); isp = &is->is_hnext) {
+		/*
+		 * Only allow this icmp though if the
+		 * encapsulated packet was allowed through the
+		 * other way around. Note that the minimal amount
+		 * of info present does not allow for checking against
+		 * tcp internals such as seq and ack numbers.
+		 */
+		if ((is->is_p == pr) && (is->is_v == 6) &&
+		    fr_matchsrcdst(is, src, dst, &ofin, tcp)) {
+			fr = is->is_rule;
+			ips_stats.iss_hits++;
+			/*
+			 * we must swap src and dst here because the icmp
+			 * comes the other way around
+			 */
+			is->is_pkts++;
+			is->is_bytes += fin->fin_plen;
+			/*
+			 * we deliberately do not touch the timeouts
+			 * for the accompanying state table entry.
+			 * It remains to be seen if that is correct. XXX
+			 */
+			RWLOCK_EXIT(&ipf_state);
+			return fr;
 		}
+	}
 	RWLOCK_EXIT(&ipf_state);
+	return NULL;
 }
+#endif
diff --git a/sys/contrib/ipfilter/netinet/ip_state.h b/sys/contrib/ipfilter/netinet/ip_state.h
index 7b8803f..675b50b 100644
--- a/sys/contrib/ipfilter/netinet/ip_state.h
+++ b/sys/contrib/ipfilter/netinet/ip_state.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-1998 by Darren Reed.
+ * Copyright (C) 1995-2000 by Darren Reed.
  *
  * Redistribution and use in source and binary forms are permitted
  * provided that this notice is preserved and due credit is given
@@ -12,6 +12,12 @@
 #ifndef	__IP_STATE_H__
 #define	__IP_STATE_H__
 
+#if defined(__STDC__) || defined(__GNUC__)
+# define	SIOCDELST	_IOW('r', 61, struct ipstate *)
+#else
+# define	SIOCDELST	_IOW(r, 61, struct ipstate *)
+#endif
+
 #define	IPSTATE_SIZE	257
 #define	IPSTATE_MAX	2048	/* Maximum number of states held */
 
@@ -47,17 +53,20 @@ typedef	struct tcpstate {
 
 typedef struct ipstate {
 	struct	ipstate	*is_next;
+	struct	ipstate	**is_pnext;
+	struct	ipstate	*is_hnext;
+	struct	ipstate	**is_phnext;
 	u_long	is_age;
 	u_int	is_pass;
 	U_QUAD_T	is_pkts;
 	U_QUAD_T	is_bytes;
-	void	*is_ifpin;
-	void	*is_ifpout;
+	void	*is_ifp[2];
 	frentry_t	*is_rule;
-	struct	in_addr	is_src;
-	struct	in_addr	is_dst;
+	union	i6addr	is_src;
+	union	i6addr	is_dst;
 	u_char	is_p;			/* Protocol */
-	u_char	is_rout;		/* Is rule in/out ? */
+	u_char	is_v;
+	u_int	is_hv;
 	u_32_t	is_flags;
 	u_32_t	is_opt;			/* packet options set */
 	u_32_t	is_optmsk;		/*    "      "    mask */
@@ -70,15 +79,21 @@ typedef struct ipstate {
 		tcpstate_t	is_ts;
 		udpstate_t	is_us;
 	} is_ps;
+	char	is_ifname[2][IFNAMSIZ];
+#if SOLARIS || defined(__sgi)
+	kmutex_t	is_lock;
+#endif
 } ipstate_t;
 
-#define	is_icmp	is_ps.is_ics
-#define	is_type	is_icmp.ics_type
-#define	is_code	is_icmp.ics_code
-#define	is_tcp	is_ps.is_ts
-#define	is_udp	is_ps.is_us
-#define is_send	is_tcp.ts_data[0].td_end
-#define is_dend	is_tcp.ts_data[1].td_end
+#define	is_saddr	is_src.in4.s_addr
+#define	is_daddr	is_dst.in4.s_addr
+#define	is_icmp		is_ps.is_ics
+#define	is_type		is_icmp.ics_type
+#define	is_code		is_icmp.ics_code
+#define	is_tcp		is_ps.is_ts
+#define	is_udp		is_ps.is_us
+#define is_send		is_tcp.ts_data[0].td_end
+#define is_dend		is_tcp.ts_data[1].td_end
 #define is_maxswin	is_tcp.ts_data[0].td_maxwin
 #define is_maxdwin	is_tcp.ts_data[1].td_maxwin
 #define is_maxsend	is_tcp.ts_data[0].td_maxend
@@ -86,6 +101,8 @@ typedef struct ipstate {
 #define	is_sport	is_tcp.ts_sport
 #define	is_dport	is_tcp.ts_dport
 #define	is_state	is_tcp.ts_state
+#define	is_ifpin	is_ifp[0]
+#define	is_ifpout	is_ifp[1]
 
 #define	TH_OPENING	(TH_SYN|TH_ACK)
 /*
@@ -97,21 +114,30 @@ typedef struct ipstate {
  * Bits 8,9 are used to indicate wildcard source/destination port matching.
  */
 
+typedef	struct	ipstate_save	{
+	void	*ips_next;
+	struct	ipstate	ips_is;
+	struct	frentry	ips_fr;
+} ipstate_save_t;
+
+#define	ips_rule	ips_is.is_rule
+
 
 typedef	struct	ipslog	{
 	U_QUAD_T	isl_pkts;
 	U_QUAD_T	isl_bytes;
-	struct	in_addr	isl_src;
-	struct	in_addr	isl_dst;
-	u_char	isl_p;
-	u_char	isl_flags;
-	u_char	isl_state[2];
+	union	i6addr	isl_src;
+	union	i6addr	isl_dst;
 	u_short	isl_type;
 	union {
 		u_short	isl_filler[2];
 		u_short	isl_ports[2];
 		u_short	isl_icmp;
 	} isl_ps;
+	u_char	isl_v;
+	u_char	isl_p;
+	u_char	isl_flags;
+	u_char	isl_state[2];
 } ipslog_t;
 
 #define	isl_sport	isl_ps.isl_ports[0]
@@ -121,6 +147,7 @@ typedef	struct	ipslog	{
 #define	ISL_NEW		0
 #define	ISL_EXPIRE	0xffff
 #define	ISL_FLUSH	0xfffe
+#define	ISL_REMOVE	0xfffd
 
 
 typedef	struct	ips_stat {
@@ -138,6 +165,7 @@ typedef	struct	ips_stat {
 	u_long	iss_logfail;
 	u_long	iss_inuse;
 	ipstate_t **iss_table;
+	ipstate_t *iss_list;
 } ips_stat_t;
 
 
@@ -148,13 +176,14 @@ extern	u_long	fr_tcptimeout;
 extern	u_long	fr_tcpclosed;
 extern	u_long	fr_udptimeout;
 extern	u_long	fr_icmptimeout;
+extern	int	fr_state_lock;
 extern	int	fr_stateinit __P((void));
 extern	int	fr_tcpstate __P((ipstate_t *, fr_info_t *, ip_t *, tcphdr_t *));
 extern	ipstate_t	*fr_addstate __P((ip_t *, fr_info_t *, u_int));
 extern	frentry_t	*fr_checkstate __P((ip_t *, fr_info_t *));
 extern	void	ip_statesync __P((void *));
 extern	void	fr_timeoutstate __P((void));
-extern	void	fr_tcp_age __P((u_long *, u_char *, ip_t *, fr_info_t *, int));
+extern	void	fr_tcp_age __P((u_long *, u_char *, fr_info_t *, int));
 extern	void	fr_stateunload __P((void));
 extern	void	ipstate_log __P((struct ipstate *, u_int));
 #if defined(__NetBSD__) || defined(__OpenBSD__)