From nobody@FreeBSD.org  Tue Oct 16 07:40:21 2007
Return-Path: <nobody@FreeBSD.org>
Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34])
	by hub.freebsd.org (Postfix) with ESMTP id 2B00516A417
	for <freebsd-gnats-submit@FreeBSD.org>; Tue, 16 Oct 2007 07:40:21 +0000 (UTC)
	(envelope-from nobody@FreeBSD.org)
Received: from www.freebsd.org (www.freebsd.org [IPv6:2001:4f8:fff6::21])
	by mx1.freebsd.org (Postfix) with ESMTP id 2EC9B13C447
	for <freebsd-gnats-submit@FreeBSD.org>; Tue, 16 Oct 2007 07:40:20 +0000 (UTC)
	(envelope-from nobody@FreeBSD.org)
Received: from www.freebsd.org (localhost [127.0.0.1])
	by www.freebsd.org (8.14.1/8.14.1) with ESMTP id l9G7eBJM020109
	for <freebsd-gnats-submit@FreeBSD.org>; Tue, 16 Oct 2007 07:40:11 GMT
	(envelope-from nobody@www.freebsd.org)
Received: (from nobody@localhost)
	by www.freebsd.org (8.14.1/8.14.1/Submit) id l9G7eB9O020108;
	Tue, 16 Oct 2007 07:40:11 GMT
	(envelope-from nobody)
Message-Id: <200710160740.l9G7eB9O020108@www.freebsd.org>
Date: Tue, 16 Oct 2007 07:40:11 GMT
From: John Court <john.w.court@nokia.com>
To: freebsd-gnats-submit@FreeBSD.org
Subject: ipfw send_pkt() and ipfw_tick() don't seem to support IPV6
X-Send-Pr-Version: www-3.1
X-GNATS-Notify:

>Number:         117234
>Category:       kern
>Synopsis:       [ipfw] [patch] ipfw send_pkt() and ipfw_tick() don't seem to support IPV6
>Confidential:   no
>Severity:       serious
>Priority:       low
>Responsible:    freebsd-ipfw
>State:          closed
>Quarter:        
>Keywords:       
>Date-Required:  
>Class:          sw-bug
>Submitter-Id:   current-users
>Arrival-Date:   Tue Oct 16 07:50:01 UTC 2007
>Closed-Date:    Mon Jan 04 15:13:34 UTC 2010
>Last-Modified:  Mon Jan 04 15:13:34 UTC 2010
>Originator:     John Court
>Release:        6.1
>Organization:
Nokia
>Environment:
Hmm sorry but this was found from a review of the code and observance of an issue when porting it to another FreeBSD based platform.
>Description:
I can't see how the send_pkt() routine in ip_fw2.c would create a valid ipv6 
source and destination address.  This is relevent due to its use in 
ipfw_tick(). Basically in an ipv6 configuration when ipfw_tick() goes 
off to send a keep-alive, I think send_pkt() would produce an 
erroneous IPV4 style packet due to its use of id->dst_ip and id->src_ip rather
than  dst_ip6 and src_ip6 ?   

Further, ipfw_tick() then calls ip_output() rather than any ip6_output()
routine.

Cheers

John
>How-To-Repeat:

>Fix:


>Release-Note:
>Audit-Trail:
Responsible-Changed-From-To: freebsd-bugs->mlaier 
Responsible-Changed-By: mlaier 
Responsible-Changed-When: Fri Oct 19 08:54:52 UTC 2007 
Responsible-Changed-Why:  
I'll take a look at this. 

http://www.freebsd.org/cgi/query-pr.cgi?pr=117234 
Responsible-Changed-From-To: mlaier->freebsd-ipfw 
Responsible-Changed-By: mlaier 
Responsible-Changed-When: Thu Oct 25 19:15:51 UTC 2007 
Responsible-Changed-Why:  
Back to the pool, I can't deal with this in a timely manner right now. 

http://www.freebsd.org/cgi/query-pr.cgi?pr=117234 

From: Max Laier <max@love2party.net>
To: bug-followup@freebsd.org,
 john.w.court@nokia.com
Cc:  
Subject: Re: kern/117234: ipfw send_pkt() and ipfw_tick() don't seem to support IPV6
Date: Thu, 25 Oct 2007 21:19:01 +0200

 --Boundary-00=_owOIHQWJlh8L15h
 Content-Type: text/plain;
   charset="us-ascii"
 Content-Transfer-Encoding: 7bit
 Content-Disposition: inline
 
 This is an untested patch which could serve as a starting point.
 
 -- 
   Max
 
 --Boundary-00=_owOIHQWJlh8L15h
 Content-Type: text/plain;
   charset="us-ascii";
   name="ipfw_v6send.diff"
 Content-Transfer-Encoding: 7bit
 Content-Disposition: attachment;
 	filename="ipfw_v6send.diff"
 
 Index: ip_fw2.c
 ===================================================================
 RCS file: /home/ncvs/src/sys/netinet/ip_fw2.c,v
 retrieving revision 1.175
 diff -u -r1.175 ip_fw2.c
 --- ip_fw2.c	7 Oct 2007 20:44:23 -0000	1.175
 +++ ip_fw2.c	19 Oct 2007 12:38:16 -0000
 @@ -98,6 +98,7 @@
  #include <netinet/ip6.h>
  #include <netinet/icmp6.h>
  #ifdef INET6
 +#include <netinet6/ip6_var.h>
  #include <netinet6/scope6_var.h>
  #endif
  
 @@ -241,6 +242,9 @@
  #define	IPFW_DYN_UNLOCK()	mtx_unlock(&ipfw_dyn_mtx)
  #define	IPFW_DYN_LOCK_ASSERT()	mtx_assert(&ipfw_dyn_mtx, MA_OWNED)
  
 +static struct mbuf *send_pkt(struct mbuf *, struct ipfw_flow_id *,
 +    u_int32_t, u_int32_t, int);
 +
  /*
   * Timeouts for various events in handing dynamic rules.
   */
 @@ -671,67 +675,25 @@
  }
  
  static void
 -send_reject6(struct ip_fw_args *args, int code, u_int hlen, struct ip6_hdr *ip6)
 +send_reject6(struct ip_fw_args *args, int code, u_int hlen,
 +    struct ip6_hdr *ip6)
  {
  	struct mbuf *m;
  
  	m = args->m;
  	if (code == ICMP6_UNREACH_RST && args->f_id.proto == IPPROTO_TCP) {
  		struct tcphdr *tcp;
 -		tcp_seq ack, seq;
 -		int flags;
 -		struct {
 -			struct ip6_hdr ip6;
 -			struct tcphdr th;
 -		} ti;
  		tcp = (struct tcphdr *)((char *)ip6 + hlen);
  
 -		if ((tcp->th_flags & TH_RST) != 0) {
 -			m_freem(m);
 -			args->m = NULL;
 -			return;
 -		}
 -
 -		ti.ip6 = *ip6;
 -		ti.th = *tcp;
 -		ti.th.th_seq = ntohl(ti.th.th_seq);
 -		ti.th.th_ack = ntohl(ti.th.th_ack);
 -		ti.ip6.ip6_nxt = IPPROTO_TCP;
 -
 -		if (ti.th.th_flags & TH_ACK) {
 -			ack = 0;
 -			seq = ti.th.th_ack;
 -			flags = TH_RST;
 -		} else {
 -			ack = ti.th.th_seq;
 -			if ((m->m_flags & M_PKTHDR) != 0) {
 -				/*
 -				 * total new data to ACK is:
 -				 * total packet length,
 -				 * minus the header length,
 -				 * minus the tcp header length.
 -				 */
 -				ack += m->m_pkthdr.len - hlen
 -					- (ti.th.th_off << 2);
 -			} else if (ip6->ip6_plen) {
 -				ack += ntohs(ip6->ip6_plen) + sizeof(*ip6) -
 -				    hlen - (ti.th.th_off << 2);
 -			} else {
 -				m_freem(m);
 -				return;
 -			}
 -			if (tcp->th_flags & TH_SYN)
 -				ack++;
 -			seq = 0;
 -			flags = TH_RST|TH_ACK;
 +		if ((tcp->th_flags & TH_RST) == 0) {
 +			struct mbuf *m0;
 +			m0 = send_pkt(args->m, &(args->f_id),
 +				ntohl(tcp->th_seq), ntohl(tcp->th_ack),
 +				tcp->th_flags | TH_RST);
 +			if (m0 != NULL)
 +				ip6_output(m0, NULL, NULL, 0, NULL, NULL, NULL);
  		}
 -		bcopy(&ti, ip6, sizeof(ti));
 -		/*
 -		 * m is only used to recycle the mbuf
 -		 * The data in it is never read so we don't need
 -		 * to correct the offsets or anything
 -		 */
 -		tcp_respond(NULL, ip6, tcp, m, ack, seq, flags);
 +		m_freem(m);
  	} else if (code != ICMP6_UNREACH_RST) { /* Send an ICMPv6 unreach. */
  #if 0
  		/*
 @@ -1609,13 +1571,16 @@
      u_int32_t ack, int flags)
  {
  	struct mbuf *m;
 -	struct ip *ip;
 -	struct tcphdr *tcp;
 +	int len, dir;
 +	struct ip *h = NULL;		/* stupid compiler */
 +#ifdef INET6
 +	struct ip6_hdr *h6 = NULL;
 +#endif
 +	struct tcphdr *th = NULL;
  
  	MGETHDR(m, M_DONTWAIT, MT_DATA);
 -	if (m == 0)
 +	if (m == NULL)
  		return (NULL);
 -	m->m_pkthdr.rcvif = (struct ifnet *)0;
  
  #ifdef MAC
  	if (replyto != NULL)
 @@ -1626,67 +1591,118 @@
  	(void)replyto;		/* don't warn about unused arg */
  #endif
  
 -	m->m_pkthdr.len = m->m_len = sizeof(struct ip) + sizeof(struct tcphdr);
 +	switch (id->addr_type) {
 +	case 4:
 +		len = sizeof(struct ip) + sizeof(struct tcphdr);
 +		break;
 +#ifdef INET6
 +	case 6:
 +		len = sizeof(struct ip6_hdr) + sizeof(struct tcphdr);
 +		break;
 +#endif
 +	default:
 +		/* XXX: log me?!? */
 +		m_freem(m);
 +		return (NULL);
 +	}
 +	dir = ((flags & (TH_SYN | TH_RST)) == TH_SYN);
 +
  	m->m_data += max_linkhdr;
 +	m->m_flags |= M_SKIP_FIREWALL;
 +	m->m_pkthdr.len = m->m_len = len;
 +	m->m_pkthdr.rcvif = NULL;
 +	bzero(m->m_data, len);
 +
 +	switch (id->addr_type) {
 +	case 4:
 +		h = mtod(m, struct ip *);
 +
 +		/* prepare for checksum */
 +		h->ip_p = IPPROTO_TCP;
 +		h->ip_len = htons(sizeof(struct tcphdr));
 +		if (dir) {
 +			h->ip_src.s_addr = htonl(id->src_ip);
 +			h->ip_dst.s_addr = htonl(id->dst_ip);
 +		} else {
 +			h->ip_src.s_addr = htonl(id->dst_ip);
 +			h->ip_dst.s_addr = htonl(id->src_ip);
 +		}
  
 -	ip = mtod(m, struct ip *);
 -	bzero(ip, m->m_len);
 -	tcp = (struct tcphdr *)(ip + 1); /* no IP options */
 -	ip->ip_p = IPPROTO_TCP;
 -	tcp->th_off = 5;
 -	/*
 -	 * Assume we are sending a RST (or a keepalive in the reverse
 -	 * direction), swap src and destination addresses and ports.
 -	 */
 -	ip->ip_src.s_addr = htonl(id->dst_ip);
 -	ip->ip_dst.s_addr = htonl(id->src_ip);
 -	tcp->th_sport = htons(id->dst_port);
 -	tcp->th_dport = htons(id->src_port);
 -	if (flags & TH_RST) {	/* we are sending a RST */
 +		th = (struct tcphdr *)(h + 1);
 +		break;
 +#ifdef INET6
 +	case 6:
 +		h6 = mtod(m, struct ip6_hdr *);
 +
 +		/* prepare for checksum */
 +		h6->ip6_nxt = IPPROTO_TCP;
 +		h6->ip6_plen = htons(sizeof(struct tcphdr));
 +		if (dir) {
 +			h6->ip6_src = id->src_ip6;
 +			h6->ip6_dst = id->dst_ip6;
 +		} else {
 +			h6->ip6_src = id->dst_ip6;
 +			h6->ip6_dst = id->src_ip6;
 +		}
 +
 +		th = (struct tcphdr *)(h6 + 1);
 +		break;
 +#endif
 +	}
 +
 +	if (dir) {
 +		th->th_sport = id->src_port;
 +		th->th_dport = id->dst_port;
 +	} else {
 +		th->th_sport = id->dst_port;
 +		th->th_dport = id->src_port;
 +	}
 +	th->th_off = sizeof(struct tcphdr) >> 2;
 +
 +	if (flags & TH_RST) {
  		if (flags & TH_ACK) {
 -			tcp->th_seq = htonl(ack);
 -			tcp->th_ack = htonl(0);
 -			tcp->th_flags = TH_RST;
 +			th->th_seq = htonl(ack);
 +			th->th_flags = TH_RST;
  		} else {
  			if (flags & TH_SYN)
  				seq++;
 -			tcp->th_seq = htonl(0);
 -			tcp->th_ack = htonl(seq);
 -			tcp->th_flags = TH_RST | TH_ACK;
 +			th->th_ack = htonl(seq);
 +			th->th_flags = TH_RST | TH_ACK;
  		}
  	} else {
  		/*
 -		 * We are sending a keepalive. flags & TH_SYN determines
 -		 * the direction, forward if set, reverse if clear.
 -		 * NOTE: seq and ack are always assumed to be correct
 -		 * as set by the caller. This may be confusing...
 +		 * Keepalive - use caller provided sequence numbers
  		 */
 -		if (flags & TH_SYN) {
 -			/*
 -			 * we have to rewrite the correct addresses!
 -			 */
 -			ip->ip_dst.s_addr = htonl(id->dst_ip);
 -			ip->ip_src.s_addr = htonl(id->src_ip);
 -			tcp->th_dport = htons(id->dst_port);
 -			tcp->th_sport = htons(id->src_port);
 -		}
 -		tcp->th_seq = htonl(seq);
 -		tcp->th_ack = htonl(ack);
 -		tcp->th_flags = TH_ACK;
 +		th->th_seq = htonl(seq);
 +		th->th_ack = htonl(ack);
 +		th->th_flags = TH_ACK;
 +	}
 +
 +	switch (id->addr_type) {
 +	case 4:
 +		th->th_sum = in_cksum(m, len);
 +
 +		/* finish the ip header */
 +		h->ip_v = 4;
 +		h->ip_hl = sizeof(*h) >> 2;
 +		h->ip_tos = IPTOS_LOWDELAY;
 +		h->ip_off = 0;
 +		h->ip_len = len;
 +		h->ip_ttl = ip_defttl;
 +		h->ip_sum = 0;
 +		break;
 +#ifdef INET6
 +	case 6:
 +		th->th_sum = in6_cksum(m, IPPROTO_TCP, sizeof(*h6),
 +		    sizeof(struct tcphdr));
 +
 +		/* finish the ip6 header */
 +		h6->ip6_vfc |= IPV6_VERSION;
 +		h6->ip6_hlim = IPV6_DEFHLIM;
 +		break;
 +#endif
  	}
 -	/*
 -	 * set ip_len to the payload size so we can compute
 -	 * the tcp checksum on the pseudoheader
 -	 * XXX check this, could save a couple of words ?
 -	 */
 -	ip->ip_len = htons(sizeof(struct tcphdr));
 -	tcp->th_sum = in_cksum(m, m->m_pkthdr.len);
 -	/*
 -	 * now fill fields left out earlier
 -	 */
 -	ip->ip_ttl = ip_defttl;
 -	ip->ip_len = m->m_pkthdr.len;
 -	m->m_flags |= M_SKIP_FIREWALL;
 +
  	return (m);
  }
  
 @@ -4860,6 +4876,9 @@
  ipfw_tick(void * __unused unused)
  {
  	struct mbuf *m0, *m, *mnext, **mtailp;
 +#ifdef INET6
 +	struct mbuf *m6, **m6_tailp;
 +#endif
  	int i;
  	ipfw_dyn_rule *q;
  
 @@ -4874,6 +4893,10 @@
  	 */
  	m0 = NULL;
  	mtailp = &m0;
 +#ifdef INET6
 +	m6 = NULL;
 +	m6_tailp = &m6;
 +#endif
  	IPFW_DYN_LOCK();
  	for (i = 0 ; i < curr_dyn_buckets ; i++) {
  		for (q = ipfw_dyn_v[i] ; q ; q = q->next ) {
 @@ -4889,14 +4912,37 @@
  			if (TIME_LEQ(q->expire, time_uptime))
  				continue;	/* too late, rule expired */
  
 -			*mtailp = send_pkt(NULL, &(q->id), q->ack_rev - 1,
 +			m = send_pkt(NULL, &(q->id), q->ack_rev - 1,
  				q->ack_fwd, TH_SYN);
 -			if (*mtailp != NULL)
 -				mtailp = &(*mtailp)->m_nextpkt;
 -			*mtailp = send_pkt(NULL, &(q->id), q->ack_fwd - 1,
 +			mnext = send_pkt(NULL, &(q->id), q->ack_fwd - 1,
  				q->ack_rev, 0);
 -			if (*mtailp != NULL)
 -				mtailp = &(*mtailp)->m_nextpkt;
 +
 +			switch (q->id.addr_type) {
 +			case 4:
 +				if (m != NULL) {
 +					*mtailp = m;
 +					mtailp = &(*mtailp)->m_nextpkt;
 +				}
 +				if (mnext != NULL) {
 +					*mtailp = mnext;
 +					mtailp = &(*mtailp)->m_nextpkt;
 +				}
 +				break;
 +#ifdef INET6
 +			case 6:
 +				if (m != NULL) {
 +					*m6_tailp = m;
 +					m6_tailp = &(*m6_tailp)->m_nextpkt;
 +				}
 +				if (mnext != NULL) {
 +					*m6_tailp = mnext;
 +					m6_tailp = &(*m6_tailp)->m_nextpkt;
 +				}
 +				break;
 +#endif
 +			}
 +
 +			m = mnext = NULL;
  		}
  	}
  	IPFW_DYN_UNLOCK();
 @@ -4905,6 +4951,13 @@
  		m->m_nextpkt = NULL;
  		ip_output(m, NULL, NULL, 0, NULL, NULL);
  	}
 +#ifdef INET6
 +	for (m = mnext = m6; m != NULL; m = mnext) {
 +		mnext = m->m_nextpkt;
 +		m->m_nextpkt = NULL;
 +		ip6_output(m, NULL, NULL, 0, NULL, NULL, NULL);
 +	}
 +#endif
  done:
  	callout_reset(&ipfw_timeout, dyn_keepalive_period*hz, ipfw_tick, NULL);
  }
 
 --Boundary-00=_owOIHQWJlh8L15h--

From: "Joost Bekkers" <joost@jodocus.org>
To: "Max Laier" <max@love2party.net>, bug-followup@FreeBSD.org
Cc: john.w.court@nokia.com
Subject: Re: kern/117234: [ipfw] [patch] ipfw send_pkt() and ipfw_tick() 
     don't seem to support IPV6
Date: Mon, 12 May 2008 08:40:04 +0200 (CEST)

 Hello
 
 
 I've just tried the patch in this PR and found it not to work (yet).
 
 The keep-alive packets that are sent for IPv6 have their tcp port octets
 in the wrong order. Eg. if a dynamic rule exists for a connetion to port
 4000 (0x0FA0), the keepalives are sent to 40975 (0xA00F)
 
 I haven't looked into where this difference between ipv4 and ipv6
 originates, but forcing the byte-swap in send_pkt() makes everything work.
 I'd post the change I made, but I'm fairly sertain it's The Wrong Way (tm)
 to fix this.
 
 
 
 Greetings
 
 Joost.
 

From: "Joost Bekkers" <joost@jodocus.org>
To: bug-followup@FreeBSD.org
Cc:  
Subject: Re: kern/117234: [ipfw] [patch] ipfw send_pkt() and ipfw_tick() 
     don't seem to support IPV6
Date: Mon, 19 May 2008 22:15:20 +0200 (CEST)

 ------=_20080519221520_63844
 Content-Type: text/plain; charset="iso-8859-1"
 Content-Transfer-Encoding: 8bit
 
 Found the problem. Two hton() statements went missing with the original
 patch from mlaier@.
 
 I've attatched a corrected version of the original diff and one against 7.0R
 
 
 ------=_20080519221520_63844
 Content-Type: application/octet-stream; name="ipfw_v6send.diff"
 Content-Transfer-Encoding: base64
 Content-Disposition: attachment; filename="ipfw_v6send.diff"
 
 SW5kZXg6IGlwX2Z3Mi5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT0KUkNTIGZpbGU6IC9ob21lL25jdnMvc3JjL3N5cy9u
 ZXRpbmV0L2lwX2Z3Mi5jLHYKcmV0cmlldmluZyByZXZpc2lvbiAxLjE3NQpkaWZmIC11IC1yMS4x
 NzUgaXBfZncyLmMKLS0tIGlwX2Z3Mi5jCTcgT2N0IDIwMDcgMjA6NDQ6MjMgLTAwMDAJMS4xNzUK
 KysrIGlwX2Z3Mi5jCTE5IE9jdCAyMDA3IDEyOjM4OjE2IC0wMDAwCkBAIC05OCw2ICs5OCw3IEBA
 CiAjaW5jbHVkZSA8bmV0aW5ldC9pcDYuaD4KICNpbmNsdWRlIDxuZXRpbmV0L2ljbXA2Lmg+CiAj
 aWZkZWYgSU5FVDYKKyNpbmNsdWRlIDxuZXRpbmV0Ni9pcDZfdmFyLmg+CiAjaW5jbHVkZSA8bmV0
 aW5ldDYvc2NvcGU2X3Zhci5oPgogI2VuZGlmCiAKQEAgLTI0MSw2ICsyNDIsOSBAQAogI2RlZmlu
 ZQlJUEZXX0RZTl9VTkxPQ0soKQltdHhfdW5sb2NrKCZpcGZ3X2R5bl9tdHgpCiAjZGVmaW5lCUlQ
 RldfRFlOX0xPQ0tfQVNTRVJUKCkJbXR4X2Fzc2VydCgmaXBmd19keW5fbXR4LCBNQV9PV05FRCkK
 IAorc3RhdGljIHN0cnVjdCBtYnVmICpzZW5kX3BrdChzdHJ1Y3QgbWJ1ZiAqLCBzdHJ1Y3QgaXBm
 d19mbG93X2lkICosCisgICAgdV9pbnQzMl90LCB1X2ludDMyX3QsIGludCk7CisKIC8qCiAgKiBU
 aW1lb3V0cyBmb3IgdmFyaW91cyBldmVudHMgaW4gaGFuZGluZyBkeW5hbWljIHJ1bGVzLgogICov
 CkBAIC02NzEsNjcgKzY3NSwyNSBAQAogfQogCiBzdGF0aWMgdm9pZAotc2VuZF9yZWplY3Q2KHN0
 cnVjdCBpcF9md19hcmdzICphcmdzLCBpbnQgY29kZSwgdV9pbnQgaGxlbiwgc3RydWN0IGlwNl9o
 ZHIgKmlwNikKK3NlbmRfcmVqZWN0NihzdHJ1Y3QgaXBfZndfYXJncyAqYXJncywgaW50IGNvZGUs
 IHVfaW50IGhsZW4sCisgICAgc3RydWN0IGlwNl9oZHIgKmlwNikKIHsKIAlzdHJ1Y3QgbWJ1ZiAq
 bTsKIAogCW0gPSBhcmdzLT5tOwogCWlmIChjb2RlID09IElDTVA2X1VOUkVBQ0hfUlNUICYmIGFy
 Z3MtPmZfaWQucHJvdG8gPT0gSVBQUk9UT19UQ1ApIHsKIAkJc3RydWN0IHRjcGhkciAqdGNwOwot
 CQl0Y3Bfc2VxIGFjaywgc2VxOwotCQlpbnQgZmxhZ3M7Ci0JCXN0cnVjdCB7Ci0JCQlzdHJ1Y3Qg
 aXA2X2hkciBpcDY7Ci0JCQlzdHJ1Y3QgdGNwaGRyIHRoOwotCQl9IHRpOwogCQl0Y3AgPSAoc3Ry
 dWN0IHRjcGhkciAqKSgoY2hhciAqKWlwNiArIGhsZW4pOwogCi0JCWlmICgodGNwLT50aF9mbGFn
 cyAmIFRIX1JTVCkgIT0gMCkgewotCQkJbV9mcmVlbShtKTsKLQkJCWFyZ3MtPm0gPSBOVUxMOwot
 CQkJcmV0dXJuOwotCQl9Ci0KLQkJdGkuaXA2ID0gKmlwNjsKLQkJdGkudGggPSAqdGNwOwotCQl0
 aS50aC50aF9zZXEgPSBudG9obCh0aS50aC50aF9zZXEpOwotCQl0aS50aC50aF9hY2sgPSBudG9o
 bCh0aS50aC50aF9hY2spOwotCQl0aS5pcDYuaXA2X254dCA9IElQUFJPVE9fVENQOwotCi0JCWlm
 ICh0aS50aC50aF9mbGFncyAmIFRIX0FDSykgewotCQkJYWNrID0gMDsKLQkJCXNlcSA9IHRpLnRo
 LnRoX2FjazsKLQkJCWZsYWdzID0gVEhfUlNUOwotCQl9IGVsc2UgewotCQkJYWNrID0gdGkudGgu
 dGhfc2VxOwotCQkJaWYgKChtLT5tX2ZsYWdzICYgTV9QS1RIRFIpICE9IDApIHsKLQkJCQkvKgot
 CQkJCSAqIHRvdGFsIG5ldyBkYXRhIHRvIEFDSyBpczoKLQkJCQkgKiB0b3RhbCBwYWNrZXQgbGVu
 Z3RoLAotCQkJCSAqIG1pbnVzIHRoZSBoZWFkZXIgbGVuZ3RoLAotCQkJCSAqIG1pbnVzIHRoZSB0
 Y3AgaGVhZGVyIGxlbmd0aC4KLQkJCQkgKi8KLQkJCQlhY2sgKz0gbS0+bV9wa3RoZHIubGVuIC0g
 aGxlbgotCQkJCQktICh0aS50aC50aF9vZmYgPDwgMik7Ci0JCQl9IGVsc2UgaWYgKGlwNi0+aXA2
 X3BsZW4pIHsKLQkJCQlhY2sgKz0gbnRvaHMoaXA2LT5pcDZfcGxlbikgKyBzaXplb2YoKmlwNikg
 LQotCQkJCSAgICBobGVuIC0gKHRpLnRoLnRoX29mZiA8PCAyKTsKLQkJCX0gZWxzZSB7Ci0JCQkJ
 bV9mcmVlbShtKTsKLQkJCQlyZXR1cm47Ci0JCQl9Ci0JCQlpZiAodGNwLT50aF9mbGFncyAmIFRI
 X1NZTikKLQkJCQlhY2srKzsKLQkJCXNlcSA9IDA7Ci0JCQlmbGFncyA9IFRIX1JTVHxUSF9BQ0s7
 CisJCWlmICgodGNwLT50aF9mbGFncyAmIFRIX1JTVCkgPT0gMCkgeworCQkJc3RydWN0IG1idWYg
 Km0wOworCQkJbTAgPSBzZW5kX3BrdChhcmdzLT5tLCAmKGFyZ3MtPmZfaWQpLAorCQkJCW50b2hs
 KHRjcC0+dGhfc2VxKSwgbnRvaGwodGNwLT50aF9hY2spLAorCQkJCXRjcC0+dGhfZmxhZ3MgfCBU
 SF9SU1QpOworCQkJaWYgKG0wICE9IE5VTEwpCisJCQkJaXA2X291dHB1dChtMCwgTlVMTCwgTlVM
 TCwgMCwgTlVMTCwgTlVMTCwgTlVMTCk7CiAJCX0KLQkJYmNvcHkoJnRpLCBpcDYsIHNpemVvZih0
 aSkpOwotCQkvKgotCQkgKiBtIGlzIG9ubHkgdXNlZCB0byByZWN5Y2xlIHRoZSBtYnVmCi0JCSAq
 IFRoZSBkYXRhIGluIGl0IGlzIG5ldmVyIHJlYWQgc28gd2UgZG9uJ3QgbmVlZAotCQkgKiB0byBj
 b3JyZWN0IHRoZSBvZmZzZXRzIG9yIGFueXRoaW5nCi0JCSAqLwotCQl0Y3BfcmVzcG9uZChOVUxM
 LCBpcDYsIHRjcCwgbSwgYWNrLCBzZXEsIGZsYWdzKTsKKwkJbV9mcmVlbShtKTsKIAl9IGVsc2Ug
 aWYgKGNvZGUgIT0gSUNNUDZfVU5SRUFDSF9SU1QpIHsgLyogU2VuZCBhbiBJQ01QdjYgdW5yZWFj
 aC4gKi8KICNpZiAwCiAJCS8qCkBAIC0xNjA5LDEzICsxNTcxLDE2IEBACiAgICAgdV9pbnQzMl90
 IGFjaywgaW50IGZsYWdzKQogewogCXN0cnVjdCBtYnVmICptOwotCXN0cnVjdCBpcCAqaXA7Ci0J
 c3RydWN0IHRjcGhkciAqdGNwOworCWludCBsZW4sIGRpcjsKKwlzdHJ1Y3QgaXAgKmggPSBOVUxM
 OwkJLyogc3R1cGlkIGNvbXBpbGVyICovCisjaWZkZWYgSU5FVDYKKwlzdHJ1Y3QgaXA2X2hkciAq
 aDYgPSBOVUxMOworI2VuZGlmCisJc3RydWN0IHRjcGhkciAqdGggPSBOVUxMOwogCiAJTUdFVEhE
 UihtLCBNX0RPTlRXQUlULCBNVF9EQVRBKTsKLQlpZiAobSA9PSAwKQorCWlmIChtID09IE5VTEwp
 CiAJCXJldHVybiAoTlVMTCk7Ci0JbS0+bV9wa3RoZHIucmN2aWYgPSAoc3RydWN0IGlmbmV0ICop
 MDsKIAogI2lmZGVmIE1BQwogCWlmIChyZXBseXRvICE9IE5VTEwpCkBAIC0xNjI2LDY3ICsxNTkx
 LDExOCBAQAogCSh2b2lkKXJlcGx5dG87CQkvKiBkb24ndCB3YXJuIGFib3V0IHVudXNlZCBhcmcg
 Ki8KICNlbmRpZgogCi0JbS0+bV9wa3RoZHIubGVuID0gbS0+bV9sZW4gPSBzaXplb2Yoc3RydWN0
 IGlwKSArIHNpemVvZihzdHJ1Y3QgdGNwaGRyKTsKKwlzd2l0Y2ggKGlkLT5hZGRyX3R5cGUpIHsK
 KwljYXNlIDQ6CisJCWxlbiA9IHNpemVvZihzdHJ1Y3QgaXApICsgc2l6ZW9mKHN0cnVjdCB0Y3Bo
 ZHIpOworCQlicmVhazsKKyNpZmRlZiBJTkVUNgorCWNhc2UgNjoKKwkJbGVuID0gc2l6ZW9mKHN0
 cnVjdCBpcDZfaGRyKSArIHNpemVvZihzdHJ1Y3QgdGNwaGRyKTsKKwkJYnJlYWs7CisjZW5kaWYK
 KwlkZWZhdWx0OgorCQkvKiBYWFg6IGxvZyBtZT8hPyAqLworCQltX2ZyZWVtKG0pOworCQlyZXR1
 cm4gKE5VTEwpOworCX0KKwlkaXIgPSAoKGZsYWdzICYgKFRIX1NZTiB8IFRIX1JTVCkpID09IFRI
 X1NZTik7CisKIAltLT5tX2RhdGEgKz0gbWF4X2xpbmtoZHI7CisJbS0+bV9mbGFncyB8PSBNX1NL
 SVBfRklSRVdBTEw7CisJbS0+bV9wa3RoZHIubGVuID0gbS0+bV9sZW4gPSBsZW47CisJbS0+bV9w
 a3RoZHIucmN2aWYgPSBOVUxMOworCWJ6ZXJvKG0tPm1fZGF0YSwgbGVuKTsKKworCXN3aXRjaCAo
 aWQtPmFkZHJfdHlwZSkgeworCWNhc2UgNDoKKwkJaCA9IG10b2QobSwgc3RydWN0IGlwICopOwor
 CisJCS8qIHByZXBhcmUgZm9yIGNoZWNrc3VtICovCisJCWgtPmlwX3AgPSBJUFBST1RPX1RDUDsK
 KwkJaC0+aXBfbGVuID0gaHRvbnMoc2l6ZW9mKHN0cnVjdCB0Y3BoZHIpKTsKKwkJaWYgKGRpcikg
 eworCQkJaC0+aXBfc3JjLnNfYWRkciA9IGh0b25sKGlkLT5zcmNfaXApOworCQkJaC0+aXBfZHN0
 LnNfYWRkciA9IGh0b25sKGlkLT5kc3RfaXApOworCQl9IGVsc2UgeworCQkJaC0+aXBfc3JjLnNf
 YWRkciA9IGh0b25sKGlkLT5kc3RfaXApOworCQkJaC0+aXBfZHN0LnNfYWRkciA9IGh0b25sKGlk
 LT5zcmNfaXApOworCQl9CiAKLQlpcCA9IG10b2QobSwgc3RydWN0IGlwICopOwotCWJ6ZXJvKGlw
 LCBtLT5tX2xlbik7Ci0JdGNwID0gKHN0cnVjdCB0Y3BoZHIgKikoaXAgKyAxKTsgLyogbm8gSVAg
 b3B0aW9ucyAqLwotCWlwLT5pcF9wID0gSVBQUk9UT19UQ1A7Ci0JdGNwLT50aF9vZmYgPSA1Owot
 CS8qCi0JICogQXNzdW1lIHdlIGFyZSBzZW5kaW5nIGEgUlNUIChvciBhIGtlZXBhbGl2ZSBpbiB0
 aGUgcmV2ZXJzZQotCSAqIGRpcmVjdGlvbiksIHN3YXAgc3JjIGFuZCBkZXN0aW5hdGlvbiBhZGRy
 ZXNzZXMgYW5kIHBvcnRzLgotCSAqLwotCWlwLT5pcF9zcmMuc19hZGRyID0gaHRvbmwoaWQtPmRz
 dF9pcCk7Ci0JaXAtPmlwX2RzdC5zX2FkZHIgPSBodG9ubChpZC0+c3JjX2lwKTsKLQl0Y3AtPnRo
 X3Nwb3J0ID0gaHRvbnMoaWQtPmRzdF9wb3J0KTsKLQl0Y3AtPnRoX2Rwb3J0ID0gaHRvbnMoaWQt
 PnNyY19wb3J0KTsKLQlpZiAoZmxhZ3MgJiBUSF9SU1QpIHsJLyogd2UgYXJlIHNlbmRpbmcgYSBS
 U1QgKi8KKwkJdGggPSAoc3RydWN0IHRjcGhkciAqKShoICsgMSk7CisJCWJyZWFrOworI2lmZGVm
 IElORVQ2CisJY2FzZSA2OgorCQloNiA9IG10b2QobSwgc3RydWN0IGlwNl9oZHIgKik7CisKKwkJ
 LyogcHJlcGFyZSBmb3IgY2hlY2tzdW0gKi8KKwkJaDYtPmlwNl9ueHQgPSBJUFBST1RPX1RDUDsK
 KwkJaDYtPmlwNl9wbGVuID0gaHRvbnMoc2l6ZW9mKHN0cnVjdCB0Y3BoZHIpKTsKKwkJaWYgKGRp
 cikgeworCQkJaDYtPmlwNl9zcmMgPSBpZC0+c3JjX2lwNjsKKwkJCWg2LT5pcDZfZHN0ID0gaWQt
 PmRzdF9pcDY7CisJCX0gZWxzZSB7CisJCQloNi0+aXA2X3NyYyA9IGlkLT5kc3RfaXA2OworCQkJ
 aDYtPmlwNl9kc3QgPSBpZC0+c3JjX2lwNjsKKwkJfQorCisJCXRoID0gKHN0cnVjdCB0Y3BoZHIg
 KikoaDYgKyAxKTsKKwkJYnJlYWs7CisjZW5kaWYKKwl9CisKKwlpZiAoZGlyKSB7CisJCXRoLT50
 aF9zcG9ydCA9IGh0b25zKGlkLT5zcmNfcG9ydCk7CisJCXRoLT50aF9kcG9ydCA9IGh0b25zKGlk
 LT5kc3RfcG9ydCk7CisJfSBlbHNlIHsKKwkJdGgtPnRoX3Nwb3J0ID0gaHRvbnMoaWQtPmRzdF9w
 b3J0KTsKKwkJdGgtPnRoX2Rwb3J0ID0gaHRvbnMoaWQtPnNyY19wb3J0KTsKKwl9CisJdGgtPnRo
 X29mZiA9IHNpemVvZihzdHJ1Y3QgdGNwaGRyKSA+PiAyOworCisJaWYgKGZsYWdzICYgVEhfUlNU
 KSB7CiAJCWlmIChmbGFncyAmIFRIX0FDSykgewotCQkJdGNwLT50aF9zZXEgPSBodG9ubChhY2sp
 OwotCQkJdGNwLT50aF9hY2sgPSBodG9ubCgwKTsKLQkJCXRjcC0+dGhfZmxhZ3MgPSBUSF9SU1Q7
 CisJCQl0aC0+dGhfc2VxID0gaHRvbmwoYWNrKTsKKwkJCXRoLT50aF9mbGFncyA9IFRIX1JTVDsK
 IAkJfSBlbHNlIHsKIAkJCWlmIChmbGFncyAmIFRIX1NZTikKIAkJCQlzZXErKzsKLQkJCXRjcC0+
 dGhfc2VxID0gaHRvbmwoMCk7Ci0JCQl0Y3AtPnRoX2FjayA9IGh0b25sKHNlcSk7Ci0JCQl0Y3At
 PnRoX2ZsYWdzID0gVEhfUlNUIHwgVEhfQUNLOworCQkJdGgtPnRoX2FjayA9IGh0b25sKHNlcSk7
 CisJCQl0aC0+dGhfZmxhZ3MgPSBUSF9SU1QgfCBUSF9BQ0s7CiAJCX0KIAl9IGVsc2UgewogCQkv
 KgotCQkgKiBXZSBhcmUgc2VuZGluZyBhIGtlZXBhbGl2ZS4gZmxhZ3MgJiBUSF9TWU4gZGV0ZXJt
 aW5lcwotCQkgKiB0aGUgZGlyZWN0aW9uLCBmb3J3YXJkIGlmIHNldCwgcmV2ZXJzZSBpZiBjbGVh
 ci4KLQkJICogTk9URTogc2VxIGFuZCBhY2sgYXJlIGFsd2F5cyBhc3N1bWVkIHRvIGJlIGNvcnJl
 Y3QKLQkJICogYXMgc2V0IGJ5IHRoZSBjYWxsZXIuIFRoaXMgbWF5IGJlIGNvbmZ1c2luZy4uLgor
 CQkgKiBLZWVwYWxpdmUgLSB1c2UgY2FsbGVyIHByb3ZpZGVkIHNlcXVlbmNlIG51bWJlcnMKIAkJ
 ICovCi0JCWlmIChmbGFncyAmIFRIX1NZTikgewotCQkJLyoKLQkJCSAqIHdlIGhhdmUgdG8gcmV3
 cml0ZSB0aGUgY29ycmVjdCBhZGRyZXNzZXMhCi0JCQkgKi8KLQkJCWlwLT5pcF9kc3Quc19hZGRy
 ID0gaHRvbmwoaWQtPmRzdF9pcCk7Ci0JCQlpcC0+aXBfc3JjLnNfYWRkciA9IGh0b25sKGlkLT5z
 cmNfaXApOwotCQkJdGNwLT50aF9kcG9ydCA9IGh0b25zKGlkLT5kc3RfcG9ydCk7Ci0JCQl0Y3At
 PnRoX3Nwb3J0ID0gaHRvbnMoaWQtPnNyY19wb3J0KTsKLQkJfQotCQl0Y3AtPnRoX3NlcSA9IGh0
 b25sKHNlcSk7Ci0JCXRjcC0+dGhfYWNrID0gaHRvbmwoYWNrKTsKLQkJdGNwLT50aF9mbGFncyA9
 IFRIX0FDSzsKKwkJdGgtPnRoX3NlcSA9IGh0b25sKHNlcSk7CisJCXRoLT50aF9hY2sgPSBodG9u
 bChhY2spOworCQl0aC0+dGhfZmxhZ3MgPSBUSF9BQ0s7CisJfQorCisJc3dpdGNoIChpZC0+YWRk
 cl90eXBlKSB7CisJY2FzZSA0OgorCQl0aC0+dGhfc3VtID0gaW5fY2tzdW0obSwgbGVuKTsKKwor
 CQkvKiBmaW5pc2ggdGhlIGlwIGhlYWRlciAqLworCQloLT5pcF92ID0gNDsKKwkJaC0+aXBfaGwg
 PSBzaXplb2YoKmgpID4+IDI7CisJCWgtPmlwX3RvcyA9IElQVE9TX0xPV0RFTEFZOworCQloLT5p
 cF9vZmYgPSAwOworCQloLT5pcF9sZW4gPSBsZW47CisJCWgtPmlwX3R0bCA9IGlwX2RlZnR0bDsK
 KwkJaC0+aXBfc3VtID0gMDsKKwkJYnJlYWs7CisjaWZkZWYgSU5FVDYKKwljYXNlIDY6CisJCXRo
 LT50aF9zdW0gPSBpbjZfY2tzdW0obSwgSVBQUk9UT19UQ1AsIHNpemVvZigqaDYpLAorCQkgICAg
 c2l6ZW9mKHN0cnVjdCB0Y3BoZHIpKTsKKworCQkvKiBmaW5pc2ggdGhlIGlwNiBoZWFkZXIgKi8K
 KwkJaDYtPmlwNl92ZmMgfD0gSVBWNl9WRVJTSU9OOworCQloNi0+aXA2X2hsaW0gPSBJUFY2X0RF
 RkhMSU07CisJCWJyZWFrOworI2VuZGlmCiAJfQotCS8qCi0JICogc2V0IGlwX2xlbiB0byB0aGUg
 cGF5bG9hZCBzaXplIHNvIHdlIGNhbiBjb21wdXRlCi0JICogdGhlIHRjcCBjaGVja3N1bSBvbiB0
 aGUgcHNldWRvaGVhZGVyCi0JICogWFhYIGNoZWNrIHRoaXMsIGNvdWxkIHNhdmUgYSBjb3VwbGUg
 b2Ygd29yZHMgPwotCSAqLwotCWlwLT5pcF9sZW4gPSBodG9ucyhzaXplb2Yoc3RydWN0IHRjcGhk
 cikpOwotCXRjcC0+dGhfc3VtID0gaW5fY2tzdW0obSwgbS0+bV9wa3RoZHIubGVuKTsKLQkvKgot
 CSAqIG5vdyBmaWxsIGZpZWxkcyBsZWZ0IG91dCBlYXJsaWVyCi0JICovCi0JaXAtPmlwX3R0bCA9
 IGlwX2RlZnR0bDsKLQlpcC0+aXBfbGVuID0gbS0+bV9wa3RoZHIubGVuOwotCW0tPm1fZmxhZ3Mg
 fD0gTV9TS0lQX0ZJUkVXQUxMOworCiAJcmV0dXJuIChtKTsKIH0KIApAQCAtNDg2MCw2ICs0ODc2
 LDkgQEAKIGlwZndfdGljayh2b2lkICogX191bnVzZWQgdW51c2VkKQogewogCXN0cnVjdCBtYnVm
 ICptMCwgKm0sICptbmV4dCwgKiptdGFpbHA7CisjaWZkZWYgSU5FVDYKKwlzdHJ1Y3QgbWJ1ZiAq
 bTYsICoqbTZfdGFpbHA7CisjZW5kaWYKIAlpbnQgaTsKIAlpcGZ3X2R5bl9ydWxlICpxOwogCkBA
 IC00ODc0LDYgKzQ4OTMsMTAgQEAKIAkgKi8KIAltMCA9IE5VTEw7CiAJbXRhaWxwID0gJm0wOwor
 I2lmZGVmIElORVQ2CisJbTYgPSBOVUxMOworCW02X3RhaWxwID0gJm02OworI2VuZGlmCiAJSVBG
 V19EWU5fTE9DSygpOwogCWZvciAoaSA9IDAgOyBpIDwgY3Vycl9keW5fYnVja2V0cyA7IGkrKykg
 ewogCQlmb3IgKHEgPSBpcGZ3X2R5bl92W2ldIDsgcSA7IHEgPSBxLT5uZXh0ICkgewpAQCAtNDg4
 OSwxNCArNDkxMiwzNyBAQAogCQkJaWYgKFRJTUVfTEVRKHEtPmV4cGlyZSwgdGltZV91cHRpbWUp
 KQogCQkJCWNvbnRpbnVlOwkvKiB0b28gbGF0ZSwgcnVsZSBleHBpcmVkICovCiAKLQkJCSptdGFp
 bHAgPSBzZW5kX3BrdChOVUxMLCAmKHEtPmlkKSwgcS0+YWNrX3JldiAtIDEsCisJCQltID0gc2Vu
 ZF9wa3QoTlVMTCwgJihxLT5pZCksIHEtPmFja19yZXYgLSAxLAogCQkJCXEtPmFja19md2QsIFRI
 X1NZTik7Ci0JCQlpZiAoKm10YWlscCAhPSBOVUxMKQotCQkJCW10YWlscCA9ICYoKm10YWlscCkt
 Pm1fbmV4dHBrdDsKLQkJCSptdGFpbHAgPSBzZW5kX3BrdChOVUxMLCAmKHEtPmlkKSwgcS0+YWNr
 X2Z3ZCAtIDEsCisJCQltbmV4dCA9IHNlbmRfcGt0KE5VTEwsICYocS0+aWQpLCBxLT5hY2tfZndk
 IC0gMSwKIAkJCQlxLT5hY2tfcmV2LCAwKTsKLQkJCWlmICgqbXRhaWxwICE9IE5VTEwpCi0JCQkJ
 bXRhaWxwID0gJigqbXRhaWxwKS0+bV9uZXh0cGt0OworCisJCQlzd2l0Y2ggKHEtPmlkLmFkZHJf
 dHlwZSkgeworCQkJY2FzZSA0OgorCQkJCWlmIChtICE9IE5VTEwpIHsKKwkJCQkJKm10YWlscCA9
 IG07CisJCQkJCW10YWlscCA9ICYoKm10YWlscCktPm1fbmV4dHBrdDsKKwkJCQl9CisJCQkJaWYg
 KG1uZXh0ICE9IE5VTEwpIHsKKwkJCQkJKm10YWlscCA9IG1uZXh0OworCQkJCQltdGFpbHAgPSAm
 KCptdGFpbHApLT5tX25leHRwa3Q7CisJCQkJfQorCQkJCWJyZWFrOworI2lmZGVmIElORVQ2CisJ
 CQljYXNlIDY6CisJCQkJaWYgKG0gIT0gTlVMTCkgeworCQkJCQkqbTZfdGFpbHAgPSBtOworCQkJ
 CQltNl90YWlscCA9ICYoKm02X3RhaWxwKS0+bV9uZXh0cGt0OworCQkJCX0KKwkJCQlpZiAobW5l
 eHQgIT0gTlVMTCkgeworCQkJCQkqbTZfdGFpbHAgPSBtbmV4dDsKKwkJCQkJbTZfdGFpbHAgPSAm
 KCptNl90YWlscCktPm1fbmV4dHBrdDsKKwkJCQl9CisJCQkJYnJlYWs7CisjZW5kaWYKKwkJCX0K
 KworCQkJbSA9IG1uZXh0ID0gTlVMTDsKIAkJfQogCX0KIAlJUEZXX0RZTl9VTkxPQ0soKTsKQEAg
 LTQ5MDUsNiArNDk1MSwxMyBAQAogCQltLT5tX25leHRwa3QgPSBOVUxMOwogCQlpcF9vdXRwdXQo
 bSwgTlVMTCwgTlVMTCwgMCwgTlVMTCwgTlVMTCk7CiAJfQorI2lmZGVmIElORVQ2CisJZm9yICht
 ID0gbW5leHQgPSBtNjsgbSAhPSBOVUxMOyBtID0gbW5leHQpIHsKKwkJbW5leHQgPSBtLT5tX25l
 eHRwa3Q7CisJCW0tPm1fbmV4dHBrdCA9IE5VTEw7CisJCWlwNl9vdXRwdXQobSwgTlVMTCwgTlVM
 TCwgMCwgTlVMTCwgTlVMTCwgTlVMTCk7CisJfQorI2VuZGlmCiBkb25lOgogCWNhbGxvdXRfcmVz
 ZXQoJmlwZndfdGltZW91dCwgZHluX2tlZXBhbGl2ZV9wZXJpb2QqaHosIGlwZndfdGljaywgTlVM
 TCk7CiB9CgotLUJvdW5kYXJ5LTAwPV9vd09JSFFXSmxoOEwxNWgtLQo=
 ------=_20080519221520_63844
 Content-Type: application/octet-stream; name="ipfw_v6send_70R.diff"
 Content-Transfer-Encoding: base64
 Content-Disposition: attachment; filename="ipfw_v6send_70R.diff"
 
 LS0tIGlwX2Z3Mi5jLm9yaWcJMjAwOC0wMS0yOCAxNzo0NDozMC4wMDAwMDAwMDAgKzAwMDAKKysr
 IGlwX2Z3Mi5jCTIwMDgtMDUtMTkgMjE6NDU6MjcuMDAwMDAwMDAwICswMDAwCkBAIC0xMDEsNiAr
 MTAxLDcgQEAKICNpbmNsdWRlIDxuZXRpbmV0L2lwNi5oPgogI2luY2x1ZGUgPG5ldGluZXQvaWNt
 cDYuaD4KICNpZmRlZiBJTkVUNgorI2luY2x1ZGUgPG5ldGluZXQ2L2lwNl92YXIuaD4KICNpbmNs
 dWRlIDxuZXRpbmV0Ni9zY29wZTZfdmFyLmg+CiAjZW5kaWYKIApAQCAtMjQ0LDYgKzI0NSw5IEBA
 CiAjZGVmaW5lCUlQRldfRFlOX1VOTE9DSygpCW10eF91bmxvY2soJmlwZndfZHluX210eCkKICNk
 ZWZpbmUJSVBGV19EWU5fTE9DS19BU1NFUlQoKQltdHhfYXNzZXJ0KCZpcGZ3X2R5bl9tdHgsIE1B
 X09XTkVEKQogCitzdGF0aWMgc3RydWN0IG1idWYgKnNlbmRfcGt0KHN0cnVjdCBtYnVmICosIHN0
 cnVjdCBpcGZ3X2Zsb3dfaWQgKiwKKyAgICB1X2ludDMyX3QsIHVfaW50MzJfdCwgaW50KTsKKwog
 LyoKICAqIFRpbWVvdXRzIGZvciB2YXJpb3VzIGV2ZW50cyBpbiBoYW5kaW5nIGR5bmFtaWMgcnVs
 ZXMuCiAgKi8KQEAgLTY3NCw2NyArNjc4LDI1IEBACiB9CiAKIHN0YXRpYyB2b2lkCi1zZW5kX3Jl
 amVjdDYoc3RydWN0IGlwX2Z3X2FyZ3MgKmFyZ3MsIGludCBjb2RlLCB1X2ludCBobGVuLCBzdHJ1
 Y3QgaXA2X2hkciAqaXA2KQorc2VuZF9yZWplY3Q2KHN0cnVjdCBpcF9md19hcmdzICphcmdzLCBp
 bnQgY29kZSwgdV9pbnQgaGxlbiwKKyAgICBzdHJ1Y3QgaXA2X2hkciAqaXA2KQogewogCXN0cnVj
 dCBtYnVmICptOwogCiAJbSA9IGFyZ3MtPm07CiAJaWYgKGNvZGUgPT0gSUNNUDZfVU5SRUFDSF9S
 U1QgJiYgYXJncy0+Zl9pZC5wcm90byA9PSBJUFBST1RPX1RDUCkgewogCQlzdHJ1Y3QgdGNwaGRy
 ICp0Y3A7Ci0JCXRjcF9zZXEgYWNrLCBzZXE7Ci0JCWludCBmbGFnczsKLQkJc3RydWN0IHsKLQkJ
 CXN0cnVjdCBpcDZfaGRyIGlwNjsKLQkJCXN0cnVjdCB0Y3BoZHIgdGg7Ci0JCX0gdGk7CiAJCXRj
 cCA9IChzdHJ1Y3QgdGNwaGRyICopKChjaGFyICopaXA2ICsgaGxlbik7CiAKLQkJaWYgKCh0Y3At
 PnRoX2ZsYWdzICYgVEhfUlNUKSAhPSAwKSB7Ci0JCQltX2ZyZWVtKG0pOwotCQkJYXJncy0+bSA9
 IE5VTEw7Ci0JCQlyZXR1cm47Ci0JCX0KLQotCQl0aS5pcDYgPSAqaXA2OwotCQl0aS50aCA9ICp0
 Y3A7Ci0JCXRpLnRoLnRoX3NlcSA9IG50b2hsKHRpLnRoLnRoX3NlcSk7Ci0JCXRpLnRoLnRoX2Fj
 ayA9IG50b2hsKHRpLnRoLnRoX2Fjayk7Ci0JCXRpLmlwNi5pcDZfbnh0ID0gSVBQUk9UT19UQ1A7
 Ci0KLQkJaWYgKHRpLnRoLnRoX2ZsYWdzICYgVEhfQUNLKSB7Ci0JCQlhY2sgPSAwOwotCQkJc2Vx
 ID0gdGkudGgudGhfYWNrOwotCQkJZmxhZ3MgPSBUSF9SU1Q7Ci0JCX0gZWxzZSB7Ci0JCQlhY2sg
 PSB0aS50aC50aF9zZXE7Ci0JCQlpZiAoKG0tPm1fZmxhZ3MgJiBNX1BLVEhEUikgIT0gMCkgewot
 CQkJCS8qCi0JCQkJICogdG90YWwgbmV3IGRhdGEgdG8gQUNLIGlzOgotCQkJCSAqIHRvdGFsIHBh
 Y2tldCBsZW5ndGgsCi0JCQkJICogbWludXMgdGhlIGhlYWRlciBsZW5ndGgsCi0JCQkJICogbWlu
 dXMgdGhlIHRjcCBoZWFkZXIgbGVuZ3RoLgotCQkJCSAqLwotCQkJCWFjayArPSBtLT5tX3BrdGhk
 ci5sZW4gLSBobGVuCi0JCQkJCS0gKHRpLnRoLnRoX29mZiA8PCAyKTsKLQkJCX0gZWxzZSBpZiAo
 aXA2LT5pcDZfcGxlbikgewotCQkJCWFjayArPSBudG9ocyhpcDYtPmlwNl9wbGVuKSArIHNpemVv
 ZigqaXA2KSAtCi0JCQkJICAgIGhsZW4gLSAodGkudGgudGhfb2ZmIDw8IDIpOwotCQkJfSBlbHNl
 IHsKLQkJCQltX2ZyZWVtKG0pOwotCQkJCXJldHVybjsKLQkJCX0KLQkJCWlmICh0Y3AtPnRoX2Zs
 YWdzICYgVEhfU1lOKQotCQkJCWFjaysrOwotCQkJc2VxID0gMDsKLQkJCWZsYWdzID0gVEhfUlNU
 fFRIX0FDSzsKKwkJaWYgKCh0Y3AtPnRoX2ZsYWdzICYgVEhfUlNUKSA9PSAwKSB7CisJCQlzdHJ1
 Y3QgbWJ1ZiAqbTA7CisJCQltMCA9IHNlbmRfcGt0KGFyZ3MtPm0sICYoYXJncy0+Zl9pZCksCisJ
 CQkJbnRvaGwodGNwLT50aF9zZXEpLCBudG9obCh0Y3AtPnRoX2FjayksCisJCQkJdGNwLT50aF9m
 bGFncyB8IFRIX1JTVCk7CisJCQlpZiAobTAgIT0gTlVMTCkKKwkJCQlpcDZfb3V0cHV0KG0wLCBO
 VUxMLCBOVUxMLCAwLCBOVUxMLCBOVUxMLCBOVUxMKTsKIAkJfQotCQliY29weSgmdGksIGlwNiwg
 c2l6ZW9mKHRpKSk7Ci0JCS8qCi0JCSAqIG0gaXMgb25seSB1c2VkIHRvIHJlY3ljbGUgdGhlIG1i
 dWYKLQkJICogVGhlIGRhdGEgaW4gaXQgaXMgbmV2ZXIgcmVhZCBzbyB3ZSBkb24ndCBuZWVkCi0J
 CSAqIHRvIGNvcnJlY3QgdGhlIG9mZnNldHMgb3IgYW55dGhpbmcKLQkJICovCi0JCXRjcF9yZXNw
 b25kKE5VTEwsIGlwNiwgdGNwLCBtLCBhY2ssIHNlcSwgZmxhZ3MpOworCQltX2ZyZWVtKG0pOwog
 CX0gZWxzZSBpZiAoY29kZSAhPSBJQ01QNl9VTlJFQUNIX1JTVCkgeyAvKiBTZW5kIGFuIElDTVB2
 NiB1bnJlYWNoLiAqLwogI2lmIDAKIAkJLyoKQEAgLTE2MTIsMTMgKzE1NzQsMTYgQEAKICAgICB1
 X2ludDMyX3QgYWNrLCBpbnQgZmxhZ3MpCiB7CiAJc3RydWN0IG1idWYgKm07Ci0Jc3RydWN0IGlw
 ICppcDsKLQlzdHJ1Y3QgdGNwaGRyICp0Y3A7CisJaW50IGxlbiwgZGlyOworCXN0cnVjdCBpcCAq
 aCA9IE5VTEw7CQkvKiBzdHVwaWQgY29tcGlsZXIgKi8KKyNpZmRlZiBJTkVUNgorCXN0cnVjdCBp
 cDZfaGRyICpoNiA9IE5VTEw7CisjZW5kaWYKKwlzdHJ1Y3QgdGNwaGRyICp0aCA9IE5VTEw7CiAK
 IAlNR0VUSERSKG0sIE1fRE9OVFdBSVQsIE1UX0RBVEEpOwotCWlmIChtID09IDApCisJaWYgKG0g
 PT0gTlVMTCkKIAkJcmV0dXJuIChOVUxMKTsKLQltLT5tX3BrdGhkci5yY3ZpZiA9IChzdHJ1Y3Qg
 aWZuZXQgKikwOwogCiAjaWZkZWYgTUFDCiAJaWYgKHJlcGx5dG8gIT0gTlVMTCkKQEAgLTE2Mjks
 NjcgKzE1OTQsMTE4IEBACiAJKHZvaWQpcmVwbHl0bzsJCS8qIGRvbid0IHdhcm4gYWJvdXQgdW51
 c2VkIGFyZyAqLwogI2VuZGlmCiAKLQltLT5tX3BrdGhkci5sZW4gPSBtLT5tX2xlbiA9IHNpemVv
 ZihzdHJ1Y3QgaXApICsgc2l6ZW9mKHN0cnVjdCB0Y3BoZHIpOworCXN3aXRjaCAoaWQtPmFkZHJf
 dHlwZSkgeworCWNhc2UgNDoKKwkJbGVuID0gc2l6ZW9mKHN0cnVjdCBpcCkgKyBzaXplb2Yoc3Ry
 dWN0IHRjcGhkcik7CisJCWJyZWFrOworI2lmZGVmIElORVQ2CisJY2FzZSA2OgorCQlsZW4gPSBz
 aXplb2Yoc3RydWN0IGlwNl9oZHIpICsgc2l6ZW9mKHN0cnVjdCB0Y3BoZHIpOworCQlicmVhazsK
 KyNlbmRpZgorCWRlZmF1bHQ6CisJCS8qIFhYWDogbG9nIG1lPyE/ICovCisJCW1fZnJlZW0obSk7
 CisJCXJldHVybiAoTlVMTCk7CisJfQorCWRpciA9ICgoZmxhZ3MgJiAoVEhfU1lOIHwgVEhfUlNU
 KSkgPT0gVEhfU1lOKTsKKwogCW0tPm1fZGF0YSArPSBtYXhfbGlua2hkcjsKKwltLT5tX2ZsYWdz
 IHw9IE1fU0tJUF9GSVJFV0FMTDsKKwltLT5tX3BrdGhkci5sZW4gPSBtLT5tX2xlbiA9IGxlbjsK
 KwltLT5tX3BrdGhkci5yY3ZpZiA9IE5VTEw7CisJYnplcm8obS0+bV9kYXRhLCBsZW4pOworCisJ
 c3dpdGNoIChpZC0+YWRkcl90eXBlKSB7CisJY2FzZSA0OgorCQloID0gbXRvZChtLCBzdHJ1Y3Qg
 aXAgKik7CisKKwkJLyogcHJlcGFyZSBmb3IgY2hlY2tzdW0gKi8KKwkJaC0+aXBfcCA9IElQUFJP
 VE9fVENQOworCQloLT5pcF9sZW4gPSBodG9ucyhzaXplb2Yoc3RydWN0IHRjcGhkcikpOworCQlp
 ZiAoZGlyKSB7CisJCQloLT5pcF9zcmMuc19hZGRyID0gaHRvbmwoaWQtPnNyY19pcCk7CisJCQlo
 LT5pcF9kc3Quc19hZGRyID0gaHRvbmwoaWQtPmRzdF9pcCk7CisJCX0gZWxzZSB7CisJCQloLT5p
 cF9zcmMuc19hZGRyID0gaHRvbmwoaWQtPmRzdF9pcCk7CisJCQloLT5pcF9kc3Quc19hZGRyID0g
 aHRvbmwoaWQtPnNyY19pcCk7CisJCX0KIAotCWlwID0gbXRvZChtLCBzdHJ1Y3QgaXAgKik7Ci0J
 Ynplcm8oaXAsIG0tPm1fbGVuKTsKLQl0Y3AgPSAoc3RydWN0IHRjcGhkciAqKShpcCArIDEpOyAv
 KiBubyBJUCBvcHRpb25zICovCi0JaXAtPmlwX3AgPSBJUFBST1RPX1RDUDsKLQl0Y3AtPnRoX29m
 ZiA9IDU7Ci0JLyoKLQkgKiBBc3N1bWUgd2UgYXJlIHNlbmRpbmcgYSBSU1QgKG9yIGEga2VlcGFs
 aXZlIGluIHRoZSByZXZlcnNlCi0JICogZGlyZWN0aW9uKSwgc3dhcCBzcmMgYW5kIGRlc3RpbmF0
 aW9uIGFkZHJlc3NlcyBhbmQgcG9ydHMuCi0JICovCi0JaXAtPmlwX3NyYy5zX2FkZHIgPSBodG9u
 bChpZC0+ZHN0X2lwKTsKLQlpcC0+aXBfZHN0LnNfYWRkciA9IGh0b25sKGlkLT5zcmNfaXApOwot
 CXRjcC0+dGhfc3BvcnQgPSBodG9ucyhpZC0+ZHN0X3BvcnQpOwotCXRjcC0+dGhfZHBvcnQgPSBo
 dG9ucyhpZC0+c3JjX3BvcnQpOwotCWlmIChmbGFncyAmIFRIX1JTVCkgewkvKiB3ZSBhcmUgc2Vu
 ZGluZyBhIFJTVCAqLworCQl0aCA9IChzdHJ1Y3QgdGNwaGRyICopKGggKyAxKTsKKwkJYnJlYWs7
 CisjaWZkZWYgSU5FVDYKKwljYXNlIDY6CisJCWg2ID0gbXRvZChtLCBzdHJ1Y3QgaXA2X2hkciAq
 KTsKKworCQkvKiBwcmVwYXJlIGZvciBjaGVja3N1bSAqLworCQloNi0+aXA2X254dCA9IElQUFJP
 VE9fVENQOworCQloNi0+aXA2X3BsZW4gPSBodG9ucyhzaXplb2Yoc3RydWN0IHRjcGhkcikpOwor
 CQlpZiAoZGlyKSB7CisJCQloNi0+aXA2X3NyYyA9IGlkLT5zcmNfaXA2OworCQkJaDYtPmlwNl9k
 c3QgPSBpZC0+ZHN0X2lwNjsKKwkJfSBlbHNlIHsKKwkJCWg2LT5pcDZfc3JjID0gaWQtPmRzdF9p
 cDY7CisJCQloNi0+aXA2X2RzdCA9IGlkLT5zcmNfaXA2OworCQl9CisKKwkJdGggPSAoc3RydWN0
 IHRjcGhkciAqKShoNiArIDEpOworCQlicmVhazsKKyNlbmRpZgorCX0KKworCWlmIChkaXIpIHsK
 KwkJdGgtPnRoX3Nwb3J0ID0gaHRvbnMoaWQtPnNyY19wb3J0KTsKKwkJdGgtPnRoX2Rwb3J0ID0g
 aHRvbnMoaWQtPmRzdF9wb3J0KTsKKwl9IGVsc2UgeworCQl0aC0+dGhfc3BvcnQgPSBodG9ucyhp
 ZC0+ZHN0X3BvcnQpOworCQl0aC0+dGhfZHBvcnQgPSBodG9ucyhpZC0+c3JjX3BvcnQpOworCX0K
 Kwl0aC0+dGhfb2ZmID0gc2l6ZW9mKHN0cnVjdCB0Y3BoZHIpID4+IDI7CisKKwlpZiAoZmxhZ3Mg
 JiBUSF9SU1QpIHsKIAkJaWYgKGZsYWdzICYgVEhfQUNLKSB7Ci0JCQl0Y3AtPnRoX3NlcSA9IGh0
 b25sKGFjayk7Ci0JCQl0Y3AtPnRoX2FjayA9IGh0b25sKDApOwotCQkJdGNwLT50aF9mbGFncyA9
 IFRIX1JTVDsKKwkJCXRoLT50aF9zZXEgPSBodG9ubChhY2spOworCQkJdGgtPnRoX2ZsYWdzID0g
 VEhfUlNUOwogCQl9IGVsc2UgewogCQkJaWYgKGZsYWdzICYgVEhfU1lOKQogCQkJCXNlcSsrOwot
 CQkJdGNwLT50aF9zZXEgPSBodG9ubCgwKTsKLQkJCXRjcC0+dGhfYWNrID0gaHRvbmwoc2VxKTsK
 LQkJCXRjcC0+dGhfZmxhZ3MgPSBUSF9SU1QgfCBUSF9BQ0s7CisJCQl0aC0+dGhfYWNrID0gaHRv
 bmwoc2VxKTsKKwkJCXRoLT50aF9mbGFncyA9IFRIX1JTVCB8IFRIX0FDSzsKIAkJfQogCX0gZWxz
 ZSB7CiAJCS8qCi0JCSAqIFdlIGFyZSBzZW5kaW5nIGEga2VlcGFsaXZlLiBmbGFncyAmIFRIX1NZ
 TiBkZXRlcm1pbmVzCi0JCSAqIHRoZSBkaXJlY3Rpb24sIGZvcndhcmQgaWYgc2V0LCByZXZlcnNl
 IGlmIGNsZWFyLgotCQkgKiBOT1RFOiBzZXEgYW5kIGFjayBhcmUgYWx3YXlzIGFzc3VtZWQgdG8g
 YmUgY29ycmVjdAotCQkgKiBhcyBzZXQgYnkgdGhlIGNhbGxlci4gVGhpcyBtYXkgYmUgY29uZnVz
 aW5nLi4uCisJCSAqIEtlZXBhbGl2ZSAtIHVzZSBjYWxsZXIgcHJvdmlkZWQgc2VxdWVuY2UgbnVt
 YmVycwogCQkgKi8KLQkJaWYgKGZsYWdzICYgVEhfU1lOKSB7Ci0JCQkvKgotCQkJICogd2UgaGF2
 ZSB0byByZXdyaXRlIHRoZSBjb3JyZWN0IGFkZHJlc3NlcyEKLQkJCSAqLwotCQkJaXAtPmlwX2Rz
 dC5zX2FkZHIgPSBodG9ubChpZC0+ZHN0X2lwKTsKLQkJCWlwLT5pcF9zcmMuc19hZGRyID0gaHRv
 bmwoaWQtPnNyY19pcCk7Ci0JCQl0Y3AtPnRoX2Rwb3J0ID0gaHRvbnMoaWQtPmRzdF9wb3J0KTsK
 LQkJCXRjcC0+dGhfc3BvcnQgPSBodG9ucyhpZC0+c3JjX3BvcnQpOwotCQl9Ci0JCXRjcC0+dGhf
 c2VxID0gaHRvbmwoc2VxKTsKLQkJdGNwLT50aF9hY2sgPSBodG9ubChhY2spOwotCQl0Y3AtPnRo
 X2ZsYWdzID0gVEhfQUNLOworCQl0aC0+dGhfc2VxID0gaHRvbmwoc2VxKTsKKwkJdGgtPnRoX2Fj
 ayA9IGh0b25sKGFjayk7CisJCXRoLT50aF9mbGFncyA9IFRIX0FDSzsKKwl9CisKKwlzd2l0Y2gg
 KGlkLT5hZGRyX3R5cGUpIHsKKwljYXNlIDQ6CisJCXRoLT50aF9zdW0gPSBpbl9ja3N1bShtLCBs
 ZW4pOworCisJCS8qIGZpbmlzaCB0aGUgaXAgaGVhZGVyICovCisJCWgtPmlwX3YgPSA0OworCQlo
 LT5pcF9obCA9IHNpemVvZigqaCkgPj4gMjsKKwkJaC0+aXBfdG9zID0gSVBUT1NfTE9XREVMQVk7
 CisJCWgtPmlwX29mZiA9IDA7CisJCWgtPmlwX2xlbiA9IGxlbjsKKwkJaC0+aXBfdHRsID0gaXBf
 ZGVmdHRsOworCQloLT5pcF9zdW0gPSAwOworCQlicmVhazsKKyNpZmRlZiBJTkVUNgorCWNhc2Ug
 NjoKKwkJdGgtPnRoX3N1bSA9IGluNl9ja3N1bShtLCBJUFBST1RPX1RDUCwgc2l6ZW9mKCpoNiks
 CisJCSAgICBzaXplb2Yoc3RydWN0IHRjcGhkcikpOworCisJCS8qIGZpbmlzaCB0aGUgaXA2IGhl
 YWRlciAqLworCQloNi0+aXA2X3ZmYyB8PSBJUFY2X1ZFUlNJT047CisJCWg2LT5pcDZfaGxpbSA9
 IElQVjZfREVGSExJTTsKKwkJYnJlYWs7CisjZW5kaWYKIAl9Ci0JLyoKLQkgKiBzZXQgaXBfbGVu
 IHRvIHRoZSBwYXlsb2FkIHNpemUgc28gd2UgY2FuIGNvbXB1dGUKLQkgKiB0aGUgdGNwIGNoZWNr
 c3VtIG9uIHRoZSBwc2V1ZG9oZWFkZXIKLQkgKiBYWFggY2hlY2sgdGhpcywgY291bGQgc2F2ZSBh
 IGNvdXBsZSBvZiB3b3JkcyA/Ci0JICovCi0JaXAtPmlwX2xlbiA9IGh0b25zKHNpemVvZihzdHJ1
 Y3QgdGNwaGRyKSk7Ci0JdGNwLT50aF9zdW0gPSBpbl9ja3N1bShtLCBtLT5tX3BrdGhkci5sZW4p
 OwotCS8qCi0JICogbm93IGZpbGwgZmllbGRzIGxlZnQgb3V0IGVhcmxpZXIKLQkgKi8KLQlpcC0+
 aXBfdHRsID0gaXBfZGVmdHRsOwotCWlwLT5pcF9sZW4gPSBtLT5tX3BrdGhkci5sZW47Ci0JbS0+
 bV9mbGFncyB8PSBNX1NLSVBfRklSRVdBTEw7CisKIAlyZXR1cm4gKG0pOwogfQogCkBAIC00ODYz
 LDYgKzQ4NzksOSBAQAogaXBmd190aWNrKHZvaWQgKiBfX3VudXNlZCB1bnVzZWQpCiB7CiAJc3Ry
 dWN0IG1idWYgKm0wLCAqbSwgKm1uZXh0LCAqKm10YWlscDsKKyNpZmRlZiBJTkVUNgorCXN0cnVj
 dCBtYnVmICptNiwgKiptNl90YWlscDsKKyNlbmRpZgogCWludCBpOwogCWlwZndfZHluX3J1bGUg
 KnE7CiAKQEAgLTQ4NzcsNiArNDg5NiwxMCBAQAogCSAqLwogCW0wID0gTlVMTDsKIAltdGFpbHAg
 PSAmbTA7CisjaWZkZWYgSU5FVDYKKwltNiA9IE5VTEw7CisJbTZfdGFpbHAgPSAmbTY7CisjZW5k
 aWYKIAlJUEZXX0RZTl9MT0NLKCk7CiAJZm9yIChpID0gMCA7IGkgPCBjdXJyX2R5bl9idWNrZXRz
 IDsgaSsrKSB7CiAJCWZvciAocSA9IGlwZndfZHluX3ZbaV0gOyBxIDsgcSA9IHEtPm5leHQgKSB7
 CkBAIC00ODkyLDE0ICs0OTE1LDM3IEBACiAJCQlpZiAoVElNRV9MRVEocS0+ZXhwaXJlLCB0aW1l
 X3VwdGltZSkpCiAJCQkJY29udGludWU7CS8qIHRvbyBsYXRlLCBydWxlIGV4cGlyZWQgKi8KIAot
 CQkJKm10YWlscCA9IHNlbmRfcGt0KE5VTEwsICYocS0+aWQpLCBxLT5hY2tfcmV2IC0gMSwKKwkJ
 CW0gPSBzZW5kX3BrdChOVUxMLCAmKHEtPmlkKSwgcS0+YWNrX3JldiAtIDEsCiAJCQkJcS0+YWNr
 X2Z3ZCwgVEhfU1lOKTsKLQkJCWlmICgqbXRhaWxwICE9IE5VTEwpCi0JCQkJbXRhaWxwID0gJigq
 bXRhaWxwKS0+bV9uZXh0cGt0OwotCQkJKm10YWlscCA9IHNlbmRfcGt0KE5VTEwsICYocS0+aWQp
 LCBxLT5hY2tfZndkIC0gMSwKKwkJCW1uZXh0ID0gc2VuZF9wa3QoTlVMTCwgJihxLT5pZCksIHEt
 PmFja19md2QgLSAxLAogCQkJCXEtPmFja19yZXYsIDApOwotCQkJaWYgKCptdGFpbHAgIT0gTlVM
 TCkKLQkJCQltdGFpbHAgPSAmKCptdGFpbHApLT5tX25leHRwa3Q7CisKKwkJCXN3aXRjaCAocS0+
 aWQuYWRkcl90eXBlKSB7CisJCQljYXNlIDQ6CisJCQkJaWYgKG0gIT0gTlVMTCkgeworCQkJCQkq
 bXRhaWxwID0gbTsKKwkJCQkJbXRhaWxwID0gJigqbXRhaWxwKS0+bV9uZXh0cGt0OworCQkJCX0K
 KwkJCQlpZiAobW5leHQgIT0gTlVMTCkgeworCQkJCQkqbXRhaWxwID0gbW5leHQ7CisJCQkJCW10
 YWlscCA9ICYoKm10YWlscCktPm1fbmV4dHBrdDsKKwkJCQl9CisJCQkJYnJlYWs7CisjaWZkZWYg
 SU5FVDYKKwkJCWNhc2UgNjoKKwkJCQlpZiAobSAhPSBOVUxMKSB7CisJCQkJCSptNl90YWlscCA9
 IG07CisJCQkJCW02X3RhaWxwID0gJigqbTZfdGFpbHApLT5tX25leHRwa3Q7CisJCQkJfQorCQkJ
 CWlmIChtbmV4dCAhPSBOVUxMKSB7CisJCQkJCSptNl90YWlscCA9IG1uZXh0OworCQkJCQltNl90
 YWlscCA9ICYoKm02X3RhaWxwKS0+bV9uZXh0cGt0OworCQkJCX0KKwkJCQlicmVhazsKKyNlbmRp
 ZgorCQkJfQorCisJCQltID0gbW5leHQgPSBOVUxMOwogCQl9CiAJfQogCUlQRldfRFlOX1VOTE9D
 SygpOwpAQCAtNDkwOCw2ICs0OTU0LDEzIEBACiAJCW0tPm1fbmV4dHBrdCA9IE5VTEw7CiAJCWlw
 X291dHB1dChtLCBOVUxMLCBOVUxMLCAwLCBOVUxMLCBOVUxMKTsKIAl9CisjaWZkZWYgSU5FVDYK
 Kwlmb3IgKG0gPSBtbmV4dCA9IG02OyBtICE9IE5VTEw7IG0gPSBtbmV4dCkgeworCQltbmV4dCA9
 IG0tPm1fbmV4dHBrdDsKKwkJbS0+bV9uZXh0cGt0ID0gTlVMTDsKKwkJaXA2X291dHB1dChtLCBO
 VUxMLCBOVUxMLCAwLCBOVUxMLCBOVUxMLCBOVUxMKTsKKwl9CisjZW5kaWYKIGRvbmU6CiAJY2Fs
 bG91dF9yZXNldCgmaXBmd190aW1lb3V0LCBkeW5fa2VlcGFsaXZlX3BlcmlvZCpoeiwgaXBmd190
 aWNrLCBOVUxMKTsKIH0K
 ------=_20080519221520_63844--
 
 

From: "Joost Bekkers" <joost@jodocus.org>
To: bug-followup@FreeBSD.org
Cc:  
Subject: Re: kern/117234: [ipfw] [patch] ipfw send_pkt() and ipfw_tick() 
     don't seem to support IPV6
Date: Sun, 21 Jun 2009 23:35:11 +0200 (CEST)

 ------=_20090621233511_54797
 Content-Type: text/plain; charset="iso-8859-1"
 Content-Transfer-Encoding: 8bit
 
 Updated the patch for use with 8.0-current
 
 This patch is against version 1.1 of src/sys/netinet/ipfw/ip_fw2.c
 It applies cleanly to HEAD (version 1.5) as well.
 ------=_20090621233511_54797
 Content-Type: application/octet-stream;
       name="ip_fw2.c-80-current-200906.diff"
 Content-Transfer-Encoding: base64
 Content-Disposition: attachment; filename="ip_fw2.c-80-current-200906.diff"
 
 LS0tIGlwX2Z3Mi5jLm9yZwkyMDA5LTA2LTIxIDE5OjUyOjM2LjAwMDAwMDAwMCArMDAwMAorKysg
 aXBfZncyLmMJMjAwOS0wNi0yMSAyMDo1NDowMy4wMDAwMDAwMDAgKzAwMDAKQEAgLTk3LDYgKzk3
 LDcgQEAKICNpbmNsdWRlIDxuZXRpbmV0L2ljbXA2Lmg+CiAjaWZkZWYgSU5FVDYKICNpbmNsdWRl
 IDxuZXRpbmV0Ni9zY29wZTZfdmFyLmg+CisjaW5jbHVkZSA8bmV0aW5ldDYvaXA2X3Zhci5oPgog
 I2VuZGlmCiAKICNpbmNsdWRlIDxtYWNoaW5lL2luX2Nrc3VtLmg+CS8qIFhYWCBmb3IgaW5fY2tz
 dW0gKi8KQEAgLTI0OSw2ICsyNTAsMTAgQEAKICNkZWZpbmUJSVBGV19EWU5fVU5MT0NLKCkJbXR4
 X3VubG9jaygmaXBmd19keW5fbXR4KQogI2RlZmluZQlJUEZXX0RZTl9MT0NLX0FTU0VSVCgpCW10
 eF9hc3NlcnQoJmlwZndfZHluX210eCwgTUFfT1dORUQpCiAKK3N0YXRpYyBzdHJ1Y3QgbWJ1ZiAq
 c2VuZF9wa3Qoc3RydWN0IG1idWYgKiwgc3RydWN0IGlwZndfZmxvd19pZCAqLAorICAgIHVfaW50
 MzJfdCwgdV9pbnQzMl90LCBpbnQpOworCisKIC8qCiAgKiBUaW1lb3V0cyBmb3IgdmFyaW91cyBl
 dmVudHMgaW4gaGFuZGluZyBkeW5hbWljIHJ1bGVzLgogICovCkBAIC03MDAsNjAgKzcwNSwxNyBA
 QAogCW0gPSBhcmdzLT5tOwogCWlmIChjb2RlID09IElDTVA2X1VOUkVBQ0hfUlNUICYmIGFyZ3Mt
 PmZfaWQucHJvdG8gPT0gSVBQUk9UT19UQ1ApIHsKIAkJc3RydWN0IHRjcGhkciAqdGNwOwotCQl0
 Y3Bfc2VxIGFjaywgc2VxOwotCQlpbnQgZmxhZ3M7Ci0JCXN0cnVjdCB7Ci0JCQlzdHJ1Y3QgaXA2
 X2hkciBpcDY7Ci0JCQlzdHJ1Y3QgdGNwaGRyIHRoOwotCQl9IHRpOwogCQl0Y3AgPSAoc3RydWN0
 IHRjcGhkciAqKSgoY2hhciAqKWlwNiArIGhsZW4pOwogCi0JCWlmICgodGNwLT50aF9mbGFncyAm
 IFRIX1JTVCkgIT0gMCkgewotCQkJbV9mcmVlbShtKTsKLQkJCWFyZ3MtPm0gPSBOVUxMOwotCQkJ
 cmV0dXJuOworICAgICAgICAgICAgICAgIGlmICgodGNwLT50aF9mbGFncyAmIFRIX1JTVCkgPT0g
 MCkgeworICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IG1idWYgKm0wOworICAgICAgICAg
 ICAgICAgICAgICAgICAgbTAgPSBzZW5kX3BrdChhcmdzLT5tLCAmKGFyZ3MtPmZfaWQpLAorICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBudG9obCh0Y3AtPnRoX3NlcSksIG50b2hsKHRj
 cC0+dGhfYWNrKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGNwLT50aF9mbGFn
 cyB8IFRIX1JTVCk7CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAobTAgIT0gTlVMTCkKKyAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaXA2X291dHB1dChtMCwgTlVMTCwgTlVMTCwg
 MCwgTlVMTCwgTlVMTCwgTlVMTCk7CiAJCX0KLQotCQl0aS5pcDYgPSAqaXA2OwotCQl0aS50aCA9
 ICp0Y3A7Ci0JCXRpLnRoLnRoX3NlcSA9IG50b2hsKHRpLnRoLnRoX3NlcSk7Ci0JCXRpLnRoLnRo
 X2FjayA9IG50b2hsKHRpLnRoLnRoX2Fjayk7Ci0JCXRpLmlwNi5pcDZfbnh0ID0gSVBQUk9UT19U
 Q1A7Ci0KLQkJaWYgKHRpLnRoLnRoX2ZsYWdzICYgVEhfQUNLKSB7Ci0JCQlhY2sgPSAwOwotCQkJ
 c2VxID0gdGkudGgudGhfYWNrOwotCQkJZmxhZ3MgPSBUSF9SU1Q7Ci0JCX0gZWxzZSB7Ci0JCQlh
 Y2sgPSB0aS50aC50aF9zZXE7Ci0JCQlpZiAoKG0tPm1fZmxhZ3MgJiBNX1BLVEhEUikgIT0gMCkg
 ewotCQkJCS8qCi0JCQkJICogdG90YWwgbmV3IGRhdGEgdG8gQUNLIGlzOgotCQkJCSAqIHRvdGFs
 IHBhY2tldCBsZW5ndGgsCi0JCQkJICogbWludXMgdGhlIGhlYWRlciBsZW5ndGgsCi0JCQkJICog
 bWludXMgdGhlIHRjcCBoZWFkZXIgbGVuZ3RoLgotCQkJCSAqLwotCQkJCWFjayArPSBtLT5tX3Br
 dGhkci5sZW4gLSBobGVuCi0JCQkJCS0gKHRpLnRoLnRoX29mZiA8PCAyKTsKLQkJCX0gZWxzZSBp
 ZiAoaXA2LT5pcDZfcGxlbikgewotCQkJCWFjayArPSBudG9ocyhpcDYtPmlwNl9wbGVuKSArIHNp
 emVvZigqaXA2KSAtCi0JCQkJICAgIGhsZW4gLSAodGkudGgudGhfb2ZmIDw8IDIpOwotCQkJfSBl
 bHNlIHsKLQkJCQltX2ZyZWVtKG0pOwotCQkJCXJldHVybjsKLQkJCX0KLQkJCWlmICh0Y3AtPnRo
 X2ZsYWdzICYgVEhfU1lOKQotCQkJCWFjaysrOwotCQkJc2VxID0gMDsKLQkJCWZsYWdzID0gVEhf
 UlNUfFRIX0FDSzsKLQkJfQotCQliY29weSgmdGksIGlwNiwgc2l6ZW9mKHRpKSk7Ci0JCS8qCi0J
 CSAqIG0gaXMgb25seSB1c2VkIHRvIHJlY3ljbGUgdGhlIG1idWYKLQkJICogVGhlIGRhdGEgaW4g
 aXQgaXMgbmV2ZXIgcmVhZCBzbyB3ZSBkb24ndCBuZWVkCi0JCSAqIHRvIGNvcnJlY3QgdGhlIG9m
 ZnNldHMgb3IgYW55dGhpbmcKLQkJICovCi0JCXRjcF9yZXNwb25kKE5VTEwsIGlwNiwgdGNwLCBt
 LCBhY2ssIHNlcSwgZmxhZ3MpOworCQltX2ZyZWVtKG0pOwogCX0gZWxzZSBpZiAoY29kZSAhPSBJ
 Q01QNl9VTlJFQUNIX1JTVCkgeyAvKiBTZW5kIGFuIElDTVB2NiB1bnJlYWNoLiAqLwogI2lmIDAK
 IAkJLyoKQEAgLTE2NTAsMTMgKzE2MTIsMTYgQEAKIHsKIAlJTklUX1ZORVRfSU5FVChjdXJ2bmV0
 KTsKIAlzdHJ1Y3QgbWJ1ZiAqbTsKLQlzdHJ1Y3QgaXAgKmlwOwotCXN0cnVjdCB0Y3BoZHIgKnRj
 cDsKKyAgICAgICAgaW50IGxlbiwgZGlyOworICAgICAgICBzdHJ1Y3QgaXAgKmggPSBOVUxMOyAg
 ICAgICAgICAgIC8qIHN0dXBpZCBjb21waWxlciAqLworI2lmZGVmIElORVQ2CisgICAgICAgIHN0
 cnVjdCBpcDZfaGRyICpoNiA9IE5VTEw7CisjZW5kaWYKKyAgICAgICAgc3RydWN0IHRjcGhkciAq
 dGggPSBOVUxMOwogCiAJTUdFVEhEUihtLCBNX0RPTlRXQUlULCBNVF9EQVRBKTsKLQlpZiAobSA9
 PSAwKQorCWlmIChtID09IE5VTEwpCiAJCXJldHVybiAoTlVMTCk7Ci0JbS0+bV9wa3RoZHIucmN2
 aWYgPSAoc3RydWN0IGlmbmV0ICopMDsKIAogCU1fU0VURklCKG0sIGlkLT5maWIpOwogI2lmZGVm
 IE1BQwpAQCAtMTY2OCw2NyArMTYzMywxMTggQEAKIAkodm9pZClyZXBseXRvOwkJLyogZG9uJ3Qg
 d2FybiBhYm91dCB1bnVzZWQgYXJnICovCiAjZW5kaWYKIAotCW0tPm1fcGt0aGRyLmxlbiA9IG0t
 Pm1fbGVuID0gc2l6ZW9mKHN0cnVjdCBpcCkgKyBzaXplb2Yoc3RydWN0IHRjcGhkcik7CisgICAg
 ICAgIHN3aXRjaCAoaWQtPmFkZHJfdHlwZSkgeworICAgICAgICBjYXNlIDQ6CisgICAgICAgICAg
 ICAgICAgbGVuID0gc2l6ZW9mKHN0cnVjdCBpcCkgKyBzaXplb2Yoc3RydWN0IHRjcGhkcik7Cisg
 ICAgICAgICAgICAgICAgYnJlYWs7CisjaWZkZWYgSU5FVDYKKyAgICAgICAgY2FzZSA2OgorICAg
 ICAgICAgICAgICAgIGxlbiA9IHNpemVvZihzdHJ1Y3QgaXA2X2hkcikgKyBzaXplb2Yoc3RydWN0
 IHRjcGhkcik7CisgICAgICAgICAgICAgICAgYnJlYWs7CisjZW5kaWYKKyAgICAgICAgZGVmYXVs
 dDoKKyAgICAgICAgICAgICAgICAvKiBYWFg6IGxvZyBtZT8hPyAqLworICAgICAgICAgICAgICAg
 IG1fZnJlZW0obSk7CisgICAgICAgICAgICAgICAgcmV0dXJuIChOVUxMKTsKKyAgICAgICAgfQor
 ICAgICAgICBkaXIgPSAoKGZsYWdzICYgKFRIX1NZTiB8IFRIX1JTVCkpID09IFRIX1NZTik7CisK
 IAltLT5tX2RhdGEgKz0gbWF4X2xpbmtoZHI7CisgICAgICAgIG0tPm1fZmxhZ3MgfD0gTV9TS0lQ
 X0ZJUkVXQUxMOworICAgICAgICBtLT5tX3BrdGhkci5sZW4gPSBtLT5tX2xlbiA9IGxlbjsKKyAg
 ICAgICAgbS0+bV9wa3RoZHIucmN2aWYgPSBOVUxMOworICAgICAgICBiemVybyhtLT5tX2RhdGEs
 IGxlbik7CisKKyAgICAgICAgc3dpdGNoIChpZC0+YWRkcl90eXBlKSB7CisgICAgICAgIGNhc2Ug
 NDoKKyAgICAgICAgICAgICAgICBoID0gbXRvZChtLCBzdHJ1Y3QgaXAgKik7CisKKyAgICAgICAg
 ICAgICAgICAvKiBwcmVwYXJlIGZvciBjaGVja3N1bSAqLworICAgICAgICAgICAgICAgIGgtPmlw
 X3AgPSBJUFBST1RPX1RDUDsKKyAgICAgICAgICAgICAgICBoLT5pcF9sZW4gPSBodG9ucyhzaXpl
 b2Yoc3RydWN0IHRjcGhkcikpOworICAgICAgICAgICAgICAgIGlmIChkaXIpIHsKKyAgICAgICAg
 ICAgICAgICAgICAgICAgIGgtPmlwX3NyYy5zX2FkZHIgPSBodG9ubChpZC0+c3JjX2lwKTsKKyAg
 ICAgICAgICAgICAgICAgICAgICAgIGgtPmlwX2RzdC5zX2FkZHIgPSBodG9ubChpZC0+ZHN0X2lw
 KTsKKyAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICAgICAgaC0+
 aXBfc3JjLnNfYWRkciA9IGh0b25sKGlkLT5kc3RfaXApOworICAgICAgICAgICAgICAgICAgICAg
 ICAgaC0+aXBfZHN0LnNfYWRkciA9IGh0b25sKGlkLT5zcmNfaXApOworICAgICAgICAgICAgICAg
 IH0KIAotCWlwID0gbXRvZChtLCBzdHJ1Y3QgaXAgKik7Ci0JYnplcm8oaXAsIG0tPm1fbGVuKTsK
 LQl0Y3AgPSAoc3RydWN0IHRjcGhkciAqKShpcCArIDEpOyAvKiBubyBJUCBvcHRpb25zICovCi0J
 aXAtPmlwX3AgPSBJUFBST1RPX1RDUDsKLQl0Y3AtPnRoX29mZiA9IDU7Ci0JLyoKLQkgKiBBc3N1
 bWUgd2UgYXJlIHNlbmRpbmcgYSBSU1QgKG9yIGEga2VlcGFsaXZlIGluIHRoZSByZXZlcnNlCi0J
 ICogZGlyZWN0aW9uKSwgc3dhcCBzcmMgYW5kIGRlc3RpbmF0aW9uIGFkZHJlc3NlcyBhbmQgcG9y
 dHMuCi0JICovCi0JaXAtPmlwX3NyYy5zX2FkZHIgPSBodG9ubChpZC0+ZHN0X2lwKTsKLQlpcC0+
 aXBfZHN0LnNfYWRkciA9IGh0b25sKGlkLT5zcmNfaXApOwotCXRjcC0+dGhfc3BvcnQgPSBodG9u
 cyhpZC0+ZHN0X3BvcnQpOwotCXRjcC0+dGhfZHBvcnQgPSBodG9ucyhpZC0+c3JjX3BvcnQpOwot
 CWlmIChmbGFncyAmIFRIX1JTVCkgewkvKiB3ZSBhcmUgc2VuZGluZyBhIFJTVCAqLworICAgICAg
 ICAgICAgICAgIHRoID0gKHN0cnVjdCB0Y3BoZHIgKikoaCArIDEpOworICAgICAgICAgICAgICAg
 IGJyZWFrOworI2lmZGVmIElORVQ2CisgICAgICAgIGNhc2UgNjoKKyAgICAgICAgICAgICAgICBo
 NiA9IG10b2QobSwgc3RydWN0IGlwNl9oZHIgKik7CisKKyAgICAgICAgICAgICAgICAvKiBwcmVw
 YXJlIGZvciBjaGVja3N1bSAqLworICAgICAgICAgICAgICAgIGg2LT5pcDZfbnh0ID0gSVBQUk9U
 T19UQ1A7CisgICAgICAgICAgICAgICAgaDYtPmlwNl9wbGVuID0gaHRvbnMoc2l6ZW9mKHN0cnVj
 dCB0Y3BoZHIpKTsKKyAgICAgICAgICAgICAgICBpZiAoZGlyKSB7CisgICAgICAgICAgICAgICAg
 ICAgICAgICBoNi0+aXA2X3NyYyA9IGlkLT5zcmNfaXA2OworICAgICAgICAgICAgICAgICAgICAg
 ICAgaDYtPmlwNl9kc3QgPSBpZC0+ZHN0X2lwNjsKKyAgICAgICAgICAgICAgICB9IGVsc2Ugewor
 ICAgICAgICAgICAgICAgICAgICAgICAgaDYtPmlwNl9zcmMgPSBpZC0+ZHN0X2lwNjsKKyAgICAg
 ICAgICAgICAgICAgICAgICAgIGg2LT5pcDZfZHN0ID0gaWQtPnNyY19pcDY7CisgICAgICAgICAg
 ICAgICAgfQorCisgICAgICAgICAgICAgICAgdGggPSAoc3RydWN0IHRjcGhkciAqKShoNiArIDEp
 OworICAgICAgICAgICAgICAgIGJyZWFrOworI2VuZGlmCisgICAgICAgIH0KKworICAgICAgICBp
 ZiAoZGlyKSB7CisgICAgICAgICAgICAgICAgdGgtPnRoX3Nwb3J0ID0gaHRvbnMoaWQtPnNyY19w
 b3J0KTsKKyAgICAgICAgICAgICAgICB0aC0+dGhfZHBvcnQgPSBodG9ucyhpZC0+ZHN0X3BvcnQp
 OworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIHRoLT50aF9zcG9ydCA9IGh0b25z
 KGlkLT5kc3RfcG9ydCk7CisgICAgICAgICAgICAgICAgdGgtPnRoX2Rwb3J0ID0gaHRvbnMoaWQt
 PnNyY19wb3J0KTsKKyAgICAgICAgfQorICAgICAgICB0aC0+dGhfb2ZmID0gc2l6ZW9mKHN0cnVj
 dCB0Y3BoZHIpID4+IDI7CisKKyAgICAgICAgaWYgKGZsYWdzICYgVEhfUlNUKSB7CiAJCWlmIChm
 bGFncyAmIFRIX0FDSykgewotCQkJdGNwLT50aF9zZXEgPSBodG9ubChhY2spOwotCQkJdGNwLT50
 aF9hY2sgPSBodG9ubCgwKTsKLQkJCXRjcC0+dGhfZmxhZ3MgPSBUSF9SU1Q7CisgICAgICAgICAg
 ICAgICAgICAgICAgICB0aC0+dGhfc2VxID0gaHRvbmwoYWNrKTsKKyAgICAgICAgICAgICAgICAg
 ICAgICAgIHRoLT50aF9mbGFncyA9IFRIX1JTVDsKIAkJfSBlbHNlIHsKIAkJCWlmIChmbGFncyAm
 IFRIX1NZTikKIAkJCQlzZXErKzsKLQkJCXRjcC0+dGhfc2VxID0gaHRvbmwoMCk7Ci0JCQl0Y3At
 PnRoX2FjayA9IGh0b25sKHNlcSk7Ci0JCQl0Y3AtPnRoX2ZsYWdzID0gVEhfUlNUIHwgVEhfQUNL
 OworICAgICAgICAgICAgICAgICAgICAgICAgdGgtPnRoX2FjayA9IGh0b25sKHNlcSk7CisgICAg
 ICAgICAgICAgICAgICAgICAgICB0aC0+dGhfZmxhZ3MgPSBUSF9SU1QgfCBUSF9BQ0s7CiAJCX0K
 IAl9IGVsc2UgewogCQkvKgotCQkgKiBXZSBhcmUgc2VuZGluZyBhIGtlZXBhbGl2ZS4gZmxhZ3Mg
 JiBUSF9TWU4gZGV0ZXJtaW5lcwotCQkgKiB0aGUgZGlyZWN0aW9uLCBmb3J3YXJkIGlmIHNldCwg
 cmV2ZXJzZSBpZiBjbGVhci4KLQkJICogTk9URTogc2VxIGFuZCBhY2sgYXJlIGFsd2F5cyBhc3N1
 bWVkIHRvIGJlIGNvcnJlY3QKLQkJICogYXMgc2V0IGJ5IHRoZSBjYWxsZXIuIFRoaXMgbWF5IGJl
 IGNvbmZ1c2luZy4uLgorICAgICAgICAgICAgICAgICAqIEtlZXBhbGl2ZSAtIHVzZSBjYWxsZXIg
 cHJvdmlkZWQgc2VxdWVuY2UgbnVtYmVycwogCQkgKi8KLQkJaWYgKGZsYWdzICYgVEhfU1lOKSB7
 Ci0JCQkvKgotCQkJICogd2UgaGF2ZSB0byByZXdyaXRlIHRoZSBjb3JyZWN0IGFkZHJlc3NlcyEK
 LQkJCSAqLwotCQkJaXAtPmlwX2RzdC5zX2FkZHIgPSBodG9ubChpZC0+ZHN0X2lwKTsKLQkJCWlw
 LT5pcF9zcmMuc19hZGRyID0gaHRvbmwoaWQtPnNyY19pcCk7Ci0JCQl0Y3AtPnRoX2Rwb3J0ID0g
 aHRvbnMoaWQtPmRzdF9wb3J0KTsKLQkJCXRjcC0+dGhfc3BvcnQgPSBodG9ucyhpZC0+c3JjX3Bv
 cnQpOwotCQl9Ci0JCXRjcC0+dGhfc2VxID0gaHRvbmwoc2VxKTsKLQkJdGNwLT50aF9hY2sgPSBo
 dG9ubChhY2spOwotCQl0Y3AtPnRoX2ZsYWdzID0gVEhfQUNLOworICAgICAgICAgICAgICAgIHRo
 LT50aF9zZXEgPSBodG9ubChzZXEpOworICAgICAgICAgICAgICAgIHRoLT50aF9hY2sgPSBodG9u
 bChhY2spOworICAgICAgICAgICAgICAgIHRoLT50aF9mbGFncyA9IFRIX0FDSzsKKyAgICAgICAg
 fQorCisgICAgICAgIHN3aXRjaCAoaWQtPmFkZHJfdHlwZSkgeworICAgICAgICBjYXNlIDQ6Cisg
 ICAgICAgICAgICAgICAgdGgtPnRoX3N1bSA9IGluX2Nrc3VtKG0sIGxlbik7CisKKyAgICAgICAg
 ICAgICAgICAvKiBmaW5pc2ggdGhlIGlwIGhlYWRlciAqLworICAgICAgICAgICAgICAgIGgtPmlw
 X3YgPSA0OworICAgICAgICAgICAgICAgIGgtPmlwX2hsID0gc2l6ZW9mKCpoKSA+PiAyOworICAg
 ICAgICAgICAgICAgIGgtPmlwX3RvcyA9IElQVE9TX0xPV0RFTEFZOworICAgICAgICAgICAgICAg
 IGgtPmlwX29mZiA9IDA7CisgICAgICAgICAgICAgICAgaC0+aXBfbGVuID0gbGVuOworICAgICAg
 ICAgICAgICAgIGgtPmlwX3R0bCA9IFZfaXBfZGVmdHRsOworICAgICAgICAgICAgICAgIGgtPmlw
 X3N1bSA9IDA7CisgICAgICAgICAgICAgICAgYnJlYWs7CisjaWZkZWYgSU5FVDYKKyAgICAgICAg
 Y2FzZSA2OgorICAgICAgICAgICAgICAgIHRoLT50aF9zdW0gPSBpbjZfY2tzdW0obSwgSVBQUk9U
 T19UQ1AsIHNpemVvZigqaDYpLAorICAgICAgICAgICAgICAgICAgICBzaXplb2Yoc3RydWN0IHRj
 cGhkcikpOworCisgICAgICAgICAgICAgICAgLyogZmluaXNoIHRoZSBpcDYgaGVhZGVyICovCisg
 ICAgICAgICAgICAgICAgaDYtPmlwNl92ZmMgfD0gSVBWNl9WRVJTSU9OOworICAgICAgICAgICAg
 ICAgIGg2LT5pcDZfaGxpbSA9IElQVjZfREVGSExJTTsKKyAgICAgICAgICAgICAgICBicmVhazsK
 KyNlbmRpZgogCX0KLQkvKgotCSAqIHNldCBpcF9sZW4gdG8gdGhlIHBheWxvYWQgc2l6ZSBzbyB3
 ZSBjYW4gY29tcHV0ZQotCSAqIHRoZSB0Y3AgY2hlY2tzdW0gb24gdGhlIHBzZXVkb2hlYWRlcgot
 CSAqIFhYWCBjaGVjayB0aGlzLCBjb3VsZCBzYXZlIGEgY291cGxlIG9mIHdvcmRzID8KLQkgKi8K
 LQlpcC0+aXBfbGVuID0gaHRvbnMoc2l6ZW9mKHN0cnVjdCB0Y3BoZHIpKTsKLQl0Y3AtPnRoX3N1
 bSA9IGluX2Nrc3VtKG0sIG0tPm1fcGt0aGRyLmxlbik7Ci0JLyoKLQkgKiBub3cgZmlsbCBmaWVs
 ZHMgbGVmdCBvdXQgZWFybGllcgotCSAqLwotCWlwLT5pcF90dGwgPSBWX2lwX2RlZnR0bDsKLQlp
 cC0+aXBfbGVuID0gbS0+bV9wa3RoZHIubGVuOwotCW0tPm1fZmxhZ3MgfD0gTV9TS0lQX0ZJUkVX
 QUxMOworCiAJcmV0dXJuIChtKTsKIH0KIApAQCAtNDU0MCw2ICs0NTU2LDkgQEAKIHsKIAlJTklU
 X1ZORVRfSVBGVyhjdXJ2bmV0KTsKIAlzdHJ1Y3QgbWJ1ZiAqbTAsICptLCAqbW5leHQsICoqbXRh
 aWxwOworI2lmZGVmIElORVQ2CisgICAgICAgIHN0cnVjdCBtYnVmICptNiwgKiptNl90YWlscDsK
 KyNlbmRpZgogCWludCBpOwogCWlwZndfZHluX3J1bGUgKnE7CiAKQEAgLTQ1NTQsNiArNDU3Mywx
 MCBAQAogCSAqLwogCW0wID0gTlVMTDsKIAltdGFpbHAgPSAmbTA7CisjaWZkZWYgSU5FVDYKKyAg
 ICAgICAgbTYgPSBOVUxMOworICAgICAgICBtNl90YWlscCA9ICZtNjsKKyNlbmRpZgogCUlQRldf
 RFlOX0xPQ0soKTsKIAlmb3IgKGkgPSAwIDsgaSA8IFZfY3Vycl9keW5fYnVja2V0cyA7IGkrKykg
 ewogCQlmb3IgKHEgPSBWX2lwZndfZHluX3ZbaV0gOyBxIDsgcSA9IHEtPm5leHQgKSB7CkBAIC00
 NTY5LDE0ICs0NTkyLDM3IEBACiAJCQlpZiAoVElNRV9MRVEocS0+ZXhwaXJlLCB0aW1lX3VwdGlt
 ZSkpCiAJCQkJY29udGludWU7CS8qIHRvbyBsYXRlLCBydWxlIGV4cGlyZWQgKi8KIAotCQkJKm10
 YWlscCA9IHNlbmRfcGt0KE5VTEwsICYocS0+aWQpLCBxLT5hY2tfcmV2IC0gMSwKKwkJCW0gPSBz
 ZW5kX3BrdChOVUxMLCAmKHEtPmlkKSwgcS0+YWNrX3JldiAtIDEsCiAJCQkJcS0+YWNrX2Z3ZCwg
 VEhfU1lOKTsKLQkJCWlmICgqbXRhaWxwICE9IE5VTEwpCi0JCQkJbXRhaWxwID0gJigqbXRhaWxw
 KS0+bV9uZXh0cGt0OwotCQkJKm10YWlscCA9IHNlbmRfcGt0KE5VTEwsICYocS0+aWQpLCBxLT5h
 Y2tfZndkIC0gMSwKKwkJCW1uZXh0ID0gc2VuZF9wa3QoTlVMTCwgJihxLT5pZCksIHEtPmFja19m
 d2QgLSAxLAogCQkJCXEtPmFja19yZXYsIDApOwotCQkJaWYgKCptdGFpbHAgIT0gTlVMTCkKLQkJ
 CQltdGFpbHAgPSAmKCptdGFpbHApLT5tX25leHRwa3Q7CisKKyAgICAgICAgICAgICAgICAgICAg
 ICAgIHN3aXRjaCAocS0+aWQuYWRkcl90eXBlKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBj
 YXNlIDQ6CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIChtICE9IE5VTEwpIHsK
 KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqbXRhaWxwID0gbTsKKyAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtdGFpbHAgPSAmKCptdGFpbHAp
 LT5tX25leHRwa3Q7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgaWYgKG1uZXh0ICE9IE5VTEwpIHsKKyAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqbXRhaWxwID0gbW5leHQ7CisgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbXRhaWxwID0gJigqbXRhaWxwKS0+bV9uZXh0
 cGt0OworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgIGJyZWFrOworI2lmZGVmIElORVQ2CisgICAgICAgICAgICAgICAgICAg
 ICAgICBjYXNlIDY6CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIChtICE9IE5V
 TEwpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqbTZfdGFpbHAg
 PSBtOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG02X3RhaWxwID0g
 JigqbTZfdGFpbHApLT5tX25leHRwa3Q7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 IH0KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgKG1uZXh0ICE9IE5VTEwpIHsK
 KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqbTZfdGFpbHAgPSBtbmV4
 dDsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtNl90YWlscCA9ICYo
 Km02X3RhaWxwKS0+bV9uZXh0cGt0OworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9
 CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJyZWFrOworI2VuZGlmCisgICAgICAg
 ICAgICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgICAgICAgICAgICAgIG0gPSBtbmV4dCA9
 IE5VTEw7CiAJCX0KIAl9CiAJSVBGV19EWU5fVU5MT0NLKCk7CkBAIC00NTg1LDYgKzQ2MzEsMTMg
 QEAKIAkJbS0+bV9uZXh0cGt0ID0gTlVMTDsKIAkJaXBfb3V0cHV0KG0sIE5VTEwsIE5VTEwsIDAs
 IE5VTEwsIE5VTEwpOwogCX0KKyNpZmRlZiBJTkVUNgorICAgICAgICBmb3IgKG0gPSBtbmV4dCA9
 IG02OyBtICE9IE5VTEw7IG0gPSBtbmV4dCkgeworICAgICAgICAgICAgICAgIG1uZXh0ID0gbS0+
 bV9uZXh0cGt0OworICAgICAgICAgICAgICAgIG0tPm1fbmV4dHBrdCA9IE5VTEw7CisgICAgICAg
 ICAgICAgICAgaXA2X291dHB1dChtLCBOVUxMLCBOVUxMLCAwLCBOVUxMLCBOVUxMLCBOVUxMKTsK
 KyAgICAgICAgfQorI2VuZGlmCiBkb25lOgogCWNhbGxvdXRfcmVzZXQoJlZfaXBmd190aW1lb3V0
 LCBWX2R5bl9rZWVwYWxpdmVfcGVyaW9kICogaHosCiAJCSAgICAgIGlwZndfdGljaywgTlVMTCk7
 Cg==
 ------=_20090621233511_54797--
 
 

From: dfilter@FreeBSD.ORG (dfilter service)
To: bug-followup@FreeBSD.org
Cc:  
Subject: Re: kern/117234: commit references a PR
Date: Wed,  2 Dec 2009 14:32:15 +0000 (UTC)

 Author: ume
 Date: Wed Dec  2 14:32:01 2009
 New Revision: 200027
 URL: http://svn.freebsd.org/changeset/base/200027
 
 Log:
   Teach an IPv6 to send_pkt() and ipfw_tick().
   It fixes the issue which keep-alive doesn't work for an IPv6.
   
   PR:		kern/117234
   Submitted by:	mlaier, Joost Bekkers <joost__at__jodocus.org>
   MFC after:	1 month
 
 Modified:
   head/sys/netinet/ipfw/ip_fw2.c
 
 Modified: head/sys/netinet/ipfw/ip_fw2.c
 ==============================================================================
 --- head/sys/netinet/ipfw/ip_fw2.c	Wed Dec  2 13:24:21 2009	(r200026)
 +++ head/sys/netinet/ipfw/ip_fw2.c	Wed Dec  2 14:32:01 2009	(r200027)
 @@ -94,6 +94,7 @@ __FBSDID("$FreeBSD$");
  #include <netinet/icmp6.h>
  #ifdef INET6
  #include <netinet6/scope6_var.h>
 +#include <netinet6/ip6_var.h>
  #endif
  
  #include <machine/in_cksum.h>	/* XXX for in_cksum */
 @@ -249,6 +250,10 @@ static struct mtx ipfw_dyn_mtx;		/* mute
  #define	IPFW_DYN_UNLOCK()	mtx_unlock(&ipfw_dyn_mtx)
  #define	IPFW_DYN_LOCK_ASSERT()	mtx_assert(&ipfw_dyn_mtx, MA_OWNED)
  
 +static struct mbuf *send_pkt(struct mbuf *, struct ipfw_flow_id *,
 +    u_int32_t, u_int32_t, int);
 +
 +
  /*
   * Timeouts for various events in handing dynamic rules.
   */
 @@ -708,60 +713,18 @@ send_reject6(struct ip_fw_args *args, in
  	m = args->m;
  	if (code == ICMP6_UNREACH_RST && args->f_id.proto == IPPROTO_TCP) {
  		struct tcphdr *tcp;
 -		tcp_seq ack, seq;
 -		int flags;
 -		struct {
 -			struct ip6_hdr ip6;
 -			struct tcphdr th;
 -		} ti;
  		tcp = (struct tcphdr *)((char *)ip6 + hlen);
  
 -		if ((tcp->th_flags & TH_RST) != 0) {
 -			m_freem(m);
 -			args->m = NULL;
 -			return;
 -		}
 -
 -		ti.ip6 = *ip6;
 -		ti.th = *tcp;
 -		ti.th.th_seq = ntohl(ti.th.th_seq);
 -		ti.th.th_ack = ntohl(ti.th.th_ack);
 -		ti.ip6.ip6_nxt = IPPROTO_TCP;
 -
 -		if (ti.th.th_flags & TH_ACK) {
 -			ack = 0;
 -			seq = ti.th.th_ack;
 -			flags = TH_RST;
 -		} else {
 -			ack = ti.th.th_seq;
 -			if ((m->m_flags & M_PKTHDR) != 0) {
 -				/*
 -				 * total new data to ACK is:
 -				 * total packet length,
 -				 * minus the header length,
 -				 * minus the tcp header length.
 -				 */
 -				ack += m->m_pkthdr.len - hlen
 -					- (ti.th.th_off << 2);
 -			} else if (ip6->ip6_plen) {
 -				ack += ntohs(ip6->ip6_plen) + sizeof(*ip6) -
 -				    hlen - (ti.th.th_off << 2);
 -			} else {
 -				m_freem(m);
 -				return;
 -			}
 -			if (tcp->th_flags & TH_SYN)
 -				ack++;
 -			seq = 0;
 -			flags = TH_RST|TH_ACK;
 +		if ((tcp->th_flags & TH_RST) == 0) {
 +			struct mbuf *m0;
 +			m0 = send_pkt(args->m, &(args->f_id),
 +			    ntohl(tcp->th_seq), ntohl(tcp->th_ack),
 +			    tcp->th_flags | TH_RST);
 +			if (m0 != NULL)
 +				ip6_output(m0, NULL, NULL, 0, NULL, NULL,
 +				    NULL);
  		}
 -		bcopy(&ti, ip6, sizeof(ti));
 -		/*
 -		 * m is only used to recycle the mbuf
 -		 * The data in it is never read so we don't need
 -		 * to correct the offsets or anything
 -		 */
 -		tcp_respond(NULL, ip6, tcp, m, ack, seq, flags);
 +		m_freem(m);
  	} else if (code != ICMP6_UNREACH_RST) { /* Send an ICMPv6 unreach. */
  #if 0
  		/*
 @@ -1649,13 +1612,16 @@ send_pkt(struct mbuf *replyto, struct ip
      u_int32_t ack, int flags)
  {
  	struct mbuf *m;
 -	struct ip *ip;
 -	struct tcphdr *tcp;
 +	int len, dir;
 +	struct ip *h = NULL;		/* stupid compiler */
 +#ifdef INET6
 +	struct ip6_hdr *h6 = NULL;
 +#endif
 +	struct tcphdr *th = NULL;
  
  	MGETHDR(m, M_DONTWAIT, MT_DATA);
 -	if (m == 0)
 +	if (m == NULL)
  		return (NULL);
 -	m->m_pkthdr.rcvif = (struct ifnet *)0;
  
  	M_SETFIB(m, id->fib);
  #ifdef MAC
 @@ -1667,67 +1633,118 @@ send_pkt(struct mbuf *replyto, struct ip
  	(void)replyto;		/* don't warn about unused arg */
  #endif
  
 -	m->m_pkthdr.len = m->m_len = sizeof(struct ip) + sizeof(struct tcphdr);
 +	switch (id->addr_type) {
 +	case 4:
 +		len = sizeof(struct ip) + sizeof(struct tcphdr);
 +		break;
 +#ifdef INET6
 +	case 6:
 +		len = sizeof(struct ip6_hdr) + sizeof(struct tcphdr);
 +		break;
 +#endif
 +	default:
 +		/* XXX: log me?!? */
 +		m_freem(m);
 +		return (NULL);
 +	}
 +	dir = ((flags & (TH_SYN | TH_RST)) == TH_SYN);
 +
  	m->m_data += max_linkhdr;
 +	m->m_flags |= M_SKIP_FIREWALL;
 +	m->m_pkthdr.len = m->m_len = len;
 +	m->m_pkthdr.rcvif = NULL;
 +	bzero(m->m_data, len);
 +
 +	switch (id->addr_type) {
 +	case 4:
 +		h = mtod(m, struct ip *);
 +
 +		/* prepare for checksum */
 +		h->ip_p = IPPROTO_TCP;
 +		h->ip_len = htons(sizeof(struct tcphdr));
 +		if (dir) {
 +			h->ip_src.s_addr = htonl(id->src_ip);
 +			h->ip_dst.s_addr = htonl(id->dst_ip);
 +		} else {
 +			h->ip_src.s_addr = htonl(id->dst_ip);
 +			h->ip_dst.s_addr = htonl(id->src_ip);
 +		}
  
 -	ip = mtod(m, struct ip *);
 -	bzero(ip, m->m_len);
 -	tcp = (struct tcphdr *)(ip + 1); /* no IP options */
 -	ip->ip_p = IPPROTO_TCP;
 -	tcp->th_off = 5;
 -	/*
 -	 * Assume we are sending a RST (or a keepalive in the reverse
 -	 * direction), swap src and destination addresses and ports.
 -	 */
 -	ip->ip_src.s_addr = htonl(id->dst_ip);
 -	ip->ip_dst.s_addr = htonl(id->src_ip);
 -	tcp->th_sport = htons(id->dst_port);
 -	tcp->th_dport = htons(id->src_port);
 -	if (flags & TH_RST) {	/* we are sending a RST */
 +		th = (struct tcphdr *)(h + 1);
 +		break;
 +#ifdef INET6
 +	case 6:
 +		h6 = mtod(m, struct ip6_hdr *);
 +
 +		/* prepare for checksum */
 +		h6->ip6_nxt = IPPROTO_TCP;
 +		h6->ip6_plen = htons(sizeof(struct tcphdr));
 +		if (dir) {
 +			h6->ip6_src = id->src_ip6;
 +			h6->ip6_dst = id->dst_ip6;
 +		} else {
 +			h6->ip6_src = id->dst_ip6;
 +			h6->ip6_dst = id->src_ip6;
 +		}
 +
 +		th = (struct tcphdr *)(h6 + 1);
 +		break;
 +#endif
 +	}
 +
 +	if (dir) {
 +		th->th_sport = htons(id->src_port);
 +		th->th_dport = htons(id->dst_port);
 +	} else {
 +		th->th_sport = htons(id->dst_port);
 +		th->th_dport = htons(id->src_port);
 +	}
 +	th->th_off = sizeof(struct tcphdr) >> 2;
 +
 +	if (flags & TH_RST) {
  		if (flags & TH_ACK) {
 -			tcp->th_seq = htonl(ack);
 -			tcp->th_ack = htonl(0);
 -			tcp->th_flags = TH_RST;
 +			th->th_seq = htonl(ack);
 +			th->th_flags = TH_RST;
  		} else {
  			if (flags & TH_SYN)
  				seq++;
 -			tcp->th_seq = htonl(0);
 -			tcp->th_ack = htonl(seq);
 -			tcp->th_flags = TH_RST | TH_ACK;
 +			th->th_ack = htonl(seq);
 +			th->th_flags = TH_RST | TH_ACK;
  		}
  	} else {
  		/*
 -		 * We are sending a keepalive. flags & TH_SYN determines
 -		 * the direction, forward if set, reverse if clear.
 -		 * NOTE: seq and ack are always assumed to be correct
 -		 * as set by the caller. This may be confusing...
 +		 * Keepalive - use caller provided sequence numbers
  		 */
 -		if (flags & TH_SYN) {
 -			/*
 -			 * we have to rewrite the correct addresses!
 -			 */
 -			ip->ip_dst.s_addr = htonl(id->dst_ip);
 -			ip->ip_src.s_addr = htonl(id->src_ip);
 -			tcp->th_dport = htons(id->dst_port);
 -			tcp->th_sport = htons(id->src_port);
 -		}
 -		tcp->th_seq = htonl(seq);
 -		tcp->th_ack = htonl(ack);
 -		tcp->th_flags = TH_ACK;
 +		th->th_seq = htonl(seq);
 +		th->th_ack = htonl(ack);
 +		th->th_flags = TH_ACK;
 +	}
 +
 +	switch (id->addr_type) {
 +	case 4:
 +		th->th_sum = in_cksum(m, len);
 +
 +		/* finish the ip header */
 +		h->ip_v = 4;
 +		h->ip_hl = sizeof(*h) >> 2;
 +		h->ip_tos = IPTOS_LOWDELAY;
 +		h->ip_off = 0;
 +		h->ip_len = len;
 +		h->ip_ttl = V_ip_defttl;
 +		h->ip_sum = 0;
 +		break;
 +#ifdef INET6
 +	case 6:
 +		th->th_sum = in6_cksum(m, IPPROTO_TCP, sizeof(*h6),
 +		    sizeof(struct tcphdr));
 +
 +		/* finish the ip6 header */
 +		h6->ip6_vfc |= IPV6_VERSION;
 +		h6->ip6_hlim = IPV6_DEFHLIM;
 +		break;
 +#endif
  	}
 -	/*
 -	 * set ip_len to the payload size so we can compute
 -	 * the tcp checksum on the pseudoheader
 -	 * XXX check this, could save a couple of words ?
 -	 */
 -	ip->ip_len = htons(sizeof(struct tcphdr));
 -	tcp->th_sum = in_cksum(m, m->m_pkthdr.len);
 -	/*
 -	 * now fill fields left out earlier
 -	 */
 -	ip->ip_ttl = V_ip_defttl;
 -	ip->ip_len = m->m_pkthdr.len;
 -	m->m_flags |= M_SKIP_FIREWALL;
 +
  	return (m);
  }
  
 @@ -4530,13 +4547,16 @@ static void
  ipfw_tick(void * vnetx) 
  {
  	struct mbuf *m0, *m, *mnext, **mtailp;
 +#ifdef INET6
 +	struct mbuf *m6, **m6_tailp;
 +#endif
  	int i;
  	ipfw_dyn_rule *q;
  #ifdef VIMAGE
  	struct vnet *vp = vnetx;
  #endif
  
 -        CURVNET_SET(vp);
 +	CURVNET_SET(vp);
  	if (V_dyn_keepalive == 0 || V_ipfw_dyn_v == NULL || V_dyn_count == 0)
  		goto done;
  
 @@ -4548,6 +4568,10 @@ ipfw_tick(void * vnetx) 
  	 */
  	m0 = NULL;
  	mtailp = &m0;
 +#ifdef INET6
 +	m6 = NULL;
 +	m6_tailp = &m6;
 +#endif
  	IPFW_DYN_LOCK();
  	for (i = 0 ; i < V_curr_dyn_buckets ; i++) {
  		for (q = V_ipfw_dyn_v[i] ; q ; q = q->next ) {
 @@ -4563,14 +4587,37 @@ ipfw_tick(void * vnetx) 
  			if (TIME_LEQ(q->expire, time_uptime))
  				continue;	/* too late, rule expired */
  
 -			*mtailp = send_pkt(NULL, &(q->id), q->ack_rev - 1,
 +			m = send_pkt(NULL, &(q->id), q->ack_rev - 1,
  				q->ack_fwd, TH_SYN);
 -			if (*mtailp != NULL)
 -				mtailp = &(*mtailp)->m_nextpkt;
 -			*mtailp = send_pkt(NULL, &(q->id), q->ack_fwd - 1,
 +			mnext = send_pkt(NULL, &(q->id), q->ack_fwd - 1,
  				q->ack_rev, 0);
 -			if (*mtailp != NULL)
 -				mtailp = &(*mtailp)->m_nextpkt;
 +
 +			switch (q->id.addr_type) {
 +			case 4:
 +				if (m != NULL) {
 +					*mtailp = m;
 +					mtailp = &(*mtailp)->m_nextpkt;
 +				}
 +				if (mnext != NULL) {
 +					*mtailp = mnext;
 +					mtailp = &(*mtailp)->m_nextpkt;
 +				}
 +				break;
 +#ifdef INET6
 +			case 6:
 +				if (m != NULL) {
 +					*m6_tailp = m;
 +					m6_tailp = &(*m6_tailp)->m_nextpkt;
 +				}
 +				if (mnext != NULL) {
 +					*m6_tailp = mnext;
 +					m6_tailp = &(*m6_tailp)->m_nextpkt;
 +				}
 +				break;
 +#endif
 +			}
 +
 +			m = mnext = NULL;
  		}
  	}
  	IPFW_DYN_UNLOCK();
 @@ -4579,6 +4626,13 @@ ipfw_tick(void * vnetx) 
  		m->m_nextpkt = NULL;
  		ip_output(m, NULL, NULL, 0, NULL, NULL);
  	}
 +#ifdef INET6
 +	for (m = mnext = m6; m != NULL; m = mnext) {
 +		mnext = m->m_nextpkt;
 +		m->m_nextpkt = NULL;
 +		ip6_output(m, NULL, NULL, 0, NULL, NULL, NULL);
 +	}
 +#endif
  done:
  	callout_reset(&V_ipfw_timeout, V_dyn_keepalive_period * hz,
  		      ipfw_tick, vnetx);
 _______________________________________________
 svn-src-all@freebsd.org mailing list
 http://lists.freebsd.org/mailman/listinfo/svn-src-all
 To unsubscribe, send any mail to "svn-src-all-unsubscribe@freebsd.org"
 
State-Changed-From-To: open->patched 
State-Changed-By: ume 
State-Changed-When: Wed Dec 2 15:11:21 UTC 2009 
State-Changed-Why:  
I've just committed it into HEAD.  Thank you for the report. 

http://www.freebsd.org/cgi/query-pr.cgi?pr=117234 
State-Changed-From-To: patched->closed 
State-Changed-By: ume 
State-Changed-When: Mon Jan 4 15:12:34 UTC 2010 
State-Changed-Why:  
MFC'ed to RELENG_8.  Thank you!! 

http://www.freebsd.org/cgi/query-pr.cgi?pr=117234 
>Unformatted:
