tcp.cpp@ 26774

Last change on this file since 26774 was 26683, checked in by vboxsync, 15 years ago
iprt: RTEXITCODE, RTTcpServerListen2, RTTcpWrite fixes.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 36.3 KB

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

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

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

Download in other formats: