tcp.cpp@ 52105

Last change on this file since 52105 was 48935, checked in by vboxsync, 11 years ago
Runtime: Whitespace and svn:keyword cleanups by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 35.0 KB

Line
1	/* $Id: tcp.cpp 48935 2013-10-07 21:19:37Z vboxsync $ */
2	/** @file
3	* IPRT - TCP/IP.
4	*/
5
6	/*
7	* Copyright (C) 2006-2012 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	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*******************************************************************************
29	* Header Files *
30	*******************************************************************************/
31	#ifdef RT_OS_WINDOWS
32	# include <winsock2.h>
33	#else
34	# include <sys/types.h>
35	# include <sys/socket.h>
36	# include <errno.h>
37	# include <netinet/in.h>
38	# include <netinet/tcp.h>
39	# include <arpa/inet.h>
40	# include <netdb.h>
41	# ifdef FIX_FOR_3_2
42	# include <fcntl.h>
43	# endif
44	#endif
45	#include <limits.h>
46
47	#include "internal/iprt.h"
48	#include <iprt/tcp.h>
49
50	#include <iprt/asm.h>
51	#include <iprt/assert.h>
52	#include <iprt/err.h>
53	#include <iprt/log.h>
54	#include <iprt/mempool.h>
55	#include <iprt/mem.h>
56	#include <iprt/string.h>
57	#include <iprt/socket.h>
58	#include <iprt/thread.h>
59	#include <iprt/time.h>
60
61	#include "internal/magics.h"
62	#include "internal/socket.h"
63
64
65	/*******************************************************************************
66	* Defined Constants And Macros *
67	*******************************************************************************/
68	/* non-standard linux stuff (it seems). */
69	#ifndef MSG_NOSIGNAL
70	# define MSG_NOSIGNAL 0
71	#endif
72	#ifndef SHUT_RDWR
73	# ifdef SD_BOTH
74	# define SHUT_RDWR SD_BOTH
75	# else
76	# define SHUT_RDWR 2
77	# endif
78	#endif
79	#ifndef SHUT_WR
80	# ifdef SD_SEND
81	# define SHUT_WR SD_SEND
82	# else
83	# define SHUT_WR 1
84	# endif
85	#endif
86
87	/* fixup backlevel OSes. */
88	#if defined(RT_OS_OS2) \|\| defined(RT_OS_WINDOWS)
89	# define socklen_t int
90	#endif
91
92	/** How many pending connection. */
93	#define RTTCP_SERVER_BACKLOG 10
94
95
96	/*******************************************************************************
97	* Structures and Typedefs *
98	*******************************************************************************/
99	/**
100	* TCP Server state.
101	*/
102	typedef enum RTTCPSERVERSTATE
103	{
104	/** Invalid. */
105	RTTCPSERVERSTATE_INVALID = 0,
106	/** Created. */
107	RTTCPSERVERSTATE_CREATED,
108	/** Listener thread is starting up. */
109	RTTCPSERVERSTATE_STARTING,
110	/** Accepting client connections. */
111	RTTCPSERVERSTATE_ACCEPTING,
112	/** Serving a client. */
113	RTTCPSERVERSTATE_SERVING,
114	/** Listener terminating. */
115	RTTCPSERVERSTATE_STOPPING,
116	/** Listener terminated. */
117	RTTCPSERVERSTATE_STOPPED,
118	/** Listener cleans up. */
119	RTTCPSERVERSTATE_DESTROYING
120	} RTTCPSERVERSTATE;
121
122	/*
123	* Internal representation of the TCP Server handle.
124	*/
125	typedef struct RTTCPSERVER
126	{
127	/** The magic value (RTTCPSERVER_MAGIC). */
128	uint32_t volatile u32Magic;
129	/** The server state. */
130	RTTCPSERVERSTATE volatile enmState;
131	/** The server thread. */
132	RTTHREAD Thread;
133	/** The server socket. */
134	RTSOCKET volatile hServerSocket;
135	/** The socket to the client currently being serviced.
136	* This is NIL_RTSOCKET when no client is serviced. */
137	RTSOCKET volatile hClientSocket;
138	/** The connection function. */
139	PFNRTTCPSERVE pfnServe;
140	/** Argument to pfnServer. */
141	void *pvUser;
142	} RTTCPSERVER;
143
144
145	/*******************************************************************************
146	* Internal Functions *
147	*******************************************************************************/
148	static DECLCALLBACK(int) rtTcpServerThread(RTTHREAD ThreadSelf, void *pvServer);
149	static int rtTcpServerListen(PRTTCPSERVER pServer);
150	static int rtTcpServerListenCleanup(PRTTCPSERVER pServer);
151	static int rtTcpClose(RTSOCKET Sock, const char *pszMsg, bool fTryGracefulShutdown);
152
153
154	/**
155	* Atomicly updates a socket variable.
156	* @returns The old handle value.
157	* @param phSock The socket handle variable to update.
158	* @param hSock The new socket handle value.
159	*/
160	DECLINLINE(RTSOCKET) rtTcpAtomicXchgSock(RTSOCKET volatile *phSock, const RTSOCKET hNew)
161	{
162	RTSOCKET hRet;
163	ASMAtomicXchgHandle(phSock, hNew, &hRet);
164	return hRet;
165	}
166
167
168	/**
169	* Tries to change the TCP server state.
170	*/
171	DECLINLINE(bool) rtTcpServerTrySetState(PRTTCPSERVER pServer, RTTCPSERVERSTATE enmStateNew, RTTCPSERVERSTATE enmStateOld)
172	{
173	bool fRc;
174	ASMAtomicCmpXchgSize(&pServer->enmState, enmStateNew, enmStateOld, fRc);
175	return fRc;
176	}
177
178	/**
179	* Changes the TCP server state.
180	*/
181	DECLINLINE(void) rtTcpServerSetState(PRTTCPSERVER pServer, RTTCPSERVERSTATE enmStateNew, RTTCPSERVERSTATE enmStateOld)
182	{
183	bool fRc;
184	ASMAtomicCmpXchgSize(&pServer->enmState, enmStateNew, enmStateOld, fRc);
185	Assert(fRc); NOREF(fRc);
186	}
187
188
189	/**
190	* Closes the a socket (client or server).
191	*
192	* @returns IPRT status code.
193	*/
194	static int rtTcpServerDestroySocket(RTSOCKET volatile pSock, const char pszMsg, bool fTryGracefulShutdown)
195	{
196	RTSOCKET hSocket = rtTcpAtomicXchgSock(pSock, NIL_RTSOCKET);
197	if (hSocket != NIL_RTSOCKET)
198	{
199	if (!fTryGracefulShutdown)
200	RTSocketShutdown(hSocket, true /fRead/, true /fWrite/);
201	return rtTcpClose(hSocket, pszMsg, fTryGracefulShutdown);
202	}
203	return VINF_TCP_SERVER_NO_CLIENT;
204	}
205
206
207	/**
208	* Create single connection at a time TCP Server in a separate thread.
209	*
210	* The thread will loop accepting connections and call pfnServe for
211	* each of the incoming connections in turn. The pfnServe function can
212	* return VERR_TCP_SERVER_STOP too terminate this loop. RTTcpServerDestroy()
213	* should be used to terminate the server.
214	*
215	* @returns iprt status code.
216	* @param pszAddress The address for creating a listening socket.
217	* If NULL or empty string the server is bound to all interfaces.
218	* @param uPort The port for creating a listening socket.
219	* @param enmType The thread type.
220	* @param pszThrdName The name of the worker thread.
221	* @param pfnServe The function which will serve a new client connection.
222	* @param pvUser User argument passed to pfnServe.
223	* @param ppServer Where to store the serverhandle.
224	*/
225	RTR3DECL(int) RTTcpServerCreate(const char pszAddress, unsigned uPort, RTTHREADTYPE enmType, const char pszThrdName,
226	PFNRTTCPSERVE pfnServe, void *pvUser, PPRTTCPSERVER ppServer)
227	{
228	/*
229	* Validate input.
230	*/
231	AssertReturn(uPort > 0, VERR_INVALID_PARAMETER);
232	AssertPtrReturn(pfnServe, VERR_INVALID_POINTER);
233	AssertPtrReturn(pszThrdName, VERR_INVALID_POINTER);
234	AssertPtrReturn(ppServer, VERR_INVALID_POINTER);
235
236	/*
237	* Create the server.
238	*/
239	PRTTCPSERVER pServer;
240	int rc = RTTcpServerCreateEx(pszAddress, uPort, &pServer);
241	if (RT_SUCCESS(rc))
242	{
243	/*
244	* Create the listener thread.
245	*/
246	RTMemPoolRetain(pServer);
247	pServer->enmState = RTTCPSERVERSTATE_STARTING;
248	pServer->pvUser = pvUser;
249	pServer->pfnServe = pfnServe;
250	rc = RTThreadCreate(&pServer->Thread, rtTcpServerThread, pServer, 0, enmType, /RTTHREADFLAGS_WAITABLE/0, pszThrdName);
251	if (RT_SUCCESS(rc))
252	{
253	/* done */
254	if (ppServer)
255	*ppServer = pServer;
256	else
257	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
258	return rc;
259	}
260	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
261
262	/*
263	* Destroy the server.
264	*/
265	rtTcpServerSetState(pServer, RTTCPSERVERSTATE_CREATED, RTTCPSERVERSTATE_STARTING);
266	RTTcpServerDestroy(pServer);
267	}
268
269	return rc;
270	}
271
272
273	/**
274	* Server thread, loops accepting connections until it's terminated.
275	*
276	* @returns iprt status code. (ignored).
277	* @param ThreadSelf Thread handle.
278	* @param pvServer Server handle.
279	*/
280	static DECLCALLBACK(int) rtTcpServerThread(RTTHREAD ThreadSelf, void *pvServer)
281	{
282	PRTTCPSERVER pServer = (PRTTCPSERVER)pvServer;
283	int rc;
284	if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, RTTCPSERVERSTATE_STARTING))
285	rc = rtTcpServerListen(pServer);
286	else
287	rc = rtTcpServerListenCleanup(pServer);
288	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
289	NOREF(ThreadSelf);
290	return VINF_SUCCESS;
291	}
292
293
294	/**
295	* Create single connection at a time TCP Server.
296	* The caller must call RTTcpServerListen() to actually start the server.
297	*
298	* @returns iprt status code.
299	* @param pszAddress The address for creating a listening socket.
300	* If NULL the server is bound to all interfaces.
301	* @param uPort The port for creating a listening socket.
302	* @param ppServer Where to store the serverhandle.
303	*/
304	RTR3DECL(int) RTTcpServerCreateEx(const char *pszAddress, uint32_t uPort, PPRTTCPSERVER ppServer)
305	{
306	/*
307	* Validate input.
308	*/
309	AssertReturn(uPort > 0, VERR_INVALID_PARAMETER);
310	AssertPtrReturn(ppServer, VERR_INVALID_PARAMETER);
311
312	/*
313	* Resolve the address.
314	*/
315	RTNETADDR LocalAddr;
316	int rc = RTSocketParseInetAddress(pszAddress, uPort, &LocalAddr);
317	if (RT_FAILURE(rc))
318	return rc;
319
320	/*
321	* Setting up socket.
322	*/
323	RTSOCKET WaitSock;
324	rc = rtSocketCreate(&WaitSock, AF_INET, SOCK_STREAM, IPPROTO_TCP);
325	if (RT_SUCCESS(rc))
326	{
327	RTSocketSetInheritance(WaitSock, false /fInheritable/);
328
329	/*
330	* Set socket options.
331	*/
332	int fFlag = 1;
333	if (!rtSocketSetOpt(WaitSock, SOL_SOCKET, SO_REUSEADDR, &fFlag, sizeof(fFlag)))
334	{
335
336	/*
337	* Bind a name to a socket and set it listening for connections.
338	*/
339	rc = rtSocketBind(WaitSock, &LocalAddr);
340	if (RT_SUCCESS(rc))
341	rc = rtSocketListen(WaitSock, RTTCP_SERVER_BACKLOG);
342	if (RT_SUCCESS(rc))
343	{
344	/*
345	* Create the server handle.
346	*/
347	PRTTCPSERVER pServer = (PRTTCPSERVER)RTMemPoolAlloc(RTMEMPOOL_DEFAULT, sizeof(*pServer));
348	if (pServer)
349	{
350	pServer->u32Magic = RTTCPSERVER_MAGIC;
351	pServer->enmState = RTTCPSERVERSTATE_CREATED;
352	pServer->Thread = NIL_RTTHREAD;
353	pServer->hServerSocket = WaitSock;
354	pServer->hClientSocket = NIL_RTSOCKET;
355	pServer->pfnServe = NULL;
356	pServer->pvUser = NULL;
357	*ppServer = pServer;
358	return VINF_SUCCESS;
359	}
360
361	/* bail out */
362	rc = VERR_NO_MEMORY;
363	}
364	}
365	else
366	AssertMsgFailed(("rtSocketSetOpt: %Rrc\n", rc));
367	rtTcpClose(WaitSock, "RTServerCreateEx", false /fTryGracefulShutdown/);
368	}
369
370	return rc;
371	}
372
373
374	/**
375	* Listen for incoming connections.
376	*
377	* The function will loop accepting connections and call pfnServe for
378	* each of the incoming connections in turn. The pfnServe function can
379	* return VERR_TCP_SERVER_STOP too terminate this loop. A stopped server
380	* can only be destroyed.
381	*
382	* @returns IPRT status code.
383	* @retval VERR_TCP_SERVER_STOP if stopped by pfnServe.
384	* @retval VERR_TCP_SERVER_SHUTDOWN if shut down by RTTcpServerShutdown.
385	*
386	* @param pServer The server handle as returned from RTTcpServerCreateEx().
387	* @param pfnServe The function which will serve a new client connection.
388	* @param pvUser User argument passed to pfnServe.
389	*/
390	RTR3DECL(int) RTTcpServerListen(PRTTCPSERVER pServer, PFNRTTCPSERVE pfnServe, void *pvUser)
391	{
392	/*
393	* Validate input and retain the instance.
394	*/
395	AssertPtrReturn(pfnServe, VERR_INVALID_POINTER);
396	AssertPtrReturn(pServer, VERR_INVALID_HANDLE);
397	AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE);
398	AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE);
399
400	int rc = VERR_INVALID_STATE;
401	if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, RTTCPSERVERSTATE_CREATED))
402	{
403	Assert(!pServer->pfnServe);
404	Assert(!pServer->pvUser);
405	Assert(pServer->Thread == NIL_RTTHREAD);
406	Assert(pServer->hClientSocket == NIL_RTSOCKET);
407
408	pServer->pfnServe = pfnServe;
409	pServer->pvUser = pvUser;
410	pServer->Thread = RTThreadSelf();
411	Assert(pServer->Thread != NIL_RTTHREAD);
412	rc = rtTcpServerListen(pServer);
413	}
414	else
415	{
416	AssertMsgFailed(("enmState=%d\n", pServer->enmState));
417	rc = VERR_INVALID_STATE;
418	}
419	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
420	return rc;
421	}
422
423
424	/**
425	* Internal worker common for RTTcpServerListen and the thread created by
426	* RTTcpServerCreate().
427	*
428	* The caller makes sure it has its own memory reference and releases it upon
429	* return.
430	*/
431	static int rtTcpServerListen(PRTTCPSERVER pServer)
432	{
433	/*
434	* Accept connection loop.
435	*/
436	for (;;)
437	{
438	/*
439	* Change state, getting an extra reference to the socket so we can
440	* allow others to close it while we're stuck in rtSocketAccept.
441	*/
442	RTTCPSERVERSTATE enmState = pServer->enmState;
443	RTSOCKET hServerSocket;
444	ASMAtomicXchgHandle(&pServer->hServerSocket, NIL_RTSOCKET, &hServerSocket);
445	if (hServerSocket != NIL_RTSOCKET)
446	{
447	RTSocketRetain(hServerSocket);
448	ASMAtomicWriteHandle(&pServer->hServerSocket, hServerSocket);
449	}
450	if ( enmState != RTTCPSERVERSTATE_ACCEPTING
451	&& enmState != RTTCPSERVERSTATE_SERVING)
452	{
453	RTSocketRelease(hServerSocket);
454	return rtTcpServerListenCleanup(pServer);
455	}
456	if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, enmState))
457	{
458	RTSocketRelease(hServerSocket);
459	continue;
460	}
461
462	/*
463	* Accept connection.
464	*/
465	struct sockaddr_in RemoteAddr;
466	size_t cbRemoteAddr = sizeof(RemoteAddr);
467	RTSOCKET hClientSocket;
468	RT_ZERO(RemoteAddr);
469	int rc = rtSocketAccept(hServerSocket, &hClientSocket, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr);
470	RTSocketRelease(hServerSocket);
471	if (RT_FAILURE(rc))
472	{
473	/* These are typical for what can happen during destruction. */
474	if ( rc == VERR_INVALID_HANDLE
475	\|\| rc == VERR_INVALID_PARAMETER
476	\|\| rc == VERR_NET_NOT_SOCKET)
477	return rtTcpServerListenCleanup(pServer);
478	continue;
479	}
480	RTSocketSetInheritance(hClientSocket, false /fInheritable/);
481
482	/*
483	* Run a pfnServe callback.
484	*/
485	if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_SERVING, RTTCPSERVERSTATE_ACCEPTING))
486	{
487	rtTcpClose(hClientSocket, "rtTcpServerListen", true /fTryGracefulShutdown/);
488	return rtTcpServerListenCleanup(pServer);
489	}
490	RTSocketRetain(hClientSocket);
491	rtTcpAtomicXchgSock(&pServer->hClientSocket, hClientSocket);
492	rc = pServer->pfnServe(hClientSocket, pServer->pvUser);
493	rtTcpServerDestroySocket(&pServer->hClientSocket, "Listener: client (secondary)", true /fTryGracefulShutdown/);
494	RTSocketRelease(hClientSocket);
495
496	/*
497	* Stop the server?
498	*/
499	if (rc == VERR_TCP_SERVER_STOP)
500	{
501	if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_STOPPING, RTTCPSERVERSTATE_SERVING))
502	{
503	/*
504	* Reset the server socket and change the state to stopped. After that state change
505	* we cannot safely access the handle so we'll have to return here.
506	*/
507	hServerSocket = rtTcpAtomicXchgSock(&pServer->hServerSocket, NIL_RTSOCKET);
508	rtTcpServerSetState(pServer, RTTCPSERVERSTATE_STOPPED, RTTCPSERVERSTATE_STOPPING);
509	rtTcpClose(hServerSocket, "Listener: server stopped", false /fTryGracefulShutdown/);
510	}
511	else
512	rtTcpServerListenCleanup(pServer); /* ignore rc */
513	return rc;
514	}
515	}
516	}
517
518
519	/**
520	* Clean up after listener.
521	*/
522	static int rtTcpServerListenCleanup(PRTTCPSERVER pServer)
523	{
524	/*
525	* Close the server socket, the client one shouldn't be set.
526	*/
527	rtTcpServerDestroySocket(&pServer->hServerSocket, "ListenCleanup", false /fTryGracefulShutdown/);
528	Assert(pServer->hClientSocket == NIL_RTSOCKET);
529
530	/*
531	* Figure the return code and make sure the state is OK.
532	*/
533	RTTCPSERVERSTATE enmState = pServer->enmState;
534	switch (enmState)
535	{
536	case RTTCPSERVERSTATE_STOPPING:
537	case RTTCPSERVERSTATE_STOPPED:
538	return VERR_TCP_SERVER_SHUTDOWN;
539
540	case RTTCPSERVERSTATE_ACCEPTING:
541	rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_STOPPED, enmState);
542	return VERR_TCP_SERVER_DESTROYED;
543
544	case RTTCPSERVERSTATE_DESTROYING:
545	return VERR_TCP_SERVER_DESTROYED;
546
547	case RTTCPSERVERSTATE_STARTING:
548	case RTTCPSERVERSTATE_SERVING:
549	default:
550	AssertMsgFailedReturn(("pServer=%p enmState=%d\n", pServer, enmState), VERR_INTERNAL_ERROR_4);
551	}
552	}
553
554
555	/**
556	* Listen and accept one incoming connection.
557	*
558	* This is an alternative to RTTcpServerListen for the use the callbacks are not
559	* possible.
560	*
561	* @returns IPRT status code.
562	* @retval VERR_TCP_SERVER_SHUTDOWN if shut down by RTTcpServerShutdown.
563	* @retval VERR_INTERRUPTED if the listening was interrupted.
564	*
565	* @param pServer The server handle as returned from RTTcpServerCreateEx().
566	* @param phClientSocket Where to return the socket handle to the client
567	* connection (on success only). This must be closed
568	* by calling RTTcpServerDisconnectClient2().
569	*/
570	RTR3DECL(int) RTTcpServerListen2(PRTTCPSERVER pServer, PRTSOCKET phClientSocket)
571	{
572	/*
573	* Validate input and retain the instance.
574	*/
575	AssertPtrReturn(phClientSocket, VERR_INVALID_HANDLE);
576	*phClientSocket = NIL_RTSOCKET;
577	AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE);
578	AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE);
579
580	int rc = VERR_INVALID_STATE;
581	for (;;)
582	{
583	/*
584	* Change state, getting an extra reference to the socket so we can
585	* allow others to close it while we're stuck in rtSocketAccept.
586	*/
587	RTTCPSERVERSTATE enmState = pServer->enmState;
588	RTSOCKET hServerSocket;
589	ASMAtomicXchgHandle(&pServer->hServerSocket, NIL_RTSOCKET, &hServerSocket);
590	if (hServerSocket != NIL_RTSOCKET)
591	{
592	RTSocketRetain(hServerSocket);
593	ASMAtomicWriteHandle(&pServer->hServerSocket, hServerSocket);
594	}
595	if ( enmState != RTTCPSERVERSTATE_SERVING
596	&& enmState != RTTCPSERVERSTATE_CREATED)
597	{
598	RTSocketRelease(hServerSocket);
599	return rtTcpServerListenCleanup(pServer);
600	}
601	if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, enmState))
602	{
603	RTSocketRelease(hServerSocket);
604	continue;
605	}
606	Assert(!pServer->pfnServe);
607	Assert(!pServer->pvUser);
608	Assert(pServer->Thread == NIL_RTTHREAD);
609	Assert(pServer->hClientSocket == NIL_RTSOCKET);
610
611	/*
612	* Accept connection.
613	*/
614	struct sockaddr_in RemoteAddr;
615	size_t cbRemoteAddr = sizeof(RemoteAddr);
616	RTSOCKET hClientSocket;
617	RT_ZERO(RemoteAddr);
618	rc = rtSocketAccept(hServerSocket, &hClientSocket, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr);
619	RTSocketRelease(hServerSocket);
620	if (RT_FAILURE(rc))
621	{
622	if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_CREATED, RTTCPSERVERSTATE_ACCEPTING))
623	rc = rtTcpServerListenCleanup(pServer);
624	if (RT_FAILURE(rc))
625	break;
626	continue;
627	}
628	RTSocketSetInheritance(hClientSocket, false /fInheritable/);
629
630	/*
631	* Chance to the 'serving' state and return the socket.
632	*/
633	if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_SERVING, RTTCPSERVERSTATE_ACCEPTING))
634	{
635	*phClientSocket = hClientSocket;
636	rc = VINF_SUCCESS;
637	}
638	else
639	{
640	rtTcpClose(hClientSocket, "RTTcpServerListen2", true /fTryGracefulShutdown/);
641	rc = rtTcpServerListenCleanup(pServer);
642	}
643	break;
644	}
645
646	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
647	return rc;
648	}
649
650
651	/**
652	* Terminate the open connection to the server.
653	*
654	* @returns iprt status code.
655	* @param pServer Handle to the server.
656	*/
657	RTR3DECL(int) RTTcpServerDisconnectClient(PRTTCPSERVER pServer)
658	{
659	/*
660	* Validate input and retain the instance.
661	*/
662	AssertPtrReturn(pServer, VERR_INVALID_HANDLE);
663	AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE);
664	AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE);
665
666	int rc = rtTcpServerDestroySocket(&pServer->hClientSocket, "DisconnectClient: client", true /fTryGracefulShutdown/);
667
668	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
669	return rc;
670	}
671
672
673	/**
674	* Terminates an open client connect when using RTTcpListen2
675	*
676	* @returns IPRT status code.
677	* @param hClientSocket The client socket handle. This will be invalid upon
678	* return, whether successful or not. NIL is quietly
679	* ignored (VINF_SUCCESS).
680	*/
681	RTR3DECL(int) RTTcpServerDisconnectClient2(RTSOCKET hClientSocket)
682	{
683	return rtTcpClose(hClientSocket, "RTTcpServerDisconnectClient2", true /fTryGracefulShutdown/);
684	}
685
686
687	/**
688	* Shuts down the server, leaving client connections open.
689	*
690	* @returns IPRT status code.
691	* @param pServer Handle to the server.
692	*/
693	RTR3DECL(int) RTTcpServerShutdown(PRTTCPSERVER pServer)
694	{
695	/*
696	* Validate input and retain the instance.
697	*/
698	AssertPtrReturn(pServer, VERR_INVALID_HANDLE);
699	AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE);
700	AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE);
701
702	/*
703	* Try change the state to stopping, then replace and destroy the server socket.
704	*/
705	for (;;)
706	{
707	RTTCPSERVERSTATE enmState = pServer->enmState;
708	if ( enmState != RTTCPSERVERSTATE_ACCEPTING
709	&& enmState != RTTCPSERVERSTATE_SERVING)
710	{
711	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
712	switch (enmState)
713	{
714	case RTTCPSERVERSTATE_CREATED:
715	case RTTCPSERVERSTATE_STARTING:
716	default:
717	AssertMsgFailed(("%d\n", enmState));
718	return VERR_INVALID_STATE;
719
720	case RTTCPSERVERSTATE_STOPPING:
721	case RTTCPSERVERSTATE_STOPPED:
722	return VINF_SUCCESS;
723
724	case RTTCPSERVERSTATE_DESTROYING:
725	return VERR_TCP_SERVER_DESTROYED;
726	}
727	}
728	if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_STOPPING, enmState))
729	{
730	rtTcpServerDestroySocket(&pServer->hServerSocket, "RTTcpServerShutdown", false /fTryGracefulShutdown/);
731	rtTcpServerSetState(pServer, RTTCPSERVERSTATE_STOPPED, RTTCPSERVERSTATE_STOPPING);
732
733	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
734	return VINF_SUCCESS;
735	}
736	}
737	}
738
739
740	/**
741	* Closes down and frees a TCP Server.
742	* This will also terminate any open connections to the server.
743	*
744	* @returns iprt status code.
745	* @param pServer Handle to the server.
746	*/
747	RTR3DECL(int) RTTcpServerDestroy(PRTTCPSERVER pServer)
748	{
749	/*
750	* Validate input and retain the instance.
751	*/
752	AssertPtrReturn(pServer, VERR_INVALID_HANDLE);
753	AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE);
754	AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE); /* paranoia */
755
756	/*
757	* Move the state along so the listener can figure out what's going on.
758	*/
759	for (;;)
760	{
761	bool fDestroyable;
762	RTTCPSERVERSTATE enmState = pServer->enmState;
763	switch (enmState)
764	{
765	case RTTCPSERVERSTATE_STARTING:
766	case RTTCPSERVERSTATE_ACCEPTING:
767	case RTTCPSERVERSTATE_SERVING:
768	case RTTCPSERVERSTATE_CREATED:
769	case RTTCPSERVERSTATE_STOPPED:
770	fDestroyable = rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_DESTROYING, enmState);
771	break;
772
773	/* destroyable states */
774	case RTTCPSERVERSTATE_STOPPING:
775	fDestroyable = true;
776	break;
777
778	/*
779	* Everything else means user or internal misbehavior.
780	*/
781	default:
782	AssertMsgFailed(("pServer=%p enmState=%d\n", pServer, enmState));
783	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
784	return VERR_INTERNAL_ERROR;
785	}
786	if (fDestroyable)
787	break;
788	}
789
790	/*
791	* Destroy it.
792	*/
793	ASMAtomicWriteU32(&pServer->u32Magic, ~RTTCPSERVER_MAGIC);
794	rtTcpServerDestroySocket(&pServer->hServerSocket, "Destroyer: server", false /fTryGracefulShutdown/);
795	rtTcpServerDestroySocket(&pServer->hClientSocket, "Destroyer: client", true /fTryGracefulShutdown/);
796
797	/*
798	* Release it.
799	*/
800	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
801	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
802	return VINF_SUCCESS;
803	}
804
805
806	RTR3DECL(int) RTTcpClientConnect(const char *pszAddress, uint32_t uPort, PRTSOCKET pSock)
807	{
808	return RTTcpClientConnectEx(pszAddress, uPort, pSock, NULL);
809	}
810
811
812	RTR3DECL(int) RTTcpClientConnectEx(const char *pszAddress, uint32_t uPort, PRTSOCKET pSock,
813	PRTTCPCLIENTCONNECTCANCEL volatile *ppCancelCookie)
814	{
815	/*
816	* Validate input.
817	*/
818	AssertReturn(uPort > 0, VERR_INVALID_PARAMETER);
819	AssertPtrReturn(pszAddress, VERR_INVALID_POINTER);
820	AssertPtrNullReturn(ppCancelCookie, VERR_INVALID_POINTER);
821
822	/*
823	* Resolve the address.
824	*/
825	RTNETADDR Addr;
826	int rc = RTSocketParseInetAddress(pszAddress, uPort, &Addr);
827	if (RT_FAILURE(rc))
828	return rc;
829
830	/*
831	* Create the socket and connect.
832	*/
833	RTSOCKET Sock;
834	rc = rtSocketCreate(&Sock, PF_INET, SOCK_STREAM, 0);
835	if (RT_SUCCESS(rc))
836	{
837	RTSocketSetInheritance(Sock, false /fInheritable/);
838
839	if (!ppCancelCookie)
840	rc = rtSocketConnect(Sock, &Addr);
841	else
842	{
843	RTSocketRetain(Sock);
844	if (ASMAtomicCmpXchgPtr(ppCancelCookie, (PRTTCPCLIENTCONNECTCANCEL)Sock, NULL))
845	{
846	rc = rtSocketConnect(Sock, &Addr);
847	if (ASMAtomicCmpXchgPtr(ppCancelCookie, NULL, (PRTTCPCLIENTCONNECTCANCEL)Sock))
848	RTSocketRelease(Sock);
849	else
850	rc = VERR_CANCELLED;
851	}
852	else
853	{
854	RTSocketRelease(Sock);
855	rc = VERR_CANCELLED;
856	}
857	}
858	if (RT_SUCCESS(rc))
859	{
860	*pSock = Sock;
861	return VINF_SUCCESS;
862	}
863
864	rtTcpClose(Sock, "RTTcpClientConnect", false /fTryGracefulShutdown/);
865	}
866	if (ppCancelCookie)
867	*ppCancelCookie = NULL;
868	return rc;
869	}
870
871
872	RTR3DECL(int) RTTcpClientCancelConnect(PRTTCPCLIENTCONNECTCANCEL volatile *ppCancelCookie)
873	{
874	AssertPtrReturn(ppCancelCookie, VERR_INVALID_POINTER);
875
876	AssertCompile(NIL_RTSOCKET == NULL);
877	RTSOCKET hSock = (RTSOCKET)ASMAtomicXchgPtr((void * volatile )ppCancelCookie, (void )(uintptr_t)0xdead9999);
878	if (hSock != NIL_RTSOCKET)
879	{
880	int rc = rtTcpClose(hSock, "RTTcpClientCancelConnect", false /fTryGracefulShutdown/);
881	AssertRCReturn(rc, rc);
882	}
883
884	return VINF_SUCCESS;
885	}
886
887
888	RTR3DECL(int) RTTcpClientClose(RTSOCKET Sock)
889	{
890	return rtTcpClose(Sock, "RTTcpClientClose", true /fTryGracefulShutdown/);
891	}
892
893
894	RTR3DECL(int) RTTcpClientCloseEx(RTSOCKET Sock, bool fGracefulShutdown)
895	{
896	return rtTcpClose(Sock, "RTTcpClientCloseEx", fGracefulShutdown);
897	}
898
899
900	#ifdef FIX_FOR_3_2
901	/**
902	* Changes the blocking mode of the socket.
903	*
904	* @returns 0 on success, -1 on failure.
905	* @param hSocket The socket to work on.
906	* @param fBlocking The desired mode of operation.
907	*/
908	static int rtTcpSetBlockingMode(RTHCUINTPTR hSocket, bool fBlocking)
909	{
910	int rc = VINF_SUCCESS;
911	#ifdef RT_OS_WINDOWS
912	u_long uBlocking = fBlocking ? 0 : 1;
913	if (ioctlsocket(hSocket, FIONBIO, &uBlocking))
914	return -1;
915
916	#else
917	int fFlags = fcntl(hSocket, F_GETFL, 0);
918	if (fFlags == -1)
919	return -1;
920
921	if (fBlocking)
922	fFlags &= ~O_NONBLOCK;
923	else
924	fFlags \|= O_NONBLOCK;
925	if (fcntl(hSocket, F_SETFL, fFlags) == -1)
926	return -1;
927	#endif
928
929	return 0;
930	}
931	#endif
932
933
934	/**
935	* Internal close function which does all the proper bitching.
936	*/
937	static int rtTcpClose(RTSOCKET Sock, const char *pszMsg, bool fTryGracefulShutdown)
938	{
939	NOREF(pszMsg); /** @todo drop this parameter? */
940
941	/* ignore nil handles. */
942	if (Sock == NIL_RTSOCKET)
943	return VINF_SUCCESS;
944
945	/*
946	* Try to gracefully shut it down.
947	*/
948	int rc;
949	if (fTryGracefulShutdown)
950	{
951	rc = RTSocketShutdown(Sock, false /fRead/, true /fWrite/);
952	#ifdef FIX_FOR_3_2
953	RTHCUINTPTR hNative = RTSocketToNative(Sock);
954	if (RT_SUCCESS(rc) && rtTcpSetBlockingMode(hNative, false /fBlocking/) == 0)
955	#else
956	if (RT_SUCCESS(rc))
957	#endif
958	{
959
960	size_t cbReceived = 0;
961	uint64_t u64Start = RTTimeMilliTS();
962	while ( cbReceived < _1G
963	&& RTTimeMilliTS() - u64Start < 30000)
964	{
965	#ifdef FIX_FOR_3_2
966	fd_set FdSetR;
967	FD_ZERO(&FdSetR);
968	FD_SET(hNative, &FdSetR);
969
970	fd_set FdSetE;
971	FD_ZERO(&FdSetE);
972	FD_SET(hNative, &FdSetE);
973
974	struct timeval TvTimeout;
975	TvTimeout.tv_sec = 1;
976	TvTimeout.tv_usec = 0;
977	rc = select(hNative + 1, &FdSetR, NULL, &FdSetE, &TvTimeout);
978	if (rc == 0)
979	continue;
980	if (rc < 0)
981	break;
982	if (FD_ISSET(hNative, &FdSetE))
983	break;
984	#else
985	uint32_t fEvents;
986	rc = RTSocketSelectOneEx(Sock, RTSOCKET_EVT_READ \| RTSOCKET_EVT_ERROR, &fEvents, 1000);
987	if (rc == VERR_TIMEOUT)
988	continue;
989	if (RT_FAILURE(rc))
990	break;
991	if (fEvents & RTSOCKET_EVT_ERROR)
992	break;
993	#endif
994
995	char abBitBucket[16*_1K];
996	#ifdef FIX_FOR_3_2
997	ssize_t cbRead = recv(hNative, &abBitBucket[0], sizeof(abBitBucket), MSG_NOSIGNAL);
998	if (cbRead == 0)
999	break; /* orderly shutdown in progress */
1000	if (cbRead < 0 && errno != EAGAIN)
1001	break; /* some kind of error, never mind which... */
1002	#else
1003	size_t cbRead;
1004	rc = RTSocketReadNB(Sock, &abBitBucket[0], sizeof(abBitBucket), &cbRead);
1005	if (RT_FAILURE(rc))
1006	break; /* some kind of error, never mind which... */
1007	if (rc != VINF_TRY_AGAIN && !cbRead)
1008	break; /* orderly shutdown in progress */
1009	#endif
1010
1011	cbReceived += cbRead;
1012	}
1013	}
1014	}
1015
1016	/*
1017	* Close the socket handle (drops our reference to it).
1018	*/
1019	return RTSocketClose(Sock);
1020	}
1021
1022
1023	RTR3DECL(int) RTTcpRead(RTSOCKET Sock, void pvBuffer, size_t cbBuffer, size_t pcbRead)
1024	{
1025	return RTSocketRead(Sock, pvBuffer, cbBuffer, pcbRead);
1026	}
1027
1028
1029	RTR3DECL(int) RTTcpWrite(RTSOCKET Sock, const void *pvBuffer, size_t cbBuffer)
1030	{
1031	return RTSocketWrite(Sock, pvBuffer, cbBuffer);
1032	}
1033
1034
1035	RTR3DECL(int) RTTcpFlush(RTSOCKET Sock)
1036	{
1037	int fFlag = 1;
1038	int rc = rtSocketSetOpt(Sock, IPPROTO_TCP, TCP_NODELAY, &fFlag, sizeof(fFlag));
1039	if (RT_SUCCESS(rc))
1040	{
1041	fFlag = 0;
1042	rc = rtSocketSetOpt(Sock, IPPROTO_TCP, TCP_NODELAY, &fFlag, sizeof(fFlag));
1043	}
1044	return rc;
1045	}
1046
1047
1048	RTR3DECL(int) RTTcpSetSendCoalescing(RTSOCKET Sock, bool fEnable)
1049	{
1050	int fFlag = fEnable ? 0 : 1;
1051	return rtSocketSetOpt(Sock, IPPROTO_TCP, TCP_NODELAY, &fFlag, sizeof(fFlag));
1052	}
1053
1054
1055	RTR3DECL(int) RTTcpSelectOne(RTSOCKET Sock, RTMSINTERVAL cMillies)
1056	{
1057	return RTSocketSelectOne(Sock, cMillies);
1058	}
1059
1060
1061	RTR3DECL(int) RTTcpSelectOneEx(RTSOCKET Sock, uint32_t fEvents, uint32_t *pfEvents,
1062	RTMSINTERVAL cMillies)
1063	{
1064	return RTSocketSelectOneEx(Sock, fEvents, pfEvents, cMillies);
1065	}
1066
1067
1068	RTR3DECL(int) RTTcpGetLocalAddress(RTSOCKET Sock, PRTNETADDR pAddr)
1069	{
1070	return RTSocketGetLocalAddress(Sock, pAddr);
1071	}
1072
1073
1074	RTR3DECL(int) RTTcpGetPeerAddress(RTSOCKET Sock, PRTNETADDR pAddr)
1075	{
1076	return RTSocketGetPeerAddress(Sock, pAddr);
1077	}
1078
1079
1080	RTR3DECL(int) RTTcpSgWrite(RTSOCKET Sock, PCRTSGBUF pSgBuf)
1081	{
1082	return RTSocketSgWrite(Sock, pSgBuf);
1083	}
1084
1085
1086	RTR3DECL(int) RTTcpSgWriteL(RTSOCKET hSocket, size_t cSegs, ...)
1087	{
1088	va_list va;
1089	va_start(va, cSegs);
1090	int rc = RTSocketSgWriteLV(hSocket, cSegs, va);
1091	va_end(va);
1092	return rc;
1093	}
1094
1095
1096	RTR3DECL(int) RTTcpSgWriteLV(RTSOCKET hSocket, size_t cSegs, va_list va)
1097	{
1098	return RTSocketSgWriteLV(hSocket, cSegs, va);
1099	}
1100
1101
1102	RTR3DECL(int) RTTcpReadNB(RTSOCKET Sock, void pvBuffer, size_t cbBuffer, size_t pcbRead)
1103	{
1104	return RTSocketReadNB(Sock, pvBuffer, cbBuffer, pcbRead);
1105	}
1106
1107
1108	RTR3DECL(int) RTTcpWriteNB(RTSOCKET Sock, const void pvBuffer, size_t cbBuffer, size_t pcbWritten)
1109	{
1110	return RTSocketWriteNB(Sock, pvBuffer, cbBuffer, pcbWritten);
1111	}
1112
1113
1114	RTR3DECL(int) RTTcpSgWriteNB(RTSOCKET Sock, PCRTSGBUF pSgBuf, size_t *pcbWritten)
1115	{
1116	return RTSocketSgWriteNB(Sock, pSgBuf, pcbWritten);
1117	}
1118
1119
1120	RTR3DECL(int) RTTcpSgWriteLNB(RTSOCKET hSocket, size_t cSegs, size_t *pcbWritten, ...)
1121	{
1122	va_list va;
1123	va_start(va, pcbWritten);
1124	int rc = RTSocketSgWriteLVNB(hSocket, cSegs, pcbWritten, va);
1125	va_end(va);
1126	return rc;
1127	}
1128
1129
1130	RTR3DECL(int) RTTcpSgWriteLVNB(RTSOCKET hSocket, size_t cSegs, size_t *pcbWritten, va_list va)
1131	{
1132	return RTSocketSgWriteLVNB(hSocket, cSegs, pcbWritten, va);
1133	}
1134

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

source: vbox/trunk/src/VBox/Runtime/r3/tcp.cpp@ 52105

Download in other formats: