AudioTestService.cpp@ 104389

Last change on this file since 104389 was 99739, checked in by vboxsync, 18 months ago
*: doxygen corrections (mostly about removing @returns from functions returning void).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 44.0 KB

Line
1	/* $Id: AudioTestService.cpp 99739 2023-05-11 01:01:08Z vboxsync $ */
2	/** @file
3	* AudioTestService - Audio test execution server.
4	*/
5
6	/*
7	* Copyright (C) 2021-2023 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/alloca.h>
36	#include <iprt/asm.h>
37	#include <iprt/assert.h>
38	#include <iprt/critsect.h>
39	#include <iprt/crc.h>
40	#include <iprt/ctype.h>
41	#include <iprt/dir.h>
42	#include <iprt/env.h>
43	#include <iprt/err.h>
44	#include <iprt/file.h>
45	#include <iprt/getopt.h>
46	#include <iprt/handle.h>
47	#include <iprt/initterm.h>
48	#include <iprt/json.h>
49	#include <iprt/list.h>
50	#include <iprt/mem.h>
51	#include <iprt/message.h>
52	#include <iprt/param.h>
53	#include <iprt/path.h>
54	#include <iprt/pipe.h>
55	#include <iprt/poll.h>
56	#include <iprt/process.h>
57	#include <iprt/stream.h>
58	#include <iprt/string.h>
59	#include <iprt/thread.h>
60
61	#include <VBox/log.h>
62
63	#include "AudioTestService.h"
64	#include "AudioTestServiceInternal.h"
65
66
67	/*********************************************************************************************************************************
68	* Structures and Typedefs *
69	*********************************************************************************************************************************/
70	/**
71	* A generic ATS reply, used by the client
72	* to process the incoming packets.
73	*/
74	typedef struct ATSSRVREPLY
75	{
76	char szOp[ATSPKT_OPCODE_MAX_LEN];
77	void *pvPayload;
78	size_t cbPayload;
79	} ATSSRVREPLY;
80	/** Pointer to a generic ATS reply. */
81	typedef struct ATSSRVREPLY *PATSSRVREPLY;
82
83
84	/*********************************************************************************************************************************
85	* Global Variables *
86	*********************************************************************************************************************************/
87	/**
88	* Transport layers.
89	*/
90	const PCATSTRANSPORT g_apTransports[] =
91	{
92	&g_TcpTransport
93	};
94	/** Number of transport layers in \a g_apTransports. */
95	const size_t g_cTransports = RT_ELEMENTS(g_apTransports);
96
97	/**
98	* ATS client state.
99	*/
100	typedef enum ATSCLIENTSTATE
101	{
102	/** Invalid client state. */
103	ATSCLIENTSTATE_INVALID = 0,
104	/** Client is initialising, only the HOWDY and BYE packets are allowed. */
105	ATSCLIENTSTATE_INITIALISING,
106	/** Client is in fully cuntional state and ready to process all requests. */
107	ATSCLIENTSTATE_READY,
108	/** Client is destroying. */
109	ATSCLIENTSTATE_DESTROYING,
110	/** 32bit hack. */
111	ATSCLIENTSTATE_32BIT_HACK = 0x7fffffff
112	} ATSCLIENTSTATE;
113
114	/**
115	* ATS client instance.
116	*/
117	typedef struct ATSCLIENTINST
118	{
119	/** List node for new clients. */
120	RTLISTNODE NdLst;
121	/** The current client state. */
122	ATSCLIENTSTATE enmState;
123	/** Transport backend specific data. */
124	PATSTRANSPORTCLIENT pTransportClient;
125	/** Client hostname. */
126	char *pszHostname;
127	} ATSCLIENTINST;
128	/** Pointer to a ATS client instance. */
129	typedef ATSCLIENTINST *PATSCLIENTINST;
130
131
132	/*********************************************************************************************************************************
133	* Prototypes *
134	*********************************************************************************************************************************/
135	static int atsClientDisconnect(PATSSERVER pThis, PATSCLIENTINST pInst);
136
137
138
139	/**
140	* Returns the string represenation of the given state.
141	*/
142	static const char *atsClientStateStringify(ATSCLIENTSTATE enmState)
143	{
144	switch (enmState)
145	{
146	case ATSCLIENTSTATE_INVALID:
147	return "INVALID";
148	case ATSCLIENTSTATE_INITIALISING:
149	return "INITIALISING";
150	case ATSCLIENTSTATE_READY:
151	return "READY";
152	case ATSCLIENTSTATE_DESTROYING:
153	return "DESTROYING";
154	case ATSCLIENTSTATE_32BIT_HACK:
155	default:
156	break;
157	}
158
159	AssertMsgFailed(("Unknown state %#x\n", enmState));
160	return "UNKNOWN";
161	}
162
163	/**
164	* Calculates the checksum value, zero any padding space and send the packet.
165	*
166	* @returns IPRT status code.
167	* @param pThis The ATS instance.
168	* @param pInst The ATS client structure.
169	* @param pPkt The packet to send. Must point to a correctly
170	* aligned buffer.
171	*/
172	static int atsSendPkt(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPkt)
173	{
174	Assert(pPkt->cb >= sizeof(*pPkt));
175	pPkt->uCrc32 = RTCrc32(pPkt->achOpcode, pPkt->cb - RT_UOFFSETOF(ATSPKTHDR, achOpcode));
176	if (pPkt->cb != RT_ALIGN_32(pPkt->cb, ATSPKT_ALIGNMENT))
177	memset((uint8_t *)pPkt + pPkt->cb, '\0', RT_ALIGN_32(pPkt->cb, ATSPKT_ALIGNMENT) - pPkt->cb);
178
179	LogFlowFunc(("cb=%RU32 (%#x), payload=%RU32 (%#x), opcode=%.8s\n",
180	pPkt->cb, pPkt->cb, pPkt->cb - sizeof(ATSPKTHDR), pPkt->cb - sizeof(ATSPKTHDR), pPkt->achOpcode));
181	int rc = pThis->pTransport->pfnSendPkt(pThis->pTransportInst, pInst->pTransportClient, pPkt);
182	while (RT_UNLIKELY(rc == VERR_INTERRUPTED) && !pThis->fTerminate)
183	rc = pThis->pTransport->pfnSendPkt(pThis->pTransportInst, pInst->pTransportClient, pPkt);
184
185	return rc;
186	}
187
188	/**
189	* Sends a babble reply and disconnects the client (if applicable).
190	*
191	* @param pThis The ATS instance.
192	* @param pInst The ATS server instance.
193	* @param pszOpcode The BABBLE opcode.
194	*/
195	static void atsReplyBabble(PATSSERVER pThis, PATSCLIENTINST pInst, const char *pszOpcode)
196	{
197	ATSPKTHDR Reply;
198	Reply.cb = sizeof(Reply);
199	Reply.uCrc32 = 0;
200	memcpy(Reply.achOpcode, pszOpcode, sizeof(Reply.achOpcode));
201
202	pThis->pTransport->pfnBabble(pThis->pTransportInst, pInst->pTransportClient, &Reply, 20*1000);
203	}
204
205	/**
206	* Receive and validate a packet.
207	*
208	* Will send bable responses to malformed packets that results in a error status
209	* code.
210	*
211	* @returns IPRT status code.
212	* @param pThis The ATS instance.
213	* @param pInst The opaque ATS instance structure.
214	* @param ppPktHdr Where to return the packet on success. Free
215	* with RTMemFree.
216	* @param fAutoRetryOnFailure Whether to retry on error.
217	*/
218	static int atsRecvPkt(PATSSERVER pThis, PATSCLIENTINST pInst, PPATSPKTHDR ppPktHdr, bool fAutoRetryOnFailure)
219	{
220	for (;;)
221	{
222	PATSPKTHDR pPktHdr;
223	int rc = pThis->pTransport->pfnRecvPkt(pThis->pTransportInst, pInst->pTransportClient, &pPktHdr);
224	if (RT_SUCCESS(rc))
225	{
226	/* validate the packet. */
227	if ( pPktHdr->cb >= sizeof(ATSPKTHDR)
228	&& pPktHdr->cb < ATSPKT_MAX_SIZE)
229	{
230	Log2Func(("pPktHdr=%p cb=%#x crc32=%#x opcode=%.8s\n",
231	pPktHdr, pPktHdr->cb, pPktHdr->uCrc32, pPktHdr->achOpcode));
232	uint32_t uCrc32Calc = pPktHdr->uCrc32 != 0
233	? RTCrc32(&pPktHdr->achOpcode[0], pPktHdr->cb - RT_UOFFSETOF(ATSPKTHDR, achOpcode))
234	: 0;
235	if (pPktHdr->uCrc32 == uCrc32Calc)
236	{
237	AssertCompileMemberSize(ATSPKTHDR, achOpcode, 8);
238	if ( RT_C_IS_UPPER(pPktHdr->achOpcode[0])
239	&& RT_C_IS_UPPER(pPktHdr->achOpcode[1])
240	&& (RT_C_IS_UPPER(pPktHdr->achOpcode[2]) \|\| pPktHdr->achOpcode[2] == ' ')
241	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[3]) \|\| pPktHdr->achOpcode[3] == ' ')
242	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[4]) \|\| pPktHdr->achOpcode[4] == ' ')
243	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[5]) \|\| pPktHdr->achOpcode[5] == ' ')
244	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[6]) \|\| pPktHdr->achOpcode[6] == ' ')
245	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[7]) \|\| pPktHdr->achOpcode[7] == ' ')
246	)
247	{
248	Log(("cb=%#x opcode=%.8s\n", pPktHdr->cb, pPktHdr->achOpcode));
249	*ppPktHdr = pPktHdr;
250	return rc;
251	}
252
253	rc = VERR_IO_BAD_COMMAND;
254	}
255	else
256	{
257	Log(("cb=%#x opcode=%.8s crc32=%#x actual=%#x\n",
258	pPktHdr->cb, pPktHdr->achOpcode, pPktHdr->uCrc32, uCrc32Calc));
259	rc = VERR_IO_CRC;
260	}
261	}
262	else
263	rc = VERR_IO_BAD_LENGTH;
264
265	/* Send babble reply and disconnect the client if the transport is
266	connection oriented. */
267	if (rc == VERR_IO_BAD_LENGTH)
268	atsReplyBabble(pThis, pInst, "BABBLE L");
269	else if (rc == VERR_IO_CRC)
270	atsReplyBabble(pThis, pInst, "BABBLE C");
271	else if (rc == VERR_IO_BAD_COMMAND)
272	atsReplyBabble(pThis, pInst, "BABBLE O");
273	else
274	atsReplyBabble(pThis, pInst, "BABBLE ");
275	RTMemFree(pPktHdr);
276	}
277
278	/* Try again or return failure? */
279	if ( pThis->fTerminate
280	\|\| rc != VERR_INTERRUPTED
281	\|\| !fAutoRetryOnFailure
282	)
283	{
284	Log(("rc=%Rrc\n", rc));
285	return rc;
286	}
287	}
288	}
289
290	/**
291	* Make a simple reply, only status opcode.
292	*
293	* @returns IPRT status code of the send.
294	* @param pThis The ATS instance.
295	* @param pInst The opaque ATS instance structure.
296	* @param pReply The reply packet.
297	* @param pszOpcode The status opcode. Exactly 8 chars long, padd
298	* with space.
299	* @param cbExtra Bytes in addition to the header.
300	*/
301	static int atsReplyInternal(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pReply, const char *pszOpcode, size_t cbExtra)
302	{
303	/* copy the opcode, don't be too strict in case of a padding screw up. */
304	size_t cchOpcode = strlen(pszOpcode);
305	if (RT_LIKELY(cchOpcode == sizeof(pReply->achOpcode)))
306	memcpy(pReply->achOpcode, pszOpcode, sizeof(pReply->achOpcode));
307	else
308	{
309	Assert(cchOpcode == sizeof(pReply->achOpcode));
310	while (cchOpcode > 0 && pszOpcode[cchOpcode - 1] == ' ')
311	cchOpcode--;
312	AssertMsgReturn(cchOpcode < sizeof(pReply->achOpcode), ("%d/'%.8s'\n", cchOpcode, pszOpcode), VERR_INTERNAL_ERROR_4);
313	memcpy(pReply->achOpcode, pszOpcode, cchOpcode);
314	memset(&pReply->achOpcode[cchOpcode], ' ', sizeof(pReply->achOpcode) - cchOpcode);
315	}
316
317	pReply->cb = (uint32_t)sizeof(ATSPKTHDR) + (uint32_t)cbExtra;
318	pReply->uCrc32 = 0;
319
320	return atsSendPkt(pThis, pInst, pReply);
321	}
322
323	/**
324	* Make a simple reply, only status opcode.
325	*
326	* @returns IPRT status code of the send.
327	* @param pThis The ATS instance.
328	* @param pInst The opaque ATS instance structure.
329	* @param pPktHdr The original packet (for future use).
330	* @param pszOpcode The status opcode. Exactly 8 chars long, padd
331	* with space.
332	*/
333	static int atsReplySimple(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr, const char *pszOpcode)
334	{
335	return atsReplyInternal(pThis, pInst, pPktHdr, pszOpcode, 0);
336	}
337
338	/**
339	* Acknowledges a packet with success.
340	*
341	* @returns IPRT status code of the send.
342	* @param pThis The ATS instance.
343	* @param pInst The opaque ATS instance structure.
344	* @param pPktHdr The original packet (for future use).
345	*/
346	static int atsReplyAck(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr)
347	{
348	return atsReplySimple(pThis, pInst, pPktHdr, "ACK ");
349	}
350
351	/**
352	* Replies with a failure.
353	*
354	* @returns IPRT status code of the send.
355	* @param pThis The ATS instance.
356	* @param pInst The opaque ATS instance structure.
357	* @param pPktHdr The original packet (for future use).
358	* @param pszOpcode The status opcode. Exactly 8 chars long, padd
359	* with space.
360	* @param rcReq The status code of the request.
361	* @param pszDetailFmt Longer description of the problem (format string).
362	* @param va Format arguments.
363	*/
364	static int atsReplyFailureV(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr,
365	const char pszOpcode, int rcReq, const char pszDetailFmt, va_list va)
366	{
367	RT_NOREF(pPktHdr);
368
369	ATSPKTREPFAIL Rep;
370	RT_ZERO(Rep);
371
372	size_t cchDetail = RTStrPrintfV(Rep.ach, sizeof(Rep.ach), pszDetailFmt, va);
373
374	Rep.rc = rcReq;
375
376	return atsReplyInternal(pThis, pInst, &Rep.Hdr, pszOpcode, sizeof(Rep.rc) + cchDetail + 1);
377	}
378
379	/**
380	* Replies with a failure.
381	*
382	* @returns IPRT status code of the send.
383	* @param pThis The ATS instance.
384	* @param pInst The opaque ATS instance structure.
385	* @param pPktHdr The original packet (for future use).
386	* @param pszOpcode The status opcode. Exactly 8 chars long, padd
387	* with space.
388	* @param rcReq Status code.
389	* @param pszDetailFmt Longer description of the problem (format string).
390	* @param ... Format arguments.
391	*/
392	static int atsReplyFailure(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr,
393	const char pszOpcode, int rcReq, const char pszDetailFmt, ...)
394	{
395	va_list va;
396	va_start(va, pszDetailFmt);
397	int rc = atsReplyFailureV(pThis, pInst, pPktHdr, pszOpcode, rcReq, pszDetailFmt, va);
398	va_end(va);
399	return rc;
400	}
401
402	/**
403	* Replies according to the return code.
404	*
405	* @returns IPRT status code of the send.
406	* @param pThis The ATS instance.
407	* @param pInst The opaque ATS instance structure.
408	* @param pPktHdr The packet to reply to.
409	* @param rcOperation The status code to report.
410	* @param pszOperationFmt The operation that failed. Typically giving the
411	* function call with important arguments.
412	* @param ... Arguments to the format string.
413	*/
414	static int atsReplyRC(PATSSERVER pThis,
415	PATSCLIENTINST pInst, PATSPKTHDR pPktHdr, int rcOperation, const char *pszOperationFmt, ...)
416	{
417	if (RT_SUCCESS(rcOperation))
418	return atsReplyAck(pThis, pInst, pPktHdr);
419
420	char szOperation[128];
421	va_list va;
422	va_start(va, pszOperationFmt);
423	RTStrPrintfV(szOperation, sizeof(szOperation), pszOperationFmt, va);
424	va_end(va);
425
426	return atsReplyFailure(pThis, pInst, pPktHdr, "FAILED ", rcOperation, "%s failed with rc=%Rrc (opcode '%.8s')",
427	szOperation, rcOperation, pPktHdr->achOpcode);
428	}
429
430	/**
431	* Signal a bad packet exact size.
432	*
433	* @returns IPRT status code of the send.
434	* @param pThis The ATS instance.
435	* @param pInst The opaque ATS instance structure.
436	* @param pPktHdr The packet to reply to.
437	* @param cb The wanted size.
438	*/
439	static int atsReplyBadSize(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr, size_t cb)
440	{
441	return atsReplyFailure(pThis, pInst, pPktHdr, "BAD SIZE", VERR_INVALID_PARAMETER, "Expected at %zu bytes, got %u (opcode '%.8s')",
442	cb, pPktHdr->cb, pPktHdr->achOpcode);
443	}
444
445	/**
446	* Deals with a unknown command.
447	*
448	* @returns IPRT status code of the send.
449	* @param pThis The ATS instance.
450	* @param pInst The opaque ATS instance structure.
451	* @param pPktHdr The packet to reply to.
452	*/
453	static int atsReplyUnknown(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr)
454	{
455	return atsReplyFailure(pThis, pInst, pPktHdr, "UNKNOWN ", VERR_NOT_FOUND, "Opcode '%.8s' is not known", pPktHdr->achOpcode);
456	}
457
458	/**
459	* Deals with a command sent in an invalid client state.
460	*
461	* @returns IPRT status code of the send.
462	* @param pThis The ATS instance.
463	* @param pInst The opaque ATS instance structure.
464	* @param pPktHdr The packet containing the unterminated string.
465	*/
466	static int atsReplyInvalidState(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr)
467	{
468	return atsReplyFailure(pThis, pInst, pPktHdr, "INVSTATE", VERR_INVALID_STATE, "Opcode '%.8s' is not supported at client state '%s",
469	pPktHdr->achOpcode, atsClientStateStringify(pInst->enmState));
470	}
471
472	/**
473	* Verifies and acknowledges a "BYE" request.
474	*
475	* @returns IPRT status code.
476	* @param pThis The ATS instance.
477	* @param pInst The opaque ATS instance structure.
478	* @param pPktHdr The bye packet.
479	*/
480	static int atsDoBye(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr)
481	{
482	int rc;
483	if (pPktHdr->cb == sizeof(ATSPKTHDR))
484	{
485	if (pThis->Callbacks.pfnBye)
486	{
487	rc = pThis->Callbacks.pfnBye(pThis->Callbacks.pvUser);
488	}
489	else
490	rc = VINF_SUCCESS;
491
492	if (RT_SUCCESS(rc))
493	{
494	rc = atsReplyAck(pThis, pInst, pPktHdr);
495	}
496	else
497	rc = atsReplyRC(pThis, pInst, pPktHdr, rc, "Disconnecting client failed");
498	}
499	else
500	rc = atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTHDR));
501	return rc;
502	}
503
504	/**
505	* Verifies and acknowledges a "HOWDY" request.
506	*
507	* @returns IPRT status code.
508	* @param pThis The ATS instance.
509	* @param pInst The opaque ATS instance structure.
510	* @param pPktHdr The howdy packet.
511	*/
512	static int atsDoHowdy(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr)
513	{
514	int rc = VINF_SUCCESS;
515
516	if (pPktHdr->cb != sizeof(ATSPKTREQHOWDY))
517	return atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTREQHOWDY));
518
519	if (pInst->enmState != ATSCLIENTSTATE_INITIALISING)
520	return atsReplyInvalidState(pThis, pInst, pPktHdr);
521
522	PATSPKTREQHOWDY pReq = (PATSPKTREQHOWDY)pPktHdr;
523
524	if (pReq->uVersion != ATS_PROTOCOL_VS)
525	return atsReplyRC(pThis, pInst, pPktHdr, VERR_VERSION_MISMATCH, "The given version %#x is not supported", pReq->uVersion);
526
527	ATSPKTREPHOWDY Rep;
528	RT_ZERO(Rep);
529
530	Rep.uVersion = ATS_PROTOCOL_VS;
531
532	rc = atsReplyInternal(pThis, pInst, &Rep.Hdr, "ACK ", sizeof(Rep) - sizeof(ATSPKTHDR));
533	if (RT_SUCCESS(rc))
534	{
535	pThis->pTransport->pfnNotifyHowdy(pThis->pTransportInst, pInst->pTransportClient);
536
537	if (pThis->Callbacks.pfnHowdy)
538	rc = pThis->Callbacks.pfnHowdy(pThis->Callbacks.pvUser);
539
540	if (RT_SUCCESS(rc))
541	pInst->enmState = ATSCLIENTSTATE_READY;
542	}
543
544	return rc;
545	}
546
547	/**
548	* Verifies and acknowledges a "TSET BEG" request.
549	*
550	* @returns IPRT status code.
551	* @param pThis The ATS instance.
552	* @param pInst The opaque ATS instance structure.
553	* @param pPktHdr The test set begin packet.
554	*/
555	static int atsDoTestSetBegin(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr)
556	{
557	if (pPktHdr->cb != sizeof(ATSPKTREQTSETBEG))
558	return atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTREQTSETBEG));
559
560	PATSPKTREQTSETBEG pReq = (PATSPKTREQTSETBEG)pPktHdr;
561
562	int rc = VINF_SUCCESS;
563
564	if (pThis->Callbacks.pfnTestSetBegin)
565	rc = pThis->Callbacks.pfnTestSetBegin(pThis->Callbacks.pvUser, pReq->szTag);
566
567	if (RT_SUCCESS(rc))
568	rc = atsReplyAck(pThis, pInst, pPktHdr);
569	else
570	rc = atsReplyRC(pThis, pInst, pPktHdr, rc, "Beginning test set failed");
571	return rc;
572	}
573
574	/**
575	* Verifies and acknowledges a "TSET END" request.
576	*
577	* @returns IPRT status code.
578	* @param pThis The ATS instance.
579	* @param pInst The opaque ATS instance structure.
580	* @param pPktHdr The test set end packet.
581	*/
582	static int atsDoTestSetEnd(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr)
583	{
584	if (pPktHdr->cb != sizeof(ATSPKTREQTSETEND))
585	return atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTREQTSETEND));
586
587	PATSPKTREQTSETEND pReq = (PATSPKTREQTSETEND)pPktHdr;
588
589	int rc = VINF_SUCCESS;
590
591	if (pThis->Callbacks.pfnTestSetEnd)
592	rc = pThis->Callbacks.pfnTestSetEnd(pThis->Callbacks.pvUser, pReq->szTag);
593
594	if (RT_SUCCESS(rc))
595	rc = atsReplyAck(pThis, pInst, pPktHdr);
596	else
597	rc = atsReplyRC(pThis, pInst, pPktHdr, rc, "Ending test set failed");
598	return rc;
599	}
600
601	/**
602	* Used by atsDoTestSetSend to wait for a reply ACK from the client.
603	*
604	* @returns VINF_SUCCESS on ACK, VERR_GENERAL_FAILURE on NACK,
605	* VERR_NET_NOT_CONNECTED on unknown response (sending a bable reply),
606	* or whatever atsRecvPkt returns.
607	* @param pThis The ATS instance.
608	* @param pInst The opaque ATS instance structure.
609	* @param pPktHdr The original packet (for future use).
610	*/
611	static int atsWaitForAck(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr)
612	{
613	RT_NOREF(pPktHdr);
614	/** @todo timeout? */
615	PATSPKTHDR pReply;
616	int rc = atsRecvPkt(pThis, pInst, &pReply, false /fAutoRetryOnFailure/);
617	if (RT_SUCCESS(rc))
618	{
619	if (atsIsSameOpcode(pReply, "ACK"))
620	rc = VINF_SUCCESS;
621	else if (atsIsSameOpcode(pReply, "NACK"))
622	rc = VERR_GENERAL_FAILURE;
623	else
624	{
625	atsReplyBabble(pThis, pInst, "BABBLE ");
626	rc = VERR_NET_NOT_CONNECTED;
627	}
628	RTMemFree(pReply);
629	}
630	return rc;
631	}
632
633	/**
634	* Verifies and acknowledges a "TSET SND" request.
635	*
636	* @returns IPRT status code.
637	* @param pThis The ATS instance.
638	* @param pInst The opaque ATS instance structure.
639	* @param pPktHdr The test set end packet.
640	*/
641	static int atsDoTestSetSend(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr)
642	{
643	if (pPktHdr->cb != sizeof(ATSPKTREQTSETSND))
644	return atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTREQTSETSND));
645
646	PATSPKTREQTSETSND pReq = (PATSPKTREQTSETSND)pPktHdr;
647
648	int rc = VINF_SUCCESS;
649
650	if (!pThis->Callbacks.pfnTestSetSendRead)
651	return atsReplyRC(pThis, pInst, pPktHdr, VERR_NOT_SUPPORTED, "Sending test set not implemented");
652
653	if (pThis->Callbacks.pfnTestSetSendBegin)
654	{
655	rc = pThis->Callbacks.pfnTestSetSendBegin(pThis->Callbacks.pvUser, pReq->szTag);
656	if (RT_FAILURE(rc))
657	return atsReplyRC(pThis, pInst, pPktHdr, rc, "Beginning sending test set '%s' failed", pReq->szTag);
658	}
659
660	for (;;)
661	{
662	uint32_t uMyCrc32 = RTCrc32Start();
663	struct
664	{
665	ATSPKTHDR Hdr;
666	uint32_t uCrc32;
667	char ab[_64K];
668	char abPadding[ATSPKT_ALIGNMENT];
669	} Pkt;
670	#ifdef DEBUG
671	RT_ZERO(Pkt);
672	#endif
673	size_t cbRead = 0;
674	rc = pThis->Callbacks.pfnTestSetSendRead(pThis->Callbacks.pvUser, pReq->szTag, &Pkt.ab, sizeof(Pkt.ab), &cbRead);
675	if ( RT_FAILURE(rc)
676	\|\| cbRead == 0)
677	{
678	if ( rc == VERR_EOF
679	\|\| (RT_SUCCESS(rc) && cbRead == 0))
680	{
681	Pkt.uCrc32 = RTCrc32Finish(uMyCrc32);
682	rc = atsReplyInternal(pThis, pInst, &Pkt.Hdr, "DATA EOF", sizeof(uint32_t) /* uCrc32 */);
683	if (RT_SUCCESS(rc))
684	rc = atsWaitForAck(pThis, pInst, &Pkt.Hdr);
685	}
686	else
687	rc = atsReplyRC(pThis, pInst, pPktHdr, rc, "Sending data for test set '%s' failed", pReq->szTag);
688	break;
689	}
690
691	uMyCrc32 = RTCrc32Process(uMyCrc32, &Pkt.ab[0], cbRead);
692	Pkt.uCrc32 = RTCrc32Finish(uMyCrc32);
693
694	Log2Func(("cbRead=%zu -> uCrc32=%#x\n", cbRead, Pkt.uCrc32));
695
696	Assert(cbRead <= sizeof(Pkt.ab));
697
698	rc = atsReplyInternal(pThis, pInst, &Pkt.Hdr, "DATA ", sizeof(uint32_t) /* uCrc32 */ + cbRead);
699	if (RT_FAILURE(rc))
700	break;
701
702	rc = atsWaitForAck(pThis, pInst, &Pkt.Hdr);
703	if (RT_FAILURE(rc))
704	break;
705	}
706
707	if (pThis->Callbacks.pfnTestSetSendEnd)
708	{
709	int rc2 = pThis->Callbacks.pfnTestSetSendEnd(pThis->Callbacks.pvUser, pReq->szTag);
710	if (RT_FAILURE(rc2))
711	return atsReplyRC(pThis, pInst, pPktHdr, rc2, "Ending sending test set '%s' failed", pReq->szTag);
712	}
713
714	return rc;
715	}
716
717	/**
718	* Verifies and processes a "TN PLY" request.
719	*
720	* @returns IPRT status code.
721	* @param pThis The ATS instance.
722	* @param pInst The opaque ATS instance structure.
723	* @param pPktHdr The packet header.
724	*/
725	static int atsDoTonePlay(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr)
726	{
727	if (pPktHdr->cb < sizeof(ATSPKTREQTONEPLAY))
728	return atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTREQTONEPLAY));
729
730	if (pInst->enmState != ATSCLIENTSTATE_READY)
731	return atsReplyInvalidState(pThis, pInst, pPktHdr);
732
733	int rc = VINF_SUCCESS;
734
735	PATSPKTREQTONEPLAY pReq = (PATSPKTREQTONEPLAY)pPktHdr;
736
737	if (pThis->Callbacks.pfnTonePlay)
738	rc = pThis->Callbacks.pfnTonePlay(pThis->Callbacks.pvUser, &pReq->ToneParms);
739
740	if (RT_SUCCESS(rc))
741	rc = atsReplyAck(pThis, pInst, pPktHdr);
742	else
743	rc = atsReplyRC(pThis, pInst, pPktHdr, rc, "Playing test tone failed");
744	return rc;
745	}
746
747	/**
748	* Verifies and processes a "TN REC" request.
749	*
750	* @returns IPRT status code.
751	* @param pThis The ATS instance.
752	* @param pInst The opaque ATS instance structure.
753	* @param pPktHdr The packet header.
754	*/
755	static int atsDoToneRecord(PATSSERVER pThis, PATSCLIENTINST pInst, PATSPKTHDR pPktHdr)
756	{
757	if (pPktHdr->cb < sizeof(ATSPKTREQTONEREC))
758	return atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTREQTONEREC));
759
760	if (pInst->enmState != ATSCLIENTSTATE_READY)
761	return atsReplyInvalidState(pThis, pInst, pPktHdr);
762
763	int rc = VINF_SUCCESS;
764
765	PATSPKTREQTONEREC pReq = (PATSPKTREQTONEREC)pPktHdr;
766
767	if (pThis->Callbacks.pfnToneRecord)
768	rc = pThis->Callbacks.pfnToneRecord(pThis->Callbacks.pvUser, &pReq->ToneParms);
769
770	if (RT_SUCCESS(rc))
771	rc = atsReplyAck(pThis, pInst, pPktHdr);
772	else
773	rc = atsReplyRC(pThis, pInst, pPktHdr, rc, "Recording test tone failed");
774	return rc;
775	}
776
777	/**
778	* Main request processing routine for each client.
779	*
780	* @returns IPRT status code.
781	* @param pThis The ATS instance.
782	* @param pInst The ATS client structure sending the request.
783	* @param pfDisconnect Where to return whether to disconnect the client on success or not.
784	*/
785	static int atsClientReqProcess(PATSSERVER pThis, PATSCLIENTINST pInst, bool *pfDisconnect)
786	{
787	LogRelFlowFuncEnter();
788
789	/*
790	* Read client command packet and process it.
791	*/
792	PATSPKTHDR pPktHdr = NULL;
793	int rc = atsRecvPkt(pThis, pInst, &pPktHdr, true /fAutoRetryOnFailure/);
794	if (RT_FAILURE(rc))
795	return rc;
796
797	/*
798	* Do a string switch on the opcode bit.
799	*/
800	/* Connection: */
801	if ( atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_HOWDY))
802	rc = atsDoHowdy(pThis, pInst, pPktHdr);
803	else if (atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_BYE))
804	{
805	rc = atsDoBye(pThis, pInst, pPktHdr);
806	if (RT_SUCCESS(rc))
807	*pfDisconnect = true;
808	}
809	/* Test set handling: */
810	else if (atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_TESTSET_BEGIN))
811	rc = atsDoTestSetBegin(pThis, pInst, pPktHdr);
812	else if (atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_TESTSET_END))
813	rc = atsDoTestSetEnd(pThis, pInst, pPktHdr);
814	else if (atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_TESTSET_SEND))
815	rc = atsDoTestSetSend(pThis, pInst, pPktHdr);
816	/* Audio testing: */
817	else if (atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_TONE_PLAY))
818	rc = atsDoTonePlay(pThis, pInst, pPktHdr);
819	else if (atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_TONE_RECORD))
820	rc = atsDoToneRecord(pThis, pInst, pPktHdr);
821	/* Misc: */
822	else
823	rc = atsReplyUnknown(pThis, pInst, pPktHdr);
824
825	RTMemFree(pPktHdr);
826
827	LogRelFlowFuncLeaveRC(rc);
828	return rc;
829	}
830
831	/**
832	* Disconnects a client.
833	*
834	* @returns VBox status code.
835	* @param pThis The ATS instance.
836	* @param pInst The ATS client to disconnect.
837	*/
838	static int atsClientDisconnect(PATSSERVER pThis, PATSCLIENTINST pInst)
839	{
840	AssertReturn(pInst->enmState != ATSCLIENTSTATE_DESTROYING, VERR_WRONG_ORDER);
841
842	pInst->enmState = ATSCLIENTSTATE_DESTROYING;
843
844	if ( pThis->pTransportInst
845	&& pInst->pTransportClient)
846	{
847	if (pThis->pTransport->pfnNotifyBye)
848	pThis->pTransport->pfnNotifyBye(pThis->pTransportInst, pInst->pTransportClient);
849
850	pThis->pTransport->pfnDisconnect(pThis->pTransportInst, pInst->pTransportClient);
851	/* Pointer is now invalid due to the call above. */
852	pInst->pTransportClient = NULL;
853	}
854
855	return VINF_SUCCESS;
856	}
857
858	/**
859	* Free's (destroys) a client instance.
860	*
861	* @param pInst The opaque ATS instance structure.
862	*/
863	static void atsClientFree(PATSCLIENTINST pInst)
864	{
865	if (!pInst)
866	return;
867
868	/* Make sure that there is no transport client associated with it anymore. */
869	AssertReturnVoid(pInst->enmState == ATSCLIENTSTATE_DESTROYING);
870	AssertReturnVoid(pInst->pTransportClient == NULL);
871
872	if (pInst->pszHostname)
873	{
874	RTStrFree(pInst->pszHostname);
875	pInst->pszHostname = NULL;
876	}
877
878	RTMemFree(pInst);
879	pInst = NULL;
880	}
881
882	/**
883	* The main thread worker serving the clients.
884	*/
885	static DECLCALLBACK(int) atsClientWorker(RTTHREAD hThread, void *pvUser)
886	{
887	RT_NOREF(hThread);
888
889	PATSSERVER pThis = (PATSSERVER)pvUser;
890	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
891
892	unsigned cClientsMax = 0;
893	unsigned cClientsCur = 0;
894	PATSCLIENTINST *papInsts = NULL;
895
896	/* Add the pipe to the poll set. */
897	int rc = RTPollSetAddPipe(pThis->hPollSet, pThis->hPipeR, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR, 0);
898	if (RT_SUCCESS(rc))
899	{
900	while (!pThis->fTerminate)
901	{
902	uint32_t fEvts;
903	uint32_t uId;
904	rc = RTPoll(pThis->hPollSet, RT_INDEFINITE_WAIT, &fEvts, &uId);
905	LogRelFlowFunc(("RTPoll(...) returned fEvts=#%x, uId=%RU32 -> %Rrc\n", fEvts, uId, rc));
906	if (RT_SUCCESS(rc))
907	{
908	if (uId == 0)
909	{
910	if (fEvts & RTPOLL_EVT_ERROR)
911	break;
912
913	/* We got woken up because of a new client. */
914	Assert(fEvts & RTPOLL_EVT_READ);
915
916	uint8_t bRead;
917	size_t cbRead = 0;
918	rc = RTPipeRead(pThis->hPipeR, &bRead, 1, &cbRead);
919	AssertRC(rc);
920
921	RTCritSectEnter(&pThis->CritSectClients);
922	/* Walk the list and add all new clients. */
923	PATSCLIENTINST pIt, pItNext;
924	RTListForEachSafe(&pThis->LstClientsNew, pIt, pItNext, ATSCLIENTINST, NdLst)
925	{
926	RTListNodeRemove(&pIt->NdLst);
927	Assert(cClientsCur <= cClientsMax);
928	if (cClientsCur == cClientsMax)
929	{
930	/* Realloc to accommodate for the new clients. */
931	PATSCLIENTINST papInstsNew = (PATSCLIENTINST )RTMemReallocZ(papInsts, cClientsMax * sizeof(PATSCLIENTINST), (cClientsMax + 10) * sizeof(PATSCLIENTINST));
932	if (RT_LIKELY(papInstsNew))
933	{
934	cClientsMax += 10;
935	papInsts = papInstsNew;
936	}
937	}
938	if (cClientsCur < cClientsMax)
939	{
940	/* Find a free slot in the client array. */
941	unsigned idxSlt = 0;
942	while ( idxSlt < cClientsMax
943	&& papInsts[idxSlt] != NULL)
944	idxSlt++;
945
946	rc = pThis->pTransport->pfnPollSetAdd(pThis->pTransportInst, pThis->hPollSet, pIt->pTransportClient, idxSlt + 1);
947	if (RT_SUCCESS(rc))
948	{
949	cClientsCur++;
950	papInsts[idxSlt] = pIt;
951	}
952	else
953	{
954	atsClientDisconnect(pThis, pIt);
955	atsClientFree(pIt);
956	pIt = NULL;
957	}
958	}
959	else
960	{
961	atsClientDisconnect(pThis, pIt);
962	atsClientFree(pIt);
963	pIt = NULL;
964	}
965	}
966	RTCritSectLeave(&pThis->CritSectClients);
967	}
968	else
969	{
970	bool fDisconnect = false;
971
972	/* Client sends a request, pick the right client and process it. */
973	PATSCLIENTINST pInst = papInsts[uId - 1];
974	AssertPtr(pInst);
975	if (fEvts & RTPOLL_EVT_READ)
976	rc = atsClientReqProcess(pThis, pInst, &fDisconnect);
977
978	if ( (fEvts & RTPOLL_EVT_ERROR)
979	\|\| RT_FAILURE(rc)
980	\|\| fDisconnect)
981	{
982	/* Close connection and remove client from array. */
983	int rc2 = pThis->pTransport->pfnPollSetRemove(pThis->pTransportInst, pThis->hPollSet, pInst->pTransportClient, uId);
984	AssertRC(rc2);
985
986	atsClientDisconnect(pThis, pInst);
987	atsClientFree(pInst);
988	pInst = NULL;
989
990	papInsts[uId - 1] = NULL;
991	Assert(cClientsCur);
992	cClientsCur--;
993	}
994	}
995	}
996	}
997	}
998
999	if (papInsts)
1000	{
1001	for (size_t i = 0; i < cClientsMax; i++)
1002	RTMemFree(papInsts[i]);
1003	RTMemFree(papInsts);
1004	}
1005
1006	return rc;
1007	}
1008
1009	/**
1010	* The main thread waiting for new client connections.
1011	*
1012	* @returns VBox status code.
1013	*/
1014	static DECLCALLBACK(int) atsMainThread(RTTHREAD hThread, void *pvUser)
1015	{
1016	RT_NOREF(hThread);
1017
1018	LogRelFlowFuncEnter();
1019
1020	PATSSERVER pThis = (PATSSERVER)pvUser;
1021	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1022
1023	int rc = RTThreadUserSignal(hThread);
1024	AssertRCReturn(rc, rc);
1025
1026	while (!pThis->fTerminate)
1027	{
1028	/*
1029	* Wait for new connection and spin off a new thread
1030	* for every new client.
1031	*/
1032	bool fFromServer;
1033	PATSTRANSPORTCLIENT pTransportClient;
1034	rc = pThis->pTransport->pfnWaitForConnect(pThis->pTransportInst, 1000 /* msTimeout */, &fFromServer, &pTransportClient);
1035	if (RT_FAILURE(rc))
1036	continue;
1037
1038	/*
1039	* New connection, create new client structure and spin off
1040	* the request handling thread.
1041	*/
1042	PATSCLIENTINST pInst = (PATSCLIENTINST)RTMemAllocZ(sizeof(ATSCLIENTINST));
1043	if (RT_LIKELY(pInst))
1044	{
1045	pInst->enmState = ATSCLIENTSTATE_INITIALISING;
1046	pInst->pTransportClient = pTransportClient;
1047	pInst->pszHostname = NULL;
1048
1049	/* Add client to the new list and inform the worker thread. */
1050	RTCritSectEnter(&pThis->CritSectClients);
1051	RTListAppend(&pThis->LstClientsNew, &pInst->NdLst);
1052	RTCritSectLeave(&pThis->CritSectClients);
1053
1054	size_t cbWritten = 0;
1055	rc = RTPipeWrite(pThis->hPipeW, "", 1, &cbWritten);
1056	if (RT_FAILURE(rc))
1057	LogRelFunc(("Failed to inform worker thread of a new client, rc=%Rrc\n", rc));
1058	}
1059	else
1060	{
1061	LogRelFunc(("Creating new client structure failed with out of memory error\n"));
1062	pThis->pTransport->pfnNotifyBye(pThis->pTransportInst, pTransportClient);
1063	rc = VERR_NO_MEMORY;
1064	break; /* This is fatal, break out of the loop. */
1065	}
1066
1067	if (RT_SUCCESS(rc))
1068	{
1069	LogRelFunc(("New connection established (%s)\n", fFromServer ? "from server" : "as client"));
1070
1071	/**
1072	* If the new client is not from our server but from a remote server (also called a reverse connection),
1073	* exit this loop and stop trying to connect to the remote server.
1074	*
1075	* Otherwise we would connect lots and lots of clients without any real use.
1076	*
1077	** @todo Improve this handling -- there might be a better / more elegant solution.
1078	*/
1079	if (!fFromServer)
1080	break;
1081	}
1082	}
1083
1084	LogRelFlowFuncLeaveRC(rc);
1085	return rc;
1086	}
1087
1088	/**
1089	* Initializes an ATS instance.
1090	*
1091	* @note This does not start the server!
1092	*
1093	* @returns VBox status code.
1094	* @param pThis The ATS instance.
1095	* @param pCallbacks The callbacks table to use.
1096	*/
1097	int AudioTestSvcInit(PATSSERVER pThis, PCATSCALLBACKS pCallbacks)
1098	{
1099	LogRelFlowFuncEnter();
1100
1101	RT_BZERO(pThis, sizeof(ATSSERVER));
1102
1103	pThis->hPipeR = NIL_RTPIPE;
1104	pThis->hPipeW = NIL_RTPIPE;
1105
1106	RTListInit(&pThis->LstClientsNew);
1107
1108	/* Copy callback table. */
1109	memcpy(&pThis->Callbacks, pCallbacks, sizeof(ATSCALLBACKS));
1110
1111	int rc = RTCritSectInit(&pThis->CritSectClients);
1112	if (RT_SUCCESS(rc))
1113	{
1114	rc = RTPollSetCreate(&pThis->hPollSet);
1115	if (RT_SUCCESS(rc))
1116	{
1117	rc = RTPipeCreate(&pThis->hPipeR, &pThis->hPipeW, 0);
1118	if (RT_SUCCESS(rc))
1119	{
1120	/*
1121	* The default transporter is the first one.
1122	*/
1123	pThis->pTransport = g_apTransports[0]; /** @todo Make this dynamic. */
1124
1125	rc = pThis->pTransport->pfnCreate(&pThis->pTransportInst);
1126	if (RT_SUCCESS(rc))
1127	return VINF_SUCCESS;
1128
1129	RTPipeClose(pThis->hPipeR);
1130	RTPipeClose(pThis->hPipeW);
1131	}
1132	else
1133	LogRel(("Creating communications pipe failed with %Rrc\n", rc));
1134
1135	RTPollSetDestroy(pThis->hPollSet);
1136	}
1137	else
1138	LogRel(("Creating pollset failed with %Rrc\n", rc));
1139
1140	RTCritSectDelete(&pThis->CritSectClients);
1141	}
1142	else
1143	LogRel(("Creating critical section failed with %Rrc\n", rc));
1144
1145	if (RT_FAILURE(rc))
1146	LogRel(("Creating server failed with %Rrc\n", rc));
1147
1148	LogRelFlowFuncLeaveRC(rc);
1149	return rc;
1150	}
1151
1152	/**
1153	* Handles a command line option.
1154	*
1155	* @returns VBox status code.
1156	* @param pThis The ATS instance to handle option for.
1157	* @param ch Option (short) to handle.
1158	* @param pVal Option union to store the result in on success.
1159	*/
1160	int AudioTestSvcHandleOption(PATSSERVER pThis, int ch, PCRTGETOPTUNION pVal)
1161	{
1162	AssertPtrReturn(pThis->pTransport, VERR_WRONG_ORDER); /* Must be creatd first. */
1163	if (!pThis->pTransport->pfnOption)
1164	return VERR_GETOPT_UNKNOWN_OPTION;
1165	return pThis->pTransport->pfnOption(pThis->pTransportInst, ch, pVal);
1166	}
1167
1168	/**
1169	* Starts a formerly initialized ATS instance.
1170	*
1171	* @returns VBox status code.
1172	* @param pThis The ATS instance to start.
1173	*/
1174	int AudioTestSvcStart(PATSSERVER pThis)
1175	{
1176	LogRelFlowFuncEnter();
1177
1178	/* Spin off the thread serving connections. */
1179	int rc = RTThreadCreate(&pThis->hThreadServing, atsClientWorker, pThis, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE,
1180	"ATSCLWORK");
1181	if (RT_FAILURE(rc))
1182	{
1183	LogRel(("Creating the client worker thread failed with %Rrc\n", rc));
1184	return rc;
1185	}
1186
1187	rc = pThis->pTransport->pfnStart(pThis->pTransportInst);
1188	if (RT_SUCCESS(rc))
1189	{
1190	/* Spin off the connection thread. */
1191	rc = RTThreadCreate(&pThis->hThreadMain, atsMainThread, pThis, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE,
1192	"ATSMAIN");
1193	if (RT_SUCCESS(rc))
1194	{
1195	rc = RTThreadUserWait(pThis->hThreadMain, RT_MS_30SEC);
1196	if (RT_SUCCESS(rc))
1197	pThis->fStarted = true;
1198	}
1199	}
1200
1201	LogRelFlowFuncLeaveRC(rc);
1202	return rc;
1203	}
1204
1205	/**
1206	* Stops (shuts down) a formerly started ATS instance.
1207	*
1208	* @returns VBox status code.
1209	* @param pThis The ATS instance.
1210	*/
1211	int AudioTestSvcStop(PATSSERVER pThis)
1212	{
1213	if (!pThis->fStarted)
1214	return VINF_SUCCESS;
1215
1216	LogRelFlowFuncEnter();
1217
1218	ASMAtomicXchgBool(&pThis->fTerminate, true);
1219
1220	if (pThis->pTransport)
1221	pThis->pTransport->pfnStop(pThis->pTransportInst);
1222
1223	size_t cbWritten;
1224	int rc = RTPipeWrite(pThis->hPipeW, "", 1, &cbWritten);
1225	AssertRCReturn(rc, rc);
1226
1227	/* First close serving thread. */
1228	int rcThread;
1229	rc = RTThreadWait(pThis->hThreadServing, RT_MS_30SEC, &rcThread);
1230	if (RT_SUCCESS(rc))
1231	{
1232	rc = rcThread;
1233	if (RT_SUCCESS(rc))
1234	{
1235	/* Close the main thread last. */
1236	rc = RTThreadWait(pThis->hThreadMain, RT_MS_30SEC, &rcThread);
1237	if (RT_SUCCESS(rc))
1238	rc = rcThread;
1239
1240	if (rc == VERR_TCP_SERVER_DESTROYED)
1241	rc = VINF_SUCCESS;
1242	}
1243	}
1244
1245	if (RT_SUCCESS(rc))
1246	pThis->fStarted = false;
1247
1248	LogRelFlowFuncLeaveRC(rc);
1249	return rc;
1250	}
1251
1252	/**
1253	* Destroys an ATS instance, internal version.
1254	*
1255	* @returns VBox status code.
1256	* @param pThis ATS instance to destroy.
1257	*/
1258	static int audioTestSvcDestroyInternal(PATSSERVER pThis)
1259	{
1260	int rc = VINF_SUCCESS;
1261
1262	if (pThis->hPipeR != NIL_RTPIPE)
1263	{
1264	rc = RTPipeClose(pThis->hPipeR);
1265	AssertRCReturn(rc, rc);
1266	pThis->hPipeR = NIL_RTPIPE;
1267	}
1268
1269	if (pThis->hPipeW != NIL_RTPIPE)
1270	{
1271	rc = RTPipeClose(pThis->hPipeW);
1272	AssertRCReturn(rc, rc);
1273	pThis->hPipeW = NIL_RTPIPE;
1274	}
1275
1276	RTPollSetDestroy(pThis->hPollSet);
1277	pThis->hPollSet = NIL_RTPOLLSET;
1278
1279	PATSCLIENTINST pIt, pItNext;
1280	RTListForEachSafe(&pThis->LstClientsNew, pIt, pItNext, ATSCLIENTINST, NdLst)
1281	{
1282	RTListNodeRemove(&pIt->NdLst);
1283	atsClientDisconnect(pThis, pIt);
1284	atsClientFree(pIt);
1285	}
1286
1287	if (RTCritSectIsInitialized(&pThis->CritSectClients))
1288	{
1289	rc = RTCritSectDelete(&pThis->CritSectClients);
1290	AssertRCReturn(rc, rc);
1291	}
1292
1293	return rc;
1294	}
1295
1296	/**
1297	* Destroys an ATS instance.
1298	*
1299	* @returns VBox status code.
1300	* @param pThis ATS instance to destroy.
1301	*/
1302	int AudioTestSvcDestroy(PATSSERVER pThis)
1303	{
1304	LogRelFlowFuncEnter();
1305
1306	int rc = audioTestSvcDestroyInternal(pThis);
1307	if (RT_SUCCESS(rc))
1308	{
1309	if (pThis->pTransport)
1310	{
1311	if ( pThis->pTransport->pfnDestroy
1312	&& pThis->pTransportInst)
1313	{
1314	pThis->pTransport->pfnDestroy(pThis->pTransportInst);
1315	pThis->pTransportInst = NULL;
1316	}
1317	}
1318	}
1319
1320	LogRelFlowFuncLeaveRC(rc);
1321	return rc;
1322	}

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

source: vbox/trunk/src/VBox/Devices/Audio/AudioTestService.cpp@ 104389

Download in other formats: