tcp.cpp@ 26430

Last change on this file since 26430 was 26252, checked in by vboxsync, 15 years ago
tcp.cpp: gcc warnings.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 30.7 KB

Line
1	/* $Id: tcp.cpp 26252 2010-02-05 00:26:14Z vboxsync $ */
2	/** @file
3	* IPRT - TCP/IP.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27	* Clara, CA 95054 USA or visit http://www.sun.com if you need
28	* additional information or have any questions.
29	*/
30
31
32	/*******************************************************************************
33	* Header Files *
34	*******************************************************************************/
35	#ifdef RT_OS_WINDOWS
36	# include <winsock.h>
37	# include <limits.h>
38	#else /* !RT_OS_WINDOWS */
39	# include <errno.h>
40	# include <sys/stat.h>
41	# include <sys/socket.h>
42	# include <netinet/in.h>
43	# include <netinet/tcp.h>
44	# include <arpa/inet.h>
45	# include <sys/un.h>
46	# include <netdb.h>
47	# include <unistd.h>
48	#endif /* !RT_OS_WINDOWS */
49
50	#include "internal/iprt.h"
51	#include <iprt/tcp.h>
52
53	#include <iprt/asm.h>
54	#include <iprt/assert.h>
55	#include <iprt/err.h>
56	#include <iprt/mempool.h>
57	#include <iprt/string.h>
58	#include <iprt/thread.h>
59	#include <iprt/time.h>
60
61	#include "internal/magics.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 SockServer;
134	/** The socket to the client currently being serviced.
135	* This is NIL_RTSOCKET when no client is serviced. */
136	RTSOCKET volatile SockClient;
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 rcTcpServerListenCleanup(PRTTCPSERVER pServer);
150	static int rtTcpServerDestroySocket(RTSOCKET volatile pSockClient, const char pszMsg);
151	static int rtTcpClose(RTSOCKET Sock, const char *pszMsg, bool fTryGracefulShutdown);
152
153
154
155	/**
156	* Get the last error as an iprt status code.
157	*
158	* @returns iprt status code.
159	*/
160	DECLINLINE(int) rtTcpError(void)
161	{
162	#ifdef RT_OS_WINDOWS
163	return RTErrConvertFromWin32(WSAGetLastError());
164	#else
165	return RTErrConvertFromErrno(errno);
166	#endif
167	}
168
169
170	/**
171	* Resets the last error.
172	*/
173	DECLINLINE(void) rtTcpErrorReset(void)
174	{
175	#ifdef RT_OS_WINDOWS
176	WSASetLastError(0);
177	#else
178	errno = 0;
179	#endif
180	}
181
182
183	/**
184	* Get the last resolver error as an iprt status code.
185	*
186	* @returns iprt status code.
187	*/
188	DECLINLINE(int) rtTcpResolverError(void)
189	{
190	#ifdef RT_OS_WINDOWS
191	return RTErrConvertFromWin32(WSAGetLastError());
192	#else
193	switch (h_errno)
194	{
195	case HOST_NOT_FOUND:
196	return VERR_NET_HOST_NOT_FOUND;
197	case NO_DATA:
198	return VERR_NET_ADDRESS_NOT_AVAILABLE;
199	case NO_RECOVERY:
200	return VERR_IO_GEN_FAILURE;
201	case TRY_AGAIN:
202	return VERR_TRY_AGAIN;
203
204	default:
205	return VERR_UNRESOLVED_ERROR;
206	}
207	#endif
208	}
209
210
211	/**
212	* Atomicly updates a socket variable.
213	* @returns The old value.
214	* @param pSock The socket variable to update.
215	* @param Sock The new value.
216	*/
217	DECLINLINE(RTSOCKET) rtTcpAtomicXchgSock(RTSOCKET volatile *pSock, const RTSOCKET Sock)
218	{
219	switch (sizeof(RTSOCKET))
220	{
221	case 4: return (RTSOCKET)ASMAtomicXchgS32((int32_t volatile *)pSock, (int32_t)Sock);
222	default:
223	AssertReleaseFailed();
224	return NIL_RTSOCKET;
225	}
226	}
227
228
229	/**
230	* Tries to change the TCP server state.
231	*/
232	DECLINLINE(bool) rtTcpServerTrySetState(PRTTCPSERVER pServer, RTTCPSERVERSTATE enmStateNew, RTTCPSERVERSTATE enmStateOld)
233	{
234	bool fRc;
235	ASMAtomicCmpXchgSize(&pServer->enmState, enmStateNew, enmStateOld, fRc);
236	return fRc;
237	}
238
239	/**
240	* Changes the TCP server state.
241	*/
242	DECLINLINE(void) rtTcpServerSetState(PRTTCPSERVER pServer, RTTCPSERVERSTATE enmStateNew, RTTCPSERVERSTATE enmStateOld)
243	{
244	bool fRc;
245	ASMAtomicCmpXchgSize(&pServer->enmState, enmStateNew, enmStateOld, fRc);
246	Assert(fRc); NOREF(fRc);
247	}
248
249	/**
250	* Closes the a socket (client or server).
251	*
252	* @returns IPRT status code.
253	*/
254	static int rtTcpServerDestroySocket(RTSOCKET volatile pSock, const char pszMsg, bool fTryGracefulShutdown)
255	{
256	RTSOCKET Sock = rtTcpAtomicXchgSock(pSock, NIL_RTSOCKET);
257	if (Sock != NIL_RTSOCKET)
258	{
259	if (!fTryGracefulShutdown)
260	shutdown(Sock, SHUT_RDWR);
261	return rtTcpClose(Sock, pszMsg, fTryGracefulShutdown);
262	}
263	return VINF_TCP_SERVER_NO_CLIENT;
264	}
265
266
267	/**
268	* Create single connection at a time TCP Server in a separate thread.
269	*
270	* The thread will loop accepting connections and call pfnServe for
271	* each of the incoming connections in turn. The pfnServe function can
272	* return VERR_TCP_SERVER_STOP too terminate this loop. RTTcpServerDestroy()
273	* should be used to terminate the server.
274	*
275	* @returns iprt status code.
276	* @param pszAddress The address for creating a listening socket.
277	* If NULL or empty string the server is bound to all interfaces.
278	* @param uPort The port for creating a listening socket.
279	* @param enmType The thread type.
280	* @param pszThrdName The name of the worker thread.
281	* @param pfnServe The function which will serve a new client connection.
282	* @param pvUser User argument passed to pfnServe.
283	* @param ppServer Where to store the serverhandle.
284	*/
285	RTR3DECL(int) RTTcpServerCreate(const char pszAddress, unsigned uPort, RTTHREADTYPE enmType, const char pszThrdName,
286	PFNRTTCPSERVE pfnServe, void *pvUser, PPRTTCPSERVER ppServer)
287	{
288	/*
289	* Validate input.
290	*/
291	AssertReturn(uPort > 0, VERR_INVALID_PARAMETER);
292	AssertPtrReturn(pfnServe, VERR_INVALID_POINTER);
293	AssertPtrReturn(pszThrdName, VERR_INVALID_POINTER);
294	AssertPtrReturn(ppServer, VERR_INVALID_POINTER);
295
296	/*
297	* Create the server.
298	*/
299	PRTTCPSERVER pServer;
300	int rc = RTTcpServerCreateEx(pszAddress, uPort, &pServer);
301	if (RT_SUCCESS(rc))
302	{
303	/*
304	* Create the listener thread.
305	*/
306	RTMemPoolRetain(pServer);
307	pServer->enmState = RTTCPSERVERSTATE_STARTING;
308	pServer->pvUser = pvUser;
309	pServer->pfnServe = pfnServe;
310	rc = RTThreadCreate(&pServer->Thread, rtTcpServerThread, pServer, 0, enmType, /RTTHREADFLAGS_WAITABLE/0, pszThrdName);
311	if (RT_SUCCESS(rc))
312	{
313	/* done */
314	if (ppServer)
315	*ppServer = pServer;
316	else
317	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
318	return rc;
319	}
320	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
321
322	/*
323	* Destroy the server.
324	*/
325	rtTcpServerSetState(pServer, RTTCPSERVERSTATE_CREATED, RTTCPSERVERSTATE_STARTING);
326	RTTcpServerDestroy(pServer);
327	}
328
329	return rc;
330	}
331
332
333	/**
334	* Server thread, loops accepting connections until it's terminated.
335	*
336	* @returns iprt status code. (ignored).
337	* @param ThreadSelf Thread handle.
338	* @param pvServer Server handle.
339	*/
340	static DECLCALLBACK(int) rtTcpServerThread(RTTHREAD ThreadSelf, void *pvServer)
341	{
342	PRTTCPSERVER pServer = (PRTTCPSERVER)pvServer;
343	int rc;
344	if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, RTTCPSERVERSTATE_STARTING))
345	rc = rtTcpServerListen(pServer);
346	else
347	rc = rcTcpServerListenCleanup(pServer);
348	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
349	NOREF(ThreadSelf);
350	return VINF_SUCCESS;
351	}
352
353
354	/**
355	* Create single connection at a time TCP Server.
356	* The caller must call RTTcpServerListen() to actually start the server.
357	*
358	* @returns iprt status code.
359	* @param pszAddress The address for creating a listening socket.
360	* If NULL the server is bound to all interfaces.
361	* @param uPort The port for creating a listening socket.
362	* @param ppServer Where to store the serverhandle.
363	*/
364	RTR3DECL(int) RTTcpServerCreateEx(const char *pszAddress, uint32_t uPort, PPRTTCPSERVER ppServer)
365	{
366	int rc;
367
368	/*
369	* Validate input.
370	*/
371	AssertReturn(uPort > 0, VERR_INVALID_PARAMETER);
372	AssertPtrReturn(ppServer, VERR_INVALID_PARAMETER);
373
374	#ifdef RT_OS_WINDOWS
375	/*
376	* Initialize WinSock and check version.
377	*/
378	WORD wVersionRequested = MAKEWORD(1, 1);
379	WSADATA wsaData;
380	rc = WSAStartup(wVersionRequested, &wsaData);
381	if (wsaData.wVersion != wVersionRequested)
382	{
383	AssertMsgFailed(("Wrong winsock version\n"));
384	return VERR_NOT_SUPPORTED;
385	}
386	#endif
387
388	/*
389	* Get host listening address.
390	*/
391	struct hostent *pHostEnt = NULL;
392	if (pszAddress != NULL && *pszAddress)
393	{
394	pHostEnt = gethostbyname(pszAddress);
395	if (!pHostEnt)
396	{
397	struct in_addr InAddr;
398	InAddr.s_addr = inet_addr(pszAddress);
399	pHostEnt = gethostbyaddr((char *)&InAddr, 4, AF_INET);
400	if (!pHostEnt)
401	{
402	rc = rtTcpResolverError();
403	AssertMsgFailed(("Could not get host address rc=%Rrc\n", rc));
404	return rc;
405	}
406	}
407	}
408
409	/*
410	* Setting up socket.
411	*/
412	RTSOCKET WaitSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
413	if (WaitSock != -1)
414	{
415	/*
416	* Set socket options.
417	*/
418	int fFlag = 1;
419	if (!setsockopt(WaitSock, SOL_SOCKET, SO_REUSEADDR, (const char *)&fFlag, sizeof(fFlag)))
420	{
421	/*
422	* Set socket family, address and port.
423	*/
424	struct sockaddr_in LocalAddr;
425	RT_ZERO(LocalAddr);
426	LocalAddr.sin_family = AF_INET;
427	LocalAddr.sin_port = htons(uPort);
428	/* if address not specified, use INADDR_ANY. */
429	if (!pHostEnt)
430	LocalAddr.sin_addr.s_addr = INADDR_ANY;
431	else
432	LocalAddr.sin_addr = ((struct in_addr )pHostEnt->h_addr);
433
434	/*
435	* Bind a name to a socket.
436	*/
437	if (bind(WaitSock, (struct sockaddr *)&LocalAddr, sizeof(LocalAddr)) != -1)
438	{
439	/*
440	* Listen for connections on a socket.
441	*/
442	if (listen(WaitSock, RTTCP_SERVER_BACKLOG) != -1)
443	{
444	/*
445	* Create the server handle.
446	*/
447	PRTTCPSERVER pServer = (PRTTCPSERVER)RTMemPoolAlloc(RTMEMPOOL_DEFAULT, sizeof(*pServer));
448	if (pServer)
449	{
450	pServer->u32Magic = RTTCPSERVER_MAGIC;
451	pServer->enmState = RTTCPSERVERSTATE_CREATED;
452	pServer->Thread = NIL_RTTHREAD;
453	pServer->SockServer = WaitSock;
454	pServer->SockClient = NIL_RTSOCKET;
455	pServer->pfnServe = NULL;
456	pServer->pvUser = NULL;
457	*ppServer = pServer;
458	return VINF_SUCCESS;
459	}
460
461	/* bail out */
462	rc = VERR_NO_MEMORY;
463	}
464	else
465	{
466	rc = rtTcpError();
467	AssertMsgFailed(("listen() %Rrc\n", rc));
468	}
469	}
470	else
471	{
472	rc = rtTcpError();
473	}
474	}
475	else
476	{
477	rc = rtTcpError();
478	AssertMsgFailed(("setsockopt() %Rrc\n", rc));
479	}
480	rtTcpClose(WaitSock, "RTServerCreateEx", false /fTryGracefulShutdown/);
481	}
482	else
483	{
484	rc = rtTcpError();
485	AssertMsgFailed(("socket() %Rrc\n", rc));
486	}
487
488	return rc;
489	}
490
491
492	/**
493	* Listen for incoming connections.
494	*
495	* The function will loop accepting connections and call pfnServe for
496	* each of the incoming connections in turn. The pfnServe function can
497	* return VERR_TCP_SERVER_STOP too terminate this loop. A stopped server
498	* can only be destroyed.
499	*
500	* @returns IPRT status code.
501	* @retval VERR_TCP_SERVER_STOP if stopped by pfnServe.
502	* @retval VERR_TCP_SERVER_SHUTDOWN if shut down by RTTcpServerShutdown.
503	*
504	* @param pServer The server handle as returned from RTTcpServerCreateEx().
505	* @param pfnServe The function which will serve a new client connection.
506	* @param pvUser User argument passed to pfnServe.
507	*/
508	RTR3DECL(int) RTTcpServerListen(PRTTCPSERVER pServer, PFNRTTCPSERVE pfnServe, void *pvUser)
509	{
510	/*
511	* Validate input and retain the instance.
512	*/
513	AssertPtrReturn(pfnServe, VERR_INVALID_POINTER);
514	AssertPtrReturn(pServer, VERR_INVALID_HANDLE);
515	AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE);
516	AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE);
517
518	int rc = VERR_INVALID_STATE;
519	if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, RTTCPSERVERSTATE_CREATED))
520	{
521	Assert(!pServer->pfnServe);
522	Assert(!pServer->pvUser);
523	Assert(pServer->Thread == NIL_RTTHREAD);
524	Assert(pServer->SockClient == NIL_RTSOCKET);
525
526	pServer->pfnServe = pfnServe;
527	pServer->pvUser = pvUser;
528	pServer->Thread = RTThreadSelf();
529	Assert(pServer->Thread != NIL_RTTHREAD);
530	rc = rtTcpServerListen(pServer);
531	}
532	else
533	{
534	AssertMsgFailed(("enmState=%d\n", pServer->enmState));
535	rc = VERR_INVALID_STATE;
536	}
537	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
538	return rc;
539	}
540
541
542	/**
543	* Internal worker common for RTTcpServerListen and the thread created by
544	* RTTcpServerCreate().
545	*
546	* The caller makes sure it has its own memory reference and releases it upon
547	* return.
548	*/
549	static int rtTcpServerListen(PRTTCPSERVER pServer)
550	{
551	/*
552	* Accept connection loop.
553	*/
554	for (;;)
555	{
556	/*
557	* Change state.
558	*/
559	RTTCPSERVERSTATE enmState = pServer->enmState;
560	RTSOCKET SockServer = pServer->SockServer;
561	if ( enmState != RTTCPSERVERSTATE_ACCEPTING
562	&& enmState != RTTCPSERVERSTATE_SERVING)
563	return rcTcpServerListenCleanup(pServer);
564	if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, enmState))
565	continue;
566
567	/*
568	* Accept connection.
569	*/
570	struct sockaddr_in RemoteAddr;
571	RT_ZERO(RemoteAddr);
572	socklen_t cbRemoteAddr = sizeof(RemoteAddr);
573	RTSOCKET Socket = accept(SockServer, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr);
574	if (Socket == -1)
575	{
576	#ifndef RT_OS_WINDOWS
577	/* These are typical for what can happen during destruction. */
578	if (errno == EBADF \|\| errno == EINVAL \|\| errno == ENOTSOCK)
579	return rcTcpServerListenCleanup(pServer);
580	#endif
581	continue;
582	}
583
584	/*
585	* Run a pfnServe callback.
586	*/
587	if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_SERVING, RTTCPSERVERSTATE_ACCEPTING))
588	{
589	rtTcpClose(Socket, "rtTcpServerListen", true /fTryGracefulShutdown/);
590	return rcTcpServerListenCleanup(pServer);
591	}
592	rtTcpAtomicXchgSock(&pServer->SockClient, Socket);
593	int rc = pServer->pfnServe(Socket, pServer->pvUser);
594	rtTcpServerDestroySocket(&pServer->SockClient, "Listener: client", true /fTryGracefulShutdown/);
595
596	/*
597	* Stop the server?
598	*/
599	if (rc == VERR_TCP_SERVER_STOP)
600	{
601	if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_STOPPING, RTTCPSERVERSTATE_SERVING))
602	{
603	/*
604	* Reset the server socket and change the state to stopped. After that state change
605	* we cannot safely access the handle so we'll have to return here.
606	*/
607	SockServer = rtTcpAtomicXchgSock(&pServer->SockServer, NIL_RTSOCKET);
608	rtTcpServerSetState(pServer, RTTCPSERVERSTATE_STOPPED, RTTCPSERVERSTATE_STOPPING);
609	rtTcpClose(SockServer, "Listener: server stopped", false /fTryGracefulShutdown/);
610	}
611	else
612	rcTcpServerListenCleanup(pServer); /* ignore rc */
613	return rc;
614	}
615	}
616	}
617
618
619	/**
620	* Clean up after listener.
621	*/
622	static int rcTcpServerListenCleanup(PRTTCPSERVER pServer)
623	{
624	/*
625	* Close the server socket, the client one shouldn't be set.
626	*/
627	rtTcpServerDestroySocket(&pServer->SockServer, "ListenCleanup", false /fTryGracefulShutdown/);
628	Assert(pServer->SockClient == NIL_RTSOCKET);
629
630	/*
631	* Figure the return code and make sure the state is OK.
632	*/
633	RTTCPSERVERSTATE enmState = pServer->enmState;
634	switch (enmState)
635	{
636	case RTTCPSERVERSTATE_STOPPING:
637	case RTTCPSERVERSTATE_STOPPED:
638	return VERR_TCP_SERVER_SHUTDOWN;
639
640	case RTTCPSERVERSTATE_ACCEPTING:
641	rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_STOPPED, enmState);
642	return VERR_TCP_SERVER_DESTROYED;
643
644	case RTTCPSERVERSTATE_DESTROYING:
645	return VERR_TCP_SERVER_DESTROYED;
646
647	case RTTCPSERVERSTATE_STARTING:
648	case RTTCPSERVERSTATE_SERVING:
649	default:
650	AssertMsgFailedReturn(("pServer=%p enmState=%d\n", pServer, enmState), VERR_INTERNAL_ERROR_4);
651	}
652	}
653
654
655	/**
656	* Terminate the open connection to the server.
657	*
658	* @returns iprt status code.
659	* @param pServer Handle to the server.
660	*/
661	RTR3DECL(int) RTTcpServerDisconnectClient(PRTTCPSERVER pServer)
662	{
663	/*
664	* Validate input and retain the instance.
665	*/
666	AssertPtrReturn(pServer, VERR_INVALID_HANDLE);
667	AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE);
668	AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE);
669
670	int rc = rtTcpServerDestroySocket(&pServer->SockClient, "DisconnectClient: client", true /fTryGracefulShutdown/);
671
672	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
673	return rc;
674	}
675
676
677	/**
678	* Shuts down the server, leaving client connections open.
679	*
680	* @returns IPRT status code.
681	* @param pServer Handle to the server.
682	*/
683	RTR3DECL(int) RTTcpServerShutdown(PRTTCPSERVER pServer)
684	{
685	/*
686	* Validate input and retain the instance.
687	*/
688	AssertPtrReturn(pServer, VERR_INVALID_HANDLE);
689	AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE);
690	AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE);
691
692	/*
693	* Try change the state to stopping, then replace and destroy the server socket.
694	*/
695	for (;;)
696	{
697	RTTCPSERVERSTATE enmState = pServer->enmState;
698	if ( enmState != RTTCPSERVERSTATE_ACCEPTING
699	&& enmState != RTTCPSERVERSTATE_SERVING)
700	{
701	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
702	switch (enmState)
703	{
704	case RTTCPSERVERSTATE_CREATED:
705	case RTTCPSERVERSTATE_STARTING:
706	default:
707	AssertMsgFailed(("%d\n", enmState));
708	return VERR_INVALID_STATE;
709
710	case RTTCPSERVERSTATE_STOPPING:
711	case RTTCPSERVERSTATE_STOPPED:
712	return VINF_SUCCESS;
713
714	case RTTCPSERVERSTATE_DESTROYING:
715	return VERR_TCP_SERVER_DESTROYED;
716	}
717	}
718	if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_STOPPING, enmState))
719	{
720	rtTcpServerDestroySocket(&pServer->SockServer, "RTTcpServerShutdown", false /fTryGracefulShutdown/);
721	rtTcpServerSetState(pServer, RTTCPSERVERSTATE_STOPPED, RTTCPSERVERSTATE_STOPPING);
722
723	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
724	return VINF_SUCCESS;
725	}
726	}
727	}
728
729
730	/**
731	* Closes down and frees a TCP Server.
732	* This will also terminate any open connections to the server.
733	*
734	* @returns iprt status code.
735	* @param pServer Handle to the server.
736	*/
737	RTR3DECL(int) RTTcpServerDestroy(PRTTCPSERVER pServer)
738	{
739	/*
740	* Validate input and retain the instance.
741	*/
742	AssertPtrReturn(pServer, VERR_INVALID_HANDLE);
743	AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE);
744	AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE); /* paranoia */
745
746	/*
747	* Move the state along so the listener can figure out what's going on.
748	*/
749	for (;;)
750	{
751	bool fDestroyable;
752	RTTCPSERVERSTATE enmState = pServer->enmState;
753	switch (enmState)
754	{
755	case RTTCPSERVERSTATE_STARTING:
756	case RTTCPSERVERSTATE_ACCEPTING:
757	case RTTCPSERVERSTATE_SERVING:
758	case RTTCPSERVERSTATE_CREATED:
759	case RTTCPSERVERSTATE_STOPPED:
760	fDestroyable = rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_DESTROYING, enmState);
761	break;
762
763	/* destroyable states */
764	case RTTCPSERVERSTATE_STOPPING:
765	fDestroyable = true;
766	break;
767
768	/*
769	* Everything else means user or internal misbehavior.
770	*/
771	default:
772	AssertMsgFailed(("pServer=%p enmState=%d\n", pServer, enmState));
773	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
774	return VERR_INTERNAL_ERROR;
775	}
776	if (fDestroyable)
777	break;
778	}
779
780	/*
781	* Destroy it.
782	*/
783	ASMAtomicWriteU32(&pServer->u32Magic, ~RTTCPSERVER_MAGIC);
784	rtTcpServerDestroySocket(&pServer->SockServer, "Destroyer: server", false /fTryGracefulShutdown/);
785	rtTcpServerDestroySocket(&pServer->SockClient, "Destroyer: client", true /fTryGracefulShutdown/);
786
787	/*
788	* Release it.
789	*/
790	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
791	RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
792	return VINF_SUCCESS;
793	}
794
795
796	RTR3DECL(int) RTTcpRead(RTSOCKET Sock, void pvBuffer, size_t cbBuffer, size_t pcbRead)
797	{
798	/*
799	* Validate input.
800	*/
801	AssertReturn(cbBuffer > 0, VERR_INVALID_PARAMETER);
802	AssertPtr(pvBuffer);
803
804	/*
805	* Read loop.
806	* If pcbRead is NULL we have to fill the entire buffer!
807	*/
808	size_t cbRead = 0;
809	size_t cbToRead = cbBuffer;
810	for (;;)
811	{
812	rtTcpErrorReset();
813	#ifdef RT_OS_WINDOWS
814	int cbNow = cbToRead >= INT_MAX/2 ? INT_MAX/2 : (int)cbToRead;
815	#else
816	size_t cbNow = cbToRead;
817	#endif
818	ssize_t cbBytesRead = recv(Sock, (char *)pvBuffer + cbRead, cbNow, MSG_NOSIGNAL);
819	if (cbBytesRead <= 0)
820	{
821	int rc = rtTcpError();
822	Assert(RT_FAILURE_NP(rc) \|\| cbBytesRead == 0);
823	if (RT_FAILURE_NP(rc))
824	return rc;
825	if (pcbRead)
826	{
827	*pcbRead = 0;
828	return VINF_SUCCESS;
829	}
830	return VERR_NET_SHUTDOWN;
831	}
832	if (pcbRead)
833	{
834	/* return partial data */
835	*pcbRead = cbBytesRead;
836	break;
837	}
838
839	/* read more? */
840	cbRead += cbBytesRead;
841	if (cbRead == cbBuffer)
842	break;
843
844	/* next */
845	cbToRead = cbBuffer - cbRead;
846	}
847
848	return VINF_SUCCESS;
849	}
850
851
852	RTR3DECL(int) RTTcpWrite(RTSOCKET Sock, const void *pvBuffer, size_t cbBuffer)
853	{
854
855	do
856	{
857	#ifdef RT_OS_WINDOWS
858	int cbNow = cbBuffer >= INT_MAX/2 ? INT_MAX/2 : (int)cbBuffer;
859	#else
860	size_t cbNow = cbBuffer;
861	#endif
862	ssize_t cbWritten = send(Sock, (const char *)pvBuffer, cbNow, MSG_NOSIGNAL);
863	if (cbWritten < 0)
864	return rtTcpError();
865	AssertMsg(cbBuffer >= (size_t)cbWritten, ("Wrote more than we requested!!! cbWritten=%d cbBuffer=%d rtTcpError()=%d\n",
866	cbWritten, cbBuffer, rtTcpError()));
867	cbBuffer -= cbWritten;
868	pvBuffer = (char *)pvBuffer + cbWritten;
869	} while (cbBuffer);
870
871	return VINF_SUCCESS;
872	}
873
874
875	RTR3DECL(int) RTTcpFlush(RTSOCKET Sock)
876	{
877	int fFlag = 1;
878	setsockopt(Sock, IPPROTO_TCP, TCP_NODELAY, (const char *)&fFlag, sizeof(fFlag));
879	fFlag = 0;
880	setsockopt(Sock, IPPROTO_TCP, TCP_NODELAY, (const char *)&fFlag, sizeof(fFlag));
881
882	return VINF_SUCCESS;
883	}
884
885
886	RTR3DECL(int) RTTcpSelectOne(RTSOCKET Sock, RTMSINTERVAL cMillies)
887	{
888	fd_set fdsetR;
889	FD_ZERO(&fdsetR);
890	FD_SET(Sock, &fdsetR);
891
892	fd_set fdsetE = fdsetR;
893
894	int rc;
895	if (cMillies == RT_INDEFINITE_WAIT)
896	rc = select(Sock + 1, &fdsetR, NULL, &fdsetE, NULL);
897	else
898	{
899	struct timeval timeout;
900	timeout.tv_sec = cMillies / 1000;
901	timeout.tv_usec = (cMillies % 1000) * 1000;
902	rc = select(Sock + 1, &fdsetR, NULL, &fdsetE, &timeout);
903	}
904	if (rc > 0)
905	return VINF_SUCCESS;
906	if (rc == 0)
907	return VERR_TIMEOUT;
908	return rtTcpError();
909	}
910
911
912	RTR3DECL(int) RTTcpClientConnect(const char *pszAddress, uint32_t uPort, PRTSOCKET pSock)
913	{
914	int rc;
915
916	/*
917	* Validate input.
918	*/
919	AssertReturn(uPort > 0, VERR_INVALID_PARAMETER);
920	AssertPtrReturn(pszAddress, VERR_INVALID_POINTER);
921
922	#ifdef RT_OS_WINDOWS
923	/*
924	* Initialize WinSock and check version.
925	*/
926	WORD wVersionRequested = MAKEWORD(1, 1);
927	WSADATA wsaData;
928	rc = WSAStartup(wVersionRequested, &wsaData);
929	if (wsaData.wVersion != wVersionRequested)
930	{
931	AssertMsgFailed(("Wrong winsock version\n"));
932	return VERR_NOT_SUPPORTED;
933	}
934	#endif
935
936	/*
937	* Resolve the address.
938	*/
939	struct hostent *pHostEnt = NULL;
940	pHostEnt = gethostbyname(pszAddress);
941	if (!pHostEnt)
942	{
943	struct in_addr InAddr;
944	InAddr.s_addr = inet_addr(pszAddress);
945	pHostEnt = gethostbyaddr((char *)&InAddr, 4, AF_INET);
946	if (!pHostEnt)
947	{
948	rc = rtTcpError();
949	AssertMsgFailed(("Could not resolve '%s', rc=%Rrc\n", pszAddress, rc));
950	return rc;
951	}
952	}
953
954	/*
955	* Create the socket and connect.
956	*/
957	RTSOCKET Sock = socket(PF_INET, SOCK_STREAM, 0);
958	if (Sock != -1)
959	{
960	struct sockaddr_in InAddr;
961	RT_ZERO(InAddr);
962	InAddr.sin_family = AF_INET;
963	InAddr.sin_port = htons(uPort);
964	InAddr.sin_addr = ((struct in_addr )pHostEnt->h_addr);
965	if (!connect(Sock, (struct sockaddr *)&InAddr, sizeof(InAddr)))
966	{
967	*pSock = Sock;
968	return VINF_SUCCESS;
969	}
970	rc = rtTcpError();
971	rtTcpClose(Sock, "RTTcpClientConnect", false /fTryGracefulShutdown/);
972	}
973	else
974	rc = rtTcpError();
975	return rc;
976	}
977
978
979	RTR3DECL(int) RTTcpClientClose(RTSOCKET Sock)
980	{
981	return rtTcpClose(Sock, "RTTcpClientClose", true /fTryGracefulShutdown/);
982	}
983
984
985	/**
986	* Internal close function which does all the proper bitching.
987	*/
988	static int rtTcpClose(RTSOCKET Sock, const char *pszMsg, bool fTryGracefulShutdown)
989	{
990	int rc;
991
992	/* ignore nil handles. */
993	if (Sock == NIL_RTSOCKET)
994	return VINF_SUCCESS;
995
996	/*
997	* Try to gracefully shut it down.
998	*/
999	if (fTryGracefulShutdown)
1000	{
1001	rc = shutdown(Sock, SHUT_WR);
1002	if (!rc)
1003	{
1004	uint64_t u64Start = RTTimeMilliTS();
1005	for (;;)
1006	{
1007	rc = RTTcpSelectOne(Sock, 1000);
1008	if (rc == VERR_TIMEOUT)
1009	{
1010	if (RTTimeMilliTS() - u64Start > 30000)
1011	break;
1012	}
1013	else if (rc != VINF_SUCCESS)
1014	break;
1015	{
1016	char abBitBucket[16*_1K];
1017	ssize_t cbBytesRead = recv(Sock, &abBitBucket[0], sizeof(abBitBucket), MSG_NOSIGNAL);
1018	if (cbBytesRead == 0)
1019	break; /* orderly shutdown in progress */
1020	if (cbBytesRead < 0)
1021	break; /* some kind of error, never mind which... */
1022	}
1023	} /* forever */
1024	}
1025	}
1026
1027	/*
1028	* Attempt to close it.
1029	*/
1030	#ifdef RT_OS_WINDOWS
1031	rc = closesocket(Sock);
1032	#else
1033	rc = close(Sock);
1034	#endif
1035	if (!rc)
1036	return VINF_SUCCESS;
1037	rc = rtTcpError();
1038	AssertMsgFailed(("\"%s\": close(%d) -> %Rrc\n", pszMsg, Sock, rc));
1039	return rc;
1040	}
1041

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

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

Download in other formats: