UsbTestService.cpp@ 105374

Last change on this file since 105374 was 100207, checked in by vboxsync, 18 months ago
ValidationKit/UsbTestService: Fix harmless memory leak, bugref:3409
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 56.6 KB

Line
1	/* $Id: UsbTestService.cpp 100207 2023-06-19 14:20:27Z vboxsync $ */
2	/** @file
3	* UsbTestService - Remote USB test configuration and execution server.
4	*/
5
6	/*
7	* Copyright (C) 2010-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	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#define LOG_GROUP RTLOGGROUP_DEFAULT
42	#include <iprt/alloca.h>
43	#include <iprt/asm.h>
44	#include <iprt/assert.h>
45	#include <iprt/critsect.h>
46	#include <iprt/crc.h>
47	#include <iprt/ctype.h>
48	#include <iprt/dir.h>
49	#include <iprt/env.h>
50	#include <iprt/err.h>
51	#include <iprt/getopt.h>
52	#include <iprt/handle.h>
53	#include <iprt/initterm.h>
54	#include <iprt/json.h>
55	#include <iprt/list.h>
56	#include <iprt/log.h>
57	#include <iprt/mem.h>
58	#include <iprt/message.h>
59	#include <iprt/param.h>
60	#include <iprt/path.h>
61	#include <iprt/pipe.h>
62	#include <iprt/poll.h>
63	#include <iprt/process.h>
64	#include <iprt/stream.h>
65	#include <iprt/string.h>
66	#include <iprt/thread.h>
67
68	#include "UsbTestServiceInternal.h"
69	#include "UsbTestServiceGadget.h"
70	#include "UsbTestServicePlatform.h"
71
72
73
74	/*********************************************************************************************************************************
75	* Structures and Typedefs *
76	*********************************************************************************************************************************/
77
78	#define UTS_USBIP_PORT_FIRST 3240
79	#define UTS_USBIP_PORT_LAST 3340
80
81	/**
82	* UTS client state.
83	*/
84	typedef enum UTSCLIENTSTATE
85	{
86	/** Invalid client state. */
87	UTSCLIENTSTATE_INVALID = 0,
88	/** Client is initialising, only the HOWDY and BYE packets are allowed. */
89	UTSCLIENTSTATE_INITIALISING,
90	/** Client is in fully cuntional state and ready to process all requests. */
91	UTSCLIENTSTATE_READY,
92	/** Client is destroying. */
93	UTSCLIENTSTATE_DESTROYING,
94	/** 32bit hack. */
95	UTSCLIENTSTATE_32BIT_HACK = 0x7fffffff
96	} UTSCLIENTSTATE;
97
98	/**
99	* UTS client instance.
100	*/
101	typedef struct UTSCLIENT
102	{
103	/** List node for new clients. */
104	RTLISTNODE NdLst;
105	/** The current client state. */
106	UTSCLIENTSTATE enmState;
107	/** Transport backend specific data. */
108	PUTSTRANSPORTCLIENT pTransportClient;
109	/** Client hostname. */
110	char *pszHostname;
111	/** Gadget host handle. */
112	UTSGADGETHOST hGadgetHost;
113	/** Handle fo the current configured gadget. */
114	UTSGADGET hGadget;
115	} UTSCLIENT;
116	/** Pointer to a UTS client instance. */
117	typedef UTSCLIENT *PUTSCLIENT;
118
119
120	/*********************************************************************************************************************************
121	* Global Variables *
122	*********************************************************************************************************************************/
123	/**
124	* Transport layers.
125	*/
126	static const PCUTSTRANSPORT g_apTransports[] =
127	{
128	&g_TcpTransport,
129	//&g_SerialTransport,
130	//&g_FileSysTransport,
131	//&g_GuestPropTransport,
132	//&g_TestDevTransport,
133	};
134
135	/** The select transport layer. */
136	static PCUTSTRANSPORT g_pTransport;
137	/** The config path. */
138	static char g_szCfgPath[RTPATH_MAX];
139	/** The scratch path. */
140	static char g_szScratchPath[RTPATH_MAX];
141	/** The default scratch path. */
142	static char g_szDefScratchPath[RTPATH_MAX];
143	/** The CD/DVD-ROM path. */
144	static char g_szCdRomPath[RTPATH_MAX];
145	/** The default CD/DVD-ROM path. */
146	static char g_szDefCdRomPath[RTPATH_MAX];
147	/** The operating system short name. */
148	static char g_szOsShortName[16];
149	/** The CPU architecture short name. */
150	static char g_szArchShortName[16];
151	/** The combined "OS.arch" name. */
152	static char g_szOsDotArchShortName[32];
153	/** The combined "OS/arch" name. */
154	static char g_szOsSlashArchShortName[32];
155	/** The executable suffix. */
156	static char g_szExeSuff[8];
157	/** The shell script suffix. */
158	static char g_szScriptSuff[8];
159	/** Whether to display the output of the child process or not. */
160	static bool g_fDisplayOutput = true;
161	/** Whether to terminate or not.
162	* @todo implement signals and stuff. */
163	static bool volatile g_fTerminate = false;
164	/** Configuration AST. */
165	static RTJSONVAL g_hCfgJson = NIL_RTJSONVAL;
166	/** Pipe for communicating with the serving thread about new clients. - read end */
167	static RTPIPE g_hPipeR;
168	/** Pipe for communicating with the serving thread about new clients. - write end */
169	static RTPIPE g_hPipeW;
170	/** Thread serving connected clients. */
171	static RTTHREAD g_hThreadServing;
172	/** Critical section protecting the list of new clients. */
173	static RTCRITSECT g_CritSectClients;
174	/** List of new clients waiting to be picked up by the client worker thread. */
175	static RTLISTANCHOR g_LstClientsNew;
176	/** First USB/IP port we can use. */
177	static uint16_t g_uUsbIpPortFirst = UTS_USBIP_PORT_FIRST;
178	/** Last USB/IP port we can use. */
179	static uint16_t g_uUsbIpPortLast = UTS_USBIP_PORT_LAST;
180	/** Next free port. */
181	static uint16_t g_uUsbIpPortNext = UTS_USBIP_PORT_FIRST;
182
183
184
185	/**
186	* Returns the string represenation of the given state.
187	*/
188	static const char *utsClientStateStringify(UTSCLIENTSTATE enmState)
189	{
190	switch (enmState)
191	{
192	case UTSCLIENTSTATE_INVALID:
193	return "INVALID";
194	case UTSCLIENTSTATE_INITIALISING:
195	return "INITIALISING";
196	case UTSCLIENTSTATE_READY:
197	return "READY";
198	case UTSCLIENTSTATE_DESTROYING:
199	return "DESTROYING";
200	case UTSCLIENTSTATE_32BIT_HACK:
201	default:
202	break;
203	}
204
205	AssertMsgFailed(("Unknown state %#x\n", enmState));
206	return "UNKNOWN";
207	}
208
209	/**
210	* Calculates the checksum value, zero any padding space and send the packet.
211	*
212	* @returns IPRT status code.
213	* @param pClient The UTS client structure.
214	* @param pPkt The packet to send. Must point to a correctly
215	* aligned buffer.
216	*/
217	static int utsSendPkt(PUTSCLIENT pClient, PUTSPKTHDR pPkt)
218	{
219	Assert(pPkt->cb >= sizeof(*pPkt));
220	pPkt->uCrc32 = RTCrc32(pPkt->achOpcode, pPkt->cb - RT_UOFFSETOF(UTSPKTHDR, achOpcode));
221	if (pPkt->cb != RT_ALIGN_32(pPkt->cb, UTSPKT_ALIGNMENT))
222	memset((uint8_t *)pPkt + pPkt->cb, '\0', RT_ALIGN_32(pPkt->cb, UTSPKT_ALIGNMENT) - pPkt->cb);
223
224	Log(("utsSendPkt: cb=%#x opcode=%.8s\n", pPkt->cb, pPkt->achOpcode));
225	Log2(("%.*Rhxd\n", RT_MIN(pPkt->cb, 256), pPkt));
226	int rc = g_pTransport->pfnSendPkt(pClient->pTransportClient, pPkt);
227	while (RT_UNLIKELY(rc == VERR_INTERRUPTED) && !g_fTerminate)
228	rc = g_pTransport->pfnSendPkt(pClient->pTransportClient, pPkt);
229	if (RT_FAILURE(rc))
230	Log(("utsSendPkt: rc=%Rrc\n", rc));
231
232	return rc;
233	}
234
235	/**
236	* Sends a babble reply and disconnects the client (if applicable).
237	*
238	* @param pClient The UTS client structure.
239	* @param pszOpcode The BABBLE opcode.
240	*/
241	static void utsReplyBabble(PUTSCLIENT pClient, const char *pszOpcode)
242	{
243	UTSPKTHDR Reply;
244	Reply.cb = sizeof(Reply);
245	Reply.uCrc32 = 0;
246	memcpy(Reply.achOpcode, pszOpcode, sizeof(Reply.achOpcode));
247
248	g_pTransport->pfnBabble(pClient->pTransportClient, &Reply, 20*1000);
249	}
250
251	/**
252	* Receive and validate a packet.
253	*
254	* Will send bable responses to malformed packets that results in a error status
255	* code.
256	*
257	* @returns IPRT status code.
258	* @param pClient The UTS client structure.
259	* @param ppPktHdr Where to return the packet on success. Free
260	* with RTMemFree.
261	* @param fAutoRetryOnFailure Whether to retry on error.
262	*/
263	static int utsRecvPkt(PUTSCLIENT pClient, PPUTSPKTHDR ppPktHdr, bool fAutoRetryOnFailure)
264	{
265	for (;;)
266	{
267	PUTSPKTHDR pPktHdr;
268	int rc = g_pTransport->pfnRecvPkt(pClient->pTransportClient, &pPktHdr);
269	if (RT_SUCCESS(rc))
270	{
271	/* validate the packet. */
272	if ( pPktHdr->cb >= sizeof(UTSPKTHDR)
273	&& pPktHdr->cb < UTSPKT_MAX_SIZE)
274	{
275	Log2(("utsRecvPkt: pPktHdr=%p cb=%#x crc32=%#x opcode=%.8s\n"
276	"%.*Rhxd\n",
277	pPktHdr, pPktHdr->cb, pPktHdr->uCrc32, pPktHdr->achOpcode, RT_MIN(pPktHdr->cb, 256), pPktHdr));
278	uint32_t uCrc32Calc = pPktHdr->uCrc32 != 0
279	? RTCrc32(&pPktHdr->achOpcode[0], pPktHdr->cb - RT_UOFFSETOF(UTSPKTHDR, achOpcode))
280	: 0;
281	if (pPktHdr->uCrc32 == uCrc32Calc)
282	{
283	AssertCompileMemberSize(UTSPKTHDR, achOpcode, 8);
284	if ( RT_C_IS_UPPER(pPktHdr->achOpcode[0])
285	&& RT_C_IS_UPPER(pPktHdr->achOpcode[1])
286	&& (RT_C_IS_UPPER(pPktHdr->achOpcode[2]) \|\| pPktHdr->achOpcode[2] == ' ')
287	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[3]) \|\| pPktHdr->achOpcode[3] == ' ')
288	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[4]) \|\| pPktHdr->achOpcode[4] == ' ')
289	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[5]) \|\| pPktHdr->achOpcode[5] == ' ')
290	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[6]) \|\| pPktHdr->achOpcode[6] == ' ')
291	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[7]) \|\| pPktHdr->achOpcode[7] == ' ')
292	)
293	{
294	Log(("utsRecvPkt: cb=%#x opcode=%.8s\n", pPktHdr->cb, pPktHdr->achOpcode));
295	*ppPktHdr = pPktHdr;
296	return rc;
297	}
298
299	rc = VERR_IO_BAD_COMMAND;
300	}
301	else
302	{
303	Log(("utsRecvPkt: cb=%#x opcode=%.8s crc32=%#x actual=%#x\n",
304	pPktHdr->cb, pPktHdr->achOpcode, pPktHdr->uCrc32, uCrc32Calc));
305	rc = VERR_IO_CRC;
306	}
307	}
308	else
309	rc = VERR_IO_BAD_LENGTH;
310
311	/* Send babble reply and disconnect the client if the transport is
312	connection oriented. */
313	if (rc == VERR_IO_BAD_LENGTH)
314	utsReplyBabble(pClient, "BABBLE L");
315	else if (rc == VERR_IO_CRC)
316	utsReplyBabble(pClient, "BABBLE C");
317	else if (rc == VERR_IO_BAD_COMMAND)
318	utsReplyBabble(pClient, "BABBLE O");
319	else
320	utsReplyBabble(pClient, "BABBLE ");
321	RTMemFree(pPktHdr);
322	}
323
324	/* Try again or return failure? */
325	if ( g_fTerminate
326	\|\| rc != VERR_INTERRUPTED
327	\|\| !fAutoRetryOnFailure
328	)
329	{
330	Log(("utsRecvPkt: rc=%Rrc\n", rc));
331	return rc;
332	}
333	}
334	}
335
336	/**
337	* Make a simple reply, only status opcode.
338	*
339	* @returns IPRT status code of the send.
340	* @param pClient The UTS client structure.
341	* @param pReply The reply packet.
342	* @param pszOpcode The status opcode. Exactly 8 chars long, padd
343	* with space.
344	* @param cbExtra Bytes in addition to the header.
345	*/
346	static int utsReplyInternal(PUTSCLIENT pClient, PUTSPKTSTS pReply, const char *pszOpcode, size_t cbExtra)
347	{
348	/* copy the opcode, don't be too strict in case of a padding screw up. */
349	size_t cchOpcode = strlen(pszOpcode);
350	if (RT_LIKELY(cchOpcode == sizeof(pReply->Hdr.achOpcode)))
351	memcpy(pReply->Hdr.achOpcode, pszOpcode, sizeof(pReply->Hdr.achOpcode));
352	else
353	{
354	Assert(cchOpcode == sizeof(pReply->Hdr.achOpcode));
355	while (cchOpcode > 0 && pszOpcode[cchOpcode - 1] == ' ')
356	cchOpcode--;
357	AssertMsgReturn(cchOpcode < sizeof(pReply->Hdr.achOpcode), ("%d/'%.8s'\n", cchOpcode, pszOpcode), VERR_INTERNAL_ERROR_4);
358	memcpy(pReply->Hdr.achOpcode, pszOpcode, cchOpcode);
359	memset(&pReply->Hdr.achOpcode[cchOpcode], ' ', sizeof(pReply->Hdr.achOpcode) - cchOpcode);
360	}
361
362	pReply->Hdr.cb = (uint32_t)sizeof(UTSPKTSTS) + (uint32_t)cbExtra;
363	pReply->Hdr.uCrc32 = 0;
364
365	return utsSendPkt(pClient, &pReply->Hdr);
366	}
367
368	/**
369	* Make a simple reply, only status opcode.
370	*
371	* @returns IPRT status code of the send.
372	* @param pClient The UTS client structure.
373	* @param pPktHdr The original packet (for future use).
374	* @param pszOpcode The status opcode. Exactly 8 chars long, padd
375	* with space.
376	*/
377	static int utsReplySimple(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr, const char *pszOpcode)
378	{
379	UTSPKTSTS Pkt;
380
381	RT_ZERO(Pkt);
382	Pkt.rcReq = VINF_SUCCESS;
383	Pkt.cchStsMsg = 0;
384	NOREF(pPktHdr);
385	return utsReplyInternal(pClient, &Pkt, pszOpcode, 0);
386	}
387
388	/**
389	* Acknowledges a packet with success.
390	*
391	* @returns IPRT status code of the send.
392	* @param pClient The UTS client structure.
393	* @param pPktHdr The original packet (for future use).
394	*/
395	static int utsReplyAck(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
396	{
397	return utsReplySimple(pClient, pPktHdr, "ACK ");
398	}
399
400	/**
401	* Replies with a failure.
402	*
403	* @returns IPRT status code of the send.
404	* @param pClient The UTS client structure.
405	* @param pPktHdr The original packet (for future use).
406	* @param rcReq Status code.
407	* @param pszOpcode The status opcode. Exactly 8 chars long, padd
408	* with space.
409	* @param rcReq The status code of the request.
410	* @param pszDetailFmt Longer description of the problem (format string).
411	* @param va Format arguments.
412	*/
413	static int utsReplyFailureV(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr, const char pszOpcode, int rcReq, const char pszDetailFmt, va_list va)
414	{
415	NOREF(pPktHdr);
416	union
417	{
418	UTSPKTSTS Hdr;
419	char ach[256];
420	} uPkt;
421
422	RT_ZERO(uPkt);
423	size_t cchDetail = RTStrPrintfV(&uPkt.ach[sizeof(UTSPKTSTS)],
424	sizeof(uPkt) - sizeof(UTSPKTSTS),
425	pszDetailFmt, va);
426	uPkt.Hdr.rcReq = rcReq;
427	uPkt.Hdr.cchStsMsg = cchDetail;
428	return utsReplyInternal(pClient, &uPkt.Hdr, pszOpcode, cchDetail + 1);
429	}
430
431	/**
432	* Replies with a failure.
433	*
434	* @returns IPRT status code of the send.
435	* @param pClient The UTS client structure.
436	* @param pPktHdr The original packet (for future use).
437	* @param pszOpcode The status opcode. Exactly 8 chars long, padd
438	* with space.
439	* @param rcReq Status code.
440	* @param pszDetailFmt Longer description of the problem (format string).
441	* @param ... Format arguments.
442	*/
443	static int utsReplyFailure(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr, const char pszOpcode, int rcReq, const char pszDetailFmt, ...)
444	{
445	va_list va;
446	va_start(va, pszDetailFmt);
447	int rc = utsReplyFailureV(pClient, pPktHdr, pszOpcode, rcReq, pszDetailFmt, va);
448	va_end(va);
449	return rc;
450	}
451
452	/**
453	* Replies according to the return code.
454	*
455	* @returns IPRT status code of the send.
456	* @param pClient The UTS client structure.
457	* @param pPktHdr The packet to reply to.
458	* @param rcOperation The status code to report.
459	* @param pszOperationFmt The operation that failed. Typically giving the
460	* function call with important arguments.
461	* @param ... Arguments to the format string.
462	*/
463	static int utsReplyRC(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr, int rcOperation, const char *pszOperationFmt, ...)
464	{
465	if (RT_SUCCESS(rcOperation))
466	return utsReplyAck(pClient, pPktHdr);
467
468	char szOperation[128];
469	va_list va;
470	va_start(va, pszOperationFmt);
471	RTStrPrintfV(szOperation, sizeof(szOperation), pszOperationFmt, va);
472	va_end(va);
473
474	return utsReplyFailure(pClient, pPktHdr, "FAILED ", rcOperation, "%s failed with rc=%Rrc (opcode '%.8s')",
475	szOperation, rcOperation, pPktHdr->achOpcode);
476	}
477
478	#if 0 /* unused */
479	/**
480	* Signal a bad packet minum size.
481	*
482	* @returns IPRT status code of the send.
483	* @param pClient The UTS client structure.
484	* @param pPktHdr The packet to reply to.
485	* @param cbMin The minimum size.
486	*/
487	static int utsReplyBadMinSize(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr, size_t cbMin)
488	{
489	return utsReplyFailure(pClient, pPktHdr, "BAD SIZE", VERR_INVALID_PARAMETER, "Expected at least %zu bytes, got %u (opcode '%.8s')",
490	cbMin, pPktHdr->cb, pPktHdr->achOpcode);
491	}
492	#endif
493
494	/**
495	* Signal a bad packet exact size.
496	*
497	* @returns IPRT status code of the send.
498	* @param pClient The UTS client structure.
499	* @param pPktHdr The packet to reply to.
500	* @param cb The wanted size.
501	*/
502	static int utsReplyBadSize(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr, size_t cb)
503	{
504	return utsReplyFailure(pClient, pPktHdr, "BAD SIZE", VERR_INVALID_PARAMETER, "Expected at %zu bytes, got %u (opcode '%.8s')",
505	cb, pPktHdr->cb, pPktHdr->achOpcode);
506	}
507
508	#if 0 /* unused */
509	/**
510	* Deals with a command that isn't implemented yet.
511	* @returns IPRT status code of the send.
512	* @param pClient The UTS client structure.
513	* @param pPktHdr The packet which opcode isn't implemented.
514	*/
515	static int utsReplyNotImplemented(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
516	{
517	return utsReplyFailure(pClient, pPktHdr, "NOT IMPL", VERR_NOT_IMPLEMENTED, "Opcode '%.8s' is not implemented", pPktHdr->achOpcode);
518	}
519	#endif
520
521	/**
522	* Deals with a unknown command.
523	* @returns IPRT status code of the send.
524	* @param pClient The UTS client structure.
525	* @param pPktHdr The packet to reply to.
526	*/
527	static int utsReplyUnknown(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
528	{
529	return utsReplyFailure(pClient, pPktHdr, "UNKNOWN ", VERR_NOT_FOUND, "Opcode '%.8s' is not known", pPktHdr->achOpcode);
530	}
531
532	/**
533	* Deals with a command which contains an unterminated string.
534	*
535	* @returns IPRT status code of the send.
536	* @param pClient The UTS client structure.
537	* @param pPktHdr The packet containing the unterminated string.
538	*/
539	static int utsReplyBadStrTermination(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
540	{
541	return utsReplyFailure(pClient, pPktHdr, "BAD TERM", VERR_INVALID_PARAMETER, "Opcode '%.8s' contains an unterminated string", pPktHdr->achOpcode);
542	}
543
544	/**
545	* Deals with a command sent in an invalid client state.
546	*
547	* @returns IPRT status code of the send.
548	* @param pClient The UTS client structure.
549	* @param pPktHdr The packet containing the unterminated string.
550	*/
551	static int utsReplyInvalidState(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
552	{
553	return utsReplyFailure(pClient, pPktHdr, "INVSTATE", VERR_INVALID_STATE, "Opcode '%.8s' is not supported at client state '%s",
554	pPktHdr->achOpcode, utsClientStateStringify(pClient->enmState));
555	}
556
557	/**
558	* Parses an unsigned integer from the given value string.
559	*
560	* @returns IPRT status code.
561	* @retval VERR_OUT_OF_RANGE if the parsed value exceeds the given maximum.
562	* @param pszVal The value string.
563	* @param uMax The maximum value.
564	* @param pu64 Where to store the parsed number on success.
565	*/
566	static int utsDoGadgetCreateCfgParseUInt(const char pszVal, uint64_t uMax, uint64_t pu64)
567	{
568	int rc = RTStrToUInt64Ex(pszVal, NULL, 0, pu64);
569	if (RT_SUCCESS(rc))
570	{
571	if (*pu64 > uMax)
572	rc = VERR_OUT_OF_RANGE;
573	}
574
575	return rc;
576	}
577
578	/**
579	* Parses a signed integer from the given value string.
580	*
581	* @returns IPRT status code.
582	* @retval VERR_OUT_OF_RANGE if the parsed value exceeds the given range.
583	* @param pszVal The value string.
584	* @param iMin The minimum value.
585	* @param iMax The maximum value.
586	* @param pi64 Where to store the parsed number on success.
587	*/
588	static int utsDoGadgetCreateCfgParseInt(const char pszVal, int64_t iMin, int64_t iMax, int64_t pi64)
589	{
590	int rc = RTStrToInt64Ex(pszVal, NULL, 0, pi64);
591	if (RT_SUCCESS(rc))
592	{
593	if ( *pi64 < iMin
594	\|\| *pi64 > iMax)
595	rc = VERR_OUT_OF_RANGE;
596	}
597
598	return rc;
599	}
600
601	/**
602	* Parses the given config item and fills in the value according to the given type.
603	*
604	* @returns IPRT status code.
605	* @param pCfgItem The config item to parse.
606	* @param u32Type The config type.
607	* @param pszVal The value encoded as a string.
608	*/
609	static int utsDoGadgetCreateCfgParseItem(PUTSGADGETCFGITEM pCfgItem, uint32_t u32Type,
610	const char *pszVal)
611	{
612	int rc = VINF_SUCCESS;
613
614	switch (u32Type)
615	{
616	case UTSPKT_GDGT_CFG_ITEM_TYPE_BOOLEAN:
617	{
618	pCfgItem->Val.enmType = UTSGADGETCFGTYPE_BOOLEAN;
619	if ( RTStrICmp(pszVal, "enabled")
620	\|\| RTStrICmp(pszVal, "1")
621	\|\| RTStrICmp(pszVal, "true"))
622	pCfgItem->Val.u.f = true;
623	else if ( RTStrICmp(pszVal, "disabled")
624	\|\| RTStrICmp(pszVal, "0")
625	\|\| RTStrICmp(pszVal, "false"))
626	pCfgItem->Val.u.f = false;
627	else
628	rc = VERR_INVALID_PARAMETER;
629	break;
630	}
631	case UTSPKT_GDGT_CFG_ITEM_TYPE_STRING:
632	{
633	pCfgItem->Val.enmType = UTSGADGETCFGTYPE_STRING;
634	pCfgItem->Val.u.psz = RTStrDup(pszVal);
635	if (!pCfgItem->Val.u.psz)
636	rc = VERR_NO_STR_MEMORY;
637	break;
638	}
639	case UTSPKT_GDGT_CFG_ITEM_TYPE_UINT8:
640	{
641	pCfgItem->Val.enmType = UTSGADGETCFGTYPE_UINT8;
642
643	uint64_t u64;
644	rc = utsDoGadgetCreateCfgParseUInt(pszVal, UINT8_MAX, &u64);
645	if (RT_SUCCESS(rc))
646	pCfgItem->Val.u.u8 = (uint8_t)u64;
647	break;
648	}
649	case UTSPKT_GDGT_CFG_ITEM_TYPE_UINT16:
650	{
651	pCfgItem->Val.enmType = UTSGADGETCFGTYPE_UINT16;
652
653	uint64_t u64;
654	rc = utsDoGadgetCreateCfgParseUInt(pszVal, UINT16_MAX, &u64);
655	if (RT_SUCCESS(rc))
656	pCfgItem->Val.u.u16 = (uint16_t)u64;
657	break;
658	}
659	case UTSPKT_GDGT_CFG_ITEM_TYPE_UINT32:
660	{
661	pCfgItem->Val.enmType = UTSGADGETCFGTYPE_UINT32;
662
663	uint64_t u64;
664	rc = utsDoGadgetCreateCfgParseUInt(pszVal, UINT32_MAX, &u64);
665	if (RT_SUCCESS(rc))
666	pCfgItem->Val.u.u32 = (uint32_t)u64;
667	break;
668	}
669	case UTSPKT_GDGT_CFG_ITEM_TYPE_UINT64:
670	{
671	pCfgItem->Val.enmType = UTSGADGETCFGTYPE_UINT64;
672	rc = utsDoGadgetCreateCfgParseUInt(pszVal, UINT64_MAX, &pCfgItem->Val.u.u64);
673	break;
674	}
675	case UTSPKT_GDGT_CFG_ITEM_TYPE_INT8:
676	{
677	pCfgItem->Val.enmType = UTSGADGETCFGTYPE_INT8;
678
679	int64_t i64;
680	rc = utsDoGadgetCreateCfgParseInt(pszVal, INT8_MIN, INT8_MAX, &i64);
681	if (RT_SUCCESS(rc))
682	pCfgItem->Val.u.i8 = (int8_t)i64;
683	break;
684	}
685	case UTSPKT_GDGT_CFG_ITEM_TYPE_INT16:
686	{
687	pCfgItem->Val.enmType = UTSGADGETCFGTYPE_INT16;
688
689	int64_t i64;
690	rc = utsDoGadgetCreateCfgParseInt(pszVal, INT16_MIN, INT16_MAX, &i64);
691	if (RT_SUCCESS(rc))
692	pCfgItem->Val.u.i16 = (int16_t)i64;
693	break;
694	}
695	case UTSPKT_GDGT_CFG_ITEM_TYPE_INT32:
696	{
697	pCfgItem->Val.enmType = UTSGADGETCFGTYPE_INT32;
698
699	int64_t i64;
700	rc = utsDoGadgetCreateCfgParseInt(pszVal, INT32_MIN, INT32_MAX, &i64);
701	if (RT_SUCCESS(rc))
702	pCfgItem->Val.u.i32 = (int32_t)i64;
703	break;
704	}
705	case UTSPKT_GDGT_CFG_ITEM_TYPE_INT64:
706	{
707	pCfgItem->Val.enmType = UTSGADGETCFGTYPE_INT64;
708	rc = utsDoGadgetCreateCfgParseInt(pszVal, INT64_MIN, INT64_MAX, &pCfgItem->Val.u.i64);
709	break;
710	}
711	default:
712	rc = VERR_INVALID_PARAMETER;
713	}
714
715	return rc;
716	}
717
718	/**
719	* Creates the configuration from the given GADGET CREATE packet.
720	*
721	* @returns IPRT status code.
722	* @param pCfgItem The first config item header in the request packet.
723	* @param cCfgItems Number of config items in the packet to parse.
724	* @param cbPkt Number of bytes left in the packet for the config data.
725	* @param paCfg The array of configuration items to fill.
726	*/
727	static int utsDoGadgetCreateFillCfg(PUTSPKTREQGDGTCTORCFGITEM pCfgItem, unsigned cCfgItems,
728	size_t cbPkt, PUTSGADGETCFGITEM paCfg)
729	{
730	int rc = VINF_SUCCESS;
731	unsigned idxCfg = 0;
732
733	while ( RT_SUCCESS(rc)
734	&& cCfgItems
735	&& cbPkt)
736	{
737	if (cbPkt >= sizeof(UTSPKTREQGDGTCTORCFGITEM))
738	{
739	cbPkt -= sizeof(UTSPKTREQGDGTCTORCFGITEM);
740	if (pCfgItem->u32KeySize + pCfgItem->u32ValSize >= cbPkt)
741	{
742	const char pszKey = (const char )(pCfgItem + 1);
743	const char *pszVal = pszKey + pCfgItem->u32KeySize;
744
745	/* Validate termination. */
746	if ( *(pszKey + pCfgItem->u32KeySize - 1) != '\0'
747	\|\| *(pszVal + pCfgItem->u32ValSize - 1) != '\0')
748	rc = VERR_INVALID_PARAMETER;
749	else
750	{
751	paCfg[idxCfg].pszKey = RTStrDup(pszKey);
752
753	rc = utsDoGadgetCreateCfgParseItem(&paCfg[idxCfg], pCfgItem->u32Type, pszVal);
754	if (RT_SUCCESS(rc))
755	{
756	cbPkt -= pCfgItem->u32KeySize + pCfgItem->u32ValSize;
757	cCfgItems--;
758	idxCfg++;
759	pCfgItem = (PUTSPKTREQGDGTCTORCFGITEM)(pszVal + pCfgItem->u32ValSize);
760	}
761	}
762	}
763	else
764	rc = VERR_INVALID_PARAMETER;
765	}
766	else
767	rc = VERR_INVALID_PARAMETER;
768	}
769
770	return rc;
771	}
772
773	/**
774	* Verifies and acknowledges a "BYE" request.
775	*
776	* @returns IPRT status code.
777	* @param pClient The UTS client structure.
778	* @param pPktHdr The howdy packet.
779	*/
780	static int utsDoBye(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
781	{
782	int rc;
783	if (pPktHdr->cb == sizeof(UTSPKTHDR))
784	rc = utsReplyAck(pClient, pPktHdr);
785	else
786	rc = utsReplyBadSize(pClient, pPktHdr, sizeof(UTSPKTHDR));
787	return rc;
788	}
789
790	/**
791	* Verifies and acknowledges a "HOWDY" request.
792	*
793	* @returns IPRT status code.
794	* @param pClient The UTS client structure.
795	* @param pPktHdr The howdy packet.
796	*/
797	static int utsDoHowdy(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
798	{
799	int rc = VINF_SUCCESS;
800
801	if (pPktHdr->cb != sizeof(UTSPKTREQHOWDY))
802	return utsReplyBadSize(pClient, pPktHdr, sizeof(UTSPKTREQHOWDY));
803
804	if (pClient->enmState != UTSCLIENTSTATE_INITIALISING)
805	return utsReplyInvalidState(pClient, pPktHdr);
806
807	PUTSPKTREQHOWDY pReq = (PUTSPKTREQHOWDY)pPktHdr;
808
809	if (pReq->uVersion != UTS_PROTOCOL_VS)
810	return utsReplyRC(pClient, pPktHdr, VERR_VERSION_MISMATCH, "The given version %#x is not supported", pReq->uVersion);
811
812	/* Verify hostname string. */
813	if (pReq->cchHostname >= sizeof(pReq->achHostname))
814	return utsReplyBadSize(pClient, pPktHdr, sizeof(pReq->achHostname) - 1);
815
816	if (pReq->achHostname[pReq->cchHostname] != '\0')
817	return utsReplyBadStrTermination(pClient, pPktHdr);
818
819	/* Extract string. */
820	pClient->pszHostname = RTStrDup(&pReq->achHostname[0]);
821	if (!pClient->pszHostname)
822	return utsReplyRC(pClient, pPktHdr, VERR_NO_MEMORY, "Failed to allocate memory for the hostname string");
823
824	if (pReq->fUsbConn & UTSPKT_HOWDY_CONN_F_PHYSICAL)
825	return utsReplyRC(pClient, pPktHdr, VERR_NOT_SUPPORTED, "Physical connections are not yet supported");
826
827	if (pReq->fUsbConn & UTSPKT_HOWDY_CONN_F_USBIP)
828	{
829	/* Set up the USB/IP server, find an unused port we can start the server on. */
830	UTSGADGETCFGITEM aCfg[2];
831
832	uint16_t uPort = g_uUsbIpPortNext;
833
834	if (g_uUsbIpPortNext == g_uUsbIpPortLast)
835	g_uUsbIpPortNext = g_uUsbIpPortFirst;
836	else
837	g_uUsbIpPortNext++;
838
839	aCfg[0].pszKey = "UsbIp/Port";
840	aCfg[0].Val.enmType = UTSGADGETCFGTYPE_UINT16;
841	aCfg[0].Val.u.u16 = uPort;
842	aCfg[1].pszKey = NULL;
843
844	rc = utsGadgetHostCreate(UTSGADGETHOSTTYPE_USBIP, &aCfg[0], &pClient->hGadgetHost);
845	if (RT_SUCCESS(rc))
846	{
847	/* Send the reply with the configured USB/IP port. */
848	UTSPKTREPHOWDY Rep;
849
850	RT_ZERO(Rep);
851
852	Rep.uVersion = UTS_PROTOCOL_VS;
853	Rep.fUsbConn = UTSPKT_HOWDY_CONN_F_USBIP;
854	Rep.uUsbIpPort = uPort;
855	Rep.cUsbIpDevices = 1;
856	Rep.cPhysicalDevices = 0;
857
858	rc = utsReplyInternal(pClient, &Rep.Sts, "ACK ", sizeof(Rep) - sizeof(UTSPKTSTS));
859	if (RT_SUCCESS(rc))
860	{
861	g_pTransport->pfnNotifyHowdy(pClient->pTransportClient);
862	pClient->enmState = UTSCLIENTSTATE_READY;
863	RTDirRemoveRecursive(g_szScratchPath, RTDIRRMREC_F_CONTENT_ONLY);
864	}
865	}
866	else
867	return utsReplyRC(pClient, pPktHdr, rc, "Creating the USB/IP gadget host failed");
868	}
869	else
870	return utsReplyRC(pClient, pPktHdr, VERR_INVALID_PARAMETER, "No access method requested");
871
872	return rc;
873	}
874
875	/**
876	* Verifies and processes a "GADGET CREATE" request.
877	*
878	* @returns IPRT status code.
879	* @param pClient The UTS client structure.
880	* @param pPktHdr The gadget create packet.
881	*/
882	static int utsDoGadgetCreate(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
883	{
884	int rc = VINF_SUCCESS;
885
886	if (pPktHdr->cb < sizeof(UTSPKTREQGDGTCTOR))
887	return utsReplyBadSize(pClient, pPktHdr, sizeof(UTSPKTREQGDGTCTOR));
888
889	if ( pClient->enmState != UTSCLIENTSTATE_READY
890	\|\| pClient->hGadgetHost == NIL_UTSGADGETHOST)
891	return utsReplyInvalidState(pClient, pPktHdr);
892
893	PUTSPKTREQGDGTCTOR pReq = (PUTSPKTREQGDGTCTOR)pPktHdr;
894
895	if (pReq->u32GdgtType != UTSPKT_GDGT_CREATE_TYPE_TEST)
896	return utsReplyRC(pClient, pPktHdr, VERR_INVALID_PARAMETER, "The given gadget type is not supported");
897
898	if (pReq->u32GdgtAccess != UTSPKT_GDGT_CREATE_ACCESS_USBIP)
899	return utsReplyRC(pClient, pPktHdr, VERR_INVALID_PARAMETER, "The given gadget access method is not supported");
900
901	PUTSGADGETCFGITEM paCfg = NULL;
902	if (pReq->u32CfgItems > 0)
903	{
904	paCfg = (PUTSGADGETCFGITEM)RTMemAllocZ((pReq->u32CfgItems + 1) * sizeof(UTSGADGETCFGITEM));
905	if (RT_UNLIKELY(!paCfg))
906	return utsReplyRC(pClient, pPktHdr, VERR_NO_MEMORY, "Failed to allocate memory for configration items");
907
908	rc = utsDoGadgetCreateFillCfg((PUTSPKTREQGDGTCTORCFGITEM)(pReq + 1), pReq->u32CfgItems,
909	pPktHdr->cb - sizeof(UTSPKTREQGDGTCTOR), paCfg);
910	if (RT_FAILURE(rc))
911	{
912	RTMemFree(paCfg);
913	return utsReplyRC(pClient, pPktHdr, rc, "Failed to parse configuration");
914	}
915	}
916
917	rc = utsGadgetCreate(pClient->hGadgetHost, UTSGADGETCLASS_TEST, paCfg, &pClient->hGadget);
918	if (RT_SUCCESS(rc))
919	{
920	UTSPKTREPGDGTCTOR Rep;
921	RT_ZERO(Rep);
922
923	Rep.idGadget = 0;
924	Rep.u32BusId = utsGadgetGetBusId(pClient->hGadget);
925	Rep.u32DevId = utsGadgetGetDevId(pClient->hGadget);
926	rc = utsReplyInternal(pClient, &Rep.Sts, "ACK ", sizeof(Rep) - sizeof(UTSPKTSTS));
927	}
928	else
929	rc = utsReplyRC(pClient, pPktHdr, rc, "Failed to create gadget with %Rrc\n", rc);
930
931	return rc;
932	}
933
934	/**
935	* Verifies and processes a "GADGET DESTROY" request.
936	*
937	* @returns IPRT status code.
938	* @param pClient The UTS client structure.
939	* @param pPktHdr The gadget destroy packet.
940	*/
941	static int utsDoGadgetDestroy(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
942	{
943	if (pPktHdr->cb != sizeof(UTSPKTREQGDGTDTOR))
944	return utsReplyBadSize(pClient, pPktHdr, sizeof(UTSPKTREQGDGTDTOR));
945
946	if ( pClient->enmState != UTSCLIENTSTATE_READY
947	\|\| pClient->hGadgetHost == NIL_UTSGADGETHOST)
948	return utsReplyInvalidState(pClient, pPktHdr);
949
950	PUTSPKTREQGDGTDTOR pReq = (PUTSPKTREQGDGTDTOR)pPktHdr;
951
952	if (pReq->idGadget != 0)
953	return utsReplyRC(pClient, pPktHdr, VERR_INVALID_HANDLE, "The given gadget handle is invalid");
954	if (pClient->hGadget == NIL_UTSGADGET)
955	return utsReplyRC(pClient, pPktHdr, VERR_INVALID_STATE, "The gadget is not set up");
956
957	utsGadgetRelease(pClient->hGadget);
958	pClient->hGadget = NIL_UTSGADGET;
959
960	return utsReplyAck(pClient, pPktHdr);
961	}
962
963	/**
964	* Verifies and processes a "GADGET CONNECT" request.
965	*
966	* @returns IPRT status code.
967	* @param pClient The UTS client structure.
968	* @param pPktHdr The gadget connect packet.
969	*/
970	static int utsDoGadgetConnect(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
971	{
972	if (pPktHdr->cb != sizeof(UTSPKTREQGDGTCNCT))
973	return utsReplyBadSize(pClient, pPktHdr, sizeof(UTSPKTREQGDGTCNCT));
974
975	if ( pClient->enmState != UTSCLIENTSTATE_READY
976	\|\| pClient->hGadgetHost == NIL_UTSGADGETHOST)
977	return utsReplyInvalidState(pClient, pPktHdr);
978
979	PUTSPKTREQGDGTCNCT pReq = (PUTSPKTREQGDGTCNCT)pPktHdr;
980
981	if (pReq->idGadget != 0)
982	return utsReplyRC(pClient, pPktHdr, VERR_INVALID_HANDLE, "The given gadget handle is invalid");
983	if (pClient->hGadget == NIL_UTSGADGET)
984	return utsReplyRC(pClient, pPktHdr, VERR_INVALID_STATE, "The gadget is not set up");
985
986	int rc = utsGadgetConnect(pClient->hGadget);
987	if (RT_SUCCESS(rc))
988	rc = utsReplyAck(pClient, pPktHdr);
989	else
990	rc = utsReplyRC(pClient, pPktHdr, rc, "Failed to connect the gadget");
991
992	return rc;
993	}
994
995	/**
996	* Verifies and processes a "GADGET DISCONNECT" request.
997	*
998	* @returns IPRT status code.
999	* @param pClient The UTS client structure.
1000	* @param pPktHdr The gadget disconnect packet.
1001	*/
1002	static int utsDoGadgetDisconnect(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
1003	{
1004	if (pPktHdr->cb != sizeof(UTSPKTREQGDGTDCNT))
1005	return utsReplyBadSize(pClient, pPktHdr, sizeof(UTSPKTREQGDGTDCNT));
1006
1007	if ( pClient->enmState != UTSCLIENTSTATE_READY
1008	\|\| pClient->hGadgetHost == NIL_UTSGADGETHOST)
1009	return utsReplyInvalidState(pClient, pPktHdr);
1010
1011	PUTSPKTREQGDGTDCNT pReq = (PUTSPKTREQGDGTDCNT)pPktHdr;
1012
1013	if (pReq->idGadget != 0)
1014	return utsReplyRC(pClient, pPktHdr, VERR_INVALID_HANDLE, "The given gadget handle is invalid");
1015	if (pClient->hGadget == NIL_UTSGADGET)
1016	return utsReplyRC(pClient, pPktHdr, VERR_INVALID_STATE, "The gadget is not set up");
1017
1018	int rc = utsGadgetDisconnect(pClient->hGadget);
1019	if (RT_SUCCESS(rc))
1020	rc = utsReplyAck(pClient, pPktHdr);
1021	else
1022	rc = utsReplyRC(pClient, pPktHdr, rc, "Failed to disconnect the gadget");
1023
1024	return rc;
1025	}
1026
1027	/**
1028	* Main request processing routine for each client.
1029	*
1030	* @returns IPRT status code.
1031	* @param pClient The UTS client structure sending the request.
1032	*/
1033	static int utsClientReqProcess(PUTSCLIENT pClient)
1034	{
1035	/*
1036	* Read client command packet and process it.
1037	*/
1038	PUTSPKTHDR pPktHdr = NULL;
1039	int rc = utsRecvPkt(pClient, &pPktHdr, true /fAutoRetryOnFailure/);
1040	if (RT_FAILURE(rc))
1041	return rc;
1042
1043	/*
1044	* Do a string switch on the opcode bit.
1045	*/
1046	/* Connection: */
1047	if ( utsIsSameOpcode(pPktHdr, UTSPKT_OPCODE_HOWDY))
1048	rc = utsDoHowdy(pClient, pPktHdr);
1049	else if (utsIsSameOpcode(pPktHdr, UTSPKT_OPCODE_BYE))
1050	rc = utsDoBye(pClient, pPktHdr);
1051	/* Gadget API. */
1052	else if (utsIsSameOpcode(pPktHdr, UTSPKT_OPCODE_GADGET_CREATE))
1053	rc = utsDoGadgetCreate(pClient, pPktHdr);
1054	else if (utsIsSameOpcode(pPktHdr, UTSPKT_OPCODE_GADGET_DESTROY))
1055	rc = utsDoGadgetDestroy(pClient, pPktHdr);
1056	else if (utsIsSameOpcode(pPktHdr, UTSPKT_OPCODE_GADGET_CONNECT))
1057	rc = utsDoGadgetConnect(pClient, pPktHdr);
1058	else if (utsIsSameOpcode(pPktHdr, UTSPKT_OPCODE_GADGET_DISCONNECT))
1059	rc = utsDoGadgetDisconnect(pClient, pPktHdr);
1060	/* Misc: */
1061	else
1062	rc = utsReplyUnknown(pClient, pPktHdr);
1063
1064	RTMemFree(pPktHdr);
1065
1066	return rc;
1067	}
1068
1069	/**
1070	* Destroys a client instance.
1071	*
1072	* @param pClient The UTS client structure.
1073	*/
1074	static void utsClientDestroy(PUTSCLIENT pClient)
1075	{
1076	if (pClient->pszHostname)
1077	RTStrFree(pClient->pszHostname);
1078	if (pClient->hGadget != NIL_UTSGADGET)
1079	utsGadgetRelease(pClient->hGadget);
1080	if (pClient->hGadgetHost != NIL_UTSGADGETHOST)
1081	utsGadgetHostRelease(pClient->hGadgetHost);
1082	RTMemFree(pClient);
1083	}
1084
1085	/**
1086	* The main thread worker serving the clients.
1087	*/
1088	static DECLCALLBACK(int) utsClientWorker(RTTHREAD hThread, void *pvUser)
1089	{
1090	RT_NOREF2(hThread, pvUser);
1091	unsigned cClientsMax = 0;
1092	unsigned cClientsCur = 0;
1093	PUTSCLIENT *papClients = NULL;
1094	RTPOLLSET hPollSet;
1095
1096	int rc = RTPollSetCreate(&hPollSet);
1097	if (RT_FAILURE(rc))
1098	return rc;
1099
1100	/* Add the pipe to the poll set. */
1101	rc = RTPollSetAddPipe(hPollSet, g_hPipeR, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR, 0);
1102	if (RT_SUCCESS(rc))
1103	{
1104	while (!g_fTerminate)
1105	{
1106	uint32_t fEvts;
1107	uint32_t uId;
1108	rc = RTPoll(hPollSet, RT_INDEFINITE_WAIT, &fEvts, &uId);
1109	if (RT_SUCCESS(rc))
1110	{
1111	if (uId == 0)
1112	{
1113	if (fEvts & RTPOLL_EVT_ERROR)
1114	break;
1115
1116	/* We got woken up because of a new client. */
1117	Assert(fEvts & RTPOLL_EVT_READ);
1118
1119	uint8_t bRead;
1120	size_t cbRead = 0;
1121	rc = RTPipeRead(g_hPipeR, &bRead, 1, &cbRead);
1122	AssertRC(rc);
1123
1124	RTCritSectEnter(&g_CritSectClients);
1125	/* Walk the list and add all new clients. */
1126	PUTSCLIENT pIt, pItNext;
1127	RTListForEachSafe(&g_LstClientsNew, pIt, pItNext, UTSCLIENT, NdLst)
1128	{
1129	RTListNodeRemove(&pIt->NdLst);
1130	Assert(cClientsCur <= cClientsMax);
1131	if (cClientsCur == cClientsMax)
1132	{
1133	/* Realloc to accommodate for the new clients. */
1134	PUTSCLIENT papClientsNew = (PUTSCLIENT )RTMemReallocZ(papClients, cClientsMax * sizeof(PUTSCLIENT), (cClientsMax + 10) * sizeof(PUTSCLIENT));
1135	if (RT_LIKELY(papClientsNew))
1136	{
1137	cClientsMax += 10;
1138	papClients = papClientsNew;
1139	}
1140	}
1141
1142	if (cClientsCur < cClientsMax)
1143	{
1144	/* Find a free slot in the client array. */
1145	unsigned idxSlt = 0;
1146	while ( idxSlt < cClientsMax
1147	&& papClients[idxSlt] != NULL)
1148	idxSlt++;
1149
1150	rc = g_pTransport->pfnPollSetAdd(hPollSet, pIt->pTransportClient, idxSlt + 1);
1151	if (RT_SUCCESS(rc))
1152	{
1153	cClientsCur++;
1154	papClients[idxSlt] = pIt;
1155	}
1156	else
1157	{
1158	g_pTransport->pfnNotifyBye(pIt->pTransportClient);
1159	utsClientDestroy(pIt);
1160	}
1161	}
1162	else
1163	{
1164	g_pTransport->pfnNotifyBye(pIt->pTransportClient);
1165	utsClientDestroy(pIt);
1166	}
1167	}
1168	RTCritSectLeave(&g_CritSectClients);
1169	}
1170	else
1171	{
1172	/* Client sends a request, pick the right client and process it. */
1173	PUTSCLIENT pClient = papClients[uId - 1];
1174	AssertPtr(pClient);
1175	if (fEvts & RTPOLL_EVT_READ)
1176	rc = utsClientReqProcess(pClient);
1177
1178	if ( (fEvts & RTPOLL_EVT_ERROR)
1179	\|\| RT_FAILURE(rc))
1180	{
1181	/* Close connection and remove client from array. */
1182	rc = g_pTransport->pfnPollSetRemove(hPollSet, pClient->pTransportClient, uId);
1183	AssertRC(rc);
1184
1185	g_pTransport->pfnNotifyBye(pClient->pTransportClient);
1186	papClients[uId - 1] = NULL;
1187	cClientsCur--;
1188	utsClientDestroy(pClient);
1189	}
1190	}
1191	}
1192	}
1193	}
1194
1195	RTPollSetDestroy(hPollSet);
1196	if (papClients)
1197	RTMemFree(papClients);
1198	return rc;
1199	}
1200
1201	/**
1202	* The main loop.
1203	*
1204	* @returns exit code.
1205	*/
1206	static RTEXITCODE utsMainLoop(void)
1207	{
1208	RTEXITCODE enmExitCode = RTEXITCODE_SUCCESS;
1209	while (!g_fTerminate)
1210	{
1211	/*
1212	* Wait for new connection and spin off a new thread
1213	* for every new client.
1214	*/
1215	PUTSTRANSPORTCLIENT pTransportClient;
1216	int rc = g_pTransport->pfnWaitForConnect(&pTransportClient);
1217	if (RT_FAILURE(rc))
1218	continue;
1219
1220	/*
1221	* New connection, create new client structure and spin of
1222	* the request handling thread.
1223	*/
1224	PUTSCLIENT pClient = (PUTSCLIENT)RTMemAllocZ(sizeof(UTSCLIENT));
1225	if (RT_LIKELY(pClient))
1226	{
1227	pClient->enmState = UTSCLIENTSTATE_INITIALISING;
1228	pClient->pTransportClient = pTransportClient;
1229	pClient->pszHostname = NULL;
1230	pClient->hGadgetHost = NIL_UTSGADGETHOST;
1231	pClient->hGadget = NIL_UTSGADGET;
1232
1233	/* Add client to the new list and inform the worker thread. */
1234	RTCritSectEnter(&g_CritSectClients);
1235	RTListAppend(&g_LstClientsNew, &pClient->NdLst);
1236	RTCritSectLeave(&g_CritSectClients);
1237
1238	size_t cbWritten = 0;
1239	rc = RTPipeWrite(g_hPipeW, "", 1, &cbWritten);
1240	if (RT_FAILURE(rc))
1241	RTMsgError("Failed to inform worker thread of a new client");
1242	}
1243	else
1244	{
1245	RTMsgError("Creating new client structure failed with out of memory error\n");
1246	g_pTransport->pfnNotifyBye(pTransportClient);
1247	}
1248
1249
1250	}
1251
1252	return enmExitCode;
1253	}
1254
1255	/**
1256	* Initializes the global UTS state.
1257	*
1258	* @returns IPRT status code.
1259	*/
1260	static int utsInit(void)
1261	{
1262	int rc = VINF_SUCCESS;
1263	PRTERRINFO pErrInfo = NULL;
1264
1265	RTListInit(&g_LstClientsNew);
1266
1267	rc = RTJsonParseFromFile(&g_hCfgJson, g_szCfgPath, pErrInfo);
1268	if (RT_SUCCESS(rc))
1269	{
1270	rc = utsPlatformInit();
1271	if (RT_SUCCESS(rc))
1272	{
1273	rc = RTCritSectInit(&g_CritSectClients);
1274	if (RT_SUCCESS(rc))
1275	{
1276	rc = RTPipeCreate(&g_hPipeR, &g_hPipeW, 0);
1277	if (RT_SUCCESS(rc))
1278	{
1279	/* Spin off the thread serving connections. */
1280	rc = RTThreadCreate(&g_hThreadServing, utsClientWorker, NULL, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE,
1281	"USBTSTSRV");
1282	if (RT_SUCCESS(rc))
1283	return VINF_SUCCESS;
1284	else
1285	RTMsgError("Creating the client worker thread failed with %Rrc\n", rc);
1286
1287	RTPipeClose(g_hPipeR);
1288	RTPipeClose(g_hPipeW);
1289	}
1290	else
1291	RTMsgError("Creating communications pipe failed with %Rrc\n", rc);
1292
1293	RTCritSectDelete(&g_CritSectClients);
1294	}
1295	else
1296	RTMsgError("Creating global critical section failed with %Rrc\n", rc);
1297
1298	RTJsonValueRelease(g_hCfgJson);
1299	}
1300	else
1301	RTMsgError("Initializing the platform failed with %Rrc\n", rc);
1302	}
1303	else
1304	{
1305	if (RTErrInfoIsSet(pErrInfo))
1306	{
1307	RTMsgError("Failed to parse config with detailed error: %s (%Rrc)\n",
1308	pErrInfo->pszMsg, pErrInfo->rc);
1309	RTErrInfoFree(pErrInfo);
1310	}
1311	else
1312	RTMsgError("Failed to parse config with unknown error (%Rrc)\n", rc);
1313	}
1314
1315	return rc;
1316	}
1317
1318	/**
1319	* Determines the default configuration.
1320	*/
1321	static void utsSetDefaults(void)
1322	{
1323	/*
1324	* OS and ARCH.
1325	*/
1326	AssertCompile(sizeof(KBUILD_TARGET) <= sizeof(g_szOsShortName));
1327	strcpy(g_szOsShortName, KBUILD_TARGET);
1328
1329	AssertCompile(sizeof(KBUILD_TARGET_ARCH) <= sizeof(g_szArchShortName));
1330	strcpy(g_szArchShortName, KBUILD_TARGET_ARCH);
1331
1332	AssertCompile(sizeof(KBUILD_TARGET) + sizeof(KBUILD_TARGET_ARCH) <= sizeof(g_szOsDotArchShortName));
1333	strcpy(g_szOsDotArchShortName, KBUILD_TARGET);
1334	g_szOsDotArchShortName[sizeof(KBUILD_TARGET) - 1] = '.';
1335	strcpy(&g_szOsDotArchShortName[sizeof(KBUILD_TARGET)], KBUILD_TARGET_ARCH);
1336
1337	AssertCompile(sizeof(KBUILD_TARGET) + sizeof(KBUILD_TARGET_ARCH) <= sizeof(g_szOsSlashArchShortName));
1338	strcpy(g_szOsSlashArchShortName, KBUILD_TARGET);
1339	g_szOsSlashArchShortName[sizeof(KBUILD_TARGET) - 1] = '/';
1340	strcpy(&g_szOsSlashArchShortName[sizeof(KBUILD_TARGET)], KBUILD_TARGET_ARCH);
1341
1342	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
1343	strcpy(g_szExeSuff, ".exe");
1344	strcpy(g_szScriptSuff, ".cmd");
1345	#else
1346	strcpy(g_szExeSuff, "");
1347	strcpy(g_szScriptSuff, ".sh");
1348	#endif
1349
1350	/*
1351	* The CD/DVD-ROM location.
1352	*/
1353	/** @todo do a better job here :-) */
1354	#ifdef RT_OS_WINDOWS
1355	strcpy(g_szDefCdRomPath, "D:/");
1356	#elif defined(RT_OS_OS2)
1357	strcpy(g_szDefCdRomPath, "D:/");
1358	#else
1359	if (RTDirExists("/media"))
1360	strcpy(g_szDefCdRomPath, "/media/cdrom");
1361	else
1362	strcpy(g_szDefCdRomPath, "/mnt/cdrom");
1363	#endif
1364	strcpy(g_szCdRomPath, g_szDefCdRomPath);
1365
1366	/*
1367	* Temporary directory.
1368	*/
1369	int rc = RTPathTemp(g_szDefScratchPath, sizeof(g_szDefScratchPath));
1370	if (RT_SUCCESS(rc))
1371	#if defined(RT_OS_OS2) \|\| defined(RT_OS_WINDOWS) \|\| defined(RT_OS_DOS)
1372	rc = RTPathAppend(g_szDefScratchPath, sizeof(g_szDefScratchPath), "uts-XXXX.tmp");
1373	#else
1374	rc = RTPathAppend(g_szDefScratchPath, sizeof(g_szDefScratchPath), "uts-XXXXXXXXX.tmp");
1375	#endif
1376	if (RT_FAILURE(rc))
1377	{
1378	RTMsgError("RTPathTemp/Append failed when constructing scratch path: %Rrc\n", rc);
1379	strcpy(g_szDefScratchPath, "/tmp/uts-XXXX.tmp");
1380	}
1381	strcpy(g_szScratchPath, g_szDefScratchPath);
1382
1383	/*
1384	* Config file location.
1385	*/
1386	/** @todo Improve */
1387	#if !defined(RT_OS_WINDOWS)
1388	strcpy(g_szCfgPath, "/etc/uts.conf");
1389	#else
1390	strcpy(g_szCfgPath, "");
1391	#endif
1392
1393	/*
1394	* The default transporter is the first one.
1395	*/
1396	g_pTransport = g_apTransports[0];
1397	}
1398
1399	/**
1400	* Prints the usage.
1401	*
1402	* @param pStrm Where to print it.
1403	* @param pszArgv0 The program name (argv[0]).
1404	*/
1405	static void utsUsage(PRTSTREAM pStrm, const char *pszArgv0)
1406	{
1407	RTStrmPrintf(pStrm,
1408	"Usage: %Rbn [options]\n"
1409	"\n"
1410	"Options:\n"
1411	" --config <path>\n"
1412	" Where to load the config from\n"
1413	" --cdrom <path>\n"
1414	" Where the CD/DVD-ROM will be mounted.\n"
1415	" Default: %s\n"
1416	" --scratch <path>\n"
1417	" Where to put scratch files.\n"
1418	" Default: %s \n"
1419	,
1420	pszArgv0,
1421	g_szDefCdRomPath,
1422	g_szDefScratchPath);
1423	RTStrmPrintf(pStrm,
1424	" --transport <name>\n"
1425	" Use the specified transport layer, one of the following:\n");
1426	for (size_t i = 0; i < RT_ELEMENTS(g_apTransports); i++)
1427	RTStrmPrintf(pStrm, " %s - %s\n", g_apTransports[i]->szName, g_apTransports[i]->pszDesc);
1428	RTStrmPrintf(pStrm, " Default: %s\n", g_pTransport->szName);
1429	RTStrmPrintf(pStrm,
1430	" --display-output, --no-display-output\n"
1431	" Display the output and the result of all child processes.\n");
1432	RTStrmPrintf(pStrm,
1433	" --foreground\n"
1434	" Don't daemonize, run in the foreground.\n");
1435	RTStrmPrintf(pStrm,
1436	" --help, -h, -?\n"
1437	" Display this message and exit.\n"
1438	" --version, -V\n"
1439	" Display the version and exit.\n");
1440
1441	for (size_t i = 0; i < RT_ELEMENTS(g_apTransports); i++)
1442	if (g_apTransports[i]->cOpts)
1443	{
1444	RTStrmPrintf(pStrm,
1445	"\n"
1446	"Options for %s:\n", g_apTransports[i]->szName);
1447	g_apTransports[i]->pfnUsage(g_pStdOut);
1448	}
1449	}
1450
1451	/**
1452	* Parses the arguments.
1453	*
1454	* @returns Exit code. Exit if this is non-zero or @a *pfExit is set.
1455	* @param argc The number of arguments.
1456	* @param argv The argument vector.
1457	* @param pfExit For indicating exit when the exit code is zero.
1458	*/
1459	static RTEXITCODE utsParseArgv(int argc, char *argv, bool pfExit)
1460	{
1461	*pfExit = false;
1462
1463	/*
1464	* Storage for locally handled options.
1465	*/
1466	bool fDaemonize = true;
1467	bool fDaemonized = false;
1468
1469	/*
1470	* Combine the base and transport layer option arrays.
1471	*/
1472	static const RTGETOPTDEF s_aBaseOptions[] =
1473	{
1474	{ "--config", 'C', RTGETOPT_REQ_STRING },
1475	{ "--transport", 't', RTGETOPT_REQ_STRING },
1476	{ "--cdrom", 'c', RTGETOPT_REQ_STRING },
1477	{ "--scratch", 's', RTGETOPT_REQ_STRING },
1478	{ "--display-output", 'd', RTGETOPT_REQ_NOTHING },
1479	{ "--no-display-output",'D', RTGETOPT_REQ_NOTHING },
1480	{ "--foreground", 'f', RTGETOPT_REQ_NOTHING },
1481	{ "--daemonized", 'Z', RTGETOPT_REQ_NOTHING },
1482	};
1483
1484	size_t cOptions = RT_ELEMENTS(s_aBaseOptions);
1485	for (size_t i = 0; i < RT_ELEMENTS(g_apTransports); i++)
1486	cOptions += g_apTransports[i]->cOpts;
1487
1488	PRTGETOPTDEF paOptions = (PRTGETOPTDEF)alloca(cOptions * sizeof(RTGETOPTDEF));
1489	if (!paOptions)
1490	return RTMsgErrorExit(RTEXITCODE_FAILURE, "alloca failed\n");
1491
1492	memcpy(paOptions, s_aBaseOptions, sizeof(s_aBaseOptions));
1493	cOptions = RT_ELEMENTS(s_aBaseOptions);
1494	for (size_t i = 0; i < RT_ELEMENTS(g_apTransports); i++)
1495	{
1496	memcpy(&paOptions[cOptions], g_apTransports[i]->paOpts, g_apTransports[i]->cOpts * sizeof(RTGETOPTDEF));
1497	cOptions += g_apTransports[i]->cOpts;
1498	}
1499
1500	/*
1501	* Parse the arguments.
1502	*/
1503	RTGETOPTSTATE GetState;
1504	int rc = RTGetOptInit(&GetState, argc, argv, paOptions, cOptions, 1, 0 /* fFlags */);
1505	AssertRC(rc);
1506
1507	int ch;
1508	RTGETOPTUNION Val;
1509	while ((ch = RTGetOpt(&GetState, &Val)))
1510	{
1511	switch (ch)
1512	{
1513	case 'C':
1514	rc = RTStrCopy(g_szCfgPath, sizeof(g_szCfgPath), Val.psz);
1515	if (RT_FAILURE(rc))
1516	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Config file path is path too long (%Rrc)\n", rc);
1517	break;
1518
1519	case 'c':
1520	rc = RTStrCopy(g_szCdRomPath, sizeof(g_szCdRomPath), Val.psz);
1521	if (RT_FAILURE(rc))
1522	return RTMsgErrorExit(RTEXITCODE_FAILURE, "CD/DVD-ROM is path too long (%Rrc)\n", rc);
1523	break;
1524
1525	case 'd':
1526	g_fDisplayOutput = true;
1527	break;
1528
1529	case 'D':
1530	g_fDisplayOutput = false;
1531	break;
1532
1533	case 'f':
1534	fDaemonize = false;
1535	break;
1536
1537	case 'h':
1538	utsUsage(g_pStdOut, argv[0]);
1539	*pfExit = true;
1540	return RTEXITCODE_SUCCESS;
1541
1542	case 's':
1543	rc = RTStrCopy(g_szScratchPath, sizeof(g_szScratchPath), Val.psz);
1544	if (RT_FAILURE(rc))
1545	return RTMsgErrorExit(RTEXITCODE_FAILURE, "scratch path is too long (%Rrc)\n", rc);
1546	break;
1547
1548	case 't':
1549	{
1550	PCUTSTRANSPORT pTransport = NULL;
1551	for (size_t i = 0; i < RT_ELEMENTS(g_apTransports); i++)
1552	if (!strcmp(g_apTransports[i]->szName, Val.psz))
1553	{
1554	pTransport = g_apTransports[i];
1555	break;
1556	}
1557	if (!pTransport)
1558	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown transport layer name '%s'\n", Val.psz);
1559	g_pTransport = pTransport;
1560	break;
1561	}
1562
1563	case 'V':
1564	RTPrintf("$Revision: 100207 $\n");
1565	*pfExit = true;
1566	return RTEXITCODE_SUCCESS;
1567
1568	case 'Z':
1569	fDaemonized = true;
1570	fDaemonize = false;
1571	break;
1572
1573	default:
1574	{
1575	rc = VERR_TRY_AGAIN;
1576	for (size_t i = 0; i < RT_ELEMENTS(g_apTransports); i++)
1577	if (g_apTransports[i]->cOpts)
1578	{
1579	rc = g_apTransports[i]->pfnOption(ch, &Val);
1580	if (RT_SUCCESS(rc))
1581	break;
1582	if (rc != VERR_TRY_AGAIN)
1583	{
1584	*pfExit = true;
1585	return RTEXITCODE_SYNTAX;
1586	}
1587	}
1588	if (rc == VERR_TRY_AGAIN)
1589	{
1590	*pfExit = true;
1591	return RTGetOptPrintError(ch, &Val);
1592	}
1593	break;
1594	}
1595	}
1596	}
1597
1598	/*
1599	* Daemonize ourselves if asked to.
1600	*/
1601	if (fDaemonize && !*pfExit)
1602	{
1603	rc = RTProcDaemonize(argv, "--daemonized");
1604	if (RT_FAILURE(rc))
1605	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTProcDaemonize: %Rrc\n", rc);
1606	*pfExit = true;
1607	}
1608
1609	return RTEXITCODE_SUCCESS;
1610	}
1611
1612
1613	int main(int argc, char **argv)
1614	{
1615	/*
1616	* Initialize the runtime.
1617	*/
1618	int rc = RTR3InitExe(argc, &argv, 0);
1619	if (RT_FAILURE(rc))
1620	return RTMsgInitFailure(rc);
1621
1622	/*
1623	* Determine defaults and parse the arguments.
1624	*/
1625	utsSetDefaults();
1626	bool fExit;
1627	RTEXITCODE rcExit = utsParseArgv(argc, argv, &fExit);
1628	if (rcExit != RTEXITCODE_SUCCESS \|\| fExit)
1629	return rcExit;
1630
1631	/*
1632	* Initialize global state.
1633	*/
1634	rc = utsInit();
1635	if (RT_FAILURE(rc))
1636	return RTEXITCODE_FAILURE;
1637
1638	/*
1639	* Initialize the transport layer.
1640	*/
1641	rc = g_pTransport->pfnInit();
1642	if (RT_FAILURE(rc))
1643	return RTEXITCODE_FAILURE;
1644
1645	/*
1646	* Ok, start working
1647	*/
1648	rcExit = utsMainLoop();
1649
1650	/*
1651	* Cleanup.
1652	*/
1653	g_pTransport->pfnTerm();
1654
1655	utsPlatformTerm();
1656
1657	return rcExit;
1658	}
1659

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

source: vbox/trunk/src/VBox/ValidationKit/utils/usb/UsbTestService.cpp@ 105374

Download in other formats: