tcp.cpp@ 39070

Last change on this file since 39070 was 39070, checked in by vboxsync, 13 years ago
VMM,IPRT: -Wunused-function.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 35.6 KB

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

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

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

Download in other formats: