[apple/xnu.git] / bsd / netiso / tuba_subr.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Copyright (c) 1992, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)tuba_subr.c	8.1 (Berkeley) 6/10/93
 */

#include <sys/param.h>
#include <sys/proc.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/protosw.h>
#include <sys/errno.h>

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

#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/in_pcb.h>
#include <netinet/ip_var.h>
#include <netinet/ip_icmp.h>
#include <netinet/tcp.h>
#include <netinet/tcp_fsm.h>
#include <netinet/tcp_seq.h>
#include <netinet/tcp_timer.h>
#include <netinet/tcp_var.h>
#include <netinet/tcpip.h>
#include <netinet/tcp_debug.h>

#include <netiso/argo_debug.h>
#include <netiso/iso.h>
#include <netiso/clnp.h>
#include <netiso/iso_pcb.h>
#include <netiso/iso_var.h>
#include <netiso/tuba_table.h>

static	struct	sockaddr_iso null_siso = { sizeof(null_siso), AF_ISO, };
extern	int	tuba_table_size, tcp_keepidle, tcp_keepintvl, tcp_maxidle;
extern	int	tcppcbcachemiss, tcppredack, tcppreddat, tcprexmtthresh;
extern	struct	tcpiphdr tcp_saveti;
struct	inpcb	tuba_inpcb;
struct	inpcb	*tuba_last_inpcb = &tuba_inpcb;
struct	isopcb	tuba_isopcb;
/*
 * Tuba initialization
 */
tuba_init()
{
#define TUBAHDRSIZE (3 /*LLC*/ + 9 /*CLNP Fixed*/ + 42 /*Addresses*/ \
		     + 6 /*CLNP Segment*/ + 20 /*TCP*/)

	tuba_inpcb.inp_next = tuba_inpcb.inp_prev = &tuba_inpcb;
	tuba_isopcb.isop_next = tuba_isopcb.isop_prev = &tuba_isopcb;
	tuba_isopcb.isop_faddr = &tuba_isopcb.isop_sfaddr;
	tuba_isopcb.isop_laddr = &tuba_isopcb.isop_sladdr;
	if (max_protohdr < TUBAHDRSIZE)
		max_protohdr = TUBAHDRSIZE;
	if (max_linkhdr + TUBAHDRSIZE > MHLEN)
		panic("tuba_init");
}

struct addr_arg {
	int	error;
	int	offset;
	u_long	sum;
};

/*
 * Calculate contribution to fudge factor for TCP checksum,
 * and coincidentally set pointer for convenience of clnp_output
 * if we are are responding when there is no isopcb around.
 */
static void
tuba_getaddr(arg, siso, index)
	register struct addr_arg *arg;
	struct sockaddr_iso **siso;
	u_long index;
{
	register struct tuba_cache *tc;
	if (index <= tuba_table_size && (tc = tuba_table[index])) {
		if (siso)
			*siso = &tc->tc_siso;
		arg->sum += (arg->offset & 1 ? tc->tc_ssum : tc->tc_sum)
				+ (0xffff ^ index);
		arg->offset += tc->tc_siso.siso_nlen + 1;
	} else
		arg->error = 1;
}

tuba_output(m, tp)
	register struct mbuf *m;
	struct tcpcb *tp;
{
	register struct tcpiphdr *n;
	struct	isopcb *isop;
	struct	addr_arg arg;

	if (tp == 0 || (n = tp->t_template) == 0 || 
	    (isop = (struct isopcb *)tp->t_tuba_pcb) == 0) {
		isop = &tuba_isopcb;
		n = mtod(m, struct tcpiphdr *);
		arg.error = arg.sum = arg.offset = 0;
		tuba_getaddr(&arg, &tuba_isopcb.isop_faddr, n->ti_dst.s_addr);
		tuba_getaddr(&arg, &tuba_isopcb.isop_laddr, n->ti_src.s_addr);
		REDUCE(arg.sum, arg.sum);
		goto adjust;
	}
	if (n->ti_sum == 0) {
		arg.error = arg.sum = arg.offset = 0;
		tuba_getaddr(&arg, (struct sockaddr_iso **)0, n->ti_dst.s_addr);
		tuba_getaddr(&arg, (struct sockaddr_iso **)0, n->ti_src.s_addr);
		REDUCE(arg.sum, arg.sum);
		n->ti_sum = arg.sum;
		n = mtod(m, struct tcpiphdr *);
	adjust:
		if (arg.error) {
			m_freem(m);
			return (EADDRNOTAVAIL);
		}
		REDUCE(n->ti_sum, n->ti_sum + (0xffff ^ arg.sum));
	}
	m->m_len -= sizeof (struct ip);
	m->m_pkthdr.len -= sizeof (struct ip);
	m->m_data += sizeof (struct ip);
	return (clnp_output(m, isop, m->m_pkthdr.len, 0));
}

tuba_refcnt(isop, delta)
	struct isopcb *isop;
{
	register struct tuba_cache *tc;
	unsigned index, sum;

	if (delta != 1)
		delta = -1;
	if (isop == 0 || isop->isop_faddr == 0 || isop->isop_laddr == 0 ||
	    (delta == -1 && isop->isop_tuba_cached == 0) ||
	    (delta == 1 && isop->isop_tuba_cached != 0))
		return;
	isop->isop_tuba_cached = (delta == 1);
	if ((index = tuba_lookup(isop->isop_faddr, M_DONTWAIT)) != 0 &&
	    (tc = tuba_table[index]) != 0 && (delta == 1 || tc->tc_refcnt > 0))
		tc->tc_refcnt += delta;
	if ((index = tuba_lookup(isop->isop_laddr, M_DONTWAIT)) != 0 &&
	    (tc = tuba_table[index]) != 0 && (delta == 1 || tc->tc_refcnt > 0))
		tc->tc_refcnt += delta;
}

tuba_pcbdetach(isop)
	struct isopcb *isop;
{
	if (isop == 0)
		return;
	tuba_refcnt(isop, -1);
	isop->isop_socket = 0;
	iso_pcbdetach(isop);
}

/*
 * Avoid  in_pcbconnect in faked out tcp_input()
 */
tuba_pcbconnect(inp, nam)
	register struct inpcb *inp;
	struct mbuf *nam;
{
	register struct sockaddr_iso *siso;
	struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);
	struct tcpcb *tp = intotcpcb(inp);
	struct isopcb *isop = (struct isopcb *)tp->t_tuba_pcb;
	int error;

	/* hardwire iso_pcbbind() here */
	siso = isop->isop_laddr = &isop->isop_sladdr;
	*siso = tuba_table[inp->inp_laddr.s_addr]->tc_siso;
	siso->siso_tlen = sizeof(inp->inp_lport);
	bcopy((caddr_t)&inp->inp_lport, TSEL(siso), sizeof(inp->inp_lport));

	/* hardwire in_pcbconnect() here without assigning route */
	inp->inp_fport = sin->sin_port;
	inp->inp_faddr = sin->sin_addr;

	/* reuse nam argument to call iso_pcbconnect() */
	nam->m_len = sizeof(*siso);
	siso = mtod(nam, struct sockaddr_iso *);
	*siso = tuba_table[inp->inp_faddr.s_addr]->tc_siso;
	siso->siso_tlen = sizeof(inp->inp_fport);
	bcopy((caddr_t)&inp->inp_fport, TSEL(siso), sizeof(inp->inp_fport));

	if ((error = iso_pcbconnect(isop, nam)) == 0)
		tuba_refcnt(isop, 1);
	return (error);
}

/*
 * CALLED FROM:
 * 	clnp's input routine, indirectly through the protosw.
 * FUNCTION and ARGUMENTS:
 * Take a packet (m) from clnp, strip off the clnp header
 * and do tcp input processing.
 * No return value.  
 */
tuba_tcpinput(m, src, dst)
	register struct mbuf *m;
	struct sockaddr_iso *src, *dst;
{
	unsigned long sum, lindex, findex;
	register struct tcpiphdr *ti;
	register struct inpcb *inp;
	caddr_t optp = NULL;
	int optlen;
	int len, tlen, off;
	register struct tcpcb *tp = 0;
	int tiflags;
	struct socket *so;
	int todrop, acked, ourfinisacked, needoutput = 0;
	short ostate;
	struct in_addr laddr;
	int dropsocket = 0, iss = 0;
	u_long tiwin, ts_val, ts_ecr;
	int ts_present = 0;

	if ((m->m_flags & M_PKTHDR) == 0)
		panic("tuba_tcpinput");
	/*
	 * Do some housekeeping looking up CLNP addresses.
	 * If we are out of space might as well drop the packet now.
	 */
	tcpstat.tcps_rcvtotal++;
	lindex = tuba_lookup(dst, M_DONTWAIT);
	findex = tuba_lookup(src, M_DONTWAIT);
	if (lindex == 0 || findex == 0)
		goto drop;
	/*
	 * CLNP gave us an mbuf chain WITH the clnp header pulled up,
	 * but the data pointer pushed past it.
	 */
	len = m->m_len;
	tlen = m->m_pkthdr.len;
	m->m_data -= sizeof(struct ip);
	m->m_len += sizeof(struct ip);
	m->m_pkthdr.len += sizeof(struct ip);
	m->m_flags &= ~(M_MCAST|M_BCAST); /* XXX should do this in clnp_input */
	/*
	 * The reassembly code assumes it will be overwriting a useless
	 * part of the packet, which is why we need to have it point
	 * into the packet itself.
	 *
	 * Check to see if the data is properly alligned
	 * so that we can save copying the tcp header.
	 * This code knows way too much about the structure of mbufs!
	 */
	off = ((sizeof (long) - 1) & ((m->m_flags & M_EXT) ?
		(m->m_data - m->m_ext.ext_buf) :  (m->m_data - m->m_pktdat)));
	if (off || len < sizeof(struct tcphdr)) {
		struct mbuf *m0 = m;

		MGETHDR(m, M_DONTWAIT, MT_DATA);
		if (m == 0) { 
			m = m0;
			goto drop;
		}
		m->m_next = m0;
		m->m_data += max_linkhdr;
		m->m_pkthdr = m0->m_pkthdr;
		m->m_flags = m0->m_flags & M_COPYFLAGS;
		if (len < sizeof(struct tcphdr)) {
			m->m_len = 0;
			if ((m = m_pullup(m, sizeof(struct tcpiphdr))) == 0) {
				tcpstat.tcps_rcvshort++;
				return;
			}
		} else {
			bcopy(mtod(m0, caddr_t) + sizeof(struct ip),
			      mtod(m, caddr_t) + sizeof(struct ip),
			      sizeof(struct tcphdr));
			m0->m_len -= sizeof(struct tcpiphdr);
			m0->m_data += sizeof(struct tcpiphdr);
			m->m_len = sizeof(struct tcpiphdr);
		}
	}
	/*
	 * Calculate checksum of extended TCP header and data,
	 * replacing what would have been IP addresses by
	 * the IP checksum of the CLNP addresses.
	 */
	ti = mtod(m, struct tcpiphdr *);
	ti->ti_dst.s_addr = tuba_table[lindex]->tc_sum;
	if (dst->siso_nlen & 1)
		ti->ti_src.s_addr = tuba_table[findex]->tc_sum;
	else
		ti->ti_src.s_addr = tuba_table[findex]->tc_ssum;
	ti->ti_prev = ti->ti_next = 0;
	ti->ti_x1 = 0; ti->ti_pr = ISOPROTO_TCP;
	ti->ti_len = htons((u_short)tlen);
	if (ti->ti_sum = in_cksum(m, m->m_pkthdr.len)) {
		tcpstat.tcps_rcvbadsum++;
		goto drop;
	}
	ti->ti_src.s_addr = findex;
	ti->ti_dst.s_addr = lindex;
	/*
	 * Now include the rest of TCP input
	 */
#define TUBA_INCLUDE
#define	in_pcbconnect	tuba_pcbconnect
#define	tcb		tuba_inpcb
#define tcp_last_inpcb	tuba_last_inpcb

#include <netinet/tcp_input.c>
}

#define tcp_slowtimo	tuba_slowtimo
#define tcp_fasttimo	tuba_fasttimo

#include <netinet/tcp_timer.c>
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* Copyright (c) 1992, 1993
	24	* The Regents of the University of California. All rights reserved.
	25	*
	26	* Redistribution and use in source and binary forms, with or without
	27	* modification, are permitted provided that the following conditions
	28	* are met:
	29	* 1. Redistributions of source code must retain the above copyright
	30	* notice, this list of conditions and the following disclaimer.
	31	* 2. Redistributions in binary form must reproduce the above copyright
	32	* notice, this list of conditions and the following disclaimer in the
	33	* documentation and/or other materials provided with the distribution.
	34	* 3. All advertising materials mentioning features or use of this software
	35	* must display the following acknowledgement:
	36	* This product includes software developed by the University of
	37	* California, Berkeley and its contributors.
	38	* 4. Neither the name of the University nor the names of its contributors
	39	* may be used to endorse or promote products derived from this software
	40	* without specific prior written permission.
	41	*
	42	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	43	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	44	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	45	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	46	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	47	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	48	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	49	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	50	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	51	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	52	* SUCH DAMAGE.
	53	*
	54	* @(#)tuba_subr.c 8.1 (Berkeley) 6/10/93
	55	*/
	56
	57	#include <sys/param.h>
	58	#include <sys/proc.h>
	59	#include <sys/systm.h>
	60	#include <sys/malloc.h>
	61	#include <sys/mbuf.h>
	62	#include <sys/socket.h>
	63	#include <sys/socketvar.h>
	64	#include <sys/protosw.h>
65	#include <sys/errno.h>
66
67	#include <net/route.h>
68	#include <net/if.h>
69
70	#include <netinet/in.h>
71	#include <netinet/in_systm.h>
72	#include <netinet/ip.h>
73	#include <netinet/in_pcb.h>
74	#include <netinet/ip_var.h>
75	#include <netinet/ip_icmp.h>
76	#include <netinet/tcp.h>
77	#include <netinet/tcp_fsm.h>
78	#include <netinet/tcp_seq.h>
79	#include <netinet/tcp_timer.h>
80	#include <netinet/tcp_var.h>
81	#include <netinet/tcpip.h>
82	#include <netinet/tcp_debug.h>
83
84	#include <netiso/argo_debug.h>
85	#include <netiso/iso.h>
86	#include <netiso/clnp.h>
87	#include <netiso/iso_pcb.h>
88	#include <netiso/iso_var.h>
89	#include <netiso/tuba_table.h>
90
91	static struct sockaddr_iso null_siso = { sizeof(null_siso), AF_ISO, };
92	extern int tuba_table_size, tcp_keepidle, tcp_keepintvl, tcp_maxidle;
93	extern int tcppcbcachemiss, tcppredack, tcppreddat, tcprexmtthresh;
94	extern struct tcpiphdr tcp_saveti;
95	struct inpcb tuba_inpcb;
96	struct inpcb *tuba_last_inpcb = &tuba_inpcb;
97	struct isopcb tuba_isopcb;
98	/*
99	* Tuba initialization
100	*/
101	tuba_init()
102	{
103	#define TUBAHDRSIZE (3 /LLC/ + 9 /CLNP Fixed/ + 42 /Addresses/ \
104	+ 6 /CLNP Segment/ + 20 /TCP/)
105
106	tuba_inpcb.inp_next = tuba_inpcb.inp_prev = &tuba_inpcb;
107	tuba_isopcb.isop_next = tuba_isopcb.isop_prev = &tuba_isopcb;
108	tuba_isopcb.isop_faddr = &tuba_isopcb.isop_sfaddr;
109	tuba_isopcb.isop_laddr = &tuba_isopcb.isop_sladdr;
110	if (max_protohdr < TUBAHDRSIZE)
111	max_protohdr = TUBAHDRSIZE;
112	if (max_linkhdr + TUBAHDRSIZE > MHLEN)
113	panic("tuba_init");
114	}
115
116	struct addr_arg {
117	int error;
118	int offset;
119	u_long sum;
120	};
121
122	/*
123	* Calculate contribution to fudge factor for TCP checksum,
124	* and coincidentally set pointer for convenience of clnp_output
125	* if we are are responding when there is no isopcb around.
126	*/
127	static void
128	tuba_getaddr(arg, siso, index)
129	register struct addr_arg *arg;
130	struct sockaddr_iso **siso;
131	u_long index;
132	{
133	register struct tuba_cache *tc;
134	if (index <= tuba_table_size && (tc = tuba_table[index])) {
135	if (siso)
136	*siso = &tc->tc_siso;
137	arg->sum += (arg->offset & 1 ? tc->tc_ssum : tc->tc_sum)
138	+ (0xffff ^ index);
139	arg->offset += tc->tc_siso.siso_nlen + 1;
140	} else
141	arg->error = 1;
142	}
143
144	tuba_output(m, tp)
145	register struct mbuf *m;
146	struct tcpcb *tp;
147	{
148	register struct tcpiphdr *n;
149	struct isopcb *isop;
150	struct addr_arg arg;
151
152	if (tp == 0 \|\| (n = tp->t_template) == 0 \|\|
153	(isop = (struct isopcb *)tp->t_tuba_pcb) == 0) {
154	isop = &tuba_isopcb;
155	n = mtod(m, struct tcpiphdr *);
156	arg.error = arg.sum = arg.offset = 0;
157	tuba_getaddr(&arg, &tuba_isopcb.isop_faddr, n->ti_dst.s_addr);
158	tuba_getaddr(&arg, &tuba_isopcb.isop_laddr, n->ti_src.s_addr);
159	REDUCE(arg.sum, arg.sum);
160	goto adjust;
161	}
162	if (n->ti_sum == 0) {
163	arg.error = arg.sum = arg.offset = 0;
164	tuba_getaddr(&arg, (struct sockaddr_iso **)0, n->ti_dst.s_addr);
165	tuba_getaddr(&arg, (struct sockaddr_iso **)0, n->ti_src.s_addr);
166	REDUCE(arg.sum, arg.sum);
167	n->ti_sum = arg.sum;
168	n = mtod(m, struct tcpiphdr *);
169	adjust:
170	if (arg.error) {
171	m_freem(m);
172	return (EADDRNOTAVAIL);
173	}
174	REDUCE(n->ti_sum, n->ti_sum + (0xffff ^ arg.sum));
175	}
176	m->m_len -= sizeof (struct ip);
177	m->m_pkthdr.len -= sizeof (struct ip);
178	m->m_data += sizeof (struct ip);
179	return (clnp_output(m, isop, m->m_pkthdr.len, 0));
180	}
181
182	tuba_refcnt(isop, delta)
183	struct isopcb *isop;
184	{
185	register struct tuba_cache *tc;
186	unsigned index, sum;
187
188	if (delta != 1)
189	delta = -1;
190	if (isop == 0 \|\| isop->isop_faddr == 0 \|\| isop->isop_laddr == 0 \|\|
191	(delta == -1 && isop->isop_tuba_cached == 0) \|\|
192	(delta == 1 && isop->isop_tuba_cached != 0))
193	return;
194	isop->isop_tuba_cached = (delta == 1);
195	if ((index = tuba_lookup(isop->isop_faddr, M_DONTWAIT)) != 0 &&
196	(tc = tuba_table[index]) != 0 && (delta == 1 \|\| tc->tc_refcnt > 0))
197	tc->tc_refcnt += delta;
198	if ((index = tuba_lookup(isop->isop_laddr, M_DONTWAIT)) != 0 &&
199	(tc = tuba_table[index]) != 0 && (delta == 1 \|\| tc->tc_refcnt > 0))
200	tc->tc_refcnt += delta;
201	}
202
203	tuba_pcbdetach(isop)
204	struct isopcb *isop;
205	{
206	if (isop == 0)
207	return;
208	tuba_refcnt(isop, -1);
209	isop->isop_socket = 0;
210	iso_pcbdetach(isop);
211	}
212
213	/*
214	* Avoid in_pcbconnect in faked out tcp_input()
215	*/
216	tuba_pcbconnect(inp, nam)
217	register struct inpcb *inp;
218	struct mbuf *nam;
219	{
220	register struct sockaddr_iso *siso;
221	struct sockaddr_in sin = mtod(nam, struct sockaddr_in );
222	struct tcpcb *tp = intotcpcb(inp);
223	struct isopcb isop = (struct isopcb )tp->t_tuba_pcb;
224	int error;
225
226	/* hardwire iso_pcbbind() here */
227	siso = isop->isop_laddr = &isop->isop_sladdr;
228	*siso = tuba_table[inp->inp_laddr.s_addr]->tc_siso;
229	siso->siso_tlen = sizeof(inp->inp_lport);
230	bcopy((caddr_t)&inp->inp_lport, TSEL(siso), sizeof(inp->inp_lport));
231
232	/* hardwire in_pcbconnect() here without assigning route */
233	inp->inp_fport = sin->sin_port;
234	inp->inp_faddr = sin->sin_addr;
235
236	/* reuse nam argument to call iso_pcbconnect() */
237	nam->m_len = sizeof(*siso);
238	siso = mtod(nam, struct sockaddr_iso *);
239	*siso = tuba_table[inp->inp_faddr.s_addr]->tc_siso;
240	siso->siso_tlen = sizeof(inp->inp_fport);
241	bcopy((caddr_t)&inp->inp_fport, TSEL(siso), sizeof(inp->inp_fport));
242
243	if ((error = iso_pcbconnect(isop, nam)) == 0)
244	tuba_refcnt(isop, 1);
245	return (error);
246	}
247
248	/*
249	* CALLED FROM:
250	* clnp's input routine, indirectly through the protosw.
251	* FUNCTION and ARGUMENTS:
252	* Take a packet (m) from clnp, strip off the clnp header
253	* and do tcp input processing.
254	* No return value.
255	*/
256	tuba_tcpinput(m, src, dst)
257	register struct mbuf *m;
258	struct sockaddr_iso src, dst;
259	{
260	unsigned long sum, lindex, findex;
261	register struct tcpiphdr *ti;
262	register struct inpcb *inp;
263	caddr_t optp = NULL;
264	int optlen;
265	int len, tlen, off;
266	register struct tcpcb *tp = 0;
267	int tiflags;
268	struct socket *so;
269	int todrop, acked, ourfinisacked, needoutput = 0;
270	short ostate;
271	struct in_addr laddr;
272	int dropsocket = 0, iss = 0;
273	u_long tiwin, ts_val, ts_ecr;
274	int ts_present = 0;
275
276	if ((m->m_flags & M_PKTHDR) == 0)
277	panic("tuba_tcpinput");
278	/*
279	* Do some housekeeping looking up CLNP addresses.
280	* If we are out of space might as well drop the packet now.
281	*/
282	tcpstat.tcps_rcvtotal++;
283	lindex = tuba_lookup(dst, M_DONTWAIT);
284	findex = tuba_lookup(src, M_DONTWAIT);
285	if (lindex == 0 \|\| findex == 0)
286	goto drop;
287	/*
288	* CLNP gave us an mbuf chain WITH the clnp header pulled up,
289	* but the data pointer pushed past it.
290	*/
291	len = m->m_len;
292	tlen = m->m_pkthdr.len;
293	m->m_data -= sizeof(struct ip);
294	m->m_len += sizeof(struct ip);
295	m->m_pkthdr.len += sizeof(struct ip);
296	m->m_flags &= ~(M_MCAST\|M_BCAST); /* XXX should do this in clnp_input */
297	/*
298	* The reassembly code assumes it will be overwriting a useless
299	* part of the packet, which is why we need to have it point
300	* into the packet itself.
301	*
302	* Check to see if the data is properly alligned
303	* so that we can save copying the tcp header.
304	* This code knows way too much about the structure of mbufs!
305	*/
306	off = ((sizeof (long) - 1) & ((m->m_flags & M_EXT) ?
307	(m->m_data - m->m_ext.ext_buf) : (m->m_data - m->m_pktdat)));
308	if (off \|\| len < sizeof(struct tcphdr)) {
309	struct mbuf *m0 = m;
310
311	MGETHDR(m, M_DONTWAIT, MT_DATA);
312	if (m == 0) {
313	m = m0;
314	goto drop;
315	}
316	m->m_next = m0;
317	m->m_data += max_linkhdr;
318	m->m_pkthdr = m0->m_pkthdr;
319	m->m_flags = m0->m_flags & M_COPYFLAGS;
320	if (len < sizeof(struct tcphdr)) {
321	m->m_len = 0;
322	if ((m = m_pullup(m, sizeof(struct tcpiphdr))) == 0) {
323	tcpstat.tcps_rcvshort++;
324	return;
325	}
326	} else {
327	bcopy(mtod(m0, caddr_t) + sizeof(struct ip),
328	mtod(m, caddr_t) + sizeof(struct ip),
329	sizeof(struct tcphdr));
330	m0->m_len -= sizeof(struct tcpiphdr);
331	m0->m_data += sizeof(struct tcpiphdr);
332	m->m_len = sizeof(struct tcpiphdr);
333	}
334	}
335	/*
336	* Calculate checksum of extended TCP header and data,
337	* replacing what would have been IP addresses by
338	* the IP checksum of the CLNP addresses.
339	*/
340	ti = mtod(m, struct tcpiphdr *);
341	ti->ti_dst.s_addr = tuba_table[lindex]->tc_sum;
342	if (dst->siso_nlen & 1)
343	ti->ti_src.s_addr = tuba_table[findex]->tc_sum;
344	else
345	ti->ti_src.s_addr = tuba_table[findex]->tc_ssum;
346	ti->ti_prev = ti->ti_next = 0;
347	ti->ti_x1 = 0; ti->ti_pr = ISOPROTO_TCP;
348	ti->ti_len = htons((u_short)tlen);
349	if (ti->ti_sum = in_cksum(m, m->m_pkthdr.len)) {
350	tcpstat.tcps_rcvbadsum++;
351	goto drop;
352	}
353	ti->ti_src.s_addr = findex;
354	ti->ti_dst.s_addr = lindex;
355	/*
356	* Now include the rest of TCP input
357	*/
358	#define TUBA_INCLUDE
359	#define in_pcbconnect tuba_pcbconnect
360	#define tcb tuba_inpcb
361	#define tcp_last_inpcb tuba_last_inpcb
362
363	#include <netinet/tcp_input.c>
364	}
365
366	#define tcp_slowtimo tuba_slowtimo
367	#define tcp_fasttimo tuba_fasttimo
368
369	#include <netinet/tcp_timer.c>