tcp_subr.c@ 107044

Last change on this file since 107044 was 106061, checked in by vboxsync, 3 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 19.3 KB

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

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

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

Download in other formats: