AudioTestServiceTcp.cpp@ 96407

Last change on this file since 96407 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 31.7 KB

Line
1	/* $Id: AudioTestServiceTcp.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2	/** @file
3	* AudioTestServiceTcp - Audio test execution server, TCP/IP Transport Layer.
4	*/
5
6	/*
7	* Copyright (C) 2021-2022 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_AUDIO_TEST
33	#include <iprt/log.h>
34
35	#include <iprt/asm.h>
36	#include <iprt/assert.h>
37	#include <iprt/critsect.h>
38	#include <iprt/err.h>
39	#include <iprt/mem.h>
40	#include <iprt/message.h>
41	#include <iprt/poll.h>
42	#include <iprt/string.h>
43	#include <iprt/tcp.h>
44	#include <iprt/thread.h>
45	#include <iprt/time.h>
46
47	#include <VBox/log.h>
48
49	#include "AudioTestService.h"
50	#include "AudioTestServiceInternal.h"
51
52
53	/*********************************************************************************************************************************
54	* Defined Constants And Macros *
55	*********************************************************************************************************************************/
56
57
58	/*********************************************************************************************************************************
59	* Structures and Typedefs *
60	*********************************************************************************************************************************/
61	/**
62	* TCP specific client data.
63	*/
64	typedef struct ATSTRANSPORTCLIENT
65	{
66	/** Socket of the current client. */
67	RTSOCKET hTcpClient;
68	/** Indicates whether \a hTcpClient comes from the server or from a client
69	* connect (relevant when closing it). */
70	bool fFromServer;
71	/** The size of the stashed data. */
72	size_t cbTcpStashed;
73	/** The size of the stashed data allocation. */
74	size_t cbTcpStashedAlloced;
75	/** The stashed data. */
76	uint8_t *pbTcpStashed;
77	} ATSTRANSPORTCLIENT;
78
79	/**
80	* Structure for keeping Audio Test Service (ATS) transport instance-specific data.
81	*/
82	typedef struct ATSTRANSPORTINST
83	{
84	/** Critical section for serializing access. */
85	RTCRITSECT CritSect;
86	/** Connection mode to use. */
87	ATSCONNMODE enmConnMode;
88	/** The addresses to bind to. Empty string means any. */
89	char szBindAddr[256];
90	/** The TCP port to listen to. */
91	uint32_t uBindPort;
92	/** The addresses to connect to if running in reversed (VM NATed) mode. */
93	char szConnectAddr[256];
94	/** The TCP port to connect to if running in reversed (VM NATed) mode. */
95	uint32_t uConnectPort;
96	/** Pointer to the TCP server instance. */
97	PRTTCPSERVER pTcpServer;
98	/** Thread calling RTTcpServerListen2. */
99	RTTHREAD hThreadServer;
100	/** Thread calling RTTcpClientConnect. */
101	RTTHREAD hThreadConnect;
102	/** The main thread handle (for signalling). */
103	RTTHREAD hThreadMain;
104	/** Stop connecting attempts when set. */
105	bool fStopConnecting;
106	/** Connect cancel cookie. */
107	PRTTCPCLIENTCONNECTCANCEL volatile pConnectCancelCookie;
108	} ATSTRANSPORTINST;
109	/** Pointer to an Audio Test Service (ATS) TCP/IP transport instance. */
110	typedef ATSTRANSPORTINST *PATSTRANSPORTINST;
111
112	/**
113	* Structure holding an ATS connection context, which is
114	* required when connecting a client via server (listening) or client (connecting).
115	*/
116	typedef struct ATSCONNCTX
117	{
118	/** Pointer to transport instance to use. */
119	PATSTRANSPORTINST pInst;
120	/** Pointer to transport client to connect. */
121	PATSTRANSPORTCLIENT pClient;
122	/** Connection timeout (in ms).
123	* Use RT_INDEFINITE_WAIT to wait indefinitely. */
124	uint32_t msTimeout;
125	} ATSCONNCTX;
126	/** Pointer to an Audio Test Service (ATS) TCP/IP connection context. */
127	typedef ATSCONNCTX *PATSCONNCTX;
128
129
130	/*********************************************************************************************************************************
131	* Global Variables *
132	*********************************************************************************************************************************/
133
134	/**
135	* Disconnects the current client and frees all stashed data.
136	*
137	* @param pThis Transport instance.
138	* @param pClient Client to disconnect.
139	*/
140	static void atsTcpDisconnectClient(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient)
141	{
142	RT_NOREF(pThis);
143
144	LogRelFlowFunc(("pClient=%RTsock\n", pClient->hTcpClient));
145
146	if (pClient->hTcpClient != NIL_RTSOCKET)
147	{
148	LogRelFlowFunc(("%RTsock\n", pClient->hTcpClient));
149
150	int rc;
151	if (pClient->fFromServer)
152	rc = RTTcpServerDisconnectClient2(pClient->hTcpClient);
153	else
154	rc = RTTcpClientClose(pClient->hTcpClient);
155	pClient->hTcpClient = NIL_RTSOCKET;
156	AssertRCSuccess(rc);
157	}
158
159	if (pClient->pbTcpStashed)
160	{
161	RTMemFree(pClient->pbTcpStashed);
162	pClient->pbTcpStashed = NULL;
163	}
164	}
165
166	/**
167	* Free's a client.
168	*
169	* @param pThis Transport instance.
170	* @param pClient Client to free.
171	* The pointer will be invalid after calling.
172	*/
173	static void atsTcpFreeClient(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient)
174	{
175	if (!pClient)
176	return;
177
178	/* Make sure to disconnect first. */
179	atsTcpDisconnectClient(pThis, pClient);
180
181	RTMemFree(pClient);
182	pClient = NULL;
183	}
184
185	/**
186	* Sets the current client socket in a safe manner.
187	*
188	* @returns NIL_RTSOCKET if consumed, otherwise hTcpClient.
189	* @param pThis Transport instance.
190	* @param pClient Client to set the socket for.
191	* @param fFromServer Whether the socket is from a server (listening) or client (connecting) call.
192	* Important when closing / disconnecting.
193	* @param hTcpClient The client socket.
194	*/
195	static RTSOCKET atsTcpSetClient(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient, bool fFromServer, RTSOCKET hTcpClient)
196	{
197	RTCritSectEnter(&pThis->CritSect);
198	if ( pClient->hTcpClient == NIL_RTSOCKET
199	&& !pThis->fStopConnecting)
200	{
201	LogRelFlowFunc(("New client %RTsock connected (fFromServer=%RTbool)\n", hTcpClient, fFromServer));
202
203	pClient->fFromServer = fFromServer;
204	pClient->hTcpClient = hTcpClient;
205	hTcpClient = NIL_RTSOCKET; /* Invalidate, as pClient has now ownership. */
206	}
207	RTCritSectLeave(&pThis->CritSect);
208	return hTcpClient;
209	}
210
211	/**
212	* Checks if it's a fatal RTTcpClientConnect return code.
213	*
214	* @returns true / false.
215	* @param rc The IPRT status code.
216	*/
217	static bool atsTcpIsFatalClientConnectStatus(int rc)
218	{
219	return rc != VERR_NET_UNREACHABLE
220	&& rc != VERR_NET_HOST_DOWN
221	&& rc != VERR_NET_HOST_UNREACHABLE
222	&& rc != VERR_NET_CONNECTION_REFUSED
223	&& rc != VERR_TIMEOUT
224	&& rc != VERR_NET_CONNECTION_TIMED_OUT;
225	}
226
227	/**
228	* Server mode connection thread.
229	*
230	* @returns iprt status code.
231	* @param hSelf Thread handle. Ignored.
232	* @param pvUser Pointer to ATSTRANSPORTINST the thread is bound to.
233	*/
234	static DECLCALLBACK(int) atsTcpServerConnectThread(RTTHREAD hSelf, void *pvUser)
235	{
236	RT_NOREF(hSelf);
237
238	PATSCONNCTX pConnCtx = (PATSCONNCTX)pvUser;
239	PATSTRANSPORTINST pThis = pConnCtx->pInst;
240	PATSTRANSPORTCLIENT pClient = pConnCtx->pClient;
241
242	/** @todo Implement cancellation support for using pConnCtx->msTimeout. */
243
244	LogRelFlowFuncEnter();
245
246	RTSOCKET hTcpClient;
247	int rc = RTTcpServerListen2(pThis->pTcpServer, &hTcpClient);
248	if (RT_SUCCESS(rc))
249	{
250	hTcpClient = atsTcpSetClient(pThis, pClient, true /* fFromServer */, hTcpClient);
251	RTTcpServerDisconnectClient2(hTcpClient);
252	}
253
254	LogRelFlowFuncLeaveRC(rc);
255	return rc;
256	}
257
258	/**
259	* Client mode connection thread.
260	*
261	* @returns iprt status code.
262	* @param hSelf Thread handle. Use to sleep on. The main thread will
263	* signal it to speed up thread shutdown.
264	* @param pvUser Pointer to a connection context (PATSCONNCTX) the thread is bound to.
265	*/
266	static DECLCALLBACK(int) atsTcpClientConnectThread(RTTHREAD hSelf, void *pvUser)
267	{
268	PATSCONNCTX pConnCtx = (PATSCONNCTX)pvUser;
269	PATSTRANSPORTINST pThis = pConnCtx->pInst;
270	PATSTRANSPORTCLIENT pClient = pConnCtx->pClient;
271
272	uint64_t msStartTs = RTTimeMilliTS();
273
274	LogRelFlowFuncEnter();
275
276	for (;;)
277	{
278	/* Stop? */
279	RTCritSectEnter(&pThis->CritSect);
280	bool fStop = pThis->fStopConnecting;
281	RTCritSectLeave(&pThis->CritSect);
282	if (fStop)
283	return VINF_SUCCESS;
284
285	/* Try connect. / /* @todo make cancelable! */
286	RTSOCKET hTcpClient;
287	int rc = RTTcpClientConnectEx(pThis->szConnectAddr, pThis->uConnectPort, &hTcpClient,
288	RT_SOCKETCONNECT_DEFAULT_WAIT, &pThis->pConnectCancelCookie);
289	if (RT_SUCCESS(rc))
290	{
291	hTcpClient = atsTcpSetClient(pThis, pClient, false /* fFromServer */, hTcpClient);
292	RTTcpClientCloseEx(hTcpClient, true /* fGracefulShutdown*/);
293	break;
294	}
295
296	if (atsTcpIsFatalClientConnectStatus(rc))
297	return rc;
298
299	if ( pConnCtx->msTimeout != RT_INDEFINITE_WAIT
300	&& RTTimeMilliTS() - msStartTs >= pConnCtx->msTimeout)
301	{
302	LogRelFlowFunc(("Timed out (%RU32ms)\n", pConnCtx->msTimeout));
303	return VERR_TIMEOUT;
304	}
305
306	/* Delay a wee bit before retrying. */
307	RTThreadUserWait(hSelf, 1536);
308	}
309
310	LogRelFlowFuncLeave();
311	return VINF_SUCCESS;
312	}
313
314	/**
315	* Wait on the threads to complete.
316	*
317	* @returns Thread status (if collected), otherwise VINF_SUCCESS.
318	* @param pThis Transport instance.
319	* @param cMillies The period to wait on each thread.
320	*/
321	static int atsTcpConnectWaitOnThreads(PATSTRANSPORTINST pThis, RTMSINTERVAL cMillies)
322	{
323	int rcRet = VINF_SUCCESS;
324
325	LogRelFlowFuncEnter();
326
327	if (pThis->hThreadConnect != NIL_RTTHREAD)
328	{
329	int rcThread;
330	int rc2 = RTThreadWait(pThis->hThreadConnect, cMillies, &rcThread);
331	if (RT_SUCCESS(rc2))
332	{
333	pThis->hThreadConnect = NIL_RTTHREAD;
334	rcRet = rcThread;
335	}
336	}
337
338	if (pThis->hThreadServer != NIL_RTTHREAD)
339	{
340	int rcThread;
341	int rc2 = RTThreadWait(pThis->hThreadServer, cMillies, &rcThread);
342	if (RT_SUCCESS(rc2))
343	{
344	pThis->hThreadServer = NIL_RTTHREAD;
345	if (RT_SUCCESS(rc2))
346	rcRet = rcThread;
347	}
348	}
349
350	LogRelFlowFuncLeaveRC(rcRet);
351	return rcRet;
352	}
353
354	/**
355	* @interface_method_impl{ATSTRANSPORT,pfnWaitForConnect}
356	*/
357	static DECLCALLBACK(int) atsTcpWaitForConnect(PATSTRANSPORTINST pThis, RTMSINTERVAL msTimeout,
358	bool *pfFromServer, PPATSTRANSPORTCLIENT ppClientNew)
359	{
360	PATSTRANSPORTCLIENT pClient = (PATSTRANSPORTCLIENT)RTMemAllocZ(sizeof(ATSTRANSPORTCLIENT));
361	AssertPtrReturn(pClient, VERR_NO_MEMORY);
362
363	int rc;
364
365	LogRelFlowFunc(("msTimeout=%RU32, enmConnMode=%#x\n", msTimeout, pThis->enmConnMode));
366
367	uint64_t msStartTs = RTTimeMilliTS();
368
369	if (pThis->enmConnMode == ATSCONNMODE_SERVER)
370	{
371	/** @todo Implement cancellation support for using \a msTimeout. */
372
373	pClient->fFromServer = true;
374	rc = RTTcpServerListen2(pThis->pTcpServer, &pClient->hTcpClient);
375	LogRelFlowFunc(("RTTcpServerListen2(%RTsock) -> %Rrc\n", pClient->hTcpClient, rc));
376	}
377	else if (pThis->enmConnMode == ATSCONNMODE_CLIENT)
378	{
379	pClient->fFromServer = false;
380	for (;;)
381	{
382	LogRelFlowFunc(("Calling RTTcpClientConnect(%s, %u,)...\n", pThis->szConnectAddr, pThis->uConnectPort));
383	rc = RTTcpClientConnect(pThis->szConnectAddr, pThis->uConnectPort, &pClient->hTcpClient);
384	LogRelFlowFunc(("RTTcpClientConnect(%RTsock) -> %Rrc\n", pClient->hTcpClient, rc));
385	if (RT_SUCCESS(rc) \|\| atsTcpIsFatalClientConnectStatus(rc))
386	break;
387
388	if ( msTimeout != RT_INDEFINITE_WAIT
389	&& RTTimeMilliTS() - msStartTs >= msTimeout)
390	{
391	rc = VERR_TIMEOUT;
392	break;
393	}
394
395	if (pThis->fStopConnecting)
396	{
397	rc = VINF_SUCCESS;
398	break;
399	}
400
401	/* Delay a wee bit before retrying. */
402	RTThreadSleep(1536);
403	}
404	}
405	else
406	{
407	Assert(pThis->enmConnMode == ATSCONNMODE_BOTH);
408
409	/*
410	* Create client threads.
411	*/
412	RTCritSectEnter(&pThis->CritSect);
413
414	pThis->fStopConnecting = false;
415	RTCritSectLeave(&pThis->CritSect);
416
417	atsTcpConnectWaitOnThreads(pThis, 32 /* cMillies */);
418
419	ATSCONNCTX ConnCtx;
420	RT_ZERO(ConnCtx);
421	ConnCtx.pInst = pThis;
422	ConnCtx.pClient = pClient;
423	ConnCtx.msTimeout = msTimeout;
424
425	rc = VINF_SUCCESS;
426	if (pThis->hThreadConnect == NIL_RTTHREAD)
427	{
428	pThis->pConnectCancelCookie = NULL;
429	rc = RTThreadCreate(&pThis->hThreadConnect, atsTcpClientConnectThread, &ConnCtx, 0, RTTHREADTYPE_DEFAULT,
430	RTTHREADFLAGS_WAITABLE, "tcpconn");
431	}
432	if (pThis->hThreadServer == NIL_RTTHREAD && RT_SUCCESS(rc))
433	rc = RTThreadCreate(&pThis->hThreadServer, atsTcpServerConnectThread, &ConnCtx, 0, RTTHREADTYPE_DEFAULT,
434	RTTHREADFLAGS_WAITABLE, "tcpserv");
435
436	RTCritSectEnter(&pThis->CritSect);
437
438	/*
439	* Wait for connection to be established.
440	*/
441	while ( RT_SUCCESS(rc)
442	&& pClient->hTcpClient == NIL_RTSOCKET)
443	{
444	RTCritSectLeave(&pThis->CritSect);
445	rc = atsTcpConnectWaitOnThreads(pThis, 10 /* cMillies */);
446	RTCritSectEnter(&pThis->CritSect);
447	}
448
449	/*
450	* Cancel the threads.
451	*/
452	pThis->fStopConnecting = true;
453
454	RTCritSectLeave(&pThis->CritSect);
455	RTTcpClientCancelConnect(&pThis->pConnectCancelCookie);
456	}
457
458	if (RT_SUCCESS(rc))
459	{
460	if (pfFromServer)
461	*pfFromServer = pClient->fFromServer;
462	*ppClientNew = pClient;
463	}
464	else
465	{
466	if (pClient)
467	{
468	atsTcpFreeClient(pThis, pClient);
469	pClient = NULL;
470	}
471	}
472
473	if (RT_FAILURE(rc))
474	LogRelFunc(("Failed with %Rrc\n", rc));
475
476	return rc;
477	}
478
479	/**
480	* @interface_method_impl{ATSTRANSPORT,pfnNotifyReboot}
481	*/
482	static DECLCALLBACK(void) atsTcpNotifyReboot(PATSTRANSPORTINST pThis)
483	{
484	LogRelFlowFuncEnter();
485	if (pThis->pTcpServer)
486	{
487	int rc = RTTcpServerDestroy(pThis->pTcpServer);
488	if (RT_FAILURE(rc))
489	LogRelFunc(("RTTcpServerDestroy failed, rc=%Rrc", rc));
490	pThis->pTcpServer = NULL;
491	}
492	LogRelFlowFuncLeave();
493	}
494
495	/**
496	* @interface_method_impl{ATSTRANSPORT,pfnNotifyBye}
497	*/
498	static DECLCALLBACK(void) atsTcpNotifyBye(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient)
499	{
500	LogRelFlowFunc(("pClient=%RTsock\n", pClient->hTcpClient));
501	atsTcpDisconnectClient(pThis, pClient);
502	}
503
504	/**
505	* @interface_method_impl{ATSTRANSPORT,pfnNotifyHowdy}
506	*/
507	static DECLCALLBACK(void) atsTcpNotifyHowdy(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient)
508	{
509	LogRelFlowFunc(("pClient=%RTsock\n", pClient->hTcpClient));
510
511	/* nothing to do here */
512	RT_NOREF(pThis);
513	}
514
515	/**
516	* @interface_method_impl{ATSTRANSPORT,pfnBabble}
517	*/
518	static DECLCALLBACK(void) atsTcpBabble(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient, PCATSPKTHDR pPktHdr, RTMSINTERVAL cMsSendTimeout)
519	{
520	/*
521	* Try send the babble reply.
522	*/
523	RT_NOREF(cMsSendTimeout); /** @todo implement the timeout here; non-blocking write + select-on-write. */
524	int rc;
525	size_t cbToSend = RT_ALIGN_Z(pPktHdr->cb, ATSPKT_ALIGNMENT);
526	do rc = RTTcpWrite(pClient->hTcpClient, pPktHdr, cbToSend);
527	while (rc == VERR_INTERRUPTED);
528
529	LogRelFlowFunc(("pClient=%RTsock, rc=%Rrc\n", pClient->hTcpClient, rc));
530
531	/*
532	* Disconnect the client.
533	*/
534	atsTcpDisconnectClient(pThis, pClient);
535	}
536
537	/**
538	* @interface_method_impl{ATSTRANSPORT,pfnSendPkt}
539	*/
540	static DECLCALLBACK(int) atsTcpSendPkt(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient, PCATSPKTHDR pPktHdr)
541	{
542	AssertReturn(pPktHdr->cb >= sizeof(ATSPKTHDR), VERR_INVALID_PARAMETER);
543
544	/*
545	* Write it.
546	*/
547	size_t cbToSend = RT_ALIGN_Z(pPktHdr->cb, ATSPKT_ALIGNMENT);
548
549	Log3Func(("%RU32 -> %zu\n", pPktHdr->cb, cbToSend));
550
551	LogRel4(("pClient=%RTsock\n", pClient->hTcpClient));
552	LogRel4(("Header:\n"
553	"%.*Rhxd\n", RT_MIN(sizeof(ATSPKTHDR), cbToSend), pPktHdr));
554
555	if (cbToSend > sizeof(ATSPKTHDR))
556	LogRel4(("Payload:\n"
557	"%.*Rhxd\n",
558	RT_MIN(64, cbToSend - sizeof(ATSPKTHDR)), (uint8_t *)pPktHdr + sizeof(ATSPKTHDR)));
559
560	int rc = RTTcpWrite(pClient->hTcpClient, pPktHdr, cbToSend);
561	if ( RT_FAILURE(rc)
562	&& rc != VERR_INTERRUPTED)
563	{
564	/* assume fatal connection error. */
565	LogRelFunc(("RTTcpWrite -> %Rrc -> atsTcpDisconnectClient(%RTsock)\n", rc, pClient->hTcpClient));
566	atsTcpDisconnectClient(pThis, pClient);
567	}
568
569	LogRel3(("atsTcpSendPkt: pClient=%RTsock, achOpcode=%.8s, cbSent=%zu -> %Rrc\n", pClient->hTcpClient, (const char *)pPktHdr->achOpcode, cbToSend, rc));
570	return rc;
571	}
572
573	/**
574	* @interface_method_impl{ATSTRANSPORT,pfnRecvPkt}
575	*/
576	static DECLCALLBACK(int) atsTcpRecvPkt(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient, PPATSPKTHDR ppPktHdr)
577	{
578	int rc = VINF_SUCCESS;
579	*ppPktHdr = NULL;
580
581	LogRel4(("pClient=%RTsock (cbTcpStashed=%zu, cbTcpStashedAlloced=%zu)\n",
582	pClient->hTcpClient, pClient->cbTcpStashed, pClient->cbTcpStashedAlloced));
583
584	/*
585	* Read state.
586	*/
587	size_t offData = 0;
588	size_t cbData = 0;
589	size_t cbDataAlloced;
590	uint8_t *pbData = NULL;
591
592	/*
593	* Any stashed data?
594	*/
595	if (pClient->cbTcpStashedAlloced)
596	{
597	offData = pClient->cbTcpStashed;
598	cbDataAlloced = pClient->cbTcpStashedAlloced;
599	pbData = pClient->pbTcpStashed;
600
601	pClient->cbTcpStashed = 0;
602	pClient->cbTcpStashedAlloced = 0;
603	pClient->pbTcpStashed = NULL;
604	}
605	else
606	{
607	cbDataAlloced = RT_ALIGN_Z(64, ATSPKT_ALIGNMENT);
608	pbData = (uint8_t *)RTMemAlloc(cbDataAlloced);
609	AssertPtrReturn(pbData, VERR_NO_MEMORY);
610	}
611
612	/*
613	* Read and validate the length.
614	*/
615	while (offData < sizeof(uint32_t))
616	{
617	size_t cbRead;
618	rc = RTTcpRead(pClient->hTcpClient, pbData + offData, sizeof(uint32_t) - offData, &cbRead);
619	if (RT_FAILURE(rc))
620	break;
621	if (cbRead == 0)
622	{
623	LogRelFunc(("RTTcpRead -> %Rrc / cbRead=0 -> VERR_NET_NOT_CONNECTED (#1)\n", rc));
624	rc = VERR_NET_NOT_CONNECTED;
625	break;
626	}
627	offData += cbRead;
628	}
629	if (RT_SUCCESS(rc))
630	{
631	ASMCompilerBarrier(); /* paranoia^3 */
632	cbData = (uint32_t volatile )pbData;
633	if (cbData >= sizeof(ATSPKTHDR) && cbData <= ATSPKT_MAX_SIZE)
634	{
635	/*
636	* Align the length and reallocate the return packet it necessary.
637	*/
638	cbData = RT_ALIGN_Z(cbData, ATSPKT_ALIGNMENT);
639	if (cbData > cbDataAlloced)
640	{
641	void *pvNew = RTMemRealloc(pbData, cbData);
642	if (pvNew)
643	{
644	pbData = (uint8_t *)pvNew;
645	cbDataAlloced = cbData;
646	}
647	else
648	rc = VERR_NO_MEMORY;
649	}
650	if (RT_SUCCESS(rc))
651	{
652	/*
653	* Read the remainder of the data.
654	*/
655	while (offData < cbData)
656	{
657	size_t cbRead;
658	rc = RTTcpRead(pClient->hTcpClient, pbData + offData, cbData - offData, &cbRead);
659	if (RT_FAILURE(rc))
660	break;
661	if (cbRead == 0)
662	{
663	LogRelFunc(("RTTcpRead -> %Rrc / cbRead=0 -> VERR_NET_NOT_CONNECTED (#2)\n", rc));
664	rc = VERR_NET_NOT_CONNECTED;
665	break;
666	}
667
668	offData += cbRead;
669	}
670
671	LogRel4(("Header:\n"
672	"%.*Rhxd\n", sizeof(ATSPKTHDR), pbData));
673
674	if ( RT_SUCCESS(rc)
675	&& cbData > sizeof(ATSPKTHDR))
676	LogRel4(("Payload:\n"
677	"%.Rhxd\n", RT_MIN(64, cbData - sizeof(ATSPKTHDR)), (uint8_t )pbData + sizeof(ATSPKTHDR)));
678	}
679	}
680	else
681	{
682	LogRelFunc(("Received invalid packet size (%zu)\n", cbData));
683	rc = VERR_NET_PROTOCOL_ERROR;
684	}
685	}
686	if (RT_SUCCESS(rc))
687	*ppPktHdr = (PATSPKTHDR)pbData;
688	else
689	{
690	/*
691	* Deal with errors.
692	*/
693	if (rc == VERR_INTERRUPTED)
694	{
695	/* stash it away for the next call. */
696	pClient->cbTcpStashed = cbData;
697	pClient->cbTcpStashedAlloced = cbDataAlloced;
698	pClient->pbTcpStashed = pbData;
699	}
700	else
701	{
702	RTMemFree(pbData);
703
704	/* assume fatal connection error. */
705	LogRelFunc(("RTTcpRead -> %Rrc -> atsTcpDisconnectClient(%RTsock)\n", rc, pClient->hTcpClient));
706	atsTcpDisconnectClient(pThis, pClient);
707	}
708	}
709
710	PATSPKTHDR pPktHdr = (PATSPKTHDR)pbData;
711	LogRel3(("atsTcpRecvPkt: pClient=%RTsock, achOpcode=%.8s, cbRead=%zu -> %Rrc\n",
712	pClient->hTcpClient, pPktHdr ? (const char *)pPktHdr->achOpcode : "NONE ", cbData, rc));
713	return rc;
714	}
715
716	/**
717	* @interface_method_impl{ATSTRANSPORT,pfnPollSetAdd}
718	*/
719	static DECLCALLBACK(int) atsTcpPollSetAdd(PATSTRANSPORTINST pThis, RTPOLLSET hPollSet, PATSTRANSPORTCLIENT pClient, uint32_t idStart)
720	{
721	RT_NOREF(pThis);
722	return RTPollSetAddSocket(hPollSet, pClient->hTcpClient, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR, idStart);
723	}
724
725	/**
726	* @interface_method_impl{ATSTRANSPORT,pfnPollSetRemove}
727	*/
728	static DECLCALLBACK(int) atsTcpPollSetRemove(PATSTRANSPORTINST pThis, RTPOLLSET hPollSet, PATSTRANSPORTCLIENT pClient, uint32_t idStart)
729	{
730	RT_NOREF(pThis, pClient);
731	return RTPollSetRemove(hPollSet, idStart);
732	}
733
734	/**
735	* @interface_method_impl{ATSTRANSPORT,pfnDisconnect}
736	*/
737	static DECLCALLBACK(void) atsTcpDisconnect(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient)
738	{
739	atsTcpFreeClient(pThis, pClient);
740	}
741
742	/**
743	* @interface_method_impl{ATSTRANSPORT,pfnPollIn}
744	*/
745	static DECLCALLBACK(bool) atsTcpPollIn(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient)
746	{
747	RT_NOREF(pThis);
748	int rc = RTTcpSelectOne(pClient->hTcpClient, 0/cMillies/);
749	return RT_SUCCESS(rc);
750	}
751
752	/**
753	* @interface_method_impl{ATSTRANSPORT,pfnStop}
754	*/
755	static DECLCALLBACK(void) atsTcpStop(PATSTRANSPORTINST pThis)
756	{
757	LogRelFlowFuncEnter();
758
759	/* Signal thread */
760	if (RTCritSectIsInitialized(&pThis->CritSect))
761	{
762	RTCritSectEnter(&pThis->CritSect);
763	pThis->fStopConnecting = true;
764	RTCritSectLeave(&pThis->CritSect);
765	}
766
767	if (pThis->hThreadConnect != NIL_RTTHREAD)
768	{
769	RTThreadUserSignal(pThis->hThreadConnect);
770	RTTcpClientCancelConnect(&pThis->pConnectCancelCookie);
771	}
772
773	/* Shut down the server (will wake up thread). */
774	if (pThis->pTcpServer)
775	{
776	LogRelFlowFunc(("Destroying server...\n"));
777	int rc = RTTcpServerDestroy(pThis->pTcpServer);
778	if (RT_FAILURE(rc))
779	LogRelFunc(("RTTcpServerDestroy failed with %Rrc", rc));
780	pThis->pTcpServer = NULL;
781	}
782
783	/* Wait for the thread (they should've had some time to quit by now). */
784	atsTcpConnectWaitOnThreads(pThis, 15000);
785
786	LogRelFlowFuncLeave();
787	}
788
789	/**
790	* @interface_method_impl{ATSTRANSPORT,pfnCreate}
791	*/
792	static DECLCALLBACK(int) atsTcpCreate(PATSTRANSPORTINST *ppThis)
793	{
794	PATSTRANSPORTINST pThis = (PATSTRANSPORTINST)RTMemAllocZ(sizeof(ATSTRANSPORTINST));
795	AssertPtrReturn(pThis, VERR_NO_MEMORY);
796
797	int rc = RTCritSectInit(&pThis->CritSect);
798	if (RT_SUCCESS(rc))
799	{
800	*ppThis = pThis;
801	}
802
803	return rc;
804	}
805
806	/**
807	* @interface_method_impl{ATSTRANSPORT,pfnDestroy}
808	*/
809	static DECLCALLBACK(int) atsTcpDestroy(PATSTRANSPORTINST pThis)
810	{
811	/* Stop things first. */
812	atsTcpStop(pThis);
813
814	/* Finally, clean up the critical section. */
815	if (RTCritSectIsInitialized(&pThis->CritSect))
816	RTCritSectDelete(&pThis->CritSect);
817
818	RTMemFree(pThis);
819	pThis = NULL;
820
821	return VINF_SUCCESS;
822	}
823
824	/**
825	* @interface_method_impl{ATSTRANSPORT,pfnStart}
826	*/
827	static DECLCALLBACK(int) atsTcpStart(PATSTRANSPORTINST pThis)
828	{
829	int rc = VINF_SUCCESS;
830
831	if (pThis->enmConnMode != ATSCONNMODE_CLIENT)
832	{
833	rc = RTTcpServerCreateEx(pThis->szBindAddr[0] ? pThis->szBindAddr : NULL, pThis->uBindPort, &pThis->pTcpServer);
834	if (RT_FAILURE(rc))
835	{
836	if (rc == VERR_NET_DOWN)
837	{
838	LogRelFunc(("RTTcpServerCreateEx(%s, %u,) failed: %Rrc, retrying for 20 seconds...\n",
839	pThis->szBindAddr[0] ? pThis->szBindAddr : NULL, pThis->uBindPort, rc));
840	uint64_t StartMs = RTTimeMilliTS();
841	do
842	{
843	RTThreadSleep(1000);
844	rc = RTTcpServerCreateEx(pThis->szBindAddr[0] ? pThis->szBindAddr : NULL, pThis->uBindPort, &pThis->pTcpServer);
845	} while ( rc == VERR_NET_DOWN
846	&& RTTimeMilliTS() - StartMs < 20000);
847	if (RT_SUCCESS(rc))
848	LogRelFunc(("RTTcpServerCreateEx succceeded\n"));
849	}
850
851	if (RT_FAILURE(rc))
852	{
853	LogRelFunc(("RTTcpServerCreateEx(%s, %u,) failed: %Rrc\n",
854	pThis->szBindAddr[0] ? pThis->szBindAddr : NULL, pThis->uBindPort, rc));
855	}
856	}
857	}
858
859	return rc;
860	}
861
862	/**
863	* @interface_method_impl{ATSTRANSPORT,pfnOption}
864	*/
865	static DECLCALLBACK(int) atsTcpOption(PATSTRANSPORTINST pThis, int ch, PCRTGETOPTUNION pVal)
866	{
867	int rc;
868
869	switch (ch)
870	{
871	case ATSTCPOPT_CONN_MODE:
872	pThis->enmConnMode = (ATSCONNMODE)pVal->u32;
873	return VINF_SUCCESS;
874
875	case ATSTCPOPT_BIND_ADDRESS:
876	rc = RTStrCopy(pThis->szBindAddr, sizeof(pThis->szBindAddr), pVal->psz);
877	if (RT_FAILURE(rc))
878	return RTMsgErrorRc(VERR_INVALID_PARAMETER, "TCP bind address is too long (%Rrc)", rc);
879	if (!pThis->szBindAddr[0])
880	return RTMsgErrorRc(VERR_INVALID_PARAMETER, "No TCP bind address specified: %s", pThis->szBindAddr);
881	return VINF_SUCCESS;
882
883	case ATSTCPOPT_BIND_PORT:
884	pThis->uBindPort = pVal->u16;
885	return VINF_SUCCESS;
886
887	case ATSTCPOPT_CONNECT_ADDRESS:
888	rc = RTStrCopy(pThis->szConnectAddr, sizeof(pThis->szConnectAddr), pVal->psz);
889	if (RT_FAILURE(rc))
890	return RTMsgErrorRc(VERR_INVALID_PARAMETER, "TCP connect address is too long (%Rrc)", rc);
891	if (!pThis->szConnectAddr[0])
892	return RTMsgErrorRc(VERR_INVALID_PARAMETER, "No TCP connect address specified");
893	return VINF_SUCCESS;
894
895	case ATSTCPOPT_CONNECT_PORT:
896	pThis->uConnectPort = pVal->u16;
897	return VINF_SUCCESS;
898
899	default:
900	break;
901	}
902	return VERR_TRY_AGAIN;
903	}
904
905	/**
906	* @interface_method_impl{ATSTRANSPORT,pfnUsage}
907	*/
908	DECLCALLBACK(void) atsTcpUsage(PRTSTREAM pStream)
909	{
910	RTStrmPrintf(pStream,
911	" --tcp-conn-mode <0=both\|1=client\|2=server>\n"
912	" Selects the connection mode\n"
913	" Default: 0 (both)\n"
914	" --tcp-bind-addr[ess] <address>\n"
915	" The address(es) to listen to TCP connection on. Empty string\n"
916	" means any address, this is the default\n"
917	" --tcp-bind-port <port>\n"
918	" The port to listen to TCP connections on\n"
919	" Default: %u\n"
920	" --tcp-connect-addr[ess] <address>\n"
921	" The address of the server to try connect to in client mode\n"
922	" Default: " ATS_TCP_DEF_CONNECT_GUEST_STR "\n"
923	" --tcp-connect-port <port>\n"
924	" The port on the server to connect to in client mode\n"
925	" Default: %u\n"
926	, ATS_TCP_DEF_BIND_PORT_GUEST, ATS_TCP_DEF_CONNECT_PORT_GUEST);
927	}
928
929	/** Command line options for the TCP/IP transport layer. */
930	static const RTGETOPTDEF g_TcpOpts[] =
931	{
932	{ "--tcp-conn-mode", ATSTCPOPT_CONN_MODE, RTGETOPT_REQ_STRING },
933	{ "--tcp-bind-addr", ATSTCPOPT_BIND_ADDRESS, RTGETOPT_REQ_STRING },
934	{ "--tcp-bind-address", ATSTCPOPT_BIND_ADDRESS, RTGETOPT_REQ_STRING },
935	{ "--tcp-bind-port", ATSTCPOPT_BIND_PORT, RTGETOPT_REQ_UINT16 },
936	{ "--tcp-connect-addr", ATSTCPOPT_CONNECT_ADDRESS, RTGETOPT_REQ_STRING },
937	{ "--tcp-connect-address", ATSTCPOPT_CONNECT_ADDRESS, RTGETOPT_REQ_STRING },
938	{ "--tcp-connect-port", ATSTCPOPT_CONNECT_PORT, RTGETOPT_REQ_UINT16 }
939	};
940
941	/** TCP/IP transport layer. */
942	const ATSTRANSPORT g_TcpTransport =
943	{
944	/* .szName = */ "tcp",
945	/* .pszDesc = */ "TCP/IP",
946	/* .cOpts = */ &g_TcpOpts[0],
947	/* .paOpts = */ RT_ELEMENTS(g_TcpOpts),
948	/* .pfnUsage = */ atsTcpUsage,
949	/* .pfnCreate = */ atsTcpCreate,
950	/* .pfnDestroy = */ atsTcpDestroy,
951	/* .pfnOption = */ atsTcpOption,
952	/* .pfnStart = */ atsTcpStart,
953	/* .pfnStop = */ atsTcpStop,
954	/* .pfnWaitForConnect = */ atsTcpWaitForConnect,
955	/* .pfnDisconnect = */ atsTcpDisconnect,
956	/* .pfnPollIn = */ atsTcpPollIn,
957	/* .pfnPollSetAdd = */ atsTcpPollSetAdd,
958	/* .pfnPollSetRemove = */ atsTcpPollSetRemove,
959	/* .pfnRecvPkt = */ atsTcpRecvPkt,
960	/* .pfnSendPkt = */ atsTcpSendPkt,
961	/* .pfnBabble = */ atsTcpBabble,
962	/* .pfnNotifyHowdy = */ atsTcpNotifyHowdy,
963	/* .pfnNotifyBye = */ atsTcpNotifyBye,
964	/* .pfnNotifyReboot = */ atsTcpNotifyReboot,
965	/* .u32EndMarker = */ UINT32_C(0x12345678)
966	};
967

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

source: vbox/trunk/src/VBox/Devices/Audio/AudioTestServiceTcp.cpp@ 96407

Download in other formats: