tcp_subr.c@ 71203

Last change on this file since 71203 was 69500, checked in by vboxsync, 7 years ago
*: scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 19.7 KB

Line
1	/* $Id: tcp_subr.c 69500 2017-10-28 15:14:05Z vboxsync $ */
2	/** @file
3	* NAT - TCP support.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/*
19	* This code is based on:
20	*
21	* Copyright (c) 1982, 1986, 1988, 1990, 1993
22	* The Regents of the University of California. All rights reserved.
23	*
24	* Redistribution and use in source and binary forms, with or without
25	* modification, are permitted provided that the following conditions
26	* are met:
27	* 1. Redistributions of source code must retain the above copyright
28	* notice, this list of conditions and the following disclaimer.
29	* 2. Redistributions in binary form must reproduce the above copyright
30	* notice, this list of conditions and the following disclaimer in the
31	* documentation and/or other materials provided with the distribution.
32	* 3. All advertising materials mentioning features or use of this software
33	* must display the following acknowledgement:
34	* This product includes software developed by the University of
35	* California, Berkeley and its contributors.
36	* 4. Neither the name of the University nor the names of its contributors
37	* may be used to endorse or promote products derived from this software
38	* without specific prior written permission.
39	*
40	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
41	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
44	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50	* SUCH DAMAGE.
51	*
52	* @(#)tcp_subr.c 8.1 (Berkeley) 6/10/93
53	* tcp_subr.c,v 1.5 1994/10/08 22:39:58 phk Exp
54	*/
55
56	/*
57	* Changes and additions relating to SLiRP
58	* Copyright (c) 1995 Danny Gasparovski.
59	*
60	* Please read the file COPYRIGHT for the
61	* terms and conditions of the copyright.
62	*/
63
64	#include <slirp.h>
65
66
67	/*
68	* Tcp initialization
69	*/
70	void
71	tcp_init(PNATState pData)
72	{
73	tcp_iss = 1; /* wrong */
74	tcb.so_next = tcb.so_prev = &tcb;
75	tcp_last_so = &tcb;
76	tcp_reass_maxqlen = 48;
77	tcp_reass_maxseg = 256;
78	}
79
80	/*
81	* Create template to be used to send tcp packets on a connection.
82	* Call after host entry created, fills
83	* in a skeletal tcp/ip header, minimizing the amount of work
84	* necessary when the connection is used.
85	*/
86	/* struct tcpiphdr * */
87	void
88	tcp_template(struct tcpcb *tp)
89	{
90	struct socket *so = tp->t_socket;
91	register struct tcpiphdr *n = &tp->t_template;
92
93	memset(n->ti_x1, 0, 9);
94	n->ti_pr = IPPROTO_TCP;
95	n->ti_len = RT_H2N_U16(sizeof (struct tcpiphdr) - sizeof (struct ip));
96	n->ti_src = so->so_faddr;
97	n->ti_dst = so->so_laddr;
98	n->ti_sport = so->so_fport;
99	n->ti_dport = so->so_lport;
100
101	n->ti_seq = 0;
102	n->ti_ack = 0;
103	n->ti_x2 = 0;
104	n->ti_off = 5;
105	n->ti_flags = 0;
106	n->ti_win = 0;
107	n->ti_sum = 0;
108	n->ti_urp = 0;
109	}
110
111	/*
112	* Send a single message to the TCP at address specified by
113	* the given TCP/IP header. If m == 0, then we make a copy
114	* of the tcpiphdr at ti and send directly to the addressed host.
115	* This is used to force keep alive messages out using the TCP
116	* template for a connection tp->t_template. If flags are given
117	* then we send a message back to the TCP which originated the
118	* segment ti, and discard the mbuf containing it and any other
119	* attached mbufs.
120	*
121	* In any case the ack and sequence number of the transmitted
122	* segment are as specified by the parameters.
123	*/
124	void
125	tcp_respond(PNATState pData, struct tcpcb tp, struct tcpiphdr ti, struct mbuf *m, tcp_seq ack, tcp_seq seq, int flags)
126	{
127	register int tlen;
128
129	LogFlowFunc(("ENTER: tp = %R[tcpcb793], ti = %p, m = %p, ack = %u, seq = %u, flags = %x\n", tp, ti, m, ack, seq, flags));
130
131	if (m == 0)
132	{
133	if ((m = m_gethdr(pData, M_DONTWAIT, MT_HEADER)) == NULL)
134	return;
135	#ifdef TCP_COMPAT_42
136	tlen = 1;
137	#else
138	tlen = 0;
139	#endif
140	m->m_data += if_maxlinkhdr;
141	m->m_pkthdr.header = mtod(m, void *);
142	mtod(m, struct tcpiphdr ) = *ti;
143	ti = mtod(m, struct tcpiphdr *);
144	flags = TH_ACK;
145	}
146	else
147	{
148	/*
149	* ti points into m so the next line is just making
150	* the mbuf point to ti
151	*/
152	m->m_data = (caddr_t)ti;
153
154	m->m_len = sizeof (struct tcpiphdr);
155	tlen = 0;
156	#define xchg(a,b,type) { type t; t = a; a = b; b = t; }
157	xchg(ti->ti_dst.s_addr, ti->ti_src.s_addr, u_int32_t);
158	xchg(ti->ti_dport, ti->ti_sport, u_int16_t);
159	#undef xchg
160	}
161	ti->ti_len = RT_H2N_U16((u_short)(sizeof (struct tcphdr) + tlen));
162	tlen += sizeof (struct tcpiphdr);
163	m->m_len = tlen;
164
165	memset(ti->ti_x1, 0, 9);
166	ti->ti_seq = RT_H2N_U32(seq);
167	ti->ti_ack = RT_H2N_U32(ack);
168	ti->ti_x2 = 0;
169	ti->ti_off = sizeof (struct tcphdr) >> 2;
170	ti->ti_flags = flags;
171	if (tp)
172	{
173	int win = sbspace(&tp->t_socket->so_rcv);
174	ti->ti_win = RT_H2N_U16((u_int16_t) (win >> tp->rcv_scale));
175	}
176	else
177	ti->ti_win = 0;
178	ti->ti_urp = 0;
179	ti->ti_sum = 0;
180	ti->ti_sum = cksum(m, tlen);
181	((struct ip *)ti)->ip_len = tlen;
182
183	if(flags & TH_RST)
184	((struct ip *)ti)->ip_ttl = MAXTTL;
185	else
186	((struct ip *)ti)->ip_ttl = ip_defttl;
187
188	(void) ip_output(pData, (struct socket *)0, m);
189	}
190
191	/*
192	* Create a new TCP control block, making an
193	* empty reassembly queue and hooking it to the argument
194	* protocol control block.
195	*/
196	struct tcpcb *
197	tcp_newtcpcb(PNATState pData, struct socket *so)
198	{
199	register struct tcpcb *tp;
200
201	tp = (struct tcpcb )RTMemAllocZ(sizeof(tp));
202	if (tp == NULL)
203	return ((struct tcpcb *)0);
204
205	tp->t_maxseg = tcp_mssdflt;
206
207	tp->t_flags = tcp_do_rfc1323 ? (TF_REQ_SCALE\|TF_REQ_TSTMP) : 0;
208	tp->t_socket = so;
209
210	/*
211	* Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
212	* rtt estimate. Set rttvar so that srtt + 2 * rttvar gives
213	* reasonable initial retransmit time.
214	*/
215	tp->t_srtt = TCPTV_SRTTBASE;
216	tp->t_rttvar = tcp_rttdflt * PR_SLOWHZ << 2;
217	tp->t_rttmin = TCPTV_MIN;
218
219	TCPT_RANGESET(tp->t_rxtcur,
220	((TCPTV_SRTTBASE >> 2) + (TCPTV_SRTTDFLT << 2)) >> 1,
221	TCPTV_MIN, TCPTV_REXMTMAX);
222
223	tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT;
224	tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;
225	TCP_STATE_SWITCH_TO(tp, TCPS_CLOSED);
226
227	so->so_tcpcb = tp;
228	so->so_type = IPPROTO_TCP;
229
230	return (tp);
231	}
232
233	/*
234	* Drop a TCP connection, reporting
235	* the specified error. If connection is synchronized,
236	* then send a RST to peer.
237	*/
238	struct tcpcb tcp_drop(PNATState pData, struct tcpcb tp, int err)
239	{
240	/* tcp_drop(tp, errno)
241	register struct tcpcb *tp;
242	int errno;
243	{
244	*/
245	int fUninitializedTemplate = 0;
246	#ifndef LOG_ENABLED
247	NOREF(err);
248	#endif
249	LogFlowFunc(("ENTER: tp = %R[tcpcb793], errno = %d\n", tp, err));
250	fUninitializedTemplate = RT_BOOL(( tp
251	&& ( tp->t_template.ti_src.s_addr == INADDR_ANY
252	\|\| tp->t_template.ti_dst.s_addr == INADDR_ANY)));
253
254	if ( TCPS_HAVERCVDSYN(tp->t_state)
255	&& !fUninitializedTemplate)
256	{
257	TCP_STATE_SWITCH_TO(tp, TCPS_CLOSED);
258	(void) tcp_output(pData, tp);
259	tcpstat.tcps_drops++;
260	}
261	else
262	tcpstat.tcps_conndrops++;
263	#if 0
264	if (errno == ETIMEDOUT && tp->t_softerror)
265	errno = tp->t_softerror;
266
267	so->so_error = errno;
268	#endif
269	return (tcp_close(pData, tp));
270	}
271
272	/*
273	* Close a TCP control block:
274	* discard all space held by the tcp
275	* discard internet protocol block
276	* wake up any sleepers
277	*/
278	struct tcpcb *
279	tcp_close(PNATState pData, register struct tcpcb *tp)
280	{
281	struct socket *so = tp->t_socket;
282
283	struct tseg_qent *te = NULL;
284	LogFlowFunc(("ENTER: tp = %R[tcpcb793]\n", tp));
285	/XXX: freeing the reassembly queue /
286	while (!LIST_EMPTY(&tp->t_segq))
287	{
288	te = LIST_FIRST(&tp->t_segq);
289	LIST_REMOVE(te, tqe_q);
290	m_freem(pData, te->tqe_m);
291	RTMemFree(te);
292	tcp_reass_qsize--;
293	}
294	RTMemFree(tp);
295	so->so_tcpcb = 0;
296	soisfdisconnected(so);
297	/* clobber input socket cache if we're closing the cached connection */
298	if (so == tcp_last_so)
299	tcp_last_so = &tcb;
300	if (so->s != -1)
301	closesocket(so->s);
302	/* Avoid double free if the socket is listening and therefore doesn't have
303	* any sbufs reserved. */
304	if (!(so->so_state & SS_FACCEPTCONN))
305	{
306	sbfree(&so->so_rcv);
307	sbfree(&so->so_snd);
308	}
309	sofree(pData, so);
310	SOCKET_UNLOCK(so);
311	tcpstat.tcps_closed++;
312	return ((struct tcpcb *)0);
313	}
314
315	void
316	tcp_drain(void)
317	{
318	/* XXX */
319	}
320
321	/*
322	* When a source quench is received, close congestion window
323	* to one segment. We will gradually open it again as we proceed.
324	*/
325
326	#if 0
327
328	void
329	tcp_quench(i, int errno)
330	{
331	struct tcpcb *tp = intotcpcb(inp);
332
333	if (tp)
334	tp->snd_cwnd = tp->t_maxseg;
335	}
336
337	#endif
338
339	/*
340	* TCP protocol interface to socket abstraction.
341	*/
342
343	/*
344	* User issued close, and wish to trail through shutdown states:
345	* if never received SYN, just forget it. If got a SYN from peer,
346	* but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
347	* If already got a FIN from peer, then almost done; go to LAST_ACK
348	* state. In all other cases, have already sent FIN to peer (e.g.
349	* after PRU_SHUTDOWN), and just have to play tedious game waiting
350	* for peer to send FIN or not respond to keep-alives, etc.
351	* We can let the user exit from the close as soon as the FIN is acked.
352	*/
353	void
354	tcp_sockclosed(PNATState pData, struct tcpcb *tp)
355	{
356	LogFlowFunc(("ENTER: tp = %R[tcpcb793]\n", tp));
357	LogFunc(("tp->t_socket:%R[natsock]\n",tp->t_socket));
358
359	switch (tp->t_state)
360	{
361	case TCPS_CLOSED:
362	case TCPS_LISTEN:
363	case TCPS_SYN_SENT:
364	TCP_STATE_SWITCH_TO(tp, TCPS_CLOSED);
365	tp = tcp_close(pData, tp);
366	break;
367
368	case TCPS_SYN_RECEIVED:
369	case TCPS_ESTABLISHED:
370	TCP_STATE_SWITCH_TO(tp, TCPS_FIN_WAIT_1);
371	break;
372
373	case TCPS_CLOSE_WAIT:
374	TCP_STATE_SWITCH_TO(tp, TCPS_LAST_ACK);
375	break;
376	}
377	/* soisfdisconnecting(tp->t_socket); */
378	if ( tp
379	&& tp->t_state >= TCPS_FIN_WAIT_2)
380	soisfdisconnected(tp->t_socket);
381	/*
382	* (vasily) there're situations when the FIN or FIN,ACK are lost (Windows host)
383	* and retransmitting keeps VBox busy on sending closing sequences very frequent,
384	* easting a lot of CPU. To avoid this we don't sent on sockets marked as closed
385	* (see slirp.c for details about setting so_close member).
386	*/
387	if ( tp
388	&& tp->t_socket
389	&& !tp->t_socket->so_close)
390	tcp_output(pData, tp);
391	}
392
393	/*
394	* Connect to a host on the Internet
395	* Called by tcp_input
396	* Only do a connect, the tcp fields will be set in tcp_input
397	* return 0 if there's a result of the connect,
398	* else return -1 means we're still connecting
399	* The return value is almost always -1 since the socket is
400	* nonblocking. Connect returns after the SYN is sent, and does
401	* not wait for ACK+SYN.
402	*/
403	int tcp_fconnect(PNATState pData, struct socket *so)
404	{
405	int ret = 0;
406
407	LogFlowFunc(("ENTER: so = %R[natsock]\n", so));
408
409	if ((ret = so->s = socket(AF_INET, SOCK_STREAM, 0)) >= 0)
410	{
411	int opt, s = so->s;
412	struct sockaddr_in addr;
413
414	fd_nonblock(s);
415	opt = 1;
416	setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt));
417	opt = 1;
418	setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (char *)&opt, sizeof(opt));
419
420	if (pData->bindIP.s_addr != INADDR_ANY)
421	{
422	struct sockaddr_in self;
423	self.sin_family = AF_INET;
424	self.sin_addr = pData->bindIP;
425	self.sin_port = 0;
426
427	ret = bind(s, (struct sockaddr *)&self, sizeof(self));
428	if (ret != 0)
429	{
430	Log2(("NAT: bind(%RTnaipv4): %s\n", pData->bindIP.s_addr, strerror(errno)));
431	return ret;
432	}
433	}
434
435	addr.sin_family = AF_INET;
436	if ((so->so_faddr.s_addr & RT_H2N_U32(pData->netmask)) == pData->special_addr.s_addr)
437	{
438	/* It's an alias */
439	switch(RT_N2H_U32(so->so_faddr.s_addr) & ~pData->netmask)
440	{
441	case CTL_DNS:
442	/*
443	* TCP DNS proxy. We only support "forwarding" to
444	* single server. We don't have infrastructure in
445	* place to re-try connections to other servers.
446	*/
447	if ( pData->fUseDnsProxy
448	&& so->so_fport == RT_H2N_U16_C(53))
449	{
450	struct dns_entry *ns = TAILQ_LAST(&pData->pDnsList, dns_list_head);
451	if (ns != NULL)
452	{
453	addr.sin_addr = ns->de_addr;
454	break;
455	}
456	}
457	RT_FALL_THRU();
458	case CTL_ALIAS:
459	default:
460	addr.sin_addr = loopback_addr;
461	break;
462	}
463	}
464	else
465	addr.sin_addr = so->so_faddr;
466	addr.sin_port = so->so_fport;
467
468	Log2((" connect()ing, addr.sin_port=%d, addr.sin_addr.s_addr=%.16s\n",
469	RT_N2H_U16(addr.sin_port), inet_ntoa(addr.sin_addr)));
470	/* We don't care what port we get */
471	ret = connect(s,(struct sockaddr *)&addr,sizeof (addr));
472
473	/*
474	* If it's not in progress, it failed, so we just return 0,
475	* without clearing SS_NOFDREF
476	*/
477	soisfconnecting(so);
478	}
479
480	return(ret);
481	}
482
483	/*
484	* Accept the socket and connect to the local-host
485	*
486	* We have a problem. The correct thing to do would be
487	* to first connect to the local-host, and only if the
488	* connection is accepted, then do an accept() here.
489	* But, a) we need to know who's trying to connect
490	* to the socket to be able to SYN the local-host, and
491	* b) we are already connected to the foreign host by
492	* the time it gets to accept(), so... We simply accept
493	* here and SYN the local-host.
494	*/
495	void
496	tcp_connect(PNATState pData, struct socket *inso)
497	{
498	struct socket *so;
499	struct sockaddr_in addr;
500	socklen_t addrlen = sizeof(struct sockaddr_in);
501	struct tcpcb *tp;
502	int s, opt;
503	int status;
504	socklen_t optlen;
505	static int cVerbose = 1;
506
507	LogFlowFunc(("ENTER: inso = %R[natsock]\n", inso));
508
509	if ( inso->so_laddr.s_addr == INADDR_ANY /* delayed port-forwarding? */
510	&& pData->guest_addr_guess.s_addr == INADDR_ANY)
511	{
512	LogRel2(("NAT: Port-forward: guest address unknown for %R[natsock]\n", inso));
513	closesocket(accept(inso->s, NULL, NULL));
514	if (inso->so_state & SS_FACCEPTONCE)
515	tcp_close(pData, sototcpcb(inso));
516	return;
517	}
518
519	/*
520	* If it's an SS_ACCEPTONCE socket, no need to socreate()
521	* another socket, just use the accept() socket.
522	*/
523	if (inso->so_state & SS_FACCEPTONCE)
524	{
525	/* FACCEPTONCE already have a tcpcb */
526	so = inso;
527	}
528	else
529	{
530	if ((so = socreate()) == NULL)
531	{
532	/* If it failed, get rid of the pending connection */
533	closesocket(accept(inso->s,(struct sockaddr *)&addr,&addrlen));
534	return;
535	}
536	if (tcp_attach(pData, so) < 0)
537	{
538	RTMemFree(so); /* NOT sofree */
539	return;
540	}
541	so->so_laddr = inso->so_laddr;
542	so->so_lport = inso->so_lport;
543	}
544
545	if (so->so_laddr.s_addr == INADDR_ANY)
546	{
547	LogRel2(("NAT: Port-forward: using %RTnaipv4 for %R[natsock]\n",
548	pData->guest_addr_guess.s_addr, inso));
549	so->so_laddr = pData->guest_addr_guess;
550	}
551
552	(void) tcp_mss(pData, sototcpcb(so), 0);
553
554	fd_nonblock(inso->s);
555	if ((s = accept(inso->s,(struct sockaddr *)&addr,&addrlen)) < 0)
556	{
557	tcp_close(pData, sototcpcb(so)); /* This will sofree() as well */
558	return;
559	}
560	fd_nonblock(s);
561	opt = 1;
562	setsockopt(s, SOL_SOCKET, SO_REUSEADDR,(char *)&opt, sizeof(int));
563	opt = 1;
564	setsockopt(s, SOL_SOCKET, SO_OOBINLINE,(char *)&opt, sizeof(int));
565	#if 0
566	opt = 1;
567	setsockopt(s, IPPROTO_TCP, TCP_NODELAY,(char *)&opt, sizeof(int));
568	#endif
569
570	optlen = sizeof(int);
571	status = getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&opt, &optlen);
572	if (status < 0)
573	{
574	LogRel(("NAT: Error(%d) while getting RCV capacity\n", errno));
575	goto no_sockopt;
576	}
577	if (cVerbose > 0)
578	LogRel(("NAT: Old socket recv size: %dKB\n", opt / 1024));
579	/** @todo (r-vvl) make it configurable (via extra data) */
580	opt = pData->socket_rcv;
581	status = setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&opt, sizeof(int));
582	if (status < 0)
583	{
584	LogRel(("NAT: Error(%d) while setting RCV capacity to (%d)\n", errno, opt));
585	goto no_sockopt;
586	}
587	optlen = sizeof(int);
588	status = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&opt, &optlen);
589	if (status < 0)
590	{
591	LogRel(("NAT: Error(%d) while getting SND capacity\n", errno));
592	goto no_sockopt;
593	}
594	if (cVerbose > 0)
595	LogRel(("NAT: Old socket send size: %dKB\n", opt / 1024));
596	opt = pData->socket_rcv;
597	status = setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&opt, sizeof(int));
598	if (status < 0)
599	{
600	LogRel(("NAT: Error(%d) while setting SND capacity to (%d)\n", errno, opt));
601	goto no_sockopt;
602	}
603	if (cVerbose > 0)
604	cVerbose--;
605
606	no_sockopt:
607	so->so_fport = addr.sin_port;
608	so->so_faddr = addr.sin_addr;
609	/* Translate connections from localhost to the real hostname */
610	if (so->so_faddr.s_addr == 0 \|\| so->so_faddr.s_addr == loopback_addr.s_addr)
611	so->so_faddr = alias_addr;
612
613	/* Close the accept() socket, set right state */
614	if (inso->so_state & SS_FACCEPTONCE)
615	{
616	closesocket(so->s); /* If we only accept once, close the accept() socket */
617	so->so_state = SS_NOFDREF; /* Don't select it yet, even though we have an FD */
618	/* if it's not FACCEPTONCE, it's already NOFDREF */
619	}
620	so->s = s;
621
622	tp = sototcpcb(so);
623
624	tcp_template(tp);
625
626	/* Compute window scaling to request. */
627	/* while (tp->request_r_scale < TCP_MAX_WINSHIFT
628	* && (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
629	* tp->request_r_scale++;
630	*/
631
632	/* soisconnecting(so); / / NOFDREF used instead */
633	tcpstat.tcps_connattempt++;
634
635	TCP_STATE_SWITCH_TO(tp, TCPS_SYN_SENT);
636	tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
637	tp->iss = tcp_iss;
638	tcp_iss += TCP_ISSINCR/2;
639	tcp_sendseqinit(tp);
640	tcp_output(pData, tp);
641	}
642
643	/*
644	* Attach a TCPCB to a socket.
645	*/
646	int
647	tcp_attach(PNATState pData, struct socket *so)
648	{
649	/* We're attaching already attached socket??? */
650	Assert(so->so_type == 0);
651	if ((so->so_tcpcb = tcp_newtcpcb(pData, so)) == NULL)
652	return -1;
653
654	SOCKET_LOCK_CREATE(so);
655	QSOCKET_LOCK(tcb);
656	insque(pData, so, &tcb);
657	NSOCK_INC();
658	QSOCKET_UNLOCK(tcb);
659	return 0;
660	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/Network/slirp/tcp_subr.c@ 71203

Download in other formats: