tcp_subr.c@ 91623

Last change on this file since 91623 was 82968, checked in by vboxsync, 5 years 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 82968 2020-02-04 10:35:17Z vboxsync $ */
2	/** @file
3	* NAT - TCP support.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 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
416	opt = 1;
417	setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (char *)&opt, sizeof(opt));
418	opt = 1;
419	setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char *)&opt, sizeof(opt));
420
421	ret = sobind(pData, so);
422	if (ret != 0)
423	return ret;
424
425	addr.sin_family = AF_INET;
426	if ((so->so_faddr.s_addr & RT_H2N_U32(pData->netmask)) == pData->special_addr.s_addr)
427	{
428	/* It's an alias */
429	switch(RT_N2H_U32(so->so_faddr.s_addr) & ~pData->netmask)
430	{
431	case CTL_DNS:
432	/*
433	* TCP DNS proxy. We only support "forwarding" to
434	* single server. We don't have infrastructure in
435	* place to re-try connections to other servers.
436	*/
437	if ( pData->fUseDnsProxy
438	&& so->so_fport == RT_H2N_U16_C(53))
439	{
440	struct dns_entry *ns = TAILQ_LAST(&pData->pDnsList, dns_list_head);
441	if (ns != NULL)
442	{
443	addr.sin_addr = ns->de_addr;
444	break;
445	}
446	}
447	RT_FALL_THRU();
448	case CTL_ALIAS:
449	default:
450	addr.sin_addr = loopback_addr;
451	break;
452	}
453	}
454	else
455	addr.sin_addr = so->so_faddr;
456	addr.sin_port = so->so_fport;
457
458	Log2(("NAT: tcp connect to %RTnaipv4:%d\n",
459	addr.sin_addr.s_addr, RT_N2H_U16(addr.sin_port)));
460
461	ret = connect(s,(struct sockaddr *)&addr,sizeof (addr));
462
463	/*
464	* If it's not in progress, it failed, so we just return 0,
465	* without clearing SS_NOFDREF
466	*/
467	soisfconnecting(so);
468	}
469
470	return(ret);
471	}
472
473	/*
474	* Accept the socket and connect to the local-host
475	*
476	* We have a problem. The correct thing to do would be
477	* to first connect to the local-host, and only if the
478	* connection is accepted, then do an accept() here.
479	* But, a) we need to know who's trying to connect
480	* to the socket to be able to SYN the local-host, and
481	* b) we are already connected to the foreign host by
482	* the time it gets to accept(), so... We simply accept
483	* here and SYN the local-host.
484	*/
485	void
486	tcp_connect(PNATState pData, struct socket *inso)
487	{
488	struct socket *so;
489	struct sockaddr_in addr;
490	socklen_t addrlen = sizeof(struct sockaddr_in);
491	struct tcpcb *tp;
492	int s, opt;
493	int status;
494	socklen_t optlen;
495	static int cVerbose = 1;
496
497	LogFlowFunc(("ENTER: inso = %R[natsock]\n", inso));
498
499	if ( inso->so_laddr.s_addr == INADDR_ANY /* delayed port-forwarding? */
500	&& pData->guest_addr_guess.s_addr == INADDR_ANY)
501	{
502	LogRel2(("NAT: Port-forward: guest address unknown for %R[natsock]\n", inso));
503	closesocket(accept(inso->s, NULL, NULL));
504	if (inso->so_state & SS_FACCEPTONCE)
505	tcp_close(pData, sototcpcb(inso));
506	return;
507	}
508
509	/*
510	* If it's an SS_ACCEPTONCE socket, no need to socreate()
511	* another socket, just use the accept() socket.
512	*/
513	if (inso->so_state & SS_FACCEPTONCE)
514	{
515	/* FACCEPTONCE already have a tcpcb */
516	so = inso;
517	}
518	else
519	{
520	if ((so = socreate()) == NULL)
521	{
522	/* If it failed, get rid of the pending connection */
523	closesocket(accept(inso->s,(struct sockaddr *)&addr,&addrlen));
524	return;
525	}
526	if (tcp_attach(pData, so) < 0)
527	{
528	RTMemFree(so); /* NOT sofree */
529	return;
530	}
531	so->so_laddr = inso->so_laddr;
532	so->so_lport = inso->so_lport;
533	}
534
535	if (so->so_laddr.s_addr == INADDR_ANY)
536	{
537	LogRel2(("NAT: Port-forward: using %RTnaipv4 for %R[natsock]\n",
538	pData->guest_addr_guess.s_addr, inso));
539	so->so_laddr = pData->guest_addr_guess;
540	}
541
542	(void) tcp_mss(pData, sototcpcb(so), 0);
543
544	fd_nonblock(inso->s);
545	if ((s = accept(inso->s,(struct sockaddr *)&addr,&addrlen)) < 0)
546	{
547	tcp_close(pData, sototcpcb(so)); /* This will sofree() as well */
548	return;
549	}
550	fd_nonblock(s);
551	opt = 1;
552	setsockopt(s, SOL_SOCKET, SO_REUSEADDR,(char *)&opt, sizeof(int));
553	opt = 1;
554	setsockopt(s, SOL_SOCKET, SO_OOBINLINE,(char *)&opt, sizeof(int));
555	opt = 1;
556	setsockopt(s, IPPROTO_TCP, TCP_NODELAY,(char *)&opt, sizeof(int));
557
558	optlen = sizeof(int);
559	status = getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&opt, &optlen);
560	if (status < 0)
561	{
562	LogRel(("NAT: Error(%d) while getting RCV capacity\n", errno));
563	goto no_sockopt;
564	}
565	if (cVerbose > 0)
566	LogRel(("NAT: Old socket recv size: %dKB\n", opt / 1024));
567	/** @todo (r-vvl) make it configurable (via extra data) */
568	opt = pData->socket_rcv;
569	status = setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&opt, sizeof(int));
570	if (status < 0)
571	{
572	LogRel(("NAT: Error(%d) while setting RCV capacity to (%d)\n", errno, opt));
573	goto no_sockopt;
574	}
575	optlen = sizeof(int);
576	status = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&opt, &optlen);
577	if (status < 0)
578	{
579	LogRel(("NAT: Error(%d) while getting SND capacity\n", errno));
580	goto no_sockopt;
581	}
582	if (cVerbose > 0)
583	LogRel(("NAT: Old socket send size: %dKB\n", opt / 1024));
584	opt = pData->socket_rcv;
585	status = setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&opt, sizeof(int));
586	if (status < 0)
587	{
588	LogRel(("NAT: Error(%d) while setting SND capacity to (%d)\n", errno, opt));
589	goto no_sockopt;
590	}
591	if (cVerbose > 0)
592	cVerbose--;
593
594	no_sockopt:
595	so->so_fport = addr.sin_port;
596	so->so_faddr = addr.sin_addr;
597	/* Translate connections from localhost to the real hostname */
598	if (so->so_faddr.s_addr == 0 \|\| so->so_faddr.s_addr == loopback_addr.s_addr)
599	so->so_faddr = alias_addr;
600
601	/* Close the accept() socket, set right state */
602	if (inso->so_state & SS_FACCEPTONCE)
603	{
604	closesocket(so->s); /* If we only accept once, close the accept() socket */
605	so->so_state = SS_NOFDREF; /* Don't select it yet, even though we have an FD */
606	/* if it's not FACCEPTONCE, it's already NOFDREF */
607	}
608	so->s = s;
609
610	tp = sototcpcb(so);
611
612	tcp_template(tp);
613
614	/* Compute window scaling to request. */
615	/* while (tp->request_r_scale < TCP_MAX_WINSHIFT
616	* && (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
617	* tp->request_r_scale++;
618	*/
619
620	/* soisconnecting(so); / / NOFDREF used instead */
621	tcpstat.tcps_connattempt++;
622
623	TCP_STATE_SWITCH_TO(tp, TCPS_SYN_SENT);
624	tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
625	tp->iss = tcp_iss;
626	tcp_iss += TCP_ISSINCR/2;
627	tcp_sendseqinit(tp);
628	tcp_output(pData, tp);
629	}
630
631	/*
632	* Attach a TCPCB to a socket.
633	*/
634	int
635	tcp_attach(PNATState pData, struct socket *so)
636	{
637	/* We're attaching already attached socket??? */
638	Assert(so->so_type == 0);
639	if ((so->so_tcpcb = tcp_newtcpcb(pData, so)) == NULL)
640	return -1;
641
642	SOCKET_LOCK_CREATE(so);
643	QSOCKET_LOCK(tcb);
644	insque(pData, so, &tcb);
645	NSOCK_INC();
646	QSOCKET_UNLOCK(tcb);
647	return 0;
648	}

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

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

Download in other formats: